第一章 开发基础

第二章 Python语言基本要素

第三章 简单数据类型

第四章 程序控制语句

第五章 组合数据类型

第六章 函数与模块

第七章 类与对象

第八章 文件处理

第九章 常见模块的使用

第十章 NumPy数值处理

第十一章 Pandas数据查询

第十二章 数据可视化

第十三章 机器学习

       

第一章 开发基础（点击代码可复制）

【代码 1-1】最简单的输出代码：

print('Hello world!')

       

第二章 Python语言基本要素（点击代码可复制）

【代码 2-1】长语句的换行：

print('XXXXXXXXXXXXXXXXXXXXXXXXXX' + 'XXXXXXXXXXXXXXXXXXXXXXXXXX' + 'XXXXXXXXXXXXXXXXXXXXXXXXXX')

【代码 2-2】有注释的代码：

# 测试代码输出 print('Hello') # 再次测试 print('World')

【代码 2-3】变量的基本使用：

count = 1 print(count) count = 2 print(count)

【代码 2-4】变量的特殊赋值方法：

count = 1 count = count + 1 num1, num2 = count, count + 1 print(count, num1, num2)

【代码 2-5】变量和函数同名产生的错误：

print = 1.2 print(print)

【代码 2-6】输入和输出的简单练习：

name = input('请输入您的姓名：') print('欢迎您，' + name + '!')

【代码 2-7】输出两个输入小数的总和：

number1 = input('请输入第一个小数：') number2 = input('请输入第二个小数：') sum = str(float(number1) + float(number2)) print('总和为：' + sum)

【代码 2-8】有字符串变量：
str1 = '南京'
str2 = '江苏'
尝试使用多种字符串格式化方法完成输出：南京是江苏省会。其中的“南京”和“江苏”分别是strs1和strs2变量的值：

str1 = '南京' str2 = '江苏' print(str1 + '是' + str2 + '省会') print('{}是{}省会'.format(str1, str2)) print(f'{str1}是{str2}省会') print('%s是%s省会' % (str1, str2))

【代码 2-9】让用户输入一个整数长度，在“Python”中各个字符之间填充空格，使得总体字符串长度等于或者接近于输入的整数长度：

term = 'Python' size = int(input('请输入长度：')) count = int((size - len(term)) / (len(term) - 1)) print((' ' * count).join(term))

【代码 2-10】让用户输入两个数的加法计算式，如“1+2”，并输出最终的加法计算式及其结果，如“1+2=3”：

strs = input('请输入加法计算式：') num1, num2 = strs.split('+') num1, num2 = int(num1), int(num2) print('{}={}'.format(strs, num1 + num2))

【代码 2-11】使用切片方法完成代码 2-10加法计算式的功能：

strs = input('请输入加法计算式：') num1 = strs[0:strs.index('+')] num2 = strs[strs.index('+') + 1:] print('{}={}'.format(strs, str(int(num1) + int(num2))))

【代码 2-12】使用eval函数完成代码 2-10加法计算式的功能：

strs = input('请输入加法计算式：') print('{}={}'.format(strs, eval(strs)))

【代码 2-13】使用exec函数实现允许用户输入代码并运行：

strs = input('请输入代码：') exec(strs)

       

第三章 简单数据类型（点击代码可复制）

【代码 3-1】二进制整数转换为十进制：

print(format(0b100110, 'd')) print('%d' % 0b100110) print(f'{0b100110:d}') print(int(0b100110))

【代码 3-2】浮点数的科学计数法表示：

num = 1 / 3 print(num) print('{:.4e}'.format(num)) print('%.4e' % num)

【代码 3-3】精度更高的浮点数表示法：

import math from decimal import Decimal print(math.pi) print(Decimal(math.pi))

【代码 3-4】数字类型的常见代数运算：

num = 2 * 3 ** 2 % 4 num += 1 print(num)

【代码 3-5】在机器学习方法的数据预处理过程中，常常需要把连续型的数值映射为离散型的枚举数值。比如将人的年龄转换为年龄阶段，23岁可以映射为“20岁阶段”。请完成相应的代码功能：

age = int(input('请输入年龄：')) age //= 10 age *= 10 print('年龄为{}阶段'.format(age))

【代码 3-6】在机器学习方法的数据预处理过程中，常常需要将多个数值映射到指定数量的数值区间，比如对所有输入的整数都映射到3个分类中。请完成相应的代码功能：

value = int(input('请输入数值：')) value %= 3 print('映射区间为{}'.format(value))

【代码 3-7】多行字符串的不同表示方法：

print('这是一段较' '长的文字') print('这是一段较\ 长的文字') print('''这是一段较 长的文字''')

【代码 3-8】利用编码规律实现大写字母向小写字母的转化：

strs = input('请输入一个大写字母：') print('小写为{}'.format(chr(ord(strs) + ord('a') - ord('A'))))

【代码 3-9】布尔类型的常见逻辑运算：

num = 1 print(num > 2) print(num == None) print(True or False and True)

       

第四章 程序控制语句（点击代码可复制）

【代码 4-1】决策树是一种常见的机器学习算法，它模拟了人类在面对决策问题时所采用的思考方式，通过一系列的条件判断，最终得出决策结果。在决策树中，每个内部节点都代表了一个特征属性的测试，每个分支则代表了测试的一个可能结果，而每个叶子节点则存储了一个对于类别的判断结果或一个预测的数值。当要对一个新的样本进行分类或预测时，可以从决策树的根节点开始，根据样本的特征属性值沿着树向下移动，直到到达一个叶子节点，该叶子节点所存储的类别或数值就是最终的决策结果。
现已知一种可以根据当前温度、湿度和是否下雨来判断是否适合外出散步的决策树：

请实现上述决策树中当温度大于20度时，根据湿度是否大于90%来判断是否适合散步的过程

humidity = float(input('请输入当前湿度（%）：')) if humidity > 90: print('不适合散步') else: print('适合散步')

【代码 4-2】在代码 4-1基础上，完整实现该决策树的全部判断过程：

# 获取用户输入的温度、湿度和是否下雨的信息 temperature = float(input('请输入当前温度（°C）：')) humidity = float(input('请输入当前湿度（%）：')) raining = input('是否下雨？（Y/N）：').lower() == 'Y' # 根据决策树进行判断 if temperature > 20: if humidity > 70: print('不适合散步') else: if raining: print('不适合散步') else: print('适合散步') else: if humidity > 90: print('不适合散步') else: print('适合散步')

【代码 4-3】输出1到100以内所有奇数：

for i in range(1, 101): if i % 2 == 1: print(i)

【代码 4-4】输出3到100以内所有素数：

for i in range(3, 101, 2): # 循环遍历3到100之间的每个奇数 isPrime = True # 假设当前整数为素数 for j in range(2, i): # 使用2到小于当前整数的所有整数去除 if i % j == 0: # 一旦能够整数 isPrime = False # 则当前整数不是素数 break # 提前退出内循环，不再进行是否素数的判断 if isPrime: # 如果是素数，则输出当前整数 print(i)

【代码 4-5】使用while语句重写代码 4-3，输出1到100以内所有奇数：

i = 1 while i <= 100: if i % 2 == 1: print(i) i += 1

