python tutorial - Python - classes and instances (__INIT__, __CALL__, ETC.) - learn python - python programming

The following statement makes a class with no attributes attached, and in fact, it's an empty namespace object:

class Student: 
    pass

>>> Student.name = "Jack"
>>> Student.id = 20001

>>> print(Student.name)
Jack

Note that this is working even though there are no instances of the class yet.

In Python, objects are created in two steps:

However, it's very rare to actually need to implement __new()__ because Python constructs our objects for us. So, in most of the cases, we usually only implement the special method, __init()__.

class Student(object):
        '''Classes can (and should) have docstrings too, just like modules and functions'''
	def __init__(self, name, id = 20001):
		self.name = name
		self.id = id

When a method assigns to a self attribute, it creates an attribute in an instance because self refers to the instance being processed.

s = Student(args)

We can use the Student class defined above as following:

studentA = Student("Jack")
studentB = Student("Judy", 10005)

Unlike C++, the attributes of Python object are public, we can access them using the dot(.) operator:

>>>studentA.name
'Jack'
>>>studentB.id
10005

We can also assign a new value to the attribute:

>>> studentB.id = 80001
>>> studentB.id
80001

How about the object destruction?

Let's look at another example:

class Student:
        def __init__(self, id):
                self.id = id
	def setData(self, value):
		self.data = value
	def display(self):
		print(self.data)

What is self.id?

Then, let's make two instances:

>>> s1 = Student()
>>> s2 = Student()

>>> s1.setData("Jake")       # method call, self is s1
>>> s2.setData(4294967296)   # runs Student.setData(s2,4294967296)

>>> s1.display()
Jake
>>> s2.display()
4294967294
>>> 

class MyClassA:
	def setData(self,d):
		self.data = d
	def display(self):
		print(self.data)

Then, we generate instance objects:

a = MyClassA()
a2 = MyClassA()

>>> a.setData("Python")
>>> a2.setData("PyQt")
>>> a.display()
Python
>>> a2.display()
PyQt
>>> 

As we expected, we stored the value for each instance object even though we used the same method, display. The self made all the differences! It refers to instances.

Superclass is listed in parenthesis in a class header as we see the example below.

class MyClassB(MyClassA):
	def display(self):
		print('B: data = "%s"' %self.data)

MyClassB redefines the display of its superclass, and it replaces the display attribute while still inherits the setData method in MyClassA as we see below:

But for the instance of MyClassA is still using the display, previously defined in MyClassA.

>>> a2.display()
PyQt
>>> 

Here is an example of a class Rectangle with a member function returning its area.

class Rectangle(object):
	def __init__(self, w, h):
		self.width = w
		self.height = h
	def area(self):
		return self.width * self.height

	
>>> rect = Rectangle(100,20)
>>> rect.area()
2000
>>> rect.height = 30
>>> rect.area()
3000
>>> 

We could have used the following implementing setter and getter methods:

class Rectangle(object):
	def __init__(self, w, h):
		self.width = w
		self.height = h
	def getWidth(self):
		return self.width
	def getHeight(self):
		return self.height
	def setWidth(self, w):
		self.width = w
	def setHeight(self):
		self.height = h
	def area(self):
		return self.getWidth() * self.getHeight()

Object attributes are where we store our information, and most of the case the following syntax is enough:

objName.attribute           # Retrieve attribute value
objName.attribute = value   # Change attribute value

However, there are cases when more flexibility is required. For example, to validate the setter and getter methods, we may need to change the whole code like this:

class Rectangle(object):
        ...
	def getWidth(self):
		if not valid():
			raise TypeError('cannot retrieve width')
		else:
			return self.width.convert()
        ...
	def setWidth(self, w):
		if not valid(w):
			raise TypeError('cannot set width')
		else:
			self.width = convert(w)
        ...

attribute = property(fget, fset, fdel, doc)

We pass

If we go back to the earlier code, and add property(), then the code looks like this:

class Rectangle(object):
	def __init__(self, w, h):
		self.width = w
		self.height = h
	def area(self):
		return self.width * self.height
	m_area = property(area)

We can use the class as below:

>>> rect = Rectangle (33, 9)
>>> rect.width, rect.height, rect.m_area
(33, 9, 297)

The example above simply traces attribute accesses. However, properties usually do compute the value of an attribute dynamically when fetched, as the following example illustrates:

class SquareIt:
	def __init__(self, init):
		self.value = init
	def getValue(self):
		return self.value**2
	def setValue(self, v):
		self.value = v
	V = property(getValue, setValue)

>>> S1 = SquareIt(4)
>>> S1.value
4
>>> S1.V
16
>>> S1.V = 5
>>> S1.V
25
>>> S2 = SquareIt(64)
>>> S2.value
64
>>> S2.V
4096
>>> 

Again, note that the fetch computes the square of the instance's data.

So, let's add the following to our Rectangle class:

class Rectangle(object):
	def __init__(self, w, h):
		self.width = w
		self.height = h
	def area(self):
		return self.width * self.height
	def __cmp__(self, other):
		return cmp(self.area, other.area)

The __str__ is the 2nd most commonly used operator overloading in Python after __init__. The __str__ is run automatically whenever an instance is converted to its print string.

class Rectangle(object):
	def __init__(self, w, h):
		self.width = w
		self.height = h
	def area(self):
		return self.width * self.height

If we print the instance, it displays the object as a whole as shown below.

>>> r1 = Rectangle(100,20)
>>> print(r1)
<__main__.Rectangle object at 0x02B40750>

class Rectangle(object):
	def __init__(self, w, h):
		self.width = w
		self.height = h
	def area(self):
		return self.width * self.height
	def __str__(self):
		return '(Rectangle: %s, %s)' %(self.width, self.height)
	
