分类： Python

import sqlite3
import json

def sqlite_connect(db_path: str):
    # 连接到 SQLite 数据库
    # 如果文件不存在，会自动在指定位置创建一个数据库文件
    connection = sqlite3.connect(db_path)
    json_data = {}
    try:
        with connection:
            with connection.cursor() as cursor:
                # 获取所有表名
                cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
                所有表 = cursor.fetchall()

                for 表名 in 所有表:
                    表名 = 表名[0]  # 获取表名
                    # 获取当前表的所有字段信息
                    cursor.execute(f"PRAGMA table_info({表名})")
                    列数据 = cursor.fetchall()
                    
                    # 存储当前表的所有字段信息
                    if 列数据:
                        json_data[表名] = [
                            {
                                "col": 列[1],  # Column name
                                "datatype": 列[2],  # Column type
                                "comment": None  # SQLite does not store column comments
                            } for 列 in 列数据
                        ]

    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        connection.close()

    return json_data

# 调用函数并打印结果
# 请替换 'your_database.db' 为你的 SQLite 数据库文件路径
result_json = sqlite_connect('your_database.db')
print(json.dumps(result_json, ensure_ascii=False, indent=4))

import pymysql
import json

def mysql_connect(用户名: str = 'root',
                  密码: str = 'root',
                  ip地址: str = '127.0.0.1',
                  端口号: int = 3306,
                  数据库名: str = 'test',
                  字符集: str = 'utf8mb4'):
    connection = pymysql.connect(host=ip地址,
                                  user=用户名,
                                  password=密码,
                                  port=端口号,
                                  database=数据库名,
                                  charset=字符集)
    try:
        cursor = connection.cursor()
        cursor.execute("SHOW TABLES")
        结果集 = cursor.fetchall()
        json_data = {}

        for 表名 in 结果集:
            表名 = 表名[0]  # 获取表名
            cursor.execute(f"SELECT COLUMN_NAME, COLUMN_TYPE, COLUMN_COMMENT FROM information_schema.COLUMNS WHERE TABLE_SCHEMA='{数据库名}' AND TABLE_NAME='{表名}'")
            列数据 = cursor.fetchall()
            字段集 = []
            for 列 in 列数据:
                列名, 数据类型, 注释 = 列
                字段集.append({
                    "col": 列名,
                    "datatype": 数据类型,
                    "comment": 注释 if 注释 else ''  # 使用 if-else 来避免 None
                })
            json_data[表名] = 字段集

    finally:
        connection.close()

    return json_data

# 调用函数并打印结果
result_json = mysql_connect(密码='123456', 数据库名='rkey_blog')
print(json.dumps(result_json, ensure_ascii=False, indent=4))

在 Python 中，可以同时遍历两个元组（或任何其他可迭代对象），有几种方法可以实现这一点：

使用索引

如果你有两个长度相同的元组，可以使用索引来同时遍历它们：

使用 zip()

zip() 函数可以将多个可迭代对象中的元素配对，生成一个元组列表。这使得同时遍历多个序列变得简单：

使用 itertools.zip_longest

如果你需要遍历长度不同的序列，可以使用 itertools.zip_longest()，它允许你指定一个填充值，以防序列长度不一致：

在这个例子中，如果 tuple2 比 tuple1 短，zip_longest 会使用 'missing' 作为填充值。

使用列表推导式

如果你想同时遍历两个元组并创建一个新的列表，可以使用列表推导式：

这将生成一个包含元组对的列表。

选择哪种方法取决于你的具体需求，例如是否需要处理长度不一致的序列，或者是否需要在遍历的同时执行复杂的操作。

来自kimi ai

