Python基础语法速通

1. 运行方式与基本规则

Python 代码通常保存在 .py 文件中，用下面的命令运行：

python hello.py

Python 用缩进表示代码块；同一代码块统一使用 4 个空格。

score = 85
if score >= 60:
    print("及格")  # 及格
else:
    print("不及格")  # 不及格

基本规则：

• 用 # 写注释。
• 直接写 变量名 = 值 就能创建变量，例如 age = 18。
• 语句末尾通常不写分号。
• Python 区分大小写，name 和 Name 是两个不同的名字。
• True、False、None 的首字母必须大写。

PEP 8 常用规范

• 变量、函数、方法：小写加下划线，如 user_name、get_user_name()。
• 类名：每个单词首字母大写，如 UserService。
• 常量：全大写，单词之间用下划线，如 MAX_RETRY_COUNT。
• 模块、包名：全小写；多个单词时使用下划线，如 user_service.py。
• 实例方法的第一个参数写 self；类方法的第一个参数写 cls。
• 每层缩进使用 4 个空格，不混用 Tab。
• 每行代码尽量不超过 79 个字符；过长时换行。
• 运算符两边留一个空格，如 total = price * count。
• 逗号后留一个空格，如 func(name, age)。
• 顶层函数和类之间留两个空行；类中的方法之间留一个空行。
• import 放在文件开头：先标准库，再第三方库，最后自己的模块。

2. 变量、类型与运算符

2.1 变量和类型

变量就是用来保存数据的名字。

value = 10
print(value)                    # 10
print(type(value))              # <class 'int'>，int 表示整数
value = "ten"
print(value)                    # ten
print(type(value))              # <class 'str'>，str 表示字符串
print(isinstance(value, str))   # True，value 是否为字符串

type(value) 用于查看数据类型。isinstance(value, str) 用于判断 value 是否是字符串，结果只有 True 或 False。

2.2 类型标注

类型标注是在变量名后面写 : 类型，作为说明。

name: str = "Alice"  # name 是字符串
age: int = 18         # age 是整数

print(name)           # Alice
print(age)            # 18

str 是字符串，int 是整数。name: str = "Alice" 与 name = "Alice" 的运行效果相同，前者只是额外说明 name 通常存放字符串。

2.3 常见类型

• int：整数，如 10、-3。
• float：小数，如 3.14。
• bool：布尔值，只有 True 和 False。
• str：文本，如 "hello"。
• list：列表，如 [1, 2, 3]。
• tuple：元组，如 (1, 2, 3)。
• set：集合，自动去重，如 {1, 2, 3}。
• dict：字典，保存“键：值”，如 {"name": "Alice"}。
• None：没有值。

常见转换：

number = int("42")        # 字符串 "42" 转为整数 42
price = float("19.5")     # 字符串 "19.5" 转为小数 19.5
text = str(100)            # 整数 100 转为字符串 "100"
items = list((1, 2, 3))    # 元组转为列表 [1, 2, 3]

2.4 运算符

