👩‍💻Итераторы и генераторы в Python

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

💡Итератор — это объект, который позволяет перебирать элементы одной за другой. Любой объект, поддерживающий протокол итераций, должен реализовать методы:
iter(): Возвращает сам итератор
next(): Возвращает следующий элемент последовательности или вызывает исключение StopIteration, когда элементы заканчиваются.

Пример создания итератора:

class MyIterator:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        self.current += 1
        return self.current - 1

my_iter = MyIterator(0, 3)
for num in my_iter:
    print(num) # 1 2

✨Генераторы — это особый вид итераторов, которые упрощают создание итераторов. Они автоматически поддерживают протокол итерации и создаются с помощью ключевого слова yield. В отличие от обычных функций, которые возвращают результат и завершаются, генераторы "приостанавливают" своё выполнение и "возвращаются" в то место, где остановились, при следующем вызове.

Пример генератора:

def my_generator(start, end):
    while start < end:
        yield start
        start += 1

for num in my_generator(0, 3):
    print(num) # 1 2

👀Итераторы и генераторы — это инструменты, которые позволяют обрабатывать данные "лениво", экономя память и делая код более производительным. Итераторы требуют больше кода для реализации, тогда как генераторы позволяют реализовать то же самое гораздо проще.
😃Эта тема может показаться бесполезной, но будьте уверены, что вас спросят об этом на собеседовании
#PyLearn

🐍Питай код с PyCode

👩‍💻Основные принципы ООП: Наследование (1/3)

❓Что такое наследование?
Наследование позволяет создавать новые классы на основе уже существующих, заимствуя у них функционал и добавляя новый. Класс, который наследует другой класс, называется дочерним (или подклассом), а класс, от которого идёт наследование, — родительским (или базовым).

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

💡Представьте, что у нас есть базовый класс Animal, который содержит общие атрибуты и методы для всех животных, такие как move() (двигаться) или sleep() (спать). Дочерние классы, такие как Dog или Cat, могут наследовать эти методы, а также добавлять свои уникальные.

class Animal:
    def move(self):
        print("Животное двигается")

class Dog(Animal):
    def bark(self):
        print("Собака лает")

dog = Dog()
dog.move() # Животное двигается

Здесь Dog наследует поведение от Animal, но может также иметь свои собственные методы, как bark().

🥺Зачем нужно наследование?
Повторное использование кода: Вместо того чтобы писать одинаковый код для нескольких классов, можно вынести общую логику в родительский класс и наследовать её.
Упрощение структуры программы: Наследование позволяет организовать классы в иерархическую структуру, что делает код более логичным и структурированным.
Расширяемость: Дочерние классы могут переопределять или расширять функционал родительского класса, адаптируя его под свои нужды.

😵‍💫В Python класс может наследовать от нескольких родительских классов одновременно, однако это может усложнить код и сделать его менее понятным (для более подробного изучения этого механизма вам стоит изучить ознакомиться с механизмом MRO)
#PyLearn #ООП

🐍Питай код с PyCode

👩‍💻Как работают try, except, finally и else в Python

🚽Что такое обработка исключений?
Когда возникает ошибка, Python генерирует исключение. Если это исключение не обработано, программа завершится с ошибкой. Блоки try-except позволяют вам "ловить" такие ошибки и обрабатывать их, не прерывая выполнение программы.

🥺Как работает try и except?
В блоке try помещается код, который может вызвать ошибку. Если ошибка возникает, программа переходит в блок except, где вы можете её обработать.

try:
    result = 10 / 0
except ZeroDivisionError as error:
    print("Ошибка: деление на ноль невозможно")
    print(f"Пойманная ошибка - {error}") # python позволяет поместить пойманную ошибку в переменную

В этом примере, когда возникает ошибка ZeroDivisionError (деление на ноль), программа не завершится с аварией, а перейдёт к блоку except и выведет сообщение.

💡Блок except позволяет обрабатывать как конкретные ошибки, так и абсолютно любые

try:
    # кусок кода, который может вызвать ошибку
except:
    # код зайдет в блок except при любом искючении

👀Зачем нужны блоки finally и else?
Блок finally выполняется всегда, независимо от того, произошло исключение или нет. Он используется для выполнения завершающих действий, таких как освобождение ресурсов, закрытие файлов или завершение операций, которые должны быть выполнены в любом случае.
Блок else выполняется только если ошибок не возникло в блоке try. Это полезно, когда нужно выполнить действия, которые зависят от успешного выполнения кода в блоке try, но они сами по себе не должны обрабатываться в блоке except.

💻Конструкция try-except позволяют программам не падать при возникновении ошибок и дают возможность контролировать их поведение. Использование этих механизмов помогает предотвратить аварийные завершения программы и обеспечивает правильное освобождение ресурсов.
#PyLearn

🐍Питай код с PyCode

