数据分析工具Pandas(一)

一、Pandas简介

1.什么是Pandas?

Pandas的名称来自于面板数据(panel data)和Python数据分析(data analysis)。
Pandas是一个强大的分析结构化数据的工具集,基于NumPy构建,提供了高级数据结构和数据操作工具,它是使Python成为强大而高效的数据分析环境的重要因素之一。
一个强大的分析和操作大型结构化数据集所需的工具集,基础是NumPy,提供了高性能矩阵的运算,提供了大量能够快速便捷地处理数据的函数和方法
应用于数据挖掘,数据分析,提供数据清洗功能。http://pandas.pydata.org

2.导入pandas
# pd别名业界约定
>>>import pandas as pd

二、pandas的数据结构

Series

Series是一种类似于一维数组的对象,组成:
一组数据(各种NumPy数据类型),一组与之对应的索引(数据标签),索引(index)在左,数据(values)在右,索引是自动创建的

DataFrame

一个表格型的数据结构,它含有一组有序的列,每列可以是不同类型的值。DataFrame既有行索引也有列索引,数据是以二维结构存放的。类似多维数组/表格数据 (如,excel, R中的data.frame),每列数据可以是不同的类型,索引包括列索引和行索引

1.Series

1-1.通过list构建Series

>>> import pandas as pd
 # 不指定索引的话,默认从0开始
>>> ser_obj=pd.Series(range(10,30))
>>>ser_obj
0     10
1     11
2     12
3     13
4     14
5     15
6     16
7     17
8     18
9     19
10    20
11    21
12    22
13    23
14    24
15    25
16    26
17    27
18    28
19    29
dtype: int64
>>> ser_obj.head(3)   #打印前三行数据
0    10
1    11
2    12
dtype: int64
>>> print(type(ser_obj)) #打印数据类型

1-2. 通过dict构建Series

>>> dict = {1000:"hello",2000:"world",3000:"!"}
>>> ser_obj = pd.Series(dict)
>>> print(ser_obj)
1000    hello
2000    world
3000        !
dtype: object

1-3.获取数据和索引
ser_obj.index 和 ser_obj.values

# 获取数据 
>>> print(ser_obj.values)
['hello' 'world' '!']
# 获取索引
>>> print(ser_obj.index)
Int64Index([1000, 2000, 3000], dtype='int64')

1-4. 通过索引获取数据
ser_obj[idx]

#通过索引获取数据 
>>> print(ser_obj[1000])
hello
>>> print(ser_obj[2000])
world

1-5. 设置名称
对象名:ser_obj.name 给整个表取名字
对象索引名:ser_obj.index.name 给某一列

>>> ser_obj.name = 'presidential_polls'
>>> ser_obj.index.name = 'adjpoll_trump'
>>> print(ser_obj.head())
adjpoll_trump
1000    hello
2000    world
3000        !
Name: presidential_polls, dtype: object

2.DataFrame

2-1. 通过darray构建DataFrame

>>> arr_obj = np.random.rand(3,4)
>>> df_obj = pd.DataFrame(arr_obj)
>>> print(df_obj)
          0         1         2         3
0  0.471906  0.210490  0.781181  0.215866
1  0.293406  0.387063  0.961384  0.935796
2  0.761027  0.038050  0.759989  0.831180
>>> print(df_obj.head(2))  # 查看前两行
          0         1         2         3
0  0.471906  0.210490  0.781181  0.215866
1  0.293406  0.387063  0.961384  0.935796

2-2. 通过dict构建DataFrame

>>> dict = {
...     "A":1,
...     "B":pd.Timestamp("20171212"),
...     "C":pd.Series(range(10,14),dtype="float64"),
...     "D":["python","java","c++","c"],
...     "E":np.array([3] *4,dtype="int32"),
...     "F":"Lyh"
... }
>>> df_obj = pd.DataFrame(dict)
>>> print(df_obj)
   A          B     C       D  E     F
0  1 2017-12-12  10.0  python  3  Lyh
1  1 2017-12-12  11.0    java  3  Lyh
2  1 2017-12-12  12.0     c++  3  Lyh
3  1 2017-12-12  13.0       c  3  Lyh

2-3. 通过列索引获取列数据
df_obj[col_idx] 或 df_obj.col_idx

>>> print(df_obj['A'])
0    1
1    1
2    1
3    1
Name: A, dtype: int64
>>> print(type(df_obj['A']))

>>> print(df_obj.A)
0    1
1    1
2    1
3    1
Name: A, dtype: int64

dataframe数据访问

#通过索引,先列后行
>>> print(df_obj['D'][0])
python
#查找指定元素,先找列,在找行
>>> print(df_obj.D[2])
c++

2-4. 增加列数据
df_obj[new_col_idx] = data
类似Python的 dict添加key-value

>>> df_obj["G"] = "呵呵"
>>> print(df_obj)
   A          B     C       D  E     F   G
0  1 2017-12-12  10.0  python  3  Lyh 呵呵
1  1 2017-12-12  11.0    java  3  Lyh 呵呵
2  1 2017-12-12  12.0     c++  3  Lyh 呵呵
3  1 2017-12-12  13.0       c  3  Lyh 呵呵

df_obj[new_col_idx] = data
类似Python的 dict添加key-value

#新增一列,数据可以是dataFrame对象的其他列运算后的结果,例如,添加H列,C的值加10
>>> df_obj["H"] = df_obj["C"]+10
>>> print(df_obj)
   A          B     C       D  E     F   G     H
0  1 2017-12-12  10.0  python  3  Lyh 呵呵  20.0
1  1 2017-12-12  11.0    java  3  Lyh 呵呵  21.0
2  1 2017-12-12  12.0     c++  3  Lyh 呵呵  22.0
3  1 2017-12-12  13.0       c  3  Lyh 呵呵  23.0

2-5. 删除列
del df_obj[col_idx]

#通过del方法,删除指定一列的数据
>>> del(df_obj['G'] )
>>> print(df_obj.head())
   A          B     C       D  E     F     H
0  1 2017-12-12  10.0  python  3  Qiku  20.0
1  1 2017-12-12  11.0    java  3  Qiku  21.0
2  1 2017-12-12  12.0     c++  3  Qiku  22.0
3  1 2017-12-12  13.0       c  3  Qiku  23.0

三、Pandas的索引操作

Series和DataFrame中的索引都是Index对象
索引对象不可变,保证了数据的安全

>>> print(type(ser_obj.index))

>>> print(type(df_obj.index))

常见的Index种类
Index,索引
Int64Index,整数索引
MultiIndex,层级索引
DatetimeIndex,时间戳类型
1-1. index 指定行索引名
不指定索引的话,默认从0开始

>>> ser_obj = pd.Series(range(5), index = ['a', 'b', 'c', 'd', 'e'])
>>> print(ser_obj.head())
a    0
b    1
c    2
d    3
e    4
dtype: int64

1-2. 行索引
ser_obj[‘label’], ser_obj[pos]

# 行索引
>>> print(ser_obj['b'])
1
>>> print(ser_obj[2])
2

1-3. 切片索引
ser_obj[2:4], ser_obj[‘label1’: ’label3’]
注意,按索引名切片操作时,是包含终止索引的。

>>> print(ser_obj[1:3])
b    1
c    2
dtype: int64
>>> print(ser_obj['b':'d'])
b    1
c    2
d    3
dtype: int64

1-4. 不连续索引
ser_obj[[‘label1’, ’label2’, ‘label3’]]

>>> print(ser_obj[[0, 2, 4]])
a    0
c    2
e    4
dtype: int64
>>> print(ser_obj[['a', 'e']])
a    0
e    4
dtype: int64

1-5. 布尔索引

>>> ser_bool = ser_obj > 2
>>> print(ser_bool)
a    False
b    False
c    False
d     True
e     True
dtype: bool
>>> print(ser_obj[ser_bool])
d    3
e    4
dtype: int64
>>> print(ser_obj[ser_obj > 2])
d    3
e    4
dtype: int64

2-1. columns 指定列索引名

>>> df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
>>> print(df_obj.head())
          a         b         c         d
0  1.201658  0.347192  1.371074 -0.111690
1  0.128548 -0.095751  0.415483  0.152507
2  1.927686  0.124433  1.118890  0.031276
3 -1.281139 -0.532217  0.074102 -0.720960
4 -0.290666 -1.252714  0.191163  0.512178

2-2. 列索引
df_obj[['label']]

>>> print(df_obj['a']) # 返回Series类型
0    1.201658
1    0.128548
2    1.927686
3   -1.281139
4   -0.290666
Name: a, dtype: float64

2-3. 不连续索引

>>> print(df_obj)
          a         b         c         d
0  1.201658  0.347192  1.371074 -0.111690
1  0.128548 -0.095751  0.415483  0.152507
2  1.927686  0.124433  1.118890  0.031276
3 -1.281139 -0.532217  0.074102 -0.720960
4 -0.290666 -1.252714  0.191163  0.512178
>>> print(df_obj[['a','c']])
          a         c
0  1.201658  1.371074
1  0.128548  0.415483
2  1.927686  1.118890
3 -1.281139  0.074102
4 -0.290666  0.191163
>>> print(df_obj[[1,3]])
3.高级索引:标签、位置和混合

高级索引有三种:标签,位置,混合
3-1. loc 标签索引
loc是基于标签名的索引,也就是我们自定义的索引名

# Series
>>> print(ser_obj)
a    0
b    1
c    2
d    3
e    4
dtype: int64
>>> print(ser_obj['b':'d'])
b    1
c    2
d    3
dtype: int64
>>> print(ser_obj.loc['b':'d'])
b    1
c    2
d    3
dtype: int64

3-2.DataFrame 不能直接切片,可以通过loc来做切片

# DataFrame
>>> print(df_obj)
          a         b         c         d
0  1.201658  0.347192  1.371074 -0.111690
1  0.128548 -0.095751  0.415483  0.152507
2  1.927686  0.124433  1.118890  0.031276
3 -1.281139 -0.532217  0.074102 -0.720960
4 -0.290666 -1.252714  0.191163  0.512178
>>> print(df_obj['a'])
0    1.201658
1    0.128548
2    1.927686
3   -1.281139
4   -0.290666
Name: a, dtype: float64
# 第一个参数索引行,第二个参数是列
>>> print(df_obj.loc[0:2, 'a'])
0    1.201658
1    0.128548
2    1.927686
Name: a, dtype: float64
>>> print(df_obj.loc[1:3,['b','c']])
          b         c
1 -0.095751  0.415483
2  0.124433  1.118890
3 -0.532217  0.074102

3-2. iloc 位置索引
作用和loc一样,不过是基于索引编号来索引

# Series
>>> print(ser_obj)
a    0
b    1
c    2
d    3
e    4
dtype: int64
>>> print(ser_obj[1:3])
b    1
c    2
dtype: int64
>>> print(ser_obj.iloc[1:3])
b    1
c    2
dtype: int64
# DataFrame
>>> print(df_obj)
          a         b         c         d
0  1.201658  0.347192  1.371074 -0.111690
1  0.128548 -0.095751  0.415483  0.152507
2  1.927686  0.124433  1.118890  0.031276
3 -1.281139 -0.532217  0.074102 -0.720960
4 -0.290666 -1.252714  0.191163  0.512178
>>> print(df_obj.iloc[0:2, 0])
0    1.201658
1    0.128548
Name: a, dtype: float64

