【最近更新：2023.10.27】机器学习python常用函数总结-不定期更新

对样本集求平均样本

# 多个样本集
samples = np.array([[1, 2, 3],
                    [4, 5, 6],
                    [7, 8, 9]])

# 计算每个样本集的样本数量
sample_count = samples.shape[0]

# 计算每个样本集的样本值总和
sample_sum = np.sum(samples, axis=0)

# 计算平均样本值
average_sample = sample_sum / sample_count

print(average_sample)
# 输出：[4. 5. 6.]

其中axis=0，是指每一行对应位置求和，axis=1指每一列对应位置求和

随机取样

np.random.choice函数，其中replace参数用于设置是否允许出现重复的样本

从一个一维数组中随机采样

x = np.array([1,2,3,5])
y = np.random.choice(x, size=10, replace=True)
print(y)
# 输出：[5 1 2 5 3 2 3 3 5 3]

从样本集中随机选取多个样本

import numpy as np

# 数据集
data = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]])

# 随机选择3个样本
random_indices = np.random.choice(len(data), size=3, replace=False)
random_samples = data[random_indices]

print(random_samples)

选取表格中除了某列之外的列

用 .colums.drop(列名/列名列表)

如：选取除了标签列之外的列（若要除去多列则参数是要除去的列的列名列表）

import pandas as pd

# 假设您有一个名为"df"的DataFrame对象，包含标签列和特征列
# 标签列是"Label"，特征列是"Feature1"、"Feature2"、"Feature3"等等

# 选择除了标签列以外的特征列
feature_columns = df.columns.drop("Label")
# 选择除了标签列和"Feature1"列以外的特征列
# feature_columns = df.columns.drop(["Label", "Feature1"])
selected_features = df[feature_columns]

# 打印选取的特征列
print(selected_features)

numpy数组转list列表

.tolist() 可以方法将 NumPy 数组转换为常规的 Python 列表

注：像这样定义：arr = []， arr就是列表 用nparr = np.array(arr)，则nparr就是numpy数组

索引

整数、切片、布尔数组、省略号…可以用作索引

布尔索引

对numpy数组适用，返回的是pd.DataFram类型

例子：

import numpy as np

features = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 2]])
labels = np.array([[0], [1], [2]])
specified_dimension = 0

# 提取指定维度的值
specified_values = features[:, specified_dimension]

# 根据指定维度的值进行划分
condition = specified_values == 0
features_subset1 = features[condition]
labels_subset1 = labels[condition]

condition = specified_values == 1
features_subset2 = features[condition]
labels_subset2 = labels[condition]

# 输出结果
print(features_subset1)
print(labels_subset1)
print(features_subset2)
print(labels_subset2)

# 输出
#[[0 0 0]
# [0 0 1]]
#[[0]
# [1]]
#[[1 0 2]]
#[[2]]

   在 NumPy 中，布尔索引是一种有效的方法，可以根据条件选择数组的部分元素。它的原理是基于布尔值数组的 True 和 False。
当我们使用条件表达式（例如 specified_values == 0）对数组执行比较操作时，将生成一个布尔值数组。这个布尔值数组的长度与原始数组相同，其中的每个元素对应于相应位置上的条件结果。
  使用布尔索引时，只选择布尔值数组中对应为 True 的位置的元素。这样就能实现根据条件选择数组的部分元素的目的。
  在给定的示例中，我们首先通过 specified_values == 0 来生成一个布尔值数组。这个数组的长度与特征集合 features 的行数相同，对应位置上的元素为 True 或 False，表示该行在指定维度上的值是否为 0。类似地，我们使用 specified_values == 1 生成了另一个布尔值数组。然后，通过将布尔值数组作为索引传递给特征集合 features 和标签集合 labels，我们只选择了布尔值数组中对为 True 的位置的特征和标签，从而实现了根据条件划分数组的目标。

花式索引

