Python生态

Python基础

Python语言特性

Python是一种高级编程语言，具有以下特点：

简洁易读：语法清晰，接近自然语言
动态类型：变量类型在运行时确定
面向对象：支持面向对象编程
丰富的标准库：内置大量实用模块
跨平台：支持Windows、macOS、Linux

Python版本

Python 2.x：已停止维护
Python 3.x：当前主流版本，推荐使用3.8+

Web框架

Django

Django是一个全栈Web框架，提供完整的Web开发解决方案。

项目结构

myproject/
├── manage.py
├── myproject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── myapp/
    ├── __init__.py
    ├── admin.py
    ├── models.py
    ├── views.py
    └── urls.py

模型定义

python

# models.py
from django.db import models

class User(models.Model):
    username = models.CharField(max_length=100, unique=True)
    email = models.EmailField(unique=True)
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.username

视图开发

python

# views.py
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse
from .models import User
from .serializers import UserSerializer

def user_list(request):
    users = User.objects.all()
    serializer = UserSerializer(users, many=True)
    return JsonResponse(serializer.data, safe=False)

def user_detail(request, pk):
    user = get_object_or_404(User, pk=pk)
    serializer = UserSerializer(user)
    return JsonResponse(serializer.data)

URL配置

python

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('users/', views.user_list, name='user_list'),
    path('users/<int:pk>/', views.user_detail, name='user_detail'),
]

Flask

Flask是一个轻量级Web框架，灵活且易于扩展。

基础应用

python

from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

@app.route('/users', methods=['GET'])
def get_users():
    users = User.query.all()
    return jsonify([{
        'id': user.id,
        'username': user.username,
        'email': user.email
    } for user in users])

@app.route('/users', methods=['POST'])
def create_user():
    data = request.get_json()
    user = User(username=data['username'], email=data['email'])
    db.session.add(user)
    db.session.commit()
    return jsonify({'message': 'User created successfully'}), 201

if __name__ == '__main__':
    app.run(debug=True)

FastAPI

FastAPI是一个现代、快速的Web框架，基于Python 3.6+的类型提示。

基础使用

python

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List

app = FastAPI()

class User(BaseModel):
    username: str
    email: str

class UserResponse(User):
    id: int

# 模拟数据库
users_db = []
user_id_counter = 1

@app.get("/users", response_model=List[UserResponse])
async def get_users():
    return users_db

@app.post("/users", response_model=UserResponse)
async def create_user(user: User):
    global user_id_counter
    new_user = UserResponse(id=user_id_counter, **user.dict())
    users_db.append(new_user)
    user_id_counter += 1
    return new_user

@app.get("/users/{user_id}", response_model=UserResponse)
async def get_user(user_id: int):
    for user in users_db:
        if user.id == user_id:
            return user
    raise HTTPException(status_code=404, detail="User not found")

数据访问

SQLAlchemy

SQLAlchemy是Python最流行的ORM框架。

python

from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    
    id = Column(Integer, primary_key=True)
    username = Column(String(100), unique=True, nullable=False)
    email = Column(String(120), unique=True, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)

# 创建数据库连接
engine = create_engine('sqlite:///users.db')
Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

# 数据库操作
def create_user(username, email):
    user = User(username=username, email=email)
    session.add(user)
    session.commit()
    return user

def get_user_by_id(user_id):
    return session.query(User).filter(User.id == user_id).first()

Django ORM

python

# 查询操作
users = User.objects.all()
user = User.objects.get(id=1)
active_users = User.objects.filter(is_active=True)

# 创建和更新
user = User.objects.create(username='john', email='[email protected]')
user.username = 'jane'
user.save()

# 删除
user.delete()

异步编程

asyncio

python

import asyncio
import aiohttp

async def fetch_user(session, user_id):
    async with session.get(f'https://api.example.com/users/{user_id}') as response:
        return await response.json()

async def fetch_all_users():
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_user(session, i) for i in range(1, 11)]
        users = await asyncio.gather(*tasks)
        return users

# 运行异步函数
users = asyncio.run(fetch_all_users())

FastAPI异步支持

python

from fastapi import FastAPI
import httpx

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    async with httpx.AsyncClient() as client:
        response = await client.get(f"https://api.example.com/users/{user_id}")
        return response.json()

数据处理

Pandas

python

import pandas as pd

# 读取数据
df = pd.read_csv('users.csv')

# 数据操作
filtered_df = df[df['age'] > 25]
grouped_df = df.groupby('city').agg({'age': 'mean'})

# 数据导出
df.to_csv('processed_users.csv', index=False)

NumPy

python

import numpy as np

# 数组操作
arr = np.array([1, 2, 3, 4, 5])
mean_value = np.mean(arr)
std_value = np.std(arr)

# 矩阵运算
matrix = np.array([[1, 2], [3, 4]])
inverse = np.linalg.inv(matrix)

机器学习

Scikit-learn

python

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import pandas as pd

# 加载数据
data = pd.read_csv('data.csv')
X = data.drop('target', axis=1)
y = data['target']

# 分割数据
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# 训练模型
model = LinearRegression()
model.fit(X_train, y_train)

# 预测
predictions = model.predict(X_test)
mse = mean_squared_error(y_test, predictions)

TensorFlow/Keras

python

import tensorflow as tf
from tensorflow import keras

# 构建模型
model = keras.Sequential([
    keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

测试

pytest

python

import pytest
from myapp.models import User

def test_create_user():
    user = User(username='test', email='[email protected]')
    assert user.username == 'test'
    assert user.email == '[email protected]'

@pytest.fixture
def sample_user():
    return User(username='fixture_user', email='[email protected]')

def test_user_with_fixture(sample_user):
    assert sample_user.username == 'fixture_user'

Django测试

python

from django.test import TestCase
from .models import User

class UserModelTest(TestCase):
    def setUp(self):
        self.user = User.objects.create(
            username='testuser',
            email='[email protected]'
        )
    
    def test_user_creation(self):
        self.assertEqual(self.user.username, 'testuser')
        self.assertEqual(self.user.email, '[email protected]')

部署

Docker

dockerfile

FROM python:3.9-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Gunicorn

python

# gunicorn.conf.py
bind = "0.0.0.0:8000"
workers = 4
worker_class = "uvicorn.workers.UvicornWorker"

包管理

pip

bash

# 安装包
pip install django
pip install -r requirements.txt

# 创建虚拟环境
python -m venv myenv
source myenv/bin/activate  # Linux/Mac
myenv\Scripts\activate     # Windows

Poetry

bash

# 安装Poetry
curl -sSL https://install.python-poetry.org | python3 -

# 创建项目
poetry new myproject

# 添加依赖
poetry add django
poetry add --dev pytest

# 运行命令
poetry run python manage.py runserver

最佳实践

项目结构

myproject/
├── app/
│   ├── __init__.py
│   ├── models.py
│   ├── views.py
│   └── utils.py
├── tests/
├── requirements.txt
├── README.md
└── .env

环境配置

python

# settings.py
import os
from dotenv import load_dotenv

load_dotenv()

DATABASE_URL = os.getenv('DATABASE_URL', 'sqlite:///db.sqlite3')
SECRET_KEY = os.getenv('SECRET_KEY', 'default-secret-key')
DEBUG = os.getenv('DEBUG', 'False').lower() == 'true'

Python生态在Web开发、数据分析、机器学习等领域都有广泛应用，选择合适的框架和工具可以大大提高开发效率。

Python生态 ​

Python基础 ​

Python语言特性 ​

Python版本 ​

Web框架 ​

Django ​

项目结构 ​

模型定义 ​

视图开发 ​

URL配置 ​

Flask ​

基础应用 ​

FastAPI ​

基础使用 ​

数据访问 ​

SQLAlchemy ​

Django ORM ​

异步编程 ​

asyncio ​

FastAPI异步支持 ​

数据处理 ​

Pandas ​

NumPy ​

机器学习 ​

Scikit-learn ​

TensorFlow/Keras ​

测试 ​

pytest ​

Django测试 ​

部署 ​

Docker ​

Gunicorn ​

包管理 ​

pip ​

Poetry ​

最佳实践 ​

项目结构 ​

环境配置 ​

Python生态

Python基础

Python语言特性

Python版本

Web框架

Django

项目结构

模型定义

视图开发

URL配置

Flask

基础应用

FastAPI

基础使用

数据访问

SQLAlchemy

Django ORM

异步编程

asyncio

FastAPI异步支持

数据处理

Pandas

NumPy

机器学习

Scikit-learn

TensorFlow/Keras

测试

pytest

Django测试

部署

Docker

Gunicorn

包管理

pip

Poetry

最佳实践

项目结构

环境配置