菜鸟教程Python语法

系统·深度·实战 · 从零基础到进阶开发

网址:www.xservx.com 备案号:蜀ICP备2026035467号-3

⚡ 菜鸟教程Python语法:为什么选择Python?

Python自1991年由吉多·范罗苏姆(Guido van Rossum)发布以来,已发展成为全球最流行的编程语言之一。其设计哲学强调代码的可读性和简洁性,使用缩进来定义代码块,大幅降低初学者的学习门槛。在2024年TIOBE指数中,Python已连续三年稳居前三,并在Web开发、数据科学、人工智能、自动化运维等领域占据主导地位。

〔核心优势〕

  • 语法简洁:用一行代码实现斐波那契数列:a, b = 0, 1;while b < 1000: print(b),a, b = b, a+b
  • 生态丰富:PyPI仓库收录超50万个项目,涵盖科学计算、机器学习、网络爬虫等全领域
  • 跨平台性强:Windows/macOS/Linux/Android/iOS均提供官方或第三方支持环境
  • 社区活跃:Stack Overflow上Python相关问题日均新增超1500条,中文社区文档完善

〈Python版本演进时间轴〉

1991年:Python 0.9.0发布
首次公开发布,包含异常处理、函数、模块等核心特性,支持面向对象编程
2000年:Python 2.0发布
引入垃圾回收机制、列表推导式,成为企业级开发主流版本长达18年
2008年:Python 3.0发布
不兼容2.x的革新版本,修复设计缺陷(如print语句改为函数),逐步推进3.x生态迁移
2020年:Python 2.7终止支持
官方正式停止维护,所有企业级项目全面转向Python 3.5+(推荐3.8+)
2023年:Python 3.12发布
引入Pegen新解析器,性能提升10%~20%;新增结构化异常处理(PEP 654)

《PyPI下载量TOP10包(2024年Q2)》

排名 包名 月下载量(亿次) 主要用途
① urllib3 128.4 HTTP客户端库,requests底层依赖
② certifi 112.7 SSL证书验证,保障网络请求安全
③ charset-normalizer 98.2 文本编码自动检测,解决乱码问题
④ requests 87.6 人类友好型HTTP库,API设计简洁直观
⑤ numpy 76.3 科学计算基础库,多维数组运算核心
⑥ pip 72.1 包管理工具,安装/升级/卸载第三方库
⑦ pytz 61.8 时区处理库,解决跨时区时间计算
⑧ cryptography 54.9 加密解密模块,支持RSA/AES等算法
⑨ pillow 48.7 PIL分支,图像处理标准库
⑩ setuptools 42.3 Python包构建工具,setup.py核心依赖

⚙️ Python基础语法:结构与规范

Python语法以简洁性和可读性为核心设计原则,摒弃了C/Java中冗余的分号和大括号,转而使用缩进定义代码块层级。这种设计强制开发者编写结构清晰的代码,但也要求严格遵守缩进规范,否则将引发IndentationError。

〔缩进规则详解〕

缩进使用4个空格(推荐)或1个制表符(不建议混合使用)。缩进层级决定代码块归属,例如:

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)
print(factorial(5))  # 输出:120

注意:if语句后必须有冒号(:),缩进部分为代码块主体。错误示例:

def bad_example():
    x = 10
  print(x)  # IndentationError: unindent does not match any outer indentation level

〈语句与表达式区别〉

Python中所有操作都通过语句(statement)或表达式(expression)实现。语句执行操作但不返回值(如赋值语句),表达式计算并返回值(如数学运算)。例如:

x = 10 + 5  # 'x = ...'是语句,'10 + 5'是表达式
print(x)    # 输出:15

〔单行注释〕

以#开头,适用于短说明。例如:

# 计算圆面积
pi = 3.14159  # 圆周率近似值
r = 5         # 半径
area = pi * r * r

〔多行注释〕

