10.1 Dictionary basics

Dictionaries in Python are powerful tools for organizing and accessing data. They use key-value pairs, allowing quick retrieval of information based on unique identifiers. This structure is perfect for tasks like counting occurrences or representing relationships between entities.

Python's dictionary methods offer versatile ways to manipulate data. From merging dictionaries to creating them from other data structures, these methods provide flexibility. Advanced concepts like hashing and dynamic typing further enhance dictionaries' efficiency and adaptability in various programming scenarios.

Dictionary Fundamentals

Creation of dictionary objects

Top images from around the web for Creation of dictionary objects

• 

  Python Data Structures View original

  Is this image relevant?

• 

  Python Programming: Dictionaries View original

  Is this image relevant?

• 

  python - Immutable vs Mutable types - Stack Overflow View original

  Is this image relevant?

• 

  Python Data Structures View original

  Is this image relevant?

• 

  Python Programming: Dictionaries View original

  Is this image relevant?

1 of 3

Top images from around the web for Creation of dictionary objects

• 

  Python Data Structures View original

  Is this image relevant?

• 

  Python Programming: Dictionaries View original

  Is this image relevant?

• 

  python - Immutable vs Mutable types - Stack Overflow View original

  Is this image relevant?

• 

  Python Data Structures View original

  Is this image relevant?

• 

  Python Programming: Dictionaries View original

  Is this image relevant?

1 of 3

• Dictionaries are unordered collections of key-value pairs where keys must be unique and immutable objects (strings, numbers, or tuples) and values can be of any data type and can be duplicated
• Create dictionaries using curly braces

  my_dict = {"key1": value1, "key2": value2}

  or the

  ###[dict](https://www.fiveableKeyTerm:dict)()_0###

  constructor

  my_dict = dict(key1=value1, key2=value2)

• Add or update key-value pairs using square bracket notation

  my_dict["new_key"] = new_value

  or the

  [update()](https://www.fiveableKeyTerm:update())

  method

  my_dict.update({"new_key": new_value})

• Remove key-value pairs using the

  [del](https://www.fiveableKeyTerm:del)

  statement

  del my_dict["key"]

  or the

  [pop()](https://www.fiveableKeyTerm:pop())

  method

  value = my_dict.pop("key")

• Key uniqueness is enforced, ensuring that each key in the dictionary is distinct

Manipulation of dictionary elements

• Access values using keys with square bracket notation

  value = my_dict["key"]

  or the

  [get()](https://www.fiveableKeyTerm:get())

  method

  value = my_dict.get("key")

• Check for key existence using the

  in

  operator

  if "key" in my_dict:

  or the

  [keys()](https://www.fiveableKeyTerm:keys())

  method

  if "key" in my_dict.keys():

• Iterate over dictionaries by keys

  for key in my_dict:

  , values

  for value in my_dict.[values()](https://www.fiveableKeyTerm:values()):

  , or key-value pairs

  for key, value in my_dict.[items()](https://www.fiveableKeyTerm:items()):

  (iteration)
• Useful dictionary methods include

  len(my_dict)

  to return the number of key-value pairs,

  my_dict.[clear()](https://www.fiveableKeyTerm:clear())

  to remove all key-value pairs, and

  my_dict.[copy()](https://www.fiveableKeyTerm:copy())

  to return a shallow copy of the dictionary

Dictionaries vs other data structures

• Dictionaries are unordered and use keys to access values, while lists are ordered and use indices (arrays)
• Dictionaries are mutable, while tuples are immutable but both use keys or indices to access values
• Dictionaries store key-value pairs, while sets store unique elements and both are unordered and provide fast membership testing (hash tables)
• Use dictionaries to store and retrieve data based on unique identifiers (user IDs, product codes), count occurrences of items (word frequencies, vote counts), or represent relationships between entities (phone books, student grades)
• Dictionaries offer efficient lookup operations (lookup efficiency) due to their underlying hash table implementation

Dictionary Methods and Operations

Creation of dictionary objects

• Merge dictionaries using the

  update()

  method

  dict1.update(dict2)

  or the unpacking operator (

  **

  )

  merged_dict = {**dict1, **dict2}

• Create dictionaries from other data structures like lists of tuples

  dict([(key1, value1), (key2, value2)])

  or two parallel lists

  dict(zip(keys_list, values_list))

Manipulation of dictionary elements

• Access nested dictionaries using chained square bracket notation

  value = my_dict["key1"]["key2"]

  or the

  get()

  method

  value = my_dict.get("key1", [{}](https://www.fiveableKeyTerm:{})).get("key2")

• Modify dictionary values by incrementing

  my_dict["key"] += 1

  or appending to list values

  my_dict["key"].append(new_item)

• Useful dictionary methods:

  1. my_dict.setdefault("key", default_value)

     returns the value for the key if it exists, otherwise sets the key with the default value and returns it

  2. my_dict.[popitem()](https://www.fiveableKeyTerm:popitem())

     removes and returns an arbitrary key-value pair as a tuple

  3. my_dict.fromkeys(keys_iterable, value=None)

     creates a new dictionary with keys from the iterable and optional default value

Dictionaries vs other data structures

• [defaultdict](https://www.fiveableKeyTerm:defaultdict)

  is a subclass of

  dict

  that allows specifying a default value for missing keys and is useful for counting or grouping items without explicitly checking for key existence

• [OrderedDict](https://www.fiveableKeyTerm:OrderedDict)

  is a subclass of

  dict

  that remembers the order in which key-value pairs were added and is useful when the order of insertion matters (LRU caches, preserving configuration file structure)
• Advanced use cases for dictionaries include memoization to store results of expensive function calls, graph representation using adjacency lists or matrices, and dynamic programming to store intermediate results for overlapping subproblems

Advanced Dictionary Concepts

Hashing and Immutability

• Dictionary keys must be immutable (immutability) to ensure consistent hashing
• Hashing is the process of converting keys into unique fixed-size values for efficient storage and retrieval
• Immutable objects like strings, numbers, and tuples are hashable and can be used as dictionary keys

Dynamic Typing and Efficiency

• Python's dynamic typing allows dictionaries to store values of different types
• Dynamic typing enables flexible data structures but requires careful type checking in some cases