Python | Вопросы собесов

erid: LjN8KPv8Y Привет! Мы BAUM, российская IT-компания. Наша работа — создавать продвинутые системы хранения данных с прикладным искусственным интеллектом. Мы завели аккаунт, где делимся своим опытом, даём советы для успешной карьеры, рассказываем об интересных событиях из нашей жизни и, конечно, публикуем вакансии. Обещаем, что будет очень полезно и совсем не душно — подписывайся!

Повышенный гонорар за технические статьи в блог на Хабре Если вы уже автор Хабра или работаете в сфере IT и чувствуете в себе творческий потенциал, то оставшиеся летние дни — прекрасная возможность посвятить себя писательскому делу! Мы запустили акцию для технических авторов и повысили гонорар за статьи в наш блог на Хабр до 22 000 рублей. Ждем материалы о системном администрировании, программировании, хостинге и серверном оборудовании. Акция действует до 29 августа. Узнать больше #реклама firstvds.ru О рекламодателе

📌 Что такое поведенческие паттерны ? 💬 Спрашивают в 3% собеседований Поведенческие паттерны (Behavioral Patterns) — это шаблоны проектирования, которые определяют способы взаимодействия объектов и классов, эффективное распределение обязанностей между ними и упрощают коммуникацию. Эти паттерны фокусируются на алгоритмах и потоках управления в системе, обеспечивая гибкость и расширяемость программного кода. 🤔 Основные паттерны 1️⃣ Chain of Responsibility (Цепочка обязанностей): ➕ Позволяет передавать запрос последовательно по цепочке обработчиков, пока один из них не обработает запрос. ➕ Система логирования, где различные уровни логов (информация, предупреждение, ошибка) обрабатываются разными обработчиками.

      class Handler(ABC):
       def __init__(self, successor=None):
           self._successor = successor

       @abstractmethod
       def handle(self, request):
           pass

   class ConcreteHandler1(Handler):
       def handle(self, request):
           if request == "Condition1":
               print("Handled by ConcreteHandler1")
           elif self._successor:
               self._successor.handle(request)

   class ConcreteHandler2(Handler):
       def handle(self, request):
           if request == "Condition2":
               print("Handled by ConcreteHandler2")
           elif self._successor:
               self._successor.handle(request)

   # Использование
   handler = ConcreteHandler1(ConcreteHandler2())
   handler.handle("Condition2")
   

2️⃣ Command (Команда): ➕ Инкапсулирует запрос как объект, позволяя параметризовать клиентов с разными запросами, ставить запросы в очередь или записывать их в журнал. ➕ Система меню, где каждый пункт меню представляет команду.

      class Command(ABC):
       @abstractmethod
       def execute(self):
           pass

   class Light:
       def on(self):
           print("Light is ON")

       def off(self):
           print("Light is OFF")

   class LightOnCommand(Command):
       def __init__(self, light):
           self._light = light

       def execute(self):
           self._light.on()

   class LightOffCommand(Command):
       def __init__(self, light):
           self._light = light

       def execute(self):
           self._light.off()

   # Использование
   light = Light()
   light_on = LightOnCommand(light)
   light_off = LightOffCommand(light)

   light_on.execute()
   light_off.execute()
   

3️⃣ Iterator (Итератор): ➕ Предоставляет способ последовательного доступа ко всем элементам коллекции без раскрытия её внутреннего представления. ➕ Обход элементов массива или связного списка.

      class Iterator(ABC):
       @abstractmethod
       def next(self):
           pass

       @abstractmethod
       def has_next(self):
           pass

   class ConcreteIterator(Iterator):
       def __init__(self, collection):
           self._collection = collection
           self._index = 0

       def next(self):
           item = self._collection[self._index]
           self._index += 1
           return item

       def has_next(self):
           return self._index < len(self._collection)

   # Использование
   collection = [1, 2, 3, 4]
   iterator = ConcreteIterator(collection)

   while iterator.has_next():
       print(iterator.next())
   

Поведенческие паттерны проектирования определяют способы взаимодействия объектов и классов, упрощая коммуникацию и обеспечивая гибкость и расширяемость программного кода. Они позволяют эффективно распределять обязанности между объектами и обеспечивать упорядоченный поток управления в системе. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

