精华内容
下载资源
问答
  • Python读写文件1.open使用open打开文件后一定要记得调用文件对象close()方法。比如可以用try/finally语句来确保最后能关闭文件。file_object = open('thefile.txt')try:all_the_text = file_object.read( )finally...

    Python读写文件

    1.open

    使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。

    file_object = open('thefile.txt')

    try:

    all_the_text = file_object.read( )

    finally:

    file_object.close( )

    注:不能把open语句放在try块里,因为当打开文件出现异常时,文件对象file_object无法执行close()方法。

    2.读文件

    读文本文件

    input = open('data', 'r')

    #第二个参数默认为r

    input = open('data')

    读二进制文件

    input = open('data', 'rb')

    读取所有内容

    file_object = open('thefile.txt')

    try:

    all_the_text = file_object.read( )

    finally:

    file_object.close( )

    读固定字节

    file_object = open('abinfile', 'rb')

    try:

    while True:

    chunk = file_object.read(100)

    if not chunk:

    break

    do_something_with(chunk)

    finally:

    file_object.close( )

    读每行

    list_of_all_the_lines = file_object.readlines( )

    如果文件是文本文件,还可以直接遍历文件对象获取每行:

    for line in file_object:

    process line

    3.写文件

    写文本文件

    output = open('data', 'w')

    写二进制文件

    output = open('data', 'wb')

    追加写文件

    output = open('data', 'w+')

    写数据

    file_object = open('thefile.txt', 'w')

    file_object.write(all_the_text)

    file_object.close( )

    写入多行

    file_object.writelines(list_of_text_strings)

    注意,调用writelines写入多行在性能上会比使用write一次性写入要高。

    在处理日志文件的时候,常常会遇到这样的情况:日志文件巨大,不可能一次性把整个文件读入到内存中进行处理,例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件,我们可能希望每次只处理其中 200MB 的内容。

    在 Python 中,内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例:

    file = open('test.log', 'r')sizehint = 209715200   # 200Mposition = 0lines = file.readlines(sizehint)while not file.tell() - position < 0:       position = file.tell()       lines = file.readlines(sizehint)

    每次调用 readlines(sizehint) 函数,会返回大约 200MB 的数据,而且所返回的必然都是完整的行数据,大多数情况下,返回的数据的字节数会稍微比 sizehint 指定的值大一点(除最后一次调用 readlines(sizehint) 函数的时候)。通常情况下,Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。

    file在python是一个特殊的类型,它用于在python程序中对外部的文件进行操作。在python中一切都是对象,file也不例外,file有file的方法和属性。下面先来看如何创建一个file对象:

    file(name[, mode[, buffering]])

    file()函数用于创建一个file对象,它有一个别名叫open(),可能更形象一些,它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。

    mode 是打开的模式,可选的值为r w a U,分别代表读(默认) 写 添加支持各种换行符的模式。用w或a模式打开文件的话,如果文件不存在,那么就自动创建。此外,用w模式打开一个已经存在的文件时,原有文件的内容会被清 空,因为一开始文件的操作的标记是在文件的开头的,这时候进行写操作,无疑会把原有的内容给抹掉。由于历史的原因,换行符在不同的系统中有不同模式,比如 在 unix中是一个\n,而在windows中是‘\r\n’,用U模式打开文件,就是支持所有的换行模式,也就说‘\r’ '\n' '\r\n'都可表示换行,会有一个tuple用来存贮这个文件中用到过的换行符。不过,虽说换行有多种模式,读到python中统一用\n代替。在模式 字符的后面,还可以加上+ b t这两种标识,分别表示可以对文件同时进行读写操作和用二进制模式、文本模式(默认)打开文件。

    buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小,应该是以字节为单位的。

    file对象有自己的属性和方法。先来看看file的属性。

    closed #标记文件是否已经关闭,由close()改写

    encoding #文件编码

    mode #打开模式

    name #文件名

    newlines #文件中用到的换行模式,是一个tuple

    softspace #boolean型,一般为0,据说用于print

    file的读写方法:

    F.read([size]) #size为读取的长度,以byte为单位

    F.readline([size])

    #读一行,如果定义了size,有可能返回的只是一行的一部分

    F.readlines([size])

    #把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。

    F.write(str)

    #把str写到文件中,write()并不会在str后加上一个换行符

    F.writelines(seq)

    #把seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西。

    file的其他方法:

    F.close()

    #关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError

    F.flush()

    #把缓冲区的内容写入硬盘

    F.fileno()

    #返回一个长整型的”文件标签“

    F.isatty()

    #文件是否是一个终端设备文件(unix系统中的)

    F.tell()

    #返回文件操作标记的当前位置,以文件的开头为原点

    F.next()

    #返回下一行,并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时,就是调用next()函数来实现遍历的。

    F.seek(offset[,whence])

    # 将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定 了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每 次进行写操作时,文件操作标记会自动返回到文件末尾。

    F.truncate([size])

    #把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

    #! /usr/bin/pythonimportos,systry:

    fsock=open("D:/SVNtest/test.py","r")exceptIOError:print"The file don't exist, Please double check!"exit()print'The file mode is',fsock.modeprint'The file name is',fsock.name

    P=fsock.tell()print'the postion is %d'%(P)

    fsock.close()#Read filefsock=open("D:/SVNtest/test.py","r")

    AllLines=fsock.readlines()#Method 1forEachLineinfsock:printEachLine#Method 2print'Star'+'='*30forEachLineinAllLines:printEachLineprint'End'+'='*30fsock.close()#write this filefsock=open("D:/SVNtest/test.py","a")

    fsock.write("""#Line 1 Just for test purpose

    #Line 2 Just for test purpose

    #Line 3 Just for test purpose""")

    fsock.close()#check the file statusS1=fsock.closedifTrue==S1:print'the file is closed'else:print'The file donot close'

    Work for fun,Live  for love!

    展开全文
  • 在本教程中,您将学习:什么组成了一个文件,为什么它在python中很重要用Python读写文件的基础知识读写文件的一些基本场景本教程主要针对初学者到中级的 Pythonistas,但这里有一些提示,更高级...

    用Python读写文件(指南)

    [TOC]

    使用Python最常见的任务之一是读取和写入文件。无论是写入简单的文本文件,读取复杂的服务器日志,甚至是分析原始字节数据,所有这些情况都需要读取或写入文件。

    在本教程中,您将学习:

    什么组成了一个文件,为什么它在python中很重要

    用Python读写文件的基础知识

    读写文件的一些基本场景

    本教程主要针对初学者到中级的 Pythonistas,但这里有一些提示,更高级的程序员可能也会从中受益。

    什么是文件?

    在讨论如何使用Python中的文件之前,了解文件的具体内容以及现代操作系统如何处理它们是很重要的。

    从本质上讲,文件是用于存储数据的连续字节集。这些数据以特定格式组织,可以是任何像文本文件一样简单的数据,也可以像程序可执行文件一样复杂。最后,这些字节文件被翻译成二进制文件1,0以便计算机更容易处理。

    大多数现代文件系统上的文件由三个主要部分组成:

    标题(Header):有关文件内容的元数据(文件名,大小,类型等)

    数据(Data):由创建者或编辑者编写的文件内容

    文件结束符(EOF):表示文件结尾的特殊字符

    FileFormat.02335d06829d.png

    数据表示的内容取决于所使用的格式规范,通常由扩展名表示。例如,具有.gif扩展名的文件最可能符合GIF规范。有数百个(甚至上千个)文件扩展名。对于本教程,您将只处理.txt或.csv文件扩展名。

    文件路径

    在操作系统上访问文件时,需要文件路径。文件路径是表示文件位置的字符串。它分为三个主要部分:

    文件夹路径:文件系统上的文件夹位置,后续文件夹由正斜杠/(Unix)或反斜杠\(Windows)分隔

    文件名:文件的实际名称

    扩展名:文件路径的末尾(句号(.)后的内容),用于表示文件类型

    这是一个简单的例子。假设您有一个位于文件结构中的文件,如下所示:

    /

    ├── path/

    | │

    │ ├── to/

    │ │ └── cats.gif

    │ │

    │ └── dog_breeds.txt

    |

    └── animals.csv

    假设您要访问cats.gif文件,并且您当前的位置位于文件夹path中。要访问该文件,您需要浏览该path文件夹,然后查看to文件夹,最后到达cats.gif文件。文件夹路径是path/to/。文件名是cats。文件扩展名是.gif。所以完整的道路是path/to/cats.gif。

    现在假设您当前的位置或当前工作目录(cwd)位于我们的示例文件夹结构的to文件夹中。可以通过文件名和扩展名cats.gif简单地引用文件,而不用引用完整路径path/to/cats.gif。

    /

    ├── path/

    | │

    | ├── to/ ← 你的当前工作目录 (cwd)在这儿

    | │ └── cats.gif ← 访问这个文件

    | │

    | └── dog_breeds.txt

    |

    └── animals.csv

    但如果要访问dog_breeds.txt呢?如果不使用完整路径,您将如何访问?您可以使用特殊字符double-dot(..)来移动到上一个目录。这意味着../dog_breeds.txt会从文件夹to引用到dog_breeds.txt:

    /

    ├── path/ ← 引用该父目录

    | │

    | ├── to/ ← 当前工作目录 (cwd)

    | │ └── cats.gif

    | │

    | └── dog_breeds.txt ← 访问该文件

    |

    └── animals.csv

    double-dot(..)可以链接在一起以遍历当前目录上的多个目录。例如,要从to文件夹访问animals.csv,您将使用../../animals.csv。

    Line Endings

    处理文件数据时经常遇到的一个问题是新行或行结尾的表示。行结尾起源于莫尔斯电码时代,那时一个特定的符号被用来传达传输的结束或一条线的末端。

    后来,国际标准化组织(ISO)和美国标准协会(ASA)对电传打字机进行了标准化。ASA标准规定行尾应使用回车(序列CR或\r)和换行(LF或\n)字符(CR+LF或\r\n)。然而,ISO标准允许CR+LF字符或仅LF字符.

    Windows使用CR+LF字符表示新行,而Unix和较新的Mac版本仅使用LF字符。当您在不同于文件源的操作系统上处理文件时,这可能会导致一些复杂情况。以下是一个简单的例子。假设我们检查在Windows系统上创建的文件dog_breeds.txt:

    哈巴狗\r\n

    杰克罗素梗犬\r\n

    英国史宾格犬\r\n

    德国牧羊犬\r\n

    斯塔福郡斗牛梗\r\n

    骑士国王查尔斯猎犬\r\n

    金毛猎犬\r\n

    西部高地白梗\r\n

    拳击手\r\n

    边境猎犬\r\n

    同样的输出将在Unix设备上以不同方式解释:

    哈巴狗\r

    \n

    杰克罗素梗犬\r

    \n

    英国史宾格犬\r

    \n

    德国牧羊犬\r

    \n

    斯塔福郡斗牛梗\r

    \n

    骑士国王查尔斯猎犬\r

    \n

    金毛猎犬\r

    \n

    西部高地白梗\r

    \n

    拳击手\r

    \n

    边境猎犬\r

    \n

    这会使每一行的迭代都有问题,您可能需要考虑这样的情况。

    字符编码

    您可能面临的另一个常见问题是字节数据的编码。编码是从字节数据到人类可读字符的转换。这通常通过指定表示字符的数值来完成。两种最常见的编码是ASCII和UNICODE格式。ASCII只能存储128个字符,而Unicode最多可包含1,114,112个字符。

    ASCII实际上是Unicode(UTF-8)的子集,这意味着ASCII和Unicode共享相同的数字到字符值。重要是要注意,使用不正确的字符编码解析文件可能会导致字符失败或误传。例如,如果文件是使用UTF-8编码创建的,并且您尝试使用ASCII编码对其进行解析,则如果存在超出128个值的字符,则会引发错误。

    在Python中打开和关闭文件

    当您想使用文件时,首先要做的就是打开它。这是通过调用open()内置函数完成的。open()有一个必需的参数,就是文件的路径。open()有一个返回,就是文件对象:

    file = open('dog_breeds.txt')

    打开文件后,接下来要学习的是如何关闭它。

    :exclamation: 警告:

    您应始终确保正确关闭打开的文件。

    重要的是要记住,关闭文件是您的责任。在大多数情况下,在应用程序或脚本终止时,文件最终将被关闭。然而,并不能保证任何时候都会发生这种情况。这可能导致不必要的行为,包括资源泄漏。确保您的代码以明确定义的方式运行并减少任何不需要的行为, 这也是Python(Pythonic)中的最佳实践。

    当您操作文件时,有两种方法可以确保文件正确关闭,即使遇到错误也是如此。关闭文件的第一种方法是使用try-finally块:

    reader = open('dog_breeds.txt')

    try:

    # 在这儿做进一步的文件处理

    finally:

    reader.close()

    关闭文件的第二种方法是使用如下的with语句:

    with open('dog_breeds.txt') as reader:

    # 在这儿做进一步的文件处理

    WITH语句在离开WITH块后自动负责关闭文件,即使在出现错误的情况下也是如此。我强烈建议您尽可能多地使用WITH语句,因为它允许使用更干净的代码,并使您更容易处理任何意外错误。

    最有可能的是,你也想要使用第二个位置参数mode。此参数是一个字符串,其中包含多个字符以表示您要如何打开文件。默认值和最常见的是'r',表示以只读模式将文件作为文本文件打开:

    with open('dog_breeds.txt', 'r') as reader:

    # 在这儿做进一步的文件处理

    其他模式选项参见: 在线完整记录,但最常用的选项如下:

    字符

    含义

    'r'

    只读模式打开(默认)

    'w'

    写模式打开,首先会截断(覆盖)文件

    'rb' 或 'wb'

    以二进制模式打开(使用字节数据读/写)

    让我们回过头来谈谈文件对象。文件对象是:

    “将面向文件的API(使用read()或write()等方法)暴露给底层资源的对象。”(定义来源)

    有三种不同类别的文件对象:

    文本文件

    缓冲的二进制文件

    原始二进制文件

    这些文件类型中的每一种都在io模块中定义。这里简要介绍下如何排列。

    文本文件类型

    文本文件是最常见的文件。以下是一些如何打开这些文件的示例:

    open('abc.txt')

    open('abc.txt', 'r')

    open('abc.txt', 'w')

    使用这些类型的文件,open()将返回一个TextIOWrapper文件对象:

    >>> file = open('dog_breeds.txt')

    >>> type(file)

    这是open()返回的默认文件对象。

    缓冲二进制文件类型

    缓冲二进制文件类型用于读取和写入二进制文件。以下是一些如何打开这些文件的示例:

    open('abc.txt', 'rb')

    open('abc.txt', 'wb')

    使用这些类型的文件,open()将返回一个BufferedReader或BufferedWriter文件对象:

    >>> file = open('dog_breeds.txt', 'rb')

    >>> type(file)

    >>> file = open('dog_breeds.txt', 'wb')

    >>> type(file)

    原始二进制文件类型

    原始文件类型是:

    “通常用作二进制和文本流的低级构建块。”(定义来源)

    因此通常不使用它。

    以下是如何打开这些文件的示例:

    open('abc.txt', 'rb', buffering=0)

    使用这些类型的文件,open()将返回一个FileIO文件对象:

    >>> file = open('dog_breeds.txt', 'rb', buffering=0)

    >>> type(file)

    读写打开的文件

    打开文件后,您将需要读取或写入文件。首先,让我们来读取一个文件。可以在文件对象上调用多种方法来帮助您:

    方法

    它能做什么

    这将根据size字节数从文件中读取。如果没有传递参数或None或传参-1,那么整个文件被读取。

    这最多读取行中的size字符大小。这将一直延伸到行尾,然后再绕回来。如果未传递任何参数,或者None或传递-1,则读取整行(或行的其余部分)。

    这将从文件对象中读取剩余行并将其作为列表返回。

    使用上面使用的相同文件dog_breeds.txt,我们来看一些如何使用这些方法的示例。以下是如何使用.read()命令打开和读取整个文件的示例:

    >>> with open('dog_breeds.txt', 'r') as reader:

    >>> # 读取并打印整个文件

    >>> print(reader.read())

    Pug

    Jack Russel Terrier

    English Springer Spaniel

    German Shepherd

    Staffordshire Bull Terrier

    Cavalier King Charles Spaniel

    Golden Retriever

    West Highland White Terrier

    Boxer

    Border Terrier

    这是一个如何使用.readline()每行读取5个字节的示例:

    >>> with open('dog_breeds.txt', 'r') as reader:

    >>> # 读取并打印一行的前5个字符, 重复5次

    >>> print(reader.readline(5))

    >>> # 请注意,一行大于5个字符,就沿该行继续,

    >>> # 每次读取5个字符,直到行尾,然后“换行”

    >>> print(reader.readline(5))

    >>> print(reader.readline(5))

    >>> print(reader.readline(5))

    >>> print(reader.readline(5))

    Pug

    Jack

    Russe

    ll Te

    rrier

    以下是使用.readlines()方法将整个文件作为列表读取的示例:

    >>> f = open('dog_breeds.txt')

    >>> f.readlines() # 返回一个列表

    ['Pug\n', 'Jack Russel Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

    上面的例子也可以通过使用list()从文件对象创建列表来完成:

    >>> f = open('dog_breeds.txt')

    >>> list(f)

    ['Pug\n', 'Jack Russel Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

    迭代文件中的每一行

    读取文件时常见的事情是迭代每一行。以下是如何使用.readline()执行迭代的示例:

    >>> with open('dog_breeds.txt', 'r') as reader:

    >>> # 一行接一行地读取和打印整个文件

    >>> line = reader.readline()

    >>> while line != '': # EOF为空

    >>> print(line, end='')

    >>> line = reader.readline()

    Pug

    Jack Russel Terrier

    English Springer Spaniel

    German Shepherd

    Staffordshire Bull Terrier

    Cavalier King Charles Spaniel

    Golden Retriever

    West Highland White Terrier

    Boxer

    Border Terrier

    您可以迭代文件中每一行的另一种方法是使用.readlines()文件对象。请记住,.readlines()返回一个列表,其中列表中的每个元素代表文件中的一行:

    >>> with open('dog_breeds.txt', 'r') as reader:

    >>> for line in reader.readlines():

    >>> print(line, end='')

    Pug

    Jack Russell Terrier

    English Springer Spaniel

    German Shepherd

    Staffordshire Bull Terrier

    Cavalier King Charles Spaniel

    Golden Retriever

    West Highland White Terrier

    Boxer

    Border Terrier

    但是,通过迭代文件对象本身可以进一步简化上述示例:

    >>> with open('dog_breeds.txt', 'r') as reader:

    >>> # Read and print the entire file line by line

    >>> for line in reader:

    >>> print(line, end='')

    Pug

    Jack Russel Terrier

    English Springer Spaniel

    German Shepherd

    Staffordshire Bull Terrier

    Cavalier King Charles Spaniel

    Golden Retriever

    West Highland White Terrier

    Boxer

    Border Terrier

    最后的方法更Pythonic,可以更快,更高效。因此,建议您改用它。

    :exclamation: 注意:

    上面的一些示例包含print('some text', end='')。这end=''是为了防止Python为正在打印的文本添加额外的换行符,并仅打印从文件中读取的内容。

    现在让我们深入研究文件。与读取文件一样,文件对象有多种方法可用于写入文件:

    方法

    它能做什么

    .write(string)

    这会将字符串写入文件。

    .writelines(seq)

    这会将序列写入文件。没有行结尾附加到每个序列项。由您来添加适当的行结尾。

    以下是使用.write()和.writelines()的简单示例:

    with open('dog_breeds.txt', 'r') as reader:

    # 注意:readlines 不裁剪行尾

    dog_breeds = reader.readlines()

    with open('dog_breeds_reversed.txt', 'w') as writer:

    # 你也可以用

    # writer.writelines(reversed(dog_breeds))

    # 把狗的品种按相反的顺序写入文件

    for breed in reversed(dog_breeds):

    writer.write(breed)

    使用字节

    有时,您可能需要使用字节字符串处理文件。这是通过在mode参数中添加'b'字符来完成的。文件对象的所有相同方法都适用。但是,每个方法都期望并返回一个bytes对象:

    >>> with open(`dog_breeds.txt`, 'rb') as reader:

    >>> print(reader.readline())

    b'Pug\n'

    使用b标志打开文本文件并不那么有趣。假设我们有一张 杰克拉塞尔梗(jack_russell.png)的可爱图片:

    jack_russell.92348cb14537.png

    您实际上可以在Python中打开该文件并检查内容!由于.png文件格式定义良好,文件的标题是8个字节,如下所示:

    解释

    0x89

    一个“魔术”数字,表示这是一个 PNG开头

    0x50 0x4E 0x47

    PNG in ASCII

    0x0D 0x0A

    DOS样式行结束 \r\n

    0x1A

    DOS风格的EOF字符

    0x0A

    一个Unix风格的行结尾 \n

    果然,当您打开文件并单独读取这些字节时,您可以看到这确实是一个.png头文件:

    >>> with open('jack_russell.png', 'rb') as byte_reader:

    >>> print(byte_reader.read(1))

    >>> print(byte_reader.read(3))

    >>> print(byte_reader.read(2))

    >>> print(byte_reader.read(1))

    >>> print(byte_reader.read(1))

    b'\x89'

    b'PNG'

    b'\r\n'

    b'\x1a'

    b'\n'

    一个完整的例子: dos2unix.py

    让我们把这整件事情捋一遍,看看如何读取和写入文件的完整示例。下面是一个类似dos2unix的工具,它将把包含\r\n行尾的文件转换为\n。

    该工具分为三个主要部分。第一个是str2unix()将字符串从\\r\\n行结尾转换为\\n。第二个是dos2unix()将包含\r\n字符的字符串转换为\n。dos2unix()调用str2unix()。最后,有__main__块,只有当文件作为脚本执行时才会调用。可以将其视为其他编程语言中的main功能。

    """

    一个简单的脚本和库,

    用来把文件或字符从dos样式行结尾转换为Unix样式行结尾

    """

    import argparse

    import os

    def str2unix(input_str: str) -> str:

    r"""\

    把 \r\n 行结尾字符串转换为 \n 行结尾

    Parameters

    ----------

    input_str

    行结尾将被转换的整个字符串

    Returns

    -------

    转换后的字符串

    """

    r_str = input_str.replace('\r\n', '\n')

    return r_str

    def dos2unix(source_file: str, dest_file: str):

    """\

    转换包含Dos样式的行结尾文件为Unix样式

    Parameters

    ----------

    source_file

    要被转换的源文件路径

    dest_file

    转换后的文件输出路径

    """

    # NOTE: 可以添加文件是否存在检查和文件覆盖保护

    with open(source_file, 'r') as reader:

    dos_content = reader.read()

    unix_content = str2unix(dos_content)

    with open(dest_file, 'w') as writer:

    writer.write(unix_content)

    if __name__ == "__main__":

    # 创建Argument parser并设置描述

    parser = argparse.ArgumentParser(

    description="把Dos样式文件转换为Unix样式文件的脚本",

    )

    # Add the arguments:

    # - source_file: 想要转换的源文件

    # - dest_file: 输出文件目的地

    # Note: the use of the argument type of argparse.FileType could

    # streamline some things

    parser.add_argument(

    'source_file',

    help='源文件路径 '

    )

    parser.add_argument(

    '--dest_file',

    help='目的文件路径(default: source_file appended with `_unix`',

    default=None

    )

    # Parse the args (argparse automatically grabs the values from

    # sys.argv)

    args = parser.parse_args()

    s_file = args.source_file

    d_file = args.dest_file

    # 如果没有传递目的文件,

    # 那么我们会自动基与源文件创建一个新文件

    if d_file is None:

    file_path, file_extension = os.path.splitext(s_file)

    d_file = f'{file_path}_unix{file_extension}'

    dos2unix(s_file, d_file)

    提示和技巧

    现在您已经掌握了读写文件的基础知识,这里有一些提示和技巧可以帮助您提高技能。

    __file__

    __file__属性是模块的特殊属性,类似于__name__。它是:

    “从中加载模块的文件的路径名(如果从文件加载模块的话)”(来源)

    :exclamation: 注意:

    要重新迭代,__file__返回相对于调用初始Python脚本的路径。如果需要完整的系统路径,可以使用os.getcwd()获取执行代码的当前工作目录。

    这是一个真实世界的例子。在我过去的一份工作中,我对硬件设备进行了多次测试。每个测试都是使用Python脚本编写的,测试脚本文件名用作标题。然后执行这些脚本并使用__file__特殊属性打印其状态。这是一个示例文件夹结构:

    project/

    |

    ├── tests/

    | ├── test_commanding.py

    | ├── test_power.py

    | ├── test_wireHousing.py

    | └── test_leds.py

    |

    └── main.py

    运行main.py产生以下内容:

    >>> python main.py

    tests/test_commanding.py Started:

    tests/test_commanding.py Passed!

    tests/test_power.py Started:

    tests/test_power.py Passed!

    tests/test_wireHousing.py Started:

    tests/test_wireHousing.py Failed!

    tests/test_leds.py Started:

    tests/test_leds.py Passed!

    通过使用__file__特殊属性,我能够运行并动态获取所有测试的状态。

    附加到文件

    有时,您可能希望附加到文件或在已填充文件的末尾开始写入。这可以通过使用mode参数的'a'轻松完成:

    with open('dog_breeds.txt', 'a') as a_writer:

    a_writer.write('\nBeagle')

    当您再次检查dog_breeds.txt时,您将看到文件的开头未更改,Beagle现在已添加到文件的末尾:

    >>> with open('dog_breeds.txt', 'r') as reader:

    >>> print(reader.read())

    Pug

    Jack Russel Terrier

    English Springer Spaniel

    German Shepherd

    Staffordshire Bull Terrier

    Cavalier King Charles Spaniel

    Golden Retriever

    West Highland White Terrier

    Boxer

    Border Terrier

    Beagle

    同时使用两个文件

    有时您可能想要读取文件并同时写入另一个文件。如果您在学习如何写入文件时同时显示的示例,则可以将其实际组合为以下内容:

    d_path = 'dog_breeds.txt'

    d_r_path = 'dog_breeds_reversed.txt'

    with open(d_path, 'r') as reader, open(d_r_path, 'w') as writer:

    dog_breeds = reader.readlines()

    writer.writelines(reversed(dog_breeds))

    创建自己的Context Manager

    可能有一段时间,您需要通过将文件对象放在自定义类中来更好地控制文件对象。执行此操作时,除非添加一些魔术方法__enter__和__exit__,否则无法再使用with语句. 通过添加这些,您将创建所谓的上下文管理器(Context Manager)。

    调用with语句时会调用__enter__()。从with语句块退出时调用__exit__()。

    这是一个可用于制作自定义类的模板:

    class my_file_reader():

    def __init__(self, file_path):

    self.__path = file_path

    self.__file_object = None

    def __enter__(self):

    self.__file_object = open(self.__path)

    return self

    def __exit__(self, type, val, tb):

    self.__file_object.close()

    # Additional methods implemented below

    现在您已经拥有了上下文管理器的自定义类,您可以通过类似内置的open()的方式来使用它:

    with my_file_reader('dog_breeds.txt') as reader:

    # Perform custom class operations

    pass

    这是一个很好的例子。还记得我们有可爱的杰克罗素形象吗?也许你想打开其他.png文件,但不想每次都解析头文件。这是一个如何做到这一点的例子。此示例还使用自定义迭代器。如果您不熟悉它们,请查看Python迭代器:

    class PngReader():

    # 每个 .png 文件都包含相同的头文件.

    # 使用它来验证该文件确实是 png

    _expected_magic = b'\x89PNG\r\n\x1a\n'

    def __init__(self, file_path):

    # 确保文件有正确的扩展名

    if not file_path.endswith('.png'):

    raise NameError("File must be a '.png' extension")

    self.__path = file_path

    self.__file_object = None

    def __enter__(self):

    self.__file_object = open(self.__path, 'rb')

    magic = self.__file_object.read(8)

    if magic != self._expected_magic:

    raise TypeError("The File is not a properly formatted .png file!")

    return self

    def __exit__(self, type, val, tb):

    self.__file_object.close()

    def __iter__(self):

    # This and __next__() are used to create a custom iterator

    # See https://dbader.org/blog/python-iterators

    return self

    def __next__(self):

    # Read the file in "Chunks"

    # See https://en.wikipedia.org/wiki/Portable_Network_Graphics#%22Chunks%22_within_the_file

    initial_data = self.__file_object.read(4)

    # The file hasn't been opened or reached EOF. This means we

    # can't go any further so stop the iteration by raising the

    # StopIteration.

    if self.__file_object is None or initial_data == b'':

    raise StopIteration

    else:

    # Each chunk has a len, type, data (based on len) and crc

    # Grab these values and return them as a tuple

    chunk_len = int.from_bytes(initial_data, byteorder='big')

    chunk_type = self.__file_object.read(4)

    chunk_data = self.__file_object.read(chunk_len)

    chunk_crc = self.__file_object.read(4)

    return chunk_len, chunk_type, chunk_data, chunk_crc

    现在可以打开.png文件并使用自定义上下文管理器正确分析它们:

    >>> with PngReader('jack_russell.png') as reader:

    >>> for l, t, d, c in reader:

    >>> print(f"{l:05}, {t}, {c}")

    00013, b'IHDR', b'v\x121k'

    00001, b'sRGB', b'\xae\xce\x1c\xe9'

    00009, b'pHYs', b'(

    00345, b'iTXt', b"L\xc2'Y"

    16384, b'IDAT', b'i\x99\x0c('

    16384, b'IDAT', b'\xb3\xfa\x9a$'

    16384, b'IDAT', b'\xff\xbf\xd1\n'

    16384, b'IDAT', b'\xc3\x9c\xb1}'

    16384, b'IDAT', b'\xe3\x02\xba\x91'

    16384, b'IDAT', b'\xa0\xa99='

    16384, b'IDAT', b'\xf4\x8b.\x92'

    16384, b'IDAT', b'\x17i\xfc\xde'

    16384, b'IDAT', b'\x8fb\x0e\xe4'

    16384, b'IDAT', b')3={'

    01040, b'IDAT', b'\xd6\xb8\xc1\x9f'

    00000, b'IEND', b'\xaeB`\x82'

    不要重复造轮子

    在处理文件时可能会遇到常见情况。大多数情况可以使用其他模块处理。您可能需要使用的两种常见文件类型是.csv和.json。Real Python已经汇总了一些关于如何处理这些内容的精彩文章:

    此外,还有内置库,您可以使用它们来帮助您:

    wave:读写WAV文件(音频)

    aifc:读写AIFF和AIFC文件(音频)

    sunau:读取和写入Sun AU文件

    tarfile:读取和写入tar归档文件

    zipfile:使用ZIP存档

    configparser:轻松创建和解析配置文件

    msilib:读取和写入Microsoft Installer文件

    plistlib:生成并解析Mac OS X .plist文件

    还有更多的东西。此外,PyPI还有更多第三方工具可用。一些流行的是以下:

    PyPDF2:PDF工具包

    xlwings:读取和写入Excel文件

    Pillow:图像阅读和操作

    结束语

    你做到了!您现在知道如何使用Python处理文件,包括一些高级技术。使用Python中的文件现在比以往任何时候都更容易,当你开始这样做时,这是一种有益的感觉。

    在本教程中,您已经了解到:

    什么是文件

    如何正确打开和关闭文件

    如何读写文件

    使用文件时的一些高级技术

    一些库使用常见的文件类型

    如果您有任何疑问,请在评论中与我们联系。

    展开全文
  • 文件try:f = open('/path/to/file', 'r')print(f.read())except IOError as e:print('except:', e)finally:if f:f.close()使用with语句会自动调用close()方法:with open('/path/to/file', 'r') as f:print(f.read...

    读文件try:

    f = open('/path/to/file', 'r')

    print(f.read())

    except IOError as e:

    print('except:', e)

    finally:

    if f:

    f.close()

    使用with语句会自动调用close()方法:with open('/path/to/file', 'r') as f:

    print(f.read())

    常用的读方法:read() 一次性读取文件的全部内容;

    read(size) 每次读取size个字节的内容;

    readline() 每次读取一行内容;

    readlines() 一次读取所有内容并按行返回list;

    readlines() 使用示例:for line in f.readlines():

    print(line.strip()) # 把末尾的'\n'删掉

    类文件对象

    含有read()方法的对象,在Python中统称为file-like Object。

    文件、字节流、网络流、自定义流等都是 file-like Object。

    读取二进制文件

    图片、视频等都属于二进制文件,需要用'rb'模式打开:>>> f = open('/Users/michael/test.jpg', 'rb')

    >>> f.read()

    b'\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' # 十六进制表示的字节

    指定读取的字符编码>>> f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')

    >>> f.read()

    '测试'

    写文件

    写文件时,操作系统往往不会立刻把数据写入磁盘,而是放到内存缓存起来,空闲的时候再慢慢写入。只有调用close()方法时,操作系统才把没有写入的数据全部写入磁盘。所以建议使用 with 方式:with open('/path/to/file', 'w') as f:

    f.write('Hello, world!')w 模式为覆盖写入

    a 模式为追加写入

    展开全文
  • Python内置了读写文件的函数,用法和C是兼容的。缓存读写文件前,咱们先必须了解一下,在磁盘上读写文件的功能都是由操做系统提供的,现代操做系统不容许普通的程序直接操做磁盘,因此,读写文件就是请求操做系统...

    读写文件是最多见的IO操做。Python内置了读写文件的函数,用法和C是兼容的。缓存

    读写文件前,咱们先必须了解一下,在磁盘上读写文件的功能都是由操做系统提供的,现代操做系统不容许普通的程序直接操做磁盘,因此,读写文件就是请求操做系统打开一个文件对象(一般称为文件描述符),而后,经过操做系统提供的接口从这个文件对象中读取数据(读文件),或者把数据写入这个文件对象(写文件)。函数

    读文件

    要以读文件的模式打开一个文件对象,使用Python内置的open()函数,传入文件名和标示符:测试

    >>> f = open('/Users/michael/test.txt', 'r')

    标示符'r'表示读,这样,咱们就成功地打开了一个文件。编码

    若是文件不存在,open()函数就会抛出一个IOError的错误,而且给出错误码和详细的信息告诉你文件不存在:spa

    >>> f=open('/Users/michael/notfound.txt', 'r')

    Traceback (most recent call last):

    File"", line 1, in FileNotFoundError: [Errno2] No such file or directory: '/Users/michael/notfound.txt'

    若是文件打开成功,接下来,调用read()方法能够一次读取文件的所有内容,Python把内容读到内存,用一个str对象表示:操作系统

    >>>f.read()'Hello, world!'

    最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭,由于文件对象会占用操做系统的资源,而且操做系统同一时间能打开的文件数量也是有限的:code

    >>> f.close()

    因为文件读写时都有可能产生IOError,一旦出错,后面的f.close()就不会调用。因此,为了保证不管是否出错都能正确地关闭文件,咱们能够使用try ... finally来实现:视频

    c1b4e81a2cae44bdb320db3b.html

    try:

    f= open('/path/to/file', 'r')print(f.read())finally:iff:

    f.close()

    c1b4e81a2cae44bdb320db3b.html

    可是每次都这么写实在太繁琐,因此,Python引入了with语句来自动帮咱们调用close()方法:对象

    with open('/path/to/file', 'r') as f:print(f.read())

    这和前面的try ... finally是同样的,可是代码更佳简洁,而且没必要调用f.close()方法。blog

    调用read()会一次性读取文件的所有内容,若是文件有10G,内存就爆了,因此,要保险起见,能够反复调用read(size)方法,每次最多读取size个字节的内容。另外,调用readline()能够每次读取一行内容,调用readlines()一次读取全部内容并按行返回list。所以,要根据须要决定怎么调用。

    若是文件很小,read()一次性读取最方便;若是不能肯定文件大小,反复调用read(size)比较保险;若是是配置文件,调用readlines()最方便:

    for line inf.readlines():print(line.strip()) #把末尾的'\n'删掉

    写文件

    写文件和读文件是同样的,惟一区别是调用open()函数时,传入标识符'w'或者'wb'表示写文本文件或写二进制文件:

    >>> f = open('/Users/michael/test.txt', 'w')>>> f.write('Hello, world!')>>> f.close()

    你能够反复调用write()来写入文件,可是务必要调用f.close()来关闭文件。当咱们写文件时,操做系统每每不会马上把数据写入磁盘,而是放到内存缓存起来,空闲的时候再慢慢写入。只有调用close()方法时,操做系统才保证把没有写入的数据所有写入磁盘。忘记调用close()的后果是数据可能只写了一部分到磁盘,剩下的丢失了。因此,仍是用with语句来得保险:

    with open('/Users/michael/test.txt', 'w') as f:

    f.write('Hello, world!')

    要写入特定编码的文本文件,请给open()函数传入encoding参数,将字符串自动转换成指定编码

    字符编码

    要读取非UTF-8编码的文本文件,须要给open()函数传入encoding参数,例如,读取GBK编码的文件:

    >>> f = open('/Users/michael/gbk.txt', 'r', encoding='gbk')>>>f.read()'测试'

    遇到有些编码不规范的文件,你可能会遇到UnicodeDecodeError,由于在文本文件中可能夹杂了一些非法编码的字符。遇到这种状况,open()函数还接收一个errors参数,表示若是遇到编码错误后如何处理。最简单的方式是直接忽略:

    >>> f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')

    二进制文件

    前面讲的默认都是读取文本文件,而且是UTF-8编码的文本文件。要读取二进制文件,好比图片、视频等等,用'rb'模式打开文件便可:

    >>> f = open('/Users/michael/test.jpg', 'rb')>>>f.read()

    b'\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' #十六进制表示的字节

    总结:之后读写文件都使用with open语句,不要再像之前那样用f = open()这种语句了

    对于多个文件的读写,能够写成如下两种方式:

    c1b4e81a2cae44bdb320db3b.html

    with open('/home/xbwang/Desktop/output_measures.txt','r') as f:

    with open('/home/xbwang/Desktop/output_measures2.txt','r') as f1:

    with open('/home/xbwang/Desktop/output_output_bk.txt','r') as f2:

    ........

    ........

    ........

    c1b4e81a2cae44bdb320db3b.html

    c1b4e81a2cae44bdb320db3b.html

    with open('/home/xbwang/Desktop/output_measures.txt','r') as f:

    ........

    with open('/home/xbwang/Desktop/output_measures2.txt','r') as f1:

    ........

    with open('/home/xbwang/Desktop/output_output_bk.txt','r') as f2:

    ........

    c1b4e81a2cae44bdb320db3b.html

    展开全文
  • Python第11课:文本读写和容错语句时间 2019-01-18下午4:30主讲陈命地点 四楼电教室一、读写文本文件f=open("dsj.txt","w") #该文件如果已存在,则替换f.write("上饶")f.close()e=open("dsj.txt","r")t=f.read()f....
  • 博主平时用Python比较多,最近因为工作需要使用Java编程,比较之...Python读写文件的语句读文件with open('readFile', 'r') as inFile:for line in inFile.readlines():print line...写文件with open('writeFile', '...
  • {"moduleinfo":{"card_count":[{"count_phone":1,"count":1}],"search_count":[{"count_phone":4,"count":4}]},"card":[{"des":"阿里云文件存储NAS是一个可共享访问,弹性扩展,高可靠,高性能分布式文件系统。...
  • Python读写文件1.open使用open打开文件后一定要记得调用文件对象close()方法。比如可以用try/finally语句来确保最后能关闭文件。file_object = open('thefile.txt')try:all_the_text=file_object.read( )finally:...
  • 1.with open() as filePython内置了读写文件的函数,用法和C是兼容的。在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘,所以,读写文件就是请求操作系统打开一个文件对象...
  • 概览在Python中, 读写文件不需要import任何库, 第一步是使用open函数获取一个文件对象文件类型文件通常被分为文本文件或二进制文件, 文本文件通常是由很多行组成序列(sequence), 而每一行又是很多字符(characters)...
  • 打开文件file_object = open(file_...access_mode 打开文件的方式,如果不写默认为‘r’buffering = 1表示有1行缓冲,默认则表示使用系统默认提供的缓冲机制。返回值:成功返回文件操作对象。操作完成需要使用file_...
  • Python文件读写之with语句关闭文件

    千次阅读 2019-06-20 18:48:00
    Python文件读写之with语句 在进行Python文件的读取或者写入的时候,我们都需要调取f.close()来关闭文件,前者是避免占用内存,后者是保证内容顺利写入到目标文件中。 当我们写入文件时,操作系统往往不会立刻把数据...
  • 展开全部Python和Java读写文件的对比Python读写文件的语句[python] view plain copy读e68a84e8a2ad62616964757a686964616f31333363353735文件with open('readFile', 'r') as inFile:for line in inFile.readlines():...
  • 这篇文章主要为大家详细介绍了Python 读写文件实现方法,具有一定参考价值,可以用来参考一下。感兴趣Python 读写文件实现方法小伙伴,下面一起跟随512笔记小编罗X来看看吧。# 512笔记网 (www.512pic.com)#1....
  • Python读写文件

    2019-04-07 21:07:19
    Python读写文件 Python读写文件 1.open 使用open打开文件后一定要记得调用文件对象close()方法。比如可以用try/finally语句来确保最后能关闭文件。 file_object = open(‘thefile.txt’) try: all_the_text = file...
  • 本文实例总结了Python读写文件方法。分享给大家供大家参考。具体分析如下:1.open使用open打开文件后一定要记得调用文件对象close()方法。比如可以用try/finally语句来确保最后能关闭文件。?12345file_object= ...
  • 文件try:f = open('/path/to/file', 'r')print(f.read())except IOError as e:print('except:', e)finally:if f:f.close()使用with语句会自动调用close()方法:with open('/path/to/file', 'r') as f:print(f.read...
  • Python读写文件的方法

    2019-11-20 16:48:09
    Python读写文件 1.open 使用open打开文件后一定要记得调用文件对象close()方法。比如可以用try/finally语句来确保最后能关闭文件。 file_object = open(‘thefile.txt’) try: all_the_text = file_object.read( )...
  • 一、文件的打开与关闭1. open 函数Python通过解释器内置的open()函数打开一个文件,并实现该文件与一个变量的关联,其语法格式如下: = open([,[,encoding=None]])参数解释::当脚本和文件存放在同一路径下时,可以...
  • 本文实例总结了Python读写文件方法。分享给大家供大家参考。具体分析如下:1.open使用open打开文件后一定要记得调用文件对象close()方法。比如可以用try/finally语句来确保最后能关闭文件。?注:不能把open语句...
  • 本文实例总结了python读写文件方法。分享给大家供大家参考。具体分析如下:1.open使用open打开文件后一定要记得调用文件对象close()方法。比如可以用try/finally语句来确保最后能关闭文件。 file_object = open('...
  • Python内置了读写文件的函数,用法和C是兼容的。 读写文件前,我们先必须了解一下,在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的程序直接操作磁盘,所以,读写文件就是请求操作系统打开...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 730
精华内容 292
关键字:

python读写文件的语句

python 订阅