Основы языка программирования. Объекты, классы, методы. Лекция 5.1 презентация

Напоминание:
29/10/2022 (следующее занятие)
Перед лекцией будет тест по 3 и 4 модулю (3, 4.1 и 4.2 презентации), всего 20 вопросов (10 на третий модуль и 10 на четвертый)
Те, кто по уважительным причинам не сможет присутствовать очно, могут пройти тест онлайн на портале Moodle с 13.30 до 23.00
Максимальная оценка 100 баллов по каждому модулю
Проходная оценка 60 баллов по каждому модулю
Для зачета будет достаточно набрать проходной балл
Напоминаю, что за текущим прогрессом можно следить в таблице:
https://docs.google.com/spreadsheets/d/1nHotD8t1h11jzW3kYlMOSpDbrluepxVQeH6B_MJgMcE/edit#gid=0
REMINDER

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

Класс сообщает Python, как создать объект, представляющий собаку. После того как класс будет написан, мы используем его для создания экземпляров, каждый из которых представляет одну конкретную собаку
В каждом экземпляре, созданном на основе класса Dog, будет храниться кличка и возраст; кроме того, в нем будут присутствовать методы sit() и roll_over()
Сначала определяется класс с именем Dog. По общепринятым соглашениям имена, начинающиеся с символа верхнего регистра, в Python обозначают классы. Круглые скобки в определении класса пусты, потому что класс создается с нуля.
CLASS
dog.py
class Dog():
"""Простая модель собаки."""
def __init__(self, name, age):
"""Инициализирует атрибуты name и age."""
self.name = name
self.age = age
def sit(self):
"""Собака садится по команде."""
print(self.name.title() + " is now sitting.")
def roll_over(self):
"""Собака перекатывается по команде."""
print(self.name.title() + " rolled over!")

Функция, являющаяся частью класса, называется методом. Все, что вы узнали ранее о функциях, также относится и к методам; единственное практическое различие — способ вызова методов. Метод __init__() — специальный метод, который автоматически выполняется при создании каждого нового экземпляра на базе класса Dog. Имя метода начинается и заканчивается двумя символами подчеркивания; эта схема предотвращает конфликты имен стандартных методов Python и методов ваших классов.
__init__()
dog.py
class Dog():
"""Простая модель собаки."""
def __init__(self, name, age):
"""Инициализирует атрибуты name и age."""
self.name = name
self.age = age
def sit(self):
"""Собака садится по команде."""
print(self.name.title() + " is now sitting.")
def roll_over(self):
"""Собака перекатывается по команде."""
print(self.name.title() + " rolled over!")

Метод __init__() определяется с тремя параметрами: self, name и age. Параметр self обязателен в определении метода; он должен предшествовать всем остальным параметрам. Он должен быть включен в определение для того, чтобы при будущем вызове метода __init__() (для создания экземпляра Dog) автоматически передавался аргумент self. При каждом вызове метода, связанного с классом, автоматически передается self — ссылка на экземпляр; она предоставляет конкретному экземпляру доступ к атрибутам и методам класса.
__init__()
dog.py
class Dog():
"""Простая модель собаки."""
def __init__(self, name, age):
"""Инициализирует атрибуты name и age."""
self.name = name
self.age = age
def sit(self):
"""Собака садится по команде."""
print(self.name.title() + " is now sitting.")
def roll_over(self):
"""Собака перекатывается по команде."""
print(self.name.title() + " rolled over!")

Любая переменная с префиксом self доступна для каждого метода в классе, и вы также сможете обращаться к этим переменным в каждом экземпляре, созданном на основе класса. Конструкция self.name = name берет значение, хранящееся в параметре name, и сохраняет его в переменной name, которая затем связывается с создаваемым экземпляром. Процесс также повторяется с self.age = age. Переменные, к которым вы обращаетесь через экземпляры, тоже называются атрибутами.
__init__()
dog.py
class Dog():
"""Простая модель собаки."""
def __init__(self, name, age):
"""Инициализирует атрибуты name и age."""
self.name = name
self.age = age
def sit(self):
"""Собака садится по команде."""
print(self.name.title() + " is now sitting.")
def roll_over(self):
"""Собака перекатывается по команде."""
print(self.name.title() + " rolled over!")

