pandas-基础笔记

Pandas学习笔记-基础篇

参考资料

https://www.yiibai.com/pandas/

导入模块

import pandas as pd
import numpy as np

Series系列

系列(Series)是能够保存任何类型的数据(整数，字符串，浮点数，Python对象等)的一维标记数组。轴标签统称为索引

pandas.Series(data, index, dtype, copy)

编号	参数	描述
1	data	数据采取各种形式，如：ndarray，list，constants
2	index	索引值必须是唯一的和散列的，与数据的长度相同。 默认np.arange(n)如果没有索引被传递。
3	dtype	dtype用于数据类型。如果没有，将推断数据类型
4	copy	复制数据，默认为false。

创建

ndarray系列

如果数据是ndarray，传递的索引必须具有相同长度。

如果没有传递索引值，则默认索引为[0,1,2,...,range(len(array))-1]-1

In[5]: data =  np.array(['a','b','c','d'])
In[6]: pd.Series(data) #没有传递索引值
Out[6]: 

0    a
1    b
2    c
3    d
dtype: object
In[7]: pd.Series(data,index = ['A','B','C','D']) #自定义索引值
Out[7]: 

A    a
B    b
C    c
D    d
dtype: object

字典系列

如果没有指定索引，按照排序顺序取得字典键构造索引；

如果传递索引，索引中与标签对应的数据中的值被拉出。

In[12]: data = {'b':1,'a':0,'c':2}
In[13]: data
Out[13]: 
{'a': 0, 'b': 1, 'c': 2}
In[14]: pd.Series(data) #键被用于构建索引
Out[14]: 

a    0
b    1
c    2
dtype: int64
In[15]: pd.Series(data,index=['b','d','a']) #输出顺序和索引顺序一致，缺少的元素使用NaN补充
Out[15]: 

b    1.0
d    NaN
a    0.0
dtype: float64

标量系列

从标量创建系列，必须提供索引。

In[20]: pd.Series(5,index=range(0,5))
Out[20]: 

0    5
1    5
2    5
3    5
4    5
dtype: int64

访问

根据位置

In[21]: s =pd.Series(5,index=range(0,5))
In[22]: print(s)
0    5
1    5
2    5
3    5
4    5
dtype: int64
In[23]: s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
In[24]: print(s)
a    1
b    2
c    3
d    4
e    5
dtype: int64
In[25]: print(s[0]) #检索第一个元素
1
In[26]: print(s[:3]) #检索前三个元素
a    1
b    2
c    3
dtype: int64
In[28]: print(s[-3:]) #检索后三个元素
c    3
d    4
e    5
dtype: int64

根据标签

In[31]: s = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
In[32]: print(s)
a    1
b    2
c    3
d    4
e    5
dtype: int64
In[33]: print(s['a']) #检索单个索引
1
In[34]: print(s[['a','c','d']]) #检索多个索引
a    1
c    3
d    4
dtype: int64

Dataframe数据框

pandas.DataFrame(data,index,columns,dtype,copy)

编号	参数	描述
1	data	数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
2	index	对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值。
3	columns	对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
4	dtype	每列的数据类型。
5	copy	如果默认值为False，则此命令(或任何它)用于复制数据。

创建

从列表创建

In[41]: data=[1,2,3,4,5] #单个列表
In[42]: df=pd.DataFrame(data) 
In[43]: print(df)
   0
0  1
1  2
2  3
3  4
4  5
In[44]: data=[['Alex',10],['Bob',12],['Clarke',13]] #多维列表
In[46]: df=pd.DataFrame(data,columns=['Name','Age'])  
In[47]: print(df)
     Name  Age
0    Alex   10
1     Bob   12
2  Clarke   13
In[48]: df=pd.DataFrame(data,columns=['Name','Age'],dtype=float) #更改数据类型
In[49]: print(df)
     Name   Age
0    Alex  10.0
1     Bob  12.0
2  Clarke  13.0

从ndarray/Lists创建

所有ndarray必须具有相同长度，如果传递了index，则索引长度应该等于数组长度

In[52]: data = {'Name':['Tom','Jack','Steve','Ricky'],'Age':[28,34,29,42]}
In[53]: df = pd.DataFrame(data)
In[54]: print(df)
   Age   Name
0   28    Tom
1   34   Jack
2   29  Steve
3   42  Ricky
In[55]: df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
In[56]: print(df)
       Age   Name
rank1   28    Tom
rank2   34   Jack
rank3   29  Steve
rank4   42  Ricky

从字典创建

字典键默认为列名

In[57]: data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
In[58]: df = pd.DataFrame(data) #缺失值使用NaN补充
In[59]: print(df)
   a   b     c
0  1   2   NaN
1  5  10  20.0
In[60]: df = pd.DataFrame(data,index=['first','second'])
In[61]: print(df)
        a   b     c
first   1   2   NaN
second  5  10  20.0

In[62]: df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a','b']) #使用字典键值创建列名
In[63]: print(df1)
        a   b
first   1   2
second  5  10
In[64]: df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a','b1']) #使用字典键以外的值创建列名
In[65]: print(df2)
        a  b1
first   1 NaN
second  5 NaN

从系列字典创建

使用系列索引并集作为DataFrame的索引

In[69]: d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   ...:       'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
In[70]: df = pd.DataFrame(d) #此处不能设置index
In[71]: print(df)
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4

自定义索引

d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack',
   'Lee','David','Gasper','Betina','Andres']),
   'Age':pd.Series([25,26,25,23,30,29,23,34,40,30,51,46]),
   'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8,3.78,2.98,4.80,4.10,3.65])}
df = pd.DataFrame(d)
print(df)
    Age    Name  Rating
