利用Python进行数据分析之pandas

Numpy能够帮助我们处理数值型数据，但是这还不够，我们的数据除了数值以外，还有字符串还有时间序列等等，所以pandas出现了。pandas是一个强大的分析结构话数据的工具集，基于Numpy构建，提供了高级数据结构和数据操作工具，是使Python成为强大而高效的数据分析环境的重要因素之一

• 一个强大的分析和操作大型结构化数据集所需的工具集

• 基础是numpy，提供了高性能矩阵的运算

• 提供了大量能够快速便捷地处理数据的函数和方法

• 应用于数据挖掘，数据分析

• 提供数据清洗功能

详细pandas内容可前往pandas官方网站进行学习。

pandas数据结构

为了入门pandas，需要熟悉两个常用的工具数据结构：Series
和DataFrame
。尽管它们并不能解决所有问题，但它们为大多数应用提供了一个有效、易用的基础。

Series

Series是一种一维的数组型对象，包含一个值序列，并且包含了数据标签（index）。

import pandas as pd
import numpy as np
# Series是一种一维的数组型对象，包含一个值序列和索引，索引（index）在左边，值（value）在右边
# 默认的索引是从0开始到N-1（N是数据的长度）

def prints(a):
   print(a)
   print('='*30)
# 创建Series的方法有三种
   # 通过list创建：
obj = pd.Series([4,7,-5,3])
prints(obj)
prints(obj.values)
prints(obj.index) # 与 range(4) 类似
prints(obj[1])
obj2 = pd.Series([4,7,-5,3],index=['d','b','a','c'])
prints(obj2.index)
prints(obj2['a'])

   # 通过数组创建
obj3 = pd.Series(np.arange(1,6))
prints(obj3)

   # 通过字典创建
sdata = {'Tom':180,'Jim':175,'Lily':168,'Jerry':185}
obj4 = pd.Series(sdata)
prints(obj4)

Series的基本用法包括

• isnull notnull 检查缺失值

• 通过索引获取数据

• 数据对齐：在数学操作中自动对齐索引

• Series的name属性

import pandas as pd
import numpy as np
def prints(a):
   print(a)
   print('='*30)
# isnull notnull 检查缺失值
sdata = {'Tom':180,'Jim':175,'Lily':168,'Jerry':185}
obj1 = pd.Series(sdata,index=['Tom','Jim','Lily','Jerry','Toby'])
prints(obj1)
prints(pd.isnull(obj1))
prints(pd.notnull(obj1))
prints(obj1.isnull()) # 实例方法
prints(obj1.notnull())
# 通过索引/切片获取数据
prints(obj1.index)
prints(obj1.values)
prints(obj1['Tom'])
prints(obj1[0])
prints(obj1[['Tom','Lily']]) #选取多个值
prints(obj1[1:3]) # 切片取值
prints(obj1['Tom':'Jerry']) # 标签切片包含末端数据
prints(obj1[obj1>170]) # 布尔索引
# 索引与数据的对应关系不被运算结果影响
prints(obj1 * 2)
# name属性
obj1.name = 'height'
obj1.index.name = 'name'
prints(obj1)
prints(obj1.head(3)) # 打印前3行
prints(obj1.tail(3)) # 打印后3行

DataFrame

DataFrame是表示矩阵的数据表，它包含已排序的列集合，每一列可以是不同的数据类型。DataFrame有行索引也有列索引，数据被存储为一个以上的二维块。后续可以利用分层索引在DataFrame中展现更高维度的数据。

常用的构建DataFrame的方式是利用Numpy数组的字典或包含等长度列表。

1. 通过字典创建DataFrame

   import pandas as pd
   import numpy as np
   def prints(a):
      print(a)
      print('='*30)
   # 字典类：
      # 数组、列表或元组构成的字典构造dataframe
   data1 = {'a':[1,2,3,4],'b':[5,6,7,8],'c':np.arange(9,13)}
   frame1 = pd.DataFrame(data1)
   prints(frame1)
   prints(frame1.index) # 行索引
   prints(frame1.columns) # 列索引
   prints(frame1.values) # 值
   frame2 = pd.DataFrame(data1,index=['A','B','C','D'],columns=['a','v','c','d'])
   prints(frame2)
      # Series构成的字典构造dataframe
   frame3 = pd.DataFrame({'a':pd.Series(np.arange(3)),'b':pd.Series(np.arange(3,5))})
   prints(frame3)
      # 字典构成的字典构造dataframe
   data2 = {
      'a':{'apple':3.6,'banana':'5.6'},
      'b':{'apple':3.6,'banana':'5.6'},
      'c':{'apple':3.6}
   }
   frame4 = pd.DataFrame(data2)
   prints(frame4)

