Python | Вопросы собесов
13.4K subscribers
8 photos
1 file
318 links
Разбираем вопросы с собеседований на Python разработчика. Django, Flask, FastApi

Реклама: @easyoffer_adv
Решай тесты - t.me/+20tRfhrwPpM4NDQy

Нарешивай задачи - t.me/+nsl4meWmhfQwNDVi
Ищи работу - t.me/+cXGKkrOY2-w3ZTky
Download Telegram
Какие паттерны проектирования используешь ?
Спросят с вероятностью 3%

Паттерны проектирования являются повторяемыми решениями общих проблем проектирования в объектно-ориентированном программировании. Они помогают создавать гибкие и легко поддерживаемые системы. Вот некоторые из наиболее часто используемых паттернов проектирования:

1️⃣Одиночка (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


2️⃣Строитель (Builder)

Цель: Отделяет создание сложного объекта от его представления, позволяя использовать один и тот же процесс создания для различных представлений.

Пример кода:
class Product:
def __init__(self):
self.parts = []

def add(self, part):
self.parts.append(part)

def show(self):
return ", ".join(self.parts)

class Builder:
def build_part_a(self):
pass

def build_part_b(self):
pass

class ConcreteBuilder(Builder):
def __init__(self):
self.product = Product()

def build_part_a(self):
self.product.add("Part A")

def build_part_b(self):
self.product.add("Part B")

def get_product(self):
return self.product

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

def construct(self):
self._builder.build_part_a()
self._builder.build_part_b()

builder = ConcreteBuilder()
director = Director(builder)
director.construct()
product = builder.get_product()
print(product.show()) # Вывод: Part A, Part B


3️⃣Фабричный метод (Factory Method)

Цель: Определяет интерфейс для создания объекта, но позволяет подклассам изменить тип создаваемого объекта.

Пример кода:
class Product:
def operation(self):
pass

class ConcreteProductA(Product):
def operation(self):
return "ConcreteProductA"

class ConcreteProductB(Product):
def operation(self):
return "ConcreteProductB"

class Creator:
def factory_method(self):
pass

def some_operation(self):
product = self.factory_method()
return f"Creator: The same creator's code has just worked with {product.operation()}"

class ConcreteCreatorA(Creator):
def factory_method(self):
return ConcreteProductA()

class ConcreteCreatorB(Creator):
def factory_method(self):
return ConcreteProductB()

creator_a = ConcreteCreatorA()
print(creator_a.some_operation()) # Вывод: Creator: The same creator's code has just worked with ConcreteProductA

creator_b = ConcreteCreatorB()
print(creator_b.some_operation()) # Вывод: Creator: The same creator's code has just worked with ConcreteProductB


Использование паттернов проектирования помогает создавать гибкие, масштабируемые и легко поддерживаемые системы. Они позволяют решать типичные задачи проектирования, избегая распространенных ошибок.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
🔥Тесты для подготовки к собеседованию🔥
Выбери своё направление:

1. Frontend
2. Python
3. Java
4. Тестировщик QA
5. Data Science
6. DevOps
7. C#
8. С/C++
9. Golang
10. PHP
11. Kotlin
12. Swift
Please open Telegram to view this post
VIEW IN TELEGRAM
В чем основные принципы инкапсуляции ?
Спросят с вероятностью 3%

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

1️⃣Сокрытие данных

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

Пример:
Публичные атрибуты: Доступны отовсюду.
    class MyClass:
def __init__(self):
self.public_attribute = "Public"


2️⃣Контроль доступа к данным

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

Пример:
class MyClass:
def __init__(self):
self.__private_attribute = "Initial Value"

def get_private_attribute(self):
return self.__private_attribute

def set_private_attribute(self, value):
if isinstance(value, str):
self.__private_attribute = value
else:
raise ValueError("Value must be a string")

obj = MyClass()
print(obj.get_private_attribute()) # Вывод: Initial Value
obj.set_private_attribute("New Value")
print(obj.get_private_attribute()) # Вывод: New Value


3️⃣Изоляция внутренней реализации

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

Пример:
class BankAccount:
def __init__(self, balance):
self.__balance = balance

def deposit(self, amount):
if amount > 0:
self.__balance += amount
else:
raise ValueError("Deposit amount must be positive")

def withdraw(self, amount):
if 0 < amount <= self.__balance:
self.__balance -= amount
else:
raise ValueError("Invalid withdraw amount")

def get_balance(self):
return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance()) # Вывод: 1500
account.withdraw(200)
print(account.get_balance()) # Вывод: 1300


4️⃣Повышение надежности и упрощение сопровождения кода

Внутренние детали реализации могут быть изменены без влияния на внешний код. Это делает код более надежным и легким в сопровождении.

Пример:
Изменение внутренней реализации:
    class BankAccount:
def __init__(self, balance):
self.__balance = balance

def deposit(self, amount):
if amount > 0:
self.__balance += amount
else:
raise ValueError("Deposit amount must be positive")

def withdraw(self, amount):
if 0 < amount <= self.__balance:
self.__balance -= amount
else:
raise ValueError("Invalid withdraw amount")

def get_balance(self):
return self.__balance

# Внешний код не изменяется
account = BankAccount(1000)
account.deposit(500)
print(account.get_balance()) # Вывод: 1500
account.withdraw(200)
print(account.get_balance()) # Вывод: 1300


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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Как связаны new и singleton ?
Спросят с вероятностью 3%

Методы __new__ и паттерн Singleton тесно связаны, поскольку методью 3%

Мечасто используется для реализации Singleton в Python. Singleton — это паттерн проектирования, который гарантирует, что у класса будет только один экземпляр на протяжении всего жизненного цикла приложения. Метод new отвечает за создание нового экземпляра класса, и именно его можно использовать для контроля создания объектов.

Метод new — это специальный метод, который вызывается перед методом init. Он отвечает за создание и возвращение нового экземпляра класса. В отличие от метода init, который инициализирует уже существующий объект, new создаёт новый объект класса.

Пример использования new в Singleton

Для реализации паттерна Singleton с использованием метода new нужно сделать так, чтобы метод new возвращал один и тот же экземпляр класса при каждом вызове.

Пример кода:
class Singleton:
_instance = None

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

def __init__(self, value):
if not hasattr(self, '_initialized'): # Проверка на инициализацию
self.value = value
self._initialized = True

# Проверка работы Singleton
singleton1 = Singleton("First Instance")
print(singleton1.value) # Вывод: First Instance

singleton2 = Singleton("Second Instance")
print(singleton2.value) # Вывод: First Instance

print(singleton1 is singleton2) # Вывод: True


Пошаговое объяснение:

1️⃣Статический атрибут _instance: Используется для хранения единственного экземпляра класса.
2️⃣
Метод
eton1 = Sin

Проверяет, существует ли уже экземпляр класса (cls._instance is None).
Если не существует, создаёт новый экземпляр с помощью super(Singleton, cls).new(cls, args, kwargs) и сохраняет его в cls._instance.
Возвращает экземпляр класса, хранящийся в cls._instance.
3️⃣Метод init:
Инициализирует экземпляр только один раз. Проверка if not hasattr(self, '_initialized') предотвращает повторную инициализацию объекта.

Почему Singleton и new связаны

Контроль создания объектов: Метод new позволяет контролировать процесс создания объекта, что идеально подходит для реализации Singleton.
Единственность экземпляра: С помощью new можно гарантировать, что будет создан только один экземпляр класса, поскольку new может возвращать уже существующий экземпляр.
Разделение обязанностей: Метод new отвечает за создание (или возврат существующего) экземпляра, а метод init — за его инициализацию, если это необходимо.

Метод new используется для создания новых экземпляров класса и идеально подходит для реализации паттерна Singleton, так как позволяет контролировать создание единственного экземпляра класса и возвращать его при каждом вызове.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Как бы реализовал паттерн singleton ?
Спросят с вероятностью 3%

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

Существует несколько способов реализовать Singleton. Рассмотрим один из наиболее распространенных способов - использование приватного конструктора и класса-метода для получения экземпляра.
class Singleton:
__instance = None

