Python3语法速查笔记：基础语法、数据类型、运算符、函数、面向对象全覆盖

用于快速回顾，内容覆盖基础语法、数据类型、运算符、流程控制、函数、模块、文件IO和面向对象。

一、第一个程序

用任意文本编辑器（记事本也行），写一个 .py 文件：

# 这是注释，不会执行
print("Hello World")

命令行运行：

python hello.py

如果提示找不到 python，检查是否装了 Python 且添加了 Path 环境变量。

推荐编辑器：

VS Code 中如果 Python 路径含空格导致 Run Code 失败，在 settings.json 的 code-runner 配置里给路径加引号就行。

二、最基础的知识

编码

Python3 源码默认 UTF-8 编码。需要改编码时，在文件头加：

# -*- coding: GBK -*-

注释

# 单行注释

"""
多行注释
可以写多行
"""

行与缩进

Python 用缩进表示代码块，不用大括号。同一代码块缩进必须一致（建议 4 空格）。

if age >= 18:
    print('adult')

缩进不一致会报 IndentationError。

多行语句

行尾加 \ 表示续行：

total = item_one + \
        item_two + \
        item_three

在 []、{}、() 中不用加 \，直接换行即可。

变量

变量 = 装数据的容器。

命名规则：

• 只能由字母、数字、下划线组成

• 不能数字开头

• 不能含空格和特殊符号

• 区分大小写

• 不能用关键字（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）

• 不推荐覆盖内置函数名（如 list、print）

命名风格：

• snake_case：普通变量，推荐

• PascalCase：类名

• camelCase：Python 中极少用

声明变量：

age = 25
name = "Alice"
a, b, c = 10, "hello", [4, 5]   # 一行多变量
x = y = z = 99                   # 多变量同值
m, n = n, m                      # 直接交换，不需要临时变量

类型注解（仅提示，不强制）：

score: int = 95
address: str = "北京"

类型转换

常量

Python 没有 const 关键字，靠约定：全大写 + 下划线 表示常量。

PI = 3.1415926
MAX_SIZE = 100

print 输出

print("Hello")                     # 普通输出
print("姓名：", name, "年龄：", age)  # 逗号分隔，自动加空格
print(x, end="")                   # 不换行

三、数据类型

6 大类：数字型、字符串、布尔型、序列型、字典、集合。

Python 是动态类型语言，变量类型由赋给它的值决定。

数字型（Number）

a = 10              # int（整数），无大小限制
b = 3.14            # float（浮点数）
c = 1.23e5          # 科学计数法 = 123000.0
d = 2 + 3j          # complex（复数）

字符串（str）

• 不可变（不能 s[0]='A'）

• 有序，索引从 0 开始

• 用 ' '、" " 或 ''' ''' 包裹

s = "hello\nworld"        # \n 换行
s = r"hello\nworld"       # r 表示原始字符串，不转义

切片（核心操作）：

str[起始:结束:步长]   # 左闭右开

s = "hello python"
s[0]         # 'h'
s[1:4]       # 'ell'
s[:3]        # 'hel'
s[3:]        # 'lo python'
s[-1:]       # 'n'
s[::2]       # 'hlopto'
s[::-1]      # 反转字符串

布尔型（bool）

只有 True 和 False。规则：非 0 / 非空 = True，0 / 空 = False。

bool(0)      # False
bool("")     # False
bool([])     # False
bool(100)    # True
bool("abc")  # True

序列型

list（列表）

可变、有序、用 [] 包裹，元素可混合类型。

lst = [1, 2, 3]
lst = list(range(0, 10, 2))  # [0, 2, 4, 6, 8]
lst = list("hello")           # ['h','e','l','l','o']

常用操作：

快捷操作：

lst1 + lst2    # 拼接
lst1 * 3       # 重复
len(lst)       # 长度
max(lst)       # 最大值
min(lst)       # 最小值
sum(lst)       # 求和

tuple（元组）

和列表一样，但 不可修改。用 () 包裹。

t = (1, 2, 3)
t = 10, 20, 30            # 省略括号也行
single = (88,)             # 单元素必须加逗号，否则是 int

试图 t[0]=100 会报 TypeError。

但嵌套的可变元素（如列表）可以改：

t = (1, [2, 3], 4)
t[1][0] = 999   # 可以，因为改的是列表不是元组

元组解包（实用）：

a, b, c = (10, 20, 30)                # 一一对应
first, *middle, last = (1,2,3,4,5)     # middle = [2,3,4]

range（范围）

生成整数序列，常配合 for 循环。

range(stop)              # 0 ~ stop-1
range(start, stop)       # start ~ stop-1
range(start, stop, step) # 指定步长

list(range(5))         # [0,1,2,3,4]
list(range(2, 8))      # [2,3,4,5,6,7]
list(range(1,10,2))    # [1,3,5,7,9]
list(range(10,1,-3))   # [10,7,4]

r = range(0,10)
r[0]       # 0
r[-1]      # 9
r[2:7]     # range(2,7)

字典（dict）

可变、无序（3.7+ 保持插入顺序）、键值对结构。用 {} 包裹，键必须唯一且不可变。

d = {"name": "张三", "age": 25}
d = dict(name="李四", age=30)
d = dict([("a",1), ("b",2)])
d = dict(zip(["x","y"], [10,20]))

常用操作：

深浅拷贝：

d2 = d.copy()            # 浅拷贝，嵌套对象共享
import copy
d2 = copy.deepcopy(d)    # 深拷贝，完全独立

合并（3.9+）：

{"a":1, "b":2} | {"b":3, "c":4}  # {'a':1, 'b':3, 'c':4}

集合型

set（可变集合）

无序、不重复，用 {} 包裹。空集合必须用 set()。

s = {1, 2, 3}
s = set([1,2,2,3])   # 自动去重 → {1,2,3}

集合运算：

a & b      # 交集
a | b      # 并集
a - b      # 差集（a有b没有）
a ^ b      # 对称差集（互不相同的）

关系判断：issubset()、issuperset()、isdisjoint()

frozenset（不可变集合）

创建后不能修改，但可以当字典的键。

fs = frozenset([1,2,3])
# fs.add(4)  报错
d = {fs: "value"}  # 可以作为字典键

四、运算符

算术运算符

7 / 2     # 3.5   （/ 永远是浮点除法）
7 // 2    # 3     （整除，向下取整）
-7 // 2   # -4    （-3.5 向下取整为 -4，而不是 -3）
7 % 3     # 1
-7 % 3    # 2     （余数符号跟随被除数）
2 ** 10   # 1024
2 ** 3 ** 2  # 512   （幂运算右结合，先算 3 ** 2）

# 字符串 / 列表也可以使用 + 和 *
"ab" + "cd"   # "abcd"
"ab" * 3      # "ababab"
[1, 2] + [3]  # [1, 2, 3]
[0] * 3       # [0, 0, 0]

除法 / 永远返回浮点数；整除 // 和取余 % 在负数时按"向下取整"规则计算，容易踩坑。

比较运算符

• 比较结果永远是 True 或 False

• 支持链式比较：1 < a < 10 等价于 1 < a and a < 10

• 浮点数不要用 == 直接比较（存在二进制精度误差）

• 字符串按 Unicode 码点逐位比较

a = 8
1 < a < 10      # True，链式比较

# 浮点数比较陷阱
0.1 + 0.2 == 0.3               # False（二进制浮点误差）
abs((0.1 + 0.2) - 0.3) < 1e-9  # True，推荐这种写法

"apple" < "banana"   # True，按字符码点比较

赋值运算符

海象运算符 :=（3.8+）：在表达式中同时赋值并取值。

if (n := 10) > 5:   # 先给 n 赋值为 10，再比较
    print(n)        # 10

# 经典场景：边读边判断
while (chunk := f.read(1024)):
    process(chunk)   # 读到空串时循环结束

位运算符

按二进制位进行运算：

5 & 3     # 1   （101 & 011 = 001）
5 | 3     # 7   （101 | 011 = 111）
5 ^ 3     # 6   （101 ^ 011 = 110）
~5        # -6  （按位取反，~x = -x - 1）
5 << 1    # 10  （左移 1 位，相当于乘 2）
5 >> 1    # 2   （右移 1 位，相当于整除 2）

# 常见用途：用位做开关标记
flags = 0b0000
flags |= 0b0001      # 打开第 1 位
flags |= 0b0010      # 打开第 2 位
flags & 0b0001       # 1，判断第 1 位是否开启

逻辑运算符

短路规则（返回值是操作数本身，不一定是布尔）：

• and：第一个为假，直接返回第一个；否则返回第二个

• or：第一个为真，直接返回第一个；否则返回第二个

0 and 20     # 0
10 and 20    # 20
0 or 20      # 20
10 or 20     # 10
not 0        # True
not "abc"    # False

# 实用写法：取默认值
name = user_name or "匿名用户"   # user_name 为空就用默认值

成员运算符

判断元素是否在序列（字符串、列表、元组、集合）中；字典判断的是键。

"a" in "abc"          # True
3 in [1, 2, 3]        # True
"x" not in "abc"      # True
"age" in {"name":"张三", "age":25}   # True，字典判断键

身份运算符

is / is not：比较两个变量是否指向同一个对象（比内存地址）；== 比较的是值。

a = [1, 2, 3]
b = [1, 2, 3]
a == b    # True（值相等）
a is b    # False（不是同一个对象）

# 小整数缓存：-5 ~ 256 的整数是同一个对象
x = 100
y = 100
x is y    # True（缓存导致指向同一对象）

# 判断 None 必须用 is
if x is None:
    ...

不要用 is 判断数值相等（超出缓存范围会出错）；判断 None 时不要用 ==。

运算符优先级（高 → 低）

2 + 3 * 4       # 14，乘法先算
(2 + 3) * 4     # 20，括号改变优先级
2 ** 3 ** 2     # 512，幂右结合，先算 3 ** 2
not 0 and 1     # 1，先 not 再 and

记不住优先级没关系，用括号明确表达意图，代码可读性优先。

五、流程控制

标准输入/输出

name = input("请输入姓名：")
print(f"你输入的是：{name}")

if 语句

# 单分支
if 条件:
    代码块

# 双分支
if 条件:
    代码块
else:
    代码块

# 多分支
if 条件1:
    代码块
elif 条件2:
    代码块
else:
    代码块

三元表达式：

result = "及格" if score >= 60 else "不及格"

注意：if-elif 要把严格条件放在前面，否则会被宽松条件"吃掉"。

while 循环

while 条件:
    循环体
else:           # 正常结束（非break）才执行
    pass

for 循环

for 变量 in 可迭代对象:
    循环体
else:           # 正常遍历完才执行
    pass

常用遍历：

for i in range(5):              # 数字序列
for char in "hello":            # 字符串
for item in [1,2,3]:            # 列表
for key, val in dict.items():   # 字典键值对
for idx, val in enumerate(lst): # 索引+元素

嵌套 for：典型如九九乘法表。

break / continue / pass

• break：终止整个循环

• continue：跳过本次，进入下一次

• pass：占位，什么都不做

六、函数

定义与调用

def 函数名(参数列表):
    """文档字符串"""
    函数体
    return 返回值   # 可选，不写默认返回None

def add(a, b):
    return a + b

result = add(3, 5)  # 调用

参数类型

默认参数：

def add(a, b=0):
    return a + b

关键字参数（调用时按参数名传）：

print_info(age=18, name="小李")

不定长参数：

def func(a, b, *args, c=0, **kwargs):
    pass

func(1, 2, 3, 4, c=10, x=100, y=200)
# a=1, b=2, args=(3,4), c=10, kwargs={'x':100,'y':200}

# 拆包传递
nums = [1, 2, 3]
add(*nums)           # 等价 add(1,2,3)

d = {"name":"小王","age":20}
print_person(**d)    # 等价 print_person(name="小王",age=20)

lambda 表达式

lambda 参数: 表达式

f = lambda x: x * 2
sorted(lst, key=lambda x: x[1])     # 按第二个元素排序
filter(lambda x: x % 2 == 0, nums)  # 筛选偶数
map(lambda x: x**2, nums)           # 批量平方

高阶函数

from functools import reduce
reduce(lambda x, y: x + y, [1,2,3,4])      # 10
reduce(lambda x, y: x + y, [1,2,3,4], 10)  # 20

作用域

查找顺序：局部 → 嵌套 → 全局 → 内置。

count = 0
def outer():
    x = 10
    def inner():
        nonlocal x
        x = 20    # 修改的是 outer 里的 x
    inner()
    print(x)      # 20

常用内置函数速查

七、模块

import 用法

import 模块名                      # 导入整个模块
import 模块名 as 别名               # 起别名
from 模块名 import 成员             # 导入指定成员
from 模块名 import 成员 as 别名      # 成员起别名
from 模块名 import *               # 导入所有（不推荐）

