Штирлиц — Сеть печатных салонов в Перми

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

Функции питона: Функции и их аргументы | Python 3 для начинающих и чайников

Содержание

Функции и их аргументы | Python 3 для начинающих и чайников

В этой статье я планирую рассказать о функциях, именных и анонимных, инструкциях def, return и lambda, обязательных и необязательных аргументах функции, функциях с произвольным числом аргументов.

Именные функции, инструкция def

Функция в python — объект, принимающий аргументы и возвращающий значение. Обычно функция определяется с помощью инструкции def.

Определим простейшую функцию:

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

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

Теперь мы ее можем вызвать:

>>> add(1, 10)
11
>>> add('abc', 'def')
'abcdef'

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

>>> def newfunc(n):
...     def myfunc(x):
...         return x + n
...     return myfunc
...
>>> new = newfunc(100)  # new - это функция
>>> new(200)
300

Функция может и не заканчиваться инструкцией return, при этом функция вернет значение None:

>>> def func():
. ..     pass
...
>>> print(func())
None

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

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

>>> def func(a, b, c=2): # c - необязательный аргумент
...     return a + b + c
...
>>> func(1, 2)  # a = 1, b = 2, c = 2 (по умолчанию)
5
>>> func(1, 2, 3)  # a = 1, b = 2, c = 3
6
>>> func(a=1, b=3)  # a = 1, b = 3, c = 2
6
>>> func(a=3, c=6)  # a = 3, c = 6, b не определен
Traceback (most recent call last):
  File "", line 1, in
    func(a=3, c=6)
TypeError: func() takes at least 2 arguments (2 given)

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

>>> def func(*args):
...     return args
...
>>> func(1, 2, 3, 'abc')
(1, 2, 3, 'abc')
>>> func()
()
>>> func(1)
(1,)

Как видно из примера, args — это кортеж из всех переданных аргументов функции, и с переменной можно работать также, как и с кортежем.

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

>>> def func(**kwargs):
...     return kwargs
...
>>> func(a=1, b=2, c=3)
{'a': 1, 'c': 3, 'b': 2}
>>> func()
{}
>>> func(a='python')
{'a': 'python'}

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

Анонимные функции, инструкция lambda

Анонимные функции могут содержать лишь одно выражение, но и выполняются они быстрее. Анонимные функции создаются с помощью инструкции lambda. Кроме этого, их не обязательно присваивать переменной, как делали мы инструкцией def func():

>>> func = lambda x, y: x + y
>>> func(1, 2)
3
>>> func('a', 'b')
'ab'
>>> (lambda x, y: x + y)(1, 2)
3
>>> (lambda x, y: x + y)('a', 'b')
'ab'

lambda функции, в отличие от обычной, не требуется инструкция return, а в остальном, ведет себя точно так же:

>>> func = lambda *args: args
>>> func(1, 2, 3, 4)
(1, 2, 3, 4)

Для вставки кода на Python в комментарий заключайте его в теги <pre><code>Ваш код</code></pre>

создать, вызвать, разные параметры и примеры аргументов

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

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

Синтаксис функций в Python

Любые функции и методы начинаются с инструкции def (от английского define — «определять»). За def в Python идет название функции, после — набор аргументов. Двоеточие в конце открывает блок тела функции, которое располагают с новой строки.

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

https://sky.pro/media/modul-requests-v-python/

Аргументы и их виды

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

🚀 Позиционные

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

def addfunc(val1, val2):
    return val1 + val2

result = addfunc(3, 2)
print(result)
5

addfunc() # вызов без аргументов
Traceback (most recent call last):
...
TypeError: addfunc() missing 2 required positional arguments: 'val1' and 'val2'

addfunc(1) # вызов с одним аргументом
Traceback (most recent call last):
...
TypeError: addfunc() missing 1 required positional argument: 'val2'

Когда вызывают функцию addfunc, то передают ей два обязательных аргумента. Они  будут доступны внутри тела функции и ассоциированы с переменными val1 и val2. Если этого не сделаете, получите ошибку TypeError.

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

def addconcat(*args):
    value = 0

    for item in args:
        if isinstance(item, (int, float)):
            value += item
        else:
            print(f"{item} is not a digit")

    return value

total = addconcat(1, "Hello", 2, 3, 4, "Python", 5.0, 6.25, 7.15, 'string')
Hello is not a digit
World is not a digit
string is not a digit

print("Total:", total)
Total: 28.4

Обращаются к позиционному аргументу такого множества с помощью операции индексации:

def demo_func(*args):
    try:
        print(args[0])
        print(args[1])
    except IndexError:
        pass

🚀 Именованные

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

def hey_concat(*args, name="World!"):
    print("Hey there,", name)

hey_concat()
Hey there, World!

hey_concat(name="Alex")
Hey there, Alex

Атрибуту name присвоили иное значение. Это поменяет результат склеивания строк и последующий вывод.

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

def print_kwargs(**kwargs):
    print(kwargs) # отобразит словарь

print_kwargs(kone="One", ktwo=2, kthree=3.0)
{'kone': 'One', 'ktwo': 2, 'kthree': 3.0}

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

def kwargs_addconcat(**kwargs):

    a = kwargs.
 
 
 get("a", None)
    b = kwargs.get("b", None)

    if not isinstance(a, type(b)):
        raise TypeError("Ошибка! Разные типы")

    if isinstance(a, str):
        return f"Результат конкатенации строк\n{a + b}"

    elif isinstance(a, int):
        return f"Результат сложения чисел\n{a + b}"

    return "Ошибка"


