最全面的Pandas开发文档

起个铭子2025-03-14 14:42

Pandas 开发文档

安装

因为 Pandas 是基于 Numpy 的，所以使用 Pandas 前要安装 Numpy。

通用安装

使用 pip 安装：

bash 复制代码 
pip install numpy
pip install pandas

Anaconda 环境

如果安装了 Anaconda 并使用 Jupyter Notebook，就无需额外安装这两个库。

使用

在代码中导入 numpy 包和 pandas 包：

python 复制代码 
import numpy as np
import pandas as pd

Series

结构

Series 是一维数据，由索引（index）和值（value）组成。

创建方式

通过列表创建
python 复制代码 
import pandas as pd
series_from_list = pd.Series([1, 2, 3])
print("通过列表创建的Series:", series_from_list)
通过 numpy 数组创建
python 复制代码 
import numpy as np
import pandas as pd
arr = np.array([1, 2, 3])
series_from_array = pd.Series(arr)
print("通过numpy数组创建的Series:", series_from_array)
通过字典创建

字典的键为 Series 的索引，值为 Series 的值。

python 复制代码 
import pandas as pd
data = {'a': 1, 'b': 2, 'c': 3}
series_from_dict = pd.Series(data)
print("通过字典创建的Series:", series_from_dict)

索引

自定义索引
python 复制代码 
import pandas as pd
series = pd.Series([1, 2, 3])

# 使用数组自定义索引
new_index_array = np.array(['x', 'y', 'z'])
series.index = new_index_array
print("使用数组自定义索引后的Series:", series)

# 使用列表自定义索引
new_index_list = ['m', 'n', 'p']
series.index = new_index_list
print("使用列表自定义索引后的Series:", series)
显示索引
python 复制代码 
import pandas as pd
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])

# 访问单个元素（不可修改）
single_value = series["a"]
print("显示索引访问单个元素（不可修改）:", single_value)

# 访问多个元素
multiple_values = series[['a', 'b']]
print("显示索引访问多个元素:", multiple_values)

# 可修改元素
series.loc["a"] = 10
print("通过loc修改元素后的Series:", series)
隐式索引
python 复制代码 
import pandas as pd
series = pd.Series([1, 2, 3])

# 访问单个元素（不可修改）
single_value = series[0]
print("隐式索引访问单个元素（不可修改）:", single_value)

# 访问多个元素
multiple_values = series[[0, 1]]
print("隐式索引访问多个元素:", multiple_values)

# 可修改元素
series.iloc[0] = 10
print("通过iloc修改元素后的Series:", series)

切片

显示切片
python 复制代码 
import pandas as pd
series = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
# 结果包含开始和结束索引对应的值
sliced_series = series["a":"c"]
print("显示切片结果:", sliced_series)
隐式切片
python 复制代码 
import pandas as pd
series = pd.Series([1, 2, 3, 4])
# 结果包含开始索引对应的值，但不包含结束索引对应的值
sliced_series = series[0:2]
print("隐式切片结果:", sliced_series)

# 将整个 Series 对象的元素倒序
reversed_series = series[::-1]
print("倒序后的Series:", reversed_series)

Series 对象之间的运算

Series 运算仅对索引相同的元素进行加、减、乘、除、整除、取余操作。当两个 Series 进行运算时，若其中一个 Series 缺少某些索引对应的元素，这些缺失部分的计算结果为 NaN，且不存在广播机制。

python 复制代码 
import pandas as pd
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([4, 5], index=['a', 'b'])

# 相加操作，'c' 索引在 s2 中缺失，结果为 NaN
result = s1 + s2
print("Series相加的结果:", result)

DataFrame

DataFrame 是一种二维数据结构，类似于电子表格或 SQL 表。它由行和列索引组成，能够方便地处理和操作结构化数据。

二、DataFrame 创建

2.1 通过字典创建

可以使用字典来创建 DataFrame，其中字典的键将成为列名，值可以是列表、数组等可迭代对象，代表每列的数据。示例代码如下：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)

2.2 通过二维数组创建

也可以直接使用二维数组来创建 DataFrame。示例如下：

python 复制代码 
import numpy as np
import pandas as pd
arr = np.array([[1, 'a'], [2, 'b'], [3, 'c']])
df = pd.DataFrame(arr, columns=['col1', 'col2'])

三、行和列索引

3.1 列索引优先

使用a[index]的形式可以优先进行列索引操作，其中index为列名。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
col1_data = df['col1']

3.2 行索引优先

使用a.loc[index]（基于标签索引）或a.iloc[index]（基于整数位置索引）进行行索引操作。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
first_row = df.loc[0]  # 基于标签获取第一行
first_row_iloc = df.iloc[0]  # 基于整数位置获取第一行

3.3 修改数据

修改某行某列或某个元素的数据时，只能使用iloc。示例：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
df.iloc[0, 0] = 10  # 将第一行第一列的数据修改为10

四、行和列切片（数据查询）

4.1 基本切片形式

使用data[m:n][m:n]的形式进行切片操作，第一个[]是行切片，第二个[]是列切片。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3, 4, 5], 'col2': ['a', 'b', 'c', 'd', 'e']}
df = pd.DataFrame(data)
subset = df[1:3]['col2']  # 获取第2、3行的col2列数据

4.2 切片与索引结合

切片和索引可以同时进行，优先进行行切片，然后进行列索引。示例：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3, 4, 5], 'col2': ['a', 'b', 'c', 'd', 'e']}
df = pd.DataFrame(data)
subset = df[1:3].loc[:, 'col2']  # 获取第2、3行的col2列数据

五、运算

5.1 DataFrame 与普通常数计算

DataFrame 可以与普通常数进行算术运算，运算会应用到 DataFrame 的每个元素上。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
new_df = df + 1  # 每个元素加1

5.2 DataFrame 与 DataFrame 计算

两个形状相同的 DataFrame 可以进行算术运算，对应位置的元素进行运算。例如：

python 复制代码 
import pandas as pd
data1 = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
data2 = {'col1': [7, 8, 9], 'col2': [10, 11, 12]}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
result = df1 + df2  # 对应元素相加

