Ввод python: Ввод строк, Чисел и Обработка исключений ~ PythonRu

Содержание

Ввод строк, Чисел и Обработка исключений ~ PythonRu

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

Python, будучи медленным относительно таких языков, как C или Java, предлагает продвинутые инструменты для получения, анализа и обработки данных от конечного пользователя.

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

Ввод в Python

Для получения информации с клавиатуры в Python есть функции input() или raw_input() (о разнице между ними чуть позже). У них есть опциональный параметр prompt, который является выводимой строкой при вызове функции.

Когда input() или raw_input() вызываются, поток программы останавливается до тех пор, пока пользователь не введет данные через командную строку. Для ввода нужно нажать Enter после завершения набора текста. Обычно Enter добавляет символ новой строки (\n), но не в этом случае. Введенная строка просто будет передана приложению.

Интересно, что кое-что поменялось в принципе работе функции между Python 2 и Python 3, что отразилось в разнице между

input() и raw_input(). Об этом дальше.

Сравнение функций input и raw_input

Разница между этими функциями зависит от версии Python. Так, в Python 2 функция raw_input() используется для получения ввода от пользователя через командную строку, а input() оценивает ее и попробует запустить как код Python.

В Python 3 от raw_input() избавились, оставив только input(). Она используется для получения ввода пользователя с клавиатуры. Возможности input() из Python 2 в Python 3 работать не будут. Для той же операции нужно использовать инструкцию eval(input()).

Взгляните на пример функции raw_input в Python 2.



txt = raw_input("Введите что-нибудь, чтобы проверить это: ")
print "Это то, что вы только что ввели?", txt

Вывод

Введите что-нибудь, чтобы проверить это: Привет, мир!

Это то, что вы только что ввели? Привет, мир!

А вот как она работает в Python 3



txt = input("Введите что-нибудь, чтобы проверить это: ")
print("Это то, что вы только что ввели?", txt)

Вывод

Введите что-нибудь, чтобы проверить это: Привет, мир 3!

Это то, что вы только что ввели? Привет, мир 3!

Дальше в материале будет использоваться метод input из Python 3, если не указано другое.

Строковый и числовой ввод

По умолчанию функция input() конвертирует всю получаемую информацию в строку. Прошлый пример продемонстрировал это.

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


test_text = input ("Введите число: ")




test_number = int(test_text)


print ("Введенное число: ", test_number)

Вывод

Введите число: 13
Введенное число: 13

Того же можно добиться и таким образом:

test_number = int(input("Введите число: "))

Здесь сразу после сохранения ввода происходит преобразование и присваивание значения переменной.

Нужно лишь отметить, что если пользователь ввел не целое число, то код вернет исключение (даже если это число с плавающей точкой).

Обработка исключений ввода

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

Вот такой код считается небезопасным:

test2word = input("Сколько вам лет? ")
test2num = int(test2word)
print("Ваш возраст ", test2num)

Запустим его и введем следующее:

Сколько вам лет? Пять

При вызове функции int() со строкой Пять появится исключение ValueError, и программа остановит работу.

Вот как можно сделать код безопаснее и обработать ввод:

test3word = input("Введите свое счастливое число: ")

try:
    test3num = int(test3word)
    print("Это правильный ввод! Ваше счастливое число: ", test3num)
except ValueError:
    print("Это не правильный ввод. Это не число вообще! Это строка, попробуйте еще раз.")

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

print.

Вот так будет выглядеть вывод с исключением.

Введите свое счастливое число: Семь
Это не правильный ввод. Это не число вообще! Это строка, попробуйте еще раз.

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

Полный пример


def example():

    
    
    while True:
        test4word = input("Как вас зовут? ")

        try:
            test4num = int(input("Сколько часов вы играете на своем мобильном телефоне?" ))

        
        except ValueError:
            
            print("Error! Это не число, попробуйте снова.")

        
        
        else:
            print("Впечатляет, ", test4word, "! Вы тратите", test4num*60, "минут или", test4num*60*60, "секунд на игры в своем телефоне!")
            break


example()

Вывод:

Как вас зовут? Александр
Сколько часов вы играете на своем мобильном телефоне? 3
Впечетляет, Александр! Вы тратите 180 минут или 10800 секунд на игры в своем телефоне!

Выводы

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

Python. Урок 12. Ввод-вывод данных. Работа с файлами

В уроке рассмотрены основные способы ввода и вывода данных в 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. Модули и пакеты >>>

чисел и текста с помощью консоли — Пример программы

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

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

Получение данных input

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

Входные данные в Python 3 обычно сохраняются в переменных или списках, чтобы их можно было обработать. Синтаксис операции ввода выглядит так:

a = input()

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

