Week 1 - Python Foundations

Python Setup

Data Types and Variables

Control Flow: Logic and Loops

Functions and Modules

Type Hints for Clearer Code

Command-Line Interface Habits

Errors and Debugging

Logging in Python

File Operations

Azure Setup and Account Access

Practice

Week 1 Gotchas & Pitfalls

Week 1 Assignment: The Data Cleaning Pipeline

Career relevance: Week 1 in the NL data job market

Week 1 Glossary

Going Further: Optional Deep Dives

Week 1 Kickoff Slides

Functions and Modules

Organizing code into functions and modules is essential for building maintainable data pipelines.

Functions Review

You learned functions in Core. Here's what's important for data engineering:

def clean_value(value: str, default: str = "") -> str:
    """Clean and normalize a string value.

    Args:
        value: The string to clean
        default: Value to return if input is empty

    Returns:
        Cleaned string, lowercase and stripped
    """
    if not value:
        return default
    return value.strip().lower()

Three things worth noticing in the example above:

• value and default are parameters in the function signature; the actual values you pass at the call site (clean_value(" HELLO ")) are called arguments. Parameter is the slot, argument is what you put in it.
• default: str = "" declares a default argument value: if the caller omits the second argument, Python uses "". Watch out for the mutable-default gotcha (Knowledge Check #4 below): never use [], {}, or set() as a default.
• The triple-quoted string under def is the docstring: Python stores it in __doc__, IDEs surface it on hover, and help(clean_value) prints it. The cheapest way to leave a note for the next reader (often future-you).

<aside> 💡 Always write docstrings. They help your future self and teammates.

</aside>

Modules

A module is simply a .py file. You can import functions from it.

# `utils.py`
def clean_value(value):
    return value.strip().lower()

# `main.py`
from utils import clean_value
print(clean_value("  HELLO  "))

The __name__ == "__main__" Pattern

This pattern relies on two dunder names (Python's convention for double-underscore identifiers) to let a file work both as a module AND as a script:

# `utils.py`
def clean_value(value):
    return value.strip().lower()

if __name__ == "__main__":
    # Only runs when executed directly
    print(clean_value("  TEST  "))

<aside> ⌨️ Hands on: Create utils.py with a function, import it in main.py.

</aside>

<aside> 🚀 Try it in the widget: https://lasse.be/simple-hyf-teach-widget/?week=1&chapter=functions_and_modules&exercise=modules_demo&lang=python

</aside>

The dunder names in the pattern above have an interesting backstory.

<aside> 🤓 Curious Geek: The __name__ == "__main__" idiom

Python files are dual-purpose by design: a .py file can be imported as a library (from utils import clean_value) or run directly as a script (python utils.py). The __name__ variable is how Python tells the file which mode it is in: set to the module's name when imported, set to the literal string "__main__" when executed directly. The idiom dates back to Python's earliest releases in the early 1990s and is unique to Python: most languages either have a dedicated main() function (C, Java, Go) or a separate "entry-point" declaration. Putting setup code under the guard means importers get the function definitions without triggering the file's smoke-test or CLI.

</aside>

You will hit this pattern again every time you write a script that should also be importable: it is a cheap way to make a file dual-purpose.

<aside> 📝 Practice: The week's Practice chapter has two exercises that lean on functions: Ex 1 (the Temperature Logger: write a "production-ready" c_to_f() with a docstring and a default) and Ex 4 (Grade Processor: refactor a 50-line script into named functions). Both run in your venv in a few minutes each.

</aside>

🧠 Knowledge Check

<aside> 🚀 Try it in the widget: Interactive Quiz: Functions and Modules

</aside>

https://lasse.be/simple-hyf-teach-widget/mcq.html?bank=week_1_ch4_functions_modules_quiz&embed=1

• 1. What is the purpose of a docstring, and what command in a Python REPL prints one?
• 2. What does the if __name__ == "__main__": block allow a single file to do, and what is __name__ set to when the file is imported?
• 3. If you have a file named utils.py with a function clean(), give two different ways to import and use it from main.py. When would you reach for each?
• 4. Why is using a mutable default argument value (e.g., def add_record(records=[]):) a footgun?
• 5. A teammate writes a 300-line script that does extract, transform, and load all in one file. What would you suggest they split into separate modules, and why?

Extra reading

• Python docs: defining functions: the canonical reference, with *args, **kwargs, and default arguments.
• Python docs: modules: how import resolves files and the __name__ == "__main__" idiom.
• PEP 257: docstring conventions: one-line vs multi-line docstrings and where to put them.
• Real Python: Defining Your Own Python Function: worked-example tutorial covering parameters, scope, and returns.

Next up: Type Hints for Clearer Code, where you turn the optional value: str annotations into a habit and meet the tooling (mypy, IDE inference) that uses them to catch bugs before your pipeline runs.

The HackYourFuture curriculum is licensed under CC BY-NC-SA 4.0 *https://hackyourfuture.net/*

Built with ❤️ by the HackYourFuture community · Thank you, contributors

Found a mistake or have a suggestion? Let us know in the feedback form.