Создать объект

Теперь мы можем использовать класс MyClass для создания объектов:

Пример

Создайте объект с именем p1 и распечатайте значение x:

p1 = MyClass ()
печать (p1.х)

Функция __init __ ()

Приведенные выше примеры представляют собой классы и объекты в их простейшей форме и являются не очень полезен в реальных приложениях.

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

Все классы имеют функцию __init __ (), которая всегда выполняется, когда занятие инициируется.

Используйте функцию __init __ () для присвоения значений свойствам объекта или другим операции, которые необходимо выполнить, когда объект создается:

Пример

Создайте класс с именем Person, используйте функцию __init __ () для присвоения значений для имени и возраста:

p1 = Person ("Джон", 36)

print (p1.name)
print (p1.age)

Примечание: Функция __init __ () вызывается автоматически каждый раз, когда класс используется для создания нового объекта.

Методы объекта

Объекты также могут содержать методы. Методы в объектах - это функции, которые принадлежат объекту.

Создадим метод в классе Person:

Пример

Вставьте функцию, которая печатает приветствие, и выполните ее для объекта p1:

def myfunc (self):
print («Привет, меня зовут» + self.name)

p1 = Person («Джон», 36)
p1.myfunc ()

Примечание: Параметр self является ссылкой на текущий экземпляр класса и используется для доступа к переменным, принадлежащим этому классу.

Параметр себя

Параметр self является ссылкой на текущий экземпляр класса и используется для доступа к переменным, принадлежащим этому классу.

Необязательно называть self , вы можете назовите его как хотите, но он должен быть первым параметром любой функции в классе:

Пример

Используйте слова mysillyobject и abc вместо self :

def myfunc (abc):
print ("Привет, меня зовут" + abc.имя)

p1 = Человек ("Джон", 36)
p1.myfunc ()

Изменить свойства объекта

Вы можете изменять свойства объектов, например:

Удалить свойства объекта

Вы можете удалять свойства объектов с помощью дель ключевое слово:

Удалить объекты

Вы можете удалять объекты с помощью ключевого слова del :

Пропуск Заявление

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

Определение классов в Python

Python - полностью объектно-ориентированный язык. Вы работали с классами и объектами с самого начала этих руководств. Каждый элемент в программе Python является объектом класса. Число, строка, список, словарь и т. Д., Используемые в программе, являются объектом соответствующего встроенного класса. Вы можете получить имя класса переменных или объектов, используя метод type (), как показано ниже.

  >>> число = 20
>>> тип (число)
<класс 'int'>
>>> s = "Python"
>>> тип (ы)
<класс 'str'>
  

Определение класса

Класс в Python можно определить с помощью ключевого слова class .

  класс :
    
    
    ..
    <заявлениеN>
  

Согласно синтаксису выше, класс определяется с помощью ключевого слова class , за которым следует имя класса и оператора : после имени класса, что позволяет продолжить в следующей строке с отступом для определения членов класса. Ниже перечислены члены класса.

1. Атрибуты класса
2. Конструктор
3. Атрибуты экземпляра
4. Характеристики
5. Методы класса

Класс также можно определить без каких-либо членов.В следующем примере определяется пустой класс с использованием ключевого слова pass .

При создании экземпляра класса используется обозначение функций. Чтобы создать объект класса, просто вызовите класс, например функцию без параметров, которая возвращает новый объект класса, как показано ниже.

Выше Student () возвращает объект класса Student , который назначен локальной переменной std .Класс Student - пустой класс, потому что он не содержит никаких членов.

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

Атрибуты класса - это переменные, определенные непосредственно в классе, которые используются всеми объектами класса. Доступ к атрибутам класса можно получить как по имени класса, так и по объектам.

  класс Студент:
    schoolName = 'Школа XYZ'
  

Выше schoolName - это атрибут класса, определенный внутри класса.Значение schoolName останется неизменным для всех объектов, если не будет изменено явно.

  >>> Student.schoolName
"Школа XYZ"
>>> std = Студент ()
>>> std.schoolName
"Школа XYZ"
  

Как видите, к атрибуту класса обращается Student.schoolName , а также std.schoolName . Изменение значения атрибута класса с использованием имени класса изменит его во всех экземплярах.Однако изменение значения атрибута класса с использованием экземпляра не отразится на других экземплярах или классе.

  >>> Student.schoolName = 'ABC School' # изменить значение атрибута, используя имя класса
