Python чтение из файла построчно: Чтение из большого файла (несколько миллионов строк) как правильно? — Хабр Q&A

Python. Примеры работы с текстовыми файлами

В данной теме представлены примеры записи и чтения информации для текстовых файлов.

Содержание

Поиск на других ресурсах:

1. Чтение/запись списка, содержащего n целых чисел

В примере демонстрируются следующие операции:

• создание списка из 10 случайных чисел;
• сохранение списка в текстовом файле;
• чтение из файла в новый список с целью контроля.

Текст программы следующий:

# Запись/чтение списка случайных чисел
# 1. Подключить модуль random
import random

# 2. Создать список из 10 случайных чисел
i = 0
lst = []
while i<10:
    number = random.randint(0, 101) # число от 0 до 100
    lst = lst + [number]
    i = i+1

print("lst = ", lst)

# 3. Сохранить список в текстовом файле
# 3.1. Открыть файл для записи
f = open('file.txt', 'wt')

# 3.2. Записать количество элементов в списке
s = str(len(lst)) # Конвертировать целое число в строку
f.write(s + '\n') # Записать строку

# 3.3. Записать каждый элемент
for i in lst:
    s = str(i) # конвертировать элемент списка в строку
    f.write(s + ' ') # записать число в строку

# 4. Закрыть файл
f.close()

# -------------------------------------------
# 5. Чтение из файла 'file.txt'
f = open('file.txt', 'r')

# 6. Прочитать из файла числа и сформировать список
# 6.1. Прочитать количество элементов в списке,
# сначала читается строка, затем эта строка
# конвертируется в целое число методом int()
s = f.readline()
n = int(s)

# 6.2. Создать пустой список
lst2 = []

# 6.3. Реализовать обход файла по строкам и считать числа.
# Для чтения строк используется итератор файла.
for line in f:
    # метод split - разбивает на слова на основании символа пробел
    strs = line.split(' ') # получить массив строк strs

    # Вывести strs с целью контроля
    print("strs = ", strs)

    # прочитать все слова и записать их в список как целые числа
    for s in strs:
        if s!='':
            lst2 = lst2 + [int(s)] # добавить число к списку

# 6.4. Вывести результат для контроля
print("n = ", len(lst2))
print("lst2 = ", lst2)

# 6.5. Закрыть файл - необязательно
f.close()

Результат работы программы

lst = [48, 89, 1, 36, 68, 26, 61, 38, 1, 6]
strs = ['48', '89', '1', '36', '68', '26', '61', '38', '1', '6', '']
n = 10
lst2 = [48, 89, 1, 36, 68, 26, 61, 38, 1, 6]

  ⇑

2. Чтение/запись списка, содержащего строки

При чтении/записи строк не нужно реализовывать дополнительные преобразования из одного типа в другой, так как данные из файла читаются в виде строк.

# Запись/чтение списка строк
# 1. Заданный список строк
L = [ 'abc', 'bcd', 'cba', 'abd']

# 2. Открыть файл для записи
f = open('filestrs.txt', 'wt')

# 3. Цикл записи строк

for s in L:
    # записать каждую строку в отдельную строку файла
    f.write(s + '\n')

# 4. Закрыть файл
f.close()

# -------------------------------------------
# 5. Чтение из файла 'filestrs.txt'
f = open('filestrs.txt', 'rt')

# 6. Сформировать новый список
lst2 = [] # сначала пустой список

# 7. Реализовать обход файла по строкам и считать числа.
# Для чтения строк используется итератор файла.
for s in f:
    # Убрать последний символ '\n' из s
    s = s.rstrip()

    # Вывести s для контроля
    print("s = ", s)

    # Добавить строку s в список lst2
    lst2 = lst2 + [s]

# 8. Вывести список lst2 для контроля
print("lst2 = ", lst2)

# 9. Закрыть файл - необязательно
f.close()

Результат работы программы

s = abc
s = bcd
s = cba
s = abd
lst2 = ['abc', 'bcd', 'cba', 'abd']

  ⇑

3. Чтение/запись кортежа, содержащего объекты чисел с плавающей запятой

Пример демонстрирует запись и чтение кортежа, который содержит объекты чисел с плавающей запятой.

# Запись/чтение кортежа, содержащего объекты типа float.
# 1. Исходный кортеж
T1 = ( 3.8, 2.77, -11.23, 14.75)

# 2. Запись кортежа в файл

# 2.2. Открыть файл для записи в текстовом режиме
f = open('myfile5.txt', 'wt')

# 2.3. Цикл записи объектов в файл
for item in T1:
    # 2.3.1. Конвертировать item в строку
    s = str(item)

    # 2.3.2. Записать строку + символ ' ' пробел
    f.write(s + ' ')

    # 2.4. Закрыть файл
    f.close()

# 3. Чтение из файла, который содержит вещественные числа
# и создание нового кортежа T2
f = open('myfile5.txt', 'rt')

# 3.1. Создать пустой кортеж T2
T2 = ()

# 3.2. Чтение данных из файла и образование кортежа
for lines in f: # Использовать итератор файла
    # 3.2.1. Разбить строку lines на подстроки strings.
    # Любая подстрока strings[i] - это вещественное число,
    # представленное в строчном формате
    strings = lines.split(' ')

# 3.2.2. Обойти все подстроки в файле,
# конвертировать и добавить их к кортежу T2
for s in strings:
    if s != '': # если непустая строка
        # Конвертировать в вещественное число
        num = float(s)

        # Добавить к кортежу
        T2 += (num,)

# 3.3. Вывести кортеж для контроля
print("T2 = ", T2) # T2 = (3.8, 2.77, -11.23, 14.75)

# 3.4. Закрыть файл
f.close()

Результат работы программы

T2 = (3.8, 2.77, -11.23, 14.75)

Вид файла myfile5.txt

3.8 2.77 -11.23 14.75

  ⇑

4. Чтение/запись кортежа содержащего разнотипные объекты

В случае, если кортеж содержит объекты разных типов при записи/чтении важно придерживаться последовательности этапов конвертирования объектов в нужный тип. Ниже приведен пример записи и чтения кортежа, который содержит объекты целого, логического и строчного типов.

# Запись/чтение кортежа, содержащего разнотипные объекты
# 1. Запись кортежа в файл

# 1.1. Исходный кортеж
T1 = ( 5, True, "abcde fghi")

# 1.2. Открыть файл для записи в текстовом режиме
f = open('myfile4.txt', 'wt')

# 1.3. Поэлементная запись кортежа в файл,
# поскольку в кортеже есть строки, то записываем
# каждый элемент в отдельную строку
for item in T1:
    s = str(item) + '\n' # добавить символ новой строки
    f.write(s)

# Закрыть файл
f.close()

# 2. Чтение кортежа
f = open('myfile4.txt', 'rt')

# 2.1. Создать пустой кортеж
T3 = ()

# 2.2. Чтение данных из файла и создание кортежа
# Первым читается число типа int
s = f.readline()
T3 = T3 + (int(s),) # конкатенация кортежей

# Вторым читается логическое значение типа bool
s = f.readline()
T3 = T3 + (bool(s),)

# Третьим читается строка типа str
s = f.readline()
s = s.rstrip() # убрать символ '\n' из строки
T3 = T3 + (s,)

# 2.3. Вывести кортеж для контроля
print("T3 = ", T3) # T3 = (5, True, 'abcde fghi')

# 2.4. Закрыть файл
f.close()

Результат выполнения программы

T3 = (5, True, 'abcde fghi')

  ⇑

5. Чтение/запись словаря

Словарь также можно записывать в файл. В данном примере записывается и читается словарь, который содержит перечень номеров дней недели и их названий. Для облегчения чтения данных каждый элемент словаря размещается в отдельной строке.

# Запись/чтение словаря в текстовый файл.
# Словарь содержит объекты типа {int:str}

# 1. Исходный словарь - перечень дней недели и их номеров
D = { 1:'Sun', 2:'Mon', 3:'Tue', 4:'Wed', 5:'Thu', 6:'Fri', 7:'Sat' }

# 2. Запись словаря в файл

# 2.1. Открыть текстовый файл для записи
f = open('myfile6.txt', 'w')

# 2.2. Цикл записи элементов словаря в файл
for item in D:
    # 2.2.1. Сформировать строку вида key:value
    s = str(item) # взять ключ как строку
    s += ':' # добавить символ ':'
    s += D.get(item) # добавить значение value по его ключу
    s += '\n' # добавить символ новой строки

    # 2.2.2. Записать строку в файл
    f.write(s)

# 2.3. Закрыть файл
f.close()

# 3. Чтение из файла, который содержит данные словаря D
# 3.1. Открыть файл для чтения
f = open('myfile6.txt', 'rt')

# 3.2. Создать пустой словарь D2
D2 = {}

# 3.3. Чтение данных из файла и образование нового словаря
for lines in f: # Использовать итератор файла
    # 3.3.1. Любая подстрока lines - это элемент вида key:value
    # представленный в строчном формате.
    # Разбить lines на 2 подстроки
    strings = lines.split(':')

    # 3.3.2. Получить ключ и значение
    key = int(strings[0]) # получить ключ
    value = strings[1].rstrip() # получить значение без '\n'

    # 3.3.3. Добавить пару key:value к словарю D2
    D2[key] = value

# 3.4. Вывести словарь для контроля
print("D2 = ", D2)

# 3.5. Закрыть файл
f.close()

Результат работы программы

D2 = {1: 'Sun', 2: 'Mon', 3: 'Tue', 4: 'Wed', 5: 'Thu', 6: 'Fri', 7: 'Sat'}

Вид файла myfile6.txt

1:Sun
2:Mon
3:Tue
4:Wed
5:Thu
6:Fri
7:Sat

  ⇑

6. Чтение/запись двумерной матрицы целых чисел, представленной в виде списка

В примере демонстрируется запись и чтение двумерной матрицы целых чисел размерностью 3*4.

