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

🤔 Что такое паттерн Адаптер (Adapter)? Паттерн "Адаптер" (Adapter) — это структурный паттерн проектирования, который позволяет объектам с несовместимыми интерфейсами работать вместе. Адаптер оборачивает один из объектов и преобразует его интерфейс в интерфейс, который ожидает клиент. Этот паттерн часто используется для интеграции кода с устаревшими библиотеками или компонентами. 🚩Основные концепции Целевой интерфейс (Target Interface): Интерфейс, который ожидает клиент. Клиент (Client): Объект, который использует целевой интерфейс для взаимодействия с другими объектами. Адаптируемый интерфейс (Adaptee): Существующий интерфейс, который необходимо адаптировать. Адаптер (Adapter): Класс, который оборачивает адаптируемый интерфейс и преобразует его в целевой интерфейс. 🚩Примеры Определение целевого интерфейса и адаптируемого интерфейса

class EuropeanSocketInterface:
    def voltage(self):
        pass

    def live(self):
        pass

    def neutral(self):
        pass

    def earth(self):
        pass

class USASocket:
    def voltage(self):
        return 120

    def live(self):
        return 1

    def neutral(self):
        return -1

Создание адаптера

class Adapter(EuropeanSocketInterface):
    def __init__(self, usa_socket):
        self.usa_socket = usa_socket

    def voltage(self):
        return self.usa_socket.voltage()

    def live(self):
        return self.usa_socket.live()

    def neutral(self):
        return self.usa_socket.neutral()

    def earth(self):
        return 0  # В американских розетках может не быть заземления

Использование адаптера

def client_code(socket):
    print(f"Voltage: {socket.voltage()}V")
    print(f"Live: {socket.live()}")
    print(f"Neutral: {socket.neutral()}")
    print(f"Earth: {socket.earth()}")

# Использование
usa_socket = USASocket()
adapter = Adapter(usa_socket)
client_code(adapter)

🚩Плюсы ➕Совместимость: Позволяет объектам с несовместимыми интерфейсами работать вместе. ➕Простота интеграции: Упрощает интеграцию старого кода с новым, минимизируя изменения. ➕Гибкость: Позволяет изменять и расширять существующие классы без изменения их исходного кода. 🚩Минусы ➖Сложность: Может добавить дополнительный уровень абстракции, что может усложнить систему. ➖Зависимость: Адаптер может зависеть от конкретных деталей реализации адаптируемого интерфейса. 🚩Разновидности паттерна "Адаптер" Объектный адаптер: Использует композицию для оборачивания объекта. Классовый адаптер: Использует множественное наследование для адаптации одного интерфейса к другому. Пример классового адаптера:

class USASocket:
    def voltage(self):
        return 120

    def live(self):
        return 1

    def neutral(self):
        return -1

class EuropeanSocketInterface:
    def voltage(self):
        pass

    def live(self):
        pass

    def neutral(self):
        pass

    def earth(self):
        pass

class Adapter(EuropeanSocketInterface, USASocket):
    def earth(self):
        return 0  # В американских розетках может не быть заземления

# Использование
adapter = Adapter()
client_code(adapter)

Ставь 👍 и забирай 📚 Базу знаний

Обучаем Java-разработчиков оплата после выхода на работу В Kata Academy можно выучиться на Java-разработчика бесплатно, а заплатить уже после трудоустройства по специальности из фактической зарплаты. Если задуматься, то все в выигрыше: — ты получаешь работу в Москве или Санкт-Петербурге с хорошей зарплатой, мы получаем процент за инвестиции в тебя; — в наших интересах научить тебя так, чтобы твоя зарплата была как можно выше; — мы прокачиваем твои навыки еще 2 года после курса: проводим выездные мероприятия и мастер-классы — и доходы наших выпускников растут; — мы не зависим от банков и их рассрочек — кризис не повлиял на доступность курсов. Чтобы попасть на курс, нужно выполнить небольшое тестовое задание. Переходи по ссылке и оставляй заявку! Узнать больше #реклама 16+ kata.academy О рекламодателе

