Pandas教程（非常详细）（第六部分）

接着Pandas教程（非常详细）（第五部分），继续讲述。

三十一、Pandas Excel读写操作详解

Excel 是由微软公司开发的办公软件之一，它在日常工作中得到了广泛的应用。在数据量较少的情况下，Excel 对于数据的处理、分析、可视化有其独特的优势，因此可以显著提升您的工作效率。但是，当数据量非常大时，Excel 的劣势就暴露出来了，比如，操作重复、数据分析难等问题。Pandas 提供了操作 Excel 文件的函数，可以很方便地处理 Excel 表格。

1、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('website.xlsx')
info_website.to_excel(writer)
writer.save()
print('输出成功')

上述代码执行后会自动生成 website.xlsx 文件，文件内容如下：

Pandas操作Excel

图1：DataFrame转为Excel

2、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

三十二、Pandas index操作索引

索引（index）是 Pandas 的重要工具，通过索引可以从 DataFame 中选择特定的行数和列数，这种选择数据的方式称为“子集选择”。

在 Pandas 中，索引值也被称为标签（label），它在 Jupyter 笔记本中以粗体字进行显示。索引可以加快数据访问的速度，它就好比数据的书签，通过它可以实现数据的快速查找。

1、创建索引

通过示例对 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

2、设置索引

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

3、重置索引

您可以使用 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

三十三、Pandas分层索引入门教程

分层索引（Multiple Index）是 Pandas 中非常重要的索引类型，它指的是在一个轴上拥有多个（即两个以上）索引层数，这使得我们可以用低维度的结构来处理更高维的数据。比如，当想要处理三维及以上的高维数据时，就需要用到分层索引。

分层索引的目的是用低维度的结构（Series 或者 DataFrame）更好地处理高维数据。通过分层索引，我们可以像处理二维数据一样，处理三维及以上的数据。分层索引的存在使得分析高维数据变得简单，让抽象的高维数据变得容易理解，同时它比废弃的 Panel 结构更容易使用。

Pandas 可以通过 MultiIndex() 方法来创建分层索引对象，该对象本质上是一个元组序列，序列中每一个元组都是唯一的。下面介绍几种创建分层索引的方式。

1、创建分层索引

（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)], )

2、应用分层索引

下面示例讲解了如何在 DataFrame 中应用分层索引。

import pandas as pd
import numpy as np
#创建一个数组
arrays = [[0, 0, 1, 1], ['A', 'B', 'A', 'B']]
#从数组创建
index=pd.MultiIndex.from_arrays(arrays, names=('number', 'letter'))
print(index)

输出结果

MultiIndex([(0, 'A'),

(0, 'B'),

(1, 'A'),

(1, 'B')],

names=['number', 'letter'])

上述示例中，第一层为 number，该层有 0、1 两个元素，第二层为 letter，有两个字母 A 和 B。

下面把已经创建的分层索引应用到 DataFrame 中，如下所示：

import pandas as pd
import numpy as np
#创建一个数组
arrays = [[0, 0, 1, 1], ['A', 'B', 'A', 'B']]
index=pd.MultiIndex.from_arrays(arrays, names=('number', 'letter'))
#在行索引位置应用分层索引
df=pd.DataFrame([{'a':11, 'b':22}], index=index)
print(df)

输出结果：

a b

number letter

0 A 11 22

B 11 22

1 A 11 22

B 11 22

（1）通过 set_index() 可以将 DataFrame 的已有列的标索设置为 index 行索引，

示例如下：

import pandas as pd
df= 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）

3、分层索引切片取值

下面讲解分层索引切片取值操作，示例如下：

（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

4、聚合函数应用

通过给level传递参数值，您可以指定在哪个层上进行聚合操作，比如求和、求均值等。示例如下：

import pandas as pd
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']])
#第一步，给行列层级起名字
df.index.names=['key1','key2']
df.columns.names=['name','course']
print(df.sum(level='key2'))
print(df.mean(level="course",axis=1))

输出结果：

#对key2层1/2对应的元素值求和

name Jack Helen

course Python Java Python

key2

1 8 10 12

2 14 16 18

#axis=1沿着水平方向求均值

cours Python Java

key1 key2

a 1 2 2

2 5 5

b 1 8 8

2 11 11

在数据分析的过程中，我们把大部分时间都花费在数据的准备和预处理上，Pandas 作为一个灵活、高效的数据预处理工具，提供了诸多数据处理的方法，分层索引（Multiple Index）就是其中之一，分层索引（或多层索引）是 Pandas 的基本特性，它能够增强 Pands 数据预处理的能力。

对于 Series 结构来说，通过给index参数传递一个二维数组就可以创建一个具有两层索引的 MultiIndex 对象，示例如下：

import pandas as pd
info = pd.Series([11, 14, 17, 24, 19, 32, 34, 27],
index = [['x', 'x', 'x', 'x', 'y', 'y', 'y', 'y'],
['obj1', 'obj2', 'obj3', 'obj4', 'obj1', 'obj2', 'obj3', 'obj4']])
print(info)

