11.python文件

CHANG_THE_WORLD2024-12-16 9:57

文章目录

      • [Python 文件 I/O 总结](#Python 文件 I/O 总结)
        • [1. **打印到屏幕**](#1. 打印到屏幕)
        • [2. **读取键盘输入**](#2. 读取键盘输入)
        • [3. **打开和关闭文件**](#3. 打开和关闭文件)
          • [3.1 `open()` 函数](#3.1 open() 函数)
          • [3.2 `close()` 方法](#3.2 close() 方法)
        • [4. **文件读写操作**](#4. 文件读写操作)
          • [4.1 `write()` 方法](#4.1 write() 方法)
          • [4.2 `read()` 方法](#4.2 read() 方法)
          • [4.3 `readline()` 方法](#4.3 readline() 方法)
          • [4.4 `readlines()` 方法](#4.4 readlines() 方法)
          • [4.5 `seek()` 和 `tell()` 方法](#4.5 seek() 和 tell() 方法)
        • [5. **文件重命名和删除**](#5. 文件重命名和删除)
          • [5.1 `os.rename()` 方法](#5.1 os.rename() 方法)
          • [5.2 `os.remove()` 方法](#5.2 os.remove() 方法)
        • [6. **目录操作**](#6. 目录操作)
          • [6.1 `os.mkdir()` 方法](#6.1 os.mkdir() 方法)
          • [6.2 `os.chdir()` 方法](#6.2 os.chdir() 方法)
          • [6.3 `os.getcwd()` 方法](#6.3 os.getcwd() 方法)
          • [6.4 `os.rmdir()` 方法](#6.4 os.rmdir() 方法)
          • [6.5 `os.listdir()` 方法](#6.5 os.listdir() 方法)
        • [7. **上下文管理器 (`with` 语句)**](#7. 上下文管理器 (with 语句))
        • [8. **文件对象的属性**](#8. 文件对象的属性)
        • [9. **文件和目录的高级操作**](#9. 文件和目录的高级操作)
      • 总结
      • [1. **文件对象的底层机制**](#1. 文件对象的底层机制)
        • [1.1 文件描述符（File Descriptor）](#1.1 文件描述符（File Descriptor）)
        • [1.2 缓冲区（Buffering）](#1.2 缓冲区（Buffering）)
        • [1.3 文件对象的状态](#1.3 文件对象的状态)
      • [2. **文件读写的高级技巧**](#2. 文件读写的高级技巧)
        • [2.1 使用 `with` 语句管理文件](#2.1 使用 with 语句管理文件)
        • [2.2 逐块读取大文件](#2.2 逐块读取大文件)
        • [2.3 使用 `pathlib` 模块简化路径操作](#2.3 使用 pathlib 模块简化路径操作)
        • [2.4 使用 `shutil` 模块进行高级文件操作](#2.4 使用 shutil 模块进行高级文件操作)
      • [3. **文件锁定与并发控制**](#3. 文件锁定与并发控制)
        • [3.1 使用 `fcntl` 模块进行文件锁定（Unix/Linux 系统）](#3.1 使用 fcntl 模块进行文件锁定（Unix/Linux 系统）)
        • [3.2 使用 `msvcrt` 模块进行文件锁定（Windows 系统）](#3.2 使用 msvcrt 模块进行文件锁定（Windows 系统）)
        • [3.3 使用 `filelock` 库简化文件锁定](#3.3 使用 filelock 库简化文件锁定)
      • [4. **异步文件I/O**](#4. 异步文件I/O)
        • [4.1 安装 `aiofiles` 库](#4.1 安装 aiofiles 库)
        • [4.2 异步读写文件](#4.2 异步读写文件)
      • [5. **文件编码与字符集**](#5. 文件编码与字符集)
        • [5.1 指定文件编码](#5.1 指定文件编码)
        • [5.2 处理编码错误](#5.2 处理编码错误)
      • [6. **文件权限与安全性**](#6. 文件权限与安全性)
        • [6.1 设置文件权限](#6.1 设置文件权限)
        • [6.2 获取文件权限](#6.2 获取文件权限)
        • [6.3 检查文件权限](#6.3 检查文件权限)
      • [7. **文件系统监控**](#7. 文件系统监控)
        • [7.1 安装 `watchdog` 库](#7.1 安装 watchdog 库)
        • [7.2 监控文件系统事件](#7.2 监控文件系统事件)
      • 总结

Python 文件 I/O 总结

Python 提供了强大的文件输入输出（I/O）功能，使得你可以轻松地读取、写入和管理文件。以下是关于Python文件I/O的详细总结，涵盖了基本操作、高级特性以及与操作系统交互的方法。

1. 打印到屏幕

最简单的输出方法是使用 print 函数，它可以接受零个或多个用逗号隔开的表达式，并将它们转换为字符串后输出到标准输出（通常是终端或控制台）。

python 复制代码 
print("Python 是一个非常棒的语言，不是吗？")

输出：

复制代码 
Python 是一个非常棒的语言，不是吗？
2. 读取键盘输入

Python提供了两种内置函数来从标准输入（通常是键盘）读取用户输入：

  • input()：读取用户输入并尝试将其作为Python表达式进行求值。适用于需要处理表达式的场景。
  • input(prompt)：带有提示信息的版本。
python 复制代码 
user_input = input("请输入：")
print(f"你输入的内容是: {user_input}")

示例：

复制代码 
请输入：Hello Python！
你输入的内容是: Hello Python！

注意： 在Python 3中，raw_input()已被移除，input()的行为等同于Python 2中的raw_input()。如果你想在Python 3中读取原始字符串而不进行求值，直接使用input()即可。

3. 打开和关闭文件

要对文件进行读写操作，首先需要使用 open() 函数打开文件，返回一个文件对象。完成操作后，应使用 close() 方法关闭文件以释放资源。

3.1 open() 函数
python 复制代码 
file_object = open(file_name, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

  • file_name：文件的路径和名称。

  • mode ：文件的打开模式，默认为 'r'（只读文本模式）。常见模式如下：

    • 'r'：只读模式（默认），文件必须存在。
    • 'w'：写入模式，如果文件存在则清空内容，不存在则创建新文件。
    • 'a'：追加模式，文件指针位于文件末尾，写入时不会覆盖原有内容。
    • 'b'：二进制模式，通常与 'r'、'w' 或 'a' 结合使用。
    • '+'：读写模式，允许同时读取和写入文件。
    • 'x'：新建文件模式，如果文件已存在则抛出 FileExistsError。
    • 't'：文本模式（默认），用于处理文本文件。
    • 'U'：通用换行模式（不推荐使用）。

  • buffering ：缓冲区大小。0 表示无缓冲，1 表示行缓冲，负数表示使用系统默认缓冲。

  • encoding ：文件的编码格式，默认为 None（系统默认编码）。

  • errors ：处理编码错误的方式，如 'strict'（默认）、'ignore'、'replace' 等。

  • newline ：控制换行符的处理方式，None 表示使用系统默认换行符。

  • closefd ：是否关闭文件描述符，默认为 True。

  • opener ：自定义打开文件的方式，默认为 None。

3.2 close() 方法
python 复制代码 
file_object.close()

关闭文件，释放资源。建议使用 with 语句来自动管理文件的打开和关闭，这样可以确保即使发生异常，文件也会被正确关闭。

python 复制代码 
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)
# 文件会在 with 语句块结束后自动关闭
4. 文件读写操作
4.1 write() 方法

用于将字符串或字节数据写入文件。注意，write() 不会自动添加换行符。

python 复制代码 
with open('example.txt', 'w') as file:
    file.write("Hello, World!\n")
    file.write("This is a new line.")
4.2 read() 方法

用于从文件中读取指定数量的字节或字符。如果不指定参数，则读取整个文件。

python 复制代码 
with open('example.txt', 'r') as file:
    content = file.read(10)  # 读取前10个字符
    print(content)
4.3 readline() 方法

用于逐行读取文件内容，返回一行字符串。

python 复制代码 
with open('example.txt', 'r') as file:
    line = file.readline()  # 读取一行
    print(line)
4.4 readlines() 方法

用于读取文件的所有行，并返回一个包含各行的列表。

python 复制代码 
with open('example.txt', 'r') as file:
    lines = file.readlines()  # 读取所有行
    for line in lines:
        print(line.strip())  # 去掉每行末尾的换行符
4.5 seek() 和 tell() 方法
  • seek(offset, whence=0) ：移动文件指针到指定位置。offset 是偏移量，whence 指定参考点（0 表示文件开头，1 表示当前位置，2 表示文件末尾）。
  • tell()：返回当前文件指针的位置。
python 复制代码 
with open('example.txt', 'r+') as file:
    print(file.tell())  # 输出: 0
    file.seek(5)  # 移动到第6个字符
    print(file.tell())  # 输出: 5
    file.write("New text")  # 从第6个字符开始写入
5. 文件重命名和删除

Python的 os 模块提供了文件和目录的操作功能。

5.1 os.rename() 方法

用于重命名文件或目录。

python 复制代码 
import os

os.rename('old_name.txt', 'new_name.txt')
5.2 os.remove() 方法

用于删除文件。

python 复制代码 
import os

os.remove('file_to_delete.txt')
6. 目录操作

os 模块还提供了对目录的操作功能。

6.1 os.mkdir() 方法

用于创建新目录。

python 复制代码 
import os

os.mkdir('new_directory')
6.2 os.chdir() 方法

用于更改当前工作目录。

python 复制代码 
import os

os.chdir('/path/to/new/directory')
6.3 os.getcwd() 方法

用于获取当前工作目录。

python 复制代码 
import os

print(os.getcwd())
6.4 os.rmdir() 方法

用于删除空目录。

python 复制代码 
import os

os.rmdir('empty_directory')
6.5 os.listdir() 方法

用于列出指定目录下的所有文件和子目录。

python 复制代码 
import os

for item in os.listdir('.'):
    print(item)
7. 上下文管理器 (with 语句)

使用 with 语句可以更安全地管理文件操作，确保文件在使用完毕后自动关闭，即使发生异常也不会导致文件未关闭的问题。

python 复制代码 
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)
# 文件会在 with 语句块结束后自动关闭
8. 文件对象的属性

文件对象有一些有用的属性，可以帮助你获取文件的相关信息：

  • file.closed：布尔值，表示文件是否已关闭。
  • file.mode ：文件的打开模式（如 'r'、'w' 等）。
  • file.name：文件的名称。
  • file.encoding：文件的编码格式（仅适用于文本模式）。
python 复制代码 
with open('example.txt', 'r') as file:
    print(f"文件名: {file.name}")
    print(f"是否已关闭: {file.closed}")
    print(f"访问模式: {file.mode}")
    print(f"编码格式: {file.encoding}")
9. 文件和目录的高级操作

除了基本的文件和目录操作外，Python还提供了更多高级功能，例如递归遍历目录、复制文件、移动文件等。这些功能可以通过 os 模块和 shutil 模块来实现。

  • os.walk()：递归遍历目录树。
  • shutil.copy()：复制文件。
  • shutil.move()：移动文件或目录。
  • shutil.rmtree()：递归删除目录及其内容。

总结

Python的文件I/O功能非常强大且灵活，能够满足各种文件处理需求。通过掌握 open()、read()、write()、seek()、tell() 等基本方法，以及 os 和 shutil 模块提供的高级功能，你可以轻松地进行文件的读取、写入、重命名、删除和目录管理等操作。使用 with 语句可以确保文件的安全关闭，避免资源泄漏问题。

如果你有更多具体的问题或需要进一步的解释，请随时告诉我！

理解您希望获得更详细和深刻的Python文件I/O讲解。接下来，我将深入探讨一些高级主题、最佳实践以及Python文件I/O的内部工作原理，帮助您更好地理解和掌握这一重要领域。

1. 文件对象的底层机制

1.1 文件描述符（File Descriptor）

在操作系统层面，每个打开的文件都由一个唯一的整数标识，称为文件描述符 （file descriptor）。Python的文件对象实际上是对这些文件描述符的封装。当你使用 open() 函数打开文件时，Python会调用操作系统的系统调用来获取文件描述符，并将其包装在一个文件对象中。

python 复制代码 
with open('example.txt', 'r') as file:
    # 文件对象内部维护了一个文件描述符
    print(file.fileno())  # 输出文件描述符的整数值
1.2 缓冲区（Buffering）

文件I/O操作通常涉及缓冲区，以提高性能。缓冲区的作用是减少与磁盘或网络的实际交互次数。Python提供了三种缓冲模式：

  • 无缓冲（buffering=0）：每次写入或读取操作都会直接与磁盘或网络进行交互，适用于需要实时性的情况。
  • 行缓冲（buffering=1）：只有当遇到换行符时才会刷新缓冲区，适用于文本文件。
  • 全缓冲（buffering>1 或 buffering=-1）：缓冲区大小为指定值（或系统默认值），只有当缓冲区满时才会刷新。
python 复制代码 
# 无缓冲
with open('example.txt', 'w', buffering=0) as file:
    file.write("No buffering\n")

# 行缓冲
with open('example.txt', 'w', buffering=1) as file:
    file.write("Line buffering\n")

# 全缓冲
with open('example.txt', 'w', buffering=4096) as file:
    file.write("Full buffering\n")
1.3 文件对象的状态

文件对象有几种重要的状态属性，可以通过以下方法访问：

  • file.closed：布尔值，表示文件是否已关闭。
  • file.mode：字符串，表示文件的打开模式。
  • file.name：字符串，表示文件的名称。
  • file.encoding：字符串，表示文件的编码格式（仅适用于文本模式）。
  • file.newlines ：表示文件中使用的换行符（如 \n、\r\n 等）。
  • file.buffer：返回底层的二进制缓冲区对象（适用于文本模式）。
  • file.raw：返回最底层的原始文件对象（适用于二进制模式）。
python 复制代码 
with open('example.txt', 'r', encoding='utf-8') as file:
    print(f"文件名: {file.name}")
    print(f"是否已关闭: {file.closed}")
    print(f"访问模式: {file.mode}")
    print(f"编码格式: {file.encoding}")
    print(f"换行符: {file.newlines}")

2. 文件读写的高级技巧

2.1 使用 with 语句管理文件

with 语句不仅确保文件在使用完毕后自动关闭，还能捕获并处理异常，避免资源泄漏。它通过上下文管理器协议（Context Manager Protocol）实现。

python 复制代码 
try:
    with open('example.txt', 'r') as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("文件不存在")
except IOError:
    print("发生I/O错误")
finally:
    print("文件操作结束")
2.2 逐块读取大文件

对于非常大的文件，一次性读取整个文件可能会消耗大量内存。可以使用 read() 方法结合循环逐块读取文件内容，或者使用 for 循环逐行读取。

python 复制代码 
# 逐块读取
chunk_size = 8192  # 每次读取8KB
with open('large_file.txt', 'r') as file:
    while True:
        chunk = file.read(chunk_size)
        if not chunk:
            break
        process_chunk(chunk)

# 逐行读取
with open('large_file.txt', 'r') as file:
    for line in file:
        process_line(line.strip())
2.3 使用 pathlib 模块简化路径操作

pathlib 是 Python 3.4 引入的一个模块，提供了一种面向对象的方式来处理文件路径。相比传统的 os.path 模块，pathlib 更加直观和易用。

python 复制代码 
from pathlib import Path

# 获取当前目录
current_dir = Path.cwd()
print(current_dir)

# 创建新文件
new_file = Path('example.txt')
new_file.touch()

# 检查文件是否存在
if new_file.exists():
    print("文件存在")

# 读取文件内容
content = new_file.read_text(encoding='utf-8')
print(content)

# 写入文件内容
new_file.write_text("Hello, World!", encoding='utf-8')

# 获取文件的父目录
parent_dir = new_file.parent
print(parent_dir)

# 获取文件的绝对路径
absolute_path = new_file.resolve()
print(absolute_path)

# 遍历目录中的所有文件
for file in Path('.').glob('*.txt'):
    print(file)
2.4 使用 shutil 模块进行高级文件操作

shutil 模块提供了更高层次的文件和目录操作功能，适合处理复杂的文件系统任务，如复制、移动、删除等。

  • shutil.copy(src, dst)：复制文件。
  • shutil.move(src, dst)：移动文件或目录。
  • shutil.rmtree(path)：递归删除目录及其内容。
  • shutil.make_archive(base_name, format, root_dir) ：创建压缩文件（如 .zip、.tar 等）。
  • shutil.unpack_archive(filename, extract_dir)：解压文件。
python 复制代码 
import shutil

# 复制文件
shutil.copy('source.txt', 'destination.txt')

# 移动文件
shutil.move('source.txt', '/path/to/new/location/')

# 删除目录及其内容
shutil.rmtree('/path/to/directory')

# 创建压缩文件
shutil.make_archive('archive', 'zip', '/path/to/directory')

# 解压文件
shutil.unpack_archive('archive.zip', '/path/to/extract/')

3. 文件锁定与并发控制

在多线程或多进程环境中，多个程序可能同时访问同一个文件。为了避免数据竞争和不一致，可以使用文件锁定机制来确保文件的独占访问。

3.1 使用 fcntl 模块进行文件锁定（Unix/Linux 系统）

fcntl 模块提供了对文件描述符的低级控制，包括文件锁定功能。它可以用于实现独占锁（exclusive lock）和共享锁（shared lock）。

python 复制代码 
import fcntl
import os

with open('example.txt', 'r+') as file:
    try:
        # 获取独占锁
        fcntl.flock(file.fileno(), fcntl.LOCK_EX)
        print("文件已锁定，开始写入...")
        file.write("Some data\n")
        # 释放锁
        fcntl.flock(file.fileno(), fcntl.LOCK_UN)
        print("文件解锁")
    except IOError:
        print("无法锁定文件")
3.2 使用 msvcrt 模块进行文件锁定（Windows 系统）

在 Windows 系统上，可以使用 msvcrt 模块来实现类似的文件锁定功能。

python 复制代码 
import msvcrt
import os

with open('example.txt', 'r+') as file:
    try:
        # 获取独占锁
        msvcrt.locking(file.fileno(), msvcrt.LK_LOCK, os.path.getsize('example.txt'))
        print("文件已锁定，开始写入...")
        file.write("Some data\n")
        # 释放锁
        msvcrt.locking(file.fileno(), msvcrt.LK_UNLCK, os.path.getsize('example.txt'))
        print("文件解锁")
    except IOError:
        print("无法锁定文件")
3.3 使用 filelock 库简化文件锁定

filelock 是一个第三方库，提供了一个简单且跨平台的文件锁定机制。它可以在不同操作系统上一致地工作。

bash 复制代码 
pip install filelock
python 复制代码 
from filelock import FileLock

with FileLock("example.txt.lock"):
    with open("example.txt", "r+") as file:
        print("文件已锁定，开始写入...")
        file.write("Some data\n")
        print("文件解锁")

4. 异步文件I/O

Python 3.5 引入了 asyncio 模块，支持异步编程。通过 aiofiles 库，可以在异步环境中进行文件I/O操作，从而提高程序的并发性能。

4.1 安装 aiofiles 库
bash 复制代码 
pip install aiofiles
4.2 异步读写文件
python 复制代码 
import asyncio
import aiofiles

async def read_file_async(filename):
    async with aiofiles.open(filename, mode='r') as file:
        content = await file.read()
        print(content)

async def write_file_async(filename, content):
    async with aiofiles.open(filename, mode='w') as file:
        await file.write(content)

async def main():
    await write_file_async('example.txt', 'Hello, Async World!')
    await read_file_async('example.txt')

# 运行异步任务
asyncio.run(main())

5. 文件编码与字符集

在处理文本文件时，编码是一个重要的问题。Python默认使用 UTF-8 编码，但你可以根据需要指定其他编码格式。常见的编码格式包括：

  • UTF-8：可变长度编码，兼容ASCII，广泛用于互联网和现代系统。
  • UTF-16：固定长度编码，适用于需要处理双字节字符的语言。
  • GBK：中文常用编码，主要用于简体中文环境。
  • ISO-8859-1：单字节编码，适用于西欧语言。
5.1 指定文件编码
python 复制代码 
# 读取 UTF-8 编码的文件
with open('example_utf8.txt', 'r', encoding='utf-8') as file:
    content = file.read()
    print(content)

# 读取 GBK 编码的文件
with open('example_gbk.txt', 'r', encoding='gbk') as file:
    content = file.read()
    print(content)
5.2 处理编码错误

有时文件的编码可能不符合预期，导致读取时出现错误。可以使用 errors 参数来指定如何处理编码错误。常见的处理方式包括：

  • 'strict' ：遇到错误时抛出 UnicodeDecodeError（默认行为）。
  • 'ignore'：忽略无法解码的字符。
  • 'replace' ：用替换字符（如 �）代替无法解码的字符。
  • 'backslashreplace'：用转义序列代替无法解码的字符。
  • 'surrogateescape'：将无法解码的字符存储为代理字符，稍后可以恢复。
python 复制代码 
# 忽略无法解码的字符
with open('example.txt', 'r', encoding='utf-8', errors='ignore') as file:
    content = file.read()
    print(content)

# 用替换字符代替无法解码的字符
with open('example.txt', 'r', encoding='utf-8', errors='replace') as file:
    content = file.read()
    print(content)

6. 文件权限与安全性

在处理文件时，确保文件的权限设置正确是非常重要的，尤其是在多用户系统或网络环境中。Python提供了 os 模块来管理文件权限。

6.1 设置文件权限

可以使用 os.chmod() 函数来修改文件的权限。权限使用八进制数表示，常见权限包括：

  • 0o777：所有用户都有读、写、执行权限。
  • 0o644：文件所有者有读写权限，其他用户只有读权限。
  • 0o755：文件所有者有读写执行权限，其他用户有读执行权限。
python 复制代码 
import os

# 设置文件权限为 0o644
os.chmod('example.txt', 0o644)
6.2 获取文件权限

可以使用 os.stat() 函数获取文件的元数据，包括权限信息。

python 复制代码 
import os
import stat

# 获取文件的元数据
stat_info = os.stat('example.txt')

# 打印文件权限
print(oct(stat_info.st_mode & 0o777))  # 输出权限的八进制表示
6.3 检查文件权限

可以使用 os.access() 函数检查文件的访问权限。

python 复制代码 
import os

# 检查文件是否可读
if os.access('example.txt', os.R_OK):
    print("文件可读")

# 检查文件是否可写
if os.access('example.txt', os.W_OK):
    print("文件可写")

# 检查文件是否可执行
if os.access('example.txt', os.X_OK):
    print("文件可执行")

7. 文件系统监控

有时你可能需要监控文件系统的更改，例如文件的创建、修改或删除。Python提供了 watchdog 库来实现文件系统事件的监控。

7.1 安装 watchdog 库
bash 复制代码 
pip install watchdog
7.2 监控文件系统事件
python 复制代码 
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class MyHandler(FileSystemEventHandler):
    def on_modified(self, event):
        print(f"文件 {event.src_path} 已被修改")

    def on_created(self, event):
        print(f"文件 {event.src_path} 已被创建")

    def on_deleted(self, event):
        print(f"文件 {event.src_path} 已被删除")

if __name__ == "__main__":
    event_handler = MyHandler()
    observer = Observer()
    observer.schedule(event_handler, path='.', recursive=True)
    observer.start()

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()

    observer.join()

总结

Python的文件I/O功能不仅强大而且灵活，能够满足从简单的文件读写到复杂的文件系统操作的各种需求。通过深入了解文件对象的底层机制、缓冲区、文件锁定、异步I/O、编码处理、权限管理和文件系统监控等高级主题，您可以编写出更加高效、安全和可靠的文件操作代码。

如果您有更多具体的问题或需要进一步的解释，请随时告诉我！

相关推荐
bkspiderx19 分钟前
Nginx 屏蔽服务器名称与版本信息（源码级修改）
运维·服务器·nginx
野生柚子32 分钟前
记录学习K8s 集群中OOM Killer的决策基准及执行流程
linux·运维
TLucas2 小时前
在CentOS 7上将PostgreSQL数据库从默认路径迁移到自定义目录
linux·运维·postgresql·centos
ZoeLandia3 小时前
nginx实战分析
运维·前端·nginx
菜菜子爱学习3 小时前
Nginx学习笔记（九）—— Nginx Rewrite深度解析
linux·运维·笔记·学习·nginx
迷之程序员4 小时前
服务器装两个cpu
运维·服务器
Mr_Xuhhh5 小时前
传输层协议 TCP（1）
运维·服务器·网络·c++·网络协议·tcp/ip·https
楽码6 小时前
端到端应用Hmac加密
服务器·后端·算法
扶风呀7 小时前
具有熔断能力和活性探测的服务负载均衡解决方案
运维·负载均衡
the sun347 小时前
从内核数据结构的角度理解socket
linux·运维·服务器
热门推荐
01UV安装并设置国内源022025最新国内服务器可用docker源仓库地址大全（2025年8月更新）03Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code04全球最强模型Grok4，国内已可免费使用！（附教程）05TRAE Rules 实践：为项目配置 6A 工作流06KGG转MP3工具|非KGM文件|解密音频07【2025.08.06最新版】Android Studio下载、安装及配置记录（自动下载sdk）08GPT-5 使用限制与国内升级全攻略（免费 / Plus / Pro）【2025 最新】09Cursor 终端“卡死/无响应”问题的解法10Claude Code + claude-code-router白嫖魔搭社区千问模型，开启AI编程之路