参考：
大致命令
- 创建 DataFrame
- 文件读取得到DataFrame
- 创建和重设 index
- 读取、添加、删除列和行
- 设置列名
- 排序
- 基本属性和方法
- 条件选择，查询函数 query
- 组合函数 merge，合并contact
- groupby 函数
创建Dataframe
pandas.DataFrame( data, index, columns, dtype, copy)
参数说明
data： 支持多种数据类型，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
index： 行标签，如果没有传递索引值，默认值为np.arrange(n)
columns： 列标签，如果没有传递索引值，默认值为np.arrange(n)
dtype： 每列的数据类型。
copy： 是否复制数据，默认值为False
DataFrame的data支持多种输入类型来创建
- 列表（list）
- 字典（dict)
- 系列（series)
- Numpy ndarrays
- DataFrame
list创建示例
import pandas as pd
df1 = pd.DataFrame([['Alex',10],['Bob',12],['Clarke',13]],columns=['Name','Age'])
df2 = pd.DataFrame(np.arange(12).reshape(3, 4), columns=list('ABCD'))
print('df1','\n',df1)
print('\n') #换行
print('df2','\n',df2)
执行结果如下:
df1
Name Age
0 Alex 10
1 Bob 12
2 Clarke 13
df2
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
字典创建示例(特别适用用MultiIndex的情况，因为要给index的列命名这个操作我一直失败。
一般情况，不指定索引会自动创建索引
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print (df)
执行结果如下:
Name Age
0 Tom 28
1 Jack 34
2 Steve 29
3 Ricky 42
单索引情况下
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print (df)
执行结果如下:
Name Age
rank1 Tom 28
rank2 Jack 34
rank3 Steve 29
rank4 Ricky 42
MutiIndex的情况下：
df = pd.DataFrame(np.random.randint(80, 120, size=(4, 2)),
columns= ['girl', 'boy'],
index=pd.MultiIndex.from_product([['English','Chinese'],
['like','dislike']]))
print(df) # 创建多级行索引
执行结果如下:
girl boy
English like 114 118
dislike 83 119
Chinese like 91 80
dislike 91 96
PS：我一直试图想找到设置索引的名字，一直失败，最后只能先将索引的那一列设为普通列，然后通过df.set_index()的操作实现。如果该问题解决了再补充。
#先创建不指定索引的DataFrame
df = pd.DataFrame(data = [[83, 82,'English','like'],
[99, 92,'English','like'],
[81, 91,'Chinese','dislike'],
[97, 94,'Chinese','dislike']],
columns= ['girl', 'boy','course','attitude'])
print(df)
print('\n')
#再设置索引行
df.set_index(['course','attitude'],inplace = True)
print(df)
运行结果
girl boy course attitude
0 83 82 English like
1 99 92 English like
2 81 91 Chinese dislike
3 97 94 Chinese dislike
girl boy
course attitude
English like 83 82
like 99 92
Chinese dislike 81 91
dislike 97 94
文件读取得到DataFrame
df = pd.read_csv(path='file.csv') #csv文件个数
df = pd.read_txt(path='file.txt') #txt文件格式
df = pd.read_pickle(path='file.pkl') #pkl文件格式
参数：header=None 用默认列名，0，1，2，3...
names=['A', 'B', 'C'...] 自定义列名
index_col='A'|['A', 'B'...] 给索引列指定名称，如果是多重索引，可以传list
skiprows=[0,1,2] 需要跳过的行号，从文件头0开始，skip_footer从文件尾开始
nrows=N 需要读取的行数，前N行
chunksize=M 返回迭代类型TextFileReader，每M条迭代一次，数据占用较大内存时使用
sep=':'数据分隔默认是','，根据文件选择合适的分隔符，如果不指定参数，会自动解析
skip_blank_lines=False 默认为True，跳过空行，如果选择不跳过，会填充NaN
converters={'col1', func} 对选定列使用函数func转换，通常表示编号的列会使用（避免转换成int）
dfjs = pd.read_json('file.json') 可以传入json格式字符串
dfex = pd.read_excel('file.xls', sheetname=[0,1..]) 读取多个sheet页，返回多个df的字典
创建和重设 index
- 创建 df.set_index( )
- 重设 df.reset_index( )
注意1：可以用df = df.set_index(['age']）或者用df.set_index(['age',inplace = True],切记不能直接df.set_index( )
inplace 的默认值是False
注意2：如果本身没有指定index的DataFrame，使用reset_index之后，会将默认的0，1，2，3...这个index列变成新列。
df = pd.DataFrame(np.arange(20).reshape(5,4),index=[1,3,4,6,8])
print(df)
print('\n')
df2 = df.reset_index()
print(df2)
运行结果：
0 1 2 3
1 0 1 2 3
3 4 5 6 7
4 8 9 10 11
6 12 13 14 15
8 16 17 18 19
index 0 1 2 3
0 1 0 1 2 3
1 3 4 5 6 7
2 4 8 9 10 11
3 6 12 13 14 15
4 8 16 17 18 19
设置列名可以直接用 df.columns = [ ]
df = pd.DataFrame(np.arange(20).reshape(5,4),index=[1,3,4,6,8])
df.columns = ['第1列','第2列','第3列','第4列']
df = df.set_index(['第1列'])
print(df)
运行结果：
第2列 第3列 第4列
第1列
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
16 17 18 19
设置双索引 df.set_index([ a, b])
df = pd.DataFrame(np.arange(20).reshape(5,4),index=[1,3,4,6,8])
df.columns = ['第1列','第2列','第3列','第4列']
df = df.set_index(['第1列','第2列'])
print(df)
运行结果：
第3列 第4列
第1列 第2列
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
16 17 18 19
三、读取、添加、删除列和行
| 操作 | 行 | 列 |
|---|---|---|
| 读取 | df.loc['a'], df.iloc[1], df.iloc[1:3] | df['a'], df[1] |
| 添加 | df.append() | df['a'] = data |
| 删除 | df.drop(1), df.drop('a') | del df['a'], df.pop('a'), df.drop(['a'], axis = 1) |
读取列 df['a']
添加列 df['a'] = data (data 可以是list，也可以是series）
import pandas as pd
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)
print(df)
# Adding a new column to an existing DataFrame object with column label by passing new series
print ("Adding a new column by passing as Series:")
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print (df)
print ("Adding a new column using the existing columns in DataFrame:")
df['four']=df['one']+df['three']
print (df)
运行结果：
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
Adding a new column by passing as Series:
one two three
a 1.0 1 10.0
b 2.0 2 20.0
c 3.0 3 30.0
d NaN 4 NaN
Adding a new column using the existing columns in DataFrame:
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaN
删除列
- del df['a']
- df.pop('a')
- df.drop(['a'], axis = 1) ，axis默认值是1，如果删除行axis=0
import pandas as pd
d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),
'two' : pd.Series([111, 222, 333], index=['a', 'b', 'c']),
'three' : pd.Series([10,20,30], index=['a','b','c']),
'four' : pd.Series([11,22,33], index=['a','b','c'])}
df = pd.DataFrame(d)
print ("Our dataframe is:")
print (df)
print('\n')
# using del function
del df['one']
print (df)
print('\n')
# using pop function
df.pop('two')
print (df)
print('\n')
# using drop function
df.drop('three',axis =1)
print('df.drop效果')
print(df) #没有df,drop函数也有inplace，默认是False
print('\n')
df = df.drop('three',axis =1)
print('df.drop(,inplace = True)或者 df = df.drop()效果')
print(df)
运行结果：
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
[RangeIndex(start=0, stop=3, step=1), Index(['A', 'B', 'C', 'D'], dtype='object')]
Name Age
0 Alex 10
1 Bob 12
2 Clarke 13
Our dataframe is:
one two three four
a 1 111 10 11
b 2 222 20 22
c 3 333 30 33
two three four
a 111 10 11
b 222 20 22
c 333 30 33
three four
a 10 11
b 20 22
c 30 33
df.drop效果,没删成功
three four
a 10 11
b 20 22
c 30 33
df.drop(,inplace = True)或者 df = df.drop()效果
four
a 11
b 22
c 33
runfile('D:/Milan_Tech/My RUL paper 2 基于状态的RUL/untitled0.py', wdir='D:/Milan_Tech/My RUL paper 2 基于状态的RUL')
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
[RangeIndex(start=0, stop=3, step=1), Index(['A', 'B', 'C', 'D'], dtype='object')]
Name Age
0 Alex 10
1 Bob 12
2 Clarke 13
Our dataframe is:
one two three four
a 1 111 10 11
b 2 222 20 22
c 3 333 30 33
two three four
a 111 10 11
b 222 20 22
c 333 30 33
three four
a 10 11
b 20 22
c 30 33
df.drop效果，没删成功
three four
a 10 11
b 20 22
c 30 33
df.drop(,inplace = True)或者 df = df.drop()效果
four
a 11
b 22
c 33
读取行
- 按索引读取 df.loc['a']
- 按位置读取 df.iloc[2]
- 按切片选择 df[2:4]
import pandas as pd
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)
print('数据：','\n',df,'\n')
print ('按索引读取：','\n',df.loc['b'],'\n') #索引为b的行
print('按位置读取','\n',df.iloc[2],'\n') #第二行
print('切片读取','\n',df[2:4],'\n') #第二行,第三行
print('切片读取','\n',df[:4],'\n') #从第一行到第三行
运行结果
数据：
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
按索引读取：
one 2.0
two 2.0
Name: b, dtype: float64
按位置读取
one 3.0
two 3.0
Name: c, dtype: float64
切片读取
one two
c 3.0 3
d NaN 4
切片读取
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
添加行 df.append()
该操作与list.append()相似
注意：索引是保留原来的索引，所以会存在重复索引的情况，可以通过ignore_index= True来重置索引。或者采用df = df.reset_index().drop('index',axis =1)来更新索引（此方法较为复杂）。
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df3 = df.append(df2)
print(df)
df3 = df3.reset_index().drop('index',axis =1)
print('更新索引笨方法：','\n',df3)
df4 = df.append(df2,ignore_index = True)
print('更新索引ignore_index：','\n',df4)
运行结果：
a b
0 1 2
1 3 4
更新索引笨方法：
a b
0 1 2
1 3 4
2 5 6
3 7 8
更新索引ignore_index：
a b
0 1 2
1 3 4
2 5 6
3 7 8
删除行
- 默认索引删除 df.drop(1) --- 删除第二行
- 特定索引删除 df.drop('a') --- 删除索引为‘a’的一行
因为axis默认值是0，所以可以不用写。
import pandas as pd
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)
print('数据：','\n',df,'\n')
print('按索引名称删除','\n',df.drop('a'))
df = df.reset_index() #重置索引
print(df)
print('按索引号删除','\n',df.drop(1))
运行结果：
数据：
one two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
按索引名称删除
one two
b 2.0 2
c 3.0 3
d NaN 4
index one two
0 a 1.0 1
1 b 2.0 2
2 c 3.0 3
3 d NaN 4
按索引号删除
index one two
0 a 1.0 1
2 c 3.0 3
3 d NaN 4
PS：当索引重复时，都会被删除
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print (df)
print('索引重复情况，都会被删除,比如删除第二行')
print(df.drop(1))
运行结果：
a b
0 1 2
1 3 4
0 5 6
1 7 8
索引重复情况，都会被删除,比如删除第二行
a b
0 1 2
0 5 6
设置列名
df.columns()可以查看列名
设置列名 df.columns = ['a','b','c']
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]])
print('原数据：','\n',df)
df.columns = ['a','b']
print('有列名之后：','\n',df)
print(df.columns)
运行结果：
原数据：
0 1
0 1 2
1 3 4
有列名之后：
a b
0 1 2
1 3 4
Index(['a', 'b'], dtype='object')
排序
- 按索引排序 df.sort_index(axis = 0, ascending = True)
- 按值排序 df.sort_value(by = 'col1', ascending = True)
用permutation()函数创建一个顺序随机的整数数组，我们按照这个数组元素的顺序为DataFrame对象进行行排序，对DataFrame对象的所有行应用take()函数，把新的次序传给它。
import pandas as pd
import numpy as np
unsorted_df=pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],
columns=['col1','col2'])
print(unsorted_df)
运行结果：
col1 col2
1 1.233648 1.581921
4 -1.879616 1.385566
6 -0.504561 -2.248236
2 -0.199065 -0.731196
3 0.474318 -1.033490
5 0.573251 0.917004
9 0.449595 0.357354
8 0.175755 -2.331086
0 -1.941363 -0.169827
7 0.234169 -0.047134
按标签index排序
使用sort_index()方法，通过传递axis参数和排序顺序，可以对DataFrame进行排序。 默认情况下，按照升序对行标签进行排序， ascending = True。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7])
print('原数据','\n',unsorted_df)
sorted_df1=unsorted_df.sort_index() #按index降序排列
print('按index升序排列','\n',sorted_df1)
sorted_df2=unsorted_df.sort_index(ascending = False) #按index降序排列
print('按index降序排列','\n',sorted_df2)
sorted_df=sorted_df1.sort_index(axis = 1, ascending = False)
print('按columns降序排列','\n',sorted_df)
运行结果：
原数据
0 1
1 -0.038716 -0.217279
4 0.160955 -1.506193
6 0.117772 1.515944
2 -0.747355 0.009414
3 1.638067 -0.739558
5 0.092901 0.786846
9 1.176006 -1.376119
8 0.064374 0.911368
0 0.140495 1.618283
7 -1.722743 1.260330
按index升序排列
0 1
0 0.140495 1.618283
1 -0.038716 -0.217279
2 -0.747355 0.009414
3 1.638067 -0.739558
4 0.160955 -1.506193
5 0.092901 0.786846
6 0.117772 1.515944
7 -1.722743 1.260330
8 0.064374 0.911368
9 1.176006 -1.376119
按index降序排列
0 1
9 1.176006 -1.376119
8 0.064374 0.911368
7 -1.722743 1.260330
6 0.117772 1.515944
5 0.092901 0.786846
4 0.160955 -1.506193
3 1.638067 -0.739558
2 -0.747355 0.009414
1 -0.038716 -0.217279
0 0.140495 1.618283
按columns降序排列
1 0
0 1.618283 0.140495
1 -0.217279 -0.038716
2 0.009414 -0.747355
3 -0.739558 1.638067
4 -1.506193 0.160955
5 0.786846 0.092901
6 1.515944 0.117772
7 1.260330 -1.722743
8 0.911368 0.064374
9 -1.376119 1.176006
按值排序
通过传递axis参数值为0或1，可以对列标签进行排序。 默认情况下，axis = 0，逐行排列。来看看下面的例子来理解这个概念。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,5],'col2':[1,3,2,4]})
print('原数据','\n',unsorted_df)
sorted_df = unsorted_df.sort_values(by='col1',ascending = True) #按col1 升序
print('排序后','\n',sorted_df)
运行结果：
原数据
col1 col2
0 2 1
1 1 3
2 1 2
3 5 4
排序后
col1 col2
1 1 3
2 1 2
0 2 1
3 5 4
注意： 观察上面的输出结果，col1值被排序，相应的col2值和行索>引将随col1一起改变。
按照某两列排序
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,4,1],'col2':[1,7,2,4],'col3':[5,9,7,1]})
print('原数据','\n',unsorted_df)
sorted_df = unsorted_df.sort_values(by=['col1'])
print('单列排序后','\n',sorted_df)
sorted_df = unsorted_df.sort_values(by=['col1','col2'])
print('双列排序后','\n',sorted_df)
运行结果：
原数据
col1 col2 col3
0 2 1 5
1 1 7 9
2 4 2 7
3 1 4 1
单列排序后
col1 col2 col3
1 1 7 9
3 1 4 1
0 2 1 5
2 4 2 7
双列排序后
col1 col2 col3
3 1 4 1
1 1 7 9
0 2 1 5
2 4 2 7
注意：对比第一行和第二行，如果至少按照单列排序，那么对于排序列的相同值，他们按照本身索引（也就是本身出现的顺序）排序。但是若是双列的时候，出现第一列值相同的情况，会对第二列的值比较，进行排序。
基本属性和方法
Pandas DataFrame 属性和方法
数学统计
sr.unique Series去重
sr.value_counts() Series统计频率，并从大到小排序，DataFrame没有这个方法
sr.describe() 返回基本统计量和分位数
df.describe() 按各列返回基本统计量和分位数
df.count() 求非NA值得数量
df.max() 求最大值
df.min() 求最大值
df.sum(axis=0) 按各列求和
df.mean() 按各列求平均值
df.median() 求中位数
df.var() 求方差
df.std() 求标准差
df.mad() 根据平均值计算平均绝对利差
df.cumsum() 求累计和
sr1.corr(sr2) 求相关系数
df.cov() 求协方差矩阵
df1.corrwith(df2) 求相关系数
pd.cut(array1, bins) 求一维数据的区间分布
pd.qcut(array1, 4) 按指定分位数进行区间划分，4可以替换成自定义的分位数列表
df['col1'].groupby(df['col2']) 列1按照列2分组，即列2作为key
df.groupby('col1') DataFrame按照列1分组
grouped.aggreagte(func) 分组后根据传入函数来聚合
grouped.aggregate([f1, f2,...]) 根据多个函数聚合，表现成多列，函数名为列名
grouped.aggregate([('f1_name', f1), ('f2_name', f2)]) 重命名聚合后的列名
grouped.aggregate({'col1':f1, 'col2':f2,...}) 对不同的列应用不同函数的聚合，函数也可以是多个
df.pivot_table(['col1', 'col2'],
rows=['row1', 'row2'],
aggfunc=[np.mean, np.sum]
fill_value=0,
margins=True) 根据row1, row2对col1， col2做分组聚合，聚合方法可以指定多种，并用指定值替换缺省值
pd.crosstab(df['col1'], df['col2']) 交叉表，计算分组的频率
条件选择，查询函数 query
- df[df['a'>1]
- df.query('a>1')
注意这里的标点符号，query的时候，条件是全部放在引号里面的
取出‘HDBScan’为列名的一列
data_0 = df[df['HDBScan'] == 0]
data_0 = df.query('HDBSCAN==0')
df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=list('ABCD'))
print(df)
a = df.query('A>2')
b = df[df['A']>2]
print('限定条件结果：','\n',a)
print(a.equals(b))
运行结果：
A B C D
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
限定条件结果：
A B C D
1 4 5 6 7
2 8 9 10 11
True
组合函数 merge，合并contact，append
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])
#concat纵向合并
res = pd.concat([df1, df2, df3], axis=0)
print('concat纵向合并','\n',res)
res = pd.concat([df1, df2, df3], axis=0, ignore_index=True) #索引重置
print('concat纵向合并且索引重置','\n',res)
#concat横向合并
res = pd.concat([df1, df2, df3], axis=1)
print('concat横向合并','\n',res)
运行结果：
concat纵向合并
a b c d
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
0 1.0 1.0 1.0 1.0
1 1.0 1.0 1.0 1.0
2 1.0 1.0 1.0 1.0
0 2.0 2.0 2.0 2.0
1 2.0 2.0 2.0 2.0
2 2.0 2.0 2.0 2.0
concat纵向合并且索引重置
a b c d
0 0.0 0.0 0.0 0.0
1 0.0 0.0 0.0 0.0
2 0.0 0.0 0.0 0.0
3 1.0 1.0 1.0 1.0
4 1.0 1.0 1.0 1.0
5 1.0 1.0 1.0 1.0
6 2.0 2.0 2.0 2.0
7 2.0 2.0 2.0 2.0
8 2.0 2.0 2.0 2.0
concat横向合并
a b c d a b c d a b c d
0 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
1 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 2.0 2.0 2.0 2.0
注意：纵向合并的时候，索引并不会改变，还是保留各自的原索引。若是要索引重置，用ignore_index=True。
join
| join 取值 | 对应操作 |
|---|---|
| join = 'out' | 用NaN补充columns没有的位置 |
| join = 'inner' | 只保留两个df相同的columns |
join='outer'为预设值，因此未设定任何参数时，函数默认join='outer'。此方式是依照column来做纵向合并，有相同的column上下合并在一起，其他独自的column个自成列，原本没有值的位置皆以NaN填充。
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
#纵向"外"合并df1与df2
res = pd.concat([df1, df2], axis=0, join='outer')
print(res)
# a b c d e
# 1 0.0 0.0 0.0 0.0 NaN
# 2 0.0 0.0 0.0 0.0 NaN
# 3 0.0 0.0 0.0 0.0 NaN
# 2 NaN 1.0 1.0 1.0 1.0
# 3 NaN 1.0 1.0 1.0 1.0
# 4 NaN 1.0 1.0 1.0 1.0
join='inner'，只有相同的column合并在一起，其他的会被抛弃。
#承上一个例子
#纵向"内"合并df1与df2
res = pd.concat([df1, df2], axis=0, join='inner')
#打印结果
print(res)
# b c d
# 1 0.0 0.0 0.0
# 2 0.0 0.0 0.0
# 3 0.0 0.0 0.0
# 2 1.0 1.0 1.0
# 3 1.0 1.0 1.0
# 4 1.0 1.0 1.0
#重置index并打印结果
res = pd.concat([df1, df2], axis=0, join='inner', ignore_index=True)
print(res)
# b c d
# 0 0.0 0.0 0.0
# 1 0.0 0.0 0.0
# 2 0.0 0.0 0.0
# 3 1.0 1.0 1.0
# 4 1.0 1.0 1.0
# 5 1.0 1.0 1.0
join_axes (依照 axes 合并)
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
#依照`df1.index`进行横向合并
res = pd.concat([df1, df2], axis=1, join_axes=[df1.index])
#打印结果
print(res)
# a b c d b c d e
# 1 0.0 0.0 0.0 0.0 NaN NaN NaN NaN
# 2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
# 3 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
#移除join_axes，并打印结果
res = pd.concat([df1, df2], axis=1)
print(res)
# a b c d b c d e
# 1 0.0 0.0 0.0 0.0 NaN NaN NaN NaN
# 2 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
# 3 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0
# 4 NaN NaN NaN NaN 1.0 1.0 1.0 1.0
append (添加数据)
append只有纵向合并，没有横向合并。这里也就是DataFrame添加行的用法。
import pandas as pd
import numpy as np
#定义资料集
df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
df3 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
s1 = pd.Series([1,2,3,4], index=['a','b','c','d'])
#将df2合并到df1的下面，以及重置index，并打印出结果
res = df1.append(df2, ignore_index=True)
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 3 1.0 1.0 1.0 1.0
# 4 1.0 1.0 1.0 1.0
# 5 1.0 1.0 1.0 1.0
#合并多个df，将df2与df3合并至df1的下面，以及重置index，并打印出结果
res = df1.append([df2, df3], ignore_index=True)
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 3 1.0 1.0 1.0 1.0
# 4 1.0 1.0 1.0 1.0
# 5 1.0 1.0 1.0 1.0
# 6 1.0 1.0 1.0 1.0
# 7 1.0 1.0 1.0 1.0
# 8 1.0 1.0 1.0 1.0
#合并series，将s1合并至df1，以及重置index，并打印出结果
res = df1.append(s1, ignore_index=True)
print(res)
# a b c d
# 0 0.0 0.0 0.0 0.0
# 1 0.0 0.0 0.0 0.0
# 2 0.0 0.0 0.0 0.0
# 3 1.0 2.0 3.0 4.0
merge函数
pandas中的merge和concat类似,但主要是用于两组有key column的数据,统一索引的数据. 通常也被用在Database的处理当中.
依据一组key合并
import pandas as pd
#定义资料集并打印出
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', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
print(left)
# A B key
# 0 A0 B0 K0
# 1 A1 B1 K1
# 2 A2 B2 K2
# 3 A3 B3 K3
print(right)
# C D key
# 0 C0 D0 K0
# 1 C1 D1 K1
# 2 C2 D2 K2
# 3 C3 D3 K3
#依据key column合并，并打印出
res = pd.merge(left, right, on='key')
print(res)
A B key C D
# 0 A0 B0 K0 C0 D0
# 1 A1 B1 K1 C1 D1
# 2 A2 B2 K2 C2 D2
# 3 A3 B3 K3 C3 D3
依据两组key合并
合并时有4种方法how = ['left', 'right', 'outer', 'inner']，预设值how='inner'。
import pandas as pd
#定义资料集并打印出
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
print(left)
# A B key1 key2
# 0 A0 B0 K0 K0
# 1 A1 B1 K0 K1
# 2 A2 B2 K1 K0
# 3 A3 B3 K2 K1
print(right)
# C D key1 key2
# 0 C0 D0 K0 K0
# 1 C1 D1 K1 K0
# 2 C2 D2 K1 K0
# 3 C3 D3 K2 K0
#依据key1与key2 columns进行合并，并打印出四种结果['left', 'right', 'outer', 'inner']
res = pd.merge(left, right, on=['key1', 'key2'], how='inner')
print(res)
# A B key1 key2 C D
# 0 A0 B0 K0 K0 C0 D0
# 1 A2 B2 K1 K0 C1 D1
# 2 A2 B2 K1 K0 C2 D2
res = pd.merge(left, right, on=['key1', 'key2'], how='outer')
print(res)
# A B key1 key2 C D
# 0 A0 B0 K0 K0 C0 D0
# 1 A1 B1 K0 K1 NaN NaN
# 2 A2 B2 K1 K0 C1 D1
# 3 A2 B2 K1 K0 C2 D2
# 4 A3 B3 K2 K1 NaN NaN
# 5 NaN NaN K2 K0 C3 D3
res = pd.merge(left, right, on=['key1', 'key2'], how='left')
print(res)
# A B key1 key2 C D
# 0 A0 B0 K0 K0 C0 D0
# 1 A1 B1 K0 K1 NaN NaN
# 2 A2 B2 K1 K0 C1 D1
# 3 A2 B2 K1 K0 C2 D2
# 4 A3 B3 K2 K1 NaN NaN
res = pd.merge(left, right, on=['key1', 'key2'], how='right')
print(res)
# A B key1 key2 C D
# 0 A0 B0 K0 K0 C0 D0
# 1 A2 B2 K1 K0 C1 D1
# 2 A2 B2 K1 K0 C2 D2
# 3 NaN NaN K2 K0 C3 D3
Indicator
indicator=True会将合并的记录放在新的一列。
import pandas as pd
#定义资料集并打印出
df1 = pd.DataFrame({'col1':[0,1], 'col_left':['a','b']})
df2 = pd.DataFrame({'col1':[1,2,2],'col_right':[2,2,2]})
print(df1)
# col1 col_left
# 0 0 a
# 1 1 b
print(df2)
# col1 col_right
# 0 1 2
# 1 2 2
# 2 2 2
# 依据col1进行合并，并启用indicator=True，最后打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
print(res)
# col1 col_left col_right _merge
# 0 0.0 a NaN left_only
# 1 1.0 b 2.0 both
# 2 2.0 NaN 2.0 right_only
# 3 2.0 NaN 2.0 right_only
# 自定indicator column的名称，并打印出
res = pd.merge(df1, df2, on='col1', how='outer', indicator='indicator_column')
print(res)
# col1 col_left col_right indicator_column
# 0 0.0 a NaN left_only
# 1 1.0 b 2.0 both
# 2 2.0 NaN 2.0 right_only
# 3 2.0 NaN 2.0 right_only
依据index合并
import pandas as pd
#定义资料集并打印出
left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
'B': ['B0', 'B1', 'B2']},
index=['K0', 'K1', 'K2'])
right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
'D': ['D0', 'D2', 'D3']},
index=['K0', 'K2', 'K3'])
print(left)
# A B
# K0 A0 B0
# K1 A1 B1
# K2 A2 B2
print(right)
# C D
# K0 C0 D0
# K2 C2 D2
# K3 C3 D3
#依据左右资料集的index进行合并，how='outer',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='outer')
print(res)
# A B C D
# K0 A0 B0 C0 D0
# K1 A1 B1 NaN NaN
# K2 A2 B2 C2 D2
# K3 NaN NaN C3 D3
#依据左右资料集的index进行合并，how='inner',并打印出
res = pd.merge(left, right, left_index=True, right_index=True, how='inner')
print(res)
# A B C D
# K0 A0 B0 C0 D0
# K2 A2 B2 C2 D2
解决overlapping的问题
import pandas as pd
#定义资料集
boys = pd.DataFrame({'k': ['K0', 'K1', 'K2'], 'age': [1, 2, 3]})
girls = pd.DataFrame({'k': ['K0', 'K0', 'K3'], 'age': [4, 5, 6]})
#使用suffixes解决overlapping的问题
res = pd.merge(boys, girls, on='k', suffixes=['_boy', '_girl'], how='inner')
print(res)
# age_boy k age_girl
# 0 1 K0 4
# 1 1 K0 5
补充例子
left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
result = pd.merge(left, right, on=['key1', 'key2'])
print('left','\n',left)
print('right','\n',right)
print('result','\n',result)
运行结果：
left
key1 key2 A B
0 K0 K0 A0 B0
1 K0 K1 A1 B1
2 K1 K0 A2 B2
3 K2 K1 A3 B3
right
key1 key2 C D
0 K0 K0 C0 D0
1 K1 K0 C1 D1
2 K1 K0 C2 D2
3 K2 K0 C3 D3
result
key1 key2 A B C D
0 K0 K0 A0 B0 C0 D0
1 K1 K0 A2 B2 C1 D1
2 K1 K0 A2 B2 C2 D2
第二组
left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'key': ['K0', 'K1', 'K0', 'K1']})
right = pd.DataFrame({'C': ['C0', 'C1'],
'D': ['D0', 'D1']},
index=['K0', 'K1'])
result = pd.merge(left, right, left_on='key', right_index=True, how='left', sort=False)
# left_on='key', right_index=True
print('left','\n',left)
print('right','\n',right)
print('result','\n',result)
运行结果：
left
A B key
0 A0 B0 K0
1 A1 B1 K1
2 A2 B2 K0
3 A3 B3 K1
right
C D
K0 C0 D0
K1 C1 D1
result
A B key C D
0 A0 B0 K0 C0 D0
1 A1 B1 K1 C1 D1
2 A2 B2 K0 C0 D0
3 A3 B3 K1 C1 D1
groupby 函数
df.groupby(by='',axis=0,level=None,as_index=True,sort=True,group_keys=True
,squeeze=False).count()
- by--分组的字段
- level--标签所在级别，默认None
- as_index--聚合标签是否以df形式输出，默认True
- sort --是否对分组依据，分组标签进行排序，默认True
- group_keys--是否显示分组,标签名称，默认True
- squeeze--是否对返回数据进行降维，默认False
- 聚合函数有count，head,max,min,median,size,std,sum