输出结果：

x obj1 11

obj2 14

obj3 17

obj4 24

y obj1 19

obj2 32

obj3 34

obj4 27

dtype: int64

上述示例，创建了两个层级的索引，即 (x, y) 和 (obj1，…， obj4)，您可以使用 'index' 命令查看索引。

info.index

输出结果：

MultiIndex([('x', 'obj1'),

                ('x', 'obj2'),

                ('x', 'obj3'),

                ('x', 'obj4'),

                ('y', 'obj1'),

                ('y', 'obj2'),

                ('y', 'obj3'),

                ('y', 'obj4')],

)

此外，您还可以基于内部索引层（也就是'obj'）来选择数据。如下所示：

info [:,'obj2' ]

输出结果：

x 14

y 32

dtype: int64

5、局部索引

局部索引可以理解为：从分层索引中选择特定索引层的一种方法。比如在下列数据中，选择所有'y'索引指定的数据，示例如下：

import pandas as pd
info = pd.Series([11, 14, 17, 24, 19, 32, 34, 27],
index = [['x', 'x', 'x', 'x', 'y', 'y', 'y', 'y'],
['obj1', 'obj2', 'obj3', 'obj4', 'obj1', 'obj2', 'obj3', 'obj4']])
info['y']

输出结果：

obj1 19

obj2 32

obj3 34

obj4 27

dtype: int64

当然您也可以基于内层索引选择数据。

6、行索引层转换为列索引

unstack() 用来将行索引转变成列索引，相当于转置操作。通过 unstack() 可以将 Series（一维序列）转变为 DataFrame（二维序列）。示例如下：

import pandas as pd
info = pd.Series([11, 14, 17, 24, 19, 32, 34, 27],
index = [['x', 'x', 'x', 'x', 'y', 'y', 'y', 'y'],
['obj1', 'obj2', 'obj3', 'obj4', 'obj1', 'obj2', 'obj3', 'obj4']])
#行索引标签默认是最外层的 x, y
#0代表第一层索引，而1代表第二层
print(info.unstack(0))

输出结果：

x y

obj1 11 19

obj2 14 32

obj3 17 34

obj4 24 27

从示例可以看出，unstack(0) 表示选择第一层索引作为列，unstack(1) 表示选择第二层，如下所示：

import pandas as pd
info = pd.Series([11, 14, 17, 24, 19, 32, 34, 27],
index = [['x', 'x', 'x', 'x', 'y', 'y', 'y', 'y'],
['obj1', 'obj2', 'obj3', 'obj4', 'obj1', 'obj2', 'obj3', 'obj4']])
print(info.unstack(1))

输出结果：

obj1 obj2 obj3 obj4

x 11 14 17 24

y 19 32 34 27

7、列索引实现分层

我们知道，列索引存在于 DataFrame 结构中，下面创建一个 DataFrame 来演示列索引如何实现分层。

import numpy as np
info = pd.DataFrame(np.arange(12).reshape(4, 3),
index = [['a', 'a', 'b', 'b'], ['one', 'two', 'three', 'four']],
columns = [['num1', 'num2', 'num3'], ['x', 'y', 'x']] )
print(info)

输出结果：

num1 num2 num3

x y x

a one 0 1 2

two 3 4 5

b three 6 7 8

four 9 10 11

查看所有列索引：

info.columns

输出结果：

MultiIndex([('num1', 'x'),

('num2', 'y'),

('num3', 'x')],)

8、交换层和层排序

（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

三十四、Pandas执行SQL操作

我们知道，使用 SQL 语句能够完成对 table 的增删改查操作，Pandas 同样也可以实现 SQL 语句的基本功能。本节主要讲解 Pandas 如何执行 SQL 操作。

首先加载一个某连锁咖啡厅地址分布的数据集，通过该数据集对本节内容进行讲解。

import pandas as pd
url = '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

1、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

假如您传入的是一个空列表，那最终结果将输出所有的行索引标签。

2、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 的行。

3、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

4、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

本节主要通过对比的方式对 SQL 和 Pandas 做了简单讲解，希望对您有所帮助。

三十五、Pandas和NumPy的比较

我们知道 Pandas 是在 NumPy 的基础构建而来，因此，熟悉 NumPy 可以更加有效的帮助我们使用 Pandas。

NumPy 主要用 C语言编写，因此，在计算还和处理一维或多维数组方面，它要比 Python 数组快得多。关于 NumPy 的学习，可以参考《NumPy教程（快速入门版）-CSDN博客》。

1、创建数组

数组的主要作用是在一个变量中存储多个值。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=" ")

输出结果：

<class 'numpy.ndarray'>

打印新建数组: 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=" ")

输出结果：

<class 'array.array'>

新建数组: 2 4 6 8 10

2、布尔索引

布尔索引是 NumPy 的重要特性之一，通常与 Pandas 一起使用。它的主要作用是过滤 DataFrame 中的数据，比如布尔值的掩码操作。

下面示例展示了如何使用布尔索引访问 DataFrame 中的数据。

首先创建一组包含布尔索引的数据，如下所示：

