Как несколько раз вызвать функцию в python

Как несколько раз вызвать функцию в python

Напомним, что в математике факториал числа n определяется как Например, Ясно, что факториал можно легко посчитать, воспользовавшись циклом for. Представим, что нам нужно в нашей программе вычислять факториал разных чисел несколько раз (или в разных местах кода). Конечно, можно написать вычисление факториала один раз, а затем используя Copy-Paste вставить его везде, где это будет нужно.

# вычислим 3! res = 1 for i in range(1, 4): res *= i print(res) # вычислим 5! res = 1 for i in range(1, 6): res *= i print(res)

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

Функции — это такие участки кода, которые изолированы от остальный программы и выполняются только тогда, когда вызываются. Вы уже встречались с функциями sqrt(), len() и print(). Они все обладают общим свойством: они могут принимать параметры (ноль, один или несколько), и они могут возвращать значение (хотя могут и не возвращать). Например, функция sqrt() принимает один параметр и возвращает значение (корень числа). Функция print() принимает переменное число параметров и ничего не возвращает.

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

def factorial(n): res = 1 for i in range(1, n + 1): res *= i return res print(factorial(3)) print(factorial(5))

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

Далее идет тело функции, оформленное в виде блока, то есть с отступом. Внутри функции вычисляется значение факториала числа n и оно сохраняется в переменной res. Функция завершается инструкцией return res, которая завершает работу функции и возвращает значение переменной res.

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

Приведём ещё один пример. Напишем функцию max(), которая принимает два числа и возвращает максимальное из них (на самом деле, такая функция уже встроена в Питон).

10 20

def max(a, b): if a > b: return a else: return b print(max(3, 5)) print(max(5, 3)) print(max(int(input()), int(input())))

Теперь можно написать функцию max3(), которая принимает три числа и возвращает максимальное их них.

def max(a, b): if a > b: return a else: return b def max3(a, b, c): return max(max(a, b), c) print(max3(3, 5, 4))

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

def max(*a): res = a[0] for val in a[1:]: if val > res: res = val return res print(max(3, 5, 4))

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

2. Локальные и глобальные переменные

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

def f(): print(a) a = 1 f()

Здесь переменной a присваивается значение 1, и функция f() печатает это значение, несмотря на то, что до объявления функции f эта переменная не инициализируется. В момент вызова функции f() переменной a уже присвоено значение, поэтому функция f() может вывести его на экран.

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

Но если инициализировать какую-то переменную внутри функции, использовать эту переменную вне функции не удастся. Например:

def f(): a = 1 f() print(a)

Получим ошибку NameError: name ‘a’ is not defined . Такие переменные, объявленные внутри функции, называются локальными. Эти переменные становятся недоступными после выхода из функции.

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

def f(): a = 1 print(a) a = 0 f() print(a)

Будут выведены числа 1 и 0. Несмотря на то, что значение переменной a изменилось внутри функции, вне функции оно осталось прежним! Это сделано в целях “защиты” глобальных переменных от случайного изменения из функции. Например, если функция будет вызвана из цикла по переменной i , а в этой функции будет использована переменная i также для организации цикла, то эти переменные должны быть различными. Если вы не поняли последнее предложение, то посмотрите на следующий код и подумайте, как бы он работал, если бы внутри функции изменялась переменная i.

def factorial(n): res = 1 for i in range(1, n + 1): res *= i return res for i in range(1, 6): print(i, '! = ', factorial(i), sep='')

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

5! = 1 5! = 2 5! = 6 5! = 24 5! = 120

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

Более формально: интерпретатор Питон считает переменную локальной для данной функции, если в её коде есть хотя бы одна инструкция, модифицирующая значение переменной, то эта переменная считается локальной и не может быть использована до инициализации. Инструкция, модифицирующая значение переменной — это операторы = , += , а также использование переменной в качестве параметра цикла for . При этом даже если инструкция, модицифицирующая переменную никогда не будет выполнена, интерпретатор это проверить не может, и переменная все равно считается локальной. Пример:

def f(): print(a) if False: a = 0 a = 1 f()

Возникает ошибка: UnboundLocalError: local variable ‘a’ referenced before assignment . А именно, в функции f() идентификатор a становится локальной переменной, т.к. в функции есть команда, модифицирующая переменную a , пусть даже никогда и не выполняющийся (но интерпретатор не может это отследить). Поэтому вывод переменной a приводит к обращению к неинициализированной локальной переменной.

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

def f(): global a a = 1 print(a) a = 0 f() print(a)

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

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

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

def factorial(n): global f res = 1 for i in range(2, n + 1): res *= i f = res n = int(input()) factorial(n) # дальше всякие действия с переменной f

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

Гораздо лучше переписать этот пример так:

# начало куска кода, который можно копировать из программы в программу def factorial(n): res = 1 for i in range(2, n + 1): res *= i return res # конец куска кода n = int(input()) f = factorial(n) # дальше всякие действия с переменной f

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