常用内置模块

自定义模块

一个 .py 文件就是一个模块。同目录下的 main.py 可以直接 import my_module。

运行后会自动生成 pycache 目录存放 .pyc 字节码缓存，加速下次导入。

模块搜索路径

Python 按 sys.path 列表顺序查找模块：

1. 当前脚本所在目录

2. PYTHONPATH 环境变量

3. Python 标准库目录

4. site-packages（第三方库）

import sys
sys.path.append("/自定义路径")   # 临时添加

第三方模块（pip）

pip install 模块名              # 安装最新版
pip install 模块名==版本号       # 安装指定版本
pip install --upgrade 模块名     # 升级
pip uninstall 模块名             # 卸载
pip list                        # 查看已安装
pip show 模块名                  # 查看模块信息
pip freeze > requirements.txt   # 导出依赖清单
pip install -r requirements.txt # 按清单安装

镜像加速：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 模块名

包（Package）

包 = 含 init.py 的文件夹，用于组织模块。

mypackage/
├── __init__.py      # 包标识 + 导出控制
├── module_a.py
├── module_b.py
└── sub_pkg/
    ├── __init__.py
    └── utils.py

init.py 常用写法：

from .module_a import func_a
from .module_b import func_b

__all__ = ["func_a", "func_b"]   # 控制 from package import * 的导出

虚拟环境

# 创建
python -m venv venv

# 激活（Windows）
venv\Scripts\activate.bat

# 激活（Linux/Mac）
source venv/bin/activate

# 退出
deactivate

其他工具：virtualenv（兼容 Python2）、conda（Anaconda 自带，适合数据科学）。

八、文件 I/O

文件路径

• 绝对路径：从根目录开始的完整路径

• Windows：C:\Users\xxx\file.txt

• Linux：/home/user/file.txt

• 相对路径：相对于程序当前运行目录

• . 当前目录、.. 上级目录

• Windows 中 **** 需写成 \\ 或用原始字符串 r"路径"

open() 函数

open(file, mode='r', encoding=None, ...)

mode 模式：

encoding：推荐始终指定 encoding="utf-8"，避免中文乱码。

with open（推荐）

自动管理资源，代码块结束自动关闭文件，即使异常也能安全关闭。

with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()

读文件

读大文件（如 10GB）必须用逐行迭代，不能一次全读。

文件指针

f.seek(偏移量, 参考位置)
# 参考位置: 0=开头, 1=当前位置, 2=末尾
f.tell()   # 查看当前指针位置

f.seek(0)       # 回到开头
f.seek(0, 2)    # 移到末尾
f.seek(-10, 2)  # 从末尾往前 10 字节

写文件

覆盖写（谨慎！会清空原内容）：

with open("test.txt", "w", encoding="utf-8") as f:
    f.write("新内容")

追加写（推荐，不丢数据）：

with open("test.txt", "a", encoding="utf-8") as f:
    f.write("追加的内容\n")

九、面向对象编程

核心概念

• 面向过程：按步骤写函数，顺序调用

• 面向对象：以对象为核心，通过对象交互实现功能

OOP 四大特性：封装、继承、多态、抽象。

类与对象

• 类：模板/图纸，定义属性和方法

• 对象：类的具体实例

定义类

class 类名:          # 大驼峰命名
    """文档字符串"""
    
    # 类属性（所有实例共享）
    species = "人类"
    
    # 构造方法
    def __init__(self, name, age):
        self.name = name    # 实例属性
        self.age = age
    
    # 实例方法
    def introduce(self):
        print(f"我叫{self.name}，今年{self.age}岁")
    
    # 类方法
    @classmethod
    def class_method(cls):
        pass
    
    # 静态方法
    @staticmethod
    def static_method():
        pass

创建和使用对象

p1 = Person("张三", 20)
p1.introduce()           # 我叫张三，今年20岁
print(p1.name)           # 访问属性

特殊说明

• self：代表实例本身，方法第一个参数必须写（约定命名）

• init()：构造方法，创建对象时自动调用

• name == "main"：判断脚本是否直接运行

if __name__ == "__main__":
    # 直接运行这个脚本时执行
    p = Person("测试", 18)
    p.introduce()

到这里，Python 基础语法就介绍完了，后续将持续更新。