必备神器之pandas

发表于 | 分类于 | 浏览 次
| 字数统计: 3,116 字 | 阅读时长 ≈ 15 分钟

python工具包pandas，数据分析

1 import语句

1
import pandas as pd

2 文件读取

1
2
3
4
5
6
7
8
9
10
11
12
13
df = pd.read_csv(path='file.csv')
参数：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的字典

3 数据预处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
df.duplicated()           返回各行是否是上一行的重复行
df.drop_duplicates()      删除重复行，如果需要按照列过滤，参数选填['col1', 'col2',...]
df.fillna(0)              用实数0填充na
df.dropna()               axis=0|1  0-index 1-column
                          how='all'|'any' all-全部是NA才删  any-只要有NA就全删
del df['col1']            直接删除某一列              
df.drop(['col1',...], aixs=1)   删除指定列，也可以删除行                          
df.column = col_lst       重新制定列名
df.rename(index={'row1':'A'},   重命名索引名和列名
          columns={'col1':'A1'})  
df.replace(dict)          替换df值，前后值可以用字典表，{1:‘A’, '2':'B'}

def get_digits(str):
    m = re.match(r'(\d+(\.\d+)?)', str.decode('utf-8'))
    if m is not None:   
        return float(m.groups()[0])
    else:
        return 0
df.apply(get_digits)      DataFrame.apply，只获取小数部分，可以选定某一列或行
df['col1'].map(func)      Series.map，只对列进行函数转换

pd.merge(df1, df2, on='col1', 
         how='inner'，sort=True) 合并两个DataFrame，按照共有的某列做内连接（交集），outter为外连接（并集），结果排序
         
pd.merge(df1, df2, left_on='col1', 
         right_on='col2')   df1 df2没有公共列名，所以合并需指定两边的参考列


pd.concat([sr1, sr2, sr3,...], axis=0) 多个Series堆叠成多行，结果仍然是一个Series
pd.concat([sr1, sr2, sr3,...], axis=1) 多个Series组合成多行多列，结果是一个DataFrame，索引取并集，没有交集的位置填入缺省值NaN
 
df1.combine_first(df2)   用df2的数据补充df1的缺省值NaN，如果df2有更多行，也一并补上

df.stack()              列旋转成行，也就是列名变为索引名，原索引变成多层索引，结果是具有多层索引的Series，实际上是把数据集拉长

df.unstack()            将含有多层索引的Series转换为DataFrame，实际上是把数据集压扁，如果某一列具有较少类别，那么把这些类别拉出来作为列
df.pivot()              实际上是unstack的应用，把数据集压扁

pd.get_dummies(df['col1'], prefix='key') 某列含有有限个值，且这些值一般是字符串，例如国家，借鉴位图的思想，可以把k个国家这一列量化成k列，每列用0、1表示

4 数据筛选

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
df.columns             列名，返回Index类型的列的集合
df.index               索引名，返回Index类型的索引的集合
df.shape               返回tuple，行x列
df.head(n=N)           返回前N条
df.tail(n=M)           返回后M条
df.values              值的二维数组，以numpy.ndarray对象返回
df.index               DataFrame的索引，索引不可以直接赋值修改
df.reindex(index=['row1', 'row2',...]
           columns=['col1', 'col2',...]) 根据新索引重新排序
df[m:n]                切片，选取m~n-1行
df[df['col1'] > 1]     选取满足条件的行
df.query('col1 > 1')   选取满足条件的行
df.query('col1==[v1,v2,...]') 
df.ix[:,'col1']        选取某一列
df.ix['row1', 'col2']  选取某一元素
df.ix[:,:'col2']       切片选取某一列之前（包括col2）的所有列
df.loc[m:n]            获取从m~n行（推荐）
df.iloc[m:n]           获取从m~n-1行
df.loc[m:n-1,'col1':'coln']   获取从m~n行的col1~coln列


sr=df['col']           取某一列，返回Series
sr.values              Series的值，以numpy.ndarray对象返回
sr.index               Series的索引，以index对象返回

5 数据运算与排序

1
2
3
4
5
6
7
8
9
10
11
12
13
df.T                   DataFrame转置
df1 + df2              按照索引和列相加，得到并集，NaN填充
df1.add(df2, fill_value=0) 用其他值填充
df1.add/sub//mul/div   四则运算的方法
df - sr                DataFrame的所有行同时减去Series
df * N                 所有元素乘以N
df.add(sr, axis=0)     DataFrame的所有列同时减去Series


sr.order()             Series升序排列
df.sort_index(aixs=0, ascending=True) 按行索引升序
df.sort_index(by=['col1', 'col2'...])  按指定列优先排序
df.rank()              计算排名rank值

6 数学统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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']) 交叉表，计算分组的频率

1. 对象创建 Data Structure Intro section

1.1 Series Series

1
2
3
4
5
6
7
8
9
10
11
In [4]: s = pd.Series([1,3,5,np.nan,6,8])

In [5]: s
Out[5]: 
0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

1.2 DataFrame DataFrame

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In [6]: dates = pd.date_range('20130101', periods=6)

In [7]: dates
Out[7]: 
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',
               '2013-01-05', '2013-01-06'],
              dtype='datetime64[ns]', freq='D')

In [8]: df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))

In [9]: df
Out[9]: 
                   A         B         C         D
