【Pandas 数据分析 2】数据结构

2.1 Python 数据结构

2.1.1 数字

2.1.2 字符串

2.1.3 布尔型

2.1.4 列表

2.1.5 元组

2.1.6 字典

2.1.7 集合

2.2 NumPy

2.2.1 NumPy简介

2.2.2 数据结构

2.2.3 创建数据

2.2.4 数据类型

2.2.5 数组信息

2.2.6 统计计算

2.3 Pandas 的数据结构

2.3.1 Series

2.3.2 DataFrame

2.3.3 索引

2.4 Pandas生成数据

2.4.1 创建数据

2.4.2 生成Series

2.4.3 生成DataFrame

2.5 Pandas的数据类型

2.5.1 数据类型查看

2.5.2 常见数据类型

2.5.3 数据检测

Pandas是基于强大的NumPy库开发的，它继承了NumPy中的一些数据结构，也继承了NumPy的高效计算特性。本篇文章，我们将深入了解Pandas的底层数据结构及其依赖的NumPy库的基础用法，还将学习它的数据生成操作。

2.1 Python 数据结构

本节将讲述Python的几大基础数字类型和结构。

在标准的Python数据类型中，有些是可变的，有些是不可变的。不可变就意味着你不能对它进行操作，只能读取。

不可变数据：Number（数字）、String（字符串）、Tuple（元组）。

可变数据：List（列表）、Dictionary（字典）、Set（集合）。

可以用Python内置的type()函数查看数据的类型，如：

type(123) # 返回int
# int
a = "Hello"
type(a) # 返回str
# str

也可以用isinstance来判断数据是不是指定的类型：

isinstance(123, int) # 123是不是整型值
# True
isinstance('123', int)
# False
isinstance(True, bool)
# True

2.1.1 数字

Python的数字类型可以存储数学中的各种数字，包括常见的自然数、复数中的虚数、无穷大数、正负数、带小数点的数、不同进制的数等。

x = 1    # int, 整型
y = 1.2  # float, 浮点
z = 1j   # complex, 复数

可以对数字进行以下运算：

a = 10
b = 21
# 数值计算
a + b # 31
a - b # -11
a * b # 210
b / a # 2.1
a ** b # 表示10的21次幂
b % a # 1 （取余）
# 地板除，相除后只保留整数部分，即向下取整
# 但如果其中一个操作数为负数，则取负无穷大方向距离结果最近的整数
9//2 # 4
9.0//2.0 # 4.0
-11//3 # -4
-11.0//3 # -4.0

2.1.2 字符串

字符串可以是一条或多条文本信息。在Python中非常容易定义字符串，字符串的计算处理也非常方便。

可以对字符串进行切片访问（同时适用于字符、列表、元组等）。字符串从左往右，索引从0开始；从右往左，索引从–1开始。可以取字符串中的片段，切片索引按左闭右开原则：

var = 'Hello World!'
# 按索引取部分内容，索引从0开始, 左必须小于右
# 支持字符、列表、元组
var[0] # 'H'
# 从右往左，索引从-1开始
var[-1] # '!'
var[-3:-1] # 'ld'
var[1:7] # 'ello W'（有个空格，不包含最后一位索引7）
var[6:] # 'World!' （只指定开头，包含后面所有的字符）
var[:] # 'Hello World!'（相当于复制）
var[0:5:2] # 'Hlo'（2为步长，按2的倍数取）
var[1:7:3] # 'ello W' -> 'eo'
var[::-1] # '!dlroW olleH'（实现反转字符功能）

下面是一些最常用的字符操作：

len('good') # 4 （字符的长度）
'good'.replace('g', 'G') # 'Good' （替换字符）
'山-水-风-雨'.split('-') # ['山', '水', '风', '雨'] （用指定字符分隔，默认空格）
'好山好水好风光'.split('好') # ['', '山', '水', '风光']
'-'.join(['山','水','风','雨']) # '山-水-风-雨'
'和'.join(['诗', '远方']) # '诗和远方'
'good'.upper() # 'GOOD' （全转大写）
'GOOD'.lower() # 'good' （全转小写）
'Good Bye'.swapcase() # 'gOOD bYE' （大小写互换）
'good'.capitalize() # 'Good' （首字母转大写）
'good'.islower() # True （是否全是小写）
'good'.isupper() # False （是否全是大写）
'3月'.zfill(3) # '03月' （指定长度，如长度不够，前面补0）

