Exercises — `self` — what it is and how Python passes it

The dot fills the first slot with rex: $\text{rex.bark(3)}\equiv \text{Dog.bark(rex, 3)}$ So inside the method: self ← rex and times ← 3. What we did: applied the single rewrite rule. Why: it removes the "magic" — there is no hidden global, only argument binding.

False. self is a naming convention, not a keyword. def bark(this, times): this.x = 1 works identically — this receives the instance. We use self only so other programmers instantly recognise it.

Rewrite each call: a.inc(2) → Counter.inc(a, 2) touches a.n; b.inc(10) → Counter.inc(b, 10) touches b.n. The bodies are the same code, but self differs, so the states never mix.

• a.n: $0\to 2\to 5$
• b.n: $0\to 10$

Output: 5 10. See Instance vs Class Attributes for why each .n lives on its own object.

Here we pass self = a by hand — no dot, no auto-injection. a.n: $0\to 4\to 10$. Output: 10. This is the proof that a.inc(x) and Counter.inc(a, x) are the same operation. See Bound and Unbound Methods.

C().greet() rewrites to C.greet(C()) — the dot still fills the first slot with the new instance. So greet receives 1 argument (the instance), but its signature accepts 0. That mismatch is the error. Fix: def greet(self): — add the slot the dot needs to fill.

Bare balance is looked up as a local variable of deposit, not as instance data. Instance attributes live on the object and are reached only through self. — see __init__ — the constructor where self.balance was created. Writing balance += amount tries to read a local that was never assigned → error. Fix:

def deposit(self, amount):
    self.balance += amount
    return self.balance

With bal=100, amount=50 this returns 150.

Each add mutates self.items then hands the same object back. So .add(20) runs on the object .add(10) returned — which is the very same Box.

• after add(10): [10]
• after add(20): [10, 20]
• after add(30): [10, 20, 30]

Output: [10, 20, 30]. Why return self: without it, add returns None, and the next .add would raise AttributeError: 'NoneType' object has no attribute 'add'.

self.n is per-instance (each object has its own); Tally.total is a class attribute, shared by all.

• t.n: $0\to 1\to 2$
• u.n: $0\to 1$
• Tally.total: $0\to 1\to 2\to 3$ (every hit bumps it)

Output: 2 1 3. This is the boundary between self (instance) and class-level state — see classmethod and staticmethod for the cls-based version.

def make_account(owner, balance):
    return {"owner": owner, "balance": balance}
 
def deposit(self, amount):          # 'self' is just our first param
    self["balance"] += amount
    return self["balance"]
 
alice = make_account("Alice", 100)
print(deposit(alice, 50))           # 150 — WE pass the object by hand

Result: 150. In a real class, alice.deposit(50) does the deposit(alice, 50) part automatically — that "handing over alice" is self. Nothing else is added.

def bind(f, obj):
    def bound(*args, **kwargs):
        return f(obj, *args, **kwargs)   # inject obj as self
    return bound
 
class Dog:
    def bark(self, times): return "woof " * times
 
rex = Dog()
my_bound = bind(Dog.bark, rex)
print(my_bound(2))          # 'woof woof '
print(rex.bark(2))          # 'woof woof '  — same thing

Both print 'woof woof '. Python's real machinery is the Descriptor Protocol: accessing rex.bark calls bark.__get__(rex, Dog), which returns exactly this kind of function + instance package (a bound method). Our bind is a hand-rolled version of that.

• rex.bark.__self__ is the rex instance — the object stored in the bound method.
• rex.bark.__func__ is the plain underlying function Dog.bark (the one whose first param is self). Calling rex.bark(2) is literally rex.bark.__func__(rex.bark.__self__, 2).

obj.method(args) ≡ Class.method(obj, args) — the dot fills the first slot with obj (that's self).

def greet(): fail when called on an instance? The dot still passes the instance, so 1 argument arrives at a 0-parameter function.

Forgetting return self; the method returns None and the next call hits NoneType.