Pandas学习笔记（下）

二、函数

1、常用的统计学函数

函数名称	描述说明
count()	统计某个非空值的数量
sum()Pandas学习笔记（下）	求和
mean()	求均值
median()	求中位数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积

案例：

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 30, 40, 50],
    'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)

# 计算每列的均值
mean_values = df.mean()
print(mean_values)

# 计算每列的中位数
median_values = df.median()
print(median_values)

#计算每列的方差
var_values = df.var()
print(var_values)

# 计算每列的标准差
std_values = df.std()
print(std_values)

# 计算每列的最小值
min_values = df.min()
print("最小值:")
print(min_values)

# 计算每列的最大值
max_values = df.max()
print("最大值:")
print(max_values)

# 计算每列的总和
sum_values = df.sum()
print(sum_values)

# 计算每列的非空值数量
count_values = df.count()
print(count_values)

注意：numpy的方差默认为总体方差，pandas默认为样本方差

 分母为n-1的样本方差的期望等于总体的方差，因此样本方差是总体方差的无偏估计。

2、重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

2.1 reindex

reindex() 方法用于重新索引 DataFrame 或 Series 对象。重新索引意味着根据新的索引标签重新排列数据，并填充缺失值。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

语法：

DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)

参数：

参数名	类型	默认值	描述
​​labels​​	数组或列表	None	新的索引标签
​​index​​	数组或列表	None	新的行索引标签
​​columns​​	数组或列表	None	新的列索引标签
​​axis​​	整数或字符串	None	指定重新索引的轴。0 或 'index' 表示行，1 或 'columns' 表示列
​​method​​	字符串	None	用于填充缺失值的方法。可选值包括 'ffill'（前向填充）、'bfill'（后向填充）等
​​copy​​	布尔值	True	是否返回新的 DataFrame 或 Series
​​level​​	整数或级别名称	None	用于多级索引（MultiIndex），指定要重新索引的级别
​​fill_value​​	标量	np.nan	用于填充缺失值的值
​​limit​​	整数	None	指定连续填充的最大数量
​​tolerance​​	标量或字典	None	指定重新索引时的容差

案例：

# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
​
# 重新索引行
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index)
print(df_reindexed)
​
# 重新索引列
new_columns = ['A', 'B', 'C', 'D']
df_reindexed = df.reindex(columns=new_columns)
print(df_reindexed)
​
# 重新索引行，并使用前向填充
# 新的行索引 ['a', 'b', 'c', 'd'] 包含了原索引中不存在的标签 'd'，使用 method='ffill' 进行前向填充，因此 'd' 对应的行填充了前一行的值。
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index, method='ffill')
print(df_reindexed)
​
# 重新索引行，并使用指定的值填充缺失值
new_index = ['a', 'b', 'c', 'd']
df_reindexed = df.reindex(new_index, fill_value=0)
print(df_reindexed)

2.2 reindex_like

reindex_like 方法用于将一个 DataFrame 或 Series 的索引重新排列，使其与另一个 DataFrame 或 Series 的索引相匹配。如果在重新索引的过程中，新的索引与原始索引不完全匹配，那么不匹配的位置将会被填充为 NaN 值。

语法：

DataFrame.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)

参数：

参数名	类型	默认值	描述
​​labels​​	数组或列表	None	新的索引标签
​​index​​	数组或列表	None	新的行索引标签
​​columns​​	数组或列表	None	新的列索引标签
​​axis​​	整数或字符串	None	指定重新索引的轴。0 或 'index' 表示行，1 或 'columns' 表示列
​​method​​	字符串	None	用于填充缺失值的方法。可选值包括 'ffill'（前向填充）、'bfill'（后向填充）等
​​copy​​	布尔值	True	是否返回新的 DataFrame 或 Series
​​level​​	整数或级别名称	None	用于多级索引（MultiIndex），指定要重新索引的级别
​​fill_value​​	标量	np.nan	用于填充缺失值的值
​​limit​​	整数	None	指定连续填充的最大数量
​​tolerance​​	标量或字典	None	指定重新索引时的容差
​​other​​	DataFrame 或 Series	None	用于对齐索引和列的参考对象

案例1：对齐行索引

