Python function: Python Function Arguments (With Examples)

python function — Конспекты (2022.09)

Атрибуты встроенных функции

• __doc__ — Строка документирования

• __name__ — Имя функции/метода

• __self__ — Ссылка на экземпляр, ассоциированный с данным методом (для связанных методов)

Атрибуты функции

• __closure__ — Кортеж, содержащий данные, связанные с вложенными областями видимости

• __code__ — Скомпилированный байт-код функции

• __defaults__ — Кортеж с аргументами по умолчанию

• __dict__ — Словарь, содержащий атрибуты функции

• __doc__ — Строка документирования

• __globals__ — Словарь, определяющий глобальное пространство имен

• __name__ — Имя функции

lambda функции

f = lambda x: x*2
for i in (1,2):
    print(f(i))
# 2
# 4

Пользовательски функции

def func(text):
    """
    документация функции
    докстринг
    """
    print(text)
func('http://ilnurgi. ru')
# http://ilnurgi.ru

def func(first_arg, second_arg):
    """
    функция с позиционными аргументами
    func(1, 2)
    """
def func(first_arg=None, second_arg=None):
    """
    функция с аргументами по умолчанию
    func()
    func(second_arg=2)
    """
def func(*args, **kwargs):
    """
    func(1, b=2) ->
        (1, )
        {'b': 2}
    """
    print(args)
    print(kwargs)

def func(a, b, /, c, d *, e, f)
    """
    a, b - могут быть присвоены только в порядке перечисления значений
    e, f - только присвоение через указание ключей
    c, d - любым указанным способом
    / - отделяет аргументы,
        значения которым могут быть присвоены только на основе порядка перечисления значений
        во время вызова функции,
        от аргументов,
        допускающих присвоение в произвольном порядке
    * - отедляет переменные,
        для которых применимо только присвоение.
    """
func(10, 20, 30, 40, e=50, f=60)
func(10, 20, c=30, d=40, e=50, f=60)

Декораторы

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

def prepare(func):
    """
    декоратор
    """
    def wrapp(*args, **kwargs):
        print(1)
        result = func(*args, **kwargs)
        print(3)
        return result
    return wrapp
@prepare
def func():
    """
    декорируемая функция
    """
    print(2)
func()
# 1
# 2
# 3

def prepare_with_parameters(params):
    print(0)
    def decorator(func):
        def wrapp():
            print(1)
            result = func()
            print(3)
            return result
        return wrapp
    return decorator
@prepare_with_parameters(0)
def func():
    print(2)
func()
# 0
# 1
# 2
# 3

Генераторы

С помощью инструкции yield, функция может генерировать целые последовательности результатов, тогда такие функции называют генераторами

def countdown(n):
    print u'Обратный отсчет!'
    while n > 0:
        yield n
        n -= 1
c = countdown(3)
c.next()
# Обратный отсчет
# 3
c.next()
# 2
c.next()
# 1

gen.gi_code

Объект с программным кодом функции-генератора

gen. gi_frame

Кадр стека функции-генератора

gen.gi_running

Целое число, указывающее – выполняется ли функция-генератор в настоящий момент

gen.next()

Выполняет функцию-генератор, пока не будет встречена следующая инструкция yield, и возвращает полученное значение

(в Python 3 этот метод вызывает метод __next__())

gen.send(value)

Передает значение value генератору.

Это значение возвращается выражением yield в функции-генераторе.

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

Метод send() возвращает значение, полученное от этой инструкции yield

gen.close()

Закрывает генератор, возбуждая исключение GeneratorExit в функции-генераторе.

Этот метод вызывается автоматически, когда объект генератора уничтожается сборщиком мусора

gen.throw(exc[, exc_value[, exc_tb]])

Возбуждает исключение в функции-генераторе в точке вызова инструкции yield.

• exc — тип исключения

• exc_value — значение исключения

• exc_tb — необязательный объект с трассировочной информацией.

  Если исключение перехвачено и обработано, вернет значение, переданное следующей инструкции yield

Сопрограммы

Функция обрабатывающая последовательность входных параметров.

