Python ввод вывод: Ввод и вывод данных. Урок 4 курса «Python. Введение в программирование»

Работа с файлами в python. Чтение и запись в файл ~ PythonRu

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

Файлы Python

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

В Python существует два типа файлов:

1. Текстовые
2. Бинарные

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

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

Текст может храниться в двух форматах: (.txt) — простой текст и (.rtf) — «формат обогащенного текста».

Бинарные файлы

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

Они хранятся в формате .bin.

Любую операцию с файлом можно разбить на три крупных этапа:

1. Открытие файла
2. Выполнение операции (запись, чтение)
3. Закрытие файла

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

Метод open()

Подписывайтесь на телеграм каналы

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

Синтаксис следующий:

f = open(file_name, access_mode)

Где,

• file_name = имя открываемого файла
• access_mode = режим открытия файла. Он может быть: для чтения, записи и т. д. По умолчанию используется режим чтения (r), если другое не указано. Далее полный список режимов открытия файла

Пример

Создадим текстовый файл example.txt и сохраним его в рабочей директории.

Следующий код используется для его открытия.

f = open('example.txt','r')  
fp = open('C:/xyz.txt','r')  

В этом примере f — переменная-указатель на файл example.txt.

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

>>> print(*f) 
This is a text file.
>>> print(f) 
<_io.TextIOWrapper name='example.txt' mode='r' encoding='cp1252'>

Стоит обратить внимание, что в Windows стандартной кодировкой является cp1252, а в Linux — utf-08.

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

Метод close()

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

Существуют следующие способы:

Способ №1

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

f = open('example.txt','r')

f.close()

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

Способ №2

Также можно написать try/finally, которое гарантирует, что если после открытия файла операции с ним приводят к исключениям, он закроется автоматически.

Без него программа завершается некорректно.

Вот как сделать это исключение:

f = open('example.txt','r')
try:
   
finally:
   f.close()

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

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

Способ №3

Инструкция with

Еще один подход — использовать инструкцию with, которая упрощает обработку исключений с помощью инкапсуляции начальных операций, а также задач по закрытию и очистке.

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

Вот как это реализовать в коде.

with open('example.txt') as f:
    

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

В Python файлы можно читать или записывать информацию в них с помощью соответствующих режимов.

Функция read()

Функция read() используется для чтения содержимого файла после открытия его в режиме чтения (r).

Синтаксис

file.read(size)

Где,

• file = объект файла
• size = количество символов, которые нужно прочитать. Если не указать, то файл прочитается целиком.

Пример

>>> f = open('example.txt','r')
>>> f.read(7)  
'This is '

Интерпретатор прочитал 7 символов файла и если снова использовать функцию read(), то чтение начнется с 8-го символа.

>>> f.read(7)  
' a text'

Функция readline()

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

Пример

Создадим файл test.txt с нескольким строками:

This is line1.
This is line2.
This is line3.

Посмотрим, как функция readline() работает в test.txt.

>>> x = open('test.txt','r')
>>> x.readline()  
This is line1.
>>> x.readline(2)  
This is line2.
>>> x.readlines()  
['This is line1.','This is line2.','This is line3.']

Обратите внимание, как в последнем случае строки отделены друг от друга.

Функция write()

Функция write() используется для записи в файлы Python, открытые в режиме записи.

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

Синтаксис

file.write(string)

Пример

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

>>> f = open('xyz.txt','w')  
>>> f.write('Hello \n World')  
Hello
World
>>> f.close()  

Переименование файлов в Python

Функция rename()

Функция rename() используется для переименовывания файлов в Python. Для ее использования сперва нужно импортировать модуль os.

Синтаксис следующий.

import os
os.rename(src,dest)

Где,

• src = файл, который нужно переименовать
• dest = новое имя файла

Пример

>>> import os
>>> 
>>> os.rename("xyz.txt","abc.txt")

Текущая позиция в файлах Python

В Python возможно узнать текущую позицию в файле с помощью функции tell(). Таким же образом можно изменить текущую позицию командой seek().

Пример

>>> f = open('example.txt')  
>>> f.read(4)  
This
>>> f.tell()  
4
>>> f.seek(0,0)  

Методы файла в Python

Ввод и вывод — Учебник по языку Python 3.1

Ввод и вывод

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

Удобное форматирование вывода

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

Часто возникает желание иметь больший контроль над форматированием вывода, чем обычная печать значений разделённых пробелами. Есть два способа форматирования вашего вывода. Первый способ — выполнять самостоятельно всю работу над строками: используя срезы строк и конкатенацию вы можете создать любой шаблон, какой пожелаете. Стандартный модуль string содержит много полезных операций для выравнивания строк по определённой ширине колонки (скоро мы их кратко рассмотрим). Второй способ — использование метода str.format().

Модуль string содержит класс Template, который предоставляет ещё один способ подстановки значений в строки.

Остаётся, конечно, один вопрос: каким образом конвертировать значения в строки? К счастью, в Python есть два способа для преобразования любого значения в строку — это функции repr() и str().

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

Несколько примеров:

>>> s = 'Привет, мир.'
>>> str(s)
'Привет, мир.'
>>> repr(s)
"'Привет, мир.'"
>>> str(0.1)
'0.1'
>>> repr(0.1)
'0.10000000000000001'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'Значение x - ' + repr(x) + ', а y - ' + repr(y) + '...'
>>> print(s)
Значение x - 32.5, а y - 40000...
>>> # Фунция repr(), применённая к строке, добавляет кавычки и обратные слэши:
... hello = 'привет, мир\n'
>>> hellos = repr(hello)
>>> print(hellos)
'привет, мир\n'
>>> # Параметром функции repr() может быть объект Python:
... repr((x, y, ('фарш', 'яйца')))
"(32.5, 40000, ('фарш', 'яйца'))"

Вот два способа вывести таблицу квадратов и кубов:

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

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

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

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

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

Основной способ применения метода str.format() выглядит так:

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

Скобки с символами внутри (их называют полями форматирования (format fields)) заменяются на объекты, переданные методу format. Номер в скобках обозначает позицию объекта в списке параметров, переданных методу format.

>>> print('{0} и {1}'.format('фарш', 'яйца'))
фарш и яйца
>>> print('{1} и {0}'.format('фарш', 'яйца'))
яйца и фарш

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

>>> print('Этот {food} — {adjective}.'.format(
...       food='фарш', adjective='непередаваемо ужасен'))
Этот фарш — непередаваемо ужасен.

Позиционные и именованные параметры можно произвольно совмещать:

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

После имени поля может следовать необязательный спецификатор формата ‘:’. С его помощью можно управлять форматированием значения. Следующий пример оставляет у числа Пи только три цифры после десятичного разделителя.

>>> import math
>>> print('Значение ПИ — примерно {0:.3f}.'.format(math.pi))
Значение ПИ — примерно 3.142.

После спецификатора ‘:’ можно указать число — минимальную ширину поля, выраженную в количестве символов. Это удобно использовать для создания красивых таблиц:

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, phone))
... 
Jack       ==>       4098
Dcab       ==>       7678
Sjoerd     ==>       4127

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

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
          'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Тоже самое можно сделать, передав словарь именованных параметров, используя нотацию „**“:

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

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

Подробное описание форматирования строк с применением метода str.format() описано в разделе Синтаксис строк форматирования.

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

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

>>> import math
>>> print 'Значение ПИ — примерно %5.3f.' % math.pi
Значение ПИ — примерно 3.142.

Поскольку метод str.format() довольно нов, большая часть исходных кодов Python всё ещё использует операцию %. Однако, со временем, форматирование строк будет удалено из языка, поэтому в большинстве случаев следует использовать str.format().

