pandas
pandas
Pandas内置数据结构
我们知道，构建和处理二维、多维数组是一项繁琐的任务。Pandas 为解决这一问题， 在 ndarray 数组（NumPy 中的数组）的基础上构建出了两种不同的数据结构，分别是 Series（一维数据结构）DataFrame（二维数据结构）：
- Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等；
- DataFrame 是一种表格型数据结构，它既有行标签，又有列标签。
| 数据结构 | 维度 | 说明 |
|---|---|---|
| Series | 1 | 该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述 数据值。Series 是一维数据结构，因此其维数不可以改变。 |
| DataFrame | 2 | DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。 在创建该结构时，可以指定相应的索引值。 |
Series结构
Series 结构，也称 Series 序列，是 Pandas 常用的数据结构之一，它是一种类似于一维数组的结构，由一组数据值（value）和一组标签组成，其中标签与数据值之间是一一对应的关系。
Series 可以保存任何数据类型，比如整数、字符串、浮点数、Python 对象等，它的标签默认为整数，从 0 开始依次递增。
通过标签我们可以更加直观地查看数据所在的索引位置。(这里索引等价于标签)
创建Series对象
Pandas 使用 Series() 函数来创建 Series 对象，通过这个对象可以调用相应的方法和属性，从而达到处理数据的目的：
import pandas as pd
s=pd.Series( data, index, dtype, copy)
参数说明如下所示：
| 参数名称 | 描述 |
|---|---|
| data | 输入的数据，可以是列表、常量、ndarray 数组等。 |
| index(相当于行) | 索引值必须是惟一的，如果没有传递索引，则默认为 np.arrange(n)。 |
| dtype | dtype表示数据类型，如果没有提供，则会自动判断得出。 |
| copy | 表示对 data 进行拷贝，默认为 False。 |
创建Series的四种方式
1) 创建一个空Series对象
使用以下方法可以创建一个空的 Series 对象，如下所示：
import pandas as pd
#输出数据为空
s = pd.Series()
print(s)
输出结果如下：
Series([], dtype: float64)
2) ndarray创建Series对象
ndarray 是 NumPy 中的数组类型，当 data 是 ndarry 时，传递的索引必须具有与数组相同的长度。假如没有给 index 参数传参，在默认情况下，索引值将使用是 range(n) 生成，其中 n 代表数组长度，如下所示：
[0,1,2,3…. range(len(array))-1]
使用默认索引，创建 Series 序列对象：
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
s = pd.Series(data)
print (s)
输出结果如下：
0 a
1 b
2 c
3 d
dtype: object
上述示例中没有传递任何索引，所以索引默认从 0 开始分配 ，其索引范围为 0 到
len(data)-1
，即 0 到 3。这种设置方式被称为“隐式索引”。
除了上述方法外，你也可以使用“显式索引”的方法定义索引标签，示例如下：
import pandas as pd
import numpy as np
data = np.array(['a','b','c','d'])
#自定义索引标签（即显示索引）
s = pd.Series(data,index=[100,101,102,103])
print(s)
输出结果：
100 a
101 b
102 c
103 d
dtype: object
3) dict创建Series对象
您可以把 dict 作为输入数据。如果没有传入索引时会按照字典的键来构造索引；反之，当传递了索引时需要将索引标签与字典中的值一一对应。
下面两组示例分别对上述两种情况做了演示。
示例1，没有传递索引时：
import pandas as pd
import numpy as np
data = {'a' : 0., 'b' : 1., 'c' : 2.}
s = pd.Series(data)
print(s)
输出结果：
a 0.0
b 1.0
c 2.0
dtype: float64
示例 2，为
index
参数传递索引时：
import pandas as pdimport numpy as npdata = {'a' : 0., 'b' : 1., 'c' : 2.}s = pd.Series(data,index=['b','c','d','a'])print(s)
输出结果：
b 1.0
c 2.0
d NaN
a 0.0
dtype: float64
当传递的索引值无法找到与其对应的值时，使用 NaN（非数字）填充。
4) 标量创建Series对象
如果 data 是标量值，则必须提供索引，示例如下：
import pandas as pd
import numpy as np
s = pd.Series(5, index=[0, 1, 2, 3])
print(s)
输出如下：
0 5
1 5
2 5
3 5
dtype: int64
标量值按照 index 的数量进行重复，并与其一一对应。
访问Series数据
1) 位置索引访问
2) 索引标签访问
Series常用属性
下面我们介绍 Series 的常用属性和方法。在下表列出了 Series 对象的常用属性。
| 名称 | 属性 |
|---|---|
| axes | 以列表的形式返回所有行索引标签。 |
| dtype | 返回对象的数据类型。 |
| empty | 返回一个布尔值，用于判断数据对象是否为空。 |
| ndim | 返回输入数据的维数。 |
| size | 返回 Series 对象的大小(长度)。 |
| values | 以 ndarray 的形式返回 Series 对象。以数组的形式返回 Series 对象中的数据。 |
| index | 返回一个RangeIndex对象，用来描述索引的取值范围。 |
全都是s.axes
Series常用方法
1) head()&tail()查看数据
import pandas as pd
import numpy as np
s = pd.Series(np.random.randn(5))
print ("The original series is:")
print (s)
#返回前三行数据
print (s.head(3))
import pandas as pd
import numpy as np
s = pd.Series(np.random.randn(4))
#原series
print(s)
#输出后两行数据
print (s.tail(2))
2) isnull()&nonull()检测缺失值
import pandas as pd#None代表缺失数据s=pd.Series([1,2,5,None])print(pd.isnull(s)) #是空值返回Trueprint(pd.notnull(s)) #空值返回False
输出结果：
0 False
1 False
2 False
3 True
dtype: bool
notnull():
0 True
1 True
2 True
3 False
dtype: bool
DataFrame结构
DataFrame 的每一行数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列标签。因此 DataFrame 其实是从 Series 的基础上演变而来。在数据分析任务中 DataFrame 的应用非常广泛，因为它描述数据的更为清晰、直观。
同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应。上述表格的行标签从 0 到 5，共记录了 5 条数据（图中将行标签省略）。当然你也可以用“显式索引”的方式来设置行标签。
- DataFrame 每一列的标签值允许使用不同的数据类型；
- DataFrame 是表格型的数据结构，具有行和列；
- DataFrame 中的每个数据值都可以被修改。
- DataFrame 结构的行数、列数允许增加或者删除；
- DataFrame 有两个方向的标签轴，分别是行标签和列标签；
- DataFrame 可以对行和列执行算术运算。
创建DataFrame对象
创建 DataFrame 对象的语法格式如下：
import pandas as pd
pd.DataFrame( data, index, columns, dtype, copy)
参数说明：
| 参数名称 | 说明 |
|---|---|
| data | 输入的数据，可以是 ndarray，series，list，dict，标量以及一个 DataFrame。 |
| index | 行标签，如果没有传递 index 值，则默认行标签是 np.arange(n)，n 代表 data 的元素个数。 |
| columns | 列标签，如果没有传递 columns 值，则默认列标签是 np.arange(n)。 |
| dtype | dtype表示每一列的数据类型。 |
| copy | 默认为 False，表示复制数据 data。 |
Pandas 提供了多种创建 DataFrame 对象的方式，主要包含以下五种，分别进行介绍。
1) 创建空的DataFrame对象
使用下列方式创建一个空的 DataFrame，这是 DataFrame 最基本的创建方法。
import pandas as pd
df = pd.DataFrame()
print(df)
输出结果如下：
Empty DataFrame
Columns: []
Index: []
2) 列表创建DataFame对象
可以使用单一列表或嵌套列表来创建一个 DataFrame。
示例 1，单一列表创建 DataFrame：
import pandas as pd
data = [1,2,3,4,5]
df = pd.DataFrame(data)
print(df)
输出如下：
0
0 1
1 2
2 3
3 4
4 5
示例 2，使用嵌套列表创建 DataFrame 对象：
import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'])
print(df)
输出结果：
Name Age
0 Alex 10
1 Bob 12
2 Clarke 13
示例 3，指定数值元素的数据类型为 float：
import pandas as pd
data = [['Alex',10],['Bob',12],['Clarke',13]]
df = pd.DataFrame(data,columns=['Name','Age'],dtype=float)
print(df)
输出结果：
Name Age
0 Alex 10.0
1 Bob 12.0
2 Clarke 13.0
3) 字典嵌套列表创建
data 字典中，键对应的值的元素长度必须相同（也就是列表长度相同）。如果传递了索引，那么索引的长度应该等于数组的长度；如果没有传递索引，那么默认情况下，索引将是 range(n)，其中 n 代表数组长度。
示例 4：
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data)
print(df)
输出结果：
Age Name
0 28 Tom
1 34 Jack
2 29 Steve
3 42 Ricky
注意：这里使用了默认行标签，也就是 range(n)。它生成了 0,1,2,3，并分别对应了列表中的每个元素值。
示例 5，现在给上述示例 4 添加自定义的行标签：
import pandas as pd
data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
df = pd.DataFrame(data, index=['rank1','rank2','rank3','rank4'])
print(df)
输出结果如下：
Age Name
rank1 28 Tom
rank2 34 Jack
rank3 29 Steve
rank4 42 Ricky
注意：index 参数为每行分配了一个索引。
4) 列表嵌套字典创建DataFrame对象
列表嵌套字典可以作为输入数据传递给 DataFrame 构造函数。默认情况下，字典的键被用作列名。
示例 6 如下：
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print(df)
输出结果：
a b c
0 1 2 NaN
1 5 10 20.0
注意：如果其中某个元素值缺失，也就是字典的 key 无法找到对应的 value，将使用 NaN 代替。
示例 7，给上述示例 6 添加行标签索引：
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print(df)
输出结果：
a b c
first 1 2 NaN
second 5 10 20.0
示例 8，如何使用字典嵌套列表以及行、列索引表创建一个 DataFrame 对象。
import pandas as pd
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b']) df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
print(df1)
print(df2)
输出结果：
#df2输出
a b
first 1 2
second 5 10
#df1输出
a b1
first 1 NaN
second 5 NaN
注意：因为 b1 在字典键中不存在，所以对应值为 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 two
a 1.0 1
b 2.0 2
c 3.0 3
d NaN 4
注意：对于 one 列而言，此处虽然显示了行索引 ‘d’，但由于没有与其对应的值，所以它的值为 NaN。
列索引操作DataFrame
DataFrame 可以使用列索（columns index）引来完成数据的选取、添加和删除操作。下面依次对这些操作进行介绍。
1) 列索引选取数据列
您可以使用列索引，轻松实现数据选取，示例如下：
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'])
输出结果：
a 1.0
b 2.0
c 3.0
d NaN
Name: one, dtype: float64
2) 列索引添加数据列
使用 columns 列索引表标签可以实现添加新的数据列，示例如下：
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)
#使用df['列']=值，插入新的数据列
df['three']=pd.Series([10,20,30],index=['a','b','c'])
print(df)
#将已经存在的数据列做相加运算
df['four']=df['one']+df['three']
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
已存在的数据列做算术运算：
one two three four
a 1.0 1 10.0 11.0
b 2.0 2 20.0 22.0
c 3.0 3 30.0 33.0
d NaN 4 NaN NaN
上述示例，我们初次使用了 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 ("Our dataframe is:")
print(df)
#使用del删除
del df['one']
print(df)
#使用pop方法删除
df.pop('two')
print (df)
输出结果：
原DataFrame:
one three two
a 1.0 10.0 1
b 2.0 20.0 2
c 3.0 30.0 3
d NaN NaN 4
使用del删除 first:
three two
a 10.0 1
b 20.0 2
c 30.0 3
d NaN 4
使用 pop()删除:
three
a 10.0
b 20.0
c 30.0
d NaN
1) 标签索引选取
可以将行标签传递给 loc 函数，来选取数据。示例如下：
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.loc['b'])
输出结果：
one 2.0
two 2.0
Name: b, dtype: float64
注意：loc 允许接两个参数分别是行和列，参数之间需要使用“逗号”隔开，但该函数只能接收标签索引。
2) 整数索引选取
通过将数据行所在的索引位置传递给 iloc 函数，也可以实现数据行选取。示例如下：
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.iloc[2]）
输出结果：
one 3.0
two 3.0
Name: c, dtype: float64
注意：iloc 允许接受两个参数分别是行和列，参数之间使用“逗号”隔开，但该函数只能接收整数索引。
3) 切片操作多行选取
您也可以使用切片的方式同时选取多行。示例如下：
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[2:4])
输出结果：
one two
c 3.0 3
d NaN 4
4) 添加数据行
使用 append() 函数，可以将新的数据行添加到 DataFrame 中，该函数会在行末追加数据行。示例如下：
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
#在行末追加新数据行
df = df.append(df2)
print(df)
输出结果：
a b
0 1 2
1 3 4
0 5 6
1 7 8
5) 删除数据行
您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。示例如下：
import pandas as pd
df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns = ['a','b'])
df = df.append(df2)
print(df)
#注意此处调用了drop()方法
df = df.drop(0)
print (df)
输出结果：
执行drop(0)前：
a b
0 1 2
1 3 4
0 5 6
1 7 8
执行drop(0)后：
a b
1 3 4
1 7 8
在上述的示例中，默认使用 range(2) 生成了行索引，并通过 drop(0) 同时删除了两行数据。
常用属性和方法汇总
DataFrame 的属性和方法，与 Series 相差无几，如下所示：
| 名称 | 属性&方法描述 |
|---|---|
| T | 行和列转置。 |
| axes | 返回一个仅以行轴标签和列轴标签为成员的列表。 |
| dtypes | 返回每列数据的数据类型。 |
| empty | DataFrame中没有数据或者任意坐标轴的长度为0，则返回True。 |
| ndim | 轴的数量，也指数组的维数。 |
| shape | 返回一个元组，表示了 DataFrame 维度。 |
| size | DataFrame中的元素数量。 |
| values | 使用 numpy 数组表示 DataFrame 中的元素值。 |
| head() | 返回前 n 行数据。 |
| tail() | 返回后 n 行数据。 |
| shift() | 将行或列移动指定的步幅长度 |
8) values
以 ndarray 数组的形式返回 DataFrame 中的数据。
import pandas as pd
import numpy as np
d = {'Name':pd.Series(['c语言中文网','编程帮',"百度",'360搜索','谷歌','微学苑','Bing搜索']),
'years':pd.Series([5,6,15,28,3,19,23]),
'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}
#构建DataFrame
df = pd.DataFrame(d)
#DataFrame的数据
print(df.values)
输出结果：
[['c语言中文网' 5 4.23]
['编程帮' 6 3.24]
['百度' 15 3.98]
['360搜索' 28 2.56]
['谷歌' 3 3.2]
['微学苑' 19 4.6]
['Bing搜索' 23 3.8]]
10) shift()移动行或列(没看懂)
| 参数名称 | 说明 |
|---|---|
| peroids | 类型为int，表示移动的幅度，可以是正数，也可以是负数，默认值为1。 |
| freq | 日期偏移量，默认值为None，适用于时间序。取值为符合时间规则的字符串。 |
| axis | 如果是 0 或者 “index” 表示上下移动，如果是 1 或者 “columns” 则会左右移动。 |
| fill_value | 该参数用来填充缺失值。 |
常用的统计学函数：
| 函数名称 | 描述说明 |
|---|---|
| count() | 统计某个非空值的数量。 |
| sum() | 求和 |
| mean() | 求均值 |
| median() | 求中位数 |
| mode() | 求众数 |
| std() | 求标准差 |
| min() | 求最小值 |
| max() | 求最大值 |
| abs() | 求绝对值 |
| prod() | 求所有数值的乘积。 |
| cumsum() | 计算累计和，axis=0，按照行累加；axis=1，按照列累加。 |
| cumprod() | 计算累计积，axis=0，按照行累积；axis=1，按照列累积。 |
| corr() | 计算数列或变量之间的相关系数，取值-1到1，值越大表示关联性越强。 |
Pandas使用自定义函数
如果想要应用自定义的函数，或者把其他库中的函数应用到 Pandas 对象中，有以下三种方法：
- 1) 操作整个 DataFrame 的函数：pipe()
- 2) 操作行或者列的函数：apply()
- 3) 操作单一元素的函数：applymap()
求每一列中，最大值与最小值之差。示例如下：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
print(df.apply(lambda x: x.max() - x.min()))
输出结果:
col1 3.538252
col2 2.904771
col3 2.650892
dtype: float64
运用该函数之后返回的结果是服从均值为0，方差为1的标准正态分布，而不是局限在0-1之间，也可以为负值，因为标准正态分布的曲线是关于x轴对阵的。其括号内的参数如果不指定，那么生成的是一个浮点型的数；如果指定一个数，那么生成的是一个numpy.ndarray类型的数组；如果指定两个数字，那么生成的是一个二维的numpy.ndarray类型的数组。和rand()相比，除了元素值不一样，其他的性质是一样的。
Pandas reindex重置索引(在大的表里面找小的表)
重命名标签
9.Pandas iteration遍历
在 Pandas 中同样也是使用 for 循环进行遍历。通过for遍历后，Series 可直接获取相应的 value，而 DataFrame 则会获取列标签。
import pandas as pd
import numpy as np
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
print(df)
for col in df:
print (col)
内置迭代方法
如果想要遍历 DataFrame 的每一行，我们下列函数：
-
- iteritems()：以键值对 (key,value) 的形式遍历；
-
- iterrows()：以 (row_index,row) 的形式遍历行;
-
- itertuples()：使用已命名元组的方式对行遍历。
10.Pandas sorting排序
按标签排序
使用 sort_index() 方法对行标签排序，指定轴参数（axis）或者排序顺序。或者可以对 DataFrame 进行排序。默认情况下，按照行标签序排序。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],columns = ['col2','col1'])
sorted_df=unsorted_df.sort_index()
print(sorted_df)
1) 排序顺序
通过将布尔值传递给
ascending
参数，可以控制排序的顺序（行号顺序）。示例如下：
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],columns = ['col2','col1'])
sorted_df = unsorted_df.sort_index(ascending=False)
print(sorted_df)
按列标签排序
通过给 axis 轴参数传递 0 或 1，可以对列标签进行排序。默认情况下，axis=0 表示按行排序；而 axis=1 则表示按列排序。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame(np.random.randn(10,2),index=[1,4,6,2,3,5,9,8,0,7],columns = ['col2','col1'])
sorted_df=unsorted_df.sort_index(axis=1)
print (sorted_df)
按值排序
与标签排序类似，sort_values() 表示按值排序。它接受一个by参数，该参数值是要排序数列的 DataFrame 列名。示例如下：
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1')
print (sorted_df)
输出结果：
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1
注意：当对 col1 列排序时，相应的 col2 列的元素值和行索引也会随 col1 一起改变。by 参数可以接受一个列表参数值
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by=['col1','col2'])
print (sorted_df）
输出结果：
col1 col2
2 1 2
1 1 3
3 1 4
0 2 1
排序算法
sort_values() 提供了参数
kind
用来指定排序算法。这里有三种排序算法：
- mergesort
- heapsort
- quicksort
默认为 quicksort(快速排序) ，其中 Mergesort 归并排序是最稳定的算法。
import pandas as pd
import numpy as np
unsorted_df = pd.DataFrame({'col1':[2,1,1,1],'col2':[1,3,2,4]})
sorted_df = unsorted_df.sort_values(by='col1' ,kind='mergesort')
print (sorted_df)
输出结果：
col1 col2
1 1 3
2 1 2
3 1 4
0 2 1
11.Pandas去重函数：drop_duplicates()
函数格式
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重新开始
df.reset_index(drop=True)
Python 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) | 返回字符串第一次出现的索引位置。 |
len()
import pandas as pd
import numpy as np
s = pd.Series(['C', 'Python', 'java', 'go', np.nan, '1125','javascript'])
print(s.str.len())
13.pandas设置数据格式
它们的功能介绍如下：
| 函数名称 | 说明 |
|---|---|
| get_option | 获取解释器的默认参数值。 |
| set_option | 更改解释器的默认参数值。 |
| reset_option | 解释器的参数重置为默认值。 |
| describe_option | 输出参数的描述信息。 |
| option_context | 临时设置解释器参数，当退出使用的语句块时，恢复为默认值。 |
14.Pandas loc/iloc用法详解
| 方法名称 | 说明 |
|---|---|
| .loc[] | 基于标签索引选取数据 |
| .iloc[] | 基于整数索引选取数据 |
df.loc[] 只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）。
loc[] 接受两个参数，并以','分隔。第一个位置表示行，第二个位置表示列。
df.iloc[] 只能使用整数索引，不能使用标签索引，通过整数索引切片选择数据时，前闭后开(不包含边界结束值)。同 Python 和 NumPy 一样，它们的索引都是从 0 开始。
loc print(df.loc[‘a’:‘d’,:]) print(df.loc[[‘a’,‘b’,‘f’,‘h’],[‘A’,‘C’]])
iloc print df.iloc[[1, 3, 5], [1, 3]] print df.iloc[1:3, 1:3]
15.统计函数
16.窗口函数
17.聚合函数
18.缺失值处理
检查缺失值
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f','h'])
print(df)
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df)
print(df.isnull())
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f','h'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df.notnull())
清理并填充缺失值
1) 用标量值替换NaN值
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(3, 3), index=['a', 'c', 'e'],columns=['one',
'two', 'three'])
df = df.reindex(['a', 'b', 'c'])
print(df)
#用 0 填充 NaN
print (df.fillna(0))
2) 向前和向后填充NA
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f','h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print df.fillna(method='ffill')
3) 使用replace替换通用值
import pandas as pd
import numpy as np
df = pd.DataFrame({'one':[10,20,30,40,50,666], 'two':[99,0,30,40,50,60]})
#使用replace()方法
print (df.replace({99:10,666:60,0:20}))
删除缺失值
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f','h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df)
#删除缺失值
print (df.dropna())
19.分组操作
创建groupby分组对象
import pandas as pd
import numpy as np
data = {'Name': ['John', 'Helen', 'Sona', 'Ella'],
'score': [82, 98, 91, 87],
'option_course': ['C#','Python','Java','C']}
df = pd.DataFrame(data)
print(df)
#生成分组groupby对象
print(df.groupby('score'))
查看分组结果
1) groups查看分组结果
通过调用groups属性查看分组
import pandas as pd
import numpy as np
data = {'Name': ['John', 'Helen', 'Sona', 'Ella'],
'score': [82, 98, 91, 87],
'option_course': ['C#','Python','Java','C']}
df = pd.DataFrame(data)
#查看分组
print(df.groupby('score').groups)
2) 多个列标签分组
import pandas as pd
import numpy as np
data = {'Name': ['John', 'Helen', 'Sona', 'Ella'],
'score': [82, 98, 91, 87],
'option_course': ['C#','Python','Java','C']}
df = pd.DataFrame(data)
#查看分组
print(df.groupby(['Name','score']).groups)
通过 get_group() 方法可以选择组内的具体数据项：
import pandas as pd
import numpy as np
data = {'Name': ['John', 'Helen', 'Sona', 'Ella'],
'score': [82, 98, 91, 87],
'option_course': ['C#','Python','Java','C']}
df = pd.DataFrame(data)
#根据score来分组
grouped=df.groupby('score')
#根据对应组的数据值，选择一个组
print(grouped.get_group(91))
遍历分组数据
import pandas as pd
import numpy as np
data = {'Name': ['John', 'Helen', 'Sona', 'Ella'],
'score': [82, 98, 91, 87],
'option_course': ['C#','Python','Java','C']}
df = pd.DataFrame(data)
#查看分组
grouped=df.groupby('score')
for label, option_course in grouped:
#其中key代表分组后字典的键，也就是score
print(label)
#字典对应的值选修的科目
print(option_course)
输出结果：
82
Name score option_course
0 John 82 C#
87
Name score option_course
3 Ella 87 C
91
Name score option_course
2 Sona 91 Java
98
Name score option_course
1 Helen 98 Python
聚合函数
import pandas as pd
import numpy as np
data = {'name': ['John', 'Helen', 'Sona', 'Ella'],
'score': [82, 98, 91, 87],
'option_course': ['C#','Python','Java','C']}
df = pd.DataFrame(data)
print(df)
grouped=df.groupby('name')
print(df.groupby('name').groups)
print(grouped['score'].agg([np.size,np.mean,np.std]))
筛选数据分组
import pandas as pd
import numpy as np
data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[874,789,863,663,741,802,756,788,694,701,812,698]}
df = pd.DataFrame(data)
#定义lambda函数来筛选数据
print (df.groupby('Team').filter(lambda x: len(x) >= 2))
20.merge合并
下面创建两个不同的 DataFrame，然后对它们进行合并操作：
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
'subject_id':['sub1','sub2','sub4','sub6']})
right = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['William', 'Albert', 'Tony', 'Allen'],
'subject_id':['sub2','sub4','sub3','sub6']})
print (left)
print (right)
输出如下：
id Name subject_id
0 1 Smith sub1
1 2 Maiki sub2
2 3 Hunter sub4
3 4 Hilen sub6
id Name subject_id
0 1 William sub2
1 2 Albert sub4
2 3 Tony sub3
3 4 Allen sub6
1) 在单个键上进行合并操作
通过 on 参数指定一个连接键，然后对上述 DataFrame 进行合并操作：
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
'subject_id':['sub1','sub2','sub4','sub6']})
right = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['William', 'Albert', 'Tony', 'Allen'],
'subject_id':['sub2','sub4','sub3','sub6']})
#通过on参数指定合并的键
print(pd.merge(left,right,on='id'))import pandas as pd left = pd.DataFrame({ 'id':[1,2,3,4], 'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'], 'subject_id':['sub1','sub2','sub4','sub6']}) right = pd.DataFrame({ 'id':[1,2,3,4], 'Name': ['William', 'Albert', 'Tony', 'Allen'], 'subject_id':['sub2','sub4','sub3','sub6']})#通过on参数指定合并的键print(pd.merge(left,right,on='id'))
输出结果：
id Name_x subject_id_x Name_y subject_id_y
0 1 Smith sub1 William sub2
1 2 Maiki sub2 Albert sub4
2 3 Hunter sub4 Tony sub3
3 4 Hilen sub6 Allen sub6
2) 在多个键上进行合并操作
下面示例，指定多个键来合并上述两个 DataFrame 对象：
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
'subject_id':['sub1','sub2','sub4','sub6']})
right = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Bill', 'Lucy', 'Jack', 'Mike'],
'subject_id':['sub2','sub4','sub3','sub6']})
print(pd.merge(left,right,on=['id','subject_id']))
输出结果：
id Name_x subject_id Name_y
0 4 Hilen sub6 Mike
使用how参数合并
通过
how
参数可以确定 DataFrame 中要包含哪些键，如果在左表、右表都不存的键，那么合并后该键对应的值为 NaN。为了便于大家学习，我们将 how 参数和与其等价的 SQL 语句做了总结：
| Merge方法 | 等效 SQL | 描述 |
|---|---|---|
| left | LEFT OUTER JOIN | 使用左侧对象的key |
| right | RIGHT OUTER JOIN | 使用右侧对象的key |
| outer | FULL OUTER JOIN | 使用左右两侧所有key的并集 |
| inner | INNER JOIN | 使用左右两侧key的交集 |
1) left join
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
'subject_id':['sub1','sub2','sub4','sub6']})
right = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Bill', 'Lucy', 'Jack', 'Mike'],
'subject_id':['sub2','sub4','sub3','sub6']})
#以left侧的subject_id为键
print(pd.merge(left,right,on='subject_id',how="left"))import pandas as pd left = pd.DataFrame({ 'id':[1,2,3,4], 'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'], 'subject_id':['sub1','sub2','sub4','sub6']}) right = pd.DataFrame({ 'id':[1,2,3,4], 'Name': ['Bill', 'Lucy', 'Jack', 'Mike'], 'subject_id':['sub2','sub4','sub3','sub6']}) #以left侧的subject_id为键print(pd.merge(left,right,on='subject_id',how="left"))
输出结果：
id_x Name_x subject_id id_y Name_y
0 1 Smith sub1 NaN NaN
1 2 Maiki sub2 1.0 Bill
2 3 Hunter sub4 2.0 Lucy
3 4 Hilen sub6 4.0 Mike
2) right join
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
'subject_id':['sub1','sub2','sub4','sub6']})
right = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Bill', 'Lucy', 'Jack', 'Mike'],
'subject_id':['sub2','sub4','sub3','sub6']})
#以right侧的subject_id为键
print(pd.merge(left,right,on='subject_id',how="right"))
输出结果：
id_x Name_x subject_id id_y Name_y
0 2.0 Maiki sub2 1 Bill
1 3.0 Hunter sub4 2 Lucy
2 4.0 Hilen sub6 4 Mike
3 NaN NaN sub3 3 Jack
3) outer join(并集)
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
'subject_id':['sub1','sub2','sub4','sub6']})
right = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Bill', 'Lucy', 'Jack', 'Mike'],
'subject_id':['sub2','sub4','sub3','sub6']})
#求出两个subject_id的并集，并作为键
print(pd.merge(left,right,on='subject_id',how="outer"))
输出结果：
id_x Name_x subject_id id_y Name_y
0 1.0 Smith sub1 NaN NaN
1 2.0 Maiki sub2 1.0 Bill
2 3.0 Hunter sub4 2.0 Lucy
3 4.0 Hilen sub6 4.0 Mike
4 NaN NaN sub3 3.0 Jack
4) inner join(交集)
import pandas as pd
left = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Smith', 'Maiki', 'Hunter', 'Hilen'],
'subject_id':['sub1','sub2','sub4','sub6']})
right = pd.DataFrame({
'id':[1,2,3,4],
'Name': ['Bill', 'Lucy', 'Jack', 'Mike'],
'subject_id':['sub2','sub4','sub3','sub6']})
#求出两个subject_id的交集，并将结果作为键
print(pd.merge(left,right,on='subject_id',how="inner"))
输出结果：
id_x Name_x subject_id id_y Name_y
0 2 Maiki sub2 1 Bill
1 3 Hunter sub4 2 Lucy
2 4 Hilen sub6 4 Mike
注意：当 a 与 b 进行内连操作时 a.join(b) 不等于 b.join(a)。
21.Pandas concat连接操作
concat()
concat() 函数用于沿某个特定的轴执行连接操作。下面让我们创建不同的对象，并对其进行连接。
import pandas as pd
a= pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
b= pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D4', 'D5', 'D6', 'D7']},
#连接a与b
print(pd.concat([a,b]))
输出结果：
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D4
5 A5 B5 C5 D5
6 A6 B6 C6 D6
7 A7 B7 C7 D7
如果想把指定的键与 DataFrame 对象连接，您可以使用 keys 参数来实现。如下所示：
import pandas as pd
a= pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
b= pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D1', 'D2', 'D5', 'D6']},
index=[2,3,4,5])
#连接a与b,并给a，b连接一个指定的键
print(pd.concat([a,b],keys=['x','y']))
输出结果：
A B C D
x 0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
y 2 A4 B4 C4 D1
3 A5 B5 C5 D2
4 A6 B6 C6 D5
5 A7 B7 C7 D6
上述示中，可以看出行索引 index 存在重复使用的现象，如果想让输出的行索引遵循依次递增的规则，那么需要将 ignore_index 设置为 True。
import pandas as pd
a= pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
b= pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D1', 'D2', 'D5', 'D6']},
index=[2,3,4,5])
#连接a与b,设置 ignore_index 等于 True
print(pd.concat([a,b],keys=['x','y'],ignore_index=True))
输出结果：
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D1
5 A5 B5 C5 D2
6 A6 B6 C6 D5
7 A7 B7 C7 D6
注意：此时的索引顺序被改变了，而且键 keys 指定的键也被覆盖了。
如果您想要沿着 axis=1 添加两个对象，那么将会追加新的列。
import pandas as pd
a= pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
b= pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D1', 'D2', 'D5', 'D6']},
index=[4,5,6,7])
#沿着 axis=1，连接a与b
print(pd.concat([a,b],axis=1))
输出结果：
A B C D A B C D
0 A0 B0 C0 D0 NaN NaN NaN NaN
1 A1 B1 C1 D1 NaN NaN NaN NaN
2 A2 B2 C2 D2 NaN NaN NaN NaN
3 A3 B3 C3 D3 NaN NaN NaN NaN
4 NaN NaN NaN NaN A4 B4 C4 D1
5 NaN NaN NaN NaN A5 B5 C5 D2
6 NaN NaN NaN NaN A6 B6 C6 D5
7 NaN NaN NaN NaN A7 B7 C7 D6
append()
如果要连接 Series 和 DataFrame 对象，有一个最方便、快捷的方法，那就是 append() 方法。该方法沿着 axis=0 （行方向）进行操作。
import pandas as pd
a= pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
b= pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D1', 'D2', 'D5', 'D6']},
index=[4,5,6,7])
#沿着 axis=0，使用 apppend()方法连接a与b
print(a.append(b))
输出结果：
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D1
5 A5 B5 C5 D2
6 A6 B6 C6 D5
7 A7 B7 C7 D6
当然 append() 函数也可接收多个对象，示例如下：
a= pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']},
index=[0, 1, 2, 3])
b= pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B4', 'B5', 'B6', 'B7'],
'C': ['C4', 'C5', 'C6', 'C7'],
'D': ['D1', 'D2', 'D5', 'D6']},
index=[4,5,6,7])
c= pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
'B': ['B8', 'B9', 'B10', 'B7'],
'C': ['C9', 'C8', 'C7', 'C6'],
'D': ['D8', 'D5', 'D7', 'D6']},
index=[8,9,10,11])
print(a.append(b,c,a))
输出结果：
A B C D
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
4 A4 B4 C4 D1
5 A5 B5 C5 D2
6 A6 B6 C6 D5
7 A7 B7 C7 D6
8 A4 B8 C9 D8
9 A5 B9 C8 D5
10 A6 B10 C7 D7
11 A7 B7 C6 D6
0 A0 B0 C0 D0
1 A1 B1 C1 D1
2 A2 B2 C2 D2
3 A3 B3 C3 D3
22.Python Pandas时间序列详解
23.Pandas日期时间格式化
24.Padans Timedelta时间差
25.Pandas sample随机抽样
参数说明如下表所示：
| 参数名称 | 参数说明 |
|---|---|
| n | 表示要抽取的行数。 |
| frac | 表示抽取的比例，比如 frac=0.5，代表抽取总体数据的50%。 |
| replace | 布尔值参数，表示是否以有放回抽样的方式进行选择，默认为 False，取出数据后不再放回。 |
| weights | 可选参数，代表每个样本的权重值，参数值是字符串或者数组。 |
| random_state | 可选参数，控制随机状态，默认为 None，表示随机数据不会重复；若为 1 表示会取得重复数据。 |
| axis | 表示在哪个方向上抽取数据(axis=1 表示列/axis=0 表示行)。 |
该函数返回与数据集类型相同的新对象，相当于 numpy.random.choice()。实例如下：
import pandas as pd
dict = {'name':["Jack", "Tom", "Helen", "John"],'age': [28, 39, 34, 36],'score':[98,92,91,89]}
info = pd.DataFrame(dict)
#默认随机选择两行
info.sample(n=2)
#随机选择两列
info.sample(n=2,axis=1)
输出结果：
name age score
3 John 36 89
0 Jack 28 98
score name
0 98 Jack
1 92 Tom
2 91 Helen
3 89 John
再来看一组示例：
import pandas as pd
info = pd.DataFrame({'data1': [2, 6, 8, 0], 'data2': [2, 5, 0, 8], 'data3': [12, 2, 1, 8]}, index=['John', 'Parker', 'Smith', 'William'])
info
#随机抽取3个数据
info['data1'].sample(n=3)
#总体的50%
info.sample(frac=0.5, replace=True)
#data3序列为权重值，并且允许重复数据出现
info.sample(n=2, weights='data3', random_state=1)
输出结果：
随机选择3行数据：
William 0
Smith 8
Parker 6
Name: data1, dtype: int64
data1 data2 data3
John 2 2 12
William 0 8 8
data1 data2 data3
John 2 2 12
William 0 8 8
26.Pandas resample数据重采样
27.Python Pandas分类对象
28.Python Pandas绘图教程（详解版）
Pandas 在数据分析、数据可视化方面有着较为广泛的应用，Pandas 对 Matplotlib 绘图软件包的基础上单独封装了一个plot()接口，通过调用该接口可以实现常用的绘图操作。本节我们深入讲解一下 Pandas 的绘图操作。
Pandas 之所以能够实现了数据可视化，主要利用了 Matplotlib 库的 plot() 方法，它对 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()
除了使用默认的线条绘图外，您还可以使用其他绘图方式，如下所示：
- 柱状图：bar() 或 barh()
- 直方图：hist()
- 箱状箱：box()
- 区域图：area()
- 散点图：scatter()
通过关键字参数kind可以把上述方法传递给 plot()。
29.Python Pandas读取文件
当使用 Pandas 做数据分析的时，需要读取事先准备好的数据集，这是做数据分析的第一步。Panda 提供了多种读取数据的方法：
- read_csv() 用于读取文本文件
- read_json() 用于读取 json 文件
- read_sql_query() 读取 sql 语句的，
30.CSV文件读取
import pandas as pd
import matplotlib .pyplot as plt
import numpy as np
df = pd.read_excel(r"D:\画图\data_01.xlsx", sheet_name=0)
print(df)
CSV 又称逗号分隔值文件，是一种简单的文件格式，以特定的结构来排列表格数据。 CSV 文件能够以纯文本形式存储表格数据，比如电子表格、数据库文件，并具有数据交换的通用格式。CSV 文件会在 Excel 文件中被打开，其行和列都定义了标准的数据格式。
1>新建txt
ID,Name,Age,City,Salary
1,Jack,28,Beijing,22000
2,Lida,32,Shanghai,19000
3,John,43,Shenzhen,12000
4,Helen,38,Hengshui,3500
2>将 txt 文件另存为 person.csv 文件格式，直接修改文件扩展名即可。
普通读取
ead_csv() 表示从 CSV 文件中读取数据，并创建 DataFrame 对象。
import pandas as pd#需要注意文件的路径df=pd.read_csv("C:/Users/Administrator/Desktop/person.csv")print (df)
输出结果：
ID Name Age City Salary
0 1 Jack 28 Beijing 22000
1 2 Lida 32 Shanghai 19000
2 3 John 43 Shenzhen 12000
3 4 Helen 38 Hengshui 3500
1) 自定义索引
在 CSV 文件中指定了一个列，然后使用index_col可以实现自定义索引。
import pandas as pd
df=pd.read_csv("C:/Users/Administrator/Desktop/person.csv",index_col=['ID'])
print(df)
输出结果：
Name Age City Salary
ID
1 Jack 28 Beijing 22000
2 Lida 32 Shanghai 19000
3 John 43 Shenzhen 12000
4 Helen 38 Hengshui 3500
2) 查看每一列的dtype
import pandas as pd
#转换salary为float类型
df=pd.read_csv("C:/Users/Administrator/Desktop/person.csv",dtype={'Salary':np.float64})
print(df.dtypes)
输出结果：
ID int64
Name object
Age int64
City object
Salary float64
dtype: object
注意：默认情况下，Salary 列的 dtype 是 int 类型，但结果显示其为 float 类型，因为我们已经在上述代码中做了类型转换。
3) 更改文件标头名
使用 names 参数可以指定头文件的名称。
import pandas as pd
df=pd.read_csv("C:/Users/Administrator/Desktop/person.csv",names=['a','b','c','d','e'])
print(df)
输出结果：
a b c d e
0 ID Name Age City Salary
1 1 Jack 28 Beijing 22000
2 2 Lida 32 Shanghai 19000
3 3 John 43 Shenzhen 12000
4 4 Helen 38 Hengshui 3500
注意：文件标头名是附加的自定义名称，但是您会发现，原来的标头名（列标签名）并没有被删除，此时您可以使用
header
参数来删除它。
通过传递标头所在行号实现删除，如下所示：
import pandas as pd
df=pd.read_csv("C:/Users/Administrator/Desktop/person.csv",names=['a','b','c','d','e'],header=0)
print(df)
输出结果：
a b c d e
0 1 Jack 28 Beijing 22000
1 2 Lida 32 Shanghai 19000
2 3 John 43 Shenzhen 12000
3 4 Helen 38 Hengshui 3500
假如原标头名并没有定义在第一行，您也可以传递相应的行号来删除它。
4) 跳过指定的行数
skiprows
参数表示跳过指定的行数。
import pandas as pd
df=pd.read_csv("C:/Users/Administrator/Desktop/person.csv",skiprows=2)
print(df)
输出结果：
2 Lida 32 Shanghai 19000
0 3 John 43 Shenzhen 12000
1 4 Helen 38 Hengshui 3500
注意：包含标头所在行。
to_csv()
Pandas 提供的 to_csv() 函数用于将 DataFrame 转换为 CSV 数据。如果想要把 CSV 数据写入文件，只需向函数传递一个文件对象即可。否则，CSV 数据将以字符串格式返回。
import pandas as pd
#注意：pd.NaT表示null缺失数据
data = {'Name': ['Smith', 'Parker'], 'ID': [101, pd.NaT], 'Language': ['Python', 'JavaScript']}
info = pd.DataFrame(data)
csv_data = info.to_csv("D:/画图/20230322.csv",sep='|')
31.Pandas Excel读写操作详解
to_excel()
通过 to_excel() 函数可以将 Dataframe 中的数据写入到 Excel 文件。
如果想要把单个对象写入 Excel 文件，那么必须指定目标文件名；如果想要写入到多张工作表中，则需要创建一个带有目标文件名的ExcelWriter对象，并通过sheet_name参数依次指定工作表的名称。
to_ecxel() 语法格式如下：
DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None)
下表列出函数的常用参数项，如下表所示：
| 参数名称 | 描述说明 |
|---|---|
| excel_wirter | 文件路径或者 ExcelWrite 对象。 |
| sheet_name | 指定要写入数据的工作表名称。 |
| na_rep | 缺失值的表示形式。 |
| float_format | 它是一个可选参数，用于格式化浮点数字符串。 |
| columns | 指要写入的列。 |
| header | 写出每一列的名称，如果给出的是字符串列表，则表示列的别名。 |
| index | 表示要写入的索引。 |
| index_label | 引用索引列的列标签。如果未指定，并且 hearder 和 index 均为为 True，则使用索引名称。如果 DataFrame 使用 MultiIndex，则需要给出一个序列。 |
| startrow | 初始写入的行位置，默认值0。表示引用左上角的行单元格来储存 DataFrame。 |
| startcol | 初始写入的列位置，默认值0。表示引用左上角的列单元格来储存 DataFrame。 |
| engine | 它是一个可选参数，用于指定要使用的引擎，可以是 openpyxl 或 xlsxwriter。 |
import pandas as pd
#创建DataFrame数据
info_website = pd.DataFrame({'name': ['编程帮', 'c语言中文网', '微学苑', '92python'],
'rank': [1, 2, 3, 4],
'language': ['PHP', 'C', 'PHP','Python' ],
'url': ['www.bianchneg.com', 'c.bianchneg.net', 'www.weixueyuan.com','www.92python.com' ]})
#创建ExcelWrite对象
writer = pd.ExcelWriter("D:/画图/20230322.xlsx")
info_website.to_excel(writer)
writer.save()
print('输出成功')
read_excel()
如果您想读取 Excel 表格中的数据，可以使用 read_excel() 方法，其语法格式如下：
pd.read_excel(io, sheet_name=0, header=0, names=None, index_col=None,
usecols=None, squeeze=False,dtype=None, engine=None,
converters=None, true_values=None, false_values=None,
skiprows=None, nrows=None, na_values=None, parse_dates=False,
date_parser=None, thousands=None, comment=None, skipfooter=0,
convert_float=True, **kwds)
下表对常用参数做了说明：
| 参数名称 | 说明 |
|---|---|
| io | 表示 Excel 文件的存储路径。 |
| sheet_name | 要读取的工作表名称。 |
| header | 指定作为列名的行，默认0，即取第一行的值为列名；若数据不包含列名，则设定 header = None。若将其设置 为 header=2，则表示将前两行作为多重索引。 |
| names | 一般适用于Excel缺少列名，或者需要重新定义列名的情况；names的长度必须等于Excel表格列的长度，否则会报错。 |
| index_col | 用做行索引的列，可以是工作表的列名称，如 index_col = ‘列名’，也可以是整数或者列表。 |
| usecols | int或list类型，默认为None，表示需要读取所有列。 |
| squeeze | boolean，默认为False，如果解析的数据只包含一列，则返回一个Series。 |
| converters | 规定每一列的数据类型。 |
| skiprows | 接受一个列表，表示跳过指定行数的数据，从头部第一行开始。 |
| nrows | 需要读取的行数。 |
| skipfooter | 接受一个列表，省略指定行数的数据，从尾部最后一行开始。 |
示例如下所示：
import pandas as pd
#读取excel数据
df = pd.read_excel('website.xlsx',index_col='name',skiprows=[2])
#处理未命名列
df.columns = df.columns.str.replace('Unnamed.*', 'col_label')
print(df)
输出结果：
col_label rank language agelimit
name
编程帮 0 1 PHP www.bianchneg.com
微学苑 2 3 PHP www.weixueyuan.com
92python 3 4 Python www.92python.com
再看一组示例：
import pandas as pd
#读取excel数据
#index_col选择前两列作为索引列
#选择前三列数据，name列作为行索引
df = pd.read_excel('website.xlsx',index_col='name',index_col=[0,1],usecols=[1,2,3])
#处理未命名列，固定用法
df.columns = df.columns.str.replace('Unnamed.*', 'col_label')
print(df)
输出结果：
language
name rank
编程帮 1 PHP
c语言中文网 2 C
微学苑 3 PHP
92python 4 Python
32.Pandas index操作索引
索引（index）是 Pandas 的重要工具，通过索引可以从 DataFame 中选择特定的行数和列数，这种选择数据的方式称为“子集选择”。
在 Pandas 中，索引值也被称为标签（label），它在 Jupyter 笔记本中以粗体字进行显示。索引可以加快数据访问的速度，它就好比数据的书签，通过它可以实现数据的快速查找。
创建索引
创建索引
通过示例对 index 索引做进一步讲解。下面创建一个带有 index 索引的数据，并使用 read_csv() 这些读取数据：
import pandas as pd data = pd.read_csv("person.csv") print(data)
输出结果：
ID Name Age City Salary
0 1 Jack 28 Beijing 22000
1 2 Lida 32 Shanghai 19000
2 3 John 43 Shenzhen 12000
3 4 Helen 38 Hengshui 3500
通过列索引（标签）读取多列数据。
import pandas as pd
#设置"Name"为行索引
data = pd.read_csv("person.csv", index_col ="Name")
# 通过列标签选取多列数据
a = data[["City","Salary"]]
print(a)
输出结果：
City Salary
Name
Jack Beijing 22000
Lida Shanghai 19000
John Shenzhen 12000
Helen Hengshui 3500
再看一组简单的示例：
import pandas as pd
info =pd.read_csv("person.csv", index_col ="Name")
#获取单列数据，或者以列表的形式传入["Salary"]
a =info["Salary"]
print(a)
输出结果：
Salary
Name
Jack 22000
Lida 19000
John 12000
Helen 3500
设置索引(就是证明set_index>>index_col)
set_index() 将已存在的列标签设置为 DataFrame 行索引。除了可以添加索引外，也可以替换已经存在的索引。比如您也可以把 Series 或者一个 DataFrme 设置成另一个 DataFrame 的索引。示例如下：
info = pd.DataFrame({'Name': ['Parker', 'Terry', 'Smith', 'William'], 'Year': [2011, 2009, 2014, 2010],
'Leaves': [10, 15, 9, 4]})
#设置Name为行索引
print(info.set_index('Name'))
输出结果：
Year Leaves
Name
Parker 2011 10
Terry 2009 15
Smith 2014 9
William 2010 4
重置索引(reset_index())
您可以使用 reset_index() 来恢复初始行索引，示例如下：
import pandas as pd
import numpy as np
info = pd.DataFrame([('William', 'C'),
('Smith', 'Java'),
('Parker', 'Python'),
('Phill', np.nan)],
index=[1, 2, 3, 4],
columns=('name', 'Language'))
print(info)
print(info.reset_index())
输出结果：
重置前：
name Language
1 William C
2 Smith Java
3 Parker Python
4 Phill NaN
重置后：
index name Language
0 1 William C
1 2 Smith Java
2 3 Parker Python
3 4 Phill NaN
33.创建分层索引
1) 直接创建
通过 MultiIndex() 的levels参数能够直接创建分层索引，示例如下：
import pandas as pd
import numpy as np
#为leves传递一个1行5列的二维数组
df=pd.MultiIndex(levels=[[np.nan, 2, pd.NaT, None, 5]], codes=[[4, -1, 1, 2, 3, 4]])
print(df.levels)
print(df)
输出结果：
[[nan, 2, NaT, None, 5]]
MultiIndex([( 5,),
(nan,),
( 2,),
(nan,),
(nan,),
( 5,)],
)
上述代码中，levels
参数用来创建层级索引，这里只有一层，该层的索引值分别是 np.nan, 2, NaT, None, 5；codes
表示按参数值对层级索引值排序（与 levels 中的值相对应），也就说 codes 中数值是 leves 序列的下标索引。需要注意，这里的 -1 代表 NaN。
2) 从元组创建
通过 from_tuples() 实现从元组创建分层索引。
#创建元组序列
arrays = [['it', 'it', 'of', 'of', 'for', 'for', 'then', 'then'],
['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
#使用zip()函数创建元组
tuples = list(zip(*arrays))
print(tuples)
输出结果如下：
[('it', 'one'),
('it', 'two'),
('of', 'one'),
('of', 'two'),
('for', 'one'),
('for', 'two'),
('then', 'one'),
('then', 'two')]
然后使用 tuples 创建分层索引，如下所示：
import pandas as pd
#创建了两层索引，并使用names对它们命名
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
print(index)
输出结果：
MultiIndex([( 'it', 'one'),
( 'it', 'two'),
( 'of', 'one'),
( 'of', 'two'),
( 'for', 'one'),
( 'for', 'two'),
('then', 'one'),
('then', 'two')],
names=['first', 'second'])
3) 从DataFrame对象创建
通过 from_frame() 创建分层索引，示例如下：
#首先创建一个 DataFrame。
import pandas as pd
df = pd.DataFrame([['bar', 'one'], ['bar', 'two'],
['foo', 'one'], ['foo', 'two']],
columns=['first', 'second'])
#然后使用 from_frame()创建分层索引。
index = pd.MultiIndex.from_frame(df)
#将index应用于Series
s=pd.Series(np.random.randn(4), index=index)
print(s)
输出结果：
first second
bar one 1.151928
two -0.694435
foo one -1.701611
two -0.486157
dtype: float64
4) 笛卡尔积创建
笛卡尔积（又称直积）是数学运算的一种方式，下面使用 from_product() 笛卡尔积创建分层索引。
import pandas as pd
#构建数据
numbers = [0, 1, 2]
language = ['Python', 'Java']
#经过笛卡尔积处理后会得到6中组合方式
index = pd.MultiIndex.from_product([numbers, language],names=['number', 'language'])
#将分层索引对象应用于Series
dk_er=pd.Series(np.random.randn(6), index=index)
print(dk_er)
输出结果：
number language
0 Python -0.319739
Java 1.599170
1 Python -0.010520
Java 0.262068
2 Python -0.124177
Java 0.315120
dtype: float64
5) 数组创建分层索引
通过 from_array() 方法，同样可以创建分层索引。示例如下：
import pandas as pd
df=pd.MultiIndex.from_arrays([['a', 'a', 'b', 'b'],[1, 2, 1, 2]])
df
输出结果：
MultiIndex([('a', 1),
('a', 2),
('b', 1),
('b', 2)],
)
通过 set_index() 可以将 DataFrame 的已有列的标索设置为 index 行索引，示例如下：
import pandas as pddf= pd.DataFrame({'a': range(5), 'b': range(5, 0, -1), 'c': ['one', 'one', 'one', 'two', 'two'], 'd': [0, 1, 2, 0, 1]})print(df)df1=df.set_index(['a','d'],drop=False)print(df1)df1=df.set_index(['a','d'],drop=False,append=Ture)print(df2)
输出结果：
转换前：
a b c d
0 0 5 one 0
1 1 4 one 1
2 2 3 one 2
3 3 2 two 0
4 4 1 two 1
转换后：
a b c d
a d
0 0 0 5 one 0
1 1 1 4 one 1
2 2 2 3 one 2
3 0 3 2 two 0
4 1 4 1 two 1
带append参数：
a b c d
a d
0 0 0 0 5 one 0
1 1 1 1 4 one 1
2 2 2 2 3 one 2
3 3 0 3 2 two 0
4 4 1 4 1 two 1
应用分层索引
通过 set_index() 将列索引转换为了分层行索引，其中 drop=False 表示更新索引的同时，不删除 a、d 列；同时，该函数还提供了一个 append = Ture 参数表示不添加默认的整数索引值（0到4）
分层索引切片取值
下面讲解分层索引切片取值操作，示例如下：
1) 分层行索引操作
import pandas as pd
#构建多层索引
tuple = [('湖人',2008),('步行者',2008),
('湖人',2007),('凯尔特人',2007),
('篮网',2007),('热火',2008)]
salary = [10000,20000,11000,30000,19000,22000]
#其次应用于DataFrame
index = pd.MultiIndex.from_tuples(tuple)
s = pd.Series(salary, index=index)
print(s)
#切片取值
print(s['湖人',2007])
print(s['湖人'])
print(s[:,2008])
#比较value
print(s[s<=20000])
输出结果：
湖人 2008 10000
步行者 2008 20000
湖人 2007 11000
凯尔特人 2007 30000
篮网 2007 19000
热火 2008 22000
dtype: int64
湖人队2007年工资：
11000
湖人队的工资：
2008 10000
2007 11000
dtype: int64
2008年所有队伍工资：
湖人 10000
步行者 20000
热火 22000
dtype: int64
小于等于20000的年份和队伍：
湖人 2008 10000
步行者 2008 20000
湖人 2007 11000
篮网 2007 19000
dtype: int64
2) 行、列多层索引操作
下面看一种更加复杂的情况，就是行、列同时存在多层索引时候，应该如何通过切片取值。示例如下：
df = pd.DataFrame(np.arange(1,13).reshape((4, 3)),
index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
columns=[['Jack', 'Jack', 'Helen'],
['Python', 'Java', 'Python']])
#选择同一层级的索引,切记不要写成['Jack','Helen']
print(df[['Jack','Helen']])
#在不同层级分别选择索引
print(df['Jack','Python'])
#iloc整数索引
print(df.iloc[:3,:2])
#loc列标签索引
print(df.loc[:,('Helen','Python')])
输出结果：
Jack Helen
Python Java Python
a 1 1 2 3
2 4 5 6
b 1 7 8 9
2 10 11 12
a 1 1
2 4
b 1 7
2 10
Name: (Jack, Python), dtype: int32
Jack
Python Java
a 1 1 2
2 4 5
b 1 7 8
a 1 3
2 6
b 1 9
2 12
Name: (Helen, Python), dtype: int32
交换层和层排序
1) 交换层
通过 swaplevel() 方法轻松地实现索引层交换，示例如下：
import pandas as pd
frame = pd.DataFrame(np.arange(12).reshape((4, 3)),
index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
columns=[['Ohio', 'Ohio', 'Colorado'],
['Green', 'Red', 'Green']])
#设置index的levels名称
frame.index.names = ['key1', 'key2']
#设置columns的levels名称
frame.columns.names = ['state','color']
#交换key1层与key层
frame.swaplevel('key1','key2')
输出结果：
state Ohio Colorado
color Green Red Green
key2 key1
1 a 0 1 2
2 a 3 4 5
1 b 6 7 8
2 b 9 10 11
2) 层排序
通过 sort_index() 的
level
参数实现对层的排序。下面示例，按“key1”的字母顺序重新排序。
import pandas as pd
frame = pd.DataFrame(np.arange(12).reshape((4, 3)),
index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
columns=[['Ohio', 'Ohio', 'Colorado'],
['Green', 'Red', 'Green']])
#设置index的levels的名称，key1 与 key2分别对应不同的层
frame.index.names = ['key1', 'key2']
#设置columns的levels的名称
frame.columns.names = ['state','color']
print(frame.sort_index(level='key1'))
输出结果：
state Ohio Colorado
color Green Red Green
key1 key2
a 1 0 1 2
2 3 4 5
b 1 6 7 8
2 9 10 11
34.spandas执行类似sql操作
我们知道，使用 SQL 语句能够完成对 table 的增删改查操作，Pandas 同样也可以实现 SQL 语句的基本功能。本节主要讲解 Pandas 如何执行 SQL 操作。
首先加载一个某连锁咖啡厅地址分布的数据集，通过该数据集对本节内容进行讲解。
import pandas as pdurl = 'C:/Users/Administrator/Desktop/coffee/kafei.xlsx'coffee_df=pd.read_excel(url)coffee_df.head()
输出结果如下：
address category id tel
0 北京市东城区南竹竿胡同2号1幢2层30212号银河SOHOC座 娱乐休闲:咖啡厅 1874263549184796345 010-85179080
1 北京市东城区东直门内大街277-31号档口 娱乐休闲:咖啡厅 1461638360847848424 400-669-2002
2 北京市东城区王府井东街8号澳门中心L117商场102室 娱乐休闲:咖啡厅 1308505235389562852 400-010-0100
3 北京市东城区前门大街108号底商 娱乐休闲:咖啡厅 15442844740539053384
4 北京市东城区和平里西街51号雍和宫壹中心A座负一层 娱乐休闲:咖啡厅 2357391864111641256 4000100100
SELECT
在 SQL 中，SELECT 查询语句使用,把要查询的每个字段分开，当然您也可以使用*来选择所有的字段。如下所示：
SELECT address, category, id, tel FROM tips LIMIT 5;
对于 Pandas 而言，要完成 SELECT 查询，需要把数据集每一列（columns）的名称传递给 DataFrame 对象。如下所示：
coffee_df[['address','category','id','tel']].head()
下面代码是 Pandas 执行 SELECT 查询的完整程序：
import pandas as pd
url = 'C:/Users/Administrator/Desktop/coffee/kafei.xlsx'
coffee_df=pd.read_excel(url)
#只查看尾3行
coffee_df[['address', 'category', 'id', 'tel']].tail(3)
输出结果如下：
address category id tel
28912 新疆维吾尔自治区北屯市芳园路69-2-12 娱乐休闲:咖啡厅 7443833746160692626
28913 新疆维吾尔自治区北屯市北屯购物公园7-1-7 娱乐休闲:咖啡厅 15288143245642241877
28914 新疆维吾尔自治区可克达拉市人民西路与育才路交叉口西北50米 娱乐休闲:咖啡厅 17884214706482955
假如您传入的是一个空列表， 那最终结果将输出所有的行索引标签。
WHERE
SQL 中的条件查询是通过 WHERE 子句完成的。格式如下所示：
SELECT * FROM coffee_df WHERE tel = '010-85179080';
然而 DataFrame 可以通过多种方式实现条件筛选，最直观的方法是通过布尔索引：
coffee_df[coffee_df['id'] == '1461638360847848424']
完整程序如下：
import pandas as pd
url = 'C:/Users/Administrator/Desktop/coffee/kafei.xlsx'
coffee_df=pd.read_excel(url)
coffee_df[coffee_df['tel'] == '400-010-0100'].head(5)
输出结果如下：
address category id tel
2 北京市东城区王府井东街8号澳门中心L117商场102室 娱乐休闲:咖啡厅 1308505235389562852 400-010-0100
5 北京市东城区崇文门外大街3号崇文新世界百货一期南门一层 娱乐休闲:咖啡厅 3294587167648650139 400-010-0100
6 北京市东城区东四北大街265号文化金融大厦1层大堂 娱乐休闲:咖啡厅 3046481700882245722 400-010-0100
7 北京市东城区珠市口东大街2号丰泰中心1层 娱乐休闲:咖啡厅 3218554253235914037 400-010-0100
9 北京市东城区怡生健身居然大厦店休闲区 娱乐休闲:咖啡厅 3141197020974020427 400-010-0100
上面的语句通过布尔运算将 True 或 False 对象传递给 DataFrame 对象，然后返回所有为 True 的行。
GroupBy
在 SQL 语句中，通过 GroupBy 操作可以获取 table 中一组记录的计数。示例如下：
SELECT id, count(*) FROM tips GROUP BY id;
而 Pandas 可通过以下代码实现：
coffe_df.groupby('id').size()
完整的程序如下所示：
import pandas as pd
url = 'C:/Users/Administrator/Desktop/coffee/kafei.xlsx'
coffee_df=pd.read_excel(url)
print(coffee_df.groupby('id').size())
输出结果：
id
938817537566269 1
1343221331916894 1
2068013370184103 1
2147497429057385 1
4021181356852391 1
..
18443951046631684378 1
18444337559943971606 1
18444494959108924300 1
18445005868173060838 1
18446259420330511125 1
Length: 23240, dtype: int64
LIMIT
在 SQL 中，LIMIT 语句主要起到限制作用，比如查询前 n 行记录：
SELECT * FROM coffee_df LIMIT n;
而在 Pandas 中，您可以通过 head() 来实现（默认前 5 行），示例如下：
import pandas as pd
url = 'C:/Users/Administrator/Desktop/coffee/kafei.xlsx'
coffee_df=pd.read_excel(url)
coffee_df[['address', 'tel']].head(3)
输出结果：
address tel
0 北京市东城区南竹竿胡同2号1幢2层30212号银河SOHOC座 010-85179080
1 北京市东城区东直门内大街277-31号档口 400-669-2002
2 北京市东城区王府井东街8号澳门中心L117商场102室 400-010-0100
35.Pandas和NumPy的比较
创建数组(np.array)
数组的主要作用是在一个变量中存储多个值。NumPy 可以轻松地处理多维数组，示例如下:
import numpy as np
arr = np.array([2, 4, 6, 8, 10, 12])
print(type(arr))
print ("打印新建数组: ",end="")
#使用for循环读取数据
for l in range (0,5):
print (arr[l], end=" ")
输出结果：
打印新建数组: 2 4 6 8 10
虽然 Python 本身没有数组这个说法，不过 Python 提供一个 array 模块，用于创建数字、字符类型的数组，它能够容纳字符型、整型、浮点型等基本类型。示例如下：
import array
#注意此处的 'l' 表示有符号int类型
arr = array.array('l', [2, 4, 6, 8, 10, 12])
print(type(arr))
print ("新建数组: ",end="")
for i in range (0,5):
print (arr[i], end=" ")
输出结果：
新建数组: 2 4 6 8 10
重塑数组形状(reshape变维)
在不改变数组数据的情况下，对数组进行变形操作，即改变数组的维度，比如 23（两行三列）的二维数组变维 32（三行两列）的二维数组。变形操作可以通过 reshape() 函数实现。
示例如下：
import numpy as np
arr = np.arange(16)
print("原数组: \n", arr)
arr = np.arange(16).reshape(2, 8)
print("\n变形后数组:\n", arr)
arr = np.arange(16).reshape(8 ,2)
print("\n变形后数组:\n", arr)
输出结果：
原数组:
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
变形后数组:
[[ 0 1 2 3 4 5 6 7]
[ 8 9 10 11 12 13 14 15]]
变形后数组:
[[ 0 1]
[ 2 3]
[ 4 5]
[ 6 7]
[ 8 9]
[10 11]
[12 13]
[14 15]]
Pdans与NumPy区别
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 对象 |