Python—常见模块概述（9）

python-dotenv

python-dotenv 是一个 Python 库，用于从 .env 文件中加载环境变量到你的应用程序中。这是管理敏感信息（如数据库凭证、API 密钥和配置参数）的一种安全而灵活的方式，而无需将这些信息硬编码到代码中。

pip install python-dotenv

• 在项目的根目录下创建一个 .env 文件，里面包含你需要的环境变量。这些环境变量以 KEY=VALUE 的格式存储。

DATABASE_URL=localhost:3306
SECRET_KEY=a123456
API_KEY=api_key
DEBUG=True

• 在 Python 代码中使用 dotenv，首先需要加载 .env 文件中的内容。 load_dotenv 函数可用来加载变量，并通过 os.getenv() 或 os.environ 来访问这些变量。

from dotenv import load_dotenv
import os

# 将 .env 文件中的环境变量加载到系统中
load_dotenv()

# 访问环境变量
database_url = os.getenv('DATABASE_URL')
secret_key = os.getenv('SECRET_KEY')
api_key = os.getenv('API_KEY')
debug = os.getenv('DEBUG')

print(f"Database URL: {database_url}")
print(f"Secret Key: {secret_key}")
print(f"API Key: {api_key}")
print(f"Debug Mode: {debug}")

使用 os.getenv() 和 os.environ

• os.getenv('VARIABLE_NAME'): 通过环境变量名称获取相应的值。如果环境变量不存在，默认返回 None（也可以指定默认值，例如：os.getenv('DATABASE_URL', 'default_value')）。
• os.environ['VARIABLE_NAME']: 直接通过 os.environ 字典访问环境变量。如果变量不存在，会抛出 KeyError 异常。

安全性和最佳实践

• 避免将 .env 文件提交到版本控制： .env 文件中通常包含敏感信息，所以一定要将它添加到 .gitignore 文件中，防止被意外提交到 Git 仓库。

• 不同环境使用不同的 .env 文件： 在开发、测试和生产环境中，可以使用不同的 .env 文件，例如 .env.dev、.env.prod 等，这样可以根据不同的环境设置不同的配置。

• 不要将敏感信息写死在代码中： 将数据库密码、API 密钥等信息保存在 .env 文件中，可以避免这些敏感信息出现在代码中，提升安全性。

SQLite

SQLite是一种嵌入式数据库，其数据库存储为单个文件。由于SQLite由C语言编写且体积小，常被集成到各种应用中，包括iOS和Android应用。Python内置SQLite3模块，无需安装。

import sqlite3

# 连接数据库
connection = sqlite3.connect('dawn.db')
cursor = connection.cursor()

# 创建表
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT,
    age INTEGER
)
''')

# 插入数据
cursor.execute("INSERT INTO users (name, age) VALUES ('王林', 30)")
cursor.execute("INSERT INTO users (name, age) VALUES ('李慕婉', 25)")
connection.commit()

# 查询数据
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

# 更新数据
cursor.execute("UPDATE users SET age = 26 WHERE name = '王林'")
connection.commit()

# 删除数据
cursor.execute("DELETE FROM users WHERE name = '李慕婉'")
connection.commit()

# 关闭连接
cursor.close()
connection.close()

mysql-connector-python

在Python中连接和操作MySQL数据库，通常使用第三方库mysql-connector-python(Mysql 官网提供)或PyMySQL

pip install mysql-connector-python 

import mysql.connector

# 连接到MySQL数据库
connection = mysql.connector.connect(
    host="192.168.10.200",
    user="root",
    password="a123456",
    database="skeleton",
    port=3306
)

# 创建游标
cursor = connection.cursor()

# 创建表
cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255),
    age INT
)
''')

# 插入数据
cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("李慕婉", 30))
cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("王林", 25))
connection.commit()

# 查询数据
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall()
for row in rows:
    print(row)

# 更新数据
cursor.execute("UPDATE users SET age = 26 WHERE name = '王林'")
connection.commit()

