Java 程序员的第一套Python代码

首先分享之前的所有文章 , 欢迎点赞收藏转发三连下次一定 >>>> 😜😜😜
文章合集 : 🎁 juejin.cn/post/694164...
Github : 👉 github.com/black-ant
CASE 备份 : 👉 gitee.com/antblack/ca...

一. 前言

上一篇只是看了一些 Python 和 Java 对标的框架，这一篇主要是应用。

选择的 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 : 访问路径44
- http://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 代码思维

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

类型	公有	方式
包	`py_util`	小写下划线
模块	`py_excel_export`	小写下划线
类	`UserDto`	大驼峰
异常	`NullFoundEx`	大驼峰
函数	`search_user()`	小写下划线
全局常量/类常量	`USER_NAME_DEFAULT`	大写下划线
全局变量/类变量	`user_name_test`	小写下划线
实例变量	`testname`	小写下划线
方法名	`search()`	小写下划线
函数参数/方法参数	`page`	小写下划线
局部变量	`username`	小写下划线

4.2 路径写法

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

按照用法

引入module 和使用者在同一级目录 ： from module import function
引入module 在其他路径 （可以使用相对路径和绝对路径）
- from .test.module import function
- from 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个建议等几本书，等看完了下一篇就该出来了。

参考文档

www.djangoproject.com/