Java 程序员的第一套Python代码
选择的 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 代码思维
- 没有中括号 ，没有结束符 ，除了这些大致结构都差不多
- 类名大写，包名模块名小写
类型 | 公有 | 方式 |
包 | 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 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个建议 等几本书，等看完了下一篇就该出来了。