2.1.3 布尔型

在计算机世界中，0和1是基本元素，代表了开或关、真或假两种状态。在Python里，True和False分别代表真和假，它们都属于布尔型。布尔型只有这两个值。

如果我们检测变量，以下情况会得到假，其他情况为真：

None、False

数值中的0、0.0、0j（虚数）、Decimal(0)、Fraction(0, 1)

空字符串""、空元组()、空列表[]

空字典{}、空集合set()

对象默认为True，除非它有bool()方法且返回False，或有len()方法且返回0

以下是一些典型的布尔运算：

a = 0
b = 1
c = 2
a and b # 0（a为假，返回假的值）
b and a # 0（b为真，返回a的值）
a or b # 2 （a为假，返回b的值）
a and b or c # 2
a and (b or c) # 0 （用类似数学中的括号提高运算优先级）# not的注意事项
not a # True
not a == b # True
not (a == b) # True（逻辑同上）
a == not b # 这条有语法错误, 正确的如下：
a == (not b) # True# and的优先级高于or。首先，'a'为真，'a' and 'b'返回'b';然后，'' or 'b'返回'b'
'' or 'a' and 'b' # 'b'

2.1.4 列表

列表是用方括号组织起来的，每个元素用逗号隔开，每个具体元素可以是任意类型的内容。通常元素的类型是相同的，但也可以不相同，例如：

x = [] # 空列表
x = [1, 2, 3, 4, 5]
x = ['a', 'b', 'c']
x = ['a', 1.5, True, [2, 3, 4]] # 各种类型混杂
type(x) # list 类型检测

列表和字符串一样支持切片访问，可以将字符串中的一个字符当成列表中的一个元素。以下是一些常用的列表操作：

a = [1, 2, 3]
len(a) # 3（元素个数）
max(a) # 3（最大值）
min(a) # 1（最小值）
sum(a) # 6（求和）
a.index(2) # 1（指定元素位置）
a.count(1) # 1（求元素的个数）
for i in a: print(i) # 迭代元素
sorted(a) # 返回一个排序的列表，但不改变原列表
any(a) # True（是否至少有一个元素为真）
all(a) # True（是否所有元素为真）
a.append(4) # a: [1, 2, 3, 4]（增加一个元素）
a.pop() # 每执行一次，删除最后一个元素
a.extend([9,8]) # a: [1, 2, 3, 9, 8]（与其他列表合并）
a.insert(1, 'a') # a: [1, 'a', 2, 3]（在指定索引位插入元素，索引从0开始）
a.remove('a') # 删除第一个指定元素
a.clear() # []（清空）

# 将一个可迭代的对象展开，形成一个列表
[i for i in range(5)]
# [0, 1, 2, 3, 4]# 可以将结果进行处理
['第'+str(i) for i in range(5)]
# ['第0', '第1', '第2', '第3', '第4']# 可以进行条件筛选，实现取偶数
[i for i in range(5) if i%2==0]# 拆开字符，过滤空格，全变成大写
[i.upper() for i in 'Hello world' if i != ' ']
# ['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']

2.1.5 元组

元组（tuple）跟列表（list）非常相似，二者之间的差异是元组不可改变，而列表是可以改变的。元组使用圆括号()，列表使用方括号[]。

元组的索引机制跟列表完全一样。元组是不可修改的，我们修改元素时，就会报错，但是我们可以修改混杂类型里的列表类型数据。

另外，我们需要掌握元组的解包操作，这些操作可以让我们灵活地赋值、定义函数、传参，非常方便。

