Функции map, filter и zip

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

• ;
• ;
• .

Общие примеры использования функции .

>>> x = input('Enter your name:')
# Enter your name:Anton
>>> print('Hello, ', x)
# Hello,  Anton

# Можно и без строки подсказки
>>> print('Введите число:')
# Введите число:
>>> x = input()
# 10

# Не забываем что функция 
# возвращает строку
>>> x
# '10'

Проверка и преобразование типов при вводе данных с клавиатура.

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

# test.py 

def str_to_num(line):
    """функция конвертирует строку в число"""
    line = line.strip()
    # если в строке только цифры
    if line.isdigit():
        return int(line) 
    # если строка содержит точку или запятую
    elif '.' in line or ',' in line
        # если из строки убрать точку или запятую
        # и при этом в строке останутся только цифры
        if any(line.replace(x, '').isdigit() for x in '.', ',']):
            return float(line.replace(',', '.'))
    else
        # ошибка
        print('Это не число!\n')
        return None

print('\nДля выхода из программы введите Ctrl+C')
print('Для окончания ввода цифр нажмите Enter\n')

nums = []
while True
    inpt = input('Ожидается ввод числа или Enter:')
    if inpt == ''
        # Закончить ввод чисел
        break
    n = str_to_num(inpt)
    if n is not None
        nums.append(n)

if nums
    if len(nums) == 1
        print('Вы ввели одну цифру: ', nums])
    else
        print('\nВыберите действие:')
        print('  сложить цифры введите 1;')
        print('  умножить цифры введите 2.\n')

        rez = None
        while True
            inpt = input('Введите 1 или 2:')
            inpt = inpt.strip()
            if inpt == '1'
                rez = sum(nums)
                print('Сумма введенных чисел:', rez)
            elif inpt == '2'
                rez = 1
                for i in nums
                    rez *= i
                print('Произведение введенных чисел:', rez)
            else
                print('Неправильное действие.\n')
            
            if rez is not None
                break
else
    print('Вы ничего не ввели.')

Вывод программы:

$ python3 test.py 

Для выхода из программы введите Ctrl+C
Для окончания ввода цифр нажмите Enter

Ожидается ввод числа или Enter:10
Ожидается ввод числа или Enter:13.9
Ожидается ввод числа или Enter:9,9
Ожидается ввод числа или Enter:

Выберите действие:
  сложить цифры введите 1;
  умножить цифры введите 2.

Введите 1 или 2:2
Произведение введенных чисел: 1376.1000000000001

Эмуляция терминала с использованием функцией .

Для воспроизведения вывода ошибок при выполнении команд в воображаемой «консоли» воспользуемся модулем . Выполнять введенный код будем при помощи встроенной функции .

# test.py
import sys, traceback

def run_user_code(envdir):
    source = input(">>> ")
    try
        # Выполнение введенного кода с клавиатуры
        exec(source, envdir)
    except Exception
        print("Exception in user code:")
        print("-"*60)
        traceback.print_exc(file=sys.stdout)
        print("-"*60)

# словарь для хранения введенных переменных
envdir = {}

while True
    run_user_code(envdir)

Запускаем эмуляцию интерпретатора Python.

$ python3 test.py
>>> a = 3
>>> b = '1'           
>>> a + b
Exception in user code:
------------------------------------------------------------
Traceback (most recent call last):
  File "tt.py", line 6, in run_user_code
    exec(source, envdir)
  File "<string>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
------------------------------------------------------------

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

n Python 2, raw_input() возвращает строку, а input() пытается запустить ввод в виде выражения Python. Итак, изменение вашей первой строки на что-то вроде этого должно сработать.

(raw_input())

EOFError возникает, когда встроенная функция, такая как input() или raw_input (), не считывает никаких данных до того, как столкнется с концом своего входного потока. Файловые методы, такие как read (), возвращают пустую строку в конце файла.

Данный код переписывается следующим образом, чтобы поймать ошибку EOFError и найти ее тип.

#eofError.py
try:
while True:('prompt:')
print 'READ:', data
except EOFError as e:
print e
Then if we run the script at the terminal
$ echo hello | python eofError.py

ВЫХОД

prompt:READ: hello
prompt:EOF when reading a line

Ввод списка (массива) в языке Питон

• Простой вариант ввода списка и его вывода:

L=
L =  int(input()) for i in range(5)  # при вводе 1 2 3 4 5
print (L) # вывод: 1 2 3 4 5

Функция int здесь используется для того, чтобы строка, введенная пользователем, преобразовывалась в целые числа.

Как уже рассмотрено выше, список можно выводить целым и поэлементно:

# вывод целого списка (массива)
print (L)
 
# поэлементный вывод списка (массива)
for i in range(5): 
  print ( Li, end = " " )

