基本语法

约 2275 字大约 8 分钟

2026-05-27

Python 是解释型、强类型、动态类型、面向对象的语言。名字绑定在运行时完成，类型检查发生在操作执行时，而不是声明时

注释

# 单行注释

"""
多行注释常用三引号字符串
也可以用三个单引号
"""

'''
这同样是多行注释写法
'''

模块或函数顶部的三引号字符串还会被当作 docstring，和 "随便写几行说明" 在语义上是同一套字面量机制

标量类型

日常最先碰到的是这些原子类型（容器见下一篇）

类别	类型	字面量	说明
数字	`int`	`42`, `0b1010`, `0o52`, `0x2A`	精度任意大
数字	`float`	`3.14`, `2.5e10`	双精度浮点
数字	`complex`	`1+2j`	虚部用 `j`
布尔	`bool`	`True`, `False`	是 `int` 的子类，`True == 1`
字符串	`str`	`"hi"`, `'hi'`, 三引号多行	不可变序列
空值	`NoneType`	`None`	单例，表示 "没有值"

字面量与 print

print(42, 0b1010, 0o52, 0x2A)   # 42 10 42 42
print(3.14, 2.5e10, 1.2e-3)
print(True, False, None)
print("hello", 'world', """多
行""")

`type` 与类型对象

type(x) 返回的是类型对象本身，不是字符串

type 返回类型对象

print(type(42))          # <class 'int'>
print(type(42) == int)   # True
print(type(None))        # <class 'NoneType'>
print(isinstance(True, int))  # True，bool 是 int 子类

判断类型时，实例检查更常用 isinstance(x, int)，因为它会考虑继承；type(x) is int 只认精确类型

变量与命名

Python 变量是名字到对象的绑定，赋值不会 "声明类型"，只是让名字指向某个对象

变量绑定

name: str = "Alice"
age: int = 25
pi: float = 3.14159
is_valid: bool = True
print(name, age, pi, is_valid)

命名规则

规则	说明
字母或 `_` 开头	不能数字开头
可含字母、数字、`_`	不能有空格、连字符
区分大小写	`Name` 与 `name` 不同
不能是关键字	如 `if` / `class` / `def`

约定：

普通变量、函数：snake_case
"常量"（约定不改）：UPPER_SNAKE
类名：PascalCase
内部实现：_leading_underscore

多重赋值

多重赋值与交换

a, b, c = 1, 2, 3
print(a, b, c)

x, y = 10, 20
x, y = y, x          # 交换，右侧先打包成元组再解包
print(x, y)          # 20 10

a = b = c = 0        # 多个名字指向同一个对象
print(a, b, c)

类型转换

转换是 "构造新对象"，不是改原对象类型

类型转换与真值

print(int("25"))      # 25
print(str(100))       # "100"
print(float(5))       # 5.0
print(int(3.9))       # 3，截断而非四舍五入

print(bool(0), bool(1))       # False True
print(bool(""), bool("hi"))   # False True
print(bool(None))             # False

真值约定（truthiness）：0 / 0.0 / "" / 空容器 / None / False 为假，其余多为真

f-string

Python 3.6+ 推荐用 f-string 做字符串插值，花括号里可以写表达式

f-string 插值与格式

name = "Alice"
age = 25
pi = 3.14159
print(f"姓名: {name}, 年龄: {age}")
print(f"{3} + {5} = {3 + 5}")
print(f"{pi:.2f}")          # 保留两位小数
print(f"{name:>10}")        # 右对齐宽度 10
print(f"{name:<10}|")       # 左对齐
print(f"{42:04d}")          # 0042，补零
print(f"{255:#x}")          # 0xff
print(f"{1_000_000:,}")     # 1,000,000
# 调试写法（3.8+）：同时打印表达式文本与值
x, y = 3, 5
print(f"{x + y=}")

运算符

算术

运算符	含义	注意
`+` `-` `*`	加减乘	`str` 支持 `+` 拼接、`*` 重复
`/`	真除	结果总是 `float`
`//`	整除	向负无穷取整
`%`	取余	与 `//` 配套
`**`	幂	优先级很高

算术运算

