BeginnerPython · 34 min

Collections: Beginner

Python's collections module ships with data structures that replace dozens of lines of manual code with a single import. Counter objects at companies like Mozilla count event frequencies across millions of records in one line, and namedtuples make tuple data self-documenting without the overhead of a full class. Palantir's data engineers use defaultdict to accumulate grouped results without checking whether a key exists on every iteration. The collections module tools in this lesson are the professional Python developer's first upgrade beyond basic lists and dicts.

Creating Tuples

Daily Life

Interviews

Build immutable sequences for safe data

A tuple is an ordered, immutable sequence of values. You create tuples using parentheses () instead of the square brackets [] used for lists. The values inside can be of any type, and you can mix types freely just like with lists.

The word "tuple" comes from mathematics, where it describes a finite ordered sequence of elements. A "pair" is a 2-tuple, a "triple" is a 3-tuple, a "quadruple" is a 4-tuple, and so on. In Python, tuples can have any number of elements, from zero to millions. The generic term "n-tuple" refers to a tuple of any length. This mathematical heritage gives tuples a formal, structured character that lists lack.

Data engineers encounter tuples constantly. Database query results often come as sequences of tuples, with each tuple representing one row. CSV files parse into tuples. Function return values use tuples when returning multiple items. Geographic coordinates are naturally represented as (latitude, longitude) tuples. Understanding tuples is essential for working with structured data.

Basic Tuple Creation

Creating a tuple is straightforward. Simply put your values inside parentheses, separated by commas. Let us start with some basic examples:

	# A tuple of coordinates (x, y)
	point = (10, 20)
	print("Point:", point)

	# A tuple of mixed types
	person = ("Alice", 30, "Engineer")
	print("Person:", person)

	# A tuple of numbers
	scores = (95, 87, 92, 88, 91)
	print("Scores:", scores)

	# Access like lists (0-indexed)
	print("First score:", scores[0])
	print("Last score:", scores[-1])
	print("Name:", person[0])

>>>Output

Point: (10, 20)

Person: ('Alice', 30, 'Engineer')

Scores: (95, 87, 92, 88, 91)

First score: 95

Last score: 91

Name: Alice

Notice that accessing tuple elements works exactly like accessing list elements. You use square brackets with an index, and indexing starts at 0. Negative indices count from the end, so -1 gets the last element. The syntax is identical to lists. This consistency across sequence types is one of Python's design strengths - once you learn indexing for one type, you know it for all types.

Tuples vs Lists: Key Diff

The fundamental difference between tuples and lists is mutability. Lists can be modified after creation; tuples cannot. If you try to change a tuple element, Python raises an error:

	# Lists are mutable
	my_list = [1, 2, 3]
	my_list[0] = 100
	print("Modified list:", my_list)

	# Tuples are immutable
	my_tuple = (1, 2, 3)
	print("Original tuple:", my_tuple)

	# Error if uncommented:
	# my_tuple[0] = 100 # TypeError

	# But you can create a new tuple
	new_tuple = (100,) + my_tuple[1:]
	print("New tuple:", new_tuple)

>>>Output

Modified list: [100, 2, 3]

Original tuple: (1, 2, 3)

New tuple: (100, 2, 3)

This immutability is not a bug - it is a feature. When you pass a tuple to a function or store it in a data structure, you know it cannot be accidentally modified. This makes tuples safer for representing data that should never change, like database record keys, coordinates, or configuration values.

Immutability also has technical benefits. Because tuples cannot change, Python can optimize them. Tuples use less memory than equivalent lists, and creating tuples is faster. More importantly, tuples can be used as dictionary keys and set elements, which lists cannot. If you need to use a sequence as a key, it must be a tuple.

•Use Tuples When

Data should not change
Representing fixed records
Dictionary keys needed
Returning multiple values
Coordinates or dimensions

•Use Lists When

Data will be modified
Building up collections
Order may change
Adding/removing items
Sorting or shuffling needed

Single-Element Tuples

Creating tuples with zero or one element requires special syntax. This is one of the few tricky parts of tuple creation:

	# Empty tuple - use empty parentheses
	empty = ()
	print("Empty tuple:", empty)
	print("Type:", type(empty))

	# Single element - trailing comma
	# The comma makes it a tuple
	single = (42,)
	print("Single tuple:", single)
	print("Type:", type(single))

	# Without the comma, it's just a number
	not_a_tuple = (42)
	print("Not a tuple:", not_a_tuple)
	print("Type:", type(not_a_tuple))

	also_a_tuple = 1, 2, 3
	print("Also a tuple:", also_a_tuple)

