python基础知识汇总

python基础知识汇总|构建扎实的Python开发基础

本页面系统梳理Python语言的核心知识体系,覆盖从基础语法、数据类型、控制结构到函数式编程、面向对象编程、模块管理、异常处理、文件I/O及标准库常用模块等关键内容。内容设计以python基础知识为主线,兼顾实际开发中高频使用场景,结合大量可运行示例,帮助读者建立完整、准确、可迁移的知识结构。

Python语言自1991年首次发布以来,凭借其简洁优雅的语法、强大的标准库、活跃的社区生态,已发展为全球主流编程语言之一,广泛应用于Web开发、数据分析、人工智能、自动化运维、科学计算等领域。掌握扎实的python基础知识是成为合格开发者的第一步,也是应对技术演进与复杂问题的底层支撑能力。

本汇总特别注重以下三方面能力培养:① 语法理解的准确性——避免常见误解;② 编程范式的适应性——支持过程式、面向对象、函数式混合编程;③ 实践迁移能力——通过真实代码片段提升工程意识。所有示例均基于Python 3.8+版本编写,确保与当前主流开发环境一致。

⚡ 一、语法核心:构建语言骨架

1.1 标识符与关键字

Python标识符由字母(A-Z、a-z)、下划线(_)和数字(0-9)组成,但不能以数字开头;区分大小写;不能使用关键字作为标识符。Python 3.12共包含35个关键字,如下所示:

关键字 用途 示例
if 条件判断 if x > 0: print("正数")
for 循环结构 for i in range(5): print(i)
def 函数定义 def add(a, b): return a + b
class 类定义 class Person: pass
import 模块导入 import math

特别注意:`True`、`False`、`None`虽为关键字,但实际属于内置常量(Built-in Constants),不可重新赋值。尝试执行`True = 1`将抛出`SyntaxError`。

1.2 缩进与语句结构

Python使用缩进(默认4空格)表示代码块,而非花括号。这是其语法强制性设计,有助于保持代码风格统一。错误缩进将导致`IndentationError`。例如:

def check_age(age):
    if age >= 18:
        return "成年人"
    else:
        return "未成年人"

注意:缩进必须一致(全用空格或全用Tab),混用将引发`TabError: inconsistent use of tabs and spaces in indentation`。推荐使用空格,且4空格为PEP 8标准。

多行语句可用反斜杠`\`或括号(推荐)实现换行:

# 不推荐:用反斜杠
total = a + b + c + \
        d + e
# 推荐:用括号
total = (a + b + c +
         d + e)

1.3 注释规范

单行注释以`#`开头;多行注释常用三引号`'''`或`"""`包裹(实际为未赋值字符串,非真正注释)。PEP 8建议:

  • 注释与代码间留1空行(块注释)或2空格(行内注释)
  • 注释首字母大写(除变量名外)
  • 避免 obvious comments(如:`x = 5 # x赋值5`)

示例:

# 计算阶乘
def factorial(n):
    """递归计算n的阶乘(n!)"""
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)  # 递归调用

文档字符串(docstring)是函数、类、模块的第一行三引号字符串,可通过`__doc__`属性访问,是生成API文档的基础。

⚙️ 二、数据结构:组织数据的核心工具

2.1 列表(List)

列表是python基础知识中最重要的可变序列类型,支持增删改查。常用操作:

操作 示例 结果
创建 nums = [1, 2, 3] `[1, 2, 3]`
索引 nums[0] `1`
切片 nums[1:3] `[2, 3]`
追加 nums.append(4) `[1, 2, 3, 4]`
插入 nums.insert(1, 1.5) `[1, 1.5, 2, 3, 4]`
删除 nums.pop(1) `[1, 2, 3, 4]`
排序 nums.sort() 原地排序

列表推导式(List Comprehension)是高效创建列表的语法糖:

# 生成1~10的平方数
squares = [x**2 for x in range(1, 11)]  # [1, 4, 9, ..., 100]
# 带条件过滤
evens = [x for x in range(20) if x % 2 == 0]  # [0, 2, 4, ..., 18]

2.2 元组(Tuple)

