A tuple is an ordered sequence of values written with parentheses, such as (3.5, 2.1, 0.0) or ('steel', 200e9). Like a list, a tuple keeps its items in order and lets you reach them by index or slice. Unlike a list, a tuple is immutable: once it is created, you cannot add, remove, or replace its elements. That single difference is what makes tuples useful for fixed collections — sensor coordinates, RGB color values, material constants, or a pair of values returned together from a function.
In this course, tuples matter for two reasons. First, they are the natural choice whenever data should be protected from accidental modification, which makes engineering code easier to trust and to read. Second, tuples support packing and unpacking, a convenient Python idiom that lets you assign several variables at once (x, y, z = point) and return multiple results from a single function. You will also meet tuples indirectly in loops, in dictionary keys, and in function arguments, so recognizing them early pays off later.
As you watch, pay attention to three things: the syntax details that trip people up (especially the single-element tuple, which needs a trailing comma), what happens when you try to modify a tuple and what the error message tells you, and which operations are still allowed — indexing, slicing, concatenation, membership tests, count, and index. Finally, keep a running mental list of decision criteria: when is a tuple the better choice than a list, and when does immutability get in your way?
An introductory walkthrough of tuples in Python: how to create them with parentheses, how to access elements by index, and how tuples differ from lists. It is likely to demonstrate immutability directly by attempting to change an element and showing the resulting error, and to cover the single-element tuple comma rule.
CodeWithHarry's Python series is a well-paced beginner course, and this episode maps directly onto the Creating and Accessing Tuples and Immutability subtopics with live code you can retype yourself.
A follow-up lesson focused on what you can actually do with a tuple once it exists, likely including indexing and slicing, concatenation and repetition, membership checks, and built-in methods such as count and index. It should reinforce why these operations return new objects rather than modifying the original tuple.
It extends the first video from syntax to practical use, giving you the concrete operation-by-operation comparison you need to judge tuples against lists in MO4 and MO5.
A short, focused screencast on tuple unpacking: replacing hard-coded indices like point[0] and point[1] with descriptive variable names assigned in a single statement. Expect a demonstration of multiple assignment and the readability benefits it brings.
Python Morsels produces precise, idiom-focused clips, and this one covers the Tuple Packing and Unpacking subtopic better than a general overview, showing why the technique improves code clarity.
Together these videos target the tuple portion of the module's data-structure outcomes. The first two build the factual basis for MO4 by showing how tuples are created and accessed and by demonstrating immutability and the limited set of permitted operations, so you can contrast tuples with the lists covered in MO3. The operations video and the unpacking clip then supply the practical and readability arguments behind MO5, helping you justify choosing a tuple over a list for fixed engineering data or for returning several values from one function. Because tuples are sequences, the indexing and iteration patterns shown here also carry straight into the for-loop work of MO2.
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.