Python数据分析入门--pandas基础学习笔记
文章目录
- 前言
- Pandas基础
-
- 1.pandas数据结构
-
- 1.1 Series对象
- 1.2 DataFrame对象
- 1.3 索引对象
- 2.pandas基本功能
-
- 2.1重建索引
- 2.2 轴向上删除条目
- 2.3 索引切片和选择
- 2.4 运算方法和数据对齐
- 2.5 函数应用和映射
- 2.6 数据排序和排名
- 3.pandas的统计与计算
-
- 3.1常用的统计方法
- 3.2 相关性和协方差
- 3.3 唯一值、计数和成员属性
- 总结
前言
Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来，享有数据分析“三剑客之一”的盛名（NumPy、Matplotlib、Pandas）。Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具。尽管pandas采用了很多NumPy的代码风格，但pandas主要用于处理表格型或异质型数据，NumPy主要用于处理同质型数据。
Pandas基础
1.pandas数据结构
1.1 Series对象
Series是一种一维的数组型对象，和NumPy中的多维数组对象ndarray有所区别。Series包含一个值的序列和索引（index），默认生成的索引是从0开始到数据个数减一
import pandas as pd
arr1 = pd.Series([2,3,4,5,6])
arr2 = pd.Series([2,3,4,5,6],index=['a','b','c','d','e'])
print(arr1)
print(arr2.index)
print(arr2['c'])
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
0 2
1 3
2 4
3 5
4 6
dtype: int64
Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
4
#Process finished with exit code 0
生成Series对象前的数组可以自己创建一个索引序列，索引序列位会和数组数据位一一对应，这就简单实现了NumPy中间接排序的小环节。Pandas继承了NumPy很多的特性，比如数组的广播，而且Pandas在使用函数或者进行其他操作时总是与索引密不可分，比如利用布尔值数组进行过滤依然保存索引值的连接
import pandas as pd
import numpy as np
arr1 = pd.Series([2,3,4,5,6],index=['a','b','c','d','e'])
arr2 = pd.Series({'Jack':65,'Janes':50,'James':60},index=['Jack','Janes','James','Jaskon'])
print(arr1[arr1>3])
print(np.exp(arr1))
print(arr2)
print(65 in arr2)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
c 4
d 5
e 6
dtype: int64
a 7.389056
b 20.085537
c 54.598150
d 148.413159
e 403.428793
dtype: float64
Jack 65.0
Janes 50.0
James 60.0
Jaskon NaN
dtype: float64
False
#Process finished with exit code 0
当我们将Python内建的字典传入来生成Series对象时，我们会发现字典中的key值自动默认为索引序列，字典中的value值自动默认为数组元素，字典中的每个键值对就组成一个基础的数组。
上述程序中，因为字典中的键中缺少’Jackson，所以当返回’Jackson’作为索引值的数据时终端打印了NaN值(not a number)，这是pandas中标记缺失值或NA值的方式。
import pandas as pd
arr1 = pd.Series({'Jack':65,'Janes':50,'James':60},index=['Jack','Janes','James','Jaskon'])
print(pd.isnull(arr1))
arr1.name = 'Weight'
arr1.index.name = 'Name'
print(arr1)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
Jack False
Janes False
James False
Jaskon True
dtype: bool
Name
Jack 65.0
Janes 50.0
James 60.0
Jaskon NaN
Name: Weight, dtype: float64
#Process finished with exit code 0
为了方便快速查找数组的缺失数据，我们可以利用pandas的isnull函数和notnull函数，它们会返回布尔序列来帮助我们判断NaN值。Series对象自身和其索引都带有name属性，就像给人起个名字一样，pandas的name属性为数据的归类统一提供了可操作性。
1.2 DataFrame对象
DataFrame表示的是矩阵的数据表，它包含已排序的列集合，每一列可以是不同的值类型（数值，字符串，布尔值等），利用DataFrame对象就可以轻而易举实现NumPy结构化数组的操作。DataFrame既有行索引也有列索引，它可以被视为一个共享相同索引的Series字典
import pandas as pd
data1 = {'name':['Jack','Jane','James'],
'age':['18','16','17'],
'weight':['70','50','60']}
arr1 = pd.DataFrame(data1)
print(arr1)
print(pd.DataFrame(data1,index=['boy','girl','boy']))
print(pd.DataFrame(data1,columns=['name','age','weight','height'],index=['boy','girl','boy']))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
name age weight
0 Jack 18 70
1 Jane 16 50
2 James 17 60
name age weight
boy Jack 18 70
girl Jane 16 50
boy James 17 60
name age weight height
boy Jack 18 70 NaN
girl Jane 16 50 NaN
boy James 17 60 NaN
#Process finished with exit code 0
最常用的构建DataFrame对象的方式是传递一个字典，无论内容是列表还是NumPy数组。DataFrame的行索引默认是数字，当然你也可以根据数据归类的要求来传递DataFrame对象的行索引。当我们传递的数组元素或索引没有包含在字典里也会生成缺失值NaN
import numpy as np
import pandas as pd
data1 = {'name':['Jack','Jane','James'],
'age':['18','16','17'],
'weight':['70','50','60']}
arr1 = pd.DataFrame(data1,index=['boy','girl','boy'])
arr2 = pd.DataFrame(data1,columns=['name','age','weight','height'],index=['boy','girl','boy'])
arr2.height = np.arange(190,160,-10)
print(arr1.weight)
print(arr1.loc['boy'])
print(arr2)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
boy 70
girl 50
boy 60
Name: weight, dtype: object
name age weight
boy Jack 18 70
boy James 17 60
name age weight height
boy Jack 18 70 190
girl Jane 16 50 180
boy James 17 60 170
#Process finished with exit code 0
巧妙的利用DataFrame设置的各种索引，比如行也可以通过位置和特殊属性loc进行选取，我们就可以访问我们想要的数据，访问索引返回数据的方式直观上有点像切片。我们也可以利用索引来操作DataFrame内部的元素。
import numpy as np
import pandas as pd
data1 = {'name':['Jack','Jane','James'],
'age':['18','16','17'],
'weight':['70','50','60']}
arr1 = pd.DataFrame(data1,index=['boy','girl','boy'])
arr1['male'] = arr1.index == 'boy'
arr2 = pd.DataFrame(data1,columns=['name','age','weight','height'],index=['boy','girl','boy'])
data2 = pd.Series([190],index=['boy'])
arr2.height = data2
print(arr1)
print(arr2)
del arr2['height']
print(arr2)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
name age weight male
boy Jack 18 70 True
girl Jane 16 50 False
boy James 17 60 True
name age weight height
boy Jack 18 70 190.0
girl Jane 16 50 NaN
boy James 17 60 190.0
name age weight
boy Jack 18 70
girl Jane 16 50
boy James 17 60
#Process finished with exit code 0
当我们用列表赋值给DataFrame对象的新一列要确保值的长度和DataFrame的长度相匹配；当我们将Series赋值给某一列，DataFrame对象会根据自身索引重排Series对象的索引，并填充缺失值。
利用是非判断也可以为DataFrame新增一列，这列会变成布尔序列，这种操作经常用来对数据进行二分搜查。del关键字用于删除DataFrame对象的列
import numpy as np
import pandas as pd
data1 = {'name':{'boy':'Jack','girl':'Jane'},
'age':{'boy':'18','girl':'16'},
'weight':{'boy':'70','girl':'50'}}
arr1 = pd.DataFrame(data1)
print(arr1)
print(arr1.T)
print(arr1.values)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
name age weight
boy Jack 18 70
girl Jane 16 50
boy girl
name Jack Jane
age 18 16
weight 70 50
[['Jack' '18' '70']
['Jane' '16' '50']]
#Process finished with exit code 0
假如我们传递一个嵌套的字典来生成DataFrame对象，pandas会将字典的键作为列，将内部字典的键作为索引，分级索引的方式类似于NumPy的多维数组。DataFrame对象自带NumPy数组的T属性，可以直接进行轴转置操作；DataFrame的values属性会将包含在DataFrame的数据以二维ndarray形式返回。
1.3 索引对象
pandas中的索引对象用于储存轴标签和其他元数据，在构造DataFrame时，所使用的任意数组或标签序列都可以在内部转化为索引对象。
import pandas as pd
data1 = {'name':{'boy':'Jack','girl':'Jane'},
'age':{'boy':'18','girl':'16'},
'weight':{'boy':'70','girl':'50'}}
arr1 = pd.DataFrame(data1)
print(arr1.columns)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
Index(['name', 'age', 'weight'], dtype='object')
#Process finished with exit code 0
与Python集合不同，pandas索引对象可以包含重复标签。以下是pandas索引对象的属性和方法汇总
2.pandas基本功能
2.1重建索引
重建pandas对象的索引方法有很多种，最常用的方法是reindex。当Series对象调用reindex方法时，会将数据按新的索引进行排列，不存在会填充缺失值NaN;当DataFrame对象调用reindex方法则会根据传递的参数改变行索引和列索引
import numpy as np
import pandas as pd
data1 = {'name':{'boy':'Jack','girl':'Jane'},
'age':{'boy':'18','girl':'16'},
'weight':{'boy':'70','girl':'50'}}
arr1 = pd.DataFrame(data1)
arr2 = pd.Series([2,4,6,8],index=['d','c','b','a'])
print(arr1)
print('\n')
print(arr2)
print('\n')
print(arr1.reindex(['girl','boy']))
print('\n')
print(arr2.reindex(['a','b','c','d']))
print('\n')
print(arr1.reindex(columns=['age','name','weight']))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
name age weight
boy Jack 18 70
girl Jane 16 50
d 2
c 4
b 6
a 8
dtype: int64
name age weight
girl Jane 16 50
boy Jack 18 70
a 8
b 6
c 4
d 2
dtype: int64
age name weight
boy 18 Jack 70
girl 16 Jane 50
#Process finished with exit code 0
DataFrame对象调用reindex默认是重建行索引，也可以通过传递关键字columns重建列索引。对于顺序数据，我们重建索引时可能需要插值或填值。method参数允许使用多种方法在重建索引时插值，比如ffill方法会将值向前填充
import numpy as np
import pandas as pd
arr1 = pd.Series([2,4,6,8],index=[2,4,6,8])
print(arr1)
print('\n')
print(arr1.reindex(range(2,10),method='ffill'))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
2 2
4 4
6 6
8 8
dtype: int64
2 2
3 2
4 4
5 4
6 6
7 6
8 8
9 8
dtype: int64
#Process finished with exit code 0
| 参数 | 描述 |
|---|---|
| keys | 包含行索引或列标签的字符串或列表 |
| method | 指定填充索引时使用的方法，仅用于增加/减少索引 |
| copy | 所有新索引与旧索引相同时是否返回新对象 |
| level | 匹配MultiIndex级别的简单索引，否则选择子集 |
| fill_value | 指定用于缺少值的值 |
| limit | 当前向填充或后向时，所需填充的最大尺寸间隙（以元素数量为参考） |
| tolerance | 当前向填充或后向时，所需填充的不精确匹配下的最大尺寸间隙（以绝对数字距离为参考） |
2.2 轴向上删除条目
在pandas对象的轴向上删除条目非常快捷，我们只需要用drop方法，通过传递元组来对指定条目进行删除。对于DataFrame对象来说，我们可以利用NumPy之前的轴参数axis来指定轴进行操作。
import numpy as np
import pandas as pd
arr1 = pd.Series([2,4,6,8],index=[2,4,6,8])
data = {'name':{'boy':'Jack','girl':'Jane'},
'age':{'boy':'18','girl':'16'},
'weight':{'boy':'70','girl':'50'}}
arr2 = pd.DataFrame(data)
print(arr1.drop([4,8]))
print('\n')
print(arr2.drop(['weight'],axis='columns'))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
2 2
6 6
dtype: int64
name age
boy Jack 18
girl Jane 16
#Process finished with exit code 0
在DataFrame对象中调用drop方法时，默认是按标签序列即行来删除，我们可以传递axis=1或axis='columns’来从列进行删除。
2.3 索引切片和选择
Series对象的索引和NumPy数组的索引功能类似，即使我们将Series对象的索引重置为非数字索引，我们依然可以利用数字索引进行切片，大大拓宽数组元素索引的多样性，值得注意的是Series的标签切片是包含结尾的
import numpy as np
import pandas as pd
arr1 = pd.Series([1,3,5,7],index=['a','b','c','d'])
print(arr1['b':'d'])
print('\n')
print(arr1[1:3])
print('\n')
arr1[1:3]=3
print(arr1)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
b 3
c 5
d 7
dtype: int64
b 3
c 5
dtype: int64
a 1
b 3
c 3
d 7
dtype: int64
#Process finished with exit code 0
DataFrame对象作为数据表所以索引切片的方式更加多样，除了基本的行列标签索引切片，同样也支持整数索引切片，简单来说DataFrame的索引就是Series对象索引的二维拓扑，而且还自带很多buff加成。
import numpy as np
import pandas as pd
data1 = {'name':{'P1':'Jack','P2':'James'},
'times':{'P1':'10','P2':'15'},
'scores':{'P1':'18','P2':'32'}}
arr1 = pd.DataFrame(data1)
arr2 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['a','b','c'])
print(arr1[['times','scores']])
print('\n')
print(arr1[:1])
print('\n')
print(arr2>5)
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
times scores
P1 10 18
P2 15 32
name times scores
P1 Jack 10 18
a b c
0 False False False
1 False False False
2 True True True
#Process finished with exit code 0
DataFrame对象通过比较大小会返回一个布尔值的列表，经常用于数据的过滤。
针对DataFrame在行上的标签索引，我们可以利用特殊索引符号loc和iloc，它们可以通过轴标签或整数标签以NumPy的风格语法从DataFrame对象选出数组的行和列的子集
import numpy as np
import pandas as pd
data1 = {'name':{'P1':'Jack','P2':'James'},
'times':{'P1':'10','P2':'15'},
'scores':{'P1':'18','P2':'32'}}
arr1 = pd.DataFrame(data1)
arr2 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['a','b','c'])
print(arr1.loc['P2','scores'])
print('\n')
print(arr2.iloc[:,:2][arr2.b>2])
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
32
a b
1 3 4
2 6 7
#Process finished with exit code 0
下面是DataFrame对象索引选项的汇总
| 类型 | 描述 |
|---|---|
| df[val] | 选取DataFrame的单个列或一组列 |
| df.loc[val] | 根据标签选取DataFrame的单行或多行 |
| df.loc[:, val] | 根据标签选取单列或多列 |
| df.loc[val1, val2] | 同时选取行和列的一部分 |
| df.iloc[where] | 根据整数的位置选择单行或多行 |
| df.iloc[:, where] | 根据整数的位置选择单列或多列 |
| df.iloc[where_i, where_j] | 根据整数的位置选择行和列 |
| df.at[label_i, label_j] | 根据行列标签选择单个标量 |
| df.iat[i, j] | 根据行列整数的位置选择单个标量 |
| get_value, set_value | 根据行和列标签设置单个值 |
2.4 运算方法和数据对齐
pandas在不同索引的对象之间进行运算时采用数据对齐的模式，比如当两个Series对象相加时索引对不相同，会返回索引对的并集的Series对象，但索引位对不上号的元素会变为缺失值NaN，同理DataFrame对象之间的相互操作也会遵循这种法则
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.arange(16).reshape(4,4),columns=['a','b','c','d'])
arr2 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['a','b','c'])
arr3 = pd.Series(np.random.randn(3))
arr4 = pd.Series(np.random.randn(4))
print(arr1 * arr2)
print('\n')
print(arr3 + arr4)
print('\n')
print(arr1.add(arr2,fill_value=0))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a b c d
0 0.0 1.0 4.0 NaN
1 12.0 20.0 30.0 NaN
2 48.0 63.0 80.0 NaN
3 NaN NaN NaN NaN
0 0.175205
1 -0.582145
2 0.413104
3 NaN
dtype: float64
a b c d
0 0.0 2.0 4.0 3.0
1 7.0 9.0 11.0 7.0
2 14.0 16.0 18.0 11.0
3 12.0 13.0 14.0 15.0
#Process finished with exit code 0
正常来说NaN缺失值和对应索引位的值进行运算也会返回NaN缺失值，所以在DataFrame对象上使用add方法就可以进行数据填充。pandas自带的运算函数能基本满足简单的算术需求
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['a','b','c'])
arr2 = pd.DataFrame(np.arange(10,19).reshape(3,3),columns=['a','b','c'])
print(pow(arr1,arr2))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a b c
0 0 1 4096
1 1594323 268435456 30517578125
2 2821109907456 232630513987207 18014398509481984
#Process finished with exit code 0
以下是运算方法汇总
| 方法 | 描述 |
|---|---|
| add, radd | 加法 |
| sub, rsub | 减法 |
| div, rdiv | 除法 |
| floordiv, rfloordiv | 整除 |
| mul, rmul | 乘法 |
| pow, rpow | 幂次方 |
DataFrame和Series之间的操作原理类似NumPy中的广播，广播最重要的原则就是轴长度的相互匹配，pandas中的广播还需要索引相匹配，我们可以通过传递axis的参数来指定轴进行广播
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['a','b','c'],index=['a','b','c'])
arr2 = pd.Series(np.arange(3),index=['a','b','c'])
print(arr1-arr2)
print('\n')
print(arr1.pow(arr2,axis='index'))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a b c
a 0 0 0
b 3 3 3
c 6 6 6
a b c
a 1 1 1
b 3 4 5
c 36 49 64
#Process finished with exit code 0
2.5 函数应用和映射
NumPy中的一元二元通用函数（ufunc）在pandas对象中同样适用，比如可以求绝对值的函数abs。DataFrame对象中经常使用apply方法来将通用函数应用到一维数组上，这样我们就可以组合通用函数形成更加复杂的函数应用于数据统计于分析
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.random.randn(3,3),columns=['a','b','c'],index=['a','b','c'])
print(arr1)
print('\n')
print(np.abs(arr1))
print('\n')
print(arr1.mean(axis=0))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a b c
a 0.558298 1.410313 0.087460
b 0.589810 0.035628 -0.052387
c 0.762054 0.205924 0.343325
a b c
a 0.558298 1.410313 0.087460
b 0.589810 0.035628 0.052387
c 0.762054 0.205924 0.343325
a 0.636721
b 0.550622
c 0.126133
dtype: float64
#Process finished with exit code 0
编写复杂的NumPy函数时，我们会使用lambda表达式，lambda 函数在 Python 编程语言中使用频率非常高，使用起来非常灵活、巧妙。lambda 函数是匿名的，它有输入和输出，也拥有自己的命名空间
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.random.randn(3,3),columns=['a','b','c'],index=['a','b','c'])
f = lambda x: x.max() - x.min()
format = lambda x: '%.2f' % x
print(arr1)
print('\n')
print(arr1.apply(f))
print('\n')
print(arr1.applymap(format))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a b c
a -1.467332 -1.416377 1.049756
b -0.391391 0.245344 -0.067097
c 0.534653 0.075703 -0.595511
a 2.001985
b 1.661721
c 1.645267
dtype: float64
a b c
a -1.47 -1.42 1.05
b -0.39 0.25 -0.07
c 0.53 0.08 -0.60
#Process finished with exit code 0
上述代码中我们利用lambda表达式编写最大差值函数和浮点数精度函数，其中也使用applymap方法，效果和apply方法差不多
2.6 数据排序和排名
根据某些准则对数据集进行排序是一种重要的内建操作，pandas对象中可以使用sort_index方法按行或按列对索引进行字典型排序，会返回一个新的索引对象。sort_index方法默认是将行的索引进行排序，我们也可以传递axis参数将列的索引排序
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['b','a','c'],index=['c','b','a'])
arr2 = pd.Series(np.arange(3),index=['a','c','b'])
print(arr2.sort_index())
print('\n')
print(arr1.sort_index())
print('\n')
print(arr1.sort_index(axis=1))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a 0
b 2
c 1
dtype: int64
b a c
a 6 7 8
b 3 4 5
c 0 1 2
a b c
c 1 0 2
b 4 3 5
a 7 6 8
#Process finished with exit code 0
pandas对象中也可以通过sort_values方法根据数据值进行排序，默认数值排序和索引排序都是升序，索引排序也可以通过传递ascending=False来实现降序排列
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.random.randn(3,3),columns=['a','b','c'],index=['a','b','c'])
arr2 = pd.Series(np.random.randn(3),index=['a','b','c'])
print(arr2.sort_values())
print('\n')
arr2[2] = np.nan
print(arr2.sort_values())
print('\n')
print(arr1.sort_values(by=['a','b','c']))
print('\n')
print(arr1.sort_values(by='c'))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a -1.845806
b -1.343287
c 0.677122
dtype: float64
a -1.845806
b -1.343287
c NaN
dtype: float64
a b c
b 0.182068 0.690903 -1.133839
a 0.810179 -0.726918 -1.865067
c 0.837042 -1.572999 -0.897297
a b c
a 0.810179 -0.726918 -1.865067
b 0.182068 0.690903 -1.133839
c 0.837042 -1.572999 -0.897297
#Process finished with exit code 0
排名是指对数组从1到有效数据点总数分配名次的操作，通过rank方法给Series对象和DataFrame对象的每个组分配平均排名。如果数组元素有相同的情况，默认的平均排名方法就会取排名值的平均值，所以会出先小数
import numpy as np
import pandas as pd
arr1 = pd.DataFrame(np.arange(9).reshape(3,3),columns=['a','b','c'],index=['a','b','c'])
arr2 = pd.Series([4,6,7,-3,7,-2,4,1])
print(arr2.rank())
print('\n')
print(arr2.rank(method='first'))
print('\n')
print(arr1.rank(method='max'))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
0 4.5
1 6.0
2 7.5
3 1.0
4 7.5
5 2.0
6 4.5
7 3.0
dtype: float64
0 4.0
1 6.0
2 7.0
3 1.0
4 8.0
5 2.0
6 5.0
7 3.0
dtype: float64
a b c
a 1.0 1.0 1.0
b 2.0 2.0 2.0
c 3.0 3.0 3.0
#Process finished with exit code 0
我们可以传递method的方法参数实现不同的排名效果，以下是汇总
| 方法 | 描述 |
|---|---|
| ‘average’ | 默认值，每个组中分配平均排名 |
| ‘min’ | 对整个组使用最小排名 |
| ‘max’ | 对整个组使用最大排名 |
| ‘first’ | 按照数据出现位置的次序分配排名 |
| ‘dense’ | 组间排名总是加1，类似于’min’ |
3.pandas的统计与计算
3.1常用的统计方法
pandas对象封装了一个常用数学、统计学方法的集合，大部分属于归约或汇总统计的类别。这些方法内建处理缺失值的功能，我们处理数据时就不需要过多担心缺失值NaN的存在
import numpy as np
import pandas as pd
arr1 = pd.DataFrame([[2,-1],[np.nan,5],[3,4]],columns=['a','b'],index=['a','b','c'])
print(arr1.sum())
print('\n')
print(arr1.mean(skipna=False))
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a 5.0
b 8.0
dtype: float64
a NaN
b 2.666667
dtype: float64
#Process finished with exit code 0
我们可以通过禁用skipna来实现统计时不排除NaN值，以下是归约方法常用可选参数列表
| 方法 | 描述 |
|---|---|
| axis | 归约轴，0为行向，1为列项 |
| skipna | 排除缺失值，默认为True |
| level | 针对轴是多层索引，缩减分层级数 |
除了归约方法，比如idxmin和idxmax返回最小值或最大值的索引值，还有累积型方法，还有一类方法describe可以一次性产生多个汇总统计
import numpy as np
import pandas as pd
arr1 = pd.DataFrame([[2,-1],[np.nan,5],[3,4]],columns=['a','b'],index=['a','b','c'])
print(arr1.idxmax())
print('\n')
print(arr1.describe())
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
a c
b b
dtype: object
a b
count 2.000000 3.000000
mean 2.500000 2.666667
std 0.707107 3.214550
min 2.000000 -1.000000
25% 2.250000 1.500000
50% 2.500000 4.000000
75% 2.750000 4.500000
max 3.000000 5.000000
#Process finished with exit code 0
3.2 相关性和协方差
协方差（Covariance）能反映两个样本/变量之间的相互关系以及之间的相关程度， 期望值分别为E[X]与E[Y]的两个实随机变量X与Y之间的协方差Cov(X,Y)定义为：
相关系数（Correlation coefficient）能反映两个样本/样本之间的相互关系以及之间的相关程度
其中，Cov(X,Y)为X与Y的协方差，Var[X]为X的方差，Var[Y]为Y的方差
书中爬取并分析 Yahoo! Fiannce（雅虎金融）的股票价格和成交量，为获取金融数据需要安装pandas_datareader包和fix_yahoo_finance包
conda install pandas-datareader
书中为了获得一些股票行情，使用了pandas_datareader模块下载一些数据
>>>import pandas as pd
>>>import pandas_datareader.data as web
>>>import yfinance as yf
>>>all_data={ticker:web.get_data_yahoo(ticker)
>>> for ticker in ['AAPL','IBM','MSFT','GOOG']}
>>>price=pd.DataFrame({ticker:data['Adj Close']
>>> for ticker,data in all_data.items()})
>>>volume=pd.DataFrame({ticker:data['Volume']
>>> for ticker,data in all_data.items()})
>>>returns=price.pct_change() #计算价格的百分比
>>>returns.tail()
AAPL GOOG IBM MSFT
Date
2016-10-17 -0.000680 0.001837 0.002072 -0.003483
2016-10-18 -0.000681 0.019616 -0.026168 0.007690
2016-10-19 -0.002979 0.007846 0.003583 -0.002255
2016-10-20 -0.000512 -0.005625 0.001719 -0.004867
2019-10-21 -0.003930 0.003011 -0.012474 0.042096
Series中的corr方法用于计算两个Series对象中重叠的、非NaN值的、按索引对齐的值的相关性，cov方法计算的是协方差
3.3 唯一值、计数和成员属性
在NumPy中我们也遇到过计算唯一值的方法，同样在pandas中也适用。unique函数会给出Series对象中的唯一值，value_counts函数用于计算Series对象中包含的值的个数
import numpy as np
import pandas as pd
arr1 = pd.Series(['a','b','c','b','a'])
print(arr1.unique())
print('\n')
print(arr1.value_counts())
#/usr/bin/python3.8 /home/ljm/PycharmProject/pythoncode1/code5.py
['a' 'b' 'c']
a 2
b 2
c 1
dtype: int64
#Process finished with exit code 0
下面是唯一值、计数和成员属性有关的方法汇总
| 方法 | 描述 |
|---|---|
| isin | 计算表征Series中每一个值是否包含于传入序列，返回布尔值数组 |
| match | 计算数组每个值的整数索引，形成一个唯一值数组，有助于数据对齐和join类型操作 |
| unique | 计算Seriess值中的唯一值数组，按照数据出现的先后次序返回 |
| value_counts | 返回一个Series，值是计数个数，按照降序排序 |
总结
以上就是今天笔记的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法，继续学习pandas进阶