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

🔹 Задачи:

📌 Напишите рекурсивную функцию для вычисления суммы всех чисел в списке.
📌 Реализуйте рекурсивную функцию для вычисления числа Фибоначчи.
📌 Напишите рекурсивную функцию для вычисления наибольшего общего делителя (НОД) двух чисел.
📌 Создайте рекурсивную функцию для определения, является ли строка палиндромом.
📌 Реализуйте рекурсивную функцию для нахождения максимального элемента в списке.
📌 Напишите рекурсивную функцию для вычисления степени числа (например, 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! 🚀

🌟 Сегодня мы познакомимся с одной из мощных возможностей 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 #Программирование #УчимсяВместе

Привет, друзья! 👋 Сегодня поговорим о полезном модуле в 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 #Программирование #Практика

### Пост 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 #Программирование #УчимсяВместе

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