Классы Python

Вступление

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

Python является объектно-ориентированным языком, все в Python является объектом.

Мы уже работали с некоторыми объектами в Python ( см. Главу «Тип данных Python» ), например, строки, списки - это объекты, определяемые классами строк и списков, которые по умолчанию доступны в Python. Давайте объявим два объекта как строку и список и проверим их тип с помощью функции type ().

Поскольку string1 является объектом, строки «Доброе утро» могут создавать свои версии в верхнем или нижнем регистре, вызывая методы upper () и lower (), связанные со строкой. Проверьте это в Python IDLE.

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

Локальные переменные:

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

# python-local-variable.py
def function_local(a):
	print('a is -> ',a)
	a = 50
	print('After new value within the function a is -> ',a)
a = 100
function_local(40)
print('Value of a is ->',a)

Выход:

 а есть -> 40
После того, как новое значение в функции a -> 50
Значение а -> 100 

Объяснение:

Строка № 2: объявлена функция function_local (a) с параметром
Строка № 3: для печати «a» используется значение параметра. [Значение a теперь равно 100, поскольку мы присваиваем a 100 (строка № 6) перед выполнением функции (строка № 7).]
Строка № 4: присвойте значение 50 «а».
Строка № 5: Снова выведите «a», поскольку a является локальным в функции, поэтому значение a теперь равно 50.
Строка № 8: это последний оператор печати, и «а» становится равным 100. Пока что мы сделали внутри функции, которая не влияет на функцию. Это называется областью действия переменной.

глобальное утверждение:

Цель глобального оператора - присвоить значение переменной, которая объявлена вне функции. Свободные переменные (см. Строку № 06 в предыдущем примере) могут ссылаться на глобальные, не объявляя глобальные. Синтаксис глобального оператора: -> global var_name1, var_name2, ..
Смотрите следующий пример:

# python-global-variable.py
def function_local():
        global a
        print('a is -> ',a)
        a = 50
        print('After new value within the function a is -> ',a)
a = 100
function_local()
print('Value of a is ->',a)

Выход:

 а есть -> 100
После того, как новое значение в функции a -> 50
 Значение a -> 50 

Объяснение:

Строка № 3: переменная 'a' объявлена как глобальная переменная, поэтому значение a теперь равно 100.
Строка № 5: присвойте значение 50 «а», и оно будет содержать одно и то же значение внутри и снаружи функции, если мы не назначим новое значение.

нелокальное утверждение

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

def outside():
       a = 10
       def inside():
           a = 20
           print("Inside a ->", a)
       inside()
       print("outside a->", a)
outside()

В приведенном выше примере первый оператор print () просто выводит значение «a», которое равно 20, поскольку «a» является локальным внутри функции inside (). Второй оператор print () печатает значение 'a', которое равно 10, поскольку функция inside () не имеет никакого эффекта. Теперь мы введем нелокальный оператор в функции inside (), и код будет:

def outside():
       a = 10
       def inside():
              nonlocal a
              a = 20
              print("The value of a in inside() function - ", a)
       inside()
       print("The value of a in outside() function -  ", a)
outside()

Второй оператор print () печатает значение 'a', которое равно 20, поскольку переменная 'a' является отскоком.

Области применения и пространства имен Python:

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

Пространство имен - это отображение имен в объекты.

- Например, «а» отображается на [1, 2, 3] или «а» отображается на значение 25.

- Большинство пространств имен в настоящее время реализованы в виде словарей Python (содержащих имена и значения объектов).

- Имена в разных пространствах имен абсолютно не связаны (например, переменная «a» может быть связана с разными объектами в разных пространствах имен).

- Примеры пространства имен: глобальное имя модуля, локальные имена в вызове функции, встроенные имена (содержащие функции, такие как min ()), атрибуты объекта.

Python создает пространства имен в разное время.

- Встроенное пространство имен создается при запуске интерпретатора Python и никогда не удаляется.

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

- Локальное пространство имен для функции создается при ее вызове и удаляется при ее возврате.

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

- Локальная область, в которой выполняется поиск, содержит локальное имя.

- Включающая область (в функции включения) содержит нелокальные и неглобальные имена.

- Глобальные имена текущего модуля.

- Внешняя область - это пространство имен, содержащее встроенные имена.

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

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

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

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

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

Создание класса:

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

#studentdetails.py
class Student:
        stu_class ='V'
        stu_roll_no = 12
        stu_name ="David"

Объекты класса:

Существует два вида поддерживаемых объектов класса операций: ссылки на атрибуты и создание экземпляров. Ссылки на атрибуты используют стандартный синтаксис obj.name для всех ссылок на атрибуты в Python. Поэтому, если определение класса (добавить метод в предыдущем примере) выглядит так

#studentdetails1.py
class Student:
    """A simple example class"""
    stu_class ='V'
    stu_roll_no = 12
    stu_name ="David"
    def messg(self):
            return 'New Session will start soon.'

затем Student.stu_class, Student.stu_roll_no, Student.stu_name являются действительными ссылками на атрибуты и возвращают «V», 12, «David». Student.messg возвращает функциональный объект. В Python self - это имя первого аргумента метода, которое отличается от обычной функции. Вместо того, чтобы передавать объект в качестве параметра в методе, слово self относится к самому объекту. Например, если метод определен как avg (self, x, y, z), он должен называться a.avg (x, y, z). Смотрите вывод атрибутов в Python Shell.

__doc__ также является допустимым атрибутом, который возвращает строку документации класса.

__init__ метод:

В Python есть много имен методов, которые имеют особое значение. Класс может определять специальный метод с именем __init__, который выполняет некоторую работу по инициализации и служит конструктором для класса. Как и другие функции или методы, __init__ может принимать любое количество аргументов. Метод __init__ запускается, как только создается экземпляр объекта класса, и создание экземпляра класса автоматически вызывает __init __ () для вновь созданного экземпляра класса. В следующем примере новый инициализированный экземпляр может быть получен:

#studentdetailsinit.py
class Student:
    """A simple example class"""
    def __init__(self, sclass, sroll, sname):
        self.c = sclass
        self.r = sroll
        self.n = sname
    def messg(self):
            return 'New Session will start soon.'

Наследование:

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

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

Пример:

На фабрике компании сотрудники и сотрудники офиса имеют определенные общие свойства - у всех есть имя, обозначение, возраст и т. Д. Таким образом, они могут быть сгруппированы в класс под названием CompanyMember. Помимо совместного использования этих общих функций, у каждого подкласса есть своя особенность - FactoryStaff получает надбавку за сверхурочную работу, а OfficeStaff - надбавку за командировки для работы в офисе. Производные классы (FactoryStaff & OfficeStaff) имеют свою собственную характеристику и, кроме того, они наследуют свойства базового класса (CompanyMember). Смотрите пример кода.

# python-inheritance.py
class CompanyMember:
	'''Represents Company  Member.'''
	def __init__(self, name, designation, age):
		self.name = name
		self.designation = designation
		self.age = age
	def tell(self):
		'''Details of an employee.'''
		print('Name: ', self.name,'\nDesignation : ',self.designation, '\nAge : ',self.age)
class FactoryStaff(CompanyMember):
	'''Represents a Factory Staff.'''
	def __init__(self, name, designation, age, overtime_allow):
		CompanyMember.__init__(self, name, designation, age)
		self.overtime_allow = overtime_allow
		CompanyMember.tell(self)
		print('Overtime Allowance : ',self.overtime_allow)
class OfficeStaff(CompanyMember):
	'''Represents a Office Staff.'''
	def __init__(self, name, designation, age, travelling_allow):
		CompanyMember.__init__(self, name, designation, age)
		self.marks = travelling_allow
		CompanyMember.tell(self)
		print('Traveling Allowance : ',self.travelling_allow)

Теперь выполните класс в Python Shell и посмотрите результат.

Предыдущая: календарь ()
Далее: встроенные функции Python