python文件操作_文件中的lines中的元素

python文件路径及操作

一个文件所在的路径，有 2 种表示方式：
绝对路径：从根文件夹开始，Window 系统中以盘符作为根文件夹，而 OS X 或者 Linux 系统中以 / 作为根文件夹。
相对路径：文件相对于当前工作目录所在的位置。（其中 .\ 就表示当前所在目录）。
python中提供了许多处理文件路径的函数：

# 首先要导入os模块
import os

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 参数中最后一个斜杠之后的所有内容。

os.path.split(path)  # 返回路径的目录名称和基本名称，获得这两个字符串的元组

os.path.exists(path)  #path 参数所指的文件或文件夹存在，将返回 True，否则返回 False。
os.path.isfile(path) #如果 path 参数存在，并且是一个文件，将返回 True，否则返回 False。
os.path.isdir(path) #如果 path 参数存在，并且是一个文件夹，将返回 True，否则返回 False。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

python文件操作

文件的操作可以分为以下 3 步：
1.打开文件：使用 open() 函数，该函数会返回一个文件对象；
2.对已打开文件做读/写操作：读取文件内容可使用 read()、readline() 以及 readlines() 函数；向文件中写入内容，可以使用 write() 函数。
3.关闭文件：完成对文件的读/写操作之后，最后需要关闭文件，可以使用 close() 函数。

python打开文件

file = open(file_name [, mode='r' [ , buffering=-1 [ , encoding = None ]]])
"""
各参数含义：
file：表示要创建的文件对象。
file_mode：要创建或打开文件的文件名称，该名称要用引号（单引号或双引号都可以）括起来。需要注意的是，如果要打开的文件和当前执行的代码文件位于同一目录，则直接写文件名即可；否则，此参数需要指定打开文件所在的完整路径。
mode：可选参数，用于指定文件的打开模式。
buffing：可选参数，用于指定对文件做读写操作时，是否使用缓冲区。（为0则使用缓冲区，大于1整数则用于指定缓冲区的大小（字节），小于0则代表使用默认的缓冲区大小）
encoding：手动设定打开文件时所使用的编码格式，不同平台的 ecoding 参数值也不同，以 Windows 为例，其默认为 cp936（实际上就是 GBK 编码）。
"""
1
2
3
4
5
6
7
8
9

mode的文件打开模式详表：


文件对象的一些常用的属性：

'''
file.name：返回文件的名称；
file.mode：返回打开文件时，采用的文件打开模式；
file.encoding：返回打开文件时使用的编码格式；
file.closed：判断文件是否己经关闭。
'''
1
2
3
4
5
6
'
运行
运行

python 文件读取

read()函数：
如果文件是以文本模式（非二进制模式）打开的，则 read() 函数会逐个字符进行读取；反之，如果文件以二进制模式打开，则 read() 函数会逐个字节进行读取。
语法格式：

file.read([size]) # size 是一个可选参数，用于指定一次最多可读取的字符（字节）个数，如果省略，则默认一次性读取所有内容。
1

readline()函数：
readline() 函数用于读取文件中的一行，包含最后的换行符“\n”。
语法格式：

file.readline([size]) # 参数与read()类似
1

readlines()函数：
readlines() 函数用于读取文件中的所有行，该函数返回是一个字符串列表，其中每个元素为文件中的一行内容。
语法格式：

file.readlines()
1

python写入数据

write() 函数
语法格式：

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

# 需保证使用 open() 函数是以 r+、w、w+、a 或 a+ 的模式打开文件，否则执行 write() 函数会抛出 io.UnsupportedOperation 错误。
1
'
运行
运行

'''
打开文件模式中包含 w（写入），那么向文件中写入内容时，会先清空原文件中的内容
打开文件模式中包含 a（追加），则不会清空原有内容，而是将新写入的内容会添加到原内容后边。
'''
1
2
3
4
'
运行
运行

