Creating dictionary from two sequences in Python - Visual Walkthrough

Concept Flow - Creating dictionary from two sequences

Start with two sequences

↓

Pair elements by position

↓

Use pairs as key-value

↓

Create dictionary

↓

Result: dictionary with keys and values

We take two lists (or sequences), pair their elements by position, and make a dictionary where the first list's items are keys and the second list's items are values.

Execution Sample

Python

keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = dict(zip(keys, values))
print(d)

This code pairs keys and values by position and creates a dictionary from them.

Execution Table

Step	Action	keys	values	zip result	Dictionary after step
1	Initialize keys and values	['a', 'b', 'c']	[1, 2, 3]	-	{}
2	Pair elements with zip	['a', 'b', 'c']	[1, 2, 3]	[('a', 1), ('b', 2), ('c', 3)]	{}
3	Create dictionary from pairs	['a', 'b', 'c']	[1, 2, 3]	[('a', 1), ('b', 2), ('c', 3)]	{'a': 1, 'b': 2, 'c': 3}
4	Print dictionary	['a', 'b', 'c']	-	-	{'a': 1, 'b': 2, 'c': 3}

💡 All pairs processed, dictionary created with keys from first list and values from second list.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
keys	['a', 'b', 'c']	['a', 'b', 'c']	['a', 'b', 'c']	['a', 'b', 'c']
values	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]
zip result	-	[('a', 1), ('b', 2), ('c', 3)]	[('a', 1), ('b', 2), ('c', 3)]	[('a', 1), ('b', 2), ('c', 3)]
d	{}	{}	{'a': 1, 'b': 2, 'c': 3}	{'a': 1, 'b': 2, 'c': 3}

Key Moments - 2 Insights

Why do we use zip() before creating the dictionary?

zip() pairs elements from keys and values by position, creating tuples that dict() can use as key-value pairs. Without zip(), dict() cannot pair them correctly. See execution_table step 2.

What happens if keys and values have different lengths?

zip() stops pairing when the shortest sequence ends, so the dictionary only includes pairs up to that length. This is why keys and values lengths matter.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what is the zip result?

A ['a', 'b', 'c', 1, 2, 3]

B [('a', 'b', 'c'), (1, 2, 3)]

C [('a', 1), ('b', 2), ('c', 3)]

D ['a1', 'b2', 'c3']

💡 Hint

Check the 'zip result' column at step 2 in execution_table.

At which step does the dictionary get its key-value pairs?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Dictionary after step' column in execution_table.

If values list was shorter, how would the dictionary change?

A It would include pairs only up to the shortest list length

B It would raise an error

C It would include all keys with None values

D It would ignore keys and use values as keys

💡 Hint

Recall how zip() works with sequences of different lengths.

Concept Snapshot

Create dictionary from two sequences:
- Use zip(keys, values) to pair elements
- Pass pairs to dict() to build dictionary
- Result keys come from first sequence, values from second
- If lengths differ, pairs stop at shortest
- Simple and clean way to combine two lists into a dict

Full Transcript

We start with two lists: keys and values. Using zip(), we pair each key with its corresponding value by position. Then, dict() takes these pairs and creates a dictionary. The dictionary keys come from the first list, and the values come from the second. If the lists have different lengths, zip stops at the shortest, so the dictionary only includes those pairs. This method is a simple way to combine two sequences into a dictionary.

Practice

1. What does the Python function zip() do when used with two sequences?

easy

A. Sorts both sequences in ascending order

B. Adds elements of both sequences together

C. Removes duplicate elements from both sequences

D. Pairs elements from both sequences into tuples

Solution

1. Step 1: Understand the purpose of zip()

   The zip() function pairs elements from two sequences by their positions, creating tuples.

2. Step 2: Recognize the output format

   Each tuple contains one element from each sequence, matched by index.

3. Final Answer:

   Pairs elements from both sequences into tuples -> Option D

4. Quick Check:

   zip() pairs elements = C [OK]

Hint: Remember zip pairs items by position from sequences [OK]

Common Mistakes:

• Thinking zip adds or subtracts elements
• Assuming zip sorts sequences
• Believing zip removes duplicates

