2026-04-276 min read

Swift Collections (Python Programming)

Learn Swift Collections (Python Programming) step by step with clear examples and exercises.

Title: Swift Collections (Python Programming) - A full guide

Why This Matters

Swift collections are a crucial part of Python programming, enabling efficient storage and manipulation of data structures such as lists, tuples, sets, and dictionaries. Understanding these collections is essential for writing clean, scalable, and high-performance code. In interviews, you may be asked to explain the differences between lists and tuples or implement custom collection classes. This guide will walk you through Swift collections, providing practical examples, common mistakes, and practice questions to help solidify your understanding.

Prerequisites

Before diving into Swift collections, it's important to have a good grasp of Python syntax and basic data types. Familiarize yourself with variables, functions, loops, and conditional statements. Having experience working with lists, tuples, and dictionaries will also be beneficial but is not required for this guide.

Core Concept

Lists

A list is a mutable sequence of elements that can contain different data types. Lists are defined using square brackets [] and separated by commas.

numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'orange']
mixed_data = [1, 'two', True, (4, 'five'), {'six': 6}]

Lists support various built-in methods for manipulating their contents:

len(list): Returns the length of the list.
list[index]: Accesses an element at a specific index.
list[-1]: Accesses the last element (negative indices count from the end).
list[start:end]: Slices the list, returning a new list with elements in the specified range.
list.append(element): Adds an element to the end of the list.
list.insert(index, element): Inserts an element at a specific index.
list.remove(element): Removes the first occurrence of the specified element.
list.pop(): Removes and returns the last element.
list.pop(index): Removes and returns the element at the specified index.
list.extend(iterable): Extends the list by appending elements from the iterable.
list.reverse(): Reverses the order of the elements in the list.
list.sort(): Sorts the elements in the list (ascending order).
list.sort(reverse=True): Sorts the elements in the list (descending order).

Tuples

A tuple is an immutable sequence of elements that can contain different data types. Tuples are defined using parentheses () and separated by commas.

tup1 = (1, 2, 3)
tup2 = ('a', 'b', 'c')
mixed_tuple = (1, 'two', True, (4, 'five'), {'six': 6})

Tuples support various built-in methods for accessing and unpacking their elements:

len(tuple): Returns the length of the tuple.
tuple[index]: Accesses an element at a specific index (read-only).
tuple[-1]: Accesses the last element (negative indices count from the end).
tuple[start:end]: Slices the tuple, returning a new tuple with elements in the specified range.
tuple + tuple2: Concatenates two tuples (creates a new tuple).
tuple * n: Repeats the tuple n times (creates a new tuple).
tuple[0], tuple[1]: Unpacks and assigns the first two elements to variables.

Sets

A set is an unordered collection of unique elements. Sets are defined using curly braces {} or the built-in set() constructor.

numbers_set = {1, 2, 3, 4, 5}
fruits_set = {'apple', 'banana', 'orange'}
mixed_set = {1, 'two', True, (4, 'five'), {'six': 6}}

Sets support various built-in methods for manipulating their contents:

len(set): Returns the number of elements in the set.
set[element]: Raises a KeyError since sets are unordered and unique (read-only).
set - set2: Computes the symmetric difference between two sets (creates a new set).
set | set2: Computes the union of two sets (creates a new set).
set & set2: Computes the intersection of two sets (creates a new set).
set ^ set2: Computes the symmetric difference between two sets (creates a new set).
set.add(element): Adds an element to the set.
set.remove(element): Removes an element from the set if it exists.
set.discard(element): Removes an element from the set if it exists (doesn't raise KeyError).
set.clear(): Removes all elements from the set.
set.copy(): Returns a shallow copy of the set.

Dictionaries

A dictionary is an unordered collection of key-value pairs. Dictionaries are defined using curly braces {}, with keys and values separated by colons, and comma-separated pairs enclosed within the braces.

person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
employee = {1: 'John', 2: 'Sarah', 3: 'Mike'}

Dictionaries support various built-in methods for manipulating their contents:

len(dict): Returns the number of key-value pairs in the dictionary.
dict[key]: Accesses the value associated with a specific key (read-only).
dict['name']: Accesses the value associated with a specific key.
dict[key] = value: Assigns a new value to the specified key.
dict.get(key, default): Returns the value associated with a specific key or the default value if the key doesn't exist.
dict.keys(): Returns a view object of the dictionary keys.
dict.values(): Returns a view object of the dictionary values.
dict.items(): Returns a view object of the dictionary items (key-value pairs).
dict.copy(): Returns a shallow copy of the dictionary.
dict.clear(): Removes all key-value pairs from the dictionary.
dict.pop(key): Removes and returns the value associated with the specified key (if it exists).

Worked Example

Let's create a simple Python program that reads a list of integers, calculates their sum, and stores the result in a dictionary with the original list as the key.

numbers = [1, 2, 3, 4, 5]
sum_dict = {}
total_sum = 0

for number in numbers:
total_sum += number
if total_sum not in sum_dict:
sum_dict[numbers] = total_sum

print(sum_dict)

Common Mistakes

Forgetting to import necessary modules or libraries.
Using lists when tuples would be more appropriate (or vice versa).
Modifying a list or tuple while iterating over it using a for loop.
Accessing an index that is out of range.
Misusing the in and not in operators with sets, lists, and tuples.
Using the wrong method (e.g., append() instead of insert()) to manipulate a list or tuple.
Forgetting to handle cases where a key may not exist in a dictionary.
Misusing dictionaries for tasks that would be better suited to other data structures like lists or sets.
Not understanding the difference between shallow and deep copying of dictionaries.
Using == instead of is when comparing objects (e.g., lists, tuples, or dictionaries).

Practice Questions

Write a Python program that takes two lists as input, computes their intersection, and stores the result in a set.
Given a list of integers, write a function that returns the second largest number (assuming there are no duplicates).
Write a Python program that reads a dictionary with employee IDs as keys and names as values, sorts the dictionary by employee IDs, and prints the sorted result.
Given two dictionaries representing sets of integers, write a function that computes their union using dictionaries (without converting them to sets).
Write a Python program that reads a list of words and returns the word with the highest frequency in the list.

FAQ

What is the difference between lists and tuples?

Lists are mutable sequences, while tuples are immutable. Tuples are often used for data that should not be modified after creation.

How can I sort a list of dictionaries in Python?

You can use the sorted() function with a custom comparison function or use the built-in sort() method along with a lambda function as its argument.

What is the time complexity of accessing an element in a dictionary by key?

Accessing an element by key in a dictionary has an average and worst-case time complexity of O(1).

How can I merge two dictionaries in Python?

You can use the update() method or the ** operator to merge two dictionaries.**

What is the difference between shallow copying and deep copying in Python?

Shallow copying creates a new object with a reference to the original object's contents, while deep copying creates a completely new copy of the original object (including nested objects).