Python — functions

Функция в Python

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

Напишем функцию, которая вычисляет квадрат своего аргумента и выводит на экран:

>>> def square(number):
…     «»»Вычисление квадрата числа»»»
…     (number 2)
…
>>> square(5)25
>>> square(124.45)15487.802500000002

Определение функции начинается с ключевого слова def, за которым следует имя функции — square. Имя функции, как и имена переменных рекомендуется писать с букв нижнего регистра, а в именах, состоящих из нескольких слов, составляющие должны разделяться символами подчеркивания. Далее в круглых скобках записываются параметры (аргументы) функции, разделенные запятыми. Функция square имеет только один аргумент с именем number — значение, возводимое в квадрат. В случае отсутствия параметров у функции пустые круглые скобки обязательны. В конце строки за параметрами всегда ставится двоеточие ().

После двоеточия новая строка должна идти с отступом (4 пробела). Все строки с отступом образуют тело или блок функции. В «Руководстве по стилю кода Python» указано, что первой строкой блока функции должна быть doc-строка, кратко поясняющая назначение функции: «»»Вычисление квадрата числа»»». Сам код в теле функции состоит всего из одной строки (number 2).

Команда squre(5) вызывает функции square() и передает ей значение аргумента, для выполнения команды . Функция возводит число в квадрат и выводит на экран. 

Создание

Python предоставляет ключевое слово def для определения функции. Синтаксис функции определения приведен ниже.

Синтаксис:

def my_function(parameters):
      function_block
return expression

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

• Ключевое слово def вместе с именем функции используется для определения функции.
• Правило идентификатора должно следовать за именем функции.
• Функция принимает параметр(аргумент), и они могут быть необязательными.
• Функциональный блок начинается с двоеточия(:), и операторы блока должны иметь такой же отступ.
• Оператор return используется для возврата значения. Функция может иметь только один возврат.

Модуль functools

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

reduce()

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

С помощью можно делать так:

lru_cache

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

update_wrapper

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

wraps

wraps — это ещё один декоратор. Он применяется к функции-обертке. wraps обновляет функцию-обертку так, чтобы она выглядела как оборачиваемая функция. При этом копируются атрибуты и .

Метод 1: Используйте атрибут __name__

Самый питонический способ извлечения имени от любого объекта или класса – использовать его атрибут. Атрибуты, заключенные в двойной подчеркивании (атрибуты Dunder), предоставляют специальные функциональные возможности для программистов Python. Например, звонок дает строковое значение Отказ

def your_function():
    pass


string_name = your_function.__name__

print(string_name)
# your_function

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

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

Поэтому вы можете создать два имени и Это оба указывают на один и тот же объект функции. При звонке Результат может быть вместо что ты ожидал.

Это демонстрируется в следующем минимальном примере:

def func_2():
    pass

func_1 = func_2
print(func_1.__name__)
# func_2

Как оба имена указывают на тот же объект памяти, но Во-первых, указывал на это имя объекта Отказ Использование памяти этого кода визуализируется с помощью инструмента Python Reputor:

Обе переменные относятся к тому же объекту функции, которые по умолчанию как имя.

Calling a Function

Defining a function only gives it a name, specifies the parameters that are to be included in the function and structures the blocks of code.

Once the basic structure of a function is finalized, you can execute it by calling it from another function or directly from the Python prompt. Following is the example to call printme() function −

#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;

# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

When the above code is executed, it produces the following result −

I'm first call to user defined function!
Again second call to the same function

Сравнение функции с методом

• Функция Python является частью файла сценария Python, в котором она определена, тогда как методы определены внутри определения класса.
• Мы можем вызвать функцию напрямую, если она находится в том же модуле. Если функция определена в другом модуле, мы можем импортировать модуль, а затем вызвать функцию напрямую. Нам нужен класс или объект класса для вызова методов.
• Функция Python может обращаться ко всем глобальным переменным, тогда как методы класса Python могут обращаться к глобальным переменным, а также к атрибутам и функциям класса.
• Тип данных функций Python — это «функция», а тип данных методов Python — «метод».

Давайте посмотрим на простой пример функций и методов в Python.

class Data:
    def foo(self):
        print('foo method')


def foo():
    print('foo function')


# calling a function
foo()

# calling a method
d = Data()
d.foo()

# checking data types
print(type(foo))
print(type(d.foo))

Вывод:

foo function
foo method
<class 'function'>
<class 'method'>

Преимущества

• Возможность повторного использования кода, потому что мы можем вызывать одну и ту же функцию несколько раз
• Модульный код, поскольку мы можем определять разные функции для разных задач
• Улучшает ремонтопригодность кода
• Абстракция, поскольку вызывающему абоненту не нужно знать реализацию функции

Required Arguments

