Как запустить def в python

Функции в Python — синтаксис, аргументы, вызов, выход

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

Синтаксис

��‍♀️ Простой пример: Вы торгуете мёдом, и после каждой продажи вам нужно печатать чек. В нём должно быть указано: название фирмы, дата продажи, список наименований проданных товаров, их количество, цены, общая сумма, а также сакраментальная фраза «Спасибо за покупку!».

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

print(«ООО Медовый Гексагон») print(«Мёд липовый», end=» «) print(1, end=»шт «) print(1250, end=»р») print(«\nCумма», 1250, end=»р») print(«\nСпасибо за покупку!»)

А теперь представьте, что произойдёт, когда вы раскрутитесь, и покупатели станут приходить один за другим. В таком случае, чеки надо будет выдавать очень быстро. Но что делать, если вдруг нагрянет ваш любимый клиент и купит 10 сортов мёда в разных количествах? Далеко не все в очереди согласятся ждать, пока вы посчитаете общую сумму и внесёте её в чек.

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

def print_check(honey_positions): sum = 0 # переменная для накопления общей суммы print(«ООО Медовый Гексагон\n») # в цикле будем выводить название, количество и цену for honey in honey_positions: name = honey[0] amount = honey[1] price = honey[2] print(f» ( шт.) — руб.») sum += amount * price # здесь же будем считать ещё и общую сумму print(f»\nИтого: руб.») print(«Спасибо за покупку!»)

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

# (название, количество, цена за штуку) honey_positions = [ («Мёд липовый», 3, 1250), («Мёд цветочный», 7, 1000), («Мёд гречишный», 6, 1300), («Донниковый мёд», 1, 1750), («Малиновый мёд», 10, 2000), ]

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

print_check(honey_positions) > ООО Медовый Гексагон Мёд липовый (3 шт.) — 1250 руб. Мёд цветочный (7 шт.) — 1000 руб. Мёд гречишный (6 шт.) — 1300 руб. Донниковый мёд (1 шт.) — 1750 руб. Малиновый мёд (10 шт.) — 2000 руб. Итого: 40300 руб. Спасибо за покупку!

Да, код стал более массивным. Однако теперь для печати чека вам не придётся самостоятельно вычислять итог. Достаточно лишь изменить количество и цену товаров в списке. Существенная экономия времени! Слава функциям!

Термины и определения

Ключевое слово def в начале функции сообщает интерпретатору о том, что следующий за ним код — есть её определение. Всё вместе — это объявление функции.

# объявим функцию my_function() def my_function(): # тело функции

Аргументы часто путают с параметрами:

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

# a, b — параметры функции def test(a, b): # do something # 120, 404 — аргументы test(120, 404)

Ключевая особенность функций — возможность возвращать значение

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

# она будет принимать два множителя, а возвращать их округленное # до целого числа произведение def int_multiple(a, b): product = a * b # возвращаем значение return int(product) print(int_multiple(341, 2.7)) > 920

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

# найдём квадратный корень из возврата функции int_multiple # во встроенную функцию sqrt() мы передали вызов int_multiple print(math.sqrt(int_multiple(44, 44))) > 44

Важность функций

Абстракция

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

Мы можем написать функцию, которая вычисляет скорость в каждом конкретном случае. Нам не важно, кто совершает движение: и для человека и для самолёта средняя скорость будет рассчитываться одинаково.

def calculate_speed(distance, time): return distance / time

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

Возможность повторного использования

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

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

# пузырьковая сортировка def bubble_sort(nums): for i in range(0, len(nums) — 1): for j in range(len(nums) — 1): if nums[j] > nums[j + 1]: nums[j], nums[j + 1] = nums[j + 1], nums[j] return nums

Всего 10 таких сортировок, и привет, лишние 50 строк кода.

Модульность

