Вложенные классы в python объясняются примерами

Создание класса в Python

Классы в Python могут моделировать практически все что угодно. Создадим простой класс, который будет описывать конкретный автомобиль:

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model):
        «»»Инициализирует атрибуты brand и model»»»
        self.brand = brand
        self.model = model

    def sold(self):
        «»»Автомобиль продан»»»
        («Автомобиль {self.brand} {self.model} продан «)

    def discount(self):
        «»»Скидка на автомобиль»»»
        («На автомобиль {self.brand} {self.model} скидка 5%»)

Разберем код по порядку. В начале определяется класс с именем Car (class Car). По общепринятым соглашение название класса начинается с символа верхнего регистра. Круглые скобки в определение класса пусты, так как класс создается с нуля. Далее идет строка документации с кратким описанием. («»»Описание автомобиля»»»). 

1.1. Метод __init__()

Функция, являющаяся частью класса, называется методом. Все свойства функций так же относятся и к методам, единственное отличие это способ вызова метода. Метод __init__() — специальный метод, который автоматически выполняется при создание нового экземпляра. Имя метода начинается и заканчивается двумя символами подчеркивания. Метод __init__() определяется с тремя параметрами: self, brand, model. Параметр self обязателен в определение метода и должен стоять перед всеми остальными параметрами. При создании экземпляра на основе класса Car, необходимо передать только два последних аргумента brand и model.

Каждая из двух переменных self.brand = brand и self.model = model снабжена префиксом self и к ним можно обращаться вызовом self.brand и self.model. Значения берутся из параметров brand и model. Переменные, к которым вы обращаетесь через экземпляры, также называются атрибутами. 

В классе Car также есть два метода: sold() и discount(). Этим методам не нужна дополнительная информация и они определяются с единственным параметром self. Экземпляры, которые будут созданы на базе этого класса смогут вызывать данные методы, которые просто выводят информацию. 

1.2. Создание экземпляра класса 

С помощью класса Car мы можем создавать экземпляры для конкретного автомобиля. Каждый экземпляр описывает конкретный автомобиль и его параметры. 

car_1 = Car(‘Bmw’, ‘X5’)

Создадим переменную car_1 и присвоим ей класс с параметрами автомобиля которые нужно обязательно передать (brand, model). При выполнение данного кода Python вызывает метод __init__ , создавая экземпляр, описывающий конкретный автомобиль и присваивает атрибутам brand и model  переданные значения. Этот экземпляр сохраняется в переменной car_1. 

1.3. Обращение к атрибутам класса

К атрибутам экземпляра класса мы можем обращаться через запись:

print(f»{car_1.brand}»)
print(f»{car_1.model}»)

В записи используется имя экземпляра класса и после точки имя атрибута (car_1.brand) или (car_1.model). В итоге на экран выведется следующая информация:

Bmw
X5

1.4. Вызов методов класса

После создания экземпляра на основе класса Car можете вызывать любые методы, написанные в классе. Чтобы вызвать метод, укажите экземпляр (car_1) и вызываемый метод после точки:

car_1.sold()
car_1.discount()

При вызове данных методов, Python выполнит код, написанный в этом методе.

Автомобиль Bmw X5 продан 
На автомобиль Bmw X5 скидка 5%

Instance Attributes

Instance attributes are attributes or properties attached to an instance of a class. Instance attributes are defined in the constructor.

The following example defines instance attributes and in the constructor.

Example: Instance Attributes
Copy

An instance attribute can be accessed using dot notation: , as shown below.

Example:
Copy

You can set the value of attributes using the dot notation, as shown below.

Example:
Copy

You can specify the values of instance attributes through the constructor.
The following constructor includes the name and age parameters, other than the parameter.

Example: Setting Attribute Values
Copy

Now, you can specify the values while creating an instance, as shown below.

Example: Passing Instance Attribute Values in Constructor
Copy

Note:

You don’t have to specify the value of the parameter. It will be assigned internally in Python.

You can also set default values to the instance attributes. The following code sets the default values of the constructor parameters.
So, if the values are not provided when creating an object, the values will be assigned latter.

Example: Setting Default Values of Attributes
Copy

Now, you can create an object with default values, as shown below.