>>> r1 = Rectangle(100,20)
>>> print(r1)
(Rectangle: 100, 20]

The difference between __str__ and __repr__ are not that obvious.

>>> class MyClass:
	def __init__(self, d):
		self.data = d
		
>>> x = MyClass('secret')
>>> print(x)
<__main__.MyClass instance at 0x027335D0>
>>> x
<__main__.MyClass instance at 0x027335D0>
>>>

>>> class MyClass:
	def __init__(self, d):
		self.data = d
	def __str__(self):
		return '[data: %s]' %self.data
	
>>> x = MyClass('secret')
>>> print(x), x
[data: secret] [data: secret]
>>> myObjects = [MyClass('A'), MyClass('B')]
>>> for obj in myObjects:
	print(obj)

[data: A]
[data: B]

But not when we use print(myObjecs). Note that the instances are in the list:

>>> print(myObjects)
[<__main__.MyClass instance at 0x02733800>, <__main__.MyClass instance at 0x027338C8>]
>>> myObjects
[<__main__.MyClass instance at 0x027338C8>, <__main__.MyClass instance at 0x027336C0>]

So, we need to define __repr__:

>>> class MyClass:
	def __init__(self, d):
		self.data = d
	def __str__(self):
		return '[str- data: %s]' %self.data
	def __repr__(self):
		return '[repr- data: %s]' %self.data 
	
>>> myObjects = [MyClass('A'), MyClass('B')]
>>> for obj in myObjects:
	print(obj)

[str- data: A]
[str- data: B]
>>> print(myObjects)
[[repr- data: A], [repr- data: B]]
>>> myObjects
[[repr- data: A], [repr- data: B]]

In his book, Learning Python, Mark Lutz summarizes as follows:

It exists so that we can change our program's behavior depending on how it was invoked. For example:

sys.argv[1] is thus the first argument we actually pass to the program.

# t.py
if __name__ == '__main__':
    import sys
    print('program: %s' %sys.argv[0])
    for arg in sys.argv[1:]:
        print('Arg: %s' %arg)

If we run it with or without any argument, we get the output below:

C:\TEST>python t.py
program: t.py

C:\TEST>python t.py A B C
program: t.py
Arg: A
Arg: B
Arg: C

The return value consists of two elements:

# option.py

import getopt, sys
 
def main():

    in_filename = 'fin'
    out_filename = 'fout'

    print('argv  : %s' %(sys.argv[1:]))

    try:
        options, remainder = getopt.getopt(sys.argv[1:], 'i:o:', ['input=', 'output='])
    except getopt.GetoptError:
        sys.exit()

    print('options  : %s' %(options))

    for opt, arg in options:
        if opt in ('-i', '--input'):
            in_filename = arg
        elif opt in ('-o', '--output'):
            out_filename = arg

    print('remainder : %s' %(remainder))

    print('input file = %s' %(in_filename))
    print('output file = %s' %(out_filename))

    return 0

if __name__ == "__main__":
    sys.exit(main())

If we run with two file long options:

$ python option.py --input=my_in_file --output=my_out_file r1 r2
argv  : ['--input=my_in_file', '--output=my_out_file', 'r1', 'r2']
options  : [('--input', 'my_in_file'), ('--output', 'my_out_file')]
remainder : ['remainer1', 'remainder2']
input file = my_in_file
output file = my_out_file

With short options:

$ python option.py -i my_in_file -o my_out_file
argv  : ['-i', 'my_in_file', '-o', 'my_out_file']
options  : [('-i', 'my_in_file'), ('-o', 'my_out_file')]
remainder : []
input file = my_in_file
output file = my_out_file

Note that the long option does not have to be fully matched:

$ python option.py --i=my_in_file --o=my_out_file
argv  : ['--i=my_in_file', '--o=my_out_file']
options  : [('--input', 'my_in_file'), ('--output', 'my_out_file')]
remainder : []
input file = my_in_file
output file = my_out_file

>>> class Called:
	def __call__(self, *args, **kwargs):
		print("I've just called:", args, kwargs)
		
>>> A = Called()
>>> A('psy', 'Gangnam', 'Style')
I've just called: ('psy', 'Gangnam', 'Style') {}
>>> A (2013, 'Sept', 16, Singer='psy', Title='Gangnam Style')
I've just called: (2013, 'Sept', 16) {'Singer': 'psy', 'Title': 'Gangnam Style'}

As another example with a little bit more mixed arguments:

>>> class classA:
	def __call__(self, *args, d=44, **kwargs):
		print(args, d, kwargs)

>>> instanceA = classA()
>>> instanceA(1)
(1,) 44 {}
>>> instanceA(1,2)     
(1, 2) 44 {}
>>> instanceA(1,2,3)
(1, 2, 3) 44 {}
>>> instanceA(1,2,3,4)
(1, 2, 3, 4) 44 {}
>>> instanceA(a=1, b=2, d=4)
() 4 {'a': 1, 'b': 2}
>>> instanceA(a=1, b=2, c=3, d=4)
() 4 {'a': 1, 'c': 3, 'b': 2}
>>> instanceA(*[1,2], **dict(c=333, d=444))
(1, 2) 444 {'c': 333}
>>> instanceA(1, *(2,), c=3, **dict(d=4))
(1, 2) 4 {'c': 3}

While the __call__ method allows us to use class instances to emulate functions as we saw in the above examples, there is another use of __call__ method: we can retain state info:

>>> class State:
	def __init__(self, state):
		self.myState = state
	def __call__(self, newInput):
		return self.myState + newInput

>>> S = State(100)
>>> S(99)
199
>>> S(77)
177
>>>