fixed small issues after review

Author: krother

README.md

@@ -11,6 +11,6 @@ The Live Website is available at [http://www.academis.eu/advanced_python](http:/
 
 ## License
 
-© 2018 Dr. Kristian Rother (krother@academis.eu)
+© 2026 Dr. Kristian Rother (krother@academis.eu)
 
 The code is distributed under the conditions of the MIT License.

classes/class_diagram.md

@@ -1,7 +1,7 @@
 
 # Class Diagrams
 
-One of the first and most important things converting ideas and into code is to structure data.
+One of the first and most important things converting ideas into code is to structure data.
 You want to start structuring your core business data.
 In the case of a snake game, this means how the playing field, the snake and the food items are represented.
 
@@ -53,8 +53,8 @@ The Python `dataclasses` module saves you a lot of typing:
     @dataclass
     class PlayingField:
 
-        size: (int, int)
-        food: (int, int) = None
+        size: tuple[int, int]
+        food: tuple[int, int] | None = None
 
         def add_food(self, x, y):
             ...
@@ -78,7 +78,7 @@ The code is already executable:
     print(pf.size)
     print(pf.get_walls())
 
-Although our class does nothing yet, it helps to think about your desing and write other code that depends on it.
+Although our class does nothing yet, it helps to think about your design and write other code that depends on it.
 
 ----
 
@@ -94,7 +94,7 @@ There are a few differences:
 * size and food have separate x and y attributes instead of being tuples
 * the walls are represented by a list of `(int, int)` tuples
 * the `add_food()` method expects a tuple instead of two integers
-* there methods `is_wall()` and `get_walls()` are no longer there
+* the methods `is_wall()` and `get_walls()` are no longer there
 
 One could discuss a lot which design is better.
 You are better off postponing that discussion to a cleanup stage once the code is running.
@@ -121,7 +121,7 @@ Now you can use all three attributes without storing redundant data:
 
 
 More complex and difficult questions arise when planning relationships between multiple classes.
-There will be multiple working alternatives, but some may fall on your feet in the long run.
+There will be multiple working alternatives, each with their own tradeoffs.
 You may want to read more about **SOLID principles**, **Object Composition** and **Design Patterns**.
 
 ## Classes vs SQL

classes/classes.rst

@@ -24,7 +24,7 @@ Defining a class
 
 To define a class, you need to define three things:
 
--  give the class a name (in ``SnakeCase``)
+-  give the class a name in ``CamelCase``)
 -  define attributes (variables that belong to the class)
 -  define methods (functions that belong to the class)
 
@@ -43,12 +43,12 @@ Creating Objects
 ----------------
 
 To use a class, you need to create an object from it first. Objects are
-*“live versions”* of a class, the class being an idealized abstration
+*“live versions”* of a class, the class being an idealized abstraction
 (in the sense of `Platos Theory of Forms <https://en.wikipedia.org/wiki/Theory_of_forms>`__).
 If you think of **Planet** as a class, the actual planets **Earth** and **Pandalor**
 would be the objects of that class.
 
-You can create multiple objects from a class, and each objects has its
+You can create multiple objects from a class, and each object has its
 own, independent attributes. Syntactically, you can think of a class as a function that returns
 objects. (This is a gross oversimplification to what textbooks on
 classes say, but in Python it is more or less what happens).

concurrency/gauss_elim.py

@@ -2,7 +2,7 @@
 from copy import deepcopy
 import numpy as np
 
-def solve_linear(data: list[float]) -> list[float]:
+def solve_linear(data: list[list[float]]) -> list[float]:
     """solves linear equations with the Gauss Elimination method"""
     nrows = len(data)
     ncols = len(data[0])

error_handling/generate_maze_buggy.py

@@ -46,7 +46,7 @@ def generate_floor_positions(xsize: int, ysize:int) -> set[tuple[int, int]]:
     """
     positions = get_all_floor_positions(xsize, ysize)
     floors = set()
-    while positions != []:
+    while positions:
         x, y = random.choice(positions)
         neighbors = get_neighbors(x, y)
         free = [for nb in neighbors if nb in floors]

error_handling/loggers.py

@@ -6,14 +6,14 @@
 log.setLevel(logging.INFO)
 
 fmt='%(asctime)s | %(message)s'
-format = logging.Formatter(fmt, datefmt='%m/%d/%Y %I:%M:%S %p')
+formatter = logging.Formatter(fmt, datefmt='%m/%d/%Y %I:%M:%S %p')
 
 handler = logging.StreamHandler(sys.stderr)
-handler.setFormatter(format)
+handler.setFormatter(formatter)
 log.addHandler(handler)
 
 handler2 = logging.FileHandler('logfile.log', mode='w')
-handler2.setFormatter(format)
+handler2.setFormatter(formatter)
 log.addHandler(handler2)
 
 log.info('message from logger ')

exercises/exercise_logging.py

@@ -17,5 +17,5 @@ def func(*args):
     return 3 + len(args)
 
 
-print func(4, 4, 4)
+print(func(4, 4, 4))
 

functions/decorators.rst

@@ -11,7 +11,7 @@ Using built-in decorators
 -------------------------
 
 Most of the time, you will use built-in decorators. One example is
-``functools.lru_cache`` that memorizes the output of a function to save
+``functools.lru_cache`` that memoizes the output of a function to save
 time later. Let's decorate a function with it:
 
 .. code:: python3
@@ -42,7 +42,7 @@ Writing your own decorators
 ---------------------------
 
 If want to add functionality for which no decorator exists,
-e.g. printing a timestamp for every addition, you could define a new function:
+e.g. printing a timestamp for every call of ``fibonacci()``, you could define a new function:
 
 .. code:: python3
 
@@ -59,11 +59,11 @@ using a decorator:
 
    def print_timestamp(func):
        def wrapper(*args):
-           print(time.asctime())  # done before addition
-           result = func(*args)   # calls the addition function
-           ...                    # actions after addition
+           print(time.asctime())  # done before function call
+           result = func(*args)   # calls the function
+           ...                    # actions after function call
            return result
-   return wrapper
+       return wrapper
 
 
    @print_timestamp
@@ -74,7 +74,7 @@ using a decorator:
        return fibonacci(n-1) + fibonacci(n-2)
 
 You can argue that this does not simplify the code.
-Decorators pays off in bigger programs, when they are used often.
+Decorators pay off in bigger programs, when they are used several times.
 Logging function calls is a good example for using a decorator.
 
 
@@ -94,11 +94,11 @@ original one. It is useful when writing your own decorators.
    def print_timestamp(func):
        @functools.wraps(func)
        def wrapper(*args):
-           print(time.asctime())  # done before addition
-           result = func(*args)   # calls the addition function
-           ...                    # actions after addition
+           print(time.asctime())
+           result = func(*args)
+           ...
            return result
-   return wrapper
+       return wrapper
 
    @print_timestamp
    def fibonacci(n):
@@ -109,4 +109,4 @@ original one. It is useful when writing your own decorators.
 
 
    # check docstring - would not work without @wraps
-   print(help(addition))
+   print(help(fibonacci))

quality/type_annotations.py

@@ -22,6 +22,5 @@
 def calc_total_price(basket: Basket, prices: FruitPrices) -> float:
     ...
 
-
 basket = {"apple", "cantaloupe"}
 print(calc_total_price(...))

refactoring/README.md

@@ -21,7 +21,7 @@ When you are working on your first real-world Python project, the codebase is ty
 
 **Refactoring is improving the structure of code without changing its functionality.**
 
-In practice, this means thing like:
+In practice, this means things like:
 
 * remove redundant code segments
 * split long functions into shorter ones