Python - 数据类型

---

---

Python 数据类型

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

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

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

Python 中的数据类型

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

• 数值数据类型
  • int (整数)
  • float (浮点数)
  • complex (复数)
• 字符串数据类型
• 序列数据类型
  • list (列表)
  • tuple (元组)
  • range (范围)
• 二进制数据类型
  • bytes (字节)
  • bytearray (字节数组)
  • memoryview (内存视图)
• 字典数据类型
• 集合数据类型
  • set (集合)
  • frozenset (冻结集合)
• 布尔数据类型
• None 类型

1. Python 数值数据类型

Python 数值数据类型存储数值。当您为其分配值时，会创建数字对象。例如 -

var1 = 1       # int data type
var2 = True    # bool data type
var3 = 10.023  # float data type
var4 = 10+3j   # complex data type

Python 支持四种不同的数值类型，并且它们各自在 Python 库中都有内置类，分别称为 int、bool、float 和 complex -

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

复数由两个部分组成 - **实部** 和 **虚部**。它们由 '+' 或 '-' 符号分隔。虚部后缀为 'j'，表示虚数单位。-1 的平方根（$\sqrt{-1}$）被定义为虚数。Python 中的复数表示为 x+yj，其中 x 是实部，y 是虚部。因此，5+6j 是一个复数。

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

以下是一些数字的例子：

int (整数)	浮点数	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

数值数据类型的示例

以下是一个示例，展示了整数、浮点数和复数的使用方法

# integer variable.
a=100
print("The type of variable having value", a, " is ", type(a))

# float variable.
c=20.345
print("The type of variable having value", c, " is ", type(c))

# complex variable.
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 结束。

加号 (+) 是 Python 中的字符串连接操作符，星号 (*) 是重复操作符。

字符串数据类型的示例

str = 'Hello World!'

print (str)          # Prints complete string
print (str[0])       # Prints first character of the string
print (str[2:5])     # Prints characters starting from 3rd to 5th
print (str[2:])      # Prints string starting from 3rd character
print (str * 2)      # Prints string two times
print (str + "TEST") # Prints concatenated string

这将产生以下结果：

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。加号 (+) 是列表连接操作符，星号 (*) 是重复操作符。

列表数据类型的示例

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

print (list)            # Prints complete list
print (list[0])         # Prints first element of the list
print (list[1:3])       # Prints elements starting from 2nd till 3rd 
print (list[2:])        # Prints elements starting from 3rd element
print (tinylist * 2)    # Prints list two times
print (list + tinylist) # Prints concatenated lists

这将产生以下结果：

['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 元组数据类型

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)

元组数据类型的示例

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

print (tuple)               # Prints the complete tuple
print (tuple[0])            # Prints first element of the tuple
print (tuple[1:3])          # Prints elements of the tuple starting from 2nd till 3rd 
print (tuple[2:])           # Prints elements of the tuple starting from 3rd element
print (tinytuple * 2)       # Prints the contents of the tuple twice
print (tuple + tinytuple)   # Prints concatenated tuples

这将产生以下结果：

('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    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

(c) Python 范围数据类型

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

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

range(start, stop, step)

以下是使用参数的描述：

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

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

• **step**：指定增量的整数（可选，默认值：1）

范围数据类型的示例

以下程序使用 for 循环打印从 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 字节数据类型

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

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

字节数据类型的示例

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

# Using bytes() function to create bytes
b1 = bytes([65, 66, 67, 68, 69])  
print(b1)  

获得的结果如下：

b'ABCDE'

在这里，我们在字符串前使用 "b" 前缀来自动创建一个字节对象：

# Using prefix 'b' to create bytes
b2 = b'Hello'  
print(b2)  

以下是上述代码的输出：

b'Hello'

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

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

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

字节数组数据类型的示例

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

# Creating a bytearray from an iterable of integers
value = bytearray([72, 101, 108, 108, 111])  
print(value)  

获得的输出如下所示：

bytearray(b'Hello')

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

# Creating a bytearray by encoding a string
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!'
# Creating a view of the last part of the data
view = memoryview(data[7:])  
print(view)

获得的结果如下：

<memory at 0x00000200D9AA3580>

5. Python 字典数据类型

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

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

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

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

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

字典用花括号 ({ }) 括起来，可以使用方括号 ([] ) 为值赋值和访问值。

字典数据类型的示例

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

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


print (dict['one'])       # Prints value for 'one' key
print (dict[2])           # Prints value for 2 key
print (tinydict)          # Prints complete dictionary
print (tinydict.keys())   # Prints all the keys
print (tinydict.values()) # Prints all the values

这将产生以下结果：

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

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

6. Python 集合数据类型

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

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

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

请注意，集合中的项目可能不遵循输入的顺序。Python 会优化项目的排列，以便根据数学中定义的集合执行操作。

Python 的集合（Set）是内置 **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 还有一组运算符来执行集合操作。这些方法和运算符将在后面的章节中进行解释。

集合示例

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

print(set1)
print(set2)

这将生成以下输出：

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

7. Python 布尔数据类型

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

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

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

布尔数据类型示例

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

a = True
# display the value of a
print(a)

# display the data type of a
print(type(a))

这将产生以下结果：

true
<class 'bool'>

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

# Returns false as a is not equal to b
a = 2
b = 4
print(bool(a==b))

# Following also prints the same
print(a==b)

# Returns False as a is None
a = None
print(bool(a))

# Returns false as a is an empty sequence
a = ()
print(bool(a))

# Returns false as a is 0
a = 0.0
print(bool(a))

# Returns false as a is 10
a = 10
print(bool(a))

这将产生以下结果：

False
False
False
False
False
True

8. Python None 类型

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

None 类型示例

在以下示例中，我们将 None 赋值给变量 x 并打印其类型，该类型将为 nonetyoe：

# Declaring a variable
# And, assigning a Null value (None)

x = None

# Printing its value and type
print("x = ", x)
print("type of x = ", type(x))

这将产生以下结果：

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

获取数据类型

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

示例

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

# Getting type of values
print(type(123))
print(type(9.99))

# Getting type of variables
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 中，在声明变量或对象时，不需要设置数据类型。数据类型会根据分配的值自动设置。

示例

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

# Declaring a variable
# And, assigning an integer value

x = 10

# Printing its value and type
print("x = ", x)
print("type of x = ", type(x))

# Now, assigning string value to
# the same variable
x = "Hello World!"

# Printing its value and type
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 数据类型之间进行转换，只需使用类型名称作为函数即可。

阅读： Python 类型转换

示例

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

print("Conversion to integer data type")
a = int(1)     # a will be 1
b = int(2.2)   # b will be 2
c = int("3.3")   # c will be 3

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

print("Conversion to floating point number")
a = float(1)     # a will be 1.0
b = float(2.2)   # b will be 2.2
c = float("3.3") # c will be 3.3

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

print("Conversion to string")
a = str(1)     # a will be "1" 
b = str(2.2)   # b will be "2.2"
c = str("3.3") # c will be "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

数据类型转换函数

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