print(kwargs_addconcat(a=1, b=2))
Результат сложения чисел
3

print(kwargs_addconcat(a=1, b="World!"))
...
TypeError: Ошибка! Разные типы

print(kwargs_addconcat(a="Hello, ", b="World!"))
Результат конкатенации строк
Hello, World!

# Без аргументов
print(kwargs_addconcat())
Ошибка

В примере упаковываем именованные аргументы в переменную с названием

kwargs. Из нее в теле функции по ключам a и b пытаемся получить значения. А если они не найдутся — объект None. Далее проверяем наличие обоих аргументов и принадлежность одному типу данных. Затем возвращаем результат выполнения в зависимости от типа переданных параметров.

Еще можно комбинировать позиционные и именованные параметры. Сначала располагают позиционные (обязательные) аргументы. Сразу за ними идет переменная, в которую записывают все остальные параметры без явного ключа. Далее — именованные аргументы с предустановленным значением (значением по умолчанию). После него располагают переменную словаря с остальными именованными параметрами.

Общая форма последовательности:

def func(a, b, *args, name="Default", **kwargs):
    return None

Функции и области видимости

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

✈️ Глобальная

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

var1 = 12

def global_func():
    print(x)

Здесь целочисленный объект var1 и функция global_func — в глобальной области видимости.

✈️ Локальная

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

var1 = 2213 # глобальная переменная

# глобальная функция, использующая глобальную переменную
def func_one():
    print(var1)

# глобальная функция, использующая локальную переменную
def func_two():
    var1 = "Local value" # создание локальной переменной
    print(var1)

# функция, изменяющая значение глобальной переменной
def func_three():
    global var1
    var1 = "Local to global"

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

func_one()
2213

func_two()
Local value

func_three() # функция меняет значение глобальной переменной
func_one() # и результат функции func_one
Local to global

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

В Python есть ключевое слово nonlocal. Например, его применяют при создании декораторов. Оно указывает, что нужно использовать переменную уровнем выше, но при этом не относящуюся к глобальной области видимости.

Так реализуют декоратор счетчика вызова функции Python с этим ключевым словом:

def count_deco(wrapper_func):
    var = 0

    def inner():
        nonlocal var
        wrapper_func()
        var += 1
        print(var)
    return inner


@count_deco
def deco_demo():
    print("A few of example text...")


for _ in range(5):
    deco_demo()

A few of example text...
1
A few of example text. ..
2
A few of example text...
3
A few of example text...
4
A few of example text...
5

Lambda-функции (анонимные)

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

list_values = [1, 3, 4, 2, 6, 7, 5, 8, 9]
filter(lambda x : x % 2 == 0, list_values)
[2, 4, 6, 8]

Оператор возврата return

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

Если функция возвращает несколько объектов, они будут запакованы в кортеж (tuple). Тогда к конкретным элементам обращаются либо по индексу, либо с помощью распаковки множества, где каждый элемент присваивают отдельной переменной. Функция, где явно не указано возвращаемое значение, по умолчанию вернет объект типа None.

def arithmetics(x, y):
    return x + y, x - y, x * y, x / y, x // y

results = arithmetics(22, 3)

print(results)
(25, 19, 66, 7.333333333333333, 7)

print(results[0])
25

r1, r2, r3, r4, r5 = arithmetics(4, 4)

# результаты сложения и умножения
print(r1)
8

print(r3)
16

Оператор возврата yield

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

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

def gen_demo(times, var):
    for _ in range(times):
        yield var

gen_inst = gen_demo(25, "Gen demo text")

for _ in range(26):
    print(next(gen_inst))

Gen demo text
Gen demo text
Gen demo text
Gen demo text
. ..

Traceback (most recent call last):
...
StopIteration

[FAQ] Частые вопросы

Функции vs процедуры — в чём отличие?

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

Для чего нужна область видимости? 

Чтобы решить конфликт имен.

Как провести распаковку множества? 

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

Обязательно ли наличие аргументов для функции? 

Нет, но чаще у функции есть один или несколько аргументов.

Вебинары

Главное о функциях в Python

  • У каждой функции есть своя область видимости, в которую входят все пространства имен уровнем выше.
  • Если явно не задать возвращаемое значение, функция вернет объект типа None.
  • Функция с одной или несколькими инструкциями yield будет генератором.
  • В Python аргументы функции бывают двух видов — именованные и позиционные. Оба типа аргументов могут быть переменной длины.

Освойте профессию Python-разработчика за 10 месяцев в онлайн-университете Skypro. Вас ждет много практики в среде коммерческой разработки. Научитесь делать авторизацию, оплату, комментарии, фильтрацию и пользоваться библиотеками Python. Писать серверы для магазина, приложения или игры. Разрабатывать сложную архитектуру сервисов.

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

Функции Python — GeeksforGeeks

Функции Python — это блок операторов, которые возвращают конкретную задачу.

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

Синтаксис: Функции Python

 

Создание функции Python

Мы можем создать функцию Python, используя ключевое слово def .

Python3

 

def fun():

   print ( "Welcome to GFG" )

Calling a  Python Function

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

Python3

def fun():

     print ( "Welcome to GFG" )

 

 

fun()

Результат: 

 Добро пожаловать в GFG

Определение и вызов функции с параметрами

Если у вас есть опыт работы с C/C++ или Java, то вы должны думать о возвращает тип функции и тип данных аргументов. Это возможно и в Python (особенно для Python 3.5 и выше).

