python文件处理-多种文件

python文件处理

  • 文件属性: 文件名、路径
  • 在 Windows 中，根文件夹名为 D:，也称为 D: 盘。在 OS X 和 Linux 中，根文件夹是 /
  • 文件夹名称和文件名在 Windows 和 OS X 上是不区分大小写的，但在 Linux 上是区分大小写的。
  • Windows上的反斜杠以及OS X和Linux上的正斜杠
    • windows: 待文件名称: acd.txt; 不带:a

相对路径 和 绝对路径:相对路径怎么切换...

  • 当前工作目录: os.getcwd() 获取

  • 更改当前工作目录: os.chdir(path)

  • 绝对路径：总是从根文件夹开始，Window 系统中以盘符（C：、D：）作为根文件夹，而 OS X 或者 Linux 系统中以 / 作为根文件夹

  • 相对路径：指的是文件相对于当前工作目录所在的位置。例如，当前工作目录为 "C:WindowsSystem32"，若文件 demo.txt 就位于这个 System32 文件夹下，则 demo.txt 的相对路径表示为 ".demo.txt"（其中 . 就表示当前所在目录）

  • 处理绝对路径和相对路径:

    • 调用 os.path.abspath(path) 将返回 path 参数的绝对路径的字符串，这是将相对路径转换为绝对路径的简便方法
    • 调用 os.path.isabs(path)，如果参数是一个绝对路径，就返回 True，如果参数是一个相对路径，就返回 False
    • 调用 os.path.relpath(path, start) 将返回从 start 路径到 path 的相对路径的字符串。如果没有提供 start，就使用当前工作目录作为开始路径
    • 调用 os.path.dirname(path) 将返回一个字符串，它包含 path 参数中最后一个斜杠之前的所有内容；调用 os.path.basename(path) 将返回一个字符串，它包含 path 参数中最后一个斜杠之后的所有内容。
    1.os.getcwd()   当前工作目录 
2.os.path.abspath(path) 将path转换为绝对路径
3.os.path.isabs(path)   判断是否绝对路径
4.os.path.relpath(path, start), start到path的相对路径转换字符串。
5.os.path.basename(path)    path对应文件名称
6.os.path.dirname(path)     path对象文件路径
7.os.path.split(path)       同时得到path 目录名称+基本名称
8.os.path.exists(path)      查看文件、文件夹是否存在 
9.os.path.isfile(path)      判断是否是文件
10.os.path.isdir(path)      判断是否是文件夹/路径

python文件操作

  • python常见操作分为:

    • 1.删除、修改权限:作用于文件本身,属于系统级操作；
      文件的系统级操作功能单一，比较容易实现，可以借助 Python 中的专用模块（os、sys 等），并调用模块中的指定函数来实现

import os
os.remove("a.txt")  删除同级目录下的文件 a.txt
    • 2.写入、读取:是文件最常用的操作,作用于文件的内容,属于应用级操作;
      文件的应用级操作可以分为以下 3 步，每一步都需要借助对应的函数实现：
1.打开文件：使用 open() 函数，该函数会返回一个文件对象；  
2.对已打开文件做读/写操作：读取文件内容可使用 read()、readline() 以及 readlines() 函数；向文件中写入内容，可以使用 write() 函数。
3.关闭文件：完成对文件的读/写操作之后，最后需要关闭文件，可以使用 close() 函数。

  • open()操作
    open() 函数用于创建或打开指定文件
    file = open(file_name, mode="r", buffering=-1, encoding=None)

    如果 buffing 参数的值为 0（或者 False），则表示在打开指定文件时不使用缓冲区；如果 buffing 参数值为大于 1 的整数，该整数用于指定缓冲区的大小（单位是字节）；如果 buffing 参数的值为负数，则代表使用默认的缓冲区大小
    • 常见的读写操作：
    with open("", encoding="utf-8", "r") as f_open:
    data = f_open.read()

with open("", "w", encoding="") as f_write:
    f_write.write("help me")
    • 相关参数:两种操作: +代表读写; b:二进制; 追加:a
    r: 以只读方式打开文件; 文件的指针将会放在文件的开头， 这是默认模式; 