2. Which of the following is the correct syntax to create a dictionary from two lists keys and values?

easy

A. dict(zip(keys, values))

B. dict(keys, values)

C. zip(dict(keys), dict(values))

D. dict(keys + values)

Solution

1. Step 1: Understand dict() and zip() usage

   The dict() function can convert an iterable of key-value pairs into a dictionary. zip(keys, values) creates these pairs.

2. Step 2: Check each option's correctness

   dict(zip(keys, values)) correctly uses dict(zip(keys, values)). Others misuse dict() or zip() syntax.

3. Final Answer:

   dict(zip(keys, values)) -> Option A

4. Quick Check:

   dict(zip(keys, values)) = B [OK]

Hint: Use dict(zip(keys, values)) to combine lists into dictionary [OK]

Common Mistakes:

• Trying dict(keys, values) directly
• Using zip on dict() results
• Adding lists inside dict()

3. What is the output of this code?

keys = ['a', 'b', 'c']
values = [1, 2, 3]
result = dict(zip(keys, values))
print(result)

medium

A. {'a': 1, 'b': 2, 'c': 3}

B. {1: 'a', 2: 'b', 3: 'c'}

C. [('a', 1), ('b', 2), ('c', 3)]

D. Error: cannot convert zip object to dict

Solution

1. Step 1: Understand zip pairing

   zip(keys, values) pairs 'a' with 1, 'b' with 2, and 'c' with 3.

2. Step 2: Convert pairs to dictionary

   dict() converts these pairs into key-value pairs in a dictionary.

3. Final Answer:

   {'a': 1, 'b': 2, 'c': 3} -> Option A

4. Quick Check:

   dict(zip(keys, values)) = {'a': 1, 'b': 2, 'c': 3} [OK]

Hint: zip pairs keys and values; dict converts pairs to dictionary [OK]

Common Mistakes:

• Confusing keys and values order
• Expecting list instead of dict
• Thinking zip returns dict directly

4. The following code throws an error. What is the problem?

keys = ['x', 'y']
values = [10, 20, 30]
result = dict(zip(keys, values))
print(result)

medium

A. dict() cannot convert zip object

B. zip() cannot be used with lists

C. There is no error; code runs fine

D. The lists have different lengths causing an error

Solution

1. Step 1: Check list lengths and zip behavior

   zip() pairs elements until the shortest list ends, so no error occurs even if lengths differ.

2. Step 2: Confirm dict() accepts zip object

   dict() can convert the zip object to a dictionary without error.

3. Final Answer:

   There is no error; code runs fine -> Option C

4. Quick Check:

   zip truncates to shortest list; dict accepts zip [OK]

Hint: zip stops at shortest list; no error if lengths differ [OK]

Common Mistakes:

• Assuming zip requires equal length lists
• Thinking dict() can't convert zip
• Expecting error due to list length mismatch

5. Given two lists keys = ['name', 'age', 'city'] and values = ['Alice', '', None], which dictionary comprehension correctly creates a dictionary excluding keys with empty or None values?

hard

A. {k: v for k, v in zip(keys, values)}

B. {k: v for k, v in zip(keys, values) if v}

C. {k: v for k, v in zip(keys, values) if v != ''}

D. {k: v for k, v in zip(keys, values) if v is not None}

Solution

1. Step 1: Understand filtering with dictionary comprehension

   We want to exclude keys where values are empty strings or None. The condition if v filters out falsy values like '' and None.

2. Step 2: Analyze each option's filter

   {k: v for k, v in zip(keys, values) if v} uses if v which excludes both '' and None. {k: v for k, v in zip(keys, values) if v is not None} excludes only None, {k: v for k, v in zip(keys, values) if v != ''} excludes only '', and {k: v for k, v in zip(keys, values)} includes all.

3. Final Answer:

   {k: v for k, v in zip(keys, values) if v} -> Option B

4. Quick Check:

   Filter falsy values with if v = D [OK]

Hint: Use if v to exclude empty or None values in comprehension [OK]

Common Mistakes:

• Filtering only None or only empty string
• Not filtering any values
• Using incorrect syntax for filtering