文件对象的seek()和tell()

打开一个文件，读取内容，是很常见的操作。不过有的时候我们还需要反复读取文件中的内容，如果多次打开文件读取再多次关闭，显然不是特别好的操作，我们可以借助Python文件对象的seek()和tell()函数，来实现反复的读取文件内容，最后再关闭文件。

tell()函数

先说tell()函数，这个简单，就是告诉我们当前文件读取指针处于文件的什么位置。tell()函数返回的位置，以byte计数：

  1. >>> f = open('1.txt')
  2. >>> f.tell()
  3. 0
  4. >>> f.read(1)
  5. '#'
  6. >>> f.tell()
  7. 1
  8. >>> f.read(24)
  9. ' GTR2SP2L A0A2 table\n# g'
  10. >>> f.tell()
  11. 25

打开文件后，tell()返回的位置是0；读取一个字符，tell()就返回1。因此，python文件对象的tell()函数，返回的位置就是已经去读的最后一个byte，下次再read()，就是从这个位置往后开始算。

seek()函数

seek()函数是用来重新定位读取文件的指针位置。

  1. >>> f.close()
  2. >>> f = open('1.txt')
  3. >>> f.read(48)
  4. '# GTR2SP2L A0A2 table\n# generating time: 17:00:0'
  5. >>> f.tell()
  6. 48
  7. >>> f.seek(0)
  8. 0
  9. >>> f.read(48)
  10. '# GTR2SP2L A0A2 table\n# generating time: 17:00:0'

以上代码，中间那个f.seek(0)，将读取文件的指针，重新定位到最开始的位置，因此两次f.read(48)，得到的内容是一样的。
seek()含有一个参数，用来确定参考位置。

  • 0表示从文件头开始的绝对位置（默认）
  • 1表示以当前位置为参考，
  • 2表示从文件末尾开始。

文件对象的read()、readline()和readlines()

  • read()函数可以带一个长度，用来控制每次读入的内容长度，这根内容直接相关，如果读取一个超大文件，read()不带长度，程序可能直接卡死。
  • readline()函数也可以带一个长度，表示在这个长度范围内读取一行，如果读取一个超大文件，文件中没有换行符，readline()不带长度，程序可能直接卡死。
  • readlines()虽然可以让代码更易写易读，但是其实很消耗内存， read all lines into memory，如果是很大的文件，这一定不是个好的选择。当然，readlines()也可以设置一个最大读取字节数，但是readlines()函数总是会尝试读出一个完整的行出来。比如一行有10个bytes，readlines(2)，也会把这10个bytes读出来。

要特别注意readline()和readlines()在给定参数时的行为的不同！

read()

Python文件对象的read()函数很直接，就是读，如果不带参数，一口气就将文件内容全部读出来了。不过也可以带个参数，限制一下每次读取的长度。

  1. >>> f = open('test.txt')
  2. >>> f.read()
  3. '12345\nabcde\n14sdn854nd\nhahaha..\n'
  4. >>> f.seek(0)
  5. 0
  6. >>> f.read(5)
  7. '12345'
  8. >>> f.read(5)
  9. '\nabcd'
  10. >>> f.read(5)
  11. 'e\n14s'
  12. >>> f.read(5)
  13. 'dn854'
  14. >>> f.read(5)
  15. 'nd\nha'

read()函数不带参数，就是将文件内容全部读出；参数表示读取的字节数。

readline()

顾名思义，这个函数的作用就是读取文件的一行。

  1. >>> f.seek(0)
  2. 0
  3. >>> f.readline()
  4. '12345\n'
  5. >>> f.readline()
  6. 'abcde\n'
  7. >>> f.readline()
  8. '14sdn854nd\n'
  9. >>> f.readline()
  10. 'hahaha..\n'
  11. >>> f.readline()
  12. ''

readline()的逻辑是，读取到EOF或换行为止，因此所以，readline()函数也没有带一个参数，参数含义跟read()一样，表示读取的最大字节数。不过，遇到换行或EOF，readline()会返回。

  1. >>> f.seek(0)
  2. 0
  3. >>> f.readline(2)
  4. '12'
  5. >>> f.readline(2)
  6. '34'
  7. >>> f.readline(2)
  8. '5\n'
  9. >>> f.readline(2)
  10. 'ab'
  11. >>> f.readline(2)
  12. 'cd'
  13. >>> f.readline(2)
  14. 'e\n'
  15. >>> f.readline(2)
  16. '14'
  17. >>> f.readline(2)
  18. 'sd'
  19. >>> f.readline(2)
  20. 'n8'
  21. >>> f.readline(2)
  22. '54'
  23. >>> f.readline(2)
  24. 'nd'
  25. >>> f.readline(2)
  26. '\n'

readlines()

readlines()与上一个函数的区别，在于它将文件所有的行一次性读出来后，放入一个list对象中，在有循环操作的时候，这个函数用起来更方便。

  1. >>> f.seek(0)
  2. 0
  3. >>> f.readlines()
  4. ['12345\n', 'abcde\n', '14sdn854nd\n', 'hahaha..\n']
  5. >>> f.tell()
  6. 32

跟read()不带参数一样，一口气将文件读完，指针位置移动到文件最后，只是返回的是按行的list。其实，readlines()函数也可以带一个参数，参数的含义依然是字节数，不过函数的行为不是读取参数指定的字节数，而是读取符合指定字节数的行出来。请看如下代码：

  1. >>> f.seek(0)
  2. 0
  3. >>> f.readlines(10)
  4. ['12345\n', 'abcde\n']
  5. >>> f.readlines(2)
  6. ['14sdn854nd\n']
  7. >>> f.readlines(200)
  8. ['hahaha..\n']
  9. >>> f.readlines(200)
  10. []
  11. >>> f.close()

参数为10时，两行就满足了；参数为2时，只需要一行就满足了；参数为200时，遇到了EOF，只剩一行了；最后没有了，就返回空的list对象。

本文的测试代码一致使用f.seek(0)进行文件内容的重新读取，最后别忘了f.close()关闭文件。

参考