import pandas as pd
​
# 创建两个示例 DataFrame
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])
​
df2 = pd.DataFrame({
    'A': [7, 8, 9],
    'B': [10, 11, 12]
}, index=['b', 'c', 'd'])
​
# 使用 reindex_like 对齐 df1 的行索引到 df2
# df1 的行索引被重新索引为 df2 的行索引，因此 df1 中不存在的行索引 'd' 对应的行填充了 NaN。
df1_reindexed = df1.reindex_like(df2)
print(df1_reindexed)
​
# 输出：
     A    B
b  2.0  5.0
c  3.0  6.0
d  NaN  NaN
案例2：对齐列索引

# 创建两个示例 DataFrame
df1 = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}, index=['a', 'b', 'c'])
​
df2 = pd.DataFrame({
    'B': [7, 8, 9],
    'C': [10, 11, 12]
}, index=['a', 'b', 'c'])
​
# 使用 reindex_like 对齐 df1 的列索引到 df2
df1_reindexed = df1.reindex_like(df2)
​
print(df1_reindexed)
​
#输出
   B   C
a  4 NaN
b  5 NaN
c  6 NaN

3、遍历

对于 Series 而言，您可以把它当做一维数组进行遍历操作；而像 DataFrame 这种二维数据表结构，则类似于遍历 Python 字典

Series 可直接获取相应的 value，而 DataFrame 则会获取列标签

案例：

import pandas as pd
​
series_data = pd.Series(['a','b','c','d','e','f',None])
​
print('Series：')
for item in series_data:
    print(item, end=' ')
    
#输出：
a b c d e f None 

3.1 Series遍历

使用 items()

import pandas as pd
​
# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
for index, value in series.items():
    print(f"Index: {index}, Value: {value}")
    
#输出：
Index: a, Value: 1
Index: b, Value: 2
Index: c, Value: 3

使用 index 属性

import pandas as pd
​
# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
​
# 遍历索引
for index in series.index:
    print(f"Index: {index}, Value: {series[index]}")
    
#输出：
Index: a, Value: 1
Index: b, Value: 2
Index: c, Value: 3

使用 values 属性

import pandas as pd
​
# 创建一个示例 Series
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
​
# 遍历值
for value in series.values:
    print(f"Value: {value}")
    
# 输出：
Value: 1
Value: 2
Value: 3

3.2 DataFrame 遍历

dataFrame_data = pd.DataFrame({
    'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
    'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
})
# 遍历dataframe得到的是列标签
print('DataFrame：')
for item in dataFrame_data:
    print(item, end=' ')
​
#输出：
one two 

迭代器返回的是原数据的副本

遍历行

iterrows() 方法用于遍历 DataFrame 的行，返回一个包含索引和行的迭代器。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
​
# 使用 iterrows() 遍历行
for index, row in df.iterrows():
    print(f"Index: {index}, Row: {row}")
    
# 输出：
Index: a, Row: A    1
B    4
C    7
Name: a, dtype: int64
Index: b, Row: A    2
B    5
C    8
Name: b, dtype: int64
Index: c, Row: A    3
B    6
C    9
Name: c, dtype: int64

itertuples() 方法用于遍历 DataFrame 的行，返回一个包含行数据的命名元组。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
​
# 使用 itertuples() 遍历行
for row in df.itertuples():
    print(row)
    for i in row:
        print(i)
#输出：
Pandas(Index='a', A=1, B=4, C=7)
a
1
4
7
Pandas(Index='b', A=2, B=5, C=8)
b
2
5
8
Pandas(Index='c', A=3, B=6, C=9)
c
3
6
9
# 忽略索引
for row in df.itertuples(index=False):
    print(row)
    for i in row:
        print(i)

当处理大型数据集时，应尽量避免使用 iterrows()，因为它的性能相对较差。

itertuples() 是遍历 DataFrame 的推荐方法，因为它在速度和内存使用上都更高效。

遍历列

items() 方法用于遍历 DataFrame 的列，返回一个包含列名和列数据的迭代器。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
​
# 使用 items() 遍历列
for column_name, column_data in df.items():
    print(f"Column Name: {column_name}, Column Data: {column_data}")