Example: Instance Attribute Default Value
Copy

Visit class attributes vs instance attributes in Python for more information.

ADVERTISEMENT

Ошибки при работе со списками Python

Одна из основных ошибок при работе со списками, это ошибка индексирования. Например, вы пытаетесь вернуть элемент с индексом 5. В результате Python при работе со списком не находит элемент с этим индексом, происходит ошибка индексирования. 

>>> cars =          
>>> cars Traceback (most recent call last):
  File «<stdin>», line 1, in <module>
IndexError: list index out of range

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

Data Hiding

An object’s attributes may or may not be visible outside the class definition. You need to name attributes with a double underscore prefix, and those attributes then are not be directly visible to outsiders.

Example

#!/usr/bin/python

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

When the above code is executed, it produces the following result −

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python protects those members by internally changing the name to include the class name. You can access such attributes as object._className__attrName. If you would replace your last line as following, then it works for you −

.........................
print counter._JustCounter__secretCount

When the above code is executed, it produces the following result −

1
2
2

Previous Page
Print Page

Next Page  

Наследование[]

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

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

Простое наследование:

Класс, от которого произошло наследование, называется базовым или родительским (англ. base class). Классы, которые произошли от базового, называются потомками, наследниками или производными классами (англ. derived class).

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

Множественное наследование

При множественном наследовании у класса может быть более одного предка. В этом случае класс наследует методы всех предков. Достоинства такого подхода в большей гибкости. Множественное наследование реализовано в C++. Из других языков, предоставляющих эту возможность, можно отметить Python и Эйфель. Множественное наследование поддерживается в языке UML.

