Улучшите свою игру Python, определив свои собственные функции
Вы когда-нибудь думали: «Хотел бы я, чтобы у Python была функция, которая выполняла ________». Заполнить бланк. Если да, то у меня отличные новости! Python дает вам возможность создавать свои собственные пользовательские функции. Вам нужно понять несколько вещей, но это не так уж и сложно. Итак, приступим.
Пользовательские функции - отличный способ красиво упаковать повторно используемые блоки кода. На самом базовом уровне для пользовательской функции требуется всего пять компонентов:
- Используйте ключевое слово def, чтобы начать определение функции.
- Назовите свою функцию.
- Укажите один или несколько параметров. На самом деле параметры необязательны, но скобки - нет. За ними следует двоеточие.
- Введите строки кода, которые заставят вашу функцию делать то, что она делает. Введите код, где # логика здесь показана в примере кода ниже.
- Используйте ключевое слово return в конце функции, чтобы вернуть результат. Это тоже необязательно. Если опущено, функция вернет None.
| def function_name (parameter_one, parameter_two, parameter_n): | |
| # logic here | |
| return |
Как видите, основа функции проста. Но давайте перестанем играть с теоретическим и создадим реальную функцию.
Имя функции
Каждой функции нужно имя. В противном случае у вас не будет возможности ссылаться на него в своем коде, когда вам нужно его использовать. Назовите свою функцию как-нибудь интуитивно понятным. Если цель вашей функции - суммировать все числа, которые вы отправляете в нее через список параметров, назовите ее add_nums () или sum_the_numbers (). Не называйте его s () или function1 (). Последние два варианта - плохой выбор. Помните, что код читается людьми.
Кроме того, после имени функции должны быть круглые скобки. Если вам не нужны никакие параметры, круглые скобки будут пустыми, но они должны присутствовать. Затем завершите строку определения двоеточием. Двоеточие указывает, что любые строки с отступом под этой строкой являются частью функции.
| def sum_the_numbers (): |
Параметры
После того, как вы назовете свою функцию, определите необходимые параметры. Параметры или аргументы используются для передачи соответствующих данных вашей функции. Сколько чисел может сложить функция? Если параметры не указаны, будут ли использоваться значения по умолчанию? Каков порядок аргументов?
Параметры вставляются в круглые скобки после имени функции. Они разделены запятыми. Опять же, используйте интуитивно понятные имена, чтобы вы могли легко вспомнить назначение каждого параметра.
Если наша функция будет складывать только два числа, мы можем создать два параметра, num1 и num2. Если мы изменим функцию, добавив три числа, мы можем добавить третий параметр, num3.
| def sum_the_numbers (num1, num2): |
Если вы решили присвоить параметрам значения по умолчанию, просто замените текущие имена параметров на num1 = 0 и num2 = 0. 0 следует заменить любым значением по умолчанию, которое вы хотите присвоить.
| def sum_the_numbers (num1 = 0, num2 = 0): |
Обычно, когда вы выполняете функцию, вы вызываете ее, используя строку кода, подобную sum_the_numbers (5, 3). Предоставляя значения по умолчанию, вы можете опустить один или несколько параметров в строке выполнения кода, и функция все равно будет выполняться, только с использованием значений по умолчанию.
Логика
Теперь давайте добавим к функции немного логики. Это то, что заставляет функцию складывать числа. Этот раздел может быть коротким, если вы выполняете простую задачу, например, складываете два числа. Или у вас могут быть сотни строк кода в этой части для более сложной задачи. Помните, что все строки кода, включенные как часть функции, должны иметь отступ, как строка total = num1 + num2 ниже.
| def sum_the_numbers (num1 = 0, num2 = 0): | |
| total = num1 + num2 |
Вернуть значение
Теперь, когда ваш код выполнил предписанную работу, вам может потребоваться, а может и не потребоваться возвращать значение процессу, который вызвал вашу функцию. Если вам не нужно возвращать значение, вы можете опустить инструкцию return. Однако в этом примере функции нам нужно вернуть сумму. Строка - это общая сумма возврата.
| def sum_the_numbers (num1 = 0, num2 = 0): | |
| total = num1 + num2 | |
| return total |
Оператор return отправляет все сохраненное значение обратно в раздел кода, в котором эта функция была выполнена. Обычно у вас есть переменная для хранения возвращаемого значения. Например, суммирование = сумма_числов (5, 3). Значение, возвращаемое функцией, будет сохранено в переменной суммирование. Теперь, когда у нас есть все необходимые компоненты для успешного выполнения нашей функции, давайте посмотрим, как мы выполняем ее в сегменте кода.
Выполнение функции
Всякий раз, когда мы выполняем пользовательскую функцию, мы используем имя функции с любыми необходимыми параметрами. Если функция возвращает значение, мы обычно что-то делаем с ее выводом. Мы можем распечатать его, сохранить в переменной или отправить в другую функцию. Предполагая, что мы собираемся сохранить вывод в переменной, выполнение нашей функции может выглядеть примерно так, как в приведенном ниже коде.
| summation = sum_the_numbers (10, 5) |
Если мы решим печатать возвращаемое значение прямо на экран, мы можем использовать вместо этого этот код.
| print(sum_the_numbers (10, 5)) |
Помните, что при вызове функции аргументы должны предоставляться в том же порядке, в котором они указаны в определении функции: num1, за которым следует num2. Однако, если вы забыли порядок, вы можете изменить его, указав ключевые слова аргумента при выполнении функции. При использовании ключевых слов аргументов команда будет выглядеть примерно так: sum_the_numbers (num2 = 5, num1 = 10).
| summation = sum_the_numbers (num2=5, num1=10) |
Неопределенное количество параметров
Я уверен, что вы уже заметили проблему с нашим дизайном. Каждый раз, когда мы хотим добавить больше чисел, нам требуется добавить еще один параметр. Но есть способ обрабатывать бесконечное количество параметров в вашей функции. Вместо того, чтобы перечислять каждое имя параметра в круглых скобках в определении функции, используйте метод * args.
| def sum_the_numbers (*args): | |
| total = 0 | |
| for num in args: | |
| total += num | |
| return total |
Когда * следует за именем параметра, это означает, что в функцию может быть передано любое количество параметров. Это создаст список значений параметров. Вы просто распаковываете список аргументов в функции. Это небольшое изменение в нашей функции сделало ее более универсальной.
Собираем все вместе
Часто определяемая пользователем функция и исполняющий ее код находятся в одном скрипте Python. В нашем примере весь сценарий будет выглядеть так.
| def sum_the_numbers (*args): # define our function | |
| total = 0 # set initial total to zero | |
| for num in args: # loop through each value | |
| total += num # add each value to the total | |
| return total # return the summed total | |
| summation = sum_the_numbers(5, 10) # execute our function | |
| print(summation) # print the total |
Стандартные пользовательские функции просты в использовании, но являются очень мощным инструментом для разработчика. Конечно, пользовательские функции не ограничиваются этим стандартным подходом. Если вы покупаете что-то в Интернете или в ночном рекламном ролике, вы ожидаете получить еще больше за свои 19,95 доллара. То же самое и с пользовательскими функциями.
Анонимные функции
Если вам нравятся стандартные пользовательские функции, вам понравятся анонимные пользовательские функции. Эти функции написаны inline там, где они вам нужны, без имени и без надлежащего синтаксиса определения. Эти функции также называются функциями понимания или лямбда-функциями.
В этом примере представьте, что наш сценарий такой же, как и выше. Нам нужна функция, способная складывать два числа. Вместо нашей функции sum_the_numbers мы можем использовать лямбда-функцию.
| answer = lambda num1, num2: num1 + num2 | |
| print(answer(5, 10)) |
Лямбда - это ключевое слово Python, используемое для определения этих функций вместо def. Поэтому их часто называют лямбда-функциями.
В этом примере нашей лямбда-функции мы определили ответы переменной как саму функцию. Затем мы просто передаем необходимые параметры при обращении к имени переменной. Результатом является анонимная функция, замаскированная под динамическую переменную.
Вкратце, синтаксис анонимных функций - список_связанных_аргументов: выражение.
Давайте сделаем еще один шаг вперед в нашем примере и представим, что сценарий начинается со списка чисел. Нам нужно создать новый список чисел, возведя в квадрат каждое число из нашего первого списка. Мы могли бы создать стандартную определяемую пользователем функцию для этого, как делали выше. Но вместо этого мы решили использовать анонимную функцию.
Для перебора списка мы используем функцию карты Python. Функция карты принимает два аргумента. Первый - это функция. В этом случае это будет анонимная функция. Второй параметр - это некоторые повторяющиеся данные, например список чисел, которые мы хотим возвести в квадрат. Функция карты примет каждый элемент в итерируемом объекте, прогонит его через указанную функцию и добавит вывод в новую итеративную структуру данных.
| numbers = [1,2,3,4,5] | |
| squared_numbers = list(map(lambda number: number ** 2, numbers)) |
Функция list () в этом коде преобразовала итеративный вывод функции карты по умолчанию, объект карты, в список Python. List намного проще использовать в остальной части нашего кода.
Опять же, вы можете видеть, что наш лямбда-код относительно короткий по сравнению со стандартным подходом, используемым ниже.
| def square_the_numbers (numbers_to_square): | |
| the_squared_numbers = [] | |
| for number in numbers_to_square: | |
| the_squared_numbers.append(number ** 2) | |
| return the_squared_numbers | |
| numbers = [1,2,3,4,5] | |
| squared_numbers = square_the_numbers(numbers) | |
Заключение
Выделите время, необходимое для изучения того, как реализовать пользовательские функции в Python. Они сильны. Они создают повторно используемые блоки кода. Они помогают организовать ваш код. И они абсолютно необходимы, если вы начинаете использовать методы объектно-ориентированного программирования. Пользовательские функции - необходимый инструмент в репертуаре современного разработчика.
