Python - 数据类型

---

---

Python 数据类型

Python 数据类型实际上是 class，定义的变量是它们的实例或对象。由于 Python 是动态类型语言，变量的数据类型会在运行时根据赋的值来确定。

一般来说，数据类型用于定义变量的类型。它表示我们要存储在变量中的数据类型，并决定了可以对它执行哪些操作。

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

Python 中的数据类型种类

Python 支持以下内置数据类型 −

• Numeric Data Types
  • int
  • flot
  • complex
• String Data Types
• Sequence Data Types
  • list
  • tuple
  • range
• Binary Data Types
  • bytes
  • bytearray
  • memoryview
• Dictionary Data Type
• Set Data Type
  • set
  • frozenset
• Boolean Data Type
• None Type

1. Python Numeric Data Types

Python numeric data types 用于存储数值。当你给它们赋值时，就会创建 number 对象。例如 −

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

Python 支持四种不同的 numerical types，它们在 Python library 中分别有内置的 class：int, bool, float 和 complex −

• int (signed integers)
• float (floating point real values)
• complex (complex numbers)

复数由两部分组成 - 实数 和 虚数。它们由 '+' 或 '-' 符号分隔。虚数部分后缀为 'j'，这是虚数。-1 的平方根 ($\mathrm{\sqrt{-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

Numeric Data Types 示例

以下示例展示了 Integer、Float 和 Complex numbers 的用法：

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

# float 变量。
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 字符串是不可变的，这意味着当你对字符串执行操作时，总是会产生一个相同类型的新字符串对象，而不是修改现有的字符串。

只要相同的字符序列被括起来，单引号、双引号或三引号都没有区别。因此，以下字符串表示形式是等价的。

>>> ''
''
>>> ""
''
>>> ''''''
''

Python 中的字符串是 str class 的对象。可以使用 type() function 来验证。

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

字符串是一种非数值数据类型。显然，我们不能对其执行算术运算。然而，可以进行诸如 slicing 和 concatenation 等操作。Python 的 str class 定义了许多用于字符串处理的实用方法。可以使用切片操作符 ([ ] 和 [:] ) 来获取字符串的子集，索引从字符串开头处的 0 开始，到末尾处的 -1。

加号 (+) 是字符串 concatenation operator，星号 (*) 是 repetition operator。

字符串数据类型的示例

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 中定义了以下三种序列数据类型。

• List Data Type
• Tuple Data Type
• Range Data Type

Python 序列是有界的且可迭代的 - 每当我们在 Python 中提到 iterable 时，它表示序列数据类型（例如，list）。

(a) Python List Data Type

Python 列表是最通用的复合数据类型。Python 列表包含用逗号分隔的项目，并用方括号 ([]) 括起来。在某种程度上，Python 列表类似于 C 中的数组。二者的区别在于，Python 列表中的所有项目可以是不同数据类型，而 C 数组只能存储特定数据类型的元素。

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

Python 中的列表是 list class 的对象。我们可以使用 type() function 检查它。

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

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

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

列表可以包含简单数字、字符串、tuple、dictionary、set 或用户定义 class 的对象。

Python 列表中存储的值可以使用切片操作符 ([ ] 和 [:]) 访问，索引从列表开头的 0 开始，到末尾的 -1。加号 (+) 是列表连接操作符，星号 (*) 是重复操作符。

List Data Type 示例

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

print (list)            # 打印完整列表
print (list[0])         # 打印列表的第一个元素
print (list[1:3])       # 打印从第 2 个到第 3 个的元素 
print (list[2:])        # 打印从第 3 个元素开始的元素
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']

(b) Python Tuple Data Type

Python tuple 是另一种类似于列表的序列数据类型。Python tuple 由多个用逗号分隔的值组成。然而，与列表不同的是，tuple 用括号 (...) 括起来。

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

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

在 Python 中，tuple 是 tuple class 的对象。我们可以使用 type() function 检查它。

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

与列表类似，tuple 中的项目也可以是列表、tuple 本身或其他 Python class 的对象。

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

创建 tuple 时，括号的使用是可选的。没有括号符号、仅用逗号分隔的数据项目默认被视为 tuple。

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

Tuple Data Type 示例

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

print (tuple)               # 打印完整的 tuple
print (tuple[0])            # 打印 tuple 的第一个元素
print (tuple[1:3])          # 打印 tuple 从第 2 个到第 3 个的元素 
print (tuple[2:])           # 打印 tuple 从第 3 个元素开始的元素
print (tinytuple * 2)       # 打印 tuple 内容两次
print (tuple + tinytuple)   # 打印连接后的 tuple

这将产生以下结果 −

('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 的主要区别在于：列表用方括号 ( [ ] ) 括起来，其元素和大小可以改变，即列表是 mutable 的，而 tuple 用括号 ( ( ) ) 括起来且不可更新（immutable）。tuple 可以被视为 read-only 列表。

以下代码对 tuple 是无效的，因为我们试图更新 tuple，这是被禁止的。类似情况在列表中是可能的 −

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

(c) Python Range Data Type

Python range 是一个不可变的数字序列，通常用于迭代特定数量的项目。

它由 Range class 表示。该 class 的构造函数接受从 0 开始的数字序列，并以 1 为步长递增，直到达到指定的数字。以下是该 function 的语法 −

range(start, stop, step)

以下是所用参数的描述 −

• start: 指定起始位置的整数（可选，默认：0）

• stop: 指定结束位置的整数（必填）

• step: 指定递增步长的整数（可选，默认：1）

Range Data Type 示例

以下程序使用 for loop 打印从 0 到 4 的数字 −

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

这将产生以下结果 −

0
1
2
3
4

现在让我们修改上述程序，从 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

4. Python 二进制数据类型

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

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

Python 提供了三种不同的方式来表示二进制数据。它们如下 −

• bytes
• bytearray
• memoryview

让我们逐一讨论这些数据类型 −

(a) Python Bytes 数据类型

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

我们可以使用内置的 bytes() 函数或在数字序列前加前缀 b 来在 Python 中创建 bytes。

Bytes 数据类型的示例

在以下示例中，我们使用内置的 bytes() 函数明确指定一个表示 ASCII 值的数字序列 −

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

得到的结果如下 −

b'ABCDE'

在这里，我们在字符串前使用 "b" 前缀来自动创建 bytes 对象 −

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

以上代码的输出如下 −

b'Hello'

(b) Python Bytearray 数据类型

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

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

Bytearray 数据类型的示例

在下面的示例中，我们通过传递表示字节值的整数可迭代对象来创建 bytearray −

# 从整数可迭代对象创建 bytearray
value = bytearray([72, 101, 108, 108, 111])  
print(value)  

得到的输出如下所示 −

bytearray(b'Hello')

现在，我们通过使用 "UTF-8" 编码对字符串进行编码来创建 bytearray −

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

产生的结果如下 −

bytearray(b'Hello')

(c) Python Memoryview 数据类型

在 Python 中，memoryview 是一个内置对象，它提供了对原始对象内存的视图，通常是支持 buffer protocol 的对象，如 bytearray 和 bytes。它允许您访问原始对象的底层数据而无需复制，从而为大型数据集提供高效的内存访问。

您可以使用多种方法创建 memoryview。这些方法包括使用 memoryview() 构造函数、对 bytes 或 bytearray 对象进行切片、从 array 对象提取，或在使用内置函数如 open() 读取文件时使用。

Memoryview 数据类型的示例

在给定的示例中，我们通过将支持的对象传递给 memoryview() 构造函数直接创建一个 memoryview 对象。支持的对象通常包括 bytearray、bytes 以及其他支持 buffer protocol 的对象 −

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

以上代码的输出如下 −

<memory at 0x00000186FFAA3580>

如果您有一个 array 对象，可以如下所示使用 buffer 接口创建 memoryview −

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

得到的输出如下所示 −

<memory at 0x0000017963CD3580>

您也可以通过切片 bytes 或 bytearray 对象来创建 memoryview −

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

得到的结果如下 −

<memory at 0x00000200D9AA3580>

5. Python Dictionary 数据类型

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

Python dictionary 类似于 Perl 中的关联数组或哈希，由 key:value 对组成。这些键值对用逗号分隔，并放在大括号 {} 内。为了建立键和值之间的映射，在两者之间放置冒号 ':' 符号。

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

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

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

Dictionary 用大括号 ({ }) 包围，可以使用方括号 ([]) 来赋值和访问值。

Dictionary 数据类型的示例

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)          # 打印完整的 dictionary
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 的 dictionary 不是 sequence。它是项的集合，但每个项（键值对）不像 string、list 或 tuple 那样由位置索引标识。因此，无法对 dictionary 执行切片操作。Dictionary 是 mutable 对象，因此可以使用 dict class 中定义的相应功能来执行添加、修改或删除操作。这些操作将在后续章节中解释。

6. Python Set 数据类型

Set 是 Python 对数学中定义的 set 的实现。Python 中的 set 是一种集合，但不像 string、list 或 tuple 那样是索引的或有序的集合。对象在 set 中不能出现多次，而在 List 和 Tuple 中，同一对象可以出现多次。

Set 中的用逗号分隔的项放在大括号或花括号 {} 内。Set 集合中的项可以是不同数据类型。

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

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

Python 的 Set 是内置 set class 的对象，可以使用 type() 函数检查。

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

Set 只能存储 immutable 对象，如数字（int、float、complex 或 bool）、string 或 tuple。如果尝试将 list 或 dictionary 放入 set 集合，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'

Hashing 是计算机科学中一种机制，能够在计算机内存中更快地搜索对象。只有 immutable 对象是 hashable 的。

即使 set 不允许 mutable 项，set 本身是 mutable 的。因此，可以对 set 对象使用内置 set class 中的方法执行添加/删除/更新操作。Python 还提供了一组运算符来执行 set 操作。这些方法和运算符将在后续章节中解释。

Set 的示例

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

print(set1)
print(set2)

这将生成以下输出 −

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

7. Python Boolean 数据类型

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

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

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

Boolean 数据类型的示例

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

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

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

这将产生以下结果 −

true
<class 'bool'>

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

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

# 以下也会打印相同结果
print(a==b)

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

# 因为 a 是空序列，所以返回 False
a = ()
print(bool(a))

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

# 因为 a 是 10，所以返回 True
a = 10
print(bool(a))

这将产生以下结果 −

False
False
False
False
False
True

8. Python None 类型

Python 的 None 类型由 "nonetype" 表示。它是其自身数据类型的对象。nonetype 表示值的空类型或值的缺失。

None 类型的示例

在以下示例中，我们将 None 赋值给变量 x 并打印其类型，结果将是 nonetyoe −

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

x = None

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

这将产生以下结果 −

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

获取数据类型

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

示例

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

# 获取值的类型
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. 基本类型

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

• Integers
• Floats
• Booleans
• Strings

2. 非基本类型

非基本数据类型存储值或值的集合。主要有四种非基本类型，它们是 −

• Lists
• Tuples
• Dictionaries
• Sets

Python 数据类型转换

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

阅读： Python 类型转换

示例

以下示例分别将不同值转换为 integer、floating point 和 string 值 −

print("Conversion to integer data type")  # 转换为 integer 数据类型
a = int(1)     # a 将是 1
b = int(2.2)   # b 将是 2
c = int("3.3")   # c 将是 3

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

print("Conversion to floating point number")  # 转换为浮点数
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("Conversion to string")  # 转换为字符串
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)

这将产生以下结果 −

Conversion to integer data type
1
2
3
Conversion to floating point number
1.0
2.2
3.3
Conversion to string
1
2.2
3.3

数据类型转换函数

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