Overview

1. Basic Concepts of Classes

• Classes provide a means of bundling data and functionality together.

• Creating a new class creates a new type of object.

• Objects created from that class are called instances. To use an analogy, a class is like a fish-shaped pastry mold, and the instances are the fish-shaped pastries made from it.

2. Characteristics of Python Classes

1. Python classes are a mix of mechanisms from C++ and Modula-3, designed with minimal syntax.

2. Python classes satisfy all the standard features of Object-Oriented Programming.
1. They can inherit attributes and methods from multiple parent classes.
2. A derived class can override any method of its base class(es) and can also call the method of the base class with the same name.

3. In C++ terminology, all members (attributes and methods) of a Python class are public (with some exceptions), and all member functions are virtual.
1. Python does not have keywords like private or virtual.
2. "Public" members mean that class attributes and methods can be accessed from outside the class anywhere.
3. "Virtual" member functions mean that a derived class can redefine any method of its base class.

4. The class itself is also an object, so it can be imported and renamed.

5. Unlike C++ and Modula-3, built-in types (like int, string, etc.) can be used as base classes for inheritance.

6. Like in C++, built-in operators (+, -, /, %, etc.) can be redefined for class instances.

3. Scopes and Namespaces

3.1. Names and Objects

3.2. Namespace

• The set of built-in names: containing functions like abs().

• The global names in a module.

• The local names in a function invocation.

• 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 (e.g., import module); normally, module namespaces also last until the interpreter quits.

• The local namespace for a function is created when the function is called, and deleted when the function returns or raises an exception. Of course, recursive invocations each have their own local namespace.

3.3. Attribute

3.4. Scope

• 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, contain 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.

3.5. Example

def scope_test():
    def do_local():
        spam = "local spam"

    def do_nonlocal():
        nonlocal spam
        spam = "nonlocal spam"

    def do_global():
        global spam
        spam = "global spam"

    spam = "test spam"
    do_local()
    print("After local assignment:", spam)
    do_nonlocal()
    print("After nonlocal assignment:", spam)
    do_global()
    print("After global assignment:", spam)

scope_test()
print("In global scope:", spam)

After local assignment: test spam
After nonlocal assignment: nonlocal spam
After global assignment: nonlocal spam
In global scope: global spam

4. How Classes Work

4.1. Class Definition

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

4.2. Class Objects

4.2.1. Attribute References

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

4.2.2. Instantiation

x = MyClass()

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

(3.0, -4.5)

4.3. Instance Objects

x.counter = 1
while x.counter < 10:
    x.counter = x.counter * 2
print(x.counter)
del x.counter

4.4. Method Objects

x.f()

xf = x.f
while True:
    print(xf())

1. When a non-data attribute of an instance is referenced, the instance’s class is searched.

2. 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.

3. 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.

4.5. Class and Instance Variables

class Dog:

    kind = 'canine'         # class variable shared by all instances

    def __init__(self, name):
        self.name = name    # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
'canine'
>>> e.kind                  # shared by all dogs
'canine'
>>> d.name                  # unique to d
'Fido'
>>> e.name                  # unique to e
'Buddy'

class Dog:

    tricks = []             # mistaken use of a class variable

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # unexpectedly shared by all dogs
['roll over', 'play dead']

class Dog:

    def __init__(self, name):
        self.name = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

5. Other Useful Information

class Warehouse:
   purpose = 'storage'
   region = 'west'

w1 = Warehouse()
print(w1.purpose, w1.region)
# -> storage west

w2 = Warehouse()
w2.region = 'east'
print(w2.purpose, w2.region)
# -> storage east

1. Data attributes may be referenced by methods as well as by ordinary users (clients) of an object. In other words, classes are not usable to implement pure abstract data types. In fact, nothing in Python makes it possible to enforce data hiding — it is all based upon convention. On the other hand, the Python implementation, written in C, can completely hide implementation details and control access to an object if necessary.

2. Clients should use data attributes with care — clients may mess up invariants maintained by the methods by stamping on their data attributes. So, a naming convention can solve this headache very well.

3. There is no shorthand for referencing data attributes from within methods. It always has to be referenced as self.attr. This reduces the chance of confusion between local variables and instance variables.

4. The first argument of a method is often called self. In fact, the name self has absolutely no special meaning to Python. However, not following the convention will make your code less readable to other Python programmers, and it is also conceivable that a class browser program might be written that relies upon such a convention.

5. Any function object that is a class attribute defines a method for instances of that class. It is not necessary that the function definition is textually enclosed in the class definition. You can assign a function object to a local variable, as in the example below.

# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1

    def g(self):
        return 'hello world'

    h = g

In the example above, f, g, and h are all attributes of class C that refer to function objects, and consequently they are all methods of instances of C. h is exactly equivalent to g.