def print_matches(matchtext):
    print 'Поиск подстроки', matchtext
    while True:
        # Получение текстовой строки
        line = (yield)
        if matchtext in line:
            print line
matcher = print_matches('python')
# Перемещение до первой инструкции (yield)
matcher.next()
# Поиск подстроки python
matcher.  send("Hello World")
matcher.send("python is cool")
# python is cool
matcher.send("yow!")
# Завершение работы с объектом matcher
matcher.close()

Аннтоации в функциях:

Warning

Добавлено в 3 ветке

def func(a: 'Параметр', b: 10 + 5 = 3) -> None:
   pass

Функция возвращает None, для параметров

После создания функции все выражения будут выполнены и результаты сохранятся в виде словаря в атрибуте __annotations__ объекта функции.

Замыкания

def sum_factory(first):
    """
    функция создает сумматор
    """
    def sum(second):
        """
        переменная first замыкается в этой функции
        """
        return first + second
    return sum
sum_2 = sum_factory(2)
sum_2(1)
# 3
sum_2(10)
# 12

Что есть функция в Python? / Хабр

В начале же статьи предупрежу:

Эта статья предназначена только для тех людей, которым хочется узнать, чем на самом деле является функция в python. …НО! Предупреждаю, я не буду лезть в сурсы питона. Эта статья была создана только для обычных вроде меня программистов.

Статья будет состоять из 4 частей:

1. Как осуществляется поиск атрибутов в классах.

2. Что есть метод и как он вызывается.

3. Что есть функция и как она вызывается.

4. Вывод

1. Как осуществляется поиск атрибутов в классах

Мы знаем, что при обращении к атрибуту вызывается дандер-метод __getattribute__, который в свою очередь пытается возвратить наш атрибут, но! Если он его не находит атрибут, то он вызывает исключение AttributeError, если

Ссылка на мою блок-схему

Как видите, тут не так все просто как нам казалось) Срабатывается куча проверок, чтобы наконец-то либо возвратить наш атрибут или вызвать исключение.

Давайте с помощью этой блок-схемы, реализуем свой прототип __getattribute__ и посмотрим, будет ли он работать так же как и оригинал.

def __getattribute__(self, item):
    ''' Прототип дандер-метода __getattribute__.'''
    for cls in Class.__mro__:
      
        if item in cls.__dict__:  # есть ли атрибут в пространстве имен класса.
            item_class_dict = type(cls.__dict__[item]).__dict__  # Пространства имен класса нашего атрибута
            if "__get__" in item_class_dict:  # Является ли атрибут, дескриптором.
                return cls.__dict__[item].__get__(self, cls)
            return cls.__dict__[item]
    else:
        if item in self.__dict__:  # есть ли атрибут в пространстве имен экземпляра класса
            return self.__dict__[item]
        if "__getattr__" in self.__class__.__dict__:  # Есть ли у класса, дандер-метод __getattr__
            return self.__getattr__(item)
        raise AttributeError

И давайте наконец его испробуем!

Создадим класс Pet, который наследуется от класса Animal, где первый атрибут будет объектом дескриптора данных и 2 обычных переменных экземпляра класса это animal и age:

class Animal:
    eyes = 2
    legs = 4
    def eat(self, food):
        return f"Yum, yum, yum ({food})"
class Descriptor:
    def __set_name__(self, owner, name):
        self. name = name
    def __get__(self, instance, owner):
        return instance.__dict__[self.name]
    def __set__(self, instance, value):
        if isinstance(value, str):
            instance.__dict__[self.name] = value
        else:
            raise TypeError("Название, должно быть строкой!")