0    25     Tom    4.23
1    26   James    3.24
2    25   Ricky    3.98
3    23     Vin    2.56
4    30   Steve    3.20
5    29   Minsu    4.60
6    23    Jack    3.80
7    34     Lee    3.78
8    40   David    2.98
9    30  Gasper    4.80
10   51  Betina    4.10
df.index = [chr(i) for i in range(ord("a"),ord("m"))]
print(df)
   Age    Name  Rating
a   25     Tom    4.23
b   26   James    3.24
c   25   Ricky    3.98
d   23     Vin    2.56
e   30   Steve    3.20
f   29   Minsu    4.60
g   23    Jack    3.80
h   34     Lee    3.78
i   40   David    2.98
j   30  Gasper    4.80
k   51  Betina    4.10
l   46  Andres    3.65

列操作

选择列

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
      'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
In[72]: print(df['one'])
a    1.0
b    2.0
c    3.0
d    NaN
Name: one, dtype: float64

添加列

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
      'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
In[81]: df['three'] = pd.Series([10,20,40],index=['a','b','c'])
In[82]: print(df)
   one  two  three
a  1.0    1   10.0
b  2.0    2   20.0
c  3.0    3   40.0
d  NaN    4    NaN
In[83]: df['four'] = df['one']+df['two']
In[84]: print(df)
   one  two  three  four
a  1.0    1   10.0   2.0
b  2.0    2   20.0   4.0
c  3.0    3   40.0   6.0
d  NaN    4    NaN   NaN

删除列

In[85]: print(df)
   one  two  three  four
a  1.0    1   10.0   2.0
b  2.0    2   20.0   4.0
c  3.0    3   40.0   6.0
d  NaN    4    NaN   NaN
In[86]: del df['one'] #直接在原DataFrame中删除对应列
In[87]: print(df)
   two  three  four
a    1   10.0   2.0
b    2   20.0   4.0
c    3   40.0   6.0
d    4    NaN   NaN
In[88]: df.pop('three') #返回选择列内容，并在原DataFrame中删除对应列
Out[88]: 

a    10.0
b    20.0
c    40.0
d     NaN
Name: three, dtype: float64
In[89]: print(df)
   two  four
a    1   2.0
b    2   4.0
c    3   6.0
d    4   NaN

行操作

标签选择

In[91]: d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   ...:       'two' : pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}
   ...: df = pd.DataFrame(d)
In[92]: print(df)
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4
In[93]: print(df.loc['b'])
one    2.0
two    2.0
Name: b, dtype: float6

位置选择

In[96]: print(df.iloc[3])
one    NaN
two    4.0
Name: d, dtype: float64

切片

In[99]: print(df[2:4])
   one  two
c  3.0    3
d  NaN    4

添加行

In[105]: df1 = pd.DataFrame([[1,2],[3,4]], columns = ['a', 'b'])
In[106]: df2 = pd.DataFrame([[5,6],[7,8]], columns = ['a', 'b'])
In[107]: print(df1)
   a  b
0  1  2
1  3  4
In[108]: print(df2)
   a  b
0  5  6
1  7  8
In[109]: df1 = df1.append(df2)
In[110]: print(df2)
   a  b
0  5  6
1  7  8
In[111]: print(df1) # 注意行索引
   a  b
0  1  2
1  3  4
0  5  6
1  7  8
In[114]: print(df1.loc[1])
   a  b
1  3  4
1  7  8

删除行

drop()返回删除指定行后的内容，但是不能直接修改原DataFrame

如果有标签重复，则删除多行

In[119]: print(df1)
   a  b
0  1  2
1  3  4
0  5  6
1  7  8
In[120]: df1.drop(0)
Out[120]: 

   a  b
1  3  4
1  7  8
In[121]: print(df1)
   a  b
0  1  2
1  3  4
0  5  6
1  7  8
In[122]: df1 = df1.drop(0)
In[123]: print(df1)
   a  b
1  3  4
1  7  8

综合定位

In[225]: print(df)
   Age    Name  Rating
a   25     Tom    4.23
b   26   James    3.24
c   25   Ricky    3.98
d   23     Vin    2.56
e   30   Steve    3.20
f   29   Minsu    4.60
g   23    Jack    3.80

loc[]通过关键字符来定位；只有一维列表时，默认定位行；只要索引范围中含有一个正确值，错误地方会用NaN替代

In[280]: print(df.loc[['a','z'],['Age','time']])
    Age  time
a  25.0   NaN
z   NaN   NaN

iloc[]通过位置来定位；只有以为列表时，默认定位列；超出范围时报错

打印第一行

In[254]: print(df.loc['a'])
Age         25
Name       Tom
Rating    4.23
Name: a, dtype: object
In[255]: print(df.iloc[0])
Age         25
Name       Tom
Rating    4.23
Name: a, dtype: object
In[256]: print(df.iloc[0:1,:])
   Age Name  Rating
a   25  Tom    4.23
In[257]: print(df.iloc[0:1])
   Age Name  Rating
a   25  Tom    4.23

打印前两行

In[227]: print(df.loc[['a','b']])
   Age   Name  Rating
a   25    Tom    4.23
b   26  James    3.24
In[229]: print(df.iloc[[0,1]])
   Age   Name  Rating
a   25    Tom    4.23
b   26  James    3.24
In[230]: print(df.iloc[0:2,:])
   Age   Name  Rating
a   25    Tom    4.23
b   26  James    3.24

打印前3行+后2列

In[270]: print(df.loc[['a','b','c'],['Name','Rating']])
    Name  Rating
a    Tom    4.23
b  James    3.24
c  Ricky    3.98
In[231]: print(df.iloc[0:3,1:3])
    Name  Rating
a    Tom    4.23
b  James    3.24
c  Ricky    3.98
In[237]: print(df.iloc[0:3,df.columns.size-2:df.columns.size])
    Name  Rating
a    Tom    4.23
b  James    3.24
c  Ricky    3.98
In[291]: print(df.iloc[0:3,df.shape[1]-2:df.shape[1]])
    Name  Rating
a    Tom    4.23
b  James    3.24
c  Ricky    3.98

打印第1列

In[261]: print(df['Name'])
a      Tom
b    James
c    Ricky
d      Vin
e    Steve
f    Minsu
g     Jack
Name: Name, dtype: object
In[263]: print(df.iloc[:,1])
a      Tom
b    James
c    Ricky
d      Vin
e    Steve
f    Minsu
g     Jack
Name: Name, dtype: object

Series基本功能

编号	属性或方法	描述
1	axes	返回行轴标签列表。
2	dtype	返回对象的数据类型(dtype)。
3	empty	如果系列为空，则返回True。
4	ndim	返回底层数据的维数，默认定义：1。
5	size	返回基础数据中的元素数。
6	values	将系列作为ndarray返回。
7	head()	返回前n行。
8	tail()	返回最后n行。

创建示例

In[124]: s = pd.Series(np.random.randn(4))
In[125]: print(s)
0    0.032700
1    0.589703
2   -0.122490
3    0.333868
dtype: float64

axes

In[126]: print(s.axes) # 返回行名标签列表
[RangeIndex(start=0, stop=4, step=1)] 

empty

In[128]: print(s.empty) #判断是否为空表格
False

ndim

In[129]: print(s.ndim) #返回对象维数，一个Searies的一个1D数据结构
1

size

In[133]: print(s.size) # 返回系列的大小（长度）
4

values

In[134]: print(s.values) # 返回系列实际数据值
[ 0.03270012  0.58970334 -0.12249047  0.33386772]

head tail

In[135]: print(s.head(2))
0    0.032700
1    0.589703
dtype: float64
In[136]: print(s.tail(3))
1    0.589703
2   -0.122490
3    0.333868
dtype: float64

DataFrame基本功能

编号	属性或方法	描述
1	T	转置行和列。
2	axes	返回一个列，行轴标签和列轴标签作为唯一的成员。
3	dtypes	返回此对象中的数据类型(dtypes)。
4	empty	如果NDFrame完全为空[无项目]，则返回为True; 如果任何轴的长度为0。
5	ndim	轴/数组维度大小。
6	shape	返回表示DataFrame的维度的元组。
7	size	NDFrame中的元素数。
8	values	NDFrame的Numpy表示。
9	head()	返回开头前n行。
10	tail()	返回最后n行。

创建示例

In[137]: d = {'Name':pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack']),
    ...:    'Age':pd.Series([25,26,25,23,30,29,23]),
    ...:    'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
In[138]: df = pd.DataFrame(d)
In[139]: print(df)
   Age   Name  Rating
0   25    Tom    4.23
1   26  James    3.24
2   25  Ricky    3.98
3   23    Vin    2.56
4   30  Steve    3.20
5   29  Minsu    4.60
6   23   Jack    3.80

T

In[147]: print(df.T)
           a      b      c     d      e      f     g
Age       25     26     25    23     30     29    23
Name     Tom  James  Ricky   Vin  Steve  Minsu  Jack
Rating  4.23   3.24   3.98  2.56    3.2    4.6   3.8

axes

In[148]: print(df.axes) #返回行轴标签和列轴标签
[Index(['a', 'b', 'c', 'd', 'e', 'f', 'g'], dtype='object'), Index(['Age', 'Name', 'Rating'], dtype='object')]

dtypes

In[149]: print(df.dtypes)
Age         int64
Name       object
Rating    float64
dtype: object

shape

In[152]: print(df.shape) #返回元组(a,b),a表示行数,b表示列数
(7, 3)

size

In[153]: print(df.size) # df所有元素数
21
In[243]: df.iloc[:,0].size #第一列的元素数，即行数
Out[243]: 
7
In[244]: len(df)
Out[244]: 
7

values

In[155]: print(df.values) #将DataFrame中的实际数据作为NDarray返回
[[25 'Tom' 4.23]
 [26 'James' 3.24]
 [25 'Ricky' 3.98]
 [23 'Vin' 2.56]
 [30 'Steve' 3.2]
 [29 'Minsu' 4.6]
 [23 'Jack' 3.8]]

索引名称

In[264]: print(df.index) #打印行索引
Index(['a', 'b', 'c', 'd', 'e', 'f', 'g'], dtype='object')
In[265]: print(df.columns) #打印列索引
Index(['Age', 'Name', 'Rating'], dtype='object')

行列统计

In[285]: print(len(df)) #统计行数
7
In[286]: print(df.columns.size) #统计列数
3

DataFrame描述性统计

编号	函数	描述
1	count()	非空观测数量
2	sum()	所有值之和
3	mean()	所有值的平均值
4	median()	所有值的中位数
5	mode()	值的模值
6	std()	值的标准偏差
7	min()	所有值中的最小值
8	max()	所有值中的最大值
9	abs()	绝对值
10	prod()	数组元素的乘积
11	cumsum()	累计总和
12	cumprod()	累计乘积

统计摘要

In[298]: print(df.describe())
             Age     Rating
count  12.000000  12.000000
mean   31.833333   3.743333
std     9.232682   0.661628
min    23.000000   2.560000
25%    25.000000   3.230000
50%    29.500000   3.790000
75%    35.500000   4.132500
max    51.000000   4.800000

个别统计示例

In[295]: print(df.sum()) # 列求和
Age                                                     382
Name      TomJamesRickyVinSteveMinsuJackLeeDavidGasperBe...
Rating                                                44.92
dtype: object 
In[296]: print(df.cumsum()) # 列累计求和
    Age                                               Name Rating
0    25                                                Tom   4.23
1    51                                           TomJames   7.47
2    76                                      TomJamesRicky  11.45
3    99                                   TomJamesRickyVin  14.01
4   129                              TomJamesRickyVinSteve  17.21
5   158                         TomJamesRickyVinSteveMinsu  21.81
6   181                     TomJamesRickyVinSteveMinsuJack  25.61
7   215                  TomJamesRickyVinSteveMinsuJackLee  29.39
8   255             TomJamesRickyVinSteveMinsuJackLeeDavid  32.37
9   285       TomJamesRickyVinSteveMinsuJackLeeDavidGasper  37.17
10  336  TomJamesRickyVinSteveMinsuJackLeeDavidGasperBe...  41.27
11  382  TomJamesRickyVinSteveMinsuJackLeeDavidGasperBe...  44.92
In[299]: print(df.mean()) # 列求均值
Age       31.833333
Rating     3.743333
dtype: float64
In[300]: print(df.std()) # 列求标准差
Age       9.232682
Rating    0.661628
dtype: float64

axis

sum() mean() std()等默认axis=0，以列为单位计算；设置axis=1，以行为单位计算

In[317]: df.sum(axis=1)
Out[317]:
a    29.23
b    29.24
c    28.98
d    25.56
e    33.20
f    33.60
g    26.80
h    37.78
i    42.98
j    34.80
k    55.10
l    49.65
dtype: float64
In[319]: df.mean(axis=1)
Out[319]: 

a    14.615
b    14.620
c    14.490
d    12.780
e    16.600
f    16.800
g    13.400
h    18.890
i    21.490
j    17.400
k    27.550
l    24.825
dtype: float64

函数

pipe()

将函数定义在每一个元素上

In[4]: df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
In[5]: def adder(ele1,ele2):
  ...:     return ele1+ele2
  ...: 
In[6]: print(df)
       col1      col2      col3
0  1.123701  0.750719  0.556304
1  1.060900 -0.148950  1.589776
2 -1.861831 -0.526665  0.553255
3 -1.844168  0.932637 -1.051271
4  1.539621  0.931820 -0.210631
In[7]: print(df.pipe(adder,2))
       col1      col2      col3
0  3.123701  2.750719  2.556304
1  3.060900  1.851050  3.589776
2  0.138169  1.473335  2.553255
3  0.155832  2.932637  0.948729
4  3.539621  2.931820  1.789369

apply()

axis=0（默认）以列为单位，axis=1以行为单位

In[12]: print(df.apply(np.mean))
col1    0.003645
col2    0.387912
col3    0.287487
dtype: float64
In[13]: df.mean()
Out[13]: 

col1    0.003645
col2    0.387912
col3    0.287487
dtype: float64
In[14]: print(df.apply(np.mean,axis=1))
0    0.810242
1    0.833909
2   -0.611747
3   -0.654267
4    0.753603
dtype: float64
In[15]: df.apply(lambda x:x.max()-x.min())
Out[15]: 

col1    3.401452
col2    1.459302
col3    2.641048
dtype: float64
In[16]: df.apply(lambda x:x.max()-x.min(),axis=1)
Out[16]: 

0    0.567397
1    1.738727
2    2.415086
3    2.776805
4    1.750251
dtype: float64

applymap()

applymap(func)也可以将函数定义在每个元素上，但是不能传递参数

In[28]: print(df.applymap(lambda x:x*2))
       col1      col2      col3
0  2.247402  1.501439  1.112609
1  2.121800 -0.297900  3.179553
2 -3.723662 -1.053330  1.106511
3 -3.688336  1.865274 -2.102542
4  3.079241  1.863641 -0.421261
In[29]: print(df.pipe(lambda x,y:x*2+y,y=2))
       col1      col2      col3
0  4.247402  3.501439  3.112609
1  4.121800  1.702100  5.179553
2 -1.723662  0.946670  3.106511
3 -1.688336  3.865274 -0.102542
4  5.079241  3.863641  1.578739
In[30]: print(df.applymap(lambda x,y:x*2+y,y=2))
TypeError: applymap() got an unexpected keyword argument 'y'

重建索引

reindex

In[31]: N=20
In[32]: df = pd.DataFrame({
   ...:    'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
   ...:    'x': np.linspace(0,stop=N-1,num=N), # 创建等差数列
   ...:    'y': np.random.rand(N), #生成[0,1)之间的随机浮点数
   ...:    'C': np.random.choice(['Low','Medium','High'],N).tolist(), #.choice随机取样
   ...:    'D': np.random.normal(100, 10, size=(N)).tolist()
   ...: })
In[33]: print(df)
            A       C           D     x         y
0  2016-01-01    High   96.701722   0.0  0.399212
1  2016-01-02    High  109.993893   1.0  0.372344
2  2016-01-03     Low   93.826082   2.0  0.616053
3  2016-01-04    High  119.389641   3.0  0.406933
4  2016-01-05    High   87.518321   4.0  0.426282
5  2016-01-06     Low   91.836151   5.0  0.483436
6  2016-01-07    High   94.608244   6.0  0.540012
7  2016-01-08    High  108.886962   7.0  0.389494
8  2016-01-09     Low  106.946830   8.0  0.794819
9  2016-01-10    High   86.482129   9.0  0.919236
10 2016-01-11     Low   88.937570  10.0  0.824543
11 2016-01-12  Medium  104.843442  11.0  0.068905
12 2016-01-13     Low   96.481772  12.0  0.330995
13 2016-01-14     Low   97.454468  13.0  0.075122
14 2016-01-15     Low   94.906360  14.0  0.931858
15 2016-01-16  Medium   96.722896  15.0  0.775683
16 2016-01-17  Medium  116.414839  16.0  0.435225
17 2016-01-18    High  111.923778  17.0  0.492274
18 2016-01-19    High  122.022068  18.0  0.393136
19 2016-01-20     Low  109.190275  19.0  0.680880
In[44]: df_reindexed = df.reindex(index=[0,2,5], columns=['A','C','B'])
In[45]: print(df_reindexed)
           A     C   B
0 2016-01-01  High NaN
2 2016-01-03   Low NaN
5 2016-01-06   Low NaN

reindex_like

根据另外一个对象的索引，重新标记自身的索引。

行列名称需要相互匹配，否则以NaN替代

In[63]: df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
   ...: df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
In[64]: print(df1)
       col1      col2      col3
0  1.624844  0.278656  1.172339
1  0.145682  0.355114 -1.034259
2  0.901337 -0.987445 -0.598795
3 -0.750509  0.081066  1.014804
4  0.987722  2.106214 -0.722732
5 -0.254307  0.018380  1.453138
In[65]: print(df2)
       col1      col2      col3
0  1.070348  0.076233  0.821260
1  0.694489  0.680185 -1.355397
In[66]: print(df1.reindex_like(df2)) # 根据df2的索引提取df1对应内容
       col1      col2      col3
0  1.624844  0.278656  1.172339
1  0.145682  0.355114 -1.034259
In[67]: print(df2.reindex_like(df1))
       col1      col2      col3
0  1.070348  0.076233  0.821260
1  0.694489  0.680185 -1.355397
2       NaN       NaN       NaN
3       NaN       NaN       NaN
4       NaN       NaN       NaN
5       NaN       NaN       NaN
In[68]: print(df2.reindex_like(df1,method='ffill')) 
       col1      col2      col3
0  1.070348  0.076233  0.821260
1  0.694489  0.680185 -1.355397
2  0.694489  0.680185 -1.355397
3  0.694489  0.680185 -1.355397
4  0.694489  0.680185 -1.355397
5  0.694489  0.680185 -1.355397
In[69]: print(df2.reindex_like(df1,method='ffill',limit=1))
       col1      col2      col3
0  1.070348  0.076233  0.821260
1  0.694489  0.680185 -1.355397
2  0.694489  0.680185 -1.355397
3       NaN       NaN       NaN
4       NaN       NaN       NaN
5       NaN       NaN       NaN

填充方法有pad/ffill-向前填充；bfill/backfill-向后填充；nearest-从最近的索引值填充

limit限定指定连续匹配的最大计数

重命名

In[70]: print(df1)
       col1      col2      col3
0  1.624844  0.278656  1.172339
1  0.145682  0.355114 -1.034259
2  0.901337 -0.987445 -0.598795
3 -0.750509  0.081066  1.014804
4  0.987722  2.106214 -0.722732
5 -0.254307  0.018380  1.453138
In[71]: print(df1.rename(columns={'col1':'c1','col2':'c2'},index={0:'apple',1:'banana',2:'durian'}))
              c1        c2      col3
apple   1.624844  0.278656  1.172339
banana  0.145682  0.355114 -1.034259
durian  0.901337 -0.987445 -0.598795
3      -0.750509  0.081066  1.014804
4       0.987722  2.106214 -0.722732
5      -0.254307  0.018380  1.453138
In[72]: df1.rename(columns={'col1':'c1','col2':'c2'},index={0:'apple',1:'banana',2:'durian'},inplace=True) #inplace=True，直接修改数据对象
In[73]: print(df1)
              c1        c2      col3
apple   1.624844  0.278656  1.172339
banana  0.145682  0.355114 -1.034259
durian  0.901337 -0.987445 -0.598795
3      -0.750509  0.081066  1.014804
4       0.987722  2.106214 -0.722732
5      -0.254307  0.018380  1.453138

排序

In[89]: unsorted_df=pd.DataFrame(np.random.randn(5,2),index=[1,4,6,2,3],columns=['col2','col1'])
In[90]: print(unsorted_df)
       col2      col1
1 -1.603360 -0.835863
4 -0.717269 -0.720635
6 -1.124588 -0.255081
2 -0.220290 -0.824135
3  0.975299 -0.728140

按标签排序

In[91]: print(unsorted_df.sort_index())
       col2      col1
1 -1.603360 -0.835863
2 -0.220290 -0.824135
3  0.975299 -0.728140
4 -0.717269 -0.720635
6 -1.124588 -0.255081
In[92]: print(unsorted_df.sort_index(ascending=False)) #反向排序
       col2      col1
6 -1.124588 -0.255081
4 -0.717269 -0.720635
3  0.975299 -0.728140
2 -0.220290 -0.824135
1 -1.603360 -0.835863

按列排序

In[93]: print(unsorted_df.sort_index(axis=1))
       col1      col2
1 -0.835863 -1.603360
4 -0.720635 -0.717269
6 -0.255081 -1.124588
2 -0.824135 -0.220290
3 -0.728140  0.975299

按值排序

In[94]: print(unsorted_df.sort_values(by='col1'))
       col2      col1
1 -1.603360 -0.835863
2 -0.220290 -0.824135
3  0.975299 -0.728140
4 -0.717269 -0.720635
6 -1.124588 -0.255081
In[96]: print(unsorted_df.sort_values(by=['col1','col2'])) #先按col1排序，col1值相同时，按照col2排序
       col2      col1
1 -1.603360 -0.835863
2 -0.220290 -0.824135
3  0.975299 -0.728140
4 -0.717269 -0.720635
6 -1.124588 -0.255081

字符串和文本数据

编号	函数	描述
1	lower()	将Series/Index中的字符串转换为小写。
2	upper()	将Series/Index中的字符串转换为大写。
3	len()	计算字符串长度。
4	strip()	帮助从两侧的系列/索引中的每个字符串中删除空格(包括换行符)。
5	split(' ')	用给定的模式拆分每个字符串。
6	cat(sep=' ')	使用给定的分隔符连接系列/索引元素。
7	get_dummies()	返回具有单热编码值的数据帧(DataFrame)。
8	contains(pattern)	如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False。
9	replace(a,b)	将值a替换为值b。
10	repeat(value)	重复每个元素指定的次数。
11	count(pattern)	返回模式中每个元素的出现总数。
12	startswith(pattern)	如果系列/索引中的元素以模式开始，则返回true。
13	endswith(pattern)	如果系列/索引中的元素以模式结束，则返回true。
14	find(pattern)	返回模式第一次出现的位置。
15	findall(pattern)	返回模式的所有出现的列表。
16	swapcase	变换字母大小写。
17	islower()	检查系列/索引中每个字符串中的所有字符是否小写，返回布尔值
18	isupper()	检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值
19	isnumeric()	检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值。

示例

In[161]: print(df1)
       c1        c2      col3
apple   a  0.278656  1.172339
banana  B  0.355114 -1.034259
durian  C -0.987445 -0.598795
3       D  0.081066  1.014804
4       e  2.106214 -0.722732
5       f  0.018380  1.453138
In[162]: print(df1['c1'].str.lower())
apple     a
banana    b
durian    c
3         d
4         e
5         f
Name: c1, dtype: object

缺失值

In[165]: df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
    ...: 'h'],columns=['one', 'two', 'three'])
    ...: 
    ...: df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
    ...: 
    ...: print (df)
        one       two     three
a -0.882456  0.591886 -0.696753
b       NaN       NaN       NaN
c  0.674265  0.542562 -1.987910
d       NaN       NaN       NaN
e  1.220943  0.368924  2.119967
f  0.663993  1.373907 -2.186622
g       NaN       NaN       NaN
h -0.019313  0.016706  0.731410

检测

In[166]: print(df.isnull())
     one    two  three
a  False  False  False
b   True   True   True
c  False  False  False
d   True   True   True
e  False  False  False
f  False  False  False
g   True   True   True
h  False  False  False
In[167]: print(df.notnull())
     one    two  three
a   True   True   True
b  False  False  False
c   True   True   True
d  False  False  False
e   True   True   True
f   True   True   True
g  False  False  False
h   True   True   True

替换

In[169]: print(df.fillna(0)) #将NaN替换为0
        one       two     three
a -0.882456  0.591886 -0.696753
b  0.000000  0.000000  0.000000
c  0.674265  0.542562 -1.987910
d  0.000000  0.000000  0.000000
e  1.220943  0.368924  2.119967
f  0.663993  1.373907 -2.186622
g  0.000000  0.000000  0.000000
h -0.019313  0.016706  0.731410
In[170]: print(df.fillna(method='pad')) # 用前一个数字填充
        one       two     three
a -0.882456  0.591886 -0.696753
b -0.882456  0.591886 -0.696753
c  0.674265  0.542562 -1.987910
d  0.674265  0.542562 -1.987910
e  1.220943  0.368924  2.119967
f  0.663993  1.373907 -2.186622
g  0.663993  1.373907 -2.186622
h -0.019313  0.016706  0.731410
In[171]: print(df.fillna(method='bfill')) # 用后一个数字填充
        one       two     three
a -0.882456  0.591886 -0.696753
b  0.674265  0.542562 -1.987910
c  0.674265  0.542562 -1.987910
d  1.220943  0.368924  2.119967
e  1.220943  0.368924  2.119967
f  0.663993  1.373907 -2.186622
g -0.019313  0.016706  0.731410
h -0.019313  0.016706  0.731410

丢弃

In[172]: print(df.dropna())
        one       two     three
a -0.882456  0.591886 -0.696753
c  0.674265  0.542562 -1.987910
e  1.220943  0.368924  2.119967
f  0.663993  1.373907 -2.186622
h -0.019313  0.016706  0.731410
In[173]: print(df.dropna(axis=1))
Empty DataFrame
Columns: []
Index: [a, b, c, d, e, f, g, h]

替换

In[182]: print(df)
    one   two
0    10  1000
1    20     0
2    30    30
3    40    40
4    50    50
5  2000    60
In[183]: print (df.replace({1000:10,2000:60}))
   one  two
0   10   10
1   20    0
2   30   30
3   40   40
4   50   50
5   60   60

分组

In[218]: ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
    ...:          'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
    ...:          'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
    ...:          'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
    ...:          'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
    ...: df = pd.DataFrame(ipl_data)
In[219]: print(df)
    Points  Rank    Team  Year
0      876     1  Riders  2014
1      789     2  Riders  2015
2      863     2  Devils  2014
3      673     3  Devils  2015
4      741     3   Kings  2014
5      812     4   kings  2015
6      756     1   Kings  2016
7      788     1   Kings  2017
8      694     2  Riders  2016
9      701     4  Royals  2014
10     804     1  Royals  2015
11     690     2  Riders  2017

按列分组

In[221]: grouped = df.groupby("Year")
In[222]: print(grouped)

In[223]: print(grouped.groups)
{2014: Int64Index([0, 2, 4, 9], dtype='int64'), 2015: Int64Index([1, 3, 5, 10], dtype='int64'), 2016: Int64Index([6, 8], dtype='int64'), 2017: Int64Index([7, 11], dtype='int64')}
In[224]: for name, group in grouped: # 默认情况下，group对象具有与分组相同的标签名称
    ...:     print(name)
    ...:     print(group)
    ...:     
2014
   Points  Rank    Team  Year
0     876     1  Riders  2014
2     863     2  Devils  2014
4     741     3   Kings  2014
9     701     4  Royals  2014
2015
    Points  Rank    Team  Year
1      789     2  Riders  2015
3      673     3  Devils  2015
5      812     4   kings  2015
10     804     1  Royals  2015
2016
   Points  Rank    Team  Year
6     756     1   Kings  2016
8     694     2  Riders  2016
2017
    Points  Rank    Team  Year
7      788     1   Kings  2017
11     690     2  Riders  2017

In[6]: grouped2 = df.groupby(['Team','Year']) #按多列分组

获取一个分组

In[7]: grouped = df.groupby('Year')
In[8]: print (grouped.get_group(2014))
   Points  Rank    Team  Year
0     876     1  Riders  2014
2     863     2  Devils  2014
4     741     3   Kings  2014
9     701     4  Royals  2014

聚合

In[9]: grouped = df.groupby('Year')
In[10]: print (grouped['Points'].agg(np.mean))  # 计算不同分组中Points列的均值
Year
2014    795.25
2015    769.50
2016    725.00
2017    739.00
Name: Points, dtype: float64
In[11]: print (grouped.agg(np.size)) # 查看每个分组的大小
      Points  Rank  Team
Year                    
2014       4     4     4
2015       4     4     4
2016       2     2     2
2017       2     2     2
In[13]: print (grouped['Points'].agg([np.mean,np.sum,np.std]))  # 一次使用多个聚合函数
        mean   sum        std
Year                         
2014  795.25  3181  87.439026
2015  769.50  3078  65.035888
2016  725.00  1450  43.840620
2017  739.00  1478  69.296465
In[21]: print(grouped.get_group(2014)['Points'].agg([np.mean,np.sum])) #特异计算2014的属性
mean     795.25
sum     3181.00
Name: Points, dtype: float64

转换

In[30]: grouped = df.groupby("Year")
In[31]: score = lambda x: (x - x.mean()) / x.std()*10
In[32]: print (grouped.transform(score))
       Points       Rank
0    9.235007 -11.618950
1    2.998345  -3.872983
2    7.748256  -3.872983
3  -14.837962   3.872983
4   -6.204323   3.872983
5    6.534854  11.618950
6    7.071068  -7.071068
7    7.071068  -7.071068
8   -7.071068   7.071068
9  -10.778940  11.618950
10   5.304763 -11.618950
11  -7.071068   7.071068

过滤

In[34]: print(df.groupby('Year').size())
Year
2014    4
2015    4
2016    2
2017    2
dtype: int64
In[35]: filter = df.groupby("Year").filter(lambda x:len(x)>=3) # 只保留数目大于3的对象
In[36]: print(filter)
    Points  Rank    Team  Year
0      876     1  Riders  2014
1      789     2  Riders  2015
2      863     2  Devils  2014
3      673     3  Devils  2015
4      741     3   Kings  2014
5      812     4   kings  2015
9      701     4  Royals  2014
10     804     1  Royals  2015

合并

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True)

• left - 一个DataFrame对象。
• right - 另一个DataFrame对象。
• on - 列(名称)连接，必须在左和右DataFrame对象中存在(找到)。
• left_on - 左侧DataFrame中的列用作键，可以是列名或长度等于DataFrame长度的数组。
• right_on - 右侧DataFrame的列作为键，可以是列名或长度等于DataFrame长度的数组。
• left_index - 如果为True，则使用左侧DataFrame中的索引(行标签)作为其连接键。 在具有MultiIndex(分层)的DataFrame的情况下，级别的数量必须与来自右DataFrame的连接键的数量相匹配。
• right_index - 与右DataFrame的left_index具有相同的用法。
• how - 它是left, right, outer以及inner之中的一个，默认为内inner。 下面将介绍每种方法的用法。
• sort - 按照字典顺序通过连接键对结果DataFrame进行排序。默认为True，设置为False时，在很多情况下大大提高性能。

In[47]: print(left)
     Name  id subject_id
0    Alex   1       sub1
1     Amy   2       sub2
2   Allen   3       sub4
3   Alice   4       sub6
4  Ayoung   5       sub5
In[48]: print(right)
    Name  id subject_id
0  Billy   1       sub2
1  Brian   2       sub4
2   Bran   3       sub3
3  Bryce   4       sub6
4  Betty   5       sub5
In[50]: print(pd.merge(left,right,on=['id','subject_id']))
   Name_x  id subject_id Name_y
0   Alice   4       sub6  Bryce
1  Ayoung   5       sub5  Betty
In[52]: print(pd.merge(left,right,on=['id','subject_id'],how='left')) # 输出左侧dataframe的所有内容,右侧没有的话用NaN替代
   Name_x  id subject_id Name_y
0    Alex   1       sub1    NaN
1     Amy   2       sub2    NaN
2   Allen   3       sub4    NaN
3   Alice   4       sub6  Bryce
4  Ayoung   5       sub5  Betty
In[53]: print(pd.merge(left,right,on=['id','subject_id'],how='right')) # 输出右侧dataframe的所有内容
   Name_x  id subject_id Name_y
0   Alice   4       sub6  Bryce
1  Ayoung   5       sub5  Betty
2     NaN   1       sub2  Billy
3     NaN   2       sub4  Brian
4     NaN   3       sub3   Bran
In[54]: print(pd.merge(left,right,on=['id','subject_id'],how='outer')) # 输出两个dataframe的所有内容
   Name_x  id subject_id Name_y
0    Alex   1       sub1    NaN
1     Amy   2       sub2    NaN
2   Allen   3       sub4    NaN
3   Alice   4       sub6  Bryce
4  Ayoung   5       sub5  Betty
5     NaN   1       sub2  Billy
6     NaN   2       sub4  Brian
7     NaN   3       sub3   Bran
In[55]: print(pd.merge(left,right,on=['id','subject_id'],how='inner'))  # 默认为inner
   Name_x  id subject_id Name_y
0   Alice   4       sub6  Bryce
1  Ayoung   5       sub5  Betty

数据读取

常规文本

pandas.read_csv(filepath_or_buffer, sep=',', delimiter=None, header='infer',
names=None, index_col=None, usecols=None)

pandas.read_table(filepath_or_buffer, sep='\t', delimiter=None, header='infer',
names=None, index_col=None, usecols=None)

filepath_or_buffer:文件路径

sep: str, 分隔符

delimiter: str, 定界符，备选分隔符（设置该参数，sep失效）

header: int or list of ints, 指定行数用来作为列名

names: array-like, 对格列重命名，如果数据有表头，但想用新表头，可以设置header=0,names=['a','b']实现表头重制

index_col: int or sequence or False, 用作行索引的列编号或列名，可以通过index_col=[0,1]来指定文件第1列和第2列作为索引

usecols: array-like, 返回一个数据子集，即选取某几列，不读取整个文件，usecols=[1,2] or usecols=['a','b']

squeeze: boolean, default False, 如果文件只包含一列，则返回一个Series

prefix : str, default None, 在没有列标题时，给列添加前缀。例如：添加‘X’ 成为 X0, X1, ...

mangle_dupe_cols : boolean, default True, 重复的列，将‘X’...’X’表示为‘X.0’...’X.N’。如果设定为False则会将所有重名列覆盖。

skiprows : list-like or integer, default None,需要忽略的行数（从文件开始处算起），或需要跳过的行号列表（从0开始）。
nrows : int, default None,需要读取的行数（从文件头开始算起）。
skip_blank_lines :boolean, default True,如果为True，则跳过空行；否则记为NaN。

In[67]: df = pd.read_table("test_data.txt") # 默认第一行作为列名，索引为新生成的编号
In[68]: print(df)
     gene_id  ERR1698194  ERR1698195  ERR1698196
0  AT1G01010          21          58          24
1  AT1G01020         429         603         675
2  AT1G01030          10          32         187
3  AT1G01040        1237        2061        1376
4  AT1G01050         406         502         122
5  AT1G01060           0         274          41
In[71]: df = pd.read_table("test_data.txt",header=1)
In[72]: print(df)
   AT1G01010    21    58    24
0  AT1G01020   429   603   675
1  AT1G01030    10    32   187
2  AT1G01040  1237  2061  1376
3  AT1G01050   406   502   122
4  AT1G01060     0   274    41
In[73]: df = pd.read_table("test_data.txt",header=None) # 不设置表头
In[74]: print(df)
           0           1           2           3
0    gene_id  ERR1698194  ERR1698195  ERR1698196
1  AT1G01010          21          58          24
2  AT1G01020         429         603         675
3  AT1G01030          10          32         187
4  AT1G01040        1237        2061        1376
5  AT1G01050         406         502         122
6  AT1G01060           0         274          41
In[89]: df = pd.read_table("test_data.txt",names=['a','b','c','d']) # 自定义表头，保留原来的第一行内容
In[90]: print(df)
           a           b           c           d
0    gene_id  ERR1698194  ERR1698195  ERR1698196
1  AT1G01010          21          58          24
2  AT1G01020         429         603         675
3  AT1G01030          10          32         187
4  AT1G01040        1237        2061        1376
5  AT1G01050         406         502         122
6  AT1G01060           0         274          41
In[91]: df = pd.read_table("test_data.txt",names=['a','b','c','d'],header=1) # 自定以表头，并跳过header指定的前面行
In[92]: print(df)
           a     b     c     d
0  AT1G01020   429   603   675
1  AT1G01030    10    32   187
2  AT1G01040  1237  2061  1376
3  AT1G01050   406   502   122
4  AT1G01060     0   274    41
In[77]: df = pd.read_table("test_data.txt",index_col=[0])
In[78]: print(df)
           ERR1698194  ERR1698195  ERR1698196
gene_id                                      
AT1G01010          21          58          24
AT1G01020         429         603         675
AT1G01030          10          32         187
AT1G01040        1237        2061        1376
AT1G01050         406         502         122
AT1G01060           0         274          41
In[87]: df = pd.read_table("test_data.txt",index_col=['gene_id'])
In[88]: print(df)
           ERR1698194  ERR1698195  ERR1698196
gene_id                                      
AT1G01010          21          58          24
AT1G01020         429         603         675
AT1G01030          10          32         187
AT1G01040        1237        2061        1376
AT1G01050         406         502         122
AT1G01060           0         274          41
In[79]: df = pd.read_table("test_data.txt",index_col=[0,1]) # 用前两列作为行索引
In[80]: print(df)
                      ERR1698195  ERR1698196
gene_id   ERR1698194                        
AT1G01010 21                  58          24
AT1G01020 429                603         675
AT1G01030 10                  32         187
AT1G01040 1237              2061        1376
AT1G01050 406                502         122
AT1G01060 0                  274          41

excel

read_excel(io, sheetname=0, header=0, skiprows=None, skip_footer=0, index_col=None,names=None, parse_cols=None, parse_dates=False,date_parser=None,na_values=None,thousands=None, convert_float=True, has_index_names=None, converters=None,dtype=None, true_values=None, false_values=None, engine=None, squeeze=False, **kwds)

• io : string, path object ; excel 路径。
• sheetname : string, int, mixed list of strings/ints, or None, default 0 返回多表使用sheetname=[0,1],若sheetname=None是返回全表 注意：int/string 返回的是dataframe，而none和list返回的是dict of dataframe
• header : int, list of ints, default 0 指定列名行，默认0，即取第一行，数据为列名行以下的数据 若数据不含列名，则设定 header = None
• skiprows : list-like,Rows to skip at the beginning，省略指定行数的数据
• skip_footer : int,default 0, 省略从尾部数的int行数据
• index_col : int, list of ints, default None指定列为索引列，也可以使用u”strings”
• names : array-like, default None, 指定列的名字。

输出

DataFrame.to_csv(path_or_buf=None, sep=', ', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, mode='w', encoding=None, compression=None, quoting=None, quotechar='"', line_terminator='\n', chunksize=None, tupleize_cols=None, date_format=None, doublequote=True, escapechar=None, decimal='.')

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)

na_rep，缺失值填充

mode='w'，表示写入，同名文件直接覆盖；'a'表示追加