>>> std = Студент ()
>>> std.schoolName
Значение "ABC School" # изменено для всех экземпляров.
>>> std.schoolName = 'My School' # изменение атрибута экземпляра
>>> std.schoolName
'Моя школа'
>>> Студент.schoolName # изменение уровня экземпляра не отражено в атрибуте класса
"Школа ABC"
>>> std2 = Студент ()
>>> std2.schoolName
"Школа ABC"
  

В следующем примере демонстрируется использование атрибута класса count .

  класс Студент:
    count = 0
    def __init __ (сам):
        Ученик.count + = 1
  

В приведенном выше примере count - это атрибут в классе Student. Каждый раз, когда создается новый объект, значение count увеличивается на 1. Теперь вы можете получить доступ к атрибуту count после создания объектов, как показано ниже.

  >>> std1 = Студент ()
>>> Студент.считать
1
>>> std2 = Студент ()
>>> Student.count
2
  

Конструктор

В Python метод конструктора вызывается автоматически всякий раз, когда создается новый объект класса, так же, как конструкторы в C # или Java. Конструктор должен иметь специальное имя __init __ () и специальный параметр self .

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

В следующем примере определяется конструктор.

  класс Студент:
    def __init __ (self): # метод конструктора
        print ('Конструктор вызван')
  

Теперь, когда вы создаете объект класса Student , будет вызываться метод конструктора __init __ () , как показано ниже.

  >>> s1 = Студент ()
Конструктор вызван
>>> s2 = Студент ()
Конструктор вызван
  

Конструктор в Python используется для определения атрибутов экземпляра и присвоения им значений.

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

Атрибуты экземпляра - это атрибуты или свойства, прикрепленные к экземпляру класса.Атрибуты экземпляра определяются в конструкторе.

В следующем примере в конструкторе определяются атрибуты экземпляра name и age .

  класс Студент:
    schoolName = 'XYZ School' # атрибут класса

    def __init __ (self): # конструктор
        себя.name = '' # атрибут экземпляра
        self.age = 0 # атрибут экземпляра
  

Доступ к атрибуту экземпляра можно получить, используя точечную нотацию: [имя экземпляра]. [Имя атрибута] , как показано ниже.

  >>> std = Студент ()
>>> std.name
''
>>> std.age
0
  

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

  >>> std = Студент ()
>>> std.name = "Bill" # присвоить значение атрибуту экземпляра
>>> std.age = 25 # присвоить значение атрибуту экземпляра
>>> std.name # значение атрибута экземпляра доступа
Билл
>>> std.age # значение доступа к атрибуту экземпляра
25
  

Вы можете указать значения атрибутов экземпляра через конструктор.Следующий конструктор включает параметры name и age, кроме параметра self .

  класс Студент:
    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст
  

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

  >>> std = Студент ('Bill', 25)
>>> std.name
'Билл'
>>> std.age
25
  

Вам не нужно указывать значение параметра self . Он будет назначен внутри Python.

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

  класс Студент:
    def __init __ (self, name = "Гость", возраст = 25)
        self.name = имя
        self.age = возраст
  

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

  >>> std = Студент ()
>>> std.name
'Гость'
>>> std.age
25
  

Посетите атрибуты класса и атрибуты экземпляра в Python для получения дополнительной информации.

Свойства класса

В Python свойство в классе можно определить с помощью функции property ().

Метод property () в Python предоставляет интерфейс для атрибутов экземпляра. Он инкапсулирует атрибуты экземпляра и предоставляет свойство, как в Java и C #.

Метод property () принимает методы get, set и delete в качестве аргументов и возвращает объект класса property .

В следующем примере показано, как создать свойство в Python с помощью функции property () .

  класс Студент:
    def __init __ (сам):
        сам .__ имя = ''
    def setname (self, name):
        print ('setname () называется')
        self .__ name = имя
    def getname (сам):
        print ('getname () называется')
        вернуть self .__ name
    имя = свойство (getname, setname)
  

В приведенном выше примере свойство (getname, setname) возвращает объект свойства и присваивает ему name .Таким образом, свойство name скрывает атрибут частного экземпляра __name . Доступ к свойству name осуществляется напрямую, но внутренне оно вызывает метод getname () или setname () , как показано ниже.

  >>> std = Студент ()
>>> std.name = "Стив"
setname () называется
>>> std.name
getname () называется
'Стив'
  

Рекомендуется использовать декоратор свойств вместо метода property () .

Методы класса

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

  класс Студент:
    def displayInfo (self): # метод класса
        print ('Информация о студенте')
  