>>>Output

Empty tuple: ()

Type: <class 'tuple'>

Single tuple: (42,)

Type: <class 'tuple'>

Not a tuple: 42

Type: <class 'int'>

Also a tuple: (1, 2, 3)

()(42,)(1, 2, 3)1, 2, 3

()

Empty tuple

Contains zero elements

(42,)

Single element

Trailing comma required

(1, 2, 3)

Multi-element

Comma-separated values

1, 2, 3

No parentheses

Parentheses are optional

One syntax detail trips up nearly every Python beginner when working with tuples.

TIP

The trailing comma in single-element tuples is essential. Without it, (42) is just the number 42 with unnecessary parentheses. This is a common source of bugs for Python beginners.

Converting Tuples and Lists

You can convert between tuples and lists using tuple() and list(). This is useful when you need to modify data that arrived as a tuple, or when you need to make a list immutable:

	# Convert list to tuple
	my_list = [1, 2, 3, 4, 5]
	my_tuple = tuple(my_list)
	print("List to tuple:", my_tuple)

	# Convert tuple to list (to modify it)
	coordinates = (10, 20)
	coords_list = list(coordinates)
	coords_list[0] = 15
	updated_coords = tuple(coords_list)
	print("Updated coordinates:", updated_coords)

	# Convert a string to a tuple of characters
	letters = tuple("hello")
	print("String to tuple:", letters)

>>>Output

List to tuple: (1, 2, 3, 4, 5)

Updated coordinates: (15, 20)

String to tuple: ('h', 'e', 'l', 'l', 'o')

This pattern of converting to list, modifying, and converting back is common when you need to make a one-time change to otherwise immutable data. Think of it as creating a revised copy rather than editing the original document.

Start with tuple

Your original immutable data like (10, 20)

Convert to list

Use list() to get a mutable copy you can modify

Make changes

Modify the list freely using index assignment

Convert back

Use tuple() to freeze the result as immutable again

This preserves the immutability guarantee for any code that holds a reference to the original tuple. The new tuple is a completely separate object with no connection to the original.

Fill in the Blank

> You need to store a single value, 42, as a tuple rather than an integer. Pick the syntax that actually creates a tuple instead of just grouping.

single = 
print(type(single))

Tuples are memory-efficient because Python can optimize them at a lower level than lists. A tuple of fixed values can even be shared across the program without copying.

You can use tuples as dictionary keys because they are hashable, unlike lists. This is useful when you need to index data by multiple fields, such as (latitude, longitude) or (year, month).

Converting between tuples and lists is a common pattern: convert a tuple to a list to modify it, then convert back to a tuple to preserve immutability.

Python Quiz

> You need to change the first coordinate of an immutable tuple. Choose the right conversions: one to make it modifiable, and one to freeze the result back.

point = (10, 20)
coords = ___(point)
coords[0] = 15
result = ___(coords)
print(result)

list

tuple

dict

set

Tuples use less memory than lists of the same content because their fixed size allows Python to allocate them more efficiently. For large datasets of fixed records, this difference is meaningful.

Immutability also makes tuples safer to pass between functions. When a caller passes a tuple, they can be confident it will not be modified by the callee, unlike a list which could be altered in place.

Python functions naturally return tuples when returning multiple values. Calling a function that returns two values and unpacking them into two variables uses this tuple mechanism behind the scenes.

Tuple Unpacking

Daily Life

Interviews

Extract multiple values in one line

Tuple unpacking is one of Python's most elegant features. It allows you to assign multiple variables from a tuple in a single statement. Instead of accessing each element by index, you can extract all values at once into named variables. This makes code more readable and expressive. When you see unpacking in code, you immediately understand the structure of the data being processed.

Data engineers use tuple unpacking constantly. When a function returns multiple values, when iterating over pairs of data, when processing database rows - unpacking makes all of these operations cleaner. It is one of those features that, once learned, you will use every day.

Basic Unpacking

To unpack a tuple, provide the same number of variables on the left side of the assignment as there are elements in the tuple:

	# Basic tuple unpacking
	point = (10, 20)
	x, y = point
	print("x =", x)
	print("y =", y)

	# Unpacking a person record
	person = ("Alice", 30, "Engineer")
	name, age, job = person
	print(name, "is", age, "years old and works as an", job)

	# Unpacking in a single line
	a, b, c = (1, 2, 3)
	print("a =", a, ", b =", b, ", c =", c)

