Python 第二课：变量、数据类型与类型转换
课程概述
本节课我们将深入学习 Python 编程中最核心的概念之一——变量（Variables）。变量是存储数据的容器，是所有程序的基础构建块。我们还将全面介绍 Python 的内置数据类型（Built-in Data Types），包括整数（int）、浮点数（float）、字符串（str）、布尔值（bool）、列表（list）、元组（tuple）、字典（dict）和集合（set）。此外，我们还将学习 Python 中的类型转换（Type Conversion）和 f-string 高级格式化技巧。本课程所有内容基于 Python 3.11 标准，涵盖了 Python 3.11 中关于类型系统的新特性和改进。Python 是一门动态类型语言（dynamically typed language），这意味着变量不需要显式声明类型，Python 解释器会根据赋给变量的值自动推断类型。但与此同时，Python 也是一门强类型语言（strongly typed language），不同类型的数据不能随意进行混合运算，必须通过显式的类型转换来实现。
变量详解
变量的基本概念
在 Python 中，变量是用于存储数据值的容器。你可以形象地将变量想象为一个贴有标签的盒子，盒子里存放着数据，而标签就是变量的名字。每次给变量赋值时，变量就会指向新的数据对象。
# 变量的基本赋值
name = "张三" # 字符串变量
age = 25 # 整数变量
height = 1.75 # 浮点数变量
is_student = True # 布尔变量
print(f"姓名：{name}")
print(f"年龄：{age}")
print(f"身高：{height} 米")
print(f"是否学生：{is_student}")
输出：
姓名：张三 年龄：25 身高：1.75 米 是否学生：True变量的命名规则
Python 中的变量名必须遵守以下规则：
- 变量名只能包含字母、数字和下划线（_），不能包含空格或特殊字符。
- 变量名不能以数字开头。
- 变量名不能使用 Python 的保留关键字（keywords）。
- 变量名区分大小写（
name和Name是两个不同的变量）。
# 合法的变量名
my_variable = 10
_private_data = "secret"
camelCase = "驼峰命名"
CONSTANT_VALUE = 100 # 常量习惯用全大写
# Python 3.11 中还可以使用 Unicode 字符作为变量名
姓名 = "李四"
π = 3.14159
# 不合法的变量名（会导致 SyntaxError）
# 2nd_value = 20 # 不能以数字开头
# my-var = 30 # 不能使用连字符
# class = "高级" # 不能使用保留关键字
Python 保留关键字
以下是 Python 3.11 中的所有保留关键字（35个），你不能将它们作为变量名使用：
False None True and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield你可以通过以下代码查看当前的保留关键字列表：
import keyword
print(keyword.kwlist)
print(f"Python 3.11 共有 {len(keyword.kwlist)} 个保留关键字")
变量的多重赋值
Python 支持同时给多个变量赋相同的值，也支持交换两个变量的值：
# 多个变量赋相同值
x = y = z = 0
print(f"x={x}, y={y}, z={z}")
# 多个变量赋不同的值（解包赋值）
a, b, c = 1, 2, 3
print(f"a={a}, b={b}, c={c}")
# 变量值交换（Pythonic 方式，无需临时变量）
p, q = 10, 20
p, q = q, p # 交换 p 和 q 的值
print(f"交换后：p={p}, q={q}")
变量的内存管理
Python 使用引用计数（reference counting）和垃圾回收（garbage collection）机制来管理内存。当你给变量赋一个新值时，Python 会先创建新的对象，然后让变量指向新对象，不再被引用的旧对象会被垃圾回收器自动回收：
a = [1, 2, 3] # 创建列表对象 [1,2,3]，a 指向它
b = a # b 也指向同一个列表对象
print(f"a 的 id：{id(a)}")
print(f"b 的 id：{id(b)}")
print(f"a is b：{a is b}") # True，它们是同一个对象
c = a[:] # 创建列表的副本
print(f"c 的 id：{id(c)}")
print(f"a is c：{a is c}") # False，它们是不同的对象
Python 内置数据类型详解
整数类型（int）
整数是 Python 中最基本的数据类型，用于表示没有小数部分的数值。Python 3 中的整数没有大小限制（受限于可用内存）。Python 3.11 对整数的处理做了多项优化，使得大整数的运算更加高效。
# 整数的各种进制表示
decimal = 42 # 十进制（默认）
binary = 0b101010 # 二进制，以 0b 开头
octal = 0o52 # 八进制，以 0o 开头
hexadecimal = 0x2A # 十六进制，以 0x 开头
print(f"十进制：{decimal}")
print(f"二进制：{binary}")
print(f"八进制：{octal}")
print(f"十六进制：{hexadecimal}")
print(f"二进制 101010 = {binary}") # Python 会自动转换显示
# 进制转换函数
print(f"十进制 42 转二进制：{bin(42)}")
print(f"十进制 42 转八进制：{oct(42)}")
print(f"十进制 42 转十六进制：{hex(42)}")
# 整数计算
big_num = 10**100 # 10 的 100 次方
print(f"10 的 100 次方：{big_num}")
print(f"位数：{len(str(big_num))} 位")
浮点数类型（float）
浮点数用于表示带小数部分的数值，基于 IEEE 754 双精度标准实现。Python 3.11 中的浮点数运算遵循 IEEE 754 标准，并且对一些常见的浮点数运算做了优化：
# 浮点数的基本使用
price = 19.99
temperature = -5.5
scientific = 1.23e-5 # 科学计数法
print(f"价格：{price}")
print(f"温度：{temperature}°C")
print(f"科学计数：{scientific}")
# 浮点数的精度问题
a = 0.1 + 0.2
print(f"0.1 + 0.2 = {a}") # 可能是 0.30000000000000004
print(f"精确比较：{a == 0.3}") # False
# 使用 math 模块处理精度问题
import math
print(f"使用 math.isclose：{math.isclose(a, 0.3)}") # True
# Python 3.11 中浮点数的新表示方法
print(f"3.14 的类型：{type(3.14)}")
print(f"使用下划线分隔的大数字：{1_000_000.5}") # 更易读
字符串类型（str）
字符串是 Python 中用于表示文本数据的数据类型。字符串是不可变的（immutable），这意味着一旦创建，就不能直接修改字符串的内容。Python 3.11 对字符串处理做了大量优化，UTF-8 编码成为默认编码，字符串操作的性能显著提升。
# 字符串的创建
s1 = '单引号字符串'
s2 = "双引号字符串"
s3 = """多行字符串
可以跨越多行"""
s4 = '''也可以使用
三个单引号'''
print(s3)
print(s4)
# 字符串的基本操作
text = "Hello, Python 3.11!"
print(f"长度：{len(text)}")
print(f"首字母大写：{text.capitalize()}")
print(f"全部大写：{text.upper()}")
print(f"全部小写：{text.lower()}")
print(f"是否以 H 开头：{text.startswith('H')}")
print(f"是否以 ! 结尾：{text.endswith('!')}")
# 字符串的切片（Slice）操作
print(f"前5个字符：{text[:5]}") # Hello
print(f"第7到最后：{text[7:]}") # Python 3.11!
print(f"反转字符串：{text[::-1]}") # !111.1 nohtyP ,olleH
布尔类型（bool）
布尔类型只有两个值：True（真）和 False（假）。在 Python 中，布尔类型是整数类型（int）的子类，True 等于整数 1，False 等于整数 0。这一特性在某些场景下非常有用：
# 布尔值的基本使用
is_python_fun = True
is_snake_dangerous = False
print(f"Python 有趣吗？{is_python_fun}")
print(f"蛇危险吗？{is_snake_dangerous}")
# 布尔值与整数的转换
print(f"True 的整数值：{int(True)}")
print(f"False 的整数值：{int(False)}")
print(f"1 的布尔值：{bool(1)}")
print(f"0 的布尔值：{bool(0)}")
# 布尔值在条件判断中的应用
age = 20
is_adult = age >= 18
print(f"{age} 岁是否是成年人：{is_adult}")
# Python 3.11 中布尔运算的特点
print(f"True + True = {True + True}") # 2
print(f"False + False = {False + False}") # 0
列表类型（list）
列表是 Python 中最常用的可变序列（mutable sequence），可以存储任意类型的数据。列表使用方括号 [] 创建，元素之间用逗号分隔。列表是动态数组，支持索引、切片、添加、删除等操作。Python 3.11 对列表操作进行了多项优化，特别是列表的 sort() 方法在处理大规模数据时性能提升显著。
# 列表的创建
fruits = ["苹果", "香蕉", "橙子", "葡萄"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "你好", 3.14, True, None]
empty = []
print(f"水果列表：{fruits}")
print(f"数字列表：{numbers}")
print(f"混合列表：{mixed}")
print(f"空列表：{empty}")
# 列表的索引和切片
print(f"第一个水果：{fruits[0]}")
print(f"最后一个水果：{fruits[-1]}")
print(f"前两个水果：{fruits[:2]}")
print(f"反序列表：{fruits[::-1]}")
# 列表的增删改查
fruits.append("草莓") # 在末尾添加元素
fruits.insert(1, "西瓜") # 在指定位置插入元素
fruits.remove("香蕉") # 移除第一个匹配的元素
popped = fruits.pop() # 移除并返回末尾元素
print(f"修改后列表：{fruits}")
print(f"弹出的元素：{popped}")
元组类型（tuple）
元组与列表非常相似，但元组是不可变的（immutable）。元组使用圆括号 () 创建（也可以不用括号）。由于元组不可变，它们通常用于存储不应该被修改的数据，如日期、坐标等。元组的不可变性也使得它们可以作为字典的键（dict keys）使用。
# 元组的创建
point = (3, 4)
dimensions = (1920, 1080)
date = 2023, 12, 25 # 括号可以省略
single = (42,) # 单元素元组必须加逗号
print(f"坐标点：{point}")
print(f"分辨率：{dimensions}")
print(f"日期：{date}")
print(f"单个元素元组：{single}")
# 元组的解包（Unpacking）
x, y = point
print(f"解包：x={x}, y={y}")
# 使用解包交换变量
a, b = 1, 2
a, b = b, a
print(f"交换后：a={a}, b={b}")
# 命名元组（Named Tuple）- Python 3.11 推荐用法
from collections import namedtuple
Person = namedtuple('Person', ['name', 'age', 'city'])
p1 = Person("张三", 30, "北京")
print(f"命名元组：{p1.name}, {p1.age}, {p1.city}")
字典类型（dict）
字典是 Python 中最强大的内置数据类型之一，用于存储键值对（key-value pairs）。字典使用大括号 {} 创建，键值对之间用冒号 : 分隔。字典的键必须是可哈希的（hashable），即不可变类型；值可以是任意类型。Python 3.11 对字典操作做了大量优化，内存使用效率提升了约 20-25%。
# 字典的创建
student = {
"name": "张三",
"age": 20,
"major": "计算机科学",
"gpa": 3.8
}
print(f"学生信息：{student}")
print(f"学生姓名：{student['name']}")
# 使用 dict() 构造函数创建字典
pairs = [("a", 1), ("b", 2), ("c", 3)]
d = dict(pairs)
print(f"从键值对列表创建：{d}")
# 使用关键字参数创建（Python 3.11 新特性，支持更简洁的语法）
config = dict(
host="localhost",
port=8080,
debug=True
)
print(f"配置字典：{config}")
# 字典的方法
print(f"所有键：{list(student.keys())}")
print(f"所有值：{list(student.values())}")
print(f"所有键值对：{list(student.items())}")
print(f"是否存在 'name' 键：{'name' in student}")
集合类型（set）
集合是无序的、不重复的元素集。集合使用大括号 {} 创建（但不同于字典，集合只有元素没有键值对）。集合的主要用途包括去重、成员测试和数学集合运算（交集、并集、差集等）。
# 集合的创建
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}
print(f"集合1：{s1}")
print(f"集合2：{s2}")
# 集合的去重功能
numbers_with_dup = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_numbers = set(numbers_with_dup)
print(f"去重：{unique_numbers}")
# 集合运算
print(f"交集：{s1 & s2}") # {4, 5}
print(f"并集：{s1 | s2}") # {1, 2, 3, 4, 5, 6, 7, 8}
print(f"差集：{s1 - s2}") # {1, 2, 3}
print(f"对称差集：{s1 ^ s2}") # {1, 2, 3, 6, 7, 8}
# Python 3.11 中集合的新方法
s1.add(10) # 添加元素
s1.discard(1) # 移除元素（不存在不报错）
s1.remove(2) # 移除元素（不存在则 KeyError）
print(f"添加 10 后：{s1}")
类型转换详解
Python 是一门强类型语言，不同类型的数据不能直接混合运算。因此，我们需要显式地进行类型转换。
隐式类型转换（自动转换）
Python 在某些情况下会自动进行类型转换，例如在混合整数和浮点数的运算中：
# 整数自动转换为浮点数
result = 10 + 3.14
print(f"10 + 3.14 = {result}")
print(f"结果类型：{type(result)}") # <class 'float'>
# 布尔值自动转换为整数
result2 = True + 5
print(f"True + 5 = {result2}") # 6
# 小整数复用（Python 3.11 的优化）
a = 256
b = 256
print(f"256 is 256: {a is b}") # True（Python 缓存了 -5 到 256 的整数）
显式类型转换（强制转换）
Python 提供了多个内置函数来进行显式类型转换：
# int() - 转换为整数
print(f"int(3.7) = {int(3.7)}") # 3（截断，不是四舍五入）
print(f"int('42') = {int('42')}") # 42
print(f"int('1010', 2) = {int('1010', 2)}") # 10（二进制转十进制）
print(f"int('FF', 16) = {int('FF', 16)}") # 255（十六进制转十进制）
# float() - 转换为浮点数
print(f"float(10) = {float(10)}") # 10.0
print(f"float('3.14') = {float('3.14')}") # 3.14
print(f"float('1e-5') = {float('1e-5')}") # 1e-05
# str() - 转换为字符串
print(f"str(42) = {str(42)}")
print(f"str(3.14) = {str(3.14)}")
print(f"str([1,2,3]) = {str([1,2,3])}")
# bool() - 转换为布尔值
print(f"bool(0) = {bool(0)}") # False
print(f"bool(1) = {bool(1)}") # True
print(f"bool('') = {bool('')}") # False（空字符串）
print(f"bool(' ') = {bool(' ')}") # True（空格字符串）
print(f"bool(None) = {bool(None)}") # False
print(f"bool([]) = {bool([])}") # False（空列表）
print(f"bool([0]) = {bool([0])}") # True（非空列表）
列表、元组、集合之间的转换
# 各种序列类型之间的转换
original = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
to_tuple = tuple(original)
print(f"列表转元组：{to_tuple}")
to_set = set(original)
print(f"列表转集合（自动去重）：{to_set}")
to_list = list(to_set)
print(f"集合转列表：{to_list}")
# 使用列表推导式进行复杂转换
squares = [x**2 for x in range(1, 11)]
print(f"1-10 的平方列表：{squares}")
even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(f"1-10 偶数的平方：{even_squares}")
字符串与其他类型的转换
# 字符串到数字的转换
num_str = "123"
print(f"int('{num_str}') + 10 = {int(num_str) + 10}")
# 使用 map() 进行批量转换
str_numbers = ["1", "2", "3", "4", "5"]
int_numbers = list(map(int, str_numbers))
print(f"批量转换：{int_numbers}")
# 使用 split() 和 map() 读取输入
user_input = "10 20 30 40 50"
numbers = list(map(int, user_input.split()))
print(f"解析输入：{numbers}, 和={sum(numbers)}")
# 格式化数字（千位分隔符）
big_num = 1234567890
print(f"带千位分隔符：{big_num:,}")
print(f"科学计数法：{big_num:.2e}")
字典的键和值的类型转换
# 将两个列表转换为字典
keys = ["name", "age", "city"]
values = ["张三", 25, "北京"]
data_dict = dict(zip(keys, values))
print(f"合并为字典：{data_dict}")
# 字典键值角色互换（值必须可哈希且唯一）
original = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in original.items()}
print(f"键值互换：{inverted}")
Python 3.11 中的类型提示（Type Hints）
Python 3.11 引入了对类型系统的重要改进，类型提示现在更加简洁和强大。类型提示不会影响程序运行时的行为，但可以与 IDE、类型检查器（如 mypy）配合使用，提供更好的开发体验。
基本类型提示
# Python 3.11 之前的类型提示
def greet(name: str) -> str:
return f"Hello, {name}"
# Python 3.11 新增的 Self 类型支持
from typing import Self
class Builder:
def set_name(self, name: str) -> Self:
self.name = name
return self
# Python 3.11 中可以使用变量注解类型
x: int = 10
y: float = 3.14
name: str = "Python"
is_active: bool = True
items: list[int] = [1, 2, 3] # Python 3.9+
coordinates: tuple[int, int] = (10, 20)
config: dict[str, str] = {"host": "localhost"}
联合类型与可选类型
from typing import Union, Optional
# Union 表示多种可能的类型
def process_value(value: Union[int, float, str]) -> str:
return str(value)
# Optional 等价于 Union[X, None]
def find_user(user_id: int) -> Optional[str]:
if user_id > 0:
return "张三"
return None
# Python 3.10+ 引入了更简洁的 union 语法
def process(value: int | float | str) -> str:
return str(value)
运行时类型检查
# 使用 assert 进行运行时类型检查
def add_numbers(a: int, b: int) -> int:
assert isinstance(a, int) and isinstance(b, int), "参数必须是整数"
return a + b
# Python 3.11 中的类型自省改进
from typing import get_type_hints
def greet(name: str, times: int = 1) -> str:
return (f"Hello, {name}! " * times).strip()
hints = get_type_hints(greet)
print(f"类型提示：{hints}")
f-string 高级格式化
数值格式化
# 固定小数位数
pi = 3.141592653589793
print(f"π 保留 2 位：{pi:.2f}")
print(f"π 保留 4 位：{pi:.4f}")
# 百分数格式化
ratio = 0.256789
print(f"百分比：{ratio:.2%}")
print(f"百分比（无小数）：{ratio:.0%}")
# 货币格式化
price = 1234.56
print(f"价格：${price:,.2f}")
print(f"人民币：¥{price:,.2f}")
# 零填充
num = 42
print(f"零填充到 5 位：{num:05d}")
print(f"二进制：{num:08b}")
print(f"十六进制：{num:08X}")
条件表达式在 f-string 中的应用
score = 85
grade = "A" if score >= 90 else "B" if score >= 80 else "C" if score >= 70 else "D"
print(f"成绩 {score} 分，等级：{grade}")
# Python 3.11 中更清晰的多条件表达
def get_grade(score: int) -> str:
return (
"A+" if score >= 95 else
"A" if score >= 90 else
"B+" if score >= 85 else
"B" if score >= 80 else
"C" if score >= 70 else
"D"
)
print(f"分数 87 分 = {get_grade(87)}")
综合练习题
练习一：个人资料管理系统
"""
个人资料管理系统
练习变量、数据类型和 f-string 格式化
"""
# 基本信息
name = "李明"
age = 28
height = 1.78
weight = 70.5
is_employed = True
skills = ["Python", "JavaScript", "SQL", "Git"]
contact = {
"email": "liming@example.com",
"phone": "138-0013-8000",
"city": "上海"
}
# 使用 f-string 输出个人资料卡
print("=" * 50)
print(f" 个 人 资 料 卡")
print("=" * 50)
print(f"姓名：{name}")
print(f"年龄：{age} 岁")
print(f"身高：{height} 米")
print(f"体重：{weight} 公斤")
print(f"BMI：{weight / height**2:.2f}")
print(f"在职状态：{'是' if is_employed else '否'}")
print("-" * 50)
print("技能清单：")
for i, skill in enumerate(skills, 1):
print(f" {i}. {skill}")
print("-" * 50)
print("联系方式：")
print(f" 邮箱：{contact['email']}")
print(f" 电话：{contact['phone']}")
print(f" 城市：{contact['city']}")
print("=" * 50)
练习二：温度单位转换器
"""
温度单位转换器
练习类型转换和格式化输出
"""
def celsius_to_fahrenheit(c: float) -> float:
"""将摄氏度转换为华氏度"""
return c * 9/5 + 32
def celsius_to_kelvin(c: float) -> float:
"""将摄氏度转换为开尔文"""
return c + 273.15
def fahrenheit_to_celsius(f: float) -> float:
"""将华氏度转换为摄氏度"""
return (f - 32) * 5/9
# 测试各种温度值
temps_c = [-40, 0, 20, 37, 100]
print("=" * 60)
print(f"{'°C':>8} | {'°F':>8} | {'K':>10} | {'状态':>15}")
print("-" * 60)
for c in temps_c:
f = celsius_to_fahrenheit(c)
k = celsius_to_kelvin(c)
if c <= 0:
status = "结冰 ❄️"
elif c < 100:
status = "液态 💧"
else:
status = "气态 🔥"
print(f"{c:>8.1f} | {f:>8.1f} | {k:>10.2f} | {status:>15}")
print("=" * 60)
练习三：购物车计算器
"""
购物车计算器
练习列表、字典、类型转换和格式化
"""
# 购物车中的商品
cart = [
{"name": "Python 入门书籍", "price": 89.00, "quantity": 1},
{"name": "机械键盘", "price": 299.00, "quantity": 1},
{"name": "鼠标垫", "price": 29.90, "quantity": 2},
{"name": "耳机", "price": 159.00, "quantity": 1},
]
# 计算总价和商品数量
total_items = sum(item["quantity"] for item in cart)
subtotal = sum(item["price"] * item["quantity"] for item in cart)
discount = subtotal * 0.1 if subtotal > 500 else 0 # 满500打9折
tax = (subtotal - discount) * 0.13 # 13% 税
total = subtotal - discount + tax
# 输出购物小票
print("=" * 60)
print(" 购 物 小 票")
print("=" * 60)
print(f"{'商品名称':<20} {'单价':>10} {'数量':>5} {'小计':>10}")
print("-" * 60)
for item in cart:
subtotal_item = item["price"] * item["quantity"]
print(f"{item['name']:<20} ¥{item['price']:>8.2f} {item['quantity']:>5} ¥{subtotal_item:>9.2f}")
print("-" * 60)
print(f"{'商品总数：':<20}{total_items:>30}")
print(f"{'小计：':<20}¥{subtotal:>29.2f}")
if discount > 0:
print(f"{'折扣（9折）：':<20}¥{-discount:>29.2f}")
print(f"{'税额（13%）：':<20}¥{tax:>29.2f}")
print("=" * 60)
print(f"{'应付总额：':<20}¥{total:>29.2f}")
print("=" * 60)
Python 3.11 类型系统的新特性
类型别名
# Python 3.11 中的类型别名
from typing import TypeAlias
Vector: TypeAlias = list[float]
Matrix: TypeAlias = list[list[float]]
def scale_vector(v: Vector, scalar: float) -> Vector:
return [x * scalar for x in v]
def multiply_matrices(a: Matrix, b: Matrix) -> Matrix:
# 矩阵乘法简化实现
result = [[0.0] * len(b[0]) for _ in range(len(a))]
for i in range(len(a)):
for j in range(len(b[0])):
for k in range(len(b)):
result[i][j] += a[i][k] * b[k][j]
return result
TypeGuard（类型守卫）
from typing import TypeGuard
def is_str_list(val: list[object]) -> TypeGuard[list[str]]:
"""检查列表是否全是字符串"""
return all(isinstance(x, str) for x in val)
data: list[object] = ["a", "b", "c"]
if is_str_list(data):
# 在这个分支中，mypy 知道 data 是 list[str]
print(f"全部是字符串，长度：{len(data)}")
常见错误与调试
错误一：TypeError 类型不匹配
# 错误示例
age = 25
print("年龄：" + age) # TypeError: can only concatenate str
# 正确做法
print(f"年龄：{age}")
print("年龄：" + str(age))
错误二：KeyError 字典键不存在
config = {"host": "localhost", "port": 8080}
# print(config["username"]) # KeyError: 'username'
# 安全访问方式
print(config.get("username", "未设置")) # 输出：未设置
错误三：IndexError 列表索引越界
items = ["a", "b", "c"]
# print(items[5]) # IndexError: list index out of range
# 安全访问方式
print(items[5] if len(items) > 5 else "索引超出范围")
本章小结
今天我们学习了以下核心内容：
- 变量：Python 变量的命名规则、多重赋值、内存管理机制。
- 数据类型：整数、浮点数、字符串、布尔值、列表、元组、字典、集合的详细介绍。
- 类型转换：隐式转换和显式转换，各种数据类型之间的转换方法。
- f-string 高级格式化：数值格式化、条件表达式、字典和列表在 f-string 中的使用。
- Python 3.11 类型提示：类型别名、TypeGuard、类型守卫等新特性。
下一节课我们将学习 Python 的运算符、运算符优先级以及 Python 3.8 引入的 walrus operator（海象运算符），敬请期待！