return [a, b]

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

Как вызвать функцию n раз одноремено?

К примеру у меня есть функция, которая регистрируется на сайте, как вызвать 100 таких функций за раз?

• Вопрос задан более трёх лет назад
• 1834 просмотра

Комментировать
Решения вопроса 1

Говнокодер

for i in range(n): vzlom()

Ответ написан более трёх лет назад
d4c4237abc @d4c4237abc Автор вопроса

Да, проверил с datetime.now().microsecond

d4c4237abc, ну как одновременно? Не одновременно, поочерёдно, один вызов за другим. Просто чертовски быстро.

import asyncio tasks = [] async def vzlom(): chpok_pentagon(host=127.0.0.1).hack() async def main(): for i in range(100): task.append(asyncio.create_task(vzlom())) await asyncio.gather(*tasks) if __name__ == '__main__': asyncio.run(main())

Как сделать несколько return в одной функции в Python?

Функция в python может вернуть значение только один раз. Если нужно вернуть разные значения в зависимости от условий, то можно воспользоваться условной конструкцией if :

def function(): . if condition1: return result1 if condition2: return result2 

Также можно вернуть несколько значений одновременно в виде кортежа:

def function(): . return result1, result2 

Как вернуть сразу несколько значений из функции в Python 3

Сегодня мы делимся с вами переводом статьи, которую нашли на сайте medium.com. Автор, Vivek Coder, рассказывает о способах возврата значений из функции в Python и объясняет, как можно отличить друг от друга разные структуры данных.

Фото с сайта Unsplash. Автор: Vipul Jha

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

def hours_to_write(happy_hours): week1 = happy_hours + 2 week2 = happy_hours + 4 week3 = happy_hours + 6 return [week1, week2, week3] print(hours_to_write(4)) # [6, 8, 10]

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

Способ 1: возврат значений с помощью словарей

Словари содержат комбинации элементов, которые представляют собой пары «ключ — значение» ( key:value ), заключенные в фигурные скобки ( <> ).

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

people=

А теперь перейдем к функции, которая возвращает словарь с парами «ключ — значение».

# A Python program to return multiple values using dictionary # This function returns a dictionary def people_age(): d = dict(); d['Jack'] = 30 d['Kim'] = 28 d['Bob'] = 27 return d d = people_age() print(d) #

Способ 2: возврат значений с помощью списков

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

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

# A Python program to return multiple values using list def test(): str1 = "Happy" str2 = "Coding" return [str1, str2]; list = test() print(list) # ['Happy', 'Coding']

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

def natural_numbers(numbers = []): for i in range(1, 16): numbers.append(i) return numbers print(natural_numbers()) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

Способ 3: возврат значений с помощью кортежей

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

Кортежи напоминают списки, однако их нельзя изменить после того, как они были объявлены. А еще, как правило, кортежи быстрее в работе, чем списки. Кортеж можно создать, отделив элементы запятыми: x, y, z или (x, y, z) .

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

Bob = ("Bob", 7, "Google")

А вот пример написания функции для возврата кортежа.

# A Python program to return multiple values using tuple # This function returns a tuple def fun(): str1 = "Happy" str2 = "Coding" return str1, str2; # we could also write (str1, str2) str1, str2= fun() print(str1) print(str2) # Happy Coding

Обратите внимание: мы опустили круглые скобки в операторе return , поскольку для возврата кортежа достаточно просто отделить каждый элемент запятой (как показано выше).

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

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

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

def student(name, class): return (name, class) print(student("Brayan", 10)) # ('Brayan', 10)

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

Способ 4: возврат значений с помощью объектов

Тут все так же, как в C/C++ или в Java. Можно просто сформировать класс (в C он называется структурой) для сохранения нескольких признаков и возврата объекта класса.

# A Python program to return multiple values using class class Intro: def __init__(self): self.str1 = "hello" self.str2 = "world" # This function returns an object of Intro def message(): return Intro() x = message() print(x.str1) print(x.str2) # hello world

Способ 5: возврат значений с помощью классов данных (Python 3.7+)

Классы данных в Python 3.7+ как раз помогают вернуть класс с автоматически добавленными уникальными методами, модулем typing и другими полезными инструментами.

from dataclasses import dataclass @dataclass class Item_list: name: str perunit_cost: float quantity_available: int = 0 def total_cost(self) -> float: return self.perunit_cost * self.quantity_available book = Item_list("better programming.", 50, 2) x = book.total_cost() print(x) print(book) # 100 Item_list(name='better programming.', perunit_cost=50, quantity_available=2)

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

Вывод

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

Учите матчасть и постоянно развивайте свои навыки программирования. Спасибо за внимание!

• python 3
• python
• программирование для начинающих
• программирование
• функции
• data science

• Блог компании Plarium
• Python
• Программирование