3-3. ix 标签与位置混合索引
ix是以上二者的综合,既可以使用索引编号,又可以使用自定义索引,要视情况不同来使用
如果索引既有数字又有英文,容易导致定位的混乱,那么这种方式不建议使用的

# Series
>>> print(ser_obj.ix[1:3])
b    1
c    2
dtype: int64
>>> print(ser_obj.ix['b':'c'])
b    1
c    2
dtype: int64
# DataFrame
>>> print(df_obj.loc[0:2, 'a'])
0    1.201658
1    0.128548
2    1.927686
Name: a, dtype: float64
>>> print(df_obj.ix[0:2, 0])
0    1.201658
1    0.128548
2    1.927686
Name: a, dtype: float64

四、Pandas的对齐运算

是数据清洗的重要过程,可以按索引对齐进行运算,如果没对齐的位置则补NaN

Series的对齐运算

1. Series 按行、索引对齐
ser_obj1 + ser_obj2

>>> ser_obj1 = pd.Series(range(10, 20), index = range(10))
>>> ser_obj2 = pd.Series(range(20, 25), index = range(5))
>>> print(ser_obj1)
0    10
1    11
2    12
3    13
4    14
5    15
6    16
7    17
8    18
9    19
dtype: int64
>>> print(ser_obj2)
0    20
1    21
2    22
3    23
4    24
dtype: int64
>>> print(ser_obj1.add(ser_obj2))
0    30.0
1    32.0
2    34.0
3    36.0
4    38.0
5     NaN
6     NaN
7     NaN
8     NaN
9     NaN
dtype: float64
DataFrame的对齐运算

1. DataFrame 按行、索引对齐
DataFrame做对齐运算时,未对齐数据可以通过fill_value来指定数据做对齐运算
add,sub,mul,div,加减乘除

五、Pandas的函数应用

1. 可直接使用NumPy的函数
在numpy里,可以对数组里的每一个元素进行操作的函数称为ufunc 通用函数(universal function)
在Pandas里可以直接使用Numpy的ufunc

>>> df = pd.DataFrame(np.random.randn(5,4) - 1)
>>> print(df)
          0         1         2         3
0 -1.146296 -1.067455 -2.439676 -0.680181
1 -1.835651 -1.495050 -1.646479 -1.546212
2 -0.121636  0.126804 -3.583221 -3.205977
3 -0.361062  0.139010 -0.816511 -0.800901
4 -0.569759 -1.029041 -1.010752 -1.747664
>>> print(np.abs(df))
          0         1         2         3
0  1.146296  1.067455  2.439676  0.680181
1  1.835651  1.495050  1.646479  1.546212
2  0.121636  0.126804  3.583221  3.205977
3  0.361062  0.139010  0.816511  0.800901
4  0.569759  1.029041  1.010752  1.747664

2. 通过apply将函数应用到列或行上
Axis参数可以指定轴向,默认值为0,方向是列,值为1:方向是行

>>> f = lambda x : x.max()
>>> print(df.apply(lambda x : x.max()))
0   -0.121636
1    0.139010
2   -0.816511
3   -0.680181
dtype: float64
>>> print(df.apply(lambda x : x.max(), axis=1))
0   -0.680181
1   -1.495050
2    0.126804
3    0.139010
4   -0.569759
dtype: float64

3. 通过applymap将函数应用到每个数据上,只用于DataFrame

>>> f1 = lambda x : '%.2f' % x
>>> print(df.applymap(f1))
       0      1      2      3
0  -1.15  -1.07  -2.44  -0.68
1  -1.84  -1.50  -1.65  -1.55
2  -0.12   0.13  -3.58  -3.21
3  -0.36   0.14  -0.82  -0.80
4  -0.57  -1.03  -1.01  -1.75
>>> f2 = lambda x: x+x
>>> print(df_obj.applymap(f2))
          a         b         c         d