Синтаксис: Функция Python с параметрами

 def имя_функции (параметр: тип_данных) -> тип_возврата:
    """Строка документа"""
    # тело функции
    возвращаемое выражение

В следующем примере используются аргументы, которые вы узнаете позже в этой статье, поэтому вы можете вернуться к нему снова, если не поняли. Здесь он предназначен для людей, имеющих опыт работы с такими языками, как C/C++ или Java.

Python3

def add(num1: int , num2: int ) - > int :

    

     num3 = num1 + num2

 

     return num3

 

NUM1, NUM2 = 5 , 15

ANS = ADD (NUM1, NUM2) 131 (NUM1, NUM2) (NUM1, NUM2) (NUM1, NUM2). и {num2} Результаты {ans}. " )

Выход: 

 Добавление 5 и 15 результатов 20.

. Следующие примеры определены с использованием синтаксиса 1, попробуйте преобразовать их в синтаксис 2 для практики.

Python3

def is_prime(n):

     if n in [ 2 , 3 ]:

         return True

     if (n = = 1 ) or (n % 2 = = 0 ):

         return False

     r = 3

     while r * R < = N:

IF N % R = = R = = = = = = = = = = = = = . 0031 0 :

             return False

         r + = 2

     return True

print (is_prime ( 78 ), is_prime( 79 ))

Вывод:

5 True0014 Аргументы функции Python

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

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

Python3

def четныйНечетный(x):

9 0 3 9 0 3 9 0 9 0 3 1 9 0 0 30032 (x % 2 = = 0 ):

         print ( "even" )

     else :

         print ( "odd" )

 

 

evenOdd( 2 )

evenOdd( 3 )

Выход: 

 четный
нечетный

Типы аргументов

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

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

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

Python3

 

 

def myFun(x, y = 50 ):

     print ( "x: " , x)

     print ( "y: " , y)

 

 

myFun( 10 )

Выход 

 х: 10
y: 50

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

Аргументы ключевого слова

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

Python3

def student(firstname, lastname):

     print (firstname, lastname)

 

 

student(firstname = 'Geeks' , LastName = 'Практика' )