В классе Dog также определяются два метода: sit() и roll_over(). Так как этим методам не нужна дополнительная информация (кличка или возраст), они определяются с единственным параметром self.
Экземпляры, которые будут созданы позднее, смогут вызывать эти методы. Пока методы sit() и roll_over() ограничиваются простым выводом сообщения о том, что собака садится или перекатывается.
__init__()
dog.py
class Dog():
"""Простая модель собаки."""
def __init__(self, name, age):
"""Инициализирует атрибуты name и age."""
self.name = name
self.age = age
def sit(self):
"""Собака садится по команде."""
print(self.name.title() + " is now sitting.")
def roll_over(self):
"""Собака перекатывается по команде."""
print(self.name.title() + " rolled over!")

Мы приказываем Python создать экземпляр собаки с кличкой 'willie' и возрастом 6.
В процессе обработки этой строки Python вызывает метод __init__() класса Dog с аргументами 'willie' и 6. Метод __init__() создает экземпляр, представляющий конкретную собаку, и присваивает его атрибутам name и age переданные значения.
Метод __init__() не содержит явной команды return, но Python автоматически возвращает экземпляр, представляющий собаку. Этот экземпляр сохраняется в переменной my_dog.
Создание экземпляра
class Dog():
...
my_dog = Dog('willie', 6)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")

Для обращения к атрибутам экземпляра используется «точечная» запись. В строке из примера мы обращаемся к значению атрибута name экземпляра my_dog:
my_dog.name
Python обращается к экземпляру my_dog и ищет атрибут name, связанный с экземпляром my_dog.
Это тот же атрибут, который обозначался self.name в классе Dog. Тот же прием используется для работы с атрибутом age. В первой команде print вызов my_dog.name.title() записывает 'willie' (значение атрибута name экземпляра my_dog) с символа верхнего регистра. Во второй команде print вызов str(my_dog.age) преобразует 6, значение атрибута age экземпляра my_dog, в строку.
Пример выводит сводку известных фактов о my_dog:
My dog's name is Willie.
My dog is 6 years old.
Создание экземпляра
class Dog():
...
my_dog = Dog('willie', 6)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")

После создания экземпляра на основе класса Dog можно
применять точечную запись для вызова любых методов,
определенных в Dog
Чтобы вызвать метод, укажите экземпляр (в данном
случае my_dog) и вызываемый метод, разделив их точкой.
В ходе обработки my_dog.sit() Python ищет метод sit()в
классе Dog и выполняет его код. Строка my_dog.roll_over()
интерпретируется аналогичным образом.
Теперь экземпляр послушно выполняет полученные команды:
Willie is now sitting.
Willie rolled over!
Это очень полезный синтаксис. Если атрибутам и методам были присвоены содержательные имена (например, name, age, sit() и roll_over()), разработчик сможет легко понять, что делает блок кода, — даже если он видит этот блок впервые.
Вызов методов
class Dog():
...
my_dog = Dog('willie', 6)
my_dog.sit()
my_dog.roll_over()

На основе класса можно создать столько экземпляров, сколько вам потребуется. Создадим второй экземпляр Dog с именем your_dog
В этом примере создаются два экземпляра с именами Willie и Lucy. Каждый экземпляр обладает своим набором атрибутов и способен выполнять действия из общего набора:
Даже если второй собаке будут назначены те же имя и возраст, Python все равно создаст отдельный экземпляр класса Dog. Вы можете создать сколько угодно экземпляров одного класса при условии, что эти экземпляры хранятся в переменных с разными именами или занимают разные позиции в списке или словаре
Создание нескольких экземпляров
class Dog():
...
my_dog = Dog('willie', 6)
your_dog = Dog('lucy', 3)
print("My dog's name is " + my_dog.name.title() + ".")
print("My dog is " + str(my_dog.age) + " years old.")
my_dog.sit()
print("\nYour dog's name is " + your_dog.name.title() + ".")
print("Your dog is " + str(your_dog.age) + " years old.")
your_dog.sit()
_______________________
My dog's name is Willie.
My dog is 6 years old.
Willie is now sitting.
Your dog's name is Lucy.
Your dog is 3 years old.
Lucy is now sitting.