rb: 以二进制格式打开一个文件用于 只读, 文件指针放在文件的开头;
r+: 打开一个文件用于读写; 指针放在文件的开头; 
rb+: 以二进制格式打开一个文件用于 读写, 指针放在文件的开头;

w: 打开一个文件只用于 写入; 如果该文件已经存在则将其覆盖。如果该文件不存在，则创建新文件；
wb: 以二进制打开一个文件只用于 写入; 如果该文件已经存在则将其覆盖。如果该文件不存在，则创建新文件；
w+: 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
wb+:以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

a:    打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab:    以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+:    打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+:以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
    • file对象的属性:
    1.file.read([size])   将文件数据作为字符串返回,可选参数size控制读取的字节数；  
2.file.readlines([size])    返回文件中 行内容 的列表,size可选参数；  

3.file.write(str)   将字符串写入文件
4.file.writelines(strings)  将字符串序列写入文件
5.file.close()      关闭文件
6.file.closed       表示文件已经被关闭,否则为False

7.file.mode    文件打开时使用的访问模式 
8.file.name    文件名
9.file.encoding 文件所使用的编码
10.file.softspace   为0,表示在输出最后一行数据后,要加上一个空格符, 1表示不加;

  • read() 函数
    open() 函数，并以可读模式（包括 r、r+、rb、rb+）打开的文件，可以调用 read() 函数逐个字节（或者逐个字符）读取文件中的内容
    如果文件是以文本模式（非二进制模式）打开的，则 read() 函数会逐个字符进行读取；反之，如果文件以二进制模式打开，则 read() 函数会逐个字节进行读取

    read() 函数：逐个字节或者字符读取文件中的内容；
readline() 函数：逐行读取文件中的内容；
readlines() 函数：一次性读取文件中多行内容。
    • read()函数抛出UnicodeDecodeError异常的解决方法
    在使用 read() 函数时，如果 Python 解释器提示UnicodeDecodeError异常，其原因在于，目标文件使用的编码格式和 open() 函数打开该文件时使用的编码格式不匹配。   

举个例子，如果目标文件的编码格式为 GBK 编码，而我们在使用 open() 函数并以文本模式打开该文件时，手动指定 encoding 参数为 UTF-8。这种情况下，由于编码格式不匹配，当我们使用 read() 函数读取目标文件中的数据时，Python 解释器就会提示UnicodeDecodeError异常。

解决方法1:将 open() 函数中的 encoding 参数值修改为和目标文件相同的编码格式   

解决方法2:重新生成目标文件（即将该文件的编码格式改为和 open() 函数中的 encoding 参数相同）  

解决方法3: 先使用二进制模式读取文件，然后调用 bytes 的 decode() 方法，使用目标文件的编码格式，将读取到的字节串转换成认识的字符串 