#输出：
Column Name: A, Column Data: a    1
b    2
c    3
Name: A, dtype: int64
Column Name: B, Column Data: a    4
b    5
c    6
Name: B, dtype: int64
Column Name: C, Column Data: a    7
b    8
c    9
Name: C, dtype: int64

使用属性遍历

loc 和 iloc 方法可以用于按索引或位置遍历 DataFrame 的行和列。

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
​
# 使用 loc 遍历行和列
for index in df.index:
    for column in df.columns:
        print(f"Index: {index}, Column: {column}, Value: {df.loc[index, column]}")
        
        
# 输出：
Index: a, Column: A, Value: 1
Index: a, Column: B, Value: 4
Index: a, Column: C, Value: 7
Index: b, Column: A, Value: 2
Index: b, Column: B, Value: 5
Index: b, Column: C, Value: 8
Index: c, Column: A, Value: 3
Index: c, Column: B, Value: 6
Index: c, Column: C, Value: 9

4、排序

4.1 sort_index

sort_index 方法用于对 DataFrame 或 Series 的索引进行排序。

语法：

DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)

参数：

• axis：指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。

• ascending：布尔值，指定是升序排序（True）还是降序排序（False）。

• inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])
​
# 按行索引标签排序，不对对应的值排序
df_sorted = df.sort_index()
#输出：
   A  B  C
a  3  6  9
b  1  4  7
c  2  5  8
​
#按列索引标签降序排序
df_sorted = df.sort_index(axis=1,ascending=False)
print(df_sorted)
# 输出：
   C  B  A
b  7  4  1
c  8  5  2
a  9  6  3

4.2 sort_values

sort_values 方法用于根据一个或多个列的值对 DataFrame 进行排序。

语法：

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')

参数：

参数	类型	默认值	描述	示例值
​​by​​	str/list	必填	排序依据的列名或列名列表	'salary'
​​axis​​	int	0	排序轴：0=行排序，1=列排序	1
​​ascending​​	bool/list	True	排序方向：True=升序，False=降序	[True, False]
​​inplace​​	bool	False	是否原地修改（不返回新对象）	True
​​kind​​	str	'quicksort'	排序算法：'quicksort', 'mergesort', 'heapsort'	'mergesort'
​​na_position​​	str	'last'	缺失值位置：'first'或'last'	'first'

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [3, 2, 1],
    'B': [6, 5, 4],
    'C': [9, 8, 7]
}
df = pd.DataFrame(data, index=['b', 'c', 'a'])
​
# 按列 'A' 排序
df_sorted = df.sort_values(by='A')
print(df_sorted)
​
# 按列 'A' 和 'B' 排序
df_sorted = df.sort_values(by=['A', 'B'])
print(df_sorted)
​
# 按列 'A' 降序排序
df_sorted = df.sort_values(by='A', ascending=False)
print(df_sorted)
​
# 按列 'A' 和 'B' 排序，先按A列降序排序，如果A列中值相同则按B列升序排序
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, 25, 35, 30],
    'Score': [85, 90, 80, 95, 88]
})
df_sorted = df.sort_values(by=['Age', 'Score'], ascending=[False, True])
print(df_sorted)

5、去重

drop_duplicates 方法用于删除 DataFrame 或 Series 中的重复行或元素。

语法：

drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)

参数：

• by：用于标识重复项的列名或列名列表。如果未指定，则使用所有列。

• subset：与 by 类似，但用于指定列的子集。

• keep：指定如何处理重复项。可以是：

  • 'first'：保留第一个出现的重复项（默认值）。

  • 'last'：保留最后一个出现的重复项。

  • False：删除所有重复项。

• inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 2, 3],
    'B': [4, 5, 5, 6],
    'C': [7, 8, 8, 9]
}
df = pd.DataFrame(data)
​
# 删除所有列的重复行，默认保留第一个出现的重复项
df_unique = df.drop_duplicates()
print(df_unique)
​
# 删除重复行，保留最后一个出现的重复项
df_unique = df.drop_duplicates(keep='last')
print(df_unique)

6、分组

6.1 groupby

groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。

语法：

DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

参数：