>>>Output

x = 10

y = 20

Alice is 30 years old and works as an Engineer

a = 1 , b = 2 , c = 3

The number of variables must match the number of tuple elements exactly. If they do not match, Python raises a ValueError. This strict matching helps catch bugs early - if your tuple structure changes, unpack statements will immediately fail rather than silently producing wrong results. This behavior makes tuple unpacking a form of lightweight data validation.

Compare unpacking to index-based access. Without unpacking, you would write x = point[0] and y = point[1] on separate lines. Unpacking combines these into a single, readable statement that makes the intent clear. You are extracting x and y coordinates from a point - the code says exactly that.

Swapping Variables

One of the most elegant uses of tuple unpacking is swapping two variables without a temporary variable. In most languages, swapping requires three lines and a temporary variable to hold one value during the exchange. In Python, tuple unpacking reduces this to a single, readable line:

	a = 10
	b = 20
	temp = a
	a = b
	b = temp
	print("Traditional swap: a =", a, ", b =", b)

	# Python swap using tuple unpacking
	x = 100
	y = 200
	x, y = y, x
	print("Python swap: x =", x, ", y =", y)

	# Works with any number of values
	first, second, third = "C", "B", "A"
	first, second, third = third, second, first
	print("Reversed:", first, second, third)

>>>Output

Traditional swap: a = 20 , b = 10

Python swap: x = 200 , y = 100

Reversed: A B C

The expression x, y = y, x works because Python evaluates the right side completely before assigning to the left side. It creates a temporary tuple (y, x) and then unpacks it into x and y.

Unpacking in Loops

Tuple unpacking is especially powerful when iterating over sequences of tuples. Each tuple in the sequence gets unpacked automatically into your loop variables:

	# List of coordinate pairs
	points = [(0, 0), (10, 5), (20, 15), (30, 10)]

	# Unpack each point into x and y
	print("Coordinates:")
	for x, y in points:
	print(f" x={x}, y={y}")

	# List of person records
	people = [
	("Alice", 30),
	("Bob", 25),
	("Charlie", 35),
	]

	print("\nPeople:")
	for name, age in people:
	print(f" {name} is {age} years old")

>>>Output

Coordinates:

  x=0, y=0

  x=10, y=5

  x=20, y=15

  x=30, y=10

People:

  Alice is 30 years old

  Bob is 25 years old

  Charlie is 35 years old

Without unpacking, you would need to write point[0] and point[1] inside the loop. Unpacking into x and y makes the code much clearer. This pattern appears constantly when processing data - database rows, CSV records, and API responses are often sequences of tuples. The ability to give meaningful names to each position transforms cryptic index access into self-documenting code.

Unpacking with enumerate()

The built-in enumerate() function pairs each item with its index, returning tuples. Combined with unpacking, it gives you both the index and value in a clean way:

	fruits = ["apple", "banana", "cherry", "date"]

	# Without unpacking - awkward
	print("Without unpacking:")
	for item in enumerate(fruits):
	print(f" Index {item[0]}: {item[1]}")

	# With unpacking - much cleaner
	print("\nWith unpacking:")
	for index, fruit in enumerate(fruits):
	print(f" Index {index}: {fruit}")

	# Start counting from 1 instead of 0
	print("\nStarting from 1:")
	for num, fruit in enumerate(fruits, start=1):
	print(f" {num}. {fruit}")

>>>Output

Without unpacking:

  Index 0: apple

  Index 1: banana

  Index 2: cherry

  Index 3: date

With unpacking:

  Index 0: apple

  Index 1: banana

  Index 2: cherry

  Index 3: date

Starting from 1:

  1. apple

  2. banana

  3. cherry

  4. date

TIP

Always use enumerate() with unpacking when you need both index and value. Avoid the pattern for i in range(len(list)) - it is less readable and more error-prone.

Ignoring Values: Underscore

Sometimes you only need some values from a tuple. By convention, Python programmers use underscore _ for values they want to ignore:

	# Only need the name, not age or job
	record = ("Alice", 30, "Engineer")
	name, _, _ = record
	print("Name only:", name)

	data = (1, 2, 3, 4, 5)
	first, _, _, _, last = data
	print("First and last:", first, last)

	# In loops - only need the value, not index
	print("\nJust values:")
	for _, value in enumerate(["a", "b", "c"]):
	print(" ", value)

