Collections and Data Structures

In computer programming, a collection is a grouping of some variable number of data items (possibly zero) that have some shared significance to the problem being solved and need to be operated upon together in some controlled fashion. [1]

This page provides syntax for different types of collections and data structures in Python (arrays, sets, dictionaries, etc.). Each section includes an example to demonstrate the described methods

Arrays

Arrays are ordered collections of elements. In Python they are automatically indexed (consecutively numbered) by an integer starting with 0.

Action	Syntax
New array (empty)	[]
Array with values (integers)	[1, 2, 3, 4, 5]
Array with values (string)	[“a1”, “ab2”, “c3”]
Array of numbers	list(range(1, 11))

Creating Array From String

Action	Syntax
Split string str by delimiter into words (e.g., space)	str.split(“ “)

Accessing Elements

Action	Syntax
Get length of array my_array	len(my_array)
Get first element of array my_array	my_array[0]
Get last element of array my_array	my_array[-1]
Get nth element of array my_array(e.g., 2)	my_array[1]
Check if element is in array	str in my_array

Adding and Removing Elements

Action	Syntax
Add element to end	my_array.append(str)
Remove element from end	my_array.pop()
Remove element from beginning	my_array.pop(0)
Add element to beginning	my_array.insert(0, str)

Sort and Unique

Action	Syntax
Sort array (will not change array itself)	sorted(my_array)
Sort array in place (will change array)	my_array.sort()
Get unique elements in array	list(set(my_array))

Compare Arrays

Action	Syntax
Intersection	set(my_array).intersection(your_array)
Union	set(my_array).union(your_array)

Input:

# Initialize the list and day variable
day_array = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
day = "Thursday"

# Get the array length and specific days
array_length = len(day_array)
array_first_day = day_array[0]  # Indexing in Python starts at 0
array_last_day = day_array[-1]  # Python's negative indexing for last element

# Print information about the array
print(f"Length of array: {array_length}")
print(f"First day of week: {array_first_day}")
print(f"Third day of week: {day_array[2]}")
print(f"Last day of week: {array_last_day}")

# Check if the day is in the array
print(f"{day} is in {day_array}: {day in day_array}")

# Add "Sunday" to the beginning and "Saturday" to the end
day_array.insert(0, "Sunday")
day_array.append("Saturday")

# Print each element in the array
print("Day of week:")
for day in day_array:
    print(f"  {day}")

# Join array elements with ";" and print
print(f"Day of the week: {';'.join(day_array)}")

# Sort the array and print again
day_array.sort()
print(f"Day of the week (sorted): {';'.join(day_array)}")

Output:

Length of array: 5
First day of week: Monday
Third day of week: Wednesday
Last day of week: Friday
Thursday is in ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']: True
Day of week: 
  Sunday
  Monday
  Tuesday
  Wednesday
  Thursday
  Friday
  Saturday
Day of the week: Sunday;Monday;Tuesday;Wednesday;Thursday;Friday;Saturday
Day of the week (sorted): Friday;Monday;Saturday;Sunday;Thursday;Tuesday;Wednesday

Sets

Sets are an unordered collection of unique elements.

Creating Sets

Action	Syntax
New set (empty)	[]
Set with values	my_set = {1, 2, 3, 4, 5}
Set with values	my_set = {"a1", "b2", "c3"}

Interacting With Sets

Action	Syntax
Get length of set my_set	len(my_set)
Check if value is in set	"str" in my_set
Add value	my_set.add("str")

Comparing Sets

Action	Syntax
Intersection	my_set.intersection(your_set)
Union	my_set.union(your_set)
Difference	my_set.difference(your_set)

Input:

color_set = {"red", "yellow", "blue"}
color_set2 = {"red", "orange", "yellow"}

print("Length of set:", len(color_set))

print("Color Set 1")
for color in color_set:
    print("  ", color)

print("Color Set 2:", "---".join(color_set2))