Разбитие больших и сложных процессов на простые составляющие — важная часть, как кодинга, так и реальной жизни. В повседневности мы занимаемся этим неосознанно. Когда убираемся в квартире, мы пылесосим, моем полы и окна, очищаем поверхности от пыли и наводим блеск на всё блестящее. Всё это — составляющие одного большого процесса под названием «уборка», но каждую из них также можно разбить на более простые подпроцессы.

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

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

Без применения модульности получится сплошная последовательность инструкций:

# Database operation program # Код для чтения данных из базы # . # . # Код для выполнения операций над данными # . # . # Код для вывода результата # . # . # Код для записи данных в базу # . # .

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

def read_from_db(): # Код для чтения данных из базы # . # . # . def operate_with_data(): # Код для выполнения операций над данными # . # . # . def print_result(): # Код для вывода результата # . # . # . def write_to_db(): # Код для записи данных в базу # . # . # . # код основной программы # Database operation program read_from_db() operate_with_data() print_result() write_to_db()

Это и называется модульностью.

Пространство имен

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

��‍♀️ Пример из жизни: в ВУЗе учатся два человека с совпадающими ФИО. Их нужно как-то различать. Если сделать пространствами имён группы этих студентов, то проблема будет решена. В рамках своей группы ФИО этих студентов будут уникальными.

Объявление и вызов функций

def hello(): print(‘Adele is cute’)

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

# код выполняется последовательно, поэтому сейчас интерпретатор # не знает о существовании функции hello hello() def hello(): print(‘Adele is cute’) > NameError: name ‘hello’ is not defined

Поэтому стоит лишь поменять объявление и вызов местами, и всё заработает:

def hello(): print(‘Adele is cute’) hello() > Adele is cute

Область видимости функций

Рассмотрим подробнее области видимости:

Локальная (L)

Локальная область видимости находится внутри def :

def L(): # переменная i_am_local является локальной внутри L() i_am_local = 5

Область объемлющих функций (E)

Объявили функцию e() . Внутри неё объявили функцию inner_e() . Относительно inner_e() все переменные, объявленные в e() будут относиться к области объемлющих функций. Такие переменные являются нелокальными в inner_e() . Чтобы с ними взаимодействовать, нужно использовать ключевое слово nonlocal :

def e(): x = 5 def inner_e(): nonlocal x x = x + 1 return x return inner_e() print(e()) > 6

Глобальная (G)

Глобальная область видимости лежит за пределами всех def .

# G num = 42 def some_function(n): res = n + num return res print(some_function(1)) > 43

Аргументы

Позиционные

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

Значения в позиционных аргументах подставляются согласно позиции имён аргументов:

nums = [42, 11, 121, 13, 7] state = True # в данном примере # 1-я позиция «nums» -> parameter_1 # 2-я позиция «state» -> parameter_2 def test_params(parameter_1, parameter_2): pass # равнозначные варианты вызова функции test_params(nums, state) test_params([42, 11, 121, 13, 7], True)

Именованные

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

def print_trio(a, b, c): print(a, b, c) print_trio(c=4, b=5, a=6) > 6 5 4

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

Необязательные параметры (параметры по умолчанию)

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

def not_necessary_arg(x=’My’, y=’love’): print(x, y) # если не передавать в функцию никаких значений, она отработает со значениями по умолчанию not_necessary_arg() > My love # переданные значения заменяют собой значения по умолчанию not_necessary_arg(2, 1) > 2 1

Аргументы переменной длины (args, kwargs)

Когда заранее неизвестно, сколько конкретно аргументов будет передано в функцию, мы пользуемся аргументами переменной длины. Звёздочка «*» перед именем параметра сообщает интерпретатору о том, что количество позиционных аргументов будет переменным:

def infinity(*args): print(args) infinity(42, 12, ‘test’, [6, 5]) > (42, 12, ‘test’, [6, 5])

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

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

def named_infinity(**kwargs): print(kwargs) named_infinity(first=’nothing’, second=’else’, third=’matters’) >

Здесь kwargs уже заключает аргументы не в кортеж, а в словарь.

Передача по значению и по ссылке

