Python之Pandas详解

Pandas是Python语言的一个扩展程序库，用于数据分析。

Pandas是一个开放源码、BSD许可的库，提供高性能、易于使用的数据结构和数据分析工具。

Pandas名字衍生自术语 “panel data“（面板数据）和 “Python data analysis“（Python数据分析）。

Pandas一个强大的分析结构化数据的工具集，基础是NumPy（提供高性能的矩阵运算）。

Pandas可以从各种文件格式比如CSV、JSON、SQL、Microsoft Excel 导入数据。

Pandas可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征。

Pandas广泛应用在学术、金融、统计学等各个数据分析领域。

Pandas主要包括以下几个特点：

• 它提供了一个简单、高效、带有默认标签（也可以自定义标签）的DataFrame对象。
• 能够快速从不同格式的文件中加载数据（比如 Excel、CSV 、SQL文件），然后转换为可处理的对象；
• 能够按数据的行、列标签进行分组，并对分组后的对象执行聚合和转换操作；
• 能够很方便地实现数据归一化操作和缺失值处理；
• 能够很方便地对DataFrame的数据列进行增加、修改或者删除的操作；
• 能够处理不同格式的数据集，比如矩阵数据、异构数据表、时间序列等；
• 提供了多种处理数据集的方式，比如构建子集、切片、过滤、分组以及重新排序等。

⛄Pandas数据结构

Pandas的主要数据结构是Series（一维数据）与DataFrame（二维数据），这两种数据结构足以处理金融、统计、社会科学、工程等领域里的大多数典型用例。

**Series**是一种类似于一维数组的对象，它由一组数据（各种Numpy数据类型）以及一组与之相关的数据标签（即索引）组成。

**DataFrame**是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共同用一个索引）。

⛄Pandas Series

Pandas Series类似表格中的一个列（column），类似于一维数组，由一组数据值（value）和一组标签组成，其中标签与数据值之间是一一对应的关系。Series可以保存任何数据类型，比如整数、字符串、浮点数、Python对象等，它的标签默认为整数，从0开始依次递增。

👀创建Series对象

Series由索引（index）和列组成，函数如下：

pandas.Series(data, index, dtype, name, copy)
参数说明：
    data：一组数据(ndarray类型)。
    index：数据索引标签，如果不指定，默认从0开始。
    dtype：数据类型，默认会自己判断。
    name：设置名称。
    copy：拷贝数据，默认为False。

import pandas as pd
a = [1, 2, 3]
myvar = pd.Series(a)
print(myvar)
print(myvar[1])

# 输出结果：第一列为索引，第二列为数据
# 如果没有指定索引，索引值就从0开始，我们可以根据索引值读取数据：
0    1
1    2
2    3
dtype: int64
2

我们也可以使用数组、字典、标量值或者Python对象来创建Series对象。

（1）创建一个空Series对象

import pandas as pd
#输出数据为空
s = pd.Series()
print(s)

# 输出结果
Series([], dtype: float64)

（2）ndarray创建Series对象

ndarray是NumPy中的数组类型，当data是ndarry时，传递的索引必须具有与数组相同的长度。如果没有指定索引（隐式索引)，索引值就从0开始（索引值将使用是range(n) 生成，其中n代表数组长度）；我们可以根据索引值读取数据。可以指定索引值（显式索引），如下实例。

import pandas as pd
import numpy as np

# 指定索引值
a = np.array(["Google", "Runoob", "Wiki"])
myvar = pd.Series(a, index = ["x", "y", "z"])
print(myvar)
print(myvar["y"])

#输出结果
x    Google
y    Runoob
z      Wiki
dtype: object
Runoob

（3）dict创建Series对象

我们也可以使用key/value对象，类似字典来创建Series：

import pandas as pd

# 使用字典创建Series
# 没有传递索引，字典的key变成了索引值。
sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myvar1 = pd.Series(sites)
print(myvar1)
# 如果我们只需要字典中的一部分数据，只需要指定需要数据的索引即可，如下实例：
myvar2 = pd.Series(sites, index = [1,2])
print(myvar2)
# 当传递的索引值无法找到与其对应的值时，使用NaN（非数字）填充。
myvar3 = pd.Series(sites, index = [1,3,2,4])
print(myvar3)

# 输出结果
1    Google
2    Runoob
3      Wiki
dtype: object
1    Google
2    Runoob
dtype: object
1    Google
3      Wiki
2    Runoob
4       NaN
dtype: object

当传递的索引值无法找到与其对应的值时，使用NaN（非数字）填充。

（4）标量创建Series对象

如果data是标量值，则必须提供索引，示例如下：

import pandas as pd
s = pd.Series(5, index = [0,1,2,3])
print(s)

# 输出结果
0    5
1    5
2    5
3    5
dtype: int64

标量值按照index的数量进行重复，并与其一一对应。

设置Series名称参数：

import pandas as pd

sites = {1: "Google", 2: "Runoob", 3: "Wiki"}
myvar = pd.Series(sites, index = [1, 2], name="RUNOOB-Series-TEST" )
print(myvar)

# 输出结果
1    Google
2    Runoob
Name: RUNOOB-Series-TEST, dtype: object

👀访问Series数据

（1）位置索引访问

这种访问方式与ndarray和list相同，使用元素自身的下标进行访问。我们知道数组的索引计数从0开始，这表示第一个元素存储在第0个索引位置上，以此类推，就可以获得Series序列中的每个元素。

import pandas as pd
s = pd.Series([5,2,3,4,5],index = ['a','b','c','d','e'])
print(s[0])  	# 位置下标
print(s['a']) 	# 标签下标
# 通过切片的方式访问Series序列中的数据
print(s[:3])
# 获取最后三个元素
print(s[-3:])

# 输出结果
5
5
a    5
b    2
c    3
dtype: int64
c    3
d    4
e    5
dtype: int64

（2）索引标签访问

Series类似于固定大小的dict，把index中的索引标签当做key，而把Series序列中的元素值当做value，然后通过index索引标签来访问或者修改元素值。

import pandas as pd
# 使用索标签访问单个元素值
s = pd.Series([16,17,18,19,20],index = ['a','b','c','d','e'])
print(s['a'])
# 使用索引标签访问多个元素值
print(s[['a','c','d']])
# 如果使用了index中不包含的标签，则会触发异常
print(s['f'])

# 输出结果
16
a    16
c    18
d    19
dtype: int64
......
KeyError: 'f'

👀Series常用属性

Series的常用属性和方法：

名称	属性
axes	以列表的形式返回所有行索引标签
dtype	返回对象的数据类型
empty	返回一个空的Series对象
ndim	返回输入数据的维数
size	返回输入数据的元素数量
values	以ndarray的形式返回Series对象
index	返回一个RangeIndex对象，用来描述索引的取值范围

import pandas as pd
import numpy as np
s = pd.Series(np.random.randn(6))
print(s)
print("*"*20)
# axes属性
print(s.axes)
print("*"*20)
# dtype属性
print(s.dtype)
print("*"*20)
# empty
print(s.empty)
print("*"*20)
# ndim，Series是一维数据结构，因此它始终返回1
print(s.ndim)
print("*"*20)
# size返回Series对象的大小(长度)
print(s.size)
print("*"*20)
# value以数组的形式返回Series对象中的数据
print(s.values)
print("*"*20)
# index该属性用来查看Series中索引的取值范围
#显示索引
s1 = pd.Series([1,2,5,8],index = ['a','b','c','d'])
print(s1.index)
#隐式索引
s2 = pd.Series([1,2,5,8])
print(s2.index)

# 输出结果
0   -0.674501
1    1.030106
2   -1.636359
3   -1.540996
4    1.312837
5   -0.735986
dtype: float64
********************
[RangeIndex(start=0, stop=6, step=1)]
********************
float64
********************
False
********************
1
********************
6
********************
[-0.67450078  1.03010573 -1.63635856 -1.54099596  1.31283698 -0.73598645]
********************
Index(['a', 'b', 'c', 'd'], dtype='object')
RangeIndex(start=0, stop=4, step=1)

👀Series常用方法

（1）head()&tail()查看数据

如果想要查看Series的某一部分数据，可以使用head()或者tail()方法。其中head()返回前n行数据，默认显示前5行数据。tail()返回的是后n行数据，默认为后5行。

import pandas as pd
import numpy as np
s = pd.Series(np.random.randn(5))
print (s)
# 返回前三行数据
print(s.head(3))
# 返回后两行数据
print(s.tail(3))

# 输出结果
0   -0.264915
1   -1.120671
2    0.621638
3   -0.449170
4    0.533876
dtype: float64
0   -0.264915
1   -1.120671
2    0.621638
dtype: float64
2    0.621638
3   -0.449170
4    0.533876
dtype: float64

（2）isnull()&notnull()检测缺失值

isnull()和notnull()用于检测Series中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少。

• isnull()：如果为值不存在或者缺失，则返回True。
• notnull()：如果值不存在或者缺失，则返回False。

其实不难理解，在实际的数据分析任物中，数据的收集往往要经历一个繁琐的过程。在这个过程中难免会因为一些不可抗力，或者人为因素导致数据丢失的现象。这时，我们可以使用相应的方法对缺失值进行处理，比如均值插值、数据补齐等方法。上述两个方法就是帮助我们检测是否存在缺失值。

import pandas as pd
#None代表缺失数据
s = pd.Series([1,6,None,8,None])
print(pd.isnull(s))  #是空值返回True
print(pd.notnull(s)) #空值返回False

# 输出结果
0    False
1    False
2     True
3    False
4     True
dtype: bool
0     True
1     True
2    False
3     True
4    False
dtype: bool

⛄Pandas DataFrame

DataFrame是表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表。

它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共同用一个索引），每一行数据都可以看成一个Series结构，DataFrame为这些行中每个数据值增加了一个列标签。

同Series一样，DataFrame自带行标签索引，默认为“隐式索引”即从0开始依次递增，行标签与DataFrame中的数据项一一对应。DataFrame数据结构的特点：

• DataFrame每一列的标签值允许使用不同的数据类型；
• DataFrame是表格型的数据结构，具有行和列；
• DataFrame中的每个数据值都可以被修改；
• DataFrame结构的行数、列数允许增加或者删除；
• DataFrame有两个方向的标签轴，分别是行标签和列标签；
• DataFrame可以对行和列执行算术运算。

👀创建DF对象

DataFrame构造方法如下：

