Classes and objects, part 1

Make a day16 folder for today’s files, open it in your editor, and run each script from its terminal, as on earlier days.

Since Day 2 you have used values of many types: ints, strings, lists, dictionaries, files, paths. Each type came with its own methods, such as upper() for strings and append() for lists. Today you make your own types. A game can have a Player type, a library program a Book type, a bank program a BankAccount type, each holding its own data and knowing its own operations. This is the biggest new idea since functions, and it is how most large Python programs are organized. On Day 15 you copied a two-line pattern starting with the word class to make a custom exception; by the end of today you will know what every part of that pattern means.

Imagine a small game that keeps a name and a score for each player. With what you know, you would store each player as a dictionary (Day 8) and write functions that take a player dictionary as their argument (Day 9). Read this program and look for the mistake before you look at the output:

def add_points(player, points):
    player["score"] += points


def describe(player):
    name = player["name"]
    score = player["score"]
    return f"{name}: {score} points"


ana = {"name": "Ana", "score": 0}
ben = {"name": "Ben", "scroe": 0}
add_points(ana, 5)
print(describe(ana))
add_points(ben, 3)
print(describe(ben))

Ana: 5 points
Traceback (most recent call last):
  File ".../day16/player_dicts.py", line 15, in <module>
    add_points(ben, 3)
    ~~~~~~~~~~^^^^^^^^
  File ".../day16/player_dicts.py", line 2, in add_points
    player["score"] += points
    ~~~~~~^^^^^^^^^
KeyError: 'score'

The mistake is on line 12: "scroe" instead of "score". Nothing complained when the dictionary was made, because a dictionary accepts any keys you give it. The crash came three lines later, inside a different function. In a real program the typo and the crash could be hundreds of lines apart. This design has two weaknesses:

1. Nothing guarantees the shape of the data. Every player dictionary is supposed to have a "name" and a "score", but that rule lives only in your head. Each place that makes a player can get it wrong.
2. The data and the code that works on it are separate. add_points and describe only make sense for player dictionaries, but nothing connects them. They sit loose in the file, and any dictionary at all can be passed to them.

Now think about a list. A list holds its items (data), and it also knows how to append, sort, and pop (behavior). You never pass a list to a separate append_to_list(items, value) function; the operation belongs to the list. Strings are the same:

>>> type("hello")
<class 'str'>
>>> type([3, 1, 2])
<class 'list'>
>>> word = "hello"
>>> word.upper()
'HELLO'
>>> scores = [3, 1, 2]
>>> scores.sort()
>>> scores
[1, 2, 3]

Day 2 said that “class” is Python’s word for a type, which is why type() answers <class 'str'>. A class is a definition of a new type: it says what data each value of that type holds and which methods it has. Each value made from a class is an instance of that class, also called an object of that class. "hello" is an instance of str, and [3, 1, 2] is an instance of list.

A helpful picture is a blank form. A class is like a printed form design for a library card: it has a box for a name and a box for a card number. Each filled-in card is an instance. All cards share the same design, but each holds its own name and number. The picture stops working in one place: a paper form cannot do anything, but an object also carries methods, the actions that make sense for it.

Writing your own class fixes both weaknesses from the game:

• One place, the class, says what data every player has, so every player is made the same way.
• The functions that work on players move inside the class and become methods, so they travel with the data: ana.add_points(5), just like scores.append(5).

Bundling data together with the behavior that works on it is the whole point of a class. The sections that follow build a Player class step by step.

The smallest possible class has a name and nothing else:

class Player:
    pass

• class is the keyword that starts a class definition, the way def starts a function definition.
• Player is the class’s name. Class names are written in CapWords (each word starts with a capital, no underscores), as you saw for exception names on Day 15: Player, BankAccount, TaskNumberError. That is how a reader tells a class from a function or variable, which use snake_case.
• The colon and the indented block are the class body. Like any block, it cannot be empty, so pass (Day 15) fills it for now.

Running a class definition does not make any players. It only creates the class, the way running a def line creates a function without calling it. To make an instance, call the class like a function, with parentheses. Making an instance is called instantiating the class.

class Player:
    pass


ana = Player()
ben = Player()
print(type(ana))
print(ana is ben)
ana.name = "Ana"
ana.score = 5
print(ana.name, ana.score)

<class '__main__.Player'>
False
Ana 5

So an object is something like a dictionary that you reach with dots instead of square brackets: ana.name instead of ana["name"]. But this example still has the first weakness from 16.1. Nothing says every player must have a name. Only ana got attributes:

class Player:
    pass


ana = Player()
ana.name = "Ana"
ben = Player()
print(ana.name)
print(ben.name)

Ana
Traceback (most recent call last):
  File ".../day16/missing_attribute.py", line 9, in <module>
    print(ben.name)
          ^^^^^^^^
AttributeError: 'Player' object has no attribute 'name'

An AttributeError is the object version of a KeyError: you asked an object for an attribute it does not have. (You met it on Day 7, when a dictionary had no add method.) ben was made by the same class, but nobody gave it a name. The fix is to make the class itself set up every attribute the moment an object is created, which is 16.3’s job.

class Player:
    pass


ana = Player
print(ana)
print(ana is Player)

<class '__main__.Player'>
True

class Lamp:
    pass


desk = Lamp()
hall = Lamp()
desk.on = True
hall.on = False
desk.on = not hall.on
hall.watts = 40
print(desk.on, hall.on, desk is hall)
print(hall.watts)

True False False
40

You want every Player to get a name and a score the moment it is made, without anyone remembering to add them. Python looks for a method with a special name, __init__, inside the class. If it exists, Python calls it automatically every time a new object is made, so its job is to set up the new object’s starting attributes. __init__ is called the initializer (many people also call it the constructor).

The name has two underscores on each side: _ _ i n i t _ _. Python uses names in this double-underscore form, called dunder names (short for “double underscore”), for methods it calls for you at special moments. You write them; Python decides when to run them.

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score

Take it apart:

• def __init__(...) sits inside the class body, indented under class Player:. A function defined inside a class is a method of that class.
• self is the first parameter. When Python calls __init__, it passes the brand-new object as self. Every method gets the object it is working on as its first parameter, and by convention that parameter is always named self.
• name and score are ordinary parameters (Day 9). They receive the arguments you write when you call the class.
• self.name = name creates an attribute called name on the new object and gives it the value of the parameter name. The two names are different things: self.name is an attribute that lives on the object for as long as the object exists, while name is a local variable that disappears when __init__ ends (Day 9). Using the same word for both is normal and makes the line easy to read: “this object’s name is the name I was given”.
• Attributes made this way, on one object through self, are instance attributes: each instance has its own.

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score


ana = Player("Ana", 5)
ben = Player("Ben", 0)
print(ana.name, ana.score)
print(ben.name, ben.score)

Ana 5
Ben 0

__init__ is an ordinary function in every other way, so everything from Days 9 and 10 works in it. It can have default values (Day 10), so a new player can start at 0 points without saying so. It can also run code to clean up its arguments, and it can make attributes that do not come from a parameter at all:

class Player:
    def __init__(self, name, score=0):
        self.name = name.strip().title()
        self.score = score
        self.badges = []


ana = Player("  ana ")
ben = Player("Ben", 12)
ana.badges.append("first win")
print(ana.name, ana.score, ana.badges)
print(ben.name, ben.score, ben.badges)

Ana 0 ['first win']
Ben 12 []

• Player(" ana ") leaves out score, so the default 0 is used. Line 3 stores the name after strip() and title() (Day 3), so the messy text becomes "Ana".
• Line 5 gives each player a badges list. __init__ runs once per object, so [] runs once per object, and each player gets its own list. Appending to ana.badges leaves ben.badges empty. (16.5 shows what goes wrong when a list is not made inside __init__.)

__init__ must not return a value: its job is to set up self, and calling the class gives back the object automatically.

Because __init__ has required parameters, calling the class with too few arguments fails at once, with a message that names what is missing:

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score


ben = Player("Ben")

Traceback (most recent call last):
  File ".../day16/missing_argument.py", line 7, in <module>
    ben = Player("Ben")
TypeError: Player.__init__() missing 1 required positional argument: 'score'

This is exactly what 16.1 wanted. A player without a score can no longer be made by accident, and the mistake is reported on the line that made it, not somewhere later.

class Player:
    def __init__(self, name, score):
        name = name
        score = score


ana = Player("Ana", 5)
print("Made a player")
print(ana.name)

Made a player
Traceback (most recent call last):
  File ".../day16/forgot_self.py", line 9, in <module>
    print(ana.name)
          ^^^^^^^^
AttributeError: 'Player' object has no attribute 'name'

class Pet:
    def __init__(self, name, kind="cat", age=1):
        self.name = name
        self.kind = kind
        self.age_in_months = age * 12


rex = Pet("Rex", "dog", 3)
tom = Pet("Tom")
mia = Pet("Mia", age=2)
print(rex.name, rex.kind, rex.age_in_months)
print(tom.name, tom.kind, tom.age_in_months)
print(mia.name, mia.kind, mia.age_in_months)

Rex dog 36
Tom cat 12
Mia cat 24

class Book:
    def __init__(self, title, pages):
        self.title = title
        pages = pages


novel = Book("Holes", 233)
print(novel.title)
print(novel.pages)

AttributeError: 'Book' object has no attribute 'pages'

class Book:
    def __init__(self, title, pages):
        self.title = title
        self.pages = pages


novel = Book("Holes", 233)
print(novel.title)
print(novel.pages)

Holes
233

Now for the behavior half of the bundle. The game needs to add points to a player and ask whether a player has reached a target. Instead of loose functions, define them inside the class, below __init__:

    def add_points(self, points):
        self.score += points

A method is a function defined inside a class. You have called methods since Day 3 (name.upper()); now you write them. Every method takes self as its first parameter, for the same reason as __init__: it needs to know which object to work on. Inside the method, self.score means “the score of the object this method was called on”.

class Player:
    def __init__(self, name, score=0):
        self.name = name
        self.score = score

    def add_points(self, points):
        self.score += points

    def has_won(self, target):
        return self.score >= target


ana = Player("Ana")
ben = Player("Ben")
ana.add_points(5)
ana.add_points(7)
ben.add_points(3)
print(ana.score, ana.has_won(10))
print(ben.score, ben.has_won(10))
Player.add_points(ben, 8)
print(ben.score, ben.has_won(10))

12 True
3 False
11 True

Methods can do anything a function can: take several parameters, raise exceptions (Day 15), and call other methods of the same object through self. This shopping cart guards its data and builds a receipt from another method’s answer:

class Cart:
    def __init__(self, owner):
        self.owner = owner
        self.prices = {}

    def add(self, item, price):
        if price <= 0:
            raise ValueError(f"price must be more than 0, not {price}")
        self.prices[item] = price

    def total(self):
        return sum(self.prices.values())

    def receipt(self):
        count = len(self.prices)
        return f"{self.owner}: {count} items, {self.total():.2f}"


cart = Cart("Ana")
cart.add("bread", 2.25)
cart.add("milk", 1.5)
try:
    cart.add("apples", -3)
except ValueError as error:
    print(f"Not added: {error}")
print(cart.receipt())

Not added: price must be more than 0, not -3
Ana: 2 items, 3.75

• __init__ gives each cart its own empty dictionary of prices (line 4).
• add refuses a price of 0 or less by raising a ValueError (line 8), so a bad price never gets into the dictionary. The caller decides what to do about it (lines 22 to 25), exactly as on Day 15.
• receipt calls self.total() on line 16. Inside a method, self is the object, so self.total() calls another method on the same cart. Writing just total() would fail with a NameError, because methods are not loose names in the file; they are reached through an object.
• The total is 2.25 + 1.5 = 3.75.

Protecting data like this is one of the main reasons to use methods: if every change to the prices goes through add, a negative price can never sneak in.

class Player:
    def __init__(self, name):
        self.name = name
        self.score = 0

    def add_points(points):
        self.score += points


ana = Player("Ana")
ana.add_points(5)

Traceback (most recent call last):
  File ".../day16/forgot_self_param.py", line 11, in <module>
    ana.add_points(5)
    ~~~~~~~~~~~~~~^^^
TypeError: Player.add_points() takes 1 positional argument but 2 were given

class Counter:
    def __init__(self, start=0):
        self.value = start

    def up(self, step=1):
        self.value += step
        return self.value

    def reset(self):
        self.value = 0


clicks = Counter(5)
print(clicks.up())
print(clicks.up(3))
clicks.reset()
clicks.up()
print(clicks.value)

6
9
1

Every player in the game starts with 3 lives. That number is not about any one player; it is a rule of the game, the same for all of them. Storing a copy on every player works, but then changing the rule means changing every object. A value that belongs to the whole class goes in the class body itself, outside any method:

class Player:
    max_lives = 3

A variable assigned directly in the class body is a class attribute: there is one of it, stored on the class and shared by every instance. An attribute set through self in a method is an instance attribute: each object has its own.

class Player:
    max_lives = 3

    def __init__(self, name):
        self.name = name
        self.lives = Player.max_lives


ana = Player("Ana")
ben = Player("Ben")
print(Player.max_lives, ana.max_lives, ben.max_lives)
Player.max_lives = 5
cy = Player("Cy")
print(ana.lives, cy.lives, ana.max_lives)
ana.max_lives = 9
print(ana.max_lives, ben.max_lives, Player.max_lives)