元组是不可变序列,常用于固定数据集合、函数多返回值、字典键等场景。其不可变性带来性能优势(内存占用更小)与安全性保障。

# 单元素元组需加逗号
single = (1,)  # 正确
not_tuple = (1)  # 实际是整数1
# 多返回值函数
def min_max(lst):
    return min(lst), max(lst)
result = min_max([3, 1, 4, 1, 5])  # (1, 5)
print(f"最小值:{result[0]},最大值:{result[1]}")

解包(Unpacking)是元组常用技巧:

a, b, c = (10, 20, 30)  # a=10, b=20, c=30
head, *rest = [1, 2, 3, 4]  # head=1, rest=[2,3,4]

2.3 字典(Dict)

字典是键值对集合,键必须为可哈希对象(如字符串、数字、元组),值可为任意类型。Python 3.7+中字典保持插入顺序。

操作 示例 说明
创建 person = {"name":"Alice","age":25} 键值对用冒号分隔
访问 person.get("name") 安全访问,不存在返回None
更新 person.update({"city":"Beijing"}) 合并字典
删除 del person["age"] 或`person.pop("age")`
遍历 for k,v in person.items(): ... 同时获取键与值

字典推导式(Dict Comprehension):

# 生成1~5的平方数字典
squares_dict = {x: x**2 for x in range(1, 6)}  # {1:1, 2:4, 3:9, 4:16, 5:25}
# 翻转字典(键值互换)
original = {"a": 1, "b": 2, "c": 3}
flipped = {v: k for k, v in original.items()}  # {1:'a', 2:'b', 3:'c'}

2.4 集合(Set)

集合是无序不重复元素序列,支持数学集合运算(并集、交集、差集、对称差集)。常用于去重与成员测试。

# 创建集合
fruits = {"apple", "banana", "cherry"}
numbers = set([1, 2, 2, 3, 3])  # {1,2,3}
# 去重
data = [1, 2, 2, 3, 1]
unique_data = list(set(data))  # [1,2,3](顺序可能改变)
# 集合运算
set_a = {1, 2, 3}
set_b = {2, 3, 4}
union = set_a | set_b        # {1,2,3,4}
intersection = set_a & set_b  # {2,3}
difference = set_a - set_b    # {1}
sym_diff = set_a ^ set_b      # {1,4}

⚡ 函数编程:代码复用与抽象

3.1 函数定义与参数

函数是组织代码的基本单元,使用`def`关键字定义。参数类型包括:

  • 位置参数(Positional Arguments):按顺序传递
  • 关键字参数(Keyword Arguments):指定参数名传递
  • 默认参数(Default Arguments):提供默认值,必须在非默认参数之后
  • 可变参数(*args, **kwargs):接收任意数量参数
def process_data(data, type="clean", *args, **kwargs):
    """处理数据的通用函数
    :param data: 输入数据
    :param type: 处理类型(clean/transform/analyze)
    :param args: 额外的位置参数
    :param kwargs: 额外的关键字参数
    """
    print(f"处理类型:{type}")
    if args:
        print(f"额外位置参数:{args}")
    if kwargs:
        print(f"额外关键字参数:{kwargs}")
    return "完成"
# 调用示例
process_data([1, 2, 3], "analyze", "extra1", "extra2", verbose=True, threshold=0.8)

3.2 匿名函数与高阶函数

`lambda`用于创建匿名函数,常与`map()`、`filter()`、`sorted()`等高阶函数配合使用。

# map: 将函数应用于序列每个元素
cubes = list(map(lambda x: x**3, [1, 2, 3]))  # [1, 8, 27]
# filter: 过滤满足条件的元素
evens = list(filter(lambda x: x % 2 == 0, range(10)))  # [0,2,4,6,8]
# sorted: 自定义排序键
words = ["apple", "Banana", "cherry"]
sorted_words = sorted(words, key=str.lower)  # 按小写排序

注意:`lambda`只能是单表达式,不能包含语句(如`if`、`for`等),复杂逻辑应使用普通函数。

3.3 闭包与装饰器

闭包是嵌套函数中内部函数引用外部函数变量的组合。装饰器是闭包的典型应用,用于在不修改原函数代码的前提下增强功能。