Кроме того, оператор input() позволяет перед запросом ввода вывести какой-либо текст, например:

a = input("Введите своё имя")

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

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

a = int(input("Введите целое число"))

Если пользователь введет строку или дробь, интерпретатор Python возбудит исключение. Поэтому для ввода используют оператор try-except:

try:
    a = int(input("Введите целое число"))
except:
    print("Ошибка, введено не целое число")

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

Также можно запрашивать ввод в бесконечном цикле, выход из которого осуществляется только тогда, когда пользователь вводит данные нужного типа:

while True:
    try:
        a = int(input("Введите целое число: "))
    except:
        print("Вы ввели не целое число, ошибка")
        continue
    break

Вывод данных print

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

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

print("Строка")

print(5)

Интерпретатор Python также позволяет передавать в print() другую функцию:

def sum(a, b):
    return a + b
print(sum(5, 2)) # Выведет 7

В этом случае функция sum посчитает сумму аргументов и вернёт результат. Этот результат будет выведен с помощью print в консоль.

В print() можно передать несколько аргументов:

print("один", "два", 5) # Выведет "один два 5"

Кроме того, строки можно складывать с помощью оператора “+”:

print("один" + "два", 5) # Выведет "одиндва 5"

Однако не всегда нужно выводить что-то на экран. Программисты могут перенаправить вывод программы в файл. Функцию print() имеет необязательный параметр “file”, который по умолчанию равен “sys.stdout”, то есть выводу на экран. Если программист хочет перенаправить вывод в файл, он должен написать код:

f = open("file.txt", "w") # Открываем файл в режиме запись
print("Строка", file = f) # Выводим "Строка" в файл

Кроме того, если нужно сделать красивое оформление вывода разными цветами, то можно воспользоваться библиотекой colorama или termcolor. Подробно про цветной вывод описано в отдельной статье на сайте.

Пример программы

В программах ввод и вывод взаимосвязаны, например, пользователь вводит данные, программа обрабатывает их и выводит обратно на экран. Даже если программа не консольная, а с графическим интерфейсом, то если пользователь нажал на кнопку “Запустить”, он всё равно ввел в программу данные, которые дали сигнал для выполнения какой-либо функции.

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

# Операции над двумя числами
def sum(a, b):
    return a + b
def sub(a, b):
    return a - b
def mult(a, b):
    return a * b
def div(a, b):
    return a / b

def main():
    while True:
        try:
            #Вводим числа
            a = float(input("Введите первое число: "))
            b = float(input("Введите второе число: "))
            c = int(input("Номер операции:\n1) +\n2) -\n3) *\n4) /\n"))
        except:
            print("Нужно ввести число, попробуйте ещё раз ...\n")
            continue # Повторяем ввод, если введено не число
        break # Выходим из цикла, если числа введены правильно
    # Применяем нужную операцию в зависимости от ввода
    cond = {1 : sum(a, b),
            2 : sub(a, b),
            3 : mult(a, b),
            4 : div(a, b)}
    # Выводим результат операции
    print(cond[c])

if __name__ == "__main__":
    main()

Вот пример работы:

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

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

Статьи — Ввод данных с клавиатуры

Ввод данных с клавиатуры осуществляется с помощью функции input(). После выполнения данной функции программа ожидает ввода данных и после нажатия «Enter» записывает их в переменную или возвращает результат на экран.

Существуют 4 вида ввода:

1. a=int(input())

Это означает, что в переменную a будет записано целое число (int — integer).

Например:

Чтобы программа начала работать, можно нажать F5 или Run Module (после этого Python предложит ее сохранить, так как он не может работать с несохраненными программами):

После этого появится примерно такое окно (окна могут различаться в зависимости от процессора, операционной системы и версии Python):

На строке, идущей после двух наборов стрелочек (в данном случае на шестой) будет мигающий курсор. Вам надо будет ввести любое целое число и нажать «Enter». После этого программа начнет работать и выведет введенное число.

2. a=float(input())

«float» означает ввод действительного числа. При вводе нецелого числа Вы должны разделить целую и дробную часть точкой. Например, «34.75»

3. a=str(input())

«str» означает ввод строки. Например, «qwerty» или «Hello, Python!» (str — string).

4. a,b=input().split()

Это означает ввод любых двух и более элементов. Скобки после «split» используются для того, чтобы задать, чем будут разделяться переменные (по умолчанию пробел). Например:

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

Результат:

В скобки после «input» можно ввести любой текст в кавычках. Например:

После начала работы у Вас откроется окно с заданным текстом:

В которое Вы можете ввести свою переменную.

Ввод и вывод в Python. Input и print

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

Введение