Больше информации можно найти в разделе Операции форматирования строк в старом стиле.

Запись и чтение файлов

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

>>> f = open('/tmp/workfile', 'w')

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

В обычном случае файлы открываются в текстовом режиме (text mode) — это значит что вы читаете из файла и записываете в файл строки в определённой кодировке (по умолчанию используется UTF-8). Если добавить к режиму файла символ ‘b’, файл открывается в двоичном режиме (binary mode): теперь данные считываются и записываются в виде двоичных объектов. Этот режим следует использовать для всех файлов, которые не содержат текст.

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

Методы объектов-файлов

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

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

>>> f.read()
'Это всё содержимое файла.\n'
>>> f.read()
''

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

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

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

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

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

>>> for line in f:
        print(line, end='')
 
Это первая строка файла.
Вторая строка файла

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

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

>>> f.write('This is a test\n')
15

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

>>> value = ('ответ', 42)
>>> s = str(value)
>>> f.write(s)
18

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

>>> f = open('/tmp/workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # Перейти к шестому байту в файле
5
>>> f.read(1)        
b'5'
>>> f.seek(-3, 2) # Перейти к третьему байту с конца 
13
>>> f.read(1)
b'd'

При работе с текстовыми файлами (открытыми без символа b в строке режима), выполнять позиционирование (seek) позволяется только от начала файла (за исключением прокрутки в конец файла с использованием seek(0, 2)).

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

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

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

>>> with open('/tmp/workfile', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

У объектов-файлов есть ещё несколько дополнительных методов, таких как isatty() и truncate(), которые используются не так часто; обратитесь к Справочнику по библиотеке для более полного обзора по файловым объектам.

Модуль pickle

Строки могут с лёгкостью быть записаны в файл и прочитаны из файла. В случае чисел нужно применить несколько больше усилий: метод read() возвращает только строки, которые придётся передать функции вроде int(), которая принимает строку вида '123' и возвращает её числовое значение: 123. Однако если вы намереваетесь сохранить более сложные типы данных, такие как списки, словари или экземпляры классов, всё становится несколько запутаннее.

Вместо того чтобы принуждать программиста постоянно писать и отлаживать код для замысловатых типов данных, Python предоставляет стандартный модуль под названием pickle. Это замечательный модуль, который может принять любой объект Python (даже некоторые формы кода на Python!) и конвертировать его в строковое представление: этот процесс называется консервацией (pickling). Восстановление объекта из его строкового представления называется расконсервацией (unpickling): строка, описывающая объект, может быть сохранена в файл, добавлена к некоторым данным, или отослана через соединение по сети на удаленный компьютер.

Если у вас есть некоторый объект x и объект файла f, открытый на запись в двоичном режиме (binary mode, с параметром ‘wb’), простейший способ законсервировать объект требует одной-единственной строки кода:

Чтобы снова расконсервировать объект, при условии что f — объект файла, открытого для чтения (так же в двоичном режиме, с параметром ‘rb’):

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

pickle — стандартный способ для создания объектов Python, которые могут быть повторно использованы другими программами или будущими версиями этой же программы; для них есть технический термин — устойчивый объект (persistent object). Поскольку pickle используется часто, многие авторы расширений для Python заботятся о том, чтобы новые типы данных, такие как матрицы, могли быть корректно законсервированы и расконсервированы.

Интерактивный учебник языка Python

Python 3 — это современный язык, на котором просто и приятно писать программы.

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

	
print(5 + 10)
print(3 * 7, (17 - 2) * 8)
print(2 ** 16)  # две звёздочки означают возведение в степень
print(37 / 3)  # один слэш — это деление с ответом-дробью
print(37 // 3)  # два слэша считают частное от деления нацело
                # это как операция div в других языках
print(37 % 3)  # процент считает остаток от деления нацело
               # это как операция mod в других языках
 Для ввода данных в программу мы используем функцию input(). Она считывает одну строку.
 Вот программа, которая считывает имя пользователя и приветствует его:
Пётр
print('Как вас зовут?')
name = input()  # считываем строку и кладём её в переменную name
print('Здравствуйте, ' + name + '!')
 Мы будем писать программы, которые считывают данные, перерабатывают их и выводят какой-то результат. При запуске на компьютере такие программы считывают данные, которые пользователь вводит с клавиатуры, а результат выводят на экран.
 Попробуем написать программу, которая считывает два числа и выводит их сумму. Для этого считаем два числа и сохраним их в переменные a и b, пользуясь оператором присваивания =. Слева от оператора присваивания в программах на Питоне ставится имя переменной — например, строка из латинских букв. Справа от оператора присваивания ставится любое выражение. Имя станет указывать на результат вычисления выражения. Проиграйте эту программу и посмотрите на результаты её работы:
5
7
a = input()
b = input()
s = a + b
print(s)
 Мы видим, что программа выводит 57, хотя в реальной жизни 5 + 7 будет 12. Это произошло потому, что Питон в третьей строчке «сложил» две строки, а не два числа. В Питоне две строки складываются так: к первой строке приписывается вторая.
 Обратите внимание, что в визуализаторе содержимое переменных a и b заключено в кавычки. Это означает, что в a и b лежат строки, а не числа.
 В Питоне все данные называются объектами. Число 2 представляется объектом «число 2», строка 'hello' – это объект «строка 'hello'».
 Каждый объект относится к какому-то типу. Строки хранятся в объектах типа str, целые числа хранятся в объектах типа int, дробные числа (вещественные числа) — в объектах типа float. Тип объекта определяет, какие действия можно делать с объектами этого типа. Например, если в переменных first и second лежат объекты типа int, то их можно перемножить, а если в них лежат объекты типа str, то их перемножить нельзя:
	
first = 5
second = 7
print(first * second)
first = '5'
second = '7'
print(first * second)
 Чтобы преобразовать строку из цифр в целое число, воспользуемся функцией int(). Например, int('23') вернет число 23.
 Вот пример правильной программы, которая считывает два числа и выводит их сумму:
5
7
a = int(input())
b = int(input())
s = a + b
print(s)

 Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи.
 
Ввод и вывод в языке Python » Nikulux
Бывает необходимо, чтобы пользователь ввёл какую-то информацию с клавиатуры, например ввёл своё имя. Бывают случаи, когда какой-то расчёт нужно не только посчитать, но и его результат вывести на экран.
В Python организовать подобные возможности совершенно не трудно.
 a = input(«Введите Ваше имя: «)  #записываем с клавиатуры имя пользователя в переменную a

 print(«Ваше имя: «, a)  #выводим содержимое переменной a на экран
a = input(«Введите Ваше имя: «)  #записываем с клавиатуры имя пользователя в переменную a
print(«Ваше имя: «, a)  #выводим содержимое переменной a на экран
 
Вывод на экран
Предположим у нас есть переменная с каким-то значением и мы хотим вывести её на экран. Для этого в Python существует функция print(). Во внутрь круглых скобок мы помещаем имя нашей переменной или же какие-то символы. Если просто ввести цифру как численную переменную, то интерпретатор будет ругаться.
 a = ‘Это текстовая информация’ #это символьная переменная

 

 print(a)  #вывод на экран содержимого переменой a

 print(‘Это текстовая информация’)  #вывод на экран строки
a = ‘Это текстовая информация’ #это символьная переменная
 
print(a)  #вывод на экран содержимого переменой a
print(‘Это текстовая информация’)  #вывод на экран строки
Каждый раз при срабатывании функции print() будет выводиться некая информация на экран, в данном случае одна и та же. После того, как print() вывел всё то, что ему было велено, он сделает отступ на следующую строку. Чтобы этого не происходило нужно кое-что дописать…
 a = ‘Это текстовая информация’

 

 print(a, end=»»)  #ничего не записываем в кавычки

 #перенос на следующую строку не произойдёт

 print(‘Отступа не было…’)
a = ‘Это текстовая информация’
 
print(a, end=»»)  #ничего не записываем в кавычки
                  #перенос на следующую строку не произойдёт
print(‘Отступа не было…’)
В кавычки можно, в принципе, записать что душе угодно.
 
Ввод пользователем
Запомните, всё что ввёл пользователь является символьной переменной, даже если он ввёл только число.
Если нам необходимо, чтобы пользователь ввёл число для какого-то дальнейшего действия с ним как с числом (для математических операций, например), то необходимо сделать следующую хитрость: преобразовать наш строковый результат в числовой.
 a = int(input(«Введите Ваше число: «))

 #служебное слово int() должно стоять перед input()
a = int(input(«Введите Ваше число: «))
#служебное слово int() должно стоять перед input()
Сначала пользователь вводит данные, после того, как он ввёл и нажал Enter, введённая им строковая информация преобразовывается в числовой формат. В этом нам помогает функция int(). Она преобразует любые данные в числовой целочисленный формат. Но, если Вы решите преобразовать в численный формат какие-то символы интерпретатор выдаст Вам ошибку.
Буквы — это Вам не цифры!
 
Таким нехитрым образом мы познакомились с «Ввод и вывод в языке Python«
Команды ввода-вывода и арифметические операции в Питоне.
После того, как вы узнали в какой среде можно создавать и выполнять программы на Питоне, можно приступить к изучению основ этого языка. Самым интересным является то, что первые простые программы можно писать без знаний о каких-либо сложных конструкций и тела программы (как и в Паскале). В этом уроке мы познакомимся с операциями ввода-вывода в Питоне, а также быстрого вывода арифметических операций на экран компьютера.
Чтобы узнать, что получается в результате действий, проводимых вами в программе, необходимо как-то это отобразить. К самому простому и основному способу вывода данных из программы является старый добрый  вывод результата на экран, прямо из командной строке Shell среды разработки IDLE.
Для вывода значений на экран, в Питоне предусмотрена функция print(). Внутри круглых скобок, через запятую, следует писать то, что вы хотите вывести.
Примеры вывода:
Вывод результата вычислений на экран
Для немедленного вывода результата вычислений на экран, производим действия в скобочках.
print(2+3) #  результат сложения 2 и 3
Также, есть возможность с помощью одного оператора вывести на экран сразу несколько результатов вычислений.
print(2*5, (10-1)*9) # результат вычисления нескольких арифметических операций 
Вывод текста
print(Введите значение b) #  вывод поясняющей строки 
Вывод значения переменной на экран
print(b) #  вывод в виде строки значения переменной b

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

b=2+3   # Помещаем в переменную b, результат сложения двух чисел

print(b) # Выводим значение переменной на экран
Ввод и вывод значений на экран
А теперь перейдём к рассмотрению оператора ввода значений в программу. Для ввода данных в программу из командной строки в Питоне используют функцию input(). Она считывает введенные вами данные из одной строку. Ввод данных завершают нажатием клавиши Enter. Можно вводить значения с пояснением, указывая его прямо в скобках
.
Pervoe_znachenie=input(Введите значение Pervoe_znachenie=) # Выводим поясняющую строку и передаем результат ввода в переменную Pervoe_znachenie

print(Pervoe_znachenie) # Выводим значение переменной Pervoe_znachenie на экран
Однако не стоит забывать и о типе вводимых данных. Помните, что в самом начале статьи я говорил, что мы вводим строку. Проверим это на примере. Попробуйте выполнить следующий код:
print(Введите значение a)

a=input()

print(Введите значение b)

b=input()

c=a+b

print(Сумма а и b = + c)

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

Перенос значения в уже заданную переменную
print(Введите значение a)

a=input()

print(Введите значение b)

b=input()

a=a+b

print(Сумма а и b =, a)
Вывод без использования новой переменной
print(Введите значение a)

a=input()

print(Введите значение b)

b=input()

print(Сумма а и b =, a+b)
В следующем уроке, когда мы будем говорить о типе данных, данная ситуация будет легко исправлена.
print(2 ** 16)  #  возведение в степень

print(37 / 3)  #  обычное полное деление числа

print(37 // 3)  # частное от деления нацело

print(37 % 3)  #  остаток от деления нацело
 
Идентификаторы в Питоне     Дополнительные возможности оператора вывода
Ввод и вывод — документация Python 3.х
Существует несколько способов представить вывод программы; данные могут быть напечатаны в читаемой форме или записаны в файл для будущего использования. В этой главе будут рассмотрены некоторые из этих возможностей.
7.1. Особенности форматирования вывода
До сих пор мы сталкивались с двумя способами вывода значений: операторы выражений и функция print(). (Третий способ — это использование метода write() файловых объектов; на файл стандартного вывода можно ссылаться как на sys.stdout. См. Справку по библиотеке для дополнительной информации об этом.)
Чаще вам захочется больше контроля над форматированием вашего вывода, чем простое печатание разделенных пробелом значений. Есть два способа форматировать ваш вывод; первый способ — чтобы все строки обрабатывали сами себя; используя нарезание строк и операторы конкатенации, вы можете создать любую разметку, какое можете представить. Строковый тип имеет несколько методов, которые выполняют полезные операции для обивки строк данной шириной столбца; скоро они будут обсуждаться. Второй способ — использовать formatted string literals (docs.python.org/3/reference/lexical_analysis.html#f-strings) или метод str.format().
Модуль string (docs.python.org/3/library/string.html#module-string) содержит класс Template (docs.python.org/3/library/string.html#string.Template), который предлагает еще один способ подстановки значений в строки.
Конечно остается один вопрос: как вы конвертируете значения в строки? К счастью Python имеет способы конвертации любого значения в строку: передайте его функции repr() или str().
Функция str() подразумевалась для возврата представлений значений, которые достаточно читабельны, тогда как repr() подразумевалась для генерации представлений, которые могут быть прочитаны интерпретатором (или приведут к SyntaxError (docs.python.org/3/library/exceptions.html#SyntaxError), если не окажется эквивалентного синтаксиса). Для объектов, которые не имеют конкретного представления для восприятия человеком, str() вернет то же самое значение, что и repr(). Множество значений, такие как числа или структуры как списки и словари, имеют одинаковое представление, используя любую функцию. Строки, в частности, имеют два отдельных представления.
Несколько примеров:
>>> s = 'Hello, world.'
>>> str(s)
'Hello, world.'
>>> repr(s)
"'Hello, world.'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
>>> print(s)
The value of x is 32.5, and y is 40000...
>>> # repr() строки добавляет строковые кавычки и бэкслэши:
... hello = 'hello, world\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, world\n'
>>> # Аргумент для repr() может быть любым объектом Python:
... repr((x, y, ('spam', 'eggs')))
"(32.5, 40000, ('spam', 'eggs'))"
Вот два способа вывести таблицу квадратов и кубов:
>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # Обратите внимание на использование 'end' в предыдущей строке
...     print(repr(x*x*x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000
 
>>> for x in range(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  49  343
 8  64  512
 9  81  729
10 100 1000
(Заметьте, что в первом примере один пробел между каждым столбцом был добавлен с помощью print(): он всегда добавляет пробелы между своими аргументами.)
Этот пример демонстрирует метод строковых объектов str.rjust(), который выравнивает строку по правому краю в поле заданной ширины, заполняя ее пробелами слева. Есть схожие методы str.ljust() и str.center(). Они ничего не выводят, а просто возвращают новую строку. Если вводимая строка слишком длинная, они не урезают ее, а возвращают без изменений; это приведет в беспорядок вашу планировку столбцов, но это обычно лучше, чем альтернатива, которая выдала бы ложное значение. (Если вы действительно хотите усечь, вы всегда можете добавить оператор среза, как в x.ljust(n)[:n].)
Существует другой метод, str.zfill(), который заполняет нулями слева числовую строку. Он понимает знаки плюс и минус:
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
Основное использование метода str.format() выглядит вот так:
>>> print('We are the {} who say "{}!"'.format('knights', 'Ni'))
We are the knights who say "Ni!
Скобки и символы внутри них (называемые полями форматирования) заменяются объектами, переданными методу str.format(). Число в скобках может быть использовано как ссылка на позицию объекта, переданного методу str.format().
>>> print('{0} and {1}'.format('spam', 'eggs'))
spam and eggs
>>> print('{1} and {0}'.format('spam', 'eggs'))
eggs and spam
Если в методе используются аргументы-ключевые слова, их значения определяются путем использования имени аргумента.
>>> print('This {food} is {adjective}.'.format(
...       food='spam', adjective='absolutely horrible'))
This spam is absolutely horrible.
Позиционные и keyword (ключевые слова — прим. пер.) аргументы могут быть произвольно скомбинированы:
>>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
                                                       other='Georg'))
The story of Bill, Manfred, and Georg.
'!a' (применяет ascii()), '!s' (применяет str()) и '!r' (применяет repr() ) могут быть использованы для конвертирования значение перед тем, как оно будет отформатировано:
>>> contents = 'eels'
>>> print('My hovercraft is full of {}.'.format(contents))
My hovercraft is full of eels.
>>> print('My hovercraft is full of {!r}.'.format(contents))
My hovercraft is full of 'eels'.
Необязательное ':' и спецификатор формата могут следовать за именем поля. Это позволяет получить больший контроль над форматированием значения. Следующий пример округляет Pi до трех знаков после точки.
>>> import math
>>> print('The value of PI is approximately {0:.3f}.'.format(math.pi))
The value of PI is approximately 3.142.
Передача целого числа после ':' создаст поле, минимальная ширина которого будет соответствовать этому числу. Это полезно для создания таблицы.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> for name, phone in table.items():
...     print('{0:10} ==> {1:10d}'.format(name, phone))
...
Jack       ==>       4098
Dcab       ==>       7678
Sjoerd     ==>       4127
Если у вас действительно длинная строка, которую вы не хотите разделять, будет замечательно, если вы упомяните переменные, которые форматируются по имени, вместо позиций. Это может быть сделано простой передачей словаря и использованием квадратных скобок '[]' для доступа к ключам
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
...       'Dcab: {0[Dcab]:d}'.format(table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Это может быть также сделано передачей таблицы в качестве аргумента-ключевого слова с использованием нотации ‘**’.
>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
Jack: 4098; Sjoerd: 4127; Dcab: 8637678
Это особенно полезно в сочетании с функцией vars(), которая возвращает словарь, включающий все локальные переменные.
Для полного обзора строкового форматирования с помощью str.format() см. Format String Syntax (docs.python.org/3/library/string.html#formatstrings).
7.1.1. Старое форматирование строк
Оператор % также может быть использован для форматирования строки. Он интерпретирует левый аргумент так же, как sprintf()-стиль формата строки, будучи примененным к правому аргументу, и возвращает строку результата из этой форматирующей операции. Например:
>>> import math
>>> print('The value of PI is approximately %5.3f.' % math.pi)
The value of PI is approximately 3.142.
Больше информации может быть найдено в разделе printf-стиль форматирования строк.
7.2. Чтение и запись файлов
open() возвращает файловый объект (docs.python.org/3/glossary.html#term-file-object) и чаще всего используется с двумя аргументами: open(filename, mode).
>>> f = open('workfile', 'w')
Первый аргумент является строкой, содержащей имя файла. Второй аргумент — другая строка, содержащая несколько символов, описывающих способ, которым файл будет открыт. mode (режим — прим. пер.) может быть 'r', когда файл будет только читаться, 'w' — только для записи (существующий файл с таким же именем будет стерт), и 'a' открывает файл для добавления; любые данные, записанные в файл, автоматически добавляются в конец. 'r+' открывает файл как для чтения, так и записи. Аргумент mode опциональный; если он пропущен, будет назначен 'r'.
 Обычно файл открывается в текстовом режиме, это означает, что вы считываете из файла и записываете в файл строки. Файл кодируется в определенной кодировке. Если кодировка не указана, то по умолчанию она зависит от платформы (см. open()). Добавление 'b' к режиму откроет файл в режиме binary (бинарном — прим. пер.): теперь данные читаются и записываются из байтовых объектов. Этот режим следует использовать для всех файлов, которые не содержат текст.
В текстовом режиме, по-умолчанию при чтении происходит преобразование окончания строки, которое зависит от платформы (\n в Unix, \r\n в Windows) в просто \n. При записи в текстовом режиме происходит обратная конвертация. Это происходящее за сценой преобразование файловых данные прекрасно для текстовых файлов, но будет портить бинарные данные как те, что в файлах JPEG или EXE. Будьте очень осторожны, используя бинарный режим, когда читаете и пишите такие файлы.
7.2.1. Методы файловых объектов
Остальные примеры в этом разделе будут предполагать, что файловый объект под названием f уже был создан.
Считывая содержимое файла, вызовите f.read(size), который читает некоторое количество данных и возвращает их как строку (в текстовом режиме) или объект байтов (в бинарном режиме). size — необязательный числовой аргумент. Когда size пропущен или отрицателен, все содержимое файла будет прочитано и возвращено; это ваша проблема, если файл окажется вдвое больше, чем память компьютера. По-другому, наибольший размер байтов читается и возвращается. Если был достигнут конец файла, f.read() вернет пустую строку.
>>> f.read()
'This is the entire file.\n'
>>> f.read()
''
f.readline() читает одну строку (линию) из файла; символ новой строки (\n) остается в конце строки, и опускается только на последней строке файла, если файл не заканчивается новой строкой. Это делает возврат значения недвусмысленным; если f.readline() возвращает пустую строку, значит был достигнут конец файла, в то время как пустая линия представлена '\n', строкой, содержащей только одиночный символ новой линии.
>>> f.readline()
'This is the first line of the file.\n'
>>> f.readline()
'Second line of the file\n'
>>> f.readline()
''
Для чтения строк из файла, вы можете использовать цикл для обхода файлового объекта. Это эффективно для памяти, быстро и управляется простым кодом:
>>> for line in f:
...     print(line, end='')
...
This is the first line of the file.
Second line of the file
Если вы хотите считать все строки файла в список, вы можете также использовать list(f) или f.readlines().
f.write(string) записывает содержимое string в файл, возвращает количество записанных символов.
>>> f.write('This is a test\n')
15
Другие типы объектов нуждаются в конвертации — или в строку (в текстовом режиме) или объект байтов (в бинарном режиме) — перед своей записью:
>>> value = ('the answer', 42)
>>> s = str(value)  # конвертирование кортежа в строку
>>> f.write(s)
18
При двоичном режиме f.tell() возвращает целое число, указывающее для файлового объекта текущую позицию в файле, представленное как количество байтов от начала файла, и непрозрачный номер в текстовом режиме.
Чтобы изменить позицию в файловом объекте, используйте f.seek(offset, from_what). Позиция вычисляется из добавления offset (смещение — прим. пер.) к упомянутой точке; эта точка определяется аргументом from_what. Значение 0 from_what  указывает на начало файла, 1 использует текущую позицию файла и 2 — конец файла как упомянутая точка. from_what может быть опущен, что приравнивает его к 0, использованию начала файла, как отправной точки.
>>> f = open('workfile', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)      # Идем к 6-му байту в файле
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2)  # Идем к третьему байту с конца
13
>>> f.read(1)
b'd'
В текстовых фалах (тех, что были открыты без 'b') seek разрешен только относительно начала файла (исключение — ищет самый конец файла с помощью seek(0, 2)), и единственными допустимыми значениями смещения являются те, которые возвращаются из f.tell(), или ноль. Любое другое значение смещения вызывает неопределенное поведение.
Когда вы закончите с файлом, вызовите f.close(), чтобы закрыть его и освободить какие-либо системные ресурсы, занятые открытым файлом. После вызова f.close(), попытки использовать файловый объект будут приводить к автоматическому сбою.
>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file
Хорошая практика — использовать ключевое слово with (docs.python.org/3/reference/compound_stmts.html#with), когда имеете дело с объектами-файлами. У этого есть преимущество, что файл правильно закроется после завершения его набора, даже если по пути возникнет исключение. Это также намного короче, чем писать эквивалентный try(docs.python.org/3/reference/compound_stmts.html#try)-finally(docs.python.org/3/reference/compound_stmts.html#finally) блок:
>>> with open('workfile', 'r') as f:
...     read_data = f.read()
>>> f.closed
True
Файловые объекты имеют несколько дополнительных методов, таких как isstty() и trancate(), которые используются менее часто; обратитесь к справке по библиотеке для полного экскурса по объектам-файлам.
7.2.2. Сохранение структурированных данных с помощью json
Строки могут быть легко записаны в и считаны из файла. Числа отнимают немного больше усилий, поскольку метод read() возвращает только строку, которая будет передана функции наподобие int() (docs.python.org/3/library/functions.html#int), которая примет строку как ‘123’ и вернет ее числовое значение 123. Когда вы хотите сохранить более сложные типы данных как вложенные списки и словари, ручной разбор и сериализация становятся сложными.
Вместо того, чтобы постоянно писать и отлаживать код для сохранения сложных типов данных в файлах, Python позволяет использовать популярный формат обмена данными под названием JSON (JavaScript Object Notation) (json.org/). Стандартный модуль под названием json (docs.python.org/3/library/json.html#module-json) может принимать иерархии данных Python и конвертировать их в строковое представление; этот процесс называется serializing (сериализация, упорядочивание, издание выпусками — прим. пер.). Реконструкция данных из строкового представления называется deserializing. Между сериализацией и десереализацией строковое представление объекта может быть сохранено в файле или данных, или отправлено по сетевому соединению удаленному компьютеру.
Обратите внимание: Формат JSON обычно используется современными приложениями для позволения обмена данными. Много программистов уже хорошо знакомы с ним, что хорошо для совместимости.
Если у вас есть объект x, вы можете взглянуть на его JSON представление в виде строки с помощью одной строки кода:
>>> json.dumps([1, 'simple', 'list'])
'[1, "simple", "list"]'
Другой вариант функции dumps() (docs.python.org/3/library/json.html#json.dumps), называемый dump() (docs.python.org/3/library/json.html#json.dump), просто сериализует объект в текстовый файл (docs.python.org/3/glossary.html#term-text-file). Так если f — текстовый файловый объект, открытый на запись, мы можем сделать это:
json.dump(x, f)
Для декодирования объекта опять если f — текстовый файл, который был открыт для чтения:
x = json.load(f)
Это простая техника сериализации может обрабатывать списки и словари, но сериализация объектов произвольных классов в JSON требует немного больше дополнительных усилий. Обратитесь к справке по модулю json, содержащей объяснение этого.
См. также: pickle (docs.python.org/3/library/pickle.html#module-pickle) — модуль pickle
В противоположность JSON, pickle — протокол, который позволяет сериализацию произвольных объектов Python. Как таковой он специфичен для Python и не может использоваться для взаимодействия с приложениями, написанными на других языках. Он также небезопасен по-умолчанию: десериализация данных pickle, приходящих из ненадежных источников, может выполнить произвольный код, если данные были созданы опытным злоумышленником.
Ввод-Вывод данных. Программирование на языке Питон для начинающих | Учи Урок информатики
ВВОД данных
В учебных программах и простых примерах исходные данные для программы заданы в тексте программы
И для того, чтобы использовать программу для группы похожих (схожих по условию и отличных по входным данным) задач необходимо исправлять текст программы. Это неудобно, лучше, чтобы текст программы не менялся, а программа запрашивала бы у пользователя данные, необходимые для решения задачи, то есть запрашивала бы значения двух исходных переменных a и b. Для этого будем использовать функцию input(), которая считывает строку с клавиатуры и возвращает значение считанной строки, которое сразу же присвоим переменым a и b:




1
2


a = input()
b = input()

Правда, функция input возвращает текстовую строку, а нам нужно сделать так, чтобы переменные имели числовые значения (например Целые числа). Поэтому сразу же после считывания выполним преобразование типов (превратим текстовые данные в другие) при помощи фунцкии int (превращаем в целые числа), и запишем новые значения в переменные a и b.




1
2


a = int(a)
b = int(b)

Можно объединить считывание строк и преобразование типов, если вызывать функцию int для того значения, которое вернет функция input:




1
2


a = int(input())
b = int(input())

Теперь мы можем не меняя исходного кода программы многократно использовать ее для решения различных задач. Для того нужно запустить программу и после запуска программы ввести данные (например число или текст), нажимая после кажого блока данных клавишу Enter. Затем программа сама выведет результат.
Блок данных — это может быть одно число, символ, текстовая стока
ВЫВОД данных
Функция print может выводить не только значения переменных, но и значения любых выражений. Например, допустима запись print(2 + 2 ** 2). Также при помощи функции print можно выводить значение не одного, а нескольких выражений, для этого нужно перечислить их через запятую: 




1
2
3


a = 1
b = 2
print (a, '+', b, '=', a + b)

В данном случае будет напечатан текст 1 + 2 = 3: сначала выводится зание переменной a, затем строка из знака “+”, затем значение переменной b, затем строка из знака “=”, наконец, значение суммы a + b.
Обратите внимание, выводимые значение разделяются одним пробелом. Но такое поведение можно изменить: можно разделять выводимые значения двумя пробелами, любым другим символом, любой другой строкой, выводить их в отдельных строках или не разделять никак. Для этого нужно функции print передать специальный именованный параметр, называемый sep, равный строке, используемый в качестве разделителя (sep — аббревиатура от слова separator, т.е. разделитель). По умолчанию параметр sep равен строке из одного пробела и между значениями выводится пробел. Чтобы использовать в качестве разделителя, например, символ двоеточия нужно передать параметр sep, равный строке ‘:’: 




1


print(a, b, c, sep = ':')

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




1


print(a, '+', b, '=', a + b, sep = '')

Для того, чтобы значения выводились с новой строке, нужно в качестве параметра sep передать строку, состоящую из специального символа новой строки, которая задается как \n:
print(a, b, sep = ‘\n’)Символ обратного слэша в текстовых строках является указанием на обозначение специального символа, в зависимости от того, какой символ записан после него. Наиболее часто употребляется символ новой строки ‘\n’. А для того, чтобы вставить в строку сам символ обратного слэша, нужно повторить его два раза: ‘\\’. И после этих слов я обязан показать эту картинку ))
 
такое возможно у когото в голове сейчас, после прочтения. Но не стоит волноваться — дальше проще.
Вторым полезным именованным параметром функции print является параметр end, который указывает на то, что выводится после вывода всех значений, перечисленных в функции print. По умолчанию параметр end равен ‘\n’, то есть следующий вывод будет происходить с новой строки. Этот параметр также можно исправить, например, для того, чтобы убрать все дополнительные выводимые символы можно вызывать функцию print так:




1


print(a, b, c, sep = '', end = '')

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




1
2
3
4
5


a=3
b=5
print(a, b, sep = '', end = '')
c=6
print(c, sep = '', end = '')

В результате работы этого алгоритма на экране мы получим 356 (в одну строку). В отличии от вот этого




1
2
3
4
5


a=3
b=5
print(a, b, sep = '')
c=6
print(c, sep = '')

Результат
35
6
(в две строки)
Пропробуйте сами. Нажмите кнопку RUN


 

 a=3

 b=5

 print(a, b, sep = '')

 c=6

 print(c, sep = '')

 
Статья написана на основе материалов:
http://informatics.mccme.ru/

https://server.179.ru

Пожалуйста, оцените статью
4.21 из 5. (Всего голосов:262)
 Ввод и вывод — документация Python v3.0.1 
 Есть несколько способов представить вывод программы; данные можно распечатать
 в удобочитаемой форме или записаны в файл для использования в будущем. В этой главе будет
 обсудите некоторые возможности.
 Более удобное форматирование вывода 
 До сих пор мы встречали два способа записи значений:  операторов выражения  и
 функция print (). (Третий способ — использовать метод write ()
 файловых объектов; на стандартный выходной файл можно ссылаться как на sys.стандартный вывод.
 Дополнительную информацию см. В Справочнике по библиотеке.)
 Часто требуется больше контроля над форматированием вывода, чем просто
 печать значений, разделенных пробелами. Есть два способа отформатировать ваш вывод; то
 первый способ — выполнить всю обработку строк самостоятельно; используя нарезку строк и
 операции конкатенации вы можете создать любой макет, который вы можете себе представить. В
 стандартная строка модуля содержит некоторые полезные операции для заполнения
 строки с заданной шириной столбца; они будут обсуждаться в ближайшее время.Секунда
 способ — использовать метод str.format ().
 Строковый модуль содержит шаблон класса, который предлагает еще один способ
 подставлять значения в строки.
 Конечно, остается один вопрос: как преобразовать значения в строки? К счастью,
 У Python есть способы преобразовать любое значение в строку: передать его в repr ()
 или функции str ().
 Функция str () предназначена для возврата представлений значений, которые
 довольно удобочитаемы, в то время как repr () предназначен для генерации представлений
 который может быть прочитан интерпретатором (или вызовет SyntaxError, если
 нет эквивалентного синтаксиса).Для объектов, не имеющих особого
 представление для человеческого потребления, str () вернет то же значение, что и
 repr (). Многие значения, такие как числа или структуры, такие как списки и
 словари имеют одинаковое представление с использованием любой функции. Струны и
 В частности, числа с плавающей запятой имеют два различных представления.
 Некоторые примеры:
 >>> s = 'Привет, мир.'
>>> ул (а)
'Привет мир.'
>>> представитель (ы)
"'Привет мир.'"
>>> str (0.1)
'0,1'
>>> repr (0.1)
'0.10000000000000001'
>>> х = 10 * 3,25
>>> y = 200 * 200
>>> s = 'Значение x равно' + repr (x) + ', а y равно' + repr (y) + '...'
>>> печать (и)
Значение x равно 32,5, а y равно 40000 ...
>>> # Функция repr () строки добавляет строковые кавычки и обратную косую черту:
... hello = 'привет, мир \ n'
>>> привет = repr (привет)
>>> печать (привет)
'привет, мир \ n'
>>> # Аргументом repr () может быть любой объект Python:
... repr ((x, y, ('спам', 'яйца')))
"(32,5, 40000, ('спам', 'яйца'))"
 
 Вот два способа написать таблицу из квадратов и кубов:
 >>> для x в диапазоне (1, 11):
... print (repr (x) .rjust (2), repr (x * x) .rjust (3), end = '')
... # Обратите внимание на использование 'end' в предыдущей строке
... печать (repr (x * x * x) .rjust (4))
...
 1 1 1
 2 4 8
 3 9 27
 4 16 64
 5 25 125
 6 36 216
 7 49 343
 8 64 512
 9 81 729
10 100 1000

>>> для x в диапазоне (1, 11):
... print ('{0: 2d} {1: 3d} {2: 4d}'.формат (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 49 343
 8 64 512
 9 81 729
10 100 1000
 
 (обратите внимание, что в первом примере один пробел между каждым столбцом был добавлен
 способ print () работает: он всегда добавляет пробелы между своими аргументами.)
 В этом примере демонстрируется метод строковых объектов rjust (), который
 выравнивает строку по правому краю в поле заданной ширины, заполняя ее пробелами
 слева. Есть похожие методы ljust () и center ().Эти
 методы ничего не пишут, они просто возвращают новую строку. Если вход
 строка слишком длинная, они не усекают ее, а возвращают без изменений; это будет
 испортить макет столбца, но обычно это лучше, чем альтернатива,
 что было бы ложью о стоимости. (Если вам действительно нужно усечение, вы можете
 всегда добавляйте операцию среза, как в x.ljust (n) [: n].)
 Есть еще один метод, zfill (), который заполняет числовую строку слева.
 с нулями. Он разбирается в плюсах и минусах:
 >>> '12'.zfill (5)
«00012»
>>> '-3.14'.zfill (7)
'-003,14'
>>> '3.14159265359'.zfill (5)
"3.14159265359"
 
 Базовое использование метода str.format () выглядит так:
 >>> print ('Мы те {0}, которые говорят "{1}!". Format (' рыцари ',' Ни '))
Мы рыцари, которые говорят «Ни!»
 
 Скобки и символы в них (называемые полями формата) заменяются на
 объекты, переданные в метод форматирования. Число в скобках относится к
 позиция объекта, переданного в метод форматирования.
 >>> print ('{0} и {1}'. Формат ('спам', 'яйца'))
спам и яйца
>>> print ('{1} и {0}'. format ('спам', 'яйца'))
яйца и спам
 
 Если в методе форматирования используются аргументы ключевого слова, их значения ссылаются на
 используя имя аргумента.
 >>> print ('Эта {еда} есть {прилагательное}.'. Format (
... food = 'spam', прилагательное = 'абсолютно ужасно'))
Этот спам просто ужасен.
 
 Позиционные аргументы и аргументы ключевого слова можно произвольно комбинировать:
 >>> print ('История о {0}, {1} и {other}.'.format (' Билл ',' Манфред ',
                                                       другой = 'Георг'))
История Билла, Манфреда и Георга.
 
 Необязательный «:» и спецификатор формата могут следовать за именем поля. Это также
 больший контроль над форматированием значения. Следующий пример
 усекает число Пи до трех знаков после запятой.
 .
 7. Ввод и вывод — документация Python 2.7.18 
 Есть несколько способов представить вывод программы; данные можно распечатать
 в удобочитаемой форме или записаны в файл для использования в будущем. В этой главе будет
 обсудите некоторые возможности.
 7.1. Более удобное форматирование вывода 
 До сих пор мы встречали два способа записи значений:  операторов выражения  и
  печатает заявление . (Третий способ — использовать метод  write () 
 файловых объектов; на стандартный выходной файл можно ссылаться как на  sys.stdout .
 Дополнительную информацию см. В Справочнике по библиотеке.)
 Часто требуется больше контроля над форматированием вывода, чем просто
 печать значений, разделенных пробелами. Есть два способа отформатировать ваш вывод; то
 первый способ — выполнить всю обработку строк самостоятельно; используя нарезку строк и
 операции конкатенации вы можете создать любой макет, который вы можете себе представить. В
 строковые типы имеют некоторые методы, которые выполняют полезные операции для заполнения
 строки с заданной шириной столбца; они будут обсуждаться в ближайшее время.Секунда
 способ — использовать метод  str.format () .
 Модуль  string  содержит класс  Template , который предлагает
 еще один способ подставить значения в строки.
 Конечно, остается один вопрос: как преобразовать значения в строки? К счастью,
 У Python есть способы преобразовать любое значение в строку: передать его  repr () 
 или  str ()  функций.
 Функция  str ()  предназначена для возврата представлений значений, которые
 довольно удобочитаемый, а  repr ()  предназначен для генерации представлений
 который может быть прочитан интерпретатором (или вызовет  SyntaxError , если
 нет эквивалентного синтаксиса).Для объектов, не имеющих особого
 представление для человеческого потребления,  str ()  вернет то же значение, что и
  репр () . Многие значения, такие как числа или структуры, такие как списки и
 словари имеют одинаковое представление с использованием любой функции. Струны и
 В частности, числа с плавающей запятой имеют два различных представления.
 Некоторые примеры:
 >>> s = 'Привет, мир.'
>>> ул (а)
'Привет мир.'
>>> представитель (ы)
"'Привет мир.'"
>>> str (1.0 / 7.0)
'0,142857142857'
>>> repr (1.0 / 7.0)
'0,14285714285714285'
>>> х = 10 * 3,25
>>> y = 200 * 200
>>> s = 'Значение x равно' + repr (x) + ', а y равно' + repr (y) + '...'
>>> печать s
Значение x равно 32,5, а y равно 40000 ...
>>> # Функция repr () строки добавляет строковые кавычки и обратную косую черту:
... hello = 'привет, мир \ n'
>>> привет = repr (привет)
>>> распечатать привет
'привет, мир \ n'
>>> # Аргументом repr () может быть любой объект Python:
... repr ((x, y, ('спам', 'яйца')))
"(32,5, 40000, ('спам', 'яйца'))"
 
 Вот два способа написать таблицу из квадратов и кубов:
 >>> для x в диапазоне (1, 11):
... напечатать repr (x) .rjust (2), repr (x * x) .rjust (3),
... # Обратите внимание на запятую в конце предыдущей строки
... напечатать repr (x * x * x) .rjust (4)
...
 1 1 1
 2 4 8
 3 9 27
 4 16 64
 5 25 125
 6 36 216
 7 49 343
 8 64 512
 9 81 729
10 100 1000

>>> для x в диапазоне (1,11):
... напечатайте '{0: 2d} {1: 3d} {2: 4d}'.формат (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 49 343
 8 64 512
 9 81 729
10 100 1000
 
 (обратите внимание, что в первом примере один пробел между каждым столбцом был добавлен
 способ  print  работает: по умолчанию он добавляет пробелы между своими аргументами.)
 В этом примере демонстрируется метод строки  str.rjust () 
 объекты, которые выравнивают строку по правому краю в поле заданной ширины путем заполнения
 это с пробелами слева.Есть аналогичные методы  str.ljust ()  и
  ул. Центр () . Эти методы ничего не пишут, они просто возвращают
 новая строка. Если входная строка слишком длинная, они не усекают ее, а
 вернуть без изменений; это испортит макет столбца, но обычно
 лучше, чем альтернатива, которая будет лгать о стоимости. (Если ты
 действительно хотите усечения, вы всегда можете добавить операцию среза, как в
  x.ljust (n) [: n] .)
 Есть еще способ,  ул.zfill () , который дополняет числовую строку на
 осталось с нулями. Он разбирается в плюсах и минусах:
 >>> '12'.zfill (5)
«00012»
>>> '-3.14'.zfill (7)
'-003,14'
>>> '3.14159265359'.zfill (5)
"3.14159265359"
 
 Базовое использование метода  str.format ()  выглядит так:
 >>> print 'Мы те {}, которые говорят "{}!". Format (' рыцари ',' Ни ')
Мы рыцари, которые говорят «Ни!»
 
 Скобки и символы в них (называемые полями формата) заменяются на
 объекты перешли на  ул.format ()  метод. Число в
 скобки относятся к позиции объекта, переданного в
  str.format ()  метод.
 >>> print '{0} и {1}'. Format ('спам', 'яйца')
спам и яйца
>> 
.
 Python Input Output (I / O) Использование функций input () и print () 
 Python предоставляет множество встроенных функций, которые легко доступны нам в командной строке Python.
 Некоторые функции, такие как  input ()  и  print () , широко используются для стандартных операций ввода и вывода соответственно. Давайте сначала посмотрим на раздел вывода.
 Вывод Python с использованием функции print () 
 Мы используем функцию  print ()  для вывода данных на стандартное устройство вывода (экран).Мы также можем вывести данные в файл, но об этом мы поговорим позже.
 Пример его использования приведен ниже.
  print ('Это предложение выводится на экран')  
  Выход 
  Это предложение выводится на экран  
 Другой пример приведен ниже:
  а = 5
print ('Значение a равно', a)  
  Выход 
  Значение a составляет 5  
 Во втором операторе  print ()  мы можем заметить, что между строкой и значением переменной  a  был добавлен пробел.Это по умолчанию, но мы можем это изменить.
 Фактический синтаксис функции  print () :
print (* объекты, sep = '', end = '\ n', file = sys.stdout, flush = False) 
 Здесь  объектов  — это значение (я) для печати.
 Между значениями используется разделитель  sep . По умолчанию используется пробел.
 После того, как все значения напечатаны, будет напечатано  end . По умолчанию это новая строка.
 Файл   — это объект, в котором печатаются значения, и его значение по умолчанию —  sys.stdout  (экран). Вот пример, иллюстрирующий это.
  печать (1, 2, 3, 4)
печать (1, 2, 3, 4, sep = '*')
печать (1, 2, 3, 4, sep = '#', end = '&')  
  Выход 
  1 2 3 4
1 * 2 * 3 * 4
1 # 2 # 3 # 4 и  
 Форматирование вывода 
 Иногда нам нужно отформатировать наш вывод, чтобы он выглядел привлекательно. Это можно сделать с помощью метода  str.format () . Этот метод виден любому строковому объекту.
  >>> х = 5; у = 10
>>> print ('Значение x равно {}, а y равно {}'. format (x, y))
Значение x равно 5, а y равно 10  
.
 Здесь фигурные скобки  {}  используются в качестве заполнителей. Мы можем указать порядок, в котором они печатаются, используя числа (индекс кортежа).
  print ('Я люблю {0} и {1}'. Format ('хлеб', 'масло'))
print ('Я люблю {1} и {0}'. format ('хлеб', 'масло'))  
  Выход 
  Я люблю хлеб с маслом
Я люблю масло и хлеб  
 Мы даже можем использовать аргументы ключевого слова для форматирования строки.
  >>> print ('Привет, {имя}, {приветствие}'. Format (welcome = 'Goodmorning', name = 'John'))
Привет, Джон, доброе утро  
 Мы также можем форматировать строки, как в старом стиле  sprintf () , используемом в языке программирования C. Для этого мы используем оператор % .
  >>> х = 12,3456789
>>> print ('Значение x равно% 3.2f'% x)
Значение x равно 12,35.
>>> print ('Значение x равно% 3.4f'% x)
Значение x равно 12.3457  
 Ввод Python 
 До сих пор наши программы были статичными. Значение переменных было определено или жестко закодировано в исходном коде.
 Чтобы обеспечить гибкость, мы могли бы захотеть получить ввод от пользователя. В Python у нас есть функция  input () , позволяющая это сделать. Синтаксис  input () :
ввод ([подсказка]) 
, где  подсказка  — строка, которую мы хотим отобразить на экране. Это необязательно.
  >>> num = input ('Введите число:')
Введите число: 10
>>> число
'10'  
 Здесь мы видим, что введенное значение  10  является строкой, а не числом. Чтобы преобразовать это в число, мы можем использовать функции  int ()  или  float () .
  >>> число ('10 ')
10
>>> float ('10 ')
10,0  
 Эту же операцию можно выполнить с помощью функции  eval () . Но  eval  идет дальше.Он может вычислять даже выражения, если на входе строка
  >>> int ('2 + 3')
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 301, в коде выполнения
  Файл «<интерактивный ввод>», строка 1, в <модуле>
ValueError: недопустимый литерал для int () с базой 10: '2 + 3'
>>> eval ('2 + 3')
5  
 Импорт Python 
 Когда наша программа станет больше, рекомендуется разбить ее на разные модули.
 Модуль — это файл, содержащий определения и инструкции Python.Модули Python имеют имя файла и заканчиваются расширением  .py .
 Определения внутри модуля можно импортировать в другой модуль или в интерактивный интерпретатор Python. Для этого мы используем ключевое слово  import .
 Например, мы можем импортировать модуль  math , набрав следующую строку:
  импорт математики  
 Мы можем использовать модуль следующими способами:
  импорт математики
печать (math.pi)  
  Выход 
  3.141592653589793  
 Теперь все определения внутри модуля  math  доступны в нашей области. Мы также можем импортировать только некоторые определенные атрибуты и функции, используя ключевое слово  из . Например:
  >>> from math import pi
>>> пи
3,141592653589793  
 При импорте модуля Python просматривает несколько мест, определенных в  sys.path . Это список расположений каталогов.
  >>> import sys
>>> sys.дорожка
['',
 'C: \ Python33 \ Lib \ idlelib',
 'C: \ Windows \ system32 \ python33.zip',
 'C: \ Python33 \ DLLs',
 'C: \ Python33 \ lib',
 'C: \\ Python33',
 'C: \ Python33 \ lib \ site-packages']  
 Мы также можем добавить в этот список наше собственное местоположение.
 .
 7. Ввод и вывод — документация Python 3.3.7 
 Есть несколько способов представить вывод программы; данные можно распечатать
 в удобочитаемой форме или записаны в файл для использования в будущем. В этой главе будет
 обсудите некоторые возможности.
 7.1. Более удобное форматирование вывода 
 До сих пор мы встречали два способа записи значений:  операторов выражения  и
 функция print (). (Третий способ — использовать метод write ()
 файловых объектов; на стандартный выходной файл можно ссылаться как на sys.стандартный вывод.
 Дополнительную информацию см. В Справочнике по библиотеке.)
 Часто требуется больше контроля над форматированием вывода, чем просто
 печать значений, разделенных пробелами. Есть два способа отформатировать ваш вывод; то
 первый способ — выполнить всю обработку строк самостоятельно; используя нарезку строк и
 операции конкатенации вы можете создать любой макет, который вы можете себе представить. В
 строковый тип имеет несколько методов, которые выполняют полезные операции для заполнения
 строки с заданной шириной столбца; они будут обсуждаться в ближайшее время.Секунда
 способ — использовать метод str.format ().
 Строковый модуль содержит класс Template, который предлагает
 еще один способ подставить значения в строки.
 Конечно, остается один вопрос: как преобразовать значения в строки? К счастью,
 У Python есть способы преобразовать любое значение в строку: передать его в repr ()
 или функции str ().
 Функция str () предназначена для возврата представлений значений, которые
 довольно удобочитаемы, в то время как repr () предназначен для генерации представлений
 который может быть прочитан интерпретатором (или вызовет SyntaxError, если
 нет эквивалентного синтаксиса).Для объектов, не имеющих особого
 представление для человеческого потребления, str () вернет то же значение, что и
 repr (). Многие значения, такие как числа или структуры, такие как списки и
 словари имеют одинаковое представление с использованием любой функции. Струны, в
 в частности, имеют два различных представления.
 Некоторые примеры:
 >>> s = 'Привет, мир.'
>>> ул (а)
'Привет мир.'
>>> представитель (ы)
"'Привет мир.'"
>>> str (1/7)
'0,14285714285714285'
>>> х = 10 * 3.25
>>> y = 200 * 200
>>> s = 'Значение x равно' + repr (x) + ', а y равно' + repr (y) + '...'
>>> печать (и)
Значение x равно 32,5, а y равно 40000 ...
>>> # Функция repr () строки добавляет строковые кавычки и обратную косую черту:
... hello = 'привет, мир \ n'
>>> привет = repr (привет)
>>> печать (привет)
'привет, мир \ n'
>>> # Аргументом repr () может быть любой объект Python:
... repr ((x, y, ('спам', 'яйца')))
"(32,5, 40000, ('спам', 'яйца'))"
 
 Вот два способа написать таблицу из квадратов и кубов:
 >>> для x в диапазоне (1, 11):
... print (repr (x) .rjust (2), repr (x * x) .rjust (3), end = '')
... # Обратите внимание на использование 'end' в предыдущей строке
... печать (repr (x * x * x) .rjust (4))
...
 1 1 1
 2 4 8
 3 9 27
 4 16 64
 5 25 125
 6 36 216
 7 49 343
 8 64 512
 9 81 729
10 100 1000

>>> для 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 49 343
 8 64 512
 9 81 729
10 100 1000
 
 (обратите внимание, что в первом примере один пробел между каждым столбцом был добавлен
 способ print () работает: он всегда добавляет пробелы между своими аргументами.)
 В этом примере демонстрируется метод str.rjust () строки
 объекты, которые выравнивают строку по правому краю в поле заданной ширины путем заполнения
 это с пробелами слева. Есть похожие методы str.ljust () и
 str.center (). Эти методы ничего не пишут, они просто возвращают
 новая строка. Если входная строка слишком длинная, они не усекают ее, а
 вернуть без изменений; это испортит макет столбца, но обычно
 лучше, чем альтернатива, которая будет лгать о стоимости.(Если ты
 действительно хотите усечения, вы всегда можете добавить операцию среза, как в
 x.ljust (n) [: n].)
 Существует еще один метод, str.zfill (), который заполняет числовую строку на
 осталось с нулями. Он разбирается в плюсах и минусах:
 >>> '12'.zfill (5)
«00012»
>>> '-3.14'.zfill (7)
'-003,14'
>>> '3.14159265359'.zfill (5)
"3.14159265359"
 
 Базовое использование метода str.format () выглядит так:
 >>> print ('Мы {} говорим "{}!"'.format ('рыцари', 'Ни'))
Мы рыцари, которые говорят «Ни!»
 
 Скобки и символы в них (называемые полями формата) заменяются на
 объекты, переданные в метод str.format (). Число в
 скобки могут использоваться для обозначения позиции объекта, переданного в
 str.format () метод.
 >>> print ('{0} и {1}'. Формат ('спам', 'яйца'))
спам и яйца
>>> print ('{1} и {0}'. format ('спам', 'яйца'))
яйца и спам
 
 Если аргументы ключевого слова используются в str.format (), их значения
 упоминаются с использованием имени аргумента.
 >>> print ('Эта {еда} есть {прилагательное}.'. Format (
... food = 'spam', прилагательное = 'абсолютно ужасно'))
 
.
No related posts.