from flask import session,flash,redirect,url_for
from functools import wraps
def 需要登录(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not session.get('logged_in', False):
            # 如果用户未登录，重定向到登录页面，并提示需要登录
            flash('你需要登录。')
            return redirect(url_for('login.login'))
        return f(*args, **kwargs)
    return decorated_function

这段代码定义了一个名为 需要登录 的装饰器，用于 Flask 应用中保护需要用户登录后才能访问的视图函数。下面是对这段代码的详细解释：

1. 导入必要的模块：
   from flask import session, flash, redirect, url_for
from functools import wraps

   导入 Flask 的 session 用于访问和管理用户会话信息；flash 用于向用户显示一次性消息；redirect 用于重定向用户到另一个 URL；url_for 用于获取路由的 URL。wraps 用于保留原函数的名称和文档字符串。

2. 定义装饰器 需要登录:
   def 需要登录(f):

   需要登录 是一个装饰器工厂函数，它接受一个函数 f 作为参数，f 通常是 Flask 应用中的一个视图函数。

3. 使用 wraps 装饰器：
   @wraps(f)

   使用 wraps 来包装 decorated_function，这样可以让装饰后的函数保持原始函数 f 的名称和文档字符串。

4. 定义嵌套函数 decorated_function:
   def decorated_function(*args, **kwargs):

   decorated_function 是一个嵌套函数，它将作为装饰器返回的函数。它接受任意数量的位置参数 *args 和关键字参数 **kwargs，以便将这些参数传递给原始的视图函数 f。

5. 检查用户是否已登录：
   if not session.get('logged_in', False):

   使用 session.get 方法检查 session 中是否有 'logged_in' 键，并且其值是否为 True。如果用户未登录（即 'logged_in' 键不存在或值为 False），则执行以下重定向和消息提示操作。

6. 显示登录提示并重定向到登录页面：
   flash('你需要登录。')
return redirect(url_for('login.login'))

   使用 flash 函数向用户显示一条消息，提示用户需要登录。然后使用 redirect 函数和 url_for 函数重定向用户到登录页面。这里假设登录视图函数的端点（endpoint）名称为 'login.login'。

7. 调用原始的视图函数：
   return f(*args, **kwargs)

   如果用户已登录，decorated_function 将调用原始的视图函数 f，并传入所有接收到的参数。

8. 返回装饰器函数：
   return decorated_function

   需要登录 装饰器返回 decorated_function 函数，这样它就可以被用作装饰器。

使用这个装饰器，你可以保护 Flask 应用中的任何视图函数，确保只有登录用户才能访问。例如：

在这个例子中，任何尝试访问 /protected 路由的用户，如果没有登录，都会被重定向到登录页面，并在登录页面上显示一条消息。如果用户已经登录，他们将能看到受保护页面的内容。

在 Flask 应用中，before_request 是一个特殊的装饰器，它允许你在处理请求之前执行某些操作。这意味着无论用户请求应用中的哪个端点（URL），before_request 装饰的函数都会首先被调用。

下面是 before_request 装饰器函数的一个例子：

python
@app.before_request
def before_request():
    g.user_logged_in = session.get('logged_in', False)
这行代码的意思是：

@app.before_request：这是一个装饰器，它会告诉 Flask 在处理每个请求之前先运行 before_request 函数。
def before_request()：这是被装饰的函数，它将在每个请求处理之前被调用。
g：是 Flask 的全局变量，它是一个特殊的对象，用于在请求之间存储数据。g 对象在请求的生命周期内是唯一的，这意味着在一个请求处理过程中，你可以使用 g 来存储数据，然后在同一个请求的其他部分访问这些数据。
session.get('logged_in', False)：这行代码尝试从 session 中获取键为 logged_in 的值。如果 logged_in 键不存在，它将返回默认值 False。这通常用来检查用户是否已经登录。
g.user_logged_in：将 session.get('logged_in', False) 的结果赋值给 g 对象的 user_logged_in 属性。这样，你就可以在请求处理的任何地方，包括模板中，通过 g.user_logged_in 来访问用户的登录状态。
使用 before_request 钩子，你可以在每个请求开始时设置 g.user_logged_in，然后在模板中使用这个变量来判断是否显示登录按钮或登出按钮，或者执行其他基于用户登录状态的操作。

内容来自kimi ai

如果你想要创建一个压缩包，用户解压后即可直接使用 Python 环境，而不依赖于系统上已安装的 Python，可以考虑以下方法：

1. 创建自定义 Python 发行版:
   • 你可以下载 Python 源代码并自行编译，或者使用现成的 Python 发行版，如 Anaconda 或 WinPython。
   • 编译时，确保包含所有必要的库和模块。
2. 使用 Portable Python:
   • Portable Python 是一个预编译的 Python 发行版，专为便携式使用设计。它可以在没有安装 Python 的系统上运行。
   • 你可以从 Portable Python 的官方网站下载一个与你的需求相匹配的版本，然后将其压缩为 zip 或 tar.gz 格式。
3. 手动打包 Python 环境:
   • 手动下载 Python 解释器的可执行文件（例如 python.exe、pythonw.exe 等）和相关 DLL 文件。
   • 将 Python 解释器、标准库、以及你程序所需的第三方库一起复制到一个文件夹中。
   • 将这个文件夹压缩为 zip 或 tar.gz 格式。
4. 使用虚拟环境:
   • 在一个独立的环境中安装 Python 和所有必要的库，然后使用工具如 venv 或 virtualenv 创建虚拟环境。
   • 将虚拟环境文件夹压缩，用户解压后即可使用。
5. 使用 Docker 容器:
   • 创建一个 Dockerfile，定义 Python 环境和所有必要的依赖。
   • 构建 Docker 镜像，并将镜像保存为 tar 文件。
   • 用户可以下载这个 tar 文件，然后使用 Docker 载入镜像并运行。
6. 使用 PyOxidizer:
   • PyOxidizer 允许你打包 Python 应用程序，包括 Python 解释器和所有依赖，到一个单一的可执行文件或库文件中。
   • 你可以配置 PyOxidizer 生成包含 Python 解释器的压缩包。
7. 使用自定义脚本:
   • 编写一个脚本，当运行时，它会解压 Python 解释器和所有必要的文件到一个临时目录，并从那里执行你的 Python 程序。

请注意，打包 Python 环境需要确保包含解释器、所有必要的动态链接库（DLLs 或 SO 文件），以及可能的依赖项。此外，确保遵守 Python 及第三方库的版权和许可协议。如果你需要具体的帮助或示例，请提供更多的信息。

项目结构

templates\index.html

main.py

网页

templates\index.html

<!DOCTYPE html>
<html>
<head>
    <title>视频播放</title>
</head>
<body>
    <h1>视频播放</h1>
    <video width="320" height="240" controls>
        <source src="/video/处处吻.mp4" type="video/mp4">
        你的浏览器不支持 HTML5 video 标签。
    </video>
</body>
</html>

python文件

main.py

from flask import Flask, render_template, send_from_directory

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')  # 你的视频播放页面

@app.route('/video/<filename>')
def video(filename):
    VIDEO_PATH = 'E:/code/flask/video'
    # filename='1.mp4'
    return send_from_directory(directory=VIDEO_PATH, path=filename)

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

–

–

–

–

使用pyautogui库,模拟按键win+d

import pyautogui
pyautogui.keyDown('win')
pyautogui.press('d')
pyautogui.keyUp('win')

–

–

又看到一种查看指定python库版本的方法了

pip show ipython

代码中导入pyautogui

打印pyautogui.__version__

–

import pyautogui 
print(pyautogui.__version__)

–

想查看其他python库的版本也是一样的.

python库安装太多了,我就想知道这一个库的版本就用这个方法了