【代码 4-6】PageRank算法是一种常见的网络权值迭代算法，主要用于诸如互联网网页的质量测度。基本计算原理是根据网页自身的链出将原始权值进行扩散，并通过多轮迭代获得稳定的收敛值来表征网页自身的最终权值。基本计算公式为：
其中R(u)'和R(u)分别表示网页u的新权值和上次计算的旧权值，Bu表示网页u的链入网页集合，Nv表示网页u的一个链入网页v全部的链出数量。下面通过一个例子说明基本计算方法。 假设有5个网页，链接关系如：
初始设置每个网页的权值都为0.2，即网页总数分之一。 第一轮计算为： 再加上每个网页各自的原始权值，可以得到第一轮计算后每个网页的新权值，即： 利用权值总和（为2）去除每个权值得到规范化后的权值为： 以此类推，再次使用该权值迭代进行相同的计算，反复计算后即可得到最终每个网页的权值。

r1, r2, r3, r4, r5 = 0.2, 0.2, 0.2, 0.2, 0.2 _r1 = 0 while abs(_r1 - r1) > 0.000001: _r1, _r2, _r3, _r4, _r5 = r1, r2, r3, r4, r5 r1 = _r1 + _r2 / 2 + _r3 / 2 + _r5 / 2 r2 = _r2 + _r1 / 1 r3 = _r3 + _r2 / 2 r4 = _r4 + _r3 / 2 + _r5 / 2 r5 = _r5 + _r4 / 1 total = r1 + r2 + r3 + r4 + r5 r1, r2, r3, r4, r5 = r1 / total, r2 / total, r3 / total, r4 / total, r5 / total print(r1, r2, r3, r4, r5)

【代码 4-7】使用while、break和continue语句重写代码 4-3，输出1到100以内所有奇数：

i = 0 while True: if i >= 100: break i += 1 if i % 2 == 0: continue print(i)

【代码 4-8】实现直接退出两层循环。如被乘数从1到5依次循环，每个被乘数都和2个输入的整数进行乘积运算，如果一旦输入的乘数为0，立刻结束所有循环：

for i in range(1, 6): for j in range(2): num = int(input('请输入乘数：')) print(i, '*', num, '=', i * num) if num == 0: break else: continue break

【代码 4-9】将输入整数作为分母，输出该分数的浮点数值。要求使用异常捕获实现对各种错误的处理：

try: num = int(input('请输入分母：')) print('结果是: {}'.format(1 / num)) except ValueError: print('输入无效，请输入一个整数。') except ZeroDivisionError: print('错误：分母不能为零。') except Exception as e: print('发生了一个意外错误: {}'.format(e))

【代码 4-10】在代码 4-9基础上，使用异常触发增加对负数分母的提示：

try: num = int(input('请输入分母：')) if num < 0: raise Exception('请输入正数') print('结果是: {}'.format(1 / num)) except ValueError: print('输入无效，请输入一个整数。') except Exception as e: print('发生了一个意外错误: {}'.format(e))

       

第五章 组合数据类型（点击代码可复制）

【代码 5-1】实现矩阵相加计算，如： matrix1 = [[1, 2, 3], [2, 3, 4], [3, 4, 5]] matrix2 = [[2, 3, 4], [3, 4, 5], [4, 5, 6]] matrix3 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] for i in range(len(matrix1)): for j in range(len(matrix1[i])): matrix3[i][j] = matrix1[i][j] + matrix2[i][j] for i in range(len(matrix3)): print(' '.join(str(x) for x in matrix3[i]))

【代码 5-2】排序是各类机器学习方法中一种非常基础的算法，常见的方法有选择排序、冒泡排序、希尔排序和归并排序等。其中选择排序每次从待排序列中选出一个最小值（或最大值），然后放在序列的起始位置（或末尾位置），直到全部待排数据排完即可。请利用选择排序算法对列表元素进行排序：

nums = [5, 2, 6, 1, 4, 3, 7, 8, 0] for i in range(0, len(nums) - 1): swapped = False for j in range(i + 1, len(nums)): if nums[i] > nums[j]: nums[i], nums[j] = nums[j], nums[i] swapped = True if not swapped: break print(nums)

【代码 5-3】判断列表为空的多种方法：

nums = [] if not nums: print('空列表') if len(nums) == 0: print('空列表') if bool(nums) == False: print('空列表')

【代码 5-4】使用序号来循环遍历列表次数不会受到列表元素增减的影响：

nums = [1, 2] for i in range(len(nums)): nums.append(0) print(nums)

【代码 5-5】使用直接循环遍历列表的次数会受到列表元素增减的影响：

nums = [1, 2] for i in nums: nums.append(0) print(nums)

【代码 5-6】利用梯度下降方法可以进行线性回归拟合。具体方法包括以下步骤：
①定义线性回归模型：假设线性回归模型为：
其中y是价格，x是面积，m是斜率，b是截距。
②定义损失函数：使用均方误差（MSE）作为损失函数，即：
其中，其中yi是真实面积，是预测面积。
③梯度下降：通过迭代更新m和b来最小化损失函数。在梯度下降计算时，每次迭代都需要更新初始设置的m和b，具体的更新增量可以使用损失函数求导来计算，比如在使用均方误差作为损失函数时，可以使用该损失函数的导数来计算m和b的增量，即：
④预测：使用训练好的模型预测指定面积时的房屋价格。
假设有房屋面积和价格数据，具体如列表内容所示：
areas = [120, 200.5, 80, 140, 90] # 面积
prices = [170.5, 210, 135.2, 180, 150.5] # 价格
请使用线性回归进行拟合，并预测当面积为100时的房屋价格：

# 已知数据 areas = [120, 200.5, 80, 140, 90] # 面积 prices = [170.5, 210, 135.2, 180, 150.5] # 价格 # 初始化参数 m = 0 # 斜率 b = 0 # 截距 learning_rate = 0.00001 # 学习率 num_iterations = 10000000 # 迭代次数 # 计算损失函数和梯度下降更新 for i in range(num_iterations): m_gradient = 0 b_gradient = 0 for j in range(len(areas)): x = areas[j] y = prices[j] y_pred = m * x + b m_gradient += (2 / len(areas)) * x * (y - y_pred) b_gradient += (2 / len(areas)) * (y - y_pred) m = m + learning_rate * m_gradient b = b + learning_rate * b_gradient if i % 100 == 0: # 每100次迭代打印一次损失 total_cost = 0 for j in range(len(areas)): y_pred = m * areas[j] + b total_cost += (prices[j] - y_pred) ** 2 print('Iteration {}: Cost = {}'.format(i, total_cost / len(areas))) # 打印结果 print('学习的参数为: m = {}, b = {}'.format(m, b)) # 预测当面积为100时的房屋价格 area = 100 predicted_price = m * area + b print('根据面积预测价格 {}: {}'.format(area, predicted_price))

【代码 5-7】在文本分析应用中，文档的词频统计通常是进行词语权值设计和语义相关性测度的基础性工作。请利用字典结构，实现对文本关键词的词频统计：

text = 'to be or not to be' keywords = text.lower().split() wordsDict = {} for word in keywords: if word not in wordsDict: wordsDict[word] = 1 else: wordsDict[word] = wordsDict[word] + 1 print(wordsDict)

【代码 5-8】在文本分析应用中，文档关键词的TF-IDF计算是一项基础性词项权值设置方法。其中TF是指词频，即文档中包含词语的个数，IDF是指倒文档频率，计算公式为：
其中N表示文档总数，n(i)表示含有关键词i的文档总数。假设有三篇文档：
Python is a computer language of AI
Java is also an important computer language
Learning Python is a very important thing in Python era
请编写计算每篇文档每个关键词TF-IDF权值的方法：

