Объектно-ориентированное программирование (ООП) в Python 3

29 апреля, 2020

Подписывайся на наш канал в Telegram, чтобы ежедневно совершенствоваться в Python. Там выходят задачи, полезные советы и сливы платных курсов - перейти

Оглавление

  • Что такое объектно-ориентированное программирование (ООП)?
  • Занятия на Python
  • Объекты Python (экземпляры)
  • Как определить класс в Python
    • Атрибуты экземпляра
    • Атрибуты класса
  • Создание объектов
    • В чем дело?
    • Обзор упражнений (# 1)
  • Методы экземпляра
    • Изменение атрибутов
  • Наследование объектов Python
    • Пример парка собак
    • Расширение функциональности родительского класса
    • Родительские и детские классы
    • Переопределение функциональности родительского класса
    • Обзор упражнений (# 2)
  • Вывод

В этой статье вы познакомитесь со следующими основными понятиями ООП в Python:

  • Классы Python
  • Экземпляры объектов
  • Определение и работа с методами
  • ООП Наследование

Что такое объектно-ориентированное программирование (ООП)?

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

Например, объект может представлять человека с именем, возрастом, адресом и т. Д., С такими поведениями, как ходьба, разговор, дыхание и бег. Или электронное письмо со свойствами, такими как список получателей, тема, тело и т. Д., А также с такими поведениями, как добавление вложений и отправка.

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

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

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

ПРИМЕЧАНИЕ . Поскольку Python является языком программирования с множеством парадигм, вы можете выбрать парадигму, которая лучше всего подходит для рассматриваемой проблемы, смешать разные парадигмы в одной программе и / или переключаться с одной парадигмы на другую по мере развития вашей программы.

Занятия на Python

Сосредоточившись сначала на данных, каждая вещь или объект является экземпляром некоторого класса .

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

Что если вы хотите представить что-то гораздо более сложное?

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

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

Классы используются для создания новых пользовательских структур данных, которые содержат произвольную информацию о чем-либо. В случае с животным мы могли бы создать Animal()класс для отслеживания таких свойств животного, как имя и возраст.

Важно отметить, что класс просто обеспечивает структуру – это образец того, как что-то должно быть определено, но на самом деле он не предоставляет никакого реального контента. Animal()Класс может указать , что имя и возраст, необходимые для определения животного, но он не будет на самом деле утверждать , что имя или возраст конкретного животного является.

Это может помочь представить класс как идею того, как что-то должно быть определено.

Объекты Python (экземпляры)

В то время как класс является планом, экземпляр является копией класса с фактическими значениями, буквально объектом, принадлежащим определенному классу. Это больше не идея; это настоящее животное, как собака по имени Роджер, которой восемь лет.

Иными словами, класс – это форма или анкета. Он определяет необходимую информацию. После того, как вы заполните форму, ваша конкретная копия является экземпляром класса; он содержит актуальную информацию, относящуюся к вам.

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

Как определить класс в Python

Определить класс просто в Python:

class Dog:
    pass

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

Также здесь мы использовали ключевое слово Python pass. Это очень часто используется как заполнитель, где код в конечном итоге будет идти. Это позволяет нам запускать этот код без выдачи ошибки.

Примечание: приведенный выше код является правильным на Python 3. На Python 2.x («устаревший Python») вы бы использовали немного другое определение класса:

# Python 2.x Class Definition:
class Dog(object):
    pass

Не (object)части в круглых скобках указывает на родительский класс , который вы наследующий (подробнее об этом ниже) . В Python 3 это уже не нужно , потому что это неявное по умолчанию.

Атрибуты экземпляра

Все классы создают объекты, и все объекты содержат характеристики, называемые атрибутами (называемые свойствами в первом абзаце). Используйте __init__()метод для инициализации (например, определения) начальных атрибутов объекта, задав им значение по умолчанию (или состояние). Этот метод должен иметь как минимум один аргумент, а также selfпеременную, которая ссылается на сам объект (например, Dog).

class Dog:

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

В нашем Dog()классе каждая собака имеет определенное имя и возраст, что, безусловно, важно знать, когда вы начинаете создавать разных собак. Помните: класс предназначен только для определения собаки, а не для создания экземпляров отдельных собак с конкретными именами и возрастами; мы вернемся к этому в ближайшее время.

Точно так же selfпеременная также является экземпляром класса. Поскольку экземпляры класса имеют различные значения, мы могли бы утверждать, Dog.name = nameа не self.name = name. Но поскольку не все собаки имеют одно и то же имя, мы должны иметь возможность назначать разные значения для разных экземпляров. Отсюда необходимость в специальной selfпеременной, которая поможет отслеживать отдельные экземпляры каждого класса.

ПРИМЕЧАНИЕ : вам никогда не придется вызывать __init__()метод; он вызывается автоматически при создании нового экземпляра Dog.

Атрибуты класса

Хотя атрибуты экземпляра являются специфическими для каждого объекта, атрибуты класса одинаковы для всех экземпляров, в данном случае это все собаки.

class Dog:

    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

Таким образом, хотя каждая собака имеет уникальное имя и возраст, каждая собака будет млекопитающим.

Давайте создадим несколько собак …

Создание объектов

Instantiating – необычный термин для создания нового уникального экземпляра класса.

Например: >>>

>>> class Dog:
...     pass
...
>>> Dog()
<__main__.Dog object at 0x1004ccc50>
>>> Dog()
<__main__.Dog object at 0x1004ccc90>
>>> a = Dog()
>>> b = Dog()
>>> a == b
False

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

Как вы думаете, тип экземпляра класса? >>>

>>> class Dog:
...     pass
...
>>> a = Dog()
>>> type(a)
<class '__main__.Dog'>

Давайте посмотрим на немного более сложный пример …

class Dog:

    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age


# Instantiate the Dog object
philo = Dog("Philo", 5)
mikey = Dog("Mikey", 6)

# Access the instance attributes
print("{} is {} and {} is {}.".format(
    philo.name, philo.age, mikey.name, mikey.age))

# Is Philo a mammal?
if philo.species == "mammal":
    print("{0} is a {1}!".format(philo.name, philo.species))

ПРИМЕЧАНИЕ . Обратите внимание, как мы используем точечную запись для доступа к атрибутам каждого объекта.

Сохраните это как dog_class.py , затем запустите программу. Тебе следует увидеть:

Philo is 5 and Mikey is 6.
Philo is a mammal!

В чем дело?

Мы создали новый экземпляр Dog()класса и присвоили его переменной philo. Затем мы передали ему два аргумента, "Philo"и 5, которые представляют имя и возраст этой собаки, соответственно.

Эти атрибуты передаются __init__методу, который вызывается каждый раз, когда вы создаете новый экземпляр, прикрепляя имя и возраст к объекту. Вы можете быть удивлены, почему мы не должны были приводить selfаргументы.

Это магия Питона; когда вы создаете новый экземпляр класса, Python автоматически определяет, что selfесть (в данном случае это Dog), и передает его __init__методу.

Обзор упражнений (# 1)

Упражнение: “Самая старая собака”

Используя тот же Dogкласс, создайте три новые собаки, каждая с разным возрастом. Затем напишите функцию с именем, get_biggest_number()которая принимает любое количество возрастов ( *args) и возвращает самую старую. Затем выведите возраст самой старой собаки примерно так:

The oldest dog is 7 years old.Решение: "Самая старая собака"

Решение “Самая старая собака”.

class Dog:

    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age


# Instantiate the Dog object
jake = Dog("Jake", 7)
doug = Dog("Doug", 4)
william = Dog("William", 5)


# Determine the oldest dog
def get_biggest_number(*args):
    return max(args)


# Output
print("The oldest dog is {} years old.".format(
    get_biggest_number(jake.age, doug.age, william.age)))

Методы экземпляра

Методы экземпляра определены внутри класса и используются для получения содержимого экземпляра. Они также могут быть использованы для выполнения операций с атрибутами наших объектов. Как и __init__метод, первый аргумент всегда self:

class Dog:

    # Class Attribute
    species = 'mammal'

    # Initializer / Instance Attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # instance method
    def description(self):
        return "{} is {} years old".format(self.name, self.age)

    # instance method
    def speak(self, sound):
        return "{} says {}".format(self.name, sound)

# Instantiate the Dog object
mikey = Dog("Mikey", 6)

# call our instance methods
print(mikey.description())
print(mikey.speak("Gruff Gruff"))

Сохраните это как dog_instance_methods.py , затем запустите его:

Mikey is 6 years old
Mikey says Gruff Gruff

В последнем методе speak()мы определяем поведение. Какие другие виды поведения вы можете назначить собаке? Вернитесь к началу абзаца, чтобы увидеть примеры поведения других объектов.

Изменение атрибутов

Вы можете изменить значение атрибутов на основе некоторого поведения: >>>

>>> class Email:
...     def __init__(self):
...         self.is_sent = False
...     def send_email(self):
...         self.is_sent = True
...
>>> my_email = Email()
>>> my_email.is_sent
False
>>> my_email.send_email()
>>> my_email.is_sent
True

Здесь мы добавили метод для отправки электронного письма, который обновляет is_sentпеременную до True.

Наследование объектов Python

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

Важно отметить, что дочерние классы переопределяют или расширяют функциональность (например, атрибуты и поведение) родительских классов. Другими словами, дочерние классы наследуют все атрибуты и поведение родителя, но могут также определять другое поведение, которому нужно следовать. Самый базовый тип класса – это класс object, который обычно все другие классы наследуют как родительский.

Когда вы определяете новый класс, Python 3 неявно использует его objectкак родительский класс. Таким образом, следующие два определения эквивалентны:

class Dog(object):
    pass

# In Python 3, this is the same as:

class Dog:
    pass

Примечание. В Python 2.x существует различие между классами нового и старого стиля . Я не буду вдаваться в подробности, но вы, как правило, захотите указать objectв качестве родительского класса, чтобы убедиться, что вы определили класс нового стиля, если вы пишете код ООП Python 2.

Пример парка собак

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

Как еще можно отличить одну собаку от другой? Как насчет породы собаки: >>>

>>> class Dog:
...     def __init__(self, breed):
...         self.breed = breed
...
>>> spencer = Dog("German Shepard")
>>> spencer.breed
'German Shepard'
>>> sara = Dog("Boston Terrier")
>>> sara.breed
'Boston Terrier'

У каждой породы собак есть немного отличающиеся поведения. Чтобы принять это во внимание, давайте создадим отдельные классы для каждой породы. Это дочерние классы родительского Dogкласса.

Расширение функциональности родительского класса

Создайте новый файл с именем dog_inheritance.py :

# Parent class
class Dog:

    # Class attribute
    species = 'mammal'

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # instance method
    def description(self):
        return "{} is {} years old".format(self.name, self.age)

    # instance method
    def speak(self, sound):
        return "{} says {}".format(self.name, sound)


# Child class (inherits from Dog class)
class RussellTerrier(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)


# Child class (inherits from Dog class)
class Bulldog(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)


# Child classes inherit attributes and
# behaviors from the parent class
jim = Bulldog("Jim", 12)
print(jim.description())

# Child classes have specific attributes
# and behaviors as well
print(jim.run("slowly"))

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

Тебе следует увидеть:

Jim is 12 years old
Jim runs slowly

Мы не добавили никаких специальных атрибутов или методов, чтобы отличать a RussellTerrierот a Bulldog, но, поскольку они теперь представляют собой два разных класса, мы могли бы, например, дать им разные атрибуты класса, определяющие их соответствующие скорости.

Родительские и детские классы

isinstance()Функция используется , чтобы определить , если экземпляр также является экземпляром определенного родительского класса.

Сохраните это как dog_isinstance.py :

# Parent class
class Dog:

    # Class attribute
    species = 'mammal'

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # instance method
    def description(self):
        return "{} is {} years old".format(self.name, self.age)

    # instance method
    def speak(self, sound):
        return "{} says {}".format(self.name, sound)


# Child class (inherits from Dog() class)
class RussellTerrier(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)


# Child class (inherits from Dog() class)
class Bulldog(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)


# Child classes inherit attributes and
# behaviors from the parent class
jim = Bulldog("Jim", 12)
print(jim.description())

# Child classes have specific attributes
# and behaviors as well
print(jim.run("slowly"))

# Is jim an instance of Dog()?
print(isinstance(jim, Dog))

# Is julie an instance of Dog()?
julie = Dog("Julie", 100)
print(isinstance(julie, Dog))

# Is johnny walker an instance of Bulldog()
johnnywalker = RussellTerrier("Johnny Walker", 4)
print(isinstance(johnnywalker, Bulldog))

# Is julie and instance of jim?
print(isinstance(julie, jim))

Вывод: >>>

('Jim', 12)
Jim runs slowly
True
True
False
Traceback (most recent call last):
  File "dog_isinstance.py", line 50, in <module>
    print(isinstance(julie, jim))
TypeError: isinstance() arg 2 must be a class, type, or tuple of classes and types

Есть смысл? Оба jimи julieявляются экземплярами Dog()класса, а johnnywalkerне являются экземплярами Bulldog()класса. Затем, в качестве проверки работоспособности, мы проверили, julieявляется ли экземпляр экземпляром jim, что невозможно, поскольку jimон принадлежит instanceне к самому классу, а к классу TypeError.

Переопределение функциональности родительского класса

Помните, что дочерние классы также могут переопределять атрибуты и поведение родительского класса. Например: >>>

>>> class Dog:
...     species = 'mammal'
...
>>> class SomeBreed(Dog):
...     pass
...
>>> class SomeOtherBreed(Dog):
...     species = 'reptile'
...
>>> frank = SomeBreed()
>>> frank.species
'mammal'
>>> beans = SomeOtherBreed()
>>> beans.species
'reptile'

В SomeBreed()класс наследует speciesот родительского класса, в то время как SomeOtherBreed()класс переопределяет species, установив его reptile.

Обзор упражнений (# 2)

Упражнение: «Наследство собак»

Создайте Petsкласс, который содержит экземпляры собак; этот класс полностью отделен от Dogкласса. Другими словами, Dogкласс не наследуется от Petsкласса. Затем назначьте три экземпляра собаки экземпляру Petsкласса. Начните со следующего кода ниже. Сохраните файл как pets_class.py . Ваш вывод должен выглядеть так:

I have 3 dogs. 
Tom is 6. 
Fletcher is 7. 
Larry is 9. 
And they're all mammals, of course.

Стартовый код:

# Parent class
class Dog:

    # Class attribute
    species = 'mammal'

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # instance method
    def description(self):
        return "{} is {} years old".format(self.name, self.age)

    # instance method
    def speak(self, sound):
        return "{} says {}".format(self.name, sound)

# Child class (inherits from Dog class)
class RussellTerrier(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)

# Child class (inherits from Dog class)
class Bulldog(Dog):
    def run(self, speed):
        return "{} runs {}".format(self.name, speed)

Решение: “Наследство собак”

# Parent class
class Pets:

    dogs = []

    def __init__(self, dogs):
        self.dogs = dogs


# Parent class
class Dog:

    # Class attribute
    species = 'mammal'

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Instance method
    def description(self):
        return self.name, self.age

    # Instance method
    def speak(self, sound):
        return "%s says %s" % (self.name, sound)

    # Instance method
    def eat(self):
        self.is_hungry = False


# Child class (inherits from Dog class)
class RussellTerrier(Dog):
    def run(self, speed):
        return "%s runs %s" % (self.name, speed)


# Child class (inherits from Dog class)
class Bulldog(Dog):
    def run(self, speed):
        return "%s runs %s" % (self.name, speed)

# Create instances of dogs
my_dogs = [
    Bulldog("Tom", 6), 
    RussellTerrier("Fletcher", 7), 
    Dog("Larry", 9)
]

# Instantiate the Pets class
my_pets = Pets(my_dogs)

# Output
print("I have {} dogs.".format(len(my_pets.dogs)))
for dog in my_pets.dogs:
    print("{} is {}.".format(dog.name, dog.age))

print("And they're all {}s, of course.".format(dog.species))

Упражнение: «Голодные псы»

Используя один и тот же файл, добавьте атрибут экземпляра is_hungry = Trueв Dogклассе. Затем добавьте вызываемый метод, eat()который при вызове изменяет значение is_hungryна False. Выясните, как лучше кормить каждую собаку, а затем выведите «Мои собаки голодны». если все голодны или «Мои собаки не голодны». если все не голодны. Окончательный результат должен выглядеть следующим образом:

I have 3 dogs. 
Tom is 6. 
Fletcher is 7. 
Larry is 9. 
And they're all mammals, of course. 
My dogs are not hungry.

Решение: “Голодные псы”

# Parent class
class Pets:

    dogs = []

    def __init__(self, dogs):
        self.dogs = dogs


# Parent class
class Dog:

    # Class attribute
    species = 'mammal'

    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.is_hungry = True

    # Instance method
    def description(self):
        return self.name, self.age

    # Instance method
    def speak(self, sound):
        return "%s says %s" % (self.name, sound)

    # Instance method
    def eat(self):
        self.is_hungry = False


# Child class (inherits from Dog class)
class RussellTerrier(Dog):
    def run(self, speed):
        return "%s runs %s" % (self.name, speed)


# Child class (inherits from Dog class)
class Bulldog(Dog):
    def run(self, speed):
        return "%s runs %s" % (self.name, speed)

# Create instances of dogs
my_dogs = [
    Bulldog("Tom", 6), 
    RussellTerrier("Fletcher", 7), 
    Dog("Larry", 9)
]

# Instantiate the Pets class
my_pets = Pets(my_dogs)

# Output
print("I have {} dogs.".format(len(my_pets.dogs)))
for dog in my_pets.dogs:
    dog.eat()
    print("{} is {}.".format(dog.name, dog.age))

print("And they're all {}s, of course.".format(dog.species))

are_my_dogs_hungry = False
for dog in my_pets.dogs:
    if dog.is_hungry:
        are_my_dogs_hungry = True

if are_my_dogs_hungry:
    print("My dogs are hungry.")
else:
    print("My dogs are not hungry.")

Упражнение: “Собачья ходьба”

Далее, добавьте walk()метод как Petsи Dogклассы , так что при вызове метода на Petsклассе, каждый экземпляр собака присваивается Petsкласс walk(). Сохраните это как dog_walking.py . Это немного сложнее.

Начните с реализации метода так же, как speak()метод. Что касается метода в Petsклассе, вам нужно будет перебрать список собак, а затем вызвать сам метод.

Вывод должен выглядеть так:

Tom is walking!
Fletcher is walking!
Larry is walking!

Решение: “выгула собак”

# Parent class
class Pets:

    dogs = []

    def __init__(self, dogs):
        self.dogs = dogs

    def walk(self):
        for dog in self.dogs:
            print(dog.walk())


# Parent class
class Dog:

    # Class attribute
    species = 'mammal'
    is_hungry = True

    # Initializer / instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Instance method
    def description(self):
        return self.name, self.age

    # Instance method
    def speak(self, sound):
        return "%s says %s" % (self.name, sound)

    # Instance method
    def eat(self):
        self.is_hungry = False

    def walk(self):
        return "%s is walking!" % (self.name)


# Child class (inherits from Dog class)
class RussellTerrier(Dog):
    def run(self, speed):
        return "%s runs %s" % (self.name, speed)


# Child class (inherits from Dog class)
class Bulldog(Dog):
    def run(self, speed):
        return "%s runs %s" % (self.name, speed)

# Create instances of dogs
my_dogs = [
    Bulldog("Tom", 6), 
    RussellTerrier("Fletcher", 7), 
    Dog("Larry", 9)
]

# Instantiate the Pet class
my_pets = Pets(my_dogs)

# Output
my_pets.walk()

Упражнение: «Проверка понимания»

Ответьте на следующие вопросы об ООП, чтобы проверить свой прогресс в обучении:

  1. Что за класс?
  2. Какой пример?
  3. Какая связь между классом и экземпляром?
  4. Какой синтаксис Python используется для определения нового класса?
  5. Что такое орфографическое соглашение для имени класса?
  6. Как вы создаете или создаете экземпляр класса?
  7. Как вы получаете доступ к атрибутам и поведению экземпляра класса?
  8. Что за метод?
  9. Какова цель self?
  10. Какова цель __init__метода?
  11. Опишите, как наследование помогает предотвратить дублирование кода.
  12. Могут ли дочерние классы переопределять свойства своих родителей?

Решение: «Проверка понимания»Показать спрятать

  1. Класс – это механизм, используемый для создания новых пользовательских структур данных. Он содержит данные, а также методы, используемые для обработки этих данных.
  2. Экземпляр – это копия класса с фактическими значениями, буквально объект определенного класса.
  3. В то время как класс – это план, используемый для описания того, как что-то создать, экземпляры – это объекты, созданные из этих чертежей.
  4. class PythonClassName:
  5. Обозначение CamelCase, начинающееся с заглавной буквы – т.е. PythonClassName()
  6. Вы используете имя класса, за которым следуют скобки. Так что, если имя класса Dog(), экземпляр собаки будет – my_class = Dog().
  7. С точечной нотацией – например, instance_name.attribute_name
  8. Функция, которая определена внутри класса.
  9. Первый аргумент каждого метода ссылается на текущий экземпляр класса, который по соглашению называется self. В __init__методе selfссылается на вновь созданный объект; в то время как в других методах selfссылается на экземпляр, метод которого был вызван. Для больше на __init__против self, проверьте эту статью.
  10. __init__Метод инициализирует экземпляр класса.
  11. Дочерние классы наследуют все атрибуты и поведение родителя.
  12. Да.

Вывод

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

Помните, что ООП – это парадигма программирования, а не концепция Python. Большинство современных языков программирования, таких как Java, C #, C ++, следуют принципам ООП. Итак, хорошая новость заключается в том, что изучение основ объектно-ориентированного программирования будет полезным для вас в различных обстоятельствах – независимо от того, работаете вы на Python или нет.


Совершенствуй знания каждый день у нас в Телеграм-каналах

Вопросы, реклама — VK | Telegram