Required arguments are the arguments passed to a function in correct positional order. Here, the number of arguments in the function call should match exactly with the function definition.

To call the function printme(), you definitely need to pass one argument, otherwise it gives a syntax error as follows −

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme()

When the above code is executed, it produces the following result −

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Pass by reference vs value

All parameters (arguments) in the Python language are passed by reference. It means if you change what a parameter refers to within a function, the change also reflects back in the calling function. For example −

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append();
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = ;
changeme( mylist );
print "Values outside the function: ", mylist

Here, we are maintaining reference of the passed object and appending values in the same object. So, this would produce the following result −

Values inside the function:  ]
Values outside the function:  ]

There is one more example where argument is being passed by reference and the reference is being overwritten inside the called function.

#!/usr/bin/python

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = ; # This would assig new reference in mylist
   print "Values inside the function: ", mylist
   return

# Now you can call changeme function
mylist = ;
changeme( mylist );
print "Values outside the function: ", mylist

The parameter mylist is local to the function changeme. Changing mylist within the function does not affect mylist. The function accomplishes nothing and finally this would produce the following result −

Values inside the function:  
Values outside the function:  

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

Функции могут вызываться в циклах while где угодно. Приведем пример цикла while, где у посетителя запрашивают имя и фамилию, а с помощью функции form_name возвращается отформатированное имя и фамилия с приветствием:

def form_name(first_name, last_name):
    «»»Возвращает отформатированное полное имя»»»
    full_name = «{first_name} {last_name}»
    return full_name.

while True:
    print(«Введите ‘x’ если хотите завершить программу»)
    first_name = («Введите ваше имя: «)
     first_name == ‘x’:
        break
    last_name = («Введите вашу фамилию: «)
     last_name == ‘x’:
        break
    formatted_name = form_name(first_name, last_name)
    print(«Добрый день {formatted_name}!»)

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

Генерация случайных чисел (модуль random)

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

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

random.random() - случайное число от 0 до 1.

random.randint(A, B) - случайное целое число N, A ≤ N ≤ B.

random.shuffle(list) перемешивает список случайным образом

random.choice(list) возвращает один случайный элемент из списка

Примеры

Функцияrandom.random()случайное число от 0 до 1.

import randomnumber = random.random()  # значение от 0.0 до 1.0print(number)number = random.random() * 100  # значение от 0.0 до 100.0print(number)

Функция    random.randint(A, B) — случайное целое число N, A ≤ N ≤ B

import randomnumber = random.randint(20, 35)  # значение от 20 до 35print(number)

функция random.shuffle(list) перемешивает список случайным образом

import randomnumbers =    # списокrandom.shuffle(numbers)print('numbers shuffle:',numbers)

Результат работы программы:

numbers shuffle:

функция  random.choice(list) возвращает один случайный элемент из списка

numbers =  random_number = random.choice(numbers)print('random_number:', random_number)

The return Statement

The statement return exits a function, optionally passing back an expression to the caller. A return statement with no arguments is the same as return None.

All the above examples are not returning any value. You can return a value from a function as follows −

#!/usr/bin/python

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total 

When the above code is executed, it produces the following result −

Inside the function :  30
Outside the function :  30

Scope and Lifetime of variables

Scope of a variable is the portion of a program where the variable is recognized. Parameters and variables defined inside a function are not visible from outside the function. Hence, they have a local scope.

The lifetime of a variable is the period throughout which the variable exists in the memory. The lifetime of variables inside a function is as long as the function executes.

They are destroyed once we return from the function. Hence, a function does not remember the value of a variable from its previous calls.

Here is an example to illustrate the scope of a variable inside a function.

Output

Value inside function: 10
Value outside function: 20

Here, we can see that the value of x is 20 initially. Even though the function changed the value of x to 10, it did not affect the value outside the function.

This is because the variable x inside the function is different (local to the function) from the one outside. Although they have the same names, they are two different variables with different scopes.

On the other hand, variables outside of the function are visible from inside. They have a global scope.

We can read these values from inside the function but cannot change (write) them. In order to modify the value of variables outside the function, they must be declared as global variables using the keyword .

Наследование класса в Python

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

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты brand и model»»»
        self.brand = brand
        self.model = model
        self.years = years
        self.mileage = 0

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years}»
        return name.title()

    def read_mileage(self):
        «»»Пробег автомобиля»»»
        print(f»Пробег автомобиля {self.mileage} км.»)

    def update_mileage(self, new_mileage):
        «»»Устанавливает новое значение пробега»»»
        self.mileage = new_mileage
    
    def add_mileage(self, km):
        «»»Добавляет пробег»»»
        self.mileage += km

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(«Мощность аккумулятора {self.battery_size} кВт⋅ч»)

