Python代码大全100例

100个真实可运行的Python实战代码示例|覆盖12大核心应用场景|零基础入门到进阶提升

《Python代码大全100例》核心价值

本合集系统整合Python编程从基础语法到高阶应用的完整知识体系,精选100个高频、实用、可复用的代码示例,每个示例均包含以下要素:

  • ✅ 完整可运行的代码实现(经Python 3.9+验证)
  • ✅ 逐行关键注释与逻辑说明
  • ✅ 预期输出结果展示与异常处理方案
  • ✅ 扩展思考与最佳实践建议
  • ✅ 相关标准库/第三方库使用指南

与传统“教程式”学习不同,本合集采用“问题驱动+代码反哺”模式,以真实业务场景为牵引,帮助学习者快速建立Python编程思维与工程化能力。特别适合以下用户:

  • 编程零基础者:通过循序渐进的案例建立信心与兴趣
  • 转行开发者:快速掌握Python核心语法与常用库
  • 技术面试者:强化算法、数据结构与工程实践能力
  • 教学研究者:获取高质量教学案例与课堂演示素材

所有代码示例均经过严格校验,确保在主流Python发行版(CPython 3.7+)中稳定运行,无语法错误、无运行时异常,可直接复制粘贴至IDE或Jupyter Notebook中执行验证。

为什么选择100个示例?——从“量”到“质”的学习跃迁

研究表明,编程技能的掌握需要通过“刻意练习”实现神经回路的重构。单一示例难以覆盖知识全貌,而100个高质量示例则构成完整的能力拼图:

① 知识覆盖广度

100例覆盖Python语法、数据结构、文件处理、网络编程、Web框架、数据库操作、自动化脚本、数据分析、机器学习等12大领域,形成系统知识图谱。

② 认知梯度合理

按“基础语法→数据处理→高级应用”三级递进设计,前20例夯实基础,中间50例强化实践,后30例拓展前沿,符合认知发展规律。

③ 实战场景真实

所有案例源自真实项目需求:如自动整理下载文件夹、爬取电商价格数据、生成月度报表、构建简易API服务、训练文本分类模型等,拒绝“玩具级”示例。

通过100次“代码编写→运行验证→问题调试→优化迭代”的完整闭环,学习者将逐步内化为编程直觉,最终实现从“能看懂代码”到“能写出代码”再到“能优化代码”的三级跃迁。

一、基础语法10例|构建编程认知基石

从变量声明到函数定义,掌握Python核心语法结构

① 变量与数据类型操作

在Python中,变量无需声明类型,解释器自动推断。以下代码演示常见数据类型的声明、转换与操作:

print("整数类型转换:") a = 42 b = float(a) c = complex(a) print(f"整数 {a} → 浮点数 {b} → 复数 {c}") print("\n字符串与数字转换:") s = "123" i = int(s) print(f"字符串 '{s}' → 整数 {i},类型:{type(i)}") print("\n列表生成式:") evens = [x for x in range(1, 11) if x % 2 == 0] print(f"1-10的偶数列表:{evens}") print("\n集合去重:") words = ["apple", "banana", "apple", "cherry"] unique = set(words) print(f"去重后:{unique}")

关键要点:Python中所有数据都是对象,类型转换通过构造函数实现;列表生成式是高效创建列表的语法糖;集合自动去重且无序。

② 条件与循环结构

掌握条件判断与循环是编程基础。以下示例实现“九九乘法表”与“斐波那契数列前20项”:

# 九九乘法表(格式化输出) for i in range(1, 10): for j in range(1, i + 1): print(f"{j}×{i}={i*j:<2}", end="\t") print() # 斐波那契数列(前20项) def fibonacci(n): a, b = 0, 1 seq = [] for _ in range(n): seq.append(a) a, b = b, a + b return seq print("\n斐波那契前20项:") print(fibonacci(20))

输出格式说明:print(..., end="\t")控制不换行并用制表符分隔;{i*j:<2}实现左对齐占位2字符,确保排版整齐。

③ 函数定义与参数传递

Python函数支持多种参数形式,以下示例演示默认参数、可变参数与关键字参数的使用:

def greet(name, greeting="您好", *args, **kwargs): print(f"{greeting},{name}!") if args: print("附加信息:", ", ".join(args)) if kwargs: print("详细信息:") for k, v in kwargs.items(): print(f" - {k}: {v}") greet("张三") greet("李四", "早上好") greet("王五", "欢迎", "来自北京", "30岁", age=30, city="上海")

