欢迎访问 Python基础学习网 | 网站备案号:蜀ICP备2026035467号-3

Python基础学习|系统入门与进阶指南

Python作为当今最流行、最易学、应用最广的编程语言之一,正被广泛应用于数据分析、人工智能、Web开发、自动化运维、网络爬虫、科学计算、教育科研等领域。无论您是零基础的小白、在校学生、转行者,还是希望系统提升编程能力的职场人士,Python基础学习都是您迈出第一步的关键起点。

本页面提供全面、系统、深入的Python基础学习资源,涵盖从环境搭建、语法结构、数据类型到函数编程、模块使用、异常处理、文件操作、网络编程、爬虫开发、自动化办公、Web开发等核心模块,配合大量真实代码示例、对比表格、流程图解与学习路径建议,助您构建扎实的编程基础,形成清晰的知识体系。

我们坚持“学以致用”的理念,所有内容均基于真实项目经验提炼,强调可操作性与工程思维,拒绝空洞理论。每个章节均包含典型应用场景、常见误区、调试技巧与最佳实践,确保您在掌握语法的同时,理解Python的编程哲学与设计范式。

为什么选择Python作为入门语言?

与其他编程语言相比,Python具有以下显著优势:

  • 语法简洁清晰:采用接近自然语言的表达方式,缩进机制强制代码规范,极大降低初学者理解门槛;
  • 生态丰富强大:拥有超过35万个第三方库(PyPI),覆盖从AI(TensorFlow、PyTorch)、Web(Django、Flask)、自动化(Selenium、PyAutoGUI)到办公(openpyxl、python-docx)等全场景;
  • 跨平台兼容性好:支持Windows、macOS、Linux、树莓派等主流操作系统,一次编写,多处运行;
  • 社区活跃高效:全球数百万开发者组成的活跃社区,提供海量教程、问答与开源项目,问题解决效率极高;
  • 学习曲线平缓:无复杂指针、内存管理等底层细节干扰,可快速进入“解决问题”阶段,增强学习成就感。

但需注意:Python并非“万能胶水语言”的替代品。对于高并发、低延迟、嵌入式等场景,仍需结合C/C++、Rust、Go等语言。**Python基础学习**的目标是建立编程思维与工程能力,而非追求极致性能。

学习路径建议(新手友好版)

  1. 安装Python:推荐使用Python 3.10+版本,通过官网或Anaconda安装;
  2. 配置编辑器:PyCharm(专业版)、VS Code + Python插件、Jupyter Notebook(适合交互式学习);
  3. 掌握基础语法:变量、数据类型、运算符、流程控制(if/for/while)、输入输出;
  4. 理解核心数据结构:列表、元组、字典、集合的特性与使用场景;
  5. 函数与模块:自定义函数、参数传递、模块导入机制、包结构;
  6. 异常处理与调试:try/except、日志记录、断言使用;
  7. 文件操作:文本/二进制文件读写、路径处理、上下文管理器;
  8. 进阶方向选择:数据分析(Pandas)、网络编程(socket/requests)、爬虫(BeautifulSoup/Scrapy)、自动化(selenium)、Web开发(Flask/Django)等。

本页面将按此逻辑展开,每个模块均含完整示例、对比分析与常见陷阱提醒。建议配合本地实践,边学边练,效果更佳。

一、Python基础语法核心要点

**Python基础学习**的起点在于掌握其语法规范与编程范式。Python采用动态类型、强类型、解释型语言设计,这意味着变量类型无需声明,但类型转换必须显式;解释执行带来开发效率,但运行速度低于编译型语言。理解这些底层特性,有助于规避常见错误。

1.1 变量与命名规范

变量命名遵循“小写字母+下划线”风格(snake_case),避免使用Python关键字(如class、def、if等)。变量赋值采用“=”,但并非传统意义上的“存储”,而是绑定引用(binding)。例如:

x = 10
y = x
x = 20
print(y)  # 输出:10

此处y绑定的是10的引用,修改x不会影响y。对于可变对象(如列表),则需注意引用共享问题:

a = [1, 2, 3]
b = a
a.append(4)
print(b)  # 输出:[1, 2, 3, 4]

解决方法:使用浅拷贝(b = a.copy())或深拷贝(import copy; b = copy.deepcopy(a))。

1.2 数据类型与运算符

Python内置六种标准数据类型:Number(数字)、String(字符串)、List(列表)、Tuple(元组)、Dict(字典)、Set(集合)。其中Number、String、Tuple为不可变类型;List、Dict、Set为可变类型。

类型是否可变典型用途常见操作
int / float否数值计算+, -, *, /, //, %, **
str否文本处理+, *, len(), .split(), .join(), .replace()
list是有序序列append(), insert(), pop(), sort(), sorted()
tuple否固定数据集索引、切片、解包
dict是键值映射.get(), .keys(), .values(), .items()
set是去重、集合运算union(), intersection(), difference()

特别提醒:字符串拼接应避免在循环中使用“+”,推荐使用str.join()或f-string(Python 3.6+)提升性能。例如:

# 低效写法
s = ""
for i in range(1000):
    s += str(i)
# 高效写法
s = "".join(str(i) for i in range(1000))
# f-string写法(推荐)
name = "张三"
age = 25
msg = f"姓名:{name},年龄:{age}"

1.3 流程控制结构

Python通过缩进(4空格)定义代码块,替代传统的大括号。常见结构包括:

  • if-elif-else:支持多条件判断,注意使用“elif”而非“else if”;
  • for循环:遍历可迭代对象(列表、字符串、字典等),支持break、continue;
  • while循环:条件满足时重复执行,需手动更新循环变量;
  • 三元表达式:x if condition else y;
  • 列表推导式:[expr for item in iterable if condition],简洁高效。

示例:筛选1~100中能被3整除的偶数

# 传统写法
nums = []
for i in range(1, 101):
    if i % 3 == 0 and i % 2 == 0:
        nums.append(i)
# 推导式写法
nums = [i for i in range(1, 101) if i % 6 == 0]
# 输出:[6, 12, 18, ..., 96]

1.4 输入与输出

标准输入使用input()函数,返回字符串类型,需手动转换:

age = int(input("请输入年龄:"))
height = float(input("请输入身高(米):"))
print(f"年龄:{age},身高:{height:.2f}米")

输出使用print(),支持格式化参数:

  • sep:分隔符,默认为空格;
  • end:结尾符,默认为换行;
  • file:输出目标,默认为sys.stdout;
  • flush:是否立即刷新缓冲区。

示例:倒计时输出(不换行)

import time
for i in range(5, 0, -1):
    print(f"倒计时:{i}秒...", end="\r")
    time.sleep(1)
print("发射!")

二、核心数据结构详解

**Python基础学习**中,数据结构是程序逻辑的骨架。正确选择数据类型,可大幅提升代码可读性与性能。本节将对比列表、元组、字典、集合的特性与适用场景。

2.1 列表(List)

列表是有序、可变的序列,支持索引、切片、追加、排序等操作。常用于存储同质数据或需要频繁修改的集合。

典型场景:

  • 存储学生成绩列表;
  • 收集API返回的多条数据;
  • 作为栈(后进先出)或队列(先进先出)使用。

注意陷阱:

  • 避免在遍历列表时直接修改其长度(如删除元素),应创建副本或使用列表推导式过滤;
  • 浅拷贝问题:[1,2] + [3,4]生成新列表,但嵌套列表仍共享引用。
# 创建列表
scores = [95, 88, 76, 92]
names = list(("张三", "李四", "王五"))
# 修改与查询
scores[1] = 90  # 修改第二个元素
print(scores[0:2])  # 切片:[95, 90]
print(scores.index(90))  # 查找索引:1
# 追加与插入
scores.append(85)
scores.insert(0, 100)  # 插入到开头
# 删除元素
removed = scores.pop()  # 移除末尾
scores.remove(76)  # 移除指定值
# 排序(原地)
scores.sort(reverse=True)  # 降序
scores.reverse()  # 反转

2.2 元组(Tuple)