def timer(func):
    """计算函数执行时间的装饰器"""
    import time
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 执行耗时:{end - start:.4f}秒")
        return result
    return wrapper
@timer
def slow_add(a, b):
    import time
    time.sleep(0.5)  # 模拟耗时操作
    return a + b
print(slow_add(3, 5))  # slow_add 执行耗时:0.5002秒 → 8

装饰器本质是返回函数的函数,`@timer`等价于`slow_add = timer(slow_add)`。`functools.wraps`可保留原函数元数据:

import functools
def debug(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"调用 {func.__name__}({args}, {kwargs})")
        return func(*args, **kwargs)
    return wrapper

⚡ 面向对象编程:封装、继承与多态

4.1 类与对象基础

类是对象的模板,对象是类的实例。Python中所有类默认继承`object`。

class Animal:
    """动物基类"""
    species = "Animalia"  # 类属性(所有实例共享)
    def __init__(self, name):
        self.name = name    # 实例属性(每个对象独立)
        self.age = 0
    def speak(self):
        return f"{self.name} 发出叫声"
# 创建实例
dog = Animal("旺财")
cat = Animal("咪咪")
print(dog.name, cat.name)  # 旺财 咪咪

注意:实例属性在`__init__`中定义;类属性需谨慎使用,避免可变类型(如列表)导致共享状态问题。

4.2 继承与方法重写

子类继承父类属性和方法,可重写(Override)或扩展新功能。`super()`用于调用父类方法。

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类初始化
        self.breed = breed
    def speak(self):  # 重写方法
        return f"{self.name} 汪汪叫"
    def fetch(self, item):
        return f"{self.name} 正在叼取 {item}"  # 新增方法
dog = Dog("拉布拉多", "Labrador")
print(dog.speak())  # 拉布拉多 汪汪叫
print(dog.fetch("球"))  # 拉布拉多 正在叼取 球

多继承时遵循MRO(Method Resolution Order),可通过`ClassName.__mro__`查看继承顺序。

4.3 特性(Property)与封装

`@property`装饰器将方法转换为只读属性,实现数据封装与验证。

class Student:
    def __init__(self, score):
        self._score = score  # 约定私有属性(单下划线)
    @property
    def score(self):
        return self._score
    @score.setter
    def score(self, value):
        if not isinstance(value, (int, float)):
            raise TypeError("分数必须是数字")
        if value < 0 or value > 100:
            raise ValueError("分数必须在0~100之间")
        self._score = value
student = Student(85)
print(student.score)  # 85
student.score = 92  # 触发setter
try:
    student.score = 150  # 抛出ValueError
except ValueError as e:
    print(e)  # 分数必须在0~100之间

单下划线(`_attr`)表示受保护属性(约定俗成);双下划线(`__attr`)触发名称改写(Name Mangling),增强封装性。

⚙️ 模块系统:代码组织与复用

5.1 模块导入机制

模块是Python代码文件(`.py`),用于组织相关功能。导入方式包括:

  • `import module`:导入整个模块
  • `from module import name`:导入指定名称
  • `import module as alias`:重命名模块
  • `from module import *`:导入所有(不推荐,易冲突)
# 标准导入
import math
from os import path, listdir
# 别名导入
import numpy as np
from collections import defaultdict as dd
# 使用
print(math.sqrt(16))   # 4.0
print(path.join("usr", "bin"))  # 'usr/bin'

模块搜索路径:当前目录 → `PYTHONPATH`环境变量 → 标准库路径 → 第三方库路径。可通过`sys.path`查看。

5.2 包与相对导入

包是包含`__init__.py`的目录,用于组织模块层次结构。

myproject/
├── main.py
├── utils/
│   ├── __init__.py
│   ├── string_utils.py
│   └── file_utils.py
└── data/
    ├── __init__.py
    └── loader.py

相对导入(包内使用):

# data/loader.py
from ..utils.string_utils import clean_text  # ..表示上级目录
from .file_utils import read_json  # .表示当前目录

注意:相对导入仅适用于包内模块;顶层脚本(如`main.py`)中不能使用相对导入。