2. 通过列表创建DataFrame

   import pandas as pd
   import numpy as np
   
   def prints(a):
      print(a)
      print('='*30)
   
   # 列表类
      # 2D ndarray构造dataframe
   arr1 = np.arange(12).reshape(4,3)
   prints(arr1)
   frame1 = pd.DataFrame(arr1,index=['a','b','c','d'],columns=['A','B','C'])
   prints(frame1)
      # 字典构成的列表构造dataframe
   list1 = [{'apple':3.6,'banana':5.6},{'apple':3,'banana':5},{'apple':3.2}]
   frame2 = pd.DataFrame(list1,index=['a','b','c'])
   prints(frame2)
      # Series构成的列表构造dataframe
   list2 = [pd.Series(np.random.rand(3)),pd.Series(np.random.rand(2))]
   frame3 = pd.DataFrame(list2)
   prints(list2)
   prints(frame3)

1. DataFrame构造函数的有效输入

   类型	描述
   2D ndarray	数据的矩阵，行和列标签是可选参数
   数组、列表和元组构成的字典	每个序列成为DataFrame的一列，所有的序列必须长度相等
   Numpy结构化数组	与数组构成的字典一致
   Series构成的字典	每个值成为一列，每个Series的索引形成行索引，也可以显式地传递索引
   字典构成的字典	每个内部字典成为一列，字典的键形成行索引，
   字典或Series构成的列表	列表中的一个元素形成DataFrame的一行，字典键或Series索引形成列标签
   列表或元组构成的列表	与2D ndarray一致
   其他DataFrame	如果不显示传递索引，则会使用原DataFrame索引
   Numpy MaskedArray	与2D ndarray类似，但隐蔽值会在结果DataFrame中成为缺失值

DataFrame的基本使用

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# 转置
frame1 = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['A','B','C'])
prints(frame1)
prints(frame1.T) # 行与列转置
# 通过列索引获取数据（Series类型）
prints(frame1['A'])
prints(type(frame1['A']))
# 增加列数据
frame1['D'] = 9
prints(frame1)
frame1['D'] = [1,2,3]
prints(frame1)
# 删除列
del(frame1['D'])
prints(frame1)

索引对象

索引对象是用于存储轴标签和其他元数据的，索引对象不可变，保证了数据的安全。

import pandas as pd
import numpy as np
# Series和DataFrame中的索引都是Index对象
def prints(a):
   print(a)
   print('='*30)

ps = pd.Series(np.arange(1,5),index=('a','b','c','d'))
prints(ps)
prints(ps.index)
prints(type(ps.index))
pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=('a','b','c'),columns=('A','B','C'))
prints(pd1)
prints(pd1.index)
prints(pd1.columns)

与Python集合不同，pandas索引对象可以包含重复标签，根据重复标签进行筛选，会选取所有重复标签对应的数据。下表总结了一些索引集合逻辑的方法和属性：

pandas基本功能

重点了解Series和DataFrame中数据交互的基础机制。

重建索引

reindex方法用于创建一个符合新索引的新对象

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# reindex 创建一个符合新索引的新对象
ps1 = pd.Series(np.arange(1,5),index=('a','b','c','d'))
ps2 = ps1.reindex(['a','b','c','d','e'])
prints(ps1)
prints(ps2)

pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=('a','b','c'),columns=('A','B','C'))
pd2 = pd1.reindex(['a','b','c','d']) # 重建行索引
prints(pd2)
pd3 = pd1.reindex(columns=['C','B','A']) # 重建列索引
prints(pd3)

reindex方法的参数：

索引操作

pandas索引操作与Numpy数组索引的功能类似，但pandas的索引值可以不仅仅是整数，简单来说可以分为增删改查四种基本操作。

增

append函数和insert函数

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

