Форматированный вывод с: C# и .NET | Форматирование и интерполяция строк

visual studio — Форматированный вывод в консоль C++

Вопрос задан 4 года 2 месяца назад

Изменён 4 года 2 месяца назад

Просмотрен 388 раз

Имеется массив структур device следующего вида:

struct device {
    unsigned int number;
    char name[20];
    unsigned int year;
    double cost;
};

Необходимо написать функцию которая выводит шапку и информацию об устройствах.

Пример:

|№  |Код  |Имя       |Год производства  |Цена   |
|1  |1234 |abcdefsdf |2019              |20.19  |
|2  |4321 |asdfa     |2017              |999.99 |

В ходе многочасовых поисков я пришел к следующему коду:

void printAll(device* d) {
    cout << left << setw(3) << "|№";
    cout << left << setw(11) << "|Код";
    cout << left << setw(21) << "|Имя";
    cout << left << setw(5) << "|Год";
    cout << left << setw(10) << "|Цена";
    cout << right << "|\n\n";
    for (int i = 0; i <= N; i++) {
        cout << left << setw(3) << "|" << i+1;
        cout << left << setw(11) << "|" << d[i].  number;
        cout << left << setw(21) << "|" << d[i].name;
        cout << left << setw(5) << "|" << d[i].year;
        cout << left << setw(10) << "|" << d[i].cost;
        cout << right << "|\n" ;
    }
}

Вывод:

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

• c++
• visual-studio

Зарегистрируйтесь или войдите

Отправить без регистрации

Необходима, но никому не показывается

Отправить без регистрации

Необходима, но никому не показывается

By clicking “Отправить ответ”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

форматированный вывод данных и ошибок в консоль

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

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

Функция print и её параметры

Функция print() включена в стандартную библиотеку языка Python, как основной инструмент для вывода данных в консоль или любое другое устройство (экран, принтер и так далее).

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

*objects

Передавая объекты в функцию, программист может их передавать через запятую или использовать конкатенацию. Передача нескольких аргументов не приведёт к конфликту между *objects и другими необязательными аргументами, потому что интерпретатор автоматически распознаёт остальные параметры по ключевому слову (sep, end, file, flush)!

Вот пример:

print("apple", "orange" + " banana", "cherry")

apple orange banana cherry

sep

Этот аргумент определяет, что будет стоять между переданными объектами. По умолчанию параметр sep имеет значение » «, то есть при выводе нескольких объектов, между ними будет установлен пробел, поменяем его на другой символ, например «-«

print("Один", "Два", "Три", sep="-")

Один-Два-Три

end

Аргумент определяет символ, которым заканчивается выполнение функции print(). По умолчанию это символ переноса строки «\n», то есть после вывода всех данных каретка переходит на следующую строку, и следующий вывод функции print начинается с новой строки. Если нужно, чтобы вывод нескольких print был в одну строку — следует заменить последний символ.

Вот пример:

print("Один")
print("Два", end=" ")
print("Три")

Один
Два Три

file

Этот аргумент позволяет переопределить поток вывода. По умолчанию установлено значение «sys.stdout», то есть данные выводятся в консоль. Если вместо этого указать какой-нибудь файл, то в данные запишутся в него.

Вот пример скрипта на Python, который откроет файл temp.txt и запишет в него текст с помощью функции print

with open("temp.txt", "w") as f:
    print("Write to file", file=f)

flush

Этот необязательный аргумент позволяет отчистить поток вывода. По умолчанию имеет значение False, когда вывод буферизуется, программист может указать значение «True», чтобы вывод производился сразу. Например, если вы пишете в файл данные, то они попадают в буфер и записываются реально в файл когда буфер заполнится или будет закрыт файл.

Аналогично и с выводом в консоль, данные записываются в буфер и выводятся из него в консоль. Если flush выставлен в True, то вывод производится немедленно.

print("Some text", flush=True)

Форматированный вывод

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

Оператор %

Оператор % часто используется для форматирования и хорошо известен не только программистам на Python, но и программистам на C/С++. По сути, оператор % — это метка, вместо которой подставляется значение переменной или выражение. Оператор % размещается непосредственно в выводимой строке, а подставляемые значения — в кортеже после второго %. Пример:

