Как создать инициализатор класса someclass

Объектно-ориентированное программирование. Специальные методы.

Декоратор @staticmethod определяет обычную функцию (статический метод) в пространстве имён класса. У него нет обязательного параметра-ссылки self. Может быть полезно для вспомогательных функций, чтобы не мусорить пространство имён модуля. Доступ к таким методам можно получить как из экземпляра класса, так и из самого класса:

Декоратор @classmethod создаёт метод класса и требует обязательную ссылку на класс (cls). Поэтому объект класса явно передаётся через первый параметр как это с параметром self происходит для обычных методов. Также как и для self, переданный cls может отличаться от класса, в котором определён класс-метод (может быть потомок). Часто используется для создания альтернативных конструкторов.

Давайте взглянем на пример кода, в котором одновременно показаны она декоратора, это может помочь понять основные принципы:

Важно понимать, что ни classmethod ни staticmethod НЕ являются функциями от конкретного объекта класса и соответственно не принимают self. Подчеркнем еще раз их различия: — classmethod принимает cls как первый параметр, тогда как staticmethod в специальных аргументах не нуждается — classmethod может получать доступ или менять состояние класса, в то время как staticmethod нет — staticmethod в целом вообще ничего не знают про класс. Это просто функция над аргументами, объявленная внутри класса.

Специальные методы (магические) вида _ < param > _

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

Эти методы могут эмулировать поведение встроенных классов, но при этом они необязательно существуют у самих встроенных классов. Например, у объектов int при сложении не вызывается метод add. Таким образом, их нельзя переопределить.

Давайте для примера переопределим стандартную операцию сложения. Рассмотрим класс Vector, используемый для представления радиус-векторов на координатной плоскости, и определим в нем поля-координаты: x и y. Также очень хотелось бы определить для векторов операцию +, чтобы их можно было складывать столь же удобно, как и числа или строки.

Для этого необходимо перегрузить операцию +: определить функцию, которая будет использоваться, если операция + будет вызвана для объекта класса Vector. Для этого нужно определить метод add класса Vector, у которого два параметра: неявная ссылка self на экземпляр класса, для которого она будет вызвана (это левый операнд операции +) и явная ссылка other на правый операнд:

Теперь при вызове оператора A + B Питон вызовет метод A.add(B), то есть вызовет указанный метод, где self = A, other = B.

Аналогично можно определить и оставшиеся операции. Полезной для переопределения является операция <. Она должна возвращать логическое значение True, если левый операнд меньше правого или False в противном случае (также в том случае, если объекты равны). Для переопределения этого операнда нужно определить метод lt (less than):

В этом примере оператор вернет True, если у левого операнда поле x меньше, чем у правого операнда, а также если поля x у них равны, а поле y меньше у левого операнда.

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

Список основных перегружаемых операторов

Задачи:

Задача 1:

Реализуйте свой класс Complex для комплексных чисел, аналогично встроенной реализации complex:

Python syntax: x = SomeClass(some_input)(x)

I am trying to understand the following python snippet:

Can anyone shed some light on what is going on here?

2 Answers 2

It can be simplified to the following (assuming that the auxiliary variables y and z are not used by surrounding code):

Extending others response will try to give you a more general answer, on how Python will solve that statement

First Python’s interpreter will try solve the statement after the = and then assign it to x , so this leave us with_

In this statement there are two main elements the SomeClass instation and the call for the result instance that should be a callable)

It will solve first the left-side to determine what should be called, in the left-side We have a Class instantiation, it means that Python interpreter will call the SomeClass.__init__(. ) method with the arguments ( some_input ). This involves that if some_input is a call of a method, instantiation, formula or so itself, it will try to solve that first.

This <new_object> is the one who will be called with the arguments ( x ) and this is possible because the SomeClass can (and should in this example) be callable just with implementing the __call__ method as you would do with __init__ , as example:

note: The reference <new_object> , as it not bound with any variable, will be lost after the last statement.

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

