Python Tutorial for Beginners 8: Functions

Functions in Python are reusable blocks of instructions defined with `def` that can take inputs (parameters) and optionally produce outputs (return values). The core practical payoff is maintainability: once logic lives in one place, it can be called repeatedly and updated once when requirements change.

A first function can be created with `def` and a name, followed by parentheses for parameters. If the function body is intentionally empty, `pass` prevents syntax errors while leaving room to fill in later. Execution depends on calling the function: writing the function name alone refers to the function object (showing a memory location), while adding parentheses actually runs it. When a function doesn’t return anything, Python yields `None`, which shows up when the call is printed.

Adding code inside the function turns it into a tool that performs work. A simple example prints a greeting from inside the function. That leads directly to the “don’t repeat yourself” principle (DRY): instead of copying the same print statement across many lines, the program can call the same function multiple times. If a boss later changes punctuation from `!` to `.`, updating the function once updates every call site—whether there are four lines or hundreds spread across files.

The next step is returning data rather than just printing it. Using `return` makes the function call evaluate to the returned value, so the result can be assigned, printed, or fed into other operations. A helpful mental model treats a function like a black box: focus on inputs and the output it returns, not the internal mechanics. This matters because returned values behave like normal data types. For instance, if a function returns a string, string methods such as `.upper()` can be chained onto the function call result.

Parameters customize behavior. Introducing a required parameter like `greeting` forces callers to supply an argument; omitting it triggers a “missing required positional argument” error. Parameters can also have defaults, such as `name='...'`, allowing calls to succeed even when that argument isn’t provided. Defaulted parameters make functions more flexible while keeping call sites concise.

Python also enforces ordering rules: required positional arguments must come before keyword arguments. For more advanced flexibility, `*args` and `**kwargs` accept an arbitrary number of positional and keyword arguments. Inside such a function, `args` arrives as a tuple of positional values, while `kwargs` arrives as a dictionary of keyword values. The same syntax can be used in reverse when calling a function: `*` unpacks a list into positional arguments, and `**` unpacks a dictionary into keyword arguments.

To tie everything together, the tutorial walks through two small functions modeled after Python’s standard library style: `isLeap` determines whether a year is a leap year using divisibility rules, and `daysInMonth` returns the number of days in a given month, including the February leap-year exception. By running these functions with specific inputs (e.g., 2017 vs. 2020, February month=2), the logic demonstrates how arguments drive return values and how multiple functions can cooperate to produce correct results.