5.3 `__name__ == "__main__"` 模式

每个模块都有内置变量`__name__`:直接运行时为`"__main__"`;被导入时为模块名。用于区分模块用途:

# mymodule.py
def process(data):
    return data.strip().lower()
if __name__ == "__main__":
    # 仅在直接运行时执行测试代码
    test_data = "  Hello World  "
    print(process(test_data))  # 'hello world'

这样设计使模块既可作为独立脚本运行,又可作为库被导入,提升复用性。

⚡ 异常处理:健壮性保障

6.1 基础异常处理结构

使用`try-except-else-finally`结构捕获并处理异常:

def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError as e:
        print(f"除零错误:{e}")
        return None
    except TypeError as e:
        print(f"类型错误:{e}")
        return None
    else:
        print("计算成功")
        return result
    finally:
        print("操作结束")
print(safe_divide(10, 0))   # 除零错误 → None
print(safe_divide("10", 2)) # 类型错误 → None

`else`块仅在`try`无异常时执行;`finally`块始终执行,常用于资源清理(如关闭文件、断开连接)。

6.2 自定义异常

继承`Exception`类创建自定义异常,便于业务逻辑错误处理:

class InvalidAgeError(Exception):
    """年龄输入无效异常"""
    def __init__(self, age):
        self.age = age
        super().__init__(f"年龄{age}无效:必须在1~120之间")
def register_user(age):
    if age < 1 or age > 120:
        raise InvalidAgeError(age)
    return f"用户注册成功,年龄:{age}"
try:
    register_user(150)
except InvalidAgeError as e:
    print(f"注册失败:{e}")  # 注册失败:年龄150无效...

合理使用自定义异常可使错误信息更具业务语义,便于调试与日志分析。

⚙️ 文件操作:数据持久化基础

7.1 文本文件读写

使用`with`语句确保文件自动关闭,推荐使用`open()`的`encoding`参数:

# 写入文本
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("Python是优秀的编程语言\n")
    f.write("支持跨平台、易学易用\n")
# 读取文本
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

常用模式:`"r"`(读)、`"w"`(写)、`"a"`(追加)、`"b"`(二进制)、`"+"`(读写)。推荐使用`encoding="utf-8"`避免中文乱码。

7.2 JSON与CSV数据处理

JSON适合结构化数据交换;CSV适合表格数据。