pandas.DataFrame(data, index, columns, dtype, copy)
参数说明：
    data：一组数据(ndarray、series, map, lists, dict等类型)。
    index：索引值，或者可以称为行标签。
    columns：列标签，默认为RangeIndex(0, 1, 2, …, n) 。
    dtype：数据类型。
    copy：拷贝数据，默认为False。

Pandas DataFrame是一个二维的数组结构，类似二维数组。

Pandas提供了多种创建DataFrame对象的方式，主要包含以下五种：

（1）创建空的DataFrame对象

import pandas as pd
df = pd.DataFrame()
print(df)
# 输出结果
Empty DataFrame
Columns: []
Index: []

（2）列表创建DataFame对象

可以使用单一列表或嵌套列表来创建一个DataFrame。

import pandas as pd

# 单一列表创建DataFrame对象
data1 = [6,7,8,9,10]
df1 = pd.DataFrame(data1)
print(df1)
# 嵌套列表创建DataFrame对象，并指定数值元素的数据类型为float
data2 = [['Google',10],['Runoob',12],['Wiki',13]]
df2 = pd.DataFrame(data2,columns = ['Site','Age'],dtype = float)
print(df2)

# 输出结果
    0
0   6
1   7
2   8
3   9
4  10
     Site   Age
0  Google  10.0
1  Runoob  12.0
2    Wiki  13.0

（3）字典嵌套列表创建DataFame对象

dict字典中，键对应的值的元素长度必须相同（也就是列表长度相同）。如果传递了索引，那么索引的长度应该等于数组的长度；如果没有传递索引，那么默认情况下，索引将是range(n)，其中n代表数组长度。

import pandas as pd

# 这里使用了默认行标签，也就是range(n)。它生成了0,1,2,3，并分别对应了列表中的每个元素值
data = {'Site':['Google', 'Runoob', 'Wiki'], 'Age':[10, 12, 13]}
df = pd.DataFrame(data)
print(df)
# 添加自定义的行标签,index参数为每行分配了一个索引
df2 = pd.DataFrame(data,index = ['one','two','three'])
print(df2)

# 输出结果
     Site  Age
0  Google   10
1  Runoob   12
2    Wiki   13
         Site  Age
one    Google   10
two    Runoob   12
three    Wiki   13

从以上输出结果可以知道， DataFrame数据类型一个表格，包含rows（行）和columns（列）。

（4）列表嵌套字典创建DataFrame对象

列表嵌套字典可以作为输入数据传递给DataFrame构造函数。默认情况下，字典的键被用作列名。

import pandas as pd

# 列表嵌套字典
data1 = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
# 字典嵌套列表
data2 = {'a':[1, 5], 'b':[2, 10], 'c':[15, 20]}
df1 = pd.DataFrame(data1)
print(df1)
df2 = pd.DataFrame(data2)
print(df2)
# 添加行标签索引
df3 = pd.DataFrame(data1,index = ['one','two'])
print(df3)
# 行标签索引
# 注意：因为'abc'在字典键中不存在，所以对应值为NaN
df4 = pd.DataFrame(data1,index = ['one','two'],columns = ['a','abc'])
print(df4)

# 输出结果，没有对应的部分数据为NaN。
   a   b     c
0  1   2   NaN
1  5  10  20.0
   a   b   c
0  1   2  15
1  5  10  20
     a   b     c
one  1   2   NaN
two  5  10  20.0
     a  abc
one  1  NaN
two  5  NaN

（5）Series创建DataFrame对象

可以传递一个字典形式的Series，从而创建一个DataFrame对象，其输出结果的行索引是所有index的合集。

import pandas as pd

d = {'one' : pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
   'two' : pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print(df)

# 输出结果，对于one列而言，此处虽然显示了行索引'd'，但由于没有与其对应的值，所以它的值为NaN
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4

👀列索引操作DF对象

DataFrame可以使用列索（columns index）引来完成数据的选取、添加和删除操作。

（1）列索引选取数据列

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}
# 数据载入到DataFrame对象
df = pd.DataFrame(data, index = ['a', 'b', 'c'])
print(df)
# 返回第一列 
print(df['calories'])

# 输出结果
   calories  duration
a       420        50
b       380        40
c       390        45
a    420
b    380
c    390
Name: calories, dtype: int64

（2）列索引添加数据列

使用columns列索引表标签可以实现添加新的数据列。

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}
# 数据载入到DataFrame对象
df = pd.DataFrame(data, index = ['a', 'b', 'c'])
print(df)
# 返回第一列 
print("*"*20)
# 使用df['列']=值，插入新的数据列
df['height'] = pd.Series([160,170,180], index = ['a', 'b', 'c'])
print(df)
print("*"*20)
# 将已经存在的数据列做相加运算
df['sums'] = df['calories'] + df['duration']
print(df)

# 输出结果
   calories  duration
a       420        50
b       380        40
c       390        45
********************
   calories  duration  height
a       420        50     160
b       380        40     170
c       390        45     180
********************
   calories  duration  height  sums
a       420        50     160  470
b       380        40     170  420
c       390        45     180  435

我们初次使用了DataFrame的算术运算，这和NumPy非常相似。除了使用df[]=value的方式外，您还可以使用insert()方法插入新的列.

import pandas as pd
info = [['Jack',18],['Helen',19],['John',17]]
df = pd.DataFrame(info,columns = ['name','age'])
print(df)
# 注意是column参数
# 数值1代表插入到columns列表的索引位置
df.insert(1,column = 'score',value = [91,90,75])
print(df)

# 输出结果
    name  age
0   Jack   18
1  Helen   19
2   John   17
    name  score  age
0   Jack     91   18
1  Helen     90   19
2   John     75   17

（3）列索引删除数据列

通过del和pop()都能够删除DataFrame中的数据列。示例如下：

import pandas as pd
d = {'one': pd.Series([1, 2, 3], index = ['a', 'b', 'c']),
   'two': pd.Series([1, 2, 3, 4], index = ['a', 'b', 'c', 'd']),
   'three': pd.Series([10,20,30], index = ['a','b','c'])}
df = pd.DataFrame(d)
print(df)
print("*"*20)
# 使用del删除
del df['one']
print(df)
print("*"*20)
# 使用pop方法删除
df.pop('two')
print(df)

# 输出结果
   one  two  three
a  1.0    1   10.0
b  2.0    2   20.0
c  3.0    3   30.0
d  NaN    4    NaN
********************
   two  three
a    1   10.0
b    2   20.0
c    3   30.0
d    4    NaN
********************
   three
a   10.0
b   20.0
c   30.0
d    NaN

👀行索引操作DF对象

Pandas可以使用**loc**函数返回指定行的数据，如果没有设置索引，第一行索引为0，第二行索引为1，以此类推。

（1）标签索引选取

通过将行标签传递给loc函数，来选取数据。

loc允许接两个参数分别是行和列，参数之间需要使用“逗号”隔开，但该函数只能接收标签索引。

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data, index = ['a', 'b', 'c'])
print(df)
print('*'*20)
print(df.loc['a'])

# 输出结果
   calories  duration
a       420        50
b       380        40
c       390        45
********************
calories    420
duration     50
Name: a, dtype: int64

（2）整数索引选取

通过将数据行所在的索引位置传递给iloc函数，也可以实现数据行选取。

iloc允许接受两个参数分别是行和列，参数之间使用“逗号”隔开，但该函数只能接收整数索引。

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data, index = ['a', 'b', 'c'])
print(df)
print('*'*20)
# 返回第一行，返回结果其实就是一个Pandas Series数据。
print(df.iloc[0])
print('*'*20)
# 返回第二行，返回结果其实就是一个Pandas Series数据。
print(df.iloc[1])
print('*'*20)
# 也可以返回多行数据，使用[[ ... ]] 格式，... 为各行的索引，以逗号隔开：
# 返回第一行和第二行，返回结果其实就是一个Pandas DataFrame数据。
print(df.iloc[[0, 1]])

# 输出结果
   calories  duration
a       420        50
b       380        40
c       390        45
********************
calories    420
duration     50
Name: a, dtype: int64
********************
calories    380
duration     40
Name: b, dtype: int64
********************
   calories  duration
a       420        50
b       380        40

（3）切片操作多行数据

通过使用切片的方式同时选取多行。

import pandas as pd

data = {
  "calories": [420, 380, 390],
  "duration": [50, 40, 45]
}
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data, index = ['a', 'b', 'c'])
print(df)
print('*'*20)
# 左闭右开
print(df[1:3])

# 输出结果
   calories  duration
a       420        50
b       380        40
c       390        45
********************
   calories  duration
b       380        40
c       390        45

（4）添加数据行

使用append()函数，可以将新的数据行添加到DataFrame中，该函数会在行末追加数据行。

import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], index = ['one','two'], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], index = ['one','two'], columns = ['a','b'])
# 在行末追加新数据行
df = df.append(df2)
print(df)

# 输出结果
     a  b
one  1  2
two  3  4
one  5  6
two  7  8

（5）删除数据行

使用行索引标签，从DataFrame中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。

import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], index = ['one','two'], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], index = ['one','two'], columns = ['a','b'])
# 在行末追加新数据行
df = df.append(df2)
print(df)
print('*'*20)
# 注意此处调用了drop()方法,drop('one')同时删除了两行数据
df1 = df.drop('one')
print(df1)

# 输出结果
     a  b
one  1  2
two  3  4
one  5  6
two  7  8
********************
     a  b
two  3  4
two  7  8

👀DF对象属性和方法

DataFrame的属性和方法，与Series相差无几。

名称	属性方法描述
T	行和列转置
axes	返回一个仅以行轴标签和列轴标签为成员的列表
dtypes	返回每列数据的数据类型
empty	DataFrame中没有数据或者任意坐标轴的长度为0，则返回True
ndim	轴的数量，也指数组的维数。
shape	返回一个元组，表示了DataFrame维度
size	DataFrame中的元素数量
values	使用numpy数组表示DataFrame中的元素值
head()	返回前n行数据
tail()	返回后n行数据
shift()	将行或列移动指定的步幅长度

import pandas as pd
import numpy as np
d = {'Name':pd.Series(['小汤','小王',"小明",'小红','小小','小微','小黄']),
   'years':pd.Series([2005,2006,2015,2008,2003,2009,2003]),
   'height':pd.Series([180,175,178,179,176,170,173])}