CLASSES
car.py
class Car():
"""Простая модель автомобиля."""
(1) def __init__(self, make, model, year):
"""Инициализирует атрибуты описания автомобиля.""" self.make = make
self.model = model
self.year = year
(2)def get_descriptive_name(self):
"""Возвращает аккуратно отформатированное описание."""
long_name = str(self.year) + ' ' + self.make + ' ' + self.model
return long_name.title()
(3) my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())

Каждый атрибут класса должен иметь исходное значение, даже если оно равно 0 или пустой строке. В некоторых случаях (например, при задании значений по умолчанию) это исходное значение есть смысл задавать в теле метода __init__(); в таком случае передавать параметр для этого атрибута при создании объекта не обязательно.
Добавим атрибут с именем odometer_reading, исходное значение которого всегда равно 0. Также в класс будет включен метод read_odometer() для чтения текущих показаний одометра:
ATRIBUTES
class Car():
def __init__(self, make, model, year):
"""Инициализирует атрибуты описания автомобиля."""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
...
def read_odometer(self):
"""Выводит пробег машины в милях."""
print("This car has " + str(self.odometer_reading) + " miles on it.")
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer()
_________________________
2016 Audi A4
This car has 0 miles on it.

Значение атрибута можно изменить одним из трех способов: изменить его прямо в экземпляре, задать значение при помощи метода или изменить его с приращением (то есть прибавлением определенной величины) при помощи метода.
ATRIBUTES

Чтобы изменить значение атрибута, проще всего обратиться к нему прямо через экземпляр. В следующем примере на одометре напрямую выставляется значение 23:
Точечная запись используется для обращения к атрибуту odometer_reading экземпляра и прямого присваивания его значения. Эта строка приказывает Python взять экземпляр my_new_car, найти связанный с ним атрибут odometer_reading и задать значение атрибута равным 23
Иногда подобные прямые обращения к атрибутам допустимы, но чаще разработчик пишет вспомогательный метод, который изменяет значение за него.
Прямое изменение значения атрибута
class Car():
...
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
_________________________
2016 Audi A4
This car has 23 miles on it.

В класс можно включить методы, которые изменяют некоторые атрибуты за вас. Вместо того чтобы изменять атрибут напрямую, вы передаете новое значение методу, который берет обновление атрибута на себя.
В следующем примере в класс включается метод update_odometer() для изменения показаний одометра:
Изменение значения атрибута с использованием метода
class Car():
def update_odometer(self, mileage):
"""Устанавливает заданное значение на одометре."""
self.odometer_reading = mileage
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.update_odometer(23)
my_new_car.read_odometer()
_________________________
2016 Audi A4
This car has 23 miles on it.

Метод update_odometer() можно расширить так, чтобы при каждом изменении показаний одометра выполнялась некоторая дополнительная работа. Добавим проверку, которая гарантирует, что никто не будет пытаться сбрасывать показания одометра:
Теперь update_odometer() проверяет новое значение перед изменением атрибута. Если новое значение mileage больше или равно текущего, self.odometer_reading, показания одометра можно обновить новым значением. Если же новое значение меньше текущего, вы получите предупреждение о недопустимости обратной подкрутки.
Изменение значения атрибута с использованием метода
class Car():
def update_odometer(self, mileage):
""“
Устанавливает на одометре заданное значение.
При попытке обратной подкрутки изменение
отклоняется.
"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
_________________________