6. Methods may call other methods by using method attributes of the self argument.

class Bag:
    def __init__(self):
        self.data = []

    def add(self, x):
        self.data.append(x)

    def addtwice(self, x):
        self.add(x)
        self.add(x)

7. Methods may reference global names in the same way as ordinary functions. The global scope associated with a method is the module containing its definition. (A class is never used as a global scope.) While one rarely encounters a good reason for using global data in a method, there are many legitimate uses of the global scope: for one thing, functions and modules imported into the global scope can be used by methods.

8. Each value is an object, and therefore has a class. It is stored in object.__class__.

6. Inheritance

6.1. Definition

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

class DerivedClassName(modname.BaseClassName):

6.2. Method Override

class Food:
    def __init__(self, name):
        self.name = name

    def introduce(self):
        print(f"I am {self.get_taste()} {self.name}!")

    def get_taste(self):
        return "salty"

class Apple(Food):
    def get_taste(self):
        return "sweet"


pizza = Food("pizza")
pizza.introduce()
# -> I am salty pizza!

apple = Apple("apple")
apple.introduce()   
# -> I am sweet apple!

6.3. Built-in functions

6.4. Multiple Inheritance

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

                          6
                         ---
Level 3                 | O |                  (more general)
                      /  ---  \
                     /    |    \                      |
                    /     |     \                     |
                   /      |      \                    |
                  ---    ---    ---                   |
Level 2        3 | D | 4| E |  | F | 5                |
                  ---    ---    ---                   |
                   \  \ _ /       |                   |
                    \    / \ _    |                   |
                     \  /      \  |                   |
                      ---      ---                    |
Level 1            1 | B |    | C | 2                 |
                      ---      ---                    |
                        \      /                      |
                         \    /                      \ /
                           ---
Level 0                 0 | A |                (more specialized)
                           ---

7. Private Variables

class Mapping:
    def __init__(self, iterable):
        self.items_list = []
        self.__update(iterable) ## name mangling

    def update(self, iterable):
        for item in iterable:
            self.items_list.append(item)

    __update = update   # private copy of original update() method

class MappingSubclass(Mapping):

    def update(self, keys, values):
        # provides new signature for update()
        # but does not break __init__()
        for item in zip(keys, values):
            self.items_list.append(item)

8. Odds and Ends

1. Sometimes it is useful to have a data type similar to the C “struct”, which can be done with dataclasses as shown below.

from dataclasses import dataclass

@dataclass
class Employee:
    name: str
    dept: str
    salary: int

john = Employee('john', 'computer lab', 1000)
john.dept
# -> 'computer lab'
john.salary
# -> 1000

2. In code that expects a specific data type, you can pass a class that emulates the methods of that type instead. For example, if you have a function that accepts a file object, you can define a class with read() and readline() methods and pass it a string buffer instead.

3. Instance method objects have attributes as well: m.__self__ is the instance object with the method m(), and m.__func__ is the function object corresponding to the method.

9. Iterators

for element in [1, 2, 3]:
    print(element)
for element in (1, 2, 3):
    print(element)
for key in {'one':1, 'two':2}:
    print(key)
for char in "123":
    print(char)
for line in open("myfile.txt"):
    print(line, end='')

s = 'abc'
it = iter(s)
it
# -> <str_iterator object at 0x10c90e650>
next(it)
# -> 'a'
next(it)
# -> 'b'
next(it)
# -> 'c'
next(it)
# -> Traceback (most recent call last):
# ->   File "<stdin>", line 1, in <module>
# ->     next(it)
# -> StopIteration

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

rev = Reverse('spam')
iter(rev)
# -> <__main__.Reverse object at 0x00A1DB50>
for char in rev:
    print(char)
# -> m
# -> a
# -> p
# -> s

10. Generators

def reverse(data):
    for index in range(len(data)-1, -1, -1):
        yield data[index]
        
for char in reverse('golf'):
    print(char)

f
l
o
g

• Local variables and execution state are automatically saved between calls, so you don't need to use self.data and self.index.

• Generators automatically raise StopIteration when they terminate.

11. Generator Expressions

sum(i*i for i in range(10))                 # sum of squares
# -> 285

xvec = [10, 20, 30]
yvec = [7, 5, 3]
sum(x*y for x,y in zip(xvec, yvec))         # dot product
# -> 260

unique_words = set(word for line in page  for word in line.split())

valedictorian = max((student.gpa, student.name) for student in graduates)

data = 'golf'
list(data[i] for i in range(len(data)-1, -1, -1)) # range(start, stop, step)
# -> ['f', 'l', 'o', 'g']

squares_list = [i*i for i in range(10)]

Reference

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 ...

https://docs.python.org/3.13/tutorial/classes.html#tut-object