🌟 Сегодня мы поговорим о функциях в Python. Функции — это один из самых важных инструментов в программировании, который позволяет организовать код, сделать его повторно используемым и улучшить читаемость. Давайте разберемся, для чего нужны функции, как их создавать и использовать! 🚀

🔹 Для чего нужны функции:

1. Повторное использование кода: функции позволяют написать код один раз и использовать его многократно.
2. Организация кода: функции помогают разбивать код на логические блоки, что делает его более структурированным и читаемым.
3. Упрощение отладки: изолируя отдельные части кода в функции, легче находить и исправлять ошибки.
4. Модульность: функции позволяют делить большие задачи на более мелкие и управляемые части.

🔹 Примеры встроенных функций в Python:

1. print(): выводит сообщение на экран.

   print("Hello, World!")
   # Результат: Hello, World!
   

2. len(): возвращает длину объекта (например, строки или списка).

   my_list = [1, 2, 3]
   print(len(my_list))
   # Результат: 3
   

3. max(): возвращает максимальное значение в списке.

   numbers = [1, 2, 3, 4, 5]
   print(max(numbers))
   # Результат: 5
   

🔹 Создание собственных функций:

1. Определение функции:
- Пример:

     def greet():
         print("Hello, World!")
     

2. Вызов функции:
- Пример:

     greet()
     # Результат: Hello, World!
     

3. Функция с аргументами:
- Пример:

     def greet(name):
         print(f"Hello, {name}!")
     
     greet("Alice")
     # Результат: Hello, Alice!
     

4. Функция с возвратом значения:
- Пример:

     def add(a, b):
         return a + b
     
     result = add(3, 5)
     print(result)
     # Результат: 8
     

🔹 Примеры полезных функций:

1. Функция для вычисления факториала:
- Пример:

     def factorial(n):
         if n == 0:
             return 1
         else:
             return n * factorial(n-1)
     
     print(factorial(5))
     # Результат: 120
     

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

     def is_even(number):
         return number % 2 == 0
     
     print(is_even(4))  # Результат: True
     print(is_even(7))  # Результат: False
     

Подробнее читайте в полном уроке по ссылке: Функции в Python.

Видеоуроки: урок1, урок2, урок3
#Python #Программирование #УчимсяВместе

Привет, друзья! 😊 Давайте закрепим наши знания о функциях с помощью практических задач. 📝

🔹 Задачи:

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

🌟 Сегодня мы углубимся в изучение параметров функций в Python. Функции могут принимать различные типы параметров, что делает их невероятно гибкими. Давайте разберемся с этим подробнее! 🚀

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

1. Функции с различным числом параметров:
- Пример:

     def greet(name, age):
         print(f"Hello, {name}! You are {age} years old.")
     
     greet("Alice", 30)
     # Результат: Hello, Alice! You are 30 years old.
     

2. Функции с переменным числом параметров:
- Пример:

     def greet(*names):
         for name in names:
             print(f"Hello, {name}!")
     
     greet("Alice", "Bob", "Charlie")
     # Результат:
     # Hello, Alice!
     # Hello, Bob!
     # Hello, Charlie!
     

3. Функции с переменным числом именованных параметров:
- Пример:

     def greet(**kwargs):
         for key, value in kwargs.items():
             print(f"{key} is {value}")
     
     greet(name="Alice", age=30, city="New York")
     # Результат:
     # name is Alice
     # age is 30
     # city is New York
     

4. **Явное указание аргументов при вызове функции:**
- Пример:

     def greet(name, age):
         print(f"Hello, {name}! You are {age} years old.")
     
     greet(name="Alice", age=30)
     # Результат: Hello, Alice! You are 30 years old.
     

5. Обязательные и необязательные аргументы. Значения аргументов по умолчанию:
- Пример:

     def greet(name, age=25):
         print(f"Hello, {name}! You are {age} years old.")
     
     greet("Alice")
     # Результат: Hello, Alice! You are 25 years old.
     
     greet("Bob", 30)
     # Результат: Hello, Bob! You are 30 years old.
     

