一、注释、标识符与字面量
注释
注释的作用是给人看，不会作为真正要执行的程序语句参与运行。刚入门时，先分清两种最常见的写法：
#开头的是单行注释，适合给某一行代码做简短说明''' ... '''或""" ... """包起来的内容常被当作多行注释使用，更准确地说它本质上是多行字符串；如果只是为了说明代码，也可以这样写
# 这是单行注释
"""
这是多行字符串。
如果它只是用来解释代码，也常被当作多行注释使用。
"""
标识符
标识符可以理解成“程序里名字的统称”，变量名、函数名、模块名，本质上都属于标识符。
先记住 Python 标识符的硬规则：
- 只能由字母、数字、下划线组成
- 不能以数字开头
- 严格区分大小写，例如
name和Name不是同一个名字 - 不能使用 Python 关键字作为名字，例如
if、class、for
例如下面这些写法里，前两个合法，后两个不合法：
user_name = "alex"
age2 = 18
# 2name = "tom" # 不能以数字开头
# class = "vip" # 不能使用关键字
除了“能不能用”，还建议尽量这样写：
- 变量名优先使用小写加下划线，例如
user_name - 常量名通常使用全大写，例如
MAX_RETRY - 文件名不要和标准库模块重名，例如不要把脚本起名为
random.py
字面量与常量
字面量，就是代码里直接写出来的值；常见的常量写法，则是把那些“通常不希望被随意修改”的值，用全大写名字保存起来。
先看最直观的字面量例子：
18
3.14
True
"hello"
None
这些直接写在代码里的值，都属于字面量。
再看常量的常见写法：
PI = 3.14159
MAX_RETRY = 3
DEFAULT_PORT = 8000
要注意一点：Python 并没有像有些语言那样提供“绝对不可修改”的常量语法。所谓常量，更多是一种命名约定，告诉自己和别人“这个值通常不要改”。
二、变量、数据类型与类型转换
可以把变量理解成存放数据的名字，或者说“程序里一个可引用的数据容器”。
- 变量用来保存程序运行过程中的数据
- 这些数据通常只在程序运行期间保存在内存里，可以把它理解成“临时保存”
- 变量里保存的值在程序执行期间可以变化
- 变量名的意义是让你后续还能再次引用这份数据
最常见的定义方式就是：
name = "Tom"
age = 19
price = 5.5
这里的 = 不是“数学里的相等”，而是赋值，表示把右边的值绑定给左边的变量名。
数据类型
age = 18 # int：整数，常用于计数、索引、状态值
price = 9.9 # float：浮点数，常用于测量值、价格、比例
is_admin = False # bool：布尔值，常用于条件判断
name = "alex" # str：字符串，表示文本内容
nickname = None # NoneType：表示没有值，或当前暂时缺省
scores = [90, 85, 92] # list：有序、可修改的数据集合
point = (10, 20) # tuple：有序、通常不修改的数据组合
user = {"name": "alex", "age": 18} # dict：键值映射
tags = {"python", "web", "async"} # set：自动去重，适合集合运算
查看数据类型
a = 18
print(type(a)) #<class 'int'>
print(type("python")) #<class 'str'>
print(type([1, 2, 3])) #<class 'list'>
print(type({"name": "alex"})) #<class 'dict'>
类型转换：
age_text = "18"
age = int(age_text)
ratio = float("3.5")
message = str(100)
print(age, ratio, message) #18 3.5 100
认识类型提示
从 Python 3 开始，变量后面也可以顺手写上“这个值大概是什么类型”：
name: str = "alex"
age: int = 18
scores: list[int] = [90, 85, 92]
这类写法叫类型提示，主要是给人和编辑器看的，用来说明数据形状，本身不会把 Python 变成强类型语言。
可以先记住两点：
name: str表示“这个变量通常应该是字符串”list[int]表示“这是一个列表，里面的元素通常是整数”
这里先认识这种写法就够了。更完整的函数参数、返回值、str | None 和 mypy，放到下一篇《Python 函数与模块》统一讲。
三、输入输出与运算符
输出函数
输出函数 print()，把结果显示到屏幕上。可以输出变量、输出表达式、输出调试信息。
age = 18
print("明年年龄：", age + 1) # 明年年龄： 19
print() 也常配合 sep 和 end 使用：
sep：多个输出项之间的分隔符end：本次输出结束时追加的结尾字符，默认是换行
print("Sun", "Mon", "Tue", sep=", ", end=";\n") # Sun, Mon, Tue;
print("Wed", "Thu") # Wed Thu
格式化输出通常优先用 f-string：
goods_name = "胡萝卜"
goods_price = 5.5
print(f"今天蔬菜特价了，{goods_name}只要{goods_price:.2f}元/斤！")
# 今天蔬菜特价了，胡萝卜只要5.50元/斤！
其中 {goods_price:.2f} 表示保留 2 位小数。
输入函数
Python 最常见的输入函数是 input()，它会暂停程序，等待用户输入内容。
注意：
input()接收到的结果默认是字符串。
age_text = input("请输入年龄：")
age = int(age_text)
print(age)
print(age + 1)
如果不做类型转换，很多数值计算都会得到错误结果，或者直接报错。
运算符
a = 9
b = 4
print(a + b) # 13，加法
print(a - b) # 5，减法
print(a * b) # 36，乘法
print(a / b) # 2.25，除法，结果通常是浮点数
print(a // b) # 2，整除
print(a % b) # 1，取模
print(a ** b) # 6561，幂运算
比较运算符和逻辑运算符：
- 比较运算符：
==、!=、>、<、>=、<= - 逻辑运算符：
and、or、not
age = 20
has_ticket = True
print(age >= 18) # True
print(age < 18) # False
print(age >= 18 and has_ticket) # True
print(not has_ticket) # False
四、字符串与切片
切片是 Python 非常高频的能力，几乎所有序列类型都能用。
text = "python-note"
#[开始:结束:步长]
print(text[0:3]) # 取索引 0 到 2
print(text[:]) # 整体复制
print(text[6:]) # 从索引 6 到结尾
print(text[:-3]) # 去掉最后 3 个字符
print(text[-1]) # 最后一个字符
print(text[::-1]) # 反转字符串
常见字符串方法：
raw = " Alex Li "
print(raw.strip()) # 去掉首尾空白字符
print(raw.lower()) # 转换为全小写
print(raw.upper()) # 转换为全大写
print(raw.replace("Li", "Wang")) # 替换子字符串
print(raw.startswith(" Al")) # 判断是否以指定内容开头
print(raw.endswith(" ")) # 判断是否以指定内容结尾
print(raw.find("Li")) # 查找子字符串第一次出现的位置，找不到返回 -1
print(raw.count(" ")) # 统计子字符串出现次数
print("2026-06-20".split("-")) # 以 "-" 为分隔符拆分字符串为列表
print("-".join(["2026", "06", "20"])) # 使用 "-" 将列表元素连接成字符串
五、条件判断与循环
条件判断里的真值规则
Python 不只 True / False 能参与条件判断。很多对象在 if 里也会被转换成真值。
print(bool(1)) # True
print(bool(0)) # False
print(bool("hi")) # True
print(bool("")) # False
print(bool([1, 2])) # True
print(bool([])) # False
print(bool(None)) # False
- 常见假值有：
0、0.0、""、[]、{}、set()、None - 其他大多数对象在条件里都视为真
if / elif / else
if 语句用来做条件判断。可以先把它理解成一句话：
- 条件成立，就执行这一段代码
- 条件不成立，就跳过或执行另一段代码
选择结构的 3 种常见形式
1. 单分支 if
age = 19
if age >= 18:
print("已满 18 岁，可以上网")
这种写法适合“满足条件才执行，不满足就什么都不做”的情况。
2. 双分支 if ... else
age = 16
if age >= 18:
print("已满 18 岁，可以上网")
else:
print("未满 18 岁，不可以上网")
这种写法适合“二选一”的场景。
3. 多分支 if ... elif ... else
score = 87
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 60:
print("及格")
else:
print("不及格")
if 嵌套
当一个条件块内部还要继续判断时，就会出现嵌套结构：
username = "root"
is_vip = True
if username == "root":
if is_vip:
print("管理员且是会员")
while 循环
target_age = 56
count = 0
# 循环条件：尝试次数小于 3
while count < 3:
guess_age = int(input("guess age: "))
if guess_age == target_age:
print("yes, you got it")
break # 猜对时跳出循环
elif guess_age > target_age:
print("think smaller...")
else:
print("think bigger...")
count += 1
else:
# 当 while 循环正常结束（没有被 break 打断）时执行
print("you have tried too many times")
for 循环
for 循环最适合做“遍历一个容器里的每一项”。
的基本语法：
for 变量 in 可迭代对象:
重复执行的代码
常见的“可迭代对象”：字符串/列表/元组/字典/集合/range()
# range(0, 10, 2) 表示从 0 到 9，步长为 2。
for number in range(0, 10, 2):
print(number)
可以直接遍历容器：
for name in ["tom", "rose", "alex"]:
print(name)
break 和 continue
break：立刻结束当前整个循环continue：跳过本次循环，直接进入下一次循环
break 示例：
for index in range(1, 6):
if index == 4:
print("已经吃饱了，后面的苹果不吃了")
break
print(f"正在吃第{index}个苹果")
continue 示例：
for index in range(1, 6):
if index == 3:
print("不好，有大虫，这个苹果不吃了")
continue
print(f"正在吃第{index}个苹果")
六、列表、元组、字典、集合
列表 list
列表最适合存放一组有顺序、可重复、可修改的数据。
number_list = [1, 3, 5, 7, 9]
mixed_list = ["tom", 18, True, 9.9]
列表的增删改查
- 查：通过索引读取元素
- 增：使用
append()、insert()添加元素 - 改：通过索引直接重新赋值
- 删：使用
del、pop()、remove()删除元素
number_list = [1, 3, 5, 7, 9]
names = ["tom", "rose", "alex", "rose"]
# 查：访问索引位置上的元素
second_num = number_list[1]
print(second_num) # 3
# 增：在末尾追加
number_list.append(11)
# 增：在指定位置插入
number_list.insert(2, 99)
# 改：修改索引位置上的值
number_list[1] = 30
print(number_list)
# 删：按索引删除
del number_list[2]
print(number_list)
last_item = number_list.pop() # 删除并返回最后一个元素
names.remove("rose") # 删除第一个匹配到的值
列表的其他常见操作
numbers = [1, 2, 3]
print(len(numbers)) # 长度
print([1, 2, 3] + [4, 5, 6]) # 组合
print(["Hello"] * 4) # 重复
print(3 in [1, 2, 3]) # 成员判断
print(8 not in numbers) # 不在列表中
列表索引
列表支持正向索引和反向索引：
abcd_list = ["a", "b", "c", "d"]
print(abcd_list[1]) # b
print(abcd_list[-2]) # c
可以先这样理解：
- 正向索引从
0开始 - 反向索引从
-1开始，表示最后一个元素
列表切片
列表和元组也支持切片，语法和字符串类似：
字典（dict）和集合（set）不支持切片。
abcd_list = ["a", "b", "c", "d"]
print(abcd_list[1:]) # ['b', 'c', 'd']
print(abcd_list[:3]) # ['a', 'b', 'c']
print(abcd_list[1:3]) # ['b', 'c']
print(abcd_list[:-1]) # ['a', 'b', 'c']
print(abcd_list[::2]) # ['a', 'c']
print(abcd_list[::-1]) # ['d', 'c', 'b', 'a']
切片可以记成 列表[起始:结束:步长]：
- 起始位默认从开头开始
- 结束位默认切到末尾，但本身不包含结束位
- 步长不写时默认为
1 - 步长为负数时表示反向切片
可变对象与不可变对象
- 常见不可变类型：
int、float、bool、str、tuple - 常见可变类型：
list、dict、set
浅拷贝与深拷贝
注意：浅拷贝只复制第一层，嵌套对象仍然共享引用。
import copy
source = ["zhangsan", ["alex", "oldboy"]]
# 浅拷贝，只复制外层列表，内层列表仍然是引用
shallow = source.copy()
# 深拷贝，递归复制所有层级，完全独立
deep = copy.deepcopy(source)
# 修改原列表的内层元素
source[1][0] = "updated"
print(shallow) # 内层列表会一起变
print(deep) # 深拷贝保持独立
元组 tuple
point = (10, 20)
# 元组不可变，适合表示一组固定数据。
元组和列表长得很像，但有一个关键区别：元组一旦创建，通常不能再原地修改。
只有一个元素的元组，必须带上逗号。
a_tuple = (2,)
not_tuple = (2)
print(type(a_tuple)) # <class 'tuple'>
print(type(not_tuple)) # <class 'int'>
也就是说，(2) 只是普通括号表达式，(2,) 才是单元素元组。
字典 dict
phone_book = {"Tom": 123, "Jerry": 456, "Kim": 789}
print(phone_book["Tom"]) # 123
print(phone_book.get("Jack")) # None，键不存在也不会报错
print("Tom" in phone_book) # True，判断键是否存在
phone_book["Tom"] = 999 # 修改
phone_book["Heath"] = 888 # 新增
print(phone_book)
for name, number in phone_book.items():
print(name, number) # 遍历字典的键值对
del phone_book["Tom"] # 删除指定键
print(phone_book)
phone_book.clear() # 清空整个字典
print(phone_book) # {}
可以先这样区分：
del phone_book["Tom"]：删除某一个键值对phone_book.clear()：清空字典内容，但字典对象本身还在del phone_book：删除整个变量名绑定，后续再访问会报错
集合 set
集合最常见的用途就是去重与集合运算。
两个很容易混淆的点：
{3, 5}是一个集合{}不是空集合，而是空字典- 真正的空集合要写成
set()
a_set = {3, 5}
b_set = set(range(8, 14))
c_set = set([1, 2, 3])
d_set = set({"a": 1, "b": 2}.items())
empty_set = set()
left = {1, 2, 3, 4, 5, 6}
right = {5, 6, 7, 8, 9}
print(left & right) # 交集，等价于 left.intersection(right)
print(left | right) # 并集，等价于 left.union(right)
print(left - right) # 差集，等价于 left.difference(right)
集合的增删查
可以先把集合理解成：无序、元素不重复、适合做成员判断。
最常见的操作包括：
- 增：使用
add()添加单个元素，使用update()一次加入多个元素 - 查：使用
in/not in判断元素是否存在 - 删：使用
remove()、discard()、pop()、clear()删除元素
numbers = {1, 2, 3}
# 增：添加单个元素
numbers.add(4)
print(numbers)
# 增：一次加入多个元素
numbers.update([5, 6])
print(numbers)
# 查：判断元素是否存在
print(3 in numbers) # True
print(10 not in numbers) # True
# 删：删除指定元素，不存在时会报错
numbers.remove(6)
print(numbers)
# 删：删除指定元素，不存在时不会报错
numbers.discard(10)
print(numbers)
# 删：随机删除并返回一个元素
removed_item = numbers.pop()
print(removed_item)
print(numbers)
# 删：清空整个集合
numbers.clear()
print(numbers) # set()