2013-01-01  0.469112 -0.282863 -1.509059 -1.135632
2013-01-02  1.212112 -0.173215  0.119209 -1.044236
2013-01-03 -0.861849 -2.104569 -0.494929  1.071804
2013-01-04  0.721555 -0.706771 -1.039575  0.271860
2013-01-05 -0.424972  0.567020  0.276232 -1.087401
2013-01-06 -0.673690  0.113648 -1.478427  0.524988

2. 导入数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
pd.read_csv()           默认分割符为逗号
参数：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）

pd.read_json()          可以传入json格式字符串
pd.read_excel('file.xls', sheetname=[0,1..]) 读取多个sheet页，返回多个df的字典
pd.read_table()			默认分隔符为制表符
pd.read_fwf()			没有分隔符
pd.read_clipboard()

3. 查看数据Basics section

1
2
3
4
5
6
7
8
9
df.head()              查看开始五行
df.tail(3)             查看最后三行
df.index               展示行名
df.columns             展示列名
df.values              展示所有值
df.describe()          描述数据的统计摘要
df.T                   转置数据
df.sort_index(axis=1, ascending=False)        通过一个轴排序
df.sort_values(by='B') 通过值排序

4. 选择

Indexing and Selecting Data MultiIndex / Advanced Indexing

4.1 get

1
2
3
df['A']           得到一列，想当年于df.A
df[0:3]           切片。取1-3行
df['20130102':'20130104']  得到两个行标之间的部分

4.2 通过标签选择 Selection by Label

1
2
3
4
5
df.loc[dates[0]]              通过行标签获取横截面
df.loc[:,['A','B']]           通过列标签获取纵界面
In [28]: df.loc['20130102':'20130104',['A','B']]     获取横纵截面
df.loc[dates[0],'A']          获取标量值
df.at[dates[0],'A']           快速获取标量值

4.3 通过位置选择Selection by Position

1
2
3
4
5
6
df.iloc[3]                      获得第三行横截面
df.iloc[[1,2,4],[0,2]]          获得2，3，5行和1，3列
df.iloc[1:3,:]                  获得2，3行
df.iloc[:,1:3]                  获得2，3列
df.iloc[1,1]                    获取2，2明确值
df.iat[1,1]                     快速获取2，2明确值

4.4 布尔索引isin()

1
2
3
df[df.A > 0]                    获得A列中大于0的行
df[df > 0]                      选择所有大于0的值
df2[df2['E'].isin(['two','four'])]   通过isin方法过滤

4.5 设置

1
2
3
4
pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102', periods=6))   设置新列自动按索引排列数据
df.at[dates[0],'A'] = 0   通过标签设置值
df.iat[0,1] = 0           通过位置设置值
df.loc[:,'D'] = np.array([5] * len(df))    通过numpy数组设置值

###

5. 数据缺失 Missing Data section

1
2
3
4
5
df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])
df1.loc[dates[0]:dates[1],'E'] = 1      Reindex允许您更改/添加/删除指定轴上的索引   
df1.dropna(how='any')                   删除任何缺少数据的行
df1.fillna(value=5)                     填写缺少的数据
pd.isna(df1)                            获取值为nan的布尔值掩码

###

6. 操作Basic section on Binary Ops

6.1 统计

1
2
3
df.mean()                    描述性统计
df.mean(1)                   一个轴上的统计
s = pd.Series([1,3,5,np.nan,6,8], index=dates).shift(2)

6.2 Apply

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
In [66]: df.apply(np.cumsum)
Out[66]: 
                   A         B         C   D     F
2013-01-01  0.000000  0.000000 -1.509059   5   NaN
2013-01-02  1.212112 -0.173215 -1.389850  10   1.0
2013-01-03  0.350263 -2.277784 -1.884779  15   3.0
2013-01-04  1.071818 -2.984555 -2.924354  20   6.0
2013-01-05  0.646846 -2.417535 -2.648122  25  10.0
2013-01-06 -0.026844 -2.303886 -4.126549  30  15.0

In [67]: df.apply(lambda x: x.max() - x.min())
Out[67]: 
A    2.073961
B    2.671590
C    1.785291
D    0.000000
F    4.000000
dtype: float64

6.3 直方图化 Histogramming and Discretization

1
2
s = pd.Series(np.random.randint(0, 7, size=10))    
s.value_counts()

6.4 字符串方法Vectorized String Methods.

1
2
s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
s.str.lower()

7. MergeMerging section

7.1 Concat concat()

1
2
3
df = pd.DataFrame(np.random.randn(10, 4))
pieces = [df[:3], df[3:7], df[7:]]
pd.concat(pieces)

7.2 Join Database style joining

1
2
3
left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})
right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})
pd.merge(left, right, on='key')

7.3 AppendAppending

1
2
3
df = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])
s = df.iloc[3]
df.append(s, ignore_index=True)

###

8.GroupingGrouping section

1
2
df.groupby('A').sum()         分组，然后将函数总和应用于结果组。
df.groupby(['A','B']).sum()   按多列分组会形成一个分层索引，然后我们应用这个函数。

9.Reshape Reshaping

Hierarchical Indexing

9.1 堆stack()

1
2
3
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second']) 
df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])
df2 = df[:4]

9.2 数据透视表Pivot Tables

1
2


-------------感谢阅读-------------
0%