import math documents = [ "Python is a computer language of AI", "Java is also an important computer language", "Learning Python is a very important thing in Python era" ] # 停用词表 stopWords = ['is', 'a', 'an', 'of', 'in', 'also', 'very'] # 获取所有词，不使用集合 allKeywords = {word for doc in documents for word in doc.split() if word not in stopWords} # 计算IDF idfDict = {} for word in allKeywords: numDocsWithWord = sum(word in doc for doc in documents) idfDict[word] = math.log10(len(documents) / numDocsWithWord) # 计算TF allTfDict = [] for doc in documents: keywords = doc.split() keywords = [word for word in keywords if word not in stopWords] tfDict = {} for word in keywords: if word in tfDict: tfDict[word] += 1 else: tfDict[word] = 1 allTfDict.append(tfDict) # 利用上面的TF和IDF计算TF-IDF tfIdfDict = [] for tfDict in allTfDict: tfIdfDict.append({word: tfDict[word] * idfDict[word] for word in tfDict}) # 格式化输出tfIdfDict for i, tfIdf in enumerate(tfIdfDict): print("-------------------------\nDocument %d:" % (i + 1)) for word, tfIdfValue in tfIdf.items(): print("%s: %.4f" % (word, tfIdfValue))

【代码 5-9】删除出现在其他列表的列表元素：

vector1 = [1, 2, 3, 4, 5, 6] vector2 = [4, 5, 6, 7, 8] print(list(set(vector1) - set(vector2)))

       

第六章 函数与模块（点击代码可复制）

【代码 6-1】K近邻算法（K-Nearest Neighbors，简称KNN）常应用于各种分类任务中，算法认为如果一个样本数据在特征空间中的k个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，则该样本也属于这个类别。已知数据点及其所在的类别如：
为简化问题，请通过计算查询点（2.5，2.5）与已知数据点之间的欧几里得距离，找到距离最近的2个邻居类别。要求使用不同自定义函数来划分各种基本计算功能。

# 假设有以下数据点和它们的标签 data = [ [[1.5, 2.4], 'A'], [[2.0, 3.1], 'B'], [[2.8, 3.0], 'C'], [[6.5, 6.0], 'D'] ] # 定义一个函数来计算两点之间的欧几里得距离 def euclidean_distance(point1, point2): return sum((x - y) ** 2 for x, y in zip(point1, point2)) ** 0.5 # 定义一个函数来找到K个最近的邻居 def find_k_nearest_neighbors(data, query_point, k): d = [(euclidean_distance(query_point, point[0]), point[1]) for point in data] d.sort() return [label for point, label in d[:k]] # 测试K近邻算法 query_point = [2.5, 2.5] k = 2 predicted_label = find_k_nearest_neighbors(data, query_point, k) print('对测试点{}的预测标签为{}'.format(query_point, predicted_label))

【代码 6-2】利用递归函数调用反转字符串：

def reverseStr(strs): if len(strs) > 2: return strs[-1] + reverseStr(strs[:-1]) else: return strs[1] + strs[0] print(reverseStr('Python'))

【代码 6-3】利用递归函数可以实现决策树生成。
主要过程包括：
①实现基尼不纯度的计算，该指标可以衡量数据集纯度的一个指标，值越低表示数据集越纯净。当完全纯净时表示已经无需再进行判断分支的添加。
首先确定标签列表中有多少种类，对于每个标签类别，分别计算它在标签列表中出现的次数占总样本数的比例。通过计算每个类别比例的平方和，然后用1减去这个和，得到基尼不纯度值。计算公式为： 其中C为不同类别的总数，P(i)是第i个类别的出现比率。
②实现最佳分割点，通过遍历每个特征所有可能的分割点，计算每个分割点的基尼不纯度，并选择基尼不纯度最低的分割点作为最佳分割点。
首先对于每个特征（通过i索引），获取该特征的所有唯一值作为可能的阈值（thresholds），并使用相邻两个阈值平均值作为候选阈值。其次，对于每个候选阈值，将数据集分为左子集和右子集。如果某个子集为空，则跳过该阈值。同时，计算左子集和右子集的基尼不纯度，并加权求和得到总的基尼不纯度。最后，如果当前阈值的基尼不纯度小于当前最优的基尼不纯度，则确定最优分割点。
③递归构建决策树，根据设定的最大深度或数据集无法进一步分割（所有标签都相同或者基尼不纯度为0）的情况停止递归，并返回叶节点的值。否则，它会找到最佳分割点，分割数据集，并递归地构建左右子树。
已有电商企业订货数据，给出了该企业商品采购与否的已有情况： 请给出利用递归函数生成决策树的代码。

# 计算一组标签的基尼不纯度 def gini_impurity(labels): m = len(labels) return 1 - sum((labels.count(c) / m) ** 2 for c in set(labels)) # 找到最佳分割点（简化的决策树分裂函数） def best_split(X, y): best_gini = 1.0 best_feature = None best_threshold = None # 遍历每个特征和可能的分割点 for i in range(len(X[0])): thresholds = sorted( set(row[i] for row in X)) for j in range(len(thresholds) - 1): # 使用两个相邻值的平均值作为阈值 threshold = (thresholds[j] + thresholds[j + 1]) / 2 # 将数据集分割为左右子集 left_labels = [] right_labels = [] for row, label in zip(X, y): if row[i] <= threshold: left_labels.append(label) else: right_labels.append(label) # 如果某个子集为空，则跳过该分割点 if not left_labels or not right_labels: continue # 计算基尼不纯度 gini = (len(left_labels) / len(y)) * gini_impurity(left_labels) + \ (len(right_labels) / len(y)) * gini_impurity(right_labels) # 找到最佳分割点 if gini < best_gini: best_gini = gini best_feature = i best_threshold = threshold return best_gini, best_feature, best_threshold # 递归地分割数据集以构建决策树 def recursive_tree_split(X, y): # 达到最大深度或无法进一步分割（所有标签都相同），返回叶节点的值 if len(set(y)) == 1: return {'叶节点的值为：': max(set(y), key=y.count)} # 找到最佳分割点 best_gini, best_feature, best_threshold = best_split(X, y) # 如果无法找到有效的分割点，返回叶节点的值（多数类） if best_feature is None: return {'叶节点的值为：': max(set(y), key=y.count)} # 分割数据集 left_X = [] right_X = [] left_y = [] right_y = [] for row, label in zip(X, y): if row[best_feature] <= best_threshold: left_X.append(row) left_y.append(label) else: right_X.append(row) right_y.append(label) # 递归地构建左右子树 left_subtree = recursive_tree_split(left_X, left_y) right_subtree = recursive_tree_split(right_X, right_y) # 返回节点信息 return { '特征序号：': best_feature, '阈值：': best_threshold, '左子树：': left_subtree, '右子树：': right_subtree } # 特征矩阵 X = [ [50, 0.03, 60, 30], [100, 0.06, 100, 20], [210, 0.03, 250, 30], [200, 0.03, 450, 30], [220.3, 0.09, 500, 20], [150, 0.03, 50, 30], [210, 0.03, 90, 30], [320, 0.03, 100, 30], [120, 0.03, 285, 30], [21.6, 0.03, 450, 30], [80, 0.03, 500, 20], [155, 0.06, 500, 30], [80, 0.03, 510, 20], [91, 0.09, 520, 30]] # 标签向量 y = [ '不采购', '不采购', '不采购', '不采购', '不采购', '采购', '采购', '采购', '采购', '采购', '采购', '采购', '采购', '采购' ] # 构建决策树 tree = recursive_tree_split(X, y) print(tree)

【代码 6-4】神经元是神经网络的基本单位，可以接受多个数值输入，对其做一些数据操作，然后产生一个输出。比如图展示了一个2输入的神经元： 当x1和x2两个数值传递过来时，该神经元首先分别使用w1和w2权值去进行加权求和，然后加上偏置b，再继续将计算结果传递给一个激活函数F形成最终的输出y。
请编写一个可以表达上述计算过程的神经元函数：