x = (1,2,3,4,5)
a, *b = x # a占第一个，剩余的组成列表全给b
# a -> 1
# b -> [2, 3, 4, 5]
# a, b -> (1, [2, 3, 4, 5])a, *b, c = x # a占第一个，c占最后一个，剩余的组成列表全给b
# a -> 1
# b -> [2, 3, 4]
# c -> 5
# a, b, c -> (1, [2, 3, 4], 5)

2.1.6 字典

字典是Python重要的数据结构，由键值对组成。我们用属性（key）和值（value）组成“键值对”（key-value）这样的数据结构。它可以用以下方法定义：

d = {} # 定义空字典
d = dict() # 定义空字典
d = {'a': 1, 'b': 2, 'c': 3}
d = {'a': 1, 'a': 1, 'a': 1} # {'a': 1} key不能重复，重复时取最后一个
d = {'a': 1, 'b': {'x': 3}} # 嵌套字典
d = {'a': [1,2,3], 'b': [4,5,6]} # 嵌套列表# 以下均可定义如下结果
# {'name': 'Tom', 'age': 18, 'height': 180}
d = dict(name='Tom', age=18, height=180)
d = dict([('name', 'Tom'), ('age', 18), ('height', 180)])
d = dict(zip(['name', 'age', 'height'], ['Tom', 18, 180]))

访问字典的方法如下：

d['name']  # 'Tom'（获取键的值）
d['age'] = 20  # 将age的值更新为20
d['Female'] = 'man'  # 增加属性
d.get('height', 180)  # 180# 嵌套取值
d = {'a': {'name': 'Tom', 'age':18}, 'b': [4,5,6]}
d['b'][1] # 5
d['a']['age'] # 18

常用的字典操作方法如下：

d.pop('name') # 'Tom'（删除指定key）
d.popitem() # 随机删除某一项
del d['name']  # 删除键值对
d.clear()  # 清空字典# 按类型访问，可迭代
d.keys() # 列出所有键
d.values() # 列出所有值
d.items() # 列出所有键值对元组（k, v）# 操作
d.setdefault('a', 3) # 插入一个键并给定默认值3，如不指定，则为None
d1.update(dict2) # 将字典dict2的键值对添加到字典dict
# 如果键存在，则返回其对应值；如果键不在字典中，则返回默认值
d.get('math', 100) # 100
d2 = d.copy() # 深拷贝，d变化不影响d2d = {'a': 1, 'b': 2, 'c': 3}
max(d) # 'c'（最大的键）
min(d) # 'a'（最小的键）
len(d) # 3（字典的长度）
str(d) # "{'a': 1, 'b': 2, 'c': 3}"（字符串形式）
any(d) # True（只要一个键为True）
all(d) # True（所有键都为True）
sorted(d) # ['a', 'b', 'c']（所有键的列表排序）

2.1.7 集合

集合（set）是存放无顺序、无索引内容的容器。在Python中，集合用花括号{}表示。我们用集合可以消除重复的元素，也可以用它作交、差、并、补等数学运算。以下是它的定义方法：

s = {} # 空集合
s = {'5元', '10元', '20元'} # 定义集合
s = set() # 空集合
s = set([1,2,3,4,5]) # {1, 2, 3, 4, 5}（使用列表定义）
s = {1, True, 'a'}
s = {1, 1, 1} # {1}（去重）
type(s) # set（类型检测）

集合没有顺序，没有索引，所以无法指定位置去访问，但可以用for遍历的方式进行读取。以下是一些常用的操作：

s = {'a', 'b', 'c'}# 判断是否有某个元素
'a' in s # True# 添加元素
s.add(2) # {2, 'a', 'b', 'c'}
s.update([1,3,4]) # {1, 2, 3, 4, 'a', 'b', 'c'}# 删除和清空元素
s.remove('a') # {'b', 'c'}（删除不存在的会报错）
s.discard('3') # 删除一个元素，无则忽略，不报错
s.clear() # set()（清空）

集合的数学运算如下：