参数	类型	默认值	描述	示例值
​​by​​	str/list/Series	必填	分组依据的列或规则	'department'
​​axis​​	int	0	分组轴：0=行，1=列	1
​​level​​	int/str	None	MultiIndex 的分组级别	1 或 'date'
​​as_index​​	bool	True	分组列是否作为索引	False
​​sort​​	bool	True	是否对分组键排序	False
​​group_keys​​	bool	True	是否显示分组键	False
​​squeeze​​	bool	False	是否压缩单组结果	True
​​observed​​	bool	False	是否只使用存在的分类	True

# 创建一个示例 DataFrame
    data = {
        'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [10, 20, 30, 40, 50, 60, 70, 80]
    }
    df = pd.DataFrame(data)
​
    # 按列 'A' 分组
    grouped = df.groupby('A')
​
    # 查看分组结果
    for name, group in grouped:
        print(f"Group: {name}")
        print(group)
        print()
​
    mean = df.groupby(['A']).mean()
    print(mean)
    #输出：
           C     D
    A             
    bar  4.0  40.0
    foo  4.8  48.0
    
    mean = grouped['C'].mean()
    print(mean)
    #输出：
    A
    bar    4.0
    foo    4.8
    
    
    
    # 在分组内根据C列求平均值
    # transform用于在分组操作中对每个组内的数据进行转换，并将结果合并回原始 DataFrame。
    mean = grouped['C'].transform(lambda x: x.mean())
    df['C_mean'] = mean
    print(df)
    #输出：
         A      B  C   D  C_mean
    0  foo    one  1  10     4.8
    1  bar    one  2  20     4.0
    2  foo    two  3  30     4.8
    3  bar  three  4  40     4.0
    4  foo    two  5  50     4.8
    5  bar    two  6  60     4.0
    6  foo    one  7  70     4.8
    7  foo  three  8  80     4.8
​
​
    # 在分组内根据C列求标准差
    std = grouped['C'].transform(np.std)
    df['C_std'] = std
    print(df)
​
    # 在分组内根据C列进行正太分布标准化
    norm = grouped['C'].transform(lambda x: (x - x.mean()) / x.std())
    df['C_normal'] = norm
    print(df)

6.2 filter

通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集

import pandas as pd
​
# 创建一个示例 DataFrame
    data = {
        'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [10, 20, 30, 40, 50, 60, 70, 80]
    }
    df = pd.DataFrame(data)
​
# 按列 'A' 分组，并过滤掉列 'C' 的平均值小于 4 的组
filtered = df.groupby('A').filter(lambda x: x['C'].mean() >= 4)
​
print(filtered)

7、合并

merge 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。这个方法非常适合用来基于某些共同字段将不同数据源的数据组合在一起，最后拼接成一个新的 DataFrame 数据表。

函数：

pandas.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)

参数：

参数	类型	默认值	描述	示例值
​​left​​	DataFrame	必填	左侧 DataFrame	df1
​​right​​	DataFrame	必填	右侧 DataFrame	df2
​​how​​	str	'inner'	合并方式：'inner', 'outer', 'left', 'right'	'left'
​​on​​	str/list	None	连接列名（两表共有）	'key'
​​left_on​​	str/list	None	左表连接列	['id', 'date']
​​right_on​​	str/list	None	右表连接列	['ID', 'DATE']
​​left_index​​	bool	False	是否使用左表索引	True
​​right_index​​	bool	False	是否使用右表索引	True
​​sort​​	bool	False	是否排序结果	True
​​suffixes​​	tuple	('_x', '_y')	列名冲突时的后缀	('_left', '_right')
​​copy​​	bool	True	是否创建新对象	False
​​indicator​​	bool/str	False	是否添加合并标记列	'_merge'
​​validate​​	str	None	验证合并类型	'one_to_one'

案例1：内连接

import pandas as pd
​
# 创建两个示例 DataFrame
left = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K3'],
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3']
})
​
right = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K4'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
})
​
# 内连接
result = pd.merge(left, right, on='key')
​
print(result)
​
#输出：K3、K4被忽略
  key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1
2  K2  A2  B2  C2  D2

案例2：左连接

