What Constitutes a Dictionary?

A dictionary is a specialized data type that organizes data in key-value pairs, allowing values to be indexed by their corresponding keys. Other terms that can be used interchangeably with dictionaries include associative arrays, maps, and symbol tables. For example:

country_languages = {

"en": "English",

"es": "Spanish",

"pl": "Polish"

}

Dictionaries in Python

In Python, dictionaries are represented through the dict structure. They are one of the built-in data collections in the language, characterized by the following features:

• Dictionaries are mutable.
• Keys must be immutable (refer to section 8).
• Dictionaries preserve the order of insertion (see section 7).

Basic Operations

To create an empty dictionary:

country_languages = {}

To add a key-value pair:

country_languages["en"] = "English"

To check for a key's existence:

if "en" in country_languages:

...

To retrieve a value by key:

country_languages["en"]

To delete a key along with its associated value:

del country_languages["en"]

Initialization of a Non-Empty Dictionary

You can initialize a dictionary with key-value pairs in several ways:

• Using a dictionary literal:

country_languages = {"en": "English", "es": "Spanish"}

• Using the dict constructor:

country_languages = dict(en="English", es="Spanish")

• From a list of tuples:

country_languages = dict(("en", "English"), ("es", "Spanish"))

For each of these methods, the resulting dictionary will be:

{

"en": "English",

"es": "Spanish"

}

Retrieving Values by Key

When accessing a dictionary with the bracket notation, the specified key must exist; otherwise, an exception will be raised. To safely check for a key before accessing it, you can use the ternary operator:

value = country_languages["en"] if "en" in country_languages else None

Alternatively, you can use the get method:

value = country_languages.get("en", None)

Inserting Default Values

The get method allows you to retrieve a default value for a non-existent key without altering the dictionary. If you wish to insert a default value upon access, the setdefault method is more appropriate. This can be especially useful when organizing a collection of items by a specific attribute. For instance, if you have a list of names that you want to group by their length:

names = ["Jo", "John", "Chris", "Mark", "Ivona"]

lengths = {}

for name in names:

lengths.setdefault(len(name), []).append(name)

To better understand the performance implications of these methods, consider the following:

Retaining Order of Insertion

The dict type in Python has the beneficial feature of maintaining the order of element insertion. This characteristic can be advantageous in specific algorithmic tasks, such as identifying the first distinct element in a list.

To achieve this, you can create a function that utilizes a dictionary to track occurrences:

def first_distinct_item(items: list[str]) -> str:

groups = defaultdict(list)

for item in items:

groups[item].append(1)

for k, v in groups.items():

if len(v) == 1:

return k

return None

Comparing this with a method that does not leverage insertion order can illustrate its efficiency:

def first_distinct_item_2pass(items: list[str]) -> str:

groups = defaultdict(list)

for item in items:

groups[item].append(1)

for item in items: # Second iteration

if len(groups.get(item, [])) == 1:

return item

return None

By utilizing the order of insertion, the processing time can be significantly reduced.

The Importance of Immutable Keys

In a dictionary, keys must be immutable. You can use various basic types (e.g., int, float, str) or tuples as keys. However, lists, sets, and other dictionaries are not permissible due to their mutable nature.

Custom objects can be used as keys as long as you implement __hash__ and __eq__ methods. Here’s an example:

from dataclasses import dataclass

@dataclass

class Person:

first_name: str

last_name: str

def __repr__(self):

return f"{self.first_name} {self.last_name}"

p1 = Person("John", "Smith")

p2 = Person("John", "Smith")

p3 = Person("Paul", "Smith")

people = {p1: p1.first_name, p2: p2.first_name, p3: p3.first_name}

print(people)

In conclusion, understanding the various applications and capabilities of dictionaries in Python is essential for efficiently implementing algorithms. In subsequent discussions, we will explore several algorithmic challenges that leverage the power of dictionaries for enhanced performance.

Thank you for your attention!

This video titled "Python 3.7: Introduction To Python Dictionaries" provides foundational insights into dictionaries, making it a great starting point for understanding their significance in Python.

The second video, "6 of Python's Newest and Best Features (3.7-3.9)," highlights some of the latest enhancements in Python, including improvements related to dictionaries.