class Pet(Animal):
    name = Descriptor()
    def __init__(self, name, animal, age=1):
        self.name = name
        self.animal = animal
        self.age = age
    def __getattribute__(self, item):
        ''' Прототип дандер-метода __getattribute__.'''
        for cls in Pet.__mro__:
            if item in cls.__dict__:  # есть ли атрибут в пространстве имен класса.
                item_class_dict = type(cls.__dict__[item]).__dict__  # Пространства имен класса нашего атрибута
                if "__get__" in item_class_dict:  # Является ли атрибут, дескриптором.
                    return cls.__dict__[item].__get__(self, cls)
                return cls.__dict__[item]
        else:
            if item in self.
   __dict__:  # есть ли атрибут в пространстве имен экземпляра класса
                return self.__dict__[item]
            if "__getattr__" in self.__class__.__dict__:  # Есть ли у класса, дандер-метод __getattr__
                return self.__getattr__(item)
            raise AttributeError
    def meow(self):
        return "Meowwww!!!!" if self.animal.lower() == "cat" else "You're pet isn't cat!"
cat_kit = Pet("Kit", "Cat", 17)
print(cat_kit.name)  # Kit
print(cat_kit.animal)  # Cat
print(cat_kit.meow())  # Meowwww!
print(cat_kit.meow)  # <bound method Pet.meow of <__main__.Pet object at 0x7f940fe2f1f0>>
print(cat_kit.eyes)  # 2
print(cat_kit.eat("Kitekat"))  # "Yum, yum, yum (Kitekat)"
print(cat_kit.eat)  # <bound method Animal.eat of <__main__.Pet object at 0x7f940fe2f1f0>>
cat_kit.dog

И как вы видите, у нас все сработало!) Наш прототип __getattribute__ отлично возвращает методы, дескрипторы данных, дескрипторы не-данных, локальные атрибуты (если так можно назвать), атрибуты класса. ) (Небольшое уточнение: под возвращением атрибутов, я имею ввиду возвращения их через экземпляр класса, т.к через класс все атрибуты возвращаются с помощью вызова __getattribute__ у метакласса (type))

Давайте на этом примере я объясню как все происходит. К примеру, второй вызов нашего прототипа для возвращения локального атрибута animal. Тут все очень просто. Происходит 3 итерации нашего цикла, где мы проверяем, является ли animal чьим-то атрибутом класса. Конечно же нет, потому у нас выполняется конструкция в else, где мы проверяем есть ли animal в пространстве имен экземпляра класса. Есть. И мы его возвращаем.

А теперь давайте перейдем к дескриптору данных, то есть к атрибуту name. Происходит 1 итерация, где мы проверяем, есть ли он в пространстве имен класса Pet. Да, есть. Дальше, является ли он дескриптором данных. Является. Потому мы с помощью дандер метода __get__ возвращаем его.

Так же не забываем, что наш прототип проходит по всему MRO класса, как у оригинала, он может возвращать все методы род. класса и так же его атрибуты (как показано на примере). Но некоторые из вас спросят, как вызвался атрибут eyes класса Animal к примеру? Для начала узнаем как выглядит MRO у класса Pet.
Вот так:
[<class ‘main.Pet’>, <class ‘main.A’>, <class ‘object’>]
В первую очередь происходит первая итерация нашего цикла в прототипе __getattribute__, где cls это класс Pet. Он не проходит проверку if item in cls.__dict__, потому что у Pet нет такого атрибута. Потому, происходит вторая итерация, уже Animal и при той проверке, она возвращает True поэтому мы возвращаем атрибут класса Animal.

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

2. Что такое метод и как он вызывается

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

Давайте по порядку и издалека. Какие свойства имеют методы? Ну, они возвращают объект bound method при обращении через экземпляр класса, а так же первым аргументом всегда у них является опять-таки экземпляр класса. Отлично! С этим мы разобрались.

Теперь…Давайте, чтобы доказать вам, что метод является дескриптором не-данных я вам объясню почему метод не вызывается как обычный атрибут класса (Class.__dict__[item]) или как обычный локальный атрибут объекта класса (obj.__dict__[item])

Во первых, если бы методы вызывались как обычный атрибут класса, мы бы точно не смогли бы возвращать объект bound method через экземпляр класса при обращений к ним, потому что метод возвращал бы объект функций (как и класс). И тут вы зададите вопрос, а почему? Ну потому что в любом случае он бы под капотом вызывался бы как атрибут класса (Class.__dict__[item]), если бы мы даже обращались к нему с помощью объекта класса. Вот небольшой пример:

class Foo:
    def get_one(self):
        return 1
    def __getattribute__(self, item):
        return Foo.__dict__[item]
      
a = Foo()
print(Foo.get_one) # <function Foo.get_one at 0x7f5f7c9efd00>
print(a.get_one) # <function Foo.get_one at 0x7f5f7c9efd00>, а должен был возвратить <bound method Foo.get_one of <__main__.Foo object at 0x7ffb25aca800>>
print(Foo.get_one(a)) # 1
print(a.get_one(a)) # 1
print(a.get_one()) # TypeError: Foo.get_one() missing 1 required positional argument: 'self'
print(Foo.get_one is a.get_one) # True

А теперь, давайте попробуем второй вариант. Запустим такой код:

class Email:
  
    def __init__(self):
        self.lst_packages = []
    def add_package(self, package):
        if isinstance(package, dict) is False:
            raise TypeError("Предмет должен иметь адрес и товар!!!")
        if package not in self.lst_packages:
            self.lst_packages.append(package)
            return "Посылка была добавлена!"
        return "В нашей почте такая посылка уже есть!"
    def get_packages(self):
        return self. lst_packages
    def __getattribute__(self, item):
      if item == "__dict__":
          return Email.__dict__[item].__get__(self, Email)
      return self.__dict__[item]
mail_ru = Email()
print(mail_ru.lst_packages) # []
print(mail_ru.get_packages()) # KeyError: 'get_packages'

И к сожалению мы получаем исключение KeyError.
Тут мне кажется и так было понятно что вариант с объектом класса не сработает, только из-за того что методы находятся в пространстве имен класса, а не в экземпляре естественно. И прежде чем я отвечу на вопрос что вообще делает тут такое:

 if item == "__dict__":
     return Email.__dict__[item].__get__(self, Email)

Давайте вернемся к результатам:

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

2. Метод не вызывается как обычный локальный атрибут объекта класса, т.к методы находятся в пространстве имен класса, а не в объекте класса.

И что мы получаем тогда? То что метод является — дескриптором…А точнее: Метод — это дескриптор не-данных.

Если вы мне не поверили, то:

print("__get__" in type(cat_kit.meow).__dict__) # True
print("__set__" in type(cat_kit.meow).__dict__) # False
print("__delete__" in type(cat_kit.meow).__dict__) # False

Кстати, если уж мы вспомнили о классе Pet и его методе meow, то давайте заодно попробуем вызвать его как дескриптор:

class Descriptor:
    
    def __set_name__(self, owner, name):
        self.name = name 
    
    def __get__(self, instance, owner):
        return 1
class Pet:
    foobar = Descriptor()
    def __getattribute__(self, item):
        ''' Прототип дандер-метода __getattribute__.  Возвращает'''
        for cls in Pet.__mro__:
            if item in cls.__dict__:  # есть ли атрибут в пространстве имен класса.
                item_class_dict = type(cls.__dict__[item]).__dict__  # Пространства имен класса нашего атрибута
                if "__get__" in item_class_dict:  # Является ли атрибут, дескриптором.
                    print(f"THE DESCRIPTOR!!!! {item}")
                  
                    return cls.__dict__[item].__get__(self, cls)
                  
                return cls.__dict__[item]
        else:
            if item in self.__dict__:  # есть ли атрибут в пространстве имен экземпляра класса
                return self.__dict__[item]
            if "__getattr__" in self.__class__.__dict__:  # Есть ли у класса, дандер-метод __getattr__
                return self.__getattr__(item)
            raise AttributeError
    def meow(self):
        return "Meowwww!!!"
cat_kit = Pet()
print(cat_kit.meow()) # THE DESCRIPTOR!!!!!! Meowwww!!!
print(cat_kit.foobar) # THE DESCRIPTOR!!!!!! 1
     
#     cls. __dict__[item].__get__(instance, owner)
print(Pet.__dict__["meow"].__get__(cat_kit, Pet).__call__()) # Meowwww!!!
print(Pet.__dict__["meow"].__get__(cat_kit, Pet)) # <bound method Pet.meow of <__main__.Pet object at 0x7f0dd1c03df0>>
print(Pet.__dict__["foobar"].__get__(cat_kit, Pet)) # 1

