PythonUnderstand the concepts. Build real technical depth.

Module 1 – Python Fundamentals and Execution Model

1.1 Module Overview

Python is a high-level, dynamically typed, interpreted programming language designed for readability and developer productivity. It supports procedural, object-oriented, and functional programming paradigms.

By the end of this module, you should be able to:

• Explain Python’s execution model (source code to bytecode to PVM).
• Run Python interactively and as standalone scripts.
• Understand how Python scripts execute.
• Use type hints for function signatures.
• Understand the role and mechanics of if __name__ == "__main__":.
• Describe common real-world domains where Python excels.

1.2 What is Python?

Definition

Python is an interpreted, high-level, multi-paradigm language known for clean syntax, rich standard library support, and dynamic typing.

Where Python is used

• Web development (FastAPI, Django, Flask)
• Automation, scripting, and web scraping
• Data analysis and data engineering (Pandas, Polars)
• Machine learning, deep learning, and Generative AI (PyTorch, TensorFlow, Transformers)
• Backend APIs and microservices
• DevOps, infrastructure scripting, and cloud automation
• Desktop tools and CLI utilities

1.3 Running Python

Creating a script

# main.py
print("Hello, CodeStudio!")

Running via command line

python main.py
# or
python3 main.py

Interactive REPL

>>> 2 + 3
5
>>> name = "Sanjay"
>>> name.upper()
'SANJAY'

1.4 Anatomy of a Python Program and Type Hints

def greet(name: str) -> str:
    return f"Hello, {name}!"


if __name__ == "__main__":
    print(greet("Sanjay"))

Output

Hello, Sanjay!

Explanation

• def greet(name: str) -> str: defines a function with optional type hints.
• Type hints improve readability, static analysis (mypy), and IDE autocompletion, but are not enforced by Python at runtime.
• f"Hello, {name}!" is an f-string evaluated at runtime.

1.5 Why if __name__ == "__main__": Matters

When Python executes a file directly, the interpreter assigns "__main__" to the special built-in variable __name__. When the file is imported into another file as a module, __name__ is set to the module's filename (without .py).

Example: utils.py

# utils.py
def helper():
    print("Helper function")


if __name__ == "__main__":
    print("Running utils.py directly")

Importing in another file

import utils

utils.helper()

Output when importing

Helper function

The line "Running utils.py directly" does not print because __name__ was "utils", not "__main__".

1.6 Best Practices

• Always guard script entry points with if __name__ == "__main__":.
• Use descriptive snake_case names for functions and variables.
• Write docstrings for public functions and modules.
• Prefer Python 3.10+ syntax features.

1.7 Practice Exercises

1. Write a script that prints your name and Python runtime version.
2. Create a module with two utility functions and test direct vs imported execution.
3. Add type hints to a mathematical calculation function.
4. Experiment with the interactive Python REPL.

1.8 Module Recap

In this module, you learned:

• What Python is and why it dominates modern development.
• How Python compiles source code to bytecode executed by the PVM.
• How to execute scripts and use interactive mode.
• How type hints and entry point guards structure production-grade Python code.