Update docs/tech_docs/Python_programming.md

docs/tech_docs/Python_programming.md

@@ -1,3 +1,181 @@
+# Python Functions: A Comprehensive Guide
+
+Python functions are the building blocks of Python programming, enabling code reusability, organization, and modularity. This guide explores Python functions, their syntax, and how to use them effectively.
+
+## Introduction to Python Functions
+
+A function is a block of code that runs when it's called. It can accept input, produce output, and perform a specific task. Here's a basic example:
+
+```python
+# Defining a function
+def greet(name):
+    return f"Hello, {name}!"
+
+# Calling the function
+print(greet("Alice"))
+```
+
+- **Defining Functions**: Use the `def` keyword followed by the function name and parentheses.
+- **Arguments**: Functions can take arguments, which are specified within the parentheses.
+- **Returning Values**: Use the `return` statement to send back an output.
+
+## Key Concepts
+
+### Parameters vs. Arguments
+
+- **Parameters** are the variables listed inside the parentheses in the function definition.
+- **Arguments** are the values passed to the function when it is called.
+
+### Default Parameters
+
+You can assign default values to parameters, making them optional during a function call:
+
+```python
+def greet(name, greeting="Hello"):
+    return f"{greeting}, {name}!"
+
+print(greet("Alice"))  # Uses default greeting
+print(greet("Alice", "Goodbye"))  # Overrides default greeting
+```
+
+### Keyword Arguments
+
+Keyword arguments allow you to specify arguments by their names, making your function calls more readable:
+
+```python
+def describe_pet(animal_type, pet_name):
+    print(f"I have a {animal_type} named {pet_name}.")
+
+describe_pet(animal_type="hamster", pet_name="Harry")
+```
+
+### Arbitrary Arguments
+
+Sometimes you might not know how many arguments will be passed into your function. Use `*args` for arbitrary number of positional arguments and `**kwargs` for arbitrary number of keyword arguments:
+
+```python
+def make_pizza(*toppings):
+    print("Making a pizza with the following toppings:")
+    for topping in toppings:
+        print(f"- {topping}")
+
+make_pizza('pepperoni', 'mushrooms', 'green peppers')
+```
+
+## Advanced Function Features
+
+### Lambda Functions
+
+Lambda functions are small, anonymous functions defined with the `lambda` keyword. They can have any number of arguments but only one expression:
+
+```python
+multiply = lambda x, y: x * y
+print(multiply(2, 3))
+```
+
+### Function Annotations
+
+Function annotations provide a way of associating metadata with function parameters and return values:
+
+```python
+def greet(name: str) -> str:
+    return f"Hello, {name}!"
+```
+
+### Generators
+
+Functions can also be generators, which yield a sequence of values lazily, meaning they generate each value only when needed:
+
+```python
+def countdown(num):
+    while num > 0:
+        yield num
+        num -= 1
+
+for i in countdown(5):
+    print(i)
+```
+
+## Best Practices
+
+- **Descriptive Names**: Choose function names that clearly describe their purpose.
+- **Small and Focused**: Functions should do one thing and do it well.
+- **Documentation Strings**: Use docstrings to describe what your function does, its parameters, and its return value.
+
+## Conclusion
+
+Python functions are a fundamental aspect of writing clean, efficient, and reusable code. By understanding and applying the concepts in this guide, you'll be able to create more complex and modular Python applications with ease.
+
+This guide should provide you with a solid understanding of Python functions, covering their definition, usage, and some advanced features to enhance your programming skills.
+
+---
+
+# Python Dictionaries: A Guide for API Calls
+
+Python dictionaries are essential for handling data in Python, especially when working with API calls. This guide provides a concise overview of dictionaries and their use in constructing API payloads.
+
+## Introduction to Python Dictionaries
+
+Dictionaries in Python are collections of key-value pairs, allowing you to store and manage data dynamically. Here's a quick rundown:
+
+```python
+# Example of a Python dictionary
+my_dict = {
+    "key1": "value1",
+    "key2": "value2",
+    "key3": "value3",
+}
+```
+
+- **Key Characteristics**:
+  - **Unordered**: The items do not have a defined order.
+  - **Changeable**: You can add, remove, or modify items.
+  - **Indexed**: Accessed by keys, which must be unique and immutable.
+
+## Basic Operations
+
+- **Accessing Items**: `value = my_dict["key1"]`
+- **Adding Items**: `my_dict["newKey"] = "newValue"`
+- **Removing Items**: `my_dict.pop("key1")`, `del my_dict["key2"]`
+- **Looping Through**: `for key in my_dict: print(key, my_dict[key])`
+
+## Using Dictionaries for API Calls
+
+When making API calls, dictionaries are often used to construct payloads or parameters:
+
+```python
+# API payload as a dictionary
+payload = {
+    "username": "user",
+    "password": "pass",
+    "email": "email@example.com"
+}
+
+# Using requests library for API call
+import requests
+response = requests.post("https://api.example.com/users", json=payload)
+```
+
+- Dictionaries are converted to JSON or other formats suitable for web transmission.
+- This method simplifies sending structured data over HTTP requests.
+
+## Best Practices
+
+- **Key Management**: Ensure keys are descriptive and consistent.
+- **Data Validation**: Validate and sanitize data before adding it to a dictionary, especially when received from user input.
+- **Dynamic Construction**: Leverage dictionary comprehensions and dynamic insertion for creating complex payloads.
+
+## Conclusion
+
+Understanding Python dictionaries is fundamental for API interactions, providing a structured and flexible way to handle data. Their key-value nature makes them ideal for constructing API payloads, facilitating efficient data transmission over networks.
+
+Remember to follow best practices for key management and data validation to ensure secure and effective API communication.
+
+
+This guide encapsulates the essentials of Python dictionaries, focusing on their application in API calls, which should be quite handy for your learning and development tasks.
+
+---
+
 # Advanced Python Concepts and Best Practices
 
 ## Advanced OOP Features