Студент (Lastname = 'Практика' , FirstName = 1 'Geeks' = 11111 ' ' 1 ' ' = 1 ' = 1' = 1 ' = . 0031 )

Выход 

 Практика гиков
Geeks Practice

Аргументы переменной длины

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

  • *args (аргументы, не являющиеся ключевыми словами)
  • **kwargs (аргументы ключевых слов)

Пример 1: Аргумент переменной длины, не являющийся ключевым словом

Python

7

 

 

def myFun( * argv):

     for arg in argv:

         print (arg

Myfun ( 'Hello' , 'Добро пожаловать' , ' , ' Geeks ' , ' Geeks. 0032 )

Выход 

 Привет
Добро пожаловать
к
GeeksforGeeks

Example 2: Variable length keyword arguments

Python3

 

 

def myFun( * * kwargs):

     for Ключ , значение в kwargs.items():

         print ( "%s == %s" % (key, value))

 

 

myFun(first = 'Geeks' , середина = 'для' , последняя = 'Geeks' )

Выход 

66699   
   
666669   
 . 
середина == для
last == Компьютерщики 
 Строка документации 
 Первая строка после функции называется строкой документа или сокращенно строкой документа. Это используется для описания функциональности функции. Использование docstring в функциях необязательно, но считается хорошей практикой.
 Для вывода строки документации функции можно использовать следующий синтаксис:
  Синтаксис:  print(имя_функции.__doc__) 
  Пример:  Добавление строки документации к функции
  Python3
7 9 00026
  
  
  def   evenOdd(x): 
       
         
         if   (x   %   2   =   =   0  ): 
    Печать   (  «даже»  ) 
    ELS  : 3130     : 0        : 0      : 0     : 0   . 0032  print   (   "odd"   ) 
  
  
  print   (evenOdd.__doc__) 
  Output 
 Function to check if the number is even или нечетное 
 Оператор возврата в функции Python 
 Оператор возврата функции используется для выхода из функции и возврата к вызывающей функции и возврата указанного значения или элемента данных вызывающей стороне.
  Синтаксис:   
 return [список_выражений] 
 Оператор return может состоять из переменной, выражения или константы, которая возвращается в конце выполнения функции. Если ничего из вышеперечисленного не присутствует в операторе return, возвращается объект None.
  Пример:  Оператор возврата функции Python
 Python3 
  def   Square_value(num): 
  3 
32 
       
         return   num   *   *   2 
  
  
  print   (square_value(   2   )) 
  print   (square_value(   -   4   )) 
  Выход 
 4
16 
 Передача по ссылке или передаче по значению 
 Важно отметить, что в Python каждое имя переменной является ссылкой. Когда мы передаем переменную в функцию, создается новая ссылка на объект. Передача параметров в Python аналогична передаче ссылок в Java.
 Python3 
  def   myFun(x): 
         x[   0   ]   =   20 
  
  
  lst   =   [   10   ,   11   ,   12   ,   13   ,   14   ,   15   ] 
  myFun( LST) 
  Печать   (LST) 
  Выход 
 [20, 11, 12, 13, 14, 15] 
, когда мы передаем ссылку и смените. что-то еще, связь между переданным и полученным параметром нарушена. Например, рассмотрим приведенную ниже программу следующим образом:
 Python3 
  def   myFun(x): 
  
       
       
       
         x   =   [   20   ,   30  ,   40  ] 
  LST   =   [  10  ,  [  10  ,  [  10  , .0032  11   ,   12   ,   13   ,   14   ,   15   ] 
  myFun(lst) 
  print   (lst) 
  Вывод 
 [10, 11, 12, 13, 14, 15] 
 Другой пример демонстрирует, что ссылка ссылки разрывается, если мы присваиваем новое значение (внутри функции).
 Python3 
  def   myFun(x): 
  
       
       
       
         x   =   20 
  
  
  x   =   10 
  Myfun (x) 
  Печать   (x) 
  Выход
 0004
 10 
  Упражнение:  Попробуйте угадать вывод следующего кода.
 Python3 
  def   swap(x, y): 
         temp   =   x 
         x   =   y 
    г   =   темп 
  
  
  x   =   2 
  y   =   3 
  swap(x, y) 
  print   (x) 
  print   (y) 
  Выход 
 2
3 
 В Python анонимная функция означает, что функция не имеет имени. Как мы уже знаем, ключевое слово def используется для определения обычных функций, а ключевое слово lambda — для создания анонимных функций. Подробности см. здесь.
 Python3 
  
  
  def   cube(x):   return   x   *   x   *   x 
  
  cube_v2   =   Lambda   x: x   *   x   *   x 
  Печать   (куб (  7 ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )0031 print   (cube_v2(   7   )) 
  Выход 
 343
343 
 Функция Python внутри функций 
 Функция, определенная внутри другой функции, называется внутренней функцией или вложенной функцией. Вложенные функции могут обращаться к переменным объемлющей области. Внутренние функции используются для того, чтобы их можно было защитить от всего, что происходит вне функции.
 Python3 
  
  def   f1(): 
         s   =   'I love GeeksforGeeks' 
         
         def   f2(): 
    Печать   (S) 
  
    F2 () 
  F1 () 9
  F1 () 9
  () 
  () 
  ()0048
  Выход 
 I Love Geeksforgeeks 
 Краткие связи: 
  •  ТРИЗИЧА НА СОБСТВЕННЫМИ 66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666 гг. .
 
 Функции Python [Полное руководство] — PYnative 
 В Python функция  представляет собой блок кода, определенный с именем  . Мы используем функции всякий раз, когда нам нужно выполнить одну и ту же задачу несколько раз без повторного написания одного и того же кода. Он может принимать аргументы и возвращать значение.
 В Python, как и в других языках программирования, используется принцип DRY. DRY означает «Не повторяйся». Рассмотрим сценарий, в котором нам нужно выполнить какое-то действие/задачу много раз. Мы можем определить это действие только один раз, используя функцию, и вызывать эту функцию всякий раз, когда требуется выполнить одно и то же действие.
 Функция повышает эффективность и уменьшает количество ошибок благодаря возможности повторного использования кода. Как только мы создадим функцию, мы сможем вызывать ее где угодно и когда угодно. Преимущество использования функции заключается в возможности повторного использования и модульности.
 Содержание 
  •  Типы функций
  •  Создание функции
    •  Создание функции без параметров
    •  Создание функции с параметрами
    •  Создание функции с параметрами и возвращаемым значением
     8 Вызов функции Вызов функции модуля
  •  Строки документации
    •  Однострочная строка документации
    •  Многострочная строка документации
  •  Возвращаемое значение из функции
    •  Возвращает несколько значений
  •  Оператор pass
  •  Как функция работает в Python?
  •  Scope and Lifetime of Variables
    •  Local Variable in function
    •  Global Variable in function
      •  Global Keyword in Function
    •  Nonlocal Variable in Function
  •  Python Function Arguments
    •  Positional Arguments
    •  Keyword Arguments
    •  Аргументы по умолчанию
    •  Variable-length Arguments
  •  Recursive Function
  •  Python Anonymous/Lambda Function
    •  filter() function in Python
    •  map() function in Python
    •  reduce() function in Python
    •  Types of Функции 
     Python поддерживает два типа функций
    1.  Встроенная функция
    2.  Пользовательская функция
      Встроенная функция 
    0003  или  предопределенная функция  . Некоторые из них перечислены ниже. 
      range()  ,  id()  ,  type()  ,  input()  ,  eval()  и т. д.
      от заданного начального целого числа до конечного целого числа.
     для i в диапазоне (1, 10):
    напечатать (я, конец = '')
# Выход 1 2 3 4 5 6 7 8 9 
      Пользовательская функция 
     Функции, созданные программистом явно в соответствии с требованием, называются пользовательскими функциями.
     Создание функции 
     Используйте следующие шаги, чтобы определить функцию в Python.
    •  Используйте ключевое слово  def  с именем функции, чтобы определить функцию.
    •  Затем укажите необходимое количество параметров. (Необязательный).
    •  Затем определите тело функции с блоком  кода  . Этот блок кода — не что иное, как действие, которое вы хотели выполнить.
     В Python нет необходимости указывать фигурные скобки для тела функции. Единственный отступ   необходим для разделения кодовых блоков. В противном случае вы получите ошибку.
      Синтаксис создания функции 
     def имя_функции(параметр1, параметр2):
       # тело функции
       # пишем какое-то действие
возвращаемое значение 
      Здесь  ,
    •   имя_функции  : Имя функции — это имя функции. Мы можем дать любое имя функции.
    •   параметр  : Параметр — это значение, передаваемое функции. Мы можем передать любое количество параметров. Тело функции использует значение параметра для выполнения действия
    •   function_body  : Тело функции — это блок кода, выполняющий некоторую задачу. Этот блок кода не что иное, как действие, которое вы хотели выполнить.
    •   возвращаемое значение  : возвращаемое значение является выходом функции.
      Примечание:  При определении функции мы используем два ключевых слова,  по умолчанию  (обязательно) и  вернуть  (необязательно).
     Функции Python
     Создание функции без каких-либо параметров 
     Теперь давайте рассмотрим пример создания простой функции, которая печатает приветственное сообщение.
     # функция
сообщение защиты():
    print("Добро пожаловать в PYnative")
# вызвать функцию по ее имени
message() 
      Output 
     Добро пожаловать в PYnative 
     Создание функции с параметром  s
     Давайте создадим функцию, которая принимает два параметра и отображает их значения.
     В этом примере мы создаем функцию с двумя параметрами «имя» и «возраст».
     # функция
def course_func (имя, имя_курса):
    print("Привет", имя, "Добро пожаловать в PYnative")
    print("Ваш курс называется", course_name)
# вызов функции
Course_func('John', 'Python') 
      Вывод 
     Привет, Джон Добро пожаловать в PYnative
Название вашего курса Python 
     Создание функции с параметрами и возвращаемым значением 
     Функции могут возвращать значение. Возвращаемое значение является выходом функции. Используйте ключевое слово return, чтобы вернуть значение из функции.
     # функция
Калькулятор деф (а, б):
    добавить = а + б
    # вернуть дополнение
    вернуть добавить
# вызов функции
# взять возвращаемое значение в переменную
рез = калькулятор (20, 5)
print("Дополнение:", разрешение)
# Дополнение вывода: 25 
     Вызов функции 
     Как только мы определили функцию или завершили структуру, мы можем вызвать эту функцию, используя ее имя. Мы также можем вызвать эту функцию из другой функции или программы, импортировав ее.
     Чтобы вызвать функцию, используйте имя функции в скобках, и если функция принимает параметры, передайте эти параметры в скобках.
      Пример 
     # функция
определение даже_нечетное (n):
    # проверить, является ли число четным или нечетным
    если n % 2 == 0:
        print('Четное число')
    еще:
        print('Нечетное число')
# вызов функции по ее имени
четное_нечетное(19)
# Вывод нечетного числа 
     Вызов функции модуля 
     Вы можете воспользоваться встроенным модулем и использовать определенные в нем функции. Например, в Python есть модуль random, который используется для генерации случайных чисел и данных. Он имеет различные функции для создания различных типов случайных данных.
     Давайте посмотрим, как использовать функции, определенные в любом модуле.
    •  Во-первых, нам нужно использовать оператор импорта для импорта определенной функции из модуля.
    •  Далее мы можем вызвать эту функцию по ее имени.
     # функция импорта randint
из случайного импорта randint
# вызвать функцию randint для получения случайного числа
печать (рандинт (10, 20))
# Output 14 
     Docstrings 
     В Python строка документации также называется  docstring  . Это описательный текст (например, комментарий), написанный программистом, чтобы другие знали, что делает блок кода.
     Мы пишем строку документации в исходном коде и определяем ее сразу после определения модуля, класса, функции или метода.
     Объявляется с использованием тройных одинарных кавычек  (''' ''')  или тройных двойных кавычек  (""" """)  .
     Мы можем получить доступ к строке документации с помощью атрибута документа  (__doc__)  для любого объекта, такого как  list  ,  tuple  ,  dict  , определяемой пользователем функции и т. д.
     Однострочная строка документации 
     29 docstring — это строка документации, умещающаяся в одну строку. Мы можем использовать тройные одинарные или тройные двойные кавычки для его определения. Открывающие и закрывающие кавычки должны быть одинаковыми. По соглашению мы должны использовать тройные двойные кавычки для определения строки документации.
     по умолчанию факториал(х):
    """Эта функция возвращает факториал заданного числа."""
    вернуть х
# доступ к строке документа
print(factorial.__doc__) 
      Вывод 
     Эта функция возвращает факториал заданного числа 
     Когда вы используете функцию справки для получения информации о любой функции, она возвращает строку документации.
     # передать имя функции в функцию help()
print(help(factorial)) 
     Вывод
     Справка по функции factorial в модуле  основной  :
факториал(х)
     Эта функция возвращает факториал заданного числа.
Нет 
     Многострочная строка документации 
     Многострочная строка документации — это такая же однострочная строка документации, но за ней следует одна пустая строка с описательным текстом.
     Общий формат записи многострочной строки документа следующий:
      Пример 
     def any_fun(parameter1):
"""
   Описание функции
                 
   Аргументы:
   параметр1(целое):Описание параметра1
                 
   Возвращает:
   целое значение
"""
печать (любое_развлечение.__doc__) 
      Выход 
     Описание функции
Аргументы
параметр1(целое):Описание параметра1
Возвращает:
int value 
     Возвращаемое значение из функции 
     В Python для возврата значения из функции используется оператор  return . Он возвращает значение выражения, следующего за ключевым словом return.
      Синтаксис оператора  return  
     def fun():
    заявление-1
    заявление-2
    заявление-3
    .
    .
    вернуть [выражение] 
     Возвращаемое значение не что иное, как результат функции.
    •  Оператор  return  завершает выполнение функции.
    •  Для функции не обязательно возвращать значение.
    •  Если оператор  return  используется без какого-либо выражения, то возвращается  None .
    •  Оператор  return  должен находиться внутри функционального блока.
      Пример 
     def is_even(list1):
    четное_число = []
    для n в списке1:
        если n % 2 == 0:
            четное_число.добавлять(n)
    # вернуть список
    вернуть четное_число
# Передать список в функцию
четное_число = is_even([2, 3, 42, 51, 62, 70, 5, 9])
print("Четные числа:", even_num) 
      Вывод 
     Четные числа: [2, 42, 62, 70] 
     Возврат нескольких значений 
     Вы также можете вернуть несколько значений из функции. Используйте оператор return, разделив каждое выражение запятой.
      Пример  : –
     В этом примере мы возвращаем три значения из функции. Мы также увидим, как обрабатывать или читать несколько возвращаемых значений в нашем коде.
     по умолчанию арифметика (число1, число2):
    добавить = число1 + число2
    суб = число1 - число2
    умножить = число1 * число2
    деление = число1 / число2
    # вернуть четыре значения
    возврат добавить, подмножество, умножение, деление
# прочитать четыре возвращаемых значения в четырех переменных
a, b, c, d = арифметика (10, 2)
print("Дополнение: ", а)
print("Вычитание: ", б)
print("Умножение: ", с)
print("Деление: ", г) 
     В Python ключевое слово  pass  ничего не делает. Иногда возникает ситуация, когда нам нужно определить синтаксически пустой блок. Мы можем определить этот блок, используя ключевое слово  pass .
     Когда интерпретатор находит в программе оператор  pass , он возвращает  нет операции  .
      Пример 
     определение сложение(число1, число2):
    # Реализация функции добавления в следующем релизе
    # Оператор передачи
    проходить
сложение(10, 2) 
     Как функция работает в Python? 
     В Python функции позволяют программисту создавать короткий и чистый код для повторного использования во всей программе.
     Функция помогает нам организовать код. Функция принимает параметры на вход, обрабатывает их и, в конце концов, возвращает значения на выходе.
     Предположим, мы определили функцию, которая вычисляет какую-то задачу. Когда мы вызываем эту функцию из другой функции, программный контроллер переходит к этой функции, выполняет некоторые вычисления и возвращает некоторое значение в качестве вывода вызывающей функции.
     На следующей диаграмме показано, как работает эта функция.
     Область действия и время жизни переменных 
     Когда мы определяем функцию с переменными, область действия этих переменных ограничивается этой функцией. В Python область действия переменной — это область, в которой объявлена ​​переменная. Это называется локальной областью видимости переменной.
     Мы не можем получить доступ к локальным переменным извне функции. Поскольку область действия является локальной, эти переменные не видны снаружи функции.
      Примечание : внутренняя функция имеет доступ к локальной области действия внешней функции.
     Когда мы выполняем функцию, жизнь переменных зависит от времени выполнения. Как только мы возвращаемся из функции, эти переменные уничтожаются. Таким образом, функции не нужно запоминать значение переменной из предыдущего вызова.
     Следующий код показывает область действия переменной внутри функции.
      Пример 
     global_lang = 'DataScience'
определение var_scope_test():
    local_lang = 'Питон'
    печать (местный_язык)
var_scope_test()
# Вывод 'Питон'
# вне функции
печать (глобальный_язык)
# Вывод 'DataScience'
# NameError: имя 'local_lang' не определено
печать (местный_язык) 
     В приведенном выше примере мы печатаем значения локальных и глобальных переменных вне функции. Глобальная переменная доступна по имени  global_lang  .
     Но когда мы пытаемся получить доступ к локальной переменной с ее именем  local_lang  , мы получаем NameError, потому что локальная переменная недоступна снаружи функции.
     Локальная переменная в функции 
     Локальная переменная — это переменная, объявленная внутри функции, которая недоступна извне функции. Область действия локальной переменной ограничивается этой функцией только там, где она объявлена.
     Если мы попытаемся получить доступ к локальной переменной извне функции, мы получим ошибку NameError.
      Пример 
     def function1():
    # локальная переменная
    лок_вар = 888
    print("Значение:", loc_var)
функция защиты2():
    print("Значение:", loc_var)
функция1()
function2() 
      Выход 
     Значение: 888
print("Значение:", loc_var) # выдает ошибку,
NameError: имя «loc_var» не определено 
     Глобальная переменная в функции 
     Глобальная переменная — это переменная, которая объявляется вне функции. Область действия глобальной переменной широка. Он доступен во всех функциях того же модуля.
      Пример 
     global_var = 999
функция защиты1():
    print("Значение в 1-й функции:", global_var)
функция защиты2():
    print("Значение во второй функции:", global_var)
функция1()
function2() 
      Выход 
     Значение в 1-й функции: 999
Значение во 2-й функции: 999
     Глобальное ключевое слово в функции 
     В Python  global  — это ключевое слово, используемое для доступа к фактической глобальной переменной извне функции. мы используем ключевое слово global для двух целей:
    1.  Чтобы объявить глобальную переменную внутри функции.
    2.  Объявление переменной глобальной, что делает ее доступной для выполнения модификации.
     Давайте посмотрим, что произойдет, если мы не используем ключевое слово global для доступа к глобальной переменной в функции 9.0005
     # Глобальная переменная
глобальная_вар = 5
функция защиты1():
    print("Значение в 1-й функции:", global_var)
функция защиты2():
    # Изменить глобальную переменную
    # функция будет рассматривать его как локальную переменную
    глобальная_вар = 555
    print("Значение во второй функции:", global_var)
функция определения3():
    print("Значение в 3-й функции:", global_var)
функция1(
функция2()
function3() 
      Выход 
     Значение в 1-й функции: 5
Значение во 2-й функции: 555
Значение в 3-й функции: 5 
     Как видите,  function2()  обрабатывает  global_var  как новую переменную (локальную переменную). Чтобы решить такие проблемы или получить доступ/изменить глобальные переменные внутри функции, мы используем ключевое слово  global .
      Пример  :
     # Глобальная переменная
х = 5
# определение первой функции
функция защиты1():
    print("Значение в 1-й функции:", x)
# определение второй функции
функция защиты2():
    # Изменить глобальную переменную, используя ключевое слово global
    глобальный х
    х = 555
    print("Значение во второй функции:", x)
# определение третьей функции
функция определения3():
    print("Значение в 3-й функции:", x)
функция1()
функция2()
функция3() 
      Выход 
     Значение в 1-й функции: 5
Значение во 2-й функции: 555
Значение в 3-й функции: 555 
     Нелокальная переменная в функции 
     В Python  nonlocal  — это ключевое слово, используемое для объявления переменной, которая действует как глобальная переменная для вложенной функции (т. е. функции внутри другой функции).
     Мы можем использовать ключевое слово  nonlocal , когда мы хотим объявить переменную в локальной области, но действовать как глобальная область.
      Пример  
     def external_func():
    х = 777
    определение внутренней_функции():
        # локальная переменная теперь действует как глобальная переменная
        нелокальный х
        х = 700
        print("значение x внутри внутренней функции:", x)
    внутренняя_функция()
    print("значение x внутри внешней функции:", x)
external_func() 
      Выход 
     значение x внутри внутренней функции: 700
значение x внутри внешней функции: 700 
     Аргументы функции Python 
     Аргумент — это значение, переменная или объект, который мы передаем в функцию или вызов метода. В Python разрешены четыре типа аргументов.
    1.  Позиционные аргументы
    2.  Аргументы ключевого слова
    3.  Аргументы по умолчанию
    4.  Аргументы переменной длины
     Прочтите полное руководство по  аргументам функции Python  .
     Позиционные аргументы 
     Позиционные аргументы — это аргументы, которые передаются функции в  правильном позиционном порядке  . То есть 1-й позиционный аргумент должен быть 1-м при вызове функции. 2-й позиционный аргумент должен быть 2-м при вызове функции и т. д. См. следующий пример для большего понимания.
      Пример 
     def add(a, b):
    печать (а - б)
добавить(50, 10)
# Выход 40
добавить(10, 50)
# Вывод -40 
     Если вы попытаетесь передать больше параметров, вы получите ошибку.
     по умолчанию добавить (а, б):
    печать (а - б)
добавить(105, 561, 4) 
      Выход 
     Ошибка типа: add() принимает 2 позиционных аргумента, но было задано 3 
     В позиционном аргументе должно совпадать число и позиция аргументов. Если мы изменим порядок, то и результат может измениться. Кроме того, если мы изменим количество аргументов, мы получим ошибку.
     Аргументы ключевого слова 
     Аргумент ключевого слова — это значение аргумента, передаваемое в функцию, которому предшествует имя переменной и знак равенства.
      Пример 
     def сообщение(имя, фамилия):
    print("Здравствуйте", имя, фамилия)
сообщение (имя = "Джон", фамилия = "Уилсон")
сообщение (фамилия = "Алт", имя = "Келли")
 
      Выход 
     Привет Джон Уилсон
Hello Kelly Ault 
     В аргументах ключевого слова порядок аргументов не имеет значения, но количество аргументов должно совпадать. В противном случае мы получим ошибку.
     При одновременном использовании ключевого слова и позиционного аргумента нам нужно передать 1-й аргумент как позиционный аргумент, а затем аргумент ключевого слова. В противном случае мы получим  SyntaxError . См. следующий пример.
      Пример 
     def message(first_nm, last_nm):
    print("Привет..!", first_nm, last_nm)
# правильное использование
сообщение("Джон", "Уилсон")
сообщение ("Джон", last_nm="Уилсон")
# Ошибка
# SyntaxError: позиционный аргумент следует за аргументом ключевого слова
сообщение (first_nm = "Джон", "Уилсон")
 
     Аргументы по умолчанию 
     Аргументы по умолчанию принимают значение по умолчанию во время вызова функции, если мы их не передаем. Мы можем присвоить значение по умолчанию аргументу в определении функции, используя оператор присваивания  = .
     Например, функция  show_employee() , которая принимает имя и зарплату сотрудника и отображает и то, и другое. Давайте изменим определение функции и присвоим зарплате значение по умолчанию 8000. Далее, если в вызове функции отсутствует значение зарплаты, функция автоматически принимает значение по умолчанию 9.000 в качестве зарплаты.
       Пример 
     # функция с аргументом по умолчанию
сообщение защиты (имя = "Гость"):
    print("Здравствуйте", имя)
# вызов функции с аргументом
сообщение("Джон")
# вызов функции без аргумента
message() 
      Вывод 
     Привет Джон
Здравствуйте, гость 
     Когда мы вызываем функцию с аргументом, она принимает это значение.
     Аргументы переменной длины 
     В Python иногда возникает ситуация, когда нам нужно передать функции несколько аргументов. Такие типы аргументов называются  аргументы переменной длины  . Мы можем объявить аргумент переменной длины с помощью символа  *   (звездочка) .
     забава по определению (*var):
    тело функции 
     Мы можем передать любое количество аргументов этой функции. Внутри все эти значения представлены в виде кортежа   .
      Пример 
     добавление по умолчанию (*числа):
    всего = 0
    для нет в цифрах:
        всего = всего + нет
    print("Сумма:", всего)
# 0 аргументов
добавление()
# 5 аргументов
сложение(10, 5, 2, 5, 4)
# 3 аргумента
сложение(78, 7, 2.5) 
      Выход 
     Сумма: 0
Сумма: 26
Сумма: 87,5 
     Подробнее: Полное руководство по  аргументам функции Python  .
     Рекурсивная функция 
     Рекурсивная функция — это функция, которая вызывает сама себя снова и снова.
     Учтите, что вычисление факториала числа является повторяющимся действием, в этом случае мы можем снова и снова вызывать функцию, которая вычисляет факториал.
     факториал(5)
    
5*факториал(4)
5*4*факториал(3)
5*4*3*факториал(2)
5*4*3*2*факториал(1)
5*4*3*2*1 = 120 
      Пример 
     def factorial(no):
    если нет == 0:
        вернуть 1
    еще:
        вернуть нет * факториал (нет - 1)
print("факториал числа:", factorial(8))
 
      Вывод 
     факториал числа: 40320 
      Преимущества рекурсивной функции: 
    1.  Используя рекурсию, мы можем уменьшить длину кода.
    2.  Читабельность кода улучшается за счет сокращения кода.
    3.  Полезно для решения сложной задачи
      Недостаток рекурсивной функции: 
    1.  Рекурсивная функция требует больше памяти и времени для выполнения.
    2.  Отладка рекурсивной функции непроста.
     Python Anonymous/Lambda Function 
     Иногда нам нужно объявить функцию без имени. Функция безымянного свойства называется  анонимной функцией  или лямбда-функцией . 
     Причиной использования анонимной функции является мгновенное использование, то есть одноразовое использование. Обычная функция объявляется с помощью функции  def . В то время как анонимная функция объявляется с использованием ключевого слова  lambda .
     В отличие от обычной функции, лямбда-функция Python представляет собой одно выражение. Но в теле лямбда мы можем расширять выражения на несколько строк, используя круглые скобки или многострочную строку. 
     пример:  лямбда n:n+n 
      Синтаксис  лямбда  функция: 
     лямбда: список_аргументов:выражение 
     Когда мы определяем функцию с помощью ключевого слова  лямбда , код становится очень кратким, чтобы его было легче читать. Лямбда-функция может иметь любое количество аргументов, но возвращать только одно значение после вычисления выражения.
     Давайте рассмотрим пример печати четных чисел без функции  lambda  и с функцией  lambda . Посмотрите на разницу в строке кода, а также на удобочитаемость кода.
      Пример 1: Программа для четных чисел без лямбда-функции 
     def even_numbers(nums):
    даже_список = []
    для n в цифрах:
        если n % 2 == 0:
            четный_список.append(n)
    вернуть четный_список
num_list = [10, 5, 12, 78, 6, 1, 7, 9]
ответ = четные_числа (число_список)
print("Четные числа:", анс) 
      Вывод 
     Четные числа: [10, 12, 78, 6] 
      Пример 2: Программа для четных чисел с лямбда-функцией 
     л = [10, 5, 12, 78, 6, 1, 7, 9]
even_nos = список (фильтр (лямбда x: x% 2 == 0, l))
print("Четные числа: ", even_nos) 
      Вывод 
     Четные числа: [10, 12, 78, 6] 
     Мы не обязаны писать  явные операторы возврата   в  лямбда-функции  потому что лямбда внутренне возвращает значение выражения.
     Лямбда-функции более полезны, когда мы передаем функцию в качестве аргумента другой функции. Мы также можем использовать лямбда-функцию со встроенными функциями, такими как  filter  ,  map  ,  уменьшите , потому что эта функция требует другой функции в качестве аргумента.
     Функция filter()  в Python
     В Python функция  filter()  используется для возврата отфильтрованного значения. Мы используем эту функцию для фильтрации значений на основе некоторых условий.
      Синтаксис  filter()  функция: 
     filter(функция, последовательность) 
     где,
    •  функция – Аргумент функции отвечает за выполнение проверки условия.
    •  последовательность — Аргумент последовательности может быть любым, например списком, кортежем, строкой
      Пример:  лямбда-функция  с  filter()  
     l = [-10, 5, 12, -78, 6, - 1, -7, 9]
Positive_nos = список (фильтр (лямбда x: x > 0, l))
print("Положительные числа: ", Positive_nos) 
      Вывод 
     Положительные числа: [5, 12, 6, 9] 
     map()  function in Python
     В Python карта ( ) 9Функция 0032 используется для применения некоторой функциональности к каждому элементу, присутствующему в заданной последовательности, и создания новой серии с требуемой модификацией.
     Пример: для каждого элемента, присутствующего в последовательности, выполнить операцию куба и создать новый список кубов.
      Синтаксис  map()  function: 
     map(function,sequence) 
     где,
    •   function  – аргумент функции, отвечающий за применение к каждому элементу последовательности
    •   последовательность  — Аргументом последовательности может быть список, кортеж, строка
      Пример:  лямбда-функция  с  map()  функция 
     list1 = [2, 8, 3, 9]
список2 = список (карта (лямбда х: х * х * х, список1))
print("Значения куба:", list2) 
      Вывод 
     Значения куба: [8, 27, 64, 512, 729] 
      уменьшить() 9Функция 0032 используется для  минимизации элементов последовательности  в  одиночное значение  путем применения указанного условия.
     Функция reduce() присутствует в модуле  functools   ; следовательно, нам нужно импортировать его с помощью оператора импорта перед его использованием.
    Оставить комментарий

    Добавить комментарий

    Ваш адрес email не будет опубликован. Обязательные поля помечены *