Построчное чтение из файла c: C читать файл построчно
Чтение файлов с помощью Python — GitJournal
Чтобы работать с сохранёнными данными, каждому программисту на Python необходимо знать про обработку файлов. Начиная с самого раннего выпуска, запись и чтение файлов встроены в Python. Если сравнить с другими языками типа С или Java, это довольно просто и требует немного строк кода. Более того, для этого не нужно загружать никаких дополнительных модулей.
Основы работы с файлами в Python
Общие методы для работы с файлами: open(), чтобы открыть файл, seek(), чтобы установить текущую позицию файла на заданное смещение, и close(), чтобы закрыть файловый объект, когда вы закончите его использовать. Метод open() возвращает ссылку на файл, представляющий файловый объект, чтобы получить доступ к чтению, записи или добавлению.
Когда открывается файл для чтения, Python нужно точно знать, как следует открыть файл в системе. Доступны два способа — обычное чтение и чтение в двоичном режиме. Соответствующие флаги имеют вид rи rbи должны быть определены, когда файл открывается встроенным методом open(). Первый режим включает в себя интерпретацию специальных символов вроде «CR» (возврат каретки) and «LF» (перенос строки), чтобы отобразить разрыв строки, тогда как двоичный режим позволяет вам считывать данные в сыром виде — где данные хранятся как есть безо всякой дальнейшей интерпретации.
Как только вы открыли файл, методopen()вернёт вам файловый объект. Эти файловые объекты содержат методы наподобиеread(), readline(), write(), tell()и seek(). Хотя сами они (или подобные объекты) имеют больше методов, чем указано здесь, эти встречаются наиболее часто. Не каждый файловый объект нуждаются в имплементации всех методов работы с файлами.
Примеры
В этой статье мы будем объяснять, как читать файлы с помощью Python, через примеры. Некоторые из них включают построчное чтение, кусками (определённое количество строк за раз) и чтение в один заход. Также мы вам покажем способ прочесть отдельную строку из файла без поиска по всему файлу.
Построчное чтение файла
Первый пример вдохновлён двумя языками программирования: C и C++. Он довольно простой: открываем файл с помощью метода open(), читаем файл построчно, используя метод readline(), и выводим строку сразу же после чтения. Здесь применяется цикл while, который непрерывно читает из файла, пока метод readline() продолжает возвращать данные. В случае конца файла (EOF) цикл while останавливается, и файловый объект закрывается, освобождая ресурсы для других программ.
# определим имя файла, который читаем
filename = "test.txt"
# открываем файл для чтения
filehandle = open(filename, 'r')
while True:
# читаем одну строку
line = filehandle.readline()
if not line:
break
print(line)
# закрываем указатель на этот файл
filehandle.close()
Листинг 1
Как вы могли заметить, в листинге 1 мы явно открыли и закрыли файл (строки 5 и 14 соответственно). Хотя интерпретатор Python закрывает открытые файлы автоматически в конце исполнения программы, явно закрывать файл через close() есть хороший стиль программирования, и это не следует забывать.
В качестве улучшения в языке Python 2.3 был введён удобный протокол итераторов. Это позволяет вам упростить цикл readline следующим образом:
# определим имя файла, который читаем
filename = "test.txt"
for line in open(filename, 'r'):
print(line)
Листинг 2
Здесть применяется цикл for в комбинации с итератором in. Файл открывается в строке 4 листинга 2. Текущая строка определяется с помощью итератора in, считывается из файла, и её содержимое подаётся на выход stdout в строке 5. Python скрывает открытие и закрытие файла, когда закончится исполнение. Хотя такой способ неэффективен, он позволяет вам больше не иметь дело с файловым потоком.
К сожалению, код выше менее явный и полагается на сборщик мусора Python, чтобы закрыть файл. Введённая в Python 2.5 команда with инкапсулирует весь процесс ещё больше и также открывает и закрывает файлы лишь однажды на протяжении блока кода. Листинг 3 показывает, как использовать команду with.
# определим имя файла, который читаем
filename = "test.txt"
with open(filename, 'r') as filehandle:
for line in filehandle:
print(line)
Листинг 3
Комбинация оператора with и команды open() открывает файл только один раз (строка 4). Если цикл for завершён успешно, содержимое файла напечатано в поток stdout (строки 5 и 6).
Более того, использование выражения with даёт побочный эффект. Внутри интерпретатора Python создаётся блок try—finally, чтобы инкапсулировать чтение из файла. Листинг 4 показывает, что неизбежно случается внутри в Python с помощью блоков кодаwith:
try:
filehandle = open(filename, 'r')
# что-то делаем
finally:
filehandle.close()
Листинг 4
Чтение файла как набора строк
До сих пор мы обрабатывали файл построчно. Это довольно медленный способ для огромных файлов, но его можно улучшить, если читать несколько строк одновременно. Чтобы этого добиться, в дело вступает метод islice() из модуля itertools. Также он работает как итератор и возвращает набор данных, состоящий из n строк. В конце файла результат может быть короче, и завершающий вызов вернёт пустой список.
from itertools import islice
# определим имя файла, который читаем
filename = "test.txt"
# определим, сколько строк нужно прочесть
number_of_lines = 5
with open(filename, 'r') as input_file:
lines_cache = islice(input_file, number_of_lines)
for current_line in lines_cache:
print (current_line)
Листинг 5
Чтение определённой строки из файла
Используя показанные выше методы, мы можем также выполнить другие полезные действия, например, прочесть определённую строку из файла. Чтобы это сделать, применим счётчик и напечатаем соответствующую строку, когда дойдём до неё, проходя итерациями по файлу.
# определим имя файла, который читаем
filename = "test.txt"
# определим номер строки
line_number = 3
print ("line %i of %s is: " % (line_number, filename))
with open(filename, 'r') as filehandle:
current_line = 1
for line in filehandle:
if current_line == line_number:
print(line)
break
current_line += 1
Листинг 6
Листинг 6 достаточно просто понять, но он немного больше, чем предыдущие примеры. Его можно сократить, используя модуль linecache. Листинг 7 поазывает, как упростить код с помощью метода getline(). Если запрашиваемая строка выпадает из ряда валидных строк в файле, то метод getline() взамен возвращает пустую строку.
# импортируем модуль linecache
import linecache
# определим имя файла, который читаем
filename = "test.txt"
# определим номер строки
line_number = 3
# получим определённую строку
line = linecache.getline(filename, line_number)
print ("line %i of %s:" % (line_number, filename))
print (line)
Листинг 7
Чтение из всего файла целиком
В заключение мы посмотрим на совершенно другой случай по сравнению с предыдущим примером — прочитаем файл за один раз. Имейте в виду, что во многих случаях вам нужно достаточно места на компьютере, чтобы прочесть файл в память целиком. Листинг 8 использует комбинацию выражения with и метода read(). В этом случае мы применим read(), чтобы загрузить содержимое файла как поток данных.
# определим имя файла, который читаем
filename = "test.txt"
with open(filename, 'r') as filehandle:
filecontent = filehandle.read()
print (filecontent)
Листинг 8
Python также предлагает метод readlines(), похожий на метод readline() из первого примера. В отличие от read(), содержимое файла сохраняется в список, где каждый элемент есть строка содержимого. Листинг 9 показывает, как получить доступ к этим данным:
# определим имя файла, который читаем
filename = "test.txt"
with open(filename, 'r') as filehandle:
filecontent = filehandle.readlines()
for line in filecontent:
print (line)
Листинг 9
Хотя readlines() будет читать содержимое из файла, пока не наткнётся на EOF (конец файла), не забывайте, что вы также можете ограничить количество прочитанного параметром sizehint, — числом байт, которое нужно прочесть.
Вывод
Как обычно, есть больше одного способа прочитать содержимое файла. В плане скорости все они примерно одинаковы. Какое решение для вас работает лучше, зависит от решаемых вами задач. Мы думаем, что было бы полезно увидеть разные возможности и выбрать более подходящее решение.
Хотя Python значительно упрощает процесс чтения файлов, иногда он бывает довольно сложным, в таком случае рекомендую взглянуть на официальную документацию Python для дальнейшего ознакомления.
with .. as · Python Express Course
Чтение и запись в файл
Часто используемые операции над файлами:
| Операция | Интерпретация |
|---|---|
| output = open(r’C:\spam’, ‘w’) | Открывает файл для записи |
| input = open(‘data’, ‘r’) | Открывает файл для чтения |
| input = open(‘data’) | То же самое, ‘r’ — по умолчанию |
| aString = input.read() | Чтение файла целиком в единственную строку |
| aString = input.read(N) | Чтение следующих N символов (или байтов) в строку |
| aString = input.readline() | Чтение следующей текстовой строки (включая символ конца строки) в строку |
| aList = input.readlines() | Чтение файла целиком в список строк (включая символ конца строки) |
| output.write(aString) | Запись строки символов (или байтов) в файл |
| output.writelines(aList) | Запись всех строк из списка в файл |
| output.close() | Закрытие файла вручную (выполняется по окончании работы с файлом) |
| output.flush() | Выталкивает выходные буферы на диск, файл остается открытым |
| anyFile.seek(N) | Изменяет текущую позицию в файле для следующей операции, смещая ее на N байтов от начала файла. |
| for line in open(‘data’): операции над line | Итерации по файлу, построчное чтение |
| open(‘f.txt’, encoding=’latin-1′) | Файлы с текстом Юникода в Python 3.0 (строки типа str) |
| open(‘f.bin’, ‘rb’) | Файлы с двоичными данными в Python 3.0 (строки типа bytes) |
Читаем файл построчно
Если файл текстовый, то это итерируемая (по строкам) величина:
with open('some.txt') as fin:
for line in fin:
print(line)
Отдельно читаем первую строку, потом остальные:
with open('some.txt') as fin:
line = next(fin)
print('first line:', line)
for line in fin:
print(line)
Или с помощью метода readline():
with open('some.txt') as fin:
line = fin.readline()
print('first line:', line)
while line:
line = fin.readline()
print(line)
Текст — список строк
Чтобы прочитать весь файл в список строк, используйте функцию readlines (-s говорит, что «много») или преобразуйте объект файл в список.
with open('some.txt') as fin:
text = fin.readlines()
или
with open('some.txt') as fin:
text = list(fin)
Чтение бинарного потока
Функция read(size) возвращает строку, если файл открывали в текстовой моде или байтовый объект (бинарная мода).
Если size не указан или <0, то пытается прочитаться весь файл. Забота о памяти — это ваша проблема, а не питона. Не читайте так большие файлы.
Положительная size — размер буфера для чтения в байтах.
Если файл закончился, read вернет пустую строку ».
with open('text.txt') as f:
s = f.read(1)
print(s)
s = f.read()
print(s)
Запись в файл print
print('Hello', file=fin)
Запись в файл write
fin.write(b'Hello')
Чтение-запись текста как потока байтов
Не забывайте, что нужно кодировать и декодировать байты.
with open('somefile.bin', 'rb') as f:
data = f.read(16)
text = data.decode('utf-8')
with open('somefile.bin', 'wb') as f:
text = 'Hello World'
f.write(text.encode('utf-8'))
Открыть файл на запись, только если такого файла нет
Не хотим испортить уже существующий файл. Хотим открывать только новый.
Использовать ‘x’ вместо ‘w’ в режиме открытия файла.
Web-разработка • Python и Flask
Перед тем как прочесть или записать что-либо в файл, его следует открыть с помощью функции open(). При вызове эта функция создает объект типа File, с которым в дальнейшем можно работать.
open(file, mode, buffering, encoding)
Режим доступа mode — строка, в которой указывается для чего открывается файл:
'r'— открытие на чтение (является значением по умолчанию)'w'— открытие на запись, содержимое файла удаляется; если файла не существует, создается новый'x'— если файла не существует — открытие на запись, иначе исключение'a'— открытие на дозапись, информация добавляется в конец файла'b'— открытие в двоичном режиме't'— открытие в текстовом режиме (является значением по умолчанию)'+'— открытие на чтение и запись
Режимы могут быть объединены, то есть, к примеру, 'rb' — чтение в двоичном режиме. По умолчанию режим равен 'rt'.
Буферизация buffering (целое число): 0 — файл открывается без буферизации, 1 — с построчной буферизацией, больше одного — буферизация выполняется с указанным размером, отрицательное число — разер буфера будет равен системному.
И последний аргумент encoding задает кодировку, нужен только в текстовом режиме чтения файла.
Как только файл был открыт и появился файловый объект, можно получить следующую информацию:
file.closed— возвращаетTrueесли файл был закрытfile.mode— возвращает режим доступа, с которым был открыт файлfile.name— возвращает имя файлаfile.softspace— возвращаетFalse, если при выводе содержимого файла следует отдельно добавлять пробел
>>> file = open('test.txt')
>>> file.closed
False
>>> file.mode
'r'
>>> file.name
'test.txt'
>>> file.close()
Метод read() читает весь файл целиком, если был вызван без аргументов, и n символов, если был вызван с аргументом (целым числом n). Запись в файл осуществляется с помощью метода write(). После окончания работы с файлом его обязательно нужно закрыть с помощью метода close().
>>> helloFile = open('C:\\example\\hello.txt', 'w')
>>> helloFile.write('Hello, world!\n')
14
>>> helloFile.close()>>> helloFile = open('C:\\example\\hello.txt', 'r')
>>> helloFile.read()
'Hello, world!\n'
>>> helloFile.close()Добавление информации в файл:
>>> helloFile = open('C:\\example\\hello.txt', 'a')
>>> helloFile.write('It\'s nice to meet you.\n')
23
>>> helloFile.close()Чтение всех строк из файла:
>>> helloFile.readlines() ['Hello, world!\n', "It's nice to meet you.\n"] >>> helloFile.close()
Построчное чтение из файла:
>>> helloFile = open('C:\\example\\hello.txt', 'r')
>>> helloFile.readline()
'Hello, world!\n'
>>> helloFile.readline()
"It's nice to meet you.\n"
>>> helloFile.close()
При считывании символ новой строки \n присутствует в конце каждой из строк. Его может не быть лишь в последней строке — это позволяет добиться однозначности: если метод возвращает пустую строку, значит достигнут конец файла; если строка содержит лишь символ \n значит это просто очередная строка.
Запись нескольких строк в файл (при использовании with закрывать файл не нужно):
>>> with open('test.txt', 'w') as file:
... file.writelines(['First line\n', 'Second line'])>>> with open('test.txt') as file:
... file.readlines()
['First line\n', 'Second line']
Метод tell() возвращает позицию указателя, метод seek(offset, [from]) позволяет перейти на нужную позицию. Аргумент offset указывает на сколько байт перейти; аргумент from означает позицию, с которой начинается движение. 0 — означает начало файла, 1 — нынешняя позиция, 2 — конец файла.
Сохранение данных с помощью модуля shelve
>>> import shelve
>>> shelfFile = shelve.open('data')
>>> users = ['Иванов', 'Петров']
>>> mails = ['[email protected]', '[email protected]']
>>> shelfFile['users'] = users
>>> shelfFile['mails'] = mails
>>> shelfFile.close()>>> os.listdir() ['data.bak', 'data.dat', 'data.dir', 'hello.txt']
>>> shelfFile = shelve.open('data')
>>> shelfFile['users']
['Иванов', 'Петров']
>>> shelfFile['mails']
['[email protected]', '[email protected]']
>>> shelfFile.close() Поиск:
Python • Web-разработка • Файл
Построчное чтение текстового файла, При условии, что в теле файла есть символы EOF
mytetra://note/1518896750sz6jui0ua1
‘Можно так, подключив библиотеку Microsoft Scripting Runtime
Public Sub Checker2()
‘http://vbhack.ru/uroki-vbscript/obekt-fso/urok-vbscript-n10-rabota-s-tekstovymi-dokument.html
‘********************************************************
‘Урок VBScript №10:
‘Работа с текстовыми документами — TextStream.
‘file_3.vbs
‘********************************************************
t = Timer
Dim FSO, arr_Line, File, Txt, my_arr()
Set FSO = CreateObject(«Scripting.FileSystemObject»)
‘Set Txt = FSO.CreateTextFile(«base.txt», True)
‘Txt.Write («строка 1» & vbCrLf & «строка 2» & vbCrLf & «строка 3» & vbCrLf & «строка 4» & vbCrLf & «строка 5» & vbCrLf & «строка 6»)
Set File = FSO.OpenTextFile(«путь.txt», 1)
arr_Line = 0
Do Until File.AtEndOfStream ‘ пока наступит конец файла
‘ ReDim Preserve my_arr(arr_Line)
‘ Debug.Print arr_Line & » — » & File.ReadLine
‘ my_arr(arr_Line) = File.ReadLine ‘ Считываем строку
s = File.ReadLine ‘ Считываем строку
arr_Line = arr_Line + 1
If (arr_Line Mod 1000000) = 0 Then Debug.Print arr_Line & » — » & s: DoEvents
‘ If arr_Line = 5000000 Then Stop
Loop
Debug.Print arr_Line
File.Close ‘закрываем base.txt
Debug.Print Timer — t
‘MsgBox my_arr(3)
End Sub
Public Sub Checker()
Const FileName As String = «c:\ESRI\authorize.txt»
Dim fso As New Scripting.FileSystemObject
Dim pStream As Scripting.TextStream
Dim Strs() As String, i As Long, sRow As String
Set pStream = fso.OpenTextFile(FileName, ForReading)
Strs = VBA.Split(pStream.ReadAll, vbNewLine)
pStream.Close
‘Естественно, если нужен только log, то
‘перезаписывать файл не нужно, тогда убрать эту строку
Set pStream = fso.CreateTextFile(FileName, True)
‘цикл по строкам исходного файла
‘а вы уверены, что в бинарной части
‘не будет vbNewLine?
For i = 0 To UBound(Strs)
sRow = Strs(i)
‘анализируем строку sRow на табуляцию и что-то с ней делаем
‘….
‘сохраняем изменённую строку, если нет перезаписи то и ниже комментируем
pStream.WriteLine sRow
Next i
‘как и эту
pStream.Close
End Sub
Покоряем Python — уроки для начинающих: Файлы, углубляемся
Файлы
Возможно, вы уже знакомы с понятием файла – так называются именованные области постоянной памяти в вашем компьютере, которыми управляет операционная система.Последний основной встроенный тип объектов, который мы исследуем в нашем обзоре, обеспечивает возможность доступа к этим файлам из программ на языке Python.
Проще говоря, встроенная функция open создает объект файла, который обеспечивает связь с файлом, размещенным в компьютере. После вызова функции open можно выполнять операции чтения и записи во внешний файл, используя методы полученного объекта.
Операция — Интерпретация
output = open(r’C:\spam’, ‘w’) — Открывает файл для записи (‘w’ означает write – запись)
input = open(‘data’, ‘r’) — Открывает файл для чтения (‘r’ означает read – чтение)
input = open(‘data’) — То же самое, что и в предыдущей строке
(режим ‘r’ используется по умолчанию)
aString = input.read() — Чтение файла целиком в единственную строку
aString = input.read(N) — Чтение следующих N символов (или байтов) в строку
aString = input.readline() — Чтение следующей текстовой строки
(включая символ конца строки) в строку
aList = input.readlines() — Чтение файла целиком в список строк
(включая символ конца строки)
output.write(aString) — Запись строки символов (или байтов) в файл
output.writelines(aList) — Запись всех строк из списка в файл
output.close() — Закрытие файла вручную (выполняется по окончании работы с файлом)
output.flush() — Выталкивает выходные буферы на диск, файл остается открытым
anyFile.seek(N) — Изменяет текущую позицию в файле для
следующей операции, смещая ее на N байтов от начала файла.
for line in open(‘data’): — Итерации по файлу, построчное чтение
операции над line
open(‘f.txt’, — Файлы с текстом Юникода в Python 3.0 (строки типа str)
encoding=’latin-1’)
open(‘f.bin’, ‘rb’) — Файлы с двоичными данными в Python 3.0
Чтобы открыть файл, программа должна вызвать функцию open, передав ей имя внешнего файла и режим работы. Обычно в качестве режима использует-
ся строка ‘r’, когда файл открывается для чтения (по умолчанию), ‘w’ – когда
файл открывается для записи или ‘a’ – когда файл открывается на запись в ко-
нец.
Использование файлов
Как только будет получен объект файла, вы можете вызывать его методы для
выполнения операций чтения или записи. В любом случае содержимое файла
в программах на языке Python принимает форму строк – операция чтения воз-
вращает текст в строках, и метод записи принимает информацию в виде строк.
Файлы в действии
>>> myfile = open(‘myfile.txt’, ‘w’) # Открывает файл (создает/очищает)
>>> myfile.write(‘hello text file\n’) # Записывает строку текста
16
>>> myfile.write(‘goodbye text file\n’)
18
>>> myfile.close() # Выталкивает выходные буферы на диск
>>> myfile = open(‘myfile.txt’) # Открывает файл: ‘r’ – по умолчанию
>>> myfile.readline() # Читает строку
‘hello text file\n’
>>> myfile.readline()
‘goodbye text file\n’
>>> myfile.readline() # Пустая строка: конец файла
Обратите внимание, что в Python 3.0 метод write возвращает количество запи-
санных символов – в версии 2.6 этого не происходит, поэтому в интерактив-
ном сеансе вы не увидите эти числа.
Если необходимо вывести содержимое файла, обеспечив правильную интер-
претацию символов конца строки, его следует прочитать в строку целиком,
с помощью метода read, и вывести:
>>> open(‘myfile.txt’).read() # Прочитать файл целиком в строку
‘hello text file\ngoodbye text file\n’
>>> print(open(‘myfile.txt’).read()) # Более дружественная
форма отображения
hello text file
goodbye text file
А если необходимо просмотреть содержимое файла строку за строкой, лучшим
выбором будет итератор файла:
>>> for line in open(‘myfile’): # Используйте итераторы, а
не методы чтения
… print(line, end=’’)
…
hello text file
goodbye text file
В этом случае функцией open создается временный объект файла, содержимое
которого автоматически будет читаться итератором и возвращаться по одной
строке в каждой итерации цикла.
Сохранение и интерпретация объектов Python в файлах
Следующий пример записывает различные объекты в текстовый файл.
>>> X, Y, Z = 43, 44, 45 # Объекты языка Python должны
>>> S = ‘Spam’ # записываться в файл только
в виде строк
>>> D = {‘a’: 1, ‘b’: 2}
>>> L = [1, 2, 3]
>>>
>>> F = open(‘datafile.txt’, ‘w’) # Создает файл для записи
>>> F.write(S + ‘\n’) # Строки завершаются символом \n
>>> F.write(‘%s,%s,%s\n’ % (X, Y, Z))# Преобразует числа в строки
>>> F.write(str(L) + ‘$’ + str(D) + ‘\n’) # Преобразует
и разделяет символом $
>>> F.close()
Использование инструкции print:
>>> chars = open(‘datafile.txt’).read() # Отображение строки
>>> chars # в неформатированном виде
“Spam\n43,44,45\n[1, 2, 3]${‘a’: 1, ‘b’: 2}\n”
>>> print(chars) # Удобочитаемое представление
Spam
43,44,45
[1, 2, 3]${‘a’: 1, ‘b’: 2}
Теперь нам необходимо выполнить обратные преобразования, чтобы получить
из строк в текстовом файле действительные объекты языка Python.
>>> F = open(‘datafile.txt’) # Открыть файл снова
>>> line = F.readline() # Прочитать одну строку
>>> line
‘Spam\n’
>>> line.rstrip() # Удалить символ конца строки
‘Spam’
Пока что мы прочитали ту часть файла, которая содержит строку. Теперь про-
читаем следующий блок, в котором содержатся числа, и выполним разбор это-
го блока (то есть извлечем объекты):
>>> line = F.readline() # Следующая строка из файла
>>> line # Это — строка
‘43,44,45\n’
>>> parts = line.split(‘,’) # Разбить на подстроки по запятым
>>> parts
[‘43’, ‘44’, ‘45\n’]
Здесь был использован метод split, чтобы разбить строку на части по запятым, которые играют роль символов-разделителей, – в результате мы получили список строк, каждая из которых содержит отдельное число. Теперь нам необходимо преобразовать эти строки в целые числа, чтобы можно было выполнять математические операции над ними:
>>> int(parts[1]) # Преобразовать строку в целое число
44
>>> numbers = [int(P) for P in parts] # Преобразовать весь список
>>> numbers
[43, 44, 45]
Как мы уже знаем, функция int преобразует строку цифр в объект целого числа.
Наконец, чтобы преобразовать список и словарь в третьей строке файла, можно воспользоваться встроенной функцией eval, которая интерпретирует строку как программный код на языке Python:
>>> line = F.readline()
>>> line
“[1, 2, 3]${‘a’: 1, ‘b’: 2}\n”
>>> parts = line.split(‘$’) # Разбить на строки по символу $
>>> parts
[‘[1, 2, 3]’, “{‘a’: 1, ‘b’: 2}\n”]
>>> eval(parts[0]) # Преобразовать строку в объект
[1, 2, 3]
>>> objects = [eval(P) for P in parts] # То же самое для всех строк в списке
>>> objects
[[1, 2, 3], {‘a’: 1, ‘b’: 2}]
Поскольку теперь все данные представляют собой список обычных объектов, а не строк, мы сможем применять к ним операции списков и словарей.
Чтение файлов в Ruby— Ruby Rush
В этом уроке вы научитесь работать с файлами в Ruby. Мы будем открывать файлы, читать их содержимое и работать с ним в удобной форме.
Мы узнаем о классе File и о том, как работают его методы new, dirname, exist? и методы его экземпляров read, readlines и close.
Мы научимся читать из файлов данные целиком и построчно, как выводить на экран произвольную строчку файла и как, а главное, для чего необходимо закрывать файлы.
План урока
- Файлы, что это такое и как программы с ними работают
- Чтение данных из файла в Ruby и не только
- Зачем нужно закрывать файлы и как это делать
Что такое файлы?
Однажды программисты поняли, что хранить данные в памяти компьютера не надёжно, затратно, не выгодно и вообще, программа должна быть постоянно запущена. Было бы здорово, если бы можно было выключить программу, а потом начать с того же места.
Как-то так были придуманы файлы.
Абсолютно вся информация на вашем или любом другом компьютере когда он выключен, храниться в файлах.
Файлы есть как у вас на домашнем компьютере — ваши документы и фотографии или системные файлы Windows или Mac OS X, так и на любом сервере, к которому вы на самом деле обращаетесь, когда вводите в браузере адрес любого сайта. То, что вы видите как сайт — это тоже файл (чаще всего несколько файлов), подготовленных определённым образом.
Именно поэтому так важно и удобно уметь работать с файлами в ваших программах.
Как программы работают с файлами
Программы — они как люди. Только люди читают книги, когда им нужна какая-то информация, а программы могут читать не только книги, но и картинки, аудиозаписи, видеоролики и много-много другого.
Когда программе сказали, что ей нужно прочесть какой-то файл, она ищет его в файловой системе вашего компьютера и достаёт его, подобно тому, как вы можете заказать книгу в ближайшей библиотеке.
После того, как файловая система предоставила ей этот файл (как заботливый библиотекарь), программа его открывает и может начать читать.
А потом, конечно же, файл нужно закрыть и вернуть на место, чтобы его могли читать другие программы (хотя, в отличие от библиотеки, один и тот же файл могут читать сразу несколько программ, копируя его себе в память или в специальное место на диске).
Чтение файлов в Ruby
Давайте напишем простенькую программку, решающую вот такую задачу:
Вывести на экран произвольный афоризм из файла со списком афоризмов.
Список будет храниться в файле quotes.txt, по одному афоризму на одну строчку файла.
Как обычно, файлы мы храним в нашей папке урока: с:\rubytut\lesson13.
Однако, для файлов с данными, не являющимися текстом программ, удобно всегда создавать вложенные подпапки. Наш файл с цитатами quotes.txt мы положим в подпапку data в нашей рабочей директории. Сам файл будет содержать вот это:
Учиться, учиться и еще раз учиться... программированию! // В. И. Ленин
Слышь, пацан, либы есть? // Ванек со второго подъезда
Я программирую, значит я существую // Фрэнсис Бэкон
Кто не умеет программировать, тот лох :) // Билл Гейтс
Тяжело в учении — легко в программировании // Народная мудрость
Программировали, перепрограммировали, да не запрограммировали // Скороговорка
Вы можете взять наши цитаты или (что гораздо интереснее, придумать свои).
Теперь создадим нашу программу open_file.rb в рабочей папке урока с:\rubytut\lesson13.
В этой программе мы будем открывать файл data/quotes.txt, брать из него произвольную строчку и выводить её на экран.
Для пользователей Windows: убедитесь, что вы сохранили файл quotes.txt в кодировке UTF-8 (для этого тоже можно использовать редактор Sublime), как это делать мы обсуждали во втором уроке.
Открытие файла
Для работы с файлами в Ruby есть специальный встроенный класс File, который позволяет в программе создавать объекты для работы с файлами.
Любой экземпляр класса начинается с конструктора. Также и здесь, чтобы создать новый файловый объект, нам надо у класса File вызвать метод new, который вернёт нам экземпляр класса File.
Методу new нужно передать несколько параметров мы уже умеем это делать: первый параметр — путь (относительно текущей директории, из которой вы запускаете программу) к файлу, который нужно открыть, подробнее об этом в 2-м уроке, второй параметр — специальный ключ.
Этот ключ говорит классу File, как именно мы хотим открыть файл, и в какой кодировке мы этот файл хотим прочитать.
В нашем случае мы хотим открыть наш файл с афоризмами ./data/quotes.txt для чтения в кодировке UTF-8, поэтому пишем так:
file = File.new("./data/quotes.txt","r:UTF-8")
Обратите внимание на ключ "r:UTF-8", первая буква обозначает тип открытия файла:
r— только для чтения: мы будем только читать файл, писать в него мы так не сможемw— только для записи: мы не хотим знать, что в файле, мы просто перепишем его содержимоеa— только для записи, но дописывать будем в конец файла, сам файл не трогаем
Есть и другие ключи, но в этом блоке не будем ими морочить вам голову, в этом уроке нам понадобится только первый, так что все остальные — для любознательных. После указания способа открытия файла через двоеточие идёт кодировка, в нашем случае UTF-8.
Чтение информации из файла
Мы открыли файл, но пока ещё ничего с ним не сделали, мы просто получили некую переменную file с экземпляром класса File, которая знает, к какому файлу она относится и как ему с этим файлом нужно обращаться.
Мы можем получить всё содержимое файла в одной большой строке (со всеми словами, пробелами и переносами) с помощью метода read экземпляра класса File, то есть нашего объекта file.
content = file.read
Теперь по идее в переменной content у нас будут все цитаты одна за другой.
Чтение файла построчно
По условию задачи нам нужно прочитать только одну цитату, а не весь файл целиком. Поэтому нам нужно немного переписать нашу программу. Мы напишем новый файл read_lines.rb
file_path = "/data/aphorizmus.txt"
f = File.new(file_path, "r:UTF-8")
lines = f.readlines
puts lines.sample
Обратите внимание, что мы сохранили путь к файлу в переменную file_path, чтобы каждый раз не писать его вручную.
Вместо file.read вызываем метод readlines, который в отличие от предыдущего возвращает не одну большую строку, а массив строк, разбитых по символам переноса.
Этот массив мы сохранили в переменную lines, поэтому чтобы вывести одну случайную строчку файла мы можем просто написать
puts lines.sample
Метод sample у массива возвращает один случайный элемент из этого массива — каждый раз разный.
Запуск программы
Программа написана и осталось её запустить, для этого как обычно переходим в нашу рабочую папку в консоли и запускаем программу с помощью команды ruby
cd c:\rubytut\lesson13\
ruby read_lines.rb
Что делать когда файл не найден?
Первое, с чем сталкивается любой программист, когда пишет программу, общающуюся с файлами — ситуация, когда файл не открылся. Не важно по какой-то причине.
Может, его стёрли, может, он опечатался и неправильно указал имя файла, может быть, диск, на котором хранился файл, не доступен. Мало ли чего в наше неспокойное время может произойти.
Запомните основное правило при работе с файлами: перед открытием файла всегда убедитесь, что он есть.
Проверить наличие файла можно с помощью метода exist? у класса File:
if File.exist?(file_path)
# тут можно работать с файлом, не боясь, что он не откроется
else
puts "Файл не найден"
end
Как вы видите, метод очень похож на new, только никакой ключ ему не нужен, потому что методу exist? не важно, как с этим файлом собрались работать, ему только нужно проверить, есть ли файл и если файл есть, то вернуть true, а если нет — вернуть false.
Именно поэтому очень удобно использовать этот метод в качестве условия в конструкции if-else, если файл есть, мы его откроем и прочитаем, если его нет, мы напишем об этом пользователю и либо пойдём дальше, либо прекратим выполнение программы.
Теперь можно переименовать файл quotes.txt в, например, quotes_.txt и убедиться, что при запуске программы, мы увидим строчку
Файл не найден
Как правильно указывать пути к файлам
При открытии файла мы считали, что он лежит в папке data, которая находится в той же папке, в которой мы запускаем программу.
Если мы в консоли поднимемся на уровень выше:
cd ../
и снова запустим нашу программу, дописав к её пути спереди название папки, в которой она лежит (мы не говорили, но так можно делать):
ruby lesson13/qoute.rb
то встретимся как раз с ситуацией, когда файл не найден.
Наша проверка обломалась, ведь файла уже нет рядом с нами, он лежит в другой папке, о чём программа не знает, она ищет его в c:\rubytut\data, то есть рассматривает путь data относительно текущей папки консоли.
Знак точки (.) в пути к файлу означает: «текущая папка, в которой мы находились в тот момент, когда запустили программу», то есть текущая папка консоли в нашем случае.
Но нам нужно, чтобы файл в подпапке data искался всегда относительно папки, в которой лежит программа, а не из которой она запущена.
Это легко исправить, ведь для этого в Ruby есть классная штука: специальный объект __FILE__ — он содержит путь к файлу программы относительно той папки, из которой программа запущена. То есть откуда бы мы не запустили, с помощью объекта __FILE__ мы всегда можем восстановить правильный путь к файлам нашей программы.
Для того, чтобы из этой переменной получить путь к папке текущей программы, нам нужно снова обратиться к нашему классу File:
current_path = File.dirname(__FILE__)
Теперь в переменной current_path всегда (откуда бы мы ни запустили нашу программу) будет лежать путь к папке с этой программой.
А от него и до data/quotes.txt рукой подать, нужно просто склеить две строчки плюсиком, как мы это умеем делать:
file_path = current_path + "/data/quotes.txt"
Теперь откуда бы мы ни запустили нашу программу, она будет искать файл data/quotes.txt рядом с собой, а не в том месте, откуда её вызвали.
Это очень удобно. Можно в консоли перейти на папку выше и запустить программу вот так:
ruby lesson13/read_lines.rb
Тяжело в учении — легко в программировании!
Закрытие файлов
Если вкратце, то файлы нужно закрывать.
Ну во-первых, незакрытые файлы могут приводить к ошибкам в ваших и чужих программах, которые работают с этим же файлом.
Во-вторых, каждый открытый файл занимает у памяти какой-то её объём и чем больше таких открытых файлов, тем медленнее работает ваша программа. Хорошие программисты помнят об этом и стараются делать свои программы быстрее.
Для нашей маленькой программы это не так важно — Ruby сам закроет все файлы после выполнения программы.
Но усвоить эту привычку надо уже сейчас, когда ваши программы станут большими и навороченными, вы еще скажете нам спасибо за эту привычку.
Это как правило хорошего тона: подобно тому, как прилежный читатель всегда возвращает книгу туда, откуда он её взял — полка в собственном доме или библиотека, также и прилежный программист всегда должен помнить о том, что чем меньше на Земле незакрытых вовремя файлов, тем больше на Земле добра!
Делайте добро, Дамы и Господа, всегда закрывайте ваши файлы.
Закрывать файлы можно сразу после того, как вы сделали с файлом всё, для чего он был нужен. Прям вот сразу же.
В нашей программе мы закроем файл ещё до того, как выведем строчку на экран.
current_path = File.dirname(__FILE__)
file_path = current_path + "/data/aphorizmus.txt"
if File.exist?(file_path)
f = File.new(file_path, "r:UTF-8")
lines = f.readlines
f.close
puts lines.sample
else
puts "Файл не найден"
end
Итак, сегодня мы научились работать с файлами, узнали о классе File, как работают его методы new, dirname, exist? и методы его экземпляров read, readlines и close.
Узнали, как читать из файлов данные целиком и построчно, как выводить на экран произвольную строчку файла и как, а главное, для чего необходимо закрывать файлы.
А в следующем уроке нас ждёт третья версия нашей замечательной игры «Виселица», мы будем использовать полученные данные и будем открывать файлы с псевдографикой.
C читать файл | Упрощенное программирование
Как читать файл на C? Вы уже знаете, что такое файл и его типы (текстовый / двоичный (аудио / изображения / видео и т. Д.)). Когда компьютер выключен, они присутствуют на жестком диске.
Предположим, на прошлой неделе вы создали программу на языке C для сортировки чисел и хотите снова увидеть эту программу. Как ты это делаешь? Вы находите файл в системе и открываете его в IDE / текстовом редакторе. Это круто! Но что интереснее, так это открыть файл через вашу программу.
Для простоты мы обсуждаем только чтение текстовых файлов.
Давайте напишем программу на C, чтобы открывать файл с жесткого диска, имя которого вводится пользователем, и отображать его содержимое на экране. Открытие файла означает, что мы переносим содержимое файла с диска в ОЗУ для выполнения над ним операций (чтения / изменения / добавления файла). Файл должен находиться в каталоге, в котором находится исполняемый файл программы.
Функция fopen используется для открытия файла; он возвращает указатель на структуру FILE, которая является предопределенной структурой в «stdio.h «заголовочный файл. Если открытие файла прошло успешно, он возвращает указатель на файл, а если не может открыть его, то возвращает NULL.
Функция fgetc возвращает символ, прочитанный из файла, и Функция fclose закрывает файл.
Чтение файла на C с использованием программного кода fopen
C для открытия файла и вывода его содержимого на экран.
#include
#include
int main ()
{
char ch, file_name [25];
FILE * fp;
printf («Введите имя файла, который вы хотите увидеть \ n»);
получает (имя_файла);
fp = fopen ( file_name, «r»); // режим чтения
if (fp == NULL)
{
perror («Ошибка при открытии файла.\ n «);
exit (EXIT_FAILURE);
}
printf (» Содержимое файла% s: \ n «, имя_файла);
while ((ch = fgetc (fp))! = EOF)
printf («% c», ch);
fclose (fp);
return 0;
}
Чтение файла Вывод программы C:
Загрузить Чтение программы файла.
В конце В нашей программе мы открыли только один файл. Вы можете открыть несколько файлов в одной программе в разных режимах по мере необходимости.
Обработка файлов необходима, когда мы хотим постоянно хранить данные на устройстве хранения. Все переменные и данные программы теряются при ее завершении. Если данные потребуются позже, нам нужно сохранить их в файле.
Программа на C для чтения содержимого файла посимвольно
В этом руководстве мы узнаем, как читать содержимое файла на языке программирования C . Вы можете изменить программу для чтения содержимого из нескольких файлов, если хотите. Программа будет читать содержимое посимвольно и распечатывать читаемый символ пользователю.
Программа C:
#include
#include
int main ()
{
ФАЙЛ * filePointer;
char ch;
filePointer = fopen ("example.txt", "r");
если (filePointer == NULL)
{
printf ("Файл недоступен \ n");
}
еще
{
в то время как ((ch = fgetc (filePointer))! = EOF)
{
printf ("% c", ch);
}
}
fclose (filePointer);
возврат 0;
} Пояснение:
Закомментированные числа в приведенной выше программе обозначают номер шага ниже:
- Создайте один указатель FILE и одну переменную символа .Указатель будет указывать на файл, который мы откроем, а символьная переменная будет содержать текущий читаемый символ.
- Открыть файл в режиме чтения . Мы используем ‘r’ , чтобы открыть его в режиме чтения. Имя файла — example.txt , и он находится в той же папке, где сохранен файл c .
- Прежде всего, проверьте, не является ли значение filePointer NULL. Если это NULL , значит файл не существует.
- Используя один цикл while , прочтите содержимое файла по одному символу.Мы используем метод fgetc для чтения символов. Прочтите его до тех пор, пока символ не станет концом файла или EOF . Внутри цикла используйте один оператор printf , чтобы распечатать текущий читаемый символ.
- Наконец, закройте файл, используя fclose .
Эта функция распечатает содержимое, сохраненное в файле example.txt .
Как видите, содержимое файла .txt , который я сохранил на моем диске, содержит только Hello World !! текст.
Вывод:
В этом кратком руководстве мы узнали, как читать содержимое файла посимвольно в C . Попробуйте запустить пример программы, который мы показали выше, и оставьте один комментарий ниже, если вам понравилась эта статья и у вас есть какие-либо вопросы.
Примеры исходного кода для наших учебных модулей
Компоненты веб-решения Пример из учебного курса Well House Consultants
Подробнее о компонентах веб-решения [ссылка]
Исходный код: примеры.txt Модуль: A100
Эта страница является только примером — вы запустили сценарий «Пример исходного кода
» на веб-сайте Well House Consultants, но
вы не сказали нам, какой пример вам нужен. Перейдите по ссылкам
, чтобы найти конкретный пример
, который вы ищете.
Узнать об этом предмете
Книги по этой теме
Да. В нашей библиотеке более 700 книг. Книги
Прикрывающее развертывание лампы перечислены здесь, и когда вы выбрали
соответствующую книгу мы свяжем вас с Amazon для заказа.
Другие примеры
Этот пример взят из нашего учебного модуля «Компоненты веб-решения». Вы найдете описание темы и некоторые
другие тесно связанные примеры на индексной странице модуля «Компоненты веб-решения».
Полное описание исходного кода
Вы можете узнать больше об этом примере на учебных курсах, перечисленных на этой странице,
на котором вы получите полный набор обучающих заметок.
Многие другие учебные модули доступны для загрузки (для ограниченного использования) с
наш центр загрузки под
Лицензия Open Training Notes.
Другие ресурсы
• В нашем центре решений есть ряд более длинных технических статей.
• В нашем архиве форумов Opentalk есть центр вопросов и ответов.
• Лошадиный рот дает ежедневные подсказки или мысли.
• Дополнительные ресурсы доступны через ресурсный центр.
• Все эти ресурсы можно найти с помощью нашей поисковой системы
.
• И здесь есть глобальный индекс.
Назначение этого сайта
Это образец программы, демонстрация класса или ответ от
учебный курс.Это основная цель
заключается в предоставлении послекурсовых услуг клиентам, которые посещали наши
общественное частное или
на сайте курсы, но примеры сделаны
обычно доступны при условиях, описанных ниже.
Автор веб-сайта
Этот веб-сайт написан и поддерживается
Консультанты Well House.
Условия использования
Прошедшие участники наших учебных курсов могут использовать индивидуальные
примеры в процессе их программирования, но необходимо проверить
примеры, которые они используют, чтобы убедиться, что они подходят для их
работа. Помните, что некоторые из наших примеров показывают вам, как , а не делать
вещи — проверяйте в своих заметках. Well House Consultants не несет ответственности
на предмет соответствия этих примеров программ потребностям клиентов.
Авторские права на эту программу принадлежат Well House Consultants Ltd.
запрещено использовать его для проведения собственных учебных курсов
без нашего предварительного письменного разрешения. Смотрите наши
страницу о предоставлении учебных программ для получения более подробной информации.
Любое из наших изображений в этом коде ЗАПРЕЩАЕТСЯ повторно использовать в общедоступном URL-адресе без нашего
предварительное разрешение.Для добросовестного личного использования мы часто предоставляем вам разрешение.
что вы предоставляете обратную ссылку. За коммерческое использование веб-сайта взимается лицензионный сбор за
каждое использованное изображение — детали по запросу.
C # .Net: самый быстрый способ чтения текстовых файлов
using System;
с использованием System.IO;
с использованием System.Linq;
с использованием System.Text;
с использованием System.Threading;
пространство имен TestApplication
{
класс Программа
{
static void Main (string [] args)
{
DateTime end;
Дата и время начала = Дата и время.Сейчас же;
Console.WriteLine («### Общее время начала:» + start.ToLongTimeString ());
Console.WriteLine ();
TestReadingLinesFromFile ((int) Math.Floor ((double) (Int32.MaxValue / 500)), 5);
TestReadingLinesFromFile ((int) Math.Floor ((double) (Int32.MaxValue / 500)), 10);
TestReadingLinesFromFile ((int) Math.Floor ((double) (Int32.MaxValue / 500)), 25);
TestReadingLinesFromFile ((int) Math.Этаж ((двойной) (Int32.MaxValue / 1000)), 5);
TestReadingLinesFromFile ((int) Math.Floor ((double) (Int32.MaxValue / 1000)), 10);
TestReadingLinesFromFile ((int) Math.Floor ((double) (Int32.MaxValue / 1000)), 25);
TestReadingLinesFromFile ((int) Math.Floor ((double) (Int32.MaxValue / 10000)), 5);
TestReadingLinesFromFile ((int) Math.Floor ((double) (Int32.MaxValue / 10000)), 10);
TestReadingLinesFromFile ((int) Math.Этаж ((двойной) (Int32.MaxValue / 10000)), 25);
конец = DateTime.Now;
Console.WriteLine ();
Console.WriteLine («### Общее время окончания:» + end.ToLongTimeString ());
Console.WriteLine («### Общее время работы:» + (конец — начало));
Console.WriteLine ();
Console.WriteLine («Нажмите Enter, чтобы выйти»);
Console.ReadLine ();
}
// ########################################################################## #########
// Выполняет сравнение чтения всех строк из файла.Какой путь самый быстрый?
static void TestReadingLinesFromFile (int numberOfLines, int numTimesGuidRepeated)
{
Console.WriteLine («########» + System.Reflection.MethodBase.GetCurrentMethod (). Name).
Console.WriteLine («######## Количество строк в файле:» + numberOfLines);
Console.WriteLine («######## Количество повторений Guid в каждой строке:» + numTimesGuidRepeated);
Консоль.WriteLine («################################################################################ ############ «);
Console.WriteLine ();
строка g = String.Join («», Enumerable.Repeat (новый Guid (). ToString (), numTimesGuidRepeated));
строка [] AllLines = null;
строка fileName = «Performance_Test_File.txt»;
int MAX = numberOfLines;
DateTime end;
DateTime start = DateTime.Now;
// Создайте файл, заполнив его идентификаторами GUID
Console.WriteLine («Создание файла:» + start.ToLongTimeString ());
с использованием (StreamWriter sw = File.CreateText (fileName))
{
для (int x = 0; x & lt; MAX; x ++)
{
sw.WriteLine (g);
}
}
end = DateTime.Now;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Консоль.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
GC.Collect ();
Thread.Sleep (1000); // даем диску аппаратное время для восстановления
// Просто считываем все в одну строку
Console.WriteLine («Чтение чтения файла до конца строки:»);
start = DateTime.Now;
попробуйте
{
используя (StreamReader sr = File.OpenText (имя_файла))
{
строка s = sr.ReadToEnd ();
// Очевидно, тогда вам нужно будет обработать строку
}
end = DateTime.Now;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (OutOfMemoryException)
{
end = DateTime.Сейчас же;
Console.WriteLine («Недостаточно памяти. Не удалось выполнить этот тест.»);
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (исключение)
{
end = DateTime.Now;
Console.WriteLine («ИСКЛЮЧЕНИЕ.Не удалось выполнить этот тест. «);
Console.WriteLine (» Finished at: «+ end.ToLongTimeString ());
Console.WriteLine (» Time: «+ (end — start));
Console .WriteLine ();
}
GC.Collect ();
Thread.Sleep (1000); // даем дисковое аппаратное время для восстановления
// Считываем все содержимое в объект StringBuilder
Console.WriteLine («Чтение файла, чтение до конца в построитель строк:»);
start = DateTime.Now;
попробуйте
{
используя (StreamReader sr = File.OpenText (fileName))
{
StringBuilder sb = new StringBuilder ();
сбн.Append (sr.ReadToEnd ());
// Очевидно, тогда вам нужно будет обработать строку
}
end = DateTime.Сейчас же;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (OutOfMemoryException)
{
end = DateTime.Now;
Console.WriteLine («Недостаточно памяти. Не удалось выполнить этот тест.»);
Консоль.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (исключение)
{
end = DateTime.Now;
Console.WriteLine («ИСКЛЮЧЕНИЕ. Не удалось выполнить этот тест.»);
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Консоль.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
GC.Collect ();
Thread.Sleep (1000); // даем диску аппаратное время для восстановления
// Стандартный и, вероятно, наиболее распространенный способ чтения файла.
Console.WriteLine («Чтение файла с присвоением каждой строки строке:»);
start = DateTime.Now;
с использованием (StreamReader sr = File.OpenText (имя_файла))
{
строка s = String.Empty;
while ((s = sr.ReadLine ())! = Null)
{
// мы просто тестируем скорость чтения
}
}
end = DateTime.Now;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Консоль.WriteLine ();
GC.Collect ();
Thread.Sleep (1000); // даем диску аппаратное время для восстановления
// Делаем это наиболее распространенным способом, но теперь с использованием буферизованного считывателя.
Console.WriteLine («Буферизованный файл чтения, приписывающий каждую строку к строке:»);
start = DateTime.Now;
с использованием (FileStream fs = File.Open (fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
с использованием (BufferedStream bs = new BufferedStream (fs))
с использованием (StreamReader sr = new StreamReader (bs ))
{
строка s;
в то время как ((s = sr.ReadLine ())! = Null)
{
// мы просто тестируем скорость чтения
}
}
end = DateTime.Now;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
GC.Collect ();
Thread.Sleep (1000); // даем диску аппаратное время для восстановления
// Повторное чтение каждой строки с помощью буферизованного считывателя, но установка размера буфера, так как мы знаем, каким он будет.
Console.WriteLine («Буферизованное чтение с предустановленным размером буфера, приписывающим каждую строку строке:»);
start = DateTime.Now;
с использованием (FileStream fs = File.Open (fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
с использованием (BufferedStream bs = new BufferedStream (fs, System.Text.ASCIIEncoding.Unicode.GetByteCoding (getByteCoding) ))
с использованием (StreamReader sr = new StreamReader (bs))
{
string s;
в то время как ((s = sr.ReadLine ())! = Null)
{
// мы просто тестируем скорость чтения
}
}
end = DateTime.Now;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
GC.Collect ();
Thread.Sleep (1000); // даем диску аппаратное время для восстановления
// Прочитать каждую строку файла, повторно используя объект StringBuilder, чтобы сэкономить время выделения памяти для строк
Console.WriteLine («Чтение файла, в котором каждая строка присваивается StringBuilder:»);
start = DateTime.Now;
с использованием (StreamReader sr = File.OpenText (fileName))
{
StringBuilder sb = new StringBuilder ();
while (sb.Append (sr.ReadLine ()). Length & gt; 0)
{
// мы просто тестируем скорость чтения
sb.Clear ();
}
}
end = DateTime.Сейчас же;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
GC.Collect ();
Thread.Sleep (1000); // даем диску аппаратное время для восстановления
// Чтение каждой строки в StringBuilder, но установка объекта StringBuilder на начальный размер
//, поскольку мы знаем, какова длина самой длинной строки в файле.
Console.WriteLine («Чтение файла, присвоение каждой строке заданного размера StringBuilder:»);
start = DateTime.Now;
с использованием (StreamReader sr = File.OpenText (fileName))
{
StringBuilder sb = new StringBuilder (g.Length);
while (sb.Append (sr.ReadLine ()). Length & gt; 0)
{
// мы просто тестируем скорость чтения
сб.Прозрачный();
}
}
end = DateTime.Now;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
GC.Collect ();
Thread.Sleep (1000); // даем диску аппаратное время для восстановления
// Считываем каждую строку в индекс массива.
Console.WriteLine («Чтение каждой строки в массив строк:»);
start = DateTime.Now;
попробовать
{
AllLines = новая строка [MAX]; // здесь выделяем только память
using (StreamReader sr = File.OpenText (fileName))
{
int x = 0;
while (! Sr.EndOfStream)
{
// мы просто тестируем скорость чтения
AllLines [x] = sr.ReadLine ();
х + = 1;
}
}
end = DateTime.Now;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (OutOfMemoryException)
{
end = DateTime.Сейчас же;
Console.WriteLine («Недостаточно памяти. Не удалось выполнить этот тест.»);
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (исключение)
{
end = DateTime.Now;
Console.WriteLine («ИСКЛЮЧЕНИЕ.Не удалось выполнить этот тест. «);
Console.WriteLine (» Finished at: «+ end.ToLongTimeString ());
Console.WriteLine (» Time: «+ (end — start));
Console .WriteLine ();
}
наконец
{
if (AllLines! = Null)
{
Array.Clear (AllLines, 0, AllLines.Length);
AllLines = null}
}
GC.Собирать();
Thread.Sleep (1000);
// Прочтите весь файл, используя File.ReadAllLines.
Console.WriteLine («Выполнение файлов ReadAllLines в массиве:»);
start = DateTime.Now;
попробовать
{
AllLines = новая строка [MAX]; // здесь выделяется только память
AllLines = File.ReadAllLines (fileName);
конец = DateTime.Сейчас же;
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (OutOfMemoryException)
{
end = DateTime.Now;
Console.WriteLine («Недостаточно памяти. Не удалось выполнить этот тест.»);
Консоль.WriteLine («Завершено в:» + end.ToLongTimeString ());
Console.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
catch (исключение)
{
end = DateTime.Now;
Console.WriteLine («ИСКЛЮЧЕНИЕ. Не удалось выполнить этот тест.»);
Console.WriteLine («Завершено в:» + end.ToLongTimeString ());
Консоль.WriteLine («Время:» + (конец — начало));
Console.WriteLine ();
}
наконец
{
if (AllLines! = Null)
{
Array.Clear (AllLines, 0, AllLines.Length);
AllLines = ноль;
}
}
File.Delete (fileName);
fileName = null;
GC.Собирать();
}
}
}
Стандартная функция C для чтения строк из файла
[обновление: как я и надеялся, есть простой ответ, getline (), см. Комментарии, спасибо Чарльз Леклидер]
Классика — fgets (), она проста и удобна в использовании …
Конечно, по какой-то причине fgets () дает вам окончания строк, поэтому я обычно получаю больше похожих.
Проблема, конечно, в том, что у вас длина строки.Это также преимущество в том, что вы ограничиваете строки и не имеете проблем с произвольным распределением памяти, но в наши дни у компьютеров так много памяти и виртуальных машин. Сколько раз я видел этот код и видел, как кто-то однажды должен был изменить 1000 на 10000?
Мне нужна простая функция, которая считывает строку и выделяет пространство по мере необходимости. Действительно, он может вернуть выделенное пространство или NULL в случае ошибки (EOF или сбой malloc). Вам придется его освободить, но это не проблема. Также было бы неплохо, если бы (а) он удалил строку, заканчивающуюся, поскольку я буквально НИКОГДА не хочу, чтобы это было в строке, и (б) плавно обрабатывал кровавый возврат каретки в стиле DOS…
Итак, пытаясь объяснить некоторые базовые принципы C своим товарищам, находясь в море, посреди Атлантического океана, я попытался объяснить это, создав для них простую программу синтаксического анализа файлов CSV. Мы погуглили и обнаружили, что не только я пытаюсь найти такую функцию. Похоже, ответом может быть fscanf (). [обновление: очевидно, я недостаточно хорошо гуглил!]
Честно говоря, fscanf () — это функция, которую я использую недостаточно. Это очень мощно, но я всегда обнаруживаю, что разбираю вещи более непосредственно.Однако я не считал это средством просто получить строку.
Магическое заклинание что-то вроде …
Это считывает любые символы до новой строки, выделяет пространство (то есть m) и сохраняет их в строке. Как раз то, что нам нужно. Небольшое изменение для обработки возврата каретки, похоже, тоже работает …
Бинго, у нас есть функция чтения файлов malloc magic line. Идеально.
И получите это, читая страницу руководства, и становится ясно, что использование функции [не занимает начальные пробелы, что идеально… Так что все хорошо
Но это не то, что происходит. Мы сделали материал CSV, а затем перешли к TSV (разделенные табуляцией), и волшебным образом ведущие табуляции (т.