s1 = {1,2,3}
s2 = {2,3,4}s1 & s2 # {2, 3}（交集）
s1.intersection(s2) # {2, 3}（交集）
s1.intersection_update(s2) # {2, 3}（交集，会覆盖s1）s1 | s2  # {1, 2, 3, 4}（并集）
s1.union(s2) # {1, 2, 3, 4}（并集）s1.difference(s2) # {1}（差集）
s1.difference_update(s2) # {1}（差集，会覆盖s1）s1.symmetric_difference(s2) # {1, 4}（交集之外）s1.isdisjoint(s2) # False（是否没有交集）
s1.issubset(s2) # False （s1是否是s2的子集）
s1.issuperset(s2) # False（s1是否是s2的超集，即s1是否包含s2中的所有元素）

2.2 NumPy

NumPy是Python的一个高性能矩阵运算的科学计算库。它的主要用途是以数组的形式进行数据操作和数学运算，数据分析、机器学习大都是进行数学计算。Pandas依赖NumPy，在安装它时会自动安装NumPy。Pandas的数据结构和运算的底层工作都交由NumPy来完成。但是，我们不需要过多关注NumPy的功能，直接使用Pandas的功能就可以，也不需要从NumPy的基础开始学习，这部分内容可以跳过，有需要再回头看。

2.2.1 NumPy简介

它是一个Python库，提供多维数组对象以及蒙版数组和矩阵等各种派生对象，用于对数组进行快速便捷的操作，包括数学、逻辑、形状处理、排序、选择、I/O、离散傅立叶变换、基本线性代数、基本统计运算、随机模拟等。可以说，NumPy是数据科学中必不可少的工具。

由于NumPy对数据进行向量化描述，没有任何显式的循环操作，所以执行速度更快，代码更加简洁优雅，出错率更低。NumPy提供了两个基本的对象。

ndarray：存储数据的多维数组。

ufunc：对数组进行处理的函数。

2.2.2 数据结构

NumPy的ndarray提供了一维到三维的数据结构，常用到的是一维和二维数组。

ndarray对数据向量化，利用隐式逐元素方式的广播机制进行算术运算、逻辑运算、位运算、函数调用等，可以快速、批量地处理数据。（——这里我还不太理解）

2.2.3 创建数据

使用NumPy需要先导入，约定俗成地为它起别名np。使用np.array可传入一个元组或列表。如果是二维数据，可以是由列表组成的列表或由元组组成的列表等形式。

import numpy as npnp.array([1, 2, 3])
np.array((1, 2, 3)) # 同上
# array([1, 2, 3])np.array(((1, 2),(1, 2)))
np.array(([1, 2],[1, 2])) # 同上
'''
array([[1, 2],[1, 2]])
'''

以下是一些常见的数据生成函数。

np.arange(10) # 10个，不包括10，步长为1
np.arange(3, 10, 0.1) # 从3到9，步长为0.1
# 从2.0到3.0，生成均匀的5个值，不包括终值3.0
np.linspace(2.0, 3.0, num=5, endpoint=False)# 返回一个6×4的随机数组，浮点型
np.random.randn(6, 4)
# 指定范围、指定形状的数组，整型
np.random.randint(3, 7, size=(2, 4))
# 创建值为0的数组
np.zeros(6) # 6个浮点0.
np.zeros((5, 6), dtype=int) # 5×6整型0
np.ones(4) # 同上
np.empty(4) # 同上# 创建一份和目标结构相同的0值数组
np.zeros_like(np.arange(6))
np.ones_like(np.arange(6)) # 同上
np.empty_like(np.arange(6)) # 同上

2.2.4 数据类型

由于Pandas中的数据类型部分继承了NumPy的数据类型，所以我们需要了解一下NumPy的常见类型。

np.int64 # 有符号64位整型
np.float32 # 标准双精度浮点类型
np.complex # 由128位的浮点数组成的复数类型
np.bool # bool类型（True或False）
np.object # Python中的object类型
np.string # 固定长度的string类型
np.unicode # 固定长度的unicode类型
np.NaN # np.float的子类型
np.nan

2.2.5 数组信息

以下是一些获取数组信息的常用方法。

n.shape() # 数组的形状，返回值是一个元组
n.shape = (4, 1) # 改变形状
a = n.reshape((2,2)) # 改变原数组的形状，创建一个新数组
n.dtype # 数据类型
n.ndim # 维度数
n.size # 元素数
np.typeDict # np的所有数据类型