Self - это просто условное имя для первого аргумента метода в классе.Метод, определенный как mymethod (self, a, b) , должен вызываться как x.mymethod (a, b) для объекта x класса.

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

  >>> std = Студент ()
>>> std.displayInfo ()
"Информация для студентов"
  

Первый параметр метода не обязательно называть self .Вы можете дать любое имя, которое относится к экземпляру вызывающего метода. Следующий метод displayInfo () называет первый параметр как obj вместо self , и он отлично работает.

  класс Студент:
    def displayInfo (obj): # метод класса
        print ('Информация о студенте')
  

Определение метода в классе без параметра self вызовет исключение при вызове метода.

  класс Студент:
    def displayInfo (): # метод без параметра self
        print ('Информация о студенте')
  

  >>> std = Студент ()
>>> std.displayInfo ()
Отслеживание (последний вызов последний):
std.displayInfo ()
TypeError: displayInfo () принимает 0 позиционных аргументов, но дан 1
  

Метод может получить доступ к атрибутам экземпляра с помощью параметра self .

  класс Студент:
    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст
    def displayInfo (self): # метод класса
        print ('Имя ученика:', self.name, ', Age:', self.age)
  

Теперь вы можете вызвать метод, как показано ниже.

  >>> std = Студент ('Стив', 25)
>>> std.displayInfo ()
Имя студента: Стив, возраст: 25
  

Удаление атрибута, объекта, класса

Вы можете удалить атрибуты, объекты или сам класс, используя ключевое слово del , как показано ниже.

  >>> std = Студент ('Стив', 25)
>>> del std.name # удаляемый атрибут
>>> std.name
Отслеживание (последний вызов последний):
Файл "", строка 1, в 
std.name
AttributeError: объект "Студент" не имеет атрибута "имя"
>>> del std # удаление объекта
>>> std.name
Отслеживание (последний вызов последний):
Файл "", строка 1, в 
std.name
NameError: имя 'std' не определено
>>> del Student # удаление класса
>>> std = Студент ('Стив', 25)
Отслеживание (последний вызов последний):
Файл "", строка 1, в 
std = Студент ()
NameError: имя "Студент" не определено
  

классов и объектов Python [с примерами]

Объекты и классы Python

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

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

Мы можем думать о классе как об эскизе (прототипе) дома. Он содержит все подробности о этажах, дверях, окнах и т. Д. На основе этих описаний мы строим дом. Дом - это объект.

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

Определение класса в Python

Как и определения функций в Python начинаются с ключевого слова def, определения классов начинаются с ключевого слова class.

Первая строка внутри класса называется docstring и содержит краткое описание класса.Хотя это не обязательно, это настоятельно рекомендуется.

Вот простое определение класса.

  класс MyNewClass:
    '' 'Это строка документации. Я создал новый класс ''
    пройти  

Класс создает новое локальное пространство имен, в котором определены все его атрибуты. Атрибуты могут быть данными или функциями.

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

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

  класс Человек:
    "Это человек класса"
    возраст = 10

    def greet (сам):
        print ('Привет')


# Вывод: 10
печать (Person.age)

# Вывод: <функция Person.greet>
печать (Person.greet)

# Вывод: «Это класс человека»
print (Лицо .__ doc__)  

Выход

  10
<функция Person.приветствовать по адресу 0x7fc78c6e8160>
Это человек класса  

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

Мы увидели, что объект класса может использоваться для доступа к различным атрибутам.

Его также можно использовать для создания новых экземпляров объекта (создания экземпляров) этого класса. Процедура создания объекта аналогична вызову функции.

  >>> harry = Person ()  

Это создаст новый экземпляр объекта с именем harry .Мы можем получить доступ к атрибутам объектов, используя префикс имени объекта.

Атрибуты могут быть данными или методом. Методы объекта - это соответствующие функции этого класса.

Это означает, что, поскольку Person.greet является объектом функции (атрибутом класса), Person.greet будет объектом метода.

  класс Человек:
    "Это человек класса"
    возраст = 10

    def greet (сам):
        print ('Привет')


# создать новый объект класса Person
harry = Человек ()

# Вывод: <функция Person.приветствовать>
печать (Person.greet)

# Вывод: <связанный метод Person.greet из <__ main __. Объект Person >>
печать (harry.greet)

# Вызов метода объекта greet ()
# Вывод: Привет
harry.greet ()  

Выход

  <функция Person.greet at 0x7fd288e4e160>
