Add docs/tech_docs/Python_programming.md

docs/tech_docs/Python_programming.md

@@ -0,0 +1,160 @@
+# Advanced Python Concepts and Best Practices
+
+## Advanced OOP Features
+
+### Polymorphism and Duck Typing
+Python is known for its "duck typing" philosophy, encapsulating the idea of polymorphism. It means that an object's suitability for a task is determined by the presence of certain methods and properties, rather than the object's type itself.
+
+```python
+def quack_and_fly(thing):
+    thing.quack()
+    thing.fly()
+    # If it looks like a duck and quacks like a duck, it's a duck.
+```
+
+### Abstract Base Classes (ABCs)
+Abstract Base Classes are a form of interface checking more strict than duck typing. ABCs allow for the definition of methods that must be created within any child classes implemented from the abstract base.
+
+```python
+from abc import ABC, abstractmethod
+
+class Bird(ABC):
+    @abstractmethod
+    def fly(self):
+        pass
+
+class Duck(Bird):
+    def fly(self):
+        print("Duck flying")
+```
+
+## Decorators
+Decorators allow you to modify or enhance functions without changing their definitions. They are a powerful tool for logging, enforcing access control, instrumentation, and more.
+
+```python
+def my_decorator(func):
+    def wrapper():
+        print("Something is happening before the function is called.")
+        func()
+        print("Something is happening after the function is called.")
+    return wrapper
+
+@my_decorator
+def say_hello():
+    print("Hello!")
+```
+
+## Generators and Iterators
+Generators provide a way to create iterators in a more straightforward manner, using the `yield` statement. They are used to iterate through sequences efficiently without requiring the entire sequence to be stored in memory.
+
+```python
+def my_generator():
+    yield 1
+    yield 2
+    yield 3
+
+for value in my_generator():
+    print(value)
+```
+
+## Context Managers
+Context managers allow setup and teardown operations to be executed around a block of code. The `with` statement simplifies the management of resources such as file streams.
+
+```python
+with open('file.txt', 'w') as opened_file:
+    opened_file.write('Hello, world!')
+```
+
+## Exception Handling
+Proper exception handling is crucial for creating reliable and resilient applications. Python provides try-except-else-finally blocks for catching and handling exceptions.
+
+```python
+try:
+    # Code block where exceptions can occur
+    pass
+except ExceptionType1:
+    # Handle specific exception
+    pass
+except ExceptionType2 as e:
+    # Handle specific exception and access its information
+    pass
+else:
+    # Execute if no exceptions
+    pass
+finally:
+    # Execute no matter what
+    pass
+```
+
+## Testing
+Testing is critical for ensuring code reliability and functionality. Python's `unittest` and `pytest` frameworks facilitate the creation and management of tests.
+
+```python
+# Example using pytest
+def add(a, b):
+    return a + b
+
+def test_add():
+    assert add(2, 3) == 5
+```
+
+This guide presents a deeper dive into essential Python concepts beyond classes and data classes. Mastery of these topics will significantly enhance your Python programming skills and your ability to develop robust, efficient, and maintainable Python applications.
+
+
+Each of these topics represents a core aspect of Python programming that, when understood and applied, can greatly improve the quality and efficiency of your code. As with any skill, practice and continuous learning are key to mastery.
+---
+
+# Python Classes and Data Classes Reference Guide
+
+## Python Classes
+
+### Basic Structure
+```python
+class MyClass:
+    def __init__(self, attribute1, attribute2):
+        self.attribute1 = attribute1
+        self.attribute2 = attribute2
+
+    def method1(self):
+        # Method implementation
+        pass
+```
+
+### Key Concepts
+- **Encapsulation**: Grouping data and methods that act on the data within a single unit.
+- **Inheritance**: Creating a new class that inherits attributes and methods from an existing class.
+  ```python
+  class DerivedClass(BaseClass):
+      pass
+  ```
+- **Polymorphism**: Allowing methods to do different things based on the object it is acting upon.
+- **Abstraction**: Hiding complex implementation details and showing only the necessary features of an object.
+
+## Data Classes (Python 3.7+)
+
+### Basic Usage
+```python
+from dataclasses import dataclass
+
+@dataclass
+class MyDataClass:
+    attribute1: int
+    attribute2: float = 0.0
+```
+
+### Key Features
+- **Automatic Method Generation**: `__init__`, `__repr__`, `__eq__`, and more.
+- **Type Hints**: Mandatory for each field, improving code readability.
+- **Default Values**: Easily set defaults for fields.
+- **Immutability**: Optionally, make instances immutable by using `@dataclass(frozen=True)`.
+
+### Comparison with Standard Classes
+- Use **data classes** for simpler, data-centric models to reduce boilerplate.
+- Use **standard classes** for more complex behaviors, custom method implementations, and when OOP features like inheritance and polymorphism are needed.
+
+## Practical Tips
+- Leverage **inheritance** in standard classes to create a logical, hierarchical structure.
+- Use **data classes** for data models in applications like data processing and analysis for cleaner, more maintainable code.
+- Remember to use type hints with data classes for better static analysis and error checking.
+
+This reference guide should serve as a quick lookup for the core concepts and usage patterns of Python classes and data classes. Adjust and expand based on specific project needs and complexity.