Мы создали класс на базе класса. Имя класса-родителя в этом случае ставится в круглые скобки( class ElectricCar(Car) ). Метод __init__  в классе потомка (подклассе) инициализирует атрибуты класса-родителя и создает экземпляр класса . Функция super() .- специальная функция, которая приказывает Python вызвать метод __init__() родительского класса Car, в результате чего экземпляр ElectricCar получает доступ ко всем атрибутам класса-родителя. Имя super как раз и происходит из-за того, что класс-родителя называют суперклассом, а класс-потомок — подклассом.          

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

Создадим экземпляр класса  и сохраним его в переменную tesla_1

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())
tesla_1.battery_power()

При вызове двух методов мы получим:

Автомобиль Tesla Model X 2021
Мощность аккумулятора 100 кВт⋅ч

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

3.1. Переопределение методов класса-родителя

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

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(«Мощность аккумулятора {self.battery_size} кВт⋅ч»)

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years} {self.battery_size}-кВт⋅ч »
         name.
 

В результате при запросе полного названия автомобиля Python проигнорирует метод def get_full_name() в классе-родителя и сразу перейдет к методу def get_full_name() написанный в классе .          

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())

Автомобиль Tesla Model X 2021 100-Квт⋅Ч

Please enable JavaScript to view the comments powered by Disqus.

Область действия переменной — область видимости переменных

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

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

• Глобальные переменные
• Локальные переменные

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

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

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

Рассмотрим следующую функцию:

def func():
    a = []
    for i in range(5):
        a.append(i)

При вызове func() создается пустой список a, в него добавляется 5 элементов, а затем, когда функция завершается, список a уничтожается. Но допустим, что мы объявили a следующим образом:

a = []
def func():
    for i in range(5):
        a.append(i)

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

a = None

def bind_a_variable():
    global a
    a = []

bind_a_variable()
print a

Результат:

[]

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

def outer_function(x, y, z):
    def inner_function(a, b, c):
        pass
    pass

Здесь функция inner_function не существует, пока не вызвана функция outer_function. Как только outer_function завершает выполнение, inner_function уничтожается.

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

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

Операции над словарями Python

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

Во-первых, мы используем ключи, хранящиеся в lowscores, для создания нового словаря. Чтобы сделать это, есть два способа: первый — извлекаем только соответствующие элементы из исходного словаря с помощью метода .get(), оставляя исходный словарь без изменений. Второй — использовать метод .pop(), который удаляет извлеченные записи из исходного словаря.

Код для подмножества может выглядеть следующим образом: subset = dict(). Такое написание может показаться незнакомым, потому что цикл задан одной строкой кода. Этот стиль называется «генерацией словаря». На самом деле это цикл for, который перебирает элементы lowscores, извлекает значения из отзывов и использует их для заполнения нового словаря.

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

# Метод с использованием цикла for для создания подмножества словаря
forloop = {}
for k in lowscores:
  forloop = reviews
# Добавляем специальный метод извлечения релевантных элементов из словаря `reviews`
dictcomp = {k : reviews.___(k) for k in lowscores}
# Удостоверимся, что эти объекты аналогичны
print(forloop == ________)

Предположим, что теперь вы хотите изменить словарь Python 3, чтобы оценки выступали в качестве ключей словаря, а не идентификаторов. Можно использовать для этого цикл for, указав как ключи, так и значения, и создав новый вложенный словарь. Нужно будет извлечь «score» из исходного вложенного словаря, чтобы использовать его в качестве нового ключа.

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

from collections import defaultdict
scoredict = defaultdict(list)
for key, value in reviews.items():
  newvalues = {'id' : key, "title" : value, "review" : value}
  # Используем 'score' из значений (!) из исходного словаря в качестве ключей для только что созданного  словаря
  scoredict].append(newvalues)

# Выводим ключи словаря, чтобы удостовериться, что это на самом деле оценки из отзывов
print(scoredict.keys())

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

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

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

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

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

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

Характеристики списков

Список имеет следующие характеристики:

• Списки упорядочены.
• Доступ к элементу списка можно получить по индексу.
• Списки являются изменяемыми типами.
• Список может хранить количество различных элементов.

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

 
a =  
b =  
a ==b 

Выход:

False 

Оба списка состояли из одних и тех же элементов, но второй список изменил позицию индекса 5-го элемента, что нарушает порядок списков. При сравнении списков возвращается false.

Списки поддерживают порядок элементов на протяжении всего существования. Вот почему это упорядоченный набор объектов.

 
a =  
b =  
a == b 

Выход:

True 

