pandas库的基本操作(一）

数据结构

引入模块

import pandas as pd

序列Series：带标签(索引)的一维数组

创建序列

d = {'b':1,'a':0,'c':3} # 参数为字典
s1 = pd.Series(d) # series是pandas的一个类 实例化方法
s2 = pd.Series(d,index = ['b','c','d','a']) # 标签

print(s1)
b    1
a    0
c    3
dtype: int64

print(s2) # NaN: Not a number
b    1.0
c    3.0
d    NaN
a    0.0
dtype: float64

l = ['e','f','g','i']
s3 = pd.Series(l) # 使用列表创建 默认标签
print(s3)
0    e
1    f
2    g
3    i
dtype: object

s4 = pd.Series(np.random.randn(5)) # 使用一维数组创建 randn生成一个符合正态分布的随机数组
print(s4)
0   -1.369760
1   -0.288076
2   -0.286320
3   -0.223246
4   -0.509974
dtype: float64

s5 = pd.Series(5,index = ['a','b','c']) # 使用标量创建
print(s5)
a    5
b    5
c    5
dtype: int64

索引的操作

print(s5[0]) # 下标索引
5

print(s5[:2]) # 切片
a    5
b    5
dtype: int64

print(s5['a':'c']) # 标签索引包括最后那个值
a    5
b    5
c    5
dtype: int64

Series的使用

# 支持大部分numpy函数
s6 = pd.Series(np.random.randn(100))
print(np.mean(s6))
0.14204728919498452

# 按照标签自动对齐
s7 = pd.Series(np.random.randn(5))
print(s7[1:])
1   -0.038398
2    1.689258
3    0.005358
4   -0.847616
dtype: float64

print(s7[:-1])
0    1.709977
1   -0.038398
2    1.689258
3    0.005358
dtype: float64

print(s7[1:] + s7[:-1]) # 注意标签
0         NaN
1   -0.076795
2    3.378516
3    0.010716
4         NaN
dtype: float64

DataFrame 由多种类型的列构成的二维标签数据结构

DataFrame的创建

data1 = np.random.randn(4,3) # 使用二维数组创建
df1 = pd.DataFrame(data1, index=['a','b','c','d'],columns=['c1','c2','c3'])

print(df1[1:2]) # 获取行数据要用切片
         c1        c2        c3
b -1.078995  0.712766  0.640863

print(df1['c1']) # 使用列名获取该列的数据 类型为series
a    1.136544
b   -1.078995
c   -0.245126
d    1.308845
Name: c1, dtype: float64

print(df1[['c1','c3']]) # 索引使用列表 获取的数据为DataFrame
         c1        c3
a  1.136544 -0.440050
b -1.078995  0.640863
c -0.245126 -1.247811
d  1.308845 -0.254885

print(df1['c1'] > 0)
a     True
b    False
c    False
d     True
Name: c1, dtype: bool

print(df1[df1['c1'] > 0]) # 布尔型数组索引
         c1        c2        c3
a  1.136544 -0.184555 -0.440050
d  1.308845  0.567491 -0.254885

print(df1.loc['a']) # 获取该行的数据 类型为series
c1    1.136544
c2   -0.184555
c3   -0.440050
Name: a, dtype: float64

print(df1.loc[['a','b']]) # 索引使用列表 获取的数据为DataFrame
         c1        c2        c3
a  1.136544 -0.184555 -0.440050
b -1.078995  0.712766  0.640863

print(df1.loc[:,'c1'].shape) # 获取该列的数据 类型为series
(4,)

print(df1.loc[:,['c1']].shape) # 全部使用切片或者列表 类型为DataFrame
(4, 1)

print(df1.iloc[0:1]) # iloc基于整数位置(轴的0到length-1),用于按位置选择,但也可用于布尔数组的索引
         c1        c2       c3
a  1.136544 -0.184555 -0.44005
print(df1.iloc[0:1,2])
a   -0.44005

data2 = {"one":pd.Series([1,2,3],index=['a','b','c']),
         "two":pd.Series([3,2,4,2],index=['a','b','c','d'])} # 使用Series 字典创建
df2 = pd.DataFrame(data2)

print(df2)
   one  two
a  1.0    3
b  2.0    2
c  3.0    4
d  NaN    2

df2['new_col'] = df2["one"] + df2["two"]
print(df2)
   one  two  new_col
a  1.0    3      4.0
b  2.0    2      4.0
c  3.0    4      7.0
d  NaN    2      NaN

data3 = [{'a':1,'b':2},{'a':5,'b':10,'c':20}] # 使用字典列表创建
df3 = pd.DataFrame(data3)
print(df3)
   a   b     c
0  1   2   NaN
1  5  10  20.0

data4 = {'one':[1,2,3.00,4],'two':[2,3,1,4]} # 使用列表字典创建
df4 = pd.DataFrame(data4)
print(df4)
    one  two
0  1.0    2
1  2.0    3
2  3.0    1
3  4.0    4

df5 = pd.DataFrame(np.random.randn(100,4),columns=(['a','b','c','d']))
print(df5.head()) # 前五行
          a         b         c         d
0 -1.162014  0.688273  0.018287 -1.252132
1 -0.114753  0.870405 -0.557706 -2.806614
2 -0.804360 -0.791331 -0.039646  0.449327
3  0.397222 -0.690422 -1.375646  1.050238
4  0.535306  0.494542 -1.050268  0.351690

print(df5.tail()) # 后五行
           a         b         c         d
95  0.492579  0.426366  0.796649 -0.240184
96  0.421093 -0.509369  1.190421  0.156422
97  1.867681 -0.750683  0.678072 -0.127596
98 -0.405343  0.302602  0.366929 -1.066400
99  0.912420 -2.934662 -0.275043 -0.705060

print(df5.shape) # 形状
(100, 4)

print(df5.index) # 索引
RangeIndex(start=0, stop=100, step=1)

print(df5.columns) # 列名
Index(['a', 'b', 'c', 'd'], dtype='object')

数据的导入与导出

pd.read_csv()

一些常用的参数解释

sep= 默认分隔符为“,” 也可以为“;”、“/”等

header= 默认表头为数据识别第一行 无表头时要设置header=None

name= 读取哪些列和指定列顺序 传入数据为列表

encoding=文件编码 也称为计算机编码，是指计算机内部代表字母或数字的方式 默认encoding=utf-8

练习：文件SH600000.csv列pct_chg大于0的占比

SH600000.csv

df_1 = pd.read_csv(r'/.../SH600000.csv',sep = ';') # 注意分隔符为';'
x = df_1.shape[0] # 查看行数 shape是元组
df1_new = df_1[df_1['pct_chg'] > 0]
y = len(df1_new) # 这样查看行数也可以
print(y/x)
0.47435456110154905

pd.read_excel()

用于读取xls或xlsx格式的数据

pd.read_sql() 

用于读取数据库语言

to_csv()

使用to_csv() 函数导出DataFrame对象的数据

数据排序 

sort_values() 函数

对指定的列进行升序或降序排列

df_2 = pd.read_csv(r'/.../sort_data.csv')
print(df_2)
      用户ID 性别  年龄
0   100000  男  52
1   100001  男  23
2   100002  男  30
3   100006  男  28
4   100010  男  28
5   100011  男  27
6   100012  男  21
7   100013  男  24
8   100015  男  33
9   100016  男  26
10  100017  女  30

df_2.sort_values(by=['年龄','性别'],ascending=[True,False],inplace=True) # ascending为升序 inplace是否修改原数据帧
print(df_2)
      用户ID 性别  年龄
6   100012  男  21
1   100001  男  23
7   100013  男  24
9   100016  男  26
5   100011  男  27
3   100006  男  28
4   100010  男  28
2   100002  男  30
10  100017  女  30
8   100015  男  33
0   100000  男  52

sort_index() 函数

将指定列转化为行索引，替换掉原来的行索引

sorted_2 = df_2.set_index('用户ID') # 将某一列属性作为索引
       性别  年龄
用户ID         
100012  男  21
100001  男  23
100013  男  24
100016  男  26
100011  男  27
100006  男  28
100010  男  28
100002  男  30
100017  女  30
100015  男  33
100000  男  52

df_2.index = df_2['用户ID'] # 这样ID存了两次
print(df_2)
          用户ID 性别  年龄
用户ID                 
100012  100012  男  21
100001  100001  男  23
100013  100013  男  24
100016  100016  男  26
100011  100011  男  27
100006  100006  男  28
100010  100010  男  28
100002  100002  男  30
100017  100017  女  30
100015  100015  男  33
100000  100000  男  52

重复数据处理

df_3 = pd.read_csv(r'/.../duplicated_data.csv')
print(df_3)
   ID  姓名 性别
0   1  刘一  男
1   1  刘一  男
2   3  张三  男
3   4  李四  女
4   5  王五  女
5   6  赵六  男
6   7  孙七  女
7   8  周八  女
8   9  吴九  男
9  10  郑十  男

# 重复数据查找
print(df_3.duplicated()) # 默认所有列为条件 返回布尔数组 True为重复 第一个不视为重复
0    False
1     True
2    False
3    False
4    False
5    False
6    False
7    False
8    False
9    False
dtype: bool

print(df_3[df_3.duplicated()]) # 找重复数据
   ID  姓名 性别
1   1  刘一  男

print(df_3.duplicated(subset = '性别')) # 指定列 只判断性别是否有重复
0    False # 第一次出现不视为重复
1     True
2     True
3    False # 第一次出现不视为重复
4     True
5     True
6     True
7     True
8     True
9     True
dtype: bool

# 重复数据删除
droped = df_3.drop_duplicates(keep='first') # 删除重复数据
print(droped)
   ID  姓名 性别
0   1  刘一  男
2   3  张三  男
3   4  李四  女
4   5  王五  女
5   6  赵六  男
6   7  孙七  女
7   8  周八  女
8   9  吴九  男
9  10  郑十  男

缺失数据处理

df = pd.DataFrame(np.random.randn(5,4))
print(df)
          0         1         2         3
0  0.415088 -0.288043 -0.546016  0.190033
1  0.138844  0.332146  0.177790  1.645046
2 -0.775388 -0.013097  0.624365  1.399664
3 -1.033250 -0.714837 -0.590460 -0.045542
4 -1.672583 -0.662195 -0.014215  0.288969

# 置空
df.iloc[1:3,1] = np.nan
df.iloc[4,1] = np.nan
df.iloc[3:5,3] = np.nan
print(df)
          0         1         2         3
0  0.415088 -0.288043 -0.546016  0.190033
1  0.138844       NaN  0.177790  1.645046
2 -0.775388       NaN  0.624365  1.399664
3 -1.033250 -0.714837 -0.590460       NaN
4 -1.672583       NaN -0.014215       NaN

# isnulll()检查数据是否有缺失 True表示有空值
print(df.isnull())
       0      1      2      3
0  False  False  False  False
1  False   True  False  False
2  False   True  False  False
3  False  False  False   True
4  False   True  False   True

print(df.isnull().any()) # 判断每一列是否有缺失 True表示有空值
0    False
1     True
2    False
3     True
dtype: bool

r = df.isnull().T.any() # 判断每一行是否有缺失 True表示有空值
print(df[r]) # 第一行没有空值故索引的bool型数组为False
          0         1         2         3
1  0.138844       NaN  0.177790  1.645046
2 -0.775388       NaN  0.624365  1.399664
3 -1.033250 -0.714837 -0.590460       NaN
4 -1.672583       NaN -0.014215       NaN

print(df.isnull().all()) # 判断某一列是否全是空值，有一个不为空就为False
0    False
1    False
2    False
3    False
dtype: bool

print(df.fillna('a')) # 以指定元素填充
          0         1         2         3
0  0.415088 -0.288043 -0.546016  0.190033
1  0.138844         a  0.177790  1.645046
2 -0.775388         a  0.624365  1.399664
3 -1.033250 -0.714837 -0.590460         a
4 -1.672583         a -0.014215         a

print(df.fillna(method = 'ffill')) # method是填充方法 默认为None ffill是用前一个数据向后填充 默认axis=0按行填充
          0         1         2         3
0  0.415088 -0.288043 -0.546016  0.190033
1  0.138844 -0.288043  0.177790  1.645046
2 -0.775388 -0.288043  0.624365  1.399664
3 -1.033250 -0.714837 -0.590460  1.399664
4 -1.672583 -0.714837 -0.014215  1.399664

print(df.fillna(method = 'bfill',axis=1)) # 用右边的数据向左填充 从最后一列开始
          0         1         2         3
0  0.415088 -0.288043 -0.546016  0.190033
1  0.138844  0.177790  0.177790  1.645046
2 -0.775388  0.624365  0.624365  1.399664
3 -1.033250 -0.714837 -0.590460       NaN
4 -1.672583 -0.014215 -0.014215       NaN

# dropna()删除包含空值的记录
print(df.dropna(axis = 0, how = any)) # 默认0为按行删除 有空值就删除 整行
          0         1         2         3
0  0.415088 -0.288043 -0.546016  0.190033

print(df.dropna(axis = 1, how = all)) # 1为按列删除 整列全为空值才删除 
          0         1         2         3
0  0.415088 -0.288043 -0.546016  0.190033
1  0.138844       NaN  0.177790  1.645046
2 -0.775388       NaN  0.624365  1.399664
3 -1.033250 -0.714837 -0.590460       NaN
4 -1.672583       NaN -0.014215       NaN

数据转换

查看数据类型.dtypes

数据类型转换.astype('type')

时间数据

# to_datetime(arg,format) 将字符型的时间数据转换为时间型数据
df = pd.read_csv(r'/.../s2t.csv')
print(df)
             电话       注册时间 是否微信
0  166412894295   2011/1/1    否
1  135416795207   2012/2/3    否
2  177423353436   2013/3/2    是
3  189424978309  2014/4/11    是
4  134450811715  2015/5/18    否
5  137450811771  2016/6/12    否
6  173450811789  2017/7/15    是
7  188450811792  2018/8/17    是
8  168450811840  2019/9/16    是

df['new_date'] = pd.to_datetime(df['注册时间']) # %Y年 %m月 %d日 %H小时 %M分钟 %S秒
print(df)
             电话       注册时间 是否微信   new_date
0  166412894295   2011/1/1    否 2011-01-01
1  135416795207   2012/2/3    否 2012-02-03
2  177423353436   2013/3/2    是 2013-03-02
3  189424978309  2014/4/11    是 2014-04-11
4  134450811715  2015/5/18    否 2015-05-18
5  137450811771  2016/6/12    否 2016-06-12
6  173450811789  2017/7/15    是 2017-07-15
7  188450811792  2018/8/17    是 2018-08-17
8  168450811840  2019/9/16    是 2019-09-16

print(df['new_date'].dt.strftime('%Y-%m')) # 将时间型数据，按照指定的格式，转为字符型数据
0    2011-01
1    2012-02
2    2013-03
3    2014-04
4    2015-05
5    2016-06
6    2017-07
7    2018-08
8    2019-09
Name: new_date, dtype: object