#IO编程

# 同步IO示例 - 本地文件读取
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()  # 程序会阻塞在这里，直到文件完全加载到内存
    print(content[:100])  # 等上面读完才能打印

# 异步IO示例 - 正确的aiofiles文件读取
import asyncio
import aiofiles

async def read_large_file_async():
    async with aiofiles.open('example.txt', 'r', encoding='utf-8') as f:
        content = await f.read()  # 不会阻塞整个事件循环，CPU可以去执行其他协程
        print(content[:100])

asyncio.run(read_large_file_async())

# 写入文本文件
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write('Hello, IO Programming!\n')
    f.writelines(['Line 2\n', 'Line 3\n'])  # 批量写入列表

# 读取全部文本
with open('output.txt', 'r', encoding='utf-8') as f:
    all_content = f.read()
    print(all_content)

from io import StringIO, BytesIO

# 字符串IO：专门处理文本
string_buf = StringIO()
string_buf.write('Hello')
string_buf.write(' Memory IO!')
print(string_buf.getvalue())  # 无需关闭就能获取全部内容 → Hello Memory IO!

# 字节IO：专门处理二进制数据（图片、压缩包片段）
bytes_buf = BytesIO()
bytes_buf.write(b'binary content')
print(bytes_buf.getvalue())  # → b'binary content'

import urllib.request

# 同步获取网页HTML（前200个字符）
with urllib.request.urlopen('https://www.python.org') as resp:
    html = resp.read().decode('utf-8')
    print(html[:200])

try:
    # 不用with的写法（容易忘写close，异常时也不会释放）
    f = open('risky.txt', 'r')
    data = f.read()
finally:
    if f:
        f.close()

# 用with的写法（简洁、安全）
with open('safe.txt', 'r') as f:
    data = f.read()

# 无缓冲（二进制模式专用，数据立即写入）
with open('no_buffer.bin', 'wb', buffering=0) as f:
    f.write(b'urgent data')

# 行缓冲（文本模式专用，遇到换行符立即写入）
with open('line_buffer.txt', 'w', encoding='utf-8', buffering=1) as f:
    f.write('line 1 will flush immediately\n')
    f.write('line 2 will wait for next newline')

# 指定缓冲区大小（4096是默认页大小，通常性能最优）
with open('custom_buffer.txt', 'w', encoding='utf-8', buffering=4096) as f:
    f.write('data will flush when buffer is full')

import mmap

with open('large_video.mp4', 'r+b') as f:
    # 映射整个文件（0表示全部）
    mm = mmap.mmap(f.fileno(), 0)
    # 像操作数组一样随机读取第100-200字节的内容
    print(mm[100:200])
    # 修改内存中的内容会同步到磁盘
    mm[0:5] = b'HELLO'
    mm.close()

from pathlib import Path

# 1. 路径拼接（自动处理Windows/Linux的路径分隔符）
data_path = Path('.') / 'data' / 'subdir' / 'input.txt'

# 2. 目录操作
data_path.parent.mkdir(parents=True, exist_ok=True)  # 自动创建父目录，存在不报错

# 3. 文件读写
data_path.write_text('Hello, pathlib!', encoding='utf-8')
content = data_path.read_text(encoding='utf-8')

# 4. 遍历当前目录下的所有txt文件
txt_files = list(Path('.').glob('*.txt'))

from concurrent.futures import ThreadPoolExecutor
from pathlib import Path

# 统计当前目录下所有txt文件的行数
def count_lines(file_path: Path) -> int:
    with open(file_path, 'r', encoding='utf-8') as f:
        return sum(1 for _ in f)  # 生成器逐行计数，不占内存

# 使用线程池并发处理
txt_files = list(Path('.').glob('*.txt'))
with ThreadPoolExecutor(max_workers=8) as executor:
    # map会按文件顺序返回结果
    line_counts = executor.map(count_lines, txt_files)

for file, count in zip(txt_files, line_counts):
    print(f"{file.name}: {count} lines")

# 逐行读取（适合行长度均匀的文本文件）
with open('large_log.txt', 'r', encoding='utf-8') as f:
    for line in f:
        process_line(line)

# 分块读取（适合行长度极不均匀的二进制/文本文件）
CHUNK_SIZE = 4 * 1024 * 1024  # 4MB块
with open('large_video.mp4', 'rb') as f:
    while chunk := f.read(CHUNK_SIZE):  # Python 3.8+海象运算符
        process_chunk(chunk)

import os

with open('critical_data.txt', 'w', encoding='utf-8') as f:
    f.write('very important data')
    f.flush()  # 把数据从Python缓冲区刷到操作系统缓冲区
    os.fsync(f.fileno())  # 强制操作系统把数据刷到物理磁盘