【面经】python后端开发工程师

1. 参与度比较深的python项目

在 Python 项目中，参与度较深的项目通常意味着需要深入理解项目架构、设计模式、技术栈，并且参与到核心模块的开发、优化、调试等环节。

1. Web 框架和后台开发

这类项目通常涉及构建和优化 Web 应用程序的核心功能，包括用户认证、数据处理、API 开发等。

技术栈：

Django / Flask / FastAPI：这些是常见的 Python Web 框架。
SQLAlchemy / Django ORM：数据库操作，ORM 技术。
Redis / Celery：缓存、任务队列、异步处理。
Nginx / Gunicorn：服务器配置与性能优化。
GraphQL / RESTful API：构建和维护 API。

参与度：

设计系统架构，如选择合适的数据库和缓存机制。
编写 RESTful API 或 GraphQL API，处理请求和响应。
使用异步任务队列（如 Celery）处理长时间运行的任务。
性能优化，解决高并发请求时的性能瓶颈。
编写单元测试和集成测试。

2. 分布式系统与微服务

在分布式系统中，参与者需要解决服务间的通信、数据同步、容错性、负载均衡等问题。

技术栈：

Kafka / RabbitMQ：消息队列系统，进行服务间的异步通信。
Docker / Kubernetes：容器化、容器编排工具。
gRPC / REST：服务间的通信协议。
Prometheus / Grafana：监控和日志系统。

参与度：

设计微服务架构，确定服务拆分和通信方式。
实现服务间的数据同步与事务管理。
编写服务接口，处理消息队列或 gRPC 请求。
监控和调试分布式应用，优化系统性能和可用性。
管理容器化部署和服务扩展。

4. 自动化与工具开发

在这类项目中，开发者需要创建自动化脚本、工具和平台来提升生产效率或优化业务流程。

技术栈：

Fabric / Ansible / SaltStack：自动化运维工具。
Selenium / PyAutoGUI：自动化测试和UI自动化。
BeautifulSoup / Scrapy：网页爬取和数据抓取。
Click / Typer：命令行工具开发。

参与度：

编写自动化任务或脚本，优化业务流程。
集成第三方 API，创建自动化工具。
设计和开发命令行工具，增强用户体验。
编写自动化测试框架，确保工具的稳定性和可扩展性。
部署并维护自动化平台或工具。

6. 云平台与 DevOps 工具
   云平台和 DevOps 项目涉及到开发、构建、测试、部署、监控等过程的自动化。

技术栈：

Docker / Kubernetes：容器化和容器编排。
Terraform / CloudFormation：基础设施即代码（IaC）工具。
CI/CD Tools：Jenkins、GitLab CI、CircleCI等。
AWS / Azure / Google Cloud：云平台。

参与度：

设计和搭建云基础设施，管理云资源。
实现 CI/CD 流程，自动化构建、测试和部署。
使用容器和 Kubernetes 进行应用部署和管理。
管理监控和日志系统，确保系统稳定运行。

示例项目：

Cloud-native Applications：构建和优化在云环境下运行的应用程序。
CI/CD Pipelines：为开发团队搭建持续集成和持续部署的流水线。

2. web框架，介绍一个基本架构，ORM用的什么，数据库是什么

Django 是一个高效的 Python Web 框架，它遵循了 MVC（Model-View-Controller） 模式，但在 Django 中称其为 MTV（Model-Template-View） 模式。Django 的架构非常模块化，旨在通过自动化和简化常见的 Web 开发任务来提高开发效率。以下是 Django 的基本架构以及各个组件的作用。

1. Django 的 MTV 架构

• 功能：Model 负责与数据库交互，定义数据库的结构（即表结构）以及数据之间的关系。每个 Model 类对应数据库中的一张表，Model 中的字段定义即为数据库表的字段。
• 作用：通过 Model，开发者可以非常简洁地操作数据库，而不需要手写 SQL 查询语句。Django 提供了一个 ORM（对象关系映射）层，使得 Python 对象和数据库表之间能够自动映射。

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    published_date = models.DateField()

• T – Template（模板）
  功能：Template 负责呈现数据，即展示 HTML 页面。Django 使用模板引擎（Django Template Language, DTL）来动态生成 HTML 内容。
• 作用：模板将数据（由 View 传递）渲染成 HTML 进行展示，模板文件通常包含 HTML 代码和特殊的模板标签/变量，用来动态渲染数据。

<h1>{
  { book.title }}</h1>
<p>Author: {
  { book.author }}</p>
<p>Published on: {
  { book.published_date }}</p>

• V – View（视图）
  功能：View 是 Django 的核心，它处理 HTTP 请求并返回 HTTP 响应。视图将从 Model 获取数据，将数据传递给 Template，并生成最终的页面响应。
• 作用：View 中包含逻辑代码，处理用户请求、执行相应的数据库操作、调用模型、准备数据并将数据传递给模板进行渲染。视图的工作包括处理 URL 路由、表单提交、请求验证等。

