Pandas - 语法基础 Pt.1

发表于 更新于 分类于

这篇随笔主要介绍 Pandas 的两种数据类型：Series 和 DataFrame 相关的内容
Pt.1 部分主要介绍对 Pandas 两种数据类型的基本操作，包括创建、索引和修改
Pt.2 部分详细介绍了 Pandas 的索引操作
Pt.3 部分主要介绍了 Pandas 的计算和函数
Pt.4 部分详细介绍了 Pandas 的统计计算相关的函数

1
2
3
import numpy as np
import pandas as pd
from pandas import Series, DataFrame

pandas 的数据结构 - Series

pd.Series( data, index )

1
2
obj = pd.Series([4, 7, -5, 3])
obj
1
2
3
4
5
0    4
1    7
2   -5
3    3
dtype: int64
1
2
obj2 = pd.Series([4, 7, -5, 3], index=['q', 'w', 'e', 'r'])
obj2
1
2
3
4
5
q    4
w    7
e   -5
r    3
dtype: int64

可以通过 Series 的 values 和 index 属性获取其数组表示形式和索引对象

1
2
3
4
print(obj.values)
print(obj.index)
print(obj2.values)
print(obj2.index)
1
2
3
4
[ 4  7 -5  3]
RangeIndex(start=0, stop=4, step=1)
[ 4  7 -5  3]
Index(['q', 'w', 'e', 'r'], dtype='object')

Series 的 index 可以通过赋值的方式就地修改

1
2
obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']
obj
1
2
3
4
5
Bob      4
Steve    7
Jeff    -5
Ryan     3
dtype: int64

pd.Series( dict ) : 通过字典创建 Series

1
2
3
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
obj3 = pd.Series(sdata)
obj3
1
2
3
4
5
Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64
1
2
3
states = ['California', 'Ohio', 'Oregon', 'Texas']
obj4 = pd.Series(sdata, index=states)
obj4 # 没有 'Utah', 但是有 'California'
1
2
3
4
5
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64

pd.isnull( obj ), pd.notnull( obj ) : 检测缺失数据

1
pd.isnull(obj4), pd.notnull(obj4)
1
2
3
4
5
6
7
8
9
10
(California     True
 Ohio          False
 Oregon        False
 Texas         False
 dtype: bool,
 California    False
 Ohio           True
 Oregon         True
 Texas          True
 dtype: bool)

Series 的索引与运算

1
obj2['w'], obj2[['w']], obj2[['r', 'q', 'e']] #['r', 'q', 'e']: 索引表
1
2
3
4
5
6
7
(7,
 w    7
 dtype: int64,
 r    3
 q    4
 e   -5
 dtype: int64)
1
obj2[obj2 > 0]
1
2
3
4
q    4
w    7
r    3
dtype: int64
1
obj2 * 2, np.exp(obj2)
1
2
3
4
5
6
7
8
9
10
(q     8
 w    14
 e   -10
 r     6
 dtype: int64,
 q      54.598150
 w    1096.633158
 e       0.006738
 r      20.085537
 dtype: float64)
1
'q' in obj2, 'a' in obj2
1
(True, False)

运算时, 索引标签会自动对齐

1
obj3, obj4, obj3+obj4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
(Ohio      35000
 Texas     71000
 Oregon    16000
 Utah       5000
 dtype: int64,
 California        NaN
 Ohio          35000.0
 Oregon        16000.0
 Texas         71000.0
 dtype: float64,
 California         NaN
 Ohio           70000.0
 Oregon         32000.0
 Texas         142000.0
 Utah               NaN
 dtype: float64)

Series 本身及索引都有 name 属性

1
2
3
obj4.name = 'population'
obj4.index.name = 'state'
obj4
1
2
3
4
5
6
state
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
Name: population, dtype: float64

pandas 的数据结构 —— DataFrame

pd.DataFrame( object ) : DataFrame 的建立

1
2
3
4
5
6
7
# 直接传入一个由等长列表或 NumPy 数组组成的字典
data = {'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2], 
        'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'], 
        'year': [2000, 2001, 2002, 2001, 2002, 2003]
        }
frame = pd.DataFrame(data)
frame
popstateyear
01.5Ohio2000
11.7Ohio2001
23.6Ohio2002
32.4Nevada2001
42.9Nevada2002
53.2Nevada2003

DataFrame.head( n ) : 对于特别大的 DataFrame,方法会选取前 n 行

1
frame.head(3)
popstateyear
01.5Ohio2000
11.7Ohio2001
23.6Ohio2002

DataFrame.columns : 返回 DataFrame 的列名

1
frame.columns

Index(['pop', 'state', 'year'], dtype='object')

pd.DataFrame( object , columns ) : 指定列序列, DataFrame会按照指定顺序进行排列

1
2
3
4
5
data = {'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2], 
        'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'], 
        'year': [2000, 2001, 2002, 2001, 2002, 2003]
        }
pd.DataFrame(data, columns=['year', 'state', 'pop'])
yearstatepop
02000Ohio1.5
12001Ohio1.7
22002Ohio3.6
32001Nevada2.4
42002Nevada2.9
52003Nevada3.2

pd.DataFrame( object , columns , index ) : 指定索引

1
2
3
frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], 
                            index=data['year'])
frame2
yearstatepopdebt
20002000Ohio1.5NaN
20012001Ohio1.7NaN
20022002Ohio3.6NaN
20012001Nevada2.4NaN
20022002Nevada2.9NaN
20032003Nevada3.2NaN

pd.DataFrame( dict ) : 嵌套字典 : { 'out1' : {'in1': v11, 'in2': v12}, 'out2': {...} }

如果嵌套字典传给DataFrame, 字典外层的键作为列, 内层的键则作为行索引

1
2
pop = {'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
pop

{'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}

1
2
frame3 = pd.DataFrame(pop)
frame3
NevadaOhio
20012.41.7
20022.93.6
2000NaN1.5

pd.DataFrame( dict , index ) : 指定索引

1
pd.DataFrame(pop, index=[2001, 2002, 2003])
NevadaOhio
20012.41.7
20022.93.6
2003NaNNaN

DataFrame 的索引和切片

1
frame2['state']
1
2
3
4
5
6
7
2000    Ohio
2001    Ohio
2002    Ohio
2001  Nevada
2002  Nevada
2003  Nevada
Name: state, dtype: object
1
frame2.state
1
2
3
4
5
6
7
2000      Ohio
2001      Ohio
2002      Ohio
2001    Nevada
2002    Nevada
2003    Nevada
Name: state, dtype: object
1
frame2.loc[2002]
yearstatepopdebt
20022002Ohio3.6NaN
20022002Nevada2.9NaN
1
frame2['state'].loc[2002]
1
2
3
2002      Ohio
2002    Nevada
Name: state, dtype: object

DataFrame 的赋值

数组或列表 : 将列表或数组赋值给某个列时， 其长度必须跟 DataFrame 的长度相匹配

1
2
frame2['debt'] = np.arange(6.)
frame2
yearstatepopdebt
20002000Ohio1.50.0
20012001Ohio1.71.0
20022002Ohio3.62.0
20012001Nevada2.43.0
20022002Nevada2.94.0
20032003Nevada3.25.0

Series : 如果赋值的是一个 Series , 就会精确匹配 DataFrame 的索引

1
2
3
val = pd.Series([-1.2, -1.5, -1.7], index=[2000, 2001, 2004])
frame2['debt'] = val
frame2
yearstatepopdebt
20002000Ohio1.5-1.2
20012001Ohio1.7-1.5
20022002Ohio3.6NaN
20012001Nevada2.4-1.5
20022002Nevada2.9NaN
20032003Nevada3.2NaN
1
2
3
frame2['debt_null'] = pd.notnull(frame2.debt)
### 注意 : 不能用frame2.debt_null创建新的列
frame2
yearstatepopdebtdebt_null
20002000Ohio1.5-1.2True
20012001Ohio1.7-1.5True
20022002Ohio3.6NaNFalse
20012001Nevada2.4-1.5True
20022002Nevada2.9NaNFalse
20032003Nevada3.2NaNFalse

del : DataFrame 删除某列

1
2
del frame2['debt_null']
frame2.columns
1
Index(['year', 'state', 'pop', 'debt'], dtype='object')

DataFrame 的转置

1
frame3.T
200120022000
Nevada2.42.9NaN
Ohio1.73.61.5

可以输入给 DataFrame 进行构造的数据

类型说明
二维 ndarray数据矩阵, 还可以传入行标和列标
由数组、列表和元组组成的字典字典的每个键对应的序列会成为 DataFrame 的一列, 所有序列的长度必须相同
Numpy 的结构化 / 记录数组类似于有数组组成的字典
由 Series 组成的字典字典的每个键对应的 Series 会成为一列
由字典组成的字典外层字典的键为列头, 内层字典的键为行索引
字典或 Series 列表列表各项会成为 DataFrame 的各行, 各项字典/ Series 对应的键/索引会成为列头
由列表或元组组成的列表类似于二维 ndarray
另一个 DataFrame该 DataFrame 的索引将被沿用
Numpy 的 MaskedArray类似于二维 ndarray, 掩码值在 DataFrame 会变成NA/缺失值

DataFrame 的 name 和 values 属性

如果设置了 DataFrame 的 index 和 columns 的 name 属性, 则这些信息也会被显示出来

1
2
frame3.index.name = 'year'; frame3.columns.name = 'state'
frame3
stateNevadaOhio
year
20012.41.7
20022.93.6
2000NaN1.5

values 属性也会以二维 ndarray 的形式返回 DataFrame 中的数据

1
frame3.values
1
2
3
array([[2.4, 1.7],
       [2.9, 3.6],
       [nan, 1.5]])
1
frame2.values
1
2
3
4
5
6
array([[2000, 'Ohio', 1.5, -1.2],
       [2001, 'Ohio', 1.7, -1.5],
       [2002, 'Ohio', 3.6, nan],
       [2001, 'Nevada', 2.4, -1.5],
       [2002, 'Nevada', 2.9, nan],
       [2003, 'Nevada', 3.2, nan]], dtype=object)