В Python аргументы могут быть переданы, как по ссылке, так и по значению. Всё зависит от типа объекта.

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

• Числовые типы (int, float, complex).
• Строки (str).
• Кортежи (tuple).

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

В Python изменяемые объекты это:

• Списки (list).
• Множества (set).
• Словари (dict).

Будьте внимательны при передаче изменяемых объектов. Одна из частых проблем новичков.

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

Словарь в качестве аргументов (упаковка)

Передаваемые в функцию аргументы можно упаковать в словарь при помощи оператора «**»:

def big_dict(**arguments): print(arguments) big_dict(key=’value’) >

Возвращаемые значения (return)

Что можно возвращать

Функции в Python способны возвращать любой тип объекта.

Распаковка возвращаемых значений

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

def calculate(num1, num2): return num1 + num2, num1 — num2, num1 * num2 # для так называемой распаковки нескольких значений # их следует присвоить равному количеству аргументов res1, res2, res3 = calculate(7, 6) print(res1, res2, res3) > 13 1 42 print(type(calculate(7, 6)))

☝️ Обратите внимание, что количество возвращаемых значение в кортеже должно совпадать с количеством переменных при распаковке. Иначе произойдет ошибка:

def calculate(num1, num2): return num1 + num2, num1 — num2 # для так называемой распаковки нескольких значений # их следует присвоить равному количеству аргументов res1, res2, res3 = calculate(7, 6) print(res1, res2, res3) > ValueError: not enough values to unpack (expected 3, got 2)

Пустая функция

Иногда разработчики оставляют реализацию на потом, и чтобы объявленная функция не генерировала ошибки из-за отсутствия тела, в качестве заглушки используется ключевое слово pass :

Чистые функции и побочные эффекты

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

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

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

Lambda функции

Кроме инструкции def в питоне можно создавать объекты функций в виде выражений. Так называемые анонимные функции создаются с помощью инструкции lambda . Чаще всего их применяют для получения встроенной функции или же для отложенного выполнения фрагмента программного кода.

lambda_test = lambda a, b: pow(a, b) print(lambda_test(2, 4)) > 16

Docstring

Документировать код — особое искусство. Оно существует параллельно с разработкой и сопоставимо с ней по важности. Поэтому нередко документации в программе больше, чем самого кода.

Когда над проектом работает большая команда, а может и не одна, да и еще и много лёт подряд, то значение и важность документации возрастают прямо пропорционально.

Как запустить def в python

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

my_function() 

Привет от Python 

А это пример простейшей функции с параметром:

def my_function(name): print(f'Привет, ') 

При вызове функция получает аргумент:

my_function('Вася') 

Привет, Вася 

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

def my_function(name, lastname): print(f'Добрый день, ') 

Если передать в функцию два аргумента – my_function(‘Егор’, ‘Куликов’) , результат вызова будет таким:

Добрый день, Егор Куликов 

Но если число аргументов окажется меньше числа параметров – my_function(‘Алена’) , возникнет ошибка:

 my_function('Алена') TypeError: my_function() missing 1 required positional argument: 'lastname' 

Больше полезных материалов вы найдете на нашем телеграм-канале «Библиотека питониста»

Порядок обработки позиционных аргументов

Python обрабатывает позиционные аргументы слева направо:

def my_function(name, last_name, occupation, age): print(f'Сотрудник #1 -   ') info1, info2, info3, info4 = 'Алиса', 'Селезнева', 'скрам-мастер', 30 my_function(info1, info2, info3, info4) my_function(info2, info3, info1, info4) my_function(info4, info1, info2, info3) 

Сотрудник #1 - Алиса Селезнева скрам-мастер 30 Сотрудник #1 - Селезнева скрам-мастер Алиса 30 Сотрудник #1 - 30 Алиса Селезнева скрам-мастер 

Аргументы по умолчанию

Функция может использовать аргументы по умолчанию – они указываются после позиционных:

def my_function(strt, build, ap, city='Москва'): print(f'Адрес: г., ул., д., кв.') my_function('Красная', '5', '3', 'Тула') my_function('Красная', '5', '3') Результат: Адрес: г.Тула, ул.Красная, д.5, кв.3 Адрес: г.Москва, ул.Красная, д.5, кв.3 

Именованные аргументы

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

def sales_price(price, discount=5): return price - price * discount / 100 print(sales_price(5000)) print(sales_price(5000, discount=10)) print(sales_price(discount=15, price=5000)) 

4750.0 4500.0 4250.0 

Произвольное количество позиционных аргументов *args

До сих пор мы передавали в функцию определенное, заранее известное число позиционных аргументов. Если в функцию нужно передать произвольное количество аргументов, используют * args :

def my_function(*args): print(f'Минимальное число: , максимальное: ') my_function(1, 4, 5, 2, -5, 0, 12, 11) 

Минимальное число: -5, максимальное: 12 

При использовании *args функция получает кортеж аргументов, и к ним можно обращаться так же, как к элементам кортежа:

def my_function(*args): print(f'Первое слово: , последнее слово: ') my_function('яблоко', 'виноград', 'апельсин', 'арбуз', 'слива', 'груша') 

Первое слово: яблоко, последнее слово: груша 

Название набора параметров, * args , используется по умолчанию. При желании его можно изменить на любое другое название с * в начале:

def my_function(*cities): print(f'Первый город: , третий город: ') my_function('Тюмень', 'Москва', 'Орел', 'Новгород', 'Ижевск', 'Ульяновск') 

Первый город: Тюмень, третий город: Орел 

Аргументы *args обрабатываются после позиционных, но до аргументов по умолчанию:

def my_function(x, y, *args, kx=15, ky=15): print(x, y, args, kx, ky) my_function(5, 6, 7, 8, 9, 0, 4) 

5 6 (7, 8, 9, 0, 4) 15 15 

Произвольное количество именованных аргументов **kwargs

Как уже было отмечено выше, именованные аргументы передаются в функцию в виде пар ключ=значение :

def my_function(cat1, cat2, cat3): print(f'Младший кот: , старший кот: ') my_function(cat1='Том', cat2='Барсик', cat3='Полосатик') 

Младший кот: Том, старший кот: Барсик 

В приведенном выше примере количество именованных аргументов известно заранее. Если в функцию нужно передать произвольное количество пар ключ=значение , используют параметр ** kwargs . С **kwargs работают все методы словарей:

def my_function(**kwargs): print(f'Самый легкий металл - , самый тяжелый - ') my_function(осмий=22.61, цинк=7.1, золото=19.3, ртуть=13.6, олово=7.3) 

Самый легкий металл - цинк 7.1, самый тяжелый - осмий 22.61 

Как и в случае с * args , название по умолчанию ** kwargs при желании можно заменить на любое другое с ** в начале:

def my_function(**countries): print(f'Самая густонаселенная страна -  чел/км2, самая малонаселенная -  чел/км2') my_function(Мальта=1432, Дания=128, Монако=18679, Индия=357, Монголия=2) 

Самая густонаселенная страна - Монако 18679 чел/км2, самая малонаселенная - Монголия 2 чел/км2 

Аргументы типа **kwargs обрабатываются после позиционных, *args и аргументов по умолчанию:

def my_function(x, y, *args, kx=15, ky=15, **kwargs): print(x, y, args, kx, ky, kwargs) my_function(7, 8, 0, 3, 4, 1, 8, 9, север=15, запад=25, восток=45, юг=10) 

 7 8 (0, 3, 4, 1, 8, 9) 15 15

Передача аргументов в виде списка

Помимо кортежей и словарей, в функции можно передавать списки:

def my_function(stationery): for i, j in enumerate(stationery): print(f'Товар # - ') stuff = ['карандаш', 'ручка', 'блокнот', 'альбом', 'тетрадь', 'ластик'] my_function(stuff) 