Python – это новый язык программирования. Он был разработан в 1991 году программистом Гвидо ванн Россумом. В отличие от многих других языков, в Python все сущности являются объектами. Также язык имеет динамическую типизацию и автоматическое управление памятью. Авторы языка старались сделать его максимально удобным для разработчиков, поэтому синтаксис языка довольно минимальный. К недостаткам Python можно отнести низкую скорость работы и большое потребление памяти в отличие от компилируемых языков.

Сегодня Python занимает 3 место в рейтинге TIOBE среди самых популярных языков мира. Его используют в разных сферах: от машинного обучения и Big data до разработки игр и приложений. Благодаря простому синтаксису язык используют в процессе обучения программированию. Python позволяет сосредоточиться на изучении алгоритмов и принципов программирования, а не на изучении синтаксиса.

Принципы объектно-ориентированного программирования

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

Принципы ООП, реализованные в Python:

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

Основы ООП

Чтобы успешно писать код на Python придётся разобраться с концепцией объектно-ориентированного программирования.

Классы

Классы представляют абстрактную структуру, которая содержит в себе логику для объекта. Пример класса:

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

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

Каждый класс имеет свойства и методы. Они задаются после «:». Пример класса со свойствами:

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

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

После «:» указывается код метода.

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

Объект класса (экземпляр) – это конкретная реализация класса. В Python работать с экземплярами довольно просто. Пример:

classSomeClass(object):
defSomeMethod(self, x):
returnx*x

Для того, чтобы создать объект этого класса, нужно:

someObj = SomeClass()
y = someObj.SomeMethod(6)
print(y)

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

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

В Python есть возможность создать объект с некоторым набором параметров. Пример:

class Point(object):
Def __init__(self, x, y, z):
self.coord(x, y, z)
p1 = Point(13, 14, 15)

В этом примере мы создали класс Point, который будет хранить в себе 3 координаты. Затем, создали экземпляр этого класс p1. Этот экземпляр представляет конкретную точку с координатами 13, 14 и 15. Обратиться к этим координатам можно так: p1.coord

Динамический изменяемые классы

В отличии от многих других языков, где класс – это неизменяемая структура, в Python программист может добавлять методы в класс прямо во время его работы. Для этого используется зарезервированное слово pass. Вот так создаётся динамический класс:

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

classSomeClass(object) :
pass
def method(self, x) :
return x*x
SomeClass.square = method
someObj = SomeClass
someObj.square(5)

Результат работы программы: 25. В этом примере мы дополняем класс новым методом, который будет доступен из любых объектов.

Статические и классовые методы

Статические методы используются во многих языках программирования. Внешне они похожи на другие методы, но с одним отличием. Вызывать статические методы можно как из класса, так и из его экземпляра. Для того чтобы их создать, нужно воспользоваться специальным декоратором: @staticmethod. Пример:

classSomeClass(object) :
@staticmethod
def Hello() :
print(‘Hello’)
SomeClass.Hello() #В результате вызовется метод Hello класса SomeClass
someObj = SomeClass()
someObj.Hello() #В этой строке мы обращаемся к методу Hello, но не класса, а экземпляра

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

Ещё существуют классовые методы, которые выполняются в контексте класса. Чтобы создать классовый метод, нужно указать декоратор @classmethod. Важной особенностью таких методов является обязательный параметр-ссылка на класс – cls. Пример:

classSomeClass(object) :
@classmethod
def Hello(cls) :
print(‘Hello, класс<>’.format(cls.__name__))
SomeClass.Hello()

В результате на кран выведется «Hello, класс SomeClass». Программистам-новичкам не всегда бывает понятно применение классовых методов. Самый яркий пример использования – фабрика объектов.

Объекты и их методы

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

Жизнь объекта

Жизненный цикл объекта включат 3 этапа — создание, работа и удаление их из памяти.Всеми этапами программист может управлять. Например, от разработчика зависит, когда объект будет проинициализирован. Для этого можно использовать метод __init__ либо __new__