Множественное наследование — потенциальный источник ошибок, которые могут возникнуть из-за наличия одинаковых имен методов в предках. В языках, которые позиционируются как наследники C++ (Java, C# и др.), от множественного наследования было решено отказаться в пользу интерфейсов. Практически всегда можно обойтись без использования данного механизма. Однако, если такая необходимость все-таки возникла, то, для разрешения конфликтов использования наследованных методов с одинаковыми именами, возможно, например, применить операцию расширения видимости — «::» — для вызова конкретного метода конкретного родителя.

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

Большинство современных объектно-ориентированных языков программирования (C#, Java, Delphi и др.) поддерживают возможность одновременно наследоваться от класса-предка и реализовать методы нескольких интерфейсов одним и тем же классом. Этот механизм позволяет во многом заменить множественное наследование — методы интерфейсов необходимо переопределять явно, что исключает ошибки при наследовании функциональности одинаковых методов различных классов-предков.

Полиморфизм в Python

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

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

Python также имеет встроенные функции, работающие с полиморфизмом. Одним из самых простых примеров является функция print в Python.

Вывод будет таким:

В приведенном выше фрагменте кода:

• Параметр конечного ключевого слова изменил работу функции print. Следовательно, «Привет!» не заканчивалось концом строки.
• len () в третьей строке возвращает int. Печать распознает тип данных и неявно преобразует его в строку и выводит его на консоль.

2.2. Перебор всех ключей в словаре методом keys().

Метод keys() удобен если вы собираетесь работать с ключами в словаре. Переберем словарь и выведем все ключи в нем:

>>> year = {‘январь’: 31, ‘февраль’: 28, ‘март’: 31, ‘апрель’: 30}
>>> for key in year.keys():
…     print(key)
…январь
февраль
март
апрель

В Python перебор ключей используется по умолчанию при переборе словаря. Две записи ниже дают один и тот же результат.

>>> for key in year.keys():

>>> for key in year:

Явный вызов метода keys() может упростить чтение вашего кода. 

Начиная с Python 3.7 перебор содержимого словаря возвращает элементы в том порядке, в каком они вставлялись. Один из способов перебрать элементы в определенном порядке, вызвать функцию sorted(). 

>>> for key in sorted(year.keys()):
…     print(key)
…апрель
март
февраль
январь

В результате ключи сортируются по алфавиту.

Обзор терминологии ООП

• Класс — определенный пользователем прототип для объекта, который определяет набор атрибутов, которые характеризуют любой объект класса. Атрибутами являются члены данных (переменные класса и переменные экземпляра) и методы, доступ к которым осуществляется через точечную запись.
• Переменная класса — переменная, которая используется всеми экземплярами класса. Переменные класса определены внутри класса, но вне любого из методов класса. Переменные класса используются не так часто, как переменные экземпляра.
• Член данных — переменная класса или переменная экземпляра, которая содержит данные, связанные с классом и его объектами.
• Перегрузка функций — назначение более чем одного поведения определенной функции. Выполняемая операция варьируется в зависимости от типов объектов или аргументов.
• Переменная экземпляра — переменная, которая определена внутри метода и принадлежит только текущему экземпляру класса.
• Наследование — передача характеристик класса другим классам, которые являются его производными.
• Экземпляр — индивидуальный объект определенного класса. Например, объект obj, принадлежащий классу Circle, является экземпляром класса Circle.
• Instantiation — создание экземпляра класса.
• Метод — особый вид функции, который определен в определении класса.
• Объект — уникальный экземпляр структуры данных, который определяется его классом. Объект включает в себя как члены данных (переменные класса и переменные экземпляра), так и методы.
• Перегрузка оператора — назначение более чем одной функции определенному оператору.

Определение конструктора для класса

Если вы заметили реализацию класса Employee, невозможно установить значение employee_id. Мы можем определить отдельный метод для установки значения employee_id. Но это обязательное свойство объекта Employee. Лучшее место для установки этих свойств — через конструктор.

Давайте продолжим и создадим конструктор для класса Employee. Мы ожидаем, что вызывающая программа передаст значение employee_id в качестве аргумента.

class Employee:

    def __init__(self, i):
        self.employee_id = i

    def work(self):
        print(f'{self.employee_id} is working')


emp = Employee(100)
emp.work()

Выход:

Примечание: предыдущий код для создания объекта Employee теперь не будет работать, потому что конструктор Employee ожидает аргумент. Если мы вызовем , он вызовет ошибку TypeError: в init() отсутствует 1 обязательный позиционный аргумент: ‘id’.

Можем ли мы иметь несколько конструкторов?

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

Однако, если мы определим несколько конструкторов в классе, это не вызовет никаких ошибок. Последний конструктор перезапишет ранее определенное определение конструктора. Давайте посмотрим на это на примере.

class Employee:

    def __init__(self, id):
        self.employee_id = id
    
    # this will overwrite earlier defined constructor
    def __init__(self, id, n):  
        self.employee_id = id
        self.emp_name = n

    def work(self):
        print(f'{self.emp_name} is working')


emp = Employee(100, 'Pankaj')
emp.work()

emp = Employee(100)  # will raise Error
emp.work()

Вывод:

Pankaj is working
Traceback (most recent call last):
  File "/Users/pankaj/Documents/PycharmProjects/AskPython/hello-world/class_examples.py", line 19, in <module>
    emp = Employee(100)
TypeError: __init__() missing 1 required positional argument: 'n'

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

Создавая новые классы не обязательно их создавать с нуля. Новый класс может наследовать свои атрибуты (переменные) и методы (функции принадлежащие классам) от ранее определенного исходного класса ( суперкласса ). Также исходный класс называют родителем, а новый класс — потомком или подклассом. В класс-потомок можно добавлять собственные атрибуты и методы. Напишем новый класс , который будет создан на базе класса :

class Car():
    «»»Описание автомобиля»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты brand и model»»»
        self.brand = brand
        self.model = model
        self.years = years
        self.mileage = 0

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years}»
        return name.title()

    def read_mileage(self):
        «»»Пробег автомобиля»»»
        print(f»Пробег автомобиля {self.mileage} км.»)

    def update_mileage(self, new_mileage):
        «»»Устанавливает новое значение пробега»»»
        self.mileage = new_mileage
    
    def add_mileage(self, km):
        «»»Добавляет пробег»»»
        self.mileage += km

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(«Мощность аккумулятора {self.battery_size} кВт⋅ч»)

Мы создали класс на базе класса. Имя класса-родителя в этом случае ставится в круглые скобки( class ElectricCar(Car) ). Метод __init__  в классе потомка (подклассе) инициализирует атрибуты класса-родителя и создает экземпляр класса . Функция super() .- специальная функция, которая приказывает Python вызвать метод __init__() родительского класса Car, в результате чего экземпляр ElectricCar получает доступ ко всем атрибутам класса-родителя. Имя super как раз и происходит из-за того, что класс-родителя называют суперклассом, а класс-потомок — подклассом.          

Далее мы добавили новый атрибут и присвоили исходное значение 100. Этот атрибут будет присутствовать во всех экземплярах класса . Добавим новый метод battery_power(), который будет выводить информацию о мощности аккумулятора.         

Создадим экземпляр класса  и сохраним его в переменную tesla_1

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())
tesla_1.battery_power()