Как видите, все сработало на ура!

Теперь, давайте вернемся к той части кода в классе Email:

def __getattribute__(self, item):
  if item == "__dict__":
       return Email.__dict__[item].__get__(self, Email)
  return self.__dict__[item]

Почему тут присутствует проверка item на значение __dict__ и почему я вызываю у него метод __get__? Ну-у, скорее всего потому что он является — дескриптором :)…И кстати дескриптором данных, он имеет и __get__ и __set__ и __delete__.

И вы наверно в ответ скажите, а когда мы вообще к нему обращаемся? Вот здесь self.__dict__ опять вызывается __getattribute__,в котором параметр item имеет значение __dict__.

И узнав что __dict__ является дескриптором, вы одновременно узнали как он возвращается у объектов.

print(Pet.__dict__["__dict__"].__get__(cat_kit, Pet)) # {"eyes": 4}
print(Pet.__dict__["__dict__"].__get__(dog, Pet)) # {"legs": 4}

И кстати, у классов же атрибут __dict__ не является дескриптором.

3. Что такое функция и как она вызывается

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

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

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

class Foo:
    pass
  
f = Foo()
def get_one(self):
    return 1
print(get_one. __get__(f, Foo)) # <bound method get_one of <__main__.Foo object at 0x7fe4c157b850>>
print(get_one.__get__(f, Foo).__call__()) # 1
print("get_one" in Foo.__dict__) # False

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

Но все равно, на самом деле функции так не вызываются. Давайте опять вспомним, что функция является объектом класса function, где тело функций содержится в дандер-методе __call__ который принадлежит естественно к классу функций. И чтобы вызвать этот метод…Что нужно сделать?) Правильно! Обратиться к дандер-методу __get__ где экземпляром класса будет сама наша функция, а класс — класс функций. Давайте же это реализуем!

def foo():
    return 1
Function = foo. __class__
print(Function.__dict__["__call__"].__get__(foo, Function) == foo.__call__) # True
print(Function.__dict__["__call__"].__get__(foo, Function).__call__()) # 1
print(foo.__call__()) # 1

И вот так, мы узнали как на самом деле «вызываются» функции) Но у некоторых может возникнуть еще один вопрос, «а почему у функций есть метод __get__, если мы его по сути не используем для вызова?» Ответ очень прост: на случае если мы обратимся к функции как к атрибуту.

4. Вывод

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

cls.__dict__["method"].__get__(instance, cls)()

Как на самом деле вызываются функции:

cls_function.__dict__["__call__"].__get__(func, cls_function)()

И…Все! Моя статья уже подходит к концу! Потому… напоследок я хочу дать вам домашнее задания:

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

И так же, всем огромное спасибо за прочтение моей первой статьи! Огромная благодарность Павлу за помощь в ее написании и спасибо Бензу! Я очень надеюсь что я хоть как-то дал вам ответ!

Функции Python — GeeksforGeeks

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

Некоторые Преимущества использования функций

• Повышение читабельности кода 
• Повышение возможности повторного использования кода

Объявление функции Python

Синтаксис объявления функции:

Синтаксис объявления функции Python

Типы функций в Python

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

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

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

Python3

Вызов функции Python

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

Python3

Выход:

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

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

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

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

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

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

Python3

Выход:

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

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

Python3

Вывод: 900 05

 False True 

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

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

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

Python3

Выход:

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

Типы аргументов функций Python

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

• Аргумент по умолчанию
• Аргументы ключевого слова (именованные аргументы)
• Позиционные аргументы
• Произвольные аргументы (переменные аргументы доступной длины *args и **kwargs)

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

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

Python3

Выход:

 х: 10
y: 50 

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

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

Python3

Вывод:

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

Позиционные аргументы