Первый дилер завода ELTEX! Коммутаторы, Маршрутизаторы, GPON, VoIP, Wi-Fi оборудование, а также совместимые SFP модули. Перейти на сайт #реклама eltexcm.ru О рекламодателе

📌 Что такое паттерн Заместитель (Proxy) ? 💬 Спросят с вероятностью 3% Паттерн "Заместитель" (Proxy) — это структурный паттерн проектирования, который предоставляет суррогатный или заместительный объект для другого объекта с целью контроля доступа к нему. Заместитель выполняет функции обёртки или посредника, передавая вызовы к реальному объекту и добавляя к ним дополнительную логику. 🤔 Зачем нужен данный паттерн? 1️⃣ Контроль доступа: Позволяет управлять доступом к объекту, добавляя проверки и ограничения. 2️⃣ Ленивая инициализация: Позволяет откладывать создание и инициализацию ресурсоёмких объектов до момента, когда они действительно понадобятся. 3️⃣ Удалённый доступ: Обеспечивает взаимодействие с удалёнными объектами, как будто они локальные. 4️⃣ Логирование и кэширование: Добавляет дополнительные действия, такие как логирование или кэширование, при доступе к объекту. 🤔 Как работает данный паттерн? Паттерн "Заместитель" включает следующие компоненты: ➕ Реальный субъект (RealSubject): Класс, представляющий реальный объект, к которому требуется контролируемый доступ. ➕ Интерфейс (Subject): Общий интерфейс для реального субъекта и заместителя, позволяющий заместителю подменять реальный объект. ➕ Заместитель (Proxy): Класс, который реализует интерфейс и содержит ссылку на реальный объект. Он перехватывает вызовы к реальному объекту и может добавлять к ним дополнительную логику.

from abc import ABC, abstractmethod

# Интерфейс (Subject)
class Subject(ABC):
    @abstractmethod
    def request(self):
        pass

# Реальный субъект (RealSubject)
class RealSubject(Subject):
    def request(self):
        print("RealSubject: Handling request.")

# Заместитель (Proxy)
class Proxy(Subject):
    def __init__(self, real_subject):
        self._real_subject = real_subject

    def request(self):
        if self.check_access():
            self._real_subject.request()
            self.log_access()

    def check_access(self):
        print("Proxy: Checking access prior to firing a real request.")
        return True

    def log_access(self):
        print("Proxy: Logging the time of request.")

# Клиентский код
def client_code(subject: Subject):
    subject.request()

# Использование
real_subject = RealSubject()
proxy = Proxy(real_subject)
client_code(proxy)

Преимущества: 1️⃣ Контроль доступа: Позволяет легко управлять доступом к реальному объекту. 2️⃣ Ленивая инициализация: Экономит ресурсы, откладывая создание объектов до необходимости. 3️⃣ Логирование и кэширование: Обеспечивает функциональность без изменения реального объекта. 4️⃣ Удалённый доступ: Упрощает взаимодействие с удалёнными объектами. Недостатки: 1️⃣ Усложнение кода: Добавляет дополнительные классы и слои абстракции, что может усложнить систему. 2️⃣ Снижение производительности: Введение дополнительных проверок и логики может повлиять на производительность. 🤔 Виды: 1️⃣ Remote Proxy: Управляет взаимодействием с удалённым объектом. 2️⃣ Virtual Proxy: Управляет доступом к ресурсоёмкому объекту, создавая его по требованию. 3️⃣ Protection Proxy: Контролирует доступ к объекту, обеспечивая безопасность. 4️⃣ Smart Proxy: Добавляет дополнительную функциональность при доступе к объекту (например, рефлекторное считывание и запись). 🤔 Когда использовать данный паттерн? ➕ Когда нужно контролировать доступ к ресурсоёмкому или удалённому объекту. ➕ Когда требуется добавить дополнительные операции при доступе к объекту. ➕ Когда необходимо обеспечить безопасность и контроль над доступом к объекту. Паттерн "Заместитель" является мощным инструментом для управления доступом к объектам, добавления логики и улучшения производительности в определённых сценариях. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

