了解这些操作,Python中99%的文件操作都将变得游刃有余!

开发 后端
处理文件是我们几乎每天都躲不开的任务之一。Python中含有几个用于执行文件操作的内置模块,例如读取文件,移动文件,获取文件属性等。

 [[342531]]

处理文件是我们几乎每天都躲不开的任务之一。Python中含有几个用于执行文件操作的内置模块,例如读取文件,移动文件,获取文件属性等。本文总结了许多值得了解的函数,这些函数可用于进行一些Python中最常见的文件操作,可以极大地提高我们处理文件的效率。

打开&关闭文件

读取或写入文件前,首先要做的就是打开文件,Python的内置函数open可以打开文件并返回文件对象。文件对象的类型取决于打开文件的模式,可以是文本文件对象,也可以是原始二进制文件,或是缓冲二进制文件对象。每个文件对象都有诸如 read()和write()之类的方法。

你能看出以下代码块中存在的问题吗?我们稍后来揭晓答案。

  1. file = open("test_file.txt","w+"
  2. file.read() 
  3. file.write("a new line"

Python文档列出了所有可能的文件模式,其中最常见的模式可见下表。但要注意一个重要规则,即:如果某一文件存在,那么任何与w相关的模式都会截断该文件,并再创建一个新文件。如果你不想覆盖原文件,请谨慎使用此模式,或尽量使用追加模式 a。

上一个代码块中的问题是打开文件后未关闭。在处理文件后关闭文件很重要,因为打开的文件对象可能会出现诸如资源泄漏等不可预测的风险,以下两种方式可以确保正确关闭文件。

1.使用 close()

第一种方法是显式使用close()。但较好的做法是将该代码放在最后,因为这样的话就可以确保在任何情况下都能关闭该文件,而且会使代码更加清晰。但开发人员也应负起责任,记得关闭文件。

  1. try: 
  2.     file =open("test_file.txt","w+"
  3.     file.write("a new line"
  4. exception Exception as e: 
  5.     logging.exception(e) 
  6. finally: 
  7.     file.close() 

2.使用上下文管理器,with open(...) as f

第二种方法是使用上下文管理器。若你对此不太熟悉,还请查阅Dan Bader用Python编写的上下文管理器和“ with”语句。用withopen() as f实现了使用__enter__ 和 __exit__ 方法来打开和关闭文件。此外,它将try / finally语句封装在上下文管理器中,这样我们就不会忘记关闭文件啦。

  1. with open("test_file","w+"as file: 
  2.     file.write("a new line"

两种方法哪个更优?这要看你使用的场景。以下示例实现了将50000条记录写入文件的3种不同方式。从输出中可见,use_context_manager_2()函数与其他函数相比性能极低。这是因为with语句在一个单独函数中,基本上会为每条记录打开和关闭文件,这种繁琐的I / O操作会极大地影响性能。

  1. def_write_to_file(file, line): 
  2.                          withopen(file, "a"as f: 
  3.                              f.write(line) 
  4.              def_valid_records(): 
  5.                          for i inrange(100000): 
  6.                              if i %2==0: 
  7.                                  yield i 
  8.              defuse_context_manager_2(file): 
  9.                          for line in_valid_records(): 
  10.                              _write_to_file(file, str(line)) 
  11.              defuse_context_manager_1(file): 
  12.                          withopen(file, "a"as f: 
  13.                              for line in_valid_records(): 
  14.                                  f.write(str(line)) 
  15.              defuse_close_method(file): 
  16.                          f =open(file, "a"
  17.                          for line in_valid_records(): 
  18.                              f.write(str(line)) 
  19.                          f.close() 
  20.                            use_close_method("test.txt"
  21.                      use_context_manager_1("test.txt"
  22.                      use_context_manager_2("test.txt"
  23.              # Finished use_close_method  in 0.0253 secs 
  24.                      # Finished  use_context_manager_1 in 0.0231 secs 
  25.                      # Finished use_context_manager_2  in 4.6302 secs 

读写文件

文件打开后,开始读取或写入文件。文件对象提供了三种读取文件的方法,分别是 read()、readline() 和readlines()。

  • 默认情况下,read(size=-1)返回文件的全部内容。但若文件大于内存,则可选参数 size 能帮助限制返回的字符(文本模式)或字节(二进制模式)的大小。
  • readline(size=-1) 返回整行,最后包括字符 n。如果 size 大于0,它将从该行返回最大字符数。
  • readlines(hint=-1) 返回列表中文件的所有行。若返回的字符数超过了可选参数hint,则将不返回任何行。

在以上三种方法中,由于read() 和readlines()在默认情况下以字符串或列表形式返回完整的文件,所以这两种方法的内存效率较低。一种更有效的内存迭代方式是使用readline()并使其停止读取,直到返回空字符串。空字符串“”表示指针到达文件末尾。

  1. withopen( test.txt ,  r ) as reader: 
  2.                      line = reader.readline() 
  3.                      while line !=""
  4.                          line = reader.readline() 
  5.                          print(line) 

以节省内存的方式读取文件

编写方式有两种:write()和writelines()。顾名思义,write()能编写一个字符串,而writelines()可编写一个字符串列表。开发人员须在末尾添加 n。

  1. withopen("test.txt""w+"as f: 
  2.                      f.write("hi"
  3.                      f.writelines(["this is aline 
  4. ", "this is another line"]) 
  5.                        # >>>cat test.txt 
  6.                  # hi 
  7.                  # this is a line 
  8.                  # this is anotherline 

在文件中写入行

若要将文本写入特殊的文件类型(例如JSON或csv),则应在文件对象顶部使用Python内置模块json或csv。

  1. import csv 
  2.       import json 
  3.              withopen("cities.csv""w+"as file: 
  4.          writer = csv.DictWriter(file, fieldnames=["city""country"]) 
  5.          writer.writeheader() 
  6.          writer.writerow({"city""Amsterdam""country""Netherlands"}) 
  7.          writer.writerows( 
  8.              [ 
  9.                  {"city""Berlin""country""Germany"}, 
  10.                  {"city""Shanghai""country""China"}, 
  11.          ) 
  12.              # >>> cat cities.csv 
  13.       # city,country 
  14.       # Amsterdam,Netherlands 
  15.       # Berlin,Germany 
  16.       # Shanghai,China 
  17.              withopen("cities.json""w+"as file: 
  18.          json.dump({"city""Amsterdam""country""Netherlands"}, file) 
  19.              # >>>cat cities.json 
  20.       # { "city":"Amsterdam""country""Netherlands" } 

在文件内移动指针

当打开文件时,会得到一个指向特定位置的文件处理程序。在r和w模式下,处理程序指向文件的开头。在a模式下,处理程序指向文件的末尾。

tell() 和 seek()

当读取文件时,若没有移动指针,那么指针将自己移动到下一个开始读取的位置。以下2种方法可以做到这一点:tell()和seek()。

tell()以文件开头的字节数/字符数的形式返回指针的当前位置。seek(offset,whence = 0)将处理程序移至远离wherece的offset字符处。wherece可以是:

  • 0: 从文件开头开始
  • 1:从当前位置开始
  • 2:从文件末尾开始

在文本模式下,wherece仅应为0,offset应≥0。

  1. withopen("text.txt""w+"as f: 
  2.                      f.write("0123456789abcdef"
  3.                      f.seek(9) 
  4.                      print(f.tell()) # 9 (pointermoves to 9, next read starts from 9) 
  5.                      print(f.read()) # 9abcdef 

tell()和seek()

了解文件状态

操作系统中的文件系统具有许多有关文件的实用信息,例如:文件的大小,创建和修改的时间。要在Python中获取此信息,可以使用os或pathlib模块。实际上,os和pathlib之间有很多共同之处。但后者更面向对象。

os

使用os.stat(“ test.txt”)可以获取文件完整状态。它能返回具有许多统计信息的结果对象,例如st_size(文件大小,以字节为单位),st_atime(最新访问的时戳),st_mtime(最新修改的时戳)等。

  1. print(os.stat("text.txt")) 
  2. >>> os.stat_result(st_mode=33188, st_ino=8618932538,st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=16,st_atime=1597527409, st_mtime=1597527409, st_ctime=1597527409) 

单独使用os.path可获取统计信息。

  1. os.path.getatime() 
  2. os.path.getctime() 
  3. os.path.getmtime() 
  4. os.path.getsize() 

Pathlib

使用pathlib.Path("text.txt").stat()也可获取文件完整状态。它能返回与os.stat()相同的对象。

  1. print(pathlib.Path("text.txt").stat()) 
  2. >>>os.stat_result(st_mode=33188, st_ino=8618932538, st_dev=16777220, st_nlink=1,st_uid=501, st_gid=20, st_size=16, st_atime=1597528703, st_mtime=1597528703,st_ctime=1597528703) 

下文将在诸多方面比较os和pathlib的异同。

复制,移动和删除文件

Python有许多处理文件移动的内置模块。你在信任Google返回的第一个答案之前,应该明白:模块选择不同,性能也会不同。有些模块会阻塞线程,直到文件移动完成;而其他模块则可能异步执行。

shutil

shutil是用于移动、复制和删除文件(夹)的最著名的模块。它有3种仅供复制文件的方法:copy(),copy2()和copyfile()。

copy() v.s. copy2():copy2()与copy()非常相似。但不同之处在于前者还能复制文件的元数据,例如最近的访问时间和修改时间等。不过由于Python文档操作系统的限制,即使copy2()也无法复制所有元数据。

  1. shutil.copy("1.csv""copy.csv"
  2.                      shutil.copy2("1.csv""copy2.csv"
  3.              print(pathlib.Path("1.csv").stat()) 
  4.                      print(pathlib.Path("copy.csv").stat()) 
  5.                      print(pathlib.Path("copy2.csv").stat()) 
  6.                      # 1.csv 
  7.                      # os.stat_result(st_mode=33152, st_ino=8618884732,st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=11,st_atime=1597570395, st_mtime=1597259421, st_ctime=1597570360) 
  8.              # copy.csv 
  9.                      # os.stat_result(st_mode=33152, st_ino=8618983930,st_dev=16777220, st_nlink=1, st_uid=501, st_gid=20, st_size=11,st_atime=1597570387, st_mtime=1597570395, st_ctime=1597570395) 
  10.              #copy2.csv 
  11.                      # os.stat_result(st_mode=33152, st_ino=8618983989, st_dev=16777220,st_nlink=1, st_uid=501, st_gid=20, st_size=11, st_atime=1597570395,st_mtime=1597259421, st_ctime=1597570395) 

copy() v.s. copy2()

copy() v.s. copyfile():copy()能将新文件的权限设置为与原文件相同,但是copyfile()不会复制其权限模式。其次,copy()的目标可以是目录。如果存在同名文件,则将覆盖原文件或创建新文件。但是,copyfile()的目标必须是目标文件名。

  1. shutil.copy("1.csv""copy.csv"
  2.                      shutil.copyfile("1.csv""copyfile.csv"
  3.              print(pathlib.Path("1.csv").stat()) 
  4.                      print(pathlib.Path("copy.csv").stat()) 
  5.                      print(pathlib.Path("copyfile.csv").stat()) 
  6.              # 1.csv 
  7.                      #os.stat_result(st_mode=33152, st_ino=8618884732, st_dev=16777220, st_nlink=1,st_uid=501, st_gid=20, st_size=11, st_atime=1597570395, st_mtime=1597259421,st_ctime=1597570360) 
  8.              # copy.csv 
  9.                      #os.stat_result(st_mode=33152, st_ino=8618983930, st_dev=16777220, st_nlink=1,st_uid=501, st_gid=20, st_size=11, st_atime=1597570387, st_mtime=1597570395,st_ctime=1597570395) 
  10.              # copyfile.csv 
  11.                      # permission(st_mode) is changed 
  12.                      #os.stat_result(st_mode=33188, st_ino=8618984694, st_dev=16777220, st_nlink=1,st_uid=501, st_gid=20, st_size=11, st_atime=1597570387, st_mtime=1597570395,st_ctime=1597570395) 
  13.              shutil.copyfile("1.csv""./source"
  14.                      #IsADirectoryError: [Errno 21] Is a directory:  ./source  

copy() v.s. copyfile()

os

os 模块内含system()函数,可在subshell中执行命令。你需要将该命令作为参数传递给system(),这与在操作系统上执行命令效果相同。为了移动和删除文件,还可以在os模块中使用专用功能。

  1. # copy 
  2.     os.system("cp 1.csvcopy.csv"
  3.              # rename/move 
  4.     os.system("mv 1.csvmove.csv"
  5.     os.rename("1.csv""move.csv"
  6.              # delete 
  7.     os.system("rmmove.csv"

异步复制/移动文件

到目前为止,解决方案始终是同步执行的,这意味着如果文件过大,需要更多时间移动,那么程序可能会终止运行。如果要异步执行程序,则可以使用threading,multiprocessing或subprocess模块,这三个模块能使文件操作在单独的线程或进程中运行。

  1. import threading 
  2.          import subprocess 
  3.          import multiprocessing 
  4.              src ="1.csv" 
  5.          dst ="dst_thread.csv" 
  6.              thread = threading.Thread(target=shutil.copy,args=[src, dst]) 
  7.          thread.start() 
  8.          thread.join() 
  9.              dst ="dst_multiprocessing.csv" 
  10.          process = multiprocessing.Process(target=shutil.copy,args=[src, dst]) 
  11.          process.start() 
  12.          process.join() 
  13.              cmd ="cp 1.csv dst_subprocess.csv" 
  14.          status = subprocess.call(cmd, shell=True

异步执行文件操作

搜索文件

复制和移动文件后,你可能需要搜索与特定模式匹配的文件名,Python提供了许多内置函数可以选择。

Glob

glob模块根据Unix shell使用的规则查找与指定模式匹配的所有路径名,它支持使用通配符。

glob.glob(“ *。csv”)搜索当前目录中所有具有csv扩展名的文件。使用glob模块,还可以在子目录中搜索文件。

  1. >>>import glob 
  2.       >>> glob.glob("*.csv"
  3.       [ 1.csv ,  2.csv ] 
  4.       >>> glob.glob("**/*.csv",recursive=True
  5.       [ 1.csv ,  2.csv ,  source/3.csv ] 

os

os模块功能十分强大,它基本上可以执行所有文件操作。我们可以简单地使用os.listdir()列出目录中的所有文件,并使用file.endswith()和file.startswith()来检测模式,还可使用os.walk()来遍历目录。

  1. import os 
  2.              for file in os.listdir("."): 
  3.           if file.endswith(".csv"): 
  4.              print(file) 
  5.          for root, dirs, files in os.walk("."): 
  6.           for file in files: 
  7.              if file.endswith(".csv"): 
  8.                  print(file) 

搜索文件名——os

pathlib

pathlib 的功能与glob模块类似。它也可以递归搜索文件名。与上文基于os的解决方案相比,pathlib代码更少,并且提供了更多面向对象的解决方案。

  1. from pathlib importPath 
  2.              p =Path("."
  3.        for name in p.glob("**/*.csv"): # recursive 
  4.           print(name

搜索文件名——pathlib

管理文件路径

管理文件路径是另一项常见的执行任务。它可以获取文件的相对路径和绝对路径,也可以连接多个路径并找到父目录等。

相对路径和绝对路径

os和pathlib都能获取文件或目录的相对路径和绝对路径。

  1. import os 
  2.       import pathlib 
  3.              print(os.path.abspath("1.txt"))  # absolute 
  4.       print(os.path.relpath("1.txt"))  # relative 
  5.              print(pathlib.Path("1.txt").absolute())  # absolute 
  6.       print(pathlib.Path("1.txt"))  # relative 

文件的相对和绝对路径

联接路径

这是我们可以独立于环境连接os和pathlib中的路径的方式。pathlib使用斜杠创建子路径。

  1. import os 
  2.       import pathlib 
  3.              print(os.path.join("/home""file.txt")) 
  4.       print(pathlib.Path("/home") /"file.txt"

链接文件路径

获取父目录

dirname()是在os中获取父目录的函数,而在pathlib中,只需使用Path().parent函数,就能获取父文件夹。

  1. import os 
  2.       import pathlib 
  3.              # relative path 
  4.       print(os.path.dirname("source/2.csv")) 
  5.       # source 
  6.       print(pathlib.Path("source/2.csv").parent) 
  7.       # source 
  8.              # absolute path 
  9.       print(pathlib.Path("source/2.csv").resolve().parent) 
  10.       # /Users/<...>/project/source 
  11.       print(os.path.dirname(os.path.abspath("source/2.csv"))) 
  12.       # /Users/<...>/project/source 

获取父文件夹

最后简单介绍一下os和pathlib。如Python文档所述,pathlib是比os更面向对象的解决方案。它将每个文件路径表示为适当的对象,而不是字符串。这对于开发人员来讲非常便利:可以直接访问对象,简化了连接多个路径的过程,而且能使在不同操作系统上的操作变得更加一致。

Get这些操作,让处理文件的效率up up up!

本文转载自微信公众号「读芯术」,可以通过以下二维码关注。转载本文请联系读芯术公众号。

 

责任编辑:武晓燕 来源: 读芯术
相关推荐

2020-09-18 11:20:28

Python文件代码

2020-08-22 11:13:36

Python文件操作函数

2016-06-15 13:05:09

WhatsUp Gol

2009-08-24 15:06:58

Mocha BSM项目运维管理摩卡软件

2014-06-30 12:35:25

2020-11-05 08:56:19

Python

2014-03-06 09:46:04

增强现实可穿戴设备

2011-05-30 19:59:42

云计算工商管理云服务浪潮云海战略

2018-03-16 10:36:56

SSD固态硬盘闪存

2023-12-05 08:47:30

Pandas数据处理

2022-05-17 08:40:20

PythonWiFi密码代码

2024-02-19 07:35:17

ProtobufNetty序列化

2009-06-25 11:18:27

siteview EC网管软件游龙科技

2024-10-09 20:42:26

match字符串函数

2023-08-18 10:48:38

平台工程开发

2022-11-10 09:00:41

2023-11-30 16:05:17

2010-03-23 16:30:47

Python文件复制

2019-05-20 16:30:36

PythonMySQL存储

2012-11-23 16:46:12

LinuxVim
点赞
收藏

51CTO技术栈公众号