from django.shortcuts import render
from .models import Book

def book_detail(request, book_id):
    book = Book.objects.get(id=book_id)
    return render(request, 'book_detail.html', {'book': book})

2. URL 路由系统

功能：Django 采用 URL 路由机制来将用户的请求映射到对应的视图函数。URL 配置通常保存在 urls.py 文件中。
作用：URL 路由系统负责处理不同的 HTTP 请求，并将它们发送到适当的视图处理函数。Django 支持通过正则表达式进行 URL 匹配，并允许动态捕获 URL 中的变量（例如文章 ID）。

from django.urls import path
from . import views

urlpatterns = [
    path('book/<int:book_id>/', views.book_detail, name='book_detail'),
]

3. Admin（管理界面）

功能：Django 提供了一个强大的后台管理系统，默认情况下可以通过管理界面来管理网站的数据和内容。
作用：开发者可以通过 Django 的 Admin 界面快速进行数据的增删改查。Django 自动为每个模型生成一个管理界面，可以进行模型对象的编辑、删除、查看等操作。

from django.contrib import admin
from .models import Book

admin.site.register(Book)

4. Forms（表单）

功能：Django 提供了处理表单的功能。Django 的 forms 模块允许开发者快速创建、渲染和验证表单。
作用：通过表单，开发者可以方便地处理用户输入的数据并进行验证、清理、保存等操作。

5. Settings（配置文件）

功能：Django 项目有一个配置文件（settings.py），用于存放项目的配置项，例如数据库配置、缓存设置、安全设置等。
作用：配置文件包含 Django 项目的所有配置项，例如数据库连接信息、静态文件路径、应用的配置、第三方库的配置等。

6. Middleware（中间件）

功能：Django 的中间件是一个钩子框架，允许开发者在请求和响应的处理过程中插入自定义的处理逻辑。
作用：中间件可以对 HTTP 请求和响应进行预处理或后处理。例如，可以通过中间件进行请求认证、会话管理、跨域请求处理等。
示例：Django 内置了如 AuthenticationMiddleware、SessionMiddleware 等中间件，开发者也可以自定义中间件。

class CustomMiddleware:
	    def __init__(self, get_response):
	        self.get_response = get_response
	    def __call__(self, request):
	        # Process request
	        response = self.get_response(request)
	        # Process response
	        return response

7. Static 和 Media 文件

功能：Django 支持静态文件（如 CSS、JavaScript、图片等）的管理和处理。静态文件通常是与前端展示相关的资源，而媒体文件是用户上传的文件。
作用：Django 通过 STATICFILES_DIRS 和 MEDIA_URL 配置来管理静态文件和媒体文件，开发者可以在模板中引用这些静态资源。
示例：

STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static']
媒体文件配置：
python
复制代码
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

8. Authentication 和 Authorization（认证与授权）

功能：Django 提供了完整的认证和授权机制。它允许开发者轻松实现用户注册、登录、权限控制等功能。
作用：通过 Django 内置的用户认证系统，可以管理用户身份、角色、权限等，确保不同用户能访问不同的资源。

from django.contrib.auth.models import User

user = User.objects.create_user('john', 'john@example.com', 'password')

9. Signals（信号）
   功能：Django 提供了信号机制，它允许不同的部分（例如模型、视图等）之间进行松耦合的通信。
   作用：信号可以在特定事件发生时（如保存数据、用户登录等）触发特定的操作或通知。

from django.db.models.signals import pre_save
from django.dispatch import receiver

@receiver(pre_save, sender=Book)
def book_pre_save(sender, instance, **kwargs):
    print(f"About to save book: {instance.title}")

总结

• Django 的基本架构遵循了 MTV（Model-Template-View） 模式，其中：

  Model 处理数据和数据库；
  Template 负责显示数据；
  View 处理请求并将结果传递给 Template 进行渲染。
  通过这种结构，Django 提供了清晰的职责分离，极大地提高了开发效率和代码的可维护性。除了 MTV 模式，Django 还提供了许多其他功能，如强大的 Admin 后台管理、认证与授权、中间件支持、缓存机制、静态和媒体文件管理 等，使得 Web 应用的开发变得更加简单和快速。

3. python搭建过微服务，了解RPC框架吗？python的RPC框架，或者console注册中心

Python 实现微服务通常涉及多个组件和框架的结合，包括 RPC 框架、服务发现、负载均衡、配置管理等。下面介绍如何使用 Python 实现微服务架构，以及常见的 RPC 框架和服务注册中心的实现方法。

1. 微服务架构的基本要素

在微服务架构中，通常需要关注以下几个方面：

