file.readline
При считывании символ новой строки \n присутствует в конце каждой из строк. Его может не быть лишь в последней строке — это позволяет добиться однозначности: если метод возвращает пустую строку, значит достигнут конец файла; если строка содержит лишь символ \n , значит это просто очередная строка.
with open('my_file.txt') as f:
f.readline() # 'The first line.\n'
f.readline() # '\n'
f.readline() # 'The last line.\n'
f.readline() # ''
Для упрощения можно считывать строки из файла пройдя по его объекту в цикле:
with open('my_file.txt') as f:
for line in f:
print(line)
Такой подход эффективен с точки зрения расходования памяти, быстр, и выглядит хорошо.
- Для считывания файла кусками используйте read().
- Для считывания всех строк разом используйте readlines().
Текстовая обработка в языке Python. Подсказки для начинающих
Как и ряд других популярных скриптовых языков, Python является великолепным инструментом для сканирования и манипуляций с текстовыми данными. Эта статья суммирует возможности текстовой обработки языка Python для тех программистов, которые являются новичками в программировании на языке Python. Эта статья объясняет некоторые основные понятия регулярных выражений и предлагает советы, когда стоит (а когда — не стоит) использовать регулярные выражения при обработке текста.
Что такое Python?
Python — это свободно доступный, интерпретируемый язык очень высокого уровня, разработанный Гвидо ван Россумом. Он объединяет ясный синтаксис с мощной (но необязательной) объектно-ориентированной семантикой. Python широко распространен и высокопортабелен.
Строки — неизменяемые последовательности
Как и в большинстве высокоуровневых языков программирования, строки переменной длины являются базовым типом в языке Python. Python выделяет область памяти для хранения строк (или других значений) «за кулисами», там, где программисту не нужно особенно задумываться об этом. Кроме того, Python имеет несколько возможностей управления строками, отсутствующих в других высокоуровневых языках.
В языке Python строки представляют собой «неизменяемые последовательности» («immutable sequences»). Программа может обращаться к элементам или подпоследовательностям строк как к любым последовательностям, несмотря на то, что строки, как и кортежи (tuples), не могут быть изменены непосредственно «на месте». Python обращается к подпоследовательностям с помощью гибкой операции «среза», формат которой напоминает задание диапазона строк и столбцов в электронной таблице. Приведенная ниже интерактивная сессия иллюстрирует использование строк и срезов.
>>> s = «mary has a little lamb»
>>> s[0] # индекс с отсчетом от нуля
‘m’
>>> s[3] = ‘x’ # непосредственное изменение элемента не удается
Traceback (innermost last):
File «», line 1, in ?
TypeError: object doesn’t support item assignment
>>> s[11:18] # ‘вырезать’ подпоследовательность
‘little ‘
>>> s[:4] # пустое начало среза предполагает нуль
‘mary’
>>> s[4] # индекс 4 не включен в срез [:4]
‘ ‘
>>> s[5:-5] # может использоваться индекс «с конца» с отрицательными числами
‘had a little’
>>> s[:5]+s[5:] # соединение начала и конца среза
‘mary had a little lamb’
Другая мощная строковая операция — просто ключевое слово in. Оно предлагает две интуитивные и полезные конструкции:
>>> s = «mary had a little lamb»
>>> for c in s[11:18]: print c, # печать каждого символа в срезе
.
l i t t l e
>>> if ‘x’ in s: print ‘got x’ # проверка на вхождение символа
.
>>> if ‘y’ in s: print ‘got y’ # проверка на вхождение символа
.
got y
Есть несколько способов написания строковых констант в языке Python. Вы можете использовать как одинарные, так и двойные кавычки при условии, пока символы открытия и закрытия соответствуют друг другу, и существует ряд других полезных вариантов. Если ваша строка содержит переводы строки или вложенные кавычки, тройные кавычки предоставляют удобный способ такого рода строк, как это сделано в следующем примере:
>>> s2 = «»»Mary had a little lamb
. its fleece was white as snow
. and everywhere that Mary went
. the lamb was sure to go»»»
>>> print s2
Mary had a little lamb
its fleece was white as snow
and everywhere that Mary went
the lamb was sure to go
Как одинарные, так и тройные кавычки могут предваряться буквой «r» для обозначения того, что специальные символы регулярных выражений не должны интерпретироваться Python. Например:
>>> s3 = «this \n and \n that»
>>> print s3
this
and
that
>>> s4 = r»this \n and \n that»
>>> print s4
this \n and \n that
В «r-строках» обратный слэш, который в иных случаях может служить для задания специального символа, обрабатывается как обычный обратный слэш. Это объясняется далее при рассмотрении регулярных выражений.
Файлы и строковые переменные
Когда мы говорим «текстовая обработка», мы обычно подразумеваем обработку содержимого файла. На языке Python не составляет труда считать содержимое текстового файла в строковые переменные, где этим содержимым можно манипулировать. Файловые объекты обеспечивают три метода чтения: .read(), .readline(), and .readlines(). Каждый из этих методов может принимать аргумент для ограничения объема данных, считываемых за один раз, однако в основном они используются без аргумента. .read() считывает весь файл за один раз, и обычно используется для помещения содержимого файла в строковую переменную. Хотя .read() дает наиболее прямое строковое представление содержимого файла, он неудобен для последовательной строчно-ориентированной обработки файла, к тому же это невозможно, если размер файла превышает объем имеющейся памяти.
.readline() и .readlines() очень похожи. И та и другая используются в конструкциях наподобие следующей:
fh = open(‘c:\\autoexec.bat’)
for line in fh.readlines():
print line
Различие между .readline() и .readlines() в том, что последняя, как и .read(), считывает весь файл за один раз. .readlines() автоматически парсит содержимое файла в список строк, который может быть обработан с помощью конструкции языка Python for . in .
С другой стороны, .readline() считывает только одну строку за раз, и в целом работает гораздо медленнее, чем .readlines(). .readline() следует использовать, только если памяти не хватает для считывания всего файла за один раз.
Если вы используете стандартный модуль, работающий с файлами, вы можете превратить строку в «виртуальный файл» с помощью модуля cStringIO (если требуется создание производных классов, можно использовать StringIO, но начинающим это требуется редко).
>>> import cStringIO
>>> fh = cStringIO.StringIO()
>>> fh.write(«mary had a little lamb»)
>>> fh.getvalue()
‘mary had a little lamb’
>>> fh.seek(5)
>>> fh.write(‘ATE’)
>>> fh.getvalue()
‘mary ATE a little lamb’
Не забывайте, однако, что, в отличие от настоящего файла, «виртуальный файл», сформированный cStringIO — временный. Он исчезнет, когда программа завершится, если вы не предпримете каких-либо шагов, чтобы его сохранить (например, запишете его в реальный файл или воспользуетесь модулем shelve либо базой данных).
Стандартный модуль: string
Модуль string, возможно, в целом наиболее полезный модуль стандартных дистрибутивов языка Python 1.5.*. На самом деле похоже, что многие из возможностей модуля string будут существовать в качестве встроенных строковых методов в Python 1.6 и выше (подробности еще не были опубликованы на момент написания этой статьи). Наиболее вероятно, что любая программа, выполняющая обработку текста, должна начинаться со строки:
Основное правило состоит в том, что если вы можете решить задачу с помощью модуля string, это правильный способ ее решения. В отличие от re (регулярных выражений), функции string в целом гораздо быстрее и в большинстве случаев проще для понимания и использования. Сторонние модули языка Python, включая и некоторые быстрые, написанные на С расширения, предназначены для специализированных задач, однако переносимость и простота, тем не менее, определяют привязку к string везде, где только возможно. Есть и исключения, однако не так много, как вы можете подумать, имея опыт использования других языков.
Модуль string содержит несколько типов инструментов, таких как функции, методы и классы. Он также содержит наиболее общие строковые константы. Например:
>>> import string
>>> string.whitespace
‘\011\012\013\014\015 ‘
>>> string.uppercase
‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’
Хотя вы можете написать эти константы сами, версии string более или менее гарантируют, что ваши константы будут правильны с точки зрения национального языка и платформы, на которой выполняется ваш скрипт на Python.
string также включает функции, преобразующие строки обычными способами (которые вы можете объединить для получения некоторых необычных преобразований). Например:
>>> import string
>>> s = «mary had a little lamb»
>>> string.capwords(s)
‘Mary Had A Little Lamb’
>>> string.replace(s, ‘little’, ‘fercious’)
‘mary had a ferocious lamb’
Существут множество других преобразований, не проиллюстрированных здесь особо; вы можете найти подробности в руководстве по языку Python. Кроме того, вы можете пользоваться функциями string для получения информации о таких атрибутах строки, как длина или позиции подстроки, например:
>>> import string
>>> s = «mary had a little lamb»
>>> string.find(s, ‘had’)
5
>>> string.count(s, ‘a’)
4
И наконец, string предоставляет очень характерную для языка Python особенность. Пара .split() и .join() обеспечивает быстрый способ преобразования строк в кортежи и наоборот, что вы найдете весьма полезным. Реализуется это просто:
>>> import string
>>> s = «mary had a little lamb»
>>> L = string.split(s)
>>> L
[‘mary’, ‘had’, ‘a’, ‘little’, ‘lamb’],br> >>> string.join(L, «-«)
‘mary-had-a-little-lamb’
Безусловно, в реальной жизни вы скорее всего будете делать со списком что-то еще, кроме немедленного объединения его вызовом .join() (возможно, что-то, включающее знакомую конструкцию for. in. ).
Стандартный модуль: re
Модуль re делает устаревшими модули regex и regsub, которые использовались в старых кодах на языке Python. Хотя в использовании regex сохраняются небольшие преимущества, они незначительны и не стоят того, чтобы использовать его в в новом коде. Устаревшие модули скорее всего будут исключены из новых версий Python, и в 1.6, возможно, будет включен усовершенствованный модуль re. Так что пользуйтесь re для регулярных выражений.
Регулярные выражения сложны. Можно написать книгу на эту тему, и это на самом деле многие сделали! Эта статья постарается ухватить «гештальт» (базовую суть) регулярных выражений и позволит читателю извлечь ее.
Регулярное выражение — это краткий путь к описанию образцов (pattern), которые могут встретиться в тексте. Встречаются ли некие символы? В определенном ли порядке? Повторяются ли участки текста данное число раз? Исключено ли совпадение других участков? Концептуально это не так уж непохоже на то, как вы интуитивно описываете понятие образца на естественном языке. Хитрость состоит в кодировке этого описания в компактный синтаксис регулярных выражений.
Рассматривайте регулярное выражение как отдельную проблему программирования, несмотря на то, что в нем могут быть задействованы только одна-две строки кода; эти строки, в сущности, составляют небольшую программу.
Начните с самых маленьких фрагментов. На нижнем уровне любое регулярное выражение будет включать сопоставление с конкретными «символьными классами» («character classes»). Простейший символьный класс представляет собой отдельный символ, который просто входит в образец как литерал. Вам часто может понадобиться сопоставить класс символов. Вы можете обозначить класс, заключив его в квадратные скобки; внутри скобок вы можете поместить как набор, так и диапазоны символов, которые обозначаются тире. Кроме того, вы можете использовать различные именованные символьные классы, корректные для вашей платформы и национального языка. Несколько примеров:
>>> import re
>>> s = «mary had a little lamb»
>>> if re.search(«m», s): print «Match!» # char literal
.
Match!
>>> if re.search(«[@A-Z]», s): print «Match!» # char class
. # match either at-sign or capital letter
.
>>> if re.search(«\d», s): print «Match!» # digits class
.
Вы можете представлять символьные классы в виде «атомов» регулярных выражений и скорее всего захотите сгруппировать эти атомы в «молекулы». Это можно сделать с помощью комбинации группировки и повторения. Группировка обозначается круглыми скобками: каждое из подвыражений, содержащихся в скобках, рассматривается как атомарное для последующей группировки или повторения. Повторение отмечается одним из следующих операторов: «*» означающего «нуль или более»; «+» означающего «один или более»; «?» означающего «нуль или один». В качестве примера взгляните на выражение:
Чтобы строка соответствовала этому выражению, она должна содержать нечто, начинающееся с «ABC» и заканчивающееся на «XYZ» — но что должно быть в середине? Средним подвыражением является ([d-w]*\d\d?), сопровождаемое оператором «один или много». Таким образом, середина строки должна состоять из одного (или двух, или одной тысячи) фрагментов, соответствующих подвыражению в скобках. Строка «ABCXYZ» ему не соответствует, так как не содержит необходимых элементов в середине.
Что же представляет собой это внутреннее подвыражение? Оно начинается с нуля или более букв в интервале от d до w. Важно отметить, что нуль букв представляет правильное сопоставление, которое может быть контринтуитивным, если вы воспользуетесь для его описания словом «несколько». В следующей строке должна быть в точности одна цифра; затем ни одной или одна дополнительная цифра. (Первый цифровой символьный класс не имеет оператора повторения, тем самым просто встречается один раз. Второй цифровой символьный класс имеет оператор «?»). Короче говоря, все это подразумевает «одну или несколько цифр». Некоторые удовлетворяющие регулярному выражению строки выглядят так:
ABC1234567890XYZ
ABCd12e1f37g3XYZ
ABC1XYZ
А вот несколько выражений, которые не сопоставляются c этим выражением:
ABC123456789dXYZ
ABCdefghijklmnopqrstuvwXYZ
ABcd12e1f37g3XYZ
ABC12345%67890XYZ
ABCD12E1F37G3XYZ
Потребуется некоторая практика, чтобы научиться созданию и пониманию регулярных выражений. Однако как только вы освоите регулярные выражения, в вашем распоряжении окажется мощная выразительная сила. Все это говорит о том, что часто проще использовать регулярные выражения для решения проблемы, которая вполне может быть решена и с помощью более примитивных (и быстрых) инструментов, например модуля string.
Ресурсы:
Почитайте об mxTextTools, быстрой библиотеке обработки текста для Python.
A regular expressions how-to документ на www.python.org.
Автор: Дэйвид Мерц
readline — GNU readline interface¶
The readline module defines a number of functions to facilitate completion and reading/writing of history files from the Python interpreter. This module can be used directly, or via the rlcompleter module, which supports completion of Python identifiers at the interactive prompt. Settings made using this module affect the behaviour of both the interpreter’s interactive prompt and the prompts offered by the built-in input() function.
Readline keybindings may be configured via an initialization file, typically .inputrc in your home directory. See Readline Init File in the GNU Readline manual for information about the format and allowable constructs of that file, and the capabilities of the Readline library in general.
The underlying Readline library API may be implemented by the libedit library instead of GNU readline. On macOS the readline module detects which library is being used at run time.
The configuration file for libedit is different from that of GNU readline. If you programmatically load configuration strings you can check for the text “libedit” in readline.__doc__ to differentiate between GNU readline and libedit.
If you use editline/ libedit readline emulation on macOS, the initialization file located in your home directory is named .editrc . For example, the following content in ~/.editrc will turn ON vi keybindings and TAB completion:
python:bind -v python:bind ^I rl_complete
Init file¶
The following functions relate to the init file and user configuration:
readline. parse_and_bind ( string ) ¶
Execute the init line provided in the string argument. This calls rl_parse_and_bind() in the underlying library.
readline. read_init_file ( [ filename ] ) ¶
Execute a readline initialization file. The default filename is the last filename used. This calls rl_read_init_file() in the underlying library.
Line buffer¶
The following functions operate on the line buffer:
Return the current contents of the line buffer ( rl_line_buffer in the underlying library).
readline. insert_text ( string ) ¶
Insert text into the line buffer at the cursor position. This calls rl_insert_text() in the underlying library, but ignores the return value.
Change what’s displayed on the screen to reflect the current contents of the line buffer. This calls rl_redisplay() in the underlying library.
History file¶
The following functions operate on a history file:
readline. read_history_file ( [ filename ] ) ¶
Load a readline history file, and append it to the history list. The default filename is ~/.history . This calls read_history() in the underlying library.
readline. write_history_file ( [ filename ] ) ¶
Save the history list to a readline history file, overwriting any existing file. The default filename is ~/.history . This calls write_history() in the underlying library.
readline. append_history_file ( nelements [ , filename ] ) ¶
Append the last nelements items of history to a file. The default filename is ~/.history . The file must already exist. This calls append_history() in the underlying library. This function only exists if Python was compiled for a version of the library that supports it.
New in version 3.5.
readline. get_history_length ( ) ¶ readline. set_history_length ( length ) ¶
Set or return the desired number of lines to save in the history file. The write_history_file() function uses this value to truncate the history file, by calling history_truncate_file() in the underlying library. Negative values imply unlimited history file size.
History list¶
The following functions operate on a global history list:
Clear the current history. This calls clear_history() in the underlying library. The Python function only exists if Python was compiled for a version of the library that supports it.
Return the number of items currently in the history. (This is different from get_history_length() , which returns the maximum number of lines that will be written to a history file.)
readline. get_history_item ( index ) ¶
Return the current contents of history item at index. The item index is one-based. This calls history_get() in the underlying library.
readline. remove_history_item ( pos ) ¶
Remove history item specified by its position from the history. The position is zero-based. This calls remove_history() in the underlying library.
readline. replace_history_item ( pos , line ) ¶
Replace history item specified by its position with line. The position is zero-based. This calls replace_history_entry() in the underlying library.
readline. add_history ( line ) ¶
Append line to the history buffer, as if it was the last line typed. This calls add_history() in the underlying library.
readline. set_auto_history ( enabled ) ¶
Enable or disable automatic calls to add_history() when reading input via readline. The enabled argument should be a Boolean value that when true, enables auto history, and that when false, disables auto history.
New in version 3.6.
CPython implementation detail: Auto history is enabled by default, and changes to this do not persist across multiple sessions.
Startup hooks¶
readline. set_startup_hook ( [ function ] ) ¶
Set or remove the function invoked by the rl_startup_hook callback of the underlying library. If function is specified, it will be used as the new hook function; if omitted or None , any function already installed is removed. The hook is called with no arguments just before readline prints the first prompt.
readline. set_pre_input_hook ( [ function ] ) ¶
Set or remove the function invoked by the rl_pre_input_hook callback of the underlying library. If function is specified, it will be used as the new hook function; if omitted or None , any function already installed is removed. The hook is called with no arguments after the first prompt has been printed and just before readline starts reading input characters. This function only exists if Python was compiled for a version of the library that supports it.
Completion¶
The following functions relate to implementing a custom word completion function. This is typically operated by the Tab key, and can suggest and automatically complete a word being typed. By default, Readline is set up to be used by rlcompleter to complete Python identifiers for the interactive interpreter. If the readline module is to be used with a custom completer, a different set of word delimiters should be set.
readline. set_completer ( [ function ] ) ¶
Set or remove the completer function. If function is specified, it will be used as the new completer function; if omitted or None , any completer function already installed is removed. The completer function is called as function(text, state) , for state in 0 , 1 , 2 , …, until it returns a non-string value. It should return the next possible completion starting with text.
The installed completer function is invoked by the entry_func callback passed to rl_completion_matches() in the underlying library. The text string comes from the first parameter to the rl_attempted_completion_function callback of the underlying library.
Get the completer function, or None if no completer function has been set.
Get the type of completion being attempted. This returns the rl_completion_type variable in the underlying library as an integer.
readline. get_begidx ( ) ¶ readline. get_endidx ( ) ¶
Get the beginning or ending index of the completion scope. These indexes are the start and end arguments passed to the rl_attempted_completion_function callback of the underlying library. The values may be different in the same input editing scenario based on the underlying C readline implementation. Ex: libedit is known to behave differently than libreadline.
readline. set_completer_delims ( string ) ¶ readline. get_completer_delims ( ) ¶
Set or get the word delimiters for completion. These determine the start of the word to be considered for completion (the completion scope). These functions access the rl_completer_word_break_characters variable in the underlying library.
readline. set_completion_display_matches_hook ( [ function ] ) ¶
Set or remove the completion display function. If function is specified, it will be used as the new completion display function; if omitted or None , any completion display function already installed is removed. This sets or clears the rl_completion_display_matches_hook callback in the underlying library. The completion display function is called as function(substitution, [matches], longest_match_length) once each time matches need to be displayed.
Example¶
The following example demonstrates how to use the readline module’s history reading and writing functions to automatically load and save a history file named .python_history from the user’s home directory. The code below would normally be executed automatically during interactive sessions from the user’s PYTHONSTARTUP file.
import atexit import os import readline histfile = os.path.join(os.path.expanduser("~"), ".python_history") try: readline.read_history_file(histfile) # default history len is -1 (infinite), which may grow unruly readline.set_history_length(1000) except FileNotFoundError: pass atexit.register(readline.write_history_file, histfile)
This code is actually automatically run when Python is run in interactive mode (see Readline configuration ).
The following example achieves the same goal but supports concurrent interactive sessions, by only appending the new history.
import atexit import os import readline histfile = os.path.join(os.path.expanduser("~"), ".python_history") try: readline.read_history_file(histfile) h_len = readline.get_current_history_length() except FileNotFoundError: open(histfile, 'wb').close() h_len = 0 def save(prev_h_len, histfile): new_h_len = readline.get_current_history_length() readline.set_history_length(1000) readline.append_history_file(new_h_len - prev_h_len, histfile) atexit.register(save, h_len, histfile)
The following example extends the code.InteractiveConsole class to support history save/restore.
import atexit import code import os import readline class HistoryConsole(code.InteractiveConsole): def __init__(self, locals=None, filename="", histfile=os.path.expanduser("~/.console-history")): code.InteractiveConsole.__init__(self, locals, filename) self.init_history(histfile) def init_history(self, histfile): readline.parse_and_bind("tab: complete") if hasattr(readline, "read_history_file"): try: readline.read_history_file(histfile) except FileNotFoundError: pass atexit.register(self.save_history, histfile) def save_history(self, histfile): readline.set_history_length(1000) readline.write_history_file(histfile)
Чтение файлов#
Посмотрим как считывать содержимое файлов, на примере файла r1.txt:
! service timestamps debug datetime msec localtime show-timezone year service timestamps log datetime msec localtime show-timezone year service password-encryption service sequence-numbers ! no ip domain lookup ! ip ssh version 2 !
read #
Метод read — считывает весь файл в одну строку.
Пример использования метода read :
In [1]: f = open('r1.txt') In [2]: f.read() Out[2]: '!\nservice timestamps debug datetime msec localtime show-timezone year\nservice timestamps log datetime msec localtime show-timezone year\nservice password-encryption\nservice sequence-numbers\n!\nno ip domain lookup\n!\nip ssh version 2\n!\n' In [3]: f.read() Out[3]: ''
При повторном чтении файла в 3 строке, отображается пустая строка. Так происходит из-за того, что при вызове метода read , считывается весь файл. И после того, как файл был считан, курсор остается в конце файла. Управлять положением курсора можно с помощью метода seek .
readline #
Построчно файл можно считать с помощью метода readline :
In [4]: f = open('r1.txt') In [5]: f.readline() Out[5]: '!\n' In [6]: f.readline() Out[6]: 'service timestamps debug datetime msec localtime show-timezone year\n'
Но чаще всего проще пройтись по объекту file в цикле, не используя методы read. :
In [7]: f = open('r1.txt') In [8]: for line in f: . print(line) . ! service timestamps debug datetime msec localtime show-timezone year service timestamps log datetime msec localtime show-timezone year service password-encryption service sequence-numbers ! no ip domain lookup ! ip ssh version 2 !
readlines #
Еще один полезный метод — readlines . Он считывает строки файла в список:
In [9]: f = open('r1.txt') In [10]: f.readlines() Out[10]: ['!\n', 'service timestamps debug datetime msec localtime show-timezone year\n', 'service timestamps log datetime msec localtime show-timezone year\n', 'service password-encryption\n', 'service sequence-numbers\n', '!\n', 'no ip domain lookup\n', '!\n', 'ip ssh version 2\n', '!\n']
Если нужно получить строки файла, но без перевода строки в конце, можно воспользоваться методом split и как разделитель, указать символ \n :
In [11]: f = open('r1.txt') In [12]: f.read().split('\n') Out[12]: ['!', 'service timestamps debug datetime msec localtime show-timezone year', 'service timestamps log datetime msec localtime show-timezone year', 'service password-encryption', 'service sequence-numbers', '!', 'no ip domain lookup', '!', 'ip ssh version 2', '!', '']
Обратите внимание, что последний элемент списка — пустая строка.
Если перед выполнением split , воспользоваться методом rstrip , список будет без пустой строки в конце:
In [13]: f = open('r1.txt') In [14]: f.read().rstrip().split('\n') Out[14]: ['!', 'service timestamps debug datetime msec localtime show-timezone year', 'service timestamps log datetime msec localtime show-timezone year', 'service password-encryption', 'service sequence-numbers', '!', 'no ip domain lookup', '!', 'ip ssh version 2', '!']
seek #
До сих пор, файл каждый раз приходилось открывать заново, чтобы снова его считать. Так происходит из-за того, что после методов чтения, курсор находится в конце файла. И повторное чтение возвращает пустую строку.
Чтобы ещё раз считать информацию из файла, нужно воспользоваться методом seek , который перемещает курсор в необходимое положение.
Пример открытия файла и считывания содержимого:
In [15]: f = open('r1.txt') In [16]: print(f.read()) ! service timestamps debug datetime msec localtime show-timezone year service timestamps log datetime msec localtime show-timezone year service password-encryption service sequence-numbers ! no ip domain lookup ! ip ssh version 2 !
Если вызывать ещё раз метод read , возвращается пустая строка:
In [17]: print(f.read())
Но с помощью метода seek можно перейти в начало файла (0 означает начало файла):
In [18]: f.seek(0)
После того как с помощью seek курсор был переведен в начало файла, можно опять считывать содержимое:
In [19]: print(f.read()) ! service timestamps debug datetime msec localtime show-timezone year service timestamps log datetime msec localtime show-timezone year service password-encryption service sequence-numbers ! no ip domain lookup ! ip ssh version 2 !