# 删除数据
cursor.execute("DELETE FROM users WHERE name = '李慕婉'")
connection.commit()

# 关闭游标和连接
cursor.close()
connection.close()

SQLAlchemy

SQLAlchemy 是一个强大的 Python ORM（对象关系映射）库。使得你可以通过 Python 对象来表示数据库中的数据，而不是直接写 SQL 语句。

• SQLAlchemy Core：是一个低级别的库，提供了与数据库的直接交互和 SQL 构建的能力。它使用的是 SQL 表达式语言，可以手动构建和执行 SQL 查询。
• SQLAlchemy ORM：是一个高级的 ORM（对象关系映射）工具，提供了将 Python 类与数据库表进行映射的功能。它使得我们能够通过类和对象来操作数据库，而无需手写 SQL。

pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, sessionmaker

# 创建数据库引擎（使用SQLite数据库）
engine = create_engine('sqlite:///dawn.db', echo=True)

# 创建基类
Base = declarative_base()

# 定义User类（数据库模型）
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    age = Column(Integer)

    def __repr__(self):
        return f"<User(name={self.name}, age={self.age})>"

# 创建所有表
Base.metadata.create_all(engine)

# 创建Session类并启动会话
Session = sessionmaker(bind=engine)
session = Session()

# 插入数据
new_user = User(name="李慕婉", age=30)
session.add(new_user)
session.commit()

# 查询数据
users = session.query(User).all()
for user in users:
    print(user)

# 更新数据
user = session.query(User).filter_by(name="李慕婉").first()
if user:
    user.age = 31
    session.commit()

# 删除数据
user = session.query(User).filter_by(name="李慕婉").first()
if user:
    session.delete(user)
    session.commit()

# 关闭会话
session.close()

socket

Python 提供了 socket 模块来进行 TCP 和 UDP 的网络编程。

TCP 服务器代码

import socket

# 创建 TCP 套接字
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind(('localhost', 12345))
server_socket.listen(1)
print("等待客户端连接...")
# 等待客户端连接
client_socket, client_address = server_socket.accept()
print(f"客户端 {client_address} 已连接")
# 接收数据
data = client_socket.recv(1024)
print(f"接收到的数据: {data.decode()}")
# 发送数据
client_socket.sendall("你好，客户端！".encode())
# 关闭连接
client_socket.close()
server_socket.close()

TCP 客户端代码

import socket

# 创建 TCP 套接字 并 连接
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(('localhost', 12345))
# 发送数据
client_socket.sendall("你好，服务器！".encode())
# 接收数据
data = client_socket.recv(1024)
print(f"接收到的数据: {data.decode()}")
# 关闭连接
client_socket.close()

UDP 不需要建立连接，可以直接发送数据。

UDP 服务端代码

import socket

# 创建 UDP 套接字，绑定服务器地址和端口
server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server_socket.bind(('localhost', 12345))
print("等待接收数据...")
# 接收数据
data, client_address = server_socket.recvfrom(1024)
print(f"接收到的数据: {data.decode()} 来自: {client_address}")
# 发送数据
server_socket.sendto("你好，客户端！".encode(), client_address)
# 关闭套接字
server_socket.close()

UDP 客户端代码

import socket

# 创建 UDP 套接字
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 发送数据
client_socket.sendto("你好，服务器！".encode(), ('localhost', 12345))
# 接收数据
data, server_address = client_socket.recvfrom(1024)
print(f"接收到的数据: {data.decode()} 来自: {server_address}")
# 关闭套接字
client_socket.close()

Flask

Flask 是一个用 Python 编写的轻量级 Web 框架，基于 WSGI（Web Server Gateway Interface） 协议，并且遵循 MVC（Model-View-Controller） 架构模式。它提供了简单、灵活的方式来构建 Web 应用。

(dawn) ➜  web git:(master) ✗ tree
.
├── flask_test.py
└── templates
    └── index.html

from flask import Flask, render_template, request

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/greet', methods=['POST'])
def greet():
    name = request.form.get('name')
    return render_template('index.html', name=name)