执行结果:第一个调用使用默认问候语;第二个指定自定义问候;第三个传递可变参数与关键字参数,体现Python函数的灵活性。

④ 模块与包管理

模块化是大型项目基础。以下创建自定义模块并调用:

# math_utils.py(模块文件) def add(a, b): return a + b def multiply(a, b): return a * b # main.py(主程序) import math_utils print("加法:", math_utils.add(3, 5)) print("乘法:", math_utils.multiply(4, 7)) # 使用as重命名 from math_utils import multiply as times print("重命名调用:", times(6, 8))

关键规范:Python模块文件以.py结尾;推荐使用from module import name提升可读性;避免from module import *防止命名冲突。

⑤ 异常处理机制

健壮的程序需处理异常。以下示例实现文件读取的安全封装:

def safe_read_file(filepath): try: with open(filepath, 'r', encoding='utf-8') as f: return f.read() except FileNotFoundError: return f"错误:文件 '{filepath}' 不存在" except PermissionError: return f"错误:无权限读取 '{filepath}'" except Exception as e: return f"未知错误:{e}" # 测试调用 print(safe_read_file("test.txt")) print(safe_read_file("nonexistent.txt"))

最佳实践:优先捕获具体异常;使用with语句确保资源释放;记录异常日志便于调试。

⑥ 面向对象编程基础

以下实现一个简单的银行账户类,演示封装与继承:

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}" return "存款金额需大于0" def withdraw(self, amount): if 0 < amount <= self.__balance: self.__balance -= amount return f"取出 {amount},当前余额:{self.__balance}" return "取款金额无效" def get_balance(self): return self.__balance # 继承实现VIP账户 class VIPAccount(BankAccount): def __init__(self, owner, balance=0): super().__init__(owner, balance) self.__bonus_points = 0 def deposit(self, amount): result = super().deposit(amount) self.__bonus_points += int(amount // 100) return f"{result}(累计积分:{self.__bonus_points})" # 使用示例 account = VIPAccount("李四", 1000) print(account.deposit(500)) print(account.withdraw(200))

要点说明:私有属性用双下划线实现封装;super()调用父类方法;子类可重写父类方法实现多态。

⑦ 装饰器实现

装饰器用于增强函数功能。以下实现带日志的函数计时器:

import time from functools import wraps def timer(func): @wraps(func) 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_function(): time.sleep(0.5) return "完成" print(slow_function()) print(f"函数名:{slow_function.__name__}") # 保留原函数名

关键机制:@wraps保留原函数元数据;*args, **kwargs支持任意参数;装饰器在导入时执行,不影响原函数逻辑。

⑧ 生成器与迭代器

生成器高效处理大数据流。以下实现无限斐波那契数列生成器:

def fibonacci_gen(): a, b = 0, 1 while True: yield a a, b = b, a + b # 获取前15项 fib = fibonacci_gen() result = [next(fib) for _ in range(15)] print("前15项斐波那契:", result) # 生成器表达式 squares = (x**2 for x in range(10)) print("平方生成器:", list(squares))

优势对比:生成器按需计算,内存占用O(1);列表推导式一次性分配内存O(n);适合处理流式数据。

⑨ 上下文管理器

上下文管理器确保资源正确释放。以下实现自定义文件上下文管理器:

class CustomFile: def __init__(self, filename, mode): self.filename = filename self.mode = mode self.file = None def __enter__(self): self.file = open(self.filename, self.mode, encoding='utf-8') return self.file def __exit__(self, exc_type, exc_val, exc_tb): if self.file: self.file.close() print("文件已关闭") # 使用示例 with CustomFile("test.txt", "w") as f: f.write("测试内容") print("写入完成")

机制说明:__enter__返回上下文对象;__exit__处理异常与资源清理;with语句自动调用这两个方法。

⑩ 命令行参数解析

使用argparse构建CLI工具:

import argparse parser = argparse.ArgumentParser(description="文件处理工具") parser.add_argument("input", 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}") # 模拟处理 with open(args.input, 'r', encoding='utf-8') as f_in: content = f_in.read() with open(args.output, 'w', encoding='utf-8') as f_out: f_out.write(content.upper()) print("处理完成!")

使用示例:python tool.py data.txt -o result.txt -v

二、数据结构与算法15例|构建高效数据处理能力

掌握链表、栈队列、树等结构及排序查找算法

① 单向链表实现

手动实现链表结构,理解指针逻辑:

class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def append(self, data): new_node = Node(data) if not self.head: self.head = new_node return current = self.head while current.next: current = current.next current.next = new_node def display(self): nodes = [] current = self.head while current: nodes.append(str(current.data)) current = current.next return " → ".join(nodes) # 使用示例 ll = LinkedList() ll.append(10) ll.append(20) ll.append(30) print("链表结构:", ll.display())

应用场景:内存管理、LRU缓存实现、图的邻接表存储。

② 二叉树遍历

实现前序、中序、后序与层序遍历:

class TreeNode: def __init__(self, val=0): self.val = val self.left = None self.right = None def preorder(root): if root: print(root.val, end=" ") preorder(root.left) preorder(root.right) def inorder(root): if root: inorder(root.left) print(root.val, end=" ") inorder(root.right) def postorder(root): if root: postorder(root.left) postorder(root.right) print(root.val, end=" ") def level_order(root): if not root: return queue = [root] while queue: node = queue.pop(0) print(node.val, end=" ") if node.left: queue.append(node.left) if node.right: queue.append(node.right) # 构建测试树 root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.left = TreeNode(4) root.left.right = TreeNode(5) print("前序:", end="") preorder(root) print("\n中序:", end="") inorder(root) print("\n后序:", end="") postorder(root) print("\n层序:", end="") level_order(root)

关键差异:前序用于复制树,中序用于二叉搜索树排序,后序用于释放树内存。

③ 排序算法对比

实现快速排序、归并排序与堆排序:

def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right) def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left = merge_sort(arr[:mid]) right = merge_sort(arr[mid:]) return merge(left, right) def merge(left, right): result = [] i = j = 0 while i < len(left) and j < len(right): if left[i] <= right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 result.extend(left[i:]) result.extend(right[j:]) return result def heap_sort(arr): def heapify(arr, n, i): largest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and arr[left] > arr[largest]: largest = left if right < n and arr[right] > arr[largest]: largest = right if largest != i: arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest) n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) for i in range(n - 1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr # 测试 data = [64, 34, 25, 12, 22, 11, 90] print("快速排序:", quick_sort(data.copy())) print("归并排序:", merge_sort(data.copy())) print("堆排序:", heap_sort(data.copy()))

复杂度对比:快速排序平均O(n log n),最坏O(n²);归并排序稳定O(n log n);堆排序O(n log n)但不稳定。

④ 二分查找实现

标准二分查找与变体实现:

def binary_search(arr, target): left, right = 0, len(arr) - 1 while left <= right: mid = (left + right) // 2 if arr[mid] == target: return mid elif arr[mid] < target: left = mid + 1 else: right = mid - 1 return -1 def left_bound(arr, target): left, right = 0, len(arr) while left < right: mid = (left + right) // 2 if arr[mid] < target: left = mid + 1 else: right = mid return left if left < len(arr) and arr[left] == target else -1 # 测试 data = [1, 3, 5, 7, 9, 11, 13] print("标准查找:", binary_search(data, 7)) print("左边界查找:", left_bound(data, 7))

应用场景:数据库索引、字典查找、有序数据快速定位。

⑤ 汉诺塔递归解

经典递归问题实现:

def hanoi(n, source, auxiliary, target): if n == 1: print(f"将盘子1从 {source} 移到 {target}") return hanoi(n-1, source, target, auxiliary) print(f"将盘子{n}从 {source} 移到 {target}") hanoi(n-1, auxiliary, source, target) # 3层汉诺塔 print("汉诺塔3层移动步骤:") hanoi(3, "A", "B", "C")

递归思想:将n个盘子问题分解为两个n-1子问题;时间复杂度O(2ⁿ),空间复杂度O(n)。

⑥ 贪心算法:活动选择问题

选择最多不重叠活动:

def activity_selection(start, finish): n = len(start) activities = sorted(zip(start, finish), key=lambda x: x[1]) selected = [activities[0]] last_end = activities[0][1] for i in range(1, n): if activities[i][0] >= last_end: selected.append(activities[i]) last_end = activities[i][1] return selected # 测试 start = [1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12] finish = [4, 5, 6, 7, 9, 9, 10, 11, 12, 14, 16] result = activity_selection(start, finish) print("最多活动数:", len(result)) print("选中活动:", result)

贪心策略:按结束时间排序,每次选择最早结束的兼容活动。

⑦ 动态规划:背包问题

0-1背包问题求解:

def knapsack(weights, values, capacity): n = len(weights) dp = [[0] * (capacity + 1) for _ in range(n + 1)] for i in range(1, n + 1): for w in range(1, capacity + 1): if weights[i-1] <= w: dp[i][w] = max(values[i-1] + dp[i-1][w-weights[i-1]], dp[i-1][w]) else: dp[i][w] = dp[i-1][w] return dp[n][capacity] # 测试 weights = [2, 3, 4, 5] values = [3, 4, 5, 6] capacity = 5 print("最大价值:", knapsack(weights, values, capacity))

状态转移:dp[i][w]表示前i个物品在容量w下的最大价值;空间可优化为O(n)。

⑧ 拓扑排序

有向无环图(DAG)的拓扑排序:

from collections import defaultdict, deque def topological_sort(graph): in_degree = defaultdict(int) for u in graph: for v in graph[u]: in_degree[v] += 1 queue = deque([u for u in graph if in_degree[u] == 0]) result = [] while queue: u = queue.popleft() result.append(u) for v in graph[u]: in_degree[v] -= 1 if in_degree[v] == 0: queue.append(v) return result if len(result) == len(graph) else [] # 测试:课程依赖关系 graph = { "数学": [], "物理": ["数学"], "化学": ["数学"], "编程": ["物理", "化学"] } print("拓扑排序:", topological_sort(graph))

应用场景:课程安排、任务调度、依赖解析。

⑨ 并查集(Union-Find)

高效处理集合合并与查询:

class UnionFind: def __init__(self, n): self.parent = list(range(n)) self.rank = [0] * n def find(self, x): if self.parent[x] != x: self.parent[x] = self.find(self.parent[x]) return self.parent[x] def union(self, x, y): px, py = self.find(x), self.find(y) if px == py: return False if self.rank[px] < self.rank[py]: px, py = py, px self.parent[py] = px if self.rank[px] == self.rank[py]: self.rank[px] += 1 return True # 测试:连通分量 uf = UnionFind(5) uf.union(0, 1) uf.union(1, 2) print("0和2连通:", uf.find(0) == uf.find(2)) print("0和3连通:", uf.find(0) == uf.find(3))

路径压缩+按秩合并使时间复杂度趋近O(1),用于网络连通性、最小生成树。

⑩ 字典树(Trie)

高效字符串前缀匹配:

class TrieNode: def __init__(self): self.children = {} self.is_end = False class Trie: def __init__(self): self.root = TrieNode() def insert(self, word): node = self.root for char in word: if char not in node.children: node.children[char] = TrieNode() node = node.children[char] node.is_end = True def search(self, word): node = self.root for char in word: if char not in node.children: return False node = node.children[char] return node.is_end # 测试 trie = Trie() trie.insert("apple") trie.insert("app") print("搜索'apple':", trie.search("apple")) print("搜索'app':", trie.search("app")) print("搜索'appl':", trie.search("appl"))

时间复杂度O(m),m为字符串长度;空间换时间,适合前缀匹配与自动补全。

⑪ LRU缓存实现

结合字典与双向链表实现:

class DLinkedNode: def __init__(self, key=0, value=0): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self, capacity): self.cache = {} self.capacity = capacity self.head = DLinkedNode() self.tail = DLinkedNode() self.head.next = self.tail self.tail.prev = self.head def _add_node(self, node): node.prev = self.head node.next = self.head.next self.head.next.prev = node self.head.next = node def _remove_node(self, node): prev = node.prev next = node.next prev.next = next next.prev = prev def _move_to_head(self, node): self._remove_node(node) self._add_node(node) def _pop_tail(self): res = self.tail.prev self._remove_node(res) return res def get(self, key): node = self.cache.get(key) if not node: return -1 self._move_to_head(node) return node.value def put(self, key, value): node = self.cache.get(key) if node: node.value = value self._move_to_head(node) else: new_node = DLinkedNode(key, value) self.cache[key] = new_node self._add_node(new_node) if len(self.cache) > self.capacity: tail = self._pop_tail() del self.cache[tail.key] # 测试 cache = LRUCache(2) cache.put(1, 1) cache.put(2, 2) print("get(1):", cache.get(1)) cache.put(3, 3) print("get(2):", cache.get(2))

核心设计:字典O(1)查找 + 双向链表O(1)移动;最近使用节点移至头部。

⑫ KMP字符串匹配

高效模式匹配算法:

def compute_lps(pattern): lps = [0] * len(pattern) length = 0 i = 1 while i < len(pattern): if pattern[i] == pattern[length]: length += 1 lps[i] = length i += 1 else: if length != 0: length = lps[length-1] else: lps[i] = 0 i += 1 return lps def kmp_search(text, pattern): lps = compute_lps(pattern) i = j = 0 indices = [] while i < len(text): if pattern[j] == text[i]: i += 1 j += 1 if j == len(pattern): indices.append(i - j) j = lps[j-1] elif i < len(text) and pattern[j] != text[i]: if j != 0: j = lps[j-1] else: i += 1 return indices # 测试 text = "ABABDABACDABABCABAB" pattern = "ABABCABAB" print("匹配位置:", kmp_search(text, pattern))

关键思想:利用部分匹配表避免回溯;时间复杂度O(n+m)。

⑬ 最小生成树(Kruskal)

基于并查集的MST算法:

class Edge: def __init__(self, u, v, w): self.u = u self.v = v self.w = w def kruskal(vertices, edges): def find(parent, i): if parent[i] == i: return i return find(parent, parent[i]) def union(parent, rank, x, y): xroot = find(parent, x) yroot = find(parent, y) if rank[xroot] < rank[yroot]: parent[xroot] = yroot elif rank[xroot] > rank[yroot]: parent[yroot] = xroot else: parent[yroot] = xroot rank[xroot] += 1 edges.sort(key=lambda x: x.w) parent = list(range(vertices)) rank = [0] * vertices mst = [] for edge in edges: x = find(parent, edge.u) y = find(parent, edge.v) if x != y: mst.append(edge) union(parent, rank, x, y) return mst # 测试 vertices = 4 edges = [ Edge(0, 1, 10), Edge(0, 2, 6), Edge(0, 3, 5), Edge(1, 3, 15), Edge(2, 3, 4) ] mst = kruskal(vertices, edges) print("MST边:", [(e.u, e.v, e.w) for e in mst])

应用场景:网络设计、聚类分析、近似算法。

⑭ Dijkstra最短路径

单源最短路径算法:

import heapq def dijkstra(graph, start): distances = {node: float('inf') for node in graph} distances[start] = 0 pq = [(0, start)] while pq: current_dist, current = heapq.heappop(pq) if current_dist > distances[current]: continue for neighbor, weight in graph[current].items(): distance = current_dist + weight if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(pq, (distance, neighbor)) return distances # 测试 graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1} } print("从A出发的最短路径:", dijkstra(graph, 'A'))

优先队列优化后时间复杂度O((V+E)log V);适用于非负权图。

⑮ 蒙特卡洛π值估算

随机算法求圆周率:

import random def estimate_pi(num_samples=100000): inside = 0 for _ in range(num_samples): x = random.uniform(-1, 1) y = random.uniform(-1, 1) if x*x + y*y <= 1: inside += 1 return 4 * inside / num_samples # 多次实验取平均 results = [estimate_pi() for _ in range(5)] print("π估算值:", [round(r, 6) for r in results]) print("平均值:", round(sum(results)/len(results), 6))

原理:单位正方形内随机点落入单位圆的概率为π/4;样本量越大精度越高。

三、自动化办公15例|释放生产力的实用脚本

文件处理、邮件发送、网页自动化与Excel操作

① 批量重命名文件

递归重命名指定目录下文件:

import os def batch_rename(directory, prefix="file", ext=".txt"): for i, filename in enumerate(os.listdir(directory)): if filename.endswith(ext): old_path = os.path.join(directory, filename) new_name = f"{prefix}_{i+1:03d}{ext}" new_path = os.path.join(directory, new_name) os.rename(old_path, new_path) print(f"重命名:{filename} → {new_name}") # 使用示例 # batch_rename("./test_files", "data")

安全建议:先备份目录;添加dry_run参数预览不执行;处理文件名冲突。

② PDF合并工具

使用PyPDF2合并PDF文件:

from PyPDF2 import PdfMerger def merge_pdfs(pdf_list, output_path): merger = PdfMerger() for pdf in pdf_list: merger.append(pdf) merger.write(output_path) merger.close() print(f"PDF合并完成:{output_path}") # 使用示例 # merge_pdfs(["a.pdf", "b.pdf"], "combined.pdf")

依赖安装:pip install PyPDF2;注意PDF版本兼容性。

③ Excel数据清洗

使用pandas处理销售数据:

import pandas as pd # 读取数据 df = pd.read_excel("sales.xlsx") # 数据清洗 df.dropna(subset=["销售额"], inplace=True) # 删除空值 df["销售额"] = pd.to_numeric(df["销售额"], errors="coerce") # 转换数值 df["日期"] = pd.to_datetime(df["日期"]) # 日期解析 # 新增列:折扣后价格 df["折扣后"] = df["销售额"] * 0.9 # 分组统计 summary = df.groupby("产品")["销售额"].sum().reset_index() # 保存结果 df.to_excel("cleaned_sales.xlsx", index=False) summary.to_excel("summary.xlsx", index=False) print("数据清洗完成!")

关键技巧:使用errors="coerce"将无效值转为NaN;groupby实现分组聚合。

④ 自动发送邮件

使用smtplib发送HTML邮件:

import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart def send_email(subject, body, to_email): msg = MIMEMultipart() msg["From"] = "sender@example.com" msg["To"] = to_email msg["Subject"] = subject msg.attach(MIMEText(body, "html")) with smtplib.SMTP("smtp.gmail.com", 587) as server: server.starttls() server.login("sender@example.com", "password") server.send_message(msg) # 使用示例 body = """

项目进度通知

当前进度:85%

预计完成日期:2023-12-15

""" send_email("项目进度更新", body, "recipient@example.com")

安全注意:使用环境变量存储密码;避免明文密码;Gmail需开启“允许不安全应用”。

⑤ 网页截图自动化

使用Selenium截取指定元素:

from selenium import webdriver from selenium.webdriver.chrome.options import Options import time def screenshot_element(url, element_selector, output_path): options = Options() options.add_argument("--headless") driver = webdriver.Chrome(options=options) driver.get(url) time.sleep(2) # 等待页面加载 element = driver.find_element("css selector", element_selector) element.screenshot(output_path) driver.quit() print(f"截图保存:{output_path}") # 使用示例 # screenshot_element("https://example.com", ".article-content", "article.png")

依赖安装:pip install selenium;需下载ChromeDriver;添加headless模式提升效率。

⑥ Word报告生成

使用python-docx生成报告:

from docx import Document from docx.shared import Inches def generate_report(data, output_path): doc = Document() doc.add_heading("项目周报", 0) doc.add_heading("本周工作", level=1) for item in data["tasks"]: doc.add_paragraph(item, style="List Bullet") doc.add_heading("下周计划", level=1) for plan in data["plans"]: doc.add_paragraph(plan, style="List Bullet") doc.add_picture(data["chart"], width=Inches(6)) doc.save(output_path) # 使用示例 report_data = { "tasks": ["完成需求分析", "设计数据库", "开发核心模块"], "plans": ["编写单元测试", "部署测试环境", "用户培训"], "chart": "chart.png" } # generate_report(report_data, "weekly_report.docx")

依赖安装:pip install python-docx;支持图片、表格、样式自定义。

⑦ CSV数据验证

验证CSV文件格式与内容:

import csv import re def validate_csv(filepath): errors = [] required_cols = ["姓名", "邮箱", "电话"] with open(filepath, "r", encoding="utf-8") as f: reader = csv.DictReader(f) # 检查列名 if not all(col in reader.fieldnames for col in required_cols): errors.append("缺少必要列") return errors # 验证数据 for i, row in enumerate(reader, start=2): if not re.match(r"[^@]+@[^@]+\.[^@]+", row["邮箱"]): errors.append(f"第{i}行:邮箱格式错误") if not re.match(r"^1[3-9]\d{9}$", row["电话"]): errors.append(f"第{i}行:电话格式错误") return errors # 测试 # errors = validate_csv("users.csv") # print("验证结果:", errors if errors else "全部通过")

正则表达式说明:[^@]+@[^@]+\.[^@]+匹配基本邮箱;^1[3-9]\d{9}$匹配11位手机号。

⑧ 自动打卡脚本

模拟浏览器操作打卡:

from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC def auto_check_in(url, username, password): driver = webdriver.Chrome() try: driver.get(url) # 等待并填写表单 WebDriverWait(driver, 10).until( EC.presence_of_element_located((By.ID, "username")) ) driver.find_element(By.ID, "username").send_keys(username) driver.find_element(By.ID, "password").send_keys(password) driver.find_element(By.ID, "login-btn").click() # 等待打卡按钮 WebDriverWait(driver, 10).until( EC.element_to_be_clickable((By.ID, "checkin-btn")) ).click() print("打卡成功!") finally: driver.quit() # 使用示例 # auto_check_in("https://school.edu/login", "user123", "pass456")

安全建议:使用环境变量存储凭证;添加异常处理;避免频繁操作触发风控。

⑨ 文本情感分析

使用SnowNLP分析评论情感:

from snownlp import SnowNLP def analyze_sentiment(texts): results = [] for text in texts: s = SnowNLP(text) sentiment = s.sentiments # 0-1,越接近1越正面 label = "正面" if sentiment > 0.6 else "负面" if sentiment < 0.4 else "中性" results.append((text, sentiment, label)) return results # 测试 comments = [ "这个产品太棒了,强烈推荐!", "质量一般,价格有点贵。", "客服态度很好,但发货慢了点。" ] for text, score, label in analyze_sentiment(comments): print(f"评论:{text}\n情感值:{score:.3f}({label})\n")

依赖安装:pip install snownlp;中文情感分析专用库;支持分词与关键词提取。

⑩ 日程提醒系统

使用schedule实现定时提醒:

import schedule import time from datetime import datetime def remind_me(task): print(f"[提醒] {datetime.now().strftime('%H:%M:%S')} - {task}") # 设置提醒 schedule.every().day.at("09:00").do(remind_me, "晨会开始") schedule.every().hour.do(remind_me, "喝水休息") # 运行循环 while True: schedule.run_pending() time.sleep(1)

注意:需持续运行脚本;生产环境建议用systemd或cron;支持随机延迟防集中触发。

⑪ 批量生成发票

使用Jinja2生成发票模板:

from jinja2 import Environment, FileSystemLoader from datetime import datetime def generate_invoice(data, template_dir="templates"): env = Environment(loader=FileSystemLoader(template_dir)) template = env.get_template("invoice.html") html = template.render(**data) with open(f"invoice_{data['invoice_id']}.html", "w", encoding="utf-8") as f: f.write(html) print(f"发票生成:invoice_{data['invoice_id']}.html") # 使用示例 invoice_data = { "invoice_id": "INV20231001", "date": datetime.now().strftime("%Y-%m-%d"), "customer": "ABC公司", "items": [ {"name": "服务A", "qty": 2, "price": 500}, {"name": "服务B", "qty": 1, "price": 1200} ] } generate_invoice(invoice_data)

模板文件invoice.html示例:{{ customer }} - {{ items | sum(attribute='qty') }}项服务

⑫ 二维码生成器

使用qrcode生成带Logo的二维码:

import qrcode from PIL import Image def generate_qr_with_logo(data, logo_path, output_path): qr = qrcode.QRCode( version=1, error_correction=qrcode.constants.ERROR_CORRECT_H, box_size=10, border=4 ) qr.add_data(data) qr.make(fit=True) img = qr.make_image(fill_color="black", back_color="white").convert("RGB") if logo_path: logo = Image.open(logo_path) logo_size = int(img.size[0] / 4) logo = logo.resize((logo_size, logo_size), Image.LANCZOS) pos = ((img.size[0] - logo_size) // 2, (img.size[1] - logo_size) // 2) img.paste(logo, pos) img.save(output_path) # 使用示例 # generate_qr_with_logo("https://example.com", "logo.png", "qr_with_logo.png")

关键设置:ERROR_CORRECT_H允许高错误率(30%);Logo大小不超过二维码1/4。

⑬ 图片批量压缩

使用PIL压缩图片尺寸:

from PIL import Image import os def compress_images(input_dir, output_dir, quality=85): os.makedirs(output_dir, exist_ok=True) for filename in os.listdir(input_dir): if filename.lower().endswith(('.png', '.jpg', '.jpeg')): input_path = os.path.join(input_dir, filename) output_path = os.path.join(output_dir, filename) with Image.open(input_path) as img: img.save(output_path, quality=quality) print(f"压缩:{filename} → {output_path}") # 使用示例 # compress_images("./images", "./compressed", quality=75)

参数调整:quality=60~85适合网页;PNG建议用img.convert("P", palette=Image.ADAPTIVE)转索引模式。

⑭ 日志监控系统

实时监控日志文件异常:

import time import re from collections import deque def monitor_log(log_path, keywords, max_lines=1000): buffer = deque(maxlen=max_lines) with open(log_path, "r", encoding="utf-8") as f: f.seek(0, 2) # 移动到文件末尾 while True: line = f.readline() if line: buffer.append(line) for keyword in keywords: if re.search(keyword, line, re.IGNORECASE): print(f"[⚠️ {keyword}] {line.strip()}") else: time.sleep(0.1) # 使用示例 # monitor_log("app.log", ["ERROR", "Exception", "CRITICAL"])

适用场景:服务器日志监控;支持正则表达式;可扩展为邮件/钉钉告警。

⑮ 爬虫数据清洗

处理爬取的电商数据:

import pandas as pd import re def clean_product_data(df): # 清理价格 df["price"] = df["price"].str.extract(r"(\d+\.?\d*)").astype(float) # 标准化标题 df["title"] = df["title"].str.replace(r"[^\w\s]", "", regex=True).str.strip() # 提取品牌 brands = ["Apple", "Samsung", "Xiaomi", "Huawei"] df["brand"] = df["title"].apply( lambda x: next((b for b in brands if b.lower() in x.lower()), "Unknown") ) # 过滤无效数据 df.dropna(subset=["price"], inplace=True) df = df[df["price"] > 0] return df # 测试 data = pd.DataFrame({ "title": ["Apple iPhone 13 (全新)", "Samsung Galaxy S22!", "小米12 翻新机"], "price": ["¥5999.00", "¥6799元", "¥2999.00"] }) cleaned = clean_product_data(data) print(cleaned)

关键技巧:str.extract()提取数字;apply()配合lambda实现复杂逻辑;dropna()处理缺失值。

四、Web开发12例|构建全栈应用基础

Flask/Django框架、REST API、模板渲染与数据库操作

① Flask基础应用

最小可用Web应用:

from flask import Flask, render_template, request app = Flask(__name__) @app.route("/") def index(): return "欢迎访问首页!" @app.route("/user/") def user_profile(username): return f"用户 {username} 的个人主页" @app.route("/calc", methods=["GET", "POST"]) def calculator(): if request.method == "POST": num1 = float(request.form["num1"]) num2 = float(request.form["num2"]) op = request.form["operation"] if op == "add": result = num1 + num2 elif op == "sub": result = num1 - num2 return f"结果:{result}" return """
""" if __name__ == "__main__": app.run(debug=True)

关键点:路由装饰器@app.route;request.form获取POST数据;debug=True启用调试模式。

② 数据库连接与查询

使用SQLAlchemy操作SQLite:

from sqlalchemy import create_engine, Column, Integer, String from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker Base = declarative_base() class User(Base): __tablename__ = "users" id = Column(Integer, primary_key=True) name = Column(String(50)) email = Column(String(100), unique=True) # 创建数据库 engine = create_engine("sqlite:///users.db") Base.metadata.create_all(engine) # 创建会话 Session = sessionmaker(bind=engine) session = Session() # 插入数据 user = User(name="张三", email="zhangsan@example.com") session.add(user) session.commit() # 查询数据 users = session.query(User).all() for u in users: print(f"{u.id}: {u.name} - {u.email}")

ORM优势:避免SQL注入;支持复杂查询;自动处理连接池;可切换不同数据库。

③ RESTful API设计

Flask实现用户资源CRUD:

from flask import Flask, request, jsonify app = Flask(__name__) users = [] # 模拟数据库 @app.route("/api/users", methods=["GET"]) def get_users(): return jsonify(users) @app.route("/api/users", methods=["POST"]) def create_user(): data = request.get_json() if not data or "name" not in data or "email" not in data: return jsonify({"error": "缺少必要字段"}), 400 user = {"id": len(users) + 1, **data} users.append(user) return jsonify(user), 201 @app.route("/api/users/", methods=["PUT"]) def update_user(user_id): data = request.get_json() user = next((u for u in users if u["id"] == user_id), None) if not user: return jsonify({"error": "用户不存在"}), 404 user.update(data) return jsonify(user) @app.route("/api/users/", methods=["DELETE"]) def delete_user(user_id): global users users = [u for u in users if u["id"] != user_id] return "", 204 if __name__ == "__main__": app.run(debug=True)

HTTP状态码:200成功;201创建成功;400请求错误;404资源不存在;204删除成功。

④ Jinja2模板继承

基础模板与子模板实现:

{% block title %}默认标题{% endblock %}
{% block content %}{% endblock %}