u03-slides-data-structures-flashcards

Question 1

What are the main types of data structures in Python?

Answer 1

Sequence types (list, tuple, string, range), unordered collections (set), and mapping types (dictionary)

Question 2

How is a list created in Python?

Answer 2

Using square brackets containing comma-separated values (e.g.

Question 3

What is special about Python lists?

Answer 3

They are mutable, can contain mixed data types, can be nested, and preserve order

Question 4

At what index do Python sequences start?

Answer 4

0

Question 5

What is the difference between lists and tuples?

Answer 5

Tuples are immutable (cannot be changed after creation), while lists are mutable

Question 6

How are tuples created in Python?

Answer 6

Using comma-separated values, optionally enclosed in parentheses (e.g., my_tuple = 42, “text”, 3.14)

Question 7

What is a set in Python?

Answer 7

An unordered collection of unique elements, created using set() or curly braces

Set:
A collection of unordered, mutable, and unique elements.

Defined using curly braces {} or the set() constructor.

Example:

my_set = {1, 2, 3}
my_set = set([1, 2, 3]) # Alternative

Question 8

What are common set operations in Python?

Answer 8

Union (|), intersection (&), difference (-)

Question 9

What is a dictionary in Python?

Answer 9

A mutable and ordered collection of key-value pairs

Question 10

How are dictionaries created in Python?

Answer 10

Output: {‘key1’: ‘value1’, ‘key2’: ‘value2’, ‘key3’: ‘value3’}

1. Using Curly Braces

my_dict = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3"
}
print(my_dict)

2. Using the dict() Constructor

my_dict = dict(key1="value1", key2="value2", key3="value3")
print(my_dict)
# Output: {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

3. From a List of Tuples
- Convert a list of key-value tuples into a dictionary:

my_dict = dict([("key1", "value1"), ("key2", "value2"), ("key3", "value3")])
print(my_dict)
# Output: {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

4. Using Dictionary Comprehension
- Create a dictionary dynamically:

my_dict = {x: x**2 for x in range(1, 4)}
print(my_dict)
# Output: {1: 1, 2: 4, 3: 9}

5. From Two Separate Iterables
- Use the zip() function to pair keys and values:

keys = ["key1", "key2", "key3"]
values = ["value1", "value2", "value3"]
my_dict = dict(zip(keys, values))
print(my_dict)
# Output: {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

6. Empty Dictionary
- Create an empty dictionary:

my_dict = {}
print(my_dict)
# Output: {}

Question 11

What can be used as dictionary keys?

Answer 11

Any hashable object

Question 12

What can be used as dictionary values?

Answer 12

Any object

Question 13

What is a list comprehension?
Explain the key concepts!

Answer 13

Output: [0, 1, 4, 9, 16]

A compact way to create a list by looping over an iterable, with optional filtering and transformations

Key Concepts:

1. Basic Syntax:

[expression for item in iterable]

2. With Filter:

[expression for item in iterable if condition]

3. Transform and Filter Together:

[transform for item in iterable if condition]

Question 14

Create a list of squares using list comprehension (base values zero to five)

Answer 14

Simple List Comprehension

A list comprehension creates a new list by iterating over an existing sequence.

Example 1: Create a list of squares

squares = [x**2 for x in range(5)]
print(squares)

Question 15

Filter even numbers using list comprehension for the integer numbers from zero to ten

Answer 15

Output: [0, 2, 4, 6, 8]

List Comprehension with Filters

You can add a condition to include only certain elements in the resulting list.

Example 2: Filter even numbers

even_numbers = [x for x in range(10) if x % 2 == 0]
print(even_numbers)

Question 16

Using list comprehension create a list containing the double value of each element in a range from 0 to 5.

Answer 16

Output: [0, 2, 4, 6, 8]

List Comprehension with Transformers

You can apply a transformation to each element in the list.

Example 3: Double the value of each element

doubled_numbers = [x * 2 for x in range(5)]
print(doubled_numbers)

Question 17

Create a list of the squares of the odd numbers from 0 to 10 using list comprehension.

Answer 17

Output: [1, 9, 25, 49, 81]

Combining Filters and Transformers

You can filter elements and then transform them in the same comprehension.

Example 4: Squares of odd numbers

odd_squares = [x**2 for x in range(10) if x % 2 != 0]
print(odd_squares)

Question 18

What does this output

Example 5: Create a multiplication table

multiplication_table = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print(multiplication_table)

Answer 18

Output: [[1, 2, 3], [2, 4, 6], [3, 6, 9]]

[[1, 2, 3], [2, 4, 6], [3, 6, 9]]