在 NumPy 中，可以通过使用整数数组作为索引来获取数组的特定元素。这种索引方式被称为"花式索引"。即在给定索引数组 sorted_index 的情况下，可以直接使用arr[sorted_index] 来获取 arr 数组中相应索引位置的元素。
如：

import numpy as np

arr = np.array([10, 20, 30, 40, 50])
indices = np.array([3, 0, 4])

selected_elements = arr[indices]

print(selected_elements)
# 输出:
# [40 10 50]

在上述示例中，原始数组 arr 包含五个元素。通过使用索引数组 indices，我们可以选择 arr 数组中索引为 3、0 和 4 的元素。结果是一个新数组 selected_elements，其中包含了这些选择的元素 [40, 10, 50]。

使用省略号获取多维数组的元素

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
sub_array = arr[..., 1]  # 获取每行的索引为1的元素，结果为[2, 5, 8]

flatten()

用于将多维数组转为一维数组

切片

一维切片

  切片是指从序列（如列表、字符串、元组等）中提取一部分元素的操作。切片操作使用方括号 [] 和冒号 : 来指定提取的起始位置和结束位置。

  操作的语法如下：

sequence[start:stop:step]

其中：
start：切片的起始位置（包含在切片中）。
stop：切片的结束位置（不包含在切片中）。
step：切片的步长（可选参数），用于指定每次跳过的元素个数。

一些例子：

sequence = [0, 1, 2, 3, 4, 5]
slice_1 = sequence[1:4]  # 提取索引1到索引3的元素
slice_2 = sequence[:3]   # 提取从开头到索引2的元素
slice_3 = sequence[2:]   # 提取从索引2到末尾的元素
slice_4 = sequence[::2]  # 每隔一个元素提取一个元素

print(slice_1)  # 输出: [1, 2, 3]
print(slice_2)  # 输出: [0, 1, 2]
print(slice_3)  # 输出: [2, 3, 4, 5]
print(slice_4)  # 输出: [0, 2, 4]

一些常用用法：
[::-1] ：用于对列表进行逆序排序

切片多维数组（numpy数组）

  操作的语法如下（各变量含义同上）：

sequence[start:stop:step, start:stop:step]

一些例子：

import numpy as np

arr = np.array([[1, 2, 3],
                [4, 5, 6],
                [7, 8, 9]])

# 选择第一行
slice_1 = arr[0, :]
print(slice_1)  # 输出: [1 2 3]

# 选择第一列
slice_2 = arr[:, 0]
print(slice_2)  # 输出: [1 4 7]

# 选择最后一列
slice_3 = arr[:, -1]

# 选择一个子数组
slice_4 = arr[1:3, 1:3]
print(slice_4)
# 输出:
# [[5 6]
#  [8 9]]

# 选择步长为2的行和列
slice_5 = arr[::2, ::2]
print(slice_5)
# 输出:
# [[1 3]
#  [7 9]]

另一个例子：选择除了第2列以外的其他特征列：用到np.r_[]

import numpy as np

# 假设您有一个名为"features"的NumPy数组，其中包含特征数据
# 特征数组的每一列代表一个特征

# 选择除了第2列以外的其他特征列
selected_features = features[:, np.r_[0:2, 3:]]

# 打印选取的特征列
print(selected_features)

使用np.r_[0:2, 3:]来生成一个索引数组，该数组指定了需要选择的列。0:2表示选择从第0列到第2列（不包括第2列），3:表示选择从第3列开始的所有列。

np.argsort()

np.argsort() 是 NumPy 数组对象的一个函数，用于返回数组排序后的索引。

在给定一个数组时，np.argsort() 返回一个数组，其中包含原始数组排序后的索引值。默认情况下，索引按升序排列。
若想得到逆序排序的索引，可以跟上[::-1]
如

index = np.argsort(arr.flatten)[::-1] 

shape和size

numpy数组、pd.DataFrame有shape这个属性（列表list没有），输出：(行数, 列数)，可以用[0]提取行数，[1]提取列数

size属性也是numpy数组、pd.DataFrame才有，和shape的区别：size是获得元素的总数

