pandas数据分析：十分钟快速入门重点函数速查

---

前言

pandas入门学习笔记，方便以后查询使用。

---

首先引入依赖库

import numpy as np
import pandas as pd
1
2

一、生成Series对象和DataFrame对象

生成Series对象：

#生成一般Series对象
s1=pd.Series([1,2,3,6,np.nan,6,8])
#生成日期Series对象
s2=pd.date_range("20221120",periods=6)
1
2
3
4

生成DataFrame对象：

#生成索引为日期的DataFrame:index行；columns列
df1=pd.DataFrame(np.random.randn(6, 4),index=s2,columns=list("ABCD"))
#利用 Series 字典对象生成DataFrame
df2=pd.DataFrame(
    {
        'A':np.arange(5),
        'B':pd.Series([10,20,30,40,50]),
        'C':"foo",
        'D':pd.Categorical(["test", "train", "test", "train","other"]),
    }
)
1
2
3
4
5
6
7
8
9
10
11

二、查看数据

#查看头部数据
df1.head(2)
#查看尾部数据
df1.tail(3)
#查看索引（行）
df1.index
#查看列名
df2.columns
#输出底层numpy数据对象：若df中每一列的类型不相同，则消耗资源多；反之，每一列都是float，则执行很迅速
df2.to_numpy()
#查看统计行描述
df1.describe()
#转置数据
df1.T
#按轴排序:axis：若为1，则按照列名称排序；若为0，则按照行名称排序。ascending:True则正序排序；False则逆序排序
df2.sort_index(axis=1, ascending=False)
#按值排序：by：列名；ascending:True则正序排序；False则逆序排序
df1.sort_values(by='C',ascending=False)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

三、获取数据

3.1 获取单列数据

#获取单列：df.列名或df["列名"] ，返回Series
df1["A"]# df1.A
#切片获取行
df1[0:3]#第0行到第2行的数据（共3行）【索引切片：不包含结束点】
df1["20221120":"20221124"]#20221120-20221124的数据（共5行）【标签切片：包含行与列结束点】
1
2
3
4
5

3.2 按照标签选择数据：loc函数

#按照标签获取一行的数据，返回Series对象
df1.loc["20221124"]
df2.loc[3]
#用标签选择多列数据:前面通过切片获取行；后面通过列表获取列
df1.loc["20221120":"20221124",['A', 'B']]
df2.loc[1:3,['C','D']]
#获取某一行的某几列数据，返回Series
df1.loc['20221124', ['A', 'B']]
#获取标量值
df2.loc[1, 'C']
df1.loc["20221124",'B']
1
2
3
4
5
6
7
8
9
10
11

3.2 按照位置选择数据：iloc函数

#选择某一行的数据，返回Series
df1.iloc[2]#选择第2行数据
#选择某几行，某几列的数据，返回DataFrame，采用切片
df1.iloc[3:5, 0:2]#利用切片
df1.iloc[[0,1,2],[2,3]]#利用列表作为切片
#显式整行切片
df1.iloc[1:3,:]
#显示整列切片
df1.iloc[:,1:3]
#显示提取标量
df1.iloc[1, 1]
df1.iat[1, 1]
1
2
3
4
5
6
7
8
9
10
11
12

3.3 布尔索引

#单列的值选择数据，返回DataFrame
df1[(df1.A > 0) & (df1.A<0.5)]
#选择 DataFrame 里满足条件的值
df1[df1>0]#不满足条件的值变为NAN
#isin进行筛选
df2[df2["D"].isin(["test","other"])]
1
2
3
4
5
6

3.4 赋值

#用索引自动对齐新增列的数据
s3=pd.Series([1,2,3,4,5,6],index=pd.date_range("20221120",periods=6))
df1["E"]=s3
#按照标签赋值
df1.loc["20221120","A"]=0.1
#按照位置赋值
df1.iloc[0,0]=0.2
#用条件赋值
df1[df1<0]=-df1
1
2
3
4
5
6
7
8
9

四、缺失值

Pandas主要用np.nan表示缺失数据。计算时，默认不包含空值。

#删除包含空值所在的行
df1.iloc[0,0]=np.nan
df1=df1.dropna(how="any")
#填充空值
df1=df1.fillna(value=5)
#提取DataFrame中空值
pd.isna(df1)
1
2
3
4
5
6
7

五、运算

运算：一般运算排除空缺值

#计算平均值
df1.mean()#按照列
df1.mean(1)#按照行
#apply:调用函数
df1.apply(np.cumsum)#按照行累加
df1.apply(lambda x: x.max() - x.min(),axis=1)#每一行计算最大值-最小值
#直方图:统计Series对象的每个数出现次数
s1.value_counts()
1
2
3
4
5
6
7
8

六、merge：合并DataFrame

6.1 concat函数

Concat：连接 Pandas 对象

df3=pd.DataFrame(np.random.randn(10,4))
temp_df1=df3.loc[:,[2,3]]
temp_df2=df3.loc[:,[0]]
res_df=pd.concat([temp_df1,temp_df2],axis=1)#axis=1按照列合并；axis=0按照行合并
1
2
3
4

6.2 merge函数：数据库join操作

#join:数据库风格链接
left=pd.DataFrame({"key":"test","numLeft":[1,2]})
right=pd.DataFrame({"key":"test","numRight":[3,4]})
res=pd.merge(left,right,on="key")#笛卡尔积
1
2
3
4

6.3 append追加：追加一行DataFrame

df3=pd.DataFrame(np.random.randn(5,4),columns=list("ABCD"))
df3.append(df3.iloc[3],ignore_index=True)#将第3行的数据追加到df3的最后一行
1
2

七、group分组

“group by” 指的是涵盖下列一项或多项步骤的处理流程：
分割：按条件把数据分割成多组；
应用：为每组单独应用函数；
组合：将处理结果组合成一个数据结构。

df5 = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar',
                          'foo', 'bar', 'foo', 'foo'],
                    'B': ['one', 'one', 'two', 'three',
                       'two', 'two', 'one', 'three'],
                   'C': np.random.randn(8),
                   'D': np.random.randn(8)})
df5.groupby("A").sum()
df5.groupby(["A","B"]).sum()
1
2
3
4
5
6
7
8

八、reshape：重塑

stack函数和unstack函数

#stack 把 DataFrame 列压缩至一层：
tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',
                     'foo', 'foo', 'qux', 'qux'],
                   ['one', 'two', 'one', 'two',
                    'one', 'two', 'one', 'two']]))
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])
stacked=df.stack()
#stack的逆运算为unstack,默认消除多级索引中最后一级索引
stacked.unstack()
1
2
3
4
5
6
7
8
9
10

九、数据透视表

df = pd.DataFrame({ 'A':['one', 'one', 'two', 'three']*3,
                    'B':['A','B','C'] * 4,
                    'C':['foo', 'foo', 'foo', 'bar', 'bar' , 'bar'] *2,
                    'D':np.random.randn(12),
                    'E':np.random.randn( 12)})
res=pd.pivot_table(df,index=['A',"B"],values=["D"],aggfunc=[np.sum,np.mean],columns=["C"])
1
2
3
4
5
6

十、时间序列

# Pandas 频率转换；如：将秒级的数据转换为 5 分钟为频率的数据
rng = pd.date_range('1/1/2012', periods=100, freq='S')
ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
ts.resample('5Min').sum()

#时区转换
rng = pd.date_range('3/6/2012 00:00', periods=5, freq='D')
ts = pd.Series(np.random.randn(len(rng)), rng)
ts_utc = ts.tz_localize('UTC')
ts_utc.tz_convert('US/Eastern')
1
2
3
4
5
6
7
8
9
10

十一、类别类型

"""
类别：Pandas 的 DataFrame 里可以包含类别数据
"""
df = pd.DataFrame({"id": [1, 2, 3, 4, 5, 6],
                   "raw_grade": ['a', 'b', 'b', 'a', 'a', 'e']})
#将raw_grade中值作为类型生成新的列
df["grade"] = df["raw_grade"].astype("category")
#将category的类型重命名
df["grade"].cat.categories = ["very good", "good", "very bad"]
#重新排序各类别，并添加缺失类
df["grade"] = df["grade"].cat.set_categories(["very bad", "bad", "medium","good", "very good"])
#类别排序：按照类别的优先级排序
df.sort_values(by="grade")
#类别分组统计，当类别为空时，也会显示0
df.groupby("grade").size()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

十二、可视化

#Series可视化
ts=pd.Series(np.random.randn(1000),index=pd.date_range("20221125",periods=1000))
ts = ts.cumsum()
#DataFrame可视化
dfPlot=pd.DataFrame(np.random.randn(1000,4),index=pd.date_range("20221125",periods=1000),columns=list("ABCD"))
dfPlot.cumsum().plot()
1
2
3
4
5
6

十三、文件读写

df.to_csv('foo.csv')
pd.read_csv('foo.csv')

df.to_excel( 'foo.xlsx',sheet_name='sheet1')
pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])
1
2
3
4
5