元组是有序、不可变的序列,常用于固定数据集、函数多返回值、字典键等场景。其不可变性带来哈希能力(可作为字典键)与内存效率。

典型场景:

  • 返回坐标(x, y)或RGB颜色值(r, g, b);
  • 数据库查询结果;
  • 作为字典的键(需内部元素也可哈希)。

注意陷阱:

  • 单元素元组需加逗号:(1,),否则被识别为普通括号;
  • 嵌套可变对象时仍可修改内部状态:
point = (10, 20)  # 正确
coord = (10)      # 错误!实际为int类型
data = ([1, 2], [3, 4])
data[0].append(5)  # 合法!元组本身未变,内部列表可变
print(data)  # 输出:([1, 2, 5], [3, 4])

2.3 字典(Dict)

字典是无序、可变的键值对集合,通过哈希表实现O(1)时间复杂度的查找。键必须可哈希(不可变),值无限制。

典型场景:

  • 存储用户信息(name, age, email);
  • 配置项管理(host, port, timeout);
  • 计数器(统计词频、访问量)。

注意陷阱:

  • 直接访问不存在的键会抛出KeyError,推荐使用.get();
  • 遍历时修改字典大小会报错,应遍历键的副本。
# 创建字典
user = {"name": "张三", "age": 25}
config = dict(host="localhost", port=8080)
# 访问与修改
print(user["name"])           # 报错风险:若键不存在
print(user.get("email", "未填写"))  # 安全:默认值
user["age"] = 26              # 修改
user["email"] = "zhangsan@example.com"  # 新增
# 遍历
for key, value in user.items():
    print(f"{key} = {value}")
# 统计词频
text = "Python基础学习很有趣,Python很强大"
words = text.replace(",", "").split()
freq = {}
for w in words:
    freq[w] = freq.get(w, 0) + 1
print(freq)  # {'Python': 2, '基础学习很有趣': 1, '很强大': 1}

2.4 集合(Set)

集合是无序、不重复的元素集,支持交集、并集、差集等数学运算。常用于去重、成员测试、关系判断。

典型场景:

  • 去除列表重复项;
  • 判断两组数据是否有交集;
  • 快速验证元素是否存在(O(1)时间)。

注意陷阱:

  • 集合本身不可哈希,不能作为字典键或另一集合的元素;
  • 空集合必须用set()创建,{}表示空字典。
# 创建集合
tags = {"Python", "爬虫", "自动化", "Python"}  # 自动去重
unique_tags = set(["Python", "爬虫", "自动化"])
# 基本操作
tags.add("数据分析")
tags.remove("爬虫")  # 不存在则报错
tags.discard("不存在")  # 安全删除
# 关系运算
set_a = {1, 2, 3, 4}
set_b = {3, 4, 5, 6}
print(set_a & set_b)  # 交集:{3, 4}
print(set_a | set_b)  # 并集:{1, 2, 3, 4, 5, 6}
print(set_a - set_b)  # 差集:{1, 2}
# 去重应用
ids = [1, 2, 2, 3, 3, 3]
unique_ids = list(set(ids))  # 注意:顺序可能改变

2.5 数据结构性能对比

操作列表list字典dict集合set元组tuple
索引/查找O(1)(按位置)O(1)(按键)O(1)(成员测试)O(1)
插入末尾O(1)均摊O(1)O(1)不可变
插入中间O(n)——不可变
删除末尾O(1)O(1)O(1)不可变
删除中间O(n)O(1)O(1)不可变
遍历O(n)O(n)O(n)O(n)
内存占用中高(哈希表)中高低

三、函数与模块化编程

**Python基础学习**中,函数是代码复用的核心单元。合理设计函数,可提升可维护性、可测试性与协作效率。Python支持位置参数、关键字参数、默认参数、可变参数等灵活调用方式。

3.1 函数定义与参数传递

函数定义使用def关键字,格式为:def 函数名(参数列表):。参数传递采用“传对象引用”,即传递的是对象的引用,而非值拷贝。

参数类型详解:

  • 位置参数:按顺序传递;
  • 关键字参数:指定参数名,顺序可变;
  • 默认参数:提供默认值,调用时可省略;
  • 可变参数:*args(元组)、**kwargs(字典);
  • 仅限关键字参数:*后参数必须用关键字传递。
def greet(name, msg="你好", *args, **kwargs):
    print(f"{msg}, {name}!")
    if args:
        print(f"额外信息:{', '.join(args)}")
    if kwargs:
        print(f"扩展信息:{kwargs}")
# 调用示例
greet("张三")
# 输出:你好, 张三!
greet("李四", "早上好", "已到岗", "今日任务:代码审查")
# 输出:早上好, 李四!
#      额外信息:已到岗, 今日任务:代码审查
greet("王五", age=28, dept="技术部", role="工程师")
# 输出:你好, 王五!
#      扩展信息:{'age': 28, 'dept': '技术部', 'role': '工程师'}

3.2 返回值与多返回值

Python函数可返回单个或多个值。多返回值本质是返回元组,调用时自动解包:

def get_stats(numbers):
    if not numbers:
        return None, None
    return min(numbers), max(numbers), sum(numbers) / len(numbers)
nums = [10, 20, 30, 40, 50]
min_val, max_val, avg = get_stats(nums)
print(f"最小值:{min_val},最大值:{max_val},平均值:{avg:.2f}")

最佳实践:优先返回结构化数据(如字典或命名元组),增强可读性与扩展性。

3.3 作用域与闭包

Python遵循LEGB规则(Local → Enclosing → Global → Built-in)查找变量。闭包(closure)是指内部函数引用外部函数变量的组合,常用于装饰器、回调等场景。

def make_counter():
    count = 0
    def counter():
        nonlocal count  # 声明使用外层变量
        count += 1
        return count
    return counter
c1 = make_counter()
print(c1())  # 1
print(c1())  # 2
print(c1())  # 3

闭包可替代全局变量,避免命名污染,但需注意内存泄漏风险(长期持有引用)。

3.4 匿名函数与高阶函数

lambda表达式用于定义简单匿名函数,常与map、filter、sorted等高阶函数配合使用:

# map:映射
nums = [1, 2, 3, 4]
squares = list(map(lambda x: x**2, nums))
# filter:过滤
evens = list(filter(lambda x: x % 2 == 0, nums))
# sorted:排序(指定键)
students = [
    {"name": "张三", "score": 88},
    {"name": "李四", "score": 95},
    {"name": "王五", "score": 76}
]
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)

但复杂逻辑不建议使用lambda,应定义具名函数提升可读性。

四、模块与包管理机制

**Python基础学习**中,模块化是大型项目的基础。Python通过模块(.py文件)和包(含__init__.py的目录)组织代码,支持绝对导入与相对导入。

4.1 模块导入方式

常见导入方式包括:

  • import module:导入模块,调用时需加前缀;
  • from module import name:导入特定对象;
  • from module import *:导入全部(不推荐,易冲突);
  • import module as alias:重命名。

示例:导入标准库time与自定义模块

# 导入标准库
import time
from datetime import datetime
# 导入自定义模块(假设在同一目录)
import utils
from utils import calculate_score
# 使用
print(time.time())
print(calculate_score(85, 90))

4.2 包结构规范

标准包结构如下:

project/
├── main.py
└── utils/
    ├── __init__.py
    ├── file_ops.py
    └── text_utils.py

在main.py中可这样导入:

from utils.file_ops import read_file
from utils.text_utils import clean_text
# 或使用相对导入(在utils/__init__.py中)
# from .file_ops import read_file

注意:相对导入仅适用于包内模块,不可在顶层脚本中使用。

4.3 标准库核心模块推荐

os / pathlib
sys
json
re
collections

os / pathlib:文件与系统操作

import os
from pathlib import Path
# 创建目录
Path("logs").mkdir(exist_ok=True)
# 遍历文件
for f in Path(".").glob("*.py"):
    print(f"文件:{f.name},大小:{f.stat().st_size}字节")
# 环境变量
print(os.getenv("PYTHONPATH"))

sys:解释器交互

import sys
# 命令行参数
print(sys.argv)  # ['script.py', 'arg1', 'arg2']
# 路径搜索
print(sys.path)
# 标准输入输出
sys.stdout.write("提示:")

json:数据序列化

import json
data = {"name": "张三", "age": 25}
json_str = json.dumps(data, ensure_ascii=False)
print(json_str)
loaded = json.loads(json_str)

re:正则表达式

import re
text = "联系电话:138-1234-5678"
pattern = r"\d{3}-\d{4}-\d{4}"
match = re.search(pattern, text)
if match:
    print(f"找到号码:{match.group()}")

collections:高级数据结构

from collections import Counter, defaultdict, deque
# 计数器
words = ["a", "b", "a", "c", "b", "a"]
counter = Counter(words)
print(counter.most_common(2))  # [('a', 3), ('b', 2)]
# 默认字典
dd = defaultdict(int)
dd["count"] += 1  # 无需初始化
# 双端队列
dq = deque([1, 2, 3])
dq.appendleft(0)
dq.append(4)
print(dq)  # deque([0, 1, 2, 3, 4])

五、异常处理与调试技巧

**Python基础学习**中,健壮的错误处理是专业开发的标志。Python通过try-except-finally结构处理异常,支持自定义异常类型。

5.1 常见异常类型

系统内置异常继承自BaseException,常用子类包括:

示例:捕获并处理异常

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("警告:除数不能为零!")
        return None
    except TypeError:
        print("错误:参数类型不匹配!")
        return None
    finally:
        print("操作完成")
print(safe_divide(10, 0))  # 输出:警告:除数不能为零!\n操作完成\nNone

5.2 自定义异常

通过继承Exception类创建自定义异常,用于业务逻辑错误:

class InvalidScoreError(Exception):
    def __init__(self, score):
        self.score = score
        super().__init__(f"无效分数:{score}(应为0-100)")
def validate_score(score):
    if not 0 <= score <= 100:
        raise InvalidScoreError(score)
    return score
try:
    validate_score(120)
except InvalidScoreError as e:
    print(e)  # 输出:无效分数:120(应为0-100)

5.3 调试技巧

高效调试是程序员核心技能,推荐以下方法:

  1. print调试:简单直接,但需清理;
  2. logging模块:支持分级(DEBUG/INFO/WARNING/ERROR/CRITICAL),可输出到文件;
  3. 断言:assert condition, "错误信息",用于开发阶段检查;
  4. 调试器pdb:交互式调试,支持单步、断点、变量查看。
import logging
logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
def process_data(data):
    logging.debug(f"输入数据:{data}")
    if not data:
        logging.warning("数据为空!")
        return []
    result = [x * 2 for x in data]
    logging.info(f"处理完成,结果:{result}")
    return result

5.4 断言与调试开关

断言仅在调试模式有效,发布时可关闭(python -O运行):

def calculate_avg(numbers):
    assert isinstance(numbers, list), "参数必须是列表"
    assert len(numbers) > 0, "列表不能为空"
    return sum(numbers) / len(numbers)
# 正常运行
print(calculate_avg([1, 2, 3]))
# 发布时关闭断言
# python -O script.py

六、文件操作与路径管理

**Python基础学习**中,文件I/O是数据持久化的核心。Python通过open()函数操作文件,配合with语句确保资源释放。

6.1 文件读写基础

open()函数参数说明:

文本文件读写示例:

# 写入文本
with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("Python基础学习笔记\n")
    f.write("今日重点:列表推导式\n")
# 读取文本
with open("notes.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)
# 按行读取
with open("notes.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())  # 去除换行

6.2 二进制文件处理

图片、音频、视频等二进制文件需用"rb"或"wb"模式:

# 复制图片
with open("logo.png", "rb") as src, open("logo_copy.png", "wb") as dst:
    dst.write(src.read())

6.3 路径处理与兼容性

使用pathlib.Path统一处理跨平台路径:

from pathlib import Path
# 构建路径
data_dir = Path("data") / "2024" / "reports"
data_dir.mkdir(parents=True, exist_ok=True)
# 拼接路径
config_path = Path.home() / ".config" / "app.ini"
# 获取文件信息
file = Path("notes.txt")
print(f"文件名:{file.name}")
print(f"扩展名:{file.suffix}")
print(f"大小:{file.stat().st_size}字节")
print(f"是否存在:{file.exists()}")

6.4 上下文管理器(with语句)

with语句自动管理资源,即使发生异常也会正确关闭文件:

class FileLogger:
    def __init__(self, filename):
        self.filename = filename
        self.file = None
    def __enter__(self):
        self.file = open(self.filename, "w", encoding="utf-8")
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
    def log(self, msg):
        if self.file:
            self.file.write(f"{msg}\n")
# 使用
with FileLogger("app.log") as logger:
    logger.log("程序启动")
    # 即使此处报错,文件也会关闭

七、网络编程基础

**Python基础学习**中,网络编程是连接外部世界的关键。Python通过socket模块实现底层通信,requests库简化HTTP请求。

7.1 TCP客户端与服务端

服务端(server.py):

import socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("127.0.0.1", 8080))
server.listen(5)
print("服务器启动,等待连接...")
while True:
    client, addr = server.accept()
    print(f"连接来自:{addr}")
    data = client.recv(1024)
    client.send(f"收到:{data.decode()}".encode())
    client.close()

客户端(client.py):

import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("127.0.0.1", 8080))
client.send("你好,服务器!".encode())
response = client.recv(1024)
print(f"服务器响应:{response.decode()}")
client.close()

7.2 HTTP请求与响应

使用requests库发送GET/POST请求:

import requests
# GET请求
response = requests.get("https://api.github.com/repos/python/cpython")
print(f"状态码:{response.status_code}")
print(f"标题:{response.headers['Content-Type']}")
print(f"内容长度:{len(response.text)}")
# 带参数GET
params = {"q": "python", "sort": "stars"}
repos = requests.get("https://api.github.com/search/repositories", params=params)
print(f"搜索结果数:{repos.json()['total_count']}")
# POST请求
payload = {"username": "test", "password": "123456"}
res = requests.post("https://httpbin.org/post", data=payload)
print(res.json()["form"])

7.3 网络错误处理

网络请求需处理常见异常:

import requests
from requests.exceptions import RequestException, Timeout, ConnectionError
try:
    response = requests.get("https://httpbin.org/delay/3", timeout=2)
    print(response.json())
except Timeout:
    print("请求超时!")
except ConnectionError:
    print("连接失败!")
except RequestException as e:
    print(f"请求异常:{e}")

八、网络爬虫实战入门

**Python基础学习**中,爬虫是综合应用的典型场景。通过requests获取页面,BeautifulSoup解析HTML,配合正则表达式提取数据。

8.1 基础爬虫结构

安装依赖:

pip install requests beautifulsoup4 lxml

爬虫代码:

import requests
from bs4 import BeautifulSoup
def fetch_page(url):
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }
    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        return response.text
    except requests.RequestException as e:
        print(f"请求失败:{e}")
        return None
def parse_news(html):
    soup = BeautifulSoup(html, "lxml")
    items = []
    for li in soup.select("li.news-item"):
        title = li.a.get_text(strip=True)
        link = li.a["href"]
        date = li.span.get_text(strip=True)
        items.append({"title": title, "link": link, "date": date})
    return items
# 使用
html = fetch_page("https://example.com/news")
if html:
    news = parse_news(html)
    for item in news[:5]:
        print(f"[{item['date']}] {item['title']}")

8.2 反爬策略应对

常见反爬手段及对策:

注意:遵守robots.txt协议,尊重网站权益!

8.3 数据存储方案

爬取数据可存储为:

示例:存储为CSV