👩‍💻f-строки в Python

💡f-строки (или форматированные строки) — это один из самых удобных способов форматировать строки в Python. Они были введены в версии 3.6 и значительно упростили подстановку переменных и выражений в текст. Форматирование с помощью f-строк читается проще, быстрее пишется и зачастую работает эффективнее по сравнению с другими методами.

☄️Для создания f-строки перед открывающей кавычкой добавляется символ f, а внутри строки в фигурных скобках {} можно вставлять переменные и выражения.

x = 10
y = 20
print(f"Сумма {x} и {y} равна {x + y}") # Сумма 10 и 20 равна 30

🥺Сравнение с str.format():

name = "PyCode"
age = 5

# Старый метод format
formatted_string = "Привет, {0}, тебе {1} лет.".format(name, age)

# f-строка
formatted_string = f"Привет, {name}, тебе {age} лет."

С f-строками нет необходимости отслеживать порядок подстановок — код становится более читаемым и интуитивным.

❗️Полезные возможности f-строк:
Округление чисел: Можно легко управлять форматированием чисел прямо в f-строке.

pi = 3.14159
print(f"Число π: {pi:.2f}") # Вывод: Число π: 3.14

Вызов функций: Внутри f-строки можно вызывать функции и методы.

name = "pycode"
print(f"Имя в верхнем регистре: {name.upper()}") # Вывод: Имя в верхнем регистре: PYCODE

📖Использование f-строк упрощает работу с форматированием строк, делает код чище и быстрее. Это важный инструмент для любого Python-разработчика.
#PyLearn

🐍Питай код с PyCode

👩‍💻Аргументы в функциях

👍В Python существует несколько способов передавать данные в функции с помощью аргументов.
Разберём основные виды: позиционные, именованные, а также специальные аргументы *args и **kwargs (но их разберем чуть позже).

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

def greet(name, age):
    print(f"Привет, {name}! Тебе {age} лет.")

greet('Alex', 25)  # Позиционные аргументы

Здесь, 'Alex' передаётся параметру name, а 25 — параметру age. Если поменять порядок аргументов при вызове функции, результат будет некорректным.

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

    print(f"Привет, {name}! Тебе {age} лет.")

pythongreet(age=25, name='Alex')

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

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

def greet(name, age=30):
    print(f"Привет, {name}. Тебе {age} лет.")

greet('Alex')  # age будет 30 по умолчанию

🤩Понимание различных типов аргументов помогает писать гибкие и универсальные функции.
#PyLearn

🐍Питай код с PyCode

👩‍💻Аргументы *args и **kwargs в Python

💬Python предлагает гибкий механизм передачи аргументов в функции с помощью специальных аргументов: *args и **kwargs. Эти конструкции позволяют передавать в функции произвольное количество позиционных и именованных аргументов.

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

Пример:

python
def greet(*args):
    for name in args:
        print(f"Привет, {name}!")

greet('Alice', 'Bob', 'Charlie')  # Выведет приветствия

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

💪kwargs — именованные аргументы kwargs применяется для передачи произвольного количества именованных аргументов. Такие аргументы передаются в виде словаря, где ключами являются имена аргументов, а значениями — переданные данные.

Пример:

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="New York")

Здесь можно передать любое количество аргументов с ключами (именами), и они будут собраны в словарь. Это полезно, когда вы не уверены, какие именно аргументы могут быть переданы.

🎧*args и **kwargs позволяют писать функции, которые могут принимать произвольное количество аргументов, что делает ваш код более гибким и универсальным. *args собирает позиционные аргументы в кортеж, а **kwargs сохраняет именованные аргументы в словарь. Эта функциональность позволяет обрабатывать различные ситуации и упрощает разработку сложных систем.
#PyLearn

🐍Питай код с PyCode

👩‍💻Основные принципы ООП: Инкапсуляция (2/3)

🏎Инкапсуляция — это ключевой принцип объектно-ориентированного программирования (ООП), который позволяет скрывать внутренние детали объекта и контролировать доступ к его данным. Она помогает защищать важную информацию и организовать чёткий интерфейс класса — набор публичных методов, через которые другие объекты могут взаимодействовать с классом.

😵‍💫Как работает инкапсуляция?
В Python инкапсуляция реализуется через сокрытие атрибутов:
Приватные атрибуты (например, __атрибут) скрыты и недоступны вне класса.
Защищённые атрибуты (например, _атрибут) доступны, но не предназначены для прямого использования за пределами класса.
Пример приватного атрибута:

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Приватный атрибут

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

🤩Зачем нужна инкапсуляция?
Контроль доступа: Инкапсуляция защищает данные, гарантируя, что изменения в них происходят безопасно и через контролируемый интерфейс.
Упрощение интерфейса: Пользователь работает только с важными методами, не вникая в детали реализации.
Повышение надёжности кода: Защищённые данные и методы уменьшают вероятность ошибок, особенно при разработке сложных систем, где взаимодействие между объектами может быть сложным.

👍Инкапсуляция — важный инструмент для защиты данных, упрощения взаимодействия с объектами и улучшения надёжности кода. Используя её, вы создаёте безопасные интерфейсы, которые не позволяют внешнему коду напрямую вмешиваться в работу объекта.
#PyLearn #ООП

🐍Питай код с PyCode

👩‍💻Lambda-функции в Python

🤩Lambda-функции — это небольшие анонимные функции в Python, которые создаются с помощью ключевого слова lambda. Они особенно полезны, когда нужно написать короткую функцию на месте, без её явного объявления через def.

🥺Как работает lambda?
Lambda-функция состоит из:
Ключевого слова lambda
Аргументов функции
Выражения, которое будет выполнено и возвращено

Синтаксис:

lambda аргументы: выражение

Пример:

double = lambda x: x * 2
print(double(5))  # Выведет 10
Lambda-функция берёт один аргумент x и возвращает его удвоенное значение.

💡Применение: Lambda часто используется с такими функциями, как map(), filter() и sorted(), для кратких операций.

Пример с sorted():

pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
pairs.sort(key=lambda pair: pair[1])
print(pairs)  # [(1, 'one'), (3, 'three'), (2, 'two')]

✨Здесь lambda позволяет отсортировать список по второму элементу кортежа.

💻Когда использовать?
Lambda-функции идеально подходят для небольших одноразовых вычислений, когда объявлять полноценную функцию через def излишне.
#PyLearn

🐍Питай код с PyCode

👩‍💻Сортировка в Python: sort() и sorted()

💡В Python есть два основных способа сортировки списков: метод списка sort() и функция sorted(). Оба они используются для упорядочивания элементов, но работают по-разному.

💻sort(). Метод sort() сортирует список на месте, изменяя его порядок. Это метод изменяет сам объект списка и не возвращает новый список.
Синтаксис:

python 
list.sort(key=None, reverse=False)  

key — необязательный параметр. Указывает функцию для сортировки элементов.
reverse — если True, сортировка выполняется в обратном порядке.
Пример:

python 
numbers = [5, 3, 4, 2, -1] 
numbers.sort() 
print(numbers) # [-1, 2, 3, 4, 5]  

🚽sorted(). Функция sorted() не изменяет исходный список, а возвращает новый отсортированный список. Она работает с любыми итерируемыми объектами (списки, кортежи, строки и т.д.).
Синтаксис:

python 
sorted(iterable, key=None, reverse=False)  

Пример:

 
python 
numbers = [3, 1, 4, 2] 
sorted_numbers = sorted(numbers) 
print(sorted_numbers)  # [1, 2, 3, 4] 
print(numbers)  # [3, 1, 4, 2] — исходный список не изменился  

🥺Основные отличия:
sort() изменяет исходный список, sorted() создаёт новый.
sort() работает только со списками, sorted() — с любыми итерируемыми объектами.

🤩sort() и sorted() — мощные инструменты сортировки в Python, которые помогают эффективно организовать данные в ваших программах. Они гибкие благодаря параметрам key и reverse, что делает их идеальными для различных задач.
#PyLearn

🐍Питай код с PyCode

👩‍💻Основные принципы ООП: Полиморфизм (3/3)
  
😵‍💫Полиморфизм — это один из ключевых принципов ООП, который позволяет методам и объектам вести себя по-разному в зависимости от контекста. Это означает, что одна и та же операция может выполняться по-разному для объектов различных классов.

Виды полиморфизма:
🤩Переопределение методов (overriding): Позволяет дочернему классу изменять поведение метода родительского класса. Это даёт возможность каждому объекту реагировать на метод по-своему, хотя метод носит одно и то же имя.

Пример:

class Animal:
    def speak(self):
        return "Some sound"

class Dog(Animal):
    def speak(self):
        return "Bark"

class Cat(Animal):
    def speak(self):
        return "Meow"

В этом примере классы Dog и Cat переопределяют метод speak(), унаследованный от класса Animal. Хотя метод имеет одно и то же название, он возвращает разные результаты в зависимости от типа объекта.

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

class Shape:
    def area(self):
        pass

class Square(Shape):
    def area(self):
        return "Calculating area of square"

class Circle(Shape):
    def area(self):
        return "Calculating area of circle"

Здесь классы Square и Circle реализуют метод area(), но их поведение различается в зависимости от фигуры.

👍Зачем нужен полиморфизм?
Полиморфизм делает код более гибким и универсальным. Вы можете писать функции, которые работают с разными типами объектов, не зная их точных классов заранее. Это упрощает разработку и поддерживает принцип "написать код один раз, использовать везде".
#PyLearn #ООП

🐍Питай код с PyCode