5.3 DataFrame 与 Series 计算

DataFrame 与 Series 之间也可以进行运算，Series 会自动对齐到 DataFrame 的行或列进行运算。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
s = pd.Series([10, 10])
result = df + s  # Series会自动对齐到列进行相加

5.4 逻辑运算

DataFrame 支持各种逻辑运算，如比较运算、逻辑与、逻辑或等。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
bool_df = df > 2  # 比较每个元素是否大于2

六、添加或修改一列数据或一行数据

6.1 添加或修改一列数据

可以通过赋值操作来添加或修改一列数据。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3]}
df = pd.DataFrame(data)
df['new_col'] = [4, 5, 6]  # 添加新列
df['col1'] = [10, 20, 30]  # 修改col1列的数据

6.2 添加或修改一行数据

可以使用loc或iloc来添加或修改一行数据。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
df.loc[3] = [7, 8]  # 添加一行数据
df.iloc[0] = [10, 20]  # 修改第一行数据

七、删除一列数据或多列数据，或者删除一行数据或多行数据

7.1 删除列数据

使用data.drop(column, inplace)方法可以删除一列或多列数据，column可以是列名或列名列表，inplace=True表示在原 DataFrame 上进行修改。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
df.drop('col2', axis=1, inplace=True)  # 删除col2列

7.2 删除行数据

使用data.drop(index, inplace)方法可以删除一行或多行数据，index可以是行索引或行索引列表，inplace=True表示在原 DataFrame 上进行修改。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
df.drop(1, axis=0, inplace=True)  # 删除第二行

八、修改索引

8.1 变维索引

可以使用set_index方法将某一列设置为索引，或者使用reset_index方法将索引重置为默认整数索引。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6], 'index_col': ['a', 'b', 'c']}
df = pd.DataFrame(data)
df.set_index('index_col', inplace=True)  # 将index_col列设置为索引
df.reset_index(inplace=True)  # 重置索引

8.2 修改索引名称

使用rename_axis方法可以修改索引的名称。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3]}
df = pd.DataFrame(data)
df.index.name = 'new_index_name'  # 修改索引名称

8.3 重置索引

使用reset_index方法可以将索引重置为默认整数索引。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3]}
df = pd.DataFrame(data)
df.set_index('col1', inplace=True)  # 将col1列设置为索引
df.reset_index(inplace=True)  # 重置索引

九、多层索引

9.1 创建

9.1.1 Series 创建多层次索引

可以使用MultiIndex.from_product等方法创建多层次索引的 Series。例如：

python 复制代码 
import pandas as pd
import numpy as np
index = pd.MultiIndex.from_product([['A', 'B'], [1, 2]], names=['level1', 'level2'])
s = pd.Series(np.random.randn(4), index=index)
9.1.2 DataFrame 创建多层次索引
  • 方式一 ：使用set_index方法将多列设置为索引。例如：
python 复制代码 
import pandas as pd
data = {'col1': ['A', 'A', 'B', 'B'], 'col2': [1, 2, 1, 2], 'col3': [10, 20, 30, 40]}
df = pd.DataFrame(data)
df.set_index(['col1', 'col2'], inplace=True)
  • 方式二：笛卡尔积 ：使用MultiIndex.from_product方法创建笛卡尔积形式的多层次索引。例如：
python 复制代码 
import pandas as pd
import numpy as np
index = pd.MultiIndex.from_product([['A', 'B'], [1, 2]], names=['level1', 'level2'])
data = np.random.randn(4, 1)
df = pd.DataFrame(data, index=index, columns=['col1'])

9.2 索引操作

可以使用loc等方法进行多层次索引的操作，例如选取特定层次的索引数据。例如：

python 复制代码 
import pandas as pd
data = {'col1': ['A', 'A', 'B', 'B'], 'col2': [1, 2, 1, 2], 'col3': [10, 20, 30, 40]}
df = pd.DataFrame(data)
df.set_index(['col1', 'col2'], inplace=True)
subset = df.loc['A']  # 选取col1为'A'的数据

9.3 切片操作

多层次索引也支持切片操作，可以对不同层次的索引进行切片。例如：

python 复制代码 
import pandas as pd
data = {'col1': ['A', 'A', 'B', 'B'], 'col2': [1, 2, 1, 2], 'col3': [10, 20, 30, 40]}
df = pd.DataFrame(data)
df.set_index(['col1', 'col2'], inplace=True)
subset = df.loc[('A', slice(None))]  # 选取col1为'A'的所有数据

9.4 堆叠

使用stack和unstack方法可以进行多层次索引的堆叠和展开操作。例如：

python 复制代码 
import pandas as pd
data = {'col1': ['A', 'A', 'B', 'B'], 'col2': [1, 2, 1, 2], 'col3': [10, 20, 30, 40]}
df = pd.DataFrame(data)
df.set_index(['col1', 'col2'], inplace=True)
stacked_df = df.stack()  # 堆叠操作
unstacked_df = stacked_df.unstack()  # 展开操作

常见操作

一、分组聚合（分组聚合）

1.1 单层索引 DataFrame 分组聚合

使用 groupby 方法对单层索引的 DataFrame 进行分组，然后应用聚合函数。例如，按某一列分组并计算另一列的总和：

python 复制代码 
import pandas as pd
data = {'category': ['A', 'A', 'B', 'B'], 'value': [1, 2, 3, 4]}
df = pd.DataFrame(data)
result = df.groupby('category')['value'].sum()

1.2 多层次索引 DataFrame 分组聚合

对于多层次索引的 DataFrame，同样使用 groupby 方法，指定相应层次的索引进行分组。例如：

python 复制代码 
import pandas as pd
import numpy as np
index = pd.MultiIndex.from_product([['A', 'B'], [1, 2]], names=['level1', 'level2'])
data = {'value': np.random.randn(4)}
df = pd.DataFrame(data, index=index)
result = df.groupby(level='level1')['value'].sum()

1.3 整个 DataFrame 当成一个分组聚合

