文件操作

写入与读取

在Python中，操作文件的步骤为： 打开文件open()->读写文件read()或write()->关闭文件close()，打开文件通过函数来实现。

基础写法

#打开文件  
file = open('路径','打开方式')  
#读取文件  
content = file.read()  
#写入文件  
file.write('写入的内容')  
#关闭文件  
file.close()

示例：

#写入  
file1 = open('abc.txt','w',encoding = 'utf-8')  
file1.write('我爱Python')  
file1.close()  
#读取  
file2 = open('abc.txt','r',encoding = 'utf-8')  
content = file2.read()  
file2.close()  
print(content)

open()函数

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数解释

• file: 要打开的文件路径（绝对路径或相对路径）。
• mode: 打开文件的模式，默认是 'r'（只读模式）。常用的模式包括：

• buffering: 设置文件的缓冲策略。
• 0：无缓冲。
• 1：行缓冲（仅适用于文本模式）。
• 大于 1的整数：指定缓冲区大小。
• -1：使用默认缓冲区大小。
• encoding: 用于解码或编码文件的编码方式，例如 'utf-8'。仅文本模式下有效。一般是'utf-8'或'gbk'。
• errors: 指定如何处理编码和解码错误，常见值有 'strict', 'ignore', 'replace'。
• newline: 控制换行符在读取和写入时的行为。可选值有 None, '', '\n', '\r', 和 '\r\n'。
• closefd: 如果文件是通过文件描述符（而不是文件名）打开的，这个参数控制文件关闭时是否关闭文件描述符（默认为True）。
• opener: 一个可调用对象，用于通过自定义方式打开文件描述符，返回文件描述符的整数。

seek()函数

seek() 函数在 Python 中是用来改变文件当前位置的。该函数是文件对象的一部分，允许你移动文件读取指针到文件中的不同位置。这在处理大文件或者需要从特定位置读取数据时非常有用。

file.seek(offset, whence=0)

• offset：是移动操作的起始位置的偏移量，表示从哪里开始移动。正值表示向前移动，负值表示向后移动。
• whence：这是可选参数，决定了 offset的参考点。它有三个可能的值：
• 0（默认值）：从文件的开头计算偏移量（绝对文件位置）。
• 1：从当前文件位置计算偏移量。
• 2：将文件的EOF作为移动的起点。

假设我们有一个名为 example.txt的文件，其内容如下：

Hello World
This is a test file.
Python is great!

以下是一个使用 seek()函数的示例：

# 打开文件
with open('example.txt', 'r') as file:
    # 移动到文件的第11个字节
    file.seek(11)
    # 从当前位置读取剩余的内容
    content = file.read()
    print(content)

    # 重置指针到文件开头
    file.seek(0)
    # 读取第一行
    first_line = file.readline()
    print(first_line)

    # 移动到文件的末尾
    file.seek(0, 2)
    # 尝试从文件末尾读取内容（不会读取到任何内容）
    end_content = file.read()
    print(end_content)  # 输出将为空

这个例子首先移动到文件的第11个字节处，然后读取并打印从那里到文件末尾的所有内容。然后，它将文件指针重置到文件的开头，并读取第一行。最后，它尝试从文件末尾开始读取内容，但由于已经到达了文件的末尾，所以不会读取到任何内容。

with关键字写法

使用 open()函数时，最佳实践是结合 with语句来自动管理文件资源，确保文件在使用后能够正确关闭。这样可以避免文件泄露和其他资源管理问题。

with open ('路径','打开方式') as file:  
  # 读取文件  
  content = file.read()  
  # 写入内容  
  file.write('写入内容')  
  #缩进，无需close()函数

示例

with open('abc.txt','w',encoding = 'utf-8') as file1:  
  file1.write('我爱Python')  
with open('abc.txt','r',encoding = 'utf-8') as file2:  
  content = file2.read()  
  print(content)

txt文件的按行读取和按行写入

writelines():'按行重写'，可以写入序列,返回一个字符串 readlines():'按行读取'，返回一个列表，每一行为列表中的元素

a = ('人生', '如', '梦')  
b = '人生苦短'  
with open('demo.txt','w', encoding='utf-8')as f:  
   f.writelines(a)  
   f.write('\n' + b) # 换行写入  
with open('demo.txt', 'r', encoding='utf-8') as f:  
   lines = f.readlines()  
   print(lines)  
   for line in lines: # 用for语句来遍历  
     print(line)

输出结果：

['人生如梦\n', '人生苦短']  
    人生如梦  

    人生苦短

示例

# Step 1: 读取文件的全部内容并打印
print("Step 1: Reading the entire content of the file.")
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

# Step 2: 写入内容到文件
print("\nStep 2: Writing 'Hello, World!' into output.txt.")
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write('Hello, World!')

# Step 3: 追加内容到文件
print("Step 3: Appending 'Goodbye, World!' into output.txt.")
with open('output.txt', 'a', encoding='utf-8') as f:
    f.write('\nGoodbye, World!')

# Step 4: 读取二进制文件（例如图片）
print("Step 4: Reading a binary file (an image).")
with open('image.png', 'rb') as f:
    binary_content = f.read()
    print(f"Binary content of image.png read. Length: {len(binary_content)} bytes.")

# Step 5: 逐行读取文件并转换为大写
print("\nStep 5: Reading lines one by one and converting to uppercase.")
with open('example.txt', 'r', encoding='utf-8') as file:
    line = file.readline()
    while line:
        print(line.upper(), end='')
        line = file.readline()

# Step 6: 读取所有行到列表中，然后反转每行并写入新文件
print("\nStep 6: Reading all lines, reversing, and writing to a new file.")
with open('example.txt', 'r', encoding='utf-8') as file:
    lines = file.readlines()
    reversed_lines = [line[::-1] for line in lines]

with open('reversed.txt', 'w', encoding='utf-8') as file:
    file.writelines(reversed_lines)

# Step 7: 创建新的句子列表并写入文件
print("Step 7: Writing new sentences to another file.")
new_sentences = [
    "Here are some new lines.\n",
    "Python makes file manipulation easy!\n",
    "Let's write these lines to a file.\n"
]

with open('new_sentences.txt', 'w', encoding='utf-8') as file:
    file.writelines(new_sentences)

OS模块总结

import os

文件路径相关

常用方法列表

`os.getcwd()`:得到当前工作目录，即当前Python脚本工作的目录路径
`os.remove()`:函数用来删除一个文件
`os.removedirs(r"c\python")`:删除多个目录
`os.path.isfile()`:检验给出的路径是否是一个文件

　　os.path.isdir()检验给出的路径是否是一个目录

　　os.path.isabs()判断是否是绝对路径

　　os.path.split()返回一个路径的目录名和文件名

　　os.path.splitext()分离扩展名

　　os.path.dirname()获取路径名

　　os.path.basename()获取文件名

　　os.system()运行shell命令

　　os.getenv() 与os.putenv()读取和设置环境变量

　　os.linesep 给出当前平台使用的行终止符，Windows使用'rn'，Linux使用'n'而Mac使用'r'

　　os.name指示你正在使用的平台，对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

　　os.rename(old, new)重命名：

　　os.mkdir("test")创建单个目录

　　os.stat(file)获取文件属性

　　os.chmod(file)修改文件权限与时间戳

　　os.exit()终止当前进程

　　os.path.getsize(filename)获取文件大小

　　os.mkdir("file")创建目录

　　shutil.copyfile("oldfile","newfile")复制文件, oldfile和newfile都只能是文件

　　shutil.copy("oldfile","newfile")oldfile只能是文件夹，newfile可以是文件，也可以是目标目录

　　shutil.copytree("olddir","newdir")复制文件夹,olddir和newdir都只能是目录，且newdir必须不存在

　　os.rename("oldname","newname")重命名文件(目录),文件或目录都是使用这条命令

　　shutil.move("oldpos","newpos")移动文件(目录)

　　os.remove("file")删除文件

　　os.rmdir("dir")删除目录, 只能删除空目录

　　shutil.rmtree("dir")空目录、有内容的目录都可以删

　　os.chdir("path")转换目录, 换路径

　　os.mknod("test.txt")创建空文件

异常处理

异常处理是编程中一种重要的概念，它帮助我们处理程序运行时可能遇到的错误和异常情况。Python通过一套完整的异常处理机制来帮助程序员捕获并处理运行时错误，从而提高程序的健壮性和可靠性。

基本概念

• 异常：在Python中，异常是一个事件，该事件会在程序执行过程中发生，中断了当前代码的正常流程。
• 捕获异常：通过异常处理机制，可以捕获并处理程序运行过程中发生的异常。

异常处理语法

Python使用 try和 except语句来捕获和处理异常。

try:
    # 尝试执行的代码
    result = 10 / 0
except ZeroDivisionError:
    # 如果发生了ZeroDivisionError异常，执行这块代码
    print("除数不能为0")

多个异常

你可以通过一个 except语句捕获多个异常，将它们放在一个元组中。

try:
    # 尝试执行的代码
    result = 10 / "2"
except (ZeroDivisionError, TypeError) as e:
    # 如果发生了ZeroDivisionError或TypeError异常，执行这块代码
    print(f"发生错误：{e}")

finally语句

无论是否发生异常， finally语句块中的代码都会被执行。这对于执行一些清理工作（如关闭文件）很有用。

try:
    # 尝试执行的代码
    f = open("file.txt")
    f.read()
except FileNotFoundError as e:
    # 文件未找到异常
    print(f"文件未找到：{e}")
finally:
    # 无论是否发生异常都会执行的代码
    f.close()

自定义异常

可以通过继承 Exception类来定义自己的异常类型。

class MyError(Exception):
    pass

try:
    raise MyError("这是一个错误信息")
except MyError as e:
    print(e)

异常链

在处理一个异常的时候引发另一个异常，可以使用 from来链接这两个异常。

try:
    raise KeyError
except KeyError as e:
    raise ValueError from e

在Python中，模块是一个包含Python定义和语句的文件。模块可以定义函数、类和变量，也可以包含可执行的代码。模块让你能够逻辑地组织你的Python代码段。把相关的代码分配到一个模块里能让你的代码更好用、更易懂。模块也是Python对象，具有随机的名称属性用来绑定或引用同一模块内的函数、类、变量。

模块

import导入模块

Python中使用 import语句来导入模块。当解释器遇到 import语句时，如果模块在当前的搜索路径中，就会导入它。

import math
print(math.sqrt(16))  # 输出: 4.0

from导入

导入模块中指定部分

使用 from...import语句可以从模块中导入特定的部分到当前命名空间中，如果有多个需要导入可以使用 ,来追加。

from math import sqrt,add
print(sqrt(16))  # 输出: 4.0

导入模块中所有

使用 frommoduleimport*导入模块中的所有名称。

from math import *
print(sqrt(16))  # 输出: 4.0

注意：这种导入方式不推荐使用，因为它可能会导入很多未使用的变量，从而污染命名空间。

重命名模块

使用 as给模块指定别名。

import math as m
print(m.sqrt(16))  # 输出: 4.0

模块的搜索路径

1. 模块查找过程

当Python遇到一个 import语句时，它会根据以下顺序查找模块：

1. 内置模块：Python首先查找其内部模块列表。如果模块名在此列表中，Python会直接加载内置模块。
2. sys.modules缓存： sys.modules是一个字典，它缓存了所有已经加载的模块。如果模块已经在这个字典中，Python会直接从这里加载模块，而不会重新执行模块代码。
3. sys.path搜索： sys.path是一个列表，包含了Python解释器的搜索路径。搜索路径的组成包括：

• 脚本的目录（或当前工作目录，如果是交互式解释器）。
• PYTHONPATH环境变量（如果设置）。
• 标准库目录。
• 安装的第三方模块和包的目录。

2. 模块编译

如果找到的模块是一个 .py文件，Python解释器会将其编译成字节码（ .pyc文件），字节码是一种Python虚拟机可以直接执行的中间代码。编译后的字节码会被存储在 __pycache__目录下，以便于下次导入时加快加载速度。

3. 模块加载

加载阶段涉及到将编译后的字节码加载到Python的虚拟机中，并执行模块级别的代码。这一步会创建模块对象，初始化任何模块级别的变量和函数。

4. 模块初始化

如果模块是第一次被导入，它的顶层代码将被执行。这可能包括函数和类的定义，以及执行模块级别的操作。一旦模块的顶层代码执行完毕，模块就被视为已初始化。

5. 模块缓存

加载并初始化后的模块会被添加到 sys.modules缓存中。这意味着，如果之后再次导入同一个模块，Python会直接从缓存中加载，而不是重新执行模块代码。

特殊情况：包的加载

当导入一个包时，过程略有不同。包实际上是一个包含 __init__.py文件的目录。当包被导入时， __init__.py中的代码会被执行，可以用于初始化包的状态或执行必要的设置。

模块重加载

在某些情况下，你可能需要重新加载已修改的模块。这可以通过 importlib.reload()实现。请注意，重加载模块可能会导致与现有对象的兼容性问题。

创建自己的模块

创建自己的模块非常简单，因为每个Python文件都可以作为一个模块。你只需要确保它具有 .py扩展名。

# mymodule.py
def greeting(name):
    print("Hello, " + name)

# 使用模块
import mymodule
mymodule.greeting("Python")

包

包是一种管理Python模块命名空间的形式，采用"点模块名称"。一个包里面可以包含子包、模块和子模块，使得模块和子包可以通过相同的方式被引入。

创建一个包非常简单。只需要在文件夹中添加一个 __init__.py文件即可。 __init__.py可以是空文件，也可以包含Python代码。

通过这个教程，你应该对Python中的模块有了基本的了解。模块是Python程序结构化和重用代码的关键概念。理解并合理使用模块，可以使你的Python程序更加模块化，更易于维护和扩展。