Kesci Datathon 第二章(Pandas基本使用)

按老师安排,完成Kesci平台的Datathon训练营.这篇文章主要记录完成第二章节的内容.

其实对python已经挺熟悉了,这里就当整理总结吧.

这里是对Pandas的总结学习.参考Pandas基础命令速查清单

本文大纲

• [缩写解释 & 库的导入]
• [数据的导入]
• [数据的导出]
• [创建测试对象]
• [数据的查看与检查]
• [数据的选取]
• [数据的清洗]
• [数据的过滤(filter),排序(sort)和分组(groupby)]
• [数据的连接(join)与组合(combine)]
• [数据的统计]

¶缩写解释 & 库的导入

df — 任意的pandas DataFrame(数据框)对象
s — 任意的pandas Series(数组)对象
pandas和numpy是用Python做数据分析最基础且最核心的库

import pandas as pd # 导入pandas库并简写为pd
import numpy as np # 导入numpy库并简写为np

¶数据的导入

pd.read_csv(filename) # 导入csv格式文件中的数据
pd.read_table(filename) # 导入有分隔符的文本 (如TSV) 中的数据
pd.read_excel(filename) # 导入Excel格式文件中的数据
pd.read_sql(query, connection_object) # 导入SQL数据表/数据库中的数据
pd.read_json(json_string) # 导入JSON格式的字符，URL地址或者文件中的数据
pd.read_html(url) # 导入经过解析的URL地址中包含的数据框 (DataFrame) 数据
pd.read_clipboard() # 导入系统粘贴板里面的数据
pd.DataFrame(dict)  # 导入Python字典 (dict) 里面的数据，其中key是数据框的表头，value是数据框的内容。

¶数据的导出

df.to_csv(filename) # 将数据框 (DataFrame)中的数据导入csv格式的文件中
df.to_excel(filename) # 将数据框 (DataFrame)中的数据导入Excel格式的文件中
df.to_sql(table_name,connection_object) # 将数据框 (DataFrame)中的数据导入SQL数据表/数据库中
df.to_json(filename) # 将数据框 (DataFrame)中的数据导入JSON格式的文件中

¶创建测试对象

pd.DataFrame(np.random.rand(10,5)) # 创建一个5列10行的由随机浮点数组成的数据框 DataFrame

pd.DataFrame(np.random.rand(10,5))

pd.Series(my_list) # 从一个可迭代的对象 my_list 中创建一个数据组

my_list = ['Kesci',100,'欢迎来到科赛网']
pd.Series(my_list)

0      Kesci
1        100
2    欢迎来到科赛网
dtype: object

df.index = pd.date_range('2017/1/1', periods=df.shape[0]) # 添加一个日期索引 index

df = pd.DataFrame(np.random.rand(10,5))
df.index = pd.date_range('2017/1/1', periods=df.shape[0])
df

¶数据的查看与检查

df.head(n)  # 查看数据框的前n行

df = pd.DataFrame(np.random.rand(10,5))
df.head(3)

df.tail(n) # 查看数据框的最后n行

df = pd.DataFrame(np.random.rand(10,5))
df.tail(3)

df.shape # 查看数据框的行数与列数

df = pd.DataFrame(np.random.rand(10,5))
df.shape

(10, 5)

df.info() # 查看数据框 (DataFrame) 的索引、数据类型及内存信息

df = pd.DataFrame(np.random.rand(10,5))
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10 entries, 0 to 9
Data columns (total 5 columns):
0    10 non-null float64
1    10 non-null float64
2    10 non-null float64
3    10 non-null float64
4    10 non-null float64
dtypes: float64(5)
memory usage: 480.0 bytes

df.describe() # 对于数据类型为数值型的列，查询其描述性统计的内容

df.describe()

s.value_counts(dropna=False) # 查询每个独特数据值出现次数统计

s = pd.Series([1,2,3,3,4,np.nan,5,5,5,6,7])
s.value_counts(dropna=False)

 5.0    3
 3.0    2
 7.0    1
 6.0    1
NaN     1
 4.0    1
 2.0    1
 1.0    1
dtype: int64

df.apply(pd.Series.value_counts) # 查询数据框 (Data Frame) 中每个列的独特数据值出现次数统计

¶数据的选取

df[col] # 以数组 Series 的形式返回选取的列

df = pd.DataFrame(np.random.rand(5,5),columns=list('ABCDE'))
df['C']

0    0.720965
1    0.360155
2    0.474067
3    0.116206
4    0.774503
Name: C, dtype: float64

df[[col1, col2]] # 以新的数据框(DataFrame)的形式返回选取的列

df = pd.DataFrame(np.random.rand(5,5),columns=list('ABCDE'))
df[['B','E']]

s.iloc[0] # 按照位置选取

s = pd.Series(np.array(['I','Love','Data']))
s.iloc[0]

'I'

s.loc['index_one'] # 按照索引选取

s = pd.Series(np.array(['I','Love','Data']))
s.loc[1]

'Love'

df.iloc[0,:] # 选取第一行