<связанный метод Person.greet объекта <__ main __. Person в 0x7fd288e9fa30 >>
Привет  

Возможно, вы заметили параметр self в определении функции внутри класса, но мы назвали этот метод просто как harry.greet () без аргументов. Это все еще работало.

Это потому, что всякий раз, когда объект вызывает свой метод, сам объект передается в качестве первого аргумента. Итак, harry.greet () переводится в Person.greet (harry) .

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

По этим причинам первым аргументом функции в классе должен быть сам объект.Это условно называется self . Его можно назвать иначе, но мы настоятельно рекомендуем следовать соглашению.

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

Конструкторы в Python

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

Особый интерес представляет функция __init __ () .Эта специальная функция вызывается всякий раз, когда создается новый объект этого класса.

Этот тип функций также называется конструкторами в объектно-ориентированном программировании (ООП). Обычно мы используем его для инициализации всех переменных.

  класс ComplexNumber:
    def __init __ (self, r = 0, i = 0):
        self.real = r
        self.imag = я

    def get_data (сам):
        print (f '{self.real} + {self.imag} j')


# Создаем новый объект ComplexNumber
num1 = Комплексное число (2, 3)

# Вызвать метод get_data ()
# Вывод: 2 + 3j
число1.получить данные()

# Создаем еще один объект ComplexNumber
# и создайте новый атрибут attr
num2 = Комплексное число (5)
num2.attr = 10

# Вывод: (5, 0, 10)
print ((num2.real, num2.imag, num2.attr))

# но объект c1 не имеет атрибута attr
# AttributeError: объект 'ComplexNumber' не имеет атрибута 'attr'
print (num1.attr)  

Выход

  2 + 3j
(5, 0, 10)
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 27, в <модуле>
    печать (число1.attr)
AttributeError: объект «ComplexNumber» не имеет атрибута «attr»  

В приведенном выше примере мы определили новый класс для представления комплексных чисел. Он имеет две функции: __init __ () для инициализации переменных (по умолчанию - ноль) и get_data () для правильного отображения числа.

Интересный момент, который следует отметить в предыдущем шаге, заключается в том, что атрибуты объекта могут быть созданы "на лету". Мы создали новый атрибут attr для объекта num2 и также прочитали его.Но это не создает этот атрибут для объекта num1 .

Удаление атрибутов и объектов

Любой атрибут объекта можно удалить в любое время с помощью оператора del . Попробуйте выполнить следующие действия в оболочке Python, чтобы увидеть результат.

  >>> число1 = Комплексное число (2,3)
>>> del num1.imag
>>> num1.get_data ()
Отслеживание (последний вызов последний):
...
AttributeError: объект 'ComplexNumber' не имеет атрибута 'imag'

>>> del ComplexNumber.получить данные
>>> num1.get_data ()
Отслеживание (последний вызов последний):
...
AttributeError: объект «ComplexNumber» не имеет атрибута «get_data»  

Мы можем даже удалить сам объект, используя оператор del.

  >>> c1 = Комплексное число (1,3)
>>> дель c1
>>> c1
Отслеживание (последний вызов последний):
...
NameError: имя 'c1' не определено  

На самом деле все намного сложнее. Когда мы выполняем c1 = ComplexNumber (1,3) , в памяти создается новый объект-экземпляр, и с ним связывается имя c1 .

По команде del c1 эта привязка удаляется, а имя c1 удаляется из соответствующего пространства имен. Однако объект продолжает существовать в памяти, и если к нему не привязано другое имя, он позже автоматически уничтожается.

Это автоматическое уничтожение объектов, на которые нет ссылок, в Python также называется сборкой мусора.

java - Как лучше всего определить слова «класс» и «объект» для того, кто их не использовал?

Объектно-ориентированное программирование - это создание программ, использующих в качестве строительных блоков «вещи», существующие в реальном мире, эти вещи реального мира называются объектами, следовательно, объектно-ориентированное -ориентированное

Например, если вы создаете программу адресной книги, вы можете определить следующие объекты:

  человек, адрес, телефон
  

Среди многих, многих других.Это будут объекты реальной жизни, и вы описываете свою программу в терминах этих абстракций.

Имея это в виду, вы можете приступить к описанию некоторых концепций.

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

  Человек:
   - имя
   - фамилия
   - номер телефона
   - адрес
  

и т. Д.