Иногда значение атрибута требуется изменить с заданным приращением (вместо того чтобы присваивать атрибуту произвольное новое значение). Допустим, вы купили подержанную машину и проехали на ней 100 миль. Следующий метод получает величину приращения и прибавляет ее к текущим показаниям одометра:
Новый метод increment_odometer()получает расстояние в милях и прибавляет его к self.odometer_reading. Далее создается экземпляр my_used_car. Мы инициализируем показания его одометра значением 23 500; для этого вызывается метод update_odometer(), которому передается значение 23500. Затем вызывается метод increment_odometer(), которому передается значение 100, чтобы увеличить показания одометра на 100 миль, пройденные с момента покупки:
Изменение значения атрибута с приращением
class Car():
...
def update_odometer(self, mileage):
--snip--
def increment_odometer(self, miles):
"""Увеличивает показания одометра с заданным
приращением."""
self.odometer_reading += miles
my_used_car = Car('subaru', 'outback', 2013)
print(my_used_car.get_descriptive_name())
my_used_car.update_odometer(23500)
my_used_car.read_odometer()
my_used_car.increment_odometer(100)
my_used_car.read_odometer()
_________________________
2013 Subaru Outback
This car has 23500 miles on it.
This car has 23600 miles on it.

Работа над новым классом не обязана начинаться с нуля. Если класс, который вы пишете, представляет собой специализированную версию ранее написанного класса, вы можете воспользоваться наследованием. Один класс, наследующий от другого, автоматически получает все атрибуты и методы первого класса. Исходный класс называется родителем, а новый класс — потомком. Класс-потомок наследует атрибуты и методы родителя, но при этом также может определять собственные атрибуты и методы.
Наследование
class BaseClass:
Тело родительского класса
class DerivedClass(BaseClass):
Телодочернегокласса

Первое, что делает Python при создании экземпляра класса-потомка, — присваивает значения всем атрибутам класса-родителя. Для этого методу __init__() класса-потомка необходима помощь со стороны родителя.
В точке 1 строится экземпляр Car. В точке 2 определяется класс-потомок ElectricCar. Метод __init__() в точке 3 получает информацию, необходимую для создания экземпляра Car. Функция super() в строке 4 — специальная функция, которая помогает Python связать потомка с родителем.
Наследование
electric_car.py
1classCar():
"""Простая модель автомобиля."""
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name = str(self.year) + ' ' + self.make + ' ' + self.model
return long_name.title()
def read_odometer(self):
print("This car has " + str(self.odometer_reading) + " miles on it.")
def update_odometer(self, mileage):
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
def increment_odometer(self, miles):
self.odometer_reading += miles
2 class ElectricCar(Car):
"""Представляет аспекты машины, специфические для электромобилей."""
3 def __init__(self, make, model, year):
"""Инициализирует атрибуты класса-родителя."""
4 super().__init__(make, model, year)
5 my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

После создания класса-потомка, наследующего от класса-родителя, можно переходить к добавлению новых атрибутов и методов, необходимых для того, чтобы потомок отличался от родителя.
Добавим атрибут, специфический для электромобилей (например, мощность аккумулятора), и метод для вывода информации об этом атрибуте
Определение атрибутов и методов класса-потомка
class Car():
...
class ElectricCar(Car):
"""Представляет аспекты машины, специфические для электромобилей."""
def __init__(self, make, model, year):
"""Инициализирует атрибуты класса-родителя.
Затем инициализирует атрибуты, специфические для электромобиля.
"""
super().__init__(make, model, year)
1 self.battery_size = 70
2 def describe_battery(self):
"""Выводит информацию о мощности аккумулятора."""
print("This car has a " + str(self.battery_size) + "-kWh battery.")
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

Любой метод родительского класса, который в моделируемой ситуации делает не то, что нужно, можно переопределить. Для этого в классе-потомке определяется метод с тем же именем, что и у метода класса-родителя. Python игнорирует метод родителя и обращает внимание только на метод, определенный в потомке.
Допустим, в классе Car имеется метод fill_gas_tank(). Для электромобилей заправка бензином бессмысленна, поэтому этот метод логично переопределить.
Переопределение методов класса-родителя
def ElectricCar(Car):
...
def fill_gas_tank():
"""Уэлектромобилейнетбензобака."""
print("This car doesn't need a gas tank!")