#以二进制形式打开指定文件，该文件编码格式为 utf-8
f = open("my_file.txt",'rb+')
byt = f.read()
print(byt)
print("
转换后：")
print(byt.decode('utf-8'))
#关闭文件
f.close()

  • readline([size])

    readline() 函数用于读取文件中的一行，包含最后的换行符“
”

  • readlines()

    readlines() 函数用于读取文件中的所有行，它和调用不指定 size 参数的 read() 函数类似，只不过该函数返回是一个字符串列表，其中每个元素为文件中的一行内容

和 readline() 函数一样，readlines() 函数在读取每一行时，会连同行尾的换行符一块读取

[b'Pythonxbdxccxb3xcc
', b'http://c.biancheng.net/python/']

  • file.write() 操作: file.write(string)

    file 表示已经打开的文件对象；string 表示要写入文件的字符串（或字节串，仅适用写入二进制文件中）

w:刷新写;
a:追加写,

  • file.writelines([list[str]]) 函数

    使用 writelines() 函数向文件中写入多行数据时，不会自动给各行添加换行符

  • file.close() 操作;

  • file.tell() 函数:判断文件指针当前所处的位置

  • file.seek(offset) 函数:将文件指针移动至指定位置

    file.seek(offset[, whence])
* file：表示文件对象；
* whence：作为可选参数，用于指定文件指针要放置的位置，该参数的参数值有 3 个选择：0 代表文件头（默认值）、1 代表当前位置、2 代表文件尾   
* offset：表示相对于 whence 位置文件指针的偏移量，正数表示向后偏移，负数表示向前偏移。例如，当whence == 0 &&offset == 3（即 seek(3,0) ），表示文件指针移动至距离文件开头处 3 个字符的位置；当whence == 1 &&offset == 5（即 seek(5,1) ），表示文件指针向后移动，移动至距离当前位置 5 个字符处

  • with ...as...

     with as 语句操作上下文管理器（context manager），它能够帮助我们自动分配并且释放资源。
 with as 操作已经打开的文件对象（本身就是上下文管理器），无论期间是否抛出异常，都能保证 with as 语句执行完毕后自动关闭已经打开的文件

 with 表达式  as target:
    代码块

  • fileinput 模块: 逐行 读取多个文件;

    fileinput 模块，通过该模块中的 input()  函数，我们能同时打开指定的多个文件，还可以逐个读取这些文件中的内容

fileinput.input（files="filename1, filename2, ...", inplace=False, backup='', bufsize=0, mode='r', openhook=None）
函数会返回一个 FileInput 对象，它可以理解为是将多个指定文件合并之后的文件对象
* files：多个文件的路径列表

  • linecache 模块: 读取指定文件中的指定

    linecache.getline()  函数: 读取指定文件中的指定行;
linecache.clearcache()  清空缓存; 
linecache.checkcache()  检查缓存的有效性;

  • fnmatch 模块: 文件名称的匹配,比简单的字符串匹配强大,但是比 正则表达式稍弱;

  • tempfile 模块: 生成临时文件 和 临时目录

  • os.path 模块: 操作字符串路径， 指定文件属性;

    os.path.abspath(path)       返回 path 的绝对路径; 
os.path.basename(path)      返回 path 路径的基本名称；
os.path.commonprefix(list)  返回 list(多个路径)中,所有path 共有的 最长的路径;
os.path.dirname(path)       返回 path 路径中的目录部分; 

os.path.exists(path)        判断 path 对应的路径、文件是否存在; 
os.path.lexists(path)       判断 路径 是否存在; 
os.path.expanduser(path)    将 path 中包含 ~ 、 ~user 转换成 用户目录;
os.path.expandvars(path)    根据环境变量的值替换 path 中包含的 "$name" 和 "${name}"

os.path.getatime(path)      返回 path 所指文件的最近访问时间
os.path.getmtime(path)      返回 path 所指文件的修改时间
os.path.getctime(path)      返回 文件 的创建时间(单位为秒，自 1970 年 1 月 1 日起（又称 Unix 时间））
os.path.getsize(path)       返回 文件 大小, 如果文件不存在就返回错误; 

os.path.isabs(path)	        判断是否为绝对路径。
os.path.isfile(path)	    判断路径是否为文件。
os.path.isdir(path)	        判断路径是否为目录。

os.path.islink(path)	判断路径是否为链接文件（类似 Windows 系统中的快捷方式）。
os.path.ismount(path)	判断路径是否为挂载点。   

os.path.join(path1, path2)  将 目录 和 文件名 合并成一个路径; 
os.path.normcase(path)      转换 path 的大小写 和 斜杠; 
os.path.normpath(path)      规范 path 字符串形式  
os.path.realpath(path)      返回 path 的真实路径    

os.path.samefile(path)      判断 目录 或 文件是否相同; 
os.path.sameopenfile(fp1, fp2)  判断 fp1 和 fp2 是否指向 同一文件; 
os.path.samestat(stat1, stat2)  判断 stat1 和 stat2 是否执行同一个文件; 

os.path.split(path)         把路径 分割成 dirname 或 basename, 返回一个元组; 
os.path.splitdrive(path)	一般用在 windows 下，返回驱动器名和路径组成的元组。
os.path.splitext(path)	    分割路径，返回路径名和文件扩展名的元组。
os.path.splitunc(path)	    把路径分割为加载点与文件。

pickle模块: 实现python对象的持久化存储

pickle 模块可以实现 任意对象和文本之间的相互转换,也可以实现任意对象和二进制之间的相互转化，picke 可以实现 python 对象的存储和恢复。

pickle 模块提供了以下 4 个函数供我们使用：

dumps()：将 Python 中的对象序列化成二进制对象，并返回；
loads()：读取给定的二进制对象数据，并将其转换为 Python 对象；

dump()：将 Python 中的对象序列化成二进制对象，并写入文件；
load()：读取指定的序列化数据文件，并返回对象。

dumps 和 loads 实现基于内存的 Python 对象与二进制互转；  
dump 和 load 实现基于文件的 Python 对象与二进制互转

  • pickle.dumps() 函数:

    dumps(obj, protocol=None, *, fic_import=True)  将 Python 中的对象序列化成二进制对象，并返回
* obj：要转换的 Python 对象；
* protocol：pickle 的转码协议，取值为 0、1、2、3、4，其中 0、1、2 对应 Python 早期的版本，3 和 4 则对应 Python 3.x 版本及之后的版本。未指定情况下，默认为 3

tup1 = ('I love Python', {1,2,3}, None)
p1 = pickle.dumps(tup1)

  • pickle.loads() 函数: 将二进制对象转换成 python 对象。

    loads(data, *, fix_imports=True, encoding='ASCII', errors='strict')
* data 参数表示要转换的二进制对象，其它参数只是为了兼容 Python 2.x 版本而保留的，可以忽略

* 注意，在使用 loads() 函数将二进制对象反序列化成 Python 对象时，会自动识别转码协议，所以不需要将转码协议当作参数传入。并且，当待转换的二进制对象的字节数超过 pickle 的 Python 对象时，多余的字节将被忽略。

  • pickle.dump()函数: 将python对象 转换成 二进制文件:

    dump (obj, file,protocol=None, *, fix mports=True)
* obj：要转换的 Python 对象。 
* file：转换到指定的二进制文件中，要求该文件必须是以"wb"的打开方式进行操作  

import pickle 
tup1 = ("I Love **", {1, 2, 3}, Nonw)
with open ("a.txt", "wb") as f:
    pickle.dump(tup1, f)

  • pickle.load() 函数: 将二进制对象文件 转换成 python 对象；

    load(file, *, fix_imports=True, encoding='ASCII', errors='strict')
* file 参数表示要转换的二进制对象文件（必须以 "rb" 的打开方式操作文件）

import pickle
tup1 = ('I love Python', {1,2,3}, None)

with open ("a.txt", 'wb') as f: #打开文件
    pickle.dump(tup1, f) #用 dump 函数将 Python 对象转成二进制对象文件
with open ("a.txt", "rb") as f:     # 打开文件
    pickle.load(f)      # 将二进制文件对象转成 python 对象;

JSON 模块

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于人阅读和编写

  • json.dumps() 将 python 对象编码成 JSON 字符串

    json.dumps(obj, ensure_ascii=True, ident=None, encoding="utf-8", skipkeys= False, echeck_circular= True, allow_nan=True, cls=None,  seperators=None, default=None, sort_keys= False, **kw)  

import json
data = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]
data2 = json.dumps(data)
print(data2)            # [{"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}]

data2 = json.dumps({'a': 'Runoob', 'b': 7}, sort_keys=True, indent=4, separators=(',', ': '))
print(data2)        # {"a": "Runoob","b": 7}

  • json.loads() 将 已编码的 JSON 字符串 解码为 python 对象;

    json.loads 用于解码 JSON 数据, 该函数返回 python字段 的数据类型

jsonData = '{"a":1,"b":2,"c":3,"d":4,"e":5}';
text = json.loads(jsonData)
print(text)             {u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}

  • json.dump(obj, ensure_ascii=True, indent=None) 将 python内置类型 序列化为 JSON对象后写入 文件

    dump(obj,skipkeys=False, ensure_ascii=True, check_circular=True,
    allow_nan=True, cls=None, indent=None, separators=None,
    default=None, sort_keys=False, **kw)

#  函数作用:       将Python的对象转变成JSON对象
#  skipkeys:       如果为True的话，则只能是字典对象，否则会TypeError错误, 默认False
#  ensure_ascii:   确定是否为ASCII编码
#  check_circular: 循环类型检查，如果为True的话
#  allow_nan:      确定是否为允许的值
#  indent:         会以美观的方式来打印，呈现，实现缩进
#  separators:     对象分隔符，默认为, 
#  encoding:       编码方式,默认为utf-8     
#  sort_keys:      如果是字典对象，选择True的话，会按照键的ASCII码来排序    

data = {
    'nanbei':'haha',
    'a':[1,2,3,4],
    'b':(1,2,3)
    }
with open('json_test.txt','w+') as f:
    json.dump(data,f)

  • json.load() 读取文件中 python形式的 字符串转换为 python 类型

    data = {
    'nanbei':'haha',
    'a':[1,2,3,4],
    'b':(1,2,3)
}
with open('json_test.txt','w+') as f:
    json.dump(data,f)

with open('json_test.txt','r+') as f:
    print(json.load(f))

  • demjson.encode(data) 将pythond 对象编码成 JSON字符串

  • demjson.decode(txt) 将 JOSN对象解码成 python 字段数据类型;

excel 处理: 暂时, xlwt + xlrd 满足

可能是全网最完整的 Python 操作 Excel库总结
python常用包读写excel对比

一、安装

1. pip install xlrd  
2. pip install xlwt 
3. pip install xlutils  
4. pip install xlwings 
5. pip install XlsxWriter  
6. pip install openpyxl  
7. pip install pandas  

xlutils 模块是 xlrd 和 xlwt 之间的桥梁, 最核心的作用是拷贝一份通过 xlrd 读取到内存中的 .xls 对象, 然后通过在拷贝对象上通过 xlwt 修改 .xls 表格的内容。 xlutils 可以将 xlrd 的Book 对象复制转换为 xlwt 的 Workbook 对象。

二、读取excel文件

1. xlwt, xlutils, XlsxWriter 不能读取文件  
2. xlrd 可以读取 .xls 和 .xlsx 文件  
3. xlwings 可以读取 .xls 和 .xlsx 文件   
4. openpyxl 可以读取 .xlsx 文件
5. pandas 可以读取 .xls 和 .xlsx 文件

2.1 获取文件

  • ⭐ 2.1.1 xlrd 读取文件
    xlrd可以读取 .xls, xlsx 文件
    xls = xlrd.open_workbook(xls_path)  
xlsx = xlrd.open_workbook(xlsx_path)
  • 2.1.2 xlwings 读取文件
    xlwings 直接对接的是 apps, 也就是 Excel 的应用程序, 然后才是工作簿 books 和工作表 sheets，xlwings 需要安装有 Excel 应用程序的环境 xlwings 可以读取 .xls 和 .xlsx 文件
    app = xw.App(visible=True, add_book=False) # 程序可见，只打开不新建工作薄
app.display_alerts = False # 警告关闭
app.screen_updating = False # 屏幕更新关闭
# wb = app.books.open(xls_path)
wb = app.books.open(xlsx_path)
wb.save() # 保存文件
wb.close() # 关闭文件
app.quit() # 关闭程序
  • 2.1.3 openpyxl 读取文件
    openpyxl 可以读取 .xlsx 文件
    wb = openpyxl.load_workbook(xlsx_path)  

如果读取 .xls 文件会报错
  • 2.1.4 pandas 读取文件
    pandas 可以读取 .xls 和 .xlsx 文件
    xls = pd.read_excel(xls_path, sheet_name="Sheet1")
xlsx = pd.read_excel(xlsx_path, sheet_name="Sheet1")

获取工作表 2.2

针对上述4个可以读取excle文件的模块,进一步讨论其 获取工作表 sheet 的方式

  • ⭐ 2.2.1 xlrd 获取工作表

    • 通过 sheet 名查找:
      sheet = xlsx.sheet_by_name("Sheet1")
    • 通过索引查找:
      sheet = xlsx.sheet_by_index(0)

  • 2.2.2 xlwings 获取工作表
    xlwings 的工作表分为活动工作表以及指定工作簿下的特定工作表：

    sheet = xw.sheets.active  # 在活动工作簿
sheet = wb.sheets.active  # 在特定工作簿

  • 2.2.3 openpyxl 获取工作表

    • .activate 方法默认获取工作薄的 第一张工作表
    sheet = wb.activate
    • 通过工作表名指定获取工作表
    sheet = wb["Sheet1"]

  • 2.2.4 pandas 获取工作表
    单独获取工作表完全没有 pandas 什么事情，因为读取文件的同时已经且必须指定工作表才能读取:

    xlsx = pd.read_excel(xlsx_path, sheet_name= "Sheet1")

三、创建 Excel 文件

简单总结创建 Excel 文件的情况

  1. xlrd、xlutils 不能创建 Excel 文件
  2. xlwt 只能创建 .xls 文件,不能创建 .xlsx 文件
  3. xlwings 可以创建 .xls 和 .xlsx 文件
  4. XlsxWriter 可以创建 .xlsx 文件
  5. openpyxl 可以创建 .xls 和 .xlsx 文件
  6. pandas 没有创建 Excel 的概念, 但可以存储临时产的 .xls 或 .xlsx 文件
  • ⭐ 3.1 xlwt 创建文件
    xlwt 只能创建 .xls 文件, 不能创建 .xlsx 文件
    xls = xlwt.Workbook(encoding="ascii")

# 创建新的 sheet 表 
worksheet = xls.add_sheet("Sheet1")
  • 3.2 xlwings 创建文件
    xlwings 可以创建 .xls 和 .xlsx 文件, 只需要最后保存时写清楚后缀即可 ；
    wb = app.books.add()

无论是新建还是打开都需要保存工作簿、关闭工作簿、关闭程序，即：
wb.save(path + r'
ew_practice.xlsx') 
wb.close() 
app.quit()
  • 3.3 XlsxWriter 创建文件
    XlsxWriter 可以创建 .xlsx 文件
    xlsx = xlsxwriter.Workbook()
# 添加工作表  
sheet = xlsx.add_worksheet("Sheet1")
  • 3.4 openpyxl 创建文件
    openpyxl可以创建 .xls 和 .xlsx 文件，只需要最后保存时写清楚后缀即可。使用如下命令：
    wb = Workbook()
# 新工作簿中指定即创建工作表
sheet = wb.active
  • 3.5 pandas 创建文件
    pandas 只需要最后转存时写清楚后缀即可。实际上比较抽象，pandas 并不需要一开始先创建一个 Excel 文件，可以围绕数据框做各式操作后用 .to_excel 命令再用 .xls 或者 .xlsx 做文件后缀。如果一定要产生一个空白 Excel 文件可以用如下命令：
    df = pd.DataFrame([])
df.to_excel(r'C:xxx	est1.xlsx')

xlrd 读取 .xlsx 和 xls 文件

  • 1.读取文件
    # xlrd 可以读取 .xls 和 .xlsx 文件
xls = xlrd.open_workbook(xls_path)
xlsx = xlrd.open_workbook(xlsx_path)
  • 2.读取工作表
    # 可以通过 sheet 名查找：
sheet = xlsx.sheet_by_name("Sheet1")

# 也可通过索引查找： 
sheet = xlsx.sheet_by_index(0)
  • 3.获取单元格的值
    xls = xlrd.open_workbook(xls_path)
sheet = xlsx.sheet_by_name("Sheet1")

value = sheet.cell_value(4, 6) # 第5行第7列的单元格
print(value)

rows = table.row_values(4)
cols = table.col_values(6)
for cell in rows:
    print(cell)

xlwt 写入文件，只能 .xls 格式，不能 .xlsx 文件

  • 1.xlwt创建文件
    xlwt 只能创建 .xls 文件，不能创建 .xlsx 文件
xls = xlwt.Workbook(encoding= 'ascii')
# 创建新的sheet表
worksheet = xls.add_sheet("Sheet1")
  • 2.保存文件
    xlwt 只能创建 .xls 文件，不能创建 .xlsx 文件
xls = xlwt.Workbook(encoding= 'ascii')
# 创建新的sheet表
worksheet = xls.add_sheet("Sheet1")

xls.save("new_table.xls")
  • 3.写入数据
    xls = xlrd.open_workbook(xls_path)
sheet = xls.sheet_by_name("Sheet1")
value = sheet.cell_value(4, 6)
print(value)
sheet.write(4, 6, "新内容")

txt 处理

with open ("a.txt" , ...) as f:
data = f.read()/readline()/readlines()
with open("a.txt" , "a+") as f_w:
f_w.write("str")

word 处理: python-docx 包

python-docx包处理word的基本操作

  • 1.安装 python-docx包
  • 2.基本操作语法
    • 2.1打开文档
      docment = Document()
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/zhangtao-0001/p/14793267.html