目录
一、open函数的常见应用场景
open函数在Python中是一个非常重要的内置函数，用于打开文件以便进行读取、写入或追加等操作，常见的应用场景有：
1、读取文件内容：当你需要从一个文件中读取数据(如文本、配置、日志等)时，你可以使用 open()函数以只读模式('r')打开文件，并使用文件对象的 read()、readline()或readlines()方法来读取内容。
2、写入文件内容：如果你需要将数据写入一个文件(如生成报告、保存配置、记录日志等)，你可以使用open()函数以写入模式('w')或追加模式('a')打开文件，并使用文件对象的write()方法来写入内容。
3、处理二进制文件：对于需要处理图像、音频、视频等二进制文件时，你可以使用'b'标志来以二进制模式打开文件，这允许你读取和写入原始的字节数据。
4、逐行读取文件：当文件非常大或你只需要逐行处理文件时，可以使用readline()方法逐行读取文件，这可以减少内存使用并提高性能。
5、文件搜索和替换：你可以使用open()函数读取文件内容，然后使用字符串操作或正则表达式来搜索和替换文本，完成修改后，可以将新内容写回到原始文件或新文件中。
6、配置和数据存储：配置文件(如INI文件、JSON文件或YAML文件)和数据文件(如CSV文件)经常使用open()函数进行读取和写入，这些文件通常包含应用程序的配置信息或用户数据。
7、文件复制和移动：虽然open()函数本身不直接支持文件复制和移动，但你可以使用它结合其他文件操作函数(如shutil.copy()或os.rename())来实现这些功能。
8、文件锁定和并发访问：在多线程或多进程环境中，你可能需要锁定文件以防止并发访问导致的冲突。虽然Python标准库没有直接提供文件锁定机制，但你可以使用第三方库(如`fcntl`在Unix系统上)或操作系统特定的命令来实现文件锁定。
9、临时文件处理：使用open()函数与`tempfile`模块结合可以创建和管理临时文件，这对于需要临时存储数据的场景(如数据处理、文件转换等)非常有用。
10、与标准输入/输出交互：虽然不直接通过open()函数实现，但你可以使用文件对象与Python的标准输入(`sys.stdin`)和标准输出(`sys.stdout`)进行交互，这些文件对象与常规文件对象类似，允许你以类似的方式读取和写入数据。
11、文件备份与恢复：你可以使用open()函数来读取原始文件的内容，并将其写入另一个文件以创建备份；同样地，你也可以从备份文件中读取内容并将其写入原始文件以恢复数据。
12、文件加密和解密：在处理敏感数据时，加密是一个重要的安全措施。你可以使用open()函数来读取未加密的文件，使用加密算法对其进行加密，并将加密后的数据写入另一个文件；类似地，你也可以读取加密的文件，使用解密算法恢复原始数据，并将其写入一个新文件。
13、文件传输：在网络编程中，你可能需要从一个服务器读取文件并将其写入到另一个服务器，或者从一个文件读取数据并通过网络发送，open()函数可以用于这些场景中的文件读取和写入操作。
14、文本处理和数据分析：使用open()函数读取大量文本数据(如日志文件、文档等)，并使用Python的文本处理库(如正则表达式、NLTK等)进行分析；也可以结合数据科学库(如Pandas、NumPy等)进行更高级的数据处理和分析。
15、文件映射：对于非常大的文件，你可能希望将它们映射到内存中以便更高效地访问，虽然这不是open()函数直接提供的功能，但你可以使用`mmap`模块来映射已打开的文件。
16、监视文件变化：虽然这通常不是open()函数直接提供的功能，但你可以结合其他库(如`watchdog`)来监视文件系统的变化，包括新文件的创建、文件的修改或删除等。
17、网络文件和特殊设备： open()函数不仅限于处理本地文件系统上的文件，在某些情况下，你可以使用它来访问网络上的文件(如使用`ftplib`或`smbclient`等库)或特殊设备(如串口设备、数据库连接等)，这通常涉及到将设备或网络连接抽象为文件描述符或文件对象，并使用open()函数或类似机制进行访问。
总之，由于open()函数的灵活性和强大性，其在Python编程中几乎无处不在，几乎任何涉及文件操作的场景都会使用到它。
二、open函数使用注意事项
在使用Python的open()函数处理文件时，为了确保代码的正确性、安全性和性能，需注意以下事项：
1、文件路径和名称：确保文件路径和名称是正确的，并且指向了有效的文件；使用原始字符串(在字符串前加上`r`)来处理包含反斜杠(`\`)的Windows路径，以避免转义字符的问题。
2、文件打开模式：仔细选择正确的文件打开模式(如'r'、'w'、'a'、'b'等)，错误的模式可能导致数据丢失或无法访问文件；当你需要在读取和写入之间切换时，使用'r+'、'w+'或'a+'模式。
3、文件关闭：使用`with`语句来自动关闭文件，即使发生异常也是如此，这可以避免资源泄露和潜在的安全风险；避免在`with`语句之外打开文件并忘记关闭它。
4、异常处理：当处理文件时，应准备好捕获并处理可能出现的异常，如`FileNotFoundError`、`PermissionError`等；使用`try-except`块来捕获和处理这些异常。
5、编码问题：在读取或写入文本文件时，确保指定了正确的字符编码(如'utf-8')，错误的编码可能导致乱码或解码错误；如果不确定文件的编码，可以尝试使用`chardet`等库来检测文件的编码。
6、二进制文件：当处理二进制文件时(如图像、音频、视频等)，应使用二进制模式(在模式字符串后添加'b')；避免在二进制模式下读取或写入文本数据，这可能导致数据损坏或不可读。
7、文件锁定和并发：在并发环境中，多个进程或线程可能同时访问同一个文件，为了避免数据竞争和不一致，可以考虑使用文件锁定机制；注意，Python标准库并没有直接提供文件锁定的功能，但你可以使用第三方库(如`fcntl`在Unix系统上)来实现。
8、文件大小和内存使用：在处理大文件时，避免一次性读取整个文件到内存中，使用逐行读取、块读取或其他内存友好的方法；考虑使用生成器或迭代器来逐步处理文件内容，以减少内存使用。
9、权限和安全性：确保你有足够的权限来读取或写入文件，如果文件受到保护或具有特定的权限设置，你可能需要额外的权限或认证；避免在代码中硬编码敏感信息(如密码、密钥等)，特别是当这些信息与文件访问相关时。
10、备份和恢复：在修改或删除文件之前，考虑先备份原始文件，这可以防止意外数据丢失或损坏；确保你有一种机制来恢复意外删除或修改的文件。
总之，只有牢记这些注意事项，你才能更安全、更有效地使用Python的open()函数来处理文件。
三、如何用好open函数？
要用好Python中的open()函数，请遵循一下建议：
1、始终使用`with`语句：使用`with`语句可以确保文件在操作完成后被正确关闭，即使发生异常也是如此，这是处理文件时的最佳实践。
2、明确指定文件打开模式：根据你要进行的操作(读取、写入、追加、二进制等)明确指定文件打开模式。
3、异常处理：使用`try-except`块来处理可能出现的异常，如FileNotFoundError、PermissionError等。
4、编码问题：当读取或写入文本文件时，确保指定正确的字符编码，对于大多数情况，建议使用UTF-8编码。
5、避免硬编码：避免在代码中硬编码文件路径、文件名或打开模式，将这些值放在配置文件、环境变量或命令行参数中，以便更容易地修改它们。
6、二进制文件处理：当处理二进制文件时，使用二进制模式(在模式字符串后添加'b')。
7、文件读写效率：对于大文件，避免一次性读取整个文件到内存中，使用逐行读取、块读取或其他内存友好的方法；写入大文件时，可以考虑使用write()方法的缓冲区(如果未指定，则使用默认的缓冲区大小)，或者调用flush()方法来手动刷新缓冲区。
8、文件锁定：在并发环境中，如果需要确保文件访问的原子性，可以考虑使用文件锁定机制，但是请注意，Python标准库并不直接提供跨平台的文件锁定机制，你可能需要使用第三方库。
9、安全性：避免在代码中硬编码敏感信息，如密码或密钥；如果你的应用程序需要处理来自不受信任来源的文件，请确保对它们进行适当的验证和清理，以防止安全漏洞(如目录遍历攻击)。
10、备份和版本控制：在修改或删除重要文件之前，始终备份原始文件；使用版本控制系统(如Git)来跟踪和管理文件的变化，以便在需要时可以轻松地回滚到以前的版本。
11、代码可读性和可维护性：使用有意义的变量名来代表文件对象；注释你的代码，解释你正在做什么以及为什么这样做；遵循一致的代码风和最佳实践，以提高代码的可读性和可维护性。
总之，通过遵循这些最佳实践和建议，你可以更好地利用Python中的open()函数来处理文件，并确保你的代码是健壮、安全和易于维护的。
1、open函数：
1-1、Python：
# 1.函数：open
# 2.功能：用于打开文件，返回一个文件读写对象，然后对文件进行相应读写操作
# 3.语法：open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# 4.参数：
# 4-1、file(必须)：一个字符串或整数
# 4-1-1、相对路径：一个字符串，若文件在当前工作目录中或子文件夹下，则表示要打开的文件名/子文件夹下的文件名
# 4-1-2、绝对路径：一个字符串，若文件不在当前工作目录中，则表示需要输入包含盘符的完整文件路径
# 4-1-3、文件描述符：一个整数，用于在底层文件系统中打开的文件描述符
# 4-2、mode(可选)：一个字符串，用于指定文件的打开模式
# 使用前提：文件必须存在
# 4-2-1、r：默认模式，以只读模式打开文件，文件的指针将会放在文件的开头
# 4-2-2、rb：以二进制格式打开文件，并且采用只读模式，文件的指针将会放在文件的开头，一般用于图片、音频等
# 4-2-3、r+：打开文件后，可以读取文件内容，也可以写入新的内容覆盖原有内容(从文件开头进行覆盖)
# 4-2-4、rb+：以二进制格式打开文件，并且采用读写模式，文件的指针将会放在文件的开头，一般用于非文本文件，如图片、音频等
# 使用前提：文件可以不存在，但必须保证文件所在的目录存在
# 4-2-5、w：以只写模式打开文件，若文件存在，则将其覆盖；反之，则创建新文件
# 4-2-6、wb：以二进制格式打开文件，并且采用只写模式，一般用于非文本文件，如图片、音频等
# 4-2-7、w+：打开文件后，先清空原有内容，使其变为一个空的文件，对这个空文件拥有读写权限
# 4-2-8、wb+：以二进制格式打开文件，并且采用读写模式，一般用于非文本文件，如图片、音频等
# 其他情形：文件/文件所在的目录存在与否，不做要求
# 4-2-9、a：以追加模式打开文件，若文件存在，文件指针将放在文件末尾，即新内容会被追加写入到已有内容之后；反之，则创建新文件用于写入
# 4-2-10、ab：以二进制格式打开文件，并且采用追加模式，若文件存在，文件指针将放在文件的末尾，即新内容会被追加写入到已有内容之后；反之，则创建新文件用于写入
# 4-2-11、a+：以读写模式打开文件，若文件存在，文件指针将放在文件末尾，即新内容会被追加写入到已有内容之后；反之，则创建新文件用于写入
# 4-2-12、ab+：以二进制格式打开文件，并且采用追加模式，若文件存在，文件指针将放在文件的末尾，即新内容会被追加写入到已有内容之后；反之，则创建新文件用于读写
# 4-2-13、x：创建并写入模式，若文件存在，则会发生异常；反之，则创建新文件用于写入
# 4-2-14、t：文本模式，默认模式，通常不需要明确指定
# 4-3、buffering(可选)：用于指定读写文件的缓冲模式/策略
# 4-3-1、-1：默认模式，表示使用默认缓冲策略(通常是全缓冲或行缓冲，取决于平台和模式)
# 4-3-2、0：表示无缓冲(所有写入操作都直接写入磁盘)
# 4-3-3、1：表示行缓冲(仅在文本模式下有效)
# 4-3-4：>1：如果设置为大于1的整数，则表示缓冲区大小
# 4-3-5：io.DEFAULT_BUFFER_SIZE：使用系统默认的缓冲区大小
# 4-4、encoding(可选)：用于解码或编码文件的编码方式，默认为None，表示使用现有平台默认的编码方式，一般为UTF-8；常见的编码方式有utf-8、ascii、latin1等
# 4-5、errors(可选)：表示读写文件时遇到错误的报错级别
# 4-5-1、strict：严格级别，字符编码有报错即抛出异常，默认级别，errors传入None即按此级别处理
# 4-5-2、ignore：忽略级别，字符编码有错误，忽略掉
# 4-5-3、replace：替换级别，字符编码有错的，替换成符号“？”
# 4-6、newline(可选)：表示控制文件读取和写入时如何处理换行符，只对文本模式有效，可以是 None、''、'\n'、'\r' 或 '\r\n'等，这对于跨平台文件兼容性可能很重要，因为不同的操作系统使用不同的换行符
# 4-7、closefd(可选)：表示传入的file参数类型，默认为True,传入文件路径时，一定为True;传入文件句柄，则为False
# 4-8、opener(可选)：一个可调用对象，用于打开文件描述符，默认为None;这通常不是必需的，但在需要自定义底层文件打开逻辑时可能会很有用
# 5.返回值：一个文件对象(file object)，也被称为文件句柄(file handle)
# 6.说明：
# 6-1、文件路径注意需要使用单引号或双引号括起来
# 6-2、使用read()方法读取文件内容时，如果文件大于可用内存，则不能实现文件的读取，而是返回空字符串
# 6-3、使用tell()方法返回的位置与为read()方法指定的size参数不同. tell()方法返回的不是字符的个数，而是字节数，其中汉字所占的字节数根据其采用的
# 编码有所不同，如果采用GBK编码，则一个汉字按两个字符计算；如果采用UTF-8编码，则一个汉字按3个字符计算
# 6-4、在指定encoding参数时，指定的编码一定是文件采用的编码，否则将抛出异常
# 7.示例：
# 用dir()函数获取该函数内置的属性和方法
print(dir(open))
# ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
# '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
# '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
# '__str__', '__subclasshook__', '__text_signature__']
# 用help()函数获取该函数的文档信息
help(open)
# 应用一：读取文件内容
# 示例1：读取整个文件内容
# 使用 'with' 语句打开文件
with open('file.txt', 'r') as file:
content = file.read() # 读取文件全部内容
print(content)
# 不需要显式调用 file.close()，因为 'with' 语句会自动处理
# 121314536273838390
# 123A
# 456B
# 789C
# 587
# 1024
# 示例2：逐行读取文件
# 使用 'with' 语句打开文件
with open('file.txt', 'r') as file:
for line in file: # 逐行读取文件
print(line, end='') # 打印每一行内容，end='' 用来避免默认的换行符
# 同样，'with' 语句会自动关闭文件
# 121314536273838390
# 123A
# 456B
# 789C
# 587
# 1024
# 示例3：读取指定字节数的文件内容
# 使用 'with' 语句打开文件，并指定读取的字节数
with open('file.txt', 'rb') as file: # 'rb' 模式用于二进制读取
content = file.read(10) # 读取前10个字节
print(content)
# 注意：如果文件内容不是二进制数据（如文本），这种方式可能导致输出不可读
# b'1213145362'
# 示例4：跳过文件的开头部分并读取
with open('file.txt', 'r') as file:
# 跳过开头的10个字符(或字节，在文本模式下)
# 注意：在文本模式下，这可能不是完全准确的10个字符，因为编码问题
file.seek(10)
content = file.read() # 从第10个字符之后开始读取
print(content)
# 'with' 语句结束时文件会被关闭
# 73838390
# 123A
# 456B
# 789C
# 587
# 1024
# 示例5：读取文件并处理每行内容(使用列表推导式)
# 使用 'with' 语句打开文件，并使用列表推导式处理每行内容
with open('file.txt', 'r') as file:
lines = [line.strip() for line in file] # 去除每行首尾的空白字符，并将结果存储到列表中
print(lines)
# 文件在 'with' 语句结束时被关闭，lines 列表包含了处理后的行内容
# ['121314536273838390', '123A', '456B', '789C', '587', '1024']
# 应用二：写入文件内容
# 示例1：写入整个字符串到文件
# 使用 'with' 语句打开文件，如果不存在则创建
with open('test.txt', 'w') as file:
file.write('Hello, World!') # 写入字符串到文件
# 'with' 语句结束时文件会被自动关闭
# 示例2：写入多行内容到文件
# 使用 'with' 语句打开文件
with open('test.txt', 'w') as file:
file.write('I am Myelsa.\n') # 写入第一行并添加换行符
file.write('I love Python very much.\n') # 写入第二行并添加换行符
# 文件在 'with' 语句结束时被关闭
# 示例3：写入列表中的每一行到文件
lines = ['Myelsa', 'Jimmy', 'Bruce']
# 使用 'with' 语句打开文件
with open('test.txt', 'w') as file:
for line in lines:
file.write(line + '\n') # 写入每一行并添加换行符
# 文件在 'with' 语句结束时被关闭
# 示例4：追加内容到文件
# 使用 'a' 模式打开文件，用于追加内容
with open('test.txt', 'a') as file:
file.write('Myelsa love Python very much.\n') # 追加内容到文件末尾
# 文件在 'with' 语句结束时被关闭
# 示例5：写入二进制数据到文件
data = b'\x00\x01\x02\x03\x04' # 二进制数据
# 使用 'wb' 模式打开文件用于二进制写入
with open('example.bin', 'wb') as file:
file.write(data) # 写入二进制数据到文件
# 文件在 'with' 语句结束时被关闭
# 应用三：处理二进制文件
# 示例1：读取二进制文件
# 使用 'rb' 模式打开二进制文件用于读取
with open('example.bin', 'rb') as file:
binary_data = file.read() # 读取整个文件作为二进制数据
# 处理二进制数据，例如打印前10个字节的十六进制表示
print(binary_data[:10].hex())
# 文件在 'with' 语句结束时被关闭
# 0001020304
# 示例2：写入二进制数据到文件
# 二进制数据，这里我们使用一个简单的字节字符串作为示例
binary_data = b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09'
# 使用 'wb' 模式打开二进制文件用于写入
with open('example.bin', 'wb') as file:
file.write(binary_data) # 写入二进制数据到文件
# 文件在 'with' 语句结束时被关闭
# 示例3：逐块读取大文件
chunk_size = 1024 # 设置每次读取的块大小为1024字节
# 使用 'rb' 模式打开二进制文件用于读取
with open('example.bin', 'rb') as file:
while True:
chunk = file.read(chunk_size) # 读取一个块的数据
if not chunk: # 如果返回空字节串，表示已经到达文件末尾
break
# 在这里处理你的块数据，例如打印或处理
print(chunk.hex())
# 文件在 'with' 语句结束时被关闭
# 00010203040506070809
# 示例4：修改二进制文件
# 使用 'rb' 模式打开原始二进制文件用于读取
with open('example.bin', 'rb') as file:
binary_data = file.read() # 读取整个文件作为二进制数据
# 修改二进制数据，例如将前4个字节设置为0xFF, 0xFF, 0xFF, 0xFF
binary_data = b'\xFF\xFF\xFF\xFF' + binary_data[4:]
# 使用 'wb' 模式打开一个新文件用于写入修改后的数据
with open('modified_binary_file.bin', 'wb') as file:
file.write(binary_data) # 写入修改后的二进制数据到新文件
# 原始文件和新文件现在都有各自的文件句柄，并且都已在 'with' 语句结束时被关闭
# 应用四：逐行读取文件
# 示例1：逐行读取文本文件
# 使用 'with' 语句打开文件，并使用 'r' 模式（默认）来读取文件
with open('test.txt', 'r') as file:
for line in file: # 逐行读取文件
print(line, end='') # 打印每一行内容，end='' 避免默认的换行符（如果你想要保留原文件的换行符，可以去掉 end=''）
# 'with' 语句结束时文件会被自动关闭
# Myelsa
# Jimmy
# Bruce
# Myelsa love Python very much.
# 示例2：逐行读取并处理文件内容
total = 0
# 使用 'with' 语句打开文件
with open('file.txt', 'r') as file:
for line in file:
# 去除每行末尾的换行符，并将字符串转换为整数（假设每行只包含一个整数）
number = int(line.strip())
total += number # 累加每行的数字
print(f"The total sum of numbers in the file is: {total}")
# 文件在 'with' 语句结束时被关闭
# The total sum of numbers in the file is: 121314536273841369
# 示例3：逐行读取并跳过空行
# 使用 'with' 语句打开文件
with open('test.txt', 'r') as file:
for line in file:
if line.strip(): # 如果行不是空的(即去除空白字符后还有内容)
print(line, end='') # 打印行内容
# 文件在 'with' 语句结束时被关闭
# Myelsa
# Jimmy
# Bruce
# Myelsa love Python very much.
# 应用五：文件搜索和替换
# 原始文件和目标文件可以是同一个文件，但这样操作会有风险，建议先写入临时文件再替换
original_file = 'file.txt'
# 如果要将结果写回到原文件，可以注释掉下面这行，并在最后将临时文件重命名为原文件名
temp_file = 'test.txt'
# 要搜索的字符串
search_string = '1'
# 要替换成的字符串
replace_string = 'm'
# 使用 'with' 语句打开原始文件以读取内容，同时打开临时文件以写入修改后的内容
with open(original_file, 'r', encoding='utf-8') as file, open(temp_file, 'w', encoding='utf-8') as temp:
for line in file:
# 替换文件中的字符串
new_line = line.replace(search_string, replace_string)
# 将替换后的行写入到临时文件中
temp.write(new_line)
# 如果需要将结果写回到原文件，删除原文件并将临时文件重命名为原文件名
import os
if original_file != temp_file:
os.remove(original_file) # 删除原文件
os.rename(temp_file, original_file) # 重命名临时文件为原文件名
print(f"Search and replace operation completed in {original_file}")
# 应用六：配置和数据存储
# 示例1：写入JSON数据到文件
# 要写入的数据
data = {
"name": "John Doe",
"age": 30,
"city": "New York"
}
# 使用 'w' 模式打开文件以写入内容
with open('data.json', 'w') as data_file:
# 将Python字典写入文件为JSON格式
json.dump(data, data_file)
# data.json 文件现在包含了写入的数据
# 示例2：读取和写入INI配置文件
import configparser
# 读取INI配置文件
config = configparser.ConfigParser()
config.read('config.ini')
# 访问配置项
print(config['section_name']['setting_name'])
# 写入INI配置文件
config['new_section'] = {'new_setting': 'new_value'}
with open('config.ini', 'w') as config_file:
config.write(config_file)
# config.ini 文件现在包含了新的配置项
# 示例3：读取和写入CSV文件
import csv
# 读取CSV文件
with open('data.csv', 'r', newline='') as csv_file:
reader = csv.reader(csv_file)
for row in reader:
print(row)
# 写入CSV文件
data = [['Name', 'Age'], ['Myelsa', 18], ['Bruce', 6]]
with open('data.csv', 'w', newline='') as csv_file:
writer = csv.writer(csv_file)
writer.writerows(data)
# data.csv 文件现在包含了写入的数据
# 应用七：文件锁定和并发访问
import fcntl
import os
def lock_file(file_path):
# 打开文件，以写入模式（这会创建文件如果它不存在）
with open(file_path, 'w+') as file_obj:
# 尝试获取独占锁（写锁）
try:
fcntl.flock(file_obj, fcntl.LOCK_EX | fcntl.LOCK_NB)
print(f"文件 {file_path} 已锁定")
# 在这里进行文件操作，如读写等
# ...
except IOError:
print(f"无法锁定文件 {file_path}，可能已被其他进程锁定")
finally:
# 释放锁
fcntl.flock(file_obj, fcntl.LOCK_UN)
# 使用示例
lock_file('example.lock')
# 应用八：临时文件处理
# 示例1：创建临时目录
import tempfile
import os
# 创建一个临时目录
with tempfile.TemporaryDirectory() as temp_dir:
print(f"临时目录已创建：{temp_dir}")
# 在临时目录中创建一个文件
with open(os.path.join(temp_dir, 'file_1.txt'), 'w') as f:
f.write('这是一个在临时目录中的文件\n')
# 你可以在这里做其他与临时目录相关的操作
# 临时目录在with块结束后会被自动删除
# 临时目录已创建：C:\Users\Administrator\AppData\Local\Temp\tmp_v1na9w7
# 应用九：与标准输入/输出交互
# 示例1：重定向标准输入/输出
import sys
# 将标准输出重定向到一个文件
with open('file.txt', 'w') as f:
sys.stdout = f # 现在print将写入到文件而不是控制台
print("这条消息将被写入到file.txt")
# 恢复标准输出到控制台
sys.stdout = sys.__stdout__
print("Myelsa love Python very much.")
# Myelsa love Python very much.
# 应用十：文件备份与恢复
# 示例1：备份文件
def backup_file(source_file, backup_file):
try:
with open(source_file, 'rb') as source, open(backup_file, 'wb') as backup:
backup.write(source.read())
print(f"文件 {source_file} 已成功备份到 {backup_file}")
except FileNotFoundError:
print(f"文件 {source_file} 不存在，无法备份。")
except Exception as e:
print(f"备份文件时发生错误：{e}")
# 使用示例
backup_file('original.txt', 'original_backup.txt')
# 示例2：恢复文件
def restore_file(backup_file, source_file):
try:
with open(backup_file, 'rb') as backup, open(source_file, 'wb') as source:
source.write(backup.read())
print(f"文件 {source_file} 已成功从 {backup_file} 恢复。")
except FileNotFoundError:
print(f"备份文件 {backup_file} 不存在，无法恢复。")
except PermissionError:
print(f"没有权限写入文件 {source_file}，无法恢复。")
except Exception as e:
print(f"恢复文件时发生错误：{e}")
# 使用示例(假设你已经备份了original.txt)
# 警告：这将会覆盖原始文件！确保这是你想要的。
restore_file('original_backup.txt', 'original.txt')
# 应用十一：文件加密和解密
# 示例1：加密文件
from cryptography.fernet import Fernet
import os
def encrypt_file(input_filename, output_filename, key):
cipher_suite = Fernet(key)
with open(input_filename, "rb") as file:
# 读取文件内容
data = file.read()
# 加密文件内容
encrypted_data = cipher_suite.encrypt(data)
with open(output_filename, "wb") as file:
# 写入加密后的内容
file.write(encrypted_data)
# 示例使用
key = Fernet.generate_key() # 生成一个随机的密钥，实际应用中需要安全地存储这个密钥
encrypt_file('input.txt', 'encrypted.txt', key)
print("文件已加密并保存为 encrypted.txt")
# 示例2：解密文件
from cryptography.fernet import Fernet
def decrypt_file(input_filename, output_filename, key):
cipher_suite = Fernet(key)
with open(input_filename, "rb") as file:
# 读取加密的文件内容
encrypted_data = file.read()
# 解密文件内容
decrypted_data = cipher_suite.decrypt(encrypted_data)
with open(output_filename, "wb") as file:
# 写入解密后的内容
file.write(decrypted_data)
# 示例使用，使用与加密时相同的密钥
decrypt_file('encrypted.txt', 'decrypted.txt', key)
print("文件已解密并保存为 decrypted.txt")
# 应用十二：文件传输
import os
import shutil
def copy_file(source_path, destination_path):
# 检查源文件是否存在
if not os.path.exists(source_path):
print(f"源文件 {source_path} 不存在。")
return
# 检查目标目录是否存在，如果不存在则创建
if not os.path.exists(os.path.dirname(destination_path)):
os.makedirs(os.path.dirname(destination_path))
# 使用shutil库复制文件，但为了模拟使用open()函数，我们手动实现
try:
with open(source_path, 'rb') as source_file, open(destination_path, 'wb') as destination_file:
# 读取源文件内容并写入目标文件
while True:
data = source_file.read(1024) # 每次读取1024字节
if not data:
break
destination_file.write(data)
print(f"文件已成功从 {source_path} 传输到 {destination_path}")
except Exception as e:
print(f"文件传输过程中发生错误：{e}")
# 使用示例
source_file = 'path/to/source/file.txt'
destination_file = 'path/to/destination/file.txt'
copy_file(source_file, destination_file)
# 应用十三：文本处理和数据分析
import csv
# 假设CSV文件有两列：姓名,年龄
total_age = 0
age_count = 0
min_age = float('inf') # 初始化为正无穷大
max_age = float('-inf') # 初始化为负无穷大
with open('data.csv', 'r', encoding='utf-8', newline='') as csvfile:
reader = csv.reader(csvfile)
next(reader, None) # 跳过表头(如果有的话)
for row in reader:
name, age_str = row # 假设CSV中没有其他额外的列或空值
try:
age = int(age_str) # 转换年龄为整数
total_age += age
age_count += 1
if age < min_age:
min_age = age
if age > max_age:
max_age = age
except ValueError:
print(f"无法解析年龄：{age_str}（跳过此行）")
# 计算平均年龄
average_age = total_age / age_count if age_count > 0 else 0
# 输出结果
print(f"总年龄：{total_age}")
print(f"年龄数量：{age_count}")
print(f"最小年龄：{min_age}")
print(f"最大年龄：{max_age}")
print(f"平均年龄：{average_age}")
# 应用十四：文件映射
# 创建一个颜色到RGB值的映射字典
color_to_rgb = {
'red': '(255, 0, 0)',
'green': '(0, 255, 0)',
'blue': '(0, 0, 255)',
# ... 其他颜色
}
# 打开文本文件以进行读取和写入（由于我们将覆盖原文件，所以需要写入权限）
with open('colors.txt', 'r', encoding='utf-8') as file, open('colors_mapped.txt', 'w', encoding='utf-8') as outfile:
# 逐行读取文本文件
for line in file:
# 对每一行进行文本映射（替换颜色名称）
for color, rgb in color_to_rgb.items():
line = line.replace(color, rgb)
# 将映射后的行写入新的文件
outfile.write(line)
# 现在'colors_mapped.txt'文件包含了映射后的颜色值
# 应用十五：监视文件变化(使用watchdog替代方案)
import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
class MyHandler(FileSystemEventHandler):
def on_modified(self, event):
if not event.is_directory:
print(f"文件 {event.src_path} 已被修改")
# 你还可以添加其他事件处理方法，如 on_created, on_deleted, on_moved 等
if __name__ == "__main__":
path_to_watch = "/path/to/directory" # 替换为你想要监视的目录路径
event_handler = MyHandler()
observer = Observer()
observer.schedule(event_handler, path_to_watch, recursive=True) # recursive=True 表示递归监视子目录
observer.start()
try:
while True:
time.sleep(1) # 保持主线程活跃，以便监视器可以运行
except KeyboardInterrupt:
observer.stop()
observer.join()
# 应用十六：网络文件和特殊设备
# 示例1：处理网络文件(例如，通过HTTP下载文件)
import requests
def download_file_from_url(url, save_path):
response = requests.get(url, stream=True)
if response.status_code == 200:
with open(save_path, 'wb') as f:
for chunk in response.iter_content(chunk_size=8192):
f.write(chunk)
else:
print(f"Failed to download file, status code: {response.status_code}")
# 使用示例
url = 'http://example.com/somefile.txt'
save_path = 'local_copy_of_somefile.txt'
download_file_from_url(url, save_path)
# 示例2：处理特殊设备(例如，通过串口通信读取数据)
# 对于特殊设备(如串口设备)，你可以使用pySerial库
import serial
def read_from_serial_port(port, baudrate):
ser = serial.Serial(port, baudrate, timeout=1)
if ser.isOpen():
print('Serial port is open.')
data = ser.readline().decode('utf-8').rstrip() # 读取一行数据并解码
print('Received:', data)
ser.close() # 关闭串口
else:
print('Unable to open serial port')
# 使用示例
port = '/dev/ttyUSB0' # 对于Linux系统，串口可能类似于/dev/ttyUSB0或/dev/ttyS0
baudrate = 9600
read_from_serial_port(port, baudrate)
# 示例3：处理网络文件系统(例如，通过SSH/SFTP访问远程文件)
# 对于网络文件系统，如SSH或SFTP，你可以使用paramiko库
import paramiko
def sftp_get_file(hostname, port, username, password, remote_path, local_path):
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # 自动添加主机名及主机密钥到本地HostKeys对象，并保存
ssh.connect(hostname, port, username, password)
sftp = ssh.open_sftp()
sftp.get(remote_path, local_path) # 从远程路径下载文件到本地路径
sftp.close()
ssh.close()
# 使用示例
hostname = 'remote.example.com'
port = 22
username = 'your_username'
password = 'your_password'
remote_path = '/path/to/remote/file.txt'
local_path = '/path/to/local/file.txt'
sftp_get_file(hostname, port, username, password, remote_path, local_path)1-2、VBA：
略，待后补。2、推荐阅读：
Python算法之旅：Algorithm
Python函数之旅：Functions
1100
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
