Функции питона: Функции и их аргументы | 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 | Функции

Последнее обновление: 16. 01.2022

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


def имя_функции ([параметры]):
    инструкции

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

Например, определение простейшей функции:


def say_hello():
    print("Hello")

Функция называется say_hello. Она не имеет параметров и содержит одну единственную инструкцию, которая выводит на консоль строку «Hello».

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


def say_hello():
    print("Hello")


print("Bye")

Здесь инструкция

print("Bye") не имеет отступов от начала функции say_hello и поэтому в эту функцию не входит. Обычно между определением функции и остальными инструкциями, которые не входят в функцию, располагаются две пустых строки.

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

имя_функции ([параметры])

Например, определим и вызовем функцию:


def say_hello():    # определение функции say_hello
    print("Hello")


say_hello()         # вызов функции say_hello
say_hello()
say_hello()

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


Hello
Hello
Hello

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

Если функция имеет одну инструкцию, то ее можно разместить на одной строке с остальным определением функции:


def say_hello(): print("Hello")

say_hello()

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


def say_hello():
    print("Hello")


def say_goodbye():
    print("Good Bye")


say_hello()
say_goodbye()

Консольный вывод:


Hello
Good Bye

Локальные функции

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


def print_messages():
    # определение локальных функций
    def say_hello(): print("Hello")
    def say_goodbye(): print("Good Bye")
    # вызов локальных функций
    say_hello()
    say_goodbye()

# Вызов функции print_messages
print_messages()

#say_hello() # вне функции print_messages функция say_hello не доступна

Здесь функции say_hello() и say_goodbye() определены внутри функции print_messages() и поэтому по отношению к ней являются локальными. Соответственно они могут использоваться только внутри функции print_messages()

Организация программы и функция main

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


def main():
    say_hello()
    say_goodbye()

def say_hello():
    print("Hello")

def say_goodbye():
    print("Good Bye")

# Вызов функции main
main()

НазадСодержаниеВперед

Функции Python — GeeksforGeeks

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

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

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

 

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

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

Python3

DEF FUN ():

Печать ( "Добро пожаловать на GFG" ( "Добро пожаловать на GFG" ( "Добро пожаловать на GFG" ( ".

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

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)

ADD (NUM1, NUM2)

1131 AD (NUM1, NUM2)

131 of AD (NUM1, NUM2) of . и {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 = = R = = R = = R = R = 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 ): ): 9005

): 9005

). , 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' = 1 'Geeks' = 1 '. 0031 )

Выход

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

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

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

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

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

Python

7

 

 

def myFun( * argv):

     for arg in argv:

         print (arg )

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

Выход

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

Example 2: Variable length keyword arguments

Python3

 

 

def myFun( * * kwargs):

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

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

 

 

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

Выход

96699 

. середина == для last == Компьютерщики

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

Первая строка после функции называется строкой документа или сокращенно строкой документа. Это используется для описания функциональности функции. Использование docstring в функциях необязательно, но считается хорошей практикой.

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

  Синтаксис:  print(имя_функции.__doc__) 

Пример: Добавление строки документации к функции

Python3

7 9 00026

 

 

def evenOdd(x):

    

      

     if (x % 2 = = 0 ):

         print ( "even" )

     else :

         Печать ( "ODD" )

Печать (ровный. или нечетное

Оператор возврата в функции Python

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

Синтаксис:  

 return [список_выражений] 

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

Пример: Оператор возврата функции Python

Python3

def Square_value(num):

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 , [ 10 , [ 10 , [ 10 , . 0032 11 , 12 , 13 , 14 , 15 ] 15 ] 15 .

Вывод

 [10, 11, 12, 13, 14, 15] 

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

Python3

def myFun(x):

 

    

    

    

     x = 20

 

 

x = 10

Myfun (x)

Печать (x)

Выход 9005

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

.0031 print (cube_v2( 7 ))

Выход

 343
343 

Функция Python внутри функций

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

Python3

 

def f1():

     s = 'I love GeeksforGeeks'

      

     def f2():

Печать (S)

F2 ()

F1 ()

F1 ()

()

()0048

Выход

 I Love Geeksforgeeks 
Краткие связи:
  • ТРИЗКИ ​​НА ПИТАНС. .

Функции Python [Полное руководство] — PYnative

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

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

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

Также, см.

  • Функции Python упражнения
  • Функции Python Quiz

Содержимое содержимого

    .
  • Создание функции с параметрами и возвращаемым значением
  • Вызов функции
    • Вызов функции модуля
  • Строки документации
    • Однострочная строка документации
    • Многострочная строка документации
  • Возвращаемое значение функции
    • Возврат нескольких значений
    • Объем и время жизни переменных
      • Локальная переменная в функции
      • Глобальная переменная в функции
        • Глобальное ключевое слово в функции
      • Нелокальная переменная в функции
    • Python Function Arguments
      • Positional Arguments
      • Keyword Arguments
      • Default Arguments
      • Variable-length Arguments
    • Recursive Function
    • Python Anonymous/Lambda Function
      • filter() function in Python
      • map( ) функция в Python
      • функция reduce() в Python

    Типы функций

    Python поддерживает два типа функций

    1. Встроенная функция
    2. Пользовательская функция

    Встроенная функция

    Функции, поставляемые вместе с самим Python, называются встроенной функцией или предопределенной функцией . Некоторые из них перечислены ниже.
    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 : Тело функции — это блок кода, выполняющий некоторую задачу. Этот блок кода не что иное, как действие, которое вы хотели выполнить.
    • возвращаемое значение : возвращаемое значение является выходом функции.

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

    Функции Python

    Создание функции без каких-либо параметров

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

     # функция
    сообщение защиты():
        print("Добро пожаловать в PYnative")
    # вызвать функцию по ее имени
    сообщение() 

    Выход

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

    Создание функции с параметром s

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

    В этом примере мы создаем функцию с двумя параметрами «имя» и «возраст».

     # функция
    def course_func (имя, имя_курса):
        print("Привет", имя, "Добро пожаловать в PYnative")
        print("Ваш курс называется", course_name)
    # вызов функции
    course_func('Джон', 'Питон') 

    Вывод

     Привет Джон Добро пожаловать в 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 для доступа к глобальной переменной в функции

     # Глобальная переменная
    глобальная_вар = 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 – аргумент функции, отвечающий за применение к каждому элементу последовательности
    • последовательность — аргументом последовательности может быть что угодно, например, список, кортеж, строка список2 = список (карта (лямбда х: х * х * х, список1)) print("Значения куба:", list2)

      Вывод

       Значения куба: [8, 27, 64, 512, 729] 

      уменьшить() 9Функция 0032 используется для минимизации элементов последовательности в одиночное значение путем применения указанного условия.

      Функция reduce() присутствует в модуле functools  ; следовательно, нам нужно импортировать его с помощью оператора импорта перед его использованием.

  • Оставить комментарий

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

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

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

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