• 服务之间的通信：微服务通常通过远程过程调用（RPC）进行通信，或者通过 HTTP（如 RESTful API）或消息队列（如 Kafka、RabbitMQ）进行消息传递。
• 服务发现和注册：微服务系统中各个服务需要动态发现彼此的地址，通常使用服务注册中心来进行注册和发现。
• 负载均衡：微服务之间的调用需要负载均衡来分配请求。
• 容错和重试机制：微服务之间的调用可能出现故障，需要实现重试、超时和断路器等机制。

2. Python 实现微服务的常见方式

2.1 RPC 框架

远程过程调用（RPC）是一种允许不同计算机之间进行通信的协议。Python 中有一些 RPC 框架，可以用于微服务之间的通信：

2.1.1 gRPC

介绍：gRPC 是 Google 推出的高性能、开源的 RPC 框架，基于 HTTP/2 协议和 Protocol Buffers（protobuf）序列化格式。gRPC 可以用于 Python 实现微服务的通信。

特点：

• 高性能：基于 HTTP/2 和 Protobuf。
• 支持双向流：支持双向流通信。
• 跨语言支持：支持多种编程语言。
• 自带负载均衡、服务发现等功能。

使用方式：

• 使用 grpcio 库来实现 Python 的客户端和服务端。
• 定义服务接口（.proto 文件），然后生成客户端和服务端代码。

安装 gRPC：
pip install grpcio grpcio-tools
示例代码：

定义服务（helloworld.proto）：

syntax = "proto3";
service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}
message HelloRequest {
  string name = 1;
}
message HelloReply {
  string message = 1;
}

生成 Python 代码：

python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. helloworld.proto

服务端实现：

import grpc
from concurrent import futures
import helloworld_pb2
import helloworld_pb2_grpc

class Greeter(helloworld_pb2_grpc.GreeterServicer):
    def SayHello(self, request, context):
        return helloworld_pb2.HelloReply(message=f"Hello, {request.name}")

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

if __name__ == '__main__':
    serve()
客户端实现：

python
复制代码
import grpc
import helloworld_pb2
import helloworld_pb2_grpc

def run():
    with grpc.insecure_channel('localhost:50051') as channel:
        stub = helloworld_pb2_grpc.GreeterStub(channel)
        response = stub.SayHello(helloworld_pb2.HelloRequest(name='World'))
        print(f"Greeter client received: {response.message}")

if __name__ == '__main__':
    run()

2.1.2 Pyro4

• 介绍：Pyro4 是一个基于 Python 的轻量级 RPC 库，能够在 Python 中实现对象的远程调用。

特点：

轻量级且易于使用。
支持跨网络的远程调用。
支持对象的自动序列化。

安装：

pip install Pyro4

服务端：

import Pyro4

@Pyro4.expose
class Greeter:
    def say_hello(self, name):
        return f"Hello, {
     name}"

daemon = Pyro4.Daemon()                # make a Pyro daemon
ns = Pyro4.locateNS()                  # find the name server
uri = daemon.register(Greeter)         # register the Greeter class
ns.register("example.greeter", uri)    # register the Greeter object in the name server

print("Ready. Waiting for requests...")
daemon.requestLoop()                   # start the event loop
客户端：

python
复制代码
import Pyro4

greeter = Pyro4.Proxy("PYRONAME:example.greeter")  # connect to the remote object
print(greeter.say_hello("World"))

2.1.3 Celery

介绍：Celery 是一个异步任务队列/调度框架，广泛用于微服务架构中的后台任务处理。它支持消息传递机制，可以实现任务的异步执行、定时执行等功能。

特点：

支持异步任务和分布式任务队列。
支持多种消息代理（如 RabbitMQ、Redis）。
支持定时任务和任务优先级。

使用方式：

pip install celery

• 配置 Celery 并使用 Redis/RabbitMQ 作为消息代理。
• 使用 Celery 来管理微服务中的异步任务。

2.2 服务发现和注册中心

在微服务架构中，服务发现是一个重要的部分，它使得服务能够动态地注册自己并发现其他服务。常见的服务注册中心包括 Consul、Eureka、Zookeeper 等。

2.2.1 Consul

介绍：Consul 是 HashiCorp 开发的一个开源工具，提供了服务发现、健康检查和配置管理等功能。它可以与 Python 结合使用，通过 python-consul 库实现服务注册与发现。

安装：

pip install python-consul

服务注册与发现示例：

from consul import Consul

# 注册服务
consul = Consul()
consul.agent.service.register('my-service', service_id='my-service-id', port=5000)

# 查询服务
index, services = consul.catalog.services()
print(services)

2.2.2 Zookeeper

介绍：Zookeeper 是一个分布式协调服务，用于分布式系统的协调、配置管理和服务发现。它支持分布式锁、选举、配置管理等功能。

安装：

pip install kazoo

服务注册与发现示例：

from kazoo.client import KazooClient

# 创建 Zookeeper 客户端
zk = KazooClient(hosts='127.0.0.1:2181')
zk.start()

# 注册服务
zk.create('/services/my-service', b"127.0.0.1:5000", ephemeral=True)

# 查询服务
service = zk