选择的 Web 组件是 Python 里面的 Django ，这不一定是一个最佳的框架或者最快的框架，当时他应该算是一个最成熟的框架。

学习嘛，不追求性能，先看看这个框架应该是有利于了解 Python 全貌的。

二. 初阶使用

2.1 django 的使用

这是一个最常见的第三方库的使用方式， Django 对标 Java 的 Spring , 在 Python 操作如下 ：

• S1 : 命令行中通过 pip 下载第三方组件 （国内正常网络都可以下载）pip install django
• S2 : 通过提供的工具创建项目django-admin startproject YouProjectName
• S3 : 直接在项目中运行python manage.py runserver
• S4 : 访问路径44http://127.0.0.1:8000/

2.2 创建第一个接口

首先要知道,前面S2创建的目录结构是这样的 ，然后我在这个目录下面创建了一个 API

java复制代码- project 
    |- manage.py 
    |- project 
        |- settings.py 
        |- urls.py 
    |- api （自己手动创建）
        |- TestController.py

S1 : 创建自己的 API 类

python复制代码from django.http import JsonResponse

def hello(request):
    data = {
        'message': 'Hello, API!'
    }
    return JsonResponse(data)

S2 : 设置 URL 引用

这里我首先通过 from 引用了这对象，这里 api.TestController 就像我们的包名，hello 就是包里面的方法

python复制代码from django.contrib import admin
from django.urls import path
from api.TestController import hello

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/hello/', hello),
]

阶段总结

在我们使用 django-admin startproject project_name 创建完项目之后，会自动生成几个文件，这几个文件也是该项目的基础

java复制代码- Parent 
    |- manage.py 
    |- ProjectName
        |- __init__.py :
        |- asgi.py : 
        |- setting.py : 
        |- urls.py :
        |- wsgi.py : 

2.3 Rest 接口

通常 Java 里面会定义 Get 接口和 Post 接口，对应 Python 也有相关的实现 ：

python复制代码import json
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from .dto import person

## 实现 Get 接口
def get_endpoint(request):
    response_data = {
        "message": "Get 请求成功",
        "data" :""
    }
    return JsonResponse(response_data)


## 实现 Post 接口
@csrf_exempt
def post_endpoint(request):
    # 如果这是个 Post 请求 （PS ：想直接基于类型可能需要更复杂得框架）
    if request.method == 'POST':
        data = request.POST  
        response_data = {
            "message": f"接收 POST 数据: {data}"
        }
        return JsonResponse(response_data)
    else:
        response_data = {
            "error": "Invalid request method"
        }
        return JsonResponse(response_data, status=400)


## 实现 Post 接口 （接收 JSON 数据）
@csrf_exempt
def post_endpoint_json(request):
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
            # 现在 data 是 Python 字典，包含从请求体解析的 JSON 数据
            response_data = {
                "message": f"接收 JSON 数据: {data}"
            }
            return JsonResponse(response_data)
        except json.JSONDecodeError:
            response_data = {
                "error": "Invalid JSON data"
            }
            return JsonResponse(response_data, status=400)
            
# 实现 Post 接口 （接收对象转换为 Class Bean ）
@csrf_exempt
def doPostBean(request):
    if request.method == 'POST':
        try:
            data = json.loads(request.body)
            personDto = person.Person(**data)
            jsonStr = json.dumps(personDto.__dict__)
            response_data = {
                "message": "接收对象:"+jsonStr
            }

            return JsonResponse(response_data)
        except json.JSONDecodeError:
            response_data = {
                "error": "异常 JSON 数据"
            }
            return JsonResponse(response_data, status=400)
    else:
        response_data = {
            "error": "Invalid request method"
        }
        return JsonResponse(response_data, status=400)

            

阶段总结 ：

• 也不一定都是在请求中判断 method 方法， Flask 也可以通过注解进行处理
• Python 的组件特别多，想要更丰富的功能可以找其他的组件，但是 python 相对而言不需要那么丰富的 Web 功能
• Post 接口涉及到跨域问题

2.3 相对概念

• Python 是面向对象的，支持类，对象，继承，多态
• Python 同样以模块和包进行分隔
• Python 支持函数式编程
• Python 中有异常处理
• Python具有自动垃圾回收（Automatic Garbage Collection）机制，支持引用计数和循环收集

继承的写法

java复制代码
class Person:
    def __init__(self, name):
        self.name = name

    def user_info(self):
        print(f"Name: {self.name}")

 # 子类继承父类
class SelfPerson(Parent): 
    def __init__(self, name, age):
        super().__init__(name)  # 调用父类的构造函数
        self.age = age

    def user_info(self):  # 子类可以重写父类的方法
        print(f"Name: {self.name}, Age: {self.age}")