Товар #1 - карандаш Товар #2 - ручка Товар #3 - блокнот Товар #4 - альбом Товар #5 - тетрадь Товар #6 - ластик 

Заглушка pass

Тело функции не может быть пустым – это приведет к сообщению об ошибке:

def my_function(): Вывод: def my_function(): ^ SyntaxError: unexpected EOF while parsing 

Если по какой-то причине нужно оставить тело функции пустым, используют оператор pass , который выступает в роли заглушки:

def my_function(): pass 

Функции с возвратом значений

Как уже было показано выше, функции могут получать и обрабатывать любые типы данных – строки, числа, списки, кортежи, словари. Результат обработки можно получить с помощью оператора return . Эта функция возвращает произведение произвольного количества значений:

def my_function(*args): prod = 1 for i in args: prod *= i return prod print(my_function(5, 6, 3, 11)) 

Значения передаются в функцию при вызове – print(my_function(5, 6, 3, 11)) . Результат при таком наборе цифр будет равен 990 . Оператор return может возвращать любое количество значений, причем значения возвращаются в виде кортежа:

def calculations(a, b): summa = a + b diff = a - b mul = a * b div = a / b return summa, diff, mul, div num1, num2 = int(input()), int(input()) summa, diff, mul, div = calculations(num1, num2) print( f'Сумма: \n' f'Разница: \n' f'Произведение: \n' f'Результат деления: \n' ) 

49 6 

Сумма: 55 Разница: 43 Произведение: 294 Результат деления: 8.17 

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

def bmi(h, w): bmi = w / (h / 100) ** 2 if bmi  

Введите рост в см: 172 Введите вес в кг: 61 

Вес в норме 

def bmi(h, w): bmi = w / (h / 100) ** 2 if bmi  

def draw_triangle(size, symb): for i in range(1, size + 1): print(symb * min(i, size - i + 1)) size, symb = int(input()), input() draw_triangle(size, symb) 

print(arith_mean(5, 5, 15, 25, 35)) 

def arith_mean(*args): summa = 0 kol = 0 for i in args: summa += i kol += 1 return summa / kol 

23edwd893rjf934#$%Ye34F^(*))_+W$#Ddq2ddscew3r 

2 3 8 9 3 9 3 4 3 4 2 3 e d w d r j f Y e F W D d q d d s c e w r # $ % ^ ( * ) ) _ + $ # 

def sort_list(st): digits = [i for i in st if i.isdigit()] letters = [i for i in st if i.isalpha()] spec_char = [i for i in st if not i.isalnum()] print(*digits) print(*letters) print(*spec_char) my_st = input() sort_list(my_st) 

ny_bonus('Алина', 'Тимофеева', salary=150000, bonus=25) ny_bonus('Алексей', 'Ковалев', bonus=15) ny_bonus('Игорь', 'Ефимов') ny_bonus('Анастасия', 'Яковлева', salary=100000, bonus=20) 

Новогодняя премия сотрудника Алина Тимофеева: 37500.00 руб. Оклад: 150000.00 руб. Всего к выдаче: 187500.00 руб. Новогодняя премия сотрудника Алексей Ковалев: 18000.00 руб. Оклад: 120000.00 руб. Всего к выдаче: 138000.00 руб. Новогодняя премия сотрудника Игорь Ефимов: 12000.00 руб. Оклад: 120000.00 руб. Всего к выдаче: 132000.00 руб. Новогодняя премия сотрудника Анастасия Яковлева: 20000.00 руб. Оклад: 100000.00 руб. Всего к выдаче: 120000.00 руб. 

def ny_bonus(name, last_name, salary=120000, bonus=10): print(f'Новогодняя премия сотрудника : руб.\n' f'Оклад: руб.\n' f'Всего к выдаче: руб.\n') 

5 7 8 9 34 28 

Есть 

def perfect_number(n): sum = 0 for i in range(1, n): if n % i == 0: sum += i return sum == n numbers = list(map(int, input().split())) flag = 'Нет' for i in numbers: if perfect_number(i): flag = 'Есть' break print(flag) 