При вызове двух методов мы получим:

Автомобиль Tesla Model X 2021
Мощность аккумулятора 100 кВт⋅ч

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

3.1. Переопределение методов класса-родителя

Методы, которые используются в родительском классе можно переопределить в классе-потомке (подклассе). Для этого в классе-потомке определяется метод с тем же именем, что и у класса-родителя. Python игнорирует метод родителя и переходит на метод, написанный в классе-потомке (подклассе). Переопределим метод def get_full_name() чтобы сразу выводилась мощность аккумуляторов. 

class ElectricCar(Car):
    «»»Описывает электромобиль»»»
    def __init__(self, brand, model, years):
        «»»Инициализирует атрибуты класса родителя»»»
        super().__init__(brand, model, years)
        # атрибут класса-потомка
        self.battery_size = 100

    def battery_power(self):
        «»»Выводит мощность аккумулятора авто»»»
        print(«Мощность аккумулятора {self.battery_size} кВт⋅ч»)

    def get_full_name(self):
        «»»Автомобиль»»»
        name = f»Автомобиль {self.brand} {self.model} {self.years} {self.battery_size}-кВт⋅ч »
         name.
 

В результате при запросе полного названия автомобиля Python проигнорирует метод def get_full_name() в классе-родителя и сразу перейдет к методу def get_full_name() написанный в классе .          

tesla_1 = ElectricCar(‘tesla’, ‘model x’, 2021)
print(tesla_1.get_full_name())

Автомобиль Tesla Model X 2021 100-Квт⋅Ч

Please enable JavaScript to view the comments powered by Disqus.

Многоуровневое наследование

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

Пример:

class employee()://Super class
def __init__(self,name,age,salary):  
self.name = name
self.age = age
self.salary = salary
class childemployee1(employee)://First child class
def __init__(self,name,age,salary):
self.name = name
self.age = age
self.salary = salary

class childemployee2(childemployee1)://Second child class
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary
emp1 = employee('harshit',22,1000)
emp2 = childemployee1('arjun',23,2000)

print(emp1.age)
print(emp2.age)

Выход: 22,23.

Объяснение:

• Это четко объясняется в коде, написанном выше. Здесь я определил суперкласс как сотрудник, а дочерний класс, как childemployee1. Теперь childemployee1 действует, как родитель для childemployee2.
• Я создал два объекта «emp1» и «emp2», где я передаю параметры «имя», «возраст», «зарплата» для emp1 из суперкласса «сотрудник» и «имя», «возраст», «зарплата» и «идентификатор». Из родительского класса «childemployee1 »

Встроенные атрибуты класса

Наряду с другими атрибутами класс Python также содержит некоторые встроенные атрибуты класса, которые предоставляют информацию о классе.

Встроенные атрибуты класса приведены в таблице ниже.

SN	Атрибут	Описание
1	__dict__	Предоставляет словарь, содержащий информацию о пространстве имен класса.
2	__doc__	Содержит строку с документацией класса.
3	__name__	Используется для доступа к имени класса.
4	__module__	Он используется для доступа к модулю, в котором определен этот класс.
5	__bases__	Содержит кортеж, включающий все базовые классы.

Пример –

 
class Student:   
    def __init__(self,name,id,age):   
        self.name = name;   
        self.id = id;   
        self.age = age   
    def display_details(self):   
        print("Name:%s, ID:%d, age:%d"%(self.name,self.id))   
s = Student("John",101,22)   
print(s.__doc__)   
print(s.__dict__)   
print(s.__module__)   

Выход:

None 
{'name': 'John', 'id': 101, 'age': 22} 
__main__ 

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

How to Check an Object’s Class