print(5 / 3)     # 1.666...
print(5 // 3)    # 1
print(5 % 3)     # 2
print(5 ** 3)    # 125
print("Hi" * 3)  # HiHiHi
print(True + True)  # 2，因为 bool 是 int 子类
# None + 1  # TypeError

# // 向负无穷取整，不是向零截断
print(-5 // 2)   # -3
print(int(-5 / 2))  # -2，int() 才是向零截断

# round 对 .5 使用银行家舍入（凑偶数）
print(round(2.5), round(3.5))  # 2 4

比较与链式比较

print(5 == 5, "abc" < "def", True == 1)  # True True True
print(None == None)  # True
# None > 0  # TypeError，None 不能做大小比较

x = 5
print(1 < x < 10)       # True，等价于 1 < x and x < 10
print(1 < x < 10 < 100) # True，中间表达式只求值一次

赋值与海象运算符

复合赋值

a = 10
a += 5     # 15
a *= 2     # 30
a /= 4     # 7.5，/= 会变成 float
print(a)

海象运算符 :=（Python 3.8+）可在表达式里赋值，适合 "先算再判断"：

海象运算符

import re

text = "age=25"
if (m := re.search(r"\d+", text)):
    print(m.group())  # 25

滥用会降低可读性；简单赋值仍用 = 更清楚

逻辑运算

and / or 返回的是操作数本身，不一定是 bool

逻辑运算返回操作数

print(0 and 5)         # 0，短路，返回第一个假值
print(3 and 5)         # 5，都真则返回最后一个
print(0 or 5)          # 5
print(3 or 5)          # 3
print(not "")          # True
print(None or "默认")  # "默认"

条件表达式（三元）

条件表达式

score = 85
result = "及格" if score >= 60 else "不及格"
level = "A" if score >= 90 else ("B" if score >= 80 else "C")
print(result, level)

复杂分支仍应用 if / elif / else，不要嵌套多层三元

输入输出

print 的 sep 与 end

print("a", "b", "c", sep="-", end="!\n")  # a-b-c!

input() 永远返回 str，需要数字时再 int(...) 转换。交互输入在笔记 REPL 里通常不可用，本地终端再试即可

流程控制

条件

Python 用缩进表示代码块，惯例 4 空格

if / elif / else

age = 18
if age >= 18:
    print("成年人")
elif age >= 12:
    print("青少年")
else:
    print("儿童")

pass 是空语句，语法上需要语句体但暂时无逻辑时用

if True:
    pass  # 占位

`while` 与循环控制

while、else、break、continue

count = 0
while count < 3:
    print(count)
    count += 1
else:
    # 循环 "正常结束"（没被 break）时执行
    print("while 正常完成")

num = 0
while num < 10:
    if num % 2 != 0:
        num += 1
        continue   # 进入下一轮
    if num > 6:
        break      # 立刻离开循环，不走 else
    print(num)     # 0 2 4 6
    num += 1

循环 else 的语义容易踩坑：

被 break 打断 → 不执行 else
条件变假自然结束，或 continue 后结束 → 执行 else

典型用途是 "查找"：找到就 break，找不到才走 else 报 "未找到"

循环 else 用于查找

target = 4
num = 1
while num <= 9:
    if num == target:
        print("找到:", target)
        break
    num += 2  # 只扫奇数
else:
    print("未找到:", target)

`for` 遍历

for 作用在可迭代对象上，比 C 风格下标循环更常见

for 与 range

for ch in "hi":
    print(ch)

for i in range(3):
    print(i)  # 0 1 2

for i in range(1, 6, 2):
    print(i)  # 1 3 5

range 是惰性序列，适合当计数器；容器细节与 enumerate / zip 见容器类型

for 同样可以带 else，语义与 while-else 相同：未被 break 打断才执行

for-else

for n in range(2, 10):
    if n % 7 == 0:
        print("找到能被 7 整除:", n)
        break
else:
    print("没有找到")

`match` / `case`（Python 3.10+）

结构模式匹配：按 值的形状 分支，比一长串 if/elif 更适合处理命令、事件、嵌套数据

字面量与序列模式

def http_status(code: int) -> str:
    match code:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500 | 502 | 503:
            return "Server Error"
        case _:
            return "Unknown"

print(http_status(404), http_status(503), http_status(418))

def describe_point(point: tuple[int, int]) -> str:
    match point:
        case (0, 0):
            return "原点"
        case (0, y):
            return f"在 y 轴, y={y}"
        case (x, 0):
            return f"在 x 轴, x={x}"
        case (x, y) if x == y:
            return f"对角线上 ({x}, {y})"
        case (x, y):
            return f"点 ({x}, {y})"

print(describe_point((0, 5)))
print(describe_point((3, 3)))

映射模式与命令解析

def handle_event(event: dict) -> str:
    match event:
        case {"type": "click", "x": x, "y": y}:
            return f"点击 ({x}, {y})"
        case {"type": "key", "key": k}:
            return f"按键 {k}"
        case {"type": t}:
            return f"其他事件: {t}"
        case _:
            return "未知"

print(handle_event({"type": "click", "x": 10, "y": 20, "button": "left"}))

def run_cmd(line: str) -> str:
    match line.split():
        case ["quit"]:
            return "退出"
        case ["load", filename]:
            return f"加载 {filename}"
        case ["move", x, y] if x.isdigit() and y.isdigit():
            return f"移动到 ({x}, {y})"
        case _:
            return "无法识别"

print(run_cmd("load data.txt"))
print(run_cmd("move 3 4"))

模式从上到下匹配，更具体的 case 要写在前面。case _ 是通配默认分支

字符串常用操作

str 是不可变序列，方法都返回新字符串

字符串常用方法

s = "  Hello, Python  "
print(s.strip())                 # 去两端空白
print(s.lower(), s.upper())
print("a,b,c".split(","))        # ['a', 'b', 'c']
print("-".join(["a", "b", "c"])) # a-b-c
print("hello".replace("l", "L"))
print("file.py".startswith("file"), "file.py".endswith(".py"))
print("abc123".isdigit(), "42".isdigit())
print("hello".find("ll"), "hello".find("x"))  # 找不到返回 -1
print("name={}".format("Alice"))  # 旧式，现多用 f-string

原始字符串 r"..." 不把反斜杠当转义，写正则或 Windows 路径时很常用：r"\n" 是两个字符 \ 和 n

原始字符串

print("换行\n下一行")
print(r"换行\n下一行")

`assert` 与 `del`

assert 用于调试期断言；用 python -O 优化运行时断言会被去掉，不要拿它做业务校验

assert

def sqrt_positive(x: float) -> float:
    assert x >= 0, "x 必须非负"
    return x ** 0.5

print(sqrt_positive(9))
# print(sqrt_positive(-1))  # AssertionError

del 可以解除名字绑定，或删除容器中的元素（容器篇会再用到）

del 名字

a = 1
del a
# print(a)  # NameError