if __name__ == '__main__':
    app.run(debug=True)

模版内容

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask Greeting</title>
</head>
<body>
    <h1>Welcome to Flask!</h1>
    <form method="POST" action="/greet">
        <label for="name">Enter your name:</label>
        <input type="text" id="name" name="name">
        <button type="submit">Submit</button>
    </form>

    {% if name %}
        <h2>Hello, {{ name }}!</h2>
    {% endif %}
</body>
</html>

FastAPI、Uvicorn

Uvicorn 和 FastAPI 的关系可以类比为 Tomcat 和 Web 应用 之间的关系

FastAPI 是一个现代的、快速（高性能）的 Web 框架，用于构建 API，特别适用于构建 RESTful API 和微服务。它基于 Python 3.6 及以上版本，并且使用了 Python 类型提示（type hints）来进行自动化的文档生成和数据验证，使得 API 的开发更加简洁且易于维护。

Uvicorn 是一个高性能的 ASGI（Asynchronous Server Gateway Interface） 服务器，在 Python Web 开发中，Uvicorn 作为一个 HTTP 服务器充当了应用程序与客户端之间的中介，处理客户端请求并将其传递给你的应用，同时将应用的响应返回给客户端。

要使用 FastAPI，需要安装 FastAPI 和 Uvicorn（用于启动 ASGI 应用的服务器）

pip install fastapi uvicorn

创建 application.py

from fastapi import FastAPI
from pydantic import BaseModel

# 创建 FastAPI 实例
app = FastAPI()

# 定义请求体的数据模型
class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.get("/")
def read_root():
    return {"message": "Hello, World!"}

@app.get("/items/{item_id}")
def read_item(item_id: int, query_param: str = None):
    return {"item_id": item_id, "query_param": query_param}

@app.post("/items/")
def create_item(item: Item):
    return {"name": item.name, "price": item.price}

使用 Uvicorn 服务器来启动应用，--reload 表示代码更改后会自动加载

uvicorn main:app --reload

• 文档地址：http://127.0.0.1:8000/docs
• 交互式文档地址：http://127.0.0.1:8000/redoc

Pillow

PIL Python Imaging Library 曾是 Python 图像处理的领军工具，但由于其维护停滞不前于是 Pillow 诞生了。

Pillow 是一个 Python 图像处理库，提供了广泛的图像操作功能，如打开、编辑、保存、转换和处理图像。它是 Python Imaging Library（PIL）的一个分支，并提供对常见图像格式的支持，如 JPEG、PNG、GIF 等。Pillow 可用于图像裁剪、缩放、旋转、颜色调整、滤镜应用等任务。

安装 pillow

 pip install pillow

requests

urllib 是 Python 内置的模块，用于访问网络资源，但操作起来较为复杂，缺乏很多高级功能。相比之下，requests 是一个第三方库，提供了更简洁和强大的功能，能够更加方便地处理 URL 资源。

import requests

# GET
response = requests.get('https://httpbin.org/get')
print(response.status_code)  # 状态码
print(response.text)  # 返回的内容

# POST
data = {'key': 'value'}
response = requests.post('https://httpbin.org/post', data=data)
print(response.status_code)
print(response.json())  # 如果返回的是 JSON 数据

# 添加请求头
headers = {'User-Agent': 'my-app'}
response = requests.get('https://httpbin.org/headers', headers=headers)
print(response.json())

# 处理超时
try:
    response = requests.get('https://httpbin.org/delay/5', timeout=3)
except requests.exceptions.Timeout:
    print('Request timed out')

# 上传文件
# 'rb'即二进制模式读取，这样获取的bytes长度才是文件的长度
files = {'file': open('test.txt', 'rb')}
response = requests.post('https://httpbin.org/post', files=files)
print(response.json())

# 处理cookies
cookies = {'session_id': '123456'}
response = requests.get('https://httpbin.org/cookies', cookies=cookies)
print(response.json())