0  2.403316  0.694383  2.742148 -0.223379
1  0.257097 -0.191501  0.830965  0.305015
2  3.855371  0.248867  2.237779  0.062553
3 -2.562277 -1.064433  0.148205 -1.441920
4 -0.581332 -2.505427  0.382325  1.024356

4.DataFrame对象可以用apply()和applymap()
apply()应用于行,列,可以通过axis来指定
Series对象只能用apply ,效果等于Pyton的map()
ser_obj.map(func)
ser_obj.apply(func)

5.排序

分为按索引排序和按值排序
5-1. 索引排序
sort_index()
排序默认使用升序排序,ascending=False 为降序排序

# Series
>>> ser_obj2 = pd.Series(range(10, 15), index = np.random.randint(5, size=5))
>>> print(ser_obj2)
1    10
1    11
2    12
4    13
4    14
dtype: int64
>>> ser_obj2.sort_index()
1    10
1    11
2    12
4    13
4    14
dtype: int64
>>> print(ser_obj2.sort_index(ascending = False))  #降序排序
4    13
4    14
2    12
1    10
1    11
dtype: int64

5-2.对DataFrame操作时注意轴方向,默认列,axis = 1 为行

# DataFrame
>>> df_obj = pd.DataFrame(np.random.randn(3, 5),
...                    index=np.random.randint(3, size=3),
...                    columns=np.random.randint(5, size=5))
>>> print(df_obj )
          2         3         3         3         1
2  1.257445 -1.205098  0.128585  0.157959 -0.190920
1 -1.885108 -1.150302  0.688331  0.661057 -0.939931
1  1.220114 -0.820277 -0.691313 -0.562682  1.460008
>>> df_obj_isort = df4.sort_index(axis=1, ascending=False)
>>> print(df_obj_isort)
   lval key4 key3
0     4  one  foo
1     5  one  foo
2     6  one  bar
3     7  two  bar

5-3.按值排序
sort_values(by='column name')
根据某个唯一的列名进行排序,如果有其他相同列名则报错
①按值排序 - Series对象 – 范例

#创建随机Series对象
>>> ser_obj = pd.Series(np.random.randint(10,20,size= 10))
>>> print(ser_obj)
0    15
1    14
2    12
3    13
4    19
5    10
6    13
7    18
8    11
9    10
dtype: int32
>>> print(ser_obj.sort_values()) #默认升序
5    10
9    10
8    11
2    12
3    13
6    13
1    14
0    15
7    18
4    19
>>> print(ser_obj.sort_values(ascending = False)) #降序
4    19
7    18
0    15
1    14
6    13
3    13
2    12
8    11
9    10
5    10
dtype: int32

②.按值排序 - DataFrame对象 – 范例

如果根据某一个行名/列名来排序时,要保证没有其他相同的行名/列名,axis 指定排序的轴方向

>>> df4 = pd.DataFrame(np.random.randn(3, 5), index=np.random.randint(3, size=3), columns=np.random.randint(5, size=5))

6.处理缺失数据

df_obj = pd.DataFrame([[1,2,np.nan,np.nan], [np.nan,3,4,np.nan],list(range(4)])
#   如果某一列中有一个数是Nan或者浮点数,其他数都转换为浮点数
print(df_obj)

6-1. 判断是否存在缺失值:isnull()

#判断是否NaN值,如果是返回True,否则False
print(df_data.isnull())

6-2. 丢弃缺失数据:dropna()
根据axis轴方向,丢弃包含NaN的行或列。
范例

有NaN的时候把相应的行/列去除掉,默认去除行,axis = 1时,去除列

print(df_obj.dropna())
print(df_obj.dropna(axis = 1))
6-3. 填充缺失数据:fillna()
将NaN值替换为指定的值
范例

将NaN值替换为0

print(df_obj.fillna(0))

你可能感兴趣的:(数据分析工具Pandas(一))