Адрес может иметь:

  Адрес:
    - улица
    - количество
    - город
    - индекс
    - страна
  

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

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

  одно лицо типа Лицо (
     - name = "Оскар"
     - фамилия = "Рейес"
     - номер телефона = "56 58 11 11"
     - адрес = адрес типа Адрес (
                     - street = "Tecolotes"
                     - число = 32
                     - city = "D.F. "
                     - почтовый индекс = 23423
                     - country = "Мексика"
                 )
  )
  

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

Это показывает разницу между ними.

В ООП есть и другие релевантные концепции, которые стоит перечислить и которые взаимосвязаны с концепцией объекта и класса:

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

Инкапсуляция Атрибуты человека скрыты для других объектов и доступны через методы, что предотвращает повреждение данных.

Полиморфизм Другой тип может по-разному реагировать на одно и то же сообщение или метод.

Наследование классы могут иметь подклассы, атрибуты и поведение, которые наследуют характеристики суперклассов.

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

Объектно-ориентированное программирование (ООП) - это метод структурирования программы путем объединения связанных свойств и поведения в отдельные объекты . В этом руководстве вы изучите основы объектно-ориентированного программирования на Python.

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

Объект содержит данные, такие как необработанные или предварительно обработанные материалы на каждом этапе сборочной линии, и поведение, такое как действие, которое выполняет каждый компонент сборочной линии.

Из этого руководства вы узнаете, как:

• Создайте класс , который похож на чертеж для создания объекта
• Использование классов для создания новых объектов
• Модельные системы с наследованием классов

Примечание: Это руководство адаптировано из главы «Объектно-ориентированное программирование (ООП)» в книге Основы Python: практическое введение в Python 3 .

В книге используется встроенный редактор IDLE Python для создания и редактирования файлов Python и взаимодействия с оболочкой Python, поэтому вы будете время от времени видеть ссылки на IDLE в этом руководстве. Однако у вас не должно возникнуть проблем с запуском примера кода из редактора и среды по вашему выбору.

Что такое объектно-ориентированное программирование в Python?

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

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

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

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

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

Определение класса в Python

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

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

Один из способов сделать это - представить каждого сотрудника в виде списка:

  kirk = ["Джеймс Кирк", 34, "Капитан", 2265]
spock = ["Спок", 35, "Научный сотрудник", 2254]
mccoy = ["Леонард Маккой", "Главный врач", 2266]
  

У этого подхода есть ряд проблем.

Во-первых, это может затруднить управление большими файлами кода. Если вы укажете kirk [0] на несколько строк от того места, где объявлен список kirk , запомните ли вы, что элемент с индексом 0 - это имя сотрудника?

Во-вторых, это может привести к ошибкам, если не у всех сотрудников одинаковое количество элементов в списке.В приведенном выше списке mccoy возраст отсутствует, поэтому mccoy [1] вернет «Главный врач» вместо возраста доктора Маккой.

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

Классы и экземпляры

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

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

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

В то время как класс является планом, экземпляр - это объект, созданный из класса и содержащий реальные данные.Экземпляр класса Dog больше не является чертежом. Это настоящая собака с таким именем, как Майлз, которому четыре года.

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

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

Все определения классов начинаются с ключевого слова class , за которым следует имя класса и двоеточие.Любой код с отступом под определением класса считается частью тела класса.

Вот пример класса Dog :

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

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

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

Свойства, которые должны иметь все объекты Dog , определены в методе .__init __ () . Каждый раз, когда создается новый объект Dog , .__ init __ () устанавливает начальное состояние объекта, присваивая значения свойствам объекта. То есть .__ init __ () инициализирует каждый новый экземпляр класса.

Вы можете указать .__ init __ () любое количество параметров, но первым параметром всегда будет переменная с именем self . Когда создается новый экземпляр класса, он автоматически передается параметру self в .__init __ () , чтобы для объекта можно было определить новые атрибуты .

Давайте обновим класс Dog с помощью метода .__ init __ () , который создает атрибуты .name и .age :

  класс Собака:
    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст
  

Обратите внимание, что подпись метода .__ init __ () имеет отступ в четыре пробела. В теле метода есть восемь пробелов.Этот отступ жизненно важен. Он сообщает Python, что метод .__ init __ () принадлежит классу Dog .

В теле .__ init __ () есть два оператора, использующие переменную self :

1. self.name = name создает атрибут с именем name и присваивает ему значение параметра name .
2. self.age = age создает атрибут с именем age и присваивает ему значение параметра age .

