Python 数据类型

Python 数据类型实际上是类，而定义的变量是它们的实例或对象。由于 Python 是动态类型的，变量的数据类型是基于分配的值在运行时确定的。

一般来说，数据类型用于定义变量的类型。它代表我们将存储在变量中的数据类型，并决定了可以在其上执行的操作。

每种编程语言都有自己的数据项分类。通过这些数据类型，我们可以存储不同类型的数据值。

Python 中的数据类型种类

Python 支持以下内置的数据类型：

数值数据类型

int
float
complex

字符串数据类型

序列数据类型

list
tuple
range

二进制数据类型

bytes
bytearray
memoryview

字典数据类型

集合数据类型

set
frozenset

布尔数据类型

None 类型

data_types

1. Python 数值数据类型

Python 数值数据类型用于存储数值。当你给它们分配一个值时就创建了数值对象。例如：

var1 = 1       # int 数据类型
var2 = True    # bool 数据类型
var3 = 10.023  # float 数据类型
var4 = 10+3j   # complex 数据类型

Python 支持四种不同的数值类型，并且在 Python 库中有对应的内置类，分别是 int、bool、float 和 complex：

int (有符号整数)
float (浮点实数)
complex (复数)

复数由两部分组成——实部和虚部。它们由 '+' 或 '-' 符号分开。虚部以 'j' 作为后缀，表示虚数。-1 的平方根定义为虚数。Python 中的复数表示为 x+yj，其中 x 是实部，y 是虚部。因此，5+6j 是一个复数。

>>> type(5+6j)
<class 'complex'>

以下是一些数值的例子：

int	float	complex
10	0.0	3.14j
0O777	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3+e18	.876j
0x17	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2-E12	4.53e-7j

数值数据类型的示例

以下是一个显示整数、浮点数和复数使用的例子：

# 整数变量。
a = 100
print("The type of variable having value", a, " is ", type(a))

# 浮点变量。
c = 20.345
print("The type of variable having value", c, " is ", type(c))

# 复数变量。
d = 10+3j
print("The type of variable having value", d, " is ", type(d))

2. Python 字符串数据类型

Python 字符串是由一个或多个 Unicode 字符组成的序列，用单引号、双引号或三重引号（也叫倒引号）括起来。Python 字符串是不可变的，这意味着当你对字符串进行操作时，总是产生一个新的字符串对象，而不是改变现有的字符串。

只要同样的字符序列被括起来，单引号或双引号或三重引号都没有关系。因此，以下字符串表示是等价的。

>>> 'TutorialsPoint'
'TutorialsPoint'
>>> "TutorialsPoint"
'TutorialsPoint'
>>> '''TutorialsPoint'''
'TutorialsPoint'

Python 中的字符串是 str 类的对象。这可以通过 type() 函数来验证。

>>> type("Welcome To TutorialsPoint")
<class 'str'>

字符串是非数值数据类型。显然，我们不能在它上面进行算术运算。然而，可以进行切片和连接等操作。Python 的 str 类定义了许多用于字符串处理的有用方法。可以使用切片操作符（[ ] 和 [:]）来取字符串的子集，索引从字符串开头的 0 开始到最后的 -1。

加号 (+) 是字符串连接运算符，星号 (*) 是重复运算符。

字符串数据类型的示例

str = 'Hello World!'

print(str)          # 输出完整字符串
print(str[0])       # 输出字符串的第一个字符
print(str[2:5])     # 输出从第 3 到第 5 个字符
print(str[2:])      # 输出从第 3 个字符开始的字符串
print(str * 2)      # 输出字符串两次
print(str + "TEST") # 输出拼接后的字符串

这会产生以下结果：

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

3. Python 序列数据类型

序列是一种集合数据类型。它是一个有序的项目集合。序列中的项目有一个从 0 开始的位置索引。概念上类似于 C 或 C++ 中的数组。Python 定义了以下三种序列数据类型：

列表数据类型

元组数据类型

范围数据类型

Python 序列是有限的且可迭代的——当我们说 Python 中的可迭代对象时，意味着序列数据类型（例如，列表）。

(a) Python 列表数据类型