import json
import csv
# JSON写入
data = {"name": "Alice", "age": 28, "skills": ["Python", "SQL"]}
with open("user.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
# CSV写入
rows = [
    ["姓名", "年龄", "城市"],
    ["张三", 30, "北京"],
    ["李四", 25, "上海"]
]
with open("users.csv", "w", newline=True, encoding="utf-8-sig") as f:
    writer = csv.writer(f)
    writer.writerows(rows)

`ensure_ascii=False`保留中文字符;`encoding="utf-8-sig"`在CSV中添加BOM头,确保Excel正确打开。

7.3 路径操作与文件管理

使用`pathlib`模块(Python 3.4+)统一处理路径,比`os.path`更现代:

from pathlib import Path
# 创建路径对象
base_dir = Path("./project")
data_dir = base_dir / "data"  # 自动处理路径分隔符
# 检查路径
if not data_dir.exists():
    data_dir.mkdir(parents=True)  # 递归创建目录
# 遍历文件
for file_path in data_dir.glob("*.txt"):
    print(f"文件:{file_path.name},大小:{file_path.stat().st_size}字节")
# 移动文件
old_file = base_dir / "temp.txt"
new_file = data_dir / "temp.txt"
old_file.rename(new_file)

`pathlib.Path`对象支持多种操作符(`/`拼接路径)、属性(`.name`、`.suffix`、`.stat()`)和方法(`.exists()`、`.is_file()`、`.read_text()`)。

⚡ 标准库精选模块

8.1 日期时间处理(datetime)

处理时间戳、日期格式化、时间差计算:

from datetime import datetime, timedelta
# 当前时间
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 2025-04-05 14:30:22
# 日期计算
one_week = timedelta(weeks=1)
next_week = now + one_week
print(next_week.strftime("%Y-%m-%d"))  # 2025-04-12
# 解析字符串日期
date_str = "2025-12-31"
date_obj = datetime.strptime(date_str, "%Y-%m-%d")

注意:`strftime()`格式化;`strptime()`解析。`%`符号定义格式(如`%Y`四位年份、`%m`两位月份)。

8.2 正则表达式(re)

用于文本模式匹配与提取:

import re
text = "订单号:ORD202504051234,金额:¥1,299.00"
# 提取订单号
order_match = re.search(r"ORD\d+", text)
if order_match:
    print(order_match.group())  # ORD202504051234
# 提取金额(含千分位)
amount_match = re.search(r"¥([\d,]+\.\d{2})", text)
if amount_match:
    amount = amount_match.group(1).replace(",", "")
    print(float(amount))  # 1299.0
# 替换邮箱
email_text = "联系:admin@example.com 或 support@test.org"
clean_text = re.sub(r"[\w\.-]+@[\w\.-]+\.\w+", "[邮箱]", email_text)
print(clean_text)  # 联系:[邮箱] 或 [邮箱]

使用原始字符串(`r""`)避免转义问题;`group()`获取匹配子串;`findall()`获取所有匹配。

8.3 命令行参数(argparse)

构建可配置命令行工具:

import argparse
def main():
    parser = argparse.ArgumentParser(description="文件处理工具")
    parser.add_argument("-i", "--input", required=True, help="输入文件路径")
    parser.add_argument("-o", "--output", default="output.txt", help="输出文件路径")
    parser.add_argument("-v", "--verbose", action="store_true", help="显示详细日志")
    args = parser.parse_args()
    if args.verbose:
        print(f"处理文件:{args.input} → {args.output}")
    print(f"成功处理 {args.input}")
if __name__ == "__main__":
    main()

运行示例:`python tool.py -i data.csv -o result.csv -v`

⚠️ 常见误区与调试技巧

9.1 Python 2 vs Python 3 关键差异

尽管Python 2已停止维护(2020年1月1日),但旧代码仍可能遇到以下问题:

差异点 Python 2 Python 3
打印语句 `print "Hello"` `print("Hello")`
整数除法 `3/2 = 1` `3/2 = 1.5`;`3//2 = 1`
字符串类型 `str`为字节串;`unicode`为文本 `str`为Unicode;`bytes`为字节串
输入函数 `raw_input()` `input()`

迁移建议:使用`2to3`工具自动转换;在代码开头添加`from __future__ import print_function, division`模拟Python 3行为。

9.2 可变默认参数陷阱

函数默认参数为可变对象时,会在多次调用间共享同一对象,导致意外结果:

# 错误示例
def add_item(item, lst=[]):
    lst.append(item)
    return lst
print(add_item(1))  # [1]
print(add_item(2))  # [1, 2](共享了同一个列表!)
# 正确做法
def add_item(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst
print(add_item(1))  # [1]
print(add_item(2))  # [2](独立列表)

始终使用`None`作为可变默认值的占位符,并在函数内部检查。

9.3 调试技巧

高效定位问题的实用方法:

  • 断言(assert):检查前置条件 `assert x > 0, "x必须为正数"
  • 调试器(pdb):在代码中插入`import pdb; pdb.set_trace()`
  • 日志记录(logging):比`print`更结构化
    import logging
    logging.basicConfig(level=logging.DEBUG)
    logging.debug(f"变量x值:{x}")
  • 交互式调试:在终端运行`python -m pdb script.py`

〔附录〕Python 3.8+ 新特性速览

  • 赋值表达式(海象运算符):`:=` 允许在表达式内部赋值
    if (n := len(data)) > 10:
        print(f"数据过长:{n}项")
  • 仅限位置形参:`/` 分隔位置与关键字参数
    def func(a, b, /, c, d): ...
    func(1, 2, c=3, d=4)  # a/b只能位置传递
  • f-string增强:`=` 自动显示变量名与值
    x = 10
    y = 20
    print(f"{x=}, {y=}")  # x=10, y=20
  • 导入系统改进:`importlib.metadata` 获取包元数据
    from importlib.metadata import version
    print(version("requests"))  # 2.28.1