Классы и объекты в Python – одна из самых важных частей этого курса. И в ней Вы научитесь создавать классы. Узнаете о свойствах и функциях класса. Создадите объекты класса и научитесь ими управлять. Приступим!
Введение в классы и объекты в Python
Python – это объектно-ориентированный язык программирования.
Это означает что, все, что мы до сих пор создавали с вами, является объектами.
А что такое классы?
Класс – это шаблон, по которому создаются все объекты. А объекты это – экземпляры класса.
Давайте посмотрим все на примере:
Баскетболист Стефен Карри – это объект (или экземпляр) класса “Баскетболист”.
Класс “Баскетболист” создает свои объекты по шаблону, в котором указаны свойства и функции этого класса. Эти свойства и функции класс передает своим объектам по наследству:
Свойства класса “Баскетболист”
- Руки = 2;
- Ноги = 2;
- Рост > 1.9 м ;
- И тд.
Функции класса “Баскетболист”
- Передвигаться по баскетбольной площадке;
- Бросать мяч в корзину;
- Отбирать мяч у соперника;
- Принимать мяч;
- Пасовать мяч;
- И тд.
Если с этим пока все понятно, давайте узнаем, как создать класс.
Да, и еще кое-что: по ходу дальнейших объяснений мы будем рассматривать примеры кода, которые нужно писать вместе со мной, для того, чтобы создать полноценный класс и объект.
Просто смотрите объяснения и пишите код вместе со мной, не запуская его. Как только настанет время запускать наш код, я об этом скажу.
Итак, поехали!
Как создать класс в Python?
Допустим, мы делаем игру. И нам необходимо создать соперников (rival по-английски).
У соперников функции и свойства одинаковые. А, значит, мы можем объединить их под одним классом “rival”.
Для того, чтобы создать класс, необходимо использовать ключевое слово class. Так Python поймет, что мы создаем класс.
Итак, создаем класс под названием Rival:
class Rival:Пока запишите этот фрагмент в наш компилятор. Сейчас мы научимся создавать свойства класса.
Кстати, код получится довольно длинным, так что комилятор будет следовать за вами по экрану, чтобы Вы его не потеряли 🙂
Свойства класса в Python
Пусть у соперника будет 3 жизни. Давайте для этого, прямо под классом, создадим переменную жизнь (life) со значением 3. Это и будет свойство класса Rival.
class Rival:
life = 3Теперь нам необходимо создать функцию класса Rival. Давайте сделаем это.
Функции класса в Python
Одна из функций нашего соперника – принимать нашу атаку. Для этого создаем функцию класса под названием атака (attack).
Мы уже создавали функции, применяя ключевое слово def. Здесь поступаем так же. Пишем def, затем имя функции, открываем скобки и передаем аргумент (self)
Вот, как это выглядит в нашем примере:
class Rival:
life = 3
def attack(self):“А что за self? Мы такое не проходили” Скажите Вы, и правильно сделаете.
self – это обязательное ключевое слово в Python, которое записывается в аргумент функции класса.
Позже, когда мы создадим объект класса, мы свяжем этот объект со своим классом именно через self. Вы это увидите на примере, и сразу все поймете.
А сейчас вернемся к функции.
Итак, мы создали функцию атаки (attack). Теперь скажем программе, что эта функция делает, а делает она вот что:
Каждый раз, когда она срабатывает, наш соперник будет кричать “Ouch!”
Для этого в теле функции мы прописываем строку “Ouch!”, и передаем ее в аргумент функции print()
Вот, как это выглядит в нашем примере:
class Rival:
life = 3
def attack(self):
print("Ouch!")Обратите внимание на отступы, которые мы делаем в коде:
Свойство класса – life и функция класса – attack помещаются в тело класса Rival с использованием четырех отступов.
При этом у функции тоже есть свое тело, и мы помещаем в него print(“Ouch!”), делая еще четыре отступа.
Так Python понимает к какому классу относятся свойства и функции. А еще так наш код выглядит более аккуратным и понятным.
А теперь вернемся к функции класса
Каждая наша атака должна не только заставлять соперника кричать “Ouch!”, но и отнимать у него по одной жизни.
Для этого из значения переменной life нужно вычитать по одной единице.
Но, для того чтобы получить доступ к этой переменной класса, нам нужно прописать self и поставить точку. Так Python поймет, что внутри этого класса мы хотим отнять одну единицу в переменной life.
И вот, как это будет выглядеть в нашем примере:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1Теперь функция атаки класса (attack) не только заставляет соперника кричать “Ouch!”, но и отнимает у него одну единицу жизни, каждый раз, когда мы его атакуем.
Теперь предлагаю создать еще одну функцию класса, которая будет считать количество жизней соперника после каждой нашей атаки.
Для этого спускаемся на две строчки ниже, и делаем то же, что и при создании предыдущей функции. А именно: пишем def, затем название этой функции (назовем новую функцию “checkLife”), и передаем ключевое слово self в ее аргумент.
Вот, что у нас получится на выходе:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):Итак, функцию мы прописали. Теперь давайте скажем программе, что делает эта функция.
Для этого мы воспользуемся условными заявлениям, о которых Вы уже знаете из пройденного материала.
Условные заявления для нашего класса:
Если количество жизней соперника будет меньше или равно нулю, функция выведет сообщение от имени соперника “You won!” (Вы победили!).
А если у соперника еще остались жизни, функция просто скажет, сколько жизней осталось.
Итак, сначала первое условие, в котором мы победили. Вот, как мы это условие пропишем:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")Наш код становится немного сложнее, поэтому давайте подробно рассмотрим то, как мы создали это условие:
Под именем функции “checkLife”, после четырех отступов, мы прописали условный оператор if, поставили точку, и прописали ключевое слово self, чтобы программа снова поняла, что мы обращаемся к переменной life, класса Rival.
Затем мы прописали оператор сравнения меньше или равно (<=), поставили ноль и двоеточие.
Теперь нам надо создать инструкцию, которую программа запустит, если прописанное нами условие сработает.
Для этого мы спустились ниже, снова четыре отступа. И приказали программе вывести сообщение “You won!”. Для этого мы передали строку “You won!” в аргумент функции print().
Готово! Теперь, если количество жизней соперника меньше или равно нулю, функция выведет сообщение “You won!” от имени соперника.
Если с этим все понятно, давайте создадим второе условие, на тот случай если у нашего соперника еще остались жизни. И зададим соответствующую инструкцию на этот случай.
Второе условие для нашего класса:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)Давайте снова рассмотрим подробно, что мы только что сделали:
Мы спустились еще на одну строку и присвоили условный оператор else.
Затем в следующей строке нужно было написать инструкцию для отображения оставшегося количества жизней.
Для этого мы назначили функцию print, и передали в ее аргумент ключевое слово self и имя переменной (life). Опять же, нам нужно self, чтобы программа знала, что мы имеем в виду переменную класса.
Ну вот! Мы создали простой класс Rival, где у нашего соперника три жизни. И где в ответ на каждую нашу атаку он кричит “Ouch!”, теряя по одной жизни.
А еще наш класс умеет считать и выводить количество оставшихся жизней после каждой атаки. И в случае, если жизней не осталось, торжественно выводит сообщение “You won!”
У нас получился довольно хороший класс. Давайте же теперь создадим объекты класса!
Как создать объект класса в Python
Что нужно знать, перед тем как создать объект класса в Python?
Во-первых, создание объектов класса очень похоже на создание переменной. Вы это сейчас увидите.
Во-вторых, создавая объект класса, нам необходимо дать нашему объекту название.
И в-третьих, поскольку класс у нас называется “соперник (Rival)”, то название объекта этого класса будет носить имя какого-нибудь злодея.
Поэтому, давайте назовем наш объект в честь Таноса (thanos) из Marvel. Достойный экземпляр соперника, не так ли?
Итак, приступим:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)
thanos = Rival()Как Вы видите, мы начали с имени объекта.
После чего поставили знак равно, и указали название класса, к которому относится наш объект.
Далее мы просто закрыли имя класса круглыми скобками. Ничего сложного.
Теперь давайте присвоим объекту функцию класса, которая отвечает за подсчет жизни (checkLife).
Это позволит нашему объекту thanos проверить количество жизней перед схваткой.
Вот, как это выглядит в нашем примере:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)
thanos = Rival()
thanos.checkLife()Давайте посмотрим, что мы сделали:
Мы спустились на две строки ниже, и прописали имя объекта.
После чего поставили точку, и прописали имя нужной нам функции (checkLife), которая уже имеется у нашего класса. Вы прописали ее на восьмой строчке.
Наконец-то настало время запускать наш код!
Запустите код, и посмотрите, сколько жизней насчитал у себя thanos перед схваткой.
Если Вы все сделали правильно, программа выдаст Вам цифру 3. Потому что мы задали Таносу три жизни перед схваткой.
А теперь в атаку! Давайте атакуем Таноса, и посмотрим, что он нам ответит.
Для этого мы спустимся на строчку ниже. Снова пропишем имя объекта thanos, постам точку, и пропишем имя другой, знакомой нам функции, которую мы создали внутри класса. Это функция attack()
Вот, что у нас получится:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)
thanos = Rival()
thanos.checkLife()
thanos.attack()Впишите thanos.attack() и запустите код. На это раз Таносу есть, что вам сказать!
Программа выдаст цифру 3, а под ней сообщение “Ouch!”
Откуда взялось сообщение “Ouch!”?
Правильно, от функции print(“Ouch!”), которую мы ранее прописали внутри функции атаки – def attack(self). Помните, да? Хорошо!
А сколько у Таноса осталось жизней после нашей первой атаки? Давайте узнаем это.
Для этого мы добавим в конец нашего кода еще одну функцию checkLife(). И вот, что у нас получится:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)
thanos = Rival()
thanos.checkLife()
thanos.attack()
thanos.checkLife()Впишите этот код в компилятор, и запускайте его. Если Вы все сделали правильно, программа выдаст цифру 3, затем сообщение “Ouch!”, а затем цифру 2.
А это значит, что у Таноса осталось две жизни! Мы побеждаем! Предлагаю атаковать нашего соперника еще два раза и посмотреть, кто победит.
Вот секретный код победы над злодеем:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)
thanos = Rival()
thanos.checkLife()
thanos.attack()
thanos.attack()
thanos.attack()
thanos.checkLife()Наконец, пришло время нанести решающий удар. Допишите этот код у себя, и запустите его.
PS: Писать функцию три раза подряд не самая лучшая практика. Но, я не хочу нагружать Вас еще и циклами сейчас. В этом уроке фокус только на классы и объекты в Python.
Итак, если Вы все сделали правильно, программа выдаст Вам вот такое сообщение:
3
Ouch!
Ouch!
Ouch!
You won!Ну как? Получилось?
Отличная работа! Вы только что научились создавать классы и объекты в Python! И даже победили Таноса по пути.
Но, тема классов и объектов будет неполной, если мы не узнаем, как управлять разными объектами, принадлежащими одному классу.
Давайте узнаем это.
Управление объектами класса в Python
Теперь мы поняли что объект – это, по сути, копия своего класса.
Но, даже если несколько объектов и могут относиться к одному классу, между собой эти объекты все равно независимы.
Таким образом, если Вы отнимите жизнь у одного соперника (объекта своего класса), то это никак не повлияет на другого соперника (объекта того же класса).
На примере реальной жизни это выглядит так:
Вы играете в видеоигру, например, в Dota. Перед Вами два соперника: Slark и Axe, которые хотят вступить с Вами в ближний бой.
И Slark, и Axe – это объекты одного класса (класс соперников), у них даже есть общие функции, унаследованные от своего класса, например, ближний бой.
Но при этом они остаются полностью независимыми друг от друга объектами.
Например, у каждого из них разные атрибуты: у Slark – ловкость, а у Axe – сила.
А еще у каждого из них отдельная шкала здоровья. Если Вы нанесете урон Сларку, то его шкала здоровья изменится, а шкала здоровья Axe останется без изменений.
Восстанавливаться их шкалы тоже могут с разной скоростью. И так далее.
Думаю, теперь Вы поняли, что программисты должны уметь управлять объектами класса так, чтобы эти объекты могли оставаться независимыми друг от друга.
А раз так, давайте создадим второй объект для нашего класса Rival, и сделаем его независимым от первого объекта.
Создаем второй объект класса
Первым объектом у нас был злодей thanos. Давайте добавим второй объект-злодея, пусть это будет Магнето (magneto).
Затем атакуем Таноса, и посмотрим как это отразится на Магнето.
Вот, как это будет выглядеть на примере:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)
thanos = Rival()
magneto = Rival()
thanos.checkLife()
magneto.checkLife()Как Вы видите из примера, мы добавили второй объект, назвав его magneto, и присвоили ему класс “Rival”.
Затем, как и в случае с объектом thanos, мы присвоили ему функцию, которая проверяет жизнь: magneto.checkLife()
Таким образом, когда программа запускается, оба объекта проверяют и сообщают количество своих жизней.
Впишите этот код в компилятор, и запустите его. Если Вы все сделали правильно, программа дважды выведет цифру 3. Потому что и у Таноса, и у Магнето по три жизни.
Затем давайте атакуем Таноса три раза, после чего оба объекта снова проверят, и сообщат нам количество оставшихся жизней.
Для этого, все что нам осталось сделать,- это трижды добавить thanos.attack() в наш код.
Вот, как это выглядит на примере:
class Rival:
life = 3
def attack(self):
print("Ouch!")
self.life -=1
def checkLife(self):
if self.life <=0:
print("You won!")
else:
print(self.life)
thanos = Rival()
magneto = Rival()
thanos.attack()
thanos.attack()
thanos.attack()
thanos.checkLife()
magneto.checkLife()Впишите этот код в наш компилятор, и запустите его. Если Вы все сделали правильно, программа вернет Вам вот такое сообщение:
Ouch!
Ouch!
Ouch!
You won!
3Как видите, Танос теперь поражен, но у Магнето все еще три жизни.
А это значит, что функции класса, которые мы применили к одному объекту, совершенно не влияют на другие объекты того же класса.
А теперь давайте отпразднуем пройденную тему небольшой самостоятельной работой.
Допишите код таким образом, чтобы победить и Магнето!
Классы и объекты в Python, итоги
В одиннадцатой части Вы сделали следующее:
- Освоили классы и объекты в Python;
- Узнали о свойствах и функциях класса;
- Создали свои классы и объекты в Python;
- Научились управлять разными объектами одного класса.
Вы проделали огромную работу, с чем я Вас и поздравляю! А теперь жду Вас на завершающем уроке курса – Модули и пакеты в Python.
Вам понравится:
Python Online – онлайн компилятор, с которым вы можете писать, запускать и проверять свой код без установки программ.
