Python都要学什么

编程基础:构建Python知识大厦的地基

Python语言特性与开发环境搭建

Python是一门解释型、面向对象、动态类型的高级编程语言,由Guido van Rossum于1991年首次发布。其设计哲学强调代码的可读性与简洁性,使用缩进来定义代码块,摒弃了传统的大括号语法,极大降低了初学者的学习门槛。

开发环境搭建是学习Python的第一步。目前主流方案有三:

  • 官方Python解释器(Python.org):支持Windows/macOS/Linux,推荐安装最新稳定版3.11+,注意勾选"Add Python to PATH"
  • Anaconda发行版:集成Conda包管理器与Jupyter Notebook,特别适合数据科学方向学习者
  • VS Code + Python扩展:轻量级编辑器组合,支持智能提示、调试、Git集成等现代开发功能

环境配置完成后,建议运行以下代码验证安装:

print("Hello, Python!")
import sys
print(f"Python版本:{sys.version}")
print(f"安装路径:{sys.executable}")

核心语法体系:变量、数据类型与控制流

Python语法简洁但功能强大,其核心语法体系包含以下模块:

  1. 变量与数据类型:支持整型(int)、浮点型(float)、字符串(str)、布尔型(bool)、NoneType等基本类型;容器类型包括列表(list)、元组(tuple)、集合(set)、字典(dict)
  2. 运算符:算术运算符(+ - * / // % **)、比较运算符(== != < > <= >=)、逻辑运算符(and or not)、成员运算符(in not in)、身份运算符(is is not)
  3. 控制结构:条件语句(if-elif-else)、循环语句(for-while)、跳转语句(break continue pass)
  4. 函数:定义函数(def)、参数传递(位置参数/关键字参数/默认参数/可变参数)、返回值、作用域规则(LEGB)

示例:计算斐波那契数列前n项

def fibonacci(n):
    """返回斐波那契数列前n项"""
    if n <= 0:
        return []
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        seq = [0, 1]
        for i in range(2, n):
            seq.append(seq[-1] + seq[-2])
        return seq
print(fibonacci(10))  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

面向对象编程:类与对象的系统化设计

Python是纯面向对象语言,一切皆对象。OOP核心概念包括:

  • 类(Class):对象的蓝图,定义属性和方法
  • 对象(Object):类的实例
  • 封装(Encapsulation):隐藏内部实现细节,通过公有接口访问
  • 继承(Inheritance):子类继承父类属性和方法,实现代码复用
  • 多态(Polymorphism):不同类的对象对同一消息做出不同响应

示例:定义学生类及继承关系

class Person:
    """人类基类"""
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def introduce(self):
        return f"我是{self.name},今年{self.age}岁"
class Student(Person):
    """学生类,继承自Person"""
    def __init__(self, name, age, student_id, major):
        super().__init__(name, age)
        self.student_id = student_id
        self.major = major
    def introduce(self):
        return f"{super().introduce()},我是{self.major}专业{self.student_id}号学生"
    def study(self, course):
        return f"{self.name}正在学习{course}课程"
# 创建对象并调用方法
s1 = Student("张三", 20, "2023001", "计算机科学")
print(s1.introduce())  # 我是张三,今年20岁,我是计算机科学专业2023001号学生
print(s1.study("Python程序设计"))  # 张三正在学习Python程序设计课程

文件操作与异常处理:构建健壮程序

Python提供完善的文件I/O操作与异常处理机制:

  • 文件操作:open()函数支持r(读)/w(写)/a(追加)/b(二进制)/t(文本)模式组合;with语句确保文件自动关闭
  • 异常处理:try-except-else-finally结构;自定义异常类继承Exception

示例:安全读取配置文件并处理异常

import json
def load_config(filepath):
    """安全加载JSON配置文件"""
    try:
        with open(filepath, 'r', encoding='utf-8') as f:
            config = json.load(f)
            return config
    except FileNotFoundError:
        print(f"错误:配置文件'{filepath}'不存在")
        return {}
    except json.JSONDecodeError as e:
        print(f"错误:JSON格式错误 - {e}")
        return {}
    except Exception as e:
        print(f"未知错误:{e}")
        return {}
# 使用示例
config = load_config("config.json")
print("配置内容:" + str(config))

Web开发:构建全栈应用能力

Flask框架
Django框架
FastAPI框架

Flask:轻量级Web开发首选

Flask是Python最流行的微框架,由Armin Ronacher开发,核心理念是"简单易用、灵活可扩展"。其特点包括:

  • 核心库极简(仅Werkzeug+Jinja2),按需添加扩展
  • 路由系统清晰直观
  • 支持Blueprint模块化开发
  • 内置开发服务器与调试器

示例:构建一个简单的RESTful API

from flask import Flask, jsonify, request
app = Flask(__name__)
# 模拟数据库
users = [
    {"id": 1, "name": "张三", "email": "zhangsan@example.com"},
    {"id": 2, "name": "李四", "email": "lisi@example.com"}
]
@app.route('/api/users', methods=['GET'])
def get_users():
    """获取所有用户"""
    return jsonify(users)
@app.route('/api/users/', methods=['GET'])
def get_user(user_id):
    """获取单个用户"""
    user = next((u for u in users if u['id'] == user_id), None)
    if user:
        return jsonify(user)
    return jsonify({"error": "用户不存在"}), 404
@app.route('/api/users', methods=['POST'])
def create_user():
    """创建新用户"""
    data = request.get_json()
    new_user = {
        "id": len(users) + 1,
        "name": data['name'],
        "email": data['email']
    }
    users.append(new_user)
    return jsonify(new_user), 201
if __name__ == '__main__':
    app.run(debug=True)

Django:企业级Web开发解决方案

Django是" batteries included "的全功能Web框架,强调快速开发与安全实践。核心特性:

  • ORM系统:支持多种数据库(MySQL/PostgreSQL/SQLite)
  • Admin后台:自动生成管理界面
  • 认证系统:用户登录、权限控制、会话管理
  • 模板引擎:Jinja2兼容的Django模板语言
  • 中间件:请求/响应处理钩子

项目结构示例:

myproject/
├── manage.py
├── myproject/
│   ├── __init__.py
│   ├── settings.py      # 配置文件
│   ├── urls.py          # URL路由
│   └── wsgi.py          # WSGI入口
└── app/
    ├── __init__.py
    ├── models.py        # 数据模型
    ├── views.py         # 视图函数
    ├── urls.py          # 应用路由
    └── templates/       # 模板文件
        └── app/
            ├── base.html
            └── index.html

模型定义示例:

from django.db import models
class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.CharField(max_length=50)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)
    class Meta:
        verbose_name = "文章"
        verbose_name_plural = "文章列表"
    def __str__(self):
        return self.title

FastAPI:现代API开发新锐

FastAPI基于Starlette和Pydantic,专为构建API设计,具有以下突出优势:

  • 自动API文档:自动生成Swagger UI与ReDoc文档
  • 类型提示驱动:利用Python类型注解自动生成数据模型
  • 异步支持:原生支持async/await,高性能
  • 数据验证:Pydantic自动验证请求与响应数据

示例:用户注册API

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, EmailStr
from typing import Optional
app = FastAPI(title="用户服务API", description="用户注册与管理服务")
class UserCreate(BaseModel):
    username: str
    email: EmailStr
    password: str
    full_name: Optional[str] = None
class UserResponse(BaseModel):
    id: int
    username: str
    email: str
    full_name: Optional[str] = None
    class Config:
        orm_mode = True
# 模拟数据库
fake_db = []
user_counter = 0
@app.post("/users", response_model=UserResponse, status_code=201)
async def create_user(user: UserCreate):
    """创建新用户"""
    global user_counter
    user_counter += 1
    db_user = {
        "id": user_counter,
        "username": user.username,
        "email": user.email,
        "full_name": user.full_name
    }
    fake_db.append(db_user)
    return db_user
@app.get("/users/{user_id}", response_model=UserResponse)
async def read_user(user_id: int):
    """获取用户信息"""
    if user_id <= 0 or user_id > len(fake_db):
        raise HTTPException(status_code=404, detail="用户不存在")
    return fake_db[user_id - 1]
@app.get("/users")
async def read_users(skip: int = 0, limit: int = 10):
    """获取用户列表(分页)"""
    return fake_db[skip:skip + limit]

数据分析:从数据中提取价值

NumPy:科学计算基石

NumPy(Numerical Python)是Python科学计算的核心库,提供:

示例:矩阵运算与统计分析

import numpy as np
# 创建数组
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[7, 8], [9, 10], [11, 12]])
# 矩阵乘法
c = np.dot(a, b)  # [[58 64] [139 154]]
# 统计计算
print("均值:", np.mean(a))      # 3.5
print("标准差:", np.std(a))     # 1.707825127659933
print("最大值:", np.max(a))     # 6
print("最小值:", np.min(a))     # 1
# 广播示例
d = np.array([1, 2, 3])
e = np.array([[1], [2], [3]])
f = d + e  # [[2 3 4] [3 4 5] [4 5 6]]

Pandas:数据处理利器

Pandas提供DataFrame与Series两种核心数据结构,用于高效处理结构化数据:

示例:销售数据处理分析

import pandas as pd
# 创建DataFrame
data = {
    '日期': ['2023-01-01', '2023-01-02', '2023-01-01', '2023-01-03'],
    '产品': ['A', 'A', 'B', 'A'],
    '销量': [100, 150, 80, 200],
    '单价': [25.5, 25.5, 30.0, 25.5]
}
df = pd.DataFrame(data)
df['日期'] = pd.to_datetime(df['日期'])
# 添加金额列
df['金额'] = df['销量'] * df['单价']
# 按产品分组统计
grouped = df.groupby('产品').agg({
    '销量': 'sum',
    '金额': 'sum',
    '日期': 'count'
}).rename(columns={'日期': '订单数'})
print(grouped)
#       销量    金额  订单数
# 产品
# A     450  11475.0     3
# B      80   2400.0     1
# 按日期排序
df_sorted = df.sort_values('日期')
print(df_sorted.head())

Matplotlib & Seaborn:数据可视化

数据可视化是数据分析的关键环节:

示例:销售趋势与分布分析

import matplotlib.pyplot as plt
import seaborn as sns
# 设置中文字体支持
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
# 创建子图
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
# 折线图:销量趋势
df_pivot = df.pivot_table(index='日期', columns='产品', values='销量', aggfunc='sum')
df_pivot.plot(ax=axes[0], marker='o')
axes[0].set_title('各产品日销量趋势')
axes[0].set_xlabel('日期')
axes[0].set_ylabel('销量')
# 箱线图:销量分布
sns.boxplot(data=df, x='产品', y='销量', ax=axes[1])
axes[1].set_title('各产品销量分布')
plt.tight_layout()
plt.savefig('sales_analysis.png', dpi=300, bbox_inches='tight')
plt.show()

自动化办公:释放重复劳动生产力

Excel自动化
Word自动化
邮件自动化

Excel数据处理:openpyxl与pandas组合

使用openpyxl处理.xlsx文件,结合pandas实现高效数据操作:

from openpyxl import load_workbook
import pandas as pd
# 读取Excel文件
wb = load_workbook('sales_data.xlsx')
ws = wb.active
# 读取数据到DataFrame
data = ws.values
headers = next(data)  # 获取表头
df = pd.DataFrame(data, columns=headers)
# 数据清洗
df.dropna(how='all', inplace=True)  # 删除全空行
df['日期'] = pd.to_datetime(df['日期'], errors='coerce')  # 转换日期格式
# 添加新列
df['季度'] = df['日期'].dt.quarter
df['月份'] = df['日期'].dt.month
# 分组统计
summary = df.groupby(['产品', '季度']).agg({
    '销量': 'sum',
    '金额': 'sum'
}).reset_index()
# 写入新工作表
with pd.ExcelWriter('sales_summary.xlsx', engine='openpyxl') as writer:
    df.to_excel(writer, sheet_name='原始数据', index=False)
    summary.to_excel(writer, sheet_name='季度汇总', index=False)
    # 自动调整列宽
    worksheet = writer.sheets['原始数据']
    for idx, col in enumerate(df.columns):
        max_length = max(df[col].astype(str).map(len).max(), len(col)) + 2
        worksheet.column_dimensions[chr(65 + idx)] = min(max_length, 50)