Пример использования инициализатора __init__ и __new__:

classSomeClass(object):
def __new__(cls):
print(‘new’)
return super(SomeClass, cls).__new__(cls)
def __init__(self):
print(‘init’)
obj = SomeClass();

В результате работы программы выведется new init.

На первый взгляд,__new__ может показаться бесполезным, но это не так. Метод полезен, например, при реализации паттерна «Одиночка». Пример реализации:

classSingleton(object):
obj = None # единственный экземпляр класса
def __new__(cls, *args, **kwargs):
if cls.obj is None:
cls.obj = object.__new__(cls, *args, **kwargs)
return cls.obj
single = Singleton()
single.attr = 42
newSingle = Singleton()
newSingle.attr # 42
newSingleissingle # true

Программист может не только создавать объекты, но и удалять их. Для этого существует метод-деструктор.
Пример с удалением объекта:

classSomeClass(object):
def __init__(self, name):
self.name = name
def __del__(self):
print(‘удаляется объект <> классаSomeClass’.format(self.name))
obj = SomeClass(«John»);
delobj

Результат работы программы: удаляется объект John класса SomeClass. Однако, часто использовать деструкторы – не очень хорошо. Python сам определяет ненужные объекты и удаляет их.

Объект в виде функции

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

class Multiplier:
def __call__(self, x, y):
return x*y
multiply = Multiplier()
multiply(19, 19) # 361
multiply.__call__(19, 19) # то же самое, что и в предыдущей строке

Имитация контейнера

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

class Collection:
def __init__(self, list):
self.list = list
collection = Collection(list)
len(collection)#в этой строке возникнет ошибка «Object of type has no len()»

Это означает, что интерпретатор Python просто не понимает, как ему считать длину. Для решения этой проблемы, был придуман метод __len__. Пример без ошибки:

class Collection:
def __init__(self, list):
self.list = list
def __len__(self):
returnlen(self.list)
collection = Collection([1, 2, 3])
len(collection) # 3

Другие специальные методы

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

Проблема с доступом к атрибутам

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

Для того чтобы разобраться с этим вопросом, рассмотрим запрос obj.field.

1. В начале, компилятор вызывает специальный метод, пусть в нашем случае это будет __getattribute__(field). В качестве параметра он принимает field
2. Затем, компилятор читает все пользовательские атрибуты, которые записаны в __dict__ .
3. Если второй шаг не дал результата, то компилятор пытается найти атрибут в obj.__class__.__slots__
4. С помощью рекурсии атрибут ищется у родительских классов в поле __dict__. Если объект имеет не одного родителя, то порядок поиска соответствующего атрибута такой же, как и порядок определения родительских классов.
5. Вызывается метод __getattr__, если он определён.
6. Если предыдущие шаги не дали никакого результата, то компилятор выбрасывает исключение: AttributeError, которое говорит он том, что нужного атрибута нет.

Если атрибут всё-таки был найден, то вызывается метод __get__, __set__ или __del__.

Принципы ООП в Python

Существует 3 основных концепции работы с ООП: инкапсуляция, наследование и полиморфизм. В разных языках они реализуются по-разному.

Инкапсуляция

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

classSomeClass(object) :
def _Hello(sefl) : #Перед именем метода стоить «_», то есть метод приватный
print(‘Hello’)
obj = SomeClass()
obj._Hello()#Метод на самом деле не приватный

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

Существует возможность полностью ограничить доступ к методу. Делается это с помощью двух нижних подчёркиваний. Пример:

classSomeClass(object) :
def __Hello(sefl) :
print(‘Hello’)
obj = SomeClass()
obj.__Hello() #метод недоступен

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

Пример работы со специальными методами:

classSomeClass():
def __init__(self, value):
self._value = value
defgetvalue(self): # получение значения атрибута
returnself._value
defsetvalue(self, value): # установка значения атрибута
self._value = value
defdelvalue(self): # удаление атрибута
delself._value
value = property(getvalue, setvalue, delvalue, «Свойство value»)