# Запись/чтение двумерной матрицы чисел
# 1. Исходная матрица целых чисел размером 3*4
M = [ [ 2, 1, -3],
      [ 4, 8, -2],
      [ 1, 2,  3],
      [ 7, -3, 8] ]

# 2. Запись матрицы в текстовый файл

# 2.1. Открыть текстовый файл для записи
f = open('myfile8.txt', 'w')

# 2.2. Цикл записи элементов матрицы в файл
#      в удобном для отображения виде
i = 0
while i < 4: # цикл по строкам
    j = 0
    while j < 3: # цикл по столбцам
        s = str(M[i][j])
        f.write(s + ' ') # между числами символ ' ' пробел
        j = j+1
    f.write('\n')
    i = i + 1

# 2.3. Закрыть файл
f.close()

# 3. Чтение матрицы из файла
# 3.1. Открыть файл для чтения
f = open('myfile8.txt', 'rt')

# 3.2. Создать пустой список
M2 = []

# 3.3. Чтение данных из файла и образование новой матрицы

i = 0
for line in f: # Использовать итератор файла
    # Конвертировать строку line в список строк
    lines = line.split(' ') # разбить строку line на подстроки lines

    # временный список
    lst = []

    # обход элементов в строке
    for ln in lines:
        # забрать символ '\n'
        ln = ln.rstrip()

        if ln != '':
            num = int(ln) # взять отдельное число
            lst = lst + [num] # добавить число к списку

    M2 = M2 + [lst] # добавить строку к результирующей матрице

# 3.4. Вывести матрицу M2 для контроля
print("M2 = ", M2) #

# 3.5. Закрыть файл
f.close()

Результат работы программы

M2 = [[2, 1, -3], [4, 8, -2], [1, 2, 3], [7, -3, 8]]

Вид файла myfile8.txt

2 1 -3
4 8 -2
1 2 3
7 -3 8

  ⇑

7. Чтение/запись множества, которое содержит целые числа

В примере демонстрируется возможный вариант сохранения множества в текстовом файле

# Запись/чтение множества в текстовом файле.

# 1. Задано множество целочисленных объектов
M = { 2, 3, -12, 22, 38 }

# 2. Запись множества в файл

# 2.1. Открыть текстовый файл для записи
f = open('myfile7.txt', 'w')

# 2.2. Цикл записи элементов множества в файл
for item in M:
    # 2.2.1. Конвертировать элемент множества в строку + '\n'
    s = str(item) + '\n'

    # 2.2.2. Записать строку в файл
    f.write(s)

# 2.3. Закрыть файл
f.close()

# 3. Чтение множества из файла
# 3.1. Открыть файл для чтения
f = open('myfile7.txt', 'rt')

# 3.2. Создать пустое множество
M2 = set()

# 3.3. Чтение данных из файла и образование нового множества
for line in f: # Использовать итератор файла
    # Конвертировать строку line в целое число
    num = int(line)
    M2 = M2.union({num})

# 3.4. Вывести множество для контроля
print("M2 = ", M2) # M2 = {2, 3, -12, 38, 22}

# 3.5. Закрыть файл
f.close()

Результат работы программы

M2 = {2, 3, -12, 38, 22}

Вид файла myfile7.txt

2
3
38
-12
22

  ⇑

8. Чтение/запись данных разных типов: список и кортеж

Чтобы записать в текстовый файл данные разных базовых типов нужно последовательно записать данные одного типа, затем другого типа. При считывании таких данных нужно придерживаться такого самого порядка чтобы не нарушить полученную структуру данных.

В примере демонстрируется последовательная запись в файл списка и кортежа. При чтении придерживается такая же последовательность: сначала читается список, затем кортеж. Список включает строки. Кортеж содержит вещественные числа. Чтобы облегчить работу по распознаванию формата файла, каждый записываемый (читаемый) элемент размещается в отдельной строке файла.
Поскольку список и кортеж могут содержать разное количество элементов, то в файл записываются их размерности.

# Запись/чтение данных разных типов.
# Обработка списка и кортежа.
# 1. Задан некоторый список строк и кортеж чисел
L = [ 'John Johnson', 'Peter Petrov', 'O Neill', 'J. Dunkan' ]
T = ( 2, 3.85, 7.77, -1.8, 5.25 )

# 2. Запись данных в файл: сначала записывается список, затем кортеж
# 2.1. Открыть текстовый файл для записи
f = open('myfile9.txt', 'w')

# 2.2. Записать количество элементов списка + '\n'
f.write(str(len(L)) + '\n')

# 2.3. Цикл записи элементов списка в файл
# Каждый из элементов списка размещается в новой строке.
for item in L: # обход списка
    f.write(item + '\n') # записать строку в файл

# 2.4. После списка записывается кортеж,
# каждый элемент кортежа размещается в отдельной строке.
# Сначала записать количество элементов кортежа
f.write(str(len(T)) + '\n')

# обход кортежа в цикле
for item in T:
    f.write(str(item) + '\n') # запись каждого элемента кортежа

# 2.3. Закрыть файл
f.close()

# 3. Чтение списка и кортежа из файла
# 3.1. Открыть файл для чтения
f = open('myfile9.txt', 'rt')

# 3.2. Создать результирующий пустой список
# и результирующий кортеж
L2 = []
T2 = ()

# 3.3. Чтение данных из файла и формирование списка L2
n = int(f.readline()) # прочитать количество элементов в списке

i = 0
while i < n: # цикл чтения строк из файла и образования списка
    s = f.readline().rstrip() # прочитать строку без символа '\n'
    if (s != ''):
        L2 += [s]
    i = i + 1

# 3.4. Прочитать количество элементов кортежа
n = int(f.readline())

i = 0
while i < n: # цикл чтения строк и образование кортежа
    s = f.readline()
    if (s != ''):
        T2 = T2 + (float(s),) # добавить вещественное число к кортежу
    i = i+1

# 3.5. Закрыть файл
f.close()

# Вывести список и кортеж для контроля
print("L2 = ", L2)
print("T2 = ", T2)

Результат работы программы

L2 = ['John Johnson', 'Peter Petrov', 'O Neill', 'J. Dunkan']
T2 = (2.0, 3.85, 7.77, -1.8, 5.25)

Вид файла myfile9.txt

4
John Johnson
Peter Petrov
O Neill
J. Dunkan
5
2
3.85
7.77
-1.8
5.25

  ⇑

Связанные темы

  ⇑

Как прочитать файл в список в Python

Вы здесь: Главная — Python — Основы Python — Как прочитать файл в список в Python

Чтение файлов в Python — это достаточно тривиальная процедура. Но несмотря на внешнюю простоту, здесь может возникнуть ряд вопросов, которые новичков могут поставить в ступор. Так, например, если не указать кодировку utf-8 при открытии файла, то вы можете получить ошибку при чтении файлов в кириллице.

Чтение файла в список — это операция требуется для многих задач. Если Вы знаете PHP, то знаете, что в PHP есть функция file, которая читает файл и преобразует его в массив.

В следующем примере мы реализуем подобную функцию в Python.

Используем так:

• Создано 24.12.2019 09:36:06
• Михаил Русаков