Сообщество IT-специалистов в Telegram от Selectel. Канал крупнейшего независимого провайдера IT-инфраструктуры и облаков. Шесть причин подписаться на канал: - железные новости; - обзоры продуктов; - разборы кейсов; - актуальные IT-статьи; - анонсы митапов; - бесплатные курсы. Подписаться #реклама О рекламодателе

📌 Что такое паттерн Приспособленец (Flyweight) ? 💬 Спросят с вероятностью 3% Паттерн "Приспособленец" (Flyweight) — это структурный паттерн проектирования, который позволяет эффективно поддерживать большое количество мелких объектов, минимизируя использование памяти. Это достигается путем совместного использования общего состояния объектов, вместо хранения одинаковых данных в каждом объекте. 🤔 Зачем нужен данный паттерн? 1️⃣ Экономия памяти: Позволяет хранить большое количество объектов, используя меньше памяти за счет разделения общего состояния между ними. 2️⃣ Увеличение производительности: Уменьшение затрат на память может также улучшить производительность системы, особенно если создание объектов является дорогостоящей операцией. 🤔 Как работает данный паттерн? Паттерн "Приспособленец" разделяет состояние объекта на: ➕ Внутреннее состояние (Intrinsic State): Состояние, которое является одинаковым для многих объектов и может быть разделено между ними. ➕ Внешнее состояние (Extrinsic State): Состояние, которое уникально для каждого объекта и передается в методы.

class Flyweight:
    def __init__(self, intrinsic_state):
        self.intrinsic_state = intrinsic_state

    def operation(self, extrinsic_state):
        print(f"Flyweight: Intrinsic state = {self.intrinsic_state}, Extrinsic state = {extrinsic_state}")

class FlyweightFactory:
    _flyweights = {}

    def get_flyweight(self, intrinsic_state):
        if intrinsic_state not in self._flyweights:
            self._flyweights[intrinsic_state] = Flyweight(intrinsic_state)
        return self._flyweights[intrinsic_state]

# Клиентский код
factory = FlyweightFactory()

# Создание и использование приспособленцев
flyweight1 = factory.get_flyweight("Shared State A")
flyweight1.operation("Unique State 1")

flyweight2 = factory.get_flyweight("Shared State B")
flyweight2.operation("Unique State 2")

flyweight3 = factory.get_flyweight("Shared State A")
flyweight3.operation("Unique State 3")

# Проверка совместного использования приспособленцев
print(flyweight1 is flyweight3)  # True

Преимущества: 1️⃣ Экономия памяти: Значительно уменьшает количество памяти, необходимое для хранения большого количества объектов. 2️⃣ Увеличение производительности: Снижение затрат на создание и хранение объектов может улучшить общую производительность системы. Недостатки: 1️⃣ Сложность реализации: Требует тщательной разработки для правильного разделения внутреннего и внешнего состояния. 2️⃣ Снижение читабельности кода: Использование внешнего состояния может сделать код менее понятным и трудным для сопровождения. 🤔 Когда использовать данный паттерн? ➕ Когда система должна эффективно работать с большим количеством объектов. ➕ Когда значительная часть состояния объектов может быть разделена. ➕ Когда создание объектов является дорогостоящей операцией и использование памяти критично. Паттерн "Приспособленец" является мощным инструментом для оптимизации использования памяти и повышения производительности в системах, работающих с большим количеством однотипных объектов. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

Запустите рекламу в телеграм-каналах с Яндекс Директом Перфоманс-реклама теперь в телеграм-каналах ⚡ Яндекс Директ знает, как привлечь целевую аудиторию 💰👌 Попробовать #реклама yandex.ru О рекламодателе

Начните обучение в магистратуре в Центральном университете уже на 3-м курсе бакалавриата! Центральный университет — современный вуз, созданный при поддержке ведущих компаний России: Т-Банка, Авито и других. Учебу реально совместить с последними курсами бакалавриата или действующей работой. Обучение занимает 20 часов в неделю в вечернее время в первый год, а занятия проводят в центре Москвы профессоры из МГУ, МФТИ, РЭШ и практики из индустрии. Обучение в университете построено по принципам ИТ-компаний, со средой, способствующей росту и развитию. У каждого студента будет: - личный ментор по траектории обучения; - доступ к карьерному центру с коучами и консультантами; - опыт работы в проектах 30+ компаний-партнеров уже во время обучения; - диплом гособразца. Участвуйте в онлайн-отборе, чтобы выиграть грант на обучение до 1,2 млн рублей. Больше подробностей про университет и конкурс грантов по ссылке! erid:2VtzqxE26Cj Реклама, АНО ВО «Центральный университет», ИНН 7743418023

📌 Что такое паттерн Фасад (Facade) ? 💬 Спросят с вероятностью 3% Паттерн "Фасад" (Facade) — это структурный паттерн проектирования, который предоставляет унифицированный интерфейс для взаимодействия с набором интерфейсов в подсистеме. Фасад определяет высокоуровневый интерфейс, упрощающий работу с более сложной подсистемой. 🤔 Зачем нужен данный паттерн? 1️⃣ Упрощение использования подсистемы: Позволяет клиентам взаимодействовать с подсистемой через простой и понятный интерфейс. 2️⃣ Сокрытие сложности: Скрывает детали реализации и организацию сложной подсистемы от клиентов. 3️⃣ Снижение зависимости: Уменьшает количество зависимостей между клиентами и подсистемой, упрощая поддержку и изменение системы. 🤔 Как работает данный паттерн? Паттерн включает следующие компоненты: ➕ Фасад (Facade): Класс, предоставляющий упрощенный интерфейс для взаимодействия с подсистемой. ➕ Подсистема (Subsystem): Один или несколько классов, выполняющих сложную работу. Подсистема не знает о существовании фасада и работает автономно.

class Amplifier:
    def on(self):
        print("Amplifier on")

    def set_volume(self, volume):
        print(f"Amplifier volume set to {volume}")

    def off(self):
        print("Amplifier off")

class DVDPlayer:
    def on(self):
        print("DVD Player on")

    def play(self, movie):
        print(f"Playing movie: {movie}")

    def stop(self):
        print("DVD Player stopped")

    def off(self):
        print("DVD Player off")

class Projector:
    def on(self):
        print("Projector on")

    def set_input(self, input):
        print(f"Projector input set to {input}")

    def off(self):
        print("Projector off")

# Фасад
class HomeTheaterFacade:
    def __init__(self, amp, dvd, projector):
        self.amp = amp
        self.dvd = dvd
        self.projector = projector

    def watch_movie(self, movie):
        print("Get ready to watch a movie...")
        self.amp.on()
        self.amp.set_volume(5)
        self.dvd.on()
        self.dvd.play(movie)
        self.projector.on()
        self.projector.set_input("DVD")

    def end_movie(self):
        print("Shutting movie theater down...")
        self.amp.off()
        self.dvd.stop()
        self.dvd.off()
        self.projector.off()

# Использование
amp = Amplifier()
dvd = DVDPlayer()
projector = Projector()

home_theater = HomeTheaterFacade(amp, dvd, projector)
home_theater.watch_movie("Inception")
home_theater.end_movie()

Преимущества: 1️⃣ Упрощение использования: Предоставляет простой интерфейс для сложной подсистемы. 2️⃣ Сокрытие деталей реализации: Скрывает внутреннюю структуру подсистемы, делая её использование проще и понятнее. 3️⃣ Снижение зависимости: Уменьшает количество зависимостей между клиентами и подсистемой. Недостатки: 1️⃣ Ограниченная функциональность: Может ограничивать функциональность, предоставляемую подсистемой, если фасад предоставляет слишком упрощенный интерфейс. 2️⃣ Дополнительный слой абстракции: Введение фасада добавляет дополнительный слой кода, что может усложнить систему в некоторых случаях. 🤔 Когда использовать данный паттерн? ➕ Когда нужно предоставить простой интерфейс для сложной подсистемы. ➕ Когда нужно сократить количество зависимостей между клиентами и подсистемой. ➕ Когда нужно организовать код и уменьшить связность в системе. Паттерн "Фасад" является полезным инструментом для упрощения взаимодействия с сложными подсистемами, скрывая их внутреннюю сложность и предоставляя удобный интерфейс для клиентов. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

Реклама для бизнеса любого уровня в Яндекс Директе Создайте эффективную рекламную кампанию с алгоритмами Яндекс Директа 👌 Начните прямо сейчас ⚡ Зарегистрироваться #реклама direct.yandex.ru О рекламодателе

