Решение модуля 1.6 Python: основы и применение

Модуль 1.6 Наследование классов

Какие числа будут выведены в результате выполнения данного кода?

class Base:
    def __init__(self):
        self.val = 0

    def add_one(self):
        self.val += 1

    def add_many(self, x):
        for i in range(x):
            self.add_one()

class Derived(Base):
    def add_one(self):
        self.val += 10


a = Derived()
a.add_one()

b = Derived()
b.add_many(3)

print(a.val)
print(b.val)

Описание:
Создается объект a класса Derived.
Вызывается метод add_one у объекта a. Этот метод в классе Derived переопределен и увеличивает val на 10.
Создается объект b класса Derived.
Вызывается метод add_many(3) у объекта b. Этот метод в классе Base добавляет единицу три раза, вызывая метод add_one из класса Derived, который увеличивает val на 10 каждый раз.

10, 30

Что будет выведено в результате выполнения данного кода?

class A:
   def foo(self):
      print("A")

class B(A):
   pass

class C(A):
   def foo(self):
      print("C")

class D:
   def foo(self):
      print("D")

class E(B, C, D):
   pass

E().foo()

Описание:
При выполнении данного кода будет вызван метод foo класса C, так как класс E наследует от классов B, C, и D в таком порядке. Когда метод foo вызывается у объекта E(), Python будет искать метод foo в классе E, затем в классе B (по порядку), затем в классе C (который переопределяет метод foo), и, наконец, в классе D.

C

Рассмотрим следующее объявление классов

class A:
    pass

class B(A):
    pass

class C:
    pass

class D(C):
    pass

class E(B, C, D):
    pass

Какие последовательности могут являться корректным порядком разрешения методов для класса E?

Никакие из перечисленных

Вам дано описание наследования классов в следующем формате.
<имя класса 1> : <имя класса 2> <имя класса 3> … <имя класса k>
Это означает, что класс 1 отнаследован от класса 2, класса 3, и т. д.

Или эквивалентно записи:

class Class1(Class2, Class3 ... ClassK):
    pass

Класс A является прямым предком класса B, если B отнаследован от A:

class B(A):
    pass

Вам необходимо отвечать на запросы, является ли один класс предком другого класса
Описание:
Данный код решает задачу проверки наследования классов. Вот шаги, которые выполняет программа:
Считывает количество классов n.
Создает словарь parents, который будет хранить информацию о том, от каких классов наследуется каждый класс. Проходит по каждому классу и сохраняет его родителей в словаре.
Определяет функцию is_parent(child, parent), которая рекурсивно проверяет, является ли один класс предком другого. Если имя ребенка совпадает с именем родителя, возвращает True. Иначе рекурсивно проверяет каждого родителя ребенка, чтобы убедиться, что родитель является предком.
Считывает количество запросов q.
Обрабатывает каждый запрос, считывая имена двух классов — ребенка и предка. Затем выводит «Yes», если предок является предком ребенка, и «No» в противном случае.
Код моделирует отношения наследования классов и проверяет, является ли один класс предком другого на основе предоставленных данных.

# Ввод количества классов
n = int(input())

# Словарь для хранения родителей каждого класса
parents = {}

# Считывание описания наследования классов
for _ in range(n):
    a = input().split()
    # Если класс не наследуется от других, добавляем пустой список в качестве родителей
    parents[a[0]] = [] if len(a) == 1 else a[2:]

# Функция для проверки, является ли один класс предком другого
def is_parent(child, parent):
    if child == parent:
        return True

    # Рекурсивно проверяем каждого родителя ребенка
    for p in parents[child]:
        if is_parent(p, parent):
            return True

    return False

# Ввод количества запросов
q = int(input())

# Обработка запросов
for _ in range(q):
    # Считывание имен классов из запроса
    child, parent = input().split()
    # Вывод "Yes", если parent является предком child, и "No" в противном случае
    print("Yes" if is_parent(parent, child) else "No")

Реализуйте структуру данных, представляющую собой расширенную структуру стек. Необходимо поддерживать добавление элемента на вершину стека, удаление с вершины стека, и необходимо поддерживать операции сложения, вычитания, умножения и целочисленного деления.

Операция сложения на стеке определяется следующим образом. Со стека снимается верхний элемент (top1), затем снимается следующий верхний элемент (top2), и затем как результат операции сложения на вершину стека кладется элемент, равный top1 + top2.

Аналогичным образом определяются операции вычитания (top1 — top2), умножения (top1 * top2) и целочисленного деления (top1 // top2).

Реализуйте эту структуру данных как класс ExtendedStack, отнаследовав его от стандартного класса list.

Описание:
Этот код определяет класс ExtendedStack, который является наследником стандартного класса list в Python. Класс расширяет функциональность обычного стека, добавляя четыре метода: sum, sub, mul и div.
Метод sum извлекает два верхних элемента из стека, складывает их, и затем добавляет результат обратно в стек.
Метод sub аналогично извлекает два верхних элемента, вычитает верхний элемент из следующего верхнего элемента, и добавляет результат в стек.
Метод mul умножает два верхних элемента, а затем добавляет результат в стек.
Метод div целочисленно делит следующий верхний элемент на верхний элемент, и результат добавляется обратно в стек.
Таким образом, этот класс предоставляет функциональность для выполнения арифметических операций на вершинах стека.

class ExtendedStack(list):
    def sum(self):
        top1 = self.pop()
        top2 = self.pop()
        result = top1 + top2
        self.append(result)

    def sub(self):
        top1 = self.pop()
        top2 = self.pop()
        result = top1 - top2
        self.append(result)

    def mul(self):
        top1 = self.pop()
        top2 = self.pop()
        result = top1 * top2
        self.append(result)

    def div(self):
        top1 = self.pop()
        top2 = self.pop()
        result = top1 // top2
        self.append(result)

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

Рассмотрим класс Loggable:

import time

class Loggable:
    def log(self, msg):
        print(str(time.ctime()) + ": " + str(msg))

У него есть ровно один метод log, который позволяет выводить в лог (в данном случае в stdout) какое-то сообщение, добавляя при этом текущее время.

Реализуйте класс LoggableList, отнаследовав его от классов list и Loggable таким образом, чтобы при добавлении элемента в список посредством метода append в лог отправлялось сообщение, состоящее из только что добавленного элемента.

Описание:
Этот код определяет класс с именем LoggableList, который наследуется от двух других классов: list и (предположительно) Loggable. Однако, по вашему примечанию, класс Loggable не должен быть включен в код, так что это создает противоречие.
В теле класса определен метод append, который переопределяет метод append из базового класса list. Внутри метода append вызывается метод log(i), который предположительно должен быть унаследован от класса Loggable. Это может вызвать ошибку, так как класс Loggable не был определен в предоставленном коде.

class LoggableList(list, Loggable):
    def append(self, i):
        super().append(i)
        self.log(i)