3 3 3
3 5 5
9 5 5

A class attribute is also the place for data that genuinely belongs to the class as a whole, such as how many players exist. Each __init__ updates the shared count through the class name:

class Player:
    count = 0

    def __init__(self, name):
        self.name = name
        Player.count += 1
        self.number = Player.count


ana = Player("Ana")
ben = Player("Ben")
cy = Player("Cy")
print(Player.count)
print(ana.number, ben.number, cy.number)

3
1 2 3

Player.count += 1 reads the shared count, adds 1, and stores it back on the class. Then self.number = Player.count gives each player its own copy of the count at the moment it was made, so ana is player 1 and cy is player 3.

class Team:
    members = []

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

    def add(self, player_name):
        self.members.append(player_name)


red = Team("Red")
blue = Team("Blue")
red.add("Ana")
blue.add("Ben")
print(red.name, red.members)
print(blue.name, blue.members)

Red ['Ana', 'Ben']
Blue ['Ana', 'Ben']

class Team:
    def __init__(self, name):
        self.name = name
        self.members = []

    def add(self, player_name):
        self.members.append(player_name)


red = Team("Red")
blue = Team("Blue")
red.add("Ana")
blue.add("Ben")
print(red.name, red.members)
print(blue.name, blue.members)

Red ['Ana']
Blue ['Ben']

class Ticket:
    sold = 0

    def __init__(self, seat):
        self.seat = seat
        self.sold += 1


first = Ticket("A1")
second = Ticket("A2")
print(first.sold, second.sold, Ticket.sold)

1 1 0

Try printing a Player from 16.3. Python does not know what a player should look like as text, so it prints the only thing it knows: the class name and where the object lives in memory. A run printed <__main__.Player object at 0x104f8a2d0>. The number after at is a memory address written in hexadecimal; it is different on every run and every computer, which is why this program checks only the parts that stay the same:

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score


ana = Player("Ana", 5)
text = str(ana)
print(text.startswith("<__main__.Player object at 0x"))
print(text.endswith(">"))

True
True

That text is useless to a user. You can tell Python how to turn your object into text with another dunder method, __str__. Whenever Python needs an object as readable text, it calls the object’s __str__ method and uses the string it returns. Three everyday things need text: print(obj), str(obj), and an f-string such as f"{obj}".

    def __str__(self):
        return f"{self.name} ({self.score} points)"

__str__ takes only self, and it must return a string. It does not print anything itself; whoever asked for the text decides what to do with it.

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __str__(self):
        return f"{self.name} ({self.score} points)"


ana = Player("Ana", 5)
print(ana)
label = str(ana)
print(label.upper())
print(f"Leader: {ana}!")

Ana (5 points)
ANA (5 POINTS)
Leader: Ana (5 points)!

A good __str__ gives the information a user would want to see, in a short, natural form. It is the object’s answer to “describe yourself to a person”.

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __str__(self):
        print(f"{self.name} ({self.score} points)")


ana = Player("Ana", 5)
print(ana)

Ana (5 points)
Traceback (most recent call last):
  File ".../day16/str_prints.py", line 11, in <module>
    print(ana)
    ~~~~~^^^^^
TypeError: __str__ returned non-string (type NoneType)

class Score:
    def __init__(self, team, points):
        self.team = team
        self.points = points

    def __str__(self):
        return f"{self.team}: {self.points}"


home = Score("Lions", 2)
print(home)
home.points += 1
message = f"Now {home}"
print(message)
print(len(str(home)))

Lions: 2
Now Lions: 3
8

__str__ fixes print(ana). But put players in a list and print the list, and the addresses come back:

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __str__(self):
        return f"{self.name} ({self.score} points)"


ana = Player("Ana", 5)
ben = Player("Ben", 0)
print(ana)
listed = str([ana, ben])
print(listed.startswith("[<__main__.Player object at 0x"))

Ana (5 points)
True

The list printed as [<__main__.Player object at 0x...>, <__main__.Player object at 0x...>], which lines 13 and 14 check. The reason goes back to Day 3. There, the REPL showed a string with quotes ('Ana') while print showed it without. Python has two text forms for every value:

• The str form, for a user: readable, no extra detail. print and str() use it.
• The repr form, for a programmer: as unambiguous as possible, ideally looking like the code that makes the value. The REPL uses it when it shows a result, and the built-in function repr() gives it to you directly.

>>> name = "Ana"
>>> print(name)
Ana
>>> print(repr(name))
'Ana'
>>> name
'Ana'
>>> print(f"Hi {name}! Hi {name!r}!")
Hi Ana! Hi 'Ana'!

print(repr(name)) shows the quotes, because the repr form of a string is the way you would type it. In an f-string, adding !r after the expression inside the braces asks for the repr form instead of the str form.

When you print a list, the list is turned into text with str, but the list builds that text from the repr of each item. That is why Day 6’s lists showed strings with quotes, ['milk', 'eggs']: the quotes tell you '15' from 15. A player’s repr is what print showed above, because you have only written __str__. To control the repr form, define __repr__:

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def __str__(self):
        return f"{self.name} ({self.score} points)"

    def __repr__(self):
        return f"Player({self.name!r}, {self.score})"


ana = Player("Ana", 5)
ben = Player("Ben", 0)
print(ana)
print(repr(ana))
print([ana, ben])
print(f"{ana} and {ben!r}")

Ana (5 points)
Player('Ana', 5)
[Player('Ana', 5), Player('Ben', 0)]
Ana (5 points) and Player('Ben', 0)

If a class has __repr__ but no __str__, Python uses __repr__ for both forms. So when you write only one, write __repr__; it covers print as well. This REPL session defines a class with only __repr__:

>>> class Player:
...     def __init__(self, name, score):
...         self.name = name
...         self.score = score
...     def __repr__(self):
...         return f"Player({self.name!r}, {self.score})"
...
>>> ana = Player("Ana", 5)
>>> ana
Player('Ana', 5)
>>> print(ana)
Player('Ana', 5)
>>> Player("Ana", 5).score
5

Typing ana at the prompt shows the repr form, and print(ana) falls back to it as well.

class Song:
    def __init__(self, title, plays):
        self.title = title
        self.plays = plays

    def __str__(self):
        return f"{self.title} ({self.plays} plays)"

    def __repr__(self):
        return f"Song({self.title!r}, {self.plays})"


hits = [Song("Echo", 12), Song("Glow", 7)]
print(hits[0])
print(hits)

Echo (12 plays)
[Song('Echo', 12), Song('Glow', 7)]

On Day 6 you learned that b = a does not copy a list; it gives the same list a second name. Your own objects follow exactly the same rule, because every value in Python is an object and every name refers to one (Day 4). A name never contains a player. It refers to one, the way a contact in your phone refers to a person. Two contacts can point to the same person.

class Player:
    def __init__(self, name, score=0):
        self.name = name
        self.score = score

    def add_points(self, points):
        self.score += points


def reward(player):
    player.add_points(10)


ana = Player("Ana", 5)
leader = ana
leader.add_points(3)
print(ana.score, leader is ana)
reward(ana)
print(ana.score, leader.score)

8 True
18 18

Now the other side of the question. Make a second player with the same name and score. Are the two equal?

class Player:
    def __init__(self, name, score):
        self.name = name
        self.score = score


ana = Player("Ana", 5)
twin = Player("Ana", 5)
leader = ana
print(leader is ana, leader == ana)
print(twin is ana, twin == ana)
print(twin.name == ana.name and twin.score == ana.score)

True True
False False
True

• Line 10: leader and ana are one object, so both is and == are True.
• Line 11: twin and ana hold the same data, yet twin == ana is False. For your own classes, == does not compare attributes. Unless you teach it otherwise, == on two objects of your class means the same as is: “are these the same object?” Python cannot guess which attributes matter for equality. (Do two players with the same name but different scores count as equal?) Day 17 shows how to define equality with another dunder method.
• Line 12: to compare the data today, compare the attributes yourself.

This is the difference from built-in types, where Day 4’s rule held: == compares contents. For a class you write, == starts out as identity.

class Player:
    def __init__(self, name, score=0):
        self.name = name
        self.score = score


guest = Player("Guest")
team = []
for _ in range(3):
    team.append(guest)
team[0].score += 5
for player in team:
    print(player.name, player.score)

Guest 5
Guest 5
Guest 5

class Player:
    def __init__(self, name, score=0):
        self.name = name
        self.score = score


team = []
for number in range(1, 4):
    team.append(Player(f"Guest {number}"))
team[0].score += 5
for player in team:
    print(player.name, player.score)

Guest 1 5
Guest 2 0
Guest 3 0

class Box:
    def __init__(self, label):
        self.label = label
        self.items = []


def pack(box, item):
    box.items.append(item)


a = Box("toys")
b = a
c = Box("toys")
pack(b, "ball")
pack(c, "kite")
print(a.items, c.items)
print(a is b, a == c, a.label == c.label)

['ball'] ['kite']
True False True

A school library tracks which books are out. Each book is an object that knows its title, its author, and who has borrowed it, and it refuses to be checked out twice. A list of a member’s loans holds references to the same book objects that sit in the shelf list.

class LoanError(Exception):
    pass


class Book:
    loan_days = 14

    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.borrower = None

    def check_out(self, member):
        if self.borrower is not None:
            raise LoanError(f"{self.title} is already out with {self.borrower}")
        self.borrower = member

    def give_back(self):
        self.borrower = None

    def __str__(self):
        if self.borrower is None:
            status = "on the shelf"
        else:
            status = f"out with {self.borrower}"
        return f"{self.title} by {self.author}: {status}"

    def __repr__(self):
        return f"Book({self.title!r}, {self.author!r})"


shelf = [
    Book("Holes", "Louis Sachar"),
    Book("Wonder", "R. J. Palacio"),
    Book("Matilda", "Roald Dahl"),
]
ana_loans = [shelf[0], shelf[2]]
for book in ana_loans:
    book.check_out("Ana")

try:
    shelf[0].check_out("Ben")
except LoanError as error:
    print(f"Sorry: {error}")

for book in shelf:
    print(book)
print(ana_loans)
print(f"Loans last {Book.loan_days} days.")
shelf[2].give_back()
print(ana_loans[1], ana_loans[1] is shelf[2])

Sorry: Holes is already out with Ana
Holes by Louis Sachar: out with Ana
Wonder by R. J. Palacio: on the shelf
Matilda by Roald Dahl: out with Ana
[Book('Holes', 'Louis Sachar'), Book('Matilda', 'Roald Dahl')]
Loans last 14 days.
Matilda by Roald Dahl: on the shelf True

Look at what the class bought you. Every book is made the same way. The rule “a book cannot be out twice” lives in one method, so no part of the program can break it by accident. And the rest of the program reads like a description of a library: book.check_out("Ana"), print(book).

Errors in class code can be confusing, because Python counts the hidden self argument and reports some mistakes far from their cause. Use this table to go from a message to its usual cause.

The fourth row is easy to fall into, because a misspelled __init__ is not an error by itself: Python just sees an ordinary method with an odd name. The class then has no initializer, so it accepts no arguments:

class Player:
    def __int__(self, name, score):
        self.name = name
        self.score = score


ana = Player("Ana", 5)

Traceback (most recent call last):
  File ".../day16/init_typo.py", line 7, in <module>
    ana = Player("Ana", 5)
TypeError: Player() takes no arguments

You saw this exact message on Day 15, when a custom exception class was missing (Exception). Now you know why: a class with no __init__ of its own accepts no arguments. Older versions of Python may word these messages a little differently.

• A class defines a new type that bundles data with the behavior that works on it. Calling the class makes a new instance (object) each time; built-in types such as str and list are classes too.
• __init__(self, ...) runs automatically for every new object and sets up its instance attributes with self.name = name, so every object starts with the same attributes.
• A method is a function inside a class whose first parameter is self; obj.method(args) passes obj as self. Methods read and change the object’s attributes, raise exceptions to protect its data, and call each other through self.
• Class attributes in the class body are shared by every instance; reading through an object falls back to the class, but assigning through an object makes an instance attribute. Make changeable lists in __init__.
• __str__ returns readable text for users (print, str(), f-strings); __repr__ returns code-like text for programmers (the REPL, repr(), items in a list).
• Names hold references: assignment and arguments never copy an object. is asks “same object?”, and for your own classes == asks the same until you define equality.

Do these in your day16 folder. Type each program yourself, run it, and only then open the answer.

class BankAccount:
    def __init__(self, owner, balance=0):
        if balance < 0:
            raise ValueError(f"opening balance cannot be negative, not {balance}")
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError(f"deposit must be more than 0, not {amount}")
        self.balance += amount

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError(f"withdrawal must be more than 0, not {amount}")
        if amount > self.balance:
            raise ValueError(f"only {self.balance:.2f} available, not {amount:.2f}")
        self.balance -= amount


account = BankAccount("Ana", 50)
account.deposit(25.5)
account.withdraw(30)
print(f"Balance: {account.balance:.2f}")
for amount in [100, -5]:
    try:
        account.withdraw(amount)
    except ValueError as error:
        print(f"Refused: {error}")
print(f"Balance: {account.balance:.2f}")

Balance: 45.50
Refused: only 45.50 available, not 100.00
Refused: withdrawal must be more than 0, not -5
Balance: 45.50

"""The Task class for the to-do manager."""


class Task:
    """One thing to do: a title, and whether it is done yet."""

    def __init__(self, title, done=False):
        self.title = title
        self.done = done

    def complete(self):
        """Mark this task as done."""
        self.done = True

    def to_dict(self):
        """Return this task as a dictionary, ready to save as JSON."""
        return {"title": self.title, "done": self.done}


if __name__ == "__main__":
    task = Task("Test the class")
    print(task.title, task.done)
    task.complete()
    print(task.to_dict())

Test the class False
{'title': 'Test the class', 'done': True}

"""Task functions for the to-do manager. main.py imports them."""

import json

from task import Task


def show_menu():
    """Print the menu of choices."""
    print()
    print("1) Add  2) List  3) Complete  4) Delete  5) Quit")


def add_task(tasks, title):
    """Add a new, unfinished Task to the end of tasks."""
    tasks.append(Task(title))


def list_tasks(tasks):
    """Print every task with its number and a check box."""
    if not tasks:
        print("No tasks yet.")
        return
    for number, task in enumerate(tasks, 1):
        mark = "x" if task.done else " "
        print(f"{number}. [{mark}] {task.title}")


def complete_task(tasks, number):
    """Mark task number (counting from 1) as done.

    Return the Task, or None if no task has that number.
    """
    if not 1 <= number <= len(tasks):
        return None
    task = tasks[number - 1]
    task.complete()
    return task


def delete_task(tasks, number):
    """Remove task number (counting from 1) from tasks.

    Return the removed Task, or None if no task has that number.
    """
    if not 1 <= number <= len(tasks):
        return None
    return tasks.pop(number - 1)


def save_tasks(tasks, path):
    """Write tasks to the JSON file at path, replacing what was there."""
    data = [task.to_dict() for task in tasks]
    with path.open("w", encoding="utf-8") as file:
        json.dump(data, file, indent=2)


def load_tasks(path):
    """Return the Tasks saved at path, or [] if there are none to load.

    A missing file means this is the first run. A file that is not valid
    JSON gets a warning, and the program starts with no tasks.
    """
    try:
        with path.open(encoding="utf-8") as file:
            data = json.load(file)
    except FileNotFoundError:
        return []
    except json.JSONDecodeError:
        print(f"Warning: {path.name} is not valid JSON, so no tasks loaded.")
        return []
    return [Task(item["title"], item["done"]) for item in data]


if __name__ == "__main__":
    test_tasks = []
    add_task(test_tasks, "Test the module")
    print(complete_task(test_tasks, 1).done)
    print(complete_task(test_tasks, 2))
    list_tasks(test_tasks)

"""The to-do manager's menu loop. Run this file to start the program."""

from pathlib import Path

from tasks import (
    add_task,
    complete_task,
    delete_task,
    list_tasks,
    load_tasks,
    save_tasks,
    show_menu,
)

SAVE_FILE = Path(__file__).parent / "tasks.json"


def main():
    """Run the menu loop until the user chooses Quit."""
    tasks = load_tasks(SAVE_FILE)
    print("To-do list manager")
    print(f"Loaded {len(tasks)} tasks from {SAVE_FILE.name}")
    while True:
        show_menu()
        choice = input("Choose 1-5: ").strip()
        if choice == "1":
            title = input("Task title: ").strip()
            if title:
                add_task(tasks, title)
                save_tasks(tasks, SAVE_FILE)
                print(f"Added: {title}")
            else:
                print("A task needs a title.")
        elif choice == "2":
            list_tasks(tasks)
        elif choice in ("3", "4"):
            try:
                number = int(input("Task number: "))
            except ValueError:
                print("Please type a task number, such as 1.")
                continue
            if choice == "3":
                task = complete_task(tasks, number)
                action = "Completed"
            else:
                task = delete_task(tasks, number)
                action = "Deleted"
            if task is None:
                print(f"There is no task {number}.")
            else:
                save_tasks(tasks, SAVE_FILE)
                print(f"{action}: {task.title}")
        elif choice == "5":
            print("Goodbye!")
            break
        else:
            print("Please choose a number from 1 to 5.")


if __name__ == "__main__":
    main()

To-do list manager
Loaded 2 tasks from tasks.json

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 2
1. [x] Return library books
2. [ ] Practice piano

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 3
Task number: two
Please type a task number, such as 1.

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 3
Task number: 2
Completed: Practice piano

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 4
Task number: 9
There is no task 9.

1) Add  2) List  3) Complete  4) Delete  5) Quit
Choose 1-5: 5
Goodbye!

class BankAccount:
    def __init__(self, owner, balance=0):
        if balance < 0:
            raise ValueError(f"opening balance cannot be negative, not {balance}")
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError(f"deposit must be more than 0, not {amount}")
        self.balance += amount

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError(f"withdrawal must be more than 0, not {amount}")
        if amount > self.balance:
            raise ValueError(f"only {self.balance:.2f} available, not {amount:.2f}")
        self.balance -= amount

    def __str__(self):
        return f"{self.owner}'s account: {self.balance:.2f}"


accounts = [BankAccount("Ana", 50), BankAccount("Ben")]
accounts[0].deposit(25.5)
accounts[1].deposit(10)
accounts[1].withdraw(2.5)
for account in accounts:
    print(account)
print(f"Most money: {max(accounts, key=lambda item: item.balance)}")

Ana's account: 75.50
Ben's account: 7.50
Most money: Ana's account: 75.50

class Task:
    def __init__(self, title, done=False):
        self.title = title
        self.done = done

    def complete(self):
        self.done = True

    def __str__(self):
        mark = "x" if self.done else " "
        return f"[{mark}] {self.title}"


tasks = [Task("Return library books"), Task("Practice piano")]
tasks[0].complete()
for number, task in enumerate(tasks, 1):
    print(f"{number}. {task}")

1. [x] Return library books
2. [ ] Practice piano

class Ticket:
    price = 8
    sold = 0

    def __init__(self, film, seats=1):
        self.film = film
        self.seats = seats
        Ticket.sold += seats

    def cost(self):
        return self.seats * self.price

    def __str__(self):
        return f"{self.seats} x {self.film} = {self.cost()}"


evening = Ticket("Up", 3)
Ticket.price = 10
matinee = Ticket("Coco")
matinee.price = 6
print(evening)
print(matinee)
print(Ticket.sold, Ticket.price)

3 x Up = 30
1 x Coco = 6
4 10

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

    def greet(self):
        return f"Hello, {name}!"


host = Greeter("Ana")
print(host.greet())

NameError: name 'name' is not defined. Did you mean: 'self.name'?

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

    def greet(self):
        return f"Hello, {self.name}!"


host = Greeter("Ana")
print(host.greet())

Hello, Ana!

class Runner:
    def __init__(self, name, time):
        self.name = name
        self.time = time

    def __repr__(self):
        return f"Runner({self.name!r}, {self.time})"


runners = [Runner("Ana", 31), Runner("Ben", 28), Runner("Cy", 35)]
ranked = sorted(runners, key=lambda runner: runner.time)
ranked[0].time -= 2
print(ranked)
print(runners)
print(ranked[0] is runners[1], ranked == runners)

[Runner('Ben', 26), Runner('Ana', 31), Runner('Cy', 35)]
[Runner('Ana', 31), Runner('Ben', 26), Runner('Cy', 35)]
True False

class LibraryCard:
    limit = 5

    def __init__(self, owner, number):
        self.owner = owner
        self.number = number
        self.borrowed = []

    def borrow(self, title):
        if len(self.borrowed) >= LibraryCard.limit:
            raise ValueError(f"{self.owner} already has {LibraryCard.limit} books")
        self.borrowed.append(title)

    def give_back(self, title):
        self.borrowed.remove(title)

    def __str__(self):
        count = len(self.borrowed)
        return f"Card {self.number} ({self.owner}): {count} of {self.limit} books"


card = LibraryCard("Ana", 1042)
card.borrow("Holes")
card.borrow("Wonder")
card.give_back("Holes")
print(card)
print(card.borrowed)

Card 1042 (Ana): 1 of 5 books
['Wonder']

The official Python Tutorial explains how classes work, including the namespaces and scopes that make self.name and plain name different, in Classes, up to and including “A First Look at Classes”. Tomorrow, Day 17, builds new classes on top of existing ones.

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can explain why a class that bundles data and behavior beats a dictionary plus loose functions. Reread
• I can define a class and make separate instances of it. Reread
• I can write __init__ with self to give every new object its starting attributes. Reread
• I can write methods and say which object becomes self in a call. Reread
• I can tell instance attributes from class attributes and predict which one a lookup finds. Reread
• I can write __str__ so print shows an object readably. Reread
• I can write __repr__ and explain when Python uses it instead of __str__. Reread
• I can predict what happens when two names refer to one object, and tell identity from equality. Reread