В данном примере показаны три специальных метода: setvalue–используется для присваивания значения свойству value, getvalue–используется для чтения и delvalue–деструктор, которые удаляет свойство.

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

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

Пример одиночного наследования:

classMammal():
className = ‘Mammal’
class Dog(Mammal):
species = ‘Canis lupus’
dog = Dog()
dog.className#Поле className доступно

В данном примере родительским классом является класс – Mammal, а дочерним – Dog. При этом из объекта dogмы можем вызвать поля и методы родительского класса.

Помимо одиночного, Python поддерживает и множественное наследование. Пример:

class Horse():
isHorse = True
class Donkey():
isDonkey = True
class Mule(Horse, Donkey):
mule = Mule()
mule.isHorse #Поля доступны
mule.isDonkey

Механизм наследования необходим для разделения логики между классами и повторного её использования. Например, есть класс Person, содержащий поле Age и метод Sleep. Также есть класс Pety, в котором доступны поля из Person, но Pety содержит ещё метод Work. Суть такого разделения заключена в том, что каждый человек может спать, но не каждый может работать. Петя может и спать, и работать.

Ассоциация

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

Пример композиции:

classSalary:
def __init__(self,pay):
self.pay = pay
defgetTotal(self):
return (self.pay*12)
class Employee:
def __init__(self,pay,bonus):
self.pay = pay
self.bonus = bonus
self.salary = Salary(self.pay)
defannualSalary(self):
return «Total: » + str(self.salary.getTotal() + self.bonus)
employee = Employee(100,10)
print(employee.annualSalary())

Пример агрегации:

class Salary(object):
def __init__(self, pay):
self.pay = pay
defgetTotal(self):
return (self.pay * 12)
class Employee(object):
def __init__(self, pay, bonus):
self.pay = pay
self.bonus = bonus
defannualSalary(self):
return «Total: » + str(self.pay.getTotal() + self.bonus)
salary = Salary(100)
employee = Employee(salary, 10)
print(employee.annualSalary())

Полиморфизм

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

classMammal:
defmove(self):
print(‘Двигается’)
class Hare(Mammal):
def move(self):
print(‘Прыгает’)
animal = Mammal()
animal.move() # Здесь вызывается метод move, класса Mammal
hare = Hare()
hare.move() # А здесь уже вызывается метод класса Hare

Как видно из примера, дочерний класс Hareпереопределил метод move, то есть добавил в него свою логику.
Чтобы получить доступ к методу базового класса, можно использовать зарезервированное слово super.
Пример с доступом к методу базового класса:

class Parent():
def __init__(self):
print(‘Parent init’)
def method1(self):
print(‘Parent method’)
class Child(Parent):
def __init__(self):
Parent.__init__(self)
def method1(self):
super(Child, self).method()
child = Child()
child.method1()

Несмотря на то, что в дочернем классе переопределён method1, вызовется всё равно метод базового класса.
Подобные способы – не единственные варианты реализации полиморфизма. В Python есть так называемая утиная типизация. Она позволяет классам иметь одинаковый интерфейс, но с разной реализацией. Под интерфейсом здесь понимается одинаковое название методов и полей.

Пример:

class English:
def greeting(self):
print («Hello»)
class French:
def greeting(self):
print («Bonjour»)

def intro(language):
language.greeting()
john = English()
gerard = French()
intro(john) # Hello
intro(gerard) # Bonjour

В данном примере реализованы два класса English и French. Оба они содержат метод с одинаковым названием. Также в самой программе прописан метод intro, который в качестве параметра принимает объект language. Не зависимо от типа объекта, который мы передали вintro, у переданного параметра будет вызван метод greeting. Главное, чтобы объект language содержал в себе реализацию метода с таким названием.

Множественная диспетчеризация

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

Множественная диспетчеризация доступна в Python благодаря мультиметодам. К сожалению, разработчики не добавили поддержку мультиметодов в язык, но существует большое количество библиотек, которые позволяют их использовать. Одна из таких библиотек – multimethods.py.

