Update the type hints examples

Author: braboj

examples/A13_type_hints/01_function_annotations.py

@@ -1,12 +1,24 @@
 # Annotations for Python Functions
 # ------------------------------------------------------------------------------
-# Annotations in Python functions allow you to specify the expected types of
-# parameters and the return type of the function. This can help with code
-# readability and static type checking.
+# Annotations were introduced in Python 3.0 and allow developers to attach
+# metadata to function parameters and return values. The metadata can be of
+# any type, but it is commonly used to indicate the expected data types of
+# parameters and the return value of a function.
 #
-# There are no strict rules enforced by Python regarding these A13_type_hints,
-# but they serve as a guide for developers and can be used by tools like
-# type checkers, IDEs, and documentation 01_generators.
+# Annotations are not enforced at runtime, but they can be used by static
+# type checkers, IDEs, and documentation generators to provide better
+# support for developers. The annotations are stored in the `__annotations__`
+# attribute of the function object.
+
 
 def add(x: int, y: int) -> int:
     return x + y
+
+def sub(x: "int", y: "int") -> "int":
+    return x - y
+
+print(add.__annotations__)
+# Output: {'x': <class 'int'>, 'y': <class 'int'>, 'return': <class 'int'>}
+
+print(sub.__annotations__)
+# Output: {'x': 'int', 'y': 'int', 'return': 'int'}

examples/A13_type_hints/02_typing_module.py

@@ -0,0 +1,35 @@
+# The typing module provides support for type hints in Python.
+# ------------------------------------------------------------------------------
+# The `typing` was introduced in Python 3.5 and provides a convention on how to
+# use type hints in Python. In this regard, it provides a stricter naming
+# convention for type hints compared to simple annotations.
+#
+# The `typing` module provides a set of classes and functions that can be used
+# to define complex data types, such as lists, dictionaries, and tuples, with
+# specific types for their elements.
+
+from typing import Union, Final
+
+# Define a constant
+var: Final[int] = 100
+
+# Define a function accepting multiple types for processing data
+def process_data(data: Union[int, float, str]) -> str:
+
+    if isinstance(data, (int, float)):
+        return f"Numeric data processed: {data * 2}"
+
+    elif isinstance(data, str):
+        return f"String data processed: {data.upper()}"
+
+    else:
+        return "Unsupported data type"
+
+print(process_data(10))
+# Output: Numeric data processed: 20
+
+print(process_data(3.14))
+# Output: Numeric data processed: 6.28
+
+print(process_data("hello"))
+# Output: String data processed: HELLO