📌 Что такое паттерн Компоновщик (Composite) ? 💬 Спросят с вероятностью 3% Паттерн "Компоновщик" (Composite) — это структурный паттерн проектирования, который позволяет сгруппировать объекты в древовидные структуры для представления иерархий "часть-целое". Этот паттерн позволяет клиенту одинаково работать как с отдельными объектами, так и с группами объектов. 🤔 Зачем нужен данный паттерн? 1️⃣ Упрощение клиентского кода: Клиентский код может работать с объектами и их контейнерами одинаково, без необходимости в различении их типов. 2️⃣ Гибкость структуры: Позволяет создавать сложные иерархии объектов динамически. 3️⃣ Повторное использование кода: Легче добавлять новые типы компонентов, не меняя существующий код. 🤔 Как работает данный паттерн? Паттерн включает следующие компоненты: ➕ Компонент (Component): Определяет общий интерфейс для всех объектов в композиции. ➕ Лист (Leaf): Представляет отдельные объекты, которые не могут иметь подкомпонентов. ➕ Контейнер (Composite): Представляет объекты, которые могут содержать другие компоненты (листы или контейнеры).

from abc import ABC, abstractmethod

# Компонент
class Employee(ABC):
    @abstractmethod
    def show_details(self):
        pass

# Лист
class Developer(Employee):
    def __init__(self, name, position):
        self.name = name
        self.position = position

    def show_details(self):
        print(f"{self.position}: {self.name}")

class Designer(Employee):
    def __init__(self, name, position):
        self.name = name
        self.position = position

    def show_details(self):
        print(f"{self.position}: {self.name}")

# Контейнер
class Organization(Employee):
    def __init__(self):
        self.employees = []

    def add(self, employee):
        self.employees.append(employee)

    def remove(self, employee):
        self.employees.remove(employee)

    def show_details(self):
        for employee in self.employees:
            employee.show_details()

# Использование
dev1 = Developer("John Doe", "Senior Developer")
dev2 = Developer("Jane Smith", "Junior Developer")
designer = Designer("Emily Davis", "Senior Designer")

org = Organization()
org.add(dev1)
org.add(dev2)
org.add(designer)

org.show_details()

Преимущества: 1️⃣ Единообразие: Позволяет клиентскому коду работать с индивидуальными объектами и их контейнерами одинаково. 2️⃣ Гибкость: Легко добавлять новые компоненты и контейнеры. 3️⃣ Простота добавления новых элементов: Новые типы компонентов можно добавлять, не изменяя существующий код. Недостатки: 1️⃣ Сложность управления: Может быть сложно управлять, если структура становится слишком глубокой или разветвленной. 2️⃣ Трудность реализации: Реализация может быть сложной, особенно когда требуется поддерживать разные виды операций над компонентами. 🤔 Когда использовать данный паттерн? ➕ Когда требуется представлять иерархические структуры объектов. ➕ Когда нужно, чтобы клиентский код одинаково работал с отдельными объектами и их контейнерами. ➕ Когда нужно упростить работу с объектами, представляющими части целого. Паттерн "Компоновщик" является мощным инструментом для работы с древовидными структурами данных, позволяя легко манипулировать и управлять как отдельными объектами, так и их группами. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

Jobski - твой помощник при поиске работы в IT Сервис индивидуально подбирает вакансии, учитывая ваш опыт, навыки и стек технологий. Узнать больше #реклама jobski.ru О рекламодателе

📌 Что такое паттерн Мост (Bridge) ? 💬 Спросят с вероятностью 3% Паттерн "Мост" (Bridge) — это структурный паттерн проектирования, который разделяет абстракцию и её реализацию так, чтобы они могли изменяться независимо друг от друга. Он используется для разделения сложных систем на части, которые можно развивать, изменять и использовать независимо. 🤔 Зачем нужен данный паттерн? 1️⃣ Разделение ответственности: Позволяет разделить абстрактную часть системы (например, интерфейс) и конкретную реализацию. 2️⃣ Упрощение изменений: Изменения в абстракции или реализации не требуют изменений в другой части. 3️⃣ Гибкость и расширяемость: Упрощает добавление новых абстракций и реализаций без изменения существующего кода. 🤔 Как работает данный паттерн? Паттерн включает следующие компоненты: ➕ Абстракция (Abstraction): Определяет интерфейс и содержит ссылку на объект реализации. ➕ Расширенная абстракция (Refined Abstraction): Расширяет интерфейс абстракции. ➕ Интерфейс реализации (Implementor): Определяет интерфейс для всех реализаций. ➕ Конкретная реализация (Concrete Implementor): Реализует интерфейс реализации.