Давайте подробно рассмотрим пример списка.

 
emp =     
Dep1 =  
Dep2 =    
HOD_CS =    
HOD_IT =    
print("printing employee data...")   
print("Name : %s, ID: %d, Country: %s"%(emp,emp,emp))   
print("printing departments...")  
print("Department 1:\nName: %s, ID: %d\nDepartment 2:\nName: %s, ID: %s"%(Dep1,Dep2,Dep2,Dep2))   
print("HOD Details ....")   
print("CS HOD Name: %s, Id: %d"%(HOD_CS,HOD_CS))   
print("IT HOD Name: %s, Id: %d"%(HOD_IT,HOD_IT))   
print(type(emp),type(Dep1),type(Dep2),type(HOD_CS),type(HOD_IT)) 

Выход:

printing employee data... 
Name : John, ID: 102, Country: USA 
printing departments... 
Department 1: 
Name: CS, ID: 11 
Department 2: 
Name: IT, ID: 11 
HOD Details .... 
CS HOD Name: Mr. Holding, Id: 10 
IT HOD Name: Mr. Bewon, Id: 11 
<class 'list'> <class 'list'> <class 'list'> <class 'list'> <class 'list'> 

В приведенном выше примере мы создали списки, состоящие из сведений о сотрудниках и отделах, и напечатали соответствующие данные

Обратите внимание на приведенный выше код, чтобы лучше понять концепцию списка

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

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

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

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

Параметры и аргументы функции

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

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

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

Логический оператор OR

Давайте посмотрим на простой пример логического оператора OR.

x = 10
y = 20

if x > 0 or y > 0:
    print('At least one of x and y is positive number')

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

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

d1 = Data(10)
d2 = Data(20)

# The expressions are evaluated until it's required
if d1 or d2:
    print('At least one of d1 and d2 id is a positive number')
else:
    print('Both d1 and d2 id are negative')

Вывод:

Data bool method called
At least one of d1 and d2 id is a positive number

Обратите внимание, что метод __bool __() вызывается только один раз и, поскольку он оценивается как True, дальнейшие выражения не оцениваются. Давайте запустим еще один пример, в котором оба логических значения объекта данных возвращают False

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

d1 = Data(-10)
d2 = Data(-20)

if d1 or d2:
    print('At least one of d1 and d2 id is a positive number')
else:
    print('Both d1 and d2 id are negative')

Вывод:

Data bool method called
Data bool method called
Both d1 and d2 id are negative

Наконец, на изображении ниже изображена блок-схема логического оператора или оператора.

Типы

В Python есть два типа функций.

1. встроенные: функции, предоставляемые языком Python, такие как print (), len (), str () и т. д.
2. пользовательские: функции, определенные нами в программе Python.

Может ли функция иметь значение параметра по умолчанию?

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

def hello(year=2019):
    print(f'Hello World {year}')


hello(2020)  # function parameter is passed
hello()  # function parameter is not passed, so default value will be used

Вывод:

Hello World 2020
Hello World 2019

Можем ли мы иметь несколько операторов возврата внутри функции?

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

def odd_even_checker(i):
    if i % 2 == 0:
        return 'even'
    else:
        return 'odd'


print(odd_even_checker(20))
print(odd_even_checker(15))

Может ли функция Python возвращать несколько значений одно за другим?

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

def return_odd_ints(i):
    x = 1
    while x <= i:
        yield x
        x += 2


output = return_odd_ints(10)
for out in output:
    print(out)

Вывод:

1
3
5
7
9

Ключевые аргументы

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

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

# Определение функции
def printinfo( name, age ):
   "This prints a passed info into this function"
   print("Name: " + name + "|Age: " + str(age))
   return

# Вызов функции printinfo
printinfo( age=23, name="Anton" )
printinfo( name="Alena", age=20 )

Результат:

Name: Anton|Age: 23
Name: Alena|Age: 20

Преимущества ключевых аргументов в функциях

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

Global vs. Local variables

Variables that are defined inside a function body have a local scope, and those defined outside have a global scope.

This means that local variables can be accessed only inside the function in which they are declared, whereas global variables can be accessed throughout the program body by all functions. When you call a function, the variables declared inside it are brought into scope. Following is a simple example −

#!/usr/bin/python

total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;

# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total 

When the above code is executed, it produces the following result −

Inside the function local total :  30
Outside the function global total :  0

Previous Page
Print Page

Next Page  

Аргументы в функции

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

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

Пример 1.

#defining the function  
def func(name):  
    print("Hi ",name) 
#calling the function   
func("Devansh")   

Выход:

Hi Devansh

Пример 2.

#Python function to calculate the sum of two variables   
#defining the function  
def sum(a,b):  
    return a+b;  
  
#taking values from the user  
a = int(input("Enter a: "))  
b = int(input("Enter b: "))  
  
#printing the sum of a and b  
print("Sum = ",sum(a,b))  

Выход:

Enter a: 10
Enter b: 20
Sum =  30