ps1 = pd.Series(np.arange(1,5),index=('a','b','c','d'))
ps1['e'] = 9
prints(ps1)
ps2 = pd.Series({'f':8})
ps3 = ps1.append(ps2) # 拼接两个Series
prints(ps3)

pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=('a','b','c'),columns=('A','B','C'))
# 增加列
pd1[4] = 9
prints(pd1)
pd1[4] = [10,11,12] # 在末尾增加列
prints(pd1)
pd1.insert(0,'E',[18,19,20]) # 在指定位置插入列
prints(pd1)

# 增加行
# 标签索引loc
pd1.loc['d'] = [1,1,1,1,1] # 末尾添加行
prints(pd1)
row = {4:6,'A':7,'B':8,'C':9,'E':10}
pd2 = pd1.append(row,ignore_index= True) # 拼接字典
prints(pd2)

删

del函数和drop函数

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# 通过del函数删除，会改变原来的值
   # Series
ps1 = pd.Series(np.arange(1,7),index=('a','b','c','d','e','f'))
del ps1['b']
prints(ps1)
   # DataFrame
pd1 = pd.DataFrame(np.arange(16).reshape(4,4),index=('a','b','c','d'),columns=('A','B','C','D'))
del pd1['C'] # 删除一列
prints(pd1)

# 通过drop函数删除，不会改变原来的值
   # Series 
ps2 = ps1.drop('a') # 删除一条
prints(ps1)
prints(ps2)
ps3 = ps1.drop(['a','d']) # 删除多条
prints(ps3)
   # DataFrame
       # 删除行
pd2 = pd1.drop('a') # 删除一行
prints(pd2)
pd3 = pd1.drop(['a','b']) # 删除多行
prints(pd3)
       # 删除列
pd4 = pd1.drop('A',axis=1) # axis = 1 列；axis = 0 行
prints(pd4)
pd5 = pd1.drop('A',axis= 'columns')
prints(pd5)

# 通过inplace属性，在原对象上删除，不会返回新的对象
ps1.drop('e',inplace=True)
prints(ps1)

改

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

ps1 = pd.Series(np.arange(1,7),index=('a','b','c','d','e','f'))
pd1 = pd.DataFrame(np.arange(16).reshape(4,4),index=('a','b','c','d'),columns=('A','B','C','D'))
# Series
ps1['a'] = 999 # 通过标签索引进行修改
prints(ps1)
ps1[0] = 888 # 通过位置索引进行修改
prints(ps1)

# DataFrame
   # 修改列
pd1['A'] = 9
prints(pd1)
pd1['A'] = [9,10,11,12]
prints(pd1)

pd1.A = 6 # 对象.列 的方式进行数据修改
prints(pd1)
   # 修改行
   # loc 标签索引
pd1.loc['a'] = 777
prints(pd1)
pd1.loc['a','A'] = 888
prints(pd1)

查

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

ps1 = pd.Series(np.arange(1,7),index=('a','b','c','d','e','f'))
pd1 = pd.DataFrame(np.arange(16).reshape(4,4),index=('a','b','c','d'),columns=('A','B','C','D'))
# Series
prints(ps1['a']) # 标签索引
prints(ps1[0]) # 位置索引
prints(ps1['a':'e']) # 标签切片索引，包含终止标签索引
prints(ps1[0:5]) # 位置切片索引，不包含终止位置索引
prints(ps1[['a','c','d']]) # 不连续索引，两个中括号
prints(ps1[[0,2,4]]) # 同上
prints(ps1[ps1>2]) # 布尔索引

# DataFrame
   # 列索引
prints(pd1['A'])
prints(pd1[['A','C','D']]) # 不连续索引
prints(pd1['A']['d'])
   # 行索引
prints(pd1[:2]) # 切片索引

高级索引

当对一个包含整数轴索引的DataFrame对象进行索引操作时，标签索引和位置索引的表达方式是很类似的，未避免将来引起歧义，数据选择时建议始终使用标签索引，为更精确地处理，可以使用loc(用于标签)或iloc(用于整数位置)进行索引。

import pandas as pd
import numpy as np


def prints(a):
   print(a)
   print('='*30)