将整个 DataFrame 视为一个分组，直接对其应用聚合函数。例如，计算整个 DataFrame 所有数值元素的总和：

python 复制代码 
import pandas as pd
import numpy as np
data = np.random.randn(3, 3)
df = pd.DataFrame(data)
result = df.sum().sum()

1.4 Series 的聚合

Series 可以直接调用聚合函数，如 sum、max 等。例如：

python 复制代码 
import pandas as pd
s = pd.Series([1, 2, 3, 4])
sum_result = s.sum()
max_result = s.max()

二、去重

使用 drop_duplicates 方法去除 DataFrame 或 Series 中的重复元素。对于 DataFrame，可以指定 subset 参数来指定基于哪些列判断重复。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 1, 2], 'col2': ['a', 'a', 'b']}
df = pd.DataFrame(data)
unique_df = df.drop_duplicates()
unique_df_subset = df.drop_duplicates(subset='col1')

三、排序

使用 sort_values 方法对 DataFrame 或 Series 进行排序。可以指定按某一列或多列进行升序或降序排列。例如：

python 复制代码 
import pandas as pd
data = {'col1': [3, 1, 2], 'col2': ['c', 'a', 'b']}
df = pd.DataFrame(data)
sorted_df_asc = df.sort_values(by='col1')  # 按col1升序排列
sorted_df_desc = df.sort_values(by='col1', ascending=False)  # 按col1降序排列

四、数据合并

4.1 拼接合并

使用 concat 方法可以将多个 DataFrame 或 Series 按行或列进行拼接。例如：

python 复制代码 
import pandas as pd
data1 = {'col1': [1, 2], 'col2': ['a', 'b']}
data2 = {'col1': [3, 4], 'col2': ['c', 'd']}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
result_row = pd.concat([df1, df2])  # 按行拼接
result_col = pd.concat([df1, df2], axis=1)  # 按列拼接

4.2 合并（join）

使用 merge 方法进行类似 SQL 中表连接的操作。可以指定连接的键、连接方式（如内连接、外连接等）。例如：

python 复制代码 
import pandas as pd
data1 = {'key': ['A', 'B'], 'col1': [1, 2]}
data2 = {'key': ['A', 'B'], 'col2': ['a', 'b']}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
result = pd.merge(df1, df2, on='key', how='inner')  # 内连接

五、联表查询 merge

与上述数据合并中的 merge 操作类似，用于将两个 DataFrame 基于指定的键进行连接查询。可通过参数指定连接方式（how，如 'inner'、'outer'、'left'、'right'）、连接键（on 或 left_on、right_on）等。

六、异常值过滤

6.1 NaN 缺失值过滤

使用 dropna 方法可以过滤掉包含 NaN 值的行或列。例如：

python 复制代码 
import pandas as pd
import numpy as np
data = {'col1': [1, np.nan, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
filtered_df = df.dropna()  # 默认过滤包含NaN值的行
filtered_df_cols = df.dropna(axis=1)  # 过滤包含NaN值的列

6.2 重复值过滤

6.2.1 标志重复行

使用 duplicated 方法可以标记出 DataFrame 中的重复行，返回一个布尔型 Series。subset 参数可指定基于哪些列判断重复，keep 参数可取值 'first'（保留第一次出现的行）、'last'（保留最后一次出现的行）、False（标记所有重复行）。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 1, 2], 'col2': ['a', 'a', 'b']}
df = pd.DataFrame(data)
duplicated_series = df.duplicated(subset=['col1', 'col2'], keep='first')
6.2.2 删除重复行

使用 drop_duplicates 方法删除重复行，参数 subset 和 keep 的作用与 duplicated 方法中类似，inplace 参数为 True 时会在原 DataFrame 上进行修改。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 1, 2], 'col2': ['a', 'a', 'b']}
df = pd.DataFrame(data)
unique_df = df.drop_duplicates(subset=['col1', 'col2'], keep='first', inplace=False)

七、查找过滤

7.1 条件查询

使用 query 方法可以方便地进行条件查询。可以使用变量、逻辑判断（and、or）、is not NULL、范围取值（in、not in、any、all）等操作。例如：

python 复制代码 
import pandas as pd
data = {'column_1': [50, 70, 80], 'column_2': ['x', 'y', 'z']}
df = pd.DataFrame(data)
result = df.query("column_1 > 60 and column_2 == 'y'")

7.2 切片筛选

通过布尔索引进行切片筛选。例如，筛选出某一列大于特定值的行：

python 复制代码 
import pandas as pd
data = {'col1': [10, 20, 30], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
subset = df[df['col1'] > 10]

7.3 模糊查询

对于文本类型的列，可以使用 str.contains 进行模糊查询。例如：

python 复制代码 
import pandas as pd
data = {'text': ['apple', 'banana', 'cherry']}
df = pd.DataFrame(data)
result = df[df['text'].str.contains('an')]

八、数据映射

8.1 map

map 方法用于 Series，将一个字典或函数应用到 Series 的每个元素上，进行值的映射或转换。例如：

python 复制代码 
import pandas as pd
s = pd.Series(['cat', 'dog', 'fish'])
mapping = {'cat': 'pet1', 'dog': 'pet2', 'fish': 'pet3'}
result = s.map(mapping)

8.2 apply

apply 方法可用于 Series 或 DataFrame。对于 Series，它将一个函数应用到每个元素上；对于 DataFrame，它可以将函数应用到行或列上。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3]}
df = pd.DataFrame(data)
result_series = df['col1'].apply(lambda x: x * 2)  # 对col1列每个元素乘以2
result_df = df.apply(lambda row: row.sum(), axis=1)  # 计算每行的总和

8.3 applymap

applymap 方法用于 DataFrame，将一个函数应用到 DataFrame 的每个元素上。例如：

python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
result = df.applymap(lambda x: x * 10)  # 每个元素乘以10

8.4 transform

transform 方法用于 DataFrame 或 Series，它可以在不改变数据形状的情况下对数据进行转换。例如，对分组后的数据进行转换：