🤔 Что такое Структурные (Structural) паттерны? Это паттерны проектирования, которые упрощают создание отношений между объектами, обеспечивая гибкую структуру и способствуя повторному использованию кода. Эти паттерны помогают организовать классы и объекты в большие структуры, сохраняя при этом гибкость и эффективность. 🚩Описание и примеры Адаптер (Adapter) Паттерн Адаптер позволяет объектам с несовместимыми интерфейсами работать вместе. Он оборачивает один из объектов, преобразуя его интерфейс в совместимый.

class EuropeanSocket:
    def voltage(self):
        return 230

class USASocket:
    def voltage(self):
        return 120

class Adapter:
    def __init__(self, socket):
        self.socket = socket

    def voltage(self):
        return self.socket.voltage()

# Использование
european_socket = EuropeanSocket()
adapter = Adapter(european_socket)
print(adapter.voltage())  # 230

Мост (Bridge) Паттерн Мост разделяет абстракцию и реализацию, позволяя изменять их независимо друг от друга.

class DrawingAPI:
    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:
    def __init__(self, drawing_api):
        self.drawing_api = drawing_api

    def draw(self):
        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)

# Использование
circle1 = CircleShape(1, 2, 3, DrawingAPI1())
circle2 = CircleShape(5, 7, 11, DrawingAPI2())
circle1.draw()  # API1.circle at 1:2 radius 3
circle2.draw()  # API2.circle at 5:7 radius 11

Компоновщик (Composite) Паттерн Компоновщик позволяет группировать объекты в древовидные структуры для представления иерархий "часть-целое".

class Component:
    def operation(self):
        pass

class Leaf(Component):
    def operation(self):
        return "Leaf"

class Composite(Component):
    def __init__(self):
        self.children = []

    def add(self, component):
        self.children.append(component)

    def operation(self):
        results = []
        for child in self.children:
            results.append(child.operation())
        return f"Branch({'+'.join(results)})"

# Использование
leaf1 = Leaf()
leaf2 = Leaf()
composite = Composite()
composite.add(leaf1)
composite.add(leaf2)
print(composite.operation())  # Branch(Leaf+Leaf)

Ставь 👍 и забирай 📚 Базу знаний

👩‍💻 Программирование уже в Telegram! Вот 10 обучающих каналов по самым востребованным направлениям в IT. Выбирай своё направление: 👩‍💻 Python: @python_ready 👩‍💻 Java: @java_ready 👩‍💻 C/C++: @cpp_ready 👩‍💻 C#: @csharp_ready 👩‍💻 Backend: @backend_ready 👩‍💻 Frontend: @code_ready 🖥 Базы Данных & SQL: @sql_ready 👩‍💻 Весь IT: @roadmap_ready 📖 IT Архив: @archive_ready 🖥 Design: @time_design 📌 Ресурсы, гайды, шпаргалки, книги и задачи для каждого языка программирования.

Помощь в трудоустройстве в IT-сфере! В России из-за дефицита айтишников запустили бесплатную программу по обучению IT-специалистов. Теперь любой желающий может попробовать себя в IT с полного нуля и начать обучение бесплатно! Узнайте про дальнейшее трудоустройство в ведущие IT-компании для восполнения кадрового дефицита. Для этого нужно: - Перейти по ссылке - Заполнить анкету и ответить на вопросы (занимает менее 3 минут) - На основании ваших ответов вы сразу узнаете, подходит ли вам сфера IT и сможете ли вы в ней работать Перейти на сайт #реклама 16+ urban-university.ru О рекламодателе

🤔 Что такое паттерн Прототип (Prototype)? Это порождающий паттерн проектирования, который позволяет создавать новые объекты, копируя уже существующие экземпляры. Этот паттерн полезен, когда процесс создания объекта является дорогим (в смысле затрат ресурсов) и трудоемким, а копирование существующего объекта оказывается проще и быстрее. 🚩Основные концепции 🟠Прототип (Prototype): Интерфейс или абстрактный класс, который объявляет метод clone(), позволяющий клонировать объект. 🟠Конкретный прототип (Concrete Prototype): Реализация интерфейса прототипа, которая определяет, как должен быть клонирован объект. 🟠Клиент (Client): Объект, который создает новые объекты, вызывая метод clone() на прототипах. 🚩Плюсы ➕Скорость создания объектов: Клонирование объектов может быть быстрее, чем создание новых с нуля, особенно если процесс создания объектов сложен. ➕Уменьшение зависимости от конкретных классов: Клиенты могут работать с интерфейсом прототипа вместо работы с конкретными классами. ➕Упрощение добавления и удаления объектов: Легко создавать новые типы объектов путем клонирования существующих. 🚩Минусы ➖Сложность реализации: Реализация клонирования может быть сложной, особенно если объект имеет сложные зависимости или использует ресурсы, которые не могут быть просто скопированы. ➖Проблемы с глубоким и поверхностным копированием: Нужно тщательно продумать, как должны копироваться вложенные объекты (глубокое копирование или поверхностное копирование). 🚩Пример Определение интерфейса прототипа

from abc import ABC, abstractmethod
import copy

class Shape(ABC):
    def __init__(self, id):
        self.id = id

    @abstractmethod
    def clone(self):
        pass

Создание конкретных прототипов

class Rectangle(Shape):
    def __init__(self, id, width, height):
        super().__init__(id)
        self.width = width
        self.height = height

    def clone(self):
        return copy.deepcopy(self)

    def __str__(self):
        return f"Rectangle(id={self.id}, width={self.width}, height={self.height})"

class Circle(Shape):
    def __init__(self, id, radius):
        super().__init__(id)
        self.radius = radius

    def clone(self):
        return copy.deepcopy(self)

    def __str__(self):
        return f"Circle(id={self.id}, radius={self.radius})"

Использование прототипа

def main():
    rect1 = Rectangle(1, 10, 20)
    circle1 = Circle(2, 15)

    rect2 = rect1.clone()
    circle2 = circle1.clone()

    print(rect1)  # Rectangle(id=1, width=10, height=20)
    print(rect2)  # Rectangle(id=1, width=10, height=20)
    print(circle1)  # Circle(id=2, radius=15)
    print(circle2)  # Circle(id=2, radius=15)

if __name__ == "__main__":
    main()

Ставь 👍 и забирай 📚 Базу знаний

Бесплатные уроки по IT-профессиям. Учитесь на практике! Узнайте, с чего начать свой путь в IT или дизайне и как выбрать профессию по душе. Получите билет! Получить предложение #реклама 16+ free.skillfactory.ru О рекламодателе

🤔 Что такое Фабричный метод (Factory method)? Это порождающий паттерн проектирования, который определяет интерфейс для создания объекта, но позволяет подклассам изменять тип создаваемого объекта. Это позволяет классу делегировать создание объектов подклассам, таким образом убирая жесткую привязку к конкретным классам и делая систему более гибкой и расширяемой. 🚩Основные концепции 🟠Продукт (Product): Определяет интерфейс для объектов, которые будут создаваться. 🟠Конкретный продукт (Concrete Product): Реализует интерфейс продукта. 🟠Создатель (Creator): Определяет фабричный метод, который возвращает объект продукта. Может содержать реализацию метода по умолчанию, возвращающую какой-то стандартный продукт. 🟠Конкретный создатель (Concrete Creator): Переопределяет фабричный метод для создания конкретного продукта. 🚩Использования фабричного метода Определение интерфейса продукта

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

Создание конкретных продуктов

class Dog(Animal):
    def speak(self):
        return "Woof!"

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

Определение создателя

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self) -> Animal:
        pass

    def some_operation(self) -> str:
        animal = self.create_animal()
        return f"The animal says: {animal.speak()}"

Создание конкретных создателей

class DogFactory(AnimalFactory):
    def create_animal(self) -> Animal:
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self) -> Animal:
        return Cat()

Использование фабричного метода

def client_code(factory: AnimalFactory):
    print(factory.some_operation())

dog_factory = DogFactory()
cat_factory = CatFactory()

print("Client: Testing client code with DogFactory:")
client_code(dog_factory)  # Вывод: The animal says: Woof!

print("\nClient: Testing client code with CatFactory:")
client_code(cat_factory)  # Вывод: The animal says: Meow!

🚩Плюсы ➕Изоляция конкретных классов: Клиентский код работает с интерфейсами или абстрактными классами, а не с конкретными реализациями. ➕Упрощение добавления новых продуктов: Легко добавлять новые виды продуктов, создавая новые конкретные создатели. ➕Гибкость и расширяемость: Позволяет изменять способ создания объектов без изменения клиентского кода. 🚩Минусы ➖Усложнение кода: Может потребоваться создание большого количества классов для каждого конкретного продукта и его создателя. ➖Дополнительные абстракции: Для каждого типа продукта требуется создание интерфейсов или абстрактных классов. Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое Построитель (Builder)? Паттерн "Строитель" — это порождающий паттерн проектирования, который позволяет создавать сложные объекты пошагово и отделяет процесс конструирования объекта от его представления, что дает возможность использовать один и тот же процесс для создания различных представлений. 🚩Основные концепции 🟠 Строитель (Builder): Интерфейс или абстрактный класс, определяющий шаги для построения объекта. 🟠Конкретные строители (Concrete Builders): Реализуют интерфейс строителя, создавая конкретные части продукта. 🟠Продукт (Product): Сложный объект, который строится. 🟠Директор (Director): Опциональный класс, который контролирует процесс построения, используя строителя. 🚩Рассмотрим пример использования паттерна "Строитель" для создания объектов типа House. 🟠Создание продукта

class House:
    def __init__(self):
        self.walls = None
        self.roof = None
        self.windows = None

    def __str__(self):
        return f"House with {self.walls} walls, {self.roof} roof, and {self.windows} windows."

🟠Определение интерфейса строителя

from abc import ABC, abstractmethod

class HouseBuilder(ABC):
    @abstractmethod
    def build_walls(self):
        pass

    @abstractmethod
    def build_roof(self):
        pass

    @abstractmethod
    def build_windows(self):
        pass

    @abstractmethod
    def get_house(self):
        pass

🟠Создание конкретных строителей

class ConcreteHouseBuilder(HouseBuilder):
    def __init__(self):
        self.house = House()

    def build_walls(self):
        self.house.walls = "brick"
        return self

    def build_roof(self):
        self.house.roof = "tile"
        return self

    def build_windows(self):
        self.house.windows = "double-glazed"
        return self

    def get_house(self):
        return self.house

🟠Создание директора (опционально)

class Director:
    def __init__(self, builder):
        self.builder = builder

    def construct_house(self):
        self.builder.build_walls().build_roof().build_windows()
        return self.builder.get_house()

🟠Использование паттерна "Строитель"

# Использование без директора
builder = ConcreteHouseBuilder()
house = builder.build_walls().build_roof().build_windows().get_house()
print(house)  # House with brick walls, tile roof, and double-glazed windows.

# Использование с директором
director = Director(builder)
house = director.construct_house()
print(house)  # House with brick walls, tile roof, and double-glazed windows.

🚩Преимущества паттерна "Строитель" 🟠 Упрощение создания сложных объектов: Позволяет создавать сложные объекты пошагово. 🟠Отделение процесса конструирования от представления: Разделяет логику создания объекта и его состав. 🟠 Гибкость: Один и тот же процесс построения можно использовать для создания различных представлений объекта. 🚩Недостатки паттерна "Строитель" 🟠Усложнение кода: Добавление дополнительных классов может усложнить структуру программы. 🟠Необходимость в дополнительных классах: Для каждого типа объекта требуется отдельный класс строителя. Ставь 👍 и забирай 📚 Базу знаний

Методичка: как сделать онлайн-встречи эффективнее Надоело ждать коллег, которые постоянно забывают о встречах, а отсутствие повестки и потерянные договоренности мешают нормально работать? Команда МТС Линк собрала на 37 страницах полезные материалы, чек-листы и кейсы, которые помогают компаниям проводить эффективные совещания в онлайне с помощью сервиса Встречи. Из методички узнаете: - Как создать постоянную ссылку и подключаться на встречи в 2 клика, - Как делать заметки и работать с файлами, не переживая за качество связи и безопасность данных. - Как облегчает жизнь ИИ, который расшифровывает созвоны в текст и автоматически отправляет расшифровку на почту. Еще в методичке описаны 7 способов оценки текущей эффективности ваших онлайн-встреч. Получить гайд можно бесплатно на сайте. Скачать #реклама mts-link.ru О рекламодателе

🤔 Что такое абстрактная фабрика? Абстрактная фабрика (Abstract Factory) — это порождающий паттерн проектирования, который предоставляет интерфейс для создания семейств взаимосвязанных или взаимозависимых объектов без указания их конкретных классов. Этот паттерн позволяет создавать комплекты объектов, которые должны работать вместе, обеспечивая при этом их взаимозаменяемость. 🚩Основные концепции 🟠Абстрактная фабрика (Abstract Factory): Интерфейс или базовый класс с методами для создания различных продуктов (объектов). 🟠Конкретные фабрики (Concrete Factories): Реализации абстрактной фабрики, создающие конкретные продукты. 🟠Абстрактные продукты (Abstract Products): Интерфейсы или базовые классы для продуктов, которые создаются фабриками. 🟠Конкретные продукты (Concrete Products): Реализации абстрактных продуктов. Создание абстрактных продуктов: Рассмотрим пример, в котором абстрактная фабрика создает различные виды кнопок и чекбоксов для двух разных операционных систем: Windows и MacOS.

from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def click(self):
        pass

class Checkbox(ABC):
    @abstractmethod
    def check(self):
        pass

Создание конкретных продуктов

class WindowsButton(Button):
    def click(self):
        print("Windows button clicked")

class MacOSButton(Button):
    def click(self):
        print("MacOS button clicked")

class WindowsCheckbox(Checkbox):
    def check(self):
        print("Windows checkbox checked")

class MacOSCheckbox(Checkbox):
    def check(self):
        print("MacOS checkbox checked")

Создание абстрактной фабрики

class GUIFactory(ABC):
    @abstractmethod
    def create_button(self) -> Button:
        pass

    @abstractmethod
    def create_checkbox(self) -> Checkbox:
        pass

Создание конкретных фабрик

class WindowsFactory(GUIFactory):
    def create_button(self) -> Button:
        return WindowsButton()

    def create_checkbox(self) -> Checkbox:
        return WindowsCheckbox()

class MacOSFactory(GUIFactory):
    def create_button(self) -> Button:
        return MacOSButton()

    def create_checkbox(self) -> Checkbox:
        return MacOSCheckbox()

Использование абстрактной фабрики

def client_code(factory: GUIFactory):
    button = factory.create_button()
    checkbox = factory.create_checkbox()
    button.click()
    checkbox.check()

# Клиентский код может работать с любыми фабриками и продуктами
windows_factory = WindowsFactory()
macos_factory = MacOSFactory()

print("Client: Testing client code with Windows factory:")
client_code(windows_factory)

print("\nClient: Testing client code with MacOS factory:")
client_code(macos_factory)

🚩Преимущества абстрактной фабрики 🟠Изоляция конкретных классов: Клиентский код работает только с интерфейсами или абстрактными классами. 🟠Легкость замены семейств продуктов: Можно легко менять фабрики, чтобы использовать другие семейства продуктов. 🟠Согласованность продуктов: Абстрактная фабрика гарантирует, что продукты одного семейства будут совместимы между собой. 🚩Недостатки абстрактной фабрики 🟠Усложнение кода: Добавление новых классов и интерфейсов может усложнить структуру кода. 🟠Трудности расширения: При добавлении нового типа продукта может потребоваться изменение интерфейсов и всех конкретных фабрик. Ставь 👍 и забирай 📚 Базу знаний

