Привет, друзья! 🌟 Сегодня мы поговорим об анонимных (лямбда) функциях в 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 #Программирование #УчимсяВместе

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

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

🔹 Задачи:

📌 У вас есть два списка товаров, купленных за два дня. Найдите все уникальные товары, купленные за эти два дня.
📌 Даны два множества студентов, посещавших два разных занятия. Найдите студентов, которые посещали оба занятия.
📌 У вас есть список чисел. Удалите все дубликаты, сохранив только уникальные значения.
📌 Найдите разность между двумя множествами чисел.
📌 Даны два множества слов. Найдите слова, которые есть только в одном из этих множеств.
📌 Создайте множество всех уникальных букв, которые встречаются в строке.
📌 Даны два множества чисел. Найдите симметрическую разность между ними.
📌 Найдите все элементы, которые есть в одном множестве, но отсутствуют в другом.
📌 Создайте пустое множество и добавьте в него несколько элементов. Проверьте, как изменяется множество после добавления дубликатов.
📌 У вас есть множество слов. Проверьте, есть ли в множестве слово "Python".
Ждем ваши решения в комментариях! 👇

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

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

#### Особенности множеств:

1. Неупорядоченность:
- Множества в Python неупорядочены. Это значит, что элементы в множестве не имеют определенного порядка, и их порядок может меняться.

   my_set = {3, 1, 4}
   print(my_set)  # Вывод может быть: {1, 3, 4}
   

2. Уникальность элементов:
- В множестве могут храниться только уникальные элементы. Если вы попытаетесь добавить элемент, который уже есть в множестве, он не добавится.

   my_set = {1, 2, 2, 3}
   print(my_set)  # {1, 2, 3}
   

3. Изменяемость:
- Множества изменяемы, что означает, что вы можете добавлять или удалять элементы после создания множества.

   my_set = {1, 2, 3}
   my_set.add(4)
   print(my_set)  # {1, 2, 3, 4}
   

4. Отсутствие индексации:
- Множества не поддерживают индексирование, как списки или строки. Вы не можете обратиться к элементу множества по индексу.

   my_set = {1, 2, 3}
   # my_set[0] вызовет ошибку
   

5. Математические операции:
- Множества поддерживают мощные математические операции: объединение, пересечение, разность, симметрическую разность.

6. Поддержка проверки принадлежности:
- Проверка принадлежности элемента множеству (in) выполняется очень быстро.

   my_set = {1, 2, 3}
   print(2 in my_set)  # True
   

#### Методы множеств:

- add(elem) — добавляет элемент в множество.
- remove(elem) — удаляет элемент из множества, вызывает ошибку, если элемента нет.
- discard(elem) — удаляет элемент, но не вызывает ошибку, если элемента нет.
- pop() — удаляет и возвращает случайный элемент из множества.
- clear() — очищает множество.
- union(*sets) — возвращает объединение множеств.
- intersection(*sets) — возвращает пересечение множеств.
- difference(*sets) — возвращает разность множеств.

#### Задания на закрепление:

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

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

2. Агрегатные функции и сортировка в множествах:
- Множества поддерживают такие функции, как len(), max(), min(), sum(). Сортировка выполняется с помощью функции sorted().

   my_set = {3, 1, 4, 2}
   print(sorted(my_set))  # [1, 2, 3, 4]
   

#### Перебор элементов множества:

- Перебор элементов множества осуществляется с помощью цикла for.

  my_set = {1, 2, 3}
  for elem in my_set:
      print(elem)
  

#### frozenset:

frozenset — это неизменяемый аналог множества. Это множество, элементы которого нельзя изменить после создания.

- Основные отличия:
- set — изменяемое множество.
- frozenset — неизменяемое множество.

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

  my_frozenset = frozenset([1, 2, 3])
  print(my_frozenset)  # frozenset({1, 2, 3})
  

#### Когда использовать set и frozenset:

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

Подробнее о множествах и примеры их использования можно найти по ссылке: Множества в Python.

Видеоурок.

#Python #Программирование #Множества

Привет, друзья! 👋 Пора применить знания о множествах на практике! 📝

🔹 Задания:

📌 Дан список чисел. Удалите из него все дубликаты, используя множества.
📌 Создайте два множества с числами и найдите их пересечение.
📌 Создайте множество из строки и посчитайте количество уникальных символов.
📌 Используйте frozenset для создания неизменяемого множества и попробуйте добавить элемент в это множество. Что произойдет?
📌 Проверьте, является ли элемент принадлежит множеству с помощью операции in.
📌 С помощью множества очистите список от дубликатов и отсортируйте его.
Ждем ваши решения в комментариях! 👇

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

Как преподаватели "поддерживают форму"? Начало читайте здесь.

Все хотят учиться у практиков. И тут противоречие. Если человек практик - зачем ему преподавать, он и так работает, зарабатывает. Где же найти практиков?
Первый тип практиков. ИТ специалист, работает в крупной компании. Любит быть ментором (наставником) и совмещает основную работу с обучением других.
➕Плюсы таких наставников очевидны: они много знают, умеют, практикуют. Им есть что рассказать, чему научить. У них богатый практический опыт.
➖Минусов два.
Первый - не каждый разработчик, хороший учитель. Скорее наоборот, разработчики в большинстве интроверты, не любят общаться, не чувствуют людей, плохо объясняют.
Второй - не всегда сильная теоретическая база. Особенно у самоучек. Например, человек сделал много проектов, но не соблюдает принципы чистого кода, рефакторинга, SOLID.
Второй тип практиков. Преподаватель развивается в практике. Он не только постоянно учится, но и применяет свои знания на практике. Желательно брать реальные проекты в работу, реализовывать их.
➕Плюсы таких наставников. Хорошо умеют объяснять, есть время глубоко погрузиться в материал, дать фундаментальные знания.
➖Минусы. Практический опыт меньше и он либо в пет-проектах, либо в проектах для малого бизнеса. Человек не работает в крупной компании, не может "пощупать" их инструменты и подходы.

К какой категории отношусь я? Скорее ко второй. У меня есть опыт работы в крупной компании, но уже три года я в свободном плавании. И в работу по найму желаний возвращаться нет. Хотя до сих пор зовут. Более того, полгода назад я даже прошел собеседование и прошел процесс онбординга (адаптации). Условия были отличные, но я отказался - не хочу в найм!

Как же я планирую развиваться дальше? Буду брать проекты для малого и среднего бизнеса и реализовывать их со своими учениками. Ученики получают стажировку, деньги, реальные проекты в портфолио. Я получаю практический опыт. Более того, сейчас, мы уже реализуем такой проект, 4 человека из моих учеников уже в деле. Я планирую задействовать еще, тех, кто показал себе способными выполнять сложные задачи.

Всем, кто у меня учится сейчас, я рекомендую показать себя с лучшей стороны, "гореть" в учебе. Мне есть что вам дать, помимо простого обучения. Ну а тем, кто еще не со мной - приходите. Будем расти как профессионалы вместе!

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

#### 🔍 Что такое словарь?

Словарь (dictionary) — это неупорядоченная коллекция пар "ключ-значение". Ключи должны быть уникальными и неизменяемыми, а значения могут быть любыми объектами Python.

# Пример словаря:
student = {"name": "Alice", "age": 25, "grade": "A"}
print(student["name"])  # Выведет: Alice

#### 🔧 Какие задачи можно эффективно решить с помощью словарей?

Словари особенно полезны, когда нужно быстро находить значения по уникальному ключу. Например:
- Хранение и доступ к данным по уникальным идентификаторам (например, имя пользователя — ключ, данные пользователя — значение).
- Подсчет частоты элементов в списке (например, подсчет слов в тексте).
- Сопоставление и быстрый доступ к конфигурационным данным.

#### 🛠 Способы создания словарей:

1. Создание с помощью литералов:

   my_dict = {"apple": 3, "banana": 5}
   

2. Создание с помощью функции `dict()`:

   my_dict = dict(apple=3, banana=5)
   

3. Создание пустого словаря:

   empty_dict = {}
   

4. Создание словаря из списка кортежей:

   my_dict = dict([("apple", 3), ("banana", 5)])
   

5. Словарь с использованием метода `fromkeys()`:

   keys = ["apple", "banana"]
   my_dict = dict.fromkeys(keys, 0)  # {'apple': 0, 'banana': 0}
   

#### Задания для тренировки:

1. Создайте словарь, где ключами будут имена студентов, а значениями — их оценки.
2. Напишите код, который создает словарь из списка чисел, где ключами будут сами числа, а значениями — их квадраты.
3. Подсчитайте количество вхождений каждого слова в тексте и сохраните это в словаре.
4. Создайте словарь, в котором хранится количество букв в каждом слове из списка.

#### 🔄 Изменяемые и неизменяемые типы данных:

- Изменяемые типы данных: списки, словари, множества.
- Неизменяемые типы данных: строки, числа, кортежи, frozenset.

Ключи в словарях должны быть неизменяемыми, чтобы Python мог их хэшировать и быстро находить соответствующее значение.

#### 🔑 Хэширование в Python:

Хэширование — это преобразование данных в уникальное значение фиксированной длины (хэш). В Python ключи словаря хэшируются, что позволяет быстро находить их.

- Можно ли хэшировать кортеж с элементами изменяемых типов?
- Нет! Кортежи с изменяемыми типами (например, списками) нельзя хэшировать, потому что содержимое списка может измениться, что нарушит целостность хэша.

#### 🔍 Какие типы данных могут быть ключами у словарей?

Ключи словарей должны быть неизменяемыми и хэшируемыми. Примеры допустимых типов данных:
- Строки (str)
- Числа (int, float)
- Кортежи (tuple), если все его элементы также неизменяемы

Пример недопустимого ключа:

# Недопустимый ключ - список (изменяемый тип данных)
my_dict = {[1, 2]: "не работает"}  # вызовет ошибку

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

#Python #Программирование #Словари

Привет, друзья! 👋 Время потренироваться в работе со словарями! 📝

🔹 Задания:

📌 Создайте словарь, который сопоставляет имена дней недели и их порядковые номера (например, "Понедельник" — 1).
📌 Напишите код, который создает словарь, где ключами являются слова из списка, а значениями — их длины.
📌 Создайте словарь, который содержит информацию о книгах (название — автор). Добавьте несколько книг в словарь.
📌 Проверьте, является ли ключ "banana" в словаре my_dict. Если нет, добавьте его со значением 10.
📌 Напишите код, который заменяет все значения в словаре на их квадрат.
📌 Создайте вложенный словарь, который хранит информацию о студентах (имя — {возраст, оценка}).
📌 Используйте функцию zip() для создания словаря из двух списков.
Ждем ваши решения в комментариях! 👇

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

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

#### 🔄 Перебор элементов словаря

В Python можно перебирать как ключи, так и значения словаря:

1. Перебор ключей:

   my_dict = {"apple": 3, "banana": 5, "orange": 2}
   for key in my_dict:
       print(key)  # выведет ключи: apple, banana, orange
   

2. Перебор значений:

   for value in my_dict.values():
       print(value)  # выведет значения: 3, 5, 2
   

3. Перебор пар ключ-значение:

   for key, value in my_dict.items():
       print(f"{key}: {value}")  # выведет apple: 3, banana: 5, orange: 2
   

#### 🔍 Отличия словарей от других структур данных:

- Ключ-значение: В отличие от списков и кортежей, в словарях данные хранятся в виде пар "ключ-значение".
- Неупорядоченность: В словарях нет гарантии порядка (до версии Python 3.7), хотя начиная с Python 3.7, они сохраняют порядок добавления.
- Операции поиска и доступа: Доступ к элементу по ключу гораздо быстрее, чем доступ по индексу в списке.

#### 🛠 Методы словарей:

1. `get()` — безопасное получение значения по ключу:

   my_dict.get("apple", 0)  # Вернет 3, если ключ есть, иначе вернет 0
   

2. `keys()` — возвращает список всех ключей:

   my_dict.keys()  # dict_keys(['apple', 'banana', 'orange'])
   

3. `values()` — возвращает список всех значений:

   my_dict.values()  # dict_values([3, 5, 2])
   

4. `items()` — возвращает пары "ключ-значение":

   my_dict.items()  # dict_items([('apple', 3), ('banana', 5), ('orange', 2)])
   

5. `update()` — обновление одного словаря другим:

   my_dict.update({"apple": 4, "grape": 6})  # добавит "grape" и изменит "apple"
   

6. `pop()` — удаление элемента по ключу с возвратом его значения:

   my_dict.pop("banana")  # удалит и вернет значение 5
   

#### 📊 Агрегатные функции и сортировка в словарях:

- Найти максимальное и минимальное значение:

  max_value = max(my_dict.values())  # Найдет максимальное значение (5)
  min_value = min(my_dict.values())  # Найдет минимальное значение (2)
  

- Сортировка словаря по ключам:

  sorted_by_key = dict(sorted(my_dict.items()))  # Сортирует по ключам
  

- Сортировка по значениям:

  sorted_by_value = dict(sorted(my_dict.items(), key=lambda item: item[1]))
  

#### 🔧 Практические примеры использования словарей:

1. Подсчет частоты элементов:

   from collections import Counter
   words = ["apple", "banana", "apple", "orange", "banana", "apple"]
   word_count = Counter(words)  # {'apple': 3, 'banana': 2, 'orange': 1}
   

2. Группировка данных:
Использование словарей для группировки объектов по категориям (например, сортировка студентов по оценкам).

#### 🚀 Распаковка словарей в Python:

Иногда словари можно "распаковывать" в аргументы функций с помощью оператора **.

Пример:

def greet(name, age):
    print(f"Hello, {name}! You are {age} years old.")

person = {"name": "Alice", "age": 25}
greet(**person)  # Hello, Alice! You are 25 years old.

#### 🔗 Оператор объединения словарей:

С появлением Python 3.9 можно использовать оператор | для объединения словарей:

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged_dict = dict1 | dict2  # {'a': 1, 'b': 3, 'c': 4}

Ссылка на полный урок
Видео.

#Python #Программирование #Словари

Учитесь, практикуйте и развивайтесь! 🚀

👋 Пора закрепить знания о словарях с помощью практики! 📝

🔹 Задания:

📌 Создайте словарь, который содержит название городов и их население.
📌 Переберите ключи и значения созданного словаря, выведя их в формате "город: население".
📌 Найдите самый большой и самый маленький город по населению.
📌 Создайте словарь, где ключами будут слова, а значениями — их длины. Выведите этот словарь отсортированным по длине слов.
📌 Используя оператор |, объедините два словаря.
📌 Напишите функцию, которая принимает несколько параметров и распаковывает их из словаря.
📌 Создайте вложенный словарь, где будут храниться данные о студентах и их оценках по разным предметам. Выведите данные по каждому студенту.
Ждем ваши решения в комментариях! 👇

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