Pandas Learning

# 导入numpy库并重命名为np
import numpy as np
# 导入pandas 库并重命名为pd
import pandas as pd

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(5, 10)) # 创建一个5列10行的由随机浮点数组成的数据框 DataFrame

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

my_list = ['abc',123,'HelloWorld', 5.7]
pd.Series(my_list)

0           abc
1           123
2    HelloWorld
3           5.7
dtype: object

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.tail(n)  # 查看后n行的数据

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

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

df.shape # 查看数据的形状（行和宽）

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() # 对于数据类型为数值型的列，查询其描述性统计的内容

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

s = s.apply(lambda x: x+1)
s

0     3.0
1     4.0
2     5.0
3     5.0
4     6.0
5     NaN
6     7.0
7     7.0
8     7.0
9     8.0
10    9.0
dtype: float64

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.452717
1    0.407755
2    0.549391
3    0.759433
4    0.153871
Name: C, dtype: float64

df[[col1, col2]] # 选择多列

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

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

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

'I'

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

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

'I'

df.DataFrame[n, :] #选取第n行

df = pd.DataFrame(np.array([['I', 'Love', 'China'], ['I', 'Love', 'Data']]))
df.iloc[1, :]

0       I
1    Love
2    Data
Name: 1, dtype: object

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

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

df.iloc[0, 0]

0.78670886755075187

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

df.columns = ['a', 'b', 'c']
df

pd.isnull() # 检查数据中出现空值的情况, 返回一个布尔型的列
pd.notnull() #相对应isnull 返回不是空值的情况

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.isnull()

df.isnull().sum() # 对每一列的空值进行统计

A    2
B    3
C    0
dtype: int64

df.dropna(axis = 0, thresh=n) # 删除包含缺失值的行  axis = 1时删除列  # thresh = n移除空值超过(包括等于)n的行

df

df.dropna(axis = 0)

df.dropna(axis = 1)

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

df.fillna(df.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(type) # 转换列的类型

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

0    1
1    3
2    5
3    5
4    7
5    9
6    9
dtype: int32

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

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':'New A', 'B':'New B'})

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)

df[df[col] > 0.5] # 选取数据df中对应行的数值大于0.5的全部列  支持逻辑运算

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

df[df['A'] > 0.5]

df[(df['A'] > 0.5) & (df['B'] < 0.7)]

df.sort_values(col, ascending=True) #按照列进行排序  # ascending: True 升序 False 降序

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

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做分组 # 常与count进行连用，统计出各词的个数

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

df.groupby('B').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(['A', 'B']).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('A')['D'].mean()

A
bar    4
foo    2
Name: D, dtype: int32

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 = 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, axis=0) # 对数据框df的每一列求平均值 axis: 0对列名（横着的）进行处理  1对索引（竖着的）进行处理

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

df.apply(np.mean, axis=0)

A    0.578480
B    0.519662
C    0.598228
D    0.558102
E    0.321024
dtype: float64

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的行数应该相等  # 中括号可以换成圆括号  # axis: 0进行行合并  1进行列合并

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=0)

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({'E': ['A4', 'A5', 'A6', 'A7'],
                    'F': ['B4', 'B5', 'B6', 'B7'],
                    'G': ['C4', 'C5', 'C6', 'C7'],
                    'H': ['D4', 'D5', 'D6', 'D7']},
                   index=[0, 1, 2, 3])
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', how='inner')

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

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

A    0.362158
B    0.432248
C    0.554478
D    0.331155
E    0.438283
dtype: float64

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

df.corr()

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

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

A     9
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.812708
B    0.886171
C    0.987035
D    0.977146
E    0.959625
dtype: float64

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

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

A    0.128560
B    0.135905
C    0.167476
D    0.137062
E    0.050306
dtype: float64

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

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

A    0.409373
B    0.597418
C    0.678203
D    0.705762
E    0.519713
dtype: float64

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

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

A    0.272847
B    0.254870
C    0.258956
D    0.301168
E    0.295753
dtype: float64