Полезный гайд для HR в сфере IT! Корпоративное обучение и онбординг в IT-компании - не простая задача, ведь необходимо продумать множество деталей. В гайде для IT-компаний МТС Линк собрал лучшие практики, кейсы и рекомендации экспертов: - Как системно растить скиллы сотрудников и автоматизировать тренинги; - Как сделать обучение интерактивным с помощью онлайн-доски; - Как ускорить онбординг новых партнеров и увеличить перформанс. Получите гайд бесплатно на сайте. Скачать #реклама 16+ mts-link.ru О рекламодателе

🤔 Что такое порождающий паттерн? Порождающие паттерны (creational patterns) — это шаблоны проектирования в объектно-ориентированном программировании, которые предназначены для управления процессом создания объектов. 🚩Основные порождающие паттерны 🟠Одиночка (Singleton) 🟠Фабричный метод (Factory Method) 🟠Абстрактная фабрика (Abstract Factory) 🟠Строитель (Builder) 🟠Прототип (Prototype) Одиночка (Singleton): Паттерн Одиночка гарантирует, что у класса будет только один экземпляр, и предоставляет глобальную точку доступа к нему.

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance

singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2)  # True

Фабричный метод (Factory Method): Фабричный метод определяет интерфейс для создания объекта, но позволяет подклассам изменять тип создаваемых объектов.

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

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

class AnimalFactory:
    @staticmethod
    def get_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            return None

dog = AnimalFactory.get_animal("dog")
cat = AnimalFactory.get_animal("cat")
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

Абстрактная фабрика (Abstract Factory): Абстрактная фабрика предоставляет интерфейс для создания семейств связанных или зависимых объектов без указания их конкретных классов.

class Dog:
    def speak(self):
        return "Woof!"

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

class PetFactory:
    def create_dog(self):
        return Dog()

    def create_cat(self):
        return Cat()

factory = PetFactory()
dog = factory.create_dog()
cat = factory.create_cat()
print(dog.speak())  # Woof!
print(cat.speak())  # Meow!

Строитель (Builder): Паттерн Строитель используется для создания сложных объектов пошагово. Он позволяет создавать разные представления объекта, используя один и тот же код.

class House:
    def __init__(self):
        self.walls = None
        self.roof = None
        self.windows = None

    def __str__(self):
        return f"House with {self.walls} walls, {self.roof} roof, and {self.windows} windows."

class HouseBuilder:
    def __init__(self):
        self.house = House()

    def build_walls(self, walls):
        self.house.walls = walls
        return self

    def build_roof(self, roof):
        self.house.roof = roof
        return self

    def build_windows(self, windows):
        self.house.windows = windows
        return self

    def build(self):
        return self.house

builder = HouseBuilder()
house = builder.build_walls("brick").build_roof("tile").build_windows("double-glazed").build()
print(house)
# House with brick walls, tile roof, and double-glazed windows.

Прототип (Prototype): Паттерн Прототип создает новые объекты путем копирования существующих экземпляров (прототипов).

import copy

class Prototype:
    def __init__(self, value):
        self.value = value

    def clone(self):
        return copy.deepcopy(self)

original = Prototype(10)
clone = original.clone()
print(original.value)  # 10
print(clone.value)     # 10
clone.value = 20
print(original.value)  # 10
print(clone.value)     # 20

Ставь 👍 и забирай 📚 Базу знаний

До сих пор боишься вопроса про TCP/IP протоколы на собеседовании? 🖥 Network Admin — обучающий канал по сетевым технологиям. В канале ты найдешь множество полезной информации: ➖ Типы SSL - сертификатов ➖ Иерархия DNS ➖ Сетевая аналитика ➖ Процессы TCP сервера ➖ Маршрутизатор, Коммутатор, Хаб: В чем разница? ➖ Проверка уязвимости сервера Linux С Network Admin твои знания и навыки стремительно пойдут вверх Подписывайся - @networkadm