python 复制代码 
import pandas as pd
data = {'category': ['A', 'A', 'B', 'B'], 'value': [1, 2, 3, 4]}
df = pd.DataFrame(data)
result = df.groupby('category')['value'].transform(lambda x: x - x.mean())

九、分箱操作（离散操作）

9.1 pandas.cut

pandas.cut 方法用于将 DataFrame 的某一列或 Series 分成指定的区间（bins），并可以为每个区间指定标签（labels）。例如：

python 复制代码 
import pandas as pd
import numpy as np
data = {'value': np.random.randn(10)}
df = pd.DataFrame(data)
df['binned'] = pd.cut(df['value'], bins=3, labels=['low','medium', 'high'])

9.2 pandas.qcut

pandas.qcut 方法根据分位数将 DataFrame 的某一列或 Series 分成指定数量的区间（q），并可以为每个区间指定标签（labels）。例如：

python 复制代码 
import pandas as pd
import numpy as np
data = {'value': np.random.randn(10)}
df = pd.DataFrame(data)
df['binned'] = pd.qcut(df['value'], q=4, labels=['Q1', 'Q2', 'Q3', 'Q4'])

Series 和 DataFrame 的常用属性和方法

一、引言

Pandas 库中的 Series 和 DataFrame 是处理结构化数据的重要数据结构。本开发文档将详细介绍它们的常用属性和方法，帮助开发者更好地操作和处理数据。

二、常用属性

2.1 修改或者获取索引的值index

  • 功能：用于修改或者获取索引的值。对于 Series，它返回一个 Index 对象，表示 Series 的索引；对于 DataFrame，它返回行索引。通过该属性，可以方便地对索引进行操作，如修改索引值、获取索引相关信息等。

  • 示例 - Series：

python 复制代码 
import pandas as pd
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(s.index)  # 输出: Index(['a', 'b', 'c'], dtype='object')
s.index = ['x', 'y', 'z']  # 修改索引
print(s)
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data, index=['row1', 'row2', 'row3'])
print(df.index)  # 输出: Index(['row1', 'row2', 'row3'], dtype='object')
df.index = ['new_row1', 'new_row2', 'new_row3']  # 修改索引
print(df)

2.2 获取元素values

  • 功能：获取 Series 或 DataFrame 的所有元素。对于 Series，它返回一个 numpy 数组，包含 Series 的所有值；对于 DataFrame，它返回一个二维 numpy 数组，包含 DataFrame 的所有数据。

  • 示例 - Series：

python 复制代码 
import pandas as pd
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(s.values)  # 输出: [10 20 30]
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
print(df.values)  
# 输出: [[1 4]
#        [2 5]
#        [3 6]]

2.3 获取元素的总个数size

  • 功能：获取 Series 或 DataFrame 元素的总个数。无论是 Series 还是 DataFrame，该属性都返回其包含的元素总数。

  • 示例 - Series：

python 复制代码 
import pandas as pd
s = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(s.size)  # 输出: 3
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
print(df.size)  # 输出: 6

三、常用方法

3.1 前 n 个索引和元素head()

  • 功能：获取 Series 或 DataFrame 的前 n 个索引和元素，n 默认值为 5。通过该方法，可以快速预览数据的前几行内容。

  • 示例 - Series：

python 复制代码 
import pandas as pd
s = pd.Series([10, 20, 30, 40, 50, 60])
print(s.head())  
# 输出: 
# 0    10
# 1    20
# 2    30
# 3    40
# 4    50
# dtype: int64
print(s.head(3))  
# 输出: 
# 0    10
# 1    20
# 2    30
# dtype: int64
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3, 4, 5, 6], 'col2': [7, 8, 9, 10, 11, 12]}
df = pd.DataFrame(data)
print(df.head())  
# 输出: 
#    col1  col2
# 0     1     7
# 1     2     8
# 2     3     9
# 3     4    10
# 4     5    11
print(df.head(3))  
# 输出: 
#    col1  col2
# 0     1     7
# 1     2     8
# 2     3     9

3.2 tail()

  • 功能：获取 Series 或 DataFrame 的后 n 个索引和元素，n 默认值为 5。该方法有助于查看数据的末尾部分。

  • 示例 - Series：

python 复制代码 
import pandas as pd
s = pd.Series([10, 20, 30, 40, 50, 60])
print(s.tail())  
# 输出: 
# 1    20
# 2    30
# 3    40
# 4    50
# 5    60
# dtype: int64
print(s.tail(3))  
# 输出: 
# 3    40
# 4    50
# 5    60
# dtype: int64
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3, 4, 5, 6], 'col2': [7, 8, 9, 10, 11, 12]}
df = pd.DataFrame(data)
print(df.tail())  
# 输出: 
#    col1  col2
# 1     2     8
# 2     3     9
# 3     4    10
# 4     5    11
# 5     6    12
print(df.tail(3))  
# 输出: 
#    col1  col2
# 3     4    10
# 4     5    11
# 5     6    12

3.3 转换数据类型astype()

  • 功能：转换 Series 或 DataFrame 列的数据类型。对于 Series，可以直接调用该方法进行类型转换；对于 DataFrame，通常对某一列调用该方法来改变其数据类型。

  • 示例 - Series：

python 复制代码 
import pandas as pd
s = pd.Series([1, 2, 3])
new_s = s.astype(float)
print(new_s)  
# 输出: 
# 0    1.0
# 1    2.0
# 2    3.0
# dtype: float64
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': ['4', '5', '6']}
df = pd.DataFrame(data)
df['col2'] = df['col2'].astype(int)
print(df.dtypes)  
# 输出: 
# col1    int64
# col2    int64
# dtype: object

3.4 isnull()

  • 功能：筛选出 Series 或 DataFrame 中值为 NaN 的元素，返回一个与原数据结构相同的布尔型 Series 或 DataFrame，其中值为 NaN 的位置对应为 True，否则为 False。

  • 示例 - Series：

python 复制代码 
import pandas as pd
import numpy as np
s = pd.Series([1, np.nan, 3])
print(s.isnull())  
# 输出: 
# 0    False
# 1     True
# 2    False
# dtype: bool
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
import numpy as np
data = {'col1': [1, np.nan, 3], 'col2': [4, 5, np.nan]}
df = pd.DataFrame(data)
print(df.isnull())  
# 输出: 
#    col1   col2
# 0  False  False
# 1   True  False
# 2  False   True

3.5 notnull()

  • 功能：与 isnull () 相反，筛选出 Series 或 DataFrame 中不为 NaN 的元素，返回一个与原数据结构相同的布尔型 Series 或 DataFrame，其中值不为 NaN 的位置对应为 True，否则为 False。

  • 示例 - Series：

python 复制代码 
import pandas as pd
import numpy as np
s = pd.Series([1, np.nan, 3])
print(s.notnull())  
# 输出: 
# 0    True
# 1    False
# 2    True
# dtype: bool
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
import numpy as np
data = {'col1': [1, np.nan, 3], 'col2': [4, 5, np.nan]}
df = pd.DataFrame(data)
print(df.notnull())  
# 输出: 
#    col1   col2
# 0   True  True
# 1  False  True
# 2   True  False

3.6 获取简要信息info()

  • 功能：提供 Series 或 DataFrame 的简要信息，包括数据类型、非空值数量等。对于 DataFrame，它会列出每一列的相关信息。

  • 示例 - Series：

python 复制代码 
import pandas as pd
s = pd.Series([1, 2, 3])
s.info()  
# 输出: <class 'pandas.core.series.Series'>
# Index: RangeIndex(start=0, stop=3, step=1)
# Data columns (total 1 columns):
# 0    int64
# dtypes: int64(1)
# memory usage: 48.0 bytes
  • 示例 - DataFrame：
python 复制代码 
import pandas as pd
data = {'col1': [1, 2, 3], 'col2': [4, 5, 6]}
df = pd.DataFrame(data)
df.info()  
# 输出: <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 3 entries, 0 to 2
# Data columns (total 2 columns):
#  #   Column  Non-Null Count  Dtype
# ---  ------  --------------  -----
#  0   col1    3 non-null      int64
#  1   col2    3 non-null      int64
# dtypes: int64(2)
# memory usage: 128.0 bytes

数据读写操作

一、MySQL 数据操作

1.1 安装相关的第三方库

在使用 Python 操作 MySQL 数据库之前，需要安装必要的第三方库：

  • pymysql：一个纯 Python 实现的 MySQL 客户端库。使用 pip install pymysql 命令进行安装。

  • sqlalchemy：一个强大的数据库抽象层库，支持多种数据库。使用 pip install sqlalchemy 命令进行安装。

1.2 创建连接引擎

通过 sqlalchemy 创建与 MySQL 数据库的连接引擎。示例代码如下：

python 复制代码 
from sqlalchemy import create_engine

# 创建连接引擎，替换用户名、密码、主机、端口和数据库名
engine = create_engine('mysql+pymysql://username:password@host:port/database_name')

1.3 直接读取 MySQL 数据成 DataFrame 对象

使用 read_sql 方法从 MySQL 数据库中读取数据并转换为 Pandas 的 DataFrame 对象。示例如下：

python 复制代码 
import pandas as pd
from sqlalchemy import create_engine

engine = create_engine('mysql+pymysql://username:password@host:port/database_name')
query = "SELECT * FROM your_table_name"  # 替换为你的 SQL 查询语句
df = pd.read_sql(query, engine)

1.4 直接将 DataFrame 对象数据保存到数据库

使用 to_sql 方法将 DataFrame 对象中的数据保存到 MySQL 数据库中。示例代码如下：

python 复制代码 
import pandas as pd
from sqlalchemy import create_engine

engine = create_engine('mysql+pymysql://username:password@host:port/database_name')
data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
# 将 DataFrame 保存到数据库表中，如果表存在，'replace' 表示替换表，可根据需求改为 'append' 等
df.to_sql('your_table_name', engine, if_exists='replace', index=False)

二、CSV 数据操作

2.1 读取 CSV 数据成 DataFrame 对象

Pandas 提供了 read_csv 方法用于读取 CSV 文件并转换为 DataFrame 对象，无需安装额外的第三方库。示例如下：

python 复制代码 
import pandas as pd

# 读取 CSV 文件，文件路径替换为实际路径
df = pd.read_csv('your_file_path.csv')

2.2 将 DataFrame 数据保存成 CSV 文件

使用 to_csv 方法将 DataFrame 对象的数据保存为 CSV 文件。该方法的常用参数如下：

  • path_or_buf：文件路径或文件对象。

  • sep：字段分隔符，默认为逗号 ,。

  • index：是否保存行索引，默认为 True。

  • header：是否保存列名，默认为 True。

  • mode：文件打开模式，默认为 'w'（写入）。

  • encoding：文件编码，如 'utf - 8'。

示例代码如下：

python 复制代码 
import pandas as pd

data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
df.to_csv('output.csv', sep=',', index=False, header=True, mode='w', encoding='utf-8')

2.3 读取 CSV 文件数据成 DataFrame（带参数详解）

read_csv 方法还有一些其他常用参数，如 index_col 用于指定用作行索引的列。示例如下：

python 复制代码 
import pandas as pd

# 将文件中的 'id' 列作为行索引
df = pd.read_csv('your_file_path.csv', index_col='id')

三、Excel 数据操作

3.1 安装三方模块

操作 Excel 文件需要安装 openpyxl 模块，使用 pip install openpyxl 命令进行安装。

3.2 将 DataFrame 保存为 Excel 文件

使用 to_excel 方法将 DataFrame 对象保存为 Excel 文件。常用参数如下：

  • excel_writer：文件路径或 ExcelWriter 对象。

  • sheet_name：工作表名称，默认为 Sheet1。

  • na_rep：缺失值表示方式。

  • index：是否保存行索引，默认为 True。

  • header：是否保存列名，默认为 True。

示例代码如下：

python 复制代码 
import pandas as pd