print("Intersection:", color_set.intersection(color_set2))
print("Union:", color_set.union(color_set2))
print("Difference:", color_set.difference(color_set2))
print("Difference:", color_set2.difference(color_set))

Output:

Length of set: 3
Color Set 1
  yellow
  blue
  red
Color Set 2: yellow---orange---red
Intersection: {'yellow', 'red'}
Union: {'yellow', 'orange', 'blue', 'red'}
Difference: {'blue'}
Difference: {'orange'}

Dictionaries

Dictionaries are unordered collection of key-value pairs where the key serves as the index (“associative collection”). Similar to elements of a set, keys are always unique.

Creating Dictionaries

Action	Syntax
New Dictionary (empty)	{}
Dictionary with values	{"one": 1, "two": 2, "three": 3, "four": 4}

Accessing Dictionaries

Action	Syntax
Get value for key in dictionary my_dict	my_dict["one"]
Check if dictionary has key	"one" in my_dict
Check for key/value pair	("one", 1) in my_dict.items()
Get value and set default	my_dict.get("one", 5) my_dict.setdefault("five", 5)
Add key/value pair	my_dict["five"] = 5
Delete key/value pair	my_dict.pop("four", None)
Get keys	my_dict.keys()
Get values	my_dict.values()

Converting Dictionaries

Action	Syntax
Convert keys to array	list(my_dict.keys())
Convert values to array	list(my_dict.values())

Sorting Dictionaries

Sorting keys	sorted(my_dict.keys())
Sorting values	sorted(my_dict.values())
Sort by value (descending) with keys	sorted(my_dict.items(), key=lambda x: x[1], reverse=True)
Sort by value (ascending) with keys	sorted(my_dict.items(), key=lambda x: x[1])
Get top n by value (e.g., 3)	sorted(my_dict.items(), key=lambda x: x[1], reverse=True)[:3]

Input:

day_dict = {}
day_length_dict = {}

day_dict["Mon"] = "Monday"
day_dict["Tue"] = "Tuesday"
day_dict["Wed"] = "Wednesday"
day_dict["Thu"] = "Thursday"
day_dict["Fri"] = "Friday"

if "Wed" in day_dict:
    print(day_dict["Wed"])

if "Sat" not in day_dict:
    print('no key "Sat"')

print("print key-value pairs")
for day in day_dict.keys():
    print(f"  {day} = {day_dict[day]}")

print("print values (sorted)")
for day_value in sorted(day_dict.values()):
    print(f"  {day_value}")

# get length of each value and keep track of lengths
for day_value in day_dict.values():
    day_length = len(day_value)
    day_length_dict[day_value] = day_length

print("print lengths")
for day in day_length_dict.keys():
    print(f"  {day} = {day_length_dict[day]}")

print("print lengths in descending order")
for length, day in sorted(zip(day_length_dict.values(), day_length_dict.keys()), reverse=True):
    print(f"  {day} = {length}")

print("print lengths in ascending order")
for length, day in sorted(zip(day_length_dict.values(), day_length_dict.keys()), reverse=False):
    print(f"  {day} = {length}")

Output:

Wednesday
no key "Sat"
print key-value pairs
  Mon = Monday
  Tue = Tuesday
  Wed = Wednesday
  Thu = Thursday
  Fri = Friday
print values (sorted)
  Friday
  Monday
  Thursday
  Tuesday
  Wednesday
print lengths
  Monday = 6
  Tuesday = 7
  Wednesday = 9
  Thursday = 8
  Friday = 6
print lengths in descending order
  Wednesday = 9
  Thursday = 8
  Tuesday = 7
  Monday = 6
  Friday = 6
print lengths in ascending order
  Friday = 6
  Monday = 6
  Tuesday = 7
  Thursday = 8
  Wednesday = 9

References

1. Wikipedia contributors (n.d.). Collection. In Wikipedia. Retrieved May 1, 2024, from https://en.wikipedia.org/wiki/Collection_(abstract_data_type)

Resources

• W3 Schools: Python Data Structures

• Data Quest: Python Data Structures