Python 列表是最具通用性的复合数据类型。Python 列表包含由逗号分隔并由方括号（[]）包围的项目。在某种程度上，Python 列表类似于 C 语言中的数组。它们之间的主要区别在于，属于 Python 列表的所有项目可以是不同的数据类型，而 C 数组只能存储特定数据类型的元素。

>>> [2023, "Python", 3.11, 5+6j, 1.23E-4]

Python 中的列表是 list 类的对象。我们可以用 type() 函数来检查它。

>>> type([2023, "Python", 3.11, 5+6j, 1.23E-4])
<class 'list'>

如前所述，列表中的项目可以是任何数据类型。这意味着列表对象也可以是另一个列表中的项目。在这种情况下，它变成了一个嵌套列表。

>>> [['One', 'Two', 'Three'], [1,2,3], [1.0, 2.0, 3.0]]

列表可以包含简单数字、字符串、元组、字典、集合或用户定义类的对象。

Python 列表中的值可以通过切片操作符（[ ] 和 [:]）访问，索引从列表开头的 0 开始到最后的 -1。加号 (+) 是列表连接运算符，星号 (*) 是重复运算符。

Python 列表数据类型示例

list = ['abcd', 786, 2.23, 'john', 70.2]
tinylist = [123, 'john']

print(list)            # 打印整个列表
print(list[0])         # 打印列表的第一个元素
print(list[1:3])       # 打印列表中从第二个元素到第三个元素的部分
print(list[2:])        # 打印列表中从第三个元素开始的所有元素
print(tinylist * 2)    # 打印列表两次
print(list + tinylist) # 打印连接后的列表

这将产生如下结果：