print("Программа номер %2d, получила результат: %5.2f" % (4, 7.3333))

Программа номер  4, получила результат:  7. 33

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

%(флаги)(ширина)(.точность)тип

Если рассмотреть пример, можно увидеть, что:

• «
  %2d» используется для первого элемента кортежа, целого числа «4». Так как после % указана длина «2», а число в кортеже состоит только из одной цифры, в выводе добавится дополнительный пробел.
• «%5.2f» — это формат для чисел с плавающей точкой. «5» — это общее количество цифр, которые должна содержать строка, а «.2» — это количество цифр после запятой.

Метод format

Этот инструмент был добавлен в Python версии 2.6. В сравнении с предыдущем способом format оказывается чуть более громоздким. Программист использует символ «{}», чтобы отметить место, в которое будет подставлена переменная или выражение. Внутри фигурных скобок можно указать имя, тип значения, ширину и точность.

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

print('{0} {1} января празднует {other} день рождения'
    .format('Никита', '25', other ='15-ый'))

Никита 25 января празднует 15-ый день рождения

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

print("Робот №{r:4d} весит {w:6.2f}"
    .format(r = 1134, w = 112.5534))

Робот №1134 весит 112.55

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

data = dict(name ="Бендер", race ="Робот")
print("Это {name}, он - {race}".format(**data))

Это Бендер, он - Робот

Строковый метод

Вывод с помощью строкового метода формируется с использованием операций среза и методов строк. Для работы со строковым типом данных создано несколько методов, которые позволяют просто и изящно форматировать вывод, среди них методы: ljust(), rjust(), center().

centre()

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

str.center(len, fillchr)

Здесь:

• str — это строка, которую будем центрировать.
• len
  – это ширина строки.
• fillchr — символ, которым заполняется недостающее пространство (по умолчанию — пробел).

Пример:

text = "Этот текст расположен в центре"
print(text.center(50))

          Этот текст расположен в центре

Важно понимать, что функция располагает текст не в центре консоли, а в центре поля указанной ширины (в примере это 50 символов).

Если поменять символ заполнения, получится следующее:

text = "Этот текст расположен в центре"
print(text.center(50, "_"))

__________Этот текст расположен в центре__________

ljust()

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

rjust()

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

f-строки

Иногда нужно просто вставить значение переменной в какую-то часть строки. Можно воспользоваться одним из методов форматирования, строить длинные конструкции из комбинаций строк и имён переменных, соединённых запятыми (или «+»), например:

print("Мне", age, ", теперь я могу пойти в", place, "когда захочу")

Однако в Python версии 3.6 в язык был добавлен простой и удобный инструмент, который называется f-строка или интерполированная строка. С его помощью можно удобно вставлять переменные в любое место выводимой строки. Для этого используются фигурные скобки «{}», внутри которых указывается имя переменной, а перед строкой ставится символ «f». Пример:

name = "Боб"
age = 25
print(f"{name} сегодня празднует {age}-ый день рождения")

Боб сегодня празднует 25-ый день рождения

Поля заданной ширины

В приведённых выше примерах уже использовались инструменты для настройки ширины полей. Ширина поля вывода настраивается с помощью вставки численного значения между знаком «%» и типом вывода (например, «d»). То есть установка ширины поля выглядит так:

print("%6d %6d" % (6, 6))

     6      6

Установка ширины полей работает так

• Интерпретатор получает информацию о численном значении ширины вывода (в примере это «6»).
• Затем он получает информацию о подставляемом значение, то есть считает, из скольки символов оно состоит (в примере это «1»).
• Если количество символов в подставляемом значение меньше, чем ширина строки, при выводе в строку добавляются дополнительные пробелы, иначе значение просто выводится.

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

Примеры

С помощью форматированного вывода можно полностью настроить любой вывод в консоль, например:

Вывод ошибки

Ниже пример обработки ошибки. Мы перехватываем исключение в блоке except и выводим сообщение о ней с помощью функции print.

try:
    for i in range(4):
        if (i == 3):
            i = text
        print(f"Попытка {i} прошла успешно")
