Обновление: Python 3.6 использует Unicode API для ввода/вывода в консоль как упомянутый ниже win_unicode_console пакет (подробнее в PEP 528). По умолчанию поддерживаются произвольные Unicode символы. Простой print(unicode_string) теперь работает без установки дополнительного ПО (консольный шрифт, поддерживающий желаемые символы, по прежнему нужно настраивать).
На границе с Windows-консолью используется Unicode, внутри sys.stdin, sys.stdout, sys.stderr используют utf-8 кодировку. Это может сломать код, который использовал двоичный интерфейс для вывода в консоль и соответственно использовал OEM codepage, к примеру cp866 кодировку. cp866 не совместима с utf-8, можно получить кракозябры в таком случае. Необходимо либо исправить код, чтобы он текст, а не байты в консоль выводил, либо выставить %PYTHONLEGACYWINDOWSIOENCODING% переменную окружения, чтобы старое поведение восстановить.
Поведение для перенаправленного ввода в файл, в канал (pipe) осталось прежним: используется locale.getpreferredencoding(False) по умолчанию (ANSI codepage, к примеру cp1251).
Это давняя проблема в Питоне. Пакет win_unicode_console добавляет наиболее полную поддержку Юникода как для вывода, так и для ввода текста в консоли—можно использовать этот пакет не меняя своего исходного кода c помощью включённого run модуля:
C:\> py -m pip install win-unicode-console
C:\> py -m run path\your_script.py
Это позволяет печатать произвольные Юникод символы, даже те которые не представимы в текущей кодировке консоли (такой как cp866), например, print(u'\N{snowman}') -> ☃ (могут быть корректно показаны все BMP Unicode символы, поддерживаемые настроенными шрифтами. Даже не-BMP символы можно скопировать в другие программы из консоли).
В качестве одноразового решения (без новых пакетов), можно установить переменную окружения PYTHONIOENCODING:
C:\> set PYTHONIOENCODING=utf-8
C:\> py path\your_script.py > output_in_utf8.txt
Оба решения, не добавляют жёстко прописанную кодировку внутрь скрипта, делая их более переносимыми.
При разработке программ постоянно используется вывод данных в консоль. Например, при тестировании функций программы, которая ещё не обзавелась графическим интерфейсом, или как средство нахождения ошибок и отладки кода.
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, то там вывод в консоль форматируется автоматически.
Консольный ввод и вывод
Последнее обновление: 15.01.2022
Вывод на консоль
Для вывода информации на консоль предназначена встроенная функция print(). При вызове этой функции ей в скобках передается
выводимое значение:
print("Hello METANIT.COM")
Данный код выведет нам на консоль строку «Hello METANIT.COM».
Отличительной особенностью этой функции является то, что по умолчанию она выводит значение на отдельной строке. Например:
print("Hello World")
print("Hello METANIT.COM")
print("Hello Python")
Здесь три вызова функции print() выводят некоторое сообщение. Причем при выводе на консоль каждое сообщение будет размещаться на отдельной
строке:
Hello World Hello METANIT.COM Hello Python
Такое поведение не всегда удобно. Например, мы хотим, чтобы все значения выводились на одной строке. Для этого нам надо настроить поведение
функции с помощью параметра end. Этот параметр задает символы, которые добавляются в конце к выводимой строке и . При применении
параметра end вызов функции print() выглядит следующим образом:
print(значение, end = конечные_символы)
По умолчанию end равен символу "\n", который задает перевод на следующую строку. Собственно поэтому функция print по умолчанию
выводит передаваемое ей значение на отдельной строке.
Теперь определим, чтобы функция не делала перевод на следующую строку, а выводила значение на той же строке:
print("Hello World", end=" ")
print("Hello METANIT.COM", end=" ")
print("Hello Python")
То есть теперь выводимые значения будут разделяться пробелом:
Hello World Hello METANIT.COM Hello Python
Причем это может быть не один символ, а набор символов:
print("Hello World", end=" and ")
print("Hello METANIT.COM", end=" and ")
print("Hello Python")
В данном случае выводимые сообщения будут отделяться символами " and ":
Hello World and Hello METANIT.COM and Hello Python
Консольный ввод
Наряду с выводом на консоль мы можем получать ввод пользователя с консоли, получать вводимые данные. Для этого в Python определена функция
input(). В эту функцию передается приглашение к вводу. А результат ввода мы можем сохранить в переменную. Например,
определим код для ввода пользователем имени:
name = input("Введите свое имя: ")
print(f"Ваше имя: {name}")
В данном случае в функцию input() передается приглашение к вводу в виде строки «Введите свое имя: «. Результат функции — результат ввода
пользователя передается в переменную name. Затем мы можем вывести значение этой переменной на консоль с помощью функции print().
Пример работы кода:
Введите свое имя: Eugene Ваше имя: Eugene
Еще пример с вводом нескольких значений:
name = input("Your name: ")
age = input("Your age: ")
print(f"Name: {name} Age: {age}")
Пример работы программы:
Your name: Tom Your age: 37 Name: Tom Age: 37
Стоит учитывать, что все введенные значения рассматриваются как значения типа str, то есть строки. И даже если мы вводим число,
как в втором случае в коде выше, то Python все равно будет рассматривать введенное значение как строку, а не как число.
В статье узнаем как в Python 3, с помощью встроенной функции print(), вывести текст на консоль. А для закрепления напишем небольшую программу.
Первая программа
По традиции первая программа должна выводить на экран консоли фразу «Hello World!». Мы не будем отходить от традиции. Вот код этой программы:
print("Hello, World!")
Функция print() — это встроенная функция, то-есть она заранее определена. Используя Python 3 вы можете создавать и собственные функции.
Эта функция в качестве аргументов принимает строки и выводит их на консоль, или может сохранить их в файл. То есть мы попросили Python вывести на экран строку «Hello, World!», что он и сделал:
$ python3 hello.py Hello, World!
Строка обязательно должна быть написана в кавычках!
Вывод нескольких строк
В предыдущем примере мы выводили только одну строку — «Hello, World!». Но функция print() может принимать несколько аргументов и выводить несколько строк. Для этого строки разделяются с помощью запятой.
Вот пример кода:
print("Hello, World!", "Привет, Мир!")
А вот что делает этот код:
$ python3 hello.py Hello, World! Привет, Мир!
Необязательные параметры
Помимо строк функция print() может использовать необязательные параметры:
- sep — с помощью этого параметра вы можете указать разделитель строк. А по умолчанию в качестве разделителя используется пробел;
- end — этот параметр позволяет указать, что нужно добавить после последней строки. По умолчанию добавляется управляющий символ ‘\n’ (перевод строки);
- file — по умолчанию функция print() выводит строки на консоль, а с помощью этого параметра можно поместить строки в файл.
Параметр sep
Следующий код выводит две строки и разделяет их символом перевода строки:
print("Hello, World!", "Привет, Мир!", sep='\n')
Вот как это работает:
$ python3 hello.py Hello, World! Привет, Мир!
Параметр end
Если мы выводим две строки с помощью двух функций priint(), то они будут на разных строках. Это происходит потому что, по умолчанию, после каждой последней строки ставится знак перевода строки. Вот пример кода:
print("Меня зовут")
print("Александр")
А вот его выполнение:
$ python3 hello.py Меня зовут Александр
А теперь используем параметр end и укажем что в конце строки нужно добавлять пробел:
print("Меня зовут", end=' ')
print("Александр")
И выполним этот код:
$ python3 hello.py Меня зовут Александр
Параметр file
По умолчанию функция print() выводит информацию на консоль. А используя параметр file, мы можем поместить вывод в файл.
Работать с файлами мы пока не умеем, но в коде я оставил комментарии которые должны помочь его понять:
file = open('print.txt','a+') # открываем файл
print("Hello, World!", file=file) # выполняем функцию print с сохранением в файл
file.close() # закрываем файл
А теперь посмотрим как это сработает:
$ python3 hello.py $ cat print.txt Hello, World! $ python3 hello.py $ cat print.txt Hello, World! Hello, World!
При выполнении этого кода на экран консоли ничего не вывелось, так как текст был помещён вместо консоли в файл. Если файла нет, то он создастся. При этом файл не перезаписывается, а строка записывается в конец файла.
Вывод результатов арифметических операций
Функция print() позволяет в себя поместить другие функции или операторы. Например мы можем вывести результат арифметических операций:
print("5 + 2 =", 5+2)
print("7 + 4 =", 7+4)
print("3*(3+4) =", 3*(3+4))
Как вы могли заметить, математическую операцию (5+2) не нужно брать в кавычки. Так как, всё что в кавычках считается строкой а не операцией и не высчитывается.
Выполним этот код:
$ python3 hello.py 5 + 2 = 7 7 + 4 = 11 3*(3+4) = 21
Подробнее математические операции рассмотрим в отдельной статье.
Вывод значений переменных
Ну и конечно мы можем выводить значения переменных. Переменную, также как и операцию, не нужно брать в кавычки, вот пример кода:
a=6 b=8 print(a, "*", b, "=", a*b, sep='')
Я изменил разделитель, чтобы убрать пробелы.
Код написанный выше выполняется следующим образом:
$ python3 hello.py 6*8=48
Итоговый пример
И для закрепления материала давайте напишем и разберём такую программку:
# Для вывода строк используем функцию print()
print("Привет!", "Сейчас посчитаем, сколько будет 6 * 8", sep='\n')
# Устанавливаем переменные
a=6
b=8
# Производим вычисления
print("Производим вычисления", end='... ')
print(a, "*", b, "=", a*b, sep='')
# И сохриним результат в файл
file = open('print.txt','a+')
print(a, "*", b, "=", a*b, sep='', file=file)
file.close()
print("Результат был записан в файл 'print.txt'")
print("Выполните команду 'cat print.txt',", end=' ')
print("чтобы посмотреть содержимое файла.")
Вот результат выполнения этой программы:
$ python3 hello.py Привет! Сейчас посчитаем, сколько будет 6 * 8 Производим вычисления... 6*8=48 Результат был записан в файл 'print.txt' Выполните команду 'cat print.txt', чтобы посмотреть содержимое файла. $ cat print.txt 6*8=48
В официальной документации встроенная в Python функция print() описана здесь.
Другие статьи по python доступны здесь.
Сводка
Имя статьи
Python 3. Вывод текста на консоль. Функция print()
Описание
В статье узнаем как в Python 3, с помощью встроенной функции print(), вывести текст на консоль. А для закрепления напишем небольшую программу
В уроке рассмотрены основные способы ввода и вывода данных в Python с использованием консоли, и работа с файлами: открытие, закрытие, чтение и запись.
Вывод данных в консоль
Один из самых распространенных способов вывести данные в Python – это напечатать их в консоли. Если вы находитесь на этапе изучения языка, такой способ является основным для того, чтобы быстро просмотреть результат свой работы. Для вывода данных в консоль используется функция print.
Рассмотрим основные способы использования данной функции.
>>> print("Hello") Hello >>> print("Hello, " + "world!") Hello, world! >>> print("Age: " + str(23)) Age: 23
По умолчанию, для разделения элементов в функции print используется пробел.
>>> print("A", "B", "C") A B C
Для замены разделителя необходимо использовать параметр sep функции print.
print("A", "B", "C", sep="#") A#B#C
В качестве конечного элемента выводимой строки, используется символ перевода строки.
>>> for i in range(3): print("i: " + str(i)) i: 0 i: 1 i: 2
Для его замены используется параметр end.
>>> for i in range(3): print("[i: " + str(i) + "]", end=" -- ") [i: 0] -- [i: 1] -- [i: 2] --
Ввод данных с клавиатуры
Для считывания вводимых с клавиатуры данных используется функция input().
>>> input() test 'test'
Для сохранения данных в переменной используется следующий синтаксис.
>>> a = input() hello >>> print(a) hello
Если считывается с клавиатуры целое число, то строку, получаемую с помощью функции input(), можно передать сразу в функцию int().
>>> val = int(input()) 123 >>> print(val) 123 >>> type(val) <class 'int'>
Для вывода строки-приглашения, используйте ее в качестве аргумента функции input().
>>> tv = int(input("input number: ")) input number: 334 >>> print(tv) 334
Преобразование строки в список осуществляется с помощью метода split(), по умолчанию, в качестве разделителя, используется пробел.
>>> l = input().split() 1 2 3 4 5 6 7 >>> print(l) ['1', '2', '3', '4', '5', '6', '7']
Разделитель можно заменить, указав его в качестве аргумента метода split().
>>> nl = input().split("-") 1-2-3-4-5-6-7 >>> print(nl) ['1', '2', '3', '4', '5', '6', '7']
Для считывания списка чисел с одновременным приведением их к типу int можно воспользоваться вот такой конструкцией.
>>> nums = map(int, input().split()) 1 2 3 4 5 6 7 >>> print(list(nums)) [1, 2, 3, 4, 5, 6, 7]
Работа с файлами
Открытие и закрытие файла
Для открытия файла используется функция open(), которая возвращает файловый объект. Наиболее часто используемый вид данной функции выглядит так open(имя_файла, режим_доступа).
Для указания режима доступа используется следующие символы:
‘r’ – открыть файл для чтения;
‘w’ – открыть файл для записи;
‘x’ – открыть файл с целью создания, если файл существует, то вызов функции open завершится с ошибкой;
‘a’ – открыть файл для записи, при этом новые данные будут добавлены в конец файла, без удаления существующих;
‘b’ – бинарный режим;
‘t’ – текстовый режим;
‘+’ – открывает файл для обновления.
По умолчанию файл открывается на чтение в текстовом режиме.
У файлового объекта есть следующие атрибуты.
file.closed – возвращает true если файл закрыт и false в противном случае;
file.mode – возвращает режим доступа к файлу, при этом файл должен быть открыт;
file.name – имя файла.
>>> f = open("test.txt", "r") >>> print("file.closed: " + str(f.closed)) file.closed: False >>> print("file.mode: " + f.mode) file.mode: r >>> print("file.name: " + f.name) file.name: test.txt
Для закрытия файла используется метод close().
Чтение данных из файла
Чтение данных из файла осуществляется с помощью методов read(размер) и readline().
Метод read(размер) считывает из файла определенное количество символов, переданное в качестве аргумента. Если использовать этот метод без аргументов, то будет считан весь файл.
>>> f = open("test.txt", "r") >>> f.read() '1 2 3 4 5\nWork with file\n' >>> f.close()
В качестве аргумента метода можно передать количество символом, которое нужно считать.
>>> f = open("test.txt", "r") >>> f.read(5) '1 2 3' >>> f.close()
Метод readline() позволяет считать строку из открытого файла.
>>> f = open("test.txt", "r") >>> f.readline() '1 2 3 4 5\n' >>> f.close()
Построчное считывание можно организовать с помощью оператора for.
>>> f = open("test.txt", "r") >>> for line in f: ... print(line) ... 1 2 3 4 5 Work with file >>> f.close()
Запись данных в файл
Для записи данных файл используется метод write(строка), при успешной записи он вернет количество записанных символов.
>>> f = open("test.txt", "a") >>> f.write("Test string") 11 >>> f.close()
Дополнительные методы для работы с файлами
Метод tell() возвращает текущую позицию “условного курсора” в файле. Например, если вы считали пять символов, то “курсор” будет установлен в позицию 5.
>>> f = open("test.txt", "r") >>> f.read(5) '1 2 3' >>> f.tell() 5 >>> f.close()
Метод seek(позиция) выставляет позицию в файле.
>>> f = open("test.txt", "r") >>> f.tell() 0 >>> f.seek(8) 8 >>> f.read(1) '5' >>> f.tell() 9 >>> f.close()
Хорошей практикой при работе с файлами является применение оператора with. При его использовании нет необходимости закрывать файл, при завершении работы с ним, эта операция будет выполнена автоматически.
>>> with open("test.txt", "r") as f: ... for line in f: ... print(line) ... 1 2 3 4 5 Work with file Test string >>> f.closed True
P.S.
Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
<<< Python. Урок 11. Работа с исключениями Python. Урок 13. Модули и пакеты >>>