FastAPI是一种现代、快速(高性能)的Web框架,用于Python 3.6+,使用Python类型提示构建API。它的设计初衷是帮助开发者在短时间内开发出高性能的API服务。FastAPI的灵感来源于许多高性能的编程框架,包括Express、Django REST Framework和Flask,但它提供了一些特定的特性和优化,使其脱颖而出。

什么是FastAPI?
FastAPI实现并支持了Python中的类型提示,使开发者能够在编写代码时更加高效和可靠。它不仅简化了API的开发过程,还在性能方面做出了显著贡献。FastAPI能够在多种情况下提供出色的吞吐量和低延迟,使其非常适合构建快速和可扩展的Web服务。

FastAPI的主要特性包括:
	- 快速:FastAPI是当前最快的Python网络框架之一,就像NodeJS和Go这样的系统语言。它使用Starlette(用于网络部分)和Pydantic(用于数据部分)进行优化。
 
	- 简单:开发者可以在数分钟内无痛地创建API。
 
	- 基于标准:遵循OpenAPI和JSON Schema标准,让我们能够自动生成交互式文档和数据验证。
 
	- 自动生成的交互式API文档:Swagger UI和ReDoc界面。
 
	- Python 3.6+类型提示让代码自动完成,极大提升开发体验。
 
	- 生产就绪:适合生产环境应用的代码。
 
安装FastAPI
在开始使用FastAPI之前,你需要确保你的Python环境已经配置好,然后你可以通过以下命令安装FastAPI:
为了运行FastAPI应用,我们还需要一个ASGI服务器,例如uvicorn:

开始使用FastAPI
让我们从一个简单的示例应用开始,该应用提供了一个基本的“Hello, World!”服务。
创建一个文件名为main.py,代码如下:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			 | 
			
			 from fastapi import FastAPI 
			app = FastAPI() 
			@app.get("/") 
			async def read_root(): 
			    return {"Hello": "World"} 
			 | 
		
	
要运行这个应用,使用以下命令:
	
		
			| 
			 1 
			 | 
			
			 uvicorn main:app --reload 
			 | 
		
	
	- main:指的是Python文件(不包括.py扩展名)。
 
	- app:是FastAPI实例的名字。
 
	- --reload:启用自动重载,在代码更改时自动重启服务器。适合开发模式使用。
 
打开浏览器访问http://127.0.0.1:8000,你将看到一个简单的JSON响应:{"Hello": "World"}。
此外,FastAPI会为你自动生成API文档。使用Swagger UI访问http://127.0.0.1:8000/docs,或者使用ReDoc访问http://127.0.0.1:8000/redoc。
定义请求方法

FastAPI支持几种常见的HTTP方法:GET、POST、PUT、DELETE等。让我们创建一个简单的示例,演示如何使用这些HTTP方法:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			6 
			7 
			8 
			9 
			10 
			11 
			12 
			13 
			14 
			15 
			16 
			17 
			18 
			 | 
			
			 from fastapi import FastAPI 
			app = FastAPI() 
			# GET请求:获取信息 
			@app.get("/") 
			async def root(): 
			    return {"message": "Hello World"} 
			# POST请求:创建新资源 
			@app.post("/items/") 
			async def create_item(item: dict): 
			    return {"item_name": item.get("name")} 
			# PUT请求:更新资源 
			@app.put("/items/{item_id}") 
			async def update_item(item_id: int, item: dict): 
			    return {"item_id": item_id, "item_name": item.get("name")} 
			# DELETE请求:删除资源 
			@app.delete("/items/{item_id}") 
			async def delete_item(item_id: int): 
			    return {"item_id": item_id} 
			 | 
		
	
在FastAPI中,通过Python的类型提示系统,我们可以方便地定义和解析路径参数、请求体、查询参数和表单数据。
路径参数

FastAPI通过使用类型提示来定义路径参数:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			 | 
			
			 from fastapi import FastAPI 
			app = FastAPI() 
			@app.get("/users/{user_id}") 
			async def read_user(user_id: int): 
			    return {"user_id": user_id} 
			 | 
		
	
在这里,路径参数user_id定义为一个整数。FastAPI会自动验证传递的参数是否为整数,并在不匹配时返回一个400错误响应。
查询参数
除了路径参数,FastAPI还支持查询参数。它们是定义在URL路径之后的可选参数,通常用于过滤和分页:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			 | 
			
			 from fastapi import FastAPI 
			app = FastAPI() 
			@app.get("/items/") 
			async def read_item(skip: int = 0, limit: int = 10): 
			    return {"skip": skip, "limit": limit} 
			 | 
		
	
在/items/路径上,skip和limit是可选的查询参数,具有默认值skip=0和limit=10。
请求体

FastAPI支持请求体数据的声明和验证。通常,POST、PUT等请求会需要一个请求体:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			6 
			7 
			8 
			9 
			10 
			11 
			 | 
			
			 from fastapi import FastAPI 
			from pydantic import BaseModel 
			class Item(BaseModel): 
			    name: str 
			    description: str = None 
			    price: float 
			    tax: float = None 
			app = FastAPI() 
			@app.post("/items/") 
			async def create_item(item: Item): 
			    return item 
			 | 
		
	
在这里,我们使用Pydantic模型来定义请求体的结构和类型。FastAPI会验证和解析请求体中的数据,并将其作为参数传递给路径操作函数。
数据验证和自动文档
FastAPI利用Pydantic进行数据验证,并自动生成API文档。当你运行FastAPI应用时,它会生成两个API文档界面,分别是Swagger UI和ReDoc。

	- Swagger UI:http://127.0.0.1:8000/docs – 提供了一个交互式的API文档,你可以在浏览器中测试所有API操作。
 
	- ReDoc:http://127.0.0.1:8000/redoc – 另一个自动生成的API文档界面,风格简洁。
 
异步支持
FastAPI完全支持异步编程,它完全利用Python中的async和await特性。在定义路径操作函数时,可以通过async def来声明异步操作:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			 | 
			
			 from fastapi import FastAPI 
			app = FastAPI() 
			@app.get("/") 
			async def read_root(): 
			    return {"Hello": "World"} 
			 | 
		
	
异步编程能够帮助服务器处理更多请求,使其能够更快地响应客户端,尤其在I/O密集型环境中。结合uvicorn或任何ASGI兼容服务器,FastAPI能够实现真正的并发操作。
中间件与扩展

中间件是一个能够在请求或响应期间处理数据的函数。FastAPI提供简单的方式来编写中间件,这有助于在应用中引入额外的功能,例如请求/响应日志、CORS处理、安全措施等。
下面是一个简单的中间件示例,用于记录请求时间:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			6 
			7 
			8 
			9 
			10 
			11 
			12 
			 | 
			
			 from fastapi import FastAPI 
			from starlette.middleware.base import BaseHTTPMiddleware 
			import time 
			app = FastAPI() 
			class TimingMiddleware(BaseHTTPMiddleware): 
			    async def dispatch(self, request, call_next): 
			        start_time = time.time() 
			        response = await call_next(request) 
			        process_time = time.time() - start_time 
			        response.headers["X-Process-Time"] = str(process_time) 
			        return response 
			app.add_middleware(TimingMiddleware) 
			 | 
		
	
CORS(跨域资源共享)
在现代Web应用开发中,CORS是一个常见的问题。FastAPI提供了一种简单的方式来处理CORS问题,你可以通过安装starlette.middleware.cors.CORSMiddleware来实现:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			6 
			7 
			8 
			9 
			10 
			 | 
			
			 from fastapi import FastAPI 
			from starlette.middleware.cors import CORSMiddleware 
			app = FastAPI() 
			app.add_middleware( 
			    CORSMiddleware, 
			    allow_origins=["*"],  # 允许访问的源 
			    allow_credentials=True, 
			    allow_methods=["*"],    # 允许的HTTP方法 
			    allow_headers=["*"],    # 允许的HTTP表头 
			) 
			 | 
		
	
通过以上配置,你可以实现从不同源的客户端访问FastAPI应用。你可以根据实际需求调整允许的来源、方法和表头。
数据库集成

FastAPI是一个轻量级框架,可以很容易地与多种数据库集成。在构建生产级应用时,数据库是必不可少的一部分。其中SQLAlchemy是Python中常用的ORM框架,我们可以利用它与FastAPI进行集成:
首先,安装SQLAlchemy和数据库驱动:
	
		
			| 
			 1 
			2 
			 | 
			
			 pip install sqlalchemy 
			pip install databases 
			 | 
		
	
接下来,定义数据库配置和模型:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			6 
			7 
			8 
			9 
			10 
			11 
			12 
			 | 
			
			 from sqlalchemy import create_engine, Column, Integer, String 
			from sqlalchemy.ext.declarative import declarative_base 
			from sqlalchemy.orm import sessionmaker 
			SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db" 
			engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}) 
			SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) 
			Base = declarative_base() 
			class Item(Base): 
			    __tablename__ = 'items' 
			    id = Column(Integer, primary_key=True, index=True) 
			    name = Column(String, index=True) 
			    description = Column(String, index=True) 
			 | 
		
	
创建数据库会话和路径操作:
	
		
			| 
			 1 
			2 
			3 
			4 
			5 
			6 
			7 
			8 
			9 
			10 
			11 
			12 
			13 
			14 
			15 
			16 
			17 
			18 
			19 
			20 
			21 
			 | 
			
			 from fastapi import Depends, FastAPI, HTTPException 
			from sqlalchemy.orm import Session 
			from typing import List 
			app = FastAPI() 
			Base.metadata.create_all(bind=engine) 
			def get_db(): 
			    db = SessionLocal() 
			    try: 
			        yield db 
			    finally: 
			        db.close() 
			@app.post("/items/", response_model=Item) 
			def create_item(item: Item, db: Session = Depends(get_db)): 
			    db.add(item) 
			    db.commit() 
			    db.refresh(item) 
			    return item 
			@app.get("/items/", response_model=List[Item]) 
			def read_items(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)): 
			    items = db.query(Item).offset(skip).limit(limit).all() 
			    return items 
			 | 
		
	
在上面的代码中,我们定义了一个SQLAlchemy数据库模型,同时创建了CRUD操作,包括创建(POST)和读取(GET)功能。通过Depends依赖注入,我们将数据库会话传递给路径操作函数,使我们能够轻松管理数据库事务。
全面总结
FastAPI是一个强大且高效的Web框架,适合从小型项目到大型企业级应用的各种开发需求。因为它的自动文档、数据验证和优秀的性能,FastAPI在编写现代Web服务时提供了巨大的便捷性。结合异步、CORS、中间件和数据库集成功能,FastAPI能够帮助开发者快速构建稳健的API服务。我们强烈推荐在你的下一个项目中试用FastAPI,并享受其带来的高效开发体验。