import pandas as pd
​
# 创建两个示例 DataFrame
left = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K3'],
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3']
})
​
right = pd.DataFrame({
    'key': ['K0', 'K1', 'K2', 'K4'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
})
​
# 左连接，以左侧表为准
result = pd.merge(left, right, on='key', how='left')
​
print(result)
# 输出：
  key   A   B    C    D
0  K0  A0  B0   C0   D0
1  K1  A1  B1   C1   D1
2  K2  A2  B2   C2   D2
3  K3  A3  B3  NaN  NaN

8、时间

8.1 datetime

datetime 模块提供了用于处理日期和时间的类。

from datetime import datetime
​
dt = datetime(2024, 5, 19, 16, 45, 30)
print(dt)
print(dt.date())  # 输出: 2024-05-19
print(dt.time())  # 输出: 16:45:00

8.2 Timestamp

Timestamp 是一个特殊的 datetime 类型，用于表示单个时间点。它是 pandas 时间序列功能的核心组件，提供了丰富的方法和属性来处理日期和时间数据。

import pandas as pd
​
# 从日期字符串创建
ts = pd.Timestamp('2024-05-19 16:45:00')
print(ts)
​
# 从时间戳创建
ts = pd.Timestamp(1735372044000, unit='ms', tz='Asia/Shanghai')
print(ts)

8.3 日期解析

pd.to_datetime() 方法用于将字符串或其他格式的日期转换为 Pandas 的 Datetime 对象。

案例：

import pandas as pd
​
# 将字符串转换为 Datetime 对象
date_str = '2023-10-01'
date_obj = pd.to_datetime(date_str)
print(date_obj)
​
# 获取当前时间
print('当前时间：')
print(datetime.now())

8.4 date_range

date_range() 函数用于生成一个固定频率的日期时间索引（DatetimeIndex）。这个函数非常灵活，可以用于生成各种时间序列数据。

语法：

pandas.date_range(start=None, end=None, periods=None, freq=None, tz=None, normalize=False, name=None, closed=None, **kwargs)

参数：

参数名	类型	默认值	描述	示例
​​start​​	字符串/日期时间	None	起始时间	'2023-01-01'
​​end​​	字符串/日期时间	None	结束时间	'2023-12-31'
​​periods​​	整数	None	生成的时间点数量	365
​​freq​​	字符串/DateOffset	None	时间间隔频率	'D'（天）
​​tz​​	字符串/时区对象	None	时区设置	'Asia/Shanghai'
​​normalize​​	布尔值	False	时间归一化到午夜	True
​​name​​	字符串	None	索引名称	'date'
​​closed​​	字符串	None	区间闭合方式	'left'

案例：

import pandas as pd
​
# 生成从 2023-01-01 到 2023-01-10 的每日日期时间索引
date_index = pd.date_range(start='2023-01-01', end='2023-01-10', freq='D')
print(date_index)
​
# 生成从 2023-01-01 00:00:00 到 2023-01-01 23:00:00 的每小时日期时间索引
date_index = pd.date_range(start='2023-01-01', periods=24, freq='H')
print(date_index)

8.5 时间差

Timedelta 是一个用于表示时间间隔的对象。它可以表示两个时间点之间的差异，或者表示某个时间段的长度。Timedelta 对象可以用于时间序列分析、日期运算等场景。

创建 Timedelta

1.使用字符串表示

import pandas as pd
​
td1 = pd.Timedelta('1 days 2 hours 30 minutes')
print(td1)  # 输出: 1 days 02:30:00

2.使用参数

td2 = pd.Timedelta(days=1, hours=2, minutes=30)
print(td2)  # 输出: 1 days 02:30:00

3.使用整数和单位

td3 = pd.Timedelta(5, unit='days')  # 5天
print(td3)  # 输出: 5 days 00:00:00

4.时间差加减

import pandas as pd
​
td1 = pd.Timedelta('1 days 2 hours 30 minutes')
print(td1)  # 输出: 1 days 02:30:00
​
ts = pd.Timestamp('2024-01-01')
new_ts = ts + td1
print(new_ts)  # 输出: 2024-01-02 02:30:00

8.6 时间日期格式化

strftime 用于将日期时间对象转换为指定格式的字符串，而 strptime 用于将字符串解析为日期时间对象。

from datetime import datetime
​
# 创建一个日期时间对象
date_obj = datetime(2023, 10, 1, 14, 30, 45)
​
# 将日期时间对象转换为字符串
date_str = date_obj.strftime("%Y-%m-%d %H:%M:%S")
​
print(f"Formatted date string: {date_str}")
​
# 将字符串解析为日期时间对象
parsed_date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
​
print(f"Parsed datetime object: {parsed_date_obj}")

时间日期符号： 符号 说明 %y 两位数的年份表示（00-99） %Y 四位数的年份表示（0000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59） %a 本地英文缩写星期名称 %A 本地英文完整星期名称 %b 本地缩写英文的月份名称 %B 本地完整英文的月份名称 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %U 一年中的星期数（00-53）星期天为星期的开始 %j 年内的一天（001-366） %c 本地相应的日期表示和时间表示

9、随机抽样

语法：

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

参数：

• n：要抽取的行数

• frac：抽取的比例，比如 frac=0.5，代表抽取总体数据的50%

• replace：布尔值参数，表示是否以有放回抽样的方式进行选择，默认为 False，取出数据后不再放回

• weights：可选参数，代表每个样本的权重值，参数值是字符串或者数组

• random_state：可选参数，控制随机状态，默认为 None，表示随机数据不会重复；若为 1 表示会取得重复数据

• axis：表示在哪个方向上抽取数据(axis=1 表示列/axis=0 表示行)

案例：

import pandas as pd  
​
def sample_test():
    df = pd.DataFrame({
        "company": ['百度', '阿里', '腾讯'],
        "salary": [43000, 24000, 40000],
        "age": [25, 35, 49]
    })
    print('随机选择两行：')
    print(df.sample(n=2, axis=0))
    print('随机选择一列：')
    print(df.sample(n=1, axis=1))
    print('总体的50%：')
    print(df.sample(axis=0, frac=0.5))

10、空值处理

10.1 检测空值

isnull()用于检测 DataFrame 或 Series 中的空值，返回一个布尔值的 DataFrame 或 Series。

notnull()用于检测 DataFrame 或 Series 中的非空值，返回一个布尔值的 DataFrame 或 Series。

案例：

import pandas as pd
import numpy as np
​
# 创建一个包含空值的示例 DataFrame
data = {
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
​
# 检测空值
is_null = df.isnull()
print(is_null)
​
# 检测非空值
not_null = df.notnull()
print(not_null)

10.2 填充空值

fillna() 方法用于填充 DataFrame 或 Series 中的空值。

案例：

# 创建一个包含空值的示例 DataFrame
data = {
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
​
# 用 0 填充空值
df_filled = df.fillna(0)
​
print(df_filled)

10.3 删除空值

dropna() 方法用于删除 DataFrame 或 Series 中的空值。

案例：

# 创建一个包含空值的示例 DataFrame
data = {
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
​
# 删除包含空值的行
df_dropped = df.dropna()
print(df_dropped)
#输出：
     A    B   C
0  1.0  5.0   9
3  4.0  8.0  12
​
# 删除包含空值的列
df_dropped = df.dropna(axis=1)
print(df_dropped)
#输出：
    C
0   9
1  10
2  11
3  12

三、读取CSV文件

CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）；

CSV 是一种通用的、相对简单的文件格式，被用户、商业和科学广泛应用。

1、to_csv()

to_csv() 方法将 DataFrame 存储为 csv 文件

案例：

import pandas as pd
​
# 创建一个简单的 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
​
# 将 DataFrame 导出为 CSV 文件
df.to_csv('output.csv', index=False)

2、read_csv()

read_csv() 表示从 CSV 文件中读取数据，并创建 DataFrame 对象。

案例：

import pandas as pd
​
df = pd.read_csv('output.csv')
print(df)

四、读取Excel文件

Excel操作需要安装第三方库

pip install openpyxl

1、read_excel()

read_excel() 读取 Excel 表格中的数据。

语法：

pd.read_excel(io, sheet_name=0, header=0, names=None, index_col=None,
              usecols=None, squeeze=False,dtype=None, engine=None,
              converters=None, true_values=None, false_values=None,
              skiprows=None, nrows=None, na_values=None, parse_dates=False,
              date_parser=None, thousands=None, comment=None, skipfooter=0,
              convert_float=True, **kwds)

参数说明：

参数名称	说明
io	表示 Excel 文件的存储路径。
sheet_name	要读取的工作表名称。
header	指定作为列名的行，默认0，即取第一行的值为列名；若数据不包含列名，则设定 header = None。若将其设置 为 header=2，则表示将前两行作为多重索引。
names	一般适用于Excel缺少列名，或者需要重新定义列名的情况；names的长度必须等于Excel表格列的长度，否则会报错。
index_col	用做行索引的列，可以是工作表的列名称，如 index_col = '列名'，也可以是整数或者列表。
usecols	int或list类型，默认为None，表示需要读取所有列。
squeeze	boolean，默认为False，如果解析的数据只包含一列，则返回一个Series。
converters	规定每一列的数据类型。
skiprows	接受一个列表，表示跳过指定行数的数据，从头部第一行开始。
nrows	需要读取的行数。
skipfooter	接受一个列表，省略指定行数的数据，从尾部最后一行开始。

案例：

import pandas as pd
​
# 读取 Excel 文件
df = pd.read_excel('data.xlsx')
print(df)
​
# 读取特定工作表
df = pd.read_excel('data.xlsx', sheet_name='Sheet1')
print(df)

2、to_excel()

to_excel() 函数可以将 DataFrame 中的数据写入到 Excel 文件。如果想要把单个对象写入 Excel 文件，那么必须指定目标文件名；如果想要写入到多张工作表中，则需要创建一个带有目标文件名的 ExcelWriter 对象，并通过 sheet_name 参数依次指定工作表的名称。

语法：

DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None) 

参数说明：

参数名称	描述说明
excel_wirter	文件路径或者 ExcelWrite 对象。
sheet_name	指定要写入数据的工作表名称。
na_rep	缺失值的表示形式。
float_format	它是一个可选参数，用于格式化浮点数字符串。
columns	指要写入的列。
header	写出每一列的名称，如果给出的是字符串列表，则表示列的别名。
index	表示要写入的索引。
index_label	引用索引列的列标签。如果未指定，并且 hearder 和 index 均为为 True，则使用索引名称。如果 DataFrame 使用 MultiIndex，则需要给出一个序列。
startrow	初始写入的行位置，默认值0。表示引用左上角的行单元格来储存 DataFrame。
startcol	初始写入的列位置，默认值0。表示引用左上角的列单元格来储存 DataFrame。
engine	它是一个可选参数，用于指定要使用的引擎，可以是 openpyxl 或 xlsxwriter。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data)
​
# 保存 DataFrame 为 Excel 文件
df.to_excel('data.xlsx')
​
# 保存 DataFrame 为 Excel 文件，不保存索引
df.to_excel('data.xlsx', index=False)

五、绘图

Pandas 在数据分析、数据可视化方面有着较为广泛的应用，Pandas 对 Matplotlib 绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作；

Pandas 之所以能够实现了数据可视化，主要利用了 Matplotlib 库的 plot() 方法，它对 plot() 方法做了简单的封装，因此您可以直接调用该接口；

只用 pandas 绘制图片可能可以编译，但是不会显示图片，需要使用 matplotlib 库，调用 show() 方法显示图形。

import pandas as pd
import matplotlib.pyplot as plt
​
# 创建一个示例 DataFrame
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 25, 30, 40]
}
df = pd.DataFrame(data)
​
# 绘制折线图
df.plot(kind='line')
# 显示图表
plt.show()
​
# 绘制柱状图
df.plot(kind='bar')
# 显示图表
plt.show()
​
​
# 绘制直方图
df['A'].plot(kind='hist')
# 显示图表
plt.show()
​
# 绘制散点图
df.plot(kind='scatter', x='A', y='B')
# 显示图表
plt.show()
饼图

# 创建一个示例 Series
data = {
    'A': 10,
    'B': 20,
    'C': 30,
    'D': 40
}
series = pd.Series(data)
# 绘制饼图
series.plot(kind='pie', autopct='%1.1f%%')
# 显示图表
plt.show()