Метаклассы

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

Пример работы с метаклассами:

classMetaClass(type):
# выделение памяти для класса
def __new__(cls, name, bases, dict):
print(«Создание нового класса <>».format(name))
returntype.__new__(cls, name, bases, dict)
# инициализация класса
def __init__(cls, name, bases, dict):
print(«Инициализация нового класса <>».format(name))
return super(MetaClass, cls).__init__(name, bases, dict)
# порождение класса на основе метакласса
SomeClass = MetaClass(«SomeClass», (), <>)
# обычное наследование
class Child(SomeClass):
def __init__(self, param):
print(param)
# получение экземплярак ласса
obj = Child(«Hello»)

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

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

Как создать инициализатор класса someclass

Классы Python: самые основы

Использование heapq или кучи

Рассмотрите возможность использования functools.partial()

Итог: классы Python — это палка о двух концах

9. Classes¶

Classes provide a means of bundling data and functionality together. Creating a new class creates a new type of object, allowing new instances of that type to be made. Each class instance can have attributes attached to it for maintaining its state. Class instances can also have methods (defined by its class) for modifying its state.

Compared with other programming languages, Python’s class mechanism adds classes with a minimum of new syntax and semantics. It is a mixture of the class mechanisms found in C++ and Modula-3. Python classes provide all the standard features of Object Oriented Programming: the class inheritance mechanism allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation.

In C++ terminology, normally class members (including the data members) are public (except see below Private Variables ), and all member functions are virtual. As in Modula-3, there are no shorthands for referencing the object’s members from its methods: the method function is declared with an explicit first argument representing the object, which is provided implicitly by the call. As in Smalltalk, classes themselves are objects. This provides semantics for importing and renaming. Unlike C++ and Modula-3, built-in types can be used as base classes for extension by the user. Also, like in C++, most built-in operators with special syntax (arithmetic operators, subscripting etc.) can be redefined for class instances.

(Lacking universally accepted terminology to talk about classes, I will make occasional use of Smalltalk and C++ terms. I would use Modula-3 terms, since its object-oriented semantics are closer to those of Python than C++, but I expect that few readers have heard of it.)

9.1. A Word About Names and Objects¶

Objects have individuality, and multiple names (in multiple scopes) can be bound to the same object. This is known as aliasing in other languages. This is usually not appreciated on a first glance at Python, and can be safely ignored when dealing with immutable basic types (numbers, strings, tuples). However, aliasing has a possibly surprising effect on the semantics of Python code involving mutable objects such as lists, dictionaries, and most other types. This is usually used to the benefit of the program, since aliases behave like pointers in some respects. For example, passing an object is cheap since only a pointer is passed by the implementation; and if a function modifies an object passed as an argument, the caller will see the change — this eliminates the need for two different argument passing mechanisms as in Pascal.

9.2. Python Scopes and Namespaces¶

Before introducing classes, I first have to tell you something about Python’s scope rules. Class definitions play some neat tricks with namespaces, and you need to know how scopes and namespaces work to fully understand what’s going on. Incidentally, knowledge about this subject is useful for any advanced Python programmer.

Let’s begin with some definitions.

A namespace is a mapping from names to objects. Most namespaces are currently implemented as Python dictionaries, but that’s normally not noticeable in any way (except for performance), and it may change in the future. Examples of namespaces are: the set of built-in names (containing functions such as abs() , and built-in exception names); the global names in a module; and the local names in a function invocation. In a sense the set of attributes of an object also form a namespace. The important thing to know about namespaces is that there is absolutely no relation between names in different namespaces; for instance, two different modules may both define a function maximize without confusion — users of the modules must prefix it with the module name.

By the way, I use the word attribute for any name following a dot — for example, in the expression z.real , real is an attribute of the object z . Strictly speaking, references to names in modules are attribute references: in the expression modname.funcname , modname is a module object and funcname is an attribute of it. In this case there happens to be a straightforward mapping between the module’s attributes and the global names defined in the module: they share the same namespace! 1