Копирование материалов разрешается только с указанием автора (Михаил Русаков) и индексируемой прямой ссылкой на сайт (http://myrusakov.ru)!

Добавляйтесь ко мне в друзья ВКонтакте: http://vk.com/myrusakov.
Если Вы хотите дать оценку мне и моей работе, то напишите её в моей группе: http://vk.com/rusakovmy.

Если Вы не хотите пропустить новые материалы на сайте,
то Вы можете подписаться на обновления: Подписаться на обновления

Если у Вас остались какие-либо вопросы, либо у Вас есть желание высказаться по поводу этой статьи, то Вы можете оставить свой комментарий внизу страницы.

Порекомендуйте эту статью друзьям:

Если Вам понравился сайт, то разместите ссылку на него (у себя на сайте, на форуме, в контакте):

1. Кнопка:
   <a href=»https://myrusakov.ru» target=»_blank»><img src=»https://myrusakov.ru/images/button.gif» alt=»Как создать свой сайт» /></a>

   Она выглядит вот так:

2. Текстовая ссылка:
   <a href=»https://myrusakov.ru» target=»_blank»>Как создать свой сайт</a>

   Она выглядит вот так: Как создать свой сайт

3. BB-код ссылки для форумов (например, можете поставить её в подписи):
   [URL=»https://myrusakov.ru»]Как создать свой сайт[/URL]

Чтение данных из файла и запись в файл

Создание файла

В Python, чтобы создать файл, надо его открыть в режиме записи (‘w’, ‘wb’) или дозаписи (‘a’, ‘ab’).

f2 = open("text2.txt", 'w')

Функция open() возвращает файловый объект.

Без ‘b’ создается текстовый файл, представляющий собой поток символов. С ‘b’ — файл, содержащий поток байтов.

В Python также существует режим ‘x’ или ‘xb’. В этом режиме проверяется, есть ли файл. Если файл с определенным именем уже существует, он не будет создан. В режиме ‘w’ файл создается заново, старый при этом теряется.

>>> f1 = open('text1.txt', 'w')
>>> f2 = open('text1.txt', 'x')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: 'text1.txt'
>>> f3 = open('text1.txt', 'w')

Чтение данных из файла

Если в функцию open() не передается второй аргумент, файл расценивается как текстовый и открывается на чтение.

Попытка открыть на чтение несуществующий файл вызывает ошибку.

>>> f = open("text10.txt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'text10.txt'

Перехватить возникшее исключение можно с помощью конструкции try-except.

>>> try:
...     f = open("text10.txt")
... except IOError:
...     print ("No file")
... 
No file

Получить все данные из файла можно с помощью метода read() файлового объекта, предварительно открыв файл на чтение. При этом файловый объект изменяется и получить из него данные еще раз не получится.

>>> f = open("text.txt")
>>> f
<_io.TextIOWrapper name='text.txt' mode='r' encoding='UTF-8'>
>>> fd = f.read()
>>> fd1 = f.read()
>>> fd
'Hello\n\tOne\n   Two\nThree Four\nШесть!\n'
>>> fd1
''

Методу read() может быть передан один аргумент, обозначающий количество байт для чтения.

>>> f = open("text.txt")
>>> fd = f.read(10)
>>> fd1 = f.read(5)
>>> fd
'Hello\n\tOne'
>>> fd1
'\n   T'

Метод readline() позволяет получать данные построчно.

>>> f = open("text.txt")
>>> f.readline()
'Hello\n'
>>> f.readline()
'\tOne\n'
>>> f.readline()
'   Two\n'

Принимает аргумент — число байт.

>>> f.readline(3)
'Thr'
>>> f.readline(3)
'ee '
>>> f.readline(3)
'Fou'
>>> f.readline(3)
'r\n'
>>> f.readline(5)
'Шесть'
>>> f.readline(5)
'!\n'

Метод readlines() считывает все строки и помещает их в список.

>>> f = open("text.txt")
>>> fd = f.readlines()
>>> fd
['Hello\n', '\tOne\n', '   Two\n', 'Three Four\n', 'Шесть!\n']

Может принимать количество байт, но дочитывает строку до конца.

>>> f = open("text.txt")
>>> fd = f.readlines(3)
>>> fd
['Hello\n']
>>> fd1 = f.readlines(6)
>>> fd1
['\tOne\n', '   Two\n']

Запись данных в файл

Записать данные в файл можно с помощью метода write(), который возвращает число записанных символов.

>>> f1 = open("text1.txt", 'w')
>>> f1.write("Table, cup.\nBig, small.")
23
>>> a = f1.write("Table, cup.\nBig, small.")
>>> type(a)
<class 'int'>

Файл, открытый на запись, нельзя прочитать. Для этого требуется его закрыть, а потом открыть на чтение.

>>> f1.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
io.UnsupportedOperation: not readable
>>> f1.close()
>>> f1 = open("text1.txt", 'r')
>>> f1.read()
'Table, cup.\nBig, small.Table, cup.\nBig, small.'

С помощью метода writelines() можно записать в файл итерируемую последовательность.

>>> a = [1,2,3,4,5,6,7,8,9,0]
>>> f = open("text2.txt",'w')
>>> f.writelines("%s\n" % i for i in a)
>>> f.close()
>>> open("text2.txt").read()
'1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n'
>>> print(open("text2.txt").read())
1
2
3
4
5
6
7
8
9
0

Смена позиции в файле

>>> f = open('text.txt')
>>> f.read()
'Hello\n\tOne\n   Two\nThree Four\nШесть!\n'
>>> f.close()
>>> f = open('text.txt')
>>> f.seek(10)
10
>>> f.read()
'\n   Two\nThree Four\nШесть!\n'

Двоичные файлы

Пример копирования изображения:

>>> f1 = open('flag.png', 'rb')
>>> f2 = open('flag2.png', 'wb')
>>> f2.write(f1.read())
446
>>> f1.close()
>>> f2.close()

Модуль struct позволяет преобразовывать данные к бинарному виду и обратно.

>>> f = open('text3.txt', 'wb')
>>> f.write('3')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' does not support the buffer interface
>>> d = struct.pack('>i',3)
>>> d
b'\x00\x00\x00\x03'
>>> f.write(d)
4
>>> f.close()
>>> f = open('text3.txt')
>>> d = f.read()
>>> d
'\x00\x00\x00\x03'
>>> struct.unpack('>i',d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' does not support the buffer interface
>>> f = open('text3.txt', 'rb')
>>> d = f.read()
>>> d
b'\x00\x00\x00\x03'
>>> struct.unpack('>i',d)
(3,)

Как читать большой файл построчно в Python – 10 Ответов

Какой-то контекст перед тем, куда я иду. Фрагменты кода находятся в конце.

Когда я могу, я предпочитаю использовать инструмент с открытым исходным кодом, например h3O, для чтения файлов с супервысокой производительности в формате CSV, но этот инструмент ограничен набором функций. В итоге я написал много кода для создания конвейеров данных, прежде чем загружать их в кластер h3O для надлежащего обучения.

Я читал файлы, такие как набор данных HIGGS объемом 8 ГБ, из репозитория UCI и даже 40 ГБ CSV файлов для целей науки о данных значительно быстрее, добавляя много parallelism с объектом объединения и обработкой библиотеки мультипроцессора. Например, кластеризация с поиском ближайших соседей, а также алгоритмы кластеризации DBSCAN и Markov требуют некоторого параллельного программирования, чтобы обойти некоторые серьезные проблемы памяти и времени работы настенных часов.

Мне обычно нравится разбивать файл по-разному на части, используя сначала инструменты gnu, а затем glob-filemask их все, чтобы находить и читать их параллельно в программе python. Обычно я использую что-то вроде 1000 + частичных файлов. Выполнение этих трюков очень помогает при скорости обработки и ограничениях памяти.

pandas dataframe.read_csv является однопоточной, поэтому вы можете сделать эти трюки, чтобы сделать pandas довольно быстрым, запустив map() для параллельного выполнения. Вы можете использовать htop, чтобы увидеть, что с простым старым последовательным pandas dataframe.read_csv, 100% процессор только на одном ядре является фактическим узким местом в pd.read_csv, а не на диске вообще.

Я должен добавить, что я использую SSD на быстрой шине видеокарты, а не крутящий HD на шине SATA6 плюс 16 ядер процессора.

Кроме того, другой метод, который я обнаружил, отлично работает в некоторых приложениях, — это параллельный файл CSV, который читает все в одном гигантском файле, начиная каждый рабочий с разным смещением в файл, а не предварительно разбивая один большой файл на многие файлы деталей. Используйте python file seek() и tell() в каждом параллельном рабочем столе, чтобы читать большой текстовый файл в полосах, в разных байтовых байтах и ​​в конце-байтах в большом файле, одновременно одновременно. Вы можете сделать regex findall в байтах и ​​возвратить количество строк. Это частичная сумма. Наконец, суммируем частичные суммы, чтобы получить глобальную сумму, когда функция карты возвращается после завершения работ.

Ниже приведены некоторые примеры тестов, использующих трюк смещения параллельного байта:

Я использую 2 файла: HIGGS.csv — 8 ГБ. Это из репозитория обучения машин UCI. all_bin.csv — 40,4 ГБ и является моим текущим проектом. Я использую 2 программы: GNU wc-программу, которая поставляется с Linux, и чистую программу python fastread.py, которую я разработал.

HP-Z820:/mnt/fastssd/fast_file_reader$ ls -l /mnt/fastssd/nzv/HIGGS.csv
-rw-rw-r-- 1 8035497980 Jan 24 16:00 /mnt/fastssd/nzv/HIGGS.csv

HP-Z820:/mnt/fastssd$ ls -l all_bin.csv
-rw-rw-r-- 1 40412077758 Feb  2 09:00 all_bin.csv

ga@ga-HP-Z820:/mnt/fastssd$ time python fastread.py --fileName="all_bin.csv" --numProcesses=32 --balanceFactor=2
2367496

real    0m8.920s
user    1m30.056s
sys 2m38.744s

In [1]: 40412077758. / 8.92
Out[1]: 4530501990.807175

Это примерно 4,5 ГБ/с, или 45 Гбит/с, скорость отсечения файла. Это не крутой жесткий диск, мой друг. Это на самом деле Samsung Pro 950 SSD.

Ниже приведен тест скорости для того же файла, который подсчитывается по строке с помощью gnu wc, чистой компилируемой программы C.

Что круто, вы можете видеть, что моя чистая программа python по сути соответствовала скорости скомпилированной программы gnu wc в этом случае. Python интерпретируется, но C скомпилирован, так что это довольно интересный подвиг скорости, я думаю, вы согласитесь. Конечно, wc действительно нужно заменить на параллельную программу, и тогда это действительно будет бить носки с моей программы python. Но, как и сегодня, gnu wc — это просто последовательная программа. Вы делаете то, что можете, и python может выполнять параллель сегодня. Компиляция Cython может помочь мне (в другое время). Кроме того, файлы с отображением памяти еще не были изучены.

HP-Z820:/mnt/fastssd$ time wc -l all_bin.csv
2367496 all_bin.csv

real    0m8.807s
user    0m1.168s
sys 0m7.636s


HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=16 --balanceFactor=2
11000000

real    0m2.257s
user    0m12.088s
sys 0m20.512s

HP-Z820:/mnt/fastssd/fast_file_reader$ time wc -l HIGGS.csv
11000000 HIGGS.csv

real    0m1.820s
user    0m0.364s
sys 0m1.456s

Заключение: скорость хороша для чистой программы python по сравнению с программой на C. Однако его недостаточно для использования чистой программы python над программой C, по крайней мере, для целей linecounting. Как правило, этот метод может использоваться для другой обработки файлов, поэтому этот код на Python по-прежнему хорош.

Вопрос: Компиляция регулярного выражения только один раз и передача его всем работникам улучшит скорость? Ответ. Предварительная компиляция Regex НЕ помогает в этом приложении. Я полагаю, причина в том, что преобладание сериализации и создания процесса для всех рабочих доминирует.

Еще одна вещь. Поддерживает ли параллельное чтение файла CSV? Является ли диск узким местом, или это центральный процессор? Многие так называемые наиболее популярные ответы на stackoverflow содержат общую мудрость разработчиков, для которой вам нужен только один поток, чтобы читать файл, что лучше всего сделать, говорят они. Они уверены, хотя?

Давайте выясним:

HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=16 --balanceFactor=2
11000000

real    0m2.256s
user    0m10.696s
sys 0m19.952s

HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=1 --balanceFactor=1
11000000

real    0m17.380s
user    0m11.124s
sys 0m6.272s

О да, да. Параллельное чтение файлов работает достаточно хорошо. Хорошо, ты идешь!

Ps. В случае, если некоторые из вас хотели бы знать, что, если balanceFactor было 2 при использовании одного рабочего процесса? Ну, его ужасно:

HP-Z820:/mnt/fastssd/fast_file_reader$ time python fastread.py --fileName="HIGGS.csv" --numProcesses=1 --balanceFactor=2
11000000

real    1m37.077s
user    0m12.432s
sys 1m24.700s

Основные части программы python fastread.py:

fileBytes = stat(fileName).st_size  # Read quickly from OS how many bytes are in a text file
startByte, endByte = PartitionDataToWorkers(workers=numProcesses, items=fileBytes, balanceFactor=balanceFactor)
p = Pool(numProcesses)
partialSum = p.starmap(ReadFileSegment, zip(startByte, endByte, repeat(fileName))) # startByte is already a list. fileName is made into a same-length list of duplicates values.
globalSum = sum(partialSum)
print(globalSum)


def ReadFileSegment(startByte, endByte, fileName, searchChar='\n'):  # counts number of searchChar appearing in the byte range
    with open(fileName, 'r') as f:
        f.seek(startByte-1)  # seek is initially at byte 0 and then moves forward the specified amount, so seek(5) points at the 6th byte.
        bytes = f.read(endByte - startByte + 1)
        cnt = len(re.findall(searchChar, bytes)) # findall with implicit compiling runs just as fast here as re.compile once + re.finditer many times.
    return cnt

Def для PartitionDataToWorkers — это просто обычный последовательный код. Я оставил его на случай, если кто-то еще захочет получить какую-то информацию о том, что такое параллельное программирование. Я отдал бесплатно более тяжелые части: проверенный и действующий параллельный код, для вашего обучения.

Благодаря: проекту h3O с открытым исходным кодом, Arno и Cliff и сотрудникам h3O за их отличные программные и обучающие видеоролики, которые предоставили мне вдохновение для этого чистого высокопроизводительного параллельного байтового считывателя с питонами, как показано выше. h3O выполняет параллельное чтение файлов с использованием java, может быть вызвана программами python и R и безумно быстро, быстрее, чем что-либо на планете, при чтении больших CSV файлов.

Как прочитать файл построчно в список? – 39 Ответов

Чтобы прочитать файл в списке, вам нужно сделать три вещи:

• Открыть файл
• Прочтите файл
• Храните содержимое в виде списка

К счастью, Python упрощает выполнение этих задач, поэтому самый короткий способ прочитать файл в списке:

lst = list(open(filename))

Однако я добавлю еще несколько объяснений.

Открытие файла

Я предполагаю, что вы хотите открыть определенный файл, и вы не имеете дело непосредственно с файловым дескриптором (или файлоподобным дескриптором). Наиболее часто используемая функция для открытия файла в Python open, он принимает один обязательный аргумент и два необязательных в Python 2.7:

• Имя файла
• Режим
• Буферизация (я проигнорирую этот аргумент в этом ответе)

Имя файла должно быть строкой, представляющей путь к файлу. Например:

open('afile')   # opens the file named afile in the current working directory
open('adir/afile')            # relative path (relative to the current working directory)
open('C:/users/aname/afile')  # absolute path (windows)
open('/usr/local/afile')      # absolute path (linux)

Обратите внимание, что необходимо указать расширение файла. Это особенно важно для пользователей Windows, поскольку файлы, такие как .txt или .doc, и т.д. Скрыты по умолчанию при просмотре в проводнике.

Второй аргумент — это mode, он r по умолчанию, что означает «только для чтения». Это именно то, что вам нужно в вашем случае.

Но если вы действительно хотите создать файл и/или записать в файл, вам понадобится другой аргумент. Если вам нужен обзор, есть отличный ответ.

Для чтения файла вы можете опустить mode или передать его явно:

open(filename)
open(filename, 'r')

Оба откроют файл в режиме только для чтения. Если вы хотите прочитать в двоичном файле в Windows, вам нужно использовать режим rb:

open(filename, 'rb')

На других платформах 'b' (двоичный режим) просто игнорируется.

Теперь, когда я показал, как open файл, расскажите о том, что вам всегда нужно close его снова. В противном случае он сохранит открытый файл-дескриптор файла до тех пор, пока процесс не завершится (или Python сбрасывает файл-дескриптор).

Хотя вы можете использовать:

f = open(filename)
# ... do stuff with f
f.close()

Это не удастся закрыть файл, если что-то между open и close вызывает исключение. Вы можете избежать этого, используя try и, finally:

f = open(filename)
# nothing in between!
try:
    # do stuff with f
finally:
    f.close()

Однако Python предоставляет менеджер контекста, которые имеют покрасивее синтаксис (но для open почти идентично try и, finally, выше):

with open(filename) as f:
    # do stuff with f
# The file is always closed after the with-scope ends.

Последний подход — рекомендуемый подход для открытия файла в Python!

Чтение файла

Хорошо, вы открыли файл, теперь как его прочитать?

Функция open возвращает объект file и поддерживает протокол итерации Pythons. Каждая итерация даст вам строку:

with open(filename) as f:
    for line in f:
        print(line)

Это напечатает каждую строку файла. Обратите внимание, однако, что каждая строка будет содержать символ новой строки \n в конце (вы можете проверить, создан ли ваш Python с поддержкой универсальной новой строки), иначе вы также могли бы иметь \r\n на Windows или \r на Mac как новые строки), Если вы не хотите, чтобы вы могли просто удалить последний символ (или два последних символа в Windows):

with open(filename) as f:
    for line in f:
        print(line[:-1])

Но последняя строка не обязательно имеет завершающую новую строку, поэтому ее не следует использовать. Можно проверить, заканчивается ли она завершающей новой строкой, и если это необходимо удалить:

with open(filename) as f:
    for line in f:
        if line.endswith('\n'):
            line = line[:-1]
        print(line)

Но вы могли бы просто удалить все пробелы (включая символ \n) с конца строки, это также удалит все остальные конечные пробелы, поэтому вы должны быть осторожны, если они важны:

with open(filename) as f:
    for line in f:
        print(f.rstrip())

Однако, если строки заканчиваются на \r\n (Windows «newlines»), что .rstrip() также позаботится о \r !

Храните содержимое в виде списка

Теперь, когда вы знаете, как открыть файл и прочитать его, нужно сохранить содержимое в списке. Самый простой вариант — использовать функцию list:

with open(filename) as f:
    lst = list(f)

Если вы хотите разделить конечные символы новой строки, вместо этого вы можете использовать понимание списка:

with open(filename) as f:
    lst = [line.rstrip() for line in f]

Или даже проще: метод .readlines() объекта file по умолчанию возвращает list строк:

with open(filename) as f:
    lst = f.readlines()

Это также будет включать в себя конечные символы новой строки, если вы не хотите их, я бы рекомендовал использовать метод [line.rstrip() for line in f] поскольку он избегает сохранения двух списков, содержащих все строки в памяти.

Там есть дополнительная опция для получения желаемого результата, однако он скорее «субоптимальный»: read полный файл в строке, а затем разделите на строки:

with open(filename) as f:
    lst = f.read().split('\n')

или же:

with open(filename) as f:
    lst = f.read().splitlines()

Они автоматически заботятся о завершающих символах новой строки, потому что символ split не включен. Однако они не идеальны, потому что вы храните файл как строку и как список строк в памяти!

Резюме

• Используйте with open(...) as f при открытии файлов, потому что вам не нужно заботиться о том, чтобы закрыть файл самостоятельно, и он закрывает файл, даже если происходит какое-то исключение.
• file объекты поддерживают протокол итерации, поэтому чтение файла по строкам так же просто, как for line in the_file_object:
• Всегда просматривайте документацию для доступных функций/классов. Большую часть времени там идеальное совпадение для задачи или хотя бы один или два хороших. Очевидным выбором в этом случае будет readlines() но если вы хотите обработать строки перед их сохранением в списке, я бы рекомендовал простое понимание списка.

Обработка больших файлов с использованием Python 

В последний год или около того, и с моим повышенным вниманием к данным ribo-seq я полностью осознал, что означает термин большие данные. Исследования ribo-seq в их необработанном виде могут легко охватить сотни ГБ, что означает, что их обработка как своевременной, так и эффективной требует некоторого обдумывания. В этом посте, и, надеюсь, в следующем, я хочу подробно описать некоторые из методов, которые я придумала (собрал из разных статей в интернете), которые помогают мне получать данные такого масштаба. В частности, я буду подробно описывать методы для Python, хотя некоторые методы можно перенести на другие языки.

Мой первый большой совет по Python о том, как разбить ваши файлы на более мелкие блоки (или куски) таким образом, чтобы вы могли использовать несколько процессоров. Давайте начнем с самого простого способа чтения файла на python.

with open("input.txt") as f:
   data = f.readlines()
   for line in data:
       process(line)

Эта ошибка, сделанная выше в отношении больших данных, заключается в том, что она считывает все данные в ОЗУ, прежде чем пытаться обрабатывать их построчно. Это, вероятно, самый простой способ вызвать переполнение памяти и возникновение ошибки. Давайте исправим это, читая данные построчно, чтобы в любой момент времени в оперативной памяти сохранялась только одна строка.

with open("input.txt") as f:
   for line in f:
       process(line)

Это большое улучшение, и именно оно не перегружает ОЗУ при загрузке большого файла. Затем мы должны попытаться немного ускорить это, используя все эти бездействующие ядра.

import multiprocessing as mp

pool = mp.Pool(cores)
jobs = []

with open("input.txt") as f:
   for line in f:
       jobs.append( pool.apply_async(process,(line)) )

# дождаться окончания всех работ
for job in jobs:
   job.get()

pool.close()

При условии, что порядок обработки строк не имеет значения, приведенный выше код генерирует набор (пул) обработчиков, в идеале один для каждого ядра, перед созданием группы задач (заданий), по одной для каждой строки. Я склонен использовать объект Pool, предоставляемый модулем multiprocessing, из-за простоты использования, однако, вы можете порождать и контролировать отдельные обработчики, используя mp.Process, если вы хотите более точное управление. Для простого вычисления числа объект Pool очень хорош.

Хотя вышеперечисленное теперь использует все эти ядра, к сожалению, снова возникают проблемы с памятью. Мы специально используем функцию apply_async, чтобы пул не блокировался во время обработки каждой строки. Однако при этом все данные снова считываются в память; это время сохраняется в виде отдельных строк, связанных с каждым заданием, ожидая обработки в строке. Таким образом, память снова будет переполнена. В идеале метод считывает строку в память только тогда, когда подходит ее очередь на обработку.

import multiprocessing as mp

def process_wrapper(lineID):
   with open("input.txt") as f:
       for i, line in enumerate(f):
           if i != lineID:
               continue
           else:
               process(line)
               break

pool = mp.Pool(cores)
jobs = []

with open("input.txt") as f:
   for ID, line in enumerate(f):
       jobs.append( pool.apply_async(process_wrapper,(ID)) )

# дождаться окончания всех работ
for job in jobs:
   job.get()

pool.close()

Выше мы изменили функцию, переданную в пул обработчика, чтобы она включала в себя открытие файла, поиск указанной строки, чтение ее в память и последующую обработку. Единственный вход, который теперь сохраняется для каждой порожденной задачи — это номер строки, что предотвращает переполнение памяти. К сожалению, накладные расходы, связанные с необходимостью найти строку путем итеративного чтения файла для каждого задания, являются несостоятельными, поскольку по мере того, как вы углубляетесь в файл, процесс занимает все больше времени. Чтобы избежать этого, мы можем использовать функцию поиска файловых объектов, которая пропускает вас в определенное место в файле. Сочетание с функцией tell, которая возвращает текущее местоположение в файле, дает:

import multiprocessing as mp

def process_wrapper(lineByte):
   with open("input.txt") as f:
       f.seek(lineByte)
       line = f.readline()
       process(line)

pool = mp.Pool(cores)
jobs = []

with open("input.txt") as f:
   nextLineByte = f.tell()
   for line in f:
       jobs.append( pool.apply_async(process_wrapper,(nextLineByte)) )
       nextLineByte = f.tell()

for job in jobs:
   job.get()

pool.close()

Используя поиск, мы можем перейти непосредственно к правильной части файла, после чего мы читаем строку в память и обрабатываем ее. Мы должны быть осторожны, чтобы правильно обрабатывать первую и последнюю строки, но в противном случае это будет именно то, что мы излагаем, а именно использование всех ядер для обработки данного файла без переполнения памяти.

Я закончу этот пост с небольшим обновлением вышеупомянутого, поскольку есть разумные накладные расходы, связанные с открытием и закрытием файла для каждой отдельной строки. Если мы обрабатываем несколько строк файла за один раз, мы можем сократить эти операции. Самая большая техническая сложность при этом заключается в том, что при переходе к месту в файле вы, скорее всего, не находитесь в начале строки. Для простого файла, как в этом примере, это просто означает, что вам нужно вызвать readline, который читает следующий символ новой строки. Более сложные типы файлов, вероятно, требуют дополнительного кода, чтобы найти подходящее место для начала / конца чанка.

import multiprocessing as mp, os

def process_wrapper(chunkStart, chunkSize):
   with open("input.txt") as f:
       f.seek(chunkStart)
       lines = f.read(chunkSize).splitlines()
       for line in lines:
           process(line)

def chunkify(fname,size=1024*1024):
   fileEnd = os.path.getsize(fname)
   with open(fname,'r') as f:
       chunkEnd = f.tell()
   while True:
       chunkStart = chunkEnd
       f.seek(size,1)
       f.readline()
       chunkEnd = f.tell()
       yield chunkStart, chunkEnd - chunkStart
       if chunkEnd > fileEnd:
           break

pool = mp.Pool(cores)
jobs = []

for chunkStart,chunkSize in chunkify("input.txt"):
   jobs.append( pool.apply_async(process_wrapper,(chunkStart,chunkSize)) )

for job in jobs:
   job.get()

pool.close()

Во всяком случае, я надеюсь, что некоторые из вышеперечисленных примеров были новыми и возможно, полезными для вас. Если вы знаете лучший способ сделать что-то (на python), мне было бы очень интересно узнать об этом. В следующем посте, который будет опубликован в ближайшем будущем, я расширю этот код, превратив его в родительский класс, из которого создается несколько дочерних элементов для использования с различными типами файлов.

По-разному читать файл построчно в список в Python

Чтение текстового файла — важная часть программирования. В основном, когда файл читается, его содержимое сохраняется в структуре данных, такой как массив, список, карта и т. Д. В этом сообщении будут подробно описаны различные методы для чтения текстового файла построчно и сохранения его содержимого непосредственно в списке на Python. .

Для более глубокого понимания чтения и записи файлов на Python см. этот учебник

Текстовый файл, который мы будем использовать в качестве примера в этой публикации, называется “codippa.txt ” и содержит следующий образец содержимого

Привет,
Это python
Обучение с codippa.com

Метод 1: Использование метода строк чтения
Откройте файл в режиме чтения и прочитайте его содержимое, используя метод строк чтения непосредственно в список.

 # открыть файл в режиме чтения
с open ("codippa.txt", 'r') как file_handle:
    # считываем содержимое файла в список
    lines = file_handle.readlines ()
# напечатать содержимое списка
print (lines) 

# открыть файл в режиме чтения с открытым («codippa.txt «, ‘r’) как file_handle: # считываем содержимое файла в список lines = file_handle.readlines () # напечатать содержимое списка print (lines)

Этот метод будет содержать символ новой строки после каждого элемента списка, как показано в выходных данных ниже.

[‘Hello there \ n’, ‘This is python \ n’, ‘Learning from codippa.com’]

Если вы хотите удалить символ новой строки в конце каждого элемента, выполните итерацию по списку и удалите новую строку символ с использованием метода полосы , как показано ниже.

 строк = [строка.strip () для строки в строках] 

Чтение файла с использованием с и в качестве ключевых слов как с open ("codippa.txt", 'r') в качестве file_handle: обеспечивает то преимущество, что файл закрывается автоматически после задача завершена. Вы также можете прочитать файл как file_handle = open ("f: /linkedFile.txt", 'r') , но тогда вам придется закрыть его вручную.

Метод 2: Использование метода чтения и разделения строк
Прочтите содержимое файла в список, используя метод read объекта файла.Этот метод читает файл как есть. Для преобразования содержимого файла в список используется метод splitlines . Этот метод разделяет содержимое файла на каждый разрыв строки и вставляет каждый элемент в список.
Python docs для splitlines method state

Возвращает список строк в S, разрывая границы строк.
Разрывы строк не включаются в результирующий список

 # открыть файл в режиме чтения
с открытым ("codippa.txt ", 'r') как file_handle:
    # конвертировать содержимое файла в список
    lines = file_handle.read (). splitlines ()
print (lines) 

# открыть файл в режиме чтения с open («codippa.txt», ‘r’) как file_handle: # конвертировать содержимое файла в список lines = file_handle.read (). splitlines () print (lines)

Вывод

[«Здравствуйте», «Это питон», «Обучение на codippa.com»]

Обратите внимание, что в конце нет символа новой строки.

Метод 3: Использование функции добавления
Откройте файл для чтения.Перебирайте содержимое файла построчно, используя цикл для . На каждой итерации добавляйте текущую строку в список, используя метод append .

 с открытым ("codippa.txt", 'r') как file_handle:
    # инициализировать список
    lines = []
    # перебирать содержимое файла
    для строки в file_handle:
        # добавить строку в список
        lines.append (line.strip ()) 

с open («codippa.txt», ‘r’) как file_handle: # инициализировать список lines = [] # перебирать содержимое файла для строки в file_handle: # добавить строку в список линий.append (line.strip ())

Обратите внимание на полосу , вызываемую в строке. Это требуется для удаления символа новой строки из конца строки.
Выход

[«Привет», «Это python», «Обучение на codippa.com»]

Метод 4: Использование итерации
Существует другой подход для преобразования содержимого файла в список с помощью цикла for. Этот метод проще по сравнению с описанным выше.

 с открытым ("f: /linkedFile.txt", 'r') как file_handle:
    lines = [строка.strip () для строки в file_handle] 

с open («f: /linkedFile.txt», ‘r’) как file_handle: lines = [line.strip () для строки в file_handle]

Перебирать файл построчно и добавлять его непосредственно в список. strip Функция требуется для удаления символа новой строки из каждой строки. Выход

[«Привет», «Это питон», «Обучение на codippa.com»]

Метод 5: Использование функции списка
Функция списка принимает в качестве аргумента повторяющийся объект.Функция list возвращает список с содержимым итерации, предоставленным ей в качестве аргумента. Документы Python для списка Состояние функции

список (итерируемый) -> новый список, инициализированный из элементов итерации

Пример этого подхода приведен ниже

 с open ("codippa.txt", 'r' ) как file_handle:
    строки = список (дескриптор_файла)
# напечатать содержимое списка
печать (строки) 

с открытым («codippa.txt «, ‘r’) как file_handle: строки = список (дескриптор_файла) # напечатать содержимое списка print (lines)

Результат выполнения вышеуказанного кода:

[«Привет», «Это питон», «Обучение на codippa.com»]

Вот и все, о преобразовании файла в список. Продолжайте посещать !!!!

Чтение и запись файлов в Python

Python предоставляет широкий спектр встроенных функций для обработки файлов. Это упрощает создание, обновление, чтение и удаление файлов.

Открыть файл

Если вы хотите работать с файлом, первое, что нужно сделать, это открыть его.Вы можете открыть файл с помощью встроенной функции open (), указав его имя.

Когда вы указываете только имя файла, предполагается, что файл находится в той же папке, что и Python. Если он находится где-то еще, вы можете указать точный путь , где находится файл.

  f = open (r'C: \ Python33 \ Scripts \ myfile.txt ')  

Помните! При указании точного пути символы, начинающиеся с \ (например, \ n \ r \ t и т. Д.), Интерпретируются как специальные символы. Вы можете избежать их, используя:

• необработанные строки, например r'C: \ new \ text.txt '
• двойная обратная косая черта, например ' C: \\ new \\ text.txt '

Укажите режим файла

Вот пять различных режимов, которые вы можете использовать для открытия файла:

Вы также можете указать, как следует обрабатывать файл.

Вот несколько примеров:

  # Открыть файл для чтения
f = открытый ('myfile.txt')

# Открыть файл для записи
f = open ('myfile.txt ',' ш ')

# Открыть файл для чтения и записи
f = открытый ('myfile.txt', 'r +')

# Открываем бинарный файл для чтения
f = open ('myfile.txt', 'rb')  

Поскольку режим чтения «r» и текстовый режим «t» являются режимами по умолчанию, вам не нужно их указывать.

Прочтите файл

Предположим, у вас есть следующий файл.

myfile.txt

  Первая строка файла.
Вторая строка файла.
Третья строка файла.  

Чтобы прочитать его содержимое, вы можете использовать метод read () .

  # Прочитать файл целиком
f = открытый ('myfile.txt')
печать (f.read ())

# Печать:
# Первая строка файла.
# Вторая строка файла.
# Третья строка файла.  

По умолчанию метод read () считывает всего файла . Однако вы можете указать максимальное количество символов для чтения.

  f = открытый ('myfile.txt')

печать (f.read (3))
# Печать ели

печать (f.read (5))
# Сначала печатает  

Строки чтения

Чтобы прочитать одну строку из файла, используйте метод readline () .

  f = открытый ('myfile.txt')
печать (f.readline ())
# Печатает первую строку файла.

# Вызовите его снова, чтобы прочитать следующую строку
печать (f.readline ())
# Печатает вторую строку файла.  

Вы можете просмотреть весь файл построчно, используя простой цикл for.

  f = открытый ('myfile.txt')
для строки в f:
    печать (строка)

# Печать:
# Первая строка файла.
# Вторая строка файла.
# Третья строка файла.  

Если вы хотите прочитать все строки в файле в виде списка строк, используйте метод readlines () .

  # Прочитать все строки файла в список строк
f = открытый ('myfile.txt')
печать (f.readlines ())

# Печать:
# ['Первая строка файла. \ N', 'Вторая строка файла. \ N', 'Третья строка файла.']  

Обратите внимание, что list (f) дает тот же результат, что и readlines ()

Запись файла

Используйте встроенный метод write () для записи в существующий файл. Помните, что вам нужно сначала открыть файл в одном из режимов записи ( ‘w’ , ‘a’ или ‘r +’ ).

Режим записи «w»

В режиме «w» перезаписывается все содержимое файла:

  f = open ('myfile.txt', 'w')
f.write ('Перезаписать существующие данные.')  

myfile.txt

  Перезаписать существующие данные.

  

Режим добавления «a»

В режиме «a» текст добавляется в конец файла:

  f = open ('myfile.txt', 'a')
f.write ('Добавить этот текст.')  

myfile.txt

  Первая строка файла.Вторая строка файла.
Третья строка файла. Добавьте этот текст.  

Режим чтения-записи «r +»

В режиме «r +» файл частично перезаписывается:

  f = open ('myfile.txt', 'r +')
f.write ('--- Перезаписать содержимое ---')  

myfile.txt

  --- Перезаписать содержимое ---
Вторая строка файла.
Третья строка файла.  

Запись нескольких строк

Чтобы записать несколько строк в файл одновременно, используйте метод writelines () .Этот метод принимает на вход список строк.

  f = open ('myfile.txt', 'w')
lines = ['Новая строка 1 \ n', 'Новая строка 2 \ n', 'Новая строка 3']
f.writelines (строки)  

myfile.txt

  Новая строка 1
Новая линия 2
Новая строка 3  

Очистить выходной буфер

При записи в файл данные не сразу записываются на диск, а сохраняются в буферной памяти . Он записывается на диск только тогда, когда вы закрываете файл или вручную очищаете выходной буфер.

  # Сбросить выходной буфер на диск без закрытия
f = open ('myfile.txt', 'а')
f.write ('Добавить этот текст.')
f.flush ()  

Закройте файл

Рекомендуется закрыть файл, как только вы закончите работу с ним. Вы же не хотите, чтобы открытый файл занимал много ресурсов!

Используйте функцию close () , чтобы закрыть открытый файл.

  f = открытый ('myfile.txt')
f.close ()

# проверить закрытый статус
печать (f.closed)
# Prints True  

Существует два подхода к обеспечению правильного закрытия файла даже в случае ошибки.

Первый подход заключается в использовании ключевого слова with, которое рекомендует Python, поскольку он автоматически закрывает файл, как только он покидает с блоком (даже в случае ошибки).

  с открытым ('myfile.txt') как f:
    print (f.read ())  

Второй подход — использовать блок try-finally:

  f = open ('myfile.txt')
пытаться:
    # Здесь идут файловые операции
Ну наконец то:
    f.close ()  

Создание нового файла

Если вы попытаетесь открыть для записи файл, который не существует, Python автоматически создаст файл для вас.

  # Создайте файл и откройте его для записи

# режим записи
f = open ('новый файл.txt', 'ш')

# режим добавления
f = open ('новыйФайл.txt', 'а')

# режим чтения + записи
f = open ('newFile.txt', 'r +')  

Есть еще один способ создать файл. Вы можете использовать метод open () и указать исключительный режим создания ‘x’ .

  # Создать файл исключительно
f = open ('newFile.txt', 'x')  

Обратите внимание, что при использовании этого режима убедитесь, что файл еще не присутствует, если он есть, Python выдаст ошибку.

Удаление файла

Вы можете удалить файл, импортировав модуль ОС и используя его метод remove () .

  импорт ОС
os.remove ('myfile.txt')  

Проверить, существует ли файл

Если вы попытаетесь открыть или удалить файл, который не существует, возникает ошибка. Чтобы избежать этого, вы можете предварительно проверить, существует ли уже файл, используя метод isfile () из модуля ОС.

  импорт ОС
если os.path.isfile ('myfile.txt'):
f = open ('myfile.текст')
еще:
print ('Файл не существует.')  

Произвольный доступ

Иногда вам нужно прочитать из записи в середине файла, в это время вы можете использовать метод seek (offset, from_what) . Эта функция перемещает указатель файла из его текущей позиции в определенную позицию.

Смещение — это количество символов из параметра from_what, имеющего три возможных значения:

• 0 — указывает начало файла (по умолчанию)
• 1 — указывает текущую позицию указателя
• 2 — указывает конец файл

Предположим, у вас есть следующий файл.

myfile.txt

  ABCDEFGHIJKLMNOPQRSTUVWXYZ  

Вот как можно использовать метод seek () для произвольного доступа к содержимому файла.

  f = open ('myfile.txt', 'rb +')

# перейти к 7-му символу и прочитать один символ
f.seek (6)
печать (f.read (1))
# Печать G

# перейти к 3-му символу с текущей позиции (буква G)
f.seek (3, 1)
печать (f.read (1))
# Отпечатков K

# перейти к 3-му символу до конца
f.seek (-3, 2)
печать (f.read (1))
# Prints X  

Для Python 3.2 и выше, в текстовых файлах (тех, которые открыты без символа b в строке режима) разрешены только поиски относительно начала файла.

Чтобы использовать поиск с текущей позиции и с конца, вы должны открыть текстовый файл в двоичном режиме.

Если вы хотите проверить текущую позицию указателя файла, используйте метод tell () .

  f = открытый ('myfile.txt')

# начальная позиция
печать (f.tell ())
# Отпечатков 0

# после прочтения 5 символов
е. читать (5)
печать (f.tell ())
# Prints 5  

Python построчно записать в файл

Python построчно записывает в файл с помощью Writelines ():

Здесь, в первой строке, мы определили список в переменной под названием «числа».вы можете дать этой переменной любое имя. и мы открываем файл DevOps.txt и добавляем строки в текстовый файл. в Python Writelines () модулю требуется список данных для записи. поэтому мы упомянули переменную «числа» в функции Writelines (), а в последней строке мы закрыли открытый файл

 numbers = ["Один \ n", "Два \ n", "Три \ n", "Четыре \ n", "Пять \ n"]
F = open ("DevOps.txt", "а")
F.writelines (числа)
F.close () 

Вывод:

DevOps.txt

 Один
Два
Три
Четыре
Пять 

Python для записи в файл построчно с использованием Writelines () и цикла For:

 строк = ['строка1', 'строка2', "строка3"]
f = open ('DevOps.txt ',' а ')
f.writelines ("% s \ n"% i вместо i в строках)
f.close ()

 

здесь в первой строке мы определили список с переменными строками. а во второй строке мы открываем файл, чтобы добавить новые строки. а затем с помощью функции Writelines () мы отправляем список в файл построчно. Функция Writelines в Python нуждается в списке. Итак, здесь мы отправляем список «строк» в writerelines () с помощью цикла for.

Вывод:

DevOps.txt

 строка1
line2
line3 

или открытие файла другим способом:

 строк = ['строка1', 'строка2']
с открытым ('DevOps.txt ',' a ') как f:
    f.writelines ("% s \ n"% l вместо l в строках) 

здесь мы использовали тот же код, что и выше, но для открытия файла и добавления мы использовали другой метод.

Вывод:

DevOps.txt

 строка1
line2
 

Python для записи в файл построчно с использованием write () и цикла For:

 abc = [«Один», «Два», «Три», «Четыре», «Пять»]
x = open ("DevOps.txt", "а")
для я в abc:
    x.write ('\ n% s'% i)
x.close () 

здесь, в первой строке, мы определили наш список, который нужно добавить в наш текстовый файл.а во второй строке мы открыли файл и добавили в него данные. в третьей и четвертой строках мы определили цикл for для построчной записи данных в этот файл. здесь вы можете видеть, что \ n он добавит новую строку только в начале, поэтому наши новые добавляемые данные будут добавлены как новая строка.

вывод:

DevOps.txt

 Один
Два
Три
Четыре
Пять 

Прочитать файл построчно и записать эти строки в новый файл

 с открытым ("DevOps.txt "," r ") как d:
  x = d.readlines ()
с open ("new.txt", "w") как f:
  f. записи (x)
  f.close () 

будет считывать файл DevOps.txt построчно и записывать его в другой файл с именем new.txt. Таким образом, оба файла будут выглядеть одинаково.

13. Файлы — Как думать как компьютерный ученый: обучение с Python 3

13.1. О файлах

Во время работы программы ее данные хранятся в оперативной памяти (RAM). Оперативная память быстрая и недорогая, но она также является энергозависимой , что означает, что когда программа завершается, или компьютер выключается, данные в оперативной памяти исчезают.Сделать данные будут доступны при следующем включении компьютера и программе запускается, он должен быть записан на энергонезависимый носитель , например, жесткий диск, USB-привод или CD-RW.

Данные на энергонезависимом носителе хранятся в названных местах на носителе. называется файлов . Читая и записывая файлы, программы могут сохранять информацию между запусками программы.

Работа с файлами очень похожа на работу с ноутбуком. Чтобы использовать записную книжку, это должно быть открыто.Когда закончите, его нужно закрыть. В то время как Блокнот открыт, в нем можно читать или писать. В любом случае, Держатель ноутбука знает, где они. Они могут прочитать всю записную книжку в естественный порядок, или они могут пропустить.

Все это относится и к файлам. Чтобы открыть файл, указываем его имя и укажите, хотим ли мы читать или писать.

13.2. Пишем наш первый файл

Начнем с простой программы, которая записывает три строки текста в файл:

myfile = open ("test.txt "," w ") myfile.write ("Мой первый файл, написанный на Python \ n") myfile.write ("--------------------------------- \ n") myfile.write ("Привет, мир! \ n") myfile.close ()

Открытие файла создает то, что мы называем дескриптором файла . В этом примере переменная myfile относится к новому объекту дескриптора. Наша программа вызывает методы на дескрипторе, и это делает изменяет фактический файл, который обычно находится на нашем диске.

В строке 1 функция open принимает два аргумента.Первый — это имя файла, а второй — режим . Режим «w» означает, что мы открываем файл для письмо.

В режиме «w», если на диске нет файла с именем test.txt, он будет создан. Если он уже есть, он будет заменен файл, который мы пишем.

Чтобы поместить данные в файл, мы вызываем метод записи на дескрипторе, показанном в строках 2, 3 и 4 выше. В больших программах строки 2–4 обычно будут заменяется циклом, который записывает в файл намного больше строк.

Закрытие дескриптора файла (строка 5) сообщает системе, что мы закончили писать и файл на диске, доступный для чтения другими программами (или нашей собственной программой).

Ручка чем-то похожа на пульт от телевизора

Все мы знакомы с пультом дистанционного управления для телевизора. Выполняем операции на пульт — переключать каналы, менять громкость и т.д. Но реальное действие бывает по телевизору. Итак, по простой аналогии, мы назвали бы пульт дистанционного управления нашей ручкой . к основному телевизору.

Иногда хочется подчеркнуть разницу — дескриптор файла не тот как файл, а пульт не такой как телевизор. Но в других случаях мы предпочитаем рассматривать их как единый мысленный кусок или абстракцию, и мы просто скажем «закрыть файл» или «переключить телеканал».

13,3. Построчное чтение файла

Теперь, когда файл существует на нашем диске, мы можем открыть его, на этот раз для чтения, и прочитать все строки в файле, по одной.На этот раз аргумент режима — «r» для чтения:

mynewhandle = open ("test.txt", "r") while True: # Продолжайте читать вечно theline = mynewhandle.readline () # Пытаться прочитать следующую строку if len (theline) == 0: # Если строк больше нет break # выйти из цикла # Теперь обработаем строку, которую мы только что прочитали печать (строка, конец = "") mynewhandle.close ()

Это удобный шаблон для нашего набора инструментов.В более крупных программах мы бы втиснуть более обширную логику в тело цикла в строке 8 — например, если каждая строка файла содержит имя и адрес электронной почты одного из наших друзей, возможно, мы разделим линию на несколько частей и вызвать функцию, чтобы отправить другу приглашение на вечеринку.

В строке 8 мы подавляем символ новой строки, печатающий обычно добавляется к нашим строкам. Почему? Это потому, что строка уже есть своя новая строка: метод readline в строке 3 возвращает все до и включая символ новой строки.Это также объясняет логика определения конца файла: когда больше нет строк читать из файла, readline возвращает пустую строку — ту, которая не даже есть символ новой строки в конце, следовательно, его длина равна 0.

Сначала отказ …

В нашем примере здесь у нас есть три строки в файле, но входим в цикл четыре раза по . В Python вы узнаете только то, что в файле больше нет строк из-за невозможности прочитать другую строку. В некоторых других языках программирования (е.г. Паскаль) дело обстоит иначе: вы читаете три строчки, но у вас есть то, что называется , смотрите вперед — после прочтения третьего line вы уже знаете, что в файле больше нет строк. Вам даже нельзя пытаться прочитать четвертую строку.

Итак, шаблоны для построчной работы в Паскале и Python немного другое!

Когда вы переносите свои навыки Python на следующий компьютерный язык, не забудьте спросить, как вы узнаете, когда файл закончился: стиль на языке «попробуй, и после неудачи узнаешь», или это «смотреть в будущее»?

Если мы попытаемся открыть несуществующий файл, мы получим ошибку:

 >>> mynewhandle = open ("wharrah.txt "," r ")
IOError: [Errno 2] Нет такого файла или каталога: "wharrah.txt"
 

13,4. Превращение файла в список строк

Часто бывает полезно получить данные из файл на диске и превратить его в список строк. Предположим, у нас есть файл, содержащий наших друзей и их адреса электронной почты, по одному в строке в файле. Но нам бы хотелось, чтобы строки были отсортированы по Алфавитный порядок. Хороший план — зачитать все в список строк, затем отсортируйте список, а затем напишите отсортированный список назад к другому файлу:

f = open ("друзья.txt "," r ") xs = f.readlines () f.close () xs.sort () g = open ("sortedfriends.txt", "w") для v в xs: g.write (v) g.close ()

Метод readlines в строке 2 считывает все строки и возвращает список строк.

Мы могли бы использовать шаблон из предыдущего раздела для чтения каждой строки по одному и составить список самостоятельно, но это намного проще использовать метод, который нам предоставили разработчики Python!

13,5. Чтение всего файла сразу

Другой способ работы с текстовыми файлами — прочитать полную содержимое файла в строку, а затем использовать нашу обработку строк навыки работы с содержимым.

Обычно мы использовали бы этот метод обработки файлов, если бы не интересует строчная структура файла. Например, мы видел метод разделения строк, который может разбить строку на слова. Итак, вот как мы можем подсчитать количество слов в файл:

f = open ("somefile.txt") content = f.read () f.close () слова = content.split () print ("В файле слов {0}.". format (len (words)))

Обратите внимание, что мы исключили режим «r» в строке 1.По умолчанию, если мы не указываем режим, Python открывает файл для чтения.

Возможно, вам потребуется явно указать пути к файлам.

В приведенном выше примере мы предполагаем, что файл somefile.txt в том же каталоге, что и исходный код Python. Если это это не так, вам может потребоваться указать полный или относительный путь к файлу. В Windows полный путь может выглядеть как «C: \\ temp \\ somefile.txt», в то время как в системе Unix полный путь может быть «/home/jimmy/somefile.txt».

Мы вернемся к этому позже в этой главе.

13,6. Работа с бинарными файлами

Файлы, содержащие фотографии, видео, zip-файлы, исполняемые программы и т. Д., Называются двоичных файлов : они не сгруппированы по строкам и не могут быть открыты с помощью обычный текстовый редактор. Python так же легко работает с двоичными файлами, но когда мы читаем из файла, мы вернем байты, а не строка. Здесь мы скопируем один двоичный файл в другой:

f = open ("somefile.zip "," rb ") g = open ("thecopy.zip", "wb") в то время как True: buf = f.read (1024) если len (buf) == 0: сломать g.write (buf) f.close () g.close ()

Здесь есть несколько новинок. В строках 1 и 2 мы добавили букву «b». в режим, чтобы сообщить Python, что файлы являются двоичными, а не текстовые файлы. В строке 5 мы видим, что чтение может принимать аргумент, который сообщает ему, сколько байтов нужно попытаться прочитать из файла. Мы тут выбрал чтение и запись до 1024 байтов на каждой итерации цикла.когда мы возвращаем пустой буфер из нашей попытки чтения, мы знаем, что можем вырваться из цикла и закрыть оба файла.

Если мы установим точку останова в строке 6 (или напечатайте там (buf)), мы посмотрите, что тип buf — байты. Мы не делаем подробных работать с байтовыми объектами в этом учебнике.

13,7. Пример

Многие полезные программы обработки строк будут читать текстовый файл построчно и выполнять некоторые незначительные обработки, поскольку они записывают строки в выходной файл.Они могли бы сосчитать строк в выходном файле или вставляйте лишние пустые строки через каждые 60 строк, чтобы сделать удобной печать на листах бумаги или извлечь какую-то конкретную столбцы только из каждой строки в исходном файле или только строки печати, которые содержат определенную подстроку. Мы называем такую ​​программу фильтром .

Вот фильтр, копирующий один файл в другой, исключая любые строки, начинающиеся с #:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

фильтр def (старый файл, новый файл): infile = open (старый файл, "r") Outfile = open (новый файл, "ш") в то время как True: текст = infile.readline () если len (текст) == 0: сломать если текст [0] == "#": Продолжить # Добавьте сюда дополнительную логику обработки Outfile.write (текст) infile.close () Outfile.close ()

Оператор continue в строке 9 пропускает оставшиеся строки в текущая итерация цикла, но цикл все равно будет повторяться. Этот стиль выглядит здесь немного надуманным, но часто бывает полезно сказать «получите линии, которые нас не интересуют, так что у нас есть более четкая более сфокусированная логика в содержательной части цикла, которая может быть написано около строки 11.”

Таким образом, если текст является пустой строкой, цикл завершается. Если первый символ текста — это решетка, поток выполнения переходит в начало цикла, готово чтобы начать обработку следующей строки. Только если оба условия не выполнены, мы провалимся, чтобы выполнить обработку в строке 11, в этом Например, запись строки в новый файл.

Рассмотрим еще один случай: предположим, что наш исходный файл содержал пустой линий. В строке 6 выше, найдет ли эта программа первую пустую строку в файл и немедленно прекратить? Нет! Помните, что строка чтения всегда включает символ новой строки в возвращаемую строку.Только когда мы попробуйте прочитать за конца файла, мы вернем пустую строку длиной 0.

13,8. Справочники

Файлы на энергонезависимом носителе организованы по набору правил, известных как файловая система . Файловые системы состоят из файлов и каталогов , которые являются контейнерами как для файлов, так и для других каталогов.

Когда мы создаем новый файл, открывая его и записывая, новый файл помещается в текущий каталог (где бы мы ни были, когда запускали программу).Аналогично, когда открываем файл для чтения, Python ищет его в текущем каталоге.

Если мы хотим открыть файл где-то еще, мы должны указать путь к файл, который является именем каталога (или папки), в которой находится файл находится:

 >>> wordsfile = open ("/ usr / share / dict / words", "r")
>>> wordlist = wordsfile.readlines ()
>>> print (список слов [: 6])
['\ n', 'A \ n', «A \ n», 'AOL \ n', «AOL \ n», 'Aachen \ n']
 

В этом примере (Unix) открывается файл с именем words, который находится в каталоге с именем dict, который находится в доле, которая находится в usr, которая находится в каталоге верхнего уровня системы, называемом /.Затем он читается в каждом строку в список, используя строки чтения, и распечатывает первые 5 элементов из тот список.

Путь Windows может быть «c: /temp/words.txt» или «c: \\ temp \\ words.txt». Поскольку обратная косая черта используется для экранирования таких вещей, как символы новой строки и табуляции, нам нужно записать две обратные косые черты в буквальную строку, чтобы получить одну! Итак, длина этих двух струны такие же!

Мы не можем использовать / или \ как часть имени файла; они зарезервированы как разделитель между каталогом и именами файлов.

Файл / usr / share / dict / words должен существовать в системах на основе Unix, и содержит список слов в алфавитном порядке.

13,9. А как насчет того, чтобы получить что-нибудь из Интернета?

Библиотеки Python местами довольно беспорядочные. Но вот очень простой пример, который копирует содержимое по некоторому веб-URL в локальный файл.

импорт urllib.request url = "http://xml.resource.org/public/rfc/txt/rfc793.txt" destination_filename = "rfc793.текст" urllib.request.urlretrieve (URL, имя_файла назначения)

Можно использовать функцию urlretrieve — всего один вызов скачивать любой контент из Интернета.

Прежде чем это сработает, нам нужно кое-что исправить:

• Ресурс, который мы пытаемся получить, должен существовать! Проверьте это с помощью браузера.
• Нам потребуется разрешение на запись в целевое имя файла, и файл будет быть созданы в «текущем каталоге» — i.е. та же папка, в которой хранится программа Python.
• Если мы находимся за прокси-сервером, который требует аутентификации, (как и некоторые студенты), это может потребовать особой обработки для работы с нашим прокси. Используйте местные ресурсы для этой демонстрации!

Вот немного другой пример. Вместо того, чтобы сохранять веб-ресурс в наш локальный диск, мы читаем его прямо в строку и возвращаем:

1 2 3 4 5 6 7 8 9 10 11 12 13

импорт urllib.запрос def retrieve_page (url): "" "Получить содержимое веб-страницы. Перед возвратом содержимое преобразуется в строку. "" " my_socket = urllib.request.urlopen (URL) dta = str (my_socket.readall ()) my_socket.close () вернуть dta the_text = retrieve_page ("http://xml.resource.org/public/rfc/txt/rfc793.txt") печать (the_text)

Открытие удаленного URL-адреса возвращает то, что мы называем сокетом . Это ручка для наш конец связи между наша программа и удаленный веб-сервер.Мы можем вызывать методы чтения, записи и закрытия на объект сокета почти так же, как мы можем работать с дескриптором файла.

13.10. Глоссарий

разделитель

Последовательность из одного или нескольких символов, используемых для указания границы. между отдельными частями текста.

справочник

Именованный набор файлов, также называемый папкой. Справочники могут содержат файлы и другие каталоги, которые называются подкаталога каталога, в котором они находятся.

файл

Именованный объект, обычно хранящийся на жестком диске, гибком диске или компакт-диске, который содержит поток символов.

файловая система

Метод наименования, доступа и организации файлов и данных, которые они содержать.

ручка

Объект в нашей программе, который подключен к базовому ресурсу (например, файлу). Дескриптор файла позволяет нашей программе управлять / читать / писать / закрывать фактический файл, который находится на нашем диске.

режим

Отдельный метод работы в компьютерной программе.Файлы в Python можно открыть в одном из четырех режимов: чтение («r»), запись («w»), добавить («a») и читать и писать («+»).

энергонезависимая память

Память, которая может сохранять свое состояние без питания. Жесткие диски, флэш приводы и перезаписываемые компакт-диски (CD-RW) являются примерами энергонезависимая память.

путь

Последовательность имен каталогов, указывающая точное местоположение файл.

текстовый файл

Файл, содержащий символы для печати, организованные в строки. разделены символами новой строки.

розетка

Один конец соединения, позволяющий читать и писать информация на другой компьютер или с другого компьютера.

энергозависимая память

Память, для поддержания состояния которой требуется электрический ток. В основная память или ОЗУ компьютера энергозависимы. Информация хранится в ОЗУ теряется при выключении компьютера.

13.11. Упражнения

1. Напишите программу, которая читает файл и записывает новый файл со строками в обратном порядке (я.е. первая строка в старом файле становится последней в новом файле.)
2. Напишите программу, которая читает файл и печатает только те строки, которые содержат подстрока змея.
3. Напишите программу, которая читает текстовый файл и создает выходной файл, который копию файла, за исключением того, что первые пять столбцов каждой строки содержат четыре цифра номер строки с последующим пробелом. Начните нумерацию первой строки в выходном файле с 1. Убедитесь, что каждый номер строки в выходном файле форматируется до одинаковой ширины.Используйте один ваших программ Python в качестве тестовых данных для этого упражнения: ваш результат должен быть распечатанный и пронумерованный листинг программы Python.
4. Напишите программу, которая отменяет нумерацию предыдущего упражнения: она должна прочитать файл с пронумерованными строками и создать другой файл без номеров строк.

Как читать файл построчно в сценарии Bash — Linux Hint

Предположим, у вас есть файл с именем company.txt , который содержит названия компаний. Этот файл содержит следующее содержимое.

Company.txt
Samsung
Nokia
LG
Symphony
iphone

Пример -1: чтение содержимого файла из командной строки

Предположим, вы хотите прочитать файл company.txt построчно из командной строки без команды «cat» .Выполните следующую команду, чтобы выполнить задачу. , а цикл будет читать каждую строку из файла company.txt на каждом шаге и сохранять содержимое строки в переменной $ line , которая будет напечатана позже.

$ при чтении строки; сделать echo $ line; done

Пример 2: чтение содержимого файла с помощью сценария

Создайте файл bash и добавьте следующий код для чтения содержимого определенного файла. Здесь существующее имя файла сохраняется в переменной $ filename , а переменная $ n используется для хранения значения номера строки этого файла.Как и в предыдущем примере, цикл и используется для чтения этого файла с номером строки.

#! / Bin / bash
filename = ‘company.txt’
n = 1
при чтении строки; do
# чтение каждой строки
echo «Line No. $ n: $ line»
n = $ ((n + 1))
done <$ filename

Выполните следующую команду, чтобы выполнить сценарий.

Запустите команду ‘cat’ с файлом company.txt , чтобы отобразить исходное содержимое файла company.txt .

Пример -3: Передача имени файла из командной строки и чтение файла

Создайте файл bash и добавьте следующий сценарий.Этот сценарий берет имя файла из аргумента командной строки. Значение первого аргумента считывается переменной $ 1, которая будет содержать имя файла для чтения. Если файл существует в текущем месте, тогда цикл , а будет читать файл построчно, как в предыдущем примере, и печатать содержимое файла.

#! / Bin / bash
filename = $ 1
при чтении строки; do
# чтение каждой строки
echo $ line
done <$ filename

Запустите указанный выше сценарий с сотрудником .txt в качестве значения аргумента. Выходные данные покажут содержимое файла employee.txt , удалив лишнее пространство. Вы можете показать исходное содержимое файла employee.txt с помощью команды ‘cat’ .

$ bash readfile2.txt employee.txt
$ cat employee.txt

Пример — 4: Чтение файла без escape-символа обратной косой черты

Если вы хотите прочитать каждую строку файла, опуская обратную косую черту, тогда вам нужно использовать опцию ‘-r’ с командой чтения в в цикле .