Python有哪些常用的内置数据类型？

冬杰姑娘_1778

发布时间：2025-09-04 18:04:02

1017人浏览过

来源于php中文网

原创

Python常用内置数据类型包括：整数（int）、浮点数（float）、复数（complex）、字符串（str）、列表（list）、元组（tuple）、字典（dict）、集合（set）、布尔值（bool）和空值（None）。这些类型分为可变（如list、dict、set）和不可变（如int、float、str、tuple、bool）两类，选择合适类型能提升代码效率与可维护性。列表用于有序可变序列，元组用于有序不可变序列，字典通过键值对实现高效查找，集合用于去重和成员检测，字符串处理文本且不可变，布尔值支持逻辑判断，None表示空值。理解可变性差异对函数参数传递、字典键使用及并发安全至关重要。高效操作包括列表推导式、字符串f-string格式化、字典get方法与推导式、集合运算等，合理运用可写出简洁高效的Python代码。

python有哪些常用的内置数据类型？

Python内置的数据类型是其强大和灵活的基础，它们是构建任何程序的核心。简单来说，我们日常开发中最常用到的有数字、字符串、列表、元组、字典和集合，以及用于逻辑判断的布尔值和表示“空”的NoneType。理解并熟练运用这些类型，是写出高效、可维护Python代码的第一步。

Python有哪些常用的内置数据类型？

说起Python的内置数据类型，这简直是老生常谈了，但每次深入思考，总能发现一些当初没太在意的小细节。对我个人而言，它们就像是编程世界的乐高积木，不同的形状和颜色，组合起来能搭出千变万化的结构。

首先是数字类型，这个最直观：

立即学习“Python免费学习笔记（深入）”；

整数（
int
）：就是不带小数点的数字，比如
```
10
```
，
```
-5
```
。Python 3 里整数大小是无限的，内存够用就行，这和一些语言的固定位宽还挺不一样。
浮点数（
float
）：带小数点的数字，比如
```
3.14
```
，
```
-0.5
```
。这里有个小坑，浮点数计算可能会有精度问题，这是计算机二进制表示的固有特性，不是Python独有。
复数（
complex
）：由实部和虚部组成，比如
```
1 + 2j
```
。日常开发中可能不常用，但在科学计算领域，它就是常客了。

接着是字符串（

str

），这几乎是所有程序都离不开的：

用单引号、双引号或三引号括起来的文本序列，比如
```
'hello'
```
，
```
"world"
```
，
```
"""多行文本"""
```
。字符串在Python里是不可变的，这意味着你不能直接修改字符串的某个字符，每次操作都会生成新的字符串。这在处理文本时，比如日志分析、用户输入，简直是主力军。

然后是几个核心的集合类型，它们在组织数据上各有千秋：

列表（
list
）：用方括号
```
[]
```
括起来，元素之间用逗号隔开，比如
```
[1, 'hello', 3.14]
```
。列表是有序的，而且是可变的。这意味着你可以随意添加、删除、修改其中的元素。在需要动态管理一组数据时，列表几乎是我的首选。比如记录一系列操作步骤，或者存储从数据库查询出来的多条记录。
```
my_list = [1, 2, 3]
my_list.append(4) # [1, 2, 3, 4]
my_list[0] = 0    # [0, 2, 3, 4]
```
元组（
tuple
）：用圆括号
```
()
```
括起来，比如
```
(1, 'hello', 3.14)
```
。元组和列表很像，但它最大的特点是不可变。一旦创建，就不能修改。这让它在某些场景下比列表更安全，比如作为字典的键（因为字典的键必须是不可变类型），或者在函数返回多个值时，用元组打包返回，能确保返回的数据不会被外部随意篡改。
```
my_tuple = (1, 2, 3)
# my_tuple[0] = 0 # 这会报错！
```
字典（
dict
）：用花括号
```
{}
```
括起来，由键值对组成，比如
```
{'name': 'Alice', 'age': 30}
```
。字典提供了一种通过“键”来快速查找“值”的方式，效率非常高。在处理配置信息、API响应数据、或者任何需要通过唯一标识符访问数据的地方，字典简直是神器。Python 3.7+ 版本开始，字典会保持插入顺序，这在很多时候非常方便。
```
my_dict = {'a': 1, 'b': 2}
print(my_dict['a']) # 输出 1
my_dict['c'] = 3    # 添加新键值对
```
集合（
set
）：也用花括号
```
{}
```
括起来，但只包含元素，没有键值对，比如
```
{1, 2, 3}
```
。集合最大的特点是元素不重复，而且是无序的。当你需要快速去重，或者进行数学上的集合操作（并集、交集、差集）时，集合是最佳选择。
```
my_set = {1, 2, 2, 3}
print(my_set) # 输出 {1, 2, 3}
```

最后，还有两个非常重要的辅助类型：

布尔值（
bool
）：只有
```
True
```
和
```
False
```
两个值。它是逻辑判断的基石，几乎所有条件语句和循环都离不开它。
空值（
NoneType
）：只有一个值
```
None
```
。它表示一个空对象，或者说“什么都没有”。在函数没有明确返回值时，默认返回
```
None
```
；或者在初始化一个变量，但暂时不想给它赋值时，用
```
None
```
也很常见。

Python数据类型在实际开发中如何选择和应用？

在实际项目里，选择合适的数据类型远不止是“哪个能用”那么简单，它直接关系到代码的效率、可读性和维护性。这就像你装修房子，螺丝刀和锤子都能把钉子敲进去，但用锤子显然更高效。

列表 vs. 元组：这是个经典问题。如果你需要一个有序的、元素可以随时增删改的序列，那毫无疑问是列表。比如用户提交的表单数据列表、待处理的任务队列。而当你需要一个有序的、但一旦创建就不能再修改的序列，比如函数返回的多个固定值（经纬度坐标
```
(lat, lon)
```
）、或者作为字典的键（因为字典的键必须是不可变类型），那就用元组。元组的不可变性也意味着它在某些场景下比列表更节省内存，并且可以被哈希（hashable）。
字典 vs. 列表（作为关联数组）：当你需要通过一个唯一的标识符（键）来快速查找对应的数据（值）时，字典是最佳选择。比如存储用户信息
```
{'user_id': '123', 'name': '张三'}
```
，或者解析 JSON 格式的 API 响应。如果只是简单地存储一串有序的、可以通过索引访问的数据，并且这些数据之间没有明显的键值关联，那列表更合适。用列表模拟字典当然可以（比如
```
[['user_id', '123'], ['name', '张三']]
```
），但查找效率会低很多，代码也会更复杂。
集合用于去重和成员测试：如果你的核心需求是确保元素唯一性，或者需要高效地判断某个元素是否存在于一个大的数据集中，那么集合是无敌的。比如从日志文件中提取所有不重复的 IP 地址，或者判断一个用户是否属于某个权限组。集合的查找效率（平均 O(1)）远高于列表（O(n)），对于大数据量尤其明显。
字符串处理：几乎所有涉及文本操作的地方都离不开字符串。从简单的拼接、格式化，到复杂的正则表达式匹配、文本解析，字符串的方法非常丰富。记住字符串的不可变性，这意味着频繁的字符串修改操作（比如在一个循环里反复拼接字符串）可能会创建大量临时字符串对象，导致性能下降。这时，考虑使用
```
str.join()
```
方法或者
```
io.StringIO
```
会更高效。

Python内置数据类型的“可变性”与“不可变性”有什么区别，为何重要？

理解Python数据类型的“可变性”（Mutable）和“不可变性”（Immutable）是掌握Python内存管理和避免一些隐晦 bug 的关键。这不仅仅是理论概念，它直接影响你代码的行为。

Python Pep Authoring

依据官方 python/peps仓库规则起草、审阅、编辑或准备 Python 改进提案（PEP），用于处理 PEP 文本和元数据头部。

下载

什么是可变性？ 一个可变（Mutable）的数据类型，意味着它在创建后，其内部状态（所包含的元素或值）可以被修改，而无需创建新的对象。修改操作会直接作用于原对象。

可变类型包括：
list
（列表）、
dict
（字典）、
set
（集合）。
```
a = [1, 2, 3]
b = a # b和a指向同一个列表对象
b.append(4)
print(a) # 输出 [1, 2, 3, 4]，a也被修改了
```
这里
```
b.append(4)
```
修改的是
```
a
```
和
```
b
```
共同指向的那个列表对象，所以
```
a
```
的值也变了。

什么是不可变性？ 一个不可变（Immutable）的数据类型，意味着它在创建后，其内部状态就不能被修改。任何看似修改它的操作，实际上都会创建一个新的对象。

不可变类型包括：
int
（整数）、
float
（浮点数）、
str
（字符串）、`
tuple
（元组）、
bool
（布尔值）。
```
x = 10
y = x # y和x指向同一个整数对象
y = y + 1 # 实际上是创建了一个新的整数对象11，并让y指向它
print(x) # 输出 10，x的值没有变
```
在这个例子中，
```
y = y + 1
```
并没有修改
```
x
```
所指向的
```
10
```
这个对象，而是创建了一个新的整数对象
```
11
```
，然后让
```
y
```
指向了
```
11
```
。
```
x
```
仍然指向
```
10
```
。

为何重要？

函数参数传递：当可变对象作为函数参数传递时，函数内部对该对象的修改会影响到函数外部的原始对象。这可能是你想要的，也可能是导致难以追踪 bug 的源头。而不可变对象作为参数时，函数内部无法修改外部对象。

def modify_list(l):
    l.append(4)

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list) # [1, 2, 3, 4]

def modify_int(i):
    i = i + 1 # 只是修改了函数内部的局部变量i
    return i

my_int = 10
new_int = modify_int(my_int)
print(my_int) # 10 (不变)
print(new_int) # 11

字典的键（
```
dict
```
keys）和集合的元素（
set
elements）：字典的键和集合的元素必须是不可变类型。这是因为字典和集合的底层实现依赖于元素的哈希值（hash value）来快速查找。如果键或元素是可变的，它们的哈希值可能会改变，导致无法正确查找。因此，列表和字典本身不能作为字典的键或集合的元素，但元组可以（只要元组内部的元素也是不可变的）。
并发编程：在多线程或多进程环境中，可变对象共享可能会引入竞态条件和同步问题，需要额外的锁机制来保护。不可变对象天生就是线程安全的，因为它们不会被修改。
性能：不可变对象在某些情况下可以进行优化，比如字符串的“interning”（字符串驻留），可以节省内存。

如何高效地操作和处理Python的常见数据类型？

掌握了数据类型，下一步就是如何高效地利用它们。Python提供了大量内置方法和语法糖，能让数据处理变得简洁而强大。

列表（
```
list
```
）的高效操作：
- 列表推导式（List Comprehensions）：这是Python处理列表的“杀手锏”。用一行代码就能创建新列表，或者对现有列表进行过滤、转换，效率和可读性都极高。
```
squares = [x**2 for x in range(10) if x % 2 == 0] # [0, 4, 16, 36, 64]
```
- 切片（Slicing）：快速获取子列表，
```
my_list[start:end:step]
```
  。这比循环遍历要快得多。
- append()
  和
  extend()
  ：
```
append()
```
  添加单个元素到列表末尾，
```
extend()
```
  添加另一个可迭代对象的所有元素到列表末尾。
- insert()
  和
  pop()
  /
  remove()
  ：
```
insert(index, element)
```
  在指定位置插入，
```
pop(index)
```
  移除并返回指定位置的元素（默认末尾），
```
remove(value)
```
  移除第一个匹配的元素。
- 排序：
```
list.sort()
```
  会原地修改列表，
```
sorted(list)
```
  返回一个新的已排序列表。
字符串（
```
str
```
）的实用技巧：
- f-string（格式化字符串字面值）：Python 3.6+ 引入，是目前最推荐的字符串格式化方式，简洁、直观、高效。
```
name = "Alice"
age = 30
greeting = f"Hello, {name}. You are {age} years old."
```
- split()
  和
  join()
  ：
```
split()
```
  将字符串按分隔符拆分成列表，
```
join()
```
  将列表中的字符串元素用指定字符连接起来。这是处理文本文件、CSV 数据时最常用的组合。
```
sentence = "Hello world Python"
words = sentence.split() # ['Hello', 'world', 'Python']
new_sentence = "-".join(words) # "Hello-world-Python"
```
- replace()
  ：替换字符串中的子串。
- strip()
  /
  lstrip()
  /
  rstrip()
  ：移除字符串两端（或左、右）的空白字符。
字典（
```
dict
```
）的进阶用法：
- get(key, default_value)
  ：安全地获取字典值。如果键不存在，不会报错，而是返回
```
default_value
```
  （默认为
```
None
```
  ）。这比直接
```
dict[key]
```
  更健壮。
- keys()
  、
  values()
  、
  items()
  ：分别返回字典的所有键、所有值、所有键值对的视图对象。这些视图对象是动态的，反映字典的最新状态。
- 字典推导式（Dictionary Comprehensions）：类似于列表推导式，快速创建或转换字典。
```
data = {'a': 1, 'b': 2}
new_data = {k: v * 2 for k, v in data.items()} # {'a': 2, 'b': 4}
```
- 合并字典：Python 3.9+ 可以使用
```
|
```
  运算符合并字典，更早版本可以使用
```
**
```
  解包运算符。
```
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'a': 4}
merged_dict = dict1 | dict2 # {'a': 4, 'b': 2, 'c': 3} (dict2的'a'覆盖dict1的)
```
集合（
```
set
```
）的集合运算：
- union()
  /
  |
  (并集)：返回两个集合的所有元素。
- intersection()
  /
  &
  (交集)：返回两个集合的共同元素。
- difference()
  /
  -
  (差集)：返回在一个集合中但不在另一个集合中的元素。
- symmetric_difference()
  /
  ^
  (对称差集)：返回在两个集合中，但不同时在两个集合中的元素。