Add basic classes and objects

Author: macdems

09 Classes and Objects.md

@@ -0,0 +1,7 @@
+---
+parent: Programming for Modelling and Data Analysis
+has_children: true
+nav_order:  9
+---
+
+# Classes and Objects

09 Classes and Objects/1 A problem.md

@@ -0,0 +1,112 @@
+---
+parent: Classes and Objects
+grand_parent: Programming for Modelling and Data Analysis
+nav_order:  1
+---
+
+# A Problem
+
+## Let's play 21
+
+Imagine a game of 21. Its rules are very simple:
+
+1. A player starts with score 0.
+2. He/she rolls a dice to increase the score. The number on the dice adds to the current score.
+3. After rolling the dice, the player may decide to end the game with the current score or roll again.
+4. The goal is to collect as high score as possible. However, if in any moment the total score exceeds 21 (i.e. becomes 22 or higher), the player immediately loses with the final score 0.
+
+Play this game with your friend. You can play in turns, changing active player after each roll, or first the first player rolls as many times as wishes, then the other one. You may also play with a larger number of players.
+
+Now implement this game in Python. Start with a version for a single player. You need to keep track of the player's current score. It is also beneficial to track whether a player is still in a game.
+
+A simple and ugly program may look like this:
+
+```python
+import random
+
+final_score = 0
+in_game = True
+
+while in_game:
+    dice = random.randint(1, 6)
+    final_score += dice
+    print(f"You roll {dice}. Your current score is {final_score}.")
+    if final_score > 21:
+        final_score = 0
+        in_game = False
+    else:
+        while True:
+            answer = input("Do you want to keep rolling? [y/n]: ").lower()
+            if answer in 'yn':
+                break
+            print("You must answer 'y' or 'n'!")
+        if answer == 'n':
+            in_game = False
+
+print(f"Your final score is {final_score}!")
+```
+
+## What is wrong with this code?
+
+The above code is simple. However, it has two significant problems. One is the lack of separation of the user interaction and logic i.e. keeping track of your score, deciding when to finish etc. (remember [Kitchen and Dining Room](../00%20Algorithms/3%20Frontend-backend)). You may somehow improve it by organizing parts of your code into functions:
+
+```python
+import random
+
+final_score = 0
+in_game = True
+
+
+def roll():
+    global final_score, in_game
+    dice = random.randint(1, 6)
+    final_score += dice
+    score = final_score
+    if score > 21:
+        final_score = 0
+        in_game = False
+    return dice, score  # this return values are used only for printing messages
+
+
+def ask():
+    while True:
+        answer = input("Do you want to keep rolling? [y/n]: ").lower()
+        if answer in 'yn':
+            break
+        print("You must answer 'y' or 'n'!")
+    return answer == 'y'
+
+
+while in_game:
+    dice, score = roll()
+    print(f"You roll {dice}. Your current score is {score}.")
+    if in_game:
+        in_game = ask()
+
+print(f"Your final score is {final_score}!")
+```
+
+The other problem... well make it a game for two or three! You need to track the score of each player and whether a particular player is still in a game. Seems not easy, doesn't it? One reason is using global variables e.g. in the `roll()` function, which are necessary to update the game state between its calls (we cannot use local variables for this purpose, as they will be lost once we leave the function).
+
+ You may keep a score and playing state of each player in lists (one for scores, second for playing states, and yet another for player names), however, it would not be very elegant solution: you will also have to pass the player number to the `roll()` function. Another possibility would be to store player data in a dictionary and pass it to the roll function:
+
+```python
+alfred = {'name': 'Alfred', 'in_game': True, 'final_score': 0}
+
+def roll(player):
+    dice = random.randint(1, 6)
+    player['final_score'] += dice
+    score = player['final_score']
+    if score > 21:
+        player['final_score'] = 0
+        player['in_game'] = False
+    return dice, score
+```
+
+This seems better, however, it is still far from elegant.
+
+**Please don't try any of these approaches!** Read the next chapter, to see how to solve the problem the right way.
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

09 Classes and Objects/2 Classes and objects to organize your code.md

@@ -0,0 +1,121 @@
+---
+parent: Classes and Objects
+grand_parent: Programming for Modelling and Data Analysis
+nav_order:  2
+---
+
+# Classes and objects to organize your code
+
+The problem described in the previous chapter can be summarized as follows: how to combine together all the variables describing each player's state and how to operate on them. Python has neat solution for this using a concept of classes and objects. Classes are general concepts of an entity, its state and what it can do (in our case this will be **a** player), while objects are specific instances of these concepts (**the** players: *Alfred*, *Beatrice*, *Charlie*).
+
+It is best illustrated in example. In Python you define a class using **`class`** keyword:
+
+```python
+class Player:
+
+    def __init__(self, name):
+        self.name = name
+        self.score = 0
+        self.in_game = True
+
+    def roll(self):
+        dice = random.randint(1, 6)
+        self.score += dice
+        score = self.score  # `score` and `self.score` are DIFFERENT THINGS
+        if score > 21:
+            self.score = 0
+            in_game = False
+        return dice, score
+```
+
+What you see above is a declaration of a class named `Player` (usually class names should start with a CapitalLetter), are two functions defined **inside a class** (in an indented block). Such functions in a class are called *methods*: I will use this term from now on. Methods in a class take one additional argument called `self`, which must be always the first argument. This argument represents a particular instance (object) we are operating on. We can use it to set and read object *attributes*, using `self.attribute_name` notation. Contrary to the local variables, the attributes are shared between the calls of the methods and may also be accessed from outside. On the other hand, unlike global variables, they can be different for different objects (i.e. we track e.g. `score` separately for *Alfred* and separately for *Beatrice*).
+
+I guess, you understand the role of the `roll` method. `__init__` is the special method name, used for initialization of objects (it will be called automatically). Here, we set the player's name to the value provided as argument `name` (this a different thing than the attribute `self.name`) and initialize the score (`self.score`) and playing status (`self.in_game`).
+
+To create particular instances of a class, we call it like a function:
+
+```python
+player1 = Player("Alfred")
+player2 = Player("Beatrice")
+```
+
+In the parenthesis we put the arguments that must be passed to the `__init__` method, **skipping the first argument `self`**.
+
+Other methods are called using notation, you have already seen: `object.method(arguments_without_self)`:
+
+```python
+player1.roll()
+player2.roll()
+```
+
+For creating objects and calling methods, all the normal rules of passing arguments by name or using default arguments are the same as for normal functions. The only difference you must remember is to skip the first `self` argument. This argument is passed automatically and contains the object before the dot (or a newly created one in case of `__init__`).
+
+You use the dot-notation, you may access not only methods, but also object attributes:
+
+```python
+print(player1.score)
+```
+
+## Two-player game
+
+Using classes and objects it is now very easy to write a two-player game:
+
+```python
+import random
+
+
+class Player:
+    def __init__(self, name):
+        self.name = name
+        self.score = 0
+        self.in_game = True
+
+    def roll(self):
+        dice = random.randint(1, 6)
+        self.score += dice
+        score = self.score  # `score` and `self.score` are DIFFERENT THINGS
+        if score > 21:
+            self.score = 0
+            self.in_game = False
+        return dice, score
+
+
+def ask(player):
+    # This function is part on the input-output,
+    # so it should not be in the `Player` class
+    while True:
+        answer = input(f"{player.name}, do you want to keep rolling? [y/n]: ").lower()
+        if answer in 'yn':
+            break
+        print("You must answer 'y' or 'n'!")
+    return answer == 'y'
+
+
+player1 = Player(input("Enter first player's name: "))
+player2 = Player(input("Enter second player's name: "))
+
+while player1.in_game or player2.in_game:
+    for player in (player1, player2):
+        if player.in_game:
+            dice, score = player.roll()
+            print(f"{player.name} roll {dice} and has total score {score}.")
+        # We check the condition again, as it might have changed in `player.roll()`
+        if player.in_game:
+            player.in_game = ask(player)
+
+print(f"{player1.name}'s final score is {player1.score}!")
+print(f"{player2.name}'s final score is {player2.score}!")
+```
+
+You may download the game code [from here](game21.py). Can you write this game to allow any number of players?
+
+## Conclusions
+
+This tutorial went through creating classes, instantiating objects, initializing attributes with the constructor method, and working with more than one object of the same class.
+
+Object-oriented programming is an important concept to understand because it makes code recycling more straightforward, as objects created for one program can be used in another. Object-oriented programs also make for better program design since complex programs are difficult to write and require careful planning, and this in turn makes it less work to maintain the program over time.
+
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.