except Exception as err:
    print("Возникла ошибка: \"{}\"".format(err))

Попытка 0 прошла успешно
Попытка 1 прошла успешно
Попытка 2 прошла успешно
Возникла ошибка: "name 'text' is not defined"

Вывод списка

Ниже пример того как выводится список в одну строку:

a = ['python', 3, 'лучший', 'язык', 'программирования']
for val in a:
    print(val, end=' ')

python 3 лучший язык программирования

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

mylist = ["кот", "собака", "крот", "ёж"]
for i, x in enumerate(mylist):
    print("{a:d} : {b:6s}". format(a = i + 1, b = x))

1 : кот   
2 : собака
3 : крот
4 : ёж

Вывод массива

Здесь выводим массив построчно с указанием номеров элементов.

from array import *
arr = array('i', [1,3,6,2,5])
for i in range(len(arr)):
    print("%d-й элемент массива = %d" %(i, arr[i]))

0-й элемент массива = 1
1-й элемент массива = 3
2-й элемент массива = 6
3-й элемент массива = 2
4-й элемент массива = 5

Вывод словаря

Здесь приведём два варианта для словарей.

Простой вариант:

a = {1: "one", 2: "two", 3: "three"}
for key, value in a.items():
  print("{0}: {1}".format(key,value))

1: one
2: two
3: three

В виде таблицы:

arr = {"Один": "one", "Два": "two", "Три": "three"}
print(" _________________ ")
print("|  Rus   :  Eng   |")
print("|-----------------|")
for key, value in arr.items():
    print("|  {r:5s} :  {w:5s} |". format(r = key, w = value))
print("|-----------------|")

 _________________
|  Rus   :  Eng   |
|-----------------|
|  Один  :  one   |
|  Два   :  two   |
|  Три   :  three |
|-----------------|

Вывод матрицы

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

mtx = [[  2, 4, 12],
       [ -6, 3,  9],
       [334, 0, 11]]
for row in mtx:
    for x in row:
        print("%3d" %(x), end = " ")
    print()

  2   4  12 
 -6   3   9
334   0  11

Здесь мы создали матрицу в виде двумерных списков, но если вы работаете с матрицами с помощью библиотеки NumPy, то там вывод в консоль форматируется автоматически.

7. Ввод и вывод — Документация по Python 3.11.3

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

7.1. Форматирование вывода Fancier

До сих пор мы сталкивались с двумя способами записи значений: операторов выражений и функция print() . (Третий способ — использовать метод write() файловых объектов; на стандартный выходной файл можно ссылаться как sys.stdout . Дополнительную информацию об этом см. в справочнике по библиотеке.)

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

• Чтобы использовать форматированные строковые литералы, начните строку с f или F перед открывающей кавычкой или тройной кавычкой. Внутри этой строки вы можете написать выражение Python между { и } символы, которые могут относиться к переменным или литеральным значениям.

   >>> год = 2016
  >>> событие = 'Референдум'
  >>> f'Результаты {года} {события}'
  «Итоги референдума 2016 года»
   

• Строковый метод str. format() требует дополнительного руководства усилие. Вы по-прежнему будете использовать { и } , чтобы отметить, где находится переменная. будет заменен и может предоставить подробные директивы форматирования, но вам также нужно будет предоставить информацию для форматирования.

   >>> yes_votes = 42_572_654
  >>> нет_голосов = 43_132_495
  >>> процент = голоса_да / (голоса_да + голоса_нет)
  >>> '{:-9} ДА голосов {:2,2%}'.format(yes_votes, процент)
  «42572654 ДА проголосовало 49,67%»
   

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

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

Функция str() предназначена для возврата представлений значений, которые довольно удобочитаемый, в то время как repr() предназначен для создания представлений который может быть прочитан интерпретатором (или вызовет SyntaxError , если нет эквивалентного синтаксиса). Для объектов, не имеющих особого представление для потребления человеком, str() вернет то же значение, что и repr() . Многие значения, такие как числа или структуры, такие как списки и словари имеют одинаковое представление с использованием любой функции. Струны, в частности, имеют два различных представления.

Некоторые примеры:

 >>> s = 'Привет, мир.'
