python中continue实例

假设我们有一个列表，其中包含一些数字。我们想要计算这些数字的总和，但是我们不想包括其中的负数。此时我们可以使用continue语句来跳过负数，只计算正数。

示例代码：

numbers = [10, -5, 6, -3, 7, 8, -2, 9]
total = 0

for num in numbers:
    if num < 0:
        continue  # 如果num为负数，跳过本次循环
    total += num

print("正数的总和为:", total)

输出结果：

正数的总和为: 40

在上面的代码中，如果num小于0，则会执行continue语句，跳过本次循环。如果num大于等于0，则会执行total += num语句，将num的值加到total中。最终输出正数的总和为40。

相关问题

PAM算法python实例

PAM（Partitioning Around Medoids）算法是一种基于贪心策略的聚类算法，它的思想是选择一部分数据作为簇的代表点（medoids），然后将其它数据点分配到最近的代表点所在的簇中。PAM算法相对于K-Means算法的优点在于它可以处理离群点（outliers）。

下面是一个使用Python实现PAM算法的示例代码：

import numpy as np

def distance(point1, point2):
    """计算两个点之间的欧几里德距离"""
    return np.sqrt(np.sum((point1 - point2) ** 2))

def pam(dataset, k):
    """PAM算法"""
    # 随机选择k个点作为medoids
    medoids = dataset[np.random.choice(len(dataset), k, replace=False)]
    # 初始化簇
    clusters = [[] for _ in range(k)]
    # 将每个点分配到最近的medoid所在的簇中
    for point in dataset:
        distances = [distance(point, medoid) for medoid in medoids]
        nearest_medoid = np.argmin(distances)
        clusters[nearest_medoid].append(point)
    # 计算当前聚类的SSE（误差平方和）
    sse = sum([sum([distance(point, medoids[i]) ** 2 for point in cluster]) for i, cluster in enumerate(clusters)])
    # 进行迭代，直到SSE不再变化
    while True:
        # 对于每个medoid，尝试用其它簇中的点替换它，并计算SSE的变化
        for i in range(k):
            for j in range(len(clusters[i])):
                if not np.array_equal(clusters[i][j], medoids[i]):
                    new_medoid = clusters[i][j]
                    new_clusters = clusters.copy()
                    new_clusters[i].remove(clusters[i][j])
                    distances = [distance(point, new_medoid) for point in new_clusters[i]]
                    nearest_medoid = np.argmin(distances)
                    new_clusters[nearest_medoid].append(medoids[i])
                    new_sse = sum([sum([distance(point, new_medoids[i]) ** 2 for point in new_cluster]) for i, new_cluster in enumerate(new_clusters)])
                    if new_sse < sse:
                        medoids[i] = new_medoid
                        clusters = new_clusters
                        sse = new_sse
                        break
            else:
                continue
            break
        else:
            break
    return clusters

使用示例：

import matplotlib.pyplot as plt

# 生成随机数据
np.random.seed(0)
dataset = np.random.randn(100, 2)

# 聚类
clusters = pam(dataset, 3)

# 绘制结果
colors = ['r', 'g', 'b']
for i, cluster in enumerate(clusters):
    for point in cluster:
        plt.scatter(point[0], point[1], color=colors[i])
plt.show()

输出结果：


c4.5决策树python实现实例

以下是使用Python实现C4.5决策树的示例代码：

from math import log
import operator

def calcShannonEnt(dataSet):
    numEntries = len(dataSet)
    labelCounts = {}
    for featVec in dataSet:
        currentLabel = featVec[-1]
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1
    shannonEnt = 0.0
    for key in labelCounts:
        prob = float(labelCounts[key])/numEntries
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt

def createDataSet():
    dataSet = [[1, 1, 'yes'],
               [1, 1, 'yes'],
               [1, 0, 'no'],
               [0, 1, 'no'],
               [0, 1, 'no']]
    labels = ['no surfacing','flippers']
    return dataSet, labels

def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reducedFeatVec = featVec[:axis]
            reducedFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reducedFeatVec)
    return retDataSet

def chooseBestFeatureToSplit(dataSet):
    numFeatures = len(dataSet[0]) - 1
    baseEntropy = calcShannonEnt(dataSet)
    bestInfoGainRatio = 0.0
    bestFeature = -1
    for i in range(numFeatures):
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList)
        newEntropy = 0.0
        splitInfo = 0.0
        for value in uniqueVals:
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet)/float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)
            splitInfo -= prob * log(prob, 2)
        infoGain = baseEntropy - newEntropy
        if (splitInfo == 0): # fix the overflow bug
            continue
        infoGainRatio = infoGain / splitInfo
        if (infoGainRatio > bestInfoGainRatio):
            bestInfoGainRatio = infoGainRatio
            bestFeature = i
    return bestFeature

def majorityCnt(classList):
    classCount = {}
    for vote in classList:
        if vote not in classCount.keys():
            classCount[vote] = 0
        classCount[vote] += 1
    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

def createTree(dataSet, labels):
    classList = [example[-1] for example in dataSet]
    if classList.count(classList[0]) == len(classList):
        return classList[0]
    if len(dataSet[0]) == 1:
        return majorityCnt(classList)
    bestFeat = chooseBestFeatureToSplit(dataSet)
    bestFeatLabel = labels[bestFeat]
    myTree = {bestFeatLabel:{}}
    del(labels[bestFeat])
    featValues = [example[bestFeat] for example in dataSet]
    uniqueVals = set(featValues)
    for value in uniqueVals:
        subLabels = labels[:]
        myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value), subLabels)
    return myTree

dataSet, labels = createDataSet()
myTree = createTree(dataSet, labels)
print(myTree)