① 变量与数据类型操作
在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
① 单向链表实现
手动实现链表结构,理解指针逻辑:
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;样本量越大精度越高。
① 批量重命名文件
递归重命名指定目录下文件:
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()处理缺失值。