6. Аннотации типов (type hints):
- Пример:

     def greet(name: str, age: int) -> str:
         return f"Hello, {name}! You are {age} years old."
     
     message = greet("Alice", 30)
     print(message)
     # Результат: Hello, Alice! You are 30 years old.
     

7. Union в аннотациях:
- Пример:

     from typing import Union
     
     def display_value(value: Union[int, str]):
         print(f"The value is {value}")
     
     display_value(100)
     # Результат: The value is 100
     
     display_value("Hello")
     # Результат: The value is Hello
     

Подробнее читайте в полном уроке по ссылке: Параметры функций в Python.
Видео по теме.

#Python #Программирование #УчимсяВместе

Привет, друзья! 😊 Давайте закрепим наши знания о параметрах функций с помощью практических задач. 📝

🔹 Задачи:

📌 Напишите функцию, которая принимает имя и возраст, и выводит сообщение. Возраст должен быть необязательным параметром с значением по умолчанию 18.
📌 Напишите функцию, которая принимает переменное число неименованных аргументов и возвращает их сумму.
📌 Напишите функцию, которая принимает переменное число именованных аргументов и выводит ключи и значения.
📌 Напишите функцию, которая принимает список чисел и возвращает их среднее значение. Используйте аннотации типов.
📌 Напишите функцию, которая принимает строку или число (используйте Union в аннотациях) и выводит сообщение, указывая тип аргумента.
📌 Напишите функцию, которая принимает три параметра: обязательное имя, необязательный возраст и необязательный город. Возраст должен быть по умолчанию 25, а город — "Unknown".
📌 Напишите функцию, которая принимает два числа и возвращает их произведение. Используйте явное указание аргументов при вызове функции.
📌 Напишите функцию, которая принимает список строк и возвращает строку, объединяя все элементы списка через пробел.
📌 Напишите функцию, которая принимает переменное число чисел и возвращает их максимум.
📌 Напишите функцию, которая принимает строку и необязательный символ-разделитель (по умолчанию пробел) и возвращает список слов.
Ждем ваши решения в комментариях! 👇

🌟 Сегодня мы поговорим о локальных и глобальных переменных в Python. Это важная тема, которая помогает понять, как управлять данными в программе и избегать конфликтов. Давайте разберемся! 🚀

🔹 Определение локальной и глобальной переменной:

1. Глобальные переменные:
- Глобальные переменные объявляются вне всех функций и доступны из любого места в коде.
- Пример:

     x = 10  # глобальная переменная

     def print_global():
         print(x)  # доступ к глобальной переменной

     print_global()  # Результат: 10
     

2. Локальные переменные:
- Локальные переменные объявляются внутри функции и доступны только в этой функции.
- Пример:

     def print_local():
         y = 5  # локальная переменная
         print(y)

     print_local()  # Результат: 5
     # print(y)  # Ошибка: переменная y не доступна вне функции
     

🔹 Глобальная и локальная переменная с одинаковым именем:

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

  x = 10  # глобальная переменная

  def print_variables():
      x = 5  # локальная переменная
      print(x)  # вывод локальной переменной

  print_variables()  # Результат: 5
  print(x)  # Результат: 10
  

🔹 Конфликты локальных и глобальных переменных:

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

  x = 10  # глобальная переменная

  def modify_global():
      global x
      x = 5  # изменение глобальной переменной
      print(x)  # вывод измененной глобальной переменной

  modify_global()  # Результат: 5
  print(x)  # Результат: 5
  

- Без использования global:

  x = 10  # глобальная переменная

  def modify_variable():
      x = 5  # локальная переменная
      print(x)  # вывод локальной переменной

  modify_variable()  # Результат: 5
  print(x)  # Результат: 10
  

Подробнее читайте в полном уроке по ссылке: Локальные и глобальные переменные в Python.
Еще смотрите видео по теме.

