When you define a function, the names listed in the parentheses of the def line are its parameters. When you call that function, the values you supply are its arguments. Keeping those two words straight makes it far easier to read error messages, documentation, and your own code, so this topic starts there and then builds outward to the different ways arguments can be matched to parameters.
Python gives you several options. Positional arguments are matched in order, left to right, so the order you write them matters. Keyword arguments are matched by name, which makes calls more readable and lets you skip the order entirely. Default parameter values let you declare a fallback in the function definition so callers can leave some arguments out, which is how most real-world library functions offer optional behavior.
As you watch these videos, pay attention to three things: the exact rule for where positional arguments must appear relative to keyword arguments, what happens when you pass too few or too many arguments, and how a default value changes which arguments are required. Try retyping each example in your own editor and then deliberately break it — swap the order, misspell a keyword, omit a required argument — so you learn to recognize the resulting TypeError messages.
A full-length tutorial lesson devoted to function arguments in Python, part of CodeWithHarry's day-by-day Python course. Based on its length and placement in the series, it should work through how arguments are passed to functions and cover the main argument styles, including positional and keyword arguments and parameters that carry default values, with live coding examples. Expect worked demonstrations rather than a quick definition-only overview.
At nearly fourteen minutes it is the most thorough of the three and functions as the main lecture-style treatment for this topic, covering the several argument styles in one place from a widely used, beginner-oriented Python channel.
A focused three-minute screencast contrasting positional arguments, where position determines which parameter receives a value, with keyword (named) arguments, where the argument name is what matters. The description signals that the central idea is name-versus-position matching, so expect short call examples that show the same function invoked both ways.
It targets the single distinction students most often confuse, and Python Morsels is a well-regarded source for precise, carefully worded explanations of exactly this kind of language detail.
A short, fast demonstration of keyword arguments in Python from the Bro Code channel, framed as arguments identified by name rather than by position. Expect a compact code example showing a function called with named arguments and a note on the readability and ordering benefits this provides.
It is a concise reinforcement of the keyword-argument subtopic and makes a good second pass or quick review after the longer lecture, with minimal time cost.
These videos directly support MO1 by building the vocabulary and mechanics you need to construct functions with appropriate parameter types. Together they establish the parameter-versus-argument distinction, demonstrate positional matching, explain keyword arguments by name, and introduce default parameter values that make arguments optional. That foundation is a prerequisite for the later *args and **kwargs material in this module, and the habit of reading a def line carefully also carries into tracing scope (MO2) and writing the small, single-purpose functions used in recursion and functional patterns (MO3, MO5).
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.