Все без исключения программные продукты обрабатывают и выводят данные. Только в некоторых информация заложена изначально, а в других она поступает извне. Черпать данные можно из файлов либо непосредственно из вводимого пользователем текста. Во втором случае предполагается интерактивный режим работы. Получается, пользователь вводит информацию, программа ее обрабатывает и выводит на экран. В таком случае говорят, что код не замкнут на себе, а может «общаться» с внешней средой. Так, для ввода информации в последних версиях Python input используется.

Вывод информации

Для печати любых данных на экране используется стандартная встроенная функция print. В версии «Питона» 3 после слова print идут круглые скобки, в которых указывается выводимая информация. В версии 2.7 после зарезервированной команды print круглых скобок быть не должно.

В ранней версии после слова print написать переменную и поставить запятую будет означать подавление перевода строки. В новой редакции «Питона» с командой вывода в круглых скобках указывается переменная и end=” ”. Это означает добавление пробела вместо перевода строки.

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

В одной команде с print в Python input работает. Об этой команде поговорим ниже.

Ввод информации

Чтобы ввести данные с консоли, необходима команда raw_input (Python 2.7). Она выводит приглашение пользователю, ожидает ввода данных и осуществляет дальнейшую работу в соответствии с поступившими аргументами. В 3-й версии Python input используется. В чем разница между двумя командами?

В более ранних версиях (2.7) raw_input была необходима для ввода строковых типов данных. Если нужно было получить число, то команда выполнялась с функцией int(). Эта функция переводила число из строки в целый тип. В этой же версии функции input Python вводила численные выражения, и использовать дополнительно int не было необходимости. Разработчики Python 3.0 устранили raw_input и оставили только input. Если через input в новой версии ввести число, то нужно дополнительно задействовать int или float, чтобы получить целочисленное или вещественное выражение. Если использовать команду с пустыми круглыми скобками, то программа будет ожидать действий со стороны пользователя.

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

Если в Python 3.0 не «оцифровать» строку, то при выполнении математических действий введенные данные будут складываться как строки.

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

Задачи с решением и алгоритмом

1. Создать программу, которая будет спрашивать у пользователя его имя и возраст. Вывести на экран сообщение, в котором говорится, сколько лет ему было бы через век.

Алгоритм:

  • вывести на экран приглашение для дальнейшего ввода имени и возраста;
  • произвести необходимые математические расчеты;
  • вывести сообщение по типу: «Марина, 100 лет Вам исполнится в 2099 году»

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

Алгоритм:

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

Задачи на закрепление

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

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

3. Написать программу, в которой выводится приглашение пользователю решить математический пример: 4*100-54. Если вводится правильный ответ, то появляется сообщение с поздравлениями. Если же нет, на экран выводится уведомление об ошибке. Дополнительно нужно переделать программу, в которой в цикле while эти действия будут повторяться до тех пор, пока пользователь не введет правильный ответ.

Основы ввода и вывод данных

Введение

Примеры

Использование input () и raw_input ()

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

foo = raw_input("Put a message here that asks the user for input") 

В приведенном выше примере foo будет хранить все входные пользователь предоставляет.

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

foo = input("Put a message here that asks the user for input")

 

В приведенном выше примере foo будет хранить все входные пользователь предоставляет.

Использование функции печати

В Python 3 функции печати представлены в виде функции:

print("This string will be displayed in the output")
# This string will be displayed in the output

print("You can print \n escape characters too.")
# You can print escape characters too.

 

В Python 2 print изначально был оператором, как показано ниже.

print "This string will be displayed in the output"
# This string will be displayed in the output

print "You can print \n escape characters too."
# You can print escape characters too.

 

Примечание: использование from __future__ import print_function в Python 2 позволит пользователям использовать print() работают так же , как и Python 3 кода. Это доступно только в Python 2.6 и выше.

Функция запрашивать у пользователя номер

def input_number(msg, err_msg=None):
    while True:
        try:
            return float(raw_input(msg))
        except ValueError:
            if err_msg is not None:
                print(err_msg)


def input_number(msg, err_msg=None):
    while True:
        try:
            return float(input(msg))
        except ValueError:
            if err_msg is not None:
                print(err_msg)



 

И использовать это:

user_number = input_number("input a number: ", "that's not a number!")

 

Или, если вы не хотите «сообщение об ошибке»:

user_number = input_number("input a number: ") 

Печать строки без перевода строки в конце

В Python 2.x, чтобы продолжить линию с print , конец print заявления с запятой. Это автоматически добавит пробел.

print "Hello,",
print "World!"
# Hello, World!
 

В Python 3.x, то print функция имеет дополнительный end параметр , который является то , что он печатает в конце данной строки. По умолчанию это символ перевода строки, поэтому эквивалентен этому:

print("Hello, ", end="\n")
print("World!")
# Hello, 
# World!

 

