What is a Class Factory?

All Questions From This Chapter    « Previously

explain this text from a book in layman terms (it's completely bouncing off of me):

The default class factory is type. When you write

class Dog:
    pass

Python roughly does:

Dog = type('Dog', (), {})

---

This is one of those Python lines that looks mysterious until you realize it's just showing what Python does behind the scenes.

Let's start with the code you normally write:

Python
class Dog:
    pass

Most people think this creates a class using some special Python magic.

What actually happens is that Python asks another object called type to create the class.

Behind the scenes, Python roughly does:

Python
Dog = type('Dog', (), {})

Let's decode each piece.

---

Step 1: What is type?

You've probably used it like this:

Python
x = 5
print(type(x))

Output:

Python
<class 'int'>

So it seems like type() tells you the type of an object.

But here's the twist:

Python
print(type(int))

Output:

Python
<class 'type'>

Even classes themselves are objects.

And the thing that creates classes is type.

Think of it like this:

Dog object  <-- created by -- type
Cat object  <-- created by -- type
Person object <-- created by -- type

type is the "class factory."

---

Step 2: The first argument

Python
type('Dog', (), {})

First argument:

Python
'Dog'

This is simply the class name.

Equivalent to:

Python
class Dog:
    pass

---

Step 3: The second argument

Python
()

This is a tuple containing parent classes.

Example:

Python
class Dog:
    pass

has no explicit parent class, so:

Python
()

means "no parent classes specified."

Another example:

Python
class Dog(Animal):
    pass

would roughly become:

Python
Dog = type('Dog', (Animal,), {})

Notice the tuple contains Animal.

---

Step 4: The third argument

Python
{}

This dictionary contains everything inside the class body.

Example:

Python
class Dog:
    species = "Canine"

    def bark(self):
        print("Woof")

becomes approximately:

Python
Dog = type(
    'Dog',
    (),
    {
        'species': 'Canine',
        'bark': bark
    }
)

The dictionary is basically:

attribute name -> value
method name    -> function

---

Visualizing the process

When Python sees:

Python
class Dog:
    pass

it internally thinks something like:

1. Create an empty dictionary {}
2. Put class variables and methods into it
3. Call type()
4. Store the result in Dog

So:

Python
class Dog:
    pass

is roughly:

Python
Dog = type('Dog', (), {})

---

Proof

These two are essentially equivalent:

Normal syntax

Python
class Dog:
    def bark(self):
        print("Woof")

Using type

Python
def bark(self):
    print("Woof")

Dog = type(
    'Dog',
    (),
    {'bark': bark}
)

Both work:

Python
d = Dog()
d.bark()

Output:

Python
Woof

---

The big idea

There are objects, classes, and something that creates classes.

Think of a car factory:

Factory ---> creates Cars

In Python:

type ---> creates Classes
Class ---> creates Objects

Example:

Python
Dog = type('Dog', (), {})

type
  ↓
Dog class
  ↓
Dog()
  ↓
dog object

This idea becomes important later when learning metaclasses, because a metaclass is simply a custom replacement for type that can control how classes themselves are created.

All Questions From This Chapter    « Previously