df = pd.DataFrame(np.random.rand(5,5),columns=list('ABCDE'))
df.iloc[0,:]

A    0.234156
B    0.513754
C    0.593067
D    0.856575
E    0.291528
Name: 0, dtype: float64

df.iloc[0,0] # 选取第一行的第一个元素

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.iloc[0,0]

0.91525996455410763

¶数据的清洗

df.columns = ['a','b'] # 重命名数据框的列名称

df = pd.DataFrame({'A':np.array([1,np.nan,2,3,6,np.nan]),
                 'B':np.array([np.nan,4,np.nan,5,9,np.nan]),
                  'C':'foo'})
df.columns = ['a','b','c']
df

pd.isnull() # 检查数据中空值出现的情况，并返回一个由布尔值(True,Fale)组成的列

df = pd.DataFrame({'A':np.array([1,np.nan,2,3,6,np.nan]),
                 'B':np.array([np.nan,4,np.nan,5,9,np.nan]),
                  'C':'foo'})
pd.isnull(df)

pd.notnull() # 检查数据中非空值出现的情况，并返回一个由布尔值(True,False)组成的列

df = pd.DataFrame({'A':np.array([1,np.nan,2,3,6,np.nan]),
                 'B':np.array([np.nan,4,np.nan,5,9,np.nan]),
                  'C':'foo'})
pd.notnull(df)

df.dropna() # 移除数据框 DataFrame 中包含空值的行

df = pd.DataFrame({'A':np.array([1,np.nan,2,3,6,np.nan]),
                 'B':np.array([np.nan,4,np.nan,5,9,np.nan]),
                  'C':'foo'})
df.dropna()

df.dropna(axis=1) # 移除数据框 DataFrame 中包含空值的列

df = pd.DataFrame({'A':np.array([1,np.nan,2,3,6,np.nan]),
                 'B':np.array([np.nan,4,np.nan,5,9,np.nan]),
                  'C':'foo'})
df.dropna(axis=1)

df.dropna(axis=0,thresh=n)

df = pd.DataFrame({'A':np.array([1,np.nan,2,3,6,np.nan]),
                 'B':np.array([np.nan,4,np.nan,5,9,np.nan]),
                  'C':'foo'})
test = df.dropna(axis=1,thresh=1)
test

df.fillna(x) # 将数据框 DataFrame 中的所有空值替换为 x

df = pd.DataFrame({'A':np.array([1,np.nan,2,3,6,np.nan]),
                 'B':np.array([np.nan,4,np.nan,5,9,np.nan]),
                  'C':'foo'})
df.fillna('Test')

s.fillna(s.mean()) -> 将所有空值替换为平均值

s = pd.Series([1,3,5,np.nan,7,9,9])
s.fillna(s.mean())

0    1.000000
1    3.000000
2    5.000000
3    5.666667
4    7.000000
5    9.000000
6    9.000000
dtype: float64

s.astype(float) # 将数组(Series)的格式转化为浮点数

s = pd.Series([1,3,5,np.nan,7,9,9])
s.astype(float)

0    1.0
1    3.0
2    5.0
3    NaN
4    7.0
5    9.0
6    9.0
dtype: float64

s.replace(1,'one') # 将数组(Series)中的所有1替换为'one'

s = pd.Series([1,3,5,np.nan,7,9,9])
s.replace(1,'one')

0    one
1      3
2      5
3    NaN
4      7
5      9
6      9
dtype: object

s.replace([1,3],['one','three']) # 将数组(Series)中所有的1替换为'one', 所有的3替换为'three'

s = pd.Series([1,3,5,np.nan,7,9,9])
s.replace([1,3],['one','three'])

0      one
1    three
2        5
3      NaN
4        7
5        9
6        9
dtype: object

df.rename(columns=lambda x: x + 2) # 将全体列重命名

df = pd.DataFrame(np.random.rand(4,4))
df.rename(columns=lambda x: x+ 2)

df.rename(columns={'old_name': 'new_ name'}) # 将选择的列重命名

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.rename(columns={'A':'newA','C':'newC'})

df.set_index('column_one') # 改变索引

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.set_index('B')

df.rename(index = lambda x: x+ 1) # 改变全体索引

df = pd.DataFrame(np.random.rand(10,5))
df.rename(index = lambda x: x+ 1)

¶数据的过滤(filter),排序(sort)和分组(groupby)

df[df[col] > 0.5] # 选取数据框df中对应行的数值大于0.5的全部列

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df[df['A'] > 0.5]

df[(df[col] > 0.5) & (df[col] < 0.7)] # 选取数据框df中对应行的数值大于0.5，并且小于0.7的全部列

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df[(df['C'] > 0.5) & (df['D'] < 0.7)]

df.sort_values(col1) # 按照数据框的列col1升序(ascending)的方式对数据框df做排序

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.sort_values('E')

df.sort_values(col2,ascending=False) # 按照数据框的列col2降序(descending)的方式对数据框df做排序

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.sort_values('A',ascending=False)

