文件的读写操作和遍历目录

读文件

• 过程：
  1. 找到文件
  2. 打开文件
  3. 读取文件内容
  4. 关闭文件
• 打开文件
  • 原型：
    def open(file, mode=‘r’, buffering=None, encoding=None, errors=None, newline=None, closefd=True)
  • 参数：
    file：要打开文件的路径
    mode：打开方式
    encoding：编码格式
    errors：错误处理
  • 返回值：文件描述符，从当前的位置操作当前打开的文件
• 打开方式
  • r 以只读方式打开文件，文件的引用(文件描述符)将会放在文件开头
  • rb 以二进制格式打开只读文件，文件的引用(文件描述符)将会放在文件开头
  • r+ 以读写的方式打开文件，文件的引用(文件描述符)将会放在文件开头
  • w 以只写方式打开文件，如果该文件存在，则将其内容覆盖，如果文件不存在则创建文件
  • wb 以二进制格式打开只写文件，如果该文件存在，则将其内容覆盖，如果文件不存在则创建文件
  • w+ 以读写的方式打开文件，如果该文件存在，则将其内容覆盖，如果文件不存在则创建文件
  • a 打开一个文件用于追加，如果该文件存在，文件描述符会放在文件的末尾，也就是说新内容添加到已有内容之后，如果文件不存在则创建文件进行写入
  • a+ 打开一个文件用于读写，如果该文件存在，文件描述符会放在文件的末尾，也就是说新内容添加到已有内容之后，如果文件不存在则创建文件进行写入

filePath = r"C:\Users\xlg\Desktop\code\file1.txt"
# 打开普通文件
fp = open(filePath, "r")
# 打开二进制文件
fp = open(filePath, "rb")
# 打开指定编码格式的文件
fp = open(filePath, "r", encoding="utf-8")
# 错误处理：直接忽略
fp = open(filePath, "r", encoding="utf-8", errors="ignore")

• 完整过程

# 一般格式
try:
    fp = open("file1.txt", "r")
finally:
    if fp:
        fp.close()

# 简单写法（推荐）
with open("file1.txt", "r") as fp:
    print(fp.read())

写文件

• 过程：
  1. 找到文件
  2. 打开文件
  3. 将内容写入缓冲区，此时内容没有写入文件
  4. 刷新缓冲区，直接把缓冲区的数据立刻写入文件
     • 刷新缓冲区方式：
       a. 程序结束
       b. 关闭文件
       c. 手动刷新
       d. 遇到\n
       e. 缓冲区满了
  5. 关闭文件

filePath = "file2.txt"
fp = open(filePath, "w")

# 将数据写入缓冲区
fp.write("bingle good\n")
# 手动刷新缓冲区
fp.flush()
time.sleep(5)

fp.close()

• 完整过程

try:
    fp = open("file2.txt", "w")
finally:
    if fp:
        fp.close()
        
# 简写
with open("file2.txt", "a") as fp:
    fp.write("good man")

文件的编码与解码

#编码写
with open("file3.txt", "wb") as fp:
    strInfo = "bingle is a good man帅"
    strInfo = strInfo.encode("utf-8")
    print(strInfo)
    fp.write(strInfo)


# 解码读
with open("file3.txt", "rb") as fp:
    strInfo = fp.read()
    print(strInfo, type(strInfo))
    strInfo = strInfo.decode("utf-8")
    print(strInfo, type(strInfo))

chardet模块检测编码

• encoding：表示编码格式，GBK是GB2312的超集，两者是同一种编码方式
• confidence：表示检测的正确的概率
• language：表示数据的语言

import chardet

#数据量小，猜测的不太对
data = "兵哥是一个好男人".encode("utf-8")
print(data)

ret = chardet.detect(data)
print(ret, type(ret))

info = data.decode(ret["encoding"])
print(info)

# 输出
b'\xe5\x85\xb5\xe5\x93\xa5\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe5\xa5\xbd\xe7\x94\xb7\xe4\xba\xba'
{'encoding': 'utf-8', 'confidence': 0.99, 'language': ''} <class 'dict'>
兵哥是一个好男人

StringIO和BytesIO

StringIO

• 作用：数据的读写不一定都是文件，也可以在内存中读写，作用是在内存中读写字符串

from io import StringIO

#写
#1、获取一片内存空间
fp = StringIO()
fp.write("bingle ")
fp.write("is ")
fp.write("a ")
fp.write("good ")
fp.write("man!")
#获取写入的内容
print(fp.getvalue())

#读
#指针从头开始
fp.seek(0)
print(fp.read())
fp2 = StringIO("bingle is a\nnice man")
# print(fp2.read())
print(fp2.readlines())
fp.close()
fp2.close()

BytesIO

• 作用：StringIO只能操作字符串，BytesIO可以操作二进制数据，作用是在内存中读写bytes

from io import BytesIO

fp3 = BytesIO()
fp3.write("bingle is a good man帅".encode("utf-8"))

fp3.seek(0)
print(fp3.read().decode("utf-8"))

OS模块的使用

• 作用：包含了普遍的操作系统功能，提供了非常丰富的方法用来处理文件和目录

# 操作系统的类型
# nt      Windows
# posix   Linux、Unix
print(os.name)

#获取操作系统的系统信息，linux、Unix下使用
# print(os.uname())

#获取系统中的环境变量
print(os.environ)
#获取指定环境变量的值
print(os.environ.get("ALLUSERSPROFILE"))



#返回当前目录
print(os.curdir)
#得到当前工作目录的绝对路径
print(os.getcwd())
#返回指定目录下的所有文件和目录
print(os.listdir(r"C:\Users\xlg\Desktop\day1903\day16\code"))

#创建指定目录，注意目录已经存在时会报错
 os.mkdir(r"C:\Users\xlg\Desktop\day1903\day16\mk1")
os.mkdir(r"C:\Users\xlg\Desktop\day1903\day16\mk1\a\b\c")#如果存在不存在的路径层级会报错

#删除目录，目录不存在时报错
os.rmdir(r"C:\Users\xlg\Desktop\day1903\day16\mk1")

#获取文件属性
print(os.stat(r"C:\Users\xlg\Desktop\day1903\day16\code\file1.txt"))
#重命名
os.rename(r"C:\Users\xlg\Desktop\day1903\day16\code\file1.txt",r"C:\Users\xlg\Desktop\day1903\day16\code\file11.txt")
#删除普通文件
 os.remove(r"C:\Users\xlg\Desktop\day1903\day16\code\file11.txt")


#运行shell命令
 os.system("notepad")
 os.system("shutdown -s -t 10")
 os.system("shutdown -a")



#操作文件和目录的函数一部分在os模块中，还有一部分在os.path中


#返回指定路径的绝对路径
print(os.path.abspath("."))
#拼接路径
print(os.path.join(r"C:\Users\xlg\Desktop\day1903\day16\code","sunck"))
#拆分路径
print(os.path.split(r"C:\Users\xlg\Desktop\day1903\day16\code\a.txt"))
#获取文件扩展名
print(os.path.splitext(r"C:\Users\xlg\Desktop\day1903\day16\code\a.txt"))
#判断是否是目录
print(os.path.isdir(r"C:\Users\xlg\Desktop\day1903\day16\code"))
print(os.path.isdir(r"C:\Users\xlg\Desktop\day1903\day16\code\file2.txt"))
print(os.path.isdir(r"C:\Users\xlg\Desktop\day1903\day16\code\sunck"))
#判断是否是文件
print(os.path.isfile(r"C:\Users\xlg\Desktop\day1903\day16\code\file2.txt"))
print(os.path.isfile(r"C:\Users\xlg\Desktop\day1903\day16\code"))
print(os.path.isfile(r"C:\Users\xlg\Desktop\day1903\day16\code\file5.txt"))
#判断文件和目录是否存在
print(os.path.exists(r"C:\Users\xlg\Desktop\day1903\day16\code"))
print(os.path.exists(r"C:\Users\xlg\Desktop\day1903\day16\code\file2.txt"))
#判断路径是否是绝对路径（不论是否存在）
print(os.path.isabs(r"C:\Users\xlg\Desktop\day1903\day16\code"))
print(os.path.isabs(r"C:\Users\xlg\Desktop\day1903\day16\code\sunck"))
print(os.path.isabs(r"file2.txt"))
#获取文件名
print(os.path.basename(r"C:\Users\xlg\Desktop\day1903\day16\code\a.txt"))
#获取目录名
print(os.path.basename(r"C:\Users\xlg\Desktop\day1903\day16\code"))
#获取文件大小
print(os.path.getsize(r"C:\Users\xlg\Desktop\day1903\day16\code\file2.txt"))

文件持久化存储

pickle文件序列化和反序列化

持久化保存对象，将list、tuple、dict、set等数据序列化存储到文件

import pickle

user = {"account": "888888", "passwd": "123456"}
with open("users.txt", "wb") as fp:
    pickle.dump(user, fp)


with open("users.txt", "rb") as fp:
    user = pickle.load(fp)
print(user, type(user))

shelve 和 json的序列化反序列化

序列化操作

递归遍历目录

递归遍历目录

def traverseDir(dirPath, treeShow=""):
    import os
    filesList = os.listdir(dirPath)
    for fileName in filesList:
        absPath = os.path.join(dirPath, fileName)
        if os.path.isdir(absPath):
            #目录
            print(treeShow+"目录："+fileName)
            traverseDir(absPath, treeShow+"  ")
        else:
            print(treeShow+"文件：" + fileName)

traverseDir(r"C:\Users\xlg\Desktop\file

栈模拟递归遍历目录

def traverseDir(dirPath):
    import os
    myStack = []

    myStack.append((dirPath, 0))

    while len(myStack) != 0:
        #出栈
        item = myStack.pop()
        path = item[0]
        num = item[1]
        treeShow = "  " * num
        filesList = os.listdir(path)
        for fileName in filesList:
            absPath = os.path.join(path, fileName)
            if os.path.isdir(absPath):
                # 目录
                print(treeShow+"目录：" + fileName)
                # 压栈
                myStack.append((absPath, num+1))
            else:
                print(treeShow+"文件：" + fileName)




traverseDir(r"C:\Users\xlg\Desktop\file")

队列模拟递归遍历目录（广度遍历）

def traverseDir(dirPath):
    import os
    from collections import deque

    q = deque([])

    #进队
    q.append((dirPath, 0))

    while len(q) != 0:
        item = q.popleft()
        path = item[0]
        num = item[1]
        treeShow = "  " * num
        
        filesList = os.listdir(path)
        for fileName in filesList:
            absPath = os.path.join(path, fileName)
            if os.path.isdir(absPath):
                # 目录
                print(treeShow+"目录：" + fileName)
                # 进队
                q.append((absPath, num+1))
            else:
                print(treeShow+"文件：" + fileName)



traverseDir(r"C:\Users\xlg\Desktop\file")