12 5 

def factorial(num): if num  

двадцать пять 

def spell_number(num): ed = ['один', 'два', 'три', 'четыре', 'пять', 'шесть', 'семь', 'восемь', 'девять', 'десять', 'одиннадцать', 'двенадцать', 'тринадцать', 'четырнадцать', 'пятнадцать', 'шестнадцать', 'семнадцать', 'восемнадцать', 'девятнадцать'] des = ['двадцать', 'тридцать', 'сорок', 'пятьдесят', 'шестьдесят', 'семьдесят', 'восемьдесят', 'девяносто'] if num < 20: return ed[num - 1] elif num >= 20: if str(num)[1] != '0': return des[int(str(num)[0]) - 2] + ' ' + ed[int(str(num)[1]) - 1] return des[int(str(num)[0]) - 2] n = int(input()) print(spell_number(n)) 

03.06.2018 

True 

def magic_date(date): return int(date[:2]) * int(date[3:5]) == int(date[-2:]) date = input() print(magic_date(date)) 

print(make_query(category='books', genre='thriller', author='Stephen_King')) print(make_query(name='Егор', last_name='Тимохин', age=25, occupation='дизайнер' 

author=Stephen_King&category=books&genre=thriller age=25&last_name=Тимохин&name=Егор&occupation=дизайнер 

def make_query(**kwargs): return '&'.join([f'=' for k in sorted(kwargs)]) 

1 2 3 4 5 6 7 8 9 32 33 34 35 36 37 38 39 10 31 56 57 58 59 60 61 40 11 30 55 72 73 74 75 62 41 12 29 54 71 80 81 76 63 42 13 28 53 70 79 78 77 64 43 14 27 52 69 68 67 66 65 44 15 26 51 50 49 48 47 46 45 16 25 24 23 22 21 20 19 18 17 

def print_matrix(n): matrix = [[0] * n for i in range(n)] vx, vy = [0, 1, 0, -1], [1, 0, -1, 0] x, y, z = 0, -1, 1 for i in range(n + n - 1): for j in range((n + n - i) // 2): x += vx[i % 4] y += vy[i % 4] matrix[x][y] = z z += 1 for i in range(len(matrix)): for j in range(len(matrix[i])): print(str(matrix[i][j]).ljust(3), end='') print() print_matrix(int(input())) 

def Имя(аргументы): "Документация" Тело (инструкции) return [значение]

def print_sum(a = 2, b = 2): sum = a + b print(sum) return # вернёт None

# определяем функцию def print_sum(a = 2, b = 2): sum = a + b print(sum) #вызываем её print_sum(5, 1)

def sum(a = 2, b = 2): sum = a + b return sum # вернёт сумму c = sum(4, 3) # переменная c будет равна возвращаемому значению print(sum(5, 5)) # можно передать значения в аргументы другой функции

def example(first, second=3, third=5): print(first) print(second) print(third) example('my string', third=4)

my string 3 4

def variable_len(*args): for x in args: print(x) variable_len(1,2,3) # Выведет 1,2,3

def variable_len(**args): print(type(args)) for x, value in args.items(): print(x, value) variable_len(apple = "яблоко", bread = "хлеб") # Выведет apple яблоко bread хлеб

x = lambda arg1, arg2: arg1 * arg2 print(x(5,5)) # Выведет 25 print(x(3,5)) # Выведет 15

def x(n): a = [1,3] a = a * n return a print(x(2)) # выведет [1,3,1,3]

def example(): language = "python" version = 3 flag = True return language, version, flag language, version, flag = example() print(language, version, flag) # выведено будет python 3 True

def f(num): if num == 0: return 1 return f(num-1) * num print(f(5)) # Выведет число 120

def x(num): a = num - 1 print(a) x(a) x(5)

def example(): pass

val1 = "my global" val2 = "another global" def example(): print(val1) # Выведет my global global val2 val2 = "change another global" example() print(val2) # Выведет change another global