import math def neuron(weights=[1, 1], bias=0, *inputs): # 加权输入，加入偏置，然后使用激活函数 total = sum(w * x for w, x in zip(weights, inputs)) + bias sigmoid = 1 / (1 + math.exp(-total)) return sigmoid weights = [0.1, 0.3] # w1权值为0.1, w2权值为0.3 bias = 1.45 # 偏置为1.45 print(neuron(weights, bias, 2, 3))

【代码 6-5】数据清洗和整理往往是各类机器学习方法必需的前期基础工作。对于各类组合数据，利用map和reduce函数可以极大的简化相关数据操作。
已知有字典数据统计了若干算法不同指标的性能：
data = [
{'name': 'CDAE', 'P@5': '0.45', 'P@10': '0.41', 'P@20': None},
{'name': 'Wide & Deep', 'P@5': None, 'P@10': '0.38', 'P@20': '0.318'},
{'name': 'NeuralCF', 'P@5': '0.419', 'P@10': None, 'P@20': '0.388'}
]
请给出每个算法的各个指标平均值，缺失值以该指标平均值来填充：

from collections import defaultdict from functools import reduce data = [ {'name': 'CDAE', 'P@5': '0.45', 'P@10': '0.41', 'P@20': None}, {'name': 'Wide & Deep', 'P@5': None, 'P@10': '0.38', 'P@20': '0.318'}, {'name': 'NeuralCF', 'P@5': '0.419', 'P@10': None, 'P@20': '0.388'} ] # 计算每个指标的平均值 def calculate_average_values(data): metric_sums = defaultdict(float) metric_counts = defaultdict(int) for row in data: for key, value in row.items(): if key != 'name': if value is not None: value = float(value) metric_sums[key] += value metric_counts[key] += 1 average_values = {key: metric_sums[key] / metric_counts[key] for key in metric_sums} return average_values # 定义函数来转换数据类型并处理空值 def clean_and_convert(row, average_values): return {key: float(value) if value is not None else average_values[key] for key, value in row.items() if key != 'name'} # 定义函数来计算平均指标值 def calculate_avg_score(row): return (reduce(lambda total, score: total + score, row.values()) / len(row.values())) average_values = calculate_average_values(data) # 使用map函数应用clean_and_convert到每一行数据 c_data = list(map(lambda row: clean_and_convert(row, average_values), data)) # 使用map函数将calculate_total_score应用到清洗后的数据行上 avg_scores = list(map(calculate_avg_score, c_data)) # 创建包含算法名称和平均指标值的列表来关联结果与原始数据 results = [{'算法': row['name'], '平均值': score} for row, score in zip(data, avg_scores)] # 输出结果 for result in results: print(result)

       

第七章 类与对象（点击代码可复制）

【代码 7-1】定义一个时钟类Clock，表达小时、分钟和秒的相关设置和格式输出：

class Clock: def setClock(self, hour, minute, second): self.hour = hour if 0 <= hour < 24 else 0 self.minute = minute if 0 <= minute < 60 else 0 self.second = second if 0 <= second < 60 else 0 def getClock(self): # 增加上午和下午的判断 suffix = 'AM' if self.hour < 12 else 'PM' display_hour = self.hour % 12 if self.hour % 12 != 0 else 12 return '{:02d}:{:02d}:{:02d} {}'.format(display_hour, self.minute, self.second, suffix) c1 = Clock() hour, minute, second = map(int, input().split(' ')) c1.setClock(hour, minute, second) print(c1.getClock())

【代码 7-2】完善代码 4-3时钟类Clock的定义，增加属性方法来访问属性：

class Clock: def setClock(self, hour, minute, second): self.hour = hour self.minute = minute self.second = second @property def hour(self): return self._hour @hour.setter def hour(self, value): self._hour = value if 0 <= value < 24 else 0 @property def minute(self): return self._minute @minute.setter def minute(self, value): self._minute = value if 0 <= value < 60 else 0 @property def second(self): return self._second @second.setter def second(self, value): self._second = value if 0 <= value < 60 else 0 def getClock(self): # 增加上午和下午的判断 suffix = 'AM' if self.hour < 12 else 'PM' display_hour = self.hour % 12 if self.hour % 12 != 0 else 12 return '{:02d}:{:02d}:{:02d} {}'.format(display_hour, self.minute, self.second, suffix) c1 = Clock() hour, minute, second = map(int, input().split(' ')) c1.setClock(hour, minute, second) c1.minute = 100 print(c1.minute)

【代码 7-3】编写表达一个字符的简单Token类，可以自动统计当前创建的类对象个数：

class Token: _count = 0 def __init__(self, char): self.char = char Token._count += 1 def __del__(self): Token._count -= 1 @property def char(self): return self._char @char.setter def char(self, value): self._char = value @classmethod def getCount(cls): return Token._count t1, t2 = Token('a'), Token('b') print(Token.getCount()) del t1 print(Token.getCount())

【代码 7-4】利用继承和多态完成时钟类和夏令时时钟类的设计，并动态以秒数更新时间显示：

from time import sleep class Clock: def __init__(self, hour=0, minute=0, second=0): self.setClock(hour, minute, second) def setClock(self, hour, minute, second): self.hour = hour self.minute = minute self.second = second @property def hour(self): return self._hour @hour.setter def hour(self, value): if value < 0: self._hour = 0 else: self._hour = value % 24 @property def minute(self): return self._minute @minute.setter def minute(self, value): if value < 0: self._minute = 0 else: self.hour += value // 60 self._minute = value % 60 @property def second(self): return self._second # 增加秒的判断和时间自动进位 @second.setter def second(self, value): if value < 0: self._second = 0 else: self.minute += value // 60 self._second = value % 60 def getClock(self): # 增加上午和下午的判断 suffix = 'AM' if self.hour < 12 else 'PM' display_hour = self.hour % 12 if self.hour % 12 != 0 else 12 return '{:02d}:{:02d}:{:02d} {}'.format(display_hour, self.minute, self.second, suffix) def __str__(self): return self.getClock() class DaylightSavingClock(Clock): # 构造函数 def __init__(self, hour=0, minute=0, second=0): super().__init__(hour, minute, second) # 表示夏令时开始，前进1小时 def start(self): self.setClock(self.hour + 1, self.minute, self.second) # 表示夏令时结束，后退1小时 def end(self): self.setClock(self.hour - 1, self.minute, self.second) def getClock(self): return 'DST ' + super().getClock() def process(c): while True: print('\r' + c.getClock(), end='') sleep(1) c.second += 1 d1 = DaylightSavingClock(1, 59, 55) d1.start() process(d1)

【代码 7-5】时间序列分析是一种常见的机器学习方法，简单的有回归分析、ARIMA等方法，复杂的有循环神经网络（RNN）、长短期记忆网络（LSTM）等。相关时间序列分析都建立在时间序列数据的表达基础之上。
为方便讲解，本例使用类来封装各种时间数据单元，并使用继承方法得到时间预测类，根据最小二乘法实现了简单线性回归时序预测模型：

class TimePoint: def __init__(self, timestamp, value): self.timestamp = timestamp self.value = value def __str__(self): return 'timestamp={}, value={}'.format(self.timestamp, self.value) class TimeSeries: def __init__(self): self.points = [] def add_point(self, timestamp, value): self.points.append(TimePoint(timestamp, value)) def __str__(self): return 'TimeSeries({})'.format(self.points) class LinearRegression: def __init__(self): self.slope = None self.intercept = None def fit(self, x, y): x_mean = sum(x) / len(x) y_mean = sum(y) / len(y) xy_cov = sum((x - x_mean) * (y - y_mean) for x, y in zip(x, y)) xx_cov = sum((x - x_mean) ** 2 for x in x) self.slope = xy_cov / xx_cov self.intercept = y_mean - self.slope * x_mean def predict(self, x_value): return self.slope * x_value + self.intercept class TimeSeriesPredictor(TimeSeries): def __init__(self): super().__init__() self.model = LinearRegression() def train(self): x_train = [p.timestamp for p in self.points] y_train = [p.value for p in self.points] self.model.fit(x_train, y_train) def predict_next(self): if (not hasattr(self.model, 'slope') or not hasattr(self.model, 'intercept')): raise Exception('模型尚未训练') # 使用最新的时间戳进行预测 latest_timestamps = [p.timestamp for p in self.points] next_timestamp = max(latest_timestamps) + 1 next_value = self.model.predict(next_timestamp) self.add_point(next_timestamp, next_value) return next_timestamp, next_value # 初始化时间序列和预测器 ts = TimeSeriesPredictor() # 添加数据点训练 ts.add_point(1, 11) ts.add_point(4, 48) ts.add_point(3, 23) ts.add_point(2, 15) ts.train() # 预测 next_timestamp, next_value = ts.predict_next() print('预测值：Timestamp={}, Value={}'.format(next_timestamp, next_value))

       

第八章 文件处理（点击代码可复制）

【代码 8-1】读取MovieLens数据集的数据文件“u.data”：

f = open('u.data') print(f.read()) f.close()

【代码 8-2】将输入内容写入文件：

f = open('result.txt', 'w') strs = input() f.write(strs) f.close()

【代码 8-3】重定位实现在“u.data”数据文件首行增加标题行：

f = open('u.data', 'r+') content = f.read() f.seek(0) f.write('uid\tmid\trating\ttimestamp\n') f.write(content) f.close()

【代码 8-4】在各种机器学习算法执行过程中，往往会产生很多错误。为了方便排查，常常使用日志文件将代码运行过程的一些关键信息和步骤保存下来，以便实时监控与调试，同时还可以记录系统在运行过程中的异常事件、方便开发者进行性能评价与优化。
编写一个简单的日志文件管理机制，可以记录代码运行的总次数和每次运行的时间：

import datetime current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') try: with open('visit.log', 'r+') as f: # 以读写模式打开，不创建文件 lines = f.readlines() # 读取全部行记录 if lines: last_visit = lines[-1].strip() # 获取最后一行 num = int(last_visit.split(',')[0]) + 1 # 访问次数加1 print('访问次数：{}次，时间为：{}'.format(num, current_time)) f.write('{},{}\n'.format(num, current_time)) except FileNotFoundError: # 如果异常说明不存在这个文件，是第一次访问 with open('visit.log', 'w') as f: # 以写入模式打开，创建文件 f.write('1,' + current_time + '\n') print('欢迎你第一次访问该文件！')

【代码 8-5】Excel文件是一种常见的数据文件形式，具体包括两种常见格式，分别是扩展名为“xls”的传统文档格式，和文件扩展名为“xlsx”的2013年以后新版格式。有两个Excel文件，分别是“sales.xls”和“sales.xlsx”（具体可以从教材配套在线资源下载），里面都只有一个工作表，名称是“Sheet1”，内容为一些超市商品的基本信息。
读取“sales.xls”文件：
import xlrd f = xlrd.open_workbook('sales.xls') sh = f.sheet_by_name('Sheet1') for i in range(sh.nrows): for j in range(sh.ncols): print(sh.cell_value(i, j), end='\t') print() 读取“sales.xlsx”文件：
import openpyxl f = openpyxl.load_workbook('sales.xlsx') sh = f['Sheet1'] for i in sh.rows: for j in i: print(j.value, end='\t') print()

【代码 8-6】以列表元素为名称批量创建多个文件夹：

import os def local_rm(path): # 递归删除含有内容的文件夹 if os.path.exists(path): # 如存在当前需要删除的文件夹 files = os.listdir(path) # 得到当前文件夹的下级文件夹及其文件列表 for file in files: # 循环遍历每一个子文件夹或者文件 filepath = os.path.join(path, file) # 获取完整路径 if os.path.isdir(filepath): # 如果是文件夹 local_rm(filepath) # 删除该子文件夹 else: # 如果是文件 os.remove(filepath) # 删除该文文件 os.rmdir(path) # 删除当前文件夹 root = 'temp' # 设置根文件夹 local_rm(root) # 删除已有的根文件夹 os.mkdir(root) os.chdir(root) dirs = ['202010001', '202010002', '202010003', '202010005', '202010010', '202010012', '202011001', '202011003'] # 文件夹名称列表 for i in dirs: # 读取每一个文件夹名称 os.mkdir(i) # 创建文件夹

       

第九章 常见模块的使用（点击代码可复制）

【代码 9-1】机器学习方法常常需要将数据文件划分为训练集和测试集。据此评价模型在未见数据上的泛化能力，确保模型不仅拟合训练数据，还能在实际应用中表现良好。
编写代码对“u.data”数据文件按照8：2随机划分训练集和测试集：

import random # 定义文件路径 file_path = 'u.data' # 定义训练集和测试集的比例 train_ratio = 0.8 # 读取数据 data = [] with open(file_path) as f: data = f.readlines() # 打乱数据顺序 random.shuffle(data) # 划分训练集和测试集 train_size = int(train_ratio * len(data)) train_data = data[:train_size] test_data = data[train_size:] # 打印结果 print("训练集样本数:", len(train_data)) print("测试集样本数:", len(test_data))

【代码 9-2】在很多机器学习方法测试中，需要大量仿真数据，这些数据常常遵守正态分布。正态分布是一种连续概率分布，由两个参数决定：均值（μ）和标准差（σ）。
请生成服从正态分布的模拟数据：

import random import math # 正态分布的随机数生成函数 def gaussian_random(mu, sigma): # 使用Box-Muller变换从均匀分布生成正态分布 u1 = random.random() u2 = random.random() z0 = math.sqrt(-2.0 * math.log(u1)) * math.cos(2.0 * math.pi * u2) return mu + sigma * z0 mu = 0 # 均值 sigma = 1 # 标准差 num_samples = 1000 # 样本数量 # 生成模拟数据 simulated_data = [gaussian_random(mu, sigma) for i in range(num_samples)] # 打印部分模拟数据 print(simulated_data[:5]) # 计算数据的统计特性以验证其分布 mean = sum(simulated_data) / num_samples variance = sum((x - mean) ** 2 for x in simulated_data) / num_samples std_dev = math.sqrt(variance) print('均值: {}'.format(mean)) print('方差: {}'.format(variance)) print('标准差: {}'.format(std_dev))

【代码 9-3】使用中文本地时间格式化输出MovieLens数据文件“u.data”中用户评分时间信息：

import time import locale startTime = time.localtime() startCount = time.perf_counter() locale.setlocale(locale.LC_CTYPE, 'zh_CN.UTF-8') with open('u.data') as f: data = f.readlines() for line in data: uid, mid, rating, dt = line.split() dt = time.strftime('%Y年%m月%d日 %H:%M:%S', time.localtime(int(dt))) print('\t'.join([uid, mid, rating, dt])) endTime = time.localtime() endCount = time.perf_counter() print('开始时间为：{}'.format(time.strftime('%H:%M:%S', startTime))) print('结束时间为：{}'.format(time.strftime('%H:%M:%S', endTime))) print('运行时间为：{}'.format(endCount - startCount))

【代码 9-4】利用MovieLens用户评分数据文件“u.data”，按照星期几统计每周所有用户的评分次数与平均评分：

import time # 数据文件路径 data_file = 'u.data' # 创建字典来存储统计信息，0-6代表星期一到星期日 data = {i: {'count': 0, 'total_rating': 0.0} for i in range(7)} # 打开并读取数据 with open(data_file) as file: for line in file: fields = line.strip().split('\t') # 分隔列数据 # 提取用户ID、电影ID、评分和时间戳 user_id = fields[0] movie_id = fields[1] rating = float(fields[2]) timestamp = int(fields[3]) # 将时间戳转换为时间元组 time_tuple = time.localtime(timestamp) # 提取星期几信息（0代表星期一，6代表星期日） weekday = time_tuple.tm_wday # 更新统计信息 data[weekday]['count'] += 1 data[weekday]['total_rating'] += rating # 计算平均评分并输出结果 for weekday, info in data.items(): if info['count'] > 0: average_rating = info['total_rating'] / info['count'] print('星期 {} : {} 访问量, 平均评分: {:.2f}'. format(weekday, info['count'], average_rating)) else: print('星期 {weekday}: 没有数据')

【代码 9-5】利用键盘控制绘图，如使用A向前绘制50像素，左箭头左转方向90度，并同时允许鼠标点击时直接绘制到点击位：

import turtle as t # 定义响应函数 def move_forward(): t.forward(50) def turn_left(): t.left(90) def click(x, y): t.setpos(x, y) t.pendown() # 监听键盘事件 t.listen() t.onkey(move_forward, 'a') # A键前进 t.onkey(turn_left, 'Left') # 左箭头键左转 t.Screen().onclick(click) # 点击绘制直线 # 保持窗口打开 t.done()

【代码 9-6】绘制指定两种颜色之间的渐变效果：

import turtle as t def lerp_color(start, end, t): # 用于计算两种颜色之间的过渡颜色 return ( start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t, start[2] + (end[2] - start[2]) * t ) width = 800 height = 600 start_color = (0, 0, 1) # 起始色 end_color = (1, 0, 1) # 终止色 t.setup(width, height) # 设置窗体大小 t.speed(0) # 设置画笔速度为最快 t.tracer(0, 0) # 关闭自动绘图更新 for i in range(width): t.penup() color_value = i / (width - 1) # 计算颜色值的改变量 current_color = lerp_color(start_color, end_color, color_value) # 计算颜色 t.pencolor(current_color) # 设置画笔颜色 t.setpos(-width / 2 + i, height / 2) # 移动画笔到最上方 t.pendown() t.setposition(-width / 2 + i, -height / 2) # 垂直绘制线条到最下方 t.done()

【代码 9-7】柱状图是一种常见的数据可视化方式，经常用于显示统计分组后的离散数据。请根据列表数据绘制柱状图：

import turtle as t import random def rectangle(t, x, y, width, height, color): angle = 0 t.penup() t.goto(x, y) t.pendown() t.colormode(1.0) t.fillcolor(color) t.begin_fill() for i in range(4): t.setheading(angle) if i % 2 == 0: t.forward(width) else: t.forward(height) angle += 90 t.end_fill() sales = [1200, 459, 710, 3000, 2100] maxSales = max(sales) for i in range(len(sales)): sales[i] = sales[i] / maxSales t.setup(600, 400) t.speed(0) x = -230 y = -100 for i in range(5): r = random.random() g = random.random() b = random.random() rectangle(t, x, y, 50, 200 * sales[i], (r, g, b)) x += 100 t.done()

【代码 9-8】统计《红楼梦》关键人物在同一段落中共现的次数：

import jieba # 得到两个列表任意两元素所有组合，不考虑重复元素对 def get_combinations(list1, list2): combinations = [] for item1 in list(set(list1)): for item2 in list(set(list2)): if item1 < item2: combinations.append((item1, item2)) return tuple(combinations) f = open('红楼梦.txt', encoding='utf-8') text = f.readlines() data = {} persons = ['宝玉', '贾母', '王夫人', '袭人', '宝钗', '黛玉', '凤姐', '贾政', '晴雯', '探春', '薛姨妈', '平儿', '贾琏', '鸳鸯', '邢夫人', '紫鹃'] for term in text: words = jieba.lcut(term) words = [k for k in words if k in persons] result = get_combinations(words, words) for i in result: data[i] = data.get(i, 0) + 1 data = dict(sorted(data.items(), key=lambda a: a[1], reverse=True)[:10]) print(data)

【代码 9-9】显示《红楼梦》相关高频词语的词云：

import jieba import wordcloud import matplotlib.pyplot as plt with open('红楼梦.txt', encoding='UTF-8') as f: data = f.read() words = jieba.lcut(data) words = [word for word in words if len(word) > 1] #去除长度为1的单字 words = ' '.join(words) img = plt.imread('book.jpg') wc = wordcloud.WordCloud(background_color='white', font_path="msyh.ttc", mask=img) #微软雅黑 wc.generate(words) wc.to_file('img.png')

【代码 9-10】利用DeepSeek实现单次大语言模型对话：

from openai import OpenAI client = OpenAI(api_key='API Key', base_url='https://api.deepseek.com') response = client.chat.completions.create( model='deepseek-chat', messages=[{'role': 'user', 'content': '简单介绍下Python语言'}], stream=False ) print(response.choices[0].message.content)

【代码 9-11】利用DeepSeek实现多轮大语言模型对话：

from openai import OpenAI client = OpenAI(api_key='API Key', base_url='https://api.deepseek.com') messages = [] while True: prompt = input('>>> ') if prompt == 'exit': break messages.append({'role': 'user', 'content': prompt}) response = client.chat.completions.create( model='deepseek-chat', messages=messages, stream=False ) messages.append(response.choices[0].message) print(response.choices[0].message.content)

【代码 9-12】抽取网页中的所有汉字（https://www.njcie.com）：

import urllib.request import re r = urllib.request.urlopen('https://www.njcie.com') page = r.read() page = page.decode('utf-8') results = re.findall("[\u4e00-\u9fa5]+", page) print(results)

【代码 9-13】点击按钮可以输出内容的简单窗体：

from tkinter import * def func(): label.config(text='点击了按钮') tk = Tk() tk.geometry('300x200+200+500') label = Label(tk, text='测试窗体') label.pack() button = Button(tk, text='确定', command=func) button.pack() mainloop()

【代码 9-14】累加两个数字之和的计算器：

from tkinter import * def add(): global preNumber preNumber = entryVar.get() entryVar.set('') def result(): entryVar.set(int(preNumber) + int(entryVar.get())) def digit(digit): entryVar.set(entryVar.get() + digit) tk = Tk() tk.title('简易计算器') tk.geometry('250x350') entryVar = StringVar() # 管理文本框内容 preNumber = '' # 存储被加数 entry = Entry(textvariable=entryVar, font=('Arial', 16), justify='right', state='readonly') entry.grid(row=0, column=0, columnspan=4, padx=10, pady=10) # 定义按钮布局配置（文本、行号、列号） buttons = [ ('7', 1, 0), ('8', 1, 1), ('9', 1, 2), # 第一行按钮 ('4', 2, 0), ('5', 2, 1), ('6', 2, 2), # 第二行按钮 ('1', 3, 0), ('2', 3, 1), ('3', 3, 2), # 第三行按钮 ('0', 4, 0), ('+', 4, 1), ('=', 4, 2) # 第四行按钮 ] # 循环创建按钮 for (text, row, col) in buttons: # 如果是加号按钮 if text == '+': btn = Button(text=text, command=add, font=('Arial', 14), width=5, height=2) elif text == '=': btn = Button(text=text, command=result, font=('Arial', 14), width=5, height=2) else: btn = Button(text=text, command=lambda t=text: digit(t), font=('Arial', 14), width=5, height=2) btn.grid(row=row, column=col, padx=4, pady=5) tk.mainloop()

【代码 9-15】最简单的静态Web网页：

from flask import Flask app = Flask('Exec') @app.route('/') def func(): return '<h1>Hello World!</h1>' app.run(debug=True)

【代码 9-16】将用户输入的内容再次显示出来的Web网页：

主代码文件Exec.py： from flask import Flask, request, render_template app = Flask('Exec') @app.route('/', methods=['GET', 'POST']) # 允许GET和POST请求 def func(): if request.method == 'POST': TEXT = request.form['TEXT'] # 获取页面输入的文本 if len(TEXT) != 0: return render_template('index.html', result=TEXT) # GET请求或TEXT为空时返回默认页面 return render_template('index.html') app.run(debug=True)

模板网页文件index.html：
<html> <body> {{result}} <form action="/" method="POST"> <textarea name="TEXT" placeholder="内容不能为空" required></textarea> <input type="submit" value="提交" id="submitButton" class="buttons2"> </form> </body> </html>

【代码 9-17】对名称为“ocr.jpg”的图片进行文字识别：

科大讯飞手写文字识别（直接粘贴到Flask项目中）

【代码 9-18】利用Flask构建在线语音合成界面：

科大讯飞语音合成（直接粘贴到Flask项目中）

       

第十章 NumPy数值处理（点击代码可复制）

【代码 10-1】生成由一千个随机浮点数组成的一维数组：

import numpy as np import random nums = np.array([random.random() for i in range(1000)]) print(nums)

【代码 10-2】返回离数组平均值最近的数组元素值：

import numpy nums = numpy.array([0, 1, 2, 3, 4, 5, 10, 15]) avg = nums.mean() diff = abs(nums - avg) print(nums[numpy.argwhere(diff == min(diff))[0][0]])

【代码 10-3】数据预处理是各类机器学习方法必须的前提工作。常见的数据问题有缺失值、异常值等问题。请利用NumPy实现使用列均值来填充二维数组的缺失值：

import numpy as np # 创建一个包含缺失值的二维数组 array = np.array([[1, 2, np.nan], [4, np.nan, 6], [7, 8, 9]]) # 获取数组的形状 rows, cols = array.shape # 创建一个相同形状的数组来存储结果 filled_array = np.copy(array) # 遍历每一列 for col in range(cols): # 计算当前列的非NaN值的均值 column_mean = np.nanmean(array[:, col]) # 使用where函数替换NaN值为均值 filled_array[:, col] = np.where(np.isnan(array[:, col]), column_mean, array[:, col]) print(filled_array)

【代码 10-4】数值分析是各类机器学习方法常见的基础性工作，尤其是相关性分析，它可以帮助去除冗余特征，实现特征选择与优化，提高模型性能，而且通过相关性分析有助于理解特征关系和进行重要性评价，从而提高模型的可解释性。
现有“pricesFull.csv”文件，记录了部分商品的相关价格数据信息： 请计算“本期价格”与“涨跌幅”的数据相关性。

import numpy as np prices = np.loadtxt('pricesFull.csv', dtype=np.str_, encoding='UTF-8', delimiter=',', skiprows=1, usecols=[4, 5, 6]) np.set_printoptions(suppress=True) prices[prices == ''] = '0' prices = prices.astype(float) print('协方差', np.cov(prices[:, 0], prices[:, 2])) print('欧式距离', np.sqrt(np.sum(np.square(prices[:, 0] - prices[:, 2])))) print('余弦夹角', np.dot(prices[:, 0], prices[:, 2].T) / (np.linalg.norm(prices[:, 0]) * np.linalg.norm(prices[:, 2])))

       

第十一章 Pandas数据查询（点击代码可复制）

【代码 11-1】查询每位读者借阅数量最多的年份及其借阅量：

import pandas as pd records = pd.read_csv('lending.dat') records['year'] = pd.to_datetime(records['date']).dt.year records = records[['uid', 'year', 'bid']].groupby(['uid', 'year']).count() records.reset_index(inplace=True) idxMax = records[['uid', 'bid']].groupby(['uid']).idxmax() print(records[records.index.isin(idxMax['bid'])].head())

【代码 11-2】k-means是一种常见的无监督机器学习聚类算法。其步骤主要为：
①初始化：随机选择K个初始簇心（centroids）。这些簇心可以是从数据集中随机抽取的数据点，或者使用其他方法如K-means++进行更智能的初始化，以提高收敛速度。
②分配数据点到簇：对每个数据点，计算其与K个簇心之间的距离（通常使用欧几里得距离）。将每个数据点分配给距离其最近的簇心，形成K个簇。
③更新簇心：重新计算每个簇的簇心，新的簇心是当前簇中所有数据点的均值（质心）。
④迭代：重复步骤2和步骤3，直到簇心不再发生显著变化（收敛），或者达到预设的最大迭代次数。
通过以上步骤，K-means算法能够找到K个簇，使得每个簇内的数据点尽可能相似，而不同簇之间的数据点尽可能不同。该算法的性能和结果受到初始簇心选择、K值的选择以及数据分布的影响。因此，在实际应用中，可能需要尝试不同的初始化方法、K值和数据预处理技术，以获得最佳的聚类效果。
现有十个二维坐标点： 请使用k-means聚类算法聚为两类：

import pandas as pd import numpy as np def kmeans(df, k, max_iters=100): # 初始化质心（随机选择k个点作为初始质心） indices = np.random.choice(df.index, k, replace=False) centroids = df.loc[indices] for i in range(max_iters): # 计算每个点到质心的距离，并分配到最近的质心 distances = [] for j, centroid in centroids.iterrows(): dist = np.sqrt(((df[['x', 'y']] - centroid)**2).sum(axis=1)) distances.append(dist) distances_df = pd.DataFrame(distances).T labels = distances_df.idxmin(axis=1) # 计算新的质心 new_centroids = df[['x', 'y']].groupby(labels).mean() # 检查质心是否收敛（是否没有变化） if new_centroids.equals(centroids): break centroids = new_centroids # 将聚类标签添加到DataFrame中 df['cluster'] = labels return df, centroids # 创建一个简单的二维数据集 data = { 'x': [1, 2, 1, 8, 8, 2, 9, 8, 7, 3], 'y': [2, 3, 3, 8, 6, 4, 10, 12, 11, 5] } df = pd.DataFrame(data) # 选择聚类数k k = 2 # 执行k-means聚类 df_clustered, centroids = kmeans(df, k) print('聚类后的数据集:') print(df_clustered) # 查询质心 print('质心坐标:') print(centroids)

【代码 11-3】利用MovieLens提供的用户评分数据（“u.data”）、用户信息（“u.user”）和电影信息（“u.item”），统计男女不同观众对各个年代电影的观影次数，其中年代以20年为单位来计算：

import pandas as pd # 读取用户评分数据 rnames = ['uid', 'mid', 'rating', 'timestamp'] ratings = pd.read_csv('u.data', sep='\t', names=rnames) ratings['datetime'] = pd.to_datetime(ratings['timestamp'], unit='s') # 读取用户数据 unames = ['uid', 'age', 'gender', 'occupation', 'zip'] users = pd.read_csv('u.user', sep='|', names=unames) # 读取电影数据 mnames = ['mid', 'title', 'date1', 'date2', 'url', 'unknown', 'Action', 'Adventure', 'Animation', 'Children', 'Comedy', 'Crime', 'Documentary', 'Drama', 'Fantasy', 'Film-Noir', 'Horror', 'Musical', 'Mystery', 'Romance', 'Sci-Fi', 'Thriller', 'War', 'Western'] movies = pd.read_csv('u.item', sep='|', names=mnames, encoding='ISO-8859-1') data = pd.merge(pd.merge(ratings, users), movies) # 获取电影拍摄年份 data = data[data['date1'].notnull()] data['year'] = pd.to_datetime(data['date1']).dt.year # 将电影年份转换为每20年一个数值 data['year'] = data['year'] % 1900 // 20 # 结果呈现 pd.set_option('display.max_rows', None) print(data[['gender', 'year', 'uid']].groupby(['gender', 'year']).count())

       

第十二章 数据可视化（点击代码可复制）

【代码 12-1】在读者借阅数据中，每天的借阅量和每天最高的单人借阅量是两个不同的借阅情况评价指标。请使用散点图分析两种数据的关系：

import pandas as pd from matplotlib import pyplot as plt records = pd.read_csv('lending.dat') records['date'] = pd.to_datetime(records['date']) # 分组得到每天借阅量 records1 = records[['uid', 'date']].groupby('date').count() # 分组得到每天最高的单人借阅量 records2 = records[['uid', 'bid', 'date']].groupby(['uid', 'date']).count().reset_index() records2 = records2[['bid', 'date']].groupby(['date']).max() # 绘制散点图 plt.scatter(records1.index, records1['uid'], c='lightgray', s=1, alpha=0.5) plt.scatter(records2.index, records2['bid'], c='black', s=1, alpha=0.5) plt.show()

【代码 12-2】代码 7-5使用类来封装各种时间数据单元，并使用继承方法得到时间预测类，根据最小二乘法实现了简单线性回归时序预测模型。在此基础上，绘制已有的原始点、预测点和拟合的线性回归线：

import matplotlib.pyplot as plt plt.rcParams['font.sans-serif'] = ['SimHei'] plt.scatter([p.timestamp for p in ts.points], [p.value for p in ts.points], color='blue', label='原始数据') plt.scatter(next_timestamp, next_value, color='red', label='预测值') plt.grid() # 使用线形图绘制线性回归模型 plt.plot([p.timestamp for p in ts.points], [ts.model.predict(p.timestamp) for p in ts.points], color='green', label='线性回归模型') plt.legend() plt.show()

【代码 12-3】代码 11-2介绍了无监督机器学习聚类算法k-means的实现，对十个二维坐标点使用k-means聚类算法聚为两类。在此基础上，绘制已有的原始点和质心，并使用不同颜色区分两个类：

import matplotlib.pyplot as plt plt.scatter(df_clustered['x'], df_clustered['y'], c=df_clustered['cluster']) plt.scatter(centroids['x'], centroids['y'], marker='d') plt.show()

       

第十三章 机器学习（点击代码可复制）

【代码 13-1】查看二手车交易记录中缺失数据所在的行列位置：

import pandas as pd records = pd.read_csv('car_train_0110.csv', sep=' ') records = records.isnull() for row in records.index: for col in records.columns: if (records.loc[row, col] == True): print(row, col)

【代码 13-2】在机器学习分类算法中，有两个常见指标，分别是精确率（Precision）和召回率（Recall）。所谓精确率，是指在分类模型预测为正例的所有样本中，实际为正例的样本所占的比例。而召回率是指在模型预测为正例的所有样本中，实际为正例的样本在全部正例样本的比例。精确率反映了模型对正例的识别能力，召回率可以测度全面捕获实际正例的能力。对于分类预测而言，虽然精确率和召回率这两个指标都是越高越好，但是在实际应用中，它们更容易产生此升彼降的“跷跷板”效应。虽然目前无法证明这种情况一定存在，但是在经验上却符合人们的认知。因为召回率会随着返回结果数量的增多而更有可能指标值上升，反之精确率却会因为返回结果数量增多后带来的更多错误判断而导致指标值下降。
请结合模拟数据，使用任一分类模型，绘制不同精确率下的召回率，形成所谓的PR（Precision-Recall）曲线：

import numpy as np import matplotlib.pyplot as plt from sklearn.metrics import precision_recall_curve, auc from sklearn.model_selection import train_test_split from sklearn.datasets import make_classification from sklearn.linear_model import LogisticRegression # 生成模拟数据 X, y = make_classification(n_samples=1000, n_features=20) # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y) # 训练一个逻辑回归模型 model = LogisticRegression() model.fit(X_train, y_train) # 计算预测概率 y_scores = model.predict_proba(X_test)[:, 1] # 计算Precision-Recall曲线和AUC（Area Under Curve） precision, recall, thresholds = precision_recall_curve(y_test, y_scores) pr_auc = auc(recall, precision) # 绘制PR曲线 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['font.size'] = 12 plt.plot(recall, precision, label=f'AUC面积 = {pr_auc:.2f}') plt.xlabel('召回率') plt.ylabel('精确率') plt.title('PR曲线') plt.legend() plt.grid(True) plt.show()

【代码 13-3】结合每日需求预测订单数据集“Daily_Demand_Forecasting_Orders.csv”（网址为：https://archive.ics.uci.edu/dataset/409/daily+demand+forecasting+orders，也可以在教学资源中下载）。这些数据来自于一家巴西物流公司60天内的相关数据，有12个与订单相关的特征数据，最后一个“Target (Total orders)”列表示订单总量。可以通过前面12个特征来预测订单总量。请使用回归模型，完成该订单总量预测模型构建：

import pandas as pd from sklearn.ensemble import AdaBoostRegressor from sklearn.model_selection import train_test_split from sklearn.tree import DecisionTreeRegressor import sklearn.metrics as sm # 读取数据 records = pd.read_csv('Daily_Demand_Forecasting_Orders.csv', sep=';') # 数据预处理 for column in records.columns: records[column] = pd.to_numeric(records[column], errors='coerce') records.fillna(records.mean(), inplace=True) # 划分特征列和预测列 predicted_column = 'Target (Total orders)' y = records[predicted_column] records.drop(columns=[predicted_column], inplace=True) X = records # 划分训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) # 训练模型并预测 model = AdaBoostRegressor(DecisionTreeRegressor(max_depth=4)) model.fit(X_train, y_train) y_pred = model.predict(X_test) # 获得最终评估模型结果 print('测试集R2指标值: {}'.format(round(sm.r2_score(y_test, y_pred), 2)))

【代码 13-4】利用Sequential模型实现企业审计数据风险列的分类预测：

# 导入必要的库 from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.utils import to_categorical import pandas as pd from sklearn.model_selection import train_test_split # 装载数据并进行数据预处理 records = pd.read_csv('audit_risk.csv') for column in records.columns: records[column] = pd.to_numeric(records[column], errors='coerce') records.fillna(records.mean(), inplace=True) # 划分特征列和预测列 y = records[records.columns[len(records.columns) - 1]] records.drop(records.columns[len(records.columns) - 1], axis=1, inplace=True) X = records # 将数据集划分为训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) # 将标签转换为独热编码 y_train = to_categorical(y_train, num_classes=2) y_test = to_categorical(y_test, num_classes=2) # 构建模型 model = Sequential() model.add(Dense(128, activation='relu')) model.add(Dense(2, activation='softmax')) # 编译模型 model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['precision']) # 训练模型 model.fit(X_train, y_train, epochs=50, batch_size=5, validation_split=0.2) # 评估模型 loss, precision = model.evaluate(X_test, y_test) print('损失值为: {:.4f}'.format(loss)) print('精确率为: {:.4f}'.format(precision))