Attributes may be read-only or writable. In the latter case, assignment to attributes is possible. Module attributes are writable: you can write modname.the_answer = 42 . Writable attributes may also be deleted with the del statement. For example, del modname.the_answer will remove the attribute the_answer from the object named by modname .

Namespaces are created at different moments and have different lifetimes. The namespace containing the built-in names is created when the Python interpreter starts up, and is never deleted. The global namespace for a module is created when the module definition is read in; normally, module namespaces also last until the interpreter quits. The statements executed by the top-level invocation of the interpreter, either read from a script file or interactively, are considered part of a module called __main__ , so they have their own global namespace. (The built-in names actually also live in a module; this is called builtins .)

The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception that is not handled within the function. (Actually, forgetting would be a better way to describe what actually happens.) Of course, recursive invocations each have their own local namespace.

A scope is a textual region of a Python program where a namespace is directly accessible. “Directly accessible” here means that an unqualified reference to a name attempts to find the name in the namespace.

Although scopes are determined statically, they are used dynamically. At any time during execution, there are 3 or 4 nested scopes whose namespaces are directly accessible:

the innermost scope, which is searched first, contains the local names

the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also non-global names

the next-to-last scope contains the current module’s global names

the outermost scope (searched last) is the namespace containing built-in names

If a name is declared global, then all references and assignments go directly to the middle scope containing the module’s global names. To rebind variables found outside of the innermost scope, the nonlocal statement can be used; if not declared nonlocal, those variables are read-only (an attempt to write to such a variable will simply create a new local variable in the innermost scope, leaving the identically named outer variable unchanged).

Usually, the local scope references the local names of the (textually) current function. Outside functions, the local scope references the same namespace as the global scope: the module’s namespace. Class definitions place yet another namespace in the local scope.

It is important to realize that scopes are determined textually: the global scope of a function defined in a module is that module’s namespace, no matter from where or by what alias the function is called. On the other hand, the actual search for names is done dynamically, at run time — however, the language definition is evolving towards static name resolution, at “compile” time, so don’t rely on dynamic name resolution! (In fact, local variables are already determined statically.)

A special quirk of Python is that – if no global or nonlocal statement is in effect – assignments to names always go into the innermost scope. Assignments do not copy data — they just bind names to objects. The same is true for deletions: the statement del x removes the binding of x from the namespace referenced by the local scope. In fact, all operations that introduce new names use the local scope: in particular, import statements and function definitions bind the module or function name in the local scope.

The global statement can be used to indicate that particular variables live in the global scope and should be rebound there; the nonlocal statement indicates that particular variables live in an enclosing scope and should be rebound there.

9.2.1. Scopes and Namespaces Example¶

This is an example demonstrating how to reference the different scopes and namespaces, and how global and nonlocal affect variable binding:

The output of the example code is:

Note how the local assignment (which is default) didn’t change scope_test‘s binding of spam. The nonlocal assignment changed scope_test‘s binding of spam, and the global assignment changed the module-level binding.

You can also see that there was no previous binding for spam before the global assignment.

9.3. A First Look at Classes¶

Classes introduce a little bit of new syntax, three new object types, and some new semantics.

9.3.1. Class Definition Syntax¶

The simplest form of class definition looks like this:

Class definitions, like function definitions ( def statements) must be executed before they have any effect. (You could conceivably place a class definition in a branch of an if statement, or inside a function.)

In practice, the statements inside a class definition will usually be function definitions, but other statements are allowed, and sometimes useful — we’ll come back to this later. The function definitions inside a class normally have a peculiar form of argument list, dictated by the calling conventions for methods — again, this is explained later.

When a class definition is entered, a new namespace is created, and used as the local scope — thus, all assignments to local variables go into this new namespace. In particular, function definitions bind the name of the new function here.

