Python 数据类型

学习目标

掌握 Python 八大内置数据类型的分类与特性
理解每种数据类型的创建方式、访问方法及典型应用场景
区分可变与不可变对象的本质差异
学会使用 type() 判断数据类型，并理解“一切皆对象”的设计哲学
掌握布尔上下文中的真值（Truthy）与假值（Falsy）判断规则

数据类型概述

在 Python 中，所有数据都是对象，每种数据类型对应一个类（class），变量则是该类的实例。Python 提供了丰富的内置数据类型，主要分为以下几类：

类型大类	具体类型
数值类型	`int`, `float`, `complex`
序列类型	`str`, `list`, `tuple`
映射类型	`dict`
集合类型	`set`, `frozenset`
布尔类型	`bool`
二进制类型	`bytes`, `bytearray`, `memoryview`

示例：变量可动态改变类型

x = 50               # int
x = 60.5             # float
x = "Hello World"    # str
x = ["code", "for", "life"]  # list
x = ("code", "for", "life")  # tuple

每次赋值后，x 引用新对象，类型随之改变。

数值类型

用于表示数字数据。

1. 整数（`int`）

表示正负整数，无大小限制（受限于内存）
支持二进制（0b）、八进制（0o）、十六进制（0x）字面量

a = 42
b = -100
c = 0b1010      # 二进制 → 10
d = 0xFF        # 十六进制 → 255
print(type(a))  # <class 'int'>

2. 浮点数（`float`）

表示带小数点的实数
支持科学计数法（e 或 E）

b = 3.14
c = -2.5e3      # -2500.0
print(type(b))  # <class 'float'>

3. 复数（`complex`）

形式为 real + imag j
实部和虚部均为浮点数

c = 2 + 3j
print(c.real)   # 2.0
print(c.imag)   # 3.0
print(type(c))  # <class 'complex'>

序列类型

有序集合，支持索引和切片。

1. 字符串（`str`）

Unicode 字符序列，不可变
可用单引号 ' '、双引号 " " 或三引号 ''' ''' 创建

s = "Welcome to the Code World"
print(s[1])    # 'e'
print(s[-1])   # 'd'（末尾字符）
print(type(s)) # <class 'str'>

注意：Python 没有单独的“字符”类型，单个字符也是长度为 1 的字符串。

2. 列表（`list`）

有序、可变、允许重复
元素可为不同类型
使用方括号 [] 创建

# 创建列表
a = [1, 2, 3]
b = ["Code", "For", "Life", 42]

# 访问元素（支持负索引）
print(a[0])    # 1
print(b[-1])   # 42
print(b[-3])   # "For"

3. 元组（`tuple`）

有序、不可变、允许重复
使用逗号分隔，可用圆括号 () 包裹（非必需）
单元素元组需加尾随逗号：(x,)

# 创建元组
tup1 = ()                     # 空元组
tup2 = ('Code', 'For')        # 标准写法
tup3 = 'Code', 'For'          # 元组打包（Tuple Packing）
tup4 = (42,)                  # 单元素元组（注意逗号！）

# 访问元素
print(tup2[0])   # 'Code'
print(tup2[-1])  # 'For'

优势：因不可变性，元组可作为字典键或集合元素；性能略优于列表。

布尔类型（`bool`）

仅有两个值：True 和 False，属于 int 的子类。

print(type(True))   # <class 'bool'>
print(issubclass(bool, int))  # True

真值与假值

在条件判断中，非布尔值也会被隐式转换为布尔值：

假值（Falsy）	真值（Truthy）
`None`	非空容器（如 `[1]`, `"a"`）
`False`	非零数字（如 `1`, `-3.14`）
数值 `0`（含 `0.0`）	自定义对象（默认为真）
空容器（`[]`, `{}`）

if 1:
    print("1 是真值")      # 执行

if not []:
    print("空列表是假值")   # 执行

注意：true（小写）不是关键字，会引发 NameError。

集合类型

无序、不重复的元素集合。

1. 可变集合（`set`）

使用 set() 或 {}（但 {} 创建的是字典！）
元素必须可哈希（不可变）

# 创建集合
s1 = set("CodeForLife")           # {'C', 'o', 'd', 'e', 'F', 'r', 'L', 'i'}
s2 = set(["Code", "For", "Code"]) # {'Code', 'For'}（自动去重）

# 遍历与成员检测
for item in s2:
    print(item, end=" ")  # 输出顺序不确定

print("Code" in s2)       # True

空集合必须用 set() 创建，{} 是空字典。

2. 不可变集合（`frozenset`）

创建后不可修改
可作为字典键或集合元素

fs = frozenset([1, 2, 3])

映射类型：字典（`dict`）

以键值对（key: value） 形式存储数据，键必须唯一且可哈希。

创建字典

# 字面量方式
d = {1: 'Code', 'name': 'For', 3: 'Life'}

# 构造函数方式
d1 = dict({1: 'Code', 2: 'For'})
d2 = dict(name='Code', age=30)  # 关键字参数形式

访问值

# 通过键访问
print(d['name'])        # 'For'

# 使用 get() 方法（更安全）
print(d.get(3))         # 'Life'
print(d.get('missing', 'Not Found'))  # 'Not Found'（默认值）

键区分大小写：'Name' 与 'name' 是不同键。

可变性对比

类型	可变性	示例
`list`	✅ 可变	`a[0] = 10`
`dict`	✅ 可变	`d['key'] = 'new'`
`set`	✅ 可变	`s.add(5)`
`str`	❌ 不可变	尝试 `s[0] = 'x'` 报错
`tuple`	❌ 不可变
`frozenset`	❌ 不可变
数值 / 布尔	❌ 不可变

不可变对象在内存中一旦创建，其内容无法更改；重新赋值会创建新对象。

类型检查与转换

检查类型

x = [1, 2, 3]
print(type(x))        # <class 'list'>
print(isinstance(x, list))  # True

类型转换（部分可行）

# 列表 ↔ 元组
lst = [1, 2, 3]
tup = tuple(lst)
lst2 = list(tup)

# 字符串 ↔ 列表
s = "abc"
chars = list(s)       # ['a', 'b', 'c']
s2 = ''.join(chars)   # "abc"

# 集合 ↔ 列表
s = set([1, 2, 2])    # {1, 2}
lst = list(s)

并非所有类型都能互相转换（如 dict 不能直接转为 list）。

重点总结

Python 数据类型丰富，涵盖数值、序列、映射、集合等结构。
可变 vs 不可变是核心概念，影响对象行为与内存管理。
字符串、元组、数值等为不可变类型；列表、字典、集合为可变类型。
布尔值 True/False 在条件判断中具有特殊语义，理解真值 / 假值规则至关重要。
字典以键值对存储数据，键必须唯一且不可变；集合自动去重且无序。
所有数据都是对象，可通过 type() 和 isinstance() 进行类型检查。

思考题

为什么元组 (1) 不是单元素元组？如何正确创建包含一个整数 1 的元组？
执行以下代码后，a 和 b 的值分别是什么？为什么？
```
a = [1, 2, 3]
b = a
a.append(4)
```
如何将字符串 "123" 安全地转换为整数？如果字符串可能是 "abc"，如何避免程序崩溃？

源本科技 | 码上会

学习目标

数据类型概述

数值类型

1. 整数（int）

2. 浮点数（float）

3. 复数（complex）