More codeblocks

Author: Raymi306

app/__main__.py

@@ -5,14 +5,15 @@
 import sys
 
 from app.codeblocks import get_func_body
-from app.pages import first_steps, first_projects, variables
+from app.pages import first_steps, first_projects, variables, classes
 from app.qa import CodeblocksTester, BuildTestFailure
 
 
 PAGE_MODULES = (
      first_steps,
      first_projects,
      variables,
+     classes,
 )
 
 OUTPUT_DIR = "dist"

app/pages/classes.py

@@ -0,0 +1,197 @@
+"""23_classes.md"""
+# pylint: disable=line-too-long
+# pylint: disable=missing-class-docstring
+# pylint: disable=missing-function-docstring
+# pylint: disable=too-few-public-methods
+# pylint: disable=unused-variable
+# pylint: disable=import-outside-toplevel
+
+
+def first_class():
+    """
+    >>> MyType = first_class()
+    >>> MyType.class_attribute
+    0
+    >>> MyType.regular_attribute
+    Traceback (most recent call last):
+        ...
+    AttributeError: type object 'MyType' has no attribute 'regular_attribute'
+    >>> instance_1 = MyType(42)
+    >>> instance_1.instance, instance_1.class_attribute
+    (1, 1)
+    >>> MyType.class_attribute
+    1
+    >>> instance_1.regular_attribute
+    42
+    >>> instance_1.regular_attribute = -700
+    >>> instance_1.regular_attribute
+    -700
+    >>> instance_2 = MyType(13)
+    >>> instance_2.instance, instance_2.class_attribute
+    (2, 2)
+    >>> instance_1.my_method()
+    Instance: 1, Regular Attribute: -700
+    >>> instance_2.regular_attribute
+    13
+    """
+    # START
+    class MyType:
+        class_attribute = 0
+        def __init__(self, arg):
+            self.regular_attribute = arg
+            MyType.class_attribute += 1
+            self.instance = MyType.class_attribute
+
+        def my_method(self):
+            print(f"Instance: {self.instance}, Regular Attribute: {self.regular_attribute}")
+    # END
+    return MyType
+
+
+def person_class():
+    """
+    >>> Person = person_class()
+    >>> person_1 = Person("Bill", 33)
+    >>> person_2 = Person(name="Jill", age=44)
+    >>> person_1.name, person_1.age
+    ('Bill', 33)
+    >>> person_2.name, person_2.age
+    ('Jill', 44)
+    >>> person_1.greet(person_2)
+    Hello, Jill, my name is Bill!
+    >>> person_1.birthday()
+    >>> person_1.age
+    34
+    """
+    # START
+    class Person:
+        def __init__(self, name, age):
+            self.name = name
+            self.age = age
+
+        def greet(self, person):
+            print(f'Hello, {person.name}, my name is {self.name}!')
+
+        def birthday(self):
+            self.age += 1
+    # END
+    return Person
+
+
+def class_dunder_eq():
+    """
+    >>> Foo = class_dunder_eq()
+    >>> f1 = Foo(13)
+    >>> f2 = Foo(42)
+    >>> f3 = Foo(13)
+    >>> f4 = f3
+    >>> f1 == f2
+    False
+    >>> f1 == f3
+    True
+    >>> f1 is f3
+    False
+    >>> f3 is f4
+    True
+    """
+    # START
+    class Foo:
+        def __init__(self, value):
+            self.value = value
+
+        def __eq__(self, other):
+            return self.value == other.value
+    # END
+    return Foo
+
+
+def callable_type():
+    """
+    >>> CallableType = callable_type()
+    >>> c = CallableType()
+    >>> c()
+    You rang?
+    """
+    # START
+    class CallableType:
+        def __call__(self):
+            print("You rang?")
+    # END
+    return CallableType
+
+
+def context_manager_type():
+    """
+    >>> ContextManagerType = context_manager_type()
+    >>> c = ContextManagerType()
+    >>> with c as bound_var:
+    ...     print(bound_var)
+    setup! here's a foo!
+    foo
+    cleanup!
+    """
+    # START
+    class ContextManagerType:
+        def __enter__(self):
+            print("setup! here's a foo!")
+            return "foo"
+        def __exit__(self, *args, **kwargs):
+            print("cleanup!")
+    # END
+    return ContextManagerType
+
+
+def enum_ints():
+    """
+    >>> StoplightColors = enum_ints()
+    >>> StoplightColors.YELLOW
+    <StoplightColors.YELLOW: 2>
+    >>> StoplightColors.YELLOW.value
+    2
+    """
+    # START
+    from enum import Enum
+
+    # The below syntax represents inheritance
+    # This means that our class StoplightColors has all of the properties
+    # of the Enum class
+    class StoplightColors(Enum):
+        # You must assign an integer to each enumerated value
+        GREEN = 1
+        YELLOW = 2
+        RED = 3
+    # END
+    return StoplightColors
+
+def enum_str():
+    """
+    >>> StoplightColors = enum_str()
+    >>> StoplightColors.GREEN
+    <StoplightColors.GREEN: 'green'>
+    >>> StoplightColors.GREEN.value
+    'green'
+    """
+    from enum import Enum
+    # START
+    # The below syntax represents multiple inheritance
+    # This gives the properties of both str and Enum to our class
+    # This may be useful if we want to retrieve a string value instead of an integer value
+    # Python 3.11 adds a StrEnum class that you can import that gives this functionality with a few extra features.
+    class StoplightColors(str, Enum):
+        GREEN = 'green'
+        YELLOW = 'yellow'
+        RED = 'red'
+    # END
+    return StoplightColors
+
+
+def dataclasses():
+    """
+    >>> dataclasses()
+    """
+    from dataclasses import dataclass
+
+    @dataclass
+    class Person:
+        name: str
+        age: int = 0

app/pages/variables.py

@@ -1,9 +1,4 @@
-from unittest.mock import patch
 # pylint: disable=line-too-long
-# pylint: disable=redefined-builtin
-
-
-NONLOCALS = ("patch",)
 
 
 def variables_assignments():
@@ -35,3 +30,161 @@ def do_something(v1, v2):
         do_something(var_1, var_2)
     # END
 
+
+def variables_underscore_as_unused():
+    """
+    >>> variables_underscore_as_unused()
+    hello
+    hello
+    hello
+    """
+    # we don't need the numbers in the range, we just want to do an action n times
+    for _ in range(3):
+        print("hello")
+
+    def returns_two():
+        return 3, 'foo'
+
+    # we do not intend to use the first element of the returned tuple
+    _, my_var = returns_two()
+
+
+def variables_scope():
+    """
+    >>> try:
+    ...     variables_scope()
+    ... except NameError:
+    ...     pass
+    2
+    """
+    var_1 = 2
+    def func_1():
+        # functions have their own scope
+        var_2 = 3
+
+    print(var_1)  # 2
+    print(var_2)  # NameError
+
+
+def variables_block_scope_good():
+    """
+    >>> variables_block_scope_good()
+    100.13
+    """
+    if True:
+        var_1 = 100.13
+    else:
+        var_1 = -33.12
+    print(var_1)  # 100.13
+
+
+def variables_block_scope_bad():
+    """
+    >>> try:
+    ...     variables_block_scope_bad()
+    ... except UnboundLocalError:
+    ...     pass
+    do something
+    """
+    if True:
+        print("do something")
+    else:
+        var_1 = True
+    print(var_1)  # UnboundLocalError
+
+
+def runtime_variable_resolution():
+    """
+    >>> runtime_variable_resolution()
+    3
+    """
+    i = 15
+    def foo():
+        print(i)
+    i = 3
+    foo()  # 3
+
+
+def variables_mutating_outer_scope():
+    """
+    >>> variables_mutating_outer_scope()
+    9.3
+    0.0
+    9.3
+    9.3
+
+    NOTE: THE LAST 9.3 IS INCORRECT.
+    Here, global should be nonlocal.
+    No pretty way to fix this.
+    """
+    var_1 = 9.3
+
+    def func_1():
+        # accessing variables from an outer scope works fine
+        print(var_1)
+
+    func_1()  # 9.3
+
+    def func_2():
+        # trying to change them will not work as expected
+        var_1 = 0.0
+        print(var_1)
+
+    func_2()  # 0.0
+    print(var_1)  # 9.3
+
+    def func_3():
+        # the global keyword here grants the ability to modify var_1
+        global var_1
+        var_1 = 'foo'
+
+    func_3()
+    print(var_1)  # 'foo'
+
+
+def variables_nonlocal():
+    """
+    >>> variables_nonlocal()
+    42
+    13
+    """
+    def outer_func():
+        var_1 = 42
+        def inner_func():
+            nonlocal var_1
+            var_1 = 13
+        print(var_1)  # 42
+        inner_func()
+        print(var_1)  # 13
+    outer_func()
+
+
+def mutable_objects_no_copy():
+    """
+    >>> mutable_objects_no_copy()
+    [1, 2, 3, 4]
+    """
+    list_1 = [1, 2, 3]
+    list_2 = list_1  # this does not copy the list
+    # both variables will reference the same list
+    list_1.append(4)
+    print(list_2)  # [1, 2, 3, 4]
+
+
+def mutable_objects_copy():
+    """
+    >>> mutable_objects_copy()
+    [1, 2, 3]
+    """
+    import copy
+    list_1 = [1, 2, 3]
+    list_2 = copy.copy(list_1)
+    list_1.append(4)
+    print(list_2)  # [1, 2, 3]
+
+    # alternatively, you may copy a list with the following syntax:
+    list_3 = list_1[:]
+
+    # dictionaries have a copy method, saving you an import
+    dict_1 = {1: 2}
+    dict_2 = dict_1.copy()