import pandas as pd
dict = {'name':["Smith", "William", "Phill", "Parker"],
'age': ["28", "39", "34", "36"]}
info = pd.DataFrame(dict, index = [True, True, False, True])
print(info)

输出结果：

name age

True Smith 28

True William 39

False Phill 34

True Parker 36

然后使用.loc访问索引为 True 的数据。示例如下：

import pandas as pd
dict = {'name':["Smith", "William", "Phill", "Parker"],
'age': ["28", "39", "34", "36"]}
info = pd.DataFrame(dict, index = [True, True, False, True])
#返回所有为 True的数据
print(info.loc[True])

输出结果：

name age

True Smith 28

True William 39

True Parker 36

3、重塑数组形状

在不改变数组数据的情况下，对数组进行变形操作，即改变数组的维度，比如 2*3（两行三列）的二维数组变维 3*2（三行两列）的二维数组。变形操作可以通过 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]]

4、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 对象

5、转换ndarray数组

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

DataFrame.to_numpy(dtype=None, copy=False)

参数说明如下：

dtype：可选参数，表示数据类型；
copy：布尔值参数，默认值为 Fales，表示返回值不是其他数组的视图。

下面使用示例，了解该函数的使用方法。示例 1：

info = pd.DataFrame({"P": [2, 3], "Q": [4.0, 5.8]})
#给info添加R列
info['R'] = pd.date_range('2020-12-23', periods=2)
print(info)
#将其转化为numpy数组
n=info.to_numpy()
print(n)
print(type(n))

输出结果：

[[2 4.0 Timestamp('2020-12-23 00:00:00')]

[3 5.8 Timestamp('2020-12-24 00:00:00')]]

可以通过 type 查看其类型，输出如下：

numpy.ndarray

示例2：

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]]

三十六、Pandas使用的注意事项

Pandas 基于 NumPy 构建，它遵循 NumPy 设定的一些规则。因此，当您在使用 Pandas 时，需要额外留意一些事项，避免出现一些不必要的错误。

1、if语句使用

在 if 语句中，如果您需要将 Pandas 对象转换为布尔值时，需要格外留意，这种操作会引起 ValueError 异常，下面通过一组示例做简单说明：

import pandas as pd
if pd.Series([False, True, False]):
    print('I am True')

输出结果：

ValueError

....

ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

从输出结果可以看出，上述代码引发了 ValueError 错误，并告诉我们 Series 的真值是不明确的。下面对其进行了简单分析：

如果 if 语句判断为 True，可能是认为它的长度并不是 0，反之 if 语句判断为 Fasle，可能是认为 Series 的数据值中包含了 False 值，因此是真还是假，无法判断，所以此处抛出了 ValueError 错误。

上述代码给出的修改建议，如下所示：

import pandas as pd
#使用 any()方法解决
if pd.Series([False, True, False]).any():
    print("I am 编程帮 www.biancheng.com")

输出结果：

I am 编程帮 www.biancheng.com

如果要是计算单个布尔元素的 Series 对象，那么您可以使用 bool() 方法进行修改，如下所示：

import pandas as pd
print(pd.Series([False]).bool())

输出结果：

False

2、布尔运算

如果在 Pandas 对象中使用==（相等）和!=（不相等） 这样的布尔运算符时，将返回一个布尔序列，示例如下：

import pandas as pd
s = pd.Series(range(4))
#返回布尔值序列，行索引为3的位置为True
print(s==3)

输出结果：

0 False

1 False

2 False

3 True

dtype: bool

3、isin()操作

isin() 也会返回一个布尔序列，它用来判断元素值是否包含在的 Series 序列中。

用于指示原始Series中的每个元素是否在给定列表中。示例如下：

import pandas as pd
s = pd.Series(list('abc'))
s = s.isin(['a', 'c', 'e'])
print(s)

输出结果：

0    True

1    False

2    True

dtype: bool

4、reindex()操作

reindex() 函数表示重置行索引，该方法会生成新的 Pandas 对象，示例如下：

import pandas as pd
import numpy as np
#index行索引使用字符和数字混合的形式
df = pd.DataFrame(np.random.randn(6, 4), columns=['one', 'two', 'three','four'],index=['a','b',2,3,'e',5])
print (df)
#数字与字符混合后取数据
print (df.reindex(['a','b',5]))
print (df.reindex([2,'e']))

输出结果：

one two three four

a 0.727276 -0.360391 0.381606 1.195126

b -1.974803 0.009088 -1.065647 0.628699

2 0.156798 -1.116029 1.020673 -0.215485

3 -1.310007 0.601206 0.417439 0.049863

e 0.232375 0.235999 -1.886337 -0.421110

5 0.488758 0.108129 -1.405737 2.375517

one two three      four

a 0.727276 -0.360391 0.381606 1.195126

b -1.974803 0.009088 -1.065647 0.628699

5 0.488758 0.108129 -1.405737 2.375517

one two three      four

2 0.156798 -1.116029 1.020673 -0.215485

e 0.232375 0.235999 -1.886337 -0.421110