注： 若想要获得list列表大小，用len(list_name)

用法举例：

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.shape)
# 输出(2, 3)
print(arr.size)
# 输出6
print(arr.shape[0])
# 输出2
print(arr.shape[1])
# 输出3

reshape

对np.array后的ndarray类型数组可以进行reshape
注意：list类型不能reshape

reshape(-1)：转换为一维数组

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
reshaped_arr = arr.reshape(-1)
print(reshaped_arr)
# 输出:
# [1, 2, 3, 4, 5, 6]

reshape(-1, 1)：可以将一维数组转换为列向量（一列）

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
reshaped_arr = arr.reshape(-1, 1)
print(reshaped_arr)
# 输出:
# [[1]
#  [2]
#  [3]
#  [4]
#  [5]]

reshape((a, b))，其中a、b均>=1：转换为a行b列的多维数组（注意a,b还要用一个括号括起来）

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6])
reshaped_arr = arr.reshape((2, 3))
print(reshaped_arr)
# 输出:
# [[1 2 3]
#  [4 5 6]]

Counter类

from collections import Counter
import numpy as np
x=np.array([[0,133,1],[0,132,0],[0,133,0]])
# 使用Counter类对数组第2列进行遍历
counter = Counter(x[:,1])
# 第2列中有1个132和2个133，输出该counter对象可以统计这列的数值情况，便于之后的统计
print(counter)
# 因为第2列中没有为0的值，所以返回0
print(counter[0])
# 因为第2列中有2个133，所以返回2
print(counter[133])
# 一般的字典操作方法都能在该类中使用，例如可以通过values函数返回该列的非重复值的个数，方便对某列的非重复值的个数进行查看。可以看每个值的个数
print(counter.values())
# counter.values()返回的是迭代器，也可以将其转换为list输出，这样可以对其for遍历
print(list(counter.valuse()))
# 可以输出所有非重复值
print(list(counter))

# 输出
# Counter({133: 2, 132: 1})
# 0
# 2
# dict_values([2, 1])
# dict_values([2, 1])
# [133, 132]

numpy数组、list列表、pd.DataFrame对比

numpy数组n，list列表l，pd.DataFrame d

numpy数组：

无列名

• 求大小：shape、size属性：n.shape、n.size
• 获取第x行：n[x]
• 获取第y列：n[:, y]
• 转list：n.tolist()
• 计算两列 NumPy 数组中相同值的个数：

import numpy as np

'''
使用条件比较运算符 == 对两个数组进行逐元素比较，生成一个布尔类型的数组，
其中相同元素的位置为 True，不同元素的位置为 False。
再使用 np.sum() 函数对布尔数组求和，
由于 True 值在求和时被视为 1，False 值被视为 0，因此求和的结果即为相同值的个数。
'''

# 两列 NumPy 数组
array1 = np.array([1, 2, 3, 4, 5])
array2 = np.array([3, 4, 5, 6, 7])

# 计算相同值的个数
count = np.sum(array1 == array2)
print(count)

pd.DataFrame：

有列名

• 求大小：shape、size属性：d.shape、d.size
• 求所有列名：d.columes / d.columns.tolist() （输出不同，两者类型不同，后者输出列表）
• 求第x列的列名：d.columns[x] / d.columns.tolist()[x] （输出相同）
• 求列名为name的列在第几列：d…columns.tolist().index(name)
• 获取列名为name的列数据：d[name] ，将该列转list：np.array(d[name]).tolist() / d[name].tolist()
• 整个DataFrame转numpy：np.array(d)
• 整个DataFrame转numpy：np.array(d).tolist() / d.values.tolist()
• 增加一行：d._append(new_row, ignore_index=True)（ ignore_index=True保证行索引从1开始递增）

注意：不能像numpy那样，如想要获得第y列，不能d[y]（会报错），需要先得到第y列的列名，再通过列名获取该列数据

list：

• 求大小：len(l)
• 转numpy：np.array(l)