When a class definition is left normally (via the end), a class object is created. This is basically a wrapper around the contents of the namespace created by the class definition; we’ll learn more about class objects in the next section. The original local scope (the one in effect just before the class definition was entered) is reinstated, and the class object is bound here to the class name given in the class definition header ( ClassName in the example).

9.3.2. Class Objects¶

Class objects support two kinds of operations: attribute references and instantiation.

Attribute references use the standard syntax used for all attribute references in Python: obj.name . Valid attribute names are all the names that were in the class’s namespace when the class object was created. So, if the class definition looked like this:

then MyClass.i and MyClass.f are valid attribute references, returning an integer and a function object, respectively. Class attributes can also be assigned to, so you can change the value of MyClass.i by assignment. __doc__ is also a valid attribute, returning the docstring belonging to the class: «A simple example class» .

Class instantiation uses function notation. Just pretend that the class object is a parameterless function that returns a new instance of the class. For example (assuming the above class):

creates a new instance of the class and assigns this object to the local variable x .

The instantiation operation (“calling” a class object) creates an empty object. Many classes like to create objects with instances customized to a specific initial state. Therefore a class may define a special method named __init__() , like this:

When a class defines an __init__() method, class instantiation automatically invokes __init__() for the newly-created class instance. So in this example, a new, initialized instance can be obtained by:

Of course, the __init__() method may have arguments for greater flexibility. In that case, arguments given to the class instantiation operator are passed on to __init__() . For example,

9.3.3. Instance Objects¶

Now what can we do with instance objects? The only operations understood by instance objects are attribute references. There are two kinds of valid attribute names: data attributes and methods.

data attributes correspond to “instance variables” in Smalltalk, and to “data members” in C++. Data attributes need not be declared; like local variables, they spring into existence when they are first assigned to. For example, if x is the instance of MyClass created above, the following piece of code will print the value 16 , without leaving a trace:

The other kind of instance attribute reference is a method. A method is a function that “belongs to” an object. (In Python, the term method is not unique to class instances: other object types can have methods as well. For example, list objects have methods called append, insert, remove, sort, and so on. However, in the following discussion, we’ll use the term method exclusively to mean methods of class instance objects, unless explicitly stated otherwise.)

Valid method names of an instance object depend on its class. By definition, all attributes of a class that are function objects define corresponding methods of its instances. So in our example, x.f is a valid method reference, since MyClass.f is a function, but x.i is not, since MyClass.i is not. But x.f is not the same thing as MyClass.f — it is a method object, not a function object.

9.3.4. Method Objects¶

Usually, a method is called right after it is bound:

In the MyClass example, this will return the string ‘hello world’ . However, it is not necessary to call a method right away: x.f is a method object, and can be stored away and called at a later time. For example:

will continue to print hello world until the end of time.

What exactly happens when a method is called? You may have noticed that x.f() was called without an argument above, even though the function definition for f() specified an argument. What happened to the argument? Surely Python raises an exception when a function that requires an argument is called without any — even if the argument isn’t actually used…

Actually, you may have guessed the answer: the special thing about methods is that the instance object is passed as the first argument of the function. In our example, the call x.f() is exactly equivalent to MyClass.f(x) . In general, calling a method with a list of n arguments is equivalent to calling the corresponding function with an argument list that is created by inserting the method’s instance object before the first argument.

If you still don’t understand how methods work, a look at the implementation can perhaps clarify matters. When a non-data attribute of an instance is referenced, the instance’s class is searched. If the name denotes a valid class attribute that is a function object, a method object is created by packing (pointers to) the instance object and the function object just found together in an abstract object: this is the method object. When the method object is called with an argument list, a new argument list is constructed from the instance object and the argument list, and the function object is called with this new argument list.

9.3.5. Class and Instance Variables¶

Generally speaking, instance variables are for data unique to each instance and class variables are for attributes and methods shared by all instances of the class:

As discussed in A Word About Names and Objects , shared data can have possibly surprising effects with involving mutable objects such as lists and dictionaries. For example, the tricks list in the following code should not be used as a class variable because just a single list would be shared by all Dog instances: