2.2 Python3 基本数据类型

        在编程世界中，数据类型是构建程序的基础。Python作为一门强大而灵活的编程语言，提供了丰富的数据类型来满足各种编程需求。本文将全面介绍Python3中的基本数据类型，帮助初学者建立扎实的基础，也为有经验的开发者提供复习参考。

目录

一、标准数据类型概览

二、Number（数字）

2.1 类型检查与转换

2.2 数值运算

2.3 del 的用法

三、String（字符串）

3.1 基本操作

3.2 字符串不可变性

3.3 常用方法

四、bool（布尔类型）

4.1 布尔运算

4.2 真值测试

五、List（列表）

5.1 基本操作

5.2 列表方法

5.3 列表推导式

六、Tuple（元组）

6.1 基本操作

6.2 元组特性

七、Set（集合）

7.1 基本操作

7.2 集合方法

八、Dictionary（字典）

8.1 基本操作

8.2 字典方法

8.3 字典推导式

九、bytes类型

9.1 基本操作

数据类型比较

---

一、标准数据类型概览

Python3中常见的数据类型可分为以下几类：

1. 不可变数据类型（3种）：

   • Number（数字）

   • String（字符串）

   • Tuple（元组）

2. 可变数据类型（3种）：

   • List（列表）

   • Dictionary（字典）

   • Set（集合）

3. 其他高级类型：

   • bytes（字节数组）

   • bytearray（可变字节数组）

   • frozenset（不可变集合）等

# 示例：查看数据类型
num = 123
print(type(num))  # 输出：<class 'int'>

---

二、Number（数字）

Python3支持多种数字类型：

• int：整数，如10, -5, 0

• float：浮点数，如3.14, -0.001, 2.0

• bool：布尔值，True或False（实际上是int的子类）

• complex：复数，如1+2j

        内置的 type() 函数可以用来查询变量所指的对象类型。

        此外还可以用 isinstance() 来判断

2.1 类型检查与转换

# 使用type()和isinstance()
x = 5
print(type(x) == int)      # True
print(isinstance(x, int))  # True

# 类型转换
float_num = float(5)      # 5.0
int_num = int(3.9)        # 3 (截断小数部分)

isinstance 和 type 的区别在于：

• isinstance() 和 type() 都是 Python 中用于检查对象类型的函数，但它们有一些重要区别：

• 继承关系处理：

  • isinstance() 会考虑继承关系（子类实例也被认为是父类的实例）

  • type() 只返回对象的确切类型，不考虑继承

• 多类型检查：

  • isinstance() 可以一次检查多个类型

  • type() 只能检查一个确切的类型

class Parent:
    pass

class Child(Parent):
    pass

obj = Child()

# type() 用法
print(type(obj))         # <class '__main__.Child'>
print(type(obj) is Child)  # True
print(type(obj) is Parent) # False

# isinstance() 用法
print(isinstance(obj, Child))  # True
print(isinstance(obj, Parent)) # True (因为 Child 继承自 Parent)
print(isinstance(obj, (Parent, str, int)))  # True 检查是否是其中任意一个类型

           

         Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。

1. bool 是 int 的子类

print(issubclass(bool, int))  # True
print(isinstance(True, int))  # True
print(isinstance(False, int))  # True

• True 和 False 本质上是 int 的子类实例：

  • True 等于 1

  • False 等于 0

2. True 和 False 可以与数字运算

print(True + 1)  # 2 (1 + 1)
print(False * 5)  # 0 (0 * 5)
print(3 - True)   # 2 (3 - 1)

• 它们可以直接参与算术运算，因为 True 是 1，False 是 0。

3. == 比较时 True == 1 和 False == 0

print(True == 1)   # True
print(False == 0)  # True

• 由于 bool 继承自 int，== 比较时会返回 True。

4. 使用 is 判断类型

print(True is 1)   # False
print(False is 0)  # False

• is 检查的是对象的 内存地址，而 True 和 False 是单例对象（singleton），和 1、0 不是同一个对象。

• 因此，is 可以用于严格区分 bool 和 int。

5. 类型转换

print(int(True))   # 1
print(int(False))  # 0
print(float(True))  # 1.0

• bool 可以显式转换为 int 或 float。

6. 特殊情况

print(True + True + True)  # 3 (1 + 1 + 1)
print(False == 0.0)        # True (False == 0, 0 == 0.0)
print(True == 1.0)         # True (True == 1, 1 == 1.0)

• bool 还可以和 float 比较，因为 int 和 float 在数值上是兼容的。

最佳实践：

• 如果需要 严格的类型检查，使用 is 或 type()。

• 如果只是 数值比较，== 是安全的。

• 避免混淆 bool 和 int 的混用，除非逻辑清晰（如 sum([True, False, True]) 返回 2）。

2.2 数值运算

Python支持丰富的数值运算：

# 基本运算
a, b = 10, 3
print(a + b)  # 13
print(a - b)  # 7
print(a * b)  # 30
print(a / b)  # 3.333... (浮点除法)
print(a // b) # 3 (整数除法)
print(a % b)  # 1 (取模)
print(a ** b) # 1000 (幂运算)

2.3 del 的用法

        在 Python 中，del 语句用于删除对象的引用（变量名），而不是直接删除对象本身。Python 的内存管理是基于引用计数的，当对象的引用计数降为 0 时，垃圾回收器（GC）会自动回收该对象的内存。

del 的基本用法

1. 删除变量

x = 10
print(x)  # 10
del x     # 删除变量 x
print(x)  # NameError: name 'x' is not defined

• del x 删除变量 x，使其不再可用。

2. 删除列表/字典元素

lst = [1, 2, 3, 4, 5]
del lst[1]  # 删除索引 1 的元素
print(lst)  # [1, 3, 4, 5]

d = {"a": 1, "b": 2, "c": 3}
del d["b"]  # 删除键 "b" 对应的项
print(d)    # {"a": 1, "c": 3}

• del 可以删除列表中的某个元素或字典中的某个键值对。

3. 删除对象属性

class MyClass:
    def __init__(self):
        self.value = 42

obj = MyClass()
print(obj.value)  # 42
del obj.value     # 删除属性 value
print(obj.value)  # AttributeError: 'MyClass' object has no attribute 'value'

• del 可以删除对象的属性。

4.del 和垃圾回收

del 不会立即释放内存，它只是减少引用计数。只有当对象的引用计数降为 0 时，Python 的垃圾回收机制才会回收内存。

a = [1, 2, 3]  # 引用计数 = 1
b = a          # 引用计数 = 2
del a          # 引用计数 = 1 (b 仍然引用该列表)
print(b)       # [1, 2, 3]

del b          # 引用计数 = 0，列表被回收

• del a 只是删除了变量 a 的引用，列表仍然被 b 引用，所以不会被回收。

• 只有 del b 后，列表的引用计数降为 0，才会被垃圾回收。

5. del vs None

• del 是彻底删除变量，使其不可访问。

• 赋值为 None 只是让变量指向 None，原对象可能仍然存在（如果其他变量引用它）。

x = [1, 2, 3]
y = x
x = None  # x 不再引用列表，但 y 仍然引用
print(y)  # [1, 2, 3]

del y     # 彻底删除 y，列表的引用计数降为 0，被回收

---

三、String（字符串）

字符串是Python中最常用的数据类型之一，用于表示文本信息。

Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：

索引值以 0 为开始值，-1 为从末尾的开始位置。

3.1 基本操作

# 创建字符串
s1 = 'Hello'
s2 = "World"
s3 = '''多行
字符串'''

# 字符串索引和切片
s = "Python"
print(s[0])     # 'P' (正向索引从0开始)
print(s[-1])    # 'n' (负向索引从-1开始)
print(s[1:4])   # 'yth' (切片)
print(s[::2])   # 'Pto' (步长为2)

# 字符串运算
print(s1 + s2)  # 'HelloWorld' (连接)
print(s1 * 3)   # 'HelloHelloHello' (重复)

3.2 字符串不可变性

Python字符串是不可变的，尝试修改会引发错误：

s = "hello"
# s[0] = 'H'  # TypeError: 'str' object does not support item assignment

3.3 常用方法

# 字符串方法
s = " Python "
print(s.strip())      # 'Python' (去除两端空格)
print(s.lower())      # ' python ' (转为小写)
print(s.upper())      # ' PYTHON ' (转为大写)
print(s.replace('P', 'J'))  # ' Jython '
print(s.split())      # ['Python'] (分割)
print(len(s))         # 8 (长度)

---

四、bool（布尔类型）

布尔类型表示逻辑值，只有两个值：True和False。

4.1 布尔运算

# 布尔运算
print(True and False)  # False
print(True or False)   # True
print(not True)        # False

4.2 真值测试

在Python中，以下值被视为False：

• None

• False

• 数值类型的0（0, 0.0, 0j）

• 空序列（'', (), []）

• 空映射（{}）

• 用户定义类的实例，如果类定义了__bool__()或__len__()方法并且返回False或0

其他所有值都被视为True。

# 真值测试示例
print(bool(0))      # False
print(bool(1))      # True
print(bool(""))     # False
print(bool(" "))    # True
print(bool([]))     # False
print(bool([0]))    # True

---

五、List（列表）

列表是Python中最灵活的可变有序集合，可以包含不同类型的元素。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

索引值以 0 为开始值，-1 为从末尾的开始位置

5.1 基本操作

# 创建列表
lst = [1, 'two', 3.0, [4, 5]]

# 索引和切片
print(lst[0])      # 1
print(lst[-1])     # [4, 5]
print(lst[1:3])    # ['two', 3.0]

# 修改列表
lst[0] = 'one'     # 修改元素
lst.append(6)      # 添加元素
lst.extend([7, 8]) # 扩展列表
lst.insert(1, 1.5)  # 插入元素
lst.remove('two')  # 移除元素
del lst[0]         # 删除元素

5.2 列表方法

# 常用列表方法
nums = [3, 1, 4, 1, 5, 9]
nums.sort()            # 排序 [1, 1, 3, 4, 5, 9]
nums.reverse()         # 反转 [9, 5, 4, 3, 1, 1]
print(nums.count(1))   # 2 (计数)
print(nums.index(5))   # 1 (查找索引)
nums_copy = nums.copy() # 浅拷贝
nums.clear()           # 清空列表

5.3 列表推导式

# 列表推导式示例
squares = [x ** 2 for x in range(10)]
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]

print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(even_squares)  # [0, 4, 16, 36, 64]

---

六、Tuple（元组）

元组是不可变的序列，通常用于存储不可修改的数据。

元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同。

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取

6.1 基本操作

# 创建元组
tup = (1, 'two', 3.0)
single_element = (42,)  # 注意逗号
not_a_tuple = (42)  # 不是元组，正常的赋值

# 访问元素
print(tup[0])    # 1
print(tup[1:])   # ('two', 3.0)

# 元组解包
a, b, c = tup
print(b)         # 'two'

6.2 元组特性

# 元组不可变性
# tup[0] = 'one'  # TypeError

# 包含可变元素的元组
mixed = (1, [2, 3], 4)
mixed[1].append(5)  # 可以修改列表元素
print(mixed)       # (1, [2, 3, 5], 4)

---

七、Set（集合）

Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。

另外，也可以使用 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

7.1 基本操作

# 创建集合
s = {1, 2, 3}
empty_set = set()  # 注意不是{}

# 集合运算
a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # 并集 {1, 2, 3, 4, 5}
print(a & b)  # 交集 {3}
print(a - b)  # 差集 {1, 2}
print(a ^ b)  # 对称差集 {1, 2, 4, 5}

7.2 集合方法

s = {1, 2, 3}
s.add(4)       # 添加元素
s.remove(2)    # 移除元素，不存在则报错
s.discard(5)   # 移除元素，不存在不报错
s.pop()        # 随机移除一个元素
s.clear()      # 清空集合

---

八、Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

8.1 基本操作

# 创建字典
d = {'name': 'Alice', 'age': 25}
empty_dict = {}

# 访问元素
print(d['name'])      # 'Alice'
print(d.get('age'))   # 25
print(d.get('email', 'default@example.com'))  # 提供默认值

# 修改字典
d['age'] = 26         # 更新值
d['email'] = 'alice@example.com'  # 添加新键值对
del d['age']          # 删除键值对

8.2 字典方法

# 常用字典方法
keys = d.keys()      # 键视图
values = d.values()  # 值视图
items = d.items()    # 键值对视图

d_copy = d.copy()    # 浅拷贝
d.update({'age': 27, 'city': 'New York'})  # 批量更新
value = d.pop('name')  # 弹出指定键
d.clear()            # 清空字典

8.3 字典推导式

# 字典推导式示例
squares = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

---

九、bytes类型

bytes是不可变的二进制序列，常用于处理二进制数据（byte sequence）。

bytes 类型中的元素是整数值（0 到 255 之间的整数），而不是 Unicode 字符。

bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。在网络编程中，也经常使用 bytes 类型来传输二进制数据。

9.1 基本操作

# 创建bytes对象
b = b'hello'
b_empty = bytes(5)  # 创建长度为5的空bytes
b_from_str = '你好'.encode('utf-8')

# bytes操作
print(b[0])        # 104 (ASCII码)
print(b[:2])       # b'he'
print(b + b' world')  # b'hello world'

---

数据类型比较

特性	List	Tuple	Set	Dictionary
可变性	可变	不可变	可变	可变
有序性	有序	有序	无序	无序(3.7+有序)
元素重复	允许	允许	不允许	键不允许重复
索引访问	支持	支持	不支持	通过键访问
表示符号	[]	()	{}	{key: value}

---