ps1 = pd.Series(np.arange(1, 7), index=('a', 'b', 'c', 'd', 'e', 'f'))
pd1 = pd.DataFrame(np.arange(16).reshape(4, 4), index=(
   'a', 'b', 'c', 'd'), columns=('A', 'B', 'C', 'D'))
# loc 标签索引，loc是基于标签名的索引
prints(ps1['a':'c'])
prints(ps1.loc['a':'c'])

prints(pd1.loc['a':'c', 'A':'C'])  # 第一个参数是索引行，第二个参数是列
# iloc 位置索引
prints(ps1[0:3])
prints(ps1.iloc[0:3])

prints(pd1.iloc[0:3, 1:3])  # 第一个参数是索引行，第二个参数是列
# ix 标签与位置混合索引
# prints(ps1.ix[1:3])
# 在pandas版本0.20.0及其以后版本中，ix已经不被推荐使用，建议采用iloc和loc实现ix。

下表总结了DataFrame不同的索引选项：

算术和数据对齐

不同索引对象之间的算术行为是pandas提供给一些应用的重要特性之一。如果某个索引对不相同，则返回结果的索引将是索引对的并集，类似于索引标签的自动外连接(outer join)

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# pandas的对齐运算是数据清洗的重要过程，可以按索引对齐进行运算
# 如果没有对齐的位置则补NAN，最后也可以填充NAN

# Series按行索引对齐
s1 = pd.Series(range(10,20),index=range(10))
s2 = pd.Series(range(20,25),index=range(0,10,2))
print('s1:')
prints(s1)
print('s2:')
prints(s2)
print('s1 + s2:')
prints(s1+s2)

# DataFrame对齐运算
df1 = pd.DataFrame(np.arange(16).reshape(4,4),index=['a','b','c','d'],columns=['A','B','C','D'])
df2 = pd.DataFrame(np.random.randint(2,20,size=(2,3)),index=['b','d'],columns=list('ABD'))
print('df1:')
prints(df1)
print('df2:')
prints(df2)
print('df1 + df2:')
prints(df1 + df2)

使用填充值的算术运算

在两个不同的索引对象之间进行算术操作时，可能想要使用特殊填充值，可以利用算术方法实现：

import pandas as pd
import numpy as np


def prints(a):
   print(a)
   print('='*30)

# 算术方法表：(字母r开头，代表会反转参数)
# add/radd 加法(+)
# sub/rsub 减法(-)
# div/rdiv 除法(/)
# floordiv/rfloordiv 整除(//)
# mul/rmul 乘法(*)
# pow/rpow 幂次方(**)


# Series
s1 = pd.Series(range(10, 20), index=range(10))
s2 = pd.Series(range(20, 25), index=range(0, 10, 2))
prints(s1.add(s2, fill_value=0))

# DataFrame
df1 = pd.DataFrame(np.arange(16).reshape(4, 4), index=[
                  'a', 'b', 'c', 'd'], columns=['A', 'B', 'C', 'D'])
df2 = pd.DataFrame(np.random.randint(2, 20, size=(2, 3)),
                  index=['b', 'd'], columns=list('ABD'))
prints(df1.add(df2, fill_value=0))
prints(df2.reindex(columns=df1.columns, fill_value=9))

DataFrame和Series的混合运算

DataFrame和Series之间的算术操作与Numpy中不同维度数组间的操作类似，Series的索引会和DataFrame的列/行进行匹配，并广播到各行/列：

import pandas as pd
import numpy as np


def prints(a):
   print(a)
   print('='*30)


# Series
s1 = pd.Series(range(10, 20), index=range(10))
s2 = pd.Series(range(20, 25), index=range(0, 10, 2))

# DataFrame
df1 = pd.DataFrame(np.arange(16).reshape(4, 4), index=[
                  'a', 'b', 'c', 'd'], columns=['A', 'B', 'C', 'D'])
df2 = pd.DataFrame(np.random.randint(2, 20, size=(2, 3)),
                  index=['b', 'd'], columns=list('ABD'))
s3 = df1.iloc[0]
prints(df1-s3)  # 按照行进行广播
s4 = df1['A']
prints(s4)
prints(df1.sub(s4, axis='index'))  # 按照列广播，axis=0能达到同样的效果

函数应用与映射

利用DataFrame中的apply和applymap方法可以将常用的一些函数应用到一行或一列的一维数组上：