You can check an object’s class with the attribute. Generally, you’ll get the same result when using the function.

Here’s how to output the class of an object (using both syntaxes):

a = «Hello World»

print(type(a))
print(a.__class__)Result

<class 'str'>
<class 'str'>

What that tells us is that the string is based on the class.

You can do the same thing for any object. Here are some more examples:

from myPackage.calculations import multiplyMe

print(type(10))
print(type(1.0))
print(type())
print(type((1,2,3)))
print(type({1,2,3}))
print(type({1:»Hello», 2:»World»}))
print(type(multiplyMe))
print(type(max))Result

<class 'int'>
<class 'float'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>
<class 'function'>
<class 'builtin_function_or_method'>

• Python Modules
• Read/Write Files

The __init__() Method

Python has a special method called that you can add to your class. The method is invoked whenever an object is created from the class. Therefore you can make use of the method without having to explictly call it.

Here’s a simple example to demonstrate:

# Create the class
class MyClass:

def __init__(self):
self.a = «Hey»

def b(self):
return «Hello World»

# Create an object from the class
o = MyClass()

# Now we can work with the object
print(o.a)
print(o.b())Result

Hey
Hello World

We can access the variable using (i.e. ). So if we had an object called and another called then we could use and respectively.

Конструктор класса — метод __init__

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

Такой метод называется конструктором класса и в языке программирования Python носит имя __init__. (В начале и конце по два знака подчеркивания.)

Первым параметром, как и у любого другого метода, у __init__ является self, на место которого подставляется объект в момент его создания. Второй и последующие (если есть) параметры заменяются аргументами, переданными в конструктор при вызове класса. Рассмотрим два класса: в одном будет использоваться конструктор, а в другом нет. Требуется создать два атрибута объекта.

Рассмотрим два класса: в одном будет использоваться конструктор, а в другом нет. Требуется создать два атрибута объекта.

Пример 1:

class YesInit:
    def __init__(self,one,two):
        self.fname = one
        self.sname = two

obj1 = YesInit("Peter","Ok")
print (obj1.fname, obj1.sname)

Пример 2:

class NoInit:
    def names(self,one,two):
        self.fname = one
        self.sname = two

obj2 = NoInit()
obj2.names("Peter","Ok")

print (obj2.fname, obj2.sname)

Результат выполнения двух скриптов:

Peter Ok

Тестирование функций в Python

Модуль unittest из стандартной библиотеки Python представляет функциональную возможность для тестирования кода. Модульный тест проверяет правильность работы одного конкретного аспекта поведения функции. Тестовый сценарий — это совокупность модульных тестов, которые совместно доказывают, что функция ведет себя правильно во всех ситуациях, которые она должна обрабатывать. Часто достаточно написать модульные тесты для критичных аспектов поведения кода. 

Для проведения теста напишем простую функцию, которая запрашивает два параметра «страна и столица» и выводит в отформатированном виде:

get_country(country, capital):
    «»»Возвращает отформатированную строку страна-столица.»»»
    full_country = «{country}-{capital}»
     full_country.

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

import unittest

class CountryTestCase(unittest.TestCase):
    «»»Тесты для функции get_country «»»

    def test_get_country(self):
        «»»Параметры вида ‘Uk-London’ работают правильно?»»»
        formatted_country = (‘uk’, ‘london’)
        self.assertEqual(formatted_country, ‘Uk-London’)

if __name__ == ‘__main__’:
    unittest.main()

После импортирования unittest, мы создаем класс CountryTestCase,  который содержит серию модульных тестов для функции (). Класс наследует от класса unittest.TestCase, чтобы Python знал как запускать тесты.

Класс CountryTestCase содержит всего один метод test_get_country(), который тестирует один аспект функции ()- правильность форматирования строки страна-столица. Любой метод, имя которого начинается с test_, будет выполняться автоматически при запуске. В тестовом методе вызывается тестируемая функция () c аргументами ‘uk’ и ‘london’ и сохраняет возвращаемое значение в переменную formatted_country.   

self.assertEqual проверяет соответствует ли полученный результат функции, тому результату, который вы хотите получить. Метод assertEqual() из модуля unittest получает переменную formatted_country и строку ‘Uk-London’ и сравнивает их. 