# 创建子类的实例
child = SelfPerson("gang", 10)

# 调用子类的方法
SelfPerson.user_info()  

异常处理的写法

java复制代码try:
    print("执行相关代码")
except SomethingException:
    print("Error: Exception show")
except TwoException: 
    print("Error: 支持多个异常")
else: 
    print("没有异常时会执行")
finally: 
    print("支持 Finally")

三. 常用的功能

3.1 语法

for 循环

java复制代码def get_endpoint(request):
    # 这是一个字典 key - value 
    my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

    # 这也是一个字典 key，它的value是 None （可以理解为 Set ）
    my_dict = {'key1', 'key2', 'key3'}

    # 这是一个列表 （也可以看成一个数组，但是在业务上其实会有不同）
    my_list = [1, 2, 'one', 'two']
    
    # 数组转 Map
    names = ['UserName123', 'goods', 'test666']
    name_lengths = {name: len(name) for name in names}
    print(name_lengths)    # -- {'UserName123': 11, 'goods': 5, 'test666': 7}

    # 数组循环后处理
    numbers = [1, 2, 3, 4, 5]
    squared = [x + 2 for x in numbers]
    print(squared)     # -- [3, 4, 5, 6, 7]
    squared = [x ** 2 for x in numbers]
    print(squared)     # -- [1, 4, 9, 16, 25]

    ## 数组转Map
    numbers = [1, 2, 2, 3, 4, 4, 5]
    unique_numbers = {x for x in numbers}
    print(unique_numbers)     # -- {1, 2, 3, 4, 5}

列表操作

java复制代码def get_endpoint(request):
    my_list = [1, 2, 'two']

    # 往列表添加数据
    my_list.append(4)  # 在后面追加
    my_list.insert(1, 5)  # 在指定索引内插入
    print(my_list)

    # 合并2个队列
    my_list_2 = [7, 8] + my_list
    print(my_list_2)

    # 添加到尾部
    my_list.extend([666,888])
    print(my_list)

Map 操作

java复制代码def get_endpoint(request):
    # 创建字典
    my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
    my_dict_key = {'key1', 'key2', 'key3'}

    # 访问字典值
    print("key value is :"+my_dict["key1"])
    keys = my_dict.keys()
    values = my_dict.values()

    # 设置值
    my_dict['key1'] = 'goods'
    print("key value is :"+my_dict["key1"])
    del my_dict['key1']

    # 判断值是否存在
    if 'key1' in my_dict:
        print("key value is :"+my_dict["key1"])

    # 循环字典
    for key in my_dict:
        print("key value is :"+key)
    for key, value in my_dict.items():
        print("key value is :"+key+value)

普通文件处理

java复制代码def readFile(request):

    # r : 读取
    # w : 写入
    # a : 追加
    # b : 二进制文件
    with open('E://output.txt', 'w') as file:
        file.write("Hello, world!")
    file.close()

    # utf-8 可以不加，用于定义编码
    listValue = []
    with open('E://output.txt', 'r', encoding='utf-8') as fileRead:
        print(fileRead.read())
        print(fileRead.readline())
    fileRead.close()

Excel 文件处理

java复制代码def exportExcel(request):

    # 创建一个新的Excel工作簿
    workbook = openpyxl.Workbook()
    sheet = workbook.active

    for row in data:
        sheet.append(row)

    # 保存Excel文件 (保存到相对路径)
    workbook.save("data.xlsx")

    # 保存到绝对路径
    workbook.save("E://data.xlsx")

    # 读取 Excel
    workbook = openpyxl.load_workbook('E://data.xlsx')
    sheet = workbook.active
    for row in sheet.iter_rows(min_row=1, max_row=sheet.max_row, min_col=1, max_col=sheet.max_column):
        print(row)
        for cell in row:
            print(cell.value)

方法调用

java复制代码def search(page, size):
    return value
    
def mysqlSearch(request):
    valueSearch = search(page, size)

不需要特意定义返回类型,只要 return 后就表示有返回, 在调用侧直接接收就行。

3.2 MySQL

java复制代码pip install mysqlclient

# models.py
import json
import re
import pymysql

from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt

# 代码中创建连接
connection = pymysql.connect(
    host='localhost',
    user='root',
    password='123456',
    db='antsso',
    cursorclass=pymysql.cursors.DictCursor
)


