Classes reorganization

Author: macdems

09 Classes and Objects.md 09 Classes and Objects Basis.md09 Classes and Objects.md renamed to 09 Classes and Objects Basis.md

@@ -4,4 +4,4 @@ has_children: true
 nav_order:  9
 ---
 
-# Classes and Objects
+# Classes and Objects: Basis

09 Classes and Objects/1 A problem.md …Classes and Objects Basis/1 A problem.md09 Classes and Objects/1 A problem.md renamed to 09 Classes and Objects Basis/1 A problem.md 09 Classes and Objects/1 A problem.md renamed to 09 Classes and Objects Basis/1 A problem.md

@@ -1,5 +1,5 @@
 ---
-parent: Classes and Objects
+parent: "Classes and Objects: Basis"
 grand_parent: Programming for Modelling and Data Analysis
 nav_order:  1
 ---

…ses and objects to organize your code.md …d Objects Basis/2 Classes and objects.md09 Classes and Objects/2 Classes and objects to organize your code.md renamed to 09 Classes and Objects Basis/2 Classes and objects.md 09 Classes and Objects/2 Classes and objects to organize your code.md renamed to 09 Classes and Objects Basis/2 Classes and objects.md

@@ -1,10 +1,10 @@
 ---
-parent: Classes and Objects
+parent: "Classes and Objects: Basis"
 grand_parent: Programming for Modelling and Data Analysis
 nav_order:  2
 ---
 
-# Classes and objects to organize your code
+# Classes and objects
 
 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*).
 
@@ -81,7 +81,7 @@ class Player:
 
 
 def ask(player):
-    # This function is part on the input-output,
+    # This function is part of 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()

09 Classes and Objects Basis/3 Custom data types.md

@@ -0,0 +1,57 @@
+---
+parent: "Classes and Objects: Basis"
+grand_parent: Programming for Modelling and Data Analysis
+nav_order:  3
+---
+
+# Custom data types
+
+Looking at **objects** and **classes**, you might have noticed a similarity with **variables** and their **types**. In fact this is exactly the same. By defining a class, you create a new type and a class instance is simply a variable of this type. Built-in Python types are also classes. Notice that you have already used their methods:
+
+```python
+name = "python"
+print(name.upper())  # `upper()` is a method in `str` class
+```
+
+You may define any type you want. Consider a class defining a fraction. It should have two attributes, *nominator* (named shortly `nom`) and *denominator* (`denom`):
+
+```python
+class Fraction:
+    def __init__(self, nom, denom):
+        self.nom = nom
+        self.denom = denom
+```
+
+It is possible to perform mathematical operations on fractions, like addition, subtraction, multiplication and division. Let's define a function `mul` that takes two fractions, multiplies them, and returns a `Fraction` instance, which is their factor:
+
+```python
+def mul(a, b):
+    return Fraction(a.nom * b.nom, a.denom * b.denom)
+```
+
+Actually this function is specific for fractions only. So, in order to keep things together, it is better to make it a method in a fraction:
+
+```python
+class Fraction:
+    def __init__(self, nom, denom):
+        self.nom = nom
+        self.denom = denom
+
+    def mul(self, other):
+        return Fraction(self.nom * self.nom, self.denom * self.denom)
+```
+
+We may use this method as follows:
+
+```python
+x = Fraction(1, 2)
+y = Fraction(5, 6)
+
+z = x.mul(y)
+```
+
+The last line does not look good. Later in this course, you will learn what you can do to be able to use normal mathematical operators (`z = x * y`) for your classes.
+
+<hr/>
+
+Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

09 Classes and Objects/game21.py 09 Classes and Objects Basis/game21.py09 Classes and Objects/game21.py renamed to 09 Classes and Objects Basis/game21.py

@@ -18,8 +18,9 @@ def roll(self):
         return dice, score
 
 
-# This function is part on the input-output, so it should not be in the `Player` class
 def ask(player):
+    # This function is part of 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':

09 Classes and Objects/3 Custom data types.md

@@ -4,4 +4,4 @@ has_children: true
 nav_order:  11
 ---
 
-# Object-Oriented Programming
+# Classes and Objects: Intermediate

11 Object-Oriented Programming.md 11 Classes and Objects Intermediate.md11 Object-Oriented Programming.md renamed to 11 Classes and Objects Intermediate.md

@@ -1,30 +1,14 @@
 ---
-parent: Classes and Objects
+parent: "Classes and Objects: Intermediate"
 grand_parent: Programming for Modelling and Data Analysis
-nav_order:  4
+nav_order:  1
 ---
 
 # Special methods
 
 ## Arithmetical operations
 
-Consider a class defining a fraction. It should have two attributes, *nominator* (named shortly `nom`) and *denominator* (`denom`):
-
-```python
-class Fraction:
-    def __init__(self, nom, denom):
-        self.nom = nom
-        self.denom = denom
-```
-
-It is possible to perform mathematical operations on fractions, like addition, subtraction, multiplication and division. Let's define a function `mul` that takes two fractions, multiplies them, and returns a `Fraction` instance, which is their factor:
-
-```python
-def mul(a, b):
-    return Fraction(a.nom * b.nom, a.denom * b.denom)
-```
-
-Actually this function is specific for fractions only. So, in order to keep things together, it is better to make it a method in a fraction:
+Let's go back to our [`Fraction` class](../09%20Classes%20and%20Objects%20Basis/3%20Custom%20data%20types):
 
 ```python
 class Fraction:
@@ -36,16 +20,7 @@ class Fraction:
         return Fraction(self.nom * self.nom, self.denom * self.denom)
 ```
 
-We may use this method as follows:
-
-```python
-x = Fraction(1, 2)
-y = Fraction(5, 6)
-
-z = x.mul(y)
-```
-
-The last line does not look good. It would be much more clear if we were able to write `c = a * b`. In fact we can. Let's rename the method `mul` to `__mul__` (two underscored in the beginning and the end, like in `__init__`):
+Such formulation allows us to multiply two fractions in an ugly way `c = a.mul(b)`. It would be much more clear if we were able to write `c = a * b`. In fact we can. Let's rename the method `mul` to `__mul__` (two underscored in the beginning and the end, like in `__init__`):
 
 ```python
 class Fraction:
@@ -63,7 +38,7 @@ Now we can write:
 x = Fraction(1, 2)
 y = Fraction(5, 6)
 
-z = a * b
+z = x * y
 ```
 
 Methods with two underscores in the beginning and the end are [*special methods*](https://diveintopython3.net/special-method-names.html). Generally you never invoke them directly. For example, you never call the `__init__` method explicitly. It is automatically invoked on instance creation. `__mul__` is another such method and it is called when two objects are multiplied.
@@ -155,7 +130,7 @@ Some other special functions that are very useful are comparisons. Fractions can
 > class Fraction:
 >     def __init__(self, nom, denom):
 >         r = gcd(nom, denom)
->         self.nom = nom // r       # we use // for integer division
+>         self.nom = nom // r      # we use // for integer division
 >         self.denom = denom // r
 >
 >     def __str__(self):
@@ -167,9 +142,6 @@ Some other special functions that are very useful are comparisons. Fractions can
 >
 > Also in the constructor you can do more sanitizations, like checking if the denominator is not 0 (and raising `ValueError` in such case), making sure that the denominator is always positive (and the sign of the nominator is adjusted accordingly), etc.
 
-
-
-
 <hr/>
 
 Published under [Creative Commons Attribution-NonCommercial-ShareAlike](https://creativecommons.org/licenses/by-nc-sa/4.0/) license.

…Classes and Objects/4 Special methods.md …bjects Intermediate/1 Special methods.md09 Classes and Objects/4 Special methods.md renamed to 11 Classes and Objects Intermediate/1 Special methods.md 09 Classes and Objects/4 Special methods.md renamed to 11 Classes and Objects Intermediate/1 Special methods.md

@@ -1,7 +1,7 @@
 ---
-parent: Object-Oriented Programming
+parent: "Classes and Objects: Intermediate"
 grand_parent: Programming for Modelling and Data Analysis
-nav_order:  3
+nav_order:  2
 ---
 
 # Understanding Class Inheritance