Задание Python 4_7:
Необходимо задать список (массив) из шести элементов; заполнить его вводимыми значениями и вывести элементы на экран. Использовать два цикла: первый — для ввода элементов, второй — для вывода.

Замечание: Для вывода через «,» используйте следующий синтаксис:

print ( Li, end = ", " )

Пример результата:

введите элементы массива: 
3.0
0.8
0.56
4.3
23.8
0.7
Массив =  3, 0.8, 0.56, 4.3, 23.8, 0.7

Задание Python 4_8:
Заполните список случайными числами в диапазоне 20..100 и подсчитайте отдельно число чётных и нечётных элементов. Использовать цикл.

Замечание: .

Задание Python 4_9: Найдите минимальный элемент списка. Выведите элемент и его индекс. Список из 10 элементов инициализируйте случайными числами. Для перебора элементов списка использовать цикл.

Пример результата:

9 5 4 22 23 7 3 16 16 8 
Минимальный элемент списка L7=3

Практическая работа

1. Примеры функции частное для деления без остатка в excel

   Напишите программу (файл user.py), которая запрашивала бы у пользователя:
   — его имя (например, «What is your name?»)
   — возраст («How old are you?»)
   — место жительства («Where are you live?»)
   После этого выводила бы три строки:
   «This is имя»
   «It is возраст»
   «(S)he live in место_жительства»
   Вместо имя, возраст, место_жительства должны быть данные, введенные пользователем. Примечание: можно писать фразы на русском языке, но если вы планируете стать профессиональным программистом, привыкайте к английскому.

2. Напишите программу (файл arithmetic.py), которая предлагала бы пользователю решить пример 4 * 100 — 54. Потом выводила бы на экран правильный ответ и ответ пользователя. Подумайте, нужно ли здесь преобразовывать строку в число.

3. Запросите у пользователя четыре числа. Отдельно сложите первые два и отдельно вторые два. Разделите первую сумму на вторую. Выведите результат на экран так, чтобы ответ содержал две цифры после запятой.

Утиный ввод в Python

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

Давайте посмотрим на это на примере настраиваемого объекта и функции add(), которую мы определили.

def add(x, y):
    return x + y

class Data:

    def __init__(self, i):
        self.id = i

d1 = Data(10)
d2 = Data(5)

print(add(d1, d2))

Этот код вызовет следующую ошибку времени выполнения:

Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/hello-world/journaldev/type_checking.py", line 12, in <module>
    print(add(d1, d2))
  File "/Users/pankaj/Documents/PycharmProjects/hello-world/journaldev/type_checking.py", line 2, in add
    return x + y
TypeError: unsupported operand type(s) for +: 'Data' and 'Data'

Если мы хотим, чтобы наш объект поддерживал оператор сложения, все, что нам нужно сделать, это определить для него функцию __add __().

def __add__(self, other):
    return self.id + other.id

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

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

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

def calculate(x, y, op='sum'):
    if op == 'divide':
        return x // y
    if op == 'difference':
        return x - y
    if op == 'multiply':
        return x * y
    # default is sum
    return x + y

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

print(calculate(10, 3, 'divide'))  # 3
print(calculate(10, 5))  # 15
print(calculate('A', 'B'))  # AB

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

def calculate1(x: int, y: int, op: str = 'sum') -> int:
    # same code as above

Подсказки типа аргумента функции снабжены двоеточием (:), а тип возвращаемого значения – знаком ->.

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

Но сторонние инструменты, такие как средства проверки типов, IDE, линтеры и т.д., могут анализировать это, чтобы предупредить нас о возможности неправильных типов аргументов. Например, если мы передадим строковые аргументы этой функции, PyCharm IDE выдаст предупреждающее сообщение как «Ожидаемый тип int, вместо этого получил str».

Изменение типов данных

Приведенную выше операцию все-таки можно выполнить, если превратить число 1 в строку «1». Для изменения одних типов данных в другие в языке Python предусмотрен ряд встроенных в него функций (что такое функция в принципе, вы узнаете в других уроках). Поскольку мы пока работаем только с тремя типами (, и ), рассмотрим вызовы соответствующих им функций – , , .

>>> str(1) + 'a'
'1a'
>>> int('3') + 4
7
>>> float('3.2') + int('2')
5.2
>>> str(4) + str(1.2)
'41.2'

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

>>> int('hi')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with 
base 10: 'hi'

Здесь возникла ошибка значения (), так как передан литерал (в данном случае строка с буквенными символами), который нельзя преобразовать к числу с основанием 10. Однако функция не такая простая:

>>> int('101', 2)
5
>>> int('F', 16)
15

Если вы знаете о различных системах счисления, то поймете, что здесь произошло.

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

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

Применяет определенную функцию к каждому элементу в последовательности.

Параметры:

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

Описание:

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

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

# функция должна принимать столько
# аргументов, сколько последовательностей
# передается в функцию map()
def plus(a, b, c):
  return a + b +c