a, b = 7, 2
print(a + b)   # 9，加法
print(a - b)   # 5，减法
print(a * b)   # 14，乘法
print(a / b)   # 3.5，除法
print(a // b)  # 3，只保留整数部分
print(a % b)   # 1，余数
print(a ** b)  # 49，7 的 2 次方

age = 20
print(age >= 18 and age < 60)  # True，同时满足两个条件
print("py" in "python")       # True，"python" 中包含 "py"
print(1 not in [2, 3])         # True，列表中没有 1

• ==：比较两个值是否相同，如 1 == 1。
• is：判断是否是同一个对象；最常用于判断 None。
• and：两个条件都成立才为 True。
• or：至少一个条件成立就为 True。
• not：把 True 变成 False，或把 False 变成 True。

result = None
if result is None:
    print("没有结果")  # 没有结果

2.5 判断

if 后面需要一个条件。False 代表“不成立”；True 代表“成立”。此外，None、0、空字符串 ""、空列表 []、空元组 ()、空集合 set()、空字典 {} 在条件判断中也会被当成 False。

items = []
if not items:
    print("容器为空")  # 容器为空

2.6 字符串格式化

f-string 是把变量放进文本里的常用写法：

name = "Alice"
age = 18
print(f"{name}今年{age}岁")  # Alice今年18岁
print(f"价格：{19.5:.2f}")    # 价格：19.50；`.2f` 表示保留两位小数

字符串中的 \n 表示换行；字符串前加 r 表示其中的反斜杠不做特殊处理。

message = "第一行\n第二行"
path = r"C:\Users\Alice\data.txt"

3. 字符串、索引与切片

字符串支持索引和切片，索引从 0 开始，切片的结束位置不包含在结果中。

text = "Python"
print(text[0])     # P
print(text[-1])    # n
print(text[1:4])   # yth
print(text[:2])    # Py
print(text[2:])    # thon
print(text[::-1])  # nohtyP

字符串不可变，不能直接修改某个位置；需要生成新字符串。

text = "python"
text = "P" + text[1:]
print(text)  # Python

常用方法：

text = "  Python,Java,Go  "
print(text.strip())                    # Python,Java,Go
print(text.lower())                    #   python,java,go
print(text.upper())                    #   PYTHON,JAVA,GO
print(text.replace("Java", "Rust"))    #   Python,Rust,Go  替换掉Java
print(text.split(","))                 # ['  Python', 'Java', 'Go  ']  切割为数组
print("-".join(["2026", "09", "16"]))  # 2026-09-16  字符串数组拼接
print("Python".startswith("Py"))       # True
print("Python".endswith("on"))         # True

4. 容器

4.1 列表 list

列表有序、可变，可以存放不同类型的对象：

numbers = [1, 2, 3]
numbers.append(4)       # 追加一个元素：4
numbers.extend([5, 6])   # 追加多个元素：5、6
numbers.insert(0, 0)    # 在0下标插入元素0
print(numbers)  # [0, 1, 2, 3, 4, 5, 6]

numbers.remove(3)
last = numbers.pop()
print(last)     # 6

常用操作：

items = ["a", "b", "c"]
print(len(items))     # 3
print("b" in items)   # True
items[0] = "A"
print(items[1:])      # ['b', 'c']；从下标 1 开始，取到最后

4.2 元组 tuple

元组通常用于表示不可变的一组值，也可以进行解包：

point = (10, 20)
x, y = point
print(x, y)  # 10 20

point[0] = 100  # 尝试修改为100，报错

single = (1,)  # 只有一个元素的元组；逗号不能省略，否则 `(1)` 只是整数 1

4.3 集合 set

集合自动去重，适合成员判断和集合运算：

tags = {"python", "java", "python"}
print(tags)  # {'python', 'java'}，顺序不固定
tags.add("go")

left = {1, 2, 3}
right = {3, 4, 5}
print(left | right)  # {1, 2, 3, 4, 5}，顺序不固定
print(left & right)  # {3}
print(left - right)  # {1, 2}

空集合必须写成 set()，因为 {} 表示空字典：

empty_set = set()
empty_dict = {}

4.4 字典 dict

字典保存“键：值”。例如用 "name" 找到对应的名字：

user = {
    "name": "Alice",
    "age": 18,
}
print(user["name"])                    # Alice
print(user.get("email"))                # None
print(user.get("email", "未填写"))       # 未填写

user["age"] = 19
user["city"] = "Shanghai"
user.pop("city")  # 删除键 "city" 及其对应的值，并返回被删除的值

遍历字典：

user = {"name": "Alice", "age": 18}
# 两种遍历字典的写法，结果相同
for key in user:
    print(key, user[key])  # 先拿到键，再用 user[key] 取值：name Alice；age 18

for key, value in user.items():
    print(key, value)      # 直接同时拿到键和值：name Alice；age 18

4.5 引用与可变对象

赋值通常是让两个变量指向同一个对象，而不是复制对象：

first = [1, 2]
second = first
second.append(3)
print(first)  # [1, 2, 3] ， 仅赋值

需要浅复制时使用 copy() 或切片：

first = [1, 2]
second = first.copy()
second.append(3)
print(first)   # [1, 2]
print(second)  # [1, 2, 3] ， copy为新的对象

5. 流程控制

5.1 条件分支

score = 86
if score >= 90:
    level = "A"
elif score >= 60:
    level = "B"
else:
    level = "C"
print(level)  # B

条件表达式：

age = 20
message = "成年" if age >= 18 else "未成年"

5.2 for 循环

Python 的 for 遍历可迭代对象，而不是只写计数器：

names = ["Alice", "Bob", "Carol"]
for name in names:
    print(name)  # 依次显示：Alice、Bob、Carol

需要下标时使用 enumerate()：

names = ["Alice", "Bob"]
for index, name in enumerate(names, start=1):
    print(index, name)  # 依次显示：1 Alice；2 Bob

同时遍历多个序列时使用 zip()：

names = ["Alice", "Bob"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)  # 依次显示：Alice 90；Bob 85

range() 常用于生成整数序列，结束值不包含在内：

for number in range(1, 4):
    print(number)  # 依次显示：1、2、3

5.3 while、break 与 continue

count = 0
while count < 3:
    count += 1
    if count == 2:
        continue
    print(count)  # 依次显示：1、3

• break 立即结束当前循环。
• continue 跳过本轮循环，进入下一轮。
• 循环变量在循环结束后仍然存在，注意不要覆盖外部同名变量。

6. 推导式

推导式适合把一个已有可迭代对象转换成新容器：

numbers = [1, 2, 3, 4, 5]
# 对 numbers 中每个 number 求平方，组成一个新列表
squares = [number ** 2 for number in numbers]
# 遍历 numbers，只保留能被 2 整除的 number，组成一个新列表
evens = [number for number in numbers if number % 2 == 0]
print(squares)  # [1, 4, 9, 16, 25]
print(evens)    # [2, 4]

集合和字典推导式：

words = ["python", "java", "python"]
# 遍历 words：键是单词，值是单词长度；重复的 "python" 会被字典自动覆盖
lengths = {word: len(word) for word in words}
# 把每个单词的长度放进集合；集合自动去重
unique_lengths = {len(word) for word in words}
print(lengths)        # {'python': 6, 'java': 4}
print(unique_lengths) # {4, 6}，顺序不固定

推导式只适合简单转换和过滤；逻辑过长时应改用普通循环或函数。

7. 函数

7.1 定义与返回值

两种都能定义函数，区别只是有没有写类型标注

• values 后面没有 : 类型：没有标注参数类型。
• 函数末尾没有 -> 类型：没有标注返回值类型。
• 冒号 : 是 Python 函数定义的固定语法，表示函数代码块从这里开始。

def add(a: int, b: int) -> int:
    """返回两个整数之和。"""
    return a + b

result = add(1, 2)
print(result)  # 3

没有显式 return 时，函数返回 None。Python 函数可以返回多个值，本质上是返回一个元组：

def min_max(values):
    return min(values), max(values)

minimum, maximum = min_max([3, 1, 5])
print(minimum, maximum)  # 1 5

7.2 参数

def greet(name, message="你好"):
    return f"{message}，{name}"

print(greet("Alice"))                         # 你好，Alice， 使用message的默认值
print(greet(name="Alice", message="早上好"))  # 早上好，Alice

可变参数：函数不知道调用时会传几个参数时使用。

# *numbers：把传入的所有数字收集成一个元组
# 调用 add(1, 2, 3) 时，numbers 就是 (1, 2, 3)
def add(*numbers):
    print(numbers)       # (1, 2, 3)
    return sum(numbers)

print(add(1, 2, 3))      # 6

* 只收集没有写参数名的值。

# **info：把“名字=值”收集成一个字典
def show_user(**info):
    print(info)          # {'name': 'Alice', 'age': 18}

show_user(name="Alice", age=18)

• *numbers 中的 numbers 只是变量名，可以换成其他名字。
• **info 中的 info 也只是变量名。
• * 收集普通值；** 收集 名字=值。

7.3 作用域基本规则

函数中可以使用外面的变量；但函数里新赋值的同名变量，默认只在函数内部有效。

count = 10

def show():
    count = 20
    print(count)  # 20

show()
print(count)      # 10

8. 模块与程序入口

导入模块：

import math
from pathlib import Path

print(math.sqrt(16))  # 4.0
print(Path.cwd())     # /当前工作目录

脚本既可以被直接运行，也可以被其他模块导入。程序入口写法：

def main():
    print("程序开始")  # 程序开始

# 直接运行当前文件时，__name__ 的值是 "__main__"，所以会执行 main()
# 被其他文件 import 时，__name__ 是当前文件名，不会自动执行 main()
if __name__ == "__main__":
    main()

• import math：使用时写 math.sqrt(16)。
• from pathlib import Path：使用时可以直接写 Path("data.txt")。
• 同一目录下的 .py 文件也可以被其他文件导入。

9. 异常处理

异常处理的基本结构：

try:
    number = int(input("请输入整数："))
except ValueError:
    print("输入格式错误")        # 输入不是整数时：输入格式错误
else:
    print(f"输入的是 {number}")   # 输入 42 时：输入的是 42
finally:
    print("处理结束")            # 总会显示：处理结束

捕获具体异常，不要无差别吞掉所有异常：

try:
    result = 10 / 0
except ZeroDivisionError as error:
    print(f"不能除以零：{error}")  # 不能除以零：division by zero

主动抛出异常：

def withdraw(balance, amount):
    if amount < 0:
        raise ValueError("金额不能为负数")
    if amount > balance:
        raise ValueError("余额不足")
    return balance - amount

常见异常：

• ValueError：值不符合要求，例如把 "abc" 转成整数。
• TypeError：类型用错了，例如数字和列表直接相加。
• KeyError：字典里没有这个键。
• IndexError：列表下标超出范围。
• FileNotFoundError：文件不存在。

10. 文件、路径与 JSON

10.1 文件读写

with 会在代码块结束后自动关闭文件：

from pathlib import Path

path = Path("data.txt")
path.write_text("第一行\n第二行\n", encoding="utf-8")
text = path.read_text(encoding="utf-8")
print(text)  # 第一行、第二行（分两行显示）

逐行读取大文件：

from pathlib import Path

with Path("data.txt").open(encoding="utf-8") as file:
    for line in file:
        print(line.strip())  # 逐行输出文件内容，去掉首尾空白

10.2 pathlib

from pathlib import Path

base = Path("data")
file_path = base / "users.json"
print(file_path.exists())  # True 或 False，文件是否存在
print(file_path.name)      # users.json
print(file_path.suffix)    # .json
print(file_path.parent)    # data

for path in base.glob("*.json"):
    print(path)  # 依次显示 data 目录下匹配到的 JSON 文件路径

10.3 JSON

JSON 是常见的数据文件格式，内容类似 Python 字典。

import json                 # JSON 相关功能
from pathlib import Path

# Python 字典
# "name" 对应 "Alice"；"roles" 对应一个列表
data = {"name": "Alice", "roles": ["admin", "user"]}
path = Path("user.json")   # 要写入的文件路径

# json.dumps：把 Python 字典转成 JSON 格式的文本
# ensure_ascii=False：保存中文时不转成 \uXXXX
# indent=2：每层缩进 2 个空格，文件更易读
json_text = json.dumps(data, ensure_ascii=False, indent=2)
path.write_text(json_text, encoding="utf-8")  # 把 JSON 文本写入 user.json

# read_text：读取文件中的文本
# json.loads：把 JSON 文本转回 Python 字典
loaded = json.loads(path.read_text(encoding="utf-8"))
print(loaded["roles"])  # ['admin', 'user']，从字典中取出 roles 对应的列表

11. 常用内置函数

numbers = [3, 1, 5, 2]
print(len(numbers))                         # 4
print(sum(numbers))                         # 11
print(min(numbers))                         # 1
print(max(numbers))                         # 5
print(sorted(numbers))                      # [1, 2, 3, 5]
print(any(number > 4 for number in numbers))  # True
print(all(number > 0 for number in numbers))  # True

• len()：计算个数。
• sorted()：返回排好序的新列表；原列表不变。
• any()：只要有一个条件成立，就是 True。
• all()：所有条件都成立，才是 True。
• enumerate()：遍历时同时拿到序号和内容。
• zip()：把多个列表按相同位置配对。
• range()：生成一段整数。

12. 基础语法最小模板

统计 data.txt 中非空行的数量。

from pathlib import Path


# path 是文件路径；-> int 表示结果是整数
def count_lines(path: str) -> int:
    file_path = Path(path)  # 把字符串路径转为 Path 对象
    if not file_path.exists():
        raise FileNotFoundError(file_path)  # 文件不存在时停止并报错

    # 打开文件，逐行读取；line.strip() 不为空时计数 1
    with file_path.open(encoding="utf-8") as file:
        return sum(1 for line in file if line.strip())


# main() 放程序的主要执行步骤
def main():
    print(count_lines("data.txt"))  # 例如：3


# 直接运行当前文件时，执行 main()
# 如果其他文件 import 当前文件，不执行 main()，只可使用 count_lines()
if __name__ == "__main__":
    main()