Python系列 之 Pandas库
Python Pandas库学习
- Pandas库
-
- Pandas数据结构
-
- Series
-
- 创建Series对象
- Series索引和切片 选择数据
- Series name属性和rename方法
- DataFrame
-
- 创建DataFrame对象
- 提取 添加 删除列
- 索引/选择
- 赋值
- 合并 连接 追加
-
- concat函数
- merge函数
- append函数
- 分组 Grouping
- 数据透视表
-
- Pivot函数
- Pivot_table函数
- 可视化
- 缺失值操作
-
- 删除缺失值
- 填充缺失值
- 提取缺失值的布尔掩码
- 调用统计函数
- Apply函数
- 其他操作
-
- 文件读写
- Head与Tail
- 数据总结 describe
- idxmax()和idxmin()函数
- .array和to_numpy()方法
- value_counts()方法
- 字符串方法
Pandas库
Pandas库是Python的核心数据分析支持库，提供了快速 灵活 明确的数据结构；
pandas主要数据结构：
Series：带标签的一维同构数组
DataFrame：带标签的 大小可变的 二维异构表格
Pandas 所有数据结构的值都是可变的，但是数据结构大小并非都是可变的；比如 Series 的长度是不可改变的，但是DataFrame的结构和值都可以改变
Pandas数据结构
Series
Series数据结构 带标签的一维同构数组；可存储整数，浮点数，字符串，Python对象等类型的数据。
创建Series对象
调用 pd.Series 函数 创建 Series：
import pandas as pd
import numpy as
# pd.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
# data : Series存储的数据 支持：Python字典，多维数组，标量值
# index： Series的标签
# dtype : 数据类型
s = pd.Series(data=np.arange(10, 50, 5))
数组构建Series的data：
如果指定index index长度需要和data一致
如果没有指定index 则会自动填充 index = range(0,len(data))
s = pd.Series(data=np.arange(10, 50, 5))
print("数组构建Series的data：\n", s)
# 输出：0,1,2,3是index
# 数组构建Series的data：
# 0 10
# 1 20
# 2 30
# 3 40
# dtype: int32
Python 字典构建Series的data：
如果未指定index 则取字典的key作为index
s = pd.Series(data={'a': '1', 'c': '2', 'B': '3',
'd': '4', 'e': '5'}, dtype=np.float64)
print("Python字典构建Series的data:\n", s)
# 输出：
# Python字典构建Series的data:
# a 1.0
# c 2.0
# B 3.0
# d 4.0
# e 5.0
# dtype: float64
标量值 构建Series的data：
必须提供index；根据index的长度重复标量值：
s = pd.Series(data=10, index=['a', 'b', 'c'])
print("标量值构建Series的data:\n", s)
# 输出：
# 标量值构建Series的data:
# a 10
# b 10
# c 10
# dtype: int64
Series索引和切片 选择数据
Series选择数据可以用索引和切片进行操作：
s = pd.Series(data=np.arange(10, 20, 2), index=['a', 'b', 'c', 'd', 'e'])
print(s)
# 输出：
# a 10
# b 12
# c 14
# d 16
# e 18
# dtype: int32
下标索引选择数据：
# 下标索引
print("下标索引访问Series数据:\n",s[4])
# 输出：
# 下标索引访问Series数据:
# 18
标签(index)访问Series数据：
# Series 的标签 如果标签不存在 会报KeyError
print("标签(index)访问Series数据:\n",s['a'])
# 输出：
# 标签(index)访问Series数据:
# 10
Series.get方法访问Series数据：
# Series.get(index,default) 如果标签index不存在 返回default
print("Series.get方法：\n", s.get('a', np.nan))
# 输出
# Series.get方法：
# 10
切片：下标索引 切片
# 下标索引 切片
print("下标索引切片访问Series数据:\n",s[0:4])
# 输出
# 下标索引切片访问Series数据:
# a 10
# b 12
# c 14
# d 16
# dtype: int32
切片：Series的标签 切片
# Series的标签 切片
print("标签(index)切片访问Series数据:\n",s['a':'b'])
# 输出
# 标签(index)切片访问Series数据:
# a 10
# b 12
# dtype: int32
Series name属性和rename方法
name属性：
s = pd.Series(np.nan, name='name_s')
print('Series的name属性:\n', s.name)
# 输出
# Series的name属性:
# name_s
rename方法：
# 更改s的name=re_name_s inplace=True 表示不创建新的对象,直接对原始对象进行修改
s.rename('re_name_s', inplace=True)
print('Series的rename方法:\n', s.name)
# 输出
# Series的rename方法:
# re_name_s
DataFrame
DataFrame 是由多种类型的列购成的二维标签数据结构，类似Excel SQL表；
包含 index(行标签)和columns(列标签)；
支持多种类型的数据输入：一维ndarray、 列表 、字典、 Series字典、 二维np.ndarray 结构、多维数组或记录多维数组 、 Series、 DataFrame；
创建DataFrame对象
调用 pd.DataFrame()方法生成DataFrame对象：
pd.DataFrame(data=None, index=[], columns=[], dtype=None, copy=False)
Python 字典生成DataFrame：字典的key会生成DataFrame的columns：
data_dict = {'A': '0', 'B': '1', 'C': '2'}
df = pd.DataFrame(data=data_dict, index=[0], dtype=float)
print("Python字典生成DataFrame:\n", df)
# 输出 A,B,C 是columns(列标签) 0 是index(行标签)
# Python字典生成DataFrame:
# A B C
# 0 0.0 1.0 2.0
Series字典生成DataFrame：
Series字典的key会生成DataFrame的columns，Series的index生成DataFrame的Index
series_dict = {'a': pd.Series(data=np.arange(5)),
'b': pd.Series(data=np.arange(6))}
df = pd.DataFrame(data=series_dict, dtype=float)
print("Series字典生成DataFrame:\n", df)
# 输出a,b是列标签 0-5是行标签
# Series字典生成DataFrame:
# a b
# 0 0.0 0.0
# 1 1.0 1.0
# 2 2.0 2.0
# 3 3.0 3.0
# 4 4.0 4.0
# 5 NaN 5.0
数组字典生成DataFrame：
数组字典中的数组长度必须一致；字典的key会生成DataFrame的columns；如果未指定index index=range(数组的长度)
array_dict = {'a': np.arange(0, 3), 'b': np.arange(
3, 6), 'c': np.arange(6, 9)}
df = pd.DataFrame(data=array_dict)
print("数组字典生成DataFrame:\n", df)
# 输出
# 数组字典生成DataFrame:
# a b c
# 0 0 3 6
# 1 1 4 7
# 2 2 5 8
列表字典生成DataFrame：
未指定columns 由字典key生成
列表中第一个字典是第一行数据，第二个是第二行…
list_dict = [{'a': 0},
{'a': 1, 'b': 2},
{'c': 3}]
df = pd.DataFrame(data=list_dict)
print("列表字典生成DataFrame:\n", df)
# 输出
# 列表字典生成DataFrame:
# a b c
# 0 0.0 NaN NaN
# 1 1.0 2.0 NaN
# 2 NaN NaN 3.0
用Series创建DataFrame：
如果未指定columns Series.name生成columns
s1 = pd.Series(data=[0, 1, 2], name="s1")
df = pd.DataFrame(data=s1)
print("Series创建DataFrame:\n", df)
# 输出
# Series创建DataFrame:
# s1
# 0 0
# 1 1
# 2 2
提取 添加 删除列
DataFrame就像带索引的Series字典，提取 添加 删除列的操作与字典类似
提取列：
data = {'a': [1, 2, 3],
'b': [4, 5, 6],
'c': [7, 8, 9]}
df = pd.DataFrame(data=data, index=['x', 'y', 'z'])
print(df)
# 输出
# a b c
# x 1 4 7
# y 2 5 8
# z 3 6 9
像Python字典一样 提取列：df[‘a’]
print("提取列a；df['a']:\n", df['a'])
# 输出
# 提取列a；df['a']:
# x 1
# y 2
# z 3
# Name: a, dtype: int64
或者：df.a
print("提取列a；df.a:\n", df.a)
# 输出
# 提取列a；df.a:
# x 1
# y 2
# z 3
# Name: a, dtype: int64
添加列：
像Python字典一样 默认在DataFrame尾部添加；
# 添加列 d 值等于 a列的2次方
df['d'] = df['a']**2
print("添加列 d :\n", df)
# 输出
# 添加列 d :
# a b c d
# x 1 4 7 1
# y 2 5 8 4
# z 3 6 9 9
insert 方法：可以指定位置插入列
# df.insert(loc, column, value)
# 在最开始插入一列 e; 值等于a列减1
df.insert(0, "e", df['a'] - 1)
print("insert 方法插入列：\n", df)
# 输出
# insert 方法插入列：
# e a b c d
# x 0 1 4 7 1
# y 1 2 5 8 4
# z 2 3 6 9 9
assign 方法：可以利用现有的列创建新列；还可以传入带参数的函数
assign方法返回的都是数据副本，原来的DataFrame不变
# 添加 new_column_name_1 列 值等于a列*b列
# 添加 new_column_name_2 列 值等a列+b列
df1 = df.assign(new_column_name_1=lambda x: x['a'] * x['b'],
new_column_name_2=df['a'] + df['b'])
print("assign 方法插入列：\n", df1)
# 输出
# assign 方法插入列：
# e a b c d new_column_name_1 new_column_name_2
# x 0 1 4 7 1 4 5
# y 1 2 5 8 4 10 7
# z 2 3 6 9 9 18 9
删除列：
del 和pop方法：
del df['e']
df.pop('d')
索引/选择
索引基础用法：
| 操作 | 语法 | 结果 |
|---|---|---|
| 选择列 | df[col] | 返回Series |
| 用标签选择行 | df.loc[lable] | 返回Series |
| 用整数位置选择行 | df.iloc[loc] | 返回Series |
| 行切片 | df[start:stop] | 返回 DataFrame |
| 用bool向量选择行 | df[bool_vec] | 返回 DataFrame |
示例：
data = {'a': [1, 2, 3],
'b': [4, 5, 6],
'c': [7, 8, 9]}
df = pd.DataFrame(data=data, index=['A', 'B', 'C'])
print(df)
# 输出
# a b c
# A 1 4 7
# B 2 5 8
# C 3 6 9
df.loc[lable] 选择行：
loc_s = df.loc['A']
print("loc_s --> type:\n", type(loc_s))
print("df.loc[lable]方法选择行 行标签=='A'的行数据：\n", loc_s)
# 输出
# loc_s --> type:
# df.loc[lable]方法选择 多列：
# df.loc[:, ['a', 'c']]
# 第一个 : 表示 所有行，['a', 'c'] 表示选择 a列和c列
loc_s_1 = df.loc[:, ['a', 'c']]
print("df.loc[lable]方法选择 多列：\n", loc_s_1)
# 输出
# df.loc[lable]方法选择 多列：
# a c
# A 1 7
# B 2 8
# C 3 9
df.loc[lable]方法选择 值：
# 标签是'A'的行 列名是'a'的列 取值
loc_s_2 = df.loc['A', 'a']
print("df.loc[lable]方法选择 值：\n", loc_s_2)
# 输出
# df.loc[lable]方法选择 值：
# 1
df.iloc[loc] 用整数位置选择行：
iloc_s = df.iloc[1]
print("iloc_s --> type:", type(iloc_s))
print("df.iloc[loc]方法选择行 第2行的数据：\n", iloc_s)
# 输出
# iloc_s --> type: df.iloc[loc]方法选择多列:
# df.iloc[:, 0:2]
# 逗号前 : 表示所有行 逗号后 0:2 表示第1,2列
iloc_s_1 = df.iloc[:, 0:2]
print("df.iloc[loc]方法选择多列:\n", iloc_s_1)
# 输出
# df.iloc[loc]方法选择多列:
# a b
# A 1 4
# B 2 5
# C 3 6
行切片 df[start:stop] 不包含 stop
# 行切片 df[start:stop] 不包含 stop
print("整数切片行：\n", df[0:2])
# 包含C行
print("行标签切片行:\n", df['A':'C'])
# 输出
# 整数切片行：
# a b c
# A 1 4 7
# B 2 5 8
# 行标签切片行:
# a b c
# A 1 4 7
# B 2 5 8
# C 3 6 9
bool索引：
布尔运算返回的DataFrame或者Series的dtype是bool类型的
print("df > 2返回的DataFrame：\n", df > 2)
# 输出
# df > 2返回的DataFrame：
# a b c
# A False True True
# B False True True
# C True True True
用布尔运算的结果作为索引取值
选择整个df中满足条件的值；不满足条件的会用 NaN 填充
print("df > 2作为索引返回:\n", df[df > 2])
# 输出
# df > 2作为索引返回:
# a b c
# A NaN 4 7
# B NaN 5 8
# C 3.0 6 9
用单列的值布尔运算 选择数据：
print("df > 2返回的Series：\n", df['a'] > 2)
print("df['a'] > 2作为索引返回:\n", df[df['a'] > 2])
# 输出：只有C行是True 所以只返回C行数据
# df > 2返回的Series：
# A False
# B False
# C True
# Name: a, dtype: bool
# df['a'] > 2作为索引返回:
# a b c
# C 3 6 9
isin方法筛选：
print("isin方法筛选:\n", df[df['a'].isin([1, 3, 5])])
# 输出 ： 选择a列包含 1 or 3 or 5 的行
# isin方法筛选:
# a b c
# A 1 4 7
# C 3 6 9
赋值
使用Series赋值：
Series的index会自动匹配DataFrame的index
# df数据同上
s = pd.Series(data=[10, 11, 12], index=['A', 'B', 'C'])
# 添加一个新列d，列d index的值等于Series对应的index，
df['d'] = s
print("根据Series的index匹配赋值：\n", df)
# 输出
# 根据Series的index匹配赋值：
# a b c d
# A 1 4 7 10
# B 2 5 8 11
# C 3 6 9 12
按标签赋值：
df.at[] 与loc类似，两者都提供基于标签的查找；如果只需要在数据中获取或设置单个值使用at
# 行标签=='A'的d列赋值为 20
df.at['A', 'd'] = 20
按位置赋值：
df.iat[] 与iloc类似，两者都提供基于整数的查找；如果只需要在数据中获取或设置单个值使用iat
# 第2行 第4列=21 ， 第3行 第四列=22
df.iat[1, 3], df.iat[2, 3] = 21, 22
NumPy数组赋值：
arr = np.array([0, 0, 0])
# d列赋值为 0
# df['d'] = arr
df.loc[:, 'd'] = arr
条件赋值：
# 将df中等于0的值 重新赋值为np.nan
df[df == 0] = np.nan
合并 连接 追加
concat函数
合并数据concat函数用法：
pd.concat(objs, axis=0, join='outer', join_axes=None, keys=None,levels=None, names=None, verify_integrity=False, sort=None, copy=True)
# objs 要合并的对象，可以是DataFrame和Series
# axis=0 默认 0=纵向，1=横向
# join='outer' 默认 outer=并集，inner交集
# ignore_index=False 是否忽略原index
pd.concat函数示例：
df1 = pd.DataFrame(data=np.arange(10).reshape(5, 2),
columns=['a', 'b'])
df2 = pd.DataFrame(data=np.arange(
10, 20).reshape(5, 2), columns=['A', 'B'])
print("df1:\n", df1)
print("df2:\n", df2)
# concat函数 默认 axis=0 进行行合并
print("df1和df2行合并:\n", pd.concat([df1, df2], axis=0, ignore_index=True))
# concat函数 axis=1 进行列合并
print("df1和df2列合并:\n", pd.concat([df1, df2], axis=1))
# 输出
# df1:
# a b
# 0 0 1
# 1 2 3
# 2 4 5
# 3 6 7
# 4 8 9
# df2:
# A B
# 0 10 11
# 1 12 13
# 2 14 15
# 3 16 17
# 4 18 19
# df1和df2行合并:
# a b A B
# 0 0.0 1.0 NaN NaN
# 1 2.0 3.0 NaN NaN
# 2 4.0 5.0 NaN NaN
# 3 6.0 7.0 NaN NaN
# 4 8.0 9.0 NaN NaN
# 5 NaN NaN 10.0 11.0
# 6 NaN NaN 12.0 13.0
# 7 NaN NaN 14.0 15.0
# 8 NaN NaN 16.0 17.0
# 9 NaN NaN 18.0 19.0
# df1和df2列合并:
# a b A B
# 0 0 1 10 11
# 1 2 3 12 13
# 2 4 5 14 15
# 3 6 7 16 17
# 4 8 9 18 19
merge函数
merge函数示例：
# pd.merge(left, right,how="left",on="[col1,col2,...]")
# how:left 左连接 right 右连接,outer 并集,inner 交集
# on=key 要合并的列 也可以是多列连接 默认是left和right相同的列
data_dict1 = [{'id': 1, 'name': 'Jack'},
{'id': 2, 'name': 'Lisa'},
{'id': 3, 'name': 'Jay'}]
df1 = pd.DataFrame(data=data_dict1)
data_dict2 = [{'id': 2, 'age': 18, 'gender': 'F'},
{'id': 3, 'age': 20, 'gender': 'M'},
{'id': 4, 'age': 19, 'gender': 'F'}]
df2 = pd.DataFrame(data=data_dict2)
print("df1:\n", df1)
print("df2:\n", df2)
merge_df = pd.merge(df1, df2, how='left', on='id')
print("根据id列左连接:\n", merge_df)
# 输出
# df1:
# id name
# 0 1 Jack
# 1 2 Lisa
# 2 3 Jay
# df2:
# id age gender
# 0 2 18 F
# 1 3 20 M
# 2 4 19 F
# 根据id列左连接:
# id name age gender
# 0 1 Jack NaN NaN
# 1 2 Lisa 18.0 F
# 2 3 Jay 20.0 M
append函数
append函数示例：
df = pd.DataFrame(data=np.arange(10).reshape((2, 5)))
print("append前：\n", df)
df1 = df.append(df.iloc[1], ignore_index=True)
print("append后：\n", df1)
# 输出
# append前：
# 0 1 2 3 4
# 0 0 1 2 3 4
# 1 5 6 7 8 9
# append后：
# 0 1 2 3 4
# 0 0 1 2 3 4
# 1 5 6 7 8 9
# 2 5 6 7 8 9
分组 Grouping
groupby函数示例：
data = [{'name': 'Jay', 'month': 'Jan', 'salary': 16000},
{'name': 'Jay', 'month': 'Feb', 'salary': 15000},
{'name': 'Jay', 'month': 'Mar', 'salary': 18000},
{'name': 'Mark', 'month': 'Jan', 'salary': 6000},
{'name': 'Mark', 'month': 'Feb', 'salary': 5000},
{'name': 'Mark', 'month': 'Mar', 'salary': 8000}]
df = pd.DataFrame(data=data)
print(df)
# 输出
# name month salary
# 0 Jay Jan 16000
# 1 Jay Feb 15000
# 2 Jay Mar 18000
# 3 Mark Jan 6000
# 4 Mark Feb 5000
# 5 Mark Mar 8000
# groupby函数 根据name分组然后对salary求和
series = df.groupby('name')['salary'].sum()
print(series)
# 输出
# name
# Jay 49000
# Mark 19000
# Name: salary, dtype: int64
# 可以看出df.groupby('name')['salary'].sum()返回的是一个Series类型,Series.name属性等于salary
数据透视表
Pivot函数和Pivot_table函数都可以对数据做透视表功能，区别在于Pivot函数不能对重复元素进行聚合操作
Pivot函数
pd.pivot函数：不能对重复元素进行聚合操作否则会报ValueError：Index contains duplicate entries, cannot reshape
索引包含重复的条目，无法重新设置其形状
示例：
# df数据
# name month salary
# 0 Jay Jan 16000
# 1 Jay Feb 15000
# 2 Jay Mar 18000
# 3 Mark Jan 6000
# 4 Mark Feb 5000
# 5 Mark Mar 8000
#pd.pivot(DataFrame, index=None, columns=None, values=None)
pivot_df = pd.pivot(df, index='month', columns='name', values='salary')
print(pivot_df, '\n', type(pivot_df))
# 输出
# name Jay Mark
# month
# Feb 15000 5000
# Jan 16000 6000
# Mar 18000 8000
# Pivot_table函数
pd.pivot_table函数：
pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean',fill_value=None, margins=False, dropna=True, margins_name='All', observed=False)
参数说明：
| 参数 | 说明 |
|---|---|
| data | DataFrame |
| values | 指定统计的值；可以指定多列 values=[‘D’, ‘E’] |
| index | 指定元素作为行标签；可以指定多列 index=[‘A’, ‘B’] |
| columns | 指定元素作为列标签 |
| aggfunc | 聚合函数，默认mean；也可以对不同的values指定不同的聚合函数；例如：aggfunc={‘values1’: np.mean,‘values2’: [min, max, np.mean]} |
| fill_value | 用于替换缺少值的值 |
示例：
# df数据
# name month salary
# 0 Jay Jan 16000
# 1 Jay Feb 15000
# 2 Jay Mar 18000
# 3 Mark Jan 6000
# 4 Mark Feb 5000
# 5 Mark Mar 8000
pivot_table_df = pd.pivot_table(df, index='month', values='salary', aggfunc=[np.sum, np.mean])
print(pivot_table_df,'\n', type(pivot_table_df))
# 输出 salary的sum值 和 mean值
# month
# Feb 20000 10000
# Jan 22000 11000
# Mar 26000 13000
# 可视化
pd.DataFrame.plot方法
DataFrame.plot(x=None, y=None, kind='line', ax=None, subplots=False,sharex=None, sharey=False, layout=None, figsize=None,use_index=True, title=None, grid=None, legend=True,style=None, logx=False, logy=False, loglog=False,xticks=None, yticks=None, xlim=None, ylim=None, rot=None,fontsize=None, colormap=None, position=0.5, table=False, yerr=None,xerr=None, stacked=True/False, sort_columns=False, secondary_y=False, mark_right=True, **kwds)
示例：
# df数据
# name month salary
# 0 Jay Jan 16000
# 1 Jay Feb 15000
# 2 Jay Mar 18000
# 3 Mark Jan 6000
# 4 Mark Feb 5000
# 5 Mark Mar 8000
import matplotlib.pyplot as plt
# 透视表
#pd.pivot(DataFrame, index=None, columns=None, values=None)
pivot_df = pd.pivot(df, index='month', columns='name', values='salary')
# DataFrame.plot(x=None, y=None, kind='line', ax=None, subplots=False,sharex=None, sharey=False, layout=None, figsize=None,use_index=True, title=None, grid=None, legend=True,style=None, logx=False, logy=False, loglog=False,xticks=None, yticks=None, xlim=None, ylim=None, rot=None,fontsize=None, colormap=None, position=0.5, table=False, yerr=None,xerr=None, stacked=True/False, sort_columns=False, secondary_y=False, mark_right=True, **kwds)
pivot_df.plot()
plt.show()
输出：
缺失值操作
Pandas主要使用NumPy的np.nan表示缺失值，进行计算时默认忽略空值。
删除缺失值
缺失值的删除操作：dropna方法：返回删除后的数据副本，不更改原数据
# dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
# axis: {0 or 'index', 1 or 'columns'}, default 0 0=删除包含缺少值的index 1=删除包含缺少值的column
# how : {'any', 'all'}, default 'any' any=如果存在任何NA值，删除该行或列。 all=如果所有值均为NA，则删除该行或列
# 返回删除后的数据副本，不更改原数据
df = pd.DataFrame(data=np.array([[1, 5, 4, np.nan],
[np.nan, 2, 0, 3]]), index=[
'A', 'B'], columns=['a', 'b', 'c', 'd'])
print("原始数据：\n", df)
# 删除所有存在NaN值的列
df1 = df.dropna(axis='columns', how='any')
print("dropna删除缺失值后的数据:\n", df1)
# 输出
# 原始数据：
# a b c d
# A 1.0 5.0 4.0 NaN
# B NaN 2.0 0.0 3.0
# dropna删除缺失值后的数据:
# b c
# A 5.0 4.0
# B 2.0 0.0
填充缺失值
缺失值填充操作：fillna方法
# df：
# a b c d
# A 1.0 5.0 4.0 NaN
# B NaN 2.0 0.0 3.0
# fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
df2 = df.fillna(value='is_na')
print("fillna方法填充缺失值后的数据：\n", df2)
# 输出
# fillna方法填充缺失值后的数据：
# a b c d
# A 1.0 5.0 4.0 is_na
# B is_na 2.0 0.0 3.0
提取缺失值的布尔掩码
提取缺失值的布尔掩码：isna方法
# df 同上
# pd.isna(df)
print("pd.isna方法提取缺失值的布尔掩码：\n", pd.isna(df))
# 输出
# pd.isna方法提取缺失值的布尔掩码：
# a b c d
# A False False False True
# B True False False False
调用统计函数
一般情况下，运算时排除缺失值
df = pd.DataFrame(data=np.array([[1, 5, 4, np.nan],
[np.nan, 2, 0, 3]]), index=[
'A', 'B'], columns=['a', 'b', 'c', 'd'])
print(df)
# df
# a b c d
# A 1.0 5.0 4.0 NaN
# B NaN 2.0 0.0 3.0
# mean(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
# 获取每列的最小值
print("获取每列的最小值:\n", df.min(axis=0))
# 获取每行的最大值
print("获取每行的最大值:\n", df.max(axis=1))
# 输出 axis=0
# 获取每列的最小值:
# a 1.0
# b 2.0
# c 0.0
# d 3.0
# dtype: float64
# 获取每行的最大值:
# A 5.0
# B 3.0
# dtype: float64
统计函数汇总：
| 函数 | 描述 |
|---|---|
| count | 统计非空值数量 |
| sum | 汇总值 |
| mean | 平均值 |
| mad | 平均绝对差 |
| median | 算数中位数 |
| min | 最小值 |
| max | 最大值 |
| mode | 众数 |
| abs | 绝对值 |
| prod | 乘积 |
| std | 贝塞尔校正的样本标准差 |
| var | 无偏方差 |
| sem | 平均值的标准误差 |
| skew | 样本偏度(第三阶) |
| kurt | 样本峰度(第四阶) |
| quantile | 样本分位数(不同%的值) |
| cumsum | 累加 |
| cumprod | 累乘 |
| cummax | 累积最大值 |
| cummin | 累积最小值 |
Apply函数
利用Apply函数处理数据：
# Apply函数
# df.apply(func, axis=0, raw=False, result_type=None, args=(), **kwds)
# df 数据
# a b c d
# A 1.0 5.0 4.0 NaN
# B NaN 2.0 0.0 3.0
# 每列求和
print("Apply函数")
print("执行求和：按列\n", df.apply(np.sum))
# 每行求和
print("执行求和：按行\n", df.apply(np.sum, axis=1))
# apply函数执行lambda函数 获取df所有元素的平方值
print("执行lambda函数:获取df所有元素的平方值\n", df.apply(lambda x: x**2))
# 输出
# Apply函数
# 执行求和：按列
# a 1.0
# b 7.0
# c 4.0
# d 3.0
# dtype: float64
# 执行求和：按行
# A 10.0
# B 5.0
# dtype: float64
# 执行lambda函数:获取df所有元素的平方值
# a b c d
# A 1.0 25.0 16.0 NaN
# B NaN 4.0 0.0 9.0
其他操作
文件读写
df.to_csv方法：将DataFrame保存到csv文件
data = [{'name': 'Jay', 'month': 'Jan', 'salary': 16000},
{'name': 'Jay', 'month': 'Feb', 'salary': 15000},
{'name': 'Jay', 'month': 'Mar', 'salary': 18000},
{'name': 'Mark', 'month': 'Jan', 'salary': 6000},
{'name': 'Mark', 'month': 'Feb', 'salary': 5000},
{'name': 'Mark', 'month': 'Mar', 'salary': 8000}]
df = pd.DataFrame(data=data)
# 保存到csv文件
df.to_csv('csv_name.csv')
pd.read_csv方法：从csv文件读取数据，返回DataFrame对象
df = pd.read_csv('csv_name.csv')
Head与Tail
Head方法查看数据的头部前N行数据
Tail方法查看数据的尾部后N行数据
df.head(N)
df.tail(N)
数据总结 describe
describe()方法快速查看数据统计的摘要
print(df.describe())
# 输出
# salary
# count 6.000000
# mean 11333.333333
# std 5645.056835
# min 5000.000000
# 25% 6500.000000
# 50% 11500.000000
# 75% 15750.000000
# max 18000.000000
idxmax()和idxmin()函数
Series 和 DataFrame的 idxmax()和idxmin()函数用来计算最大值和最小值对应的索引
print("idxmax()最大值对应的索引:", df['salary'].idxmax())
print("idxmin()最小值对应的索引:", df['salary'].idxmin())
# 输出
# idxmax()最大值对应的索引: 2
# idxmin()最小值对应的索引: 4
.array和to_numpy()方法
s = pd.Series(data=np.arange(10, 20, 2), index=['a', 'b', 'c', 'd', 'e'])
# Series.array 返回 PandasArray 对象
print("Series.array方法返回PandasArray对象:\n",s.array)
# Series.to_numpy() 返回NumPy的ndarray对象
print("Series.to_numpy()方法返回ndarray对象:\n",
type(s.to_numpy()), s.to_numpy())
# 输出
# Series.array方法返回PandasArray对象:
# value_counts()方法
value_counts方法： 直方图
data = {'a': ['x', 'y', 'y', 'x', 'x', 'z']}
df = pd.DataFrame(data=data)
print("value_counts方法: 直方图\n", df['a'].value_counts(), type(df))
# 输出
# value_counts方法: 直方图
# x 3
# y 2
# z 1
# Name: a, dtype: int64
# 字符串方法
Series的str属性包含一组字符串处理功能
# df同上
s = df.a
print("字符串方法:\n", s.str.upper())
# 输出 ： 调用str.upper()方法
# 字符串方法:
# 0 X
# 1 Y
# 2 Y
# 3 X
# 4 X
# 5 Z
# Name: a, dtype: object
以上关于Python的Pandas库的学习。
如果有什么不对的地方，欢迎指正！