from abc import ABC, abstractmethod

# Интерфейс реализации
class DrawingAPI(ABC):
    @abstractmethod
    def draw_circle(self, x, y, radius):
        pass

# Конкретные реализации
class DrawingAPI1(DrawingAPI):
    def draw_circle(self, x, y, radius):
        print(f"API1.circle at {x}:{y} radius {radius}")

class DrawingAPI2(DrawingAPI):
    def draw_circle(self, x, y, radius):
        print(f"API2.circle at {x}:{y} radius {radius}")

# Абстракция
class Shape(ABC):
    def __init__(self, drawing_api):
        self.drawing_api = drawing_api

    @abstractmethod
    def draw(self):
        pass

    @abstractmethod
    def resize(self, factor):
        pass

# Расширенная абстракция
class CircleShape(Shape):
    def __init__(self, x, y, radius, drawing_api):
        super().__init__(drawing_api)
        self.x = x
        self.y = y
        self.radius = radius

    def draw(self):
        self.drawing_api.draw_circle(self.x, self.y, self.radius)

    def resize(self, factor):
        self.radius *= factor

# Использование
circle1 = CircleShape(1, 2, 3, DrawingAPI1())
circle2 = CircleShape(5, 7, 11, DrawingAPI2())

circle1.draw()
circle2.draw()

circle1.resize(2)
circle1.draw()

Преимущества: 1️⃣ Разделение кода: Абстракция и реализация могут изменяться независимо. 2️⃣ Уменьшение связности: Уменьшает зависимость между абстракцией и реализацией. 3️⃣ Гибкость: Легко добавлять новые абстракции и реализации. Недостатки: 1️⃣ Сложность структуры: Увеличение количества классов и усложнение структуры кода. 2️⃣ Дополнительный уровень косвенности: Может затруднить понимание кода из-за дополнительных уровней абстракции. 🤔 Когда использовать данный паттерн? ➕ Когда нужно разделить монолитный класс с несколькими вариациями на иерархии классов абстракции и реализации. ➕ Когда абстракции и реализации должны изменяться независимо друг от друга. ➕ Когда нужно избежать жесткой привязки абстракции к реализации. Паттерн "Мост" обеспечивает гибкость в проектировании сложных систем, разделяя их на независимые части, что облегчает их развитие и поддержку. 🔥 ТОП ВОПРОСОВ С СОБЕСОВ 🔒 База собесов | 🔒 База тестовых

🔥 Битый код - канал для настоящих кодеров! 🔴 Тебе надоело сталкиваться с багами и ошибками в коде? 🔴 Хочешь прокачать свои навыки и узнать, как эффективно решать сложные задачи? ⭐️ Тогда тебе к нам! На канале Битый код ты найдешь: 🟡 Советы по оптимизации кода 🟡 Практические примеры и решения 🧠 Развивай свои навыки программирования вместе с нами и становись настоящим профессионалом! 🔥 Присоединяйся к Битому коду и учись исправлять ошибки как настоящий мастер.

ТОП-4 Курса по Системной аналитике Tutortop — маркетплейс курсов №1 по количеству школ-партнеров, курсов и реальных отзывов студентов. ⚡Системный аналитик разрабатывает требования к программному обеспечению. Заказчик или владелец продукта определяет, что должна делать программа. После этого системный аналитик общается с заказчиком или владельцем продукта, добывает информацию из разных источников и изучает рынок. ✅Получите одну из самых востребованных профессий! Выбрать #реклама 16+ tutortop.ru О рекламодателе

🤯 Чтобы не сидеть в творческом беспорядке, структурируй его с помощью Куб прогресса. Тут ты найдешь кучу советов для ITшника: 🟡 пользуйся полезными сайтами 🟡 подчеркивай интересные мысли 🛞 Начинай внедрять лайфхаки - создай структуру внутри себя