#Python #Программирование #УчимсяВместе

Привет, друзья! 😊 Давайте закрепим наши знания о локальных и глобальных переменных с помощью практических задач. 📝

🔹 Задачи:

📌 Напишите программу, в которой глобальная переменная изменяется внутри функции с использованием ключевого слова global.
📌 Создайте функцию, в которой объявлена локальная переменная с тем же именем, что и глобальная, и выведите обе переменные.
📌 Напишите функцию, которая выводит значение глобальной переменной, не изменяя её.
📌 Создайте программу, в которой глобальная переменная используется для хранения счетчика вызовов функции.
📌 Напишите функцию, которая принимает глобальную переменную, изменяет её и возвращает новое значение.
Ждем ваши решения в комментариях! 👇

#Python #Программирование #Практика

🌟 Сегодня мы поговорим о функциях в Python и о том, как их можно использовать как переменные (объекты). Это важная тема, которая помогает создавать более гибкий и динамичный код. Давайте разберемся! 🚀

🔹 Функции как переменные (объекты):

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

1. Присвоение функции переменной:
- Пример:

     def greet(name):
         return f"Hello, {name}!"

     greeting = greet  # присваиваем функцию переменной
     print(greeting("Alice"))  # Результат: Hello, Alice!
     

2. Передача функции как аргумента:
- Пример:

     def apply_function(func, value):
         return func(value)

     def square(x):
         return x * x

     result = apply_function(square, 5)
     print(result)  # Результат: 25
     

3. Возврат функции из функции:
- Пример:

     def outer_function():
         def inner_function():
             return "Hello from inner function!"
         return inner_function

     inner = outer_function()
     print(inner())  # Результат: Hello from inner function!
     

🔹 Практические примеры:

1. Динамический выбор функции в зависимости от условия:
- Пример:

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

     def subtract(x, y):
         return x - y

     def choose_operation(operation):
         if operation == "add":
             return add
         elif operation == "subtract":
             return subtract

     operation_func = choose_operation("add")
     print(operation_func(10, 5))  # Результат: 15

     operation_func = choose_operation("subtract")
     print(operation_func(10, 5))  # Результат: 5
     

2. Динамическая сортировка данных:
- Пример:

     data = [("Alice", 30), ("Bob", 25), ("Charlie", 35)]

     def sort_by_name(item):
         return item[0]

     def sort_by_age(item):
         return item[1]

     data.sort(key=sort_by_name)
     print(data)  # Результат: [('Alice', 30), ('Bob', 25), ('Charlie', 35)]

     data.sort(key=sort_by_age)
     print(data)  # Результат: [('Bob', 25), ('Alice', 30), ('Charlie', 35)]
     

3. Роутинг в веб-приложениях:
- Пример:

     def home():
         return "Welcome to the Home Page"

     def about():
         return "About Us"

     def not_found():
         return "404 Not Found"

     routes = {
         "/": home,
         "/about": about,
     }

     def handle_request(path):
         return routes.get(path, not_found)()

     print(handle_request("/"))  # Результат: Welcome to the Home Page
     print(handle_request("/about"))  # Результат: About Us
     print(handle_request("/contact"))  # Результат: 404 Not Found
     

Подробнее читайте в полном уроке по ссылке: Функции как переменные в Python.
Видео разбор темы смотрите здесь.

#Python #Программирование #УчимсяВместе

Привет, друзья! 😊 Давайте закрепим наши знания о функциях как переменных с помощью практических задач. 📝

🔹 Задачи:

📌 Напишите программу, которая выбирает и вызывает одну из двух функций в зависимости от значения переданного аргумента.
📌 Напишите функцию, которая принимает другую функцию и значение, и возвращает результат вызова переданной функции с этим значением.
📌 Напишите программу, которая сортирует список кортежей по второму элементу, используя функцию в качестве ключа для сортировки.
📌 Реализуйте простую систему маршрутизации для веб-приложения, где каждый URL-адрес соответствует определенной функции.
📌 Напишите программу, которая передает функцию как аргумент другой функции и возвращает результат выполнения.
📌 Создайте список функций и вызовите каждую из них в цикле, передавая разные аргументы.
📌 Напишите функцию, которая возвращает другую функцию, и вызовите возвращенную функцию.
📌 Напишите программу, которая динамически выбирает функцию для выполнения на основе введенного пользователем значения.
📌 Реализуйте функцию, которая сортирует список слов по их длине, используя функцию в качестве ключа для сортировки.
📌 Напишите программу, которая вызывает разные функции в зависимости от переданного флага (например, 'start' или 'stop').

Привет, друзья! 🌟 Сегодня мы поговорим об анонимных (лямбда) функциях в Python. Эти функции позволяют писать более краткий и удобный код. Давайте разберемся, что это такое и как их использовать! 🚀

🔹 Обычные и лямбда функции:

1. Обычные функции:
- Пример:

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

     result = add(5, 3)
     print(result)  # Результат: 8
     

2. Лямбда функции:
- Пример:

     add = lambda x, y: x + y

     result = add(5, 3)
     print(result)  # Результат: 8
     

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

🔹 Удобство использования лямбда функций:

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

1. Функция `list`:
- Пример:

     numbers = list(map(lambda x: x * 2, [1, 2, 3, 4, 5]))
     print(numbers)  # Результат: [2, 4, 6, 8, 10]
     

2. Функция `map`:
- Пример:

     numbers = [1, 2, 3, 4, 5]
     squares = list(map(lambda x: x ** 2, numbers))
     print(squares)  # Результат: [1, 4, 9, 16, 25]
     

3. **Функция filter:**
- Пример:

     numbers = [1, 2, 3, 4, 5]
     even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
     print(even_numbers)  # Результат: [2, 4]
     

🔹 Лямбда функции с несколькими аргументами:

- Пример:

  add_and_multiply = lambda x, y, z: x + y * z

  result = add_and_multiply(2, 3, 4)
  print(result)  # Результат: 14
  

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

Подробнее читайте в полном уроке по ссылке: Анонимные (лямбда) функции в Python.
Традиционное видео.

#Python #Программирование #УчимсяВместе

Пишите, если будут вопросы! Удачи в изучении Python! 🚀

😊 Давайте закрепим наши знания о лямбда функциях с помощью практических задач. 📝

🔹 Задачи:

📌 Напишите лямбда функцию, которая возвращает квадрат числа.
📌 Используя map и лямбда функцию, создайте список из кубов чисел от 1 до 10.
📌 С помощью filter и лямбда функции создайте список из чисел от 1 до 20, которые делятся на 3.
📌 Напишите лямбда функцию с тремя аргументами, которая возвращает их сумму.
📌 Используя лямбда функцию, отсортируйте список кортежей по второму элементу.
📌 Примените map с лямбда функцией, чтобы преобразовать список строк в список их длин.
📌 Напишите лямбда функцию, которая возвращает True, если переданное число четное, и False в противном случае.
📌 Создайте список имен и используйте filter с лямбда функцией, чтобы оставить только те имена, которые начинаются с буквы 'A'.
📌 Напишите лямбда функцию, которая принимает два аргумента и возвращает большее из них.
📌 Используя map и лямбда функцию, преобразуйте список температур в градусах Цельсия в список температур в градусах Фаренгейта.

🌟 Сегодня мы разберем важную тему в программировании — рекурсию. Рекурсия позволяет функции вызывать саму себя для решения задачи, которая может быть разделена на более простые подзадачи. Давайте углубимся в принцип работы рекурсивных функций и посмотрим, как их использовать. 🚀

🔹 Принцип работы рекурсивной функции:

Рекурсия — это когда функция вызывает саму себя. Важно, чтобы рекурсивная функция имела:
1. Базовый случай — условие, при котором рекурсия прекращается.
2. Рекурсивный случай — вызов самой себя с новыми аргументами.

🔹 Пример базового и рекурсивного случаев:

Рассмотрим пример вычисления факториала числа:

- Факториал числа n (n!) — это произведение всех целых чисел от 1 до n.
- Например, 5! = 5 * 4 * 3 * 2 * 1 = 120

Пример рекурсивной функции для вычисления факториала:

def factorial(n):
    if n == 1:  # Базовый случай
        return 1
    else:
        return n * factorial(n - 1)  # Рекурсивный случай

print(factorial(5))  # Результат: 120

🔹 Как избежать бесконечной рекурсии:

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

Пример бесконечной рекурсии:

def infinite_recursion():
    return infinite_recursion()

infinite_recursion()  # Приведет к ошибке: RecursionError: maximum recursion depth exceeded

🔹 Стек вызовов функций:

Когда функция вызывает саму себя, все её незавершенные вызовы сохраняются в специальной структуре данных — стеке вызовов. Стек — это структура данных, работающая по принципу LIFO (Last In, First Out), что означает: последняя вызванная функция завершится первой.

🔹 Пример стека вызовов на примере вычисления факториала:

Рассмотрим выполнение factorial(3):

1. factorial(3) вызывает factorial(2)
2. factorial(2) вызывает factorial(1)
3. factorial(1) возвращает 1
4. factorial(2) возвращает 2 * 1 = 2
5. factorial(3) возвращает 3 * 2 = 6

Последовательность выполнения в стеке вызовов:

- Вызов factorial(3)
- Вызов factorial(2)
- Вызов factorial(1) → Возврат 1
- Возврат 2
- Возврат 6

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

Подробнее читайте в полном уроке по ссылке: Рекурсия в Python.
Видео про рекурсию.

#Python #Программирование #УчимсяВместе

Привет, друзья! 😊 Пришло время закрепить наши знания о рекурсии на практике. 📝

🔹 Задачи:

📌 Напишите рекурсивную функцию для вычисления суммы всех чисел в списке.
📌 Реализуйте рекурсивную функцию для вычисления числа Фибоначчи.
📌 Напишите рекурсивную функцию для вычисления наибольшего общего делителя (НОД) двух чисел.
📌 Создайте рекурсивную функцию для определения, является ли строка палиндромом.
📌 Реализуйте рекурсивную функцию для нахождения максимального элемента в списке.
📌 Напишите рекурсивную функцию для вычисления степени числа (например, 2^n).
📌 Создайте рекурсивную функцию для подсчета количества элементов в списке.
📌 Реализуйте функцию, которая использует рекурсию для нахождения всех возможных перестановок строки.
📌 Напишите рекурсивную функцию для вычисления произведения всех элементов в списке.
📌 Создайте рекурсивную функцию для нахождения суммы цифр числа.
Ждем ваши решения в комментариях! 👇

#Python #Программирование #Практика

🌟 Сегодня поговорим о вложенных функциях в Python, замыканиях, локальных функциях и переменных nonlocal. Эти концепции помогают создавать более организованный и мощный код. Давайте разберемся, как это работает! 🚀

🔹 Вложенные функции:

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

Пример:

def outer_function(text):
    def inner_function():
        print(text)
    inner_function()

outer_function("Привет, мир!")  # Результат: Привет, мир!

Здесь inner_function доступна только внутри outer_function и не может быть вызвана напрямую извне.

🔹 Организация замыкания в Python:

Замыкание — это функция, которая "помнит" значения переменных из окружающего контекста, даже если этот контекст уже завершил выполнение.

Пример замыкания:

def outer_function(text):
    def inner_function():
        return text
    return inner_function

closure = outer_function("Замыкание в действии!")
print(closure())  # Результат: Замыкание в действии!

Здесь inner_function сохраняет значение text из outer_function, даже после завершения её работы.

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