Мы использовали аргумент Position во время вызова функции, так что первый аргумент (или значение) назначается имени, а второй аргумент (или значение) — возрасту. При изменении позиции или если вы забудете порядок позиций, значения могут быть использованы не в том месте, как показано в приведенном ниже примере Case-2, где 27 присвоено имени, а Suraj — возрасту.

Python3

Вывод:

  Случай-1: 
Привет, я Сурадж
мой возраст 27
  Дело-2: 
Привет, мне 27
Мой возраст Suraj 

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

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

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

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

Python3 9001 7

 Здравствуйте
Добро пожаловать
к
GeeksforGeeks 

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

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

 Функция для проверки, является ли число четным или нечетным 

 Я люблю GeeksforGeeks 

 343
343 

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

Вывод:

 4
16 

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

Python3

Вывод:

 [20, 11, 12, 13, 14, 15] 9 0119 
 Когда мы передаем ссылку и меняем полученную ссылку на что-то другое, разрыв связи между переданным и полученным параметром.  Например, рассмотрим приведенную ниже программу следующим образом: 
  
 Python3 
  
 
 
 
 
  def   myFun(x):  
 
   
 
 9005 3       
 
        
 
        
 
         x   =   [ 90 054  20   ,   30   ,   40   ]  
 
   
 
   9000 5 
  лст   =   [   10   ,   11   ,   12   ,   13  ,   14  ,   15   ]  
 
  myFun(lst)  
 
  печать   (lst)  
 
 
 
 
 
  Вывод:  
 
 [10, 11, 12, 13, 14, 15] 
 Другой пример показывает, что ссылка не работает, если мы присваиваем новое значение (внутри функции).
 Python3 
  def   myFun(x): 
  
       900 54
       
       
         x   =   20 
   900 05
  
  x   =   10 
  myFun(x) 
  печать  9005 3 (х) 
  Вывод: 
 10 
  Упражнение:  Попробуйте угадать вывод следующего кода.
 Python3 
  по умолчанию   swap(x, y): 
         temp   =   x  900 05
         x   =   y 
         y   =   temp 
  
  
  x   =   2 
  y 9 0054  =   3 
  своп(х, у) 
  печать   (x) 
  печать   (y) 
  Вывод:  9000 5
 2
3 
 Быстрые ссылки:  
 Викторина по функциям Python
 Разница между методом и функцией в Python
 Функции первого класса в Python
 Последние статьи о функциях Python.
 
 Функции Python [Полное руководство] — PYnative 
 В Python 9Функция 0003 — это блок кода, определенный с именем . Мы используем функции всякий раз, когда нам нужно выполнить одну и ту же задачу несколько раз без повторного написания одного и того же кода. Он может принимать аргументы и возвращать значение.
 В Python, как и в других языках программирования, используется принцип DRY. DRY означает «Не повторяйся». Рассмотрим сценарий, в котором нам нужно выполнить какое-то действие/задачу много раз. Мы можем определить это действие только один раз, используя функцию, и вызывать эту функцию всякий раз, когда требуется выполнить одно и то же действие.
 Функция повышает эффективность и уменьшает количество ошибок благодаря возможности повторного использования кода. Как только мы создадим функцию, мы сможем вызывать ее где угодно и когда угодно. Преимущество использования функции заключается в возможности повторного использования и модульности.
 Содержание 
 Типы функций
 Создание функции
 Создание функции без параметров
 Создание функции с параметрами
 Создание функции с параметрами и возвращаемым значением
 Вызов функции
 Вызов функции модуля
 Строки документации
 Однострочная строка документации
 Многострочная строка документации
 90 015
 Возврат значения из функции
 Возврат нескольких значений
 Заявление о пропуске
 Как функция работает в Python?
 Объем и время жизни переменных
 Локальная переменная в функции
 Глобальная переменная в функции
 Глобальное ключевое слово в функции
 Нелокальная переменная в функции
 Аргументы функции Python
 Позиционные аргументы
 Аргументы ключевого слова
 Аргументы по умолчанию
 Аргументы переменной длины
 Рекурсивная функция
 Python Anonymous/ Лямбда-функция
 функция filter() в Python
 функция map() в Python
 функция reduce() в Python
 Типы функций 
 Python поддерживает два типа функций
 Встроенная функция
 Пользовательская функция
  Встроенная функция  900 05
 Функции, которые поставляются вместе с самим Python, называются встроенная функция   или предопределенная функция   . Некоторые из них перечислены ниже. 
  range() ,  id() ,  type() ,  input() ,  eval()  и т. д.
  Пример . Функция Python range() генерирует неизменяемую последовательность чисел, начиная с заданного начального целого числа и заканчивая конечным целым числом.
 для 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")