import pandas as pd
import numpy as np


def prints(a):
   print(a)
   print('='*30)


# Series
s1 = pd.Series(range(10, 20), index=range(10))
s2 = pd.Series(range(20, 25), index=range(0, 10, 2))

# DataFrame
df = pd.DataFrame(np.random.randn(5, 4), index=[
                 'a', 'b', 'c', 'd', 'e'], columns=list('ABCD'))
prints(df)
# 方法一 dataframe可以直接使用numpy的函数
prints(np.abs(df))
# 通过apply将函数应用到列或者行
def f(x): return x.max()


prints(np.abs(df).apply(f))  # 默认axis=0，取的是列方向上的最大值
prints(np.abs(df).apply(f, axis=1))  # 取行方向上的最大值
# 通过applymap将函数应用到每个数据
def f2(x): return '%.2f' % x  # '%.2f'表示保留两位小数


prints(np.abs(df).applymap(f2))

大部分最常用的数据统计(比如sum
和mean
)都是DataFrame的方法，因此计算统计值时使用apply
并不是必须的，传递给apply
的函数并不一定要返回一个标量值，也可以返回带有多个值的Series。

排序与排名

根据某些准则对数据集进行排序是另一个重要的内建操作，需要掌握sort_index
和sort_values

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# Series
s1 = pd.Series(range(10,20),index=list('fghjkdsabc'))
s2 = pd.Series(range(20,25),index=range(0,10,2))

# 按索引排序
prints(s1.sort_index())
prints(s1.sort_index(ascending=False))
# 按值排序
prints(s1.sort_values())

# DataFrame
df = pd.DataFrame(np.random.randn(5,4),index=['d','c','a','e','b'],columns=list('CADB'))
prints(df.sort_index()) # 行排序，默认升序
prints(df.sort_index(axis=1)) # 列排序，默认升序
prints(df.sort_values(by='A')) # 列排序
prints(df.sort_values(by=['A','B'])) # 多列排序，类似Order by，先根据A列排 再根据B列排

排名是指对数组从1到有效数据点总数分配名次的操作，需要掌握rank
方法。

import pandas as pd
import numpy as np

obj = pd.Series([7,-5,7,4,2,0,4])
print(obj)
print(obj.rank())
print(obj.rank(ascending=False,method='max'))

frame = pd.DataFrame({'b':[4.3,7,-3,2],'a':[0,1,0,1],'c':[-2,5,8,-2.5]})
print(frame)
print(frame.rank(axis='columns'))

排名中的平级关系打破方法：

含有重复标签的轴索引

pandas中并不强制索引标签是唯一的，索引的is_unique
属性可以查看标签是否唯一：

import pandas as pd
import numpy as np


def prints(a):
   print(a)
   print('='*30)


# Series
s1 = pd.Series(list([2, 6, 8, 9, 3, 6, 4, 7, 3, 4]), index=list('fghjkdsabc'))
s2 = s1.unique()  # s2变为了唯一值数组
s3 = pd.Series(list([2, 6, 8, 9, 3, 6, 4, 7, 3, 4]), index=list('aaaaaccccc'))
s4 = s3.unique()
prints(s1)
prints(s2)
prints(s1.index.is_unique)
prints(s3)
prints(s4)
prints(s3.index.is_unique)
prints(s1.value_counts())  # 统计value出现的次数
prints(s1.isin([8]))  # 判断参数值是否在Series中出现，返回布尔类型的Series
prints(s1.isin([8, 2]))

# DataFrame
df = pd.DataFrame(np.random.randint(2, 10, size=(5, 4)), index=[
                 'd', 'c', 'a', 'e', 'b'], columns=list('CADB'))
prints(df)
prints(df.isin([2, 4]))

描述性统计概述与计算

pandas对象装配了一个常用数学、统计学方法的集合，其中大部分属于归约或汇总统计的类别，它们从DataFrame的行或列中抽取一个Series或一系列值的单个值(比如总和或平均值)，这些函数内建了处理缺失值的功能。

处理缺失值

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# Series
s1 = pd.Series(list([2,6,8,9,3,6,4,7,3,4]),index=list('fghjkdsabc'))