Списки атрибутов и методов растут, и через какое-то время файлы становятся длинными и громоздкими. В такой ситуации часть одного класса нередко можно записать в виде отдельного класса. Большой код разбивается на меньшие классы, которые работают во взаимодействии друг с другом.
Например, при дальнейшей доработке класса ElectricCar может оказаться, что в нем появилось слишком много атрибутов и методов, относящихся к аккумулятору. В таком случае можно остановиться и переместить все эти атрибуты и методы в отдельный класс с именем Battery. Затем экземпляр Battery становится атрибутом класса ElectricCar:
Экземпляры как атрибуты
class Car():
...
1 class Battery():
"""Простая модель аккумулятора электромобиля."""
2 def __init__(self, battery_size=70):
"""Инициализируетатрибутыаккумулятора."""
self.battery_size = battery_size
3 def describe_battery(self):
"""Выводит информацию о мощности аккумулятора."""
print("This car has a " + str(self.battery_size) + "-kWh battery.")
class ElectricCar(Car):
"""Представляет аспекты машины, специфические для электромобилей."""
def __init__(self, make, model, year):
"""
Инициализирует атрибуты класса-родителя.
Затем инициализирует атрибуты, специфические для электромобиля.
"""
super().__init__(make, model, year)
4 self.battery = Battery()
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
5 my_tesla.battery.describe_battery()

Начнем с создания модуля, содержащего только класс Car
В точке 1 включается строка документации уровня модуля с кратким описанием содержимого модуля. Пишите строки документации для каждого созданного вами модуля.
Теперь мы создадим отдельный файл с именем my_car.py. Этот файл импортирует класс Car и создает экземпляр этого класса
Импортирование одного класса
car.py
1 """Класс для представления автомобиля."""
class Car():
"""Простая модель автомобиля."""
def __init__(self, make, model, year):
"""Инициализирует атрибуты описания автомобиля."""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
"""Возвращаетаккуратноотформатированноеописание."""
long_name = str(self.year) + ' ' + self.make + ' ' + self.model
return long_name.title()
def read_odometer(self):
"""Выводит пробег машины в милях."""
print("This car has " + str(self.odometer_reading) + " miles on it.")
def update_odometer(self, mileage):
"""
Устанавливает на одометре заданное значение.
При попытке обратной подкрутки изменение отклоняется.
"""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
def increment_odometer(self, miles):
"""Увеличивает показания одометра с заданным приращением."""
self.odometer_reading += miles
my_car.py
1 from car import Car
my_new_car = Car('audi', 'a4', 2016)
print(my_new_car.get_descriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()

В одном модуле можно хранить сколько угодно классов, хотя все эти классы должны быть каким-то образом связаны друг с другом. Оба класса Battery и ElectricCar используются для представления автомобилей, поэтому мы добавим их в модуль car.py:
Теперь вы можете создать новый файл с именем my_electric_car.py, импортировать класс ElectricCar и создать новый экземпляр электромобиля:
Хранение нескольких классов в модуле
car.py
"""Классы для представления машин с бензиновым и электродвигателем."""
class Car():
...
class Battery():
"""Простая модель аккумулятора электромобиля."""
def __init__(self, battery_size=60):
"""Инициализация атрибутов аккумулятора."""
self.battery_size = battery_size
def describe_battery(self):
"""Выводит информацию о мощности аккумулятора."""
print("This car has a " + str(self.battery_size) + "-kWh battery.")
def get_range(self):
"""Выводит приблизительный запас хода для аккумулятора."""
if self.battery_size == 70:
range = 240
elif self.battery_size == 85:
range = 270
message = "This car can go approximately " + str(range)
message += " miles on a full charge."
print(message)
class ElectricCar(Car):
"""Представляет аспекты машины, специфические для электромобилей."""
def __init__(self, make, model, year):
"""
Инициализирует атрибуты класса-родителя.
Затем инициализирует атрибуты, специфические для электромобиля.
"""
super().__init__(make, model, year)
self.battery = Battery()
my_electric_car.py
from car import ElectricCar
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()

В файл программы можно импортировать столько классов, сколько потребуется. Если вы захотите создать обычный автомобиль и электромобиль в одном файле, потребуется импортировать оба класса, Car и ElectricCar:
Чтобы импортировать несколько классов из модуля, разделите их имена запятыми 1. После того как необходимые классы будут импортированы, вы можете создать столько экземпляров каждого класса, сколько потребуется.
Импортирование нескольких классов из модуля
my_cars.py
1 from car import Car, ElectricCar
2 my_beetle = Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
3 my_tesla = ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())