>>>Output

Name only: Alice

First and last: 1 5

Just values:

a

b

c

The underscore _ is a valid variable name, but it signals to readers "I am intentionally ignoring this value." This convention makes your intentions clear and helps code reviewers understand what you actually care about.

Debug Challenge

> This code tries to unpack a 3-element tuple into only 2 variables, causing a ValueError because the number of variables does not match.

ValueError: too many values to unpack (expected 2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99



point = (10, 20, 30)
x, y = point
print(x, y)
point = (10, 20, 30)
x, y = point
print(x, y)

Tuple unpacking errors are caught immediately at runtime, which helps you detect structural mismatches in your data early rather than working with wrong values silently.

When you only need some values from a tuple, use the underscore convention to ignore the rest. This communicates intent clearly to readers: you are deliberately skipping those positions.

Unpacking works with any iterable, not just tuples. You can unpack lists, strings, and even generator expressions using the same syntax, making it a versatile tool across all of Python.

Using min, max, sum

Daily Life

Interviews

Summarize any numeric collection instantly

Python provides three essential built-in functions for working with numeric collections: min() finds the smallest value, max() finds the largest value, and sum() totals all values. These functions work on any iterable containing comparable values - lists, tuples, sets, and more. They are so fundamental that Python includes them as built-in functions available everywhere without any imports.

Data engineers use these functions constantly. What is the earliest timestamp in a log file? Use min(). What is the highest transaction amount today? Use max(). What is the total revenue? Use sum(). These operations are so fundamental that Python makes them available as built-in functions rather than requiring imports.

Finding Minimum and Maximum

The min() and max() functions scan through a collection and return the smallest or largest value. They work with numbers, strings, and any other comparable types:

	# With lists of numbers
	temperatures = [72, 68, 75, 80, 65, 77]
	print("Lowest temp:", min(temperatures))
	print("Highest temp:", max(temperatures))

	# With tuples
	scores = (85, 92, 78, 95, 88)
	print("Min score:", min(scores))
	print("Max score:", max(scores))

	print("Min of 5, 2, 8:", min(5, 2, 8))
	print("Max of 5, 2, 8:", max(5, 2, 8))

	# With strings (alphabetical order)
	names = ["Charlie", "Alice", "Bob"]
	print("First alphabetically:", min(names))
	print("Last alphabetically:", max(names))

>>>Output

Lowest temp: 65

Highest temp: 80

Min score: 78

Max score: 95

Min of 5, 2, 8: 2

Max of 5, 2, 8: 8

First alphabetically: Alice

Last alphabetically: Charlie

Notice that min() and max() can take either a single collection (list, tuple, etc.) or multiple individual arguments. When comparing strings, they use alphabetical (lexicographic) order, where uppercase letters come before lowercase. This makes them useful for finding the first or last item when data is sorted alphabetically. The flexibility to accept either a collection or individual arguments makes these functions convenient in many contexts.

These functions are extremely efficient because they only need to scan through the data once. Python does not sort the entire collection to find min or max - it just tracks the extreme value as it goes. For a million values, min() and max() are much faster than sorting and taking the first or last element.

Summing Values

The sum() function adds all values in a collection. It works with any numeric types and is much cleaner than writing a loop:

	# Sum a list of numbers
	prices = [19.99, 24.99, 9.99, 14.99]
	total = sum(prices)
	print("Total:", total)

	# Sum a tuple
	quantities = (5, 3, 8, 2)
	print("Total quantity:", sum(quantities))

	# Sum with a starting value
	initial_balance = 100
	deposits = [50, 25, 75]
	final_balance = sum(deposits, initial_balance)
	print("Final balance:", final_balance)

	# Calculating an average
	scores = [85, 92, 78, 95, 88]
	average = sum(scores) / len(scores)
	print("Average score:", average)

>>>Output

Total: 69.96

Total quantity: 18

Final balance: 250

Average score: 87.6

The optional second argument to sum() specifies a starting value. This is useful when you want to add to an existing total rather than starting from zero. The default starting value is 0.

Combining min, max, sum

These functions are often used together to compute summary statistics. Here is a practical example analyzing sales data:

	# Daily sales figures for a week
	sales = [1250, 980, 1100, 1450, 1320, 890, 1050]

	# Calculate summary statistics
	total_sales = sum(sales)
	average_sales = total_sales / len(sales)
	best_day = max(sales)
	worst_day = min(sales)
	sales_range = best_day - worst_day

	print("Weekly Sales Report")
	print("-" * 20)
	print("Total:", total_sales)
	print("Average:", round(average_sales, 2))
	print("Best day:", best_day)
	print("Worst day:", worst_day)
	print("Range:", sales_range)

>>>Output

Weekly Sales Report

--------------------

Total: 8040

Average: 1148.57

Best day: 1450

Worst day: 890

Range: 560

sum([])min([])max([])default=

sum([])

Returns zero

Safe on empty collections

min([])

Raises error

ValueError on empty input

max([])

Raises error

ValueError on empty input

default=

Fallback value

Prevents crash on empty

default with min and max

To safely handle empty collections, use the default parameter with min() and max():

	# Empty list would crash without default
	empty_list = []

	# Safe with default parameter
	result = min(empty_list, default=0)
	print("Min of empty list:", result)

	result = max(empty_list, default=0)
	print("Max of empty list:", result)

	# Find max in possibly-empty results
	search_results = []
	best_match = max(search_results, default=None)
	print("Best match:", best_match)

	# With actual data
	actual_results = [75, 82, 91]
	best_match = max(actual_results, default=None)
	print("Best match with data:", best_match)

>>>Output

Min of empty list: 0

Max of empty list: 0

Best match: None

Best match with data: 91

Fill in the Blank

> You have a list of five test scores and need to compute a summary statistic. Pick the built-in function to apply and see what it returns.

scores = [85, 92, 78, 95, 88]
result = (scores)
print(result)

These three functions cover the most common aggregate operations in data analysis: sum() for totals, min() and max() for range, and combining them with len() for averages.

min() and max() support a key parameter just like sorted(), allowing you to find the minimum or maximum based on a computed value rather than the raw element.

For empty collections, sum() safely returns 0, but min() and max() raise ValueError. Use the default parameter to handle empty inputs gracefully in production code.

Python Quiz

> Compute the average of five test scores. Choose the function that totals all values for the numerator, and the function that counts items for the denominator.

scores = (85, 92, 78, 95, 88)
average = ___(scores) / ___(scores)
print(average)

sum

len

max

min

abs

Computing averages with sum() and len() is a fundamental pattern. For large datasets, this single-pass approach is more efficient than sorting and picking the middle value.

These built-in functions work identically on lists, tuples, sets, and any other iterable, making them versatile tools that you can apply without worrying about the underlying container type.

Combining sum(), min(), max(), and len() gives you a complete statistical summary of any numeric collection, which is the starting point for data analysis in every domain.

abs() for Absolutes

Daily Life

Interviews

Measure distances and errors correctly

The abs() function returns the absolute value of a number - its distance from zero on the number line. For positive numbers, abs() returns the same value. For negative numbers, it removes the negative sign. This function is essential when you care about magnitude but not direction.

Data engineers use abs() when calculating differences, measuring errors, and working with coordinates. If you want to know how far apart two values are regardless of which is larger, you need absolute value. If you want to know the magnitude of a change regardless of direction, you need absolute value. This function appears frequently in validation logic, error calculations, and distance measurements.

Basic Absolute Value

The abs() function works with integers, floats, and complex numbers:

	# Integers
	print("abs(-5):", abs(-5))
	print("abs(5):", abs(5))
	print("abs(0):", abs(0))

	# Floats
	print("abs(-3.14):", abs(-3.14))
	print("abs(2.71):", abs(2.71))

	# In expressions
	x = -10
	y = 3
	print("Difference:", abs(x - y))

	# Temperature difference example
	temp_yesterday = 72
	temp_today = 65
	change = abs(temp_today - temp_yesterday)
	print(f"Temperature changed by {change} degrees")

>>>Output

abs(-5): 5

abs(5): 5

abs(0): 0

abs(-3.14): 3.14

abs(2.71): 2.71

Difference: 13

Temperature changed by 7 degrees

Practical Applications

Here are common scenarios where abs() is essential:

	# Calculating error/deviation
	expected = 100
	actual = 95
	error = abs(expected - actual)
	print(f"Error: {error} (off by {error}%)")

	# Finding distance between coordinates
	point1_x, point2_x = 10, 25
	distance_x = abs(point2_x - point1_x)
	print(f"Horizontal distance: {distance_x}")

	# Checking if values are close
	value1 = 3.14159
	value2 = 3.14160
	tolerance = 0.001
	is_close = abs(value1 - value2) < tolerance
	print(f"Values close enough? {is_close}")

	# Processing financial data (gains/losses)
	changes = [100, -50, 75, -25, 30]
	total_movement = sum(abs(c) for c in changes)
	print("Total market movement:", total_movement)

>>>Output

Error: 5 (off by 5%)

Horizontal distance: 15

Values close enough? True

Total market movement: 280

The last example demonstrates a powerful pattern: using abs() inside sum() with a generator expression. This calculates total movement regardless of direction - useful for measuring volatility or activity in financial data. This combination of built-in functions with generator expressions is a hallmark of idiomatic Python code.

The tolerance check pattern is especially important for floating-point comparisons. Due to how computers represent decimals, direct equality checks often fail even when values should be equal. Checking if the absolute difference is below a threshold is the standard approach for comparing floats.

Distance calculations

Use abs(a - b) to find the gap between two values regardless of order

Error and deviation

Use abs(expected - actual) to measure how far off a prediction is

Tolerance checks

Use abs(x - y) < epsilon to safely compare floating-point numbers

Total magnitude

Use sum(abs(v) for v in values) to measure total market movement

Debug Challenge

> This code calculates the distance between two points but gets a negative result because it subtracts without taking the absolute value.

Logic error: distance should always be positive, but the output is -15

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99




a = 10
b = 25
distance = a - b
print("Distance:", distance)
a = 10
b = 25
distance = a - b
print("Distance:", distance)

abs() is essential whenever you care about magnitude rather than direction. Distances, deviations, and error measurements should always be non-negative.

The pattern abs(a - b) is symmetric: it produces the same result regardless of which value is a and which is b. This makes it the correct way to compute unsigned differences.

For floating-point comparisons, checking abs(x - y) < tolerance is the standard approach because direct equality fails due to rounding errors in how computers represent decimals.

len() Across Types

Daily Life

Interviews

Check size of any collection reliably

The len() function returns the number of items in a collection. It works uniformly across all Python sequence and collection types: lists, tuples, strings, dictionaries, sets, and more. This consistency is one of Python's design strengths.

You have probably used len() with lists already. This section explores how it works across different types and shows important patterns for using it effectively. Understanding len() deeply helps you write more robust code that handles edge cases properly. Knowing when and how to check collection size is essential for writing defensive code that handles unexpected inputs gracefully.

len() with Different Types

The len() function works consistently across all built-in collection types:

	# Lists - counts elements
	my_list = [1, 2, 3, 4, 5]
	print("List length:", len(my_list))

	# Tuples - counts elements
	my_tuple = (10, 20, 30)
	print("Tuple length:", len(my_tuple))

	# Strings - counts characters
	my_string = "Hello, World!"
	print("String length:", len(my_string))

	# Dictionaries - counts key-value pairs
	my_dict = {"a": 1, "b": 2, "c": 3}
	print("Dict length:", len(my_dict))

	# Sets - counts unique elements
	my_set = {1, 2, 2, 3, 3, 3}
	print("Set length:", len(my_set))

	# Empty collections
	print("Empty list:", len([]))
	print("Empty string:", len(""))

>>>Output

List length: 5

Tuple length: 3

String length: 13

Dict length: 3

Set length: 3

Empty list: 0

Empty string: 0

Notice that for dictionaries, len() returns the number of key-value pairs, not the total of keys plus values. For sets, it counts unique elements after duplicates are removed. This consistent behavior makes len() predictable across all collection types. Once you understand how len() works, you can apply that knowledge to any collection you encounter.

For strings, len() counts characters including spaces and punctuation. This is important for data validation - checking that a username is between 3 and 20 characters, ensuring a description is not too long, or validating that a required field is not empty.

Checking Empty Collections

A common use of len() is checking if a collection is empty. However, Python has a more idiomatic way to do this - empty collections are "falsy" and non-empty collections are "truthy":

	data = []

	# Works, but not idiomatic
	if len(data) == 0:
	print("Using len(): data is empty")

	if not data:
	print("Pythonic: data is empty")

	# With data
	data = [1, 2, 3]

	if len(data) > 0:
	print("Using len(): data has items")

	# More Pythonic - truthy check
	if data:
	print("Pythonic: data has items")

	# Works for all collection types
	empty_dict = {}
	if not empty_dict:
	print("Empty dict is falsy")

>>>Output

Using len(): data is empty

Pythonic: data is empty

Using len(): data has items

Pythonic: data has items

Empty dict is falsy

TIP

Prefer if data: over if len(data) > 0: and if not data: over if len(data) == 0:. The shorter form is more Pythonic and slightly faster.

len() in Common Patterns

Here are practical patterns using len() that appear frequently in data engineering code:

	# Calculating average
	scores = [85, 92, 78, 95, 88]
	average = sum(scores) / len(scores)
	print(f"Average: {average}")

	# Processing in batches
	all_items = list(range(25))
	batch_size = 10
	num_batches = len(all_items) // batch_size
	remainder = len(all_items) % batch_size
	print(f"Full batches: {num_batches}, Remainder: {remainder}")

	# Validating data
	def process_record(record):
	if len(record) != 3:
	print(f"Error: expected 3 fields, got {len(record)}")
	return False
	return True

	valid = ("Alice", 30, "Engineer")
	invalid = ("Bob", 25)
	print("Valid record?", process_record(valid))
	print("Valid record?", process_record(invalid))

>>>Output

Average: 87.6

Full batches: 2, Remainder: 5

Valid record? True

Error: expected 3 fields, got 2

Valid record? False

The batch processing example shows how len() helps divide work into manageable chunks. The validation example shows how len() ensures data has the expected structure before processing. Both patterns are common in real-world data pipelines. Whether you are processing millions of records or validating user input, len() is your first line of defense against malformed data.

len() on Nested Structures

When working with nested structures, len() only counts the top-level elements, not nested contents:

	# Nested list - len counts outer elements only
	matrix = [
	[1, 2, 3],
	[4, 5, 6],
	[7, 8, 9]
	]
	print("Matrix rows:", len(matrix))
	print("First row length:", len(matrix[0]))
	total_elements = sum(len(row) for row in matrix)
	print("Total elements:", total_elements)

	# List of tuples
	records = [
	("Alice", 30),
	("Bob", 25),
	("Charlie", 35)
	]
	print("Number of records:", len(records))

	# String in a list counts as one element
	words = ["hello", "world"]
	print("Number of words:", len(words))
	print("Letters in first word:", len(words[0]))

>>>Output

Matrix rows: 3

First row length: 3

Total elements: 9

Number of records: 3

Number of words: 2

Letters in first word: 5

Understanding this behavior is crucial for data engineering. When you have a list of records, len() tells you how many records you have, not how many fields across all records. To count total fields, you need to sum the lengths of each record. This distinction between counting containers versus counting contents is fundamental to working with nested data structures.

Fill in the Blank

> You have a nested list [[1, 2], [3, 4], [5, 6]] and need to count its elements. Pick the expression that returns the count you expect.

data = [[1, 2], [3, 4], [5, 6]]
result = 
print(result)

Common Mistakes

Here are the most common mistakes when working with tuples and built-in functions. Learning to recognize these pitfalls will save you debugging time and help you write more reliable code from the start:

✓Do

Use trailing comma for single-element tuples: (42,)
Use default= parameter with min() and max() on possibly empty data
Match variable count exactly when unpacking tuples

✗Don't

Try to modify tuple elements (they are immutable)
Use len() > 0 instead of the Pythonic if collection:
Confuse tuple parentheses with function call parentheses

Single-Element Tuple Error

The most common tuple mistake is forgetting the trailing comma when creating a single-element tuple. Without the comma, Python interprets the parentheses as grouping, not tuple creation.

	# WRONG: This is not a tuple
	wrong = (42)
	print("Type of (42):", type(wrong))

	# RIGHT: Include the trailing comma
	right = (42,)
	print("Type of (42,):", type(right))

	# This matters in function returns
	def get_result_wrong():
	# Returns an int!
	return (42)

	def get_result_right():
	# Returns a tuple
	return (42,)

	print("Wrong return type:", type(get_result_wrong()))
	print("Right return type:", type(get_result_right()))

>>>Output

Type of (42): <class 'int'>

Type of (42,): <class 'tuple'>

Wrong return type: <class 'int'>

Right return type: <class 'tuple'>

Unpacking Mismatch Mistake

When unpacking a tuple, the number of variables must exactly match the number of elements. Python raises a ValueError if there is a mismatch.

	# WRONG: Too few variables
	data = (1, 2, 3)
	# a, b = data # ValueError

	# WRONG: Too many variables
	# a, b, c, d = data # ValueError

	# RIGHT: Match the number exactly
	a, b, c = data
	print("Correct unpacking:", a, b, c)

	# Use underscore for unneeded values
	first, _, last = data
	print("First and last:", first, last)

>>>Output

Correct unpacking: 1 2 3

First and last: 1 3

Python's built-in collections provide the right tool for every data organization challenge. Put these fundamentals to the test with hands-on challenges in the Python Builder.

❯❯❯PUTTING IT ALL TOGETHER

> You are a data analyst at Shopify auditing a product catalog migration. You must verify that every record transferred correctly, identify the longest and shortest SKU codes, confirm the total item count, and flag any entries whose price deviates below zero after a currency conversion.

tuples hold each catalog record as an immutable pair of SKU and price so values cannot be accidentally overwritten during iteration.

tuple unpacking extracts SKU and price fields from each record in a single readable assignment rather than repeated index access.

min(), max(), and sum() scan the price column to surface the cheapest item, the most expensive, and the total catalog value in one pass.

abs() converts negative post-conversion prices to their magnitude so flagged entries can be reported as unsigned deviation amounts.

KEY TAKEAWAYS

Tuples use parentheses () and are immutable - they cannot be changed after creation

Single-element tuples require a trailing comma: (42,) not (42)

Tuple unpacking assigns multiple variables at once: x, y = point

Swap variables elegantly with a, b = b, a

Use underscore _ to ignore values when unpacking

min() and max() find extremes; use default= for empty collections

sum() totals numeric collections; combine with len() for averages

abs() returns absolute value - essential for distances and errors

len() works on all collection types: lists, tuples, strings, dicts, sets

Prefer if data: over if len(data) > 0: for checking non-empty

Tuples and essential built-in functions

Category: Python
Difficulty: beginner
Duration: 34 minutes
Challenges: 0 hands-on challenges

Topics covered: Creating Tuples, Tuple Unpacking, Using min, max, sum, abs() for Absolutes, len() Across Types

Lesson Sections

Creating Tuples (concepts: pyTuples)
The word "tuple" comes from mathematics, where it describes a finite ordered sequence of elements. A "pair" is a 2-tuple, a "triple" is a 3-tuple, a "quadruple" is a 4-tuple, and so on. In Python, tuples can have any number of elements, from zero to millions. The generic term "n-tuple" refers to a tuple of any length. This mathematical heritage gives tuples a formal, structured character that lists lack. Data engineers encounter tuples constantly. Database query results often come as sequences o
Tuple Unpacking (concepts: pyUnpacking)
Tuple unpacking is one of Python's most elegant features. It allows you to assign multiple variables from a tuple in a single statement. Instead of accessing each element by index, you can extract all values at once into named variables. This makes code more readable and expressive. When you see unpacking in code, you immediately understand the structure of the data being processed. Data engineers use tuple unpacking constantly. When a function returns multiple values, when iterating over pairs
Using min, max, sum (concepts: pyMathOps)
Finding Minimum and Maximum Notice that min() and max() can take either a single collection (list, tuple, etc.) or multiple individual arguments. When comparing strings, they use alphabetical (lexicographic) order, where uppercase letters come before lowercase. This makes them useful for finding the first or last item when data is sorted alphabetically. The flexibility to accept either a collection or individual arguments makes these functions convenient in many contexts. These functions are ext
abs() for Absolutes (concepts: pyMathOps)
Data engineers use abs() when calculating differences, measuring errors, and working with coordinates. If you want to know how far apart two values are regardless of which is larger, you need absolute value. If you want to know the magnitude of a change regardless of direction, you need absolute value. This function appears frequently in validation logic, error calculations, and distance measurements. Basic Absolute Value The abs() function works with integers, floats, and complex numbers: Pract
len() Across Types (concepts: pyCollections)
len() with Different Types Checking Empty Collections len() in Common Patterns Here are practical patterns using len() that appear frequently in data engineering code: The batch processing example shows how len() helps divide work into manageable chunks. The validation example shows how len() ensures data has the expected structure before processing. Both patterns are common in real-world data pipelines. Whether you are processing millions of records or validating user input, len() is your first