def __new__(cls, args, kwargs):
if cls.__instance is None:
cls.__instance = super(Singleton, cls).__new__(cls, args, kwargs)
return cls.__instance

def __init__(self):
if not hasattr(self, 'initialized'):
self.initialized = True
# Инициализация объекта, если нужно
self.value = 0

# Проверка работы
singleton1 = Singleton()
singleton2 = Singleton()

print(singleton1 is singleton2) # Выведет: True
print(singleton1.value) # Выведет: 0
singleton1.value = 42
print(singleton2.value) # Выведет: 42


Объяснение кода

1️⃣Приватный атрибут _instance_:
Этот атрибут используется для хранения единственного экземпляра класса.

2️⃣Метод __new__:
__new__ - это метод, который создаёт новый экземпляр класса. Если экземпляр уже существует (cls.__instance не None), возвращается существующий экземпляр.
Если экземпляр ещё не был создан, super(Singleton, cls).__new__(cls, args, kwargs) создаёт новый экземпляр и сохраняет его в cls.__instance.

3️⃣Метод init:
Методреализовалвызывается каждый раз при создании экземпляра. Чтобы избежать повторной инициализации, проверяем наличие атрибута initialized.

Можно также реализовать Singleton с помощью декоратора:
def singleton(cls):
instances = {}
def get_instance(*args, **kwargs):
if cls not in instances:
instances[cls] = cls(*args, **kwargs)
return instances[cls]
return get_instance

@singleton
class SingletonClass:
def __init__(self):
self.value = 0

# Проверка работы
singleton1 = SingletonClass()
singleton2 = SingletonClass()

print(singleton1 is singleton2) # Выведет: True
print(singleton1.value) # Выведет: 0
singleton1.value = 42
print(singleton2.value) # Выведет: 42


Объяснение

1️⃣Декоратор singleton:
Хранит экземпляры класса в словаре instances.
Если экземпляра класса ещё нет в словаре, он создаётся и добавляется в словарь.
Возвращается существующий или новый экземпляр класса.

Паттерн Singleton гарантирует, что класс имеет только один экземпляр. Это достигается контролем создания экземпляров через методые None), или декоратор. Singleton полезен для управления ресурсами и глобального состояния.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Какое максимально допустимое количество символов рекомендует PEP8 использовать в строке кода?
Anonymous Quiz
51%
79 символов
31%
120 символов
7%
100 символов
11%
90 символов
На что влияет атрибут slots ?
Спросят с вероятностью 3%

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

Как он работает

По умолчанию, Python использует словарь (__dict__) для хранения атрибутов экземпляров. Это даёт большую гибкость, но также приводит к значительному расходу памяти.

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

Пример использования
class RegularClass:
def __init__(self, x, y):
self.x = x
self.y = y

class SlotsClass:
_(self, x, = ['x', 'y']

def __init__(self, x, y):
self.x = x
self.y = y

# Создадим экземпляры классов
regular_instance = RegularClass(1, 2)
slots_instance = SlotsClass(1, 2)

# Попробуем добавить новый атрибут
regular_instance.z = 3 # Это работает
# slots_instance.z = 3 # Это вызовет ошибку AttributeError

print(regular_instance.__dict__) # {'x': 1, 'y': 2, 'z': 3}
# print(slots_instance.__dict__) # AttributeError: 'SlotsClass' object has no attribute '__dict__'

# Проверим использование памяти
import sys
print(sys.getsizeof(regular_instance)) # Выведет размер в байтах
print(sys.getsizeof(slots_instance)) # Выведет размер в байтах, который будет меньше


Объяснение

1️⃣Ограничение атрибутов:
В классе RegularClass можно добавлять любые атрибуты, так как используется словарь (__dict__).
В классе SlotsClass можно добавлять только атрибуты, указанные в
= x


2️⃣Использование памяти:
Экземпляры класса состью 3%

Азанимают меньше памяти, так как для хранения атрибутов не используется словарь.
Это может существенно уменьшить использование памяти в случаях, когда создаётся много экземпляров класса.

Преимущества:
Снижение использования памяти: Экономия памяти за счёт отказа от словарей для хранения атрибутов.
Ускорение доступа к атрибутам: Быстрый доступ к атрибутам благодаря фиксированному набору атрибутов.

Недостатки:
Ограничение гибкости: Невозможно добавлять новые атрибуты, не указанные в_slots__ в
Наследование: Классы-наследники должны явно указывать slots, чтобы сохранить оптимизацию.

Атрибут slots ограничивает набор атрибутов экземпляров класса и уменьшает использование памяти за счёт отказа от словарей для хранения атрибутов. Это повышает эффективность, но уменьшает гибкость.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Какая проблема Python связана с множественным наследованием ?
Спросят с вероятностью 3%

Множественное наследование позволяет классу наследовать от нескольких базовых классов, что может быть полезно, но также приводит к ряду проблем. Основные проблемы, связанные с множественным наследованием, включают:

1️⃣Проблема ромба (Diamond Problem):
Это ситуация, когда класс наследует от двух классов, которые оба наследуют от одного общего предка. Это может привести к неоднозначности в разрешении методов и атрибутов.
Пример:
          class A:
def method(self):
print("Method in A")

class B(A):
def method(self):
print("Method in B")

class C(A):
def method(self):
print("Method in C")

class D(B, C):
pass

d = D()
d.method() # Какой метод будет вызван: из B или из C?


2️⃣Проблемы с порядком разрешения методов (MRO - Method Resolution Order):
В Python для решения проблемы ромба используется алгоритм C3-линеаризации, который определяет порядок, в котором должны быть просмотрены базовые классы.
Можно использовать функцию mro() для просмотра порядка разрешения методов:
  print(D.mro())

Пример:
          class A:
def method(self):
print("Method in A")

class B(A):
def method(self):
print("Method in B")

class C(A):
def method(self):
print("Method in C")

class D(B, C):
pass

d = D()
d.method() # Выведет: "Method in B", так как B стоит раньше C в MRO


3️⃣Управление состоянием и совместимость:
Классы могут иметь конфликтующие атрибуты и методы, что усложняет управление состоянием объектов.
Переопределение методов в одном классе может непредсказуемо повлиять на поведение других классов.

Как он решает эти проблемы


Использует несколько подходов для решения проблем, связанных с множественным наследованием:

1️⃣Алгоритм C3-линеаризации:
Этот алгоритм гарантирует корректный и предсказуемый порядок вызовов методов при множественном наследовании.
Порядок определяется как левая-направо, глубина-первый подход с корректировкой для избежания дублирования базовых классов.

2️⃣Использование функции super():
Функция super() позволяет корректно вызывать методы родительских классов, следуя порядку MRO.
Это помогает избежать явного указания родительских классов и упрощает поддержку кода.
Пример:
          class A:
def method(self):
print("Method in A")

class B(A):
def method(self):
super().method()
print("Method in B")

class C(A):
def method(self):
super().method()
print("Method in C")

class D(B, C):
def method(self):
super().method()

d = D()
d.method()
# Выведет:
# Method in A
# Method in C
# Method in B


Проблема множественного наследования связана с неоднозначностью порядка вызова методов и конфликтами атрибутов. Python решает эти проблемы с помощью алгоритма C3-линеаризации и функции super(), обеспечивающей корректный порядок разрешения методов.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Какой HTTP метод REST API не соответствует принципу идемпотентности, согласно стандартному использованию?
Anonymous Quiz
34%
PUT
26%
DELETE
10%
GET
30%
POST
Для чего они нужны dunder методы ?
Спросят с вероятностью 3%

Dunder-методы представляют собой специальные методы, которые начинаются и заканчиваются двойным подчёркиванием (например, __init__,Для чего __repr__).

Основные методы и их назначения

1️⃣Инициализация и завершение объектов:
__init__(self, ...): Конструктор класса, вызывается при создании нового экземпляра.
          class MyClass:
def __init__(self, value):
self.value = value

__del__(self): Деструктор, вызывается при удалении объекта.

2️⃣Представление объектов:
__str__(self): Определяет поведение функции str() и print(). Возвращает строковое представление объекта для пользователя.
          class MyClass:
def __init__(self, value):
self.value = value

def __str__(self):
return f'MyClass with value {self.value}'

__repr__(self): Определяет поведение функции repr(). Возвращает строковое представление объекта для разработчика.
          class MyClass:
def __init__(self, value):
self.value = value

def __repr__(self):
return f'MyClass({self.value!r})'


3️⃣Сравнение объектов:
__eq__(self, other): Оператор равенства ==.
__lt__(self, other): Оператор меньше <.
__le__(self, other): Оператор меньше или равно <=.
Аналогично можно определить методыСравнениДля чегоДля чего

4️⃣Арифметические операции:
__add__(self, other): Оператор сложения +.
__sub__(self, other): Оператор вычитания -.
__mul__(self, other): Оператор умножения *.
Аналогично можно определить методы для других арифметических операций:х назначения
Для чего они нДля чего Для чего

5️⃣Контейнерные операции:
__len__(self): Возвращает длину объекта, используется в функции len().
          class MyContainer:
def __init__(self, items):
self.items = items

def __len__(self):
return len(self.items)

__getitem__(self, key): Позволяет доступ к элементам по ключу (используется оператор []).
          class MyContainer:
def __init__(self, items):
self.items = items

def __getitem__(self, index):
return self.items[index]


6️⃣Итерация:
__iter__(self): Возвращает итератор для объекта.
          class MyContainer:
def __init__(self, items):
self.items = items

def __iter__(self):
return iter(self.items)


7️⃣Контекстные менеджеры:
__enter__(self): Определяет действия при входе в контекст (with).
__exit__(self, exc_type, exc_value, traceback): Определяет действия при выходе из контекста.
          class MyContextManager:
def __enter__(self):
print("Entering the context")
return self

def __exit__(self, exc_type, exc_value, traceback):
print("Exiting the context")

with MyContextManager():
print("Inside the context")


Зачем они нужны

1️⃣Упрощение работы с объектами: Позволяют легко определять, как объекты класса должны вести себя при использовании стандартных операторов и функций Python.
2️⃣Читаемость и удобство: Улучшают читаемость и удобство использования кода, делая объекты более интуитивными и естественными для работы.
3️⃣Переиспользование кода: Позволяют реализовать методы один раз и переиспользовать их в различных частях программы, что способствует уменьшению дублирования кода.

Dunder-методы позволяют классам интегрироваться с встроенными операциями и функциями, такими как арифметические операции, сравнения и представления. Они делают работу с объектами интуитивной и упрощают код.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Как бы реализовал метод new через singleton ?
Спросят с вероятностью 3%

Чтобы реализовать метод __new__ для создания класса по шаблону Singleton, нужно следовать принципам, которые обеспечивают создание только одного экземпляра класса. Метод new отвечает за создание нового экземпляра класса, и его можно использовать для контроля этого процесса. Ниже приведен пример реализации Singleton с использованием метода new.

Пример реализации Singleton с методом new
class Singleton:
_instance = None

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

def __init__(self, value):
if not hasattr(self, 'initialized'):
self.value = value
self.initialized = True

# Проверка работы Singleton
singleton1 = Singleton(10)
singleton2 = Singleton(20)

print(singleton1 is singleton2) # Выведет: True
print(singleton1.value) # Выведет: 10
print(singleton2.value) # Выведет: 10


Объяснение кода

1️⃣Атрибут _instance:
cls._instance используется для хранения единственного экземпляра класса.

2️⃣Метод
e):

Методреализовавызывается передл метод neи отвечает за создание нового экземпляра класса.
Если _instance равен None, создается новый экземпляр с помощью super(Singleton, cls).__new__(cls, args, kwargs) и сохраняется в _instance.
Если _instance уже существует, возвращается существующий экземпляр.

3️⃣Метод init:
Метод init выполняет инициализацию экземпляра.
Чтобы избежать повторной инициализации, проверяется наличие атрибута initialized. Если он не существует, происходит инициализация атрибутов и устанавливается initialized = True.

Преимущества и особенности реализации

Контроль создания экземпляров: Метод new гарантирует, что создается только один экземпляр класса.
Предотвращение повторной инициализации: Метод init инициализируется только один раз, что предотвращает перезапись значений атрибутов при повторных вызовах.

Метод new используется в шаблоне Singleton для создания только одного экземпляра класса. Он контролирует процесс создания объекта, возвращая существующий экземпляр, если он уже создан.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Какой метод метакласса позволяет модифицировать атрибуты класса перед его созданием?
Anonymous Quiz
37%
__new__
41%
__init__
5%
__call__
17%
__prepare__
Как выражена инкапсуляция в python ?
Спросят с вероятностью 3%

Инкапсуляция выражена через механизмы, которые позволяют скрывать внутренние детали реализации класса и предоставлять доступ к данным и методам через определённый интерфейс. Достигается с помощью соглашений об именовании и специальных методов. Основные аспекты инкапсуляции включают:

Соглашения об именовании

1️⃣Приватные атрибуты и методы:
В Python соглашение об именовании позволяет сделать атрибуты и методы приватными, что предотвращает их случайное использование вне класса.
Атрибуты и методы, начинающиеся с одного подчёркивания (_), считаются защищёнными и не должны использоваться вне класса или подклассов.
Атрибуты и методы, начинающиеся с двойного подчёркивания (__), подвергаются манглингу имён (name mangling), что делает их труднодоступными из вне класса.
class MyClass:
def __init__(self, value):
self._protected_value = value # Защищённый атрибут
self.__private_value = value # Приватный атрибут

def _protected_method(self):
print("This is a protected method.")

def __private_method(self):
print("This is a private method.")


Примеры использования

1️⃣Защищённые атрибуты и методы:
Они не предназначены для использования вне класса, но могут быть использованы в подклассах.
Их использование вне класса является плохой практикой, но технически возможно.
class SubClass(MyClass):
def access_protected(self):
print(self._protected_value)
self._protected_method()

instance = SubClass(10)
instance.access_protected()
# Выведет:
# 10
# This is a protected method.


2️⃣Приватные атрибуты и методы:
Они подвергаются манглингу имён, что делает их труднодоступными из вне класса.
Внешний доступ возможен, но с использованием специального синтаксиса, что считается плохой практикой.
class AnotherClass:
def __init__(self, value):
self.__private_value = value

def __private_method(self):
print("This is a private method.")

def access_private(self):
print(self.__private_value)
self.__private_method()

instance = AnotherClass(20)
instance.access_private()
# Выведет:
# 20
# This is a private method.

# Попытка доступа к приватному атрибуту извне
# print(instance.__private_value) # AttributeError

# Доступ с использованием манглинга имён (не рекомендуется)
print(instance._AnotherClass__private_value) # Выведет: 20


Свойства (Properties)


Предоставляют интерфейс для управления доступом к атрибутам и позволяют инкапсулировать логику доступа и изменения данных.
class MyClassWithProperty:
def __init__(self, value):
self._value = value

@property
def value(self):
return self._value

@value.setter
def value(self, new_value):
if new_value > 0:
self._value = new_value
else:
raise ValueError("Value must be positive")

instance = MyClassWithProperty(10)
print(instance.value) # Выведет: 10
instance.value = 20
print(instance.value) # Выведет: 20
# instance.value = -10 # ValueError: Value must be positive


Инкапсуляция достигается с помощью соглашений об именовании (одинарное подчёркивание для защищённых и двойное подчёркивание для приватных атрибутов и методов) и использования свойств для управления доступом к атрибутам. Это позволяет скрывать внутренние детали реализации и предоставлять контролируемый интерфейс для взаимодействия с объектами.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 1096 вопроса на Python разработчика. Ставь 👍 если нравится контент

🔐 База собесов | 🔐 База тестовых
Какой метод декоратора property позволяет установить значение атрибута, при этом применяя дополнительные проверки или вычисления?
Anonymous Quiz
16%
getter
67%
setter
1%
deleter
16%
updater