Атрибуты, созданные в .__ init __ () , называются атрибутами экземпляра . Значение атрибута экземпляра зависит от конкретного экземпляра класса. Все объекты Dog имеют имя и возраст, но значения атрибутов name и age будут различаться в зависимости от экземпляра Dog .

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

Например, следующий класс Dog имеет атрибут класса разновидностей со значением "Canis familis" :

  класс Собака:
    # Атрибут класса
    разновидности = "Canis knownis"

    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст
  

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

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

Теперь, когда у нас есть класс Dog , давайте создадим собак!

Создание экземпляра объекта в Python

Откройте интерактивное окно IDLE и введите следующее:

  >>> класс Собака:
...     проходить
  

Это создает новый класс Dog без атрибутов или методов.

Создание нового объекта из класса называется созданием экземпляра объекта. Вы можете создать экземпляр нового объекта Dog , введя имя класса, а затем открывающие и закрывающие круглые скобки:

  >>> Собака ()
<__ main__.Dog объект в 0x106702d30>
  

Теперь у вас есть новый объект Dog по адресу 0x106702d30 .Эта забавно выглядящая строка букв и цифр представляет собой адрес памяти , который указывает, где в памяти вашего компьютера хранится объект Dog . Обратите внимание, что адрес, который вы видите на экране, будет другим.

Теперь создайте экземпляр второго объекта Dog :

  >>> Собака ()
<__ main__.Dog объект по адресу 0x0004ccc90>
  

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

Чтобы увидеть это по-другому, введите следующее:

  >>> a = Собака ()
>>> b = Собака ()
>>> а == б
Ложь
  

В этом коде вы создаете два новых объекта Dog и назначаете их переменным a и b . При сравнении a и b с использованием оператора == результатом будет False . Несмотря на то, что a и b являются экземплярами класса Dog , они представляют два разных объекта в памяти.

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

Теперь создайте новый класс Dog с атрибутом класса с именем .species и двумя атрибутами экземпляра с именем .name и .age :

  >>> класс Собака:
... разновидности = "Canisiliaris"
... def __init __ (я, имя, возраст):
... self.name = имя
... self.age = возраст
  

Чтобы создать экземпляры объектов этого класса Dog , необходимо указать значения для name и age .Если вы этого не сделаете, Python выдаст TypeError :

  >>> Собака ()
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    Собака()
TypeError: __init __ () отсутствует 2 обязательных позиционных аргумента: 'name' и 'age'
  

Чтобы передать аргументы параметрам name и age , поместите значения в круглые скобки после имени класса:

  >>> buddy = Dog ("Приятель", 9)
>>> miles = Dog ("Мили", 4)
  

Это создает два новых экземпляра Dog - один для девятилетней собаки по имени Бадди и один для четырехлетней собаки по имени Майлз.

Метод .__ init __ () класса Dog имеет три параметра, так почему в этом примере ему передаются только два аргумента?

Когда вы создаете экземпляр объекта Dog , Python создает новый экземпляр и передает его первому параметру .__ init __ () . Это по существу удаляет параметр self , поэтому вам нужно беспокоиться только о параметрах name и age .

После создания экземпляров Dog вы можете получить доступ к их атрибутам экземпляров, используя точечную нотацию :

  >>> дружище.имя
'Приятель'
>>> buddy.age
9

>>> miles.name
'Майлз'
>>> miles.age
4
  

Таким же образом можно получить доступ к атрибутам класса:

  >>> buddy.species
'Canis knownis'
  

Одним из самых больших преимуществ использования классов для организации данных является то, что экземпляры гарантированно будут иметь ожидаемые атрибуты. Все экземпляры Dog имеют атрибуты .species , .name и .age , поэтому вы можете использовать эти атрибуты с уверенностью, зная, что они всегда будут возвращать значение.

Хотя наличие атрибутов гарантировано, их значения могут быть изменены динамически:

  >>> buddy.age = 10
>>> buddy.age
10

>>> miles.species = "Felis silvestris"
>>> miles.species
'Felis silvestris'
  

В этом примере вы изменяете атрибут .age объекта buddy на 10 . Затем вы меняете атрибут .species объекта miles на "Felis silvestris" , который является разновидностью кошек.Это делает Майлза довольно странной собакой, но это настоящий Python!

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

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

Методы экземпляра - это функции, которые определены внутри класса и могут быть вызваны только из экземпляра этого класса. Как и .__ init __ () , первый параметр метода экземпляра всегда self .