2.2.6 统计计算

两个数组间的操作采用行列式的运算规则，示例如下。

np.array([10, 20, 30, 40])[:3] # 支持类似列表的切片
a = np.array([10, 20, 30, 40])
b = np.array([1, 2, 3, 4])
a+b # array([11, 22, 33, 44])（矩阵相加）
a-1 # array([9, 19, 29, 39])
4*np.sin(a)# 以下是一些数学函数的例子，还支持非常多的数学函数
a.max() # 40
a.min() # 10
a.sum() # 100
a.std() # 11.180339887498949
a.all() # True
a.cumsum() # array([10, 30, 60, 100])
b.sum(axis=1) # 多维可以指定方向

2.3 Pandas 的数据结构

Pandas提供Series和DataFrame作为数组数据的存储框架，数据进入这两种框架后，我们就可以利用它们提供的强大处理方法进行处理。

Series 一维，带标签的一维同构数组

DataFrame 2维带标签的、大小可变的二维异构表格

需要注意的是，Pandas之前支持的三维面板（Panel）结构现已不再支持，可以使用多层索引形式来实现。

2.3.1 Series

Series（系列、数列、序列）是一个带有标签的一维数组，这一系列连续的数据代表了一定的业务意义。如以下各国2019年的GDP就是一个典型的Series。

中国  14.34
美国  21.43
日本  5.08
dtype: float64

其中，国家是标签（也称索引），不是具体的数据，它起到解释、定位数据的作用。如果没有标签，只有一个数字，是不具有业务意义的。Series是Pandas最基础的数据结构。

2.3.2 DataFrame

DataFrame意为数据框，它就像一个存放数据的架子，有多行多列，每个数据在一个格子里，每个格子有自己的编号。就像一个球场的座位（见图2-3），我们在横向编成1排、2排、3排等，在纵向编成1号、2号、3号等，那么4排18号、6排1号等就是具体的位置，每个人落座后就像一个具体的数据。

DataFrame是Pandas定义的一个二维数据结构

我们来分析一下它的结构：

横向的称作行（row），我们所说的一条数据就是指其中的一行；

纵向的称作列（column）或者字段，是一条数据的某个值；

第一行是表头，或者叫字段名，类似于Python字典里的键，代表数据的属性；

第一列是索引，就是这行数据所描述的主体，也是这条数据的关键；

在一些场景下，表头和索引也称为列索引和行索引；

行索引和列索引可能会出现多层索引的情况（后面会遇到）。

我们给上例国家GDP Series数据中增加一列“人口”，形成一个DataFrame：

       人口    GDP
中国  13.97  14.34
美国   3.28  21.43
日本   1.26   5.08

这就是一个典型的DataFrame结构，其中：

共有三行两列（不包含索引）数据；

国家所在列是这个表的索引，每一行数据的主体为这个国家；

每条数据（横向）有两个值，分别是人口和GDP。

2.3.3 索引

在后续的内容中，在不同场景下可能会对索引使用以下名称。

索引（index）：行和列上的标签，标识二维数据坐标的行索引和列索引，默认情况下，指的是每一行的索引。如果是Series，那只能是它行上的索引。列索引又被称为字段名、表头。

自然索引、数字索引：行和列的0～n（n为数据长度–1）形式的索引，数据天然具有的索引形式。虽然可以指定为其他名称，但在有些方法中依然可以使用。

标签（label）：行索引和列索引，如果是Series，那只能是它行上的索引。

轴（axis）：仅用在DataFrame结构中，代表数据的方向，如行和列，用0代表列（默认），1代表行。

2.4 Pandas生成数据

今后我们处理的数据基本上是Pandas的DataFrame和Series，其中DataFrame是Series的容器，所以需要掌握数据生成方法。现在我们学习如何制造一些简单数据放入DataFrame和Series，后面会单独讲解如何从文件（如Excel）中读取和生成数据。

2.4.1 创建数据