# 进行一个 QUery 操作
def mysqlSearch(request):
    # Read (Select)

    valueResponse = []
    page = 0
    size = 1

    print("S1 : 开始进行查询")
    while True:
        valueSearch = search(page, size)
        if len(valueSearch) <= 0:
            break
        else:
            print("查询到数据:"+json.dumps(valueSearch))
            valueResponse.append(valueSearch)
            page = (page+1)*size

    response_data = {
        "message": "Mysql 查询结果",
        "data": valueResponse
    }
    return JsonResponse(response_data)


# 查询主体
def search(page, size):
    print("S2 : 当前查询页数["+str(page)+","+str(size)+"]")
    valueResult = []
    with connection.cursor() as cursor:
        sql = "SELECT * FROM `sso_user` LIMIT  %s , %s"
        cursor.execute(sql, (page, size))
        result = cursor.fetchall()
        for row in result:
            valueResult.append(row)
    return valueResult


# 创建一个数据
def mysqlCreate(request):
    with connection.cursor() as cursor:
        sql = "INSERT INTO `sso_user` (`user_name`, `user_info`) VALUES (%s, %s)"
        cursor.execute(sql, ('test', "goog"))
    connection.commit()

    response_data = {
        "message": "Mysql 查询结果"
    }
    return JsonResponse(response_data)


# 更新一条数据
def mysqlUpdate(request):
    with connection.cursor() as cursor:
        sql = "UPDATE `sso_user` SET `user_type` = %s WHERE `user_name` = %s"
        cursor.execute(sql, (666, 'test'))
    connection.commit()

    response_data = {
        "message": "Mysql 查询结果"
    }
    return JsonResponse(response_data)


# 删除一条数据
def mysqlDelete(request):
    with connection.cursor() as cursor:
        sql = "DELETE FROM `persons` WHERE `name` = %s"
        cursor.execute(sql, ('goog',))
    connection.commit()

    response_data = {
        "message": "Mysql 查询结果"
    }
    return JsonResponse(response_data)

3.3 Redis

java复制代码pip install redis

# 创建一个 Redis 客户端连接
redisConn = redis.Redis(host='localhost', port=6379, db=0)

# 实现 Get 接口
def get_endpoint(request):

    # 设置键值对
    redisConn.set('name', 'John')

    # 获取值
    name = redisConn.get('name')
    print(name.decode('utf-8'))  # 输出: John

    # 执行列表操作
    redisConn.lpush('mylist', 'item1')
    redisConn.lpush('mylist', 'item2')
    items = redisConn.lrange('mylist', 0, -1)
    for item in items:
        print(item.decode('utf-8'))  # 输出: item2  item1

    response_data = {
        "message": "This is a GET endpoint"
    }
    return JsonResponse(response_data)

3.4 调用远程 API

java复制代码# 首先安装请求
pip install requests

import requests
from django.http import JsonResponse

def requestUrl(request):
    # 发起 API 调用
    url = "http://127.0.0.1:8000/search/"
    response = requests.get(url)

    if response.status_code == 200:
        data = response.json()  # 将响应内容解析为JSON格式
        print(" API 调用完成")
        print(data)
    else:
        print("API request failed")

    response_data = {
        "message": "调用完成"
    }
    return JsonResponse(response_data)

四. 入门难点梳理

4.1 代码思维

• 没有中括号 ，没有结束符 ，除了这些大致结构都差不多
• 类名大写，包名模块名小写

4.2 路径写法

与 Java 类似，Python 中可以通过 from ... import 来导入模块，通常由以下几种场景 ：

按照用法

• 引入module 和 使用者在同一级目录 ： from module import function
• 引入module 在其他路径 （可以使用相对路径和绝对路径）from .test.module import functionfrom myapp.test.module import function
• 从包中导入模块 ： from packageName.module import function
• 从包中导入模块（为其设置别名） ： from packageName.module import function as fun001
• 导入整个包 ： import my_package
• 导入整个Module : import module_name

按照层级

• 从同级别导入 ： from . import module2
• 从父级模块导入 ： from .. import module
• 从子包导入 ： from .subpackage2 import module2
• 从父包导入 ： from ..subpackage1 import module1
• 从根导入 ：from rootPath.my_package.packageName import module1

4.3 python 组件的查找方式

访问 python 官网即可 ： pypi.org/search/ ，里面提供了大量插件，提供了按照分类，按照框架进行分类查询

总结

对于Java程序员来说，掌握了基本用法想运行一个 Python 程序不难。如果主要目的是为了在一些特殊业务上做快速处理 ，那么这些也就足够了。

但是如果要深入使用 Python ，那就有必要多看点书了。从代码格式，到命名规范，到设计模式，虽然和其他语言有相同的思路，但是细节偏差还是有不少的。

目前在看 编写高质量代码：改善Python程序的91个建议 等几本书，等看完了下一篇就该出来了。