# вызвать функцию по ее имени
message() 
  Output 
 Добро пожаловать в 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  , определяемую пользователем функцию и т. д.
 Однострочная строка документации 
 Однолинейный docstring — это строка документации, умещающаяся в одну строку. Мы можем использовать тройные одинарные или тройные двойные кавычки для его определения. Открывающие и закрывающие кавычки должны быть одинаковыми. По соглашению мы должны использовать тройные двойные кавычки для определения строки документации.
 по умолчанию факториал(х):
    """Эта функция возвращает факториал заданного числа."""
    вернуть х
# доступ к строке документа
print(factorial.__doc__) 
  Output 
 Эта функция возвращает факториал заданного числа 
 Когда вы используете функцию справки для получения информации о любой функции, она возвращает строку документации.
 # передать имя функции в функцию 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 для двух целей:
 Чтобы объявить глобальную переменную внутри функции.
 Объявление переменной глобальной, что делает ее доступной для выполнения модификации.
 Давайте посмотрим, что произойдет, если мы не используем ключевое слово 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  — это ключевое слово, используемое для объявления переменной, которая действует как глобальная переменная для вложенной функции (т. е. функции внутри другой функции).
 Мы можем использовать нелокальное ключевое слово  , когда мы хотим объявить переменную в локальной области, но действовать как глобальная область.
  Пример  
 def external_func():
    х = 777
    определение внутренней_функции():
        # локальная переменная теперь действует как глобальная переменная
        нелокальный х
        х = 700
        print("значение x внутри внутренней функции:", x)
    внутренняя_функция()
    print("значение x внутри внешней функции:", x)
external_func() 
  Выход 
 значение x внутри внутренней функции: 700
значение x внутри внешней функции: 700 
 Аргументы функции Python 
 Аргумент — это значение, переменная или объект, который мы передаем в функцию или вызов метода. В Python разрешены четыре типа аргументов.
 Позиционные аргументы
 Аргументы ключевых слов
 Аргументы по умолчанию
 Аргументы переменной длины
 Прочтите полное руководство по  аргументам функции 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 
  Преимущества рекурсивной функции: 
 Используя рекурсию, мы можем уменьшить длину кода.
 Читабельность кода улучшается за счет сокращения кода.
 Полезно для решения сложной задачи
  Недостаток рекурсивной функции: 
 Рекурсивная функция требует больше памяти и времени для выполнения.
 Отладка рекурсивной функции непроста.
 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] 
 Мы не обязаны писать  явно операторы возврата   в  лямбде 900 54 функция потому что лямбда внутренне возвращает значение выражения.
 Лямбда-функции более полезны, когда мы передаем функцию в качестве аргумента другой функции. Мы также можем использовать лямбда-функцию со встроенными функциями, такими как  filter  ,  map  ,  уменьшить  , потому что эта функция требует другой функции в качестве аргумента.
 Функция filter()  в Python
 В Python функция  filter()  используется для возврата отфильтрованного значения. Мы используем эту функцию для фильтрации значений на основе некоторых условий.
  Синтаксис  filter()  функция: 
 filter(функция, последовательность) 
 где,
 функция – Аргумент функции отвечает за выполнение проверки условия.
 последовательность — Аргументом последовательности может быть что угодно, например список, кортеж, строка
  Пример:  лямбда-функция  с  filter() 6, - 1, -7, 9]
Positive_nos = список (фильтр (лямбда x: x > 0, l))
print("Положительные числа: ", Positive_nos) 

Вывод

 Положительные числа: [5, 12, 6, 9] 

 map(function,sequence)