Откройте новое окно редактора в IDLE и введите следующий класс Dog :

  класс Собака:
    разновидности = "Canis knownis"

    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст

    # Метод экземпляра
    def описание (self):
        return f "{self.name} {self.age} лет"

    # Другой метод экземпляра
    def говорить (сам, звук):
        return f "{self.name} говорит {звук}"
  

Этот класс Dog имеет два метода экземпляра:

1. .description () возвращает строку, отображающую имя и возраст собаки.
2. .speak () имеет один параметр с именем sound и возвращает строку, содержащую имя собаки и звук, который издает собака.

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

  >>> miles = Dog ("Мили", 4)

>>> миль.описание()
"Майлзу 4 года"

>>> miles.speak ("Гав-гав")
'Майлз говорит Гав-Гав'

>>> miles.speak ("Bow Wow")
"Майлз говорит:" Вау! "
  

В приведенном выше классе Dog .description () возвращает строку, содержащую информацию об экземпляре Dog miles . При написании собственных классов рекомендуется иметь метод, возвращающий строку, содержащую полезную информацию об экземпляре класса. Однако .description () - не самый питонский способ сделать это.

Когда вы создаете объект списка , вы можете использовать print () для отображения строки, которая выглядит как список:

  >>> names = ["Флетчер", "Дэвид", "Дэн"]
>>> печать (имена)
["Флетчер", "Дэвид", "Дэн"]
  

Давайте посмотрим, что произойдет, если вы print () объект миль :

  >>> печать (мили)
<__ main__.Объект "Собака" по адресу 0x00aeff70>
  

Когда вы печатаете (миль) , вы получаете загадочное сообщение о том, что миль - это объект Dog по адресу памяти 0x00aeff70 . Это сообщение бесполезно. Вы можете изменить то, что печатается, определив специальный метод экземпляра с именем .__ str __ () .

В окне редактора измените имя метода .description () класса Dog на .__str __ () :

  класс Собака:
    # Остальные части класса Dog оставьте как есть

    # Замените .description () на __str __ ()
    def __str __ (сам):
        return f "{self.name} {self.age} лет"
  

Сохраните файл и нажмите F5 . Теперь, когда вы напечатаете (миль) , вы получите гораздо более удобный результат:

  >>> miles = Dog ("Мили", 4)
>>> печать (мили)
"Майлзу 4 года"
  

Методы, подобные .__init __ () и .__ str __ () называются методами dunder , потому что они начинаются и заканчиваются двойным подчеркиванием. Есть много ужасных методов, которые вы можете использовать для настройки классов в Python. Хотя это слишком сложная тема для начинающей книги по Python, понимание dunder-методов является важной частью освоения объектно-ориентированного программирования на Python.

В следующем разделе вы увидите, как расширить свои знания и создать классы из других классов.

Проверьте свое понимание

Разверните блок ниже, чтобы проверить свое понимание:

Создайте класс Car с двумя атрибутами экземпляра:

1. .color , в котором название цвета автомобиля хранится в виде строки
2. . Пробег , в котором количество миль на автомобиле сохраняется в виде целого числа

Затем создайте экземпляры двух объектов Car - синего автомобиля с пробегом 20 000 миль и красного автомобиля с пробегом 30 000 миль - и распечатайте их цвета и пробег.Ваш результат должен выглядеть так:

  У синей машины 20 000 миль.
У красной машины 30 000 миль.
  

Вы можете развернуть блок ниже, чтобы увидеть решение:

Сначала создайте класс Car с атрибутами экземпляра .color и .m mile :

  класс Автомобиль:
    def __init __ (себя, цвет, пробег):
        self.color = цвет
        собственный пробег = пробег
  

цвет и пробег параметры .__init __ () присваиваются self.color и self.m, что создает два атрибута экземпляра.

Теперь вы можете создать два экземпляра Car :

  blue_car = Автомобиль (цвет = "синий", пробег = 20_000)
red_car = Автомобиль (цвет = "красный", пробег = 30_000)
  

Экземпляр blue_car создается путем передачи значения «blue» параметру color и 20_000 параметру Munning .Аналогичным образом создается red_car со значениями «красный» и 30_000 .

Чтобы напечатать цвет и пробег каждого объекта Car , вы можете перебрать кортеж , содержащий оба объекта:

  для машины в (blue_car, red_car):
    print (f "У машины {car.color} {car.m900 :,} миль")
  

Строка f в приведенном выше цикле для вставляет атрибуты .color и .m в строку и использует спецификатор формата :, для печати пробега, сгруппированного по тысячам и разделенных запятой.