import csv
with open("news.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["title", "link", "date"])
    writer.writeheader()
    writer.writerows(news)

九、自动化办公实战

**Python基础学习**的终极目标是提升工作效率。通过Python自动化处理Excel、Word、PDF、邮件等办公任务,释放重复劳动。

9.1 Excel自动化(openpyxl)

安装:pip install openpyxl

from openpyxl import Workbook, load_workbook
# 创建新工作簿
wb = Workbook()
ws = wb.active
ws.title = "成绩表"
# 写入数据
ws.append(["姓名", "语文", "数学", "英语"])
ws.append(["张三", 92, 88, 95])
ws.append(["李四", 85, 90, 88])
# 样式设置
from openpyxl.styles import Font
ws["A1"].font = Font(bold=True)
# 保存
wb.save("scores.xlsx")
# 读取已有文件
wb = load_workbook("scores.xlsx")
ws = wb["成绩表"]
for row in ws.iter_rows(min_row=2, values_only=True):
    print(row)  # 输出:('张三', 92, 88, 95)

9.2 Word文档处理(python-docx)

安装:pip install python-docx

from docx import Document
from docx.shared import Pt
# 创建文档
doc = Document()
doc.add_heading("Python基础学习总结", 0)
# 添加段落
doc.add_heading("一、核心知识点", level=1)
doc.add_paragraph("1. 变量与数据类型")
doc.add_paragraph("2. 函数与模块化")
doc.add_paragraph("3. 文件与异常处理")
# 设置字体
from docx.enum.text import WD_ALIGN_PARAGRAPH
paragraph = doc.add_paragraph("总结:Python易学易用,适合快速开发。")
paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
# 保存
doc.save("summary.docx")

9.3 邮件自动发送(smtplib)

import smtplib
from email.mime.text import MIMEText
from email.header import Header
# 邮件内容
msg = MIMEText("Python基础学习完成!\n\n感谢您的关注。", "plain", "utf-8")
msg["From"] = Header("Python学习助手 ")
msg["To"] = Header("用户 ")
msg["Subject"] = Header("Python学习进度通知", "utf-8")
# 发送邮件
try:
    server = smtplib.SMTP_SSL("smtp.example.com", 465)
    server.login("sender@example.com", "password")
    server.sendmail("sender@example.com", ["receiver@example.com"], msg.as_string())
    server.quit()
    print("邮件发送成功!")
except smtplib.SMTPException as e:
    print(f"发送失败:{e}")

9.4 文件批量处理

示例:批量重命名指定目录下所有.txt文件

import os
def batch_rename(folder):
    for i, filename in enumerate(os.listdir(folder)):
        if filename.endswith(".txt"):
            old_path = os.path.join(folder, filename)
            new_name = f"note_{i+1:03d}.txt"
            new_path = os.path.join(folder, new_name)
            os.rename(old_path, new_path)
            print(f"{filename} → {new_name}")
batch_rename("notes")

十、Web开发入门(Flask框架)

**Python基础学习**的延伸方向之一是Web开发。Flask以轻量、灵活著称,适合快速构建API与小型网站。

10.1 Flask基础项目结构

安装:pip install flask

app.py:

from flask import Flask, render_template, request, jsonify
app = Flask(__name__)
@app.route("/")
def index():
    return render_template("index.html", title="Python基础学习")
@app.route("/api/data")
def get_data():
    return jsonify({
        "status": "success",
        "data": [{"id": 1, "name": "变量"}, {"id": 2, "name": "函数"}]
    })
@app.route("/submit", methods=["POST"])
def submit():
    name = request.form.get("name")
    score = request.form.get("score")
    return f"提交成功!姓名:{name},分数:{score}"
if __name__ == "__main__":
    app.run(debug=True)

templates/index.html:

<html>
<head><title>{{ title }}</title></head>
<body>
    <h1>欢迎学习Python基础!</h1>
    <form method="post" action="/submit">
        <input name="name" placeholder="姓名">
        <input name="score" placeholder="分数">
        <button type="submit">提交</button>
    </form>
    <div id="data"></div>
    <script>
        fetch("/api/data")
            .then(r => r.json())
            .then(d => document.getElementById("data").innerHTML = JSON.stringify(d.data));
    </script>
</body>
</html>

10.2 RESTful API设计原则