使用pd.DataFrame()可以创建一个DataFrame，然后用df作为变量赋值给它。df是指DataFrame，也已约定俗成，建议尽量使用。

df = pd.DataFrame({'国家': ['中国', '美国', '日本'],'地区': ['亚洲', '北美', '亚洲'],'人口': [13.97, 3.28, 1.26],'GDP': [14.34, 21.43, 5.08],})

我们知道，DataFrame可以容纳Series，所以在定义DataFrame时可以使用Series，也可以利用NumPy的方法：

df2 = pd.DataFrame({'A': 1.,'B': pd.Timestamp('20130102'),'C': pd.Series(1, index=list(range(4)), dtype='float32'),'D': np.array([3] * 4, dtype='int32'),'E': pd.Categorical(["test", "train", "test", "train"]),'F': 'foo'})
df2
'''A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo
'''

上面D列使用np.array()方法构建了一个数量为4的整型数列。从DataFrame中选取一列就会返回一个Series，当然选择多列的话依然是DataFrame。

如下单独创建一个Series：

s = pd.Series([14.34, 21.43, 5.08], name='gdp')
s
'''
0    14.34
1    21.43
2     5.08
Name: gdp, dtype: float64
'''

使用Python的type函数可以查看数据类型：

type(s) # pandas.core.series.Series
type(df) # pandas.core.frame.DataFrame

2.4.2 生成Series

Series是一个带有标签的一维数组，这个数组可以由任何类型数据构成，包括整型、浮点、字符、Python对象等。它的轴标签被称为索引，它是Pandas最基础的数据结构。

Series的创建方式如下：

s = pd.Series(data, index=index)

data可以是Python对象、NumPy的ndarray、一个标量（定值，如8）。index是轴上的一个列表，必须与data的长度相同，如果没有指定，则自动从0开始，表示为[0, …, len(data)–1]。

（1）使用列表和元组

列表和元组可以直接放入pd.Series()：

pd.Series(['a', 'b', 'c', 'd', 'e'])
pd.Series(('a', 'b', 'c', 'd', 'e'))

（2）使用ndarray

如下使用NumPy的ndarray结构：

# 由索引分别为a、b、c、d、e的5个随机浮点数数组组成
s = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])
s.index # 查看索引
s = pd.Series(np.random.randn(5)) # 未指定索引

（3）使用字典

如下使用Python的字典数据：

d = {'b': 1, 'a': 0, 'c': 2}
s = pd.Series(d)
s
'''
b    1
a    0
c    2
dtype: int64
'''# 如果指定索引，则会按索引顺序，如有无法与索引对应的值，会产生缺失值
pd.Series(d, index=['b', 'c', 'd', 'a'])
'''
b    1.0
c    2.0
d    NaN
a    0.0
dtype: float64
'''

（4）使用标量

对于一个具体的值，如果不指定索引，则其长度为1；如果指定索引，则其长度为索引的数量，每个索引的值都是它。

pd.Series(5.)
'''
0    5.0
dtype: float64
'''# 指定索引
pd.Series(5., index=['a', 'b', 'c', 'd', 'e'])
'''
a    5.0
b    5.0
c    5.0
d    5.0
e    5.0
dtype: float64
'''

2.4.3 生成DataFrame

DataFrame是二维数据结构，数据以行和列的形式排列，表达一定的数据意义。DataFrame的形式类似于CSV、Excel和SQL的结果表，有多个数据列，由多个Series组成。、

DataFrame最基本的定义格式如下：

df = pd.DataFrame(data=None, index=None, columns=None)

data：具体数据，结构化或同构的ndarray、可迭代对象、字典或DataFrame。

index：索引，类似数组的对象，支持解包，如果没有指定，会自动生成RangeIndex (0, 1, 2, …, n)。

columns：列索引、表头，如果没有指定，会自动生成RangeIndex (0, 1, 2, …,n)。

此外还可以用dtype指定数据类型，如果未指定，系统会自动推断。

大多数情况下，我们是从数据文件（如CSV、Excel）中取得数据，不过，了解这部分知识可以让我们更好地理解DataFrame的数据机制。