Локальные функции — это функции, объявленные внутри других функций. Они имеют доступ ко всем переменным внешней функции.

Пример:

def calculate_area(radius):
    pi = 3.14
    def area():
        return pi * (radius ** 2)
    return area()

result = calculate_area(5)
print(result)  # Результат: 78.5

Здесь area() — это локальная функция, которая имеет доступ к переменным pi и radius из внешней функции calculate_area.

🔹 **Переменные nonlocal:**

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

Пример использования nonlocal:

def outer_function():
    count = 0
    
    def inner_function():
        nonlocal count
        count += 1
        return count
    
    return inner_function()

print(outer_function())  # Результат: 1
print(outer_function())  # Результат: 1 (снова 1, потому что внешняя функция заново определяет count)

Здесь nonlocal позволяет изменять значение count внутри inner_function.

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

#Python #Программирование #УчимсяВместе
Не забывайте пробовать новое и экспериментировать с кодом! Удачи в изучении Python! 🚀

🔹 Задачи:

📌 Напишите вложенную функцию, которая принимает строку и возвращает её длину.
📌 Создайте замыкание, которое добавляет к числу фиксированное значение, переданное при создании замыкания.
📌 Напишите функцию с вложенной функцией, которая вычисляет периметр прямоугольника, используя длину и ширину, переданные в основную функцию.
📌 Используйте nonlocal для изменения переменной во вложенной функции, чтобы отслеживать количество вызовов этой функции.
📌 Реализуйте замыкание, которое возвращает функцию, увеличивающую число на заданное значение при каждом вызове.
📌 Напишите функцию с локальной функцией для вычисления площади и периметра квадрата.
📌 Создайте замыкание, которое будет умножать переданное значение на определенное число, переданное при создании замыкания.
📌 Используйте вложенные функции для реализации простого калькулятора, который поддерживает сложение, вычитание, умножение и деление.
📌 Напишите функцию с локальной функцией, которая будет выводить сообщение в консоль с заданным количеством восклицательных знаков.
📌 Реализуйте функцию с вложенной функцией, которая проверяет, содержит ли список переданное значение, используя замыкание.

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

🔹 Синтаксис декоратора:

Декоратор — это функция, которая принимает другую функцию в качестве аргумента и возвращает новую функцию, которая заменяет исходную.

Пример простого декоратора:

def my_decorator(func):
    def wrapper():
        print("Выполняем функцию...")
        func()
        print("Функция выполнена!")
    return wrapper

@my_decorator
def say_hello():
    print("Привет!")

say_hello()

Здесь декоратор @my_decorator оборачивает функцию say_hello, добавляя перед и после её выполнения дополнительные действия.

🔹 Практическое применение декораторов:

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

Пример логирования:

   def log_decorator(func):
       def wrapper(*args, **kwargs):
           print(f"Вызов функции {func.__name__} с аргументами {args} и {kwargs}")
           result = func(*args, **kwargs)
           print(f"Функция {func.__name__} вернула результат {result}")
           return result
       return wrapper

   @log_decorator
   def add(a, b):
       return a + b

   add(3, 4)
   

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

Пример кэширования:

   def cache_decorator(func):
       cache = {}
       def wrapper(n):
           if n in cache:
               return cache[n]
           result = func(n)
           cache[n] = result
           return result
       return wrapper

   @cache_decorator
   def fibonacci(n):
       if n in (0, 1):
           return n
       return fibonacci(n-1) + fibonacci(n-2)

   print(fibonacci(10))
   

🔹 Декораторы с параметрами:

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

Пример декоратора с параметрами:

def repeat_decorator(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat_decorator(3)
def say_hello():
    print("Привет!")

say_hello()

Здесь декоратор @repeat_decorator(3) заставляет функцию say_hello выполняться трижды.

Подробнее читайте в полном уроке по ссылке: Декораторы в Python.
Видео

#Python #Программирование #УчимсяВместе

Привет, друзья! 😊 Давайте закрепим наши знания о декораторах с помощью практических задач. 📝

🔹 Задачи:

📌 Напишите декоратор, который выводит в консоль время выполнения функции.
📌 Создайте декоратор, который проверяет, вошел ли пользователь в систему перед выполнением функции.
📌 Напишите декоратор, который кэширует результаты вычисления функции, принимающей несколько аргументов.
📌 Реализуйте декоратор с параметром, который повторяет выполнение функции заданное количество раз.
📌 Создайте декоратор, который будет оборачивать вызов функции в попытку (try) и, в случае ошибки, будет выводить сообщение об ошибке в консоль.
📌 Напишите декоратор, который добавляет перед функцией приветственное сообщение, передаваемое через параметр декоратора.
📌 Реализуйте декоратор для ограничения частоты вызова функции, чтобы функция могла выполняться не чаще одного раза в секунду.
📌 Создайте декоратор, который будет выводить на экран количество вызовов функции.
📌 Напишите декоратор, который логирует аргументы и результат выполнения функции в текстовый файл.
📌 Реализуйте декоратор, который превращает все строки, возвращаемые функцией, в верхний регистр.
Ждем ваши решения в комментариях! 👇

Привет, друзья! 👋 Сегодня поговорим о полезном модуле в Python — functools. Этот модуль содержит несколько полезных инструментов для работы с функциями и улучшения их функциональности. Рассмотрим, как его использовать на практике! 🚀

🔹 Модуль functools:

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

#### Примеры практического применения:

1. Кэширование для ускорения рекурсивных вычислений:

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

Пример использования lru_cache:

   from functools import lru_cache

   @lru_cache(maxsize=None)
   def fibonacci(n):
       if n < 2:
           return n
       return fibonacci(n-1) + fibonacci(n-2)

   print(fibonacci(50))  # Вычисляется очень быстро благодаря кэшированию!
   

Здесь lru_cache кэширует результаты функции fibonacci, что позволяет избегать повторных вычислений.

2. Обертывание функции с фиксированными аргументами:

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

Пример использования partial:

   from functools import partial

   def power(base, exponent):
       return base ** exponent

   square = partial(power, exponent=2)
   cube = partial(power, exponent=3)

   print(square(4))  # Результат: 16
   print(cube(3))    # Результат: 27
   

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

3. **Декоратор для проверки типов аргументов:**

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

   from functools import wraps

   def type_check(expected_type):
       def decorator(func):
           @wraps(func)
           def wrapper(*args, **kwargs):
               if any(not isinstance(arg, expected_type) for arg in args):
                   raise TypeError(f"Все аргументы должны быть типа {expected_type}")
               return func(*args, **kwargs)
           return wrapper
       return decorator

   @type_check(int)
   def add(a, b):
       return a + b

   print(add(3, 4))  # Результат: 7
   print(add(3, "4"))  # Выбросит TypeError
   

Этот декоратор проверяет тип всех аргументов и выбрасывает ошибку, если тип не соответствует ожидаемому.

---

Подробнее читайте в полном уроке по ссылке: Практическое применение functools в Python.

#Python #Программирование #УчимсяВместе

Учитесь, экспериментируйте и наслаждайтесь кодом! 🚀

😊 Время для практики! Давайте применим наши знания о functools на практике с помощью нескольких задач. 📝

🔹 Задачи:

📌 Используйте lru_cache для оптимизации вычислений факториала числа.
📌 Создайте функцию, которая принимает два числа и возвращает их сумму. Используйте partial, чтобы создать новую функцию, которая всегда добавляет к числу 10.
📌 Напишите декоратор с помощью functools, который будет проверять, что все аргументы функции являются строками.
📌 Используйте lru_cache для ускорения вычисления чисел Фибоначчи в рекурсивной функции.
📌 Реализуйте декоратор с functools.wraps, который логирует аргументы и возвращаемое значение функции.
📌 Напишите функцию с помощью partial, которая фиксирует первый аргумент функции power, создавая функцию, которая всегда возводит число в степень 2.
📌 Создайте декоратор для функции, который проверяет, что все переданные аргументы являются списками.
📌 Используйте lru_cache для кэширования результата функции, которая рассчитывает сумму чисел от 1 до n.
📌 Реализуйте декоратор с functools, который выводит на экран время выполнения функции.
📌 Напишите функцию с partial, которая будет выводить приветствие с фиксированным именем пользователя.
Ждем ваши решения в комментариях! 👇

#Python #Программирование #Практика

▶️ Реальное live-coding собеседование Junior Python разработчик

Сегодня вы увидите реальное собеседование на Python Backend разработчика, на котором мне предложили 100.000 рублей

В видео вы увидите live-coding, рассмотрим три практические задачи по уроню сложности

👀 Смотреть на YouTube

### Пост 1: Теория

Привет, друзья! 👋 Сегодня обсудим множества в Python. Это мощный инструмент, который поможет вам работать с уникальными элементами и решать задачи, связанные с теорией множеств. Давайте разберемся, что это такое и как их использовать на практике! 🚀

🔹 Что такое множества?

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

🔹 Создание множеств в Python:

Множество можно создать несколькими способами:

- Создание множества с элементами:

  fruits = {"яблоко", "банан", "вишня"}
  print(fruits)  # {"яблоко", "банан", "вишня"}
  

- Создание пустого множества:

Для создания пустого множества используйте функцию set(). Не путайте с {}, так как это синтаксис для создания пустого словаря.

  empty_set = set()
  print(empty_set)  # set()
  

- Создание множества из списка или строки:

  numbers = set([1, 2, 3, 4, 4, 5])
  print(numbers)  # {1, 2, 3, 4, 5}

  chars = set("hello")
  print(chars)  # {"h", "e", "l", "o"}
  

🔹 Пример использования множеств:

Представьте, что у вас есть список студентов, посетивших занятия, и вам нужно узнать, кто посещал их хотя бы один раз.

students_day1 = {"Анна", "Борис", "Виктор"}
students_day2 = {"Борис", "Галина", "Дмитрий"}

# Объединение множеств покажет всех, кто посетил занятия
all_students = students_day1.union(students_day2)
print(all_students)  # {"Анна", "Борис", "Виктор", "Галина", "Дмитрий"}

🔹 Операции над множествами:

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

1. Объединение (Union): объединяет два множества, возвращая новое множество, содержащее все уникальные элементы.

   set1 = {1, 2, 3}
   set2 = {3, 4, 5}
   union_set = set1.union(set2)
   print(union_set)  # {1, 2, 3, 4, 5}
   

2. Пересечение (Intersection): возвращает новое множество, содержащее только общие элементы из обоих множеств.

   intersection_set = set1.intersection(set2)
   print(intersection_set)  # {3}
   

3. Разность (Difference): возвращает новое множество, содержащее элементы, которые есть в одном множестве, но отсутствуют в другом.

   difference_set = set1.difference(set2)
   print(difference_set)  # {1, 2}
   

4. Симметрическая разность (Symmetric Difference): возвращает новое множество, содержащее элементы, которые есть в одном из множеств, но отсутствуют в другом.

   sym_diff_set = set1.symmetric_difference(set2)
   print(sym_diff_set)  # {1, 2, 4, 5}
   

5. Дополнение (Complement): операция дополнения не реализована как отдельная операция в Python, но ее можно представить как разность универсального множества и исходного.

   universal_set = {1, 2, 3, 4, 5, 6}
   complement_set = universal_set.difference(set1)
   print(complement_set)  # {4, 5, 6}
   

Подробнее читайте в полном уроке по ссылке: Множества в Python.

Видео: ссылка на урок по множествам.

#Python #Программирование #УчимсяВместе

Учитесь, экспериментируйте и наслаждайтесь программированием! 🚀