print("数据处理完成,已保存至sales_summary.xlsx")

Word文档自动化:python-docx

生成标准化报告模板:

from docx import Document
from docx.shared import Pt, RGBColor
from docx.enum.text import WD_ALIGN_PARAGRAPH
# 创建文档
doc = Document()
# 添加标题
title = doc.add_heading('月度销售报告', 0)
title.alignment = WD_ALIGN_PARAGRAPH.CENTER
# 添加摘要段落
doc.add_paragraph('报告周期:2023年1月1日-2023年1月31日', style='Normal')
doc.add_paragraph('本报告汇总了当月各产品线销售情况及趋势分析。')
# 添加表格
table = doc.add_table(rows=1, cols=4)
table.style = 'Table Grid'
hdr_cells = table.rows[0].cells
hdr_cells[0].text = '产品'
hdr_cells[1].text = '销量'
hdr_cells[2].text = '金额'
hdr_cells[3].text = '环比增长'
# 添加数据行
for _, row in summary.iterrows():
    cells = table.add_row().cells
    cells[0].text = str(row['产品'])
    cells[1].text = str(row['销量'])
    cells[2].text = f"{row['金额']:.2f}"
    cells[3].text = f"{row['环比增长']:.2f}%"
# 添加图表说明
doc.add_heading('图表说明', level=2)
doc.add_paragraph('图1展示了各产品月度销售趋势,其中A产品表现突出,月销量达450件。')
# 保存文档
doc.save('sales_report.docx')
print("报告生成完成")

邮件自动化:smtplib与email模块

发送带附件的报告邮件:

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
from datetime import datetime
# 邮件配置
sender = 'report@company.com'
receiver = 'manager@company.com'
subject = f'销售报告-{datetime.now().strftime("%Y年%m月")}'
# 创建邮件
msg = MIMEMultipart()
msg['From'] = sender
msg['To'] = receiver
msg['Subject'] = subject
# 邮件正文
body = f"""
尊敬的经理:
您好!
附件为{datetime.now().strftime("%Y年%m月")}销售报告,请查收。
如有任何问题,欢迎随时联系。
此致
敬礼!
数据分析团队
{datetime.now().strftime("%Y年%m月%d日")}
"""
msg.attach(MIMEText(body, 'plain', 'utf-8'))
# 添加附件
with open('sales_summary.xlsx', 'rb') as f:
    part = MIMEApplication(f.read(), _subtype='xlsx')
    part.add_header('Content-Disposition', 'attachment', filename='销售数据.xlsx')
    msg.attach(part)
# 发送邮件
try:
    server = smtplib.SMTP('smtp.company.com', 587)
    server.starttls()
    server.login(sender, 'your_password')
    text = msg.as_string()
    server.sendmail(sender, receiver, text)
    server.quit()
    print("邮件发送成功")
except Exception as e:
    print(f"邮件发送失败:{e}")

网络爬虫:数据采集与监控

基础爬虫:requests与BeautifulSoup

构建稳定可靠的网页数据采集系统:

import requests
from bs4 import BeautifulSoup
import time
import csv
from urllib.parse import urljoin
class NewsSpider:
    def __init__(self):
        self.base_url = 'https://news.example.com'
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
        }
        self.session = requests.Session()
        self.session.headers.update(self.headers)
    def fetch_page(self, url):
        """获取网页内容"""
        try:
            response = self.session.get(url, timeout=10)
            response.raise_for_status()
            response.encoding = 'utf-8'
            return response.text
        except requests.RequestException as e:
            print(f"请求失败 {url}: {e}")
            return None
    def parse_list_page(self, html):
        """解析列表页"""
        soup = BeautifulSoup(html, 'html.parser')
        articles = []
        for item in soup.select('.news-item'):
            title_tag = item.select_one('.title a')
            if not title_tag:
                continue
            title = title_tag.get_text(strip=True)
            url = urljoin(self.base_url, title_tag['href'])
            date = item.select_one('.date').get_text(strip=True) if item.select_one('.date') else ''
            summary = item.select_one('.summary').get_text(strip=True) if item.select_one('.summary') else ''
            articles.append({
                'title': title,
                'url': url,
                'date': date,
                'summary': summary
            })
        return articles
    def parse_detail_page(self, html):
        """解析详情页"""
        soup = BeautifulSoup(html, 'html.parser')
        content = soup.select_one('.article-content')
        if content:
            # 清理无用标签
            for tag in content.select('script, style, iframe'):
                tag.decompose()
            text = content.get_text(separator='\n', strip=True)
        else:
            text = ''
        return text
    def save_to_csv(self, articles, filename='news_data.csv'):
        """保存数据到CSV"""
        fieldnames = ['title', 'url', 'date', 'summary']
        with open(filename, 'w', newline='', encoding='utf-8-sig') as f:
            writer = csv.DictWriter(f, fieldnames=fieldnames)
            writer.writeheader()
            writer.writerows(articles)
    def run(self):
        """主运行逻辑"""
        all_articles = []
        # 爬取前3页
        for page in range(1, 4):
            list_url = f'{self.base_url}/news?page={page}'
            html = self.fetch_page(list_url)
            if not html:
                continue
            articles = self.parse_list_page(html)
            print(f"第{page}页采集到{len(articles)}条数据")
            # 采集详情页
            for article in articles:
                detail_html = self.fetch_page(article['url'])
                if detail_html:
                    article['content'] = self.parse_detail_page(detail_html)
                else:
                    article['content'] = ''
                time.sleep(1)  # 防止频率过快
            all_articles.extend(articles)
        # 保存结果
        self.save_to_csv(all_articles)
        print(f"共采集{len(all_articles)}条新闻数据")
# 运行爬虫
if __name__ == '__main__':
    spider = NewsSpider()
    spider.run()

动态页面:Selenium与Playwright

处理JavaScript渲染页面:

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
from selenium.webdriver.chrome.options import Options
class DynamicSpider:
    def __init__(self):
        chrome_options = Options()
        chrome_options.add_argument('--headless')
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        self.driver = webdriver.Chrome(options=chrome_options)
        self.wait = WebDriverWait(self.driver, 10)
    def fetch_dynamic_page(self, url):
        """获取动态加载页面"""
        self.driver.get(url)
        # 等待关键元素加载完成
        try:
            self.wait.until(
                EC.presence_of_element_located((By.CSS_SELECTOR, '.product-item'))
            )
        except:
            print("页面加载超时")
        # 滚动到底部加载更多内容
        last_height = self.driver.execute_script("return document.body.scrollHeight")
        while True:
            self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
            time.sleep(2)
            new_height = self.driver.execute_script("return document.body.scrollHeight")
            if new_height == last_height:
                break
            last_height = new_height
        return self.driver.page_source
    def parse_products(self, html):
        """解析产品信息"""
        from bs4 import BeautifulSoup
        soup = BeautifulSoup(html, 'html.parser')
        products = []
        for item in soup.select('.product-item'):
            name = item.select_one('.product-name').get_text(strip=True)
            price = item.select_one('.product-price').get_text(strip=True)
            rating = item.select_one('.product-rating').get_text(strip=True)
            link = item.select_one('a')['href']
            products.append({
                'name': name,
                'price': price,
                'rating': rating,
                'link': link
            })
        return products
    def run(self):
        """运行爬虫"""
        try:
            html = self.fetch_dynamic_page('https://example.com/products')
            products = self.parse_products(html)
            for product in products:
                print(f"产品: {product['name']}, 价格: {product['price']}, 评分: {product['rating']}")
        finally:
            self.driver.quit()
# 运行动态爬虫
if __name__ == '__main__':
    spider = DynamicSpider()
    spider.run()

人工智能与机器学习:开启智能时代大门

机器学习基础:scikit-learn实战

使用scikit-learn构建机器学习管道:

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix
import joblib
# 加载数据
df = pd.read_csv('iris.csv')
# 数据预处理
le = LabelEncoder()
df['species'] = le.fit_transform(df['species'])
X = df[['sepal_length', 'sepal_width', 'petal_length', 'petal_width']]
y = df['species']
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
# 特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 训练模型
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)
# 模型评估
y_pred = model.predict(X_test_scaled)
print("分类报告:")
print(classification_report(y_test, y_pred, target_names=le.classes_))
# 混淆矩阵
cm = confusion_matrix(y_test, y_pred)
print("混淆矩阵:")
print(cm)
# 保存模型
joblib.dump(model, 'iris_classifier.pkl')
joblib.dump(scaler, 'scaler.pkl')
print("模型已保存至iris_classifier.pkl")

深度学习入门:PyTorch基础

使用PyTorch构建神经网络:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
# 设置随机种子
torch.manual_seed(42)
# 准备数据
X = torch.randn(1000, 20)  # 1000个样本,20个特征
y = torch.randint(0, 3, (1000,))  # 3分类
# 划分数据集
train_size = int(0.8 * len(X))
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]
train_dataset = TensorDataset(X_train, y_train)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# 定义模型
class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(20, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 3)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.2)
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x
model = Net()
# 损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 训练模型
for epoch in range(50):
    for batch_X, batch_y in train_loader:
        optimizer.zero_grad()
        outputs = model(batch_X)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch+1}/50], Loss: {loss.item():.4f}')
# 模型评估
with torch.no_grad():
    outputs = model(X_test)
    _, predicted = torch.max(outputs, 1)
    accuracy = (predicted == y_test).sum().item() / len(y_test)
    print(f'测试集准确率: {accuracy:.2%}')

实战项目:从理论到实践的跨越

项目1:电商商品价格监控系统

使用requests + BeautifulSoup + MySQL构建实时价格监控系统,支持:

  • 多平台商品比价(京东/淘宝/拼多多)
  • 价格波动预警
  • 历史价格趋势可视化
  • 邮件通知机制

项目2:Python自动化办公工具箱

整合Excel/Word/PDF处理、邮件发送、文件批量操作等功能,实现:

  • 合同自动生成功能
  • 报表数据自动提取与汇总
  • 邮件定时发送系统
  • 文件格式批量转换工具

项目3:智能问答机器人

基于LangChain + LLM构建垂直领域问答系统:

  • 支持PDF/Word文档解析
  • 本地知识库构建
  • RAG检索增强生成
  • 多轮对话记忆机制

项目开发最佳实践

  1. 项目结构规范化:采用src/、tests/、docs/等标准目录结构
  2. 版本控制:使用Git进行代码管理,遵循Git Flow工作流
  3. 测试驱动开发:编写单元测试确保代码质量
  4. 文档编写:使用Sphinx生成API文档
  5. 容器化部署:使用Docker打包应用

学习路线图:从零基础到专家的进阶路径

新手入门阶段(1-3个月)

进阶提升阶段(3-6个月)

专家进阶阶段(6个月以上)

技术栈路线图

方向 核心技能 推荐学习路径
Web开发 HTML/CSS/JavaScript、Flask/Django/FastAPI、RESTful API 基础语法 → Flask基础 → Django进阶 → 前端集成 → 部署运维
数据分析 NumPy/Pandas、Matplotlib/Seaborn、SQL、数据可视化 Python基础 → NumPy/Pandas → 数据清洗 → 可视化 → 商业智能
自动化办公 openpyxl/python-docx、smtplib、PDF处理、GUI开发 基础操作 → Excel自动化 → Word自动化 → 邮件系统 → 综合工具箱
人工智能 scikit-learn、PyTorch/TensorFlow、NLP、计算机视觉 数学基础 → 机器学习 → 深度学习 → 项目实战 → 模型优化