Также возможно импортировать весь модуль, а потом обращаться к нужным классам с использованием точечной записи. Этот способ прост, а полученный код легко читается. Так как каждый вызов, создающий экземпляр класса, включает имя модуля, в программе не будет конфликтов с именами, используемыми в текущем файле
Импортирование всего модуля
my_cars.py
1 import car
2 my_beetle = car.Car('volkswagen', 'beetle', 2016)
print(my_beetle.get_descriptive_name())
3 my_tesla = car.ElectricCar('tesla', 'roadster', 2016)
print(my_tesla.get_descriptive_name())

Для импортирования всех классов из модуля используется следующий синтаксис:
from имя_модуля import *
Но делать это не рекомендуется)
Импортирование всех классов из модуля

Ресторан: создайте класс с именем Restaurant. Метод __init__() класса Restaurant должен содержать два атрибута: restaurant_name и cuisine_type. Создайте метод describe_restaurant(), который выводит два атрибута, и метод open_restaurant(), который выводит сообщение о том, что ресторан открыт. Создайте на основе своего класса экземпляр с именем restaurant. Выведите два атрибута по отдельности, затем вызовите оба метода.
Три ресторана: начните с класса из упражнения 1. Создайте три разных экземпляра, вызовите для каждого экземпляра метод describe_restaurant().
Пользователи: создайте класс с именем User. Создайте два атрибута first_name и last_name, а затем еще несколько атрибутов, которые обычно хранятся в профиле пользователя. Напишите метод describe_user(), который выводит сводку с информацией о пользователе. Создайте еще один метод greet_user() для вывода персонального приветствия для пользователя. Создайте несколько экземпляров, представляющих разных пользователей. Вызовите оба метода для каждого пользователя.
TASKS

4. Посетители: начните с программы из упражнения 1. Добавьте атрибут number_served со значением по умолчанию 0; он представляет количество обслуженных посетителей. Создайте экземпляр с именем restaurant. Выведите значение number_served, потом измените и выведите снова.
Добавьте метод с именем set_number_served(), позволяющий задать количество обслуженных посетителей. Вызовите метод с новым числом, снова выведите значение.
Добавьте метод с именем increment_number_served(), который увеличивает количество обслуженных посетителей на заданную величину. Вызовите этот метод с любым числом, которое могло бы представлять количество обслуженных клиентов — скажем, за один день.
5. Администратор: администратор — особая разновидность пользователя. Напишите класс с именем Admin, наследующий от класса User из упражнения 3. Добавьте атрибут privileges для хранения списка строк вида «разрешено добавлять сообщения», «разрешено удалять пользователей», «разрешено банить пользователей» и т. д. Напишите метод show_privileges() для вывода набора привилегий администратора. Создайте экземпляр Admin и вызовите свой метод.
TASKS

1.Попытки входа: добавьте атрибут login_attempts в класс User из упражнения 3 раздела Tasks. Напишите метод increment_login_attempts(), увеличивающий значение login_attempts на 1. Напишите другой метод с именем reset_login_attempts(), обнуляющий значение login_attempts.
Создайте экземпляр класса User и вызовите increment_login_attempts() несколько раз. Выведите значение login_attempts, чтобы убедиться в том, что значение было изменено правильно, а затем вызовите reset_login_attempts(). Снова выведите login_attempts и убедитесь в том, что значение обнулилось.
2.Киоск с мороженым: киоск с мороженым — особая разновидность ресторана. Напишите класс IceCreamStand, наследующий от класса Restaurant из упражнения 1 раздела Tasks или упражнения 4 раздела Tasks. Подойдет любая версия класса; просто выберите ту, которая вам больше нравится. Добавьте атрибут с именем flavors для хранения списка сортов мороженого. Напишите метод, который выводит этот список. Создайте экземпляр IceCreamStand и вызовите этот метод.
PRACTICAL TASK 5