# функция 'plus' применяется к элементам 
# из всех последовательностей параллельно
>>> x = map(plus, 1, 2], 3, 4], 5, 6])
>>> list(x)
# 

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

def create_tuple(a, b):
    return a, b

# функция `map()` останавливается, когда 
# заканчивается самая короткая последовательность
>>> x = map(create_tuple, 'a', 'b'], 3, 4, 5])
>>> print(dict(x))
# {'a': 3, 'b': 4}

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

>>> x = 1, 2, 3
>>> y = 4, 5, 6, 7
# вычисление при помощи встроенной функции 'pow()' 
# 'x' в степени 'y' для каждого элемента 2-х списков
>>> list(map(pow, x, y))
# 

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

Преимуществ использования :

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

Примеры обработки последовательностей без циклов.

• ;
• ;
• .

Удаление пунктуации в тексте при помощи .

>>> import re
>>> def clean(word):
...        return re.sub(r"", "", word.strip())

>>> text = """С помощью цикла `for .. in:` программе 
необходимо хранить в памяти системы весь (список)! """
>>> word = text.split()
>>> word = map(clean, word)
>>> text = ' '.join(word)
>>> text
# 'С помощью цикла for  in программе необходимо 
# хранить в памяти системы весь список'

Примеры создания и изменения классов «на лету» при помощи type():

Например, следующие два определения создают идентичные объекты.

>>> class Foo(object):
...       bar = True
>>> Foo = type('Foo', (), {'bar'True})

Класс , созданный через метакласс можно использовать как обычный класс:

>>> Foo
# <class '__main__.Foo'>
>>> f = Foo()
>>> f.bar
# True

# можно наследоваться от него
>>>   class FooChild(Foo): pass
...
>>> FooChild
# <class '__main__.FooChild'>
>>> FooChild.bar # bar унаследован от Foo
# True

Добавим методы в класс . Для этого определим функцию и добавим ее как атрибут.

>>> def echo_bar(self):
...       print(self.bar)
...
>>> FooChild = type('FooChild', (Foo,), {'echo_bar' echo_bar})
>>> hasattr(Foo, 'echo_bar')
# False
>>> hasattr(FooChild, 'echo_bar')
# True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
# True

# после динамического создания класса добавим еще один метод 
>>> def echo_bar_more(self):
...       print('yet another method')
...
>>> FooChild.echo_bar_more = echo_bar_more
>>> hasattr(FooChild, 'echo_bar_more')
# True

Пример пользовательского ввода Python С помощью функции input()

(«enter>

Выход:

Введите имя пользователя: Python PoolИмя пользователя: Python Pool

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

(«enter>

Выход

Enter any value: 10
value of val1:  10
type of val1:  
Enter another value: 10.23
value of val2:  10.23
type of val2:  
Enter another value: Hello
value of val3:  Hello
type of val3:  

Смотрите программу и вывод – Здесь мы предоставили три значения «10» для val1, которое является целочисленным значением, но рассматривается как строка, «10.23» для val2, которое является плавающим значением, но рассматривается как строка, «Hello» для val3, которое является строковым значением.

Операции в программировании

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

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

>>> 10.25 + 98.36
108.61
>>> 'Hello' + 'World'
'HelloWorld'

Здесь следует для себя отметить, что то, что делает оператор в операции, зависит не только от него, но и от типов данных, которыми он оперирует. Молоток в случае нападения на вас крокодила перестанет играть роль строительного инструмента. Однако в большинстве случаев операторы не универсальны. Например, знак плюса неприменим, если операндами являются, с одной стороны, число, а с другой – строка.

>>> 1 + 'a'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 
'int' and 'str'

Здесь в строке интерпретатор сообщает, что произошла ошибка типа – неподдерживаемый операнд для типов и .

3) Статически типизированные языки против динамически типизированных языков

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

Input Type Date

The is used for input fields that should contain a date.

Depending on browser support, a date picker can show up in the input field.

Example

<form>  <label for=»birthday»>Birthday:</label>  <input
type=»date» id=»birthday» name=»birthday»></form>

You can also use the and attributes to add restrictions to dates:

Example

<form>  <label for=»datemax»>Enter a date before
1980-01-01:</label>  <input type=»date» id=»datemax» name=»datemax»
max=»1979-12-31″><br><br>  <label for=»datemin»>Enter a date after
2000-01-01:</label>  <input type=»date» id=»datemin» name=»datemin»
min=»2000-01-02″></form>

Функция 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

The gets() and puts() Functions

The char *gets(char *s) function reads a line from stdin into the buffer pointed to by s until either a terminating newline or EOF (End of File).

The int puts(const char *s) function writes the string ‘s’ and ‘a’ trailing newline to stdout.

NOTE: Though it has been deprecated to use gets() function, Instead of using gets, you want to use fgets().

#include <stdio.h>
int main( ) {

   char str;

   printf( "Enter a value :");
   gets( str );

   printf( "\nYou entered: ");
   puts( str );

   return 0;
}

When the above code is compiled and executed, it waits for you to input some text. When you enter a text and press enter, then the program proceeds and reads the complete line till end, and displays it as follows −

$./a.out
Enter a value : this is test
You entered: this is test

Класс Python BytesIO

Здесь мы можем хранить наши данные в виде байтов ( ). Когда мы используем , данные хранятся в буфере в памяти.

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

import io
bytes_stream = io.BytesIO(b'Hello from Journaldev\x0AHow are you?')

Обратите внимание, что мы передаем байтовую строку (с префиксом ). Прямо сейчас – это просто дескриптор потока байтов

Прямо сейчас – это просто дескриптор потока байтов.

Чтобы на самом деле распечатать данные внутри буфера, нам нужно использовать .

import io
bytes_stream = io.BytesIO(b'Hello from Journaldev\x0AHow are you?')
print(bytes_stream.getvalue())

Здесь принимает значение байтовой строки из дескриптора.

Поскольку байтовая строка является представлением ASCII новой строки (‘\n’), мы получаем следующий вывод:

Выход

b'Hello from Journaldev\nHow are you?'

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

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

Чтобы закрыть буфер, используйте:

bytes_stream.close()

Теперь давайте посмотрим на класс StringIO.

Недостатки подсказок типа

• Для подсказок типа нет преимуществ во время выполнения. Он не применяет типы и не вызывает никаких предупреждений или ошибок, если передается другой тип аргумента.
• Подсказки типа больше похожи на документацию. Если функция была изменена, и разработчик пропустил изменение подсказок типа соответствующим образом, он даст неправильное сообщение разработчику, использующему функцию. Поддержка подсказок типа отнимает много времени и требует усилий разработчиков.
• Немного замедляет скорость работы программы.
• Подсказки типа были введены в Python 3.5, поэтому он довольно новый и не будет работать со старыми версиями Python.

Практическая работа

1. Переменной var_int присвойте значение 10, var_float — значение 8.4, var_str — «No».

2. Значение, хранимое в переменной var_int, увеличьте в 3.5 раза. Полученный результат свяжите с переменной var_big.

3. Измените значение, хранимое в переменной var_float, уменьшив его на единицу, результат свяжите с той же переменной.

4. Разделите var_int на var_float, а затем var_big на var_float. Результат данных выражений не привязывайте ни к каким переменным.

5. Измените значение переменной var_str на «NoNoYesYesYes». При формировании нового значения используйте операции конкатенации () и повторения строки ().

6. Выведите значения всех переменных.

Практическая работа

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

Основная ветка программы, не считая заголовков функций, состоит из одной строки кода. Это вызов функции . В ней запрашивается на ввод целое число. Если оно положительное, то вызывается функция , тело которой содержит команду вывода на экран слова «Положительное». Если число отрицательное, то вызывается функция , ее тело содержит выражение вывода на экран слова «Отрицательное».

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

Ввод данных. Функция input()

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

Если в интерактивном режиме ввести команду , то ничего интересного вы не увидите. Компьютер будет ждать, когда вы что-нибудь введете и нажмете Enter или просто нажмете Enter. Если вы что-то ввели, это сразу же отобразиться на экране:

>>> input()
Yes!
'Yes!'

Функция передает введенные данные в программу. Их можно присвоить переменной. В этом случае интерпретатор не выводит строку сразу же:

>>> answer = input()
No, it is not.

В данном случае строка сохраняется в переменной answer, и при желании мы можем вывести ее значение на экран:

>>> answer
'No, it is not.'

При использовании функции кавычки в выводе опускаются:

>>> print(answer)
No, it is not.

Куда интересней использовать функцию в скриптах – файлах с кодом. Рассмотрим такую программу:

При запуске программы, компьютер ждет, когда будет введена сначала одна строка, потом вторая. Они будут присвоены переменным nameUser и cityUser. После этого значения этих переменных выводятся на экран с помощью форматированного вывода.

Вышеприведенный скрипт далек от совершенства. Откуда пользователю знать, что хочет от него программа? Чтобы не вводить человека в замешательство, для функции предусмотрен специальный параметр-приглашение. Это приглашение выводится на экран при вызове . Усовершенствованная программа может выглядеть так:

Обратите внимание, что в программу поступает строка. Даже если ввести число, функция все равно вернет его строковое представление

Но что делать, если надо получить число? Ответ: использовать функции преобразования типов.

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

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

qtyOranges = int(input("Сколько апельсинов? "))
priceOrange = float(input("Цена одного? "))
 
sumOranges = qtyOranges * priceOrange
 
print("Заплатите", sumOranges, "руб.")

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