Python 文件操作

1.文件操作

1.1 创建文件

# open("文件名",读取模式,编码) ， 需要手动关闭文件
fp = open("文件名",mode="a+",encoding="utf-8") 

# with open("文件名",读取模式,编码) ， 自动关闭文件
with open("文件名",mode="a+",encoding="utf-8") as fp:  

1.2 打开模式

w   write 写入模式
    文件不存在则创建文件,存在的话则打开清空内容,并且将文件指针放在文件的开头

r   read  读取模式
    文件不存在则报错! 存在的话则打开文件，并且将文件指针放在文件的开头

a   append 追加模式
    文件不存在则创建文件,存在的话则打开文件,*并且将文件指针放在文件的末尾*

x   xor 异或模式
    文件已存在则报错! 不存在的话则创建文件,将文件指针放在文件的开头

U  表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）
    rU
    r+U

b  bytes模式，表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

t  读二进制文件,根据encoding的编码转换成字符串。

#扩展模式 (配合打开模式的辅助模式,自己单独不能使用)
    +   plus   增强模式(可以让文件具有读写功

组合使用：

rb  # 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+  # 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+  # 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
 
wb  # 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+  # 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+  # 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
 
ab  # 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+  # 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+  # 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

1.3 相关操作

f = open("test.txt",mode="r+",encoding="utf-8")
res = f.read()      # 读取全部文件(里面的参数代表字符个数)
res = f.read(3)     # 读取全部文件(里面的参数代表读取字符个数)
f.readline()   # 读取一行文件内容
f.readlines()  # 将文件中的内容按照换行读取到列表当中

f.write()      # 写入文件，写入到缓冲区，它会定时或定量的写入到硬盘。
f.writelines() # 将内容是字符串的可迭代性数据写入文件中 参数:内容为字符串类型的可迭代数据

res = f.tell()     # 把现在的文件句柄所在的指针打印出来。(返回字节数)
f.flush()    # 强制刷新，将写入缓冲取的数据存入硬盘。
f.seek(0)    # 调整指针的位置(调整到第0位)

print(f.encoding) # 打印文件编码
print(f.fileno())   # 返回文件句柄在内存中的编号
print(f.name)       # 打印文件名字
print(f.isatty())     # 是不是终端设备
print(f.readable())     # 判断文件是否可读
print(f.writable())     # 判断文件是否可写

f.truncate()   # 把要截取的字符串提取出来,然后清空内容将提取的字符串重新写入文件中 (字节)

f.close()      # 关闭文件

1.4 案例

循环读文件

f = open('test.txt', 'r')
for i in f:
    print(i.strip())

读取文件，覆盖原文件

def alter(file,old_str,new_str):
    """
    替换文件中的字符串
    :param file:文件名
    :param old_str:旧字符串
    :param new_str:新字符串
    :return:
　　 不建议使用，文件小可以使用
    """
    file_data = ""
    with open(file, "r", encoding="utf-8") as f:
        for line in f:
            if old_str in line:
                line = line.replace(old_str,new_str)
            file_data += line
    with open(file,"w",encoding="utf-8") as f:
        f.write(file_data)

alter("file1", "09876", "python")

把原文件写到新文件里

# 字符串替换
import os
def alter(file,old_str,new_str):
    """
    将替换的字符串写到一个新的文件中，然后将原文件删除，新文件改为原来文件的名字
    :param file: 文件路径
    :param old_str: 需要替换的字符串
    :param new_str: 替换的字符串
    :return: None
    """
    with open(file, "r", encoding="utf-8") as f1,open("%s.bak" % file, "w", encoding="utf-8") as f2:
        for line in f1:
            if old_str in line:
                line = line.replace(old_str, new_str)
            f2.write(line)
    os.remove(file)
    os.rename("%s.bak" % file, file)

alter("file1", "python", "测试")


# 正则替换
import re,os
def alter(file,old_str,new_str):

    with open(file, "r", encoding="utf-8") as f1,open("%s.bak" % file, "w", encoding="utf-8") as f2:
        for line in f1:
            f2.write(re.sub(old_str,new_str,line))
    os.remove(file)
    os.rename("%s.bak" % file, file)
alter("file1", "admin", "password")

2. ini文件

ini文件，用于存储数据的配置文件。

[mysqld]
datadir=/var/lib/mysql
socket=/var/lib/mysql/mysql.sock
log-bin=py-mysql-bin
character-set-server=utf8
collation-server=utf8_general_ci
log-error=/var/log/mysqld.log
# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

[mysqld_safe]
log-error=/var/log/mariadb/mariadb.log
pid-file=/var/run/mariadb/mariadb.pid

[client]
default-character-set=utf8

文件操作：

import configparser
# 创建对象
conf = configparser.ConfigParser()
# 读取ini文件
conf.read('files/my.ini')

"""
# 获取所有的节点
result = conf.sections()
print(result)
"""

"""
# 获取节点所有的值
result = conf.items("mysqld")
print(result)

# 循环打印
for key, value in conf.items("mysqld"):
    print(key, value)
"""

"""
# 获取某个节点下的键对应的值
result = conf.get("mysqld","character-set-server")
print(result)
"""

"""
# 判断是否有这个节点
result = conf.has_section("mysqld")
print(result)

# 添加节点，添加到内存中
conf.add_section("group")
# 添加节点的键值
conf.set("group","key","value")
# 写入文件中
conf.write(open("files/my.ini",mode="w",encoding="utf-8"))
"""

"""
# 删除节点
conf.remove_section("group")
# 删除节点下的值
conf.remove_option("client","default-character-set")
# 写入文件
conf.write(open("files/my.ini",mode="w",encoding="utf-8"))
"""

3. xml文件

可扩展标记语言，是一种简单的数据存储语言，XML 被设计用来传输和存储数据。

• 存储，可用来存放配置文件，例如：java的配置文件。
• 传输，网络传输时以这种格式存在，例如：早期ajax传输的数据、soap协议等。

3.1 读取文件

读取文件

# 导入模块
from xml.etree import ElementTree as ET

# 打开xml文件
tree = ET.parse('files/aa.xml')

# 获取根标签
root = tree.getroot()
print(root)

读取以字符串形式存在的xml文件

# 导入模块
from xml.etree import ElementTree as ET

content = '''
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2023</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2026</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2026</year>
        <gdppc>13600</gdppc>
        <neighbor direction="W" name="Costa Rica" />
        <neighbor direction="E" name="Colombia" />
    </country>
</data>
'''

# 获取根标签
root = ET.XML(content)
print(root)

3.2 读取节点数据

# 导入模块
from xml.etree import ElementTree as ET



# 打开xml文件
tree = ET.parse('files/aa.xml')

# 获取根标签
root = tree.getroot()

"""
# 循环根标签下的所有标签
for child in root:
    # child.tag ，标签的名字child.tag = country
    # child.attrib，标签的值child.attrib = {"name":"Liechtenstein"}
    for node in child:
        print(node.tag, node.attrib)
"""

# find 寻找第一个标签
res = root.find("country")  # 获取country标签
print(res.tag, res.attrib)
res1 = res.find("year")    # 获取year标签
# text 获取标签内容
print(res1.tag, res1.attrib,res1.text)

# iter 找到所有的标签
for child in root.iter("year"):
    print(child.tag,child.text)

3.3 修改和删除节点

# 导入模块
from xml.etree import ElementTree as ET

content = """
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2023</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2026</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
</data>
"""

# 获取根标签
root = ET.XML(content)

# 获取year标签
v = root.find("country").find("year")
# 修改文本内容，在内存中修改
v.text = "2025"
# 添加属性，在内存中修改
v.set("a","bbbb")
print(v.attrib,v.text)


# 保存到文件
tree = ET.ElementTree(root)
tree.write("files/new.xml",encoding="utf-8")

3.3 删除节点和值

# 导入模块
from xml.etree import ElementTree as ET

content = """
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2023</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2026</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
</data>
"""

# 获取根标签
root = ET.XML(content)

# 删除节点
root.remove(root.find("country"))
# 查找所有的country标签
root.findall("country")
# 保存到文件
tree = ET.ElementTree(root)
tree.write("files/new.xml",encoding="utf-8")

3.4 创建xml文件

方法1：

# 导入模块
from xml.etree import ElementTree as ET

# 创建标签
root = ET.Element("home")
v1 = ET.Element("v1",{"name":"v1"})
v2 = ET.Element("v2",{"name":"v2"})
k1 = ET.Element("k2",{"name":"k1"})
k2 = ET.Element("k2",{"name":"k2"})

# 把v1和v2标签放入home标签里
root.append(v1)
root.append(v2)

# 把k1和k2标签放入v1标签里
v1.append(k1)
v1.append(k2)

# 值写入k1中
k1.text = "<![CDATA[你好呀]]"
tree = ET.ElementTree(root)
# short_empty_elements 是否简写标签 如：<k2 name="k1" />
tree.write('files/aaaa.xml', encoding='utf-8', short_empty_elements=False)

方法2：

from xml.etree import ElementTree as ET

# 创建根节点
root = ET.Element("home")

# 创建标签，并添加值
v1 = root.makeelement('v1', {'name': 'v1'})
v2 = root.makeelement('v2', {"name": 'v2'})
k1 = v1.makeelement('k1', {'name': 'k1'})
k2 = v2.makeelement('k2', {'name': 'k2'})

# 把v1,v2标签添加到根节点中
root.append(v1)
root.append(v2)

# k1,k2标签添加到v1标签中
v1.append(k1)
v1.append(k2)

tree = ET.ElementTree(root)
tree.write('files/bbbb.xml',encoding='utf-8')

方法3：

from xml.etree import ElementTree as ET

# 创建根节点
root = ET.Element("home")

# 创建root的子标签v1 和值
v1 = ET.SubElement(root,"v1",attrib={"name":"v1"})
v2 = ET.SubElement(root,"v2",attrib={"name":"v2"})

# 创建v1的子标签k1 和值
k1 = ET.SubElement(v1,"k1",attrib={"name":"k1"})
# 写入文件
tree = ET.ElementTree(root)
tree.write('files/cccc.xml',encoding='utf-8')

4.excel文件

想要在Python中操作Excel需要按照第三方的模块。

pip install openpyxl

4.1 读取方式

from openpyxl import load_workbook

# 打开excel文件
wb = load_workbook('files/aa.xlsx')

""" 方法一
# 获取所有sheet页
sheet = wb.sheetnames
print(sheet)

# 选择sheet
sheet = wb["Sheet1"]
"""

# 方法二，根据索引获取sheet页
sheet = wb.worksheets[2]

# 获取第一行第一列的单元格值
cell = sheet.cell(1,1)
# 打印值
print(cell.value)

# 循环所有的sheet
"""
for name in wb.sheetnames:
    sheet = wb[name]
    cell = sheet.cell(1, 1)
    print(cell.value)
"""
"""
for sheet in wb.worksheets:
    cell = sheet.cell(1, 1)
    print(cell.value)
"""
"""
for sheet in wb:
    cell = sheet.cell(1, 1)
    print(cell.value)
"""

4.2 sheet页操作

from openpyxl import load_workbook

# 打开excel文件
wb = load_workbook('files/aa.xlsx')

sheet = wb.worksheets[2]

# 获取第一行第一列的单元格值
cell = sheet.cell(1,1)

"""
方法2：获取单元格值
cell = sheet["A1"]
"""

# 打印值
print(cell.value)
# 打印样式
print(cell.style)
# 打印字体
print(cell.font)
# alignment，居中，居左，居右
print(cell.alignment)

"""
# sheet[1] 获取N行所有的单元格
for cell in sheet[1]:
    print(cell.value)

# sheet.rows 获取所有行的数据
for row in sheet.rows:
    # 打印第一列的值
    print(row[0].value)

# sheet.columns 获取所有列的数据
for col in sheet.columns:
    print(col[1].value)

"""

读合并的单元格

from openpyxl import load_workbook

wb = load_workbook("files/p1.xlsx")
sheet = wb.worksheets[2]

# 获取第N行第N列的单元格(位置是从1开始）
c1 = sheet.cell(1, 1)
print(c1)  # <Cell 'Sheet1'.A1>
print(c1.value) # 用户信息

c2 = sheet.cell(1, 2)
print(c2)  # <MergedCell 'Sheet1'.B1> ，合并单元格
print(c2.value) # None

4.3 excel 写操作

• 原文件写

from openpyxl import load_workbook

# 打开excel文件
wb = load_workbook('files/aa.xlsx')
# 获取sheet页
sheet = wb.worksheets[0]
cell = sheet.cell(1,1)
# 修改内容
cell.value = "开始吖"
# 将excel文件保存到新的文件里
wb.save("files/bb.xlsx")

• 新文件写

from openpyxl import workbook

# 创建excel且默认会创建一个sheet（名称为Sheet）
wb = workbook.Workbook()

sheet = wb.worksheets[0] # 或 sheet = wb["Sheet"]

# 找到单元格，并修改单元格的内容
cell = sheet.cell(1, 1)
cell.value = "开始吖"

# 将excel文件保存到a2.xlsx文件中
wb.save("files/a2.xlsx")

• 修改sheet

from openpyxl import workbook

# 创建excel且默认会创建一个sheet（名称为Sheet）
wb = workbook.Workbook()

sheet = wb.worksheets[0]

"""
# 把sheet页修改为"电视剧"
sheet.title = "电视剧"
# 将excel文件保存
wb.save("files/a3.xlsx")
"""

# 创建sheet页，设置sheet页颜色
"""
# create_sheet(sheet页名字,插入的位置)创建sheet页
sheet = wb.create_sheet("电影",1)
# 设置sheet页颜色
sheet.sheet_properties.tabColor = "1072BA"
wb.save("files/a3.xlsx")
"""

# 默认打开的sheet
"""
wb.active = 0
wb.save("files/a3.xlsx")
"""

# 拷贝sheet
"""
new_sheet = wb.copy_worksheet(wb[ "Sheet" ])
new_sheet.title = "音乐"
wb.save("files/a4.xlsx")
"""

# 删除sheet
"""
del wb["Sheet"]
wb.save("files/a5.xlsx")
"""

• excel单元格操作

from openpyxl import load_workbook
from openpyxl.styles import Alignment, Border, Side, Font, PatternFill, GradientFill


wb = load_workbook('files/aa.xlsx')

sheet = wb.worksheets[1]

# 1. 获取某个单元格，修改值
"""
cell = sheet.cell(1, 1)
cell.value = "开始"
wb.save("files/a1.xlsx")
"""

# 2.  获取某个单元格，修改值
"""
sheet["B3"] = "aaaa"
wb.save("files/a1.xlsx")
"""

# 3. 获取某些单元格，修改值
"""
cell_list = sheet["B2":"C3"]
for row in cell_list:
    for cell in row:
        cell.value = "新的值"
wb.save("files/a1.xlsx")
"""

# 4. 对齐方式
"""
cell = sheet.cell(1, 1)

# horizontal，水平方向对齐方式："general", "left", "center", "right", "fill", "justify", "centerContinuous", "distributed"
# vertical，垂直方向对齐方式："top", "center", "bottom", "justify", "distributed"
# text_rotation，旋转角度。
# wrap_text，是否自动换行。
cell.alignment = Alignment(horizontal='center', vertical='distributed', text_rotation=45, wrap_text=True)
wb.save("files/a1.xlsx")
"""

# 5. 边框
# side的style有如下：dashDot','dashDotDot', 'dashed','dotted','double','hair', 'medium', 'mediumDashDot', 'mediumDashDotDot','mediumDashed', 'slantDashDot', 'thick', 'thin'
"""
cell = sheet.cell(9, 2)
cell.border = Border(
    top=Side(style="thin", color="FFB6C1"), 
    bottom=Side(style="dashed", color="FFB6C1"),
    left=Side(style="dashed", color="FFB6C1"),
    right=Side(style="dashed", color="9932CC"),
    diagonal=Side(style="thin", color="483D8B"),  # 对角线
    diagonalUp=True,  # 左下 ~ 右上
    diagonalDown=True  # 左上 ~ 右下
)
wb.save("files/a1.xlsx")
"""


# 6.字体
"""
cell = sheet.cell(5, 1)
cell.font = Font(name="微软雅黑", size=45, color="ff0000", underline="single")
wb.save("files/a1.xlsx")
"""

# 7.背景色
"""
cell = sheet.cell(5, 3)
cell.fill = PatternFill("solid", fgColor="99ccff")
wb.save("files/a1.xlsx")
"""

# 8.渐变背景色
"""
cell = sheet.cell(5, 5)
cell.fill = GradientFill("linear", stop=("FFFFFF", "99ccff", "000000"))
wb.save("files/a1.xlsx")
"""

# 9.宽高（索引从1开始）
"""
sheet.row_dimensions[1].height = 50
sheet.column_dimensions["E"].width = 100
wb.save("files/a1.xlsx")
"""

# 10.合并单元格
"""
# 方式1
sheet.merge_cells("B2:D8")
# 方式2
sheet.merge_cells(start_row=15, start_column=3, end_row=18, end_column=8)
wb.save("files/a1.xlsx")
"""
"""
# 取消合并
sheet.unmerge_cells("B2:D8")
wb.save("files/a1.xlsx")
"""

# 11.写入公式
"""
sheet = wb.worksheets[3]
sheet["D1"] = "合计"
sheet["D2"] = "=B2*C2"
wb.save("files/a1.xlsx")
"""
"""
sheet = wb.worksheets[3]
sheet["D3"] = "=SUM(B3,C3)"
wb.save("files/a1.xlsx")
"""

# 12.删除
"""
# idx，要删除的索引位置
# amount，从索引位置开始要删除的个数（默认为1）
sheet.delete_rows(idx=1, amount=20)
sheet.delete_cols(idx=1, amount=3)
wb.save("files/a1.xlsx")
"""

# 13.插入
"""
sheet.insert_rows(idx=5, amount=10)
sheet.insert_cols(idx=3, amount=2)
wb.save("files/a1.xlsx")
"""

# 14.循环写内容
"""
sheet = wb["Sheet"]
cell_range = sheet['A1:C2']
for row in cell_range:
    for cell in row:
        cell.value = "xx"

for row in sheet.iter_rows(min_row=5, min_col=1, max_col=7, max_row=10):
    for cell in row:
        cell.value = "oo"
wb.save("files/a1.xlsx")
"""

# 15.移动
"""
# 将H2:J10范围的数据，向右移动15个位置、向上移动1个位置
# rows=1, cols=15 ，正数向下，向右，负数向左，向上
sheet.move_range("H2:J10",rows=1, cols=15)
wb.save("files/a1.xlsx")
"""
"""
sheet = wb.worksheets[3]
sheet["D1"] = "合计"
sheet["D2"] = "=B2*C2"
sheet["D3"] = "=SUM(B3,C3)"
# translate=True ，公式会跟着单元格移动
sheet.move_range("B1:D3",cols=10, translate=True) # 自动翻译公式
wb.save("files/a1.xlsx")
"""

# 16.打印区域
"""
sheet.print_area = "A1:D200"
wb.save("files/a1.xlsx")
"""

# 17.打印时，每个页面的固定表头
"""
sheet.print_title_cols = "A:D"
sheet.print_title_rows = "1:3"
wb.save("files/a1.xlsx")
"""

5. 压缩文件

Python内置的shutil模块可以实现对压缩文件的操作。

import shutil

# 1. 压缩文件
"""
# base_name，压缩后的压缩包文件
# format，压缩的格式，例如："zip", "tar", "gztar", "bztar", or "xztar".
# root_dir，要压缩的文件夹路径
"""
# shutil.make_archive(base_name=r'datafile',format='zip',root_dir=r'files')


# 2. 解压文件
"""
# filename，要解压的压缩包文件
# extract_dir，解压的路径
# format，压缩文件格式
"""
# shutil.unpack_archive(filename=r'datafile.zip', extract_dir=r'xxxxxx/xo', format='zip')

6. 文件路径

6.1 转义

windows路径使用的是\，linux路径使用的是/。

特别的，在windows系统中如果有这样的一个路径 D:\nxxx\txxx\x1，程序会报错。因为在路径中存在特殊符 \n（换行符）和\t（制表符），Python解释器无法自动区分。

所以，在windows中编写路径时，一般有两种方式：

• 加转义符，例如："D:\\nxxx\\txxx\\x1"
• 路径前加r，例如：r"D:\\nxxx\\txxx\\x1"

6.2 路径操作

• 自动拼接路径

import os

# __file__ ，当前文件
# os.path.abspath ，获取文件的绝对路径
abs = os.path.abspath(__file__)
print(abs)
# 文件的上一级路径
path = os.path.dirname(os.path.abspath(__file__))
print(path)

# 根据系统拼接路径
file_path = os.path.join(path,"files","a1.txt")
print(file_path)

# 判断路径是否存在
if os.path.exists(file_path):
    f = open(file_path,"r",encoding="utf-8")
    print(f.read())
    f.close()
else:
    print("File not")

import shutil
import os

# 1. 获取当前脚本绝对路径
"""
abs_path = os.path.abspath(__file__)
print(abs_path)
"""

# 2. 获取当前文件的上级目录
"""
base_path = os.path.dirname( os.path.dirname(路径) ）
print(base_path)
"""

# 3. 路径拼接
"""
p1 = os.path.join(base_path, 'xx')
print(p1)

p2 = os.path.join(base_path, 'xx', 'oo', 'a1.png')
print(p2)
"""

# 4. 判断路径是否存在
"""
exists = os.path.exists(p1)
print(exists)
"""

# 5. 创建文件夹
"""
os.makedirs(路径)
"""
"""
path = os.path.join(base_path, 'xx', 'oo', 'uuuu')
if not os.path.exists(path):
    os.makedirs(path)
"""

# 6. 是否是文件夹
"""
file_path = os.path.join(base_path, 'xx', 'oo', 'uuuu.png')
is_dir = os.path.isdir(file_path)
print(is_dir) # False

folder_path = os.path.join(base_path, 'xx', 'oo', 'uuuu')
is_dir = os.path.isdir(folder_path)
print(is_dir) # True

"""

# 7. 删除文件或文件夹
"""
os.remove("文件路径")
"""
"""
path = os.path.join(base_path, 'xx')
shutil.rmtree(path)
"""

# 8. 拷贝文件夹，文件存在会报错
"""
shutil.copytree("files","new_files")
"""


# 9.拷贝文件
"""
shutil.copy("files/aa.txt","new_files/")
shutil.copy("files/aa.txt","new_files/aa1.txt") # 拷贝文件，并改名
"""


# 10.文件或文件夹重命名
"""
shutil.move("new_files/aa1.txt","new_files/aa1111.txt")
shutil.move("new_files","files1")
"""