data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
df.to_excel('output.xlsx', sheet_name='Sheet1', index=False, header=True)

3.3 读取 Excel 文件数据成 DataFrame

使用 read_excel 方法读取 Excel 文件并转换为 DataFrame 对象。常用参数如下：

  • io：文件路径或文件对象。

  • sheet_name：工作表名称或索引，默认为 0（第一个工作表）。

  • index_col：指定用作行索引的列。

示例代码如下：

python 复制代码 
import pandas as pd

# 读取 Excel 文件的第一个工作表
df = pd.read_excel('your_file_path.xlsx', sheet_name=0)

四、JSON 数据操作

4.1 加载 JSON 数据成 DataFrame

使用 read_json 方法将 JSON 数据加载为 DataFrame 对象。file_path_or_buf 参数可以是 JSON 文件路径或包含 JSON 数据的字符串。示例如下：

python 复制代码 
import pandas as pd

# 从 JSON 文件加载数据
df = pd.read_json('your_file_path.json')

4.2 将 DataFrame 保存到 JSON 文件

使用 to_json 方法将 DataFrame 对象保存为 JSON 文件。示例代码如下：

python 复制代码 
import pandas as pd

data = {'col1': [1, 2, 3], 'col2': ['a', 'b', 'c']}
df = pd.DataFrame(data)
df.to_json('output.json')

五、处理含有时序数据的情况

当上述四种数据加载和保存操作中涉及含有时序的数据时，可以使用 parse_dates 参数将指定列解析为日期时间类型。示例如下：

python 复制代码 
import pandas as pd

# 读取 CSV 文件，将 'date' 列解析为日期时间类型
df = pd.read_csv('your_file_path.csv', parse_dates=['date'])

# 将 DataFrame 保存为 CSV 文件
df.to_csv('output.csv', sep=',', index=False, header=True)

此外，还可以通过 date_format 参数指定日期时间的显示格式。例如：

python 复制代码 
import pandas as pd

data = {'date': ['2023-01-01', '2023-01-02'], 'value': [10, 20]}
df = pd.DataFrame(data)
# 将 'date' 列转换为日期时间类型，并指定保存时的格式
df['date'] = pd.to_datetime(df['date'])
df.to_csv('output.csv', sep=',', index=False, header=True, date_format='%Y-%m-%d')

重采样（时间序列）

一、时间序列基础

1.1 使用场景

时间序列数据在众多领域都有广泛应用，如金融领域的股票价格走势、电商领域的销售数据随时间变化、气象领域的气温记录等。通过对时间序列数据的分析，可以发现趋势、周期性等特征，为决策提供支持。

1.2 两种时间对象

在 Pandas 中，主要有两种与时间相关的对象：datetime64 和 Timedelta。datetime64 用于表示日期和时间，Timedelta 用于表示时间间隔。

1.3 时间转换（格式化）

使用 pandas.to_datetime() 方法可以将各种格式的时间数据转换为 Pandas 认可的标准时间格式。other_datetime_list 的元素可以是时间戳、字符串等多种形式。

示例 - 加载外部数据的日期数据格式化：

  • MySQL 数据 ：假设从 MySQL 中读取的日期数据为字符串格式 '2023-01-01'，可以使用以下代码进行转换：
python 复制代码 
import pandas as pd
import pymysql
# 连接 MySQL 数据库并读取数据（示例代码，需根据实际情况修改）
conn = pymysql.connect(host='your_host', user='your_user', password='your_password', database='your_database')
query = "SELECT date_column FROM your_table"
df = pd.read_sql(query, conn)
df['date_column'] = pd.to_datetime(df['date_column'])
  • Excel 数据 ：如果 Excel 文件中的日期列数据为 '01/01/2023' 这种格式，转换代码如下：
python 复制代码 
import pandas as pd
df = pd.read_excel('your_excel_file.xlsx')
df['date_column'] = pd.to_datetime(df['date_column'])

二、时间索引和切片

2.1 创建时间索引

  • 方式一：自己创建时间索引 ：可以使用 pd.date_range() 方法创建一个时间索引。例如，创建一个从 2023-01-01 到 2023-01-31，频率为每天的时间索引：
python 复制代码 
import pandas as pd
date_index = pd.date_range(start='2023-01-01', end='2023-01-31', freq='D')
  • 方式二：外部加载的数据设置时间索引 ：假设从外部加载的 DataFrame student_df 中有一列 'birth' 存储出生日期数据，将其设置为时间索引：
python 复制代码 
import pandas as pd
student_df = pd.read_csv('students.csv')
student_df['birth'] = pd.to_datetime(student_df['birth'])
student_df.set_index('birth', inplace=True)

2.2 时间切片和索引的使用

  • 使用时间索引注意点：时间索引支持基于标签的索引方式，可以像普通索引一样获取对应时间点的数据。

  • 使用时间切片注意点 ：时间切片可以方便地获取一段时间范围内的数据，切片时可以使用 : 来指定起始和结束时间。

索引案例：

  • 获取一月出生的同学信息 ：假设 student_df 的索引已经设置为时间索引（出生日期），代码如下：
python 复制代码 
january_students = student_df[student_df.index.month == 1]
  • 获取一月出生的同学姓名：
python 复制代码 
january_student_names = student_df[student_df.index.month == 1]['name']

切片案例：

  • 获取一月之后出生的同学信息：
python 复制代码 
after_january_students = student_df[student_df.index >= '2023-01-01']
  • 获取一月一日之后出生的同学姓名：
python 复制代码 
after_jan_1_student_names = student_df[student_df.index >= '2023-01-01']['name']

建议 ：在获取两个时间范围内的数据时，建议使用 query 来查询，而不是切片。例如：

python 复制代码 
result = student_df.query("index >= '2023-01-01' and index <= '2023-02-01'")

三、时间索引的属性

3.1 获取年份

使用 df.index.year 可以获取每个时间索引的年份，返回一个索引列表对象。例如：

