9.3 理解 Python 中的数据类型
本节是《Python 数据科学手册》（Python Data Science Handbook）的摘录。
译者：飞龙
数据驱动的科学和有效计算需要了解数据的存储和操作方式。本节概述了如何在 Python 语言本身中处理数据数组，以及对比 NumPy 如何改进它。对于理解本书其余部分的大部分内容，理解这种差异至关重要。
Python 的用户通常被它的易用性吸引，其中一部分是动态类型。虽然像 C 或 Java 这样的静态类型语言要求显式声明每个变量，但像 Python 这样的动态类型语言会跳过此规范。 例如，在 C 中，你可以指定特定操作，如下所示：
/* C 代码 */
int result = 0;
for(int i=0; i<100; i++){
result += i;
}
在 Python 中，可以用这种方式编写等效的操作：
# Python 代码
result = 0
for i in range(100):
result += i
注意主要区别：在 C 中，每个变量的数据类型是显式声明的，而在 Python 中，类型是动态推断的。 这意味着，例如，我们可以将任何类型的数据分配给任何变量：
# Python 代码
x = 4
x = "four"
这里我们将x的内容从整数转换为字符串。 C 中的相同内容会导致编译错误或其他无意义的结果（取决于编译器设置）：
/* C 代码 */
int x = 4;
x = "four"; // 失败
这种灵活性，是使 Python 和其他动态类型语言方便易用的一个方面。理解它的原理，是学习如何有效使用 Python 分析数据的一个重要方面。
但是这种类型的灵活性也指出了，Python 变量不仅仅是它们的值; 它们还包含值的类型的额外信息。 我们将在后面的章节中详细探讨它。
Python 的整数不仅仅是整数
标准的 Python 实现是用 C 编写的。这意味着每个 Python 对象都只是一个巧妙伪装的 C 结构，它不仅包含其值，还包含其他信息。
例如，当我们在 Python 中定义一个整数时，例如x = 10000，x不仅仅是一个“原始”整数。 它实际上是指向复合 C 结构的指针，包含多个值。
通过 Python 3.4 源代码，我们发现（长）整数类型定义实际上看起来像这样（C 宏扩展之后）：
struct _longobject {
long ob_refcnt;
PyTypeObject *ob_type;
size_t ob_size;
long ob_digit[1];
};
Python 3.4 中的单个整数实际上包含四个部分：
-
ob_refcnt, 引用计数，帮助 Python 静默处理内存分配和释放 -
ob_type, 它编码变量的类型 -
ob_size, 它指定以下数据成员的大小 -
ob_digit, 其中包含我们期望 Python 变量表示的实际整数值。
这意味着在 Python 中存储整数，与在 C 等编译语言中的整数相比，存在一些开销，如下图所示：
这里PyObject_HEAD是结构的一部分，包含引用计数，类型代码和之前提到的其他部分。
注意这里的区别：C 整数本质上是内存中位置的标签，它的字节编码整数值。Python 整数是指针，指向内存中包含所有 Python 对象信息的位置，包含编码整数值的字节。Python 整数结构中的这些额外信息，允许 Python 自由动态地编码。
然而，Python 类型中的所有这些附加信息都需要付出代价，这在组合了许多这些对象的结构中尤为明显。
Python 列表不仅仅是列表
现在让我们考虑，当我们使用包含许多 Python 对象的 Python 数据结构时会发生什么。
Python 中的标准可变多元素容器就是列表。我们可以创建一个整数列表，如下所示：
L = list(range(10))
L
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
type(L[0])
# int
或者，类似地，字符串列表：
L2 = [str(c) for c in L]
L2
# ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
type(L2[0])
# str
由于 Python 的动态类型，我们甚至可以创建异构列表：
L3 = [True, "2", 3.0, 4]
[type(item) for item in L3]
# [bool, str, float, int]
但是这种灵活性需要付出代价：为了允许这些灵活类型，列表中的每个项目都必须包含自己的类型信息，引用计数和其他信息 - 也就是说，每个项目都是完整的 Python 对象。在所有变量属于同一类型的特殊情况下，大部分信息都是冗余的：将数据存储在固定类型数组中会更加高效。
动态类型列表和固定类型（NumPy 样式）数组之间的区别如下图所示：
在实现级别，数组基本上包含指向一个连续数据块的单个指针。
另一方面，Python 列表包含一个指向指针块的指针，每个指针指向一个完整的 Python 对象，就像我们之前看到的 Python 整数一样。
同样，列表的优点是灵活性：因为每个列表元素是包含数据和类型信息的完整结构，所以列表可以填充为任何所需类型的数据。固定类型的 NumPy 风格数组缺乏这种灵活性，但是对于存储和操作数据更有效。
Python 中固定类型的数组
Python提供了几种不同的选项，用于在固定类型数据缓冲区中高效存储数据。内置的array模块（自 Python 3.3 起可用）可用于创建统一类型的密集数组：
import array
L = list(range(10))
A = array.array('i', L)
A
# array('i', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
这里'i'是一个类型代码，表示内容是整数。然而，更有用的是 NumPy 包的ndarray对象。
虽然Python的array对象提供了基于数组的，数据的有效存储，但 NumPy 在数组上添加了高效操作。我们将在后面的章节中探讨这些操作; 在这里，我们将演示创建 NumPy 数组的几种方法。
我们将从别名为np的标准 NumPy 导入开始：
import numpy as np
从 Python 列表创建数组
首先，我们可以使用np.array从 Python 列表创建数组：
# 整数数组
np.array([1, 4, 2, 5, 3])
# array([1, 4, 2, 5, 3])
请记住，与 Python 列表不同，NumPy 仅限于类型相同的数组。
如果类型不匹配，NumPy 将尽可能向上转换（此处，整数向上转换为浮点数）：
np.array([3.14, 4, 2, 3])
# array([ 3.14, 4. , 2. , 3. ])
如果我们想显式设置所得数组的数据类型，我们可以使用dtype关键字：
np.array([1, 2, 3, 4], dtype='float32')
# array([ 1., 2., 3., 4.], dtype=float32)
最后，与 Python 列表不同，NumPy 数组可以是显式多维的; 这是一种方法，使用列表的列表初始化多维数组：
# 嵌套列表产生多维数组
np.array([range(i, i + 3) for i in [2, 4, 6]])
'''
array([[2, 3, 4],
[4, 5, 6],
[6, 7, 8]])
'''
内部列表被视为生成的二维数组的行。
从零开始创建数组
特别是对于较大的数组，使用 NumPy 中内置的例程从头开始创建数组效率更高。以下是几个例子：
# 创建长度为 10 的零填充的整数数组
np.zeros(10, dtype=int)
# array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
# 创建一填充的 3x5 浮点数数组
np.ones((3, 5), dtype=float)
'''
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
'''
# 创建 3.14 填充的 3x5 浮点数数组
np.full((3, 5), 3.14)
'''
array([[ 3.14, 3.14, 3.14, 3.14, 3.14],
[ 3.14, 3.14, 3.14, 3.14, 3.14],
[ 3.14, 3.14, 3.14, 3.14, 3.14]])
'''
# 创建数组，填充为 0 到 20 步长为 2 的线性序列
# （类似于内建的 range() 函数）
np.arange(0, 20, 2)
# array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
# 创建五个值的数组，从 0 到 1 等间隔
np.linspace(0, 1, 5)
# array([ 0. , 0.25, 0.5 , 0.75, 1. ])
# 创建 3x3 数组，包含 0 到 1 均匀分布随机值
np.random.random((3, 3))
'''
array([[ 0.99844933, 0.52183819, 0.22421193],
[ 0.08007488, 0.45429293, 0.20941444],
[ 0.14360941, 0.96910973, 0.946117 ]])
'''
# 创建 3x3 数组，包含均值为 0 标准差为 1 的正态分布随机值
np.random.normal(0, 1, (3, 3))
'''
array([[ 1.51772646, 0.39614948, -0.10634696],
[ 0.25671348, 0.00732722, 0.37783601],
[ 0.68446945, 0.15926039, -0.70744073]])
'''
# 创建 3x3 数组，包含 [0, 10) 中的随机值
np.random.randint(0, 10, (3, 3))
'''
array([[2, 3, 4],
[5, 7, 8],
[0, 5, 0]])
'''
# 创建 3x3 单位矩阵
np.eye(3)
'''
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
'''
# 创建三个整数的未初始化数组
# 值是内存地址中已经存在的任何东西
np.empty(3)
# array([ 1., 1., 1.])
NumPy 标准数据类型
NumPy 数组包含类型单一的值，因此详细了解这些类型及其限制非常重要。由于 NumPy 是用 C 语言构建的，因此 C，Fortran 和其他相关语言的用户会熟悉这些类型。标准 NumPy 数据类型列在下表中。
请注意，在构造数组时，可以使用字符串指定它们：
np.zeros(10, dtype='int16')
或者使用相关的 NumPy 对象：
np.zeros(10, dtype=np.int16)
| 数据类型 | 描述 |
|---|---|
bool_ |
布尔值（True 或 False）储存为字节 |
int_ |
默认整数类型（与 C long相同；通常是int64或int32） |
intc |
等价于 C int（normally int32 or int64） |
intp |
用于索引的整数（与 C ssize_t相同；通常是int32或int64） |
int8 |
字节（-128 到 127） |
int16 |
整数（-32768 到 32767） |
int32 |
整数（-2147483648 到 2147483647） |
int64 |
整数（-9223372036854775808 到 9223372036854775807） |
uint8 |
无符号整数（0 到 255） |
uint16 |
无符号整数（0 到 65535） |
uint32 |
无符号整数（0 到 4294967295） |
uint64 |
无符号整数（0 到 18446744073709551615） |
float_ |
float64的简写 |
float16 |
半精度浮点: 符号位，5 位指数，10 位尾数 |
float32 |
单精度浮点: 符号位，8 位指数，23 位尾数 |
float64 |
双精度浮点: 符号位，11 位指数，52 位尾数 |
complex_ |
complex128的简写 |
complex64 |
复数，表示为两个 32 位浮点 |
complex128 |
复数，表示为两个 64 位浮点 |
更高级的类型规范是可能的，例如指定大或小端编码；更多信息请参阅 NumPy 文档。
NumPy 还支持复合数据类型，这将在结构化数据：NumPy 的结构化数组中介绍。