You can use a list comprehension inside a

Nested List Comprehension

Question 19

What is the syntax for slicing in Python?

Answer 19

sequence[start:end:step] where start is inclusive and end is exclusive

Question 20

What happens when using negative numbers in slicing?

Answer 20

They count from the end (-1 for last element, -2 for second-last, etc.)

Question 21

What is unpacking in Python?

Answer 21

Tuple unpacking

Assigning values from a sequence directly to multiple variables (e.g., a, b, c = [1, 2, 3])

Question 22

How to unpack the following tuple or list into x, y coordinates?

point = (3, 4)

Answer 22

Unpacking a Tuple or List
~~~
point = (3, 4)
x, y = point
print(x) # Output: 3
print(y) # Output: 4

List unpacking
colors = [“red”, “green”, “blue”]
a, b, c = colors
print(a, b, c) # Output: red green blue
~~~

Question 23

What will the following code do and what do you call the operation?

numbers = [1, 2, 3, 4, 5]
a, b, *rest = numbers
start, *middle, end = numbers

Answer 23

Using * for Variable-Length Unpacking
~~~
numbers = [1, 2, 3, 4, 5]

First two into separate variables, the rest into another
a, b, *rest = numbers
print(a, b, rest) # Output: 1 2 [3, 4, 5]

Collect the middle values
start, *middle, end = numbers
print(start, middle, end) # Output: 1 [2, 3, 4] 5
~~~

Question 24

What does this code do and what du you call the operaton?

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

for number, letter in pairs:
    print(f"Number: {number}, Letter: {letter}")

Answer 24

Unpacking in a Loop
~~~
pairs = [(1, ‘a’), (2, ‘b’), (3, ‘c’)]

for number, letter in pairs:
print(f”Number: {number}, Letter: {letter}”)
# Output:
# Number: 1, Letter: a
# Number: 2, Letter: b
# Number: 3, Letter: c
~~~

Question 25

How to unpact first the keys only and second the keys and values from the dictionary:

my_dict = {"name": "Alice", "age": 30}

Answer 25

Unpack keys

Unpacking Dictionaries
~~~
my_dict = {“name”: “Alice”, “age”: 30}

for key in my_dict:
print(key)
# Output: name age

for key, value in my_dict.items():
print(f”{key}: {value}”)
# Output:
# name: Alice
# age: 30
~~~

Question 26

What does immutable mean in Python?

Answer 26

Objects that cannot be changed after creation (e.g.

Question 27

What does mutable mean in Python?

Answer 27

Objects that can be changed after creation (e.g.

Question 28

Which of the following data type are immutable:

Custom Object, Strings, Tuples, Frozen Sets, Dictionaries, Sets, Booleans, Lists, Bytes, Byte Array

Answer 28

Examples of Immutable Data Types:
1. Numbers:
* Integers (int): 42
* Floating-point numbers (float): 3.14
* Complex numbers (complex): 2 + 3j
2. Strings (str): “hello”
3. Tuples (tuple): (1, 2, 3)
4. Frozen Sets (frozenset): frozenset([1, 2, 3])
5. Booleans (bool): True, False
6. Bytes (bytes): b”immutable”

Question 29

Which of the following data type are mutable:

Custom Object, Strings, Tuples, Frozen Sets, Dictionaries, Sets, Booleans, Lists, Bytes, Byte Array

Answer 29

Mutable Data Types

These can be modified after creation. Operations that modify their contents affect the same object in memory.

Examples of Mutable Data Types:
1. Lists (list): [1, 2, 3]
2. Dictionaries (dict): {“key”: “value”}
3. Sets (set): {1, 2, 3}
4. Byte Arrays (bytearray): bytearray(b”mutable”)
5. Custom Objects: If the class allows modifications to its attributes.

Question 30

What happens when you assign a mutable object to a new variable?

Answer 30

Both variables reference the same object, changes to one affect the other (alias effect)

Question 31

How can you avoid side effects with mutable objects?

Answer 31

By making a copy of the object before modifying it

Question 32

What are some examples of immutable objects in Python?

Answer 32

Integers, tuples, strings

Question 33

What are some examples of mutable objects in Python?

Answer 33

Lists, dictionaries, sets

Question 34

Why is dictionary order significant in Python?

Answer 34

Since Python 3.7 dictionaries preserve insertion order

Question 35

What happens if you add a duplicate key to a dictionary?

Answer 35

It overwrites the previous value for that key

Question 36

What happens when you slice with a negative step?

Answer 36

It reverses the order (e.g., my_list[::-1] reverses the entire sequence)