使用三引号(""" 或 ''')包裹,常用于函数/类文档字符串(docstring):

def gcd(a, b):
    """计算最大公约数(欧几里得算法)"""
    while b:
        a, b = b, a % b
    return a

〔命名规则〕

  • 只能包含字母、数字、下划线,且不能以数字开头
  • 区分大小写:age ≠ Age ≠ AGE
  • 推荐蛇形命名法(snake_case):user_name, total_score
  • 常量全大写:MAX_CONNECTIONS = 100
  • 避免使用Python关键字(如class, def, if)

〔变量赋值技巧〕

# 多重赋值
a, b, c = 1, 2, 3
print(a, b, c)  # 输出:1 2 3
# 交换变量(无需临时变量)
x, y = 10, 20
x, y = y, x
print(x, y)  # 输出:20 10
# 链式赋值
x = y = z = 0
print(x, y, z)  # 输出:0 0 0

〔内置数据类型〕

类型 示例 说明
整数(int) 42, -7 支持任意精度整数(受内存限制)
浮点(float) 3.14, -0.001 遵循IEEE 754双精度标准,注意精度误差
字符串(str) "hello", 'world' 不可变序列,支持Unicode字符
布尔(bool) True, False 继承自int,True=1, False=0
空值(NoneType) None 单例对象,表示缺失值

📊 数据容器:列表、元组、字典与集合

Python提供四种核心数据结构,各自适用于不同场景。理解其特性差异是编写高效代码的基础。列表适合动态增删,元组用于固定数据,字典实现快速查找,集合处理去重与关系运算。

〔列表(list):可变序列〕

用方括号[]定义,支持增删改查操作。典型应用:数据处理、队列/栈模拟。

# 创建列表
fruits = ["apple", "banana", "cherry"]
# 增删操作
fruits.append("orange")      # ['apple', 'banana', 'cherry', 'orange']
fruits.insert(1, "mango")    # ['apple', 'mango', 'banana', 'cherry', 'orange']
fruits.pop()                 # 删除末尾元素,返回'orange'
# 切片操作(左闭右开)
print(fruits[1:3])  # ['mango', 'banana']
print(fruits[::-1]) # 倒序:['cherry', 'banana', 'mango', 'apple']

〔元组(tuple):不可变序列〕

用圆括号()定义,创建后无法修改。常用于函数返回多值、字典键(需全为不可变类型)。

# 创建元组
point = (10, 20)
colors = ("red", "green", "blue")
# 解包操作
x, y = point
print(x, y)  # 输出:10 20
# 元组作为字典键
locations = {
    (0, 0): "原点",
    (1, 1): "第一象限"
}
print(locations[(1, 1)])  # 输出:第一象限

〔字典(dict):键值对集合〕

用花括号{}定义,键必须唯一且不可变(常用字符串/数字/元组)。实现O(1)时间复杂度查找。

# 创建字典
student = {
    "name": "张三",
    "age": 20,
    "courses": ["数学", "物理"]
}
# 访问与修改
print(student["name"])  # 输出:张三
student["grade"] = "大二"  # 新增键值对
student["age"] = 21       # 修改值
# 安全访问(避免KeyError)
print(student.get("address", "未提供"))  # 输出:未提供

〔集合(set):无序不重复元素〕

用花括号{}(无键值对时)或set()定义,自动去重,支持集合运算。

# 创建集合
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
# 集合运算
print(a & b)  # 交集:{3, 4}
print(a | b)  # 并集:{1, 2, 3, 4, 5, 6}
print(a - b)  # 差集:{1, 2}
# 去重应用
numbers = [1, 2, 2, 3, 3, 3]
unique = list(set(numbers))  # [1, 2, 3]

《数据结构选择决策树》

当需要选择容器时,请按以下逻辑判断:

  1. 数据是否需要修改?→ 否:选元组;是:进入下一步
  2. 是否需要键值映射?→ 是:选字典;否:进入下一步
  3. 是否需要去重?→ 是:选集合;否:选列表

示例场景:

  • 存储用户配置项 → 字典(键为配置名)
  • 实现栈(后进先出)→ 列表(append + pop)
  • 记录已访问URL → 集合(快速判断存在性)

🔧 函数定义与高级特性

函数是Python代码组织的核心单元。通过合理设计函数,可提升代码复用性、可读性与可维护性。Python支持默认参数、可变参数、关键字参数等灵活定义方式。

〔函数基本结构〕

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

示例:计算阶乘并处理边界情况

def factorial(n):
    """计算非负整数n的阶乘"""
    if not isinstance(n, int):
        raise TypeError("参数必须为整数")
    if n < 0:
        raise ValueError("参数必须非负")
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result
print(factorial(5))  # 输出:120

〔默认参数陷阱〕

默认参数值在函数定义时求值,而非调用时!避免使用可变对象(如列表)作为默认值。

# 错误示例
def add_item(item, lst=[]):
    lst.append(item)
    return lst
print(add_item(1))  # [1]
print(add_item(2))  # [1, 2] —— 非预期!默认列表被共享
# 正确做法
def add_item_safe(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst
print(add_item_safe(1))  # [1]
print(add_item_safe(2))  # [2] —— 正确

〔可变位置参数 *args〕

接收任意数量的位置参数,内部为元组。

def average(*numbers):
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)
print(average(1, 2, 3))  # 2.0
print(average())         # 0

〔解包操作〕

values = [10, 20, 30]
print(average(*values))  # *解包列表为独立参数

〔可变关键字参数 **kwargs〕

接收任意数量的关键字参数,内部为字典。

def build_profile(**info):
    return info
print(build_profile(name="李四", age=25, city="成都"))
# 输出:{'name': '李四', 'age': 25, 'city': '成都'}
# 实际应用:动态配置
def connect_db(host="localhost", port=3306, **options):
    config = {
        "host": host,
        "port": port,
        "timeout": options.get("timeout", 30),
        "charset": options.get("charset", "utf8mb4")
    }
    return config
print(connect_db("db.example.com", 3307, timeout=60, ssl=True))

〈函数式编程基础〉

Python支持map、filter、reduce等函数式操作,结合lambda表达式可实现简洁的数据处理。

# map:对每个元素应用函数
squares = list(map(lambda x: x**2, [1, 2, 3, 4]))  # [1, 4, 9, 16]
# filter:过滤满足条件的元素
evens = list(filter(lambda x: x % 2 == 0, range(10)))  # [0, 2, 4, 6, 8]
# reduce:累积计算(需导入)
from functools import reduce
product = reduce(lambda x, y: x * y, [1, 2, 3, 4])  # 24

注意:现代Python更推荐列表推导式替代map/filter,因其更直观:

squares = [x**2 for x in [1,2,3,4]]  # 同上结果
evens = [x for x in range(10) if x % 2 == 0]

🎨 面向对象编程:类与继承

Python是多范式语言,支持面向对象编程(OOP)。通过类(class)封装数据和行为,实现代码复用与模块化。理解封装、继承、多态三大特性是构建大型应用的基础。

〔类的基本结构〕

class 类名(父类列表):
    """可选文档字符串"""
    def __init__(self, 参数列表):
        """构造方法,初始化实例属性"""
        self.属性名 = 值
    def 方法名(self, 参数列表):
        """实例方法"""
        pass

示例:模拟银行账户

class BankAccount:
    """银行账户类"""
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance  # 单下划线表示受保护属性
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            return f"存入{amount}元,当前余额{self._balance}元"
        raise ValueError("存款金额必须为正")
    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            return f"取出{amount}元,当前余额{self._balance}元"
        raise ValueError("取款金额无效")
    def get_balance(self):
        return f"账户余额:{self._balance}元"
# 使用示例
account = BankAccount("王五", 1000)
print(account.deposit(500))   # 存入500元,当前余额1500元
print(account.withdraw(300))  # 取出300元,当前余额1200元
print(account.get_balance())  # 账户余额:1200元

〔单继承与多继承〕

子类自动获得父类所有属性和方法,支持多继承(按MRO顺序查找)。

class SavingsAccount(BankAccount):
    """储蓄账户类"""
    def __init__(self, owner, balance=0, interest_rate=0.03):
        super().__init__(owner, balance)  # 调用父类构造方法
        self.interest_rate = interest_rate
    def add_interest(self):
        interest = self._balance * self.interest_rate
        self._balance += interest
        return f"添加利息{interest:.2f}元"
# 使用
savings = SavingsAccount("赵六", 2000, 0.025)
print(savings.deposit(1000))      # 存入1000元,当前余额3000元
print(savings.add_interest())     # 添加利息75.00元

〔方法重写与super()〕

子类可重写父类方法,使用super()调用父类原方法。

class CheckingAccount(BankAccount):
    """支票账户类"""
    def __init__(self, owner, balance=0, fee=5):
        super().__init__(owner, balance)
        self.fee = fee
    def withdraw(self, amount):
        # 重写取款方法,增加手续费
        total = amount + self.fee
        if 0 < total <= self._balance:
            self._balance -= total
            return f"取出{amount}元+手续费{self.fee}元,余额{self._balance}元"
        raise ValueError("余额不足")
# 使用
checking = CheckingAccount("钱七", 500, 3)
print(checking.withdraw(100))  # 取出100元+手续费3元,余额397元

〔常用魔法方法〕

方法 触发条件 用途
__str__(self) str(obj) 或 print(obj) 返回对象字符串描述
__repr__(self) repr(obj) 返回对象调试用字符串
__len__(self) len(obj) 定义对象长度
__getitem__(self, key) obj[key] 支持索引/切片操作
__call__(self, *args) obj(*args) 使对象可被调用(函数式)
class Fibonacci:
    def __init__(self):
        self.memo = {0: 0, 1: 1}
    def __call__(self, n):
        if n not in self.memo:
            self.memo[n] = self(n-1) + self(n-2)
        return self.memo[n]
    def __len__(self):
        return len(self.memo)
    def __str__(self):
        return f"Fibonacci缓存大小:{len(self)}"
fib = Fibonacci()
print(fib(10))  # 输出:55
print(fib)      # 输出:Fibonacci缓存大小:11

📂 文件操作与I/O处理

文件操作是程序与外部世界交互的核心环节。Python通过内置open()函数及with上下文管理器,提供安全、高效的文件读写能力。

〔文件打开模式〕

模式 说明 适用场景
'r' 只读(默认) 读取现有文本文件
'w' 写入(覆盖) 创建新文件或覆盖旧文件
'a' 追加写入 日志记录、数据累积
'b' 二进制模式 图片、音频、视频等非文本文件
'+' 读写模式 需同时读写操作

〔三种读取方式〕

# 方式1:read() - 读取全部内容
with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)
# 方式2:readline() - 按行读取
with open("data.txt", "r", encoding="utf-8") as f:
    line1 = f.readline()
    line2 = f.readline()
# 方式3:readlines() - 读取所有行到列表
with open("data.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    for i, line in enumerate(lines):
        print(f"第{i+1}行:{line.strip()}")

〔写入与追加〕

# 写入字符串
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("第一行内容\n")
    f.write("第二行内容\n")
# 追加内容
with open("output.txt", "a", encoding="utf-8") as f:
    f.write("追加的新行\n")
# 写入列表
lines = ["配置项1=value1\n", "配置项2=value2\n"]
with open("config.txt", "w", encoding="utf-8") as f:
    f.writelines(lines)

〔处理图片文件〕

# 读取图片并计算大小
with open("image.jpg", "rb") as f:
    data = f.read()
    print(f"图片大小:{len(data)} 字节")
# 复制图片
with open("source.jpg", "rb") as src:
    with open("copy.jpg", "wb") as dst:
        dst.write(src.read())

〈CSV文件处理实战〉

CSV(逗号分隔值)是数据交换的通用格式。Python内置csv模块提供专业处理能力。

import csv
# 读取CSV
with open("students.csv", "r", encoding="utf-8-sig") as f:
    reader = csv.DictReader(f)  # 返回字典序列
    for row in reader:
        print(f"{row['姓名']} - {row['成绩']}分")
# 写入CSV
data = [
    {"姓名": "张三", "成绩": 85, "班级": "一班"},
    {"姓名": "李四", "成绩": 92, "班级": "二班"}
]
with open("new_students.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["姓名", "成绩", "班级"])
    writer.writeheader()  # 写入表头
    writer.writerows(data)  # 写入数据行

注意:使用encoding="utf-8-sig"可正确处理带BOM的UTF-8文件;newline=""避免写入时产生额外空行。

⚠️ 异常处理机制

异常是程序运行时出现的错误信号。合理使用try-except结构可增强程序健壮性,避免因单个错误导致整个程序崩溃。

〔基本异常处理〕

def safe_divide(a, b):
    try:
        result = a / b
    except ZeroDivisionError:
        return "错误:除数不能为零"
    except TypeError:
        return "错误:参数必须为数字"
    else:
        return f"结果:{result}"
    finally:
        print("操作完成")
print(safe_divide(10, 2))   # 操作完成\n结果:5.0
print(safe_divide(10, 0))   # 操作完成\n错误:除数不能为零

〔常见内置异常类型〕

异常 触发条件
IndexError 列表/元组索引越界
KeyError 字典中不存在指定键
ValueError 类型正确但值无效(如int("abc"))
FileNotFoundError 文件不存在
ModuleNotFoundError 导入模块不存在
AttributeError 访问对象不存在的属性

〔自定义异常类〕

class InvalidScoreError(Exception):
    """自定义异常:无效分数"""
    def __init__(self, score, message="分数必须在0-100之间"):
        self.score = score
        self.message = message
        super().__init__(f"{message}(实际值:{score})")
def validate_score(score):
    if not 0 <= score <= 100:
        raise InvalidScoreError(score)
    return score
# 使用
try:
    score = validate_score(120)
except InvalidScoreError as e:
    print(e)  # 分数必须在0-100之间(实际值:120)

〈日志记录与异常追踪〉

生产环境中应记录异常详情以便排查问题。结合traceback模块可获取完整堆栈信息。

import logging
import traceback
logging.basicConfig(
    level=logging.ERROR,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
def risky_operation():
    try:
        1 / 0
    except Exception as e:
        # 记录错误及完整堆栈
        logging.error(f"发生异常:{str(e)}")
        logging.error("堆栈追踪:\n%s", traceback.format_exc())
risky_operation()

日志输出示例:

2024-06-15 14:30:22,123 - ERROR - 发生异常:division by zero
2024-06-15 14:30:22,124 - ERROR - 堆栈追踪:
Traceback (most recent call last):
  File "script.py", line 8, in risky_operation
    1 / 0
ZeroDivisionError: division by zero

📦 标准库与常用第三方库

Python的“内置电池”哲学使其拥有丰富的标准库。掌握常用模块可避免重复造轮子,提升开发效率。

〔标准库精选模块〕

模块 核心功能 典型应用
datetime 日期时间处理 时间计算、格式化输出
os 系统交互 文件操作、环境变量
json JSON数据处理 API数据交换、配置文件
re 正则表达式 文本匹配、数据清洗
threading 多线程编程 并发任务、I/O密集型操作
collections 高级数据结构 Counter、deque、OrderedDict

〔JSON序列化与反序列化〕

import json
# Python对象 → JSON字符串
data = {"name": "王五", "scores": [95, 88, 92]}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print(json_str)
# 输出:
# {
#   "name": "王五",
#   "scores": [95, 88, 92]
# }
# JSON字符串 → Python对象
parsed = json.loads(json_str)
print(parsed["scores"])  # [95, 88, 92]
# 文件读写
with open("config.json", "w") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)
with open("config.json", "r") as f:
    loaded = json.load(f)

〔正则表达式常用模式〕

import re
# 匹配邮箱
email_pattern = r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
text = "联系邮箱:admin@company.com 或 support@sub.domain.org"
emails = re.findall(email_pattern, text)
print(emails)  # ['admin@company.com', 'support@sub.domain.org']
# 替换敏感词
text = "用户密码:123456,请勿泄露"
censored = re.sub(r"\d{6,}", "****", text)
print(censored)  # 用户密码:****,请勿泄露
# 分割字符串(支持多个分隔符)
text = "苹果,香蕉;橙子|葡萄"
fruits = re.split(r"[,;|]", text)
print(fruits)  # ['苹果', '香蕉', '橙子', '葡萄']

〔日期时间计算〕

from datetime import datetime, timedelta
# 当前时间
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 2024-06-15 14:30:22
# 计算未来时间
one_week_later = now + timedelta(days=7)
print(one_week_later.strftime("%Y-%m-%d"))  # 2024-06-22
# 解析字符串日期
date_str = "2024-12-31"
date_obj = datetime.strptime(date_str, "%Y-%m-%d")
print(date_obj.year)  # 2024
# 计算时间差
diff = datetime(2024, 12, 31) - datetime.now()
print(f"距离2024年底还有{diff.days}天")

〈第三方库生态概览〉

根据PyPI下载量,以下库为开发者高频使用:

  • requests:HTTP客户端,替代urllib的简洁API
  • beautifulsoup4:HTML/XML解析库,配合requests爬取网页
  • pandas:数据分析核心库,提供DataFrame结构
  • numpy:科学计算基础,高性能数组运算
  • flask/django:Web开发框架,快速构建API和网站
  • pillow:图像处理库,支持格式转换、裁剪、滤镜
# 安装第三方库(命令行)
pip install requests beautifulsoup4 pandas
# 在代码中导入
import requests
from bs4 import BeautifulSoup
import pandas as pd
import numpy as np
from PIL import Image

🚀 实战项目:构建Python学习助手

通过综合运用所学知识,开发一个命令行Python学习助手,具备语法查询、代码示例展示、练习生成功能。

〔项目结构设计〕

python-tutor/
├── main.py           # 程序入口
├── data/
│   ├── syntax.json   # 语法知识库
│   └── examples.json # 代码示例库
├── utils/
│   ├── parser.py     # JSON解析工具
│   └── formatter.py  # 格式化输出
└── requirements.txt  # 依赖声明

〔syntax.json示例〕

{
  "变量": {
    "定义": "使用赋值语句创建变量",
    "命名规则": [
      "只能包含字母、数字、下划线",
      "不能以数字开头",
      "区分大小写"
    ],
    "示例": "name = 'Python'"
  },
  "列表": {
    "定义": "有序可变的集合",
    "常用操作": ["增删改查", "切片", "推导式"],
    "示例": "fruits = ['apple', 'banana']"
  }
}

〔examples.json示例〕

{
  "斐波那契": {
    "递归版": "def fib(n):\n    return 1 if n <= 2 else fib(n-1) + fib(n-2)",
    "迭代版": "def fib(n):\n    a, b = 1, 1\n    for _ in range(n-1):\n        a, b = b, a+b\n    return a"
  },
  "装饰器": {
    "日志装饰器": "def log(func):\n    def wrapper(*args, **kwargs):\n        print(f'调用{func.__name__}')\n        return func(*args, **kwargs)\n    return wrapper"
  }
}

〔主逻辑实现〕

import json
import os
class PythonTutor:
    def __init__(self):
        self.syntax = self._load_data("syntax.json")
        self.examples = self._load_data("examples.json")
    def _load_data(self, filename):
        """加载JSON数据"""
        filepath = os.path.join("data", filename)
        try:
            with open(filepath, "r", encoding="utf-8") as f:
                return json.load(f)
        except FileNotFoundError:
            print(f"错误:{filepath} 文件不存在")
            return {}
    def search_syntax(self, keyword):
        """搜索语法知识"""
        results = []
        for topic, content in self.syntax.items():
            if keyword.lower() in topic.lower():
                results.append((topic, content))
        return results
    def get_example(self, topic, variant="递归版"):
        """获取代码示例"""
        if topic in self.examples:
            return self.examples[topic].get(variant, "未找到该示例")
        return "未找到相关主题"
# 使用示例
tutor = PythonTutor()
results = tutor.search_syntax("列表")
for topic, content in results:
    print(f"【{topic}】\n定义:{content['定义']}\n示例:{content['示例']}\n")

〔命令行界面〕

def main():
    tutor = PythonTutor()
    print("欢迎使用Python学习助手!")
    print("支持命令:syntax <关键词> | example <主题> | quit")
    while True:
        cmd = input("> ").strip()
        if cmd.lower() == "quit":
            print("再见!")
            break
        parts = cmd.split(maxsplit=1)
        if len(parts) < 2:
            print("命令格式错误")
            continue
        action, arg = parts
        if action == "syntax":
            results = tutor.search_syntax(arg)
            if results:
                for topic, content in results:
                    print(f"=== {topic} ===")
                    print(f"定义:{content['定义']}")
                    print(f"示例:{content['示例']}")
            else:
                print("未找到相关语法")
        elif action == "example":
            # 简化处理,实际可扩展支持变体
            example = tutor.get_example(arg)
            print(f"【{arg}示例】")
            print(example)
        else:
            print("未知命令")
if __name__ == "__main__":
    main()

运行效果:

欢迎使用Python学习助手!
支持命令:syntax <关键词> | example <主题> | quit
> syntax 列表
=== 列表 ===
定义:有序可变的集合
示例:fruits = ['apple', 'banana']
> example 斐波那契
【斐波那契示例】
def fib(n):
    a, b = 1, 1
    for _ in range(n-1):
        a, b = b, a+b
    return a