# 构建DataFrame
df = pd.DataFrame(d)
# 输出
print(df)
print('*'*20)
# T（Transpose）转置,返回DataFrame的转置，也就是把行和列进行交换
print(df.T)
print('*'*20)
# 返回一个行标签、列标签组成的列表
print(df.axes)
print('*'*20)
# 返回每一列的数据类型
print(df.dtypes)
print('*'*20)
# 返回一个布尔值，判断输出的数据对象是否为空，若为True表示对象为空
print(df.empty)
print('*'*20)
# 返回数据对象的维数。DataFrame是一个二维数据结构
print(df.ndim)
print('*'*20)
# 返回一个代表DataFrame维度的元组。返回值元组(a,b)，其中a表示行数，b表示列数
print(df.shape)
print('*'*20)
# 返回DataFrame中的元素数量
print(df.size)
print('*'*20)
# 以ndarray数组的形式返回DataFrame中的数据
print(df.values)
print('*'*20)

# 输出结果
  Name  years  height
0   小汤   2005     180
1   小王   2006     175
2   小明   2015     178
3   小红   2008     179
4   小小   2003     176
5   小微   2009     170
6   小黄   2003     173
********************
           0     1     2     3     4     5     6
Name      小汤    小王    小明    小红    小小    小微    小黄
years   2005  2006  2015  2008  2003  2009  2003
height   180   175   178   179   176   170   173
********************
[RangeIndex(start=0, stop=7, step=1), Index(['Name', 'years', 'height'], dtype='object')]
********************
Name      object
years      int64
height     int64
dtype: object
********************
False
********************
2
********************
(7, 3)
********************
21
********************
[['小汤' 2005 180]
 ['小王' 2006 175]
 ['小明' 2015 178]
 ['小红' 2008 179]
 ['小小' 2003 176]
 ['小微' 2009 170]
 ['小黄' 2003 173]]
********************

head()&tail()查看数据。如果想要查看DataFrame的一部分数据，可以使用head()或者tail()方法。head()返回前n行数据，默认显示前5行数据。tail()返回后n行数据。

import pandas as pd
import numpy as np
d = {'Name':pd.Series(['小汤','小王',"小明",'小红','小小','小微','小黄']),
   'years':pd.Series([2005,2006,2015,2008,2003,2009,2003]),
   'height':pd.Series([180,175,178,179,176,170,173])}
# 构建DataFrame
df = pd.DataFrame(d)
# 输出
print(df)
print('*'*20)
# 获取前3行数据
print(df.head(3))
print('*'*20)
# 获取后2行数据
print(df.tail(2))

# 输出结果
  Name  years  height
0   小汤   2005     180
1   小王   2006     175
2   小明   2015     178
3   小红   2008     179
4   小小   2003     176
5   小微   2009     170
6   小黄   2003     173
********************
  Name  years  height
0   小汤   2005     180
1   小王   2006     175
2   小明   2015     178
********************
  Name  years  height
5   小微   2009     170
6   小黄   2003     173

shift()移动行或列。如果您想要移动DataFrame中的某一行/列，可以使用shift()函数实现。它提供了一个periods参数，该参数表示在特定的轴上移动指定的步幅。

DataFrame.shift(periods=1, freq=None, axis=0)  
参数说明：
    peroids	类型为int，表示移动的幅度，可以是正数，也可以是负数，默认值为1。
    freq	日期偏移量，默认值为None，适用于时间序。取值为符合时间规则的字符串。
    axis	如果是0或者"index"表示上下移动，如果是1或者"columns"则会左右移动。
    fill_value	该参数用来填充缺失值。

import pandas as pd
import numpy as np
d = {'Name':pd.Series(['小汤','小王',"小明",'小红','小小','小微','小黄']),
   'years':pd.Series([2005,2006,2015,2008,2003,2009,2003]),
   'height':pd.Series([180,175,178,179,176,170,173])}
# 构建DataFrame
df = pd.DataFrame(d)
# 输出
print(df)
print('*'*20)
# 移动幅度为3
print(df.shift(periods=3))
print('*'*20)
# 使用fill_value参数填充DataFrame中的缺失值
print(df.shift(periods=3,fill_value=52)) 
print('*'*20)
print(df.shift(periods=3,axis=1,fill_value=52)) 

# 输出结果
  Name  years  height
0   小汤   2005     180
1   小王   2006     175
2   小明   2015     178
3   小红   2008     179
4   小小   2003     176
5   小微   2009     170
6   小黄   2003     173
********************
  Name   years  height
0  NaN     NaN     NaN
1  NaN     NaN     NaN
2  NaN     NaN     NaN
3   小汤  2005.0   180.0
4   小王  2006.0   175.0
5   小明  2015.0   178.0
6   小红  2008.0   179.0
********************
  Name  years  height
0   52     52      52
1   52     52      52
2   52     52      52
3   小汤   2005     180
4   小王   2006     175
5   小明   2015     178
6   小红   2008     179
********************
  Name  years  height
0   52     52      52
1   52     52      52
2   52     52      52
3   52     52      52
4   52     52      52
5   52     52      52
6   52     52      52

⛄Pandas函数操作

👀Panel结构（了解）

Panel是一个用来承载数据的三维数据结构，它有三个轴，分别是items（0轴），major_axis（1轴），而 minor_axis（2轴）。这三个轴为描述、操作Panel提供了支持，其作用介绍如下：

• items：axis =0，Panel 中的每个items都对应一个DataFrame。
• major_axis：axis=1，用来描述每个DataFrame的行索引。
• minor_axis：axis=2，用来描述每个DataFrame的列索引。

pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)
参数说明：
    data	输入数据，可以是 ndarray，Series，列表，字典，或者 DataFrame。
    items	axis=0
    major_axis	axis=1
    minor_axis	axis=2
    dtype	每一列的数据类型。
    copy	默认为 False，表示是否复制数据。

自Pandas 0.25版本后， Panel结构已经被废弃。

👀描述性统计函数

函数名称	描述说明
count()	统计某个非空值的数量
sum()	求和
mean()	求均值
median()	求中位数
mode()	求众数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积
cumsum()	计算累计和，axis=0，按照行累加；axis=1，按照列累加
cumprod()	计算累计积，axis=0，按照行累积；axis=1，按照列累积
corr()	计算数列或变量之间的相关系数，取值-1到1，值越大表示关联性越强
describe()	显示与DataFrame数据列相关的统计信息摘要

在DataFrame中，使用聚合类方法时需要指定轴(axis)参数。下面介绍两种传参方式：

• 对行操作，默认使用axis=0或者使用 “index“；
• 对列操作，默认使用axis=1或者使用 “columns“。
• axis=0表示按垂直方向进行计算，而axis=1则表示按水平方向。

describe()函数输出了平均值、std和IQR值(四分位距)等一系列统计信息。通过describe()提供的include能够筛选字符列或者数字列的摘要信息。include相关参数值说明如下：

• object： 表示对字符列进行统计信息描述；
• number：表示对数字列进行统计信息描述；
• all：汇总所有列的统计信息。

import pandas as pd
import numpy as np
d = {'Name':pd.Series(['小汤','小王',"小明",'小红','小小','小微','小黄']),
   'years':pd.Series([2005,2006,2015,2008,2003,2009,2003]),
   'height':pd.Series([180,175,178,179,176,170,173])}
# 构建DataFrame
df = pd.DataFrame(d)
# 输出
print(df)
print('*'*20)
# 求出数据的所有描述信息
print(df.describe())
print('*'*20)
print(df.describe(include=["object"]))
print('*'*20)
print(df.describe(include="all"))

# 输出结果
  Name  years  height
0   小汤   2005     180
1   小王   2006     175
2   小明   2015     178
3   小红   2008     179
4   小小   2003     176
5   小微   2009     170
6   小黄   2003     173
********************
             years      height
count     7.000000    7.000000
mean   2007.000000  175.857143
std       4.203173    3.532165
min    2003.000000  170.000000
25%    2004.000000  174.000000
50%    2006.000000  176.000000
75%    2008.500000  178.500000
max    2015.000000  180.000000
********************
       Name
count     7
unique    7
top      小汤
freq      1
********************
       Name        years      height
count     7     7.000000    7.000000
unique    7          NaN         NaN
top      小汤          NaN         NaN
freq      1          NaN         NaN
mean    NaN  2007.000000  175.857143
std     NaN     4.203173    3.532165
min     NaN  2003.000000  170.000000
25%     NaN  2004.000000  174.000000
50%     NaN  2006.000000  176.000000
75%     NaN  2008.500000  178.500000
max     NaN  2015.000000  180.000000

👀自定义函数

如果想要应用自定义的函数，或者把其他库中的函数应用到Pandas对象中，有以下三种方法：

• 操作整个DataFrame的函数：pipe()
• 操作行或者列的函数：apply()
• 操作单一元素的函数：applymap()

（1）操作整个数据表

通过给pipe()函数传递一个自定义函数和适当数量的参数值，从而操作DataFrme中的所有元素。下面示例，实现了数据表中的元素值依次加 6。

import pandas as pd
import numpy as np
# 自定义函数
def addsum(a1,a2):
   return a1 + a2
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
# 相加前
print(df)
# 相加后
print(df.pipe(addsum,6))

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
    c1   c2   c3
0  126  136  156
1   96  106  116
2   66   76   86

（2）操作行或列

如果要操作DataFrame的某一行或者某一列，可以使用apply()方法，该方法与描述性统计方法类似，都有可选参数axis，并且默认按列操作。示例如下：

import pandas as pd
import numpy as np
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
# 默认按列操作，计算每一列均值
print(df.apply(np.mean))
print('*'*20)
# 传递轴参axis=1，表示逐行进行操作
print(df.apply(np.mean,axis=1))
print('*'*20)
# 求每一列中，最大值与最小值之差
print(df.apply(lambda x: x.max() - x.min()))

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
c1     90.000000
c2    100.000000
c3    113.333333
dtype: float64
********************
0    133.333333
1    100.000000
2     70.000000
dtype: float64
********************
c1    60
c2    60
c3    70
dtype: int64

（3）操作单一元素

DataFrame数据表结构的applymap()和Series系列结构的map()类似，它们都可以接受一个Python函数，并返回相应的值。

import pandas as pd
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
# 自定义函数lambda函数
print(df['c1'].map(lambda x:x*10))
print('*'*20)
# 使用了applymap()函数
print(df.applymap(lambda x:x*10))

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
0    1200
1     900
2     600
Name: c1, dtype: int64
********************
     c1    c2    c3
0  1200  1300  1500
1   900  1000  1100
2   600   700   800

👀reindex重置索引

重置索引（reindex）可以更改原DataFrame的行标签或列标签，并使更改后的行、列标签与DataFrame中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原DataFrame中不存在，那么该标签对应的元素值将全部填充为NaN。

（1）重置行列标签

import pandas as pd
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
# 重置行、列索引标签
df_reindexed = df.reindex(index=[0,1], columns=['c1', 'c3'])
print(df_reindexed)

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
    c1   c3
0  120  150
1   90  110

现有a、b两个DataFrame对象，如果想让a的行索引与b相同，您可以使用reindex_like() 方法。示例如下：

import pandas as pd
import numpy as np
a = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
b = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])
# a会按照b的形式重建行索引。需要特别注意的是，a与b的列索引标签必须相同。
a= a.reindex_like(b)
print(a)

# 输出结果
       col1      col2      col3
0  0.669617  0.010243 -0.091776
1 -0.333395 -1.521432  0.292087
2 -0.174709 -0.623413  1.291384
3  1.033132 -0.383137  1.280788
4  1.052466 -1.326848 -1.390581
5  1.828058  0.422678 -0.734622
6  0.988210 -1.047092 -1.959839

（2）填充元素值

reindex_like()提供了一个可选的参数method，使用它来填充相应的元素值，参数值介绍如下：

• pad/ffill：向前填充值；
• bfill/backfill：向后填充值；
• nearest：从距离最近的索引值开始填充。

reindex_like()还提供了一个额外参数limit，该参数用来控制填充的最大行数。示例如下：

import pandas as pd
import numpy as np
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])
# 使df2和df1行标签相同
print(df2.reindex_like(df1))
print('*'*20)
# 向前填充
print(df2.reindex_like(df1,method='ffill'))
print('*'*20)
# 向后填充
print(df2.reindex_like(df1,method='backfill'))
print('*'*20)
# limit限制填充行数
print(df2.reindex_like(df1,method='ffill',limit=2))

# 输出结果
       col1      col2      col3
0  0.552991  1.230408  0.403586
1 -0.135228  1.065911 -0.624843
2       NaN       NaN       NaN
3       NaN       NaN       NaN
4       NaN       NaN       NaN
5       NaN       NaN       NaN
********************
       col1      col2      col3
0  0.552991  1.230408  0.403586
1 -0.135228  1.065911 -0.624843
2 -0.135228  1.065911 -0.624843
3 -0.135228  1.065911 -0.624843
4 -0.135228  1.065911 -0.624843
5 -0.135228  1.065911 -0.624843
********************
       col1      col2      col3
0  0.552991  1.230408  0.403586
1 -0.135228  1.065911 -0.624843
2       NaN       NaN       NaN
3       NaN       NaN       NaN
4       NaN       NaN       NaN
5       NaN       NaN       NaN
********************
       col1      col2      col3
0  0.552991  1.230408  0.403586
1 -0.135228  1.065911 -0.624843
2 -0.135228  1.065911 -0.624843
3 -0.135228  1.065911 -0.624843
4       NaN       NaN       NaN
5       NaN       NaN       NaN

（3）重命名标签

rename()方法允许您使用某些映射(dict或Series)或任意函数来对行、列标签重新命名，示例如下：

import pandas as pd
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
# 对行和列重新命名
print(df.rename(columns={'c1':'cc1','c2':'cc2'},index = {0:'one',1:'two',2:'three'}))

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
       cc1  cc2   c3
one    120  130  150
two     90  100  110
three   60   70   80

rename()方法提供了一个inplace参数，默认值为False，表示拷贝一份原数据，并在复制后的数据上做重命名操作。若inplace=True则表示在原数据的基础上重命名。

👀iteration遍历操作

Pandas是如何遍历Series和DataFrame结构呢？对于Series而言，您可以把它当做一维数组进行遍历操作；而像DataFrame这种二维数据表结构，则类似于遍历Python字典。

在Pandas中同样也是使用for循环进行遍历。通过for遍历后，Series可直接获取相应的value，而DataFrame则会获取列标签。示例如下：

import pandas as pd
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
for col in df:
   print (col)

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
c1
c2
c3

如果想要遍历DataFrame的每一行，我们下列函数：

• iteritems()：以键值对 (key,value) 的形式遍历；
• iterrows()：以 (row_index,row) 的形式遍历行;
• itertuples()：使用已命名元组的方式对行遍历。

iteritems()以键值对的形式遍历DataFrame对象，以列标签为键，以对应列的元素为值。

import pandas as pd
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
for key,value in df.iteritems():
   print(key)
   print(value)

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
c1
0    120
1     90
2     60
Name: c1, dtype: int64
c2
0    130
1    100
2     70
Name: c2, dtype: int64
c3
0    150
1    110
2     80
Name: c3, dtype: int64

iterrows()方法按行遍历，返回一个迭代器，以行索引标签为键，以每一行数据为值。

import pandas as pd
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
# iterrows()遍历行，其中0,1,2是行索引而c1,c2,c3是列索引。
for row_index,value in df.iterrows():
   print(row_index)
   print(value)
 
# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
0
c1    120
c2    130
c3    150
Name: 0, dtype: int64
1
c1     90
c2    100
c3    110
Name: 1, dtype: int64
2
c1    60
c2    70
c3    80
Name: 2, dtype: int64

itertuples()同样将返回一个迭代器，该方法会把DataFrame的每一行生成一个元组，示例如下：

import pandas as pd
# 操作DataFrame
df = pd.DataFrame([[120,130,150],[90,100,110],[60,70,80]],columns=['c1','c2','c3'])
print(df)
print('*'*20)
for row in df.itertuples():
    print(row)

# 输出结果
    c1   c2   c3
0  120  130  150
1   90  100  110
2   60   70   80
********************
Pandas(Index=0, c1=120, c2=130, c3=150)
Pandas(Index=1, c1=90, c2=100, c3=110)
Pandas(Index=2, c1=60, c2=70, c3=80)

迭代器返回的是原对象的副本，如果在迭代过程中修改元素值，不会影响原对象。

👀排序和去重

👁排序sorting

Pandas提供了两种排序方法，分别是按标签排序和按数值排序。

（1）按行标签排序

使用sort_index()方法对行标签排序，指定轴参数（axis）或者排序顺序。或者可以对DataFrame进行排序。默认情况下，按照行标签序排序。通过将布尔值传递给ascending参数，可以控制排序的顺序（行号顺序）。

import pandas as pd
import numpy as np
# 行标签乱序排列，列标签乱序排列
unsorted_df = pd.DataFrame(np.random.randn(6,2),index=[1,4,2,3,5,0],columns=['col2','col1'])
print(unsorted_df)
print('*'*20)
sorted_df1 = unsorted_df.sort_index()
print(sorted_df1)
print('*'*20)
sorted_df2 = unsorted_df.sort_index(ascending=False)
print(sorted_df2)

# 输出结果
       col2      col1
1 -0.458463  0.422606
4  0.809682  2.489952
2  1.609935  0.096181
3  1.087255  1.215676
5  0.436520  0.389565
0  0.536720  0.820746
********************
       col2      col1
0  0.536720  0.820746
1 -0.458463  0.422606
2  1.609935  0.096181
3  1.087255  1.215676
4  0.809682  2.489952
5  0.436520  0.389565
********************
       col2      col1
5  0.436520  0.389565
4  0.809682  2.489952
3  1.087255  1.215676
2  1.609935  0.096181
1 -0.458463  0.422606
0  0.536720  0.820746

（2）按列标签排序

通过给axis轴参数传递0或1，可以对列标签进行排序。默认情况下，axis=0表示按行排序；而axis=1则表示按列排序。

import pandas as pd
import numpy as np
# 行标签乱序排列，列标签乱序排列
unsorted_df = pd.DataFrame(np.random.randn(6,2),index=[1,4,2,3,5,0],columns=['col2','col1'])
print(unsorted_df)
print('*'*20)
sorted_df1 = unsorted_df.sort_index(axis=1)
print(sorted_df1)

# 输出结果
       col2      col1
1  0.891755  1.006258
4  0.232999  0.549146
2  0.158894  0.246825
3  0.653124 -1.695749
5 -0.774252 -0.525881
0  0.082147  0.384929
********************
       col1      col2
1  1.006258  0.891755
4  0.549146  0.232999
2  0.246825  0.158894
3 -1.695749  0.653124
5 -0.525881 -0.774252
0  0.384929  0.082147

（3）按值排序

与标签排序类似，sort_values()表示按值排序。它接受一个by参数，该参数值是要排序数列的DataFrame列名。示例如下：

import pandas as pd
# 行标签乱序排列，列标签乱序排列
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
print(unsorted_df)
print('*'*20)
sorted_df1 = unsorted_df.sort_values(by='col1')
print(sorted_df1)
print('*'*20)
# 注意：当对col1列排序时，相应的col2列的元素值和行索引也会随col1一起改变。by参数可以接受一个列表参数值
sorted_df2 = unsorted_df.sort_values(by=['col1','col2'])
print(sorted_df2)

# 输出结果
   col1  col2
0     2     1
1     1     3
2     1     2
3     1     4
********************
   col1  col2
1     1     3
2     1     2
3     1     4
0     2     1
********************
   col1  col2
2     1     2
1     1     3
3     1     4
0     2     1

（4）排序算法

sort_values()提供了参数kind用来指定排序算法。这里有三种排序算法：

• mergesort
• heapsort
• quicksort

默认为quicksort(快速排序) ，其中Mergesort归并排序是最稳定的算法。

import pandas as pd
# 行标签乱序排列，列标签乱序排列
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
print(unsorted_df)
print('*'*20)
sorted_df1 = unsorted_df.sort_values(by='col1',kind='mergesort')
print(sorted_df1)

# 输出结果
   col1  col2
0     2     1
1     1     3
2     1     2
3     1     4
********************
   col1  col2
1     1     3
2     1     2
3     1     4
0     2     1

👁去重drop_duplicates()

“去重”通过字面意思不难理解，就是删除重复的数据。在一个数据集中，找出重复的数据删并将其删除，最终只保存一个唯一存在的数据项，这就是数据去重的整个过程。

Panda DataFrame对象提供了一个数据去重的函数drop_duplicates()

df.drop_duplicates(subset=['A','B','C'],keep='first',inplace=True)
参数说明如下：
    subset：表示要进去重的列名，默认为None。
    keep：有三个可选参数，分别是first、last、False，默认为first，表示只保留第一次出现的重复项，删除其余重复项，last表示只保留最后一次出现的重复项，False则表示删除所有重复项。
    inplace：布尔值参数，默认为False表示删除重复项后返回一个副本，若为Ture则表示直接在原数据上删除重复项。

删除重复项后，行标签使用的数字是原来的，并没有从0重新开始，那么我们应该怎么从0重置索引呢？Pandas提供的reset_index()函数会直接使用重置后的索引。

import pandas as pd
data = {'col1':[1,0,1,1],'col2':[0,2,5,0],'col3':[4,0,4,4],'col4':[1,0,1,1]}
df = pd.DataFrame(data)
print(df)
print('*'*20)
# 默认保留第一次出现的重复项,默认为first
print(df.drop_duplicates())
print('*'*20)
# keep=False删除所有重复项
df1 = df.drop_duplicates(keep=False)
print(df1)
print('*'*20)
# 重置索引，从0重新开始
print(df1.reset_index(drop=True))
print('*'*20)
# 指定多列同时去重
print(df.drop_duplicates(['col3','col4'],keep='last'))

# 输出结果
   col1  col2  col3  col4
0     1     0     4     1
1     0     2     0     0
2     1     5     4     1
3     1     0     4     1
********************
   col1  col2  col3  col4
0     1     0     4     1
1     0     2     0     0
2     1     5     4     1
********************
   col1  col2  col3  col4
1     0     2     0     0
2     1     5     4     1
********************
   col1  col2  col3  col4
0     0     2     0     0
1     1     5     4     1
********************
   col1  col2  col3  col4
1     0     2     0     0
3     1     0     4     1

👀字符串处理

Pandas提供了一系列的字符串函数，因此能够很方便地对字符串进行处理。

函数名称	函数功能和描述
lower()	将的字符串转换为小写
upper()	将的字符串转换为大写
len()	得出字符串的长度
strip()	去除字符串两边的空格（包含换行符）
split()	用指定的分割符分割字符串
cat(sep="")	用给定的分隔符连接字符串元素
get_dummies()	返回一个带有独热编码值的DataFrame结构
contains(pattern)	如果子字符串包含在元素中，则为每个元素返回一个布尔值True，否则为False
replace(a,b)	将值a替换为值b
count(pattern)	返回每个字符串元素出现的次数
startswith(pattern)	如果Series中的元素以指定的字符串开头，则返回True
endswith(pattern)	如果Series中的元素以指定的字符串结尾，则返回True
findall(pattern)	以列表的形式返出现的字符串
swapcase()	交换大小写
islower()	返回布尔值，检查Series中组成每个字符串的所有字符是否都为小写
issupper()	返回布尔值，检查Series中组成每个字符串的所有字符是否都为大写
isnumeric()	返回布尔值，检查Series中组成每个字符串的所有字符是否都为数字
repeat(value)	以指定的次数重复每个元素
find(pattern)	返回字符串第一次出现的索引位置

注意：上述所有字符串函数全部适用于DataFrame对象，同时也可以与Python内置的字符串函数一起使用，这些函数在处理Series/DataFrame对象的时候会自动忽略缺失值数据（NaN）。

import pandas as pd
import numpy as np
s = pd.Series(['C ', ' Python', 'java', 'go', np.nan, '1125 ','javascript'])
print(s.str.lower)
print('*'*20)
print(s.str.len())
print('*'*20)
print(s.str.strip())
print('*'*20)
print(s.str.split(" "))
print('*'*20)
print(s.str.cat(sep="_"))
print('*'*20)
print(s.str.get_dummies())
print('*'*20)
print(s.str.contains(" "))
print('*'*20)
print(s.str.repeat(3))
print('*'*20)
print(s.str.startswith("j"))
print('*'*20)
# 如果返回-1表示该字符串中没有出现指定的字符
print(s.str.find("j"))
print('*'*20)
print(s.str.swapcase())
print('*'*20)
print(s.str.isnumeric())

# 输出结果
0            c 
1        python
2          java
3            go
4           NaN
5         1125 
6    javascript
dtype: object
********************
0     2.0
1     7.0
2     4.0
3     2.0
4     NaN
5     5.0
6    10.0
dtype: float64
********************
0             C
1        Python
2          java
3            go
4           NaN
5          1125
6    javascript
dtype: object
********************
0           [C, ]
1      [, Python]
2          [java]
3            [go]
4             NaN
5        [1125, ]
6    [javascript]
dtype: object
********************
C _ Python_java_go_1125 _javascript
********************
    Python  1125   C   go  java  javascript
0        0      0   1   0     0           0
1        1      0   0   0     0           0
2        0      0   0   0     1           0
3        0      0   0   1     0           0
4        0      0   0   0     0           0
5        0      1   0   0     0           0
6        0      0   0   0     0           1
********************
0     True
1     True
2    False
3    False
4      NaN
5     True
6    False
dtype: object
********************
0                            C C C 
1              Python Python Python
2                      javajavajava
3                            gogogo
4                               NaN
5                   1125 1125 1125 
6    javascriptjavascriptjavascript
dtype: object
********************
0    False
1    False
2     True
3    False
4      NaN
5    False
6     True
dtype: object
********************
0   -1.0
1   -1.0
2    0.0
3   -1.0
4    NaN
5   -1.0
6    0.0
dtype: float64
********************
0            c 
1        pYTHON
2          JAVA
3            GO
4           NaN
5         1125 
6    JAVASCRIPT
dtype: object
********************
0    False
1    False
2    False
3    False
4      NaN
5    False
6    False
dtype: object

👀设置数据显示格式

在用Pandas做数据分析的过程中，总需要打印数据分析的结果，如果数据体量较大就会存在输出内容不全（部分内容省略）或者换行错误等问题。Pandas为了解决上述问题，允许你对数据显示格式进行设置。下面列出了五个用来设置显示格式的函数，分别是：

函数名称	说明
get_option()	获取解释器的默认参数值
set_option()	更改解释器的默认参数值
reset_option()	解释器的参数重置为默认值
describe_option()	输出参数的描述信息
option_context()	临时设置解释器参数，当退出使用的语句块时，恢复为默认值

上述函数常用的参数项：

参数	说明
display.max_rows	最大显示行数，超过该值用省略号代替，为None时显示所有行
display.max_columns	最大显示列数，超过该值用省略号代替，为None时显示所有列
display.expand_frame_repr	输出数据宽度超过设置宽度时，表示是否对其要折叠，False不折叠，True要折叠
display.max_colwidth	单列数据宽度，以字符个数计算，超过时用省略号表示
display.precision	设置输出数据的小数点位数
display.width	数据显示区域的宽度，以总字符数计算
display.show_dimensions	当数据量大需要以truncate（带引号的省略方式）显示时，该参数表示是否在最后显示数据的维数，默认True显示，False不显示。

👀loc和iloc用法详解

在数据分析过程中，很多时候需要从数据表中提取出相应的数据，而这么做的前提是需要先“索引”出这一部分数据。虽然通过Python提供的索引操作符"[]"和属性操作符"."可以访问Series或者DataFrame中的数据，但这种方式只适应与少量的数据，为了解决这一问题，Pandas提供了两种类型的索引方式来实现数据的访问。

方法名称	说明
.loc[]	基于标签索引选取数据
.iloc[]	基于整数索引选取数据

df.loc[]只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）。

.loc[]具有多种访问方法，如下所示：

• 一个标量标签
• 标签列表
• 切片对象
• 布尔数组

loc[]接受两个参数，并以','分隔。第一个位置表示行，第二个位置表示列。

import pandas as pd

data = {
    "name": ['Tom', 'Rose', 'Mike', 'Twg'],
  "calories": [420, 380, 390, 500],
  "duration": [50, 40, 45, 60]
}
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data, index = ['a', 'b', 'c', 'd'])
print(df)
print('*'*20)
# 对行操作，等同于df.loc['a':'b']
print(df.loc['a':'b',:])
print('*'*20)
# 对列操作
print(df.loc[:,'name'])
print('*'*20)
# 对行、列操作
print(df.loc[['a','d'],['name','duration']])
print('*'*20)
# 布尔值操作
print(df.loc[:,'duration'] > 45)

# 输出结果
   name  calories  duration
a   Tom       420        50
b  Rose       380        40
c  Mike       390        45
d   Twg       500        60
********************
   name  calories  duration
a   Tom       420        50
b  Rose       380        40
********************
a     Tom
b    Rose
c    Mike
d     Twg
Name: name, dtype: object
********************
  name  duration
a  Tom        50
d  Twg        60
********************
a     True
b    False
c    False
d     True
Name: duration, dtype: bool

df.iloc[]只能使用整数索引，不能使用标签索引，通过整数索引切片选择数据时，前闭后开(不包含边界结束值)。同Python和NumPy一样，它们的索引都是从0开始。

.iloc[]提供了以下方式来选择数据：

• 整数索引
• 整数列表
• 数值范围

import pandas as pd

data = {
    "name": ['Tom', 'Rose', 'Mike', 'Twg'],
  "calories": [420, 380, 390, 500],
  "duration": [50, 40, 45, 60]
}
# 数据载入到 DataFrame 对象
df = pd.DataFrame(data, index = ['a', 'b', 'c', 'd'])
print(df)
print('*'*20)
print(df.iloc[2:,:])
print('*'*20)
print(df.iloc[[0,2],[1,2]])
print('*'*20)
print(df.iloc[:,:2])

# 输出结果
   name  calories  duration
a   Tom       420        50
b  Rose       380        40
c  Mike       390        45
d   Twg       500        60
********************
   name  calories  duration
c  Mike       390        45
d   Twg       500        60
********************
   calories  duration
a       420        50
c       390        45
********************
   name  calories
a   Tom       420
b  Rose       380
c  Mike       390
d   Twg       500

👀日期时间操作

👁Pandas时间序列

顾名思义，时间序列（time series），就是由时间构成的序列，它指的是在一定时间内按照时间顺序测量的某个变量的取值序列，比如一天内的温度会随时间而发生变化，或者股票的价格会随着时间不断的波动，这里用到的一系列时间，就可以看做时间序列。时间序列包含三种应用场景，分别是：

• 特定的时刻（timestamp），也就是时间戳；
• 固定的日期（period），比如某年某月某日；
• 时间间隔（interval），每隔一段时间具有规律性；

在处理时间序列的过程中，我们一般会遇到两个问题，第一，如何创建时间序列；第二，如何更改已生成时间序列的频率。 Pandas为解决上述问题提供了一套简单、易用的方法。

# Python内置的datetime模块来获取当前时间，通过该模块提供的now()方法即可实现。
from datetime import datetime
# 数据类型为datetime
print(datetime.now())

# 输出结果
2023-03-19 17:42:39.528176

创建时间戳：TimeStamp（时间戳） 是时间序列中的最基本的数据类型，它将数值与时间点完美结合在一起。

创建时间间隔：通过date_range()方法可以创建某段连续的时间或者固定间隔的时间时间段。该函数提供了三个参数，分别是：start开始时间；end结束时间；freq时间频率，默认为 “D”（天）。

import pandas as pd
# 创建时间戳
print(pd.Timestamp('2023-03-16'))
# 可以将整型或浮点型表示的时间转换为时间戳。默认的单位是纳秒(时间戳单位)
print(pd.Timestamp(1687687255,unit='s'))
print('*'*20)
# 创建时间范围，freq表示时间频率，每30min变化一次
print(pd.date_range("9:00", "18:10", freq="30min").time)
# 修改为按小时
print(pd.date_range("9:00", "18:10", freq="H").time)
print('*'*20)
# 使用to_datetime()函数将series或list转换为日期对象，其中list会转换为DatetimeIndex
# 输出中，注意：NaT表示的不是时间 ，它等效于NaN
# 传入series，生成Datetimeindex
print(pd.to_datetime(pd.Series(['Jun 3, 2020','2020-12-10', None])))
# 传入list，生成Datetimeindex
print(pd.to_datetime(['Jun 30, 2020','2020-12-10', None]))

# 输出结果
2023-03-16 00:00:00
2023-06-25 10:00:55
********************
[datetime.time(9, 0) datetime.time(9, 30) datetime.time(10, 0)
 datetime.time(10, 30) datetime.time(11, 0) datetime.time(11, 30)
 datetime.time(12, 0) datetime.time(12, 30) datetime.time(13, 0)
 datetime.time(13, 30) datetime.time(14, 0) datetime.time(14, 30)
 datetime.time(15, 0) datetime.time(15, 30) datetime.time(16, 0)
 datetime.time(16, 30) datetime.time(17, 0) datetime.time(17, 30)
 datetime.time(18, 0)]
[datetime.time(9, 0) datetime.time(10, 0) datetime.time(11, 0)
 datetime.time(12, 0) datetime.time(13, 0) datetime.time(14, 0)
 datetime.time(15, 0) datetime.time(16, 0) datetime.time(17, 0)
 datetime.time(18, 0)]
********************
0   2020-06-03
1   2020-12-10
2          NaT
dtype: datetime64[ns]
DatetimeIndex(['2020-06-30', '2020-12-10', 'NaT'], dtype='datetime64[ns]', freq=None)

频率和周期转换：Time Periods表示时间跨度，一段时间周期，它被定义在Pandas Periods类中，通过该类提供的方法可以实现将频率转换为周期。比如Periods()方法，可以将频率 “M“（月）转换为 Period（时间段）。使用asfreq()和start参数，打印 “01“ ，若使用end参数，则打印 “31“。对于常用的时间序列频率，Pandas为其规定了一些字符串别名，我们将这些别名称为“offset（偏移量）”。

别名	描述	别名	描述
B	工作日频率	BQS	工作季度开始频率
D	日历日频率	A	年终频率
W	每周频率	BA	工作年度结束频率
M	月末频率	BAS	工作年度开始频率
SM	半月结束频率	BH	营业时间频率
BM	工作月结束频率	H	小时频率
MS	月开始频率	T,min	每分钟频率
SMS	半月开始频率	S	每秒钟频率
BMS	工作月开始频率	L,ms	毫秒
Q	季末频率	U,us	微秒
BQ	工作季度结束频率	N	纳秒
QS	季度开始频率

周期计算：指的是对时间周期进行算术运算，所有的操作将在“频率”的基础上执行。

创建时间周期：可以使用period_range()方法来创建时间周期范围。

时间序列转换：如果想要把字符串日期转换为Period，首先需要将字符串转换为日期格式，然后再将日期转换为Period。

import pandas as pd 
# S表示秒
x = pd.Period('2014', freq='S')
print(x)
# 加1s的时间
print(x+1)
# 使用period_range()方法来创建时间周期范围
p = pd.period_range('2016','2018', freq='Y')
print(p)

# 输出结果
2014-01-01 00:00:00
2014-01-01 00:00:01
PeriodIndex(['2016', '2017', '2018'], dtype='period[A-DEC]', freq='A-DEC')

👁日期时间格式化

当进行数据分析时，我们会遇到很多带有日期、时间格式的数据集，在处理这些数据集时，可能会遇到日期格式不统一的问题，此时就需要对日期时间做统一的格式化处理。比如”Wednesday, June 6, 2020“可以写成”6/6/20“，或者写成”06-06-2020“。

（1）日期格式化符号

在对时间进行格式化处理时，它们都有固定的表示格式，比如小时的格式化符号为%H ,分钟简写为%M ，秒简写为%S。

符号	说明	符号	说明
%y	两位数的年份表示（00-99）	%Y	四位数的年份表示（000-9999）
%m	月份（01-12）	%d	月内中的一天（0-31）
%H	24小时制小时数（0-23）	%I	12小时制小时数（01-12）
%M	分钟数（00=59）	%S	秒（00-59）
%a	本地英文缩写星期名称	%A	本地英文完整星期名称
%b	本地缩写英文的月份名称	%B	本地完整英文的月份名称
%w	星期（0-6），星期天为星期的开始	%W	一年中的星期数（00-53）星期一为星期的开始
%x	本地相应的日期表示	%X	本地相应的时间表示
%Z	当前时区的名称	%U	一年中的星期数（00-53）星期天为星期的开始
%j	年内的一天（001-366）	%c	本地相应的日期表示和时间表示

（2）日期格式化处理函数

Python内置的strptime()方法能够将字符串日期转换为datetime类型。

from datetime import datetime
# 将日期定义为字符串    
date_str1 = 'Wednesday,July 18,2020' 
date_str2 = '18/7/20' 
date_str3 = '18-07-2020'  
# 将日期转化为datetime对象 
dmy_dt1 = datetime.strptime(date_str1, '%A,%B %d,%Y') 
dmy_dt2 = datetime.strptime(date_str2, '%d/%m/%y') 
dmy_dt3 = datetime.strptime(date_str3, '%d-%m-%Y')  
# 处理为相同格式，并打印输出
print(dmy_dt1) 
print(dmy_dt2) 
print(dmy_dt3) 

# 输出结果
2020-07-18 00:00:00
2020-07-18 00:00:00
2020-07-18 00:00:00

除了使用Python内置的strptime()方法外，你还可以使用Pandas模块的pd.to_datetime()和pd.DatetimeIndex()进行转换。

import pandas as pd
import numpy as np
# 通过to_datetime()直接转换为 datetime 类型
date1 = ['2012-05-06 11:00:00','2012-05-16 11:00:00']
pd_date1 = pd.to_datetime(date1)
df1 = pd.Series(np.random.randn(2),index=pd_date1)
print(pd_date1)
print(df1)
print('*'*20)
# 使用Datetimeindex()函数设置时间序
date2 = pd.DatetimeIndex(['1/1/2008', '1/2/2008', '1/3/2008', '1/4/2008', '1/5/2008'])
dt2 = pd.DataFrame(np.random.randn(5),index=date2, columns=['value'])
print(date2)
print(dt2)

# 输出结果
DatetimeIndex(['2012-05-06 11:00:00', '2012-05-16 11:00:00'], dtype='datetime64[ns]', freq=None)
2012-05-06 11:00:00    2.115566
2012-05-16 11:00:00   -0.145139
dtype: float64
********************
DatetimeIndex(['2008-01-01', '2008-01-02', '2008-01-03', '2008-01-04',
               '2008-01-05'],
              dtype='datetime64[ns]', freq=None)
               value
2008-01-01  0.828022
2008-01-02 -1.873516
2008-01-03  1.940921
2008-01-04  1.563612
2008-01-05  0.964914

👁Timedelta时间差

Timedelta表示时间差（或者时间增量），我们可以使用不同的时间单位来表示它，比如，天、小时、分、秒。时间差的最终的结果可以是正时间差，也可以是负时间差。

import pandas as pd
import numpy as np
# 通过传递字符串可以创建Timedelta对象
print(pd.Timedelta('5 days 8 hours 6 minutes 59 seconds'))
# 通过传递整数值和unit参数也可以创建一个Timedelta对象。
print(pd.Timedelta(19,unit='h'))
# 数据偏移量， 比如，周(weeks)、天(days)、小时(hours)、分钟(minutes)、秒(milliseconds)、毫秒、微秒、纳秒都可以使用。
print(pd.Timedelta(days=2,hours=6))
print('*'*20)
# 您可以使用pd.to_timedelta()方法，将具有timedelta格式的值 (标量、数组、列表或Series）转换为Timedelta类型。如果输入是Series，则返回Series；如果输入是标量，则返回值也为标量，其他情况输出TimedeltaIndex。
print(pd.to_timedelta(['1 days 06:05:01.00003', '15.5us', 'nan']))
print(pd.to_timedelta(np.arange(5), unit='s'))

# 输出结果
5 days 08:06:59
0 days 19:00:00
2 days 06:00:00
********************
TimedeltaIndex(['1 days 06:05:01.000030', '0 days 00:00:00.000015', NaT], dtype='timedelta64[ns]', freq=None)
TimedeltaIndex(['00:00:00', '00:00:01', '00:00:02', '00:00:03', '00:00:04'], dtype='timedelta64[ns]', freq=None)

通过对datetime64[ns]类型的时间序列或时间戳做算术运算，其运算结果依然是datetime64[ns]数据类型。接下来，我们创建一个带有Timedelta与datetime的DataFrame对象，并对其做一些算术运算。

import pandas as pd
s = pd.Series(pd.date_range('2020-1-1', periods=5, freq='D'))
# 推导式用法
td = pd.Series([ pd.Timedelta(days=i) for i in range(5)])
df = pd.DataFrame(dict(A = s, B = td))
print(df)
print('*'*20)
# 加法运算
df['C']=df['A']+df['B']
print(df)
print('*'*20)
# 减法运算
df['D']=df['C']-df['B']
print(df)

# 输出结果
           A      B
0 2020-01-01 0 days
1 2020-01-02 1 days
2 2020-01-03 2 days
3 2020-01-04 3 days
4 2020-01-05 4 days
********************
           A      B          C
0 2020-01-01 0 days 2020-01-01
1 2020-01-02 1 days 2020-01-03
2 2020-01-03 2 days 2020-01-05
3 2020-01-04 3 days 2020-01-07
4 2020-01-05 4 days 2020-01-09
********************
           A      B          C          D
0 2020-01-01 0 days 2020-01-01 2020-01-01
1 2020-01-02 1 days 2020-01-03 2020-01-02
2 2020-01-03 2 days 2020-01-05 2020-01-03
3 2020-01-04 3 days 2020-01-07 2020-01-04
4 2020-01-05 4 days 2020-01-09 2020-01-05

👀数据样本处理

👁Pandas缺失值处理

稀疏数据，指的是在数据库或者数据集中存在大量缺失数据或者空值，我们把这样的数据集称为稀疏数据集。稀疏数据不是无效数据，只不过是信息不全而已，只要通过适当的方法就可以“变废为宝”。

检查缺失值：Pandas提供了isnull()和notnull()两个函数，它们同时适用于Series和DataFrame对象。

缺失数据计算：计算缺失数据时，需要注意两点：首先数据求和时，将NA值视为0，其次，如果要计算的数据为NA，那么结果就是NA。

清理并填充缺失值：Pandas提供了多种方法来清除缺失值。fillna()函数可以实现用非空数据“填充”NaN值；ffill()向前填充和bfill()向后填充，使用这两个函数也可以处理NA值。replace()将DataFrame中的通用值替换成特定值。

删除缺失值：使用dropna()函数与参数axis可以实现删除缺失值。在默认情况下，按照axis=0来按行处理，这意味着如果某一行中存在NaN值将会删除整行数据。

👁Pandas随机样本选择

随机抽样，是统计学中常用的一种方法，它可以帮助我们从大量的数据中快速地构建出一组数据分析模型。在Pandas中，如果想要对数据集进行随机抽样，需要使用sample()函数。该函数返回与数据集类型相同的新对象，相当于numpy.random.choice()。

DataFrame.sample(n=None,frac=None,replace=False,weights=None,random_state=None,axis=None)
参数说明
n		表示要抽取的行数。
frac	表示抽取的比例，比如frac=0.5，代表抽取总体数据的50%。
replace	布尔值参数，表示是否以有放回抽样的方式进行选择，默认为False，取出数据后不再放回。
weights	可选参数，代表每个样本的权重值，参数值是字符串或者数组。
random_state 可选参数，控制随机状态，默认为None，表示随机数据不会重复；若为1表示会取得重复数据。
axis	表示在哪个方向上抽取数据(axis=1表示列/axis=0表示行)。

👁Pandas数据重采样

数据重采样是将时间序列从一个频率转换至另一个频率的过程，它主要有两种实现方式，分别是降采样和升采样，降采样指将高频率的数据转换为低频率，升采样则与其恰好相反，说明如下：

方法	说明
降采样	将高频率(间隔短)数据转换为低频率(间隔长)。
升采样	将低频率数据转换为高频率。

Pandas提供了resample()函数来实现数据的重采样。

asfreq()方法不仅能够实现频率转换，还可以保留原频率对应的数值，同时它也可以单独使用。

插值处理，升采样的结果会产生缺失值，那么就需要对缺失值进行处理，一般有以下几种处理方式：

方法	说明
pad/ffill	用前一个非缺失值去填充缺失值。
backfill/bfill	用后一个非缺失值去填充缺失值。
interpolater('linear')	线性插值方法。
fillna(value)	指定一个值去替换缺失值。

👁Pandas分类对象

通常情况下，数据集中会存在许多同一类别的信息，比如相同国家、相同行政编码、相同性别等，当这些相同类别的数据多次出现时，就会给数据处理增添许多麻烦，导致数据集变得臃肿，不能直观、清晰地展示数据。

Pandas提供了分类对象（Categorical Object），该对象能够实现有序排列、自动去重的功能，但是它不能执行运算。通过Category的构造函数，您可以创建一个类别对象。

pandas.Categorical(values, categories, ordered)
参数说明
    values：以列表的形式传参，表示要分类的值。
    ordered：布尔值，默认为False，若为Ture，表示对分类的数据进行排序。
    dtype：返回一个category类型，表示分类对象。

describe()：对已经分类的数据使用describe()方法，得到和数据统计相关的摘要信息。

categories：使用obj.categories命令可以获取对象的类别信息。

Series.cat.categories：对类别实现重命名。

Series.cat.add_categories()：追加新类别。

Series.cat.remove_categories()：删除不需要的类别。

👀其它函数

👁Pandas统计函数

Pandas的本质是统计学原理在计算机领域的一种应用实现，通过编程的方式达到分析、描述数据的目的。而统计函数则是统计学中用于计算和分析数据的一种工具。在数据分析的过程中，使用统计函数有助于我们理解和分析数据。常见的统计函数，比如百分比函数、协方差函数、相关系数等。

• pct_change() ：Series和DatFrames都可以使用pct_change()函数。该函数将每个元素与其前一个元素进行比较，并计算前后数值的百分比变化。默认情况下，pct_change()对列进行操作，如果想要操作行，则需要传递参数axis=1参数。
• cov()：Series对象提供了一个cov方法用来计算Series对象之间的协方差。同时，该方法也会将缺失值(NAN)自动排除。当应用于DataFrame时，协方差（cov）将计算所有列之间的协方差。
• corr()：相关系数显示任意两个Series之间的线性关系。Pandas提供了计算相关性的三种方法，分别是pearson(default)、spearman()和kendall()。注意：如果DataFrame存在非数值（NAN），该方法会自动将其删除。
• rank() ：按照某种规则（升序或者降序）对序列中的元素值排名，该函数的返回值的也是一个序列，包含了原序列中每个元素值的名次。如果序列中包含两个相同的的元素值，那么会为其分配两者的平均排名。

👁Pandas窗口函数

为了能更好地处理数值型数据，Pandas提供了几种窗口函数：

• 移动函数（rolling）
• 扩展函数（expanding）
• 指数加权函数（ewm）

窗口是一种形象化的叫法，这些函数在执行操作时，就如同窗口一样在数据区间上移动。

如何在DataFrame和Series对象上应用窗口函数：

• rolling() ：移动窗口函数，它可以与mean、count、sum、median、std等聚合函数一起使用。

  rolling(window=n, min_periods=None, center=False)
  参数说明
      window	默认值为1，表示窗口的大小，也就是观测值的数量，
      min_periods	表示窗口的最小观察值，默认与window的参数值相等。
      center	是否把中间值做为窗口标准，默认值为False。

• expanding() ：扩展窗口函数，扩展是指由序列的第一个元素开始，逐个向后计算元素的聚合值。

• ewm()：（全称 Exponentially Weighted Moving）表示指数加权移动。ewn()函数先会对序列元素做指数加权运算，其次计算加权后的均值。该函数通过指定com、span或者halflife参数来实现指数加权移动。

在数据分析的过程中，使用窗口函数能够提升数据的准确性，并且使数据曲线的变化趋势更加平滑，从而让数据分析变得更加准确、可靠。

👁Pandas聚合函数

窗口函数可以与聚合函数一起使用，聚合函数指的是对一组数据求总和、最大值、最小值以及平均值的操作，本节重点讲解聚合函数的应用。

import pandas as pd
import numpy as np

data = {'col1':[1,0,1,1],'col2':[0,2,5,0],'col3':[4,0,4,4],'col4':[1,0,1,1]}
df = pd.DataFrame(data)
print(df)
print("*"*20)
# 窗口大小为3，min_periods最小观测值为1
r1 = df.rolling(window=3,min_periods=1)
# min_periods默认与window的参数值相等
r2 = df.rolling(window=3)
print(r1.sum())
print(r2.sum())
print("*"*20)
# 把一个聚合函数传递给DataFrame
# 对整体聚合,使用aggregate()聚合操作
print(r1.aggregate(np.sum))
print("*"*20)
# 对任意某一列聚合
print(r1['col1'].aggregate(np.sum))
print("*"*20)
# 对多列数据聚合
print(r1['col1','col2'].aggregate(np.sum))
print("*"*20)
# 对单列应用多个函数
print(r1['col1'].aggregate([np.sum,np.mean]))
print("*"*20)
# 对不同列应用多个函数
print(r1['col1','col2'].aggregate([np.sum,np.mean]))
print("*"*20)
# 对不同列应用不同函数
print(r1.aggregate({'col1':np.sum,'col2':np.mean}))

# 输出结果
 col1  col2  col3  col4
0     1     0     4     1
1     0     2     0     0
2     1     5     4     1
3     1     0     4     1
********************
   col1  col2  col3  col4
0   1.0   0.0   4.0   1.0
1   1.0   2.0   4.0   1.0
2   2.0   7.0   8.0   2.0
3   2.0   7.0   8.0   2.0
   col1  col2  col3  col4
0   NaN   NaN   NaN   NaN
1   NaN   NaN   NaN   NaN
2   2.0   7.0   8.0   2.0
3   2.0   7.0   8.0   2.0
********************
   col1  col2  col3  col4
0   1.0   0.0   4.0   1.0
1   1.0   2.0   4.0   1.0
2   2.0   7.0   8.0   2.0
3   2.0   7.0   8.0   2.0
********************
0    1.0
1    1.0
2    2.0
3    2.0
Name: col1, dtype: float64
********************
   col1  col2
0   1.0   0.0
1   1.0   2.0
2   2.0   7.0
3   2.0   7.0
********************
   sum      mean
0  1.0  1.000000
1  1.0  0.500000
2  2.0  0.666667
3  2.0  0.666667
********************
  col1           col2          
   sum      mean  sum      mean
0  1.0  1.000000  0.0  0.000000
1  1.0  0.500000  2.0  1.000000
2  2.0  0.666667  7.0  2.333333
3  2.0  0.666667  7.0  2.333333
********************
   col1      col2
0   1.0  0.000000
1   1.0  1.000000
2   2.0  2.333333
3   2.0  2.333333

👁groupby分组操作

在数据分析中，经常会遇到这样的情况：根据某一列（或多列）标签把数据划分为不同的组别，然后再对其进行数据分析。比如，某网站对注册用户的性别或者年龄等进行分组，从而研究出网站用户的画像（特点）。在Pandas 中，要完成数据的分组操作，需要使用groupby()函数，它和SQL的GROUP BY操作非常相似。 在划分出来的组（group）上应用一些统计函数，从而达到数据分析的目的，比如对分组数据进行聚合、转换，或者过滤。这个过程主要包含以下三步：

• 拆分（Spliting）：表示对数据进行分组；
• 应用（Applying）：对分组数据应用聚合函数，进行相应计算；
• 合并（Combining）：最后汇总计算结果。

使用groupby()可以沿着任意轴分组。您可以把分组时指定的键（key）作为每组的组名，方法如下所示：

• df.groupby("key")
• df.groupby("key",axis=1)
• df.groupby(["key1","key2"])

import pandas as pd
import numpy as np
data = {'name': ['John', 'Helen', 'John', 'Ella'],
   'score': [82, 98, 91, 87],
   'option_course': ['C#','Python','Java','C']}
df = pd.DataFrame(data)
print(df)
print("*"*20)
# 生成分组groupby对象
print(df.groupby('score'))
print("*"*20)
# 查看分组,通过调用groups属性查看分组结果
print(df.groupby('score').groups)
print("*"*20)
# 多个列标签分组
print(df.groupby(['name','score']).groups)
print("*"*20)
# 通过 get_group()方法可以选择组内的具体数据项
print(df.groupby('score').get_group(91))
print("*"*20)
# 遍历分组数据
grouped=df.groupby('score')
for label, option_course in grouped:
	# 其中key代表分组后字典的键，也就是score
    print(label)
	# 字典对应的值选修的科目
    print(option_course)
print("*"*20)
# 通过agg()函数可以对分组对象应用多个聚合函数
grouped_name = df.groupby('name')
	# 应用一个聚合函数求均值
print(grouped_name['score'].agg(np.mean))
	# 应用多个聚合函数求均值
print(grouped_name['score'].agg([np.size,np.mean,np.std]))
print("*"*20)
# 组的数据过滤操作,筛选出名字出现超过两次的人名
print(grouped_name.filter(lambda x: len(x) >= 2))

# 输出结果
  name  score option_course
0   John     82            C#
1  Helen     98        Python
2   John     91          Java
3   Ella     87             C
********************
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001CB3F4CD948>
********************
{82: Int64Index([0], dtype='int64'), 87: Int64Index([3], dtype='int64'), 91: Int64Index([2], dtype='int64'), 98: Int64Index([1], dtype='int64')}
********************
{('Ella', 87): Int64Index([3], dtype='int64'), ('Helen', 98): Int64Index([1], dtype='int64'), ('John', 82): Int64Index([0], dtype='int64'), ('John', 91): Int64Index([2], dtype='int64')}
********************
   name  score option_course
2  John     91          Java
********************
82
   name  score option_course
0  John     82            C#
87
   name  score option_course
3  Ella     87             C
91
   name  score option_course
2  John     91          Java
98
    name  score option_course
1  Helen     98        Python
********************
name
Ella     87.0
Helen    98.0
John     86.5
Name: score, dtype: float64
       size  mean       std
name                       
Ella      1  87.0       NaN
Helen     1  98.0       NaN
John      2  86.5  6.363961
********************
   name  score option_course
0  John     82            C#
2  John     91          Java

组的转换操作：通过transform()函数可以实现组的转换，在组的行或列上可以执行转换操作，最终会返回一个与组大小相同的索引对象。

组的数据过滤操作：通过filter()函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集。

👁merge合并操作

Pandas提供的merge()函数能够进行高效的合并操作，这与SQL关系型数据库的MERGE用法非常相似。从字面意思上不难理解，merge翻译为“合并”，指的是将两个DataFrame数据表按照指定的规则进行连接，最后拼接成一个新的DataFrame数据表。merge()函数的法格式如下：

pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=True,suffixes=('_x', '_y'), copy=True)

参数说明
left/right: 两个不同的DataFrame对象。
on: 指定用于连接的键（即列标签的名字），该键必须同时存在于左右两个DataFrame中，如果没有指定，并且其他参数也未指定， 那么将会以两个DataFrame的列名交集做为连接键。
left_on: 指定左侧DataFrame中作连接键的列名。该参数在左、右列标签名不相同，但表达的含义相同时非常有用。
right_on: 指定左侧DataFrame中作连接键的列名。
left_index: 布尔参数，默认为False。如果为True 则使用左侧DataFrame的行索引作为连接键，若DataFrame具有多层索引(MultiIndex)，则层的数量必须与连接键的数量相等。
right_index: 布尔参数，默认为False。如果为True 则使用左侧DataFrame的行索引作为连接键。
how: 要执行的合并类型，从{'left','right','outer','inner'} 中取值，默认为“inner”内连接。
sort: 布尔值参数，默认为True，它会将合并后的数据进行排序；若设置为False，则按照how给定的参数值进行排序。
suffixes: 字符串组成的元组。当左右DataFrame存在相同列名时，通过该参数可以在相同的列名后附加后缀名，默认为('_x','_y')。
copy: 默认为True，表示对数据进行复制。

注意：Pandas库的merge()支持各种内外连接，与其相似的还有join()函数（默认为左连接）。

👁concat连接操作

Pandas通过concat()函数能够轻松地将Series与DataFrame对象组合在一起，函数的语法格式如下：

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False)

参数说明
objs: 一个序列或者是Series、DataFrame对象。
axis: 表示在哪个轴方向上（行或者列）进行连接操作，默认axis=0表示行方向。
join: 指定连接方式，取值为{"inner","outer"}，默认为outer表示取并集，inner代表取交集。
ignore_index: 布尔值参数，默认为False，如果为True，表示不在连接的轴上使用索引。
join_axes: 表示索引对象的列表。

append(): 如果要连接Series和DataFrame对象，有一个最方便、快捷的方法，就是append()方法。该方法沿着axis=0（行方向）进行操作；append()函数也可接收多个对象。

👀Pandas绘图

Pandas对Matplotlib绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作。

import pandas as pd
import numpy as np
# 创建包含时间序列的数据
df = pd.DataFrame(np.random.randn(8,4),index=pd.date_range('2/1/2020',periods=8), columns=list('ABCD'))
df.plot()
# 如果行索引中包含日期，Pandas会自动调用gct().autofmt_xdate()来格式化x轴。

除了使用默认的线条绘图外，您还可以使用其他绘图方式，如下所示：

• 柱状图：bar() 或 barh()
• 直方图：hist()
• 箱状箱：box()
• 区域图：area()
• 散点图：scatter()

通过关键字参数kind可以把上述方法传递给plot()。

（1）柱状图

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10,4),columns=['a','b','c','d'])
# 或使用df.plot(kind="bar")
df.plot.bar()
# 通过设置参数stacked=True可以生成柱状堆叠图
# 或者使用df.plot.bar(stacked="True")
df.plot(kind="bar",stacked=True)
# 如果要绘制水平柱状图
df.plot.barh(stacked=True)

（2）直方图

plot.hist()可以实现绘制直方图，并且它还可以指定bins（构成直方图的箱数）。

import pandas as pd
import numpy as np
df = pd.DataFrame({'A':np.random.randn(100)+2,'B':np.random.randn(100),'C':np.random.randn(100)-2,'D':np.random.randn(100)+3},columns=['A', 'B', 'C','D'])
print(df)
# 指定箱数为15
df.plot.hist(bins=15)
# 给每一列数据都绘制一个直方图
df.diff().hist(color="r",alpha=0.5,bins=15)

（3）箱线图

通过调用Series.box.plot() 、DataFrame.box.plot()或者DataFrame.boxplot()方法来绘制箱型图，它将每一列数据的分布情况，以可视化的图像展现出来。

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(10, 4), columns=['A', 'B', 'C', 'D'])
df.plot.box()

（4）区域图

使用Series.plot.area()或DataFrame.plot.area()方法来绘制区域图。

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(5, 4), columns=['a', 'b', 'c', 'd'])
df.plot.area()

（5）散点图

使用DataFrame.plot.scatter()方法来绘制散点图。

import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.rand(30, 4), columns=['a', 'b', 'c', 'd'])
df.plot.scatter(x='a',y='b')

（6）饼状图

通过DataFrame.plot.pie()方法来绘制。

import pandas as pd
import numpy as np
df = pd.DataFrame(3 * np.random.rand(4), index=['go', 'java', 'c++', 'c'], columns=['L'])
df.plot.pie(subplots=True)

⛄Pandas和NumPy的比较

Pandas和NumPy被认为是科学计算与机器学习中必不可少的库，因为它们具有直观的语法和高性能的矩阵计算能力。

比较项	Pandas	NumPy
适应性	Pandas主要用来处理类表格数据。	NumPy主要用来处理数值数据。
工具	Pandas提供了Series和DataFrame数据结构。	NumPy构建了ndarray array来容纳数据。
性能	Pandas对于处理50万行以上的数据更具优势。	NumPy则对于50万以下或者更少的数据，性能更佳。
内存利用率	与NumPy相比，Pandas会消耗大量的内存。	NumPy会消耗较少的内存。
对象	Pandas提供了DataFrame 2D数据表对象。	NumPy则提供了一个多维数组ndarray对象

在某些情况下，需要执行一些NumPy数值计算的高级函数，这个时候您可以使用to_numpy()函数，将DataFrame对象转换为NumPy ndarray数组，并将其返回。

DataFrame.to_numpy(dtype=None, copy=False)   
参数说明如下：
    dtype：可选参数，表示数据类型；
    copy：布尔值参数，默认值为 Fales，表示返回值不是其他数组的视图。

import pandas as pd 
#创建DataFrame对象
info = pd.DataFrame([[17,62,35],[25,36,54],[42,20,15],[48,62,76]], columns=['x','y','z']) 
print('DataFrame\n----------\n', info) 
#转换DataFrame为数组array
arr = info.to_numpy() 
print('\nNumpy Array\n----------\n', arr)

# 输出结果
DataFrame
----------
     x   y   z
0  17  62  35
1  25  36  54
2  42  20  15
3  48  62  76

Numpy Array
----------
 [[17 62 35]
 [25 36 54]
 [42 20 15]
 [48 62 76]]