>>> ул(ы)
'Привет, мир.'
>>> репр(ы)
"'Привет, мир.'"
>>> ул(1/7)
«0,14285714285714285»
>>> х = 10 * 3,25
>>> у = 200 * 200
>>> s = 'Значение x равно ' + repr(x) + ', а y равно ' + repr(y) + '...'
>>> печать(и)
Значение x равно 32,5, а y равно 40000...
>>> # Функция repr() строки добавляет строковые кавычки и обратную косую черту:
. .. привет = 'привет, мир\n'
>>> привет = repr(привет)
>>> распечатать (привет)
'привет, мир\n'
>>> # Аргументом repr() может быть любой объект Python:
... repr((x, y, ('спам', 'яйца')))
"(32,5, 40000, ('спам', 'яйца'))"
 

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

7.1.1. Форматированные строковые литералы

Отформатированные строковые литералы (также называемые f-строками для короткая) позволяет включать значение выражений Python в строку с помощью префикс строки с f или F и запись выражений в виде {выражение} .

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

 >>> импортировать математику
>>> print(f'Значение числа пи приблизительно равно {math. pi:.3f}.')
Значение числа пи приблизительно равно 3,142.
 

Передача целого числа после ':' приведет к тому, что это поле будет минимальным количество символов в ширину. Это полезно для выравнивания столбцов.

 >>> table = {'Шёрд': 4127, 'Джек': 4098, 'Дкаб': 7678}
>>> для имени, телефона в table.items():
... print(f'{имя:10} ==> {телефон:10d}')
...
Сьерд ==> 4127
Джек ==> 4098
Дкаб ==> 7678
 

Можно использовать другие модификаторы для преобразования значения перед его форматированием. '!a' применяется ascii() , '!s' применяется str() и '!r' применяется repr() :

 >>> животные = 'угри'
>>> print(f'Мой корабль на воздушной подушке полон {животных}.')
Мое судно на воздушной подушке полно угрей.
>>> print(f'Мой корабль на воздушной подушке полон {животных!r}.')
Мое судно на воздушной подушке полно угрей'.
 

Спецификатор = можно использовать для расширения выражения до текста выражение, знак равенства, затем представление оцениваемого выражения:

 >>> жуки = 'тараканы'
>>> количество = 13
>>> площадь = 'гостиная'
>>> print(f'Отладка {ошибок=} {количество=} {область=}')
Отладка ошибок = количество тараканов = 13 площадь = 'гостиная'
 

Дополнительные сведения см. в самодокументирующихся выражениях. на спецификаторе = . Справку по этим спецификациям формата см. справочное руководство для мини-языка спецификации формата.

7.1.2. Метод String format()

Основное использование метода str.format() выглядит следующим образом:

 >>> print('Мы те {}, которые говорят "{}!"'.format('рыцари', 'Ни'))
Мы рыцари, которые говорят "Ни!"
 

Скобки и символы внутри них (называемые полями формата) заменены на объекты перешли в метод str.format() . Номер в скобки могут использоваться для обозначения положения объекта, переданного в метод str.format() .

 >>> print('{0} и {1}'.format('спам', 'яйца'))
спам и яйца
>>> print('{1} и {0}'.format('спам', 'яйца'))
яйца и спам
 

Если в методе str.format() используются аргументы ключевого слова, их значения ссылаются, используя имя аргумента.

 >>> print('Эта {еда} является {прилагательным}. '.format(
... food='спам', adjective='абсолютно ужасный'))
Этот спам просто ужасен.
 

Аргументы позиции и ключевого слова можно произвольно комбинировать:

 >>> print('История {0}, {1} и {другого}.'.format('Билл', 'Манфред',
...другое='Георг'))
История Билла, Манфреда и Георга.
 

Если у вас очень длинная строка формата, которую вы не хотите разбивать, было бы неплохо, если бы вы могли ссылаться на переменные, которые должны быть отформатированы по имени а не по должности. Это можно сделать, просто передав dict и используя квадратные скобки '[]' для доступа к ключам.

 >>> table = {'Шёрд': 4127, 'Джек': 4098, 'Дкаб': 8637678}