df.sort_values([col1,col2],ascending=[True,False]) # 按照数据框的列col1升序，col2降序的方式对数据框df做排序

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.sort_values(['A','E'],ascending=[True,False])

df.groupby(col) # 按照某列对数据框df做分组

df = pd.DataFrame({'A':np.array(['foo','foo','foo','foo','bar','bar']),
      'B':np.array(['one','one','two','two','three','three']),
     'C':np.array(['small','medium','large','large','small','small']),
     'D':np.array([1,2,2,3,3,5])})

df.groupby('A').count()

df.groupby([col1,col2]) # 按照列col1和col2对数据框df做分组

df = pd.DataFrame({'A':np.array(['foo','foo','foo','foo','bar','bar']),
      'B':np.array(['one','one','two','two','three','three']),
     'C':np.array(['small','medium','large','large','small','small']),
     'D':np.array([1,2,2,3,3,5])})

df.groupby(['B','C']).sum()

df.groupby(col1)[col2].mean() # 按照列col1对数据框df做分组处理后，返回对应的col2的平均值

df = pd.DataFrame({'A':np.array(['foo','foo','foo','foo','bar','bar']),
      'B':np.array(['one','one','two','two','three','three']),
     'C':np.array(['small','medium','large','large','small','small']),
     'D':np.array([1,2,2,3,3,5])})
df.groupby('B')['D'].mean()

B
one      1.5
three    4.0
two      2.5
Name: D, dtype: float64

df.pivot_table(index=col1,values=[col2,col3],aggfunc=mean) # 做透视表，索引为col1,针对的数值列为col2和col3，分组函数为平均值

df = pd.DataFrame({'A':np.array(['foo','foo','foo','foo','bar','bar']),
      'B':np.array(['one','one','two','two','three','three']),
     'C':np.array(['small','medium','large','large','small','small']),
     'D':np.array([1,2,2,3,3,5])})

df.pivot_table(df,index=['A','B'],
               columns=['C'],aggfunc=np.sum)

df.groupby(col1).agg(np.mean)

df = pd.DataFrame({'A':np.array(['foo','foo','foo','foo','bar','bar']),
      'B':np.array(['one','one','two','two','three','three']),
     'C':np.array(['small','medium','large','large','small','small']),
     'D':np.array([1,2,2,3,3,5])})
df.groupby('A').agg(np.mean)

df.apply(np.mean) # 对数据框df的每一列求平均值

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.apply(np.mean)

A    0.388075
B    0.539564
C    0.607983
D    0.518634
E    0.482960
dtype: float64

df.apply(np.max,axis=1) # 对数据框df的每一行求最大值

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.apply(np.max,axis=1)

0    0.904163
1    0.804519
2    0.924102
3    0.761781
4    0.952084
5    0.923679
6    0.796320
7    0.582907
8    0.761310
9    0.893564
dtype: float64

¶数据的连接(join)与组合(combine)

df1.append(df2) # 在数据框df2的末尾添加数据框df1，其中df1和df2的列数应该相等

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']},
                   index=[0, 1, 2, 3])
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7']},
                   index=[4, 5, 6, 7])

df1.append(df2)

pd.concat([df1, df2],axis=1) # 在数据框df1的列最后添加数据框df2,其中df1和df2的行数应该相等

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']},
                   index=[0, 1, 2, 3])
df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7']},
                   index=[4, 5, 6, 7])
pd.concat([df1,df2],axis=1)

df1.join(df2,on=col1,how='inner') # 对数据框df1和df2做内连接，其中连接的列为col1

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],           
                     'B': ['B0', 'B1', 'B2', 'B3'],
                     'key': ['K0', 'K1', 'K0', 'K1']})
   

df2 = pd.DataFrame({'C': ['C0', 'C1'],
                      'D': ['D0', 'D1']},
                     index=['K0', 'K1'])
   

df1.join(df2, on='key')

¶数据的统计

df.describe() # 得到数据框df每一列的描述性统计

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.describe()

df.mean() # 得到数据框df中每一列的平均值

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.mean()

A    0.395643
B    0.528812
C    0.692011
D    0.446750
E    0.544759
dtype: float64

df.corr() # 得到数据框df中每一列与其他列的相关系数

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.corr()

df.count() # 得到数据框df中每一列的非空值个数

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.count()

A    10
B    10
C    10
D    10
E    10
dtype: int64

df.max() # 得到数据框df中每一列的最大值

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.max()

A    0.933848
B    0.730197
C    0.921751
D    0.715280
E    0.940010
dtype: float64

df.min() # 得到数据框df中每一列的最小值

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.min()

A    0.107516
B    0.001635
C    0.024502
D    0.092810
E    0.019898
dtype: float64

df.median() # 得到数据框df中每一列的中位数

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.median()

A    0.497591
B    0.359854
C    0.661607
D    0.342418
E    0.588468
dtype: float64

df.std() # 得到数据框df中每一列的标准差

df = pd.DataFrame(np.random.rand(10,5),columns=list('ABCDE'))
df.std()

A    0.231075
B    0.286691
C    0.276511
D    0.304167
E    0.272570
dtype: float64