['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

Python 元组数据类型

Python 元组是另一种类似于列表的序列数据类型。Python 元组由若干值通过逗号分隔构成。不过，与列表不同的是，元组通常用圆括号(...)来包围。

元组也是一种序列，因此每个元组内的项目都有一个索引指代其在集合中的位置。索引从 0 开始。

(2023, "Python", 3.11, 5+6j, 1.23E-4)

在 Python 中，元组是 tuple 类的对象。我们可以通过 type() 函数来检查它。

>>> type((2023, "Python", 3.11, 5+6j, 1.23E-4))
<class 'tuple'>

像列表一样，元组中的项目也可以是列表、元组本身或其他任何 Python 类的对象。

(['One', 'Two', 'Three'], 1, 2.0, 3, (1.0, 2.0, 3.0))

要形成一个元组，使用圆括号是可选的。没有包围符号、仅用逗号分隔的数据项默认被视为元组。

2023, "Python", 3.11, 5+6j, 1.23E-4
(2023, 'Python', 3.11, (5+6j), 0.000123)

Python 元组数据类型示例

tuple = ('abcd', 786, 2.23, 'john', 70.2)
tinytuple = (123, 'john')

print(tuple)               # 打印完整的元组
print(tuple[0])            # 打印元组的第一个元素
print(tuple[1:3])          # 打印元组中从第二个元素到第三个元素的部分
print(tuple[2:])           # 打印元组中从第三个元素开始的所有元素
print(tinytuple * 2)       # 打印元组两次
print(tuple + tinytuple)   # 打印连接后的元组

这将产生如下结果：

('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

列表和元组的主要区别在于：列表被方括号 ([]) 包围并且其元素和大小可以改变，即列表是可变的；而元组被圆括号 (()) 包围并且不可更新（不可变）。元组可以被认为是只读的列表。

下面的代码对于元组来说是无效的，因为我们试图更新一个元组，这是不允许的。类似的情况在列表中是可以的。

tuple = ('abcd', 786, 2.23, 'john', 70.2)
list = ['abcd', 786, 2.23, 'john', 70.2]
tuple[2] = 1000    # 对于元组无效的语法
list[2] = 1000     # 对于列表有效的语法

Python 范围数据类型

Python 范围是一种不可变的数字序列，通常用于在特定数量的项目中进行迭代。

它由 Range 类表示。这个类的构造函数接受一系列从 0 开始并递增到指定数字的数字。以下是函数的语法：

range(start, stop, step)

以下是参数的描述：

start: 用来指定起始位置的整数（可选，默认值为 0）
stop: 用来指定结束位置的整数（必须提供）
step: 用来指定增量的整数（可选，默认值为 1）

Python 范围数据类型示例

以下是一个使用 for 循环打印从 0 到 4 的数字的程序：

for i in range(5):
  print(i)

这将产生如下结果：

现在让我们修改上述程序，使其从 2 开始打印数字而不是从 0 开始：

for i in range(2, 5):
  print(i)

这将产生如下结果：

2
3
4

再次修改程序，使其从 1 开始但增量为 2 而不是 1：

for i in range(1, 5, 2):
  print(i)

这将产生如下结果：

1
3

Python 二进制数据类型

Python 中的二进制数据类型是一种将数据表示为一系列二进制位的方式，这些位是 0 和 1。它是计算机理解的一种特殊语言，用于高效地存储和处理信息。

这种类型的数据通常用于处理文件、图像或任何可以用两种可能值表示的事物。因此，代替使用常规的数字或字母，二进制序列数据类型使用 0 和 1 的组合来表示信息。

Python 提供了三种不同的方式来表示二进制数据。它们分别是：

bytes
bytearray
memoryview

让我们分别讨论这些数据类型：

(a) Python 字节数据类型

Python 中的字节数据类型表示一个字节序列。每个字节是一个介于 0 到 255 之间的整数值。它通常用于存储诸如图像、文件或网络数据包之类的二进制数据。

我们可以通过内置的 bytes() 函数或者通过在一系列数字前加上 b 来创建字节。

字节数据类型示例

在以下示例中，我们使用内置的 bytes() 函数显式指定一系列代表 ASCII 值的数字：

# 使用 bytes() 函数创建字节
b1 = bytes([65, 66, 67, 68, 69])
print(b1)

得到的结果如下：

b'ABCDE'

在这里，我们在字符串前加上 "b" 前缀以自动创建一个字节对象：

# 使用 'b' 前缀创建字节
b2 = b'Hello'
print(b2)

以上代码的输出如下：

b'Hello'

(b) Python 字节数组数据类型

Python 中的字节数组数据类型与字节数据类型非常相似，但有一个关键的区别：它是可变的，意味着你可以在创建后修改其中存储的值。

你可以通过多种方法创建字节数组，包括通过传递表示字节值的可迭代整数，通过编码字符串，或者通过转换现有的字节或字节数组对象。为此，我们使用 bytearray() 函数。

字节数组数据类型示例

在以下示例中，我们通过传递表示字节值的可迭代整数来创建字节数组：

# 通过传递表示字节值的可迭代整数创建字节数组
value = bytearray([72, 101, 108, 108, 111])
print(value)

得到的输出如下所示：

bytearray(b'Hello')

现在，我们通过使用 "UTF-8" 编码来编码字符串创建字节数组：

# 通过编码字符串创建字节数组
val = bytearray("Hello", 'utf-8')
print(val)

产生的结果如下：

bytearray(b'Hello')

(c) Python 内存视图数据类型

在 Python 中，内存视图是一个内置对象，它提供了对原始对象内存的视图，通常是支持缓冲区协议的对象，如字节数组（bytearray）和字节（bytes）。它允许你在不复制的情况下访问原始对象的底层数据，为大数据集提供高效的内存访问。

你可以通过多种方法创建内存视图。这些方法包括使用 memoryview() 构造器，切片字节或字节数组对象，从数组对象中提取，或在从文件读取时使用内置函数如 open()。

内存视图数据类型示例

在以下示例中，我们直接通过将支持的对象传递给 memoryview() 构造器来创建内存视图对象。支持的对象通常包括字节数组（bytearray）、字节（bytes），以及其他支持缓冲区协议的对象：

data = bytearray(b'Hello, world!')
view = memoryview(data)
print(view)

以上代码的输出如下：

<memory at 0x00000186FFAA3580>

如果你有一个数组对象，你可以使用缓冲接口来创建内存视图，如下所示：

import array
arr = array.array('i', [1, 2, 3, 4, 5])
view = memoryview(arr)
print(view)

得到的输出如下：

<memory at 0x0000017963CD3580>

你也可以通过切片字节或字节数组对象来创建内存视图：

data = b'Hello, world!'
# 创建数据最后一部分的视图
view = memoryview(data[7:])
print(view)

得到的结果如下：

<memory at 0x00000200D9AA3580>

Python 字典数据类型

Python 字典是一种哈希表类型。字典的键几乎可以是任何 Python 类型，但通常为数字或字符串。值则可以是任意的 Python 对象。

Python 字典类似于 Perl 中的关联数组或哈希，由键值对组成。键值对之间由逗号分隔，并且放在花括号 {} 内。为了建立键和值之间的映射关系，在两者之间放置冒号 : 符号。

>>> {1:'one', 2:'two', 3:'three'}

在 Python 中，字典是内置的 dict 类的对象。我们可以使用 type() 函数来检查它。

>>> type({1:'one', 2:'two', 3:'three'})
<class 'dict'>

字典由花括号 { } 包围，并且使用方括号 [] 来分配和访问值。

Python 字典数据类型示例

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print(dict['one'])       # 打印 'one' 键对应的值
print(dict[2])           # 打印 2 键对应的值
print(tinydict)          # 打印完整的字典
print(tinydict.keys())   # 打印所有的键
print(tinydict.values()) # 打印所有的值

这将产生如下结果：

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

Python 的字典不是一个序列。它是一组项，但是每一项（键值对）不像字符串、列表或元组那样通过位置索引标识。因此，不能对字典执行切片操作。字典是一个可变对象，所以可以执行添加、修改或删除等操作，这些操作定义在 dict 类中。这些操作将在后续章节中解释。

Python 集合数据类型

集合是 Python 在数学定义上的实现。Python 中的一个集合是一个集合，但不像字符串、列表或元组那样是一个有序或有索引的集合。一个对象在一个集合中不能出现多次，而在列表和元组中，相同的对象可以出现多次。

集合中的项目用逗号分隔，并放在花括号 {} 或大括号 [] 中。集合中的项可以有不同的数据类型。

>>> {2023, "Python", 3.11, 5+6j, 1.23E-4}

请注意，集合中的项可能不会按照输入的顺序排列。Python 对项的位置进行了优化，以便根据数学定义执行集合操作。

Python 的集合是内置 set 类的对象，可以通过 type() 函数来检查。

>>> type({2023, "Python", 3.11, 5+6j, 1.23E-4})
<class 'set'>

集合只能存储不可变对象，例如数字（int、float、complex 或 bool）、字符串或元组。如果你尝试在集合中放入一个列表或字典，Python 将抛出 TypeError。

>>> {['One', 'Two', 'Three'], 1, 2, 3, (1.0, 2.0, 3.0)}
Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

哈希是一种计算机科学机制，它使在计算机内存中更快地搜索对象成为可能。只有不可变对象是可哈希的。

尽管集合不允许包含可变项，但集合本身是可变的。因此，允许在集合对象上执行添加/删除/更新操作，使用内置 set 类的方法。Python 还有一组运算符来进行集合操作。这些方法和运算符将在后面的章节中解释。

Python 集合示例

set1 = {123, 452, 5, 6}
set2 = {'Java', 'Python', 'JavaScript'}

print(set1)
print(set2)

这将生成如下输出：

{123, 452, 5, 6}
{'Python', 'JavaScript', 'Java'}

Python 布尔数据类型

Python 布尔类型是内置数据类型之一，表示两个值之一：True 或 False。Python 的 bool() 函数允许你评估任何表达式的值，并根据表达式返回 True 或 False。

布尔值只有两个可能的值，由关键字 True 和 False 表示。它们分别对应整数 1 和 0。

>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>

Python 布尔数据类型示例

以下是一个打印布尔变量 a 和 b 的值的程序：

a = True
# 显示 a 的值
print(a)

# 显示 a 的数据类型
print(type(a))

这将产生如下结果：

True
<class 'bool'>

以下是一个评估表达式并打印返回值的另一个程序：

# 返回 False 因为 a 不等于 b
a = 2
b = 4
print(bool(a == b))

# 下面的语句也打印同样的结果
print(a == b)

# 返回 False 因为 a 是 None
a = None
print(bool(a))

# 返回 False 因为 a 是一个空序列
a = ()
print(bool(a))

# 返回 False 因为 a 是 0
a = 0.0
print(bool(a))

# 返回 True 因为 a 是非零值
a = 10
print(bool(a))

这将产生如下结果：

False
False
False
False
False
True

Python None 类型

Python 的 None 类型由 NoneType 表示。这是一个其自身数据类型的对象。NoneType 代表空值或无值的状态。

Python `None` 类型示例

在以下示例中，我们将 None 赋值给变量 x 并打印它的类型，这将是 NoneType：

# 声明一个变量
# 并赋值为 None

x = None

# 打印它的值和类型
print("x =", x)
print("type of x =", type(x))

这将产生如下结果：

x = None
type of x = <class 'NoneType'>

获取数据类型

要获取 Python 中的数据类型，可以使用 type() 函数。type() 是一个内置函数，返回给定对象的类。

示例

在以下示例中，我们正在获取值和变量的类型：

# 获取值的类型
print(type(123))
print(type(9.99))

# 获取变量的类型
a = 10
b = 2.12
c = "Hello"
d = (10, 20, 30)
e = [10, 20, 30]

print(type(a))
print(type(b))
print(type(c))
print(type(d))
print(type(e))

这将产生如下结果：

<class 'int'>
<class 'float'>
<class 'int'>
<class 'float'>
<class 'str'>
<class 'tuple'>
<class 'list'>

设置数据类型

在 Python 中，在声明变量或对象时不需要设置数据类型。数据类型会根据分配的值自动设置。

示例

以下示例演示了如何根据给定的值设置变量的数据类型：

# 声明一个变量
# 并赋值为整数

x = 10

# 打印它的值和类型
print("x =", x)
print("type of x =", type(x))

# 现在将字符串值赋给同一个变量
x = "Hello World!"

# 打印它的值和类型
print("x =", x)
print("type of x =", type(x))

这将产生如下结果：

x = 10
type of x = <class 'int'>
x = Hello World!
type of x = <class 'str'>

原始类型和非原始类型

上面解释的数据类型也可以分为原始类型和非原始类型。

1. 原始类型

原始数据类型是用于创建复杂数据类型（有时称为复杂数据结构）的基本数据类型。主要有四种原始数据类型，它们是：

整数
浮点数
布尔值
字符串

2. 非原始类型

非原始类型存储值或值的集合。主要有四种非原始类型，它们是：

列表
元组
字典
集合

Python 数据类型转换

有时，你可能需要在内置的数据类型之间进行转换。要将数据在不同的 Python 数据类型之间转换，只需将类型名称作为函数使用即可。

示例

以下示例分别将不同的值转换为整数、浮点数和字符串：

print("转换为整数数据类型")
a = int(1)     # a 将是 1
b = int(2.2)   # b 将是 2
c = int("3")   # c 将是 3

print(a)
print(b)
print(c)

print("转换为浮点数")
a = float(1)     # a 将是 1.0
b = float(2.2)   # b 将是 2.2
c = float("3.3") # c 将是 3.3

print(a)
print(b)
print(c)

print("转换为字符串")
a = str(1)     # a 将是 "1"
b = str(2.2)   # b 将是 "2.2"
c = str("3.3") # c 将是 "3.3"

print(a)
print(b)
print(c)

这将产生如下结果：

转换为整数数据类型
1
2
3
转换为浮点数
1.0
2.2
3.3
转换为字符串
1
2.2
3.3

数据类型转换函数

有几个内置函数可以执行从一种数据类型到另一种的转换。这些函数返回一个表示转换后值的新对象。

序号	函数名 & 描述
1	`int()` 函数
2	`long()` 函数
3	`float()` 函数
4	`complex()` 函数
5	`str()` 函数
6	`repr()` 函数
7	`eval()` 函数
8	`tuple()` 函数
9	`list()` 函数
10	`set()` 函数
11	`dict()` 函数
12	`frozenset()` 函数
13	`chr()` 函数
14	`unichr()` 函数
15	`ord()` 函数
16	`hex()` 函数
17	`oct()` 函数