# DataFrame
df = pd.DataFrame([np.random.randn(3),[1,2,np.nan],[np.nan,4,np.nan],[1,2,3]])
prints(df)

# Step1:判断是否存在缺失值 isnull()
prints(df.isnull())
# Step2:丢弃缺失数据 dropna()
prints(df.dropna(axis=1)) # axis决定按行丢失还是按列丢失
prints(df)
# Step3:填充缺失数据 fillna()
prints(df.fillna(0))
prints(df.fillna({0:9,2:100})) # 第一列的nan替换成9，第三列的nan替换成100
prints(df.fillna(method='ffill',limit=1)) # 用nan上一列的值向下替换nan,limit限制向下填充的nan数量

层级索引

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# Series 层级索引
s1 = pd.Series(np.random.randn(12),index=[list('aaabbbcccddd'),list([0,1,2,0,1,2,0,1,2,0,1,2])])
prints(s1)
prints(type(s1.index))
prints(s1.index)

# Series 索引选取
prints(s1['a',0])
prints(s1['a'])
prints(s1[:,2])

# Series 索引交换 
   # swaplevel() 交换内层和外层索引
prints(s1.swaplevel())
   # sortlevel() 先对外层索引进行排序，再对内层索引进行排序，默认升序
   # pandas的包中在0.23.4版本中就取消了sort方法，老版本的Series和DataFrame对象中还包含这个函数
   # 新版本中推荐使用sort_index和sort_values函数
prints(s1.swaplevel().sort_index())

归约方法与积累型方法

import pandas as pd
import numpy as np

def prints(a):
   print(a)
   print('='*30)

# Series 层级索引
s1 = pd.Series(np.random.randn(12),index=[list('aaabbbcccddd'),list([0,1,2,0,1,2,0,1,2,0,1,2])])
df = pd.DataFrame([np.random.rand(3),[1,2,np.nan],[np.nan,4,np.nan],[1,2,3]],index=list(['Bob','Sam','Tom','Jim']),columns=list(['Math','History','English']))
prints(df)
prints(df.sum()) # nan当作0，或者nan不参与求和计算
prints(df.sum(axis=1))
prints(df.sum(axis=1,skipna=False)) # nan参与计算
prints(df.idxmax()) # 返回最大值的索引
prints(df.cumsum()) # 样本值的累积和
prints(df.describe())

描述性统计和汇总统计方法汇总：

相关性和协方差

相关性和协方差的方法：

唯一值、计数与成员属性

唯一值、计数和集合成员属性的方法：

计算DataFrame多个相关列的直方图，可参考下面的例子：

data = pd.DataFrame({'Qu1':[1,3,4,3,4],'Qu2':[2,3,1,2,3],'Qu3':[1,5,2,4,4]})
print(data)
# 将pd.value_counts传入apply函数
result = data.apply(pd.value_counts).fillna(0)
print(result)
# 结果中的行标签是所有列中出现的不同值，数值则是这些不同值在每个列中出现的次数

补充知识点

数学期望：如果X是离散的随机变量，输出值为x1,x2,...,xn，和输出值相应的概率为p1,p2,...,pn(概率和为1)，那么期望值E(X)=x1 * p1 + x2 * p2 + ... + xn * pn

假设有X和Y两个随机变量，它们的均值(期望值)是μX ,μY，它们的标准差是σX以及σY，E代表求数学期望，它们的协方差和相关性可以通过以下式子计算

协方差：covariance σXY=E[(X−μX)(Y−μY)]，表示的是两个变量的总体的误差

相关性：correlation ρXY=E[(X−μX)(Y−μY)]/(σXσY)，表示的是两个变量的相关性

以上数学概念详细公式可参考协方差百度百科。

lambda表达式：Lambda表达式是Python中一类特殊的定义函数的形式，使用它可以定义一个匿名函数。语法如下：

lambda 形参列表 : 函数返回值表达式语句

具体语法可参考以下实例：

li=[{"age":20,"name":"def"},{"age":25,"name":"abc"},{"age":10,"name":"ghi"}]

# 使用lambda表达式
li=sorted(li, key=lambda x:x["age"])
print(li)

# 不使用lambda表达式，采用常规函数
def comp(x):
   return x["age"]
li=sorted(li, key=comp)
print(li)

 今日も一日、頑張るぞう！💪