1. 字典

字典中的键为列名，值一般为一个列表或者元组，是具体数据。示例如下。

d = {'国家': ['中国', '美国', '日本'],'人口': [14.33, 3.29, 1.26]}
df = pd.DataFrame(d)
df
'''国家    人口
0  中国  13.97
1  美国   3.28
2  日本   1.26
'''

如果生成时指定了索引名称，会使用指定的索引名，如a、b、c。示例如下。

df = pd.DataFrame(d, index=['a', 'b', 'c'])
df
'''国家    人口
a  中国  13.97
b  美国   3.28
c  日本   1.26
'''

2. Series组成的字典

这是一种非常典型的构造数据的方法，字典里的一个键值对为一列数据，键为列名，值是一个Series。示例如下。

d = {'x': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),'y': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
df
'''x    y
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0
'''

3. 字典组成的列表

由字典组成一个列表，每个字典是一行数据，指定索引后会使用指定的索引。示例如下。

# 定义一个字典列表
data = [{'x': 1, 'y': 2}, {'x': 3, 'y': 4, 'z': 5}]# 生成DataFrame对象
pd.DataFrame(data)
'''x  y    z
0  1  2  NaN
1  3  4  5.0
'''# 指定索引
pd.DataFrame(data, index=['a', 'b'])
'''x  y    z
a  1  2  NaN
b  3  4  5.0
'''

4. Series生成

一个Series会生成只有一列的DataFrame，示例如下。

s = pd.Series(['a', 'b', 'c', 'd', 'e'])
pd.DataFrame(s)

5. 其他方法

以下两个方法可以从字典和列表格式中取得数据。

# 从字典里生成
pd.DataFrame.from_dict({'国家': ['中国', '美国', '日本'],'人口': [13.97, 3.28, 1.26]})
# 从列表、元组、ndarray中生成
pd.DataFrame.from_records([('中国', '美国', '日本'), (13.97, 3.28, 1.26)])
# 列内容为一个字典
pd.json_normalize(df.col)
df.col.apply(pd.Series)

2.5 Pandas的数据类型

Pandas里的一列可以由NumPy数组组成，事实上大多NumPy的数据类型就是Pandas的类型，Pandas也有自己特有的数据类型。

2.5.1 数据类型查看

先加载数据：

import pandas as pddf = pd.read_excel('https://www.gairuo.com/file/data/dataset/team.xlsx')

查看df中各列的数据类型：

df.dtypes # 各字段的数据类型
'''
name    object
team    object
Q1       int64
Q2       int64
Q3       int64
Q4       int64
dtype: object
'''

可以看到，name和team列为object，其他列都是int64。如下查看具体字段的类型：

df.team.dtype
# dtype('O')

df.team是一个Series，所以要使用.dtype而不是.dtypes。

2.5.2 常见数据类型

Pandas提供了以下常见的数据类型，默认的数据类型是int64和float64，文字类型是object。float；int；bool；datetime64[ns]；datetime64[ns, tz]；timedelta64[ns]；timedelta[ns]；category；object；string

这些数据类型大多继承自NumPy的相应数据类型，Pandas提供了可以进行有限的数据类型转换的方法，如将数字型转为字符型，后续章节会进行介绍。

2.5.3 数据检测

可以使用类型判断方法检测数据的类型是否与该方法中指定的类型一致，如果一致，则返回True，注意传入的是一个Series：

pd.api.types.is_bool_dtype(s)
pd.api.types.is_categorical_dtype(s)
pd.api.types.is_datetime64_any_dtype(s)
pd.api.types.is_datetime64_ns_dtype(s)
pd.api.types.is_datetime64_dtype(s)
pd.api.types.is_float_dtype(s)
pd.api.types.is_int64_dtype(s)
pd.api.types.is_numeric_dtype(s)
pd.api.types.is_object_dtype(s)
pd.api.types.is_string_dtype(s)
pd.api.types.is_timedelta64_dtype(s)

————————————————

点击专栏阅读更多文章：

Pandas专栏

数据分析

SQL

机器学习