1. Keywords:

  • Keywords are reserved words in Python that have special meanings. They cannot be used as variable names or function names.

  • Here are some common Python keywords:

    • def: Used to define functions.
    • if, else: Used for conditional statements.
    • for, while: Used for loops.
    • return: Used to return values from functions.
    • class: Used to define classes.
    • import: Used to import modules.
    • and, or, not: Used for logical operations.

  • You can find a complete list of Python keywords in the official documentation https://docs.python.org/.

2. Multiple Output:

There are several ways to achieve multiple outputs from a function in Python:

  • Returning a tuple: You can pack multiple values into a tuple and return it from the function.

Python
def calculate_area_and_perimeter(length, width):
  area = length * width
  perimeter = 2 * (length + width)
  return area, perimeter  # Returning a tuple

# Usage
result_area, result_perimeter = calculate_area_and_perimeter(5, 3)
print(f"Area: {result_area}, Perimeter: {result_perimeter}")

  • Modifying arguments (pass by reference): This approach is generally discouraged as it can lead to unexpected side effects. You directly modify the arguments passed to the function.

Python
def update_values(x, y):
  x += 10
  y *= 2

# Usage
a = 5
b = 3
update_values(a, b)
print(f"a: {a}, b: {b}")  # Values of a and b will be modified

  • Using global variables: This is also discouraged as it tightly couples functions and makes code harder to maintain. Global variables can be modified by any function in the program.

Python
area = None
perimeter = None

def calculate_area_and_perimeter(length, width):
  global area, perimeter  # Declaring global variables
  area = length * width
  perimeter = 2 * (length + width)

# Usage
calculate_area_and_perimeter(5, 3)
print(f"Area: {area}, Perimeter: {perimeter}")

3. Documentation:

  • Writing good documentation is essential for making your code understandable and maintainable, both for yourself and others.

  • Here are some ways to document your code in Python:

    • Docstrings: Triple-quoted strings (''') placed at the beginning of a function, class, or module can explain its purpose, usage, and parameters.
    • Comments: You can use comments (#) within your code to explain specific sections or logic.
    • Type hints: While not strictly enforced, you can use type annotations to specify the expected types of variables and function arguments. This can improve readability and be used by static type checkers like mypy.

Here's an example with a docstring and type hints:

Python
def calculate_area(length: float, width: float) -> float:
  """Calculates the area of a rectangle.

  Args:
      length (float): The length of the rectangle.
      width (float): The width of the rectangle.

  Returns:
      float: The area of the rectangle.
  """
  return length * width

# Usage
area = calculate_area(5.2, 3.1)