>>> print('Джек: {0[Джек]:d}; Сьерд: {0[Джек]:d}; '
... 'Dcab: {0[Dcab]:d}'.format(table))
Джек: 4098; Сьерд: 4127; Дкаб: 8637678
 

Это также можно сделать, передав словарь таблицы в качестве аргументов ключевого слова с помощью ** обозначение.

 >>> table = {'Шёрд': 4127, 'Джек': 4098, 'Дкаб': 8637678}
>>> print('Джек: {Джек:d}; Сьорд: {Сджорд:d}; Dcab: {Dcab:d}'. format(**table))
Джек: 4098; Сьерд: 4127; Дкаб: 8637678
 

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

В качестве примера следующие строки создают аккуратно выровненный набор столбцов с целыми числами и их квадратами и кубами:

 >>> для x в диапазоне (1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1 1 1
 2 4 8
 3 9 27
 4 16 64
 5 25 125
 6 36 216
 7 49343
 8 64 512
 9 81 729
10 100 1000
 

Полный обзор форматирования строк с помощью str.format() см. Синтаксис строки формата.

7.1.3. Ручное форматирование строк

Вот та же таблица квадратов и кубов, отформатированная вручную:

 >>> для x в диапазоне (1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # Обратите внимание на использование 'end' в предыдущей строке
... печать (репр (х * х * х). rjust (4))
...
 1 1 1
 2 4 8
 3 927
 4 16 64
 5 25 125
 6 36 216
 7 49 343
 8 64 512
 9 81 729
10 100 1000
 

(Обратите внимание, что один пробел между каждым столбцом был добавлен способ print() работает: он всегда добавляет пробелы между своими аргументами. )

Метод str.rjust() строковых объектов выравнивает строку по правому краю в поле заданной ширины, дополнив его пробелами слева. Есть аналогичные методы str.ljust() и str.center() . Эти методы делают ничего не пишут, они просто возвращают новую строку. Если входная строка слишком long не усекают, а возвращают без изменений; это испортит твое расположение столбцов, но это обычно лучше, чем альтернатива, которая была бы ложь о стоимости. (Если вы действительно хотите усечение, вы всегда можете добавить операция среза, как в x.ljust(n)[:n] .)

Существует еще один метод, str.zfill() , который дополняет числовую строку в осталось с нулями. Он понимает про знаки плюс и минус:

 >>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
 

7.1.4. Старое форматирование строки

Оператор % (по модулю) также можно использовать для форматирования строк. Дана "строка" % значений , экземпляров % в строке заменяются нулем или более элементы значений . Эта операция широко известна как строка интерполяция. Например:

 >>> импортировать математику
>>> print('Значение числа пи приблизительно равно %5.3f.' % math.pi)
Значение числа пи приблизительно равно 3,142.
 

Дополнительную информацию можно найти в разделе Форматирование строк в стиле printf.

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

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

 >>> f = открыть('рабочий файл', 'w', encoding="utf-8")
 

Первый аргумент — это строка, содержащая имя файла. Второй аргумент другая строка, содержащая несколько символов, описывающих способ, которым файл будет использован. режим может быть 'r' , когда файл будет только читаться, 'w' только для записи (существующий файл с таким же именем будет стерт) и 'a' открывает файл для добавления; любые данные, записанные в файл, автоматически добавляется в конец. 'r+' открывает файл как для чтения, так и письмо. Аргумент режима является необязательным; 'r' будет считаться, если это опущено.

Обычно файлы открываются в текстовом режиме , то есть вы читаете и пишете строки из и в файл, закодированные в определенной кодировке . Если кодировка не указана, значение по умолчанию зависит от платформы. (см. open() ). Поскольку UTF-8 является современным стандартом де-факто, кодировка = "utf-8" рекомендуется, если вы не знаете, что вам нужно использовать другую кодировку. Добавление 'b' к режиму открывает файл в двоичном режиме . Данные двоичного режима читаются и записываются как байтов объектов. Нельзя указывать кодировку при открытии файла в бинарном режиме.

В текстовом режиме по умолчанию при чтении преобразуется строка, зависящая от платформы окончания ( \n в Unix, \r\n в Windows) всего до \n . При записи в в текстовом режиме по умолчанию вхождения \n преобразуются обратно в окончание строки для конкретной платформы. Эта закулисная модификация в файл данных подходит для текстовых файлов, но искажает двоичные данные, как в JPEG или EXE файлы. Будьте очень осторожны, чтобы использовать двоичный режим, когда чтение и запись таких файлов.

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

 >>> с open('workfile', encoding="utf-8") как f:
... read_data = f.read()
>>> # Мы можем проверить, что файл был автоматически закрыт.
>>> f.закрыто
Истинный
 

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

Предупреждение

Вызов f.write() без использования ключевого слова with или вызова f.close() может привести к аргументам из f.write() не полностью записывается на диск, даже если программа завершается успешно.

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

 >>> f.close()
>>> f.read()
Traceback (последний последний вызов):
  Файл "", строка 1, в 
ValueError: операция ввода-вывода в закрытом файле.
 

7.2.1. Методы файловых объектов

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

Чтобы прочитать содержимое файла, вызовите f.read(size) , который считывает некоторое количество data и возвращает его в виде строки (в текстовом режиме) или байтового объекта (в двоичном режиме). размер — необязательный числовой аргумент. Когда размер опущен или отрицателен, все содержимое файла будет прочитано и возвращено; это ваша проблема, если файл в два раза больше памяти вашей машины. В противном случае не более размер символы (в текстовом режиме) или размером байт (в двоичном режиме) читаются и возвращаются. Если достигнут конец файла, f.read() вернет пустой строка ( '' ).

 >>> f.read()
'Это весь файл.\n'
>>> f.read()
''
 

f.readline() читает одну строку из файла; символ новой строки ( \n ) остается в конце строки и опускается только в последней строке файл, если файл не заканчивается новой строкой. Это делает возвращаемое значение однозначный; если f.readline() возвращает пустую строку, конец файла была достигнута, а пустая строка представлена ​​ '\n' , строка содержащий только одну новую строку.

 >>> f.readline()
'Это первая строка файла. \n'
>>> f.readline()
'Вторая строка файла\n'
>>> f.readline()
''
 

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

 >>> для строки в f:
... печать (строка, конец = '')
...
Это первая строка файла.
Вторая строка файла
 

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

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

 >>> f.write('Это тест\n')
15
 

Другие типы объектов необходимо преобразовать – либо в строку (в текстовом режиме) или объект bytes (в бинарном режиме) — перед их записью:

 >>> значение = ('ответ', 42)
>>> s = str(value) # преобразовать кортеж в строку
>>> f.пишите(и)
18
 

f.tell() возвращает целое число, указывающее текущую позицию файлового объекта в файле представлен как количество байтов от начала файла в двоичном режиме и непрозрачный номер в текстовом режиме.

Чтобы изменить позицию файлового объекта, используйте f.seek(offset, откуда) . Позиция вычисляется от добавления смещения в контрольную точку; опорная точка выбирается аргумент откуда . , откуда значение 0 измеряет с самого начала файла, 1 использует текущую позицию файла, а 2 использует конец файла как точка отсчета. , откуда может быть опущено и по умолчанию равно 0, используя начало файла в качестве контрольной точки.

 >>> f = открыть('рабочий файл', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5) # Перейти к 6-му байту в файле
5
>>> f.read(1)
б'5'
>>> f.seek(-3, 2) # Перейти к 3-му байту перед концом
13
>>> f.read(1)
б'д'
 

В текстовых файлах (открытых без b в строке режима) ищет только относительно начала файла разрешены (за исключением поиска до самого конца файла с seek(0, 2) ) и единственными допустимыми значениями offset являются возвращенные из f. tell() или нулевые. Любое другое значение смещения дает неопределенное поведение.

Файловые объекты имеют некоторые дополнительные методы, такие как isatty() и truncate() , которые используются реже; проконсультироваться в библиотеке Ссылка на полное руководство по файловым объектам.

7.2.2. Сохранение структурированных данных с помощью

 >>> импорт json
>>> x = [1, 'простой', 'список']
>>> json.dumps(x)
'[1, "простой", "список"]'
 

 json.dump(x, f)
 

 х = json.load(f)