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

Модуль 1.5 Введение в классы

В какой момент начинается исполнение конструктора класса?

При создании каждого экземпляра класса

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

class A:
    def __init__(self, val=0):
        self.val = val

    def add(self, x):
        self.val += x

    def print_val(self):
        print(self.val)


a = A()
b = A(2)
c = A(4)
a.add(2)
b.add(2)

a.print_val()
b.print_val()
c.print_val()

Описание:
В коде определен класс A, который содержит три метода:
__init__: Конструктор класса, который инициализирует объект класса. Принимает аргумент val (по умолчанию 0) и устанавливает его в качестве атрибута val для создаваемого объекта.
add: Метод, который принимает аргумент x и увеличивает значение атрибута val на значение x.
print_val: Метод, который выводит текущее значение атрибута val объекта.
Затем создаются три объекта класса A: a, b, и c с разными начальными значениями. Вызываются методы add для объектов a и b, изменяя их значения. Затем вызываются методы print_val для каждого объекта, чтобы вывести их текущие значения на экран.
Это связано с тем, что у объекта a значение val было установлено в 0 по умолчанию, затем было увеличено на 2 и еще на 2, что дало 4. Объект b был создан с начальным значением 2, и затем его значение было увеличено на 2, также становясь равным 4. Объект c был создан с начальным значением 4 и не подвергался изменениям, поэтому его значение осталось 4.

2, 4, 4

Реализуйте класс MoneyBox, для работы с виртуальной копилкой.

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

Описание:
Данный код представляет собой реализацию класса MoneyBox для работы с виртуальной копилкой. Класс имеет три метода:
Конструктор (__init__): Принимает аргумент capacity, который представляет собой вместимость копилки. В начале создания копилки количество монет устанавливается в 0.
Метод can_add(self, v): Проверяет, можно ли добавить v монет в копилку, не превышая ее вместимость. Возвращает True, если добавление возможно, и False в противном случае.
Метод add(self, v): Добавляет v монет в копилку при условии, что это возможно с учетом вместимости. Использует метод can_add для проверки.
Этот класс предоставляет удобный интерфейс для работы с копилкой, обеспечивая контроль за вместимостью и возможностью добавления монет.

class MoneyBox:
    def __init__(self, capacity):
        # конструктор с аргументом – вместимость копилки
        self.capacity = capacity
        self.coins = 0

    def can_add(self, v):
        # True, если можно добавить v монет, False иначе
        return self.coins + v <= self.capacity

    def add(self, v):
        # положить v монет в копилку
        if self.can_add(v):
            self.coins += v

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

Но последовательность не дается вам сразу целиком. С течением времени к вам поступают её последовательные части. Например, сначала первые три элемента, потом следующие шесть, потом следующие два и т. д.

Реализуйте класс Buffer, который будет накапливать в себе элементы последовательности и выводить сумму пятерок последовательных элементов по мере их накопления.

Описание:
Этот код представляет собой реализацию класса Buffer для обработки последовательных частей числовой последовательности и вывода суммы пятерок элементов по мере их добавления.
Конструктор (__init__): Инициализирует объект класса. Создается пустой буфер (self.buffer), который будет использоваться для хранения последовательных элементов.
Метод add(self, *a): Добавляет следующую часть последовательности в буфер. Использует extend для добавления элементов в конец буфера. После добавления проверяет, если в буфере уже накопилось пять элементов или более, то выводит сумму первых пятерок элементов и удаляет их из буфера.
Метод get_current_part(self): Возвращает сохраненные в текущий момент элементы последовательности в порядке, в котором они были добавлены.
Этот класс обеспечивает эффективное добавление элементов последовательности и вывод суммы пятерок элементов по мере их поступления.

class Buffer:
    def __init__(self):
        # конструктор без аргументов
        self.buffer = []

    def add(self, *a):
        # добавить следующую часть последовательности
        self.buffer.extend(a)
        while len(self.buffer) >= 5:
            print(sum(self.buffer[:5]))
            self.buffer = self.buffer[5:]

    def get_current_part(self):
        # вернуть сохраненные в текущий момент элементы последовательности
        # в порядке, в котором они были добавлены
        return self.buffer

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

class A:
    val = 1

    def foo(self):
        A.val += 2

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


a = A()
b = A()

a.bar()
a.foo()

c = A()

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

Описание:
a.bar(): Увеличивает значение val объекта a (теперь a.val равно 2).
a.foo(): Увеличивает значение val в классе A (теперь A.val равно 3).
Создается новый объект c, который наследует значение val из класса A. Так что c.val также равно 3.

2, 3, 3