Окончательный результат выглядит так:

  У синей машины 20 000 миль.
У красной машины 30 000 миль.
  

Когда будете готовы, можете переходить к следующему разделу.

Наследование от других классов в Python

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

Дочерние классы могут переопределять или расширять атрибуты и методы родительских классов. Другими словами, дочерние классы наследуют все атрибуты и методы родительского объекта, но могут также определять атрибуты и методы, которые уникальны для них самих.

Хотя аналогия не идеальна, вы можете думать о наследовании объектов как о генетическом наследовании.

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

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

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

Представьте на мгновение, что вы находитесь в собачьем парке.В парке много собак разных пород, и все они ведут себя по-разному.

Предположим, теперь вы хотите смоделировать парк собак с помощью классов Python. Класс Dog , который вы написали в предыдущем разделе, может различать собак по имени и возрасту, но не по породе.

Вы можете изменить класс Dog в окне редактора, добавив атрибут .breed :

  класс Собака:
    разновидности = "Canis knownis"

    def __init __ (я, имя, возраст, порода):
        себя.name = имя
        self.age = возраст
        self.breed = порода
  

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

Нажмите F5 , чтобы сохранить файл. Теперь вы можете смоделировать парк собак, создав несколько экземпляров разных собак в интерактивном окне:

  >>> miles = Dog («Майлз», 4, «Джек-Рассел-терьер»)
>>> buddy = Собака («Бадди», 9, «Такса»)
>>> jack = Собака («Джек», 3, «Бульдог»)
>>> jim = Dog («Джим», 5, «Бульдог»)
  

  >>> buddy.speak ("Яп")
'Бадди говорит Яп'

>>> jim.speak («Гав»)
'Джим говорит Гав'

>>> домкрат.говорить ("Гав")
'Джек говорит Гав'
  

  класс Собака:
    разновидности = "Canis knownis"

    def __init __ (я, имя, возраст):
        себя.name = имя
        self.age = возраст

    def __str __ (сам):
        return f "{self.name} {self.age} лет"

    def говорить (сам, звук):
        return f "{self.name} говорит {звук}"
  

  класс JackRussellTerrier (Собака):
    проходить

класс Такса (Собака):
    проходить

класс Бульдог (Собака):
    проходить
  

  >>> miles = JackRussellTerrier ("Мили", 4)
>>> buddy = Такса ("Бадди", 9)
>>> jack = Бульдог ("Джек", 3)
>>> jim = Бульдог ("Джим", 5)
  

  >>> miles.species
'Canis knownis'

>>> дружище.имя
'Приятель'

>>> печать (домкрат)
Джеку 3 года

>>> jim.speak («Гав»)
'Джим говорит Гав'
  

  >>> тип (мили)
<класс '__main __. JackRussellTerrier'>
  

  >>> isinstance (мили, собака)
Правда
  

  >>> isinstance (мили, бульдог)
Ложь

>>> isinstance (Джек, Такса)
Ложь
  

  класс JackRussellTerrier (Собака):
    def Speak (self, sound = "Arf"):
        return f "{self.name} говорит {звук}"
  

  >>> miles = JackRussellTerrier ("Мили", 4)
>>> miles.speak ()
'Майлз говорит Арф'
  

  >>> miles.speak ("Гррр")
'Майлз говорит Грр'
  

  класс Собака:
    # Остальные атрибуты и методы оставьте как есть

    # Измените строку, возвращаемую .speak ()
    def говорить (сам, звук):
        return f "{self.name} лай: {звук}"
  

  >>> jim = Бульдог ("Джим", 5)
>>> jim.speak («Гав»)
'Джим лает: Гав'
  

  >>> miles = JackRussellTerrier ("Мили", 4)
>>> miles.speak ()
'Майлз говорит Арф'
  

  класс JackRussellTerrier (Собака):
    def Speak (self, sound = "Arf"):
        вернуть супер (). говорить (звук)
  

  >>> miles = JackRussellTerrier ("Мили", 4)
>>> miles.speak ()
Майлз лает: Арф
  

  класс Собака:
    разновидности = "Canis knownis"

    def __init __ (я, имя, возраст):
        self.name = имя
        self.age = возраст

    def __str __ (сам):
        return f "{self.name} {self.age} лет"

    def говорить (сам, звук):
        return f "{self.name} говорит {звук}"
  

  класс GoldenRetriever (Собака):
    def Speak (self, sound = "Лай"):
        вернуть супер (). говорить (звук)