Блок if проверяет специальную переменную __name__, значение которой задается при выполнении программы. Если файл выполняется как главная программа, переменной __name__ будет присвоено значение __main__. В этом случае вызывается метод unittest.main(), который выполняет тестовый сценарий. В результате при запуске теста мы получим:

.
———————————————————————-
Ran 1 test in 0.0001s

OK

Точка в начале сообщает, что один тест прошел успешно. Далее сообщается что на выполнение теста потребовалось 0.0001s. Сообщение Ок говорит о успешном прохождение теста. 

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

Переопределяющие методы

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

Пример

#!/usr/bin/python

class Parent:        # define parent class
   def myMethod(self):
      print 'Calling parent method'

class Child(Parent): # define child class
   def myMethod(self):
      print 'Calling child method'

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

Когда приведенный выше код выполняется, он дает следующий результат

Calling child method

Возвращаемое значение в функции на Python

Вместо вывода результата работы напрямую, функция может обработать данные и вернуть значение c помощью команды return. Значение, возвращаемое функцией, называется возвращаемым значением.

3.1. Возвращение простого значения

Напишем функцию, которая возвращает отформатированное имя и фамилию

>>> def form_name(last_name, first_name, middle_name):
…     «»»Возвращает отформатированное полное имя»»»
…     full_name = «{last_name} {first_name} {middle_name}»
…     return full_name.
…
>>> poet = form_name(‘пушкин’, ‘александр’, ‘сергеевич’)
>>> print(poet)Пушкин Александр Сергеевич

Функция form_name получает в параметрах имя, фамилию и отечество, далее объединяет эти имена и сохраняет их в переменной full_name. Завершив выполнение, функция возвращает управление в точку вызова с помощью команды return, то есть в строку кода, которая вызывала функцию. 

Предположим, что мы не знаем отчество человека, для передачи его фукции параметру middle_name. В связи с этим удобно заранее сделать в функции необязательный аргумент. Присвоим ( middle_name = «» ) пустое значение.

>>> def form_name(last_name, first_name, middle_name=»):
…     «»»Возвращает отформатированное полное имя»»»
…     full_name = «{last_name} {first_name} {middle_name}»
…     return full_name.
…
>>> poet = form_name(‘пушкин’, ‘александр’)
>>> print(poet)Пушкин Александр
>>> poet = form_name(‘пушкин’, ‘александр’, ‘сергеевич’)
>>> print(poet)Пушкин Александр Сергеевич

С необязательным аргументом мы не получим ошибку (TypeError: form_name() missing 1 required positional argument: ‘middle_name’) в случае отсутствия на входе данных по аргументу.

3.2. Возвращение словаря

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

>>> def info_person(first_name, last_name):
…     «»»Возвращает словарь с данными о человеке»»»
…     person = {‘first’: first_name, ‘last’: last_name}
…     return person
…
>>> musician = info_person(‘Freddie’, ‘Mercury’)
>>> print(musician){‘first’: ‘Freddie’, ‘last’: ‘Mercury’}

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

Defining a Class

A class in Python can be defined using the keyword.

As per the syntax above, a class is defined using the keyword followed by the class name and operator after the class name, which allows you to continue in the next indented line to define class members.
The followings are class members.

A class can also be defined without any members. The following example defines an empty class using the keyword.

Example: Define Python Class
Copy

Class instantiation uses function notation. To create an object of the class, just call a class like a parameterless function that returns a new object of the class, as shown below.

Example: Creating an Object of a Class
Copy

Above, returns an object of the class, which is assigned to a local variable .
The class is an empty class because it does not contain any members.

Кортежи в Python.

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

>>> student = ()
>>> len(student)
>>> student = ‘Ivan’, ‘Ivanov’, 3.5
>>> print(student)(‘Ivan’, ‘Ivanov’, 3.5)
>>> print(student)Ivanov

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

>>> student = ‘Petrov’Traceback (most recent call last):
  File «<stdin>», line 1, in <module>
TypeError: ‘tuple’ object does not support item assignment

Когда вы захотите изменить элемент в кортеже, Python выдаст ошибку о невозможности изменения элементов.  TypeError: ‘tuple’ object does not support item assignment.

Please enable JavaScript to view the comments powered by Disqus.