Но вы могли бы передать в других строках

print("Hello, ", end="")
print("World!")
# Hello, World!

print("Hello, ", end="<br>")
print("World!")
# Hello, <br>World!

print("Hello, ", end="BREAK")
print("World!")
# Hello, BREAKWorld!

 

Если вы хотите получить больше контроля над выходом, вы можете использовать sys.stdout.write :

import sys

sys.stdout.write("Hello, ")
sys.stdout.write("World!")
# Hello, World! 

Читать со стандартного ввода

Программы Python могут читать UniX трубопроводов . Вот простой пример того, как читать из stdin :

import sys

for line in sys.stdin:
    print(line) 

Имейте в виду , что sys.stdin представляет собой поток. Это означает, что цикл for завершится только после завершения потока.

Теперь вы можете направить вывод другой программы в вашу программу на Python следующим образом:

$ cat myfile | python myprogram.py 

В этом примере cat myfile может быть любая команда Unix , которая выводит на stdout .

Кроме того , с помощью модуля FileInput может пригодиться:

import fileinput
for line in fileinput.input():
    process(line)


 

Ввод из файла

Ввод также может быть прочитан из файлов. Файлы могут быть открыты с помощью встроенной функции open . Использование with <command> as <name> , open with <command> as <name> синтаксис ( так называемый «Контекст — менеджер») делает работу с open и получить дескриптор файла супер легко:

with open('somefile.txt', 'r') as fileobj:
    # write code here using fileobj

 

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

Файлы могут быть открыты в разных режимах. В приведенном выше примере файл открывается только для чтения. Чтобы открыть существующий файл для чтения только использовать r . Если вы хотите , чтобы прочитать этот файл как байты использовать rb . Для добавления данных в существующий файл с помощью . a Используйте w , чтобы создать файл или перезаписать существующие файлы с тем же именем. Вы можете использовать r+ , чтобы открыть файл для чтения и записи. Первый аргумент open() это имя файла, второй режим. Если режим остается пустым, то по умолчанию будет r .

# let's create an example file:
with open('shoppinglist.txt', 'w') as fileobj:
    fileobj.write('tomato\npasta\ngarlic')

with open('shoppinglist.txt', 'r') as fileobj:
    # this method makes a list where each line 
    # of the file is an element in the list
    lines = fileobj.readlines()

print(lines)
# ['tomato\n', 'pasta\n', 'garlic']

with open('shoppinglist.txt', 'r') as fileobj:
    # here we read the whole content into one string:
    content = fileobj.read()
    # get a list of lines, just like int the previous example:
    lines = content.split('\n')

print(lines)
# ['tomato', 'pasta', 'garlic']

 

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

with open('shoppinglist.txt', 'r') as fileobj:
    # this method reads line by line:
    lines = []
    for line in fileobj:
        lines.append(line.strip())

 

При чтении файлов учитывайте характерные для операционной системы символы перевода строки. Хотя for line in fileobj автоматически удаляет их, это всегда безопасно вызывать strip() на линии чтения, как показано выше.

Открытые файлы ( fileobj в приведенных выше примерах) всегда указывают на определенное место в файле. Когда они первые открыли точки дескриптор файла в самом начале файла, который является положение 0 . Дескриптор файла может отображать его текущее положение с tell :

fileobj = open('shoppinglist.txt', 'r')
pos = fileobj.tell()
print('We are at %u.' % pos) # We are at 0.

 

После прочтения всего содержимого позиция обработчика файла будет указана в конце файла:

content = fileobj.read()
end = fileobj.tell()
print('This file was %u characters long.' % end)
# This file was 22 characters long.
fileobj.close()

 

Позиция обработчика файла может быть установлена ​​на то, что нужно:

fileobj = open('shoppinglist.txt', 'r')
fileobj.seek(7)
pos = fileobj.tell()
print('We are at character #%u.' % pos)

 

Вы также можете прочитать любую длину из с

Ввод и вывод данных в Python

Назад в начало

Переменные и типы данных

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

a = 10
A = 20

a и А — это разные переменные, регистр ввода имеет значение

Типы данных

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

int — целочисленный тип (1, 192, 781287)

float — вещественный (дробный) (1.12312, 1231.12378718)

str — строковый тип (обязательно пишется в кавычках) (‘Hello world’)

bool — булевый тип (имеет всего два значения: True и False)

Приведение типов

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

a = 10
b = str(a) # b — это строка
с = int(b) # c — это снова число
d = 10.78
e = int(d) # e равно 10

Функция print

Функция print выводит переданные в неё аргументы в стандартный поток вывода. Что же такое стандартный поток вывода? Standart output или stdout называется потоком вывода, местом, куда мы выводим наш текстовый контент. По умолчанию стандартный поток вывода равен sys.stdout и поэтому вывод осуществляется в консоль.

