# Python文件操作

## 文件操作基本流程



```python
#1. 打开文件，得到文件句柄并赋值给一个变量
f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r

#2. 通过句柄对文件进行操作
data=f.read()

#3. 关闭文件
f.close()
```



打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：



```python
f.close()
# 回收操作系统级打开的文件,系统级别不回收会导致文件一直被占用，如果程序以外崩溃，会导致数据丢失
del f
# 回收应用程序级的变量
```



在操作完毕文件后，一定要记住f.close(),推荐操作方式：使用with关键字来帮我们管理上下文



```python
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
    data=read_f.read()
    write_f.write(data)
```



## 文件编码



f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。



```python
f=open('a.txt','r',encoding='utf-8')
```



## 文件的打开模式



### 打开文件的模式



| r    | 只读模式【默认模式，文件必须存在，不存在则抛出异常】   |
| ---- | ------------------------------------------------------ |
| w    | 只写模式【不可读；不存在则创建；存在则清空内容】       |
| a    | 只追加写模式【不可读；不存在则创建；存在则只追加内容】 |



对于非文本文件，我们只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）



rb

wb

ab



注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码



### ‘+’模式（就是增加了一个功能）



| r+   | 读写【可读，可写】 |
| ---- | ------------------ |
| w+   | 写读【可写，可读】 |
| a+   | 写读【可写，可读】 |

| 模式 | 可做操作 | 若文件不存在 | 是否覆盖   |
| ---- | -------- | ------------ | ---------- |
| r    | 只能读   | 报错         | -          |
| r+   | 可读可写 | 报错         | 是         |
| w    | 只能写   | 创建         | 是         |
| w+   | 可读可写 | 创建         | 是         |
| a    | 只能写   | 创建         | 否，追加写 |
| a+   | 可读可写 | 创建         | 否，追加写 |

### 以bytes类型操作的读写，写读，写读模式



| r+b  | 读写【可读，可写】 |
| ---- | ------------------ |
| w+b  | 写读【可写，可读】 |
| a+b  | 写读【可写，可读】 |



## 文件操作方法



### 常用操作方法



read（3）：



1. 文件打开方式为文本模式时，代表读取3个字符
2. 文件打开方式为b模式时，代表读取3个字节



其余的文件内光标移动都是以字节为单位的如：seek，tell，truncate



注意：



1. seek有三种移动方式0，1，2，其中1和2必须在b模式下进行，但无论哪种模式，都是以bytes为单位移动的
2. truncate是截断文件，所以文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate要在r+或a或a+等模式下测试效果。



### 所有的操作方法



```python
def close(self, *args, **kwargs): # real signature unknown
        关闭文件
        pass

def fileno(self, *args, **kwargs): # real signature unknown
    文件描述符  
    pass

def flush(self, *args, **kwargs): # real signature unknown
    刷新文件内部缓冲区
    pass

def isatty(self, *args, **kwargs): # real signature unknown
    判断文件是否是同意tty设备
    pass

def read(self, *args, **kwargs): # real signature unknown
    读取指定字节数据
    pass

def readable(self, *args, **kwargs): # real signature unknown
    是否可读
    pass

def readline(self, *args, **kwargs): # real signature unknown
    仅读取一行数据
    pass

def seek(self, *args, **kwargs): # real signature unknown
    指定文件中指针位置
    pass

def seekable(self, *args, **kwargs): # real signature unknown
    指针是否可操作
    pass

def tell(self, *args, **kwargs): # real signature unknown
    获取指针位置
    pass

def truncate(self, *args, **kwargs): # real signature unknown
    截断数据，仅保留指定之前数据
    pass

def writable(self, *args, **kwargs): # real signature unknown
    是否可写
    pass

def write(self, *args, **kwargs): # real signature unknown
    写内容
    pass

def __getstate__(self, *args, **kwargs): # real signature unknown
    pass

def __init__(self, *args, **kwargs): # real signature unknown
    pass

@staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
    """ Create and return a new object.  See help(type) for accurate signature. """
    pass

def __next__(self, *args, **kwargs): # real signature unknown
    """ Implement next(self). """
    pass

def __repr__(self, *args, **kwargs): # real signature unknown
    """ Return repr(self). """
    pass
```



## 文件的修改



文件的数据是存放于硬盘上的，因而只存在覆盖、不存在修改这么一说，我们平时看到的修改文件，都是模拟出来的效果，具体的说有两种实现方式：



方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）



```python
import os

with open('a.txt') as read_f,open('a.txt.new','w') as write_f:
    data = read_f.read()
    data = data.replace('Hello','nihao')

    write_f.write(data)

os.remove('a.txt')
os.rename('a.txt.new','a.txt')
```



方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件



```python
import os

with open('a.txt') as read_f,open('a.txt.new','w') as write_f:
    for line in read_f:
        line = line.replace('nihao','Hello')
        write_f.write(line)

os.remove('a.txt')
os.rename('a.txt.new','a.txt')
```



## 小测验



文件a.txt内容：每一行内容分别为商品名字，价钱，个数。

apple 10 3

tesla 100000 1

mac 3000 2

lenovo 30000 3

chicken 10 3

通过代码，将其构建成这种数据类型：[{'name':'apple','price':10,'amount':3},{'name':'tesla','price':1000000,'amount':1}......] 并计算出总价钱。



```python
list = []
with open('a.txt','r',encoding='utf-8') as file:
    for line in file:
        list2 = line.strip().split()
        if list2:
            dic = {'name':list2[0],'price':list2[1],'amount':list2[2]}
            list.append(dic)
        continue

print(list)
price = 0
for i in list:
    price += int(i['price']) * int(i['amount'])

print(price)
```

### 登录注册文件数据库版本

```python
while True:
    # 获取文件中保存的用户名和密码信息
    dic = {}
    with open("db", "a+", encoding="utf-8") as f:
        f.seek(0)
        temp_data = f.readlines()
        for i in temp_data:
            data = i.strip()
            if len(data) == 0:
                continue
            temp_db = data.split("✨")
            dic[temp_db[0]] = temp_db[-1]

    # 登录注册的逻辑
    print("登录".center(30,"="))
    print("请选择：\n1.登录\n2.注册")
    choice = input(">>>")
    if choice == "1":
        username = input("输入用户名：")
        if username in dic.keys():
            password = input("输入密码：")
            if dic[username] == password:
                print("\033[42;30m 登录成功！ \033[0m")
            else:
                print("\033[41;37m 密码错误 \033[0m")
        else:
            print("\033[41;37m用户名不存在！\033[0m")
    elif choice == "2":
        username = input("输入用户名")
        if username in dic.keys():
            print("\033[34;41m 用户名已存在！\033[0m")
            continue
        password = input("请输入密码")
        dic[username] = password
        print("\033[42;30m 注册成功！ \033[0m")
    else:
        print("\033[41;37m输入错误！\033[0m")

    # 将数据写入文件
    with open("db", "w+", encoding="utf-8") as f:
        for k,v in dic.items():
            data = f"{k}✨{v}\n"
            f.write(data)
```