# 自定义认证
from requests.auth import HTTPBasicAuth
response = requests.get('https://httpbin.org/basic-auth/user/pass', auth=HTTPBasicAuth('user', 'pass'))
print(response.status_code)

chardet

chardet 是一个 Python 库，用于自动检测文本编码。它能根据字节序列推测出数据的字符编码，常用于处理来自不确定编码的文本数据，比如从网络获取的内容或读取文件时。

pip install chardet

检测文本编码

import chardet
# 假设我们有一个字节串
byte_data = b'\xe4\xbd\xa0\xe5\xa5\xbd'  # 这是 "你好" 的 UTF-8 编码
result = chardet.detect(byte_data)
print(result)
"""执行结果
{'encoding': 'utf-8', 'confidence': 0.99, 'language': 'zh'}

encoding: 检测到的编码类型
confidence: 编码的置信度（范围从 0 到 1）
language: 可能的语言（有时可能为空）
"""

# 检测文件编码
with open('example.txt', 'rb') as file:
byte_data = file.read()
result = chardet.detect(byte_data)

print(result)

# 处理字节串
byte_data = b'\xe4\xbd\xa0\xe5\xa5\xbd'
encoding = chardet.detect(byte_data)['encoding']
decoded_data = byte_data.decode(encoding)
print(decoded_data)  # 输出 "你好"

# 以与其他库配合，比如在爬虫中判断网页的编码
response = requests.get('https://www.example.com')
encoding = chardet.detect(response.content)['encoding']
text = response.content.decode(encoding)

psutil

Python可通过 subprocess 模块调用系统命令（如ps、top、free等）获取监控系统状态，但需要写大量的代码，而另一种更为简便的方法是使用 psutil（process and system utilities） 可通过简洁的代码实现跨平台的系统监控，支持Linux、UNIX、OSX、Windows等

pip install psutil

import psutil

# cpu 物理核数
r0 = psutil.cpu_count(logical=False)
print(r0)
# cpu 逻辑核数
r1 = psutil.cpu_count()
print(r1)

# 获取每个 CPU 核心的使用率
print(psutil.cpu_percent(interval=1))  # 总体 CPU 使用率
print(psutil.cpu_percent(percpu=True, interval=1))

# cpu空闲时间
r0 = psutil.cpu_times()
print(r0)

# 获取内存信息
# 获取系统的虚拟内存
memory = psutil.virtual_memory()
print(f"总内存: {memory.total}")
print(f"已用内存: {memory.used}")
print(f"空闲内存: {memory.free}")
print(f"内存使用百分比: {memory.percent}%")
# 获取交换内存
swap = psutil.swap_memory()
print(f"交换总内存: {swap.total}")
print(f"交换已用内存: {swap.used}")

# 获取磁盘分区
partitions = psutil.disk_partitions()
for partition in partitions:
    print(partition.device, partition.mountpoint, partition.fstype)

# 获取磁盘使用情况
disk_usage = psutil.disk_usage('/')
print(f"磁盘总空间: {disk_usage.total}")
print(f"磁盘已用: {disk_usage.used}")
print(f"磁盘使用百分比: {disk_usage.percent}%")


# 获取网络接口状态
net_io = psutil.net_io_counters()
print(f"发送字节数: {net_io.bytes_sent}")
print(f"接收字节数: {net_io.bytes_recv}")

# 获取每个网络接口的统计
net_if_addrs = psutil.net_if_addrs()
for interface, addrs in net_if_addrs.items():
    print(f"接口 {interface}:")
    for addr in addrs:
        print(f"  {addr.family}, {addr.address}")


# 获取所有进程的 PID 和名称
for proc in psutil.process_iter(['pid', 'name']):
    print(proc.info)

# 获取指定进程的内存和CPU使用情况
pid = 1234  # 替换为实际进程 ID
proc = psutil.Process(pid)
print(f"进程 {pid} CPU 使用率: {proc.cpu_percent(interval=1)}%")
print(f"进程 {pid} 内存使用: {proc.memory_info().rss} bytes")


# 获取系统启动时间
boot_time = psutil.boot_time()
print(f"系统启动时间: {boot_time}")

# 获取当前的系统时间
import datetime
print(f"当前时间: {datetime.datetime.now()}")

# 获取系统负载（1、5、15分钟的平均负载）
load = psutil.getloadavg()
print(f"1分钟平均负载: {load[0]}")
print(f"5分钟平均负载: {load[1]}")
print(f"15分钟平均负载: {load[2]}")

Tkinter

Tkinter 是 Python 标准库中的一个模块，用于创建图形用户界面 (GUI)。它是 Python 的默认 GUI 库，提供了许多控件（如按钮、标签、文本框等），可以用来开发桌面应用程序。Tkinter 基于 Tcl/Tk，是一个轻量级的 GUI 工具包，易于使用且兼容多个平台（Windows、Linux、macOS）。

import tkinter as tk
# 创建 Tk 对象 root 作为根窗口，并设置了窗口的标题和大小。
root = tk.Tk()
root.title("用户信息表单")
root.geometry("300x300")

# Label 创建标签。
# Entry 创建输入框，供用户输入信息。
name_label = tk.Label(root, text="姓名:")
name_label.pack(pady=5)
name_entry = tk.Entry(root)
name_entry.pack(pady=5)

gender_label = tk.Label(root, text="性别:")
gender_label.pack(pady=5)

# Radiobutton 控件来创建单选按钮
gender_var = tk.StringVar()
male_radio = tk.Radiobutton(root, text="男", variable=gender_var, value="男")
male_radio.pack(pady=5)
female_radio = tk.Radiobutton(root, text="女", variable=gender_var, value="女")
female_radio.pack(pady=5)

# 提交按钮
submit_button = tk.Button(root, text="提交")
submit_button.pack(pady=20)

# 启动主事件循环
root.mainloop()

Turtle

在1966年，Seymour Papert和Wally Feurzig发明了LOGO语言，旨在帮助儿童学习编程。LOGO通过编程控制一个小海龟在屏幕上绘图。后来的Python内置了turtle库，完全继承了这种海龟绘图的功能。

绘制一个正方形

import turtle

t = turtle.Turtle()

# 设置颜色
t.color("blue")

# 绘制正方形
for _ in range(4):
    t.forward(100)
    t.left(90)

turtle.done()

• Screen命令：
  • bgcolor(): 设置背景颜色
  • title(): 设置窗口标题
  • setup(): 设置窗口大小和位置
  • tracer(): 设置绘图更新速度
• Turtle命令：
  • forward() / fd(): 向前移动指定步数
  • backward() / bk(): 向后移动指定步数
  • right() / rt(): 向右旋转指定角度
  • left() / lt(): 向左旋转指定角度
  • penup() / pu(): 提起画笔
  • pendown() / pd(): 放下画笔
  • speed(): 设置绘图速度
  • goto(): 移动到指定位置
  • setpos(): 设置当前位置
  • setposition(): 设置当前位置
  • setx(): 设置X坐标
  • sety(): 设置Y坐标
  • circle(): 绘制圆形
  • dot(): 绘制圆点
  • stamp(): 留下印记
• 颜色命令：
  • color(): 设置画笔颜色
  • begin_fill(): 开始填充
  • end_fill(): 结束填充
  • fillcolor(): 设置填充颜色
• 状态控制命令：
  • pen(): 激活画笔
  • isdown(): 检查画笔是否在画布上
  • isvisible(): 检查乌龟是否可见
  • showturtle(): 显示乌龟
  • hideturtle(): 隐藏乌龟
  • reset(): 重置画布
  • clear(): 清除绘制内容
• 窗口操作命令：
  • exitonclick(): 点击窗口退出
  • onscreenclick(): 设置点击事件
  • onkey(): 监听键盘事件
  • listen(): 开始监听事件
• 其他命令：
  • write(): 写文本
  • distance(): 计算当前位置到某点的距离
  • towards(): 获取当前位置指向指定点的角度