Функция print все переданные в неё аргументы в стандартный поток вывода. Например:

print(1)
print(‘Hello world!’)
print(False)
print(1.5, 2.0, 10, True, ‘username’)
print(‘Hello’ + ‘ ‘ + ‘world’ + ‘!’)
# 1
# Hello world!
# False
# 1.5 2.0 10 True username
# Hello world!

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

# Во-первых:
print(1)
print(2)
# 1
# 2
# Во-вторых:
print(‘Hello’, ‘world’)
# Hello world

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

print(1, end=’ ‘)
print(2, end=’ ‘)
print(3, end=’ ‘)
# 1 2 3

print(1, end=»-»)
print(2, end=’-‘)
print(3, end=»-»)
# 1-2-3-

print(1, end=’-я выведусь после первого print-‘)
print(2, end=’-a я после второго-‘)
print(3, end=’-я выведусь после третьего-‘)
# 1-я выведусь после первого print-2-a я после второго-3-я выведусь после третьего-

Рассмотрим второй параметр функции print — sep, sep от английского separator (разделитель). По умолчанию параметр sep равен ‘ ‘. Время для экспериментов ╰(▔∀▔)╯.

print(1, 2, 3, 4)
print(1, 2, 3, 4, sep=’+++’)
print(1, 2, 3, 4, sep=’разделитель’)
print(1, 2, 3, 4, sep='(◕‿◕)’)
print(1, 2, 3, 4, sep='(ノ◕ヮ◕)ノ*:・゚✧’)
# 1 2 3 4
# 1+++2+++3+++4
# 1разделитель2разделитель3разделитель4
# 1(◕‿◕)2(◕‿◕)3(◕‿◕)4
# 1(ノ◕ヮ◕)ノ*:・゚✧2(ノ◕ヮ◕)ノ*:・゚✧3(ノ◕ヮ◕)ノ*:・゚✧4

Функция input

Функция input является функцией стандартного ввода (stdin). Ее главная задача — это передача введенных пользователем данных в функцию.

name = input()
print(‘Hello, ‘ + name)

Функция input может принимать всего лишь один аргумент — строку, которая выведется перед кареткой ввода

name = input(‘Enter your name: ‘)
print(‘Hello, ‘ + name)

Функция input возвращает строковый тип данных

Строки можно складывать друг с другом — это называется конкатенацией или объединением

number = input()
print(type(number))
#

Поэтому если мы напишем такой код, то он будет работать некорректно:

number1 = input()
number2 = input()
print(number1 + number2)
# Ввод:
# 1
# 2
# Вывод:
# 12

Поэтому необходимо преобразовать строковый тип в целочисленный (str в int)

number1 = int(input())
number2 = int(input())
print(number1 + number2)
# Ввод:
# 1
# 2
# Вывод:
# 3

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

Решение задач

1. Поэкспериментируйте с переводом в различные типы данных

2. Пользователь вводит свое имя и фамилию. Выведите:

Hello, имя фамилия
# На месте слов с % должны быть введенные данные

3. Посчитайте сумму трех введенных целых чисел

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

5. Дано число, выведите предыдущее и следущее за ним числа в таком формате:

# Число равно 10
Число предшествующее числу 10 равно 9
Число следующее за числом 10 равно 11

6. Вводятся имя и возраст. Выведите, где введенное имя = Максим, а возраст = 20

Привет, Максим! Ваш возраст равен 20!

Базовое форматирование ввода, вывода и строк в Python — Real Python

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

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

В предыдущем руководстве этой вводной серии вы:

  • Увидел сравнение различных парадигм, используемых языками программирования для реализации определенной итерации.
  • Узнал об итерациях и итераторах, двух концепциях, которые составляют основу определенной итерации в Python
  • Объединил все вместе, чтобы узнать о циклах for Python.

К концу этого руководства вы научитесь:

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

Без лишних слов, приступим!

Чтение ввода с клавиатуры

Программам часто требуется получать данные от пользователя, обычно путем ввода с клавиатуры.Самый простой способ сделать это в Python — использовать input () .

ввод ([<подсказка>])

Считывает строку ввода с клавиатуры.

input () приостанавливает выполнение программы, чтобы пользователь мог ввести строку ввода с клавиатуры. Как только пользователь нажимает клавишу Enter , все набранные символы считываются и возвращаются в виде строки:

>>>
  >>> s = input ()
foo bar baz
>>> с
'foo bar baz'
  

Обратите внимание, что новая строка, генерируемая при нажатии пользователем клавиши Enter , не включается как часть возвращаемой строки.

Если вы включили необязательный аргумент , input () отобразит его как приглашение пользователю перед приостановкой чтения ввода:

>>>
  >>> name = input ('Как тебя зовут?')
Как тебя зовут? Уинстон Смит
>>> имя
'Уинстон Смит'
  

input () всегда возвращает строку. Если вам нужен числовой тип, вам нужно преобразовать строку в соответствующий тип с помощью встроенных функций int () , float () или complex () :

>>>
  1 >>> n = input ('Введите число:')
 2 Введите число: 50
 3 >>> печать (n + 100)
 4 Отслеживание (последний вызов последний):
 5 Файл "", строка 1, в 
 6 TypeError: должно быть str, а не int
 7
 8 >> & g  
.

Ввод пользователя Python с клавиатуры — функция input ()

  • Пользовательский ввод Python с клавиатуры можно прочитать с помощью встроенной функции input ().
  • Ввод от пользователя читается как строка и может быть назначен переменной.
  • После ввода значения с клавиатуры нужно нажать кнопку «Enter». Затем функция input () считывает значение, введенное пользователем.
  • Программа останавливается на неопределенное время после ввода пользователем. Нет возможности указать значение тайм-аута.
  • Если мы введем EOF (* nix: Ctrl-D, Windows: Ctrl-Z + Return) , возникает ошибка EOFError, и программа завершается.

Синтаксис функции input ()

Синтаксис функции input ():

ввод (подсказка)
 

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


Получение пользовательского ввода в Python

Вот простой пример получения пользовательского ввода и печати его на консоли.

value = input ("Пожалуйста, введите строку: \ n")

print (f'Вы ввели {значение} ')
 

Выход:

Пользовательский ввод Python

Какой тип значения, введенного пользователем?

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

value = input ("Пожалуйста, введите строку: \ n")

print (f'Вы ввели {значение}, его тип - {тип (значение)} ')

value = input ("Пожалуйста, введите целое число: \ n")

print (f'Вы ввели {значение}, его тип - {тип (значение)} ')
 

Выход:

Пожалуйста, введите строку:
Python
Вы ввели Python, и его тип - 
Пожалуйста, введите целое число:
123
Вы ввели 123, а его тип - 
 

Как получить целое число в качестве пользовательского ввода?

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

value = input ("Пожалуйста, введите целое число: \ n")

значение = int (значение)

print (f'Вы ввели {значение}, а его квадрат равен {значение ** 2} ')
 

Выход:

Целое число, вводимое пользователем Python

Пользовательский ввод Python и пример EOFError

Когда мы вводим EOF, input () вызывает EOFError и завершает программу. Давайте посмотрим на простой пример с использованием PyCharm IDE.D Отслеживание (последний вызов последний): Файл «/Users/pankaj/Documents/PycharmProjects/PythonTutorialPro/hello-world/user_input.py», строка 1, в value = input («Пожалуйста, введите целое число: \ n») EOFError: EOF при чтении строки Пользовательский ввод Python вызывает ошибку EOFError


Пример выбора пользовательского ввода Python

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

value1 = input ("Пожалуйста, введите первое целое число: \ n")
значение2 = ввод ("Пожалуйста, введите второе целое число: \ n")

v1 = int (значение1)
v2 = int (значение2)

choice = input ("Введите 1 для сложения.\ nВведите 2 для вычитания. \ nВведите 3 для умножения. :\n ")
выбор = int (выбор)

если выбор == 1:
    print (f'Вы ввели {v1} и {v2}, и их сложение равно {v1 + v2} ')
elif choice == 2:
    print (f'Вы ввели {v1} и {v2}, и их вычитание равно {v1 - v2} ')
elif choice == 3:
    print (f'Вы ввели {v1} и {v2}, и их умножение равно {v1 * v2} ')
еще:
    print («Неправильный выбор, завершение программы.»)
 

Вот пример вывода выполнения вышеуказанной программы.

Выбор ввода пользователем Python

Краткое описание функции Python raw_input ()

Функция raw_input () использовалась для ввода данных пользователем в Python 2.x версии. Вот простой пример из интерпретатора командной строки Python 2.7, показывающий использование функции raw_input ().

~ python2.7
Python 2.7.10 (по умолчанию, 22 февраля 2019 г., 21:55:15)
[GCC 4.2.1 совместимый Apple LLVM 10.0.1 (clang-1001.0.37.14)] на darwin
Для получения дополнительной информации введите «помощь», «авторские права», «кредиты» или «лицензия».
>>> value = raw_input ("Пожалуйста, введите строку \ n")
Пожалуйста, введите строку
Здравствуйте
>>> распечатать значение
Здравствуйте
 

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


Заключение

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

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

Артикул:

.

Получение пользовательского ввода в Python

Введение

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

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

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

Ввод в Python

Для получения информации через клавиатуру Python использует функции input () или raw_input () (подробнее о различиях между ними в следующем разделе). Эти функции имеют необязательный параметр, обычно известный как prompt , который представляет собой строку, которая будет выводиться на экран при каждом вызове функции.

Когда вызывается одна из функций input (), или raw_input () , выполнение программы останавливается, пока пользователь не введет ввод через командную строку.Чтобы фактически ввести данные, пользователю необходимо нажать клавишу ENTER после ввода своей строки. При нажатии клавиши ENTER обычно вставляется символ новой строки («\ n»), но в данном случае этого не происходит. Введенная строка будет просто отправлена ​​в приложение.

Любопытно отметить, что мало что изменилось в том, как эта функция работает между версиями Python 2 и 3, что отражено в работе input () и raw_input () , объясненной в следующем разделе.

Сравнение функций input и raw_input

Разница при использовании этих функций зависит только от того, какая версия Python используется. Для Python 2 функция raw_input () используется для получения строкового ввода от пользователя через командную строку, а функция input () , возвращаемая функцией, фактически оценивает вводимую строку и пытается запустить ее как код Python.

В Python 3 функция raw_input () устарела и заменена функцией input () и используется для получения строки пользователя с клавиатуры.А функция input () Python 2 больше не поддерживается в версии 3. Чтобы получить ту же функциональность, которая была предоставлена ​​функцией Python 2 input () , в Python необходимо использовать оператор eval (input ()) . 3.

Взгляните на пример функции raw_input в Python 2.

  # Python 2

txt = raw_input ("Введите что-нибудь, чтобы проверить это:")
print "Это то, что вы только что сказали?", txt
  

Выход

  Напечатайте что-нибудь, чтобы проверить это: Пусть Код будет с вами!

Это то, что вы только что сказали? Да пребудет с вами Кодекс!
  

Точно так же взгляните на пример функции ввода в Python 3.

  # Python 3

txt = input ("Введите что-нибудь, чтобы проверить это:")

# Обратите внимание, что в версии 3 функция print ()
# требует использования скобок.
print ("Это то, что вы только что сказали?", txt)
  

Выход

  Напечатайте что-нибудь, чтобы проверить это: Пусть Код будет с вами!
Это то, что вы только что сказали? Да пребудет с вами Кодекс!
  

С этого момента в этой статье будет использоваться метод input из Python 3, если не указано иное.

Строковый и числовой ввод

Функция input () по умолчанию преобразует всю получаемую информацию в строку. Предыдущий пример демонстрирует это поведение.

С другой стороны, числа

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

  # Запрашивается ввод и сохраняется в переменной
test_text = input ("Введите число:")

# Преобразует строку в целое число.Если тебе надо
# для преобразования пользовательского ввода в десятичный формат,
# функция float () используется вместо int ()
test_number = int (test_text)

# Выводит в консоль переменную по запросу
print ("Введенное вами число:", test_number)
  

Выход

  Введите число: 13
Вы ввели номер: 13
  

Другой способ сделать то же самое:

  test_number = int (input («Введите число:»))
  

Здесь мы напрямую сохраняем ввод после немедленного преобразования в переменную.

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

Обработка исключений на входе

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

В этом разделе мы продемонстрируем несколько хороших методов обработки ошибок при вводе данных.

Но сначала вот небезопасный код:

  test2word = input («Назови свой возраст:»)
test2num = int (test2word)
print ("Ух ты! Ваш возраст", test2num)
  

При запуске этого кода, допустим, вы вводите следующее:

  Назовите свой возраст: три
  

Здесь, когда функция int () вызывается со строкой «Три», генерируется исключение ValueError, и программа останавливается и / или аварийно завершается.

Теперь посмотрим, как сделать этот код более безопасным для обработки пользовательского ввода:

  test3word = input («Назови свой счастливый номер:»)

пытаться:
    test3num = int (test3word)
    print ("Это правильный номер! Ваш счастливый номер:", test3num)
кроме ValueError:
    print («Это недопустимое число. Это вообще не число! Это строка, иди и попробуйте еще раз. Удачи в следующий раз!»)
  

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

Вот пример этого кода, работающего при возникновении исключения:

  Скажите мне свой счастливый номер: Семерка
Это неверный номер. Это вообще не число! Это строка, иди и попробуй еще раз. Повезет в следующий раз!
  

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

Полный пример

  # Делает функцию, которая будет содержать
# желаемая программа.
def example ():

    # Вызывает бесконечный цикл, который продолжает выполняться
    # пока не произойдет исключение
    в то время как True:
        test4word = input ("Как вас зовут?")

        пытаться:
            test4num = int (input («С 1 по 7, сколько часов вы играете на своем мобильном телефоне?»))

        # Если что-то еще не является строкой
        # введена версия номера,
        # Будет вызвано исключение ValueError.кроме ValueError:
            # Цикл будет продолжаться до проверки
            print («Ошибка! Это не число. Попробуйте еще раз.»)

        # При успешном преобразовании в целое число
        # цикл закончится.
        еще:
            print («Впечатляет», test4word, «! Вы потратили», test4num * 60, «минут или», test4num * 60 * 60, «секунд на мобильном телефоне!»)
            сломать

# Функция вызывается
пример()
  

Результатом будет:

  Как вас зовут? Фрэнсис
С 1 по 7, сколько часов вы играете на своем мобильном телефоне? 3
Впечатляет, Фрэнсис! Вы провели на своем мобильном телефоне 180 минут или 10800 секунд!
  

Заключение

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

.Учебное пособие по

Python: ввод с клавиатуры

Ввод с клавиатуры

Вход Функция

Почти нет программ без ввода. Вход может поступать разными способами, например из базы данных, другого компьютера, щелчков и перемещений мыши или из Интернета. Тем не менее, в в большинстве случаев ввод осуществляется с клавиатуры. Для этого в Python предусмотрена функция вход (). input имеет необязательный параметр, который представляет собой строку приглашения.

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

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

Давайте посмотрим на следующий пример:

name = input ("Как вас зовут?")
print («Приятно познакомиться» + имя + «!»)
age = input ("Ваш возраст?")
print ("Итак, вам уже" + str (age) + "лет," + name + "!")
 

Сохраняем программу как «input_test.py «и запустите его:
$ python input_test.py
Как вас зовут? "Фрэнк"
Приятно познакомиться, Фрэнк!
Ваш возраст? 30
Итак, тебе уже 30 лет, Фрэнк!
 

Вполне возможно, что вы забыли указать свое имя в кавычках. Если да, то там также велика вероятность того, что вы запутались в сообщении об ошибке:
Отслеживание (последний вызов последний):
  Файл "input_test.py", строка 1, в 
    name = input ("Как вас зовут?")
  Файл «<строка>», строка 1, в <модуле>
NameError: имя «Фрэнк» не определено
 
Мы упоминали об этом в начале этой главы о функции ввода: ввод интерпретирует ввод.Вот почему нам пришлось преобразовать переменную age в строку. Если вы не обернете свое имя в кавычки, Python принимает ваше имя как переменную. Итак, сообщение об ошибке имеет смысл!

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

>>> name = input ("Как тебя зовут?")
Как вас зовут? "Джон"
>>>
>>> age = input ("Ваш возраст?")
Ваш возраст? 38
>>> print (возраст, тип (возраст))
(38, <тип int>)
>>> colors = input ("Ваши любимые цвета?")
Ваши любимые цвета? ["красный", "зеленый", "синий"]
>>> печать (цвета)
['красный', 'зеленый', 'синий']
>>> печать (цвета, тип (цвета))
(['красный', 'зеленый', 'синий'], <тип 'список'>)
>>>
 

Ввод с помощью raw_input ()

raw_input не интерпретирует ввод.Он всегда возвращает ввод пользователя без изменений, т.е. необработанный. Этот необработанный ввод может быть изменен на тип данных, необходимый для алгоритма. Для этого мы можем использовать либо функция приведения или функция eval. И снова мы используем интерактивную оболочку, чтобы продемонстрировать это поведение:
>>> age = raw_input ("Ваш возраст?")
Ваш возраст? 38
>>> print (возраст, тип (возраст))
('38', <тип 'str'>)
>>>
>>> age = int (raw_input ("Ваш возраст?"))
Ваш возраст? 42
>>> print (возраст, тип (возраст))
(42, <тип int>)
>>>
>>> programming_language = raw_input ("Ваши любимые языки программирования?")
Ваши любимые языки программирования? [«Python», «Lisp», «C ++»]
>>> print (язык_программирования, тип (язык_программирования))
('[«Python», «Lisp», «C ++»]', )
>>>
>>> programming_language = eval (raw_input ("Ваши любимые языки программирования?"))
Ваши любимые языки программирования? [«Python», «Lisp», «C ++»]
>>> print (язык_программирования, тип (язык_программирования))
(['Python', 'Lisp', 'C ++'], )
>>>
 

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

>>> programming_language = list (raw_input ("Ваши любимые языки программирования?"))
Ваши любимые языки программирования? [«Python», «Lisp», «C ++»]
>>> print (язык_программирования, тип (язык_программирования))
(['', '[', '"', 'P', 'y', 't', 'h', 'o', 'n', '"', ',', '', '" ',' L ',' i ',' s ',' p ',' "',', ','" ',' C ',' + ',' + ',' "','] '] , )
>>>
 

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *