Function Parameters and Typing - Python 3 Programming Tutorial p.7

Function parameters in Python aren’t just about passing values—they’re the mechanism that lets a single function handle multiple situations, from “show the board” to “apply a move.” The core takeaway is that Python functions can require positional arguments, accept them in a specific order, or make them optional via defaults. That flexibility becomes especially useful in a game-board function, where the same routine might be called to render the board at the start of a match and later to mark a player’s chosen row and column.

The tutorial starts with a simple example: a function that takes two parameters, x and y, and returns x + y. It then demonstrates what happens when parameter types change. Adding two integers works (5 + 3 → 8), and concatenating two strings also works (e.g., “hey” + “there” becomes “heythere”). But mixing integers and strings triggers an error because Python doesn’t have a universal “+” behavior across incompatible types. This leads into Python’s dynamic typing: variables don’t carry declared types, so the program must be ready for different types at runtime. While Python allows type annotations, the enforcement of types is uncommon in everyday code; the tutorial notes that tools like Cython (referred to as “scythe on” in the transcript) can use typing information to compile Python into faster C-like code.

From there, the focus shifts to a game board function that needs parameters such as player, row, and column. When those parameters are required, calling the function without them produces a clear runtime error: Python reports missing required positional arguments and even indicates which ones. If only one argument is provided, the function still fails because it expects the full set in order. Passing values positionally works—for example, calling game_board(1, 2, 0) to represent player 1 at row 2, column 0.

However, hard-coding positional values becomes hard to read in larger programs. The tutorial shows how keyword arguments improve clarity: game_board(player=1, row=2, column=0) makes the intent obvious. It also demonstrates that keyword arguments can be mixed with positional ones (as long as the order rules are followed), and that defaults can make parameters optional. By setting defaults like player=0, row=0, and column=0, the function can be called with no arguments to simply display the board.

To avoid corrupting the board when the function is used for display-only calls, the tutorial introduces conditional logic. Instead of always writing player values into the board array, it uses a flag (such as display) or checks whether player is nonzero before applying a move. This prevents overwriting a real move at position (0,0) when the function is invoked just to render the current state.

Finally, the tutorial warns about mutating objects defined outside a function. Modifying external state can work at first, but it often leads to confusing bugs later unless mutability and data flow are handled carefully—topics saved for the next installment.