'''
在写入文件完成后，一定要调用 close() 函数将打开的文件关闭，否则写入的内容不会保存到文件中。
写入文件内容时，操作系统不会立刻把数据写入磁盘，而是先缓存起来，只有调用 close() 函数时，操作系统才会保证把没有写入的数据全部写入磁盘文件中。
向文件写入数据后，不想马上关闭文件，也可以调用文件对象提供的 flush() 函数，它可以实现将缓冲区的数据写入文件中。
'''
1
2
3
4
5
'
运行
运行

writelines()函数
可以实现将字符串列表写入文件中。
使用 writelines() 函数向文件中写入多行数据时，不会自动给各行添加换行符。

python关闭文件

close()函数

file.close()
1

python文件指针

tell()函数

file.tell() #用于判断文件指针当前所处的位置,以 b 模式打开，每个数据就是一个字节；以普通模式打开，每个数据就是一个字符.
1

seek()函数

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

python上下文管理器

文件操作时，打开的文件最后一定要关闭，否则会程序的运行造成意想不到的隐患。但是，即便使用 close() 做好了关闭文件的操作，如果在打开文件或文件操作过程中抛出了异常，还是无法及时关闭文件。
在 Python 中，对应的解决方式是使用 with as 语句操作上下文管理器 ，它能够帮助我们自动分配并且释放资源。

# 同时包含 __enter__() 和 __exit__() 方法的对象就是上下文管理器。常见构建上下文管理器的方式有 2 种，分别是基于类实现和基于生成器实现。

# 使用 with as 操作已经打开的文件对象（本身就是上下文管理器），无论期间是否抛出异常，都能保证 with as 语句执行完毕后自动关闭已经打开的文件。
1
2
3
'
运行
运行

语法格式：

with 表达式 [as target]：
    代码块
1
2

with as原理：
上下文管理器必须实现如下两个方法：
enter(self)：进入上下文管理器自动调用的方法，该方法会在 with as 代码块执行之前执行。如果 with 语句有 as子句，那么该方法的返回值会被赋值给 as 子句后的变量；该方法可以返回多个值，因此在 as 子句后面也可以指定多个变量（多个变量必须由“()”括起来组成元组）。
exit（self, exc_type, exc_value, exc_traceback）：退出上下文管理器自动调用的方法。该方法会在 with as 代码块执行之后执行。如果 with as 代码块成功执行结束，程序自动调用该方法，调用该方法的三个参数都为 None：如果 with as 代码块因为异常而中止，程序也自动调用该方法，使用 sys.exc_info 得到的异常信息将作为调用该方法的参数。

with as 操作上下文管理器时，就会在执行语句体之前，先执行上下文管理器的 enter() 方法，然后再执行语句体，最后执行 exit() 方法。
只要一个类实现了 enter() 和 exit() 这 2 个方法，程序就可以使用 with as 语句来管理它，通过 exit() 方法的参数，即可判断出 with 代码块执行时是否遇到了异常。我们弄得文件对象内部包括这两个方法，所以可以用with as来使用。

自定义一个实现上下文管理协议的类：

class Manager:
    def __init__(self, tag):
        self.tag = tag
        print('构造器,初始化资源: %s' % tag)
    # 定义__enter__方法，with体之前的执行的方法
    def __enter__(self):
        print('[__enter__ %s]: ' % self.tag)
        # 该返回值将作为as子句中变量的值
        return 'gklong'  # 可以返回任意类型的值
    # 定义__exit__方法，with体之后的执行的方法
    def __exit__(self, exc_type, exc_value, exc_traceback):
        print('[__exit__ %s]: ' % self.tag)
        # exc_traceback为None，代表没有异常
        if exc_traceback is None:
            print('没有异常,关闭资源')
        else:
            print('遇到异常,关闭资源')
            return False   # 可以省略，默认返回None也被看做是False
with  Manager('上下文管理器1') as file_object:
    print(file_object)
    print('[with代码块] 没有异常')
print(100*'*')
with Manager('上下文管理器2'):
    print('[with代码块] 异常之前的代码')
    raise Exception
    print('[with代码块] ~~~~~~~~异常之后的代码')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

结果：

基于类的上下文管理器更加灵活，适用于大型的系统开发，而基于生成器的上下文管理器更加方便、简洁，适用于中小型程序。最重要的是不用忘记在方法“__exit__()”或者是 finally 块中释放资源。
1