python 复制代码 
import pandas as pd
date_index = pd.date_range(start='2023-01-01', end='2023-03-31', freq='D')
data = {'value': range(len(date_index))}
df = pd.DataFrame(data, index=date_index)
years = df.index.year
print(years)

3.2 获取月份

使用 df.index.month 获取每个时间索引的月份，返回一个索引列表对象：

python 复制代码 
months = df.index.month
print(months)

3.3 获取日

使用 df.index.day 获取每个时间索引的日，返回一个索引列表对象：

python 复制代码 
days = df.index.day
print(days)

3.4 获取星期几

使用 df.index.dayofweek 获取每个时间索引是星期几（0 代表星期天），返回一个索引列表对象：

python 复制代码 
day_of_week = df.index.dayofweek
print(day_of_week)

四、时间序列的常用功能

4.1 时间移动

使用 data.shift(n, freq) 方法可以将时间序列数据在时间上进行移动。n 表示移动的 periods，freq 表示时间频率。例如，将数据向后移动 1 天：

python 复制代码 
import pandas as pd
date_index = pd.date_range(start='2023-01-01', end='2023-01-03', freq='D')
data = {'value': [10, 20, 30]}
df = pd.DataFrame(data, index=date_index)
shifted_df = df.shift(1, freq='D')

4.2 频率转换（数据会变密）

频率转换可以将时间序列从一种频率转换为另一种频率，例如从日频率转换为月频率。

4.3 重采样（重要）

使用 dataframe.resample(rule) 方法进行重采样，rule 为维度规则。

模拟一年的销售额和用户量代码示例：

python 复制代码 
import pandas as pd
import numpy as np
date_index = pd.date_range(start='2023-01-01', end='2023-12-31', freq='D')
sales = np.random.randint(100, 500, size=len(date_index))
users = np.random.randint(10, 50, size=len(date_index))
data = {'sales': sales, 'users': users}
df = pd.DataFrame(data, index=date_index)

示例 1：统计每个月的销量：

python 复制代码 
monthly_sales = df['sales'].resample('M').sum()

示例 2：统计每周的销量和用户量：

python 复制代码 
weekly_data = df.resample('W').agg({'sales':'sum', 'users':'sum'})

五、时区

在处理跨时区的时间序列数据时，需要考虑时区的设置和转换。Pandas 提供了 tz 参数来处理时区相关操作。例如，将一个无时区的时间索引设置为特定时区（如 'Asia/Shanghai'）：

python 复制代码 
import pandas as pd
date_index = pd.date_range(start='2023-01-01', end='2023-01-03', freq='D')
date_index = date_index.tz_localize('Asia/Shanghai')

还可以使用 tz_convert 方法进行时区转换。例如，将时间索引从 'Asia/Shanghai' 转换为 'America/New_York'：

python 复制代码 
new_date_index = date_index.tz_convert('America/New_York')

常用数据分析方法

一、计算一列数据的分布情况

1.1 统计每个元素出现的次数

在 Pandas 的 DataFrame 中，可以使用 value_counts() 方法来统计某一列中每个元素出现的次数。该方法返回一个 Series，索引为该列的唯一元素，对应的值为元素出现的频数。

示例代码：

python 复制代码 
import pandas as pd

data = {'age': [20, 20, 25, 30, 25]}
df = pd.DataFrame(data)
age_counts = df['age'].value_counts()
print(age_counts)
输出结果 复制代码 
20    2
25    2
30    1
Name: age, dtype: int64

二、评估一列数据波动大小

2.1 方差和标准差

方差（Variance）和标准差（Standard Deviation）是衡量数据离散程度的常用统计量。在 Pandas 中，可以分别使用 var() 和 std() 方法来计算一列数据的方差和标准差。

  • 方差：反映数据与其平均值的偏离程度的平方的平均值，计算公式为 ，其中 是数据点， 是平均值， 是数据点的数量。

  • 标准差：是方差的平方根，它与原始数据具有相同的量纲，能更直观地反映数据的离散程度，计算公式为 。

示例代码：

python 复制代码 
import pandas as pd

data = {'values': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
variance = df['values'].var()
standard_deviation = df['values'].std()
print("方差:", variance)
print("标准差:", standard_deviation)
输出结果 复制代码 
方差: 250.0
标准差: 15.811388300841898

三、评估两组数据（不一定是同一张表）的变化趋势是否相关

3.1 协方差

协方差（Covariance）用于衡量两个变量的总体的变化趋势。如果两个变量的变化趋势一致，也就是说如果其中一个大于自身的期望值时另外一个也大于自身的期望值，那么两个变量之间的协方差就是正值；如果两个变量的变化趋势相反，则协方差为负值。在 Pandas 中，可以使用 cov() 方法来计算两列数据的协方差。

示例代码：

python 复制代码 
import pandas as pd

data = {
    'col1': [1, 2, 3, 4, 5],
    'col2': [5, 4, 6, 2, 7]
}
df = pd.DataFrame(data)
covariance = df['col1'].cov(df['col2'])
print("协方差:", covariance)
输出结果 复制代码 
协方差: -1.75

3.2 相关系数

相关系数（Correlation Coefficient）是衡量两个变量之间线性相关程度的统计量，其取值范围在 -1 到 1 之间。相关系数的绝对值越接近 1，表示两个变量之间的线性相关性越强；越接近 0，表示线性相关性越弱。

  • 计算一个表的每一列之间的相关系数 ：使用 corr() 方法，该方法返回一个相关系数矩阵，矩阵中的元素 表示第 列和第 列之间的相关系数。

  • 求一列数据和一张表中的每一列数据的相关系数 ：使用 corrwith() 方法，该方法返回一个 Series，索引为目标表的列名，对应的值为与指定列的相关系数。

示例代码：

python 复制代码 
import pandas as pd

data = {
    'col1': [1, 2, 3, 4, 5],
    'col2': [5, 4, 6, 2, 7],
    'col3': [10, 20, 30, 40, 50]
}
df = pd.DataFrame(data)

# 计算一个表的每一列之间的相关系数
corr_matrix = df.corr()
print("相关系数矩阵:\n", corr_matrix)

# 求一列数据和一张表中的每一列数据的相关系数
col1_corrs = df['col1'].corrwith(df)
print("col1与各列的相关系数:\n", col1_corrs)
输出结果 复制代码 
相关系数矩阵:
          col1       col2       col3
col1  1.000000 -0.540062  1.000000
col2 -0.540062  1.000000 -0.540062
col3  1.000000 -0.540062  1.000000
col1与各列的相关系数:
col1    1.000000
col2   -0.540062
col3    1.000000
dtype: float64

四、查看一列数据的增长量（累加）

4.1 使用 cumsum () 方法

cumsum() 方法用于计算某一列数据的累加和，即从第一个元素开始依次累加每个元素的值。在分析数据的增长趋势，如半年收入变化等场景中非常有用。

示例代码：

python 复制代码 
import pandas as pd

data = {'income': [1000, 2000, 1500, 3000]}
df = pd.DataFrame(data)
cumulative_income = df['income'].cumsum()
print("累加收入:", cumulative_income)
输出结果 复制代码 
累加收入: 0    1000
1    3000
2    4500
3    7500
Name: income, dtype: int64

抽样方法

一、简介

在数据分析和处理中，抽样是从大量数据中选取代表性子集的重要方法。Pandas 提供了 take 方法用于实现抽样操作，同时结合 Numpy 库的随机函数，可以方便地进行无放回抽样和放回抽样。本开发文档将详细介绍如何使用这些方法进行抽样。

二、df.take (index_list) 方法概述

df.take(index_list) 是 Pandas 中 DataFrame 的一个方法，用于根据给定的索引列表选取 DataFrame 中的行。其中，index_list 是一个包含索引值的列表，这些索引值用于指定要选取的行。

2.1 index_list 的要求

  • index_list 里面的元素数值规定是 0 到 len (df) - 1，顺序是随机的。例如 [2, 5, 1, 9, 0, 3, 4, 6, 9]。每个元素的值代表在原 DataFrame 对应的行索引。

三、无放回抽样

无放回抽样是指在抽样过程中，每个样本一旦被抽取，就不会再被放回总体中，即每个样本只能被抽取一次。

3.1 实现方法

使用 Numpy 库的 random.permutation 函数生成不重复的随机索引列表，然后将其作为参数传递给 df.take 方法。示例代码如下：

python 复制代码 
import pandas as pd
import numpy as np

# 创建示例 DataFrame
data = {'col1': [10, 20, 30, 40, 50],
        'col2': ['a', 'b', 'c', 'd', 'e']}
df = pd.DataFrame(data)

# 生成随机索引列表（无放回抽样）
index_list = np.random.permutation(len(df))
# 使用 take 方法进行无放回抽样
sampled_df = df.take(index_list)
print(sampled_df)

在上述代码中，np.random.permutation(len(df)) 生成了一个包含 0 到 len(df) - 1 的随机排列的索引列表，确保了每个索引只出现一次，从而实现了无放回抽样。

四、放回抽样

放回抽样是指在抽样过程中，每个样本被抽取后会被重新放回总体中，因此同一个样本有可能被多次抽取。

4.1 实现方法

使用 Numpy 库的 random.randint 函数生成随机索引列表，该列表允许存在重复值。示例代码如下：

python 复制代码 
import pandas as pd
import numpy as np

# 创建示例 DataFrame
data = {'col1': [10, 20, 30, 40, 50],
        'col2': ['a', 'b', 'c', 'd', 'e']}
df = pd.DataFrame(data)

# 生成随机索引列表（放回抽样）
index_list = np.random.randint(0, len(df), size=len(df))
# 使用 take 方法进行放回抽样
sampled_df = df.take(index_list)
print(sampled_df)

在上述代码中，np.random.randint(0, len(df), size=len(df)) 生成了一个长度为 len(df) 的随机整数列表，这些整数的取值范围在 0 到 len(df) - 1 之间，由于使用了 randint 函数，列表中可能会存在重复值，从而实现了放回抽样。

五、总结

通过使用 df.take 方法结合 Numpy 的随机函数，我们可以方便地在 Pandas 的 DataFrame 上进行无放回抽样和放回抽样操作。无放回抽样适用于需要确保每个样本只被抽取一次的场景，而放回抽样则适用于允许样本重复抽取的情况。根据具体的数据分析需求，选择合适的抽样方法可以有效地对大规模数据进行子集选取，提高数据处理和分析的效率。

相关推荐
火星数据-Tina4 小时前
体育赛事大数据分析：AI模型对足球大小球预测的精度优化
人工智能·机器学习·数据分析
十三画者6 小时前
【工具】IntelliGenes使用多基因组图谱进行生物标志物发现和预测分析的新型机器学习管道
人工智能·python·机器学习·数据挖掘·数据分析
赵钰老师8 小时前
【水文模型】地理信息系统（ArcGIS）在水文水资源、水环境中的应用
arcgis·数据分析
shboka92070210 小时前
如何通过数据分析提升美容院顾客复购率
大数据·数据挖掘·数据分析
十三画者13 小时前
【工具】survex一个解释机器学习生存模型的R包
人工智能·机器学习·数据挖掘·数据分析·r语言·数据可视化
SelectDB技术团队1 天前
SelectDB 实时分析性能突出，宝舵成本锐减与性能显著提升的双赢之旅
大数据·人工智能·物联网·数据分析·doris·selectdb·电商场景
潘达斯奈基~1 天前
万字总结数据分析思维
数据库·python·数据分析
Seon塞翁1 天前
关于AI数据分析可行性的初步评估
大数据·人工智能·数据分析
cheese-liang1 天前
Excel之实践出真知——数据分析
数据挖掘·数据分析·excel
热门推荐
01从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek各版本说明与优缺点分析04KGG转MP3工具|非KGM文件|解密音频05DeepSeek RAGFlow构建本地知识库系统06本地部署DeepSeek教程（Mac版本）07如何本地部署AI智能体平台，带你手搓一个AI Agent08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具10Windows 11 安装 Dify 完整指南 非docker环境