🐍Intro to Python Programming Unit 10 – Dictionaries

What Are Dictionaries?

• Dictionaries are a built-in data type in Python used to store and organize data in key-value pairs
• Consist of a collection of keys, each associated with a specific value
• Keys must be unique and immutable objects (strings, numbers, or tuples), while values can be of any data type
• Provide efficient lookup and retrieval of values based on their associated keys
• Unordered data structure, meaning the elements are not stored in a specific order
• Enclosed in curly braces

  {}

  with each key-value pair separated by a comma
• Useful for representing real-world objects or entities with multiple attributes (person with name, age, and address)

Creating and Accessing Dictionaries

• Dictionaries can be created using curly braces

  {}

  or the

  dict()

  constructor
• Key-value pairs are defined using a colon

  :

  to separate the key from its corresponding value
• Values are accessed by specifying the key within square brackets

  []

• Attempting to access a key that doesn't exist raises a

  KeyError

• The

  get()

  method can be used to retrieve a value by its key, returning a default value if the key is not found
  • Syntax:

    dictionary.get(key, default_value)

• Individual key-value pairs can be added or modified using the square bracket notation

  dictionary[key] = value

• Dictionaries are mutable, allowing for the addition, modification, and deletion of key-value pairs

Dictionary Methods and Operations

• len(dictionary)

  returns the number of key-value pairs in the dictionary

• dictionary.keys()

  returns a view object containing all the keys in the dictionary

• dictionary.values()

  returns a view object containing all the values in the dictionary

• dictionary.items()

  returns a view object containing all the key-value pairs as tuples

• dictionary.update(other_dictionary)

  merges the key-value pairs from

  other_dictionary

  into the original dictionary

• dictionary.pop(key)

  removes and returns the value associated with the specified key, raising a

  KeyError

  if the key is not found

• dictionary.clear()

  removes all key-value pairs from the dictionary, leaving it empty

• del dictionary[key]

  removes the key-value pair with the specified key from the dictionary

• key in dictionary

  checks if a key exists in the dictionary, returning

  True

  or

  False

Nested Dictionaries

• Dictionaries can contain other dictionaries as values, creating nested or hierarchical structures
• Nested dictionaries are useful for representing complex data with multiple levels of organization (employee records with personal info and job details)
• Accessing values in nested dictionaries involves chaining square brackets or using the

  get()

  method for each level
  • Example:

    employee_data[employee_id]['personal_info']['address']

• Modifying or adding values in nested dictionaries follows a similar approach, using square brackets to navigate through the levels

Dictionary Comprehensions

• Dictionary comprehensions provide a concise way to create dictionaries based on existing iterables or conditions
• Similar to list comprehensions, dictionary comprehensions use curly braces

  {}

  and a key-value pair definition
• Syntax:

  {key_expression: value_expression for item in iterable if condition}

• Key and value expressions define how the keys and values are derived from the iterable
• The

  if

  condition is optional and filters the items from the iterable
• Dictionary comprehensions are useful for transforming data or creating dictionaries with computed keys and values

Common Use Cases for Dictionaries

• Storing and accessing data based on unique identifiers or keys (student records, product catalogs)
• Counting the frequency of items in a list or string
  • Example:

    word_count = {word: text.count(word) for word in set(text.split())}

• Grouping or categorizing data based on specific criteria (grouping employees by department)
• Implementing lookup tables or mappings between different sets of values
• Caching expensive computations or frequently accessed data for faster retrieval
• Representing graph data structures, where vertices are keys and edges are stored as values (adjacency list representation)

Dictionaries vs. Other Data Structures

• Dictionaries provide fast lookup and retrieval of values based on keys, with an average time complexity of O(1)
• Lists and tuples are ordered sequences accessed by integer indices, while dictionaries are unordered and accessed by keys
• Sets are unordered collections of unique elements, similar to the keys in a dictionary, but without associated values
• Arrays in Python (NumPy) are optimized for numerical computations and have fixed sizes, while dictionaries are more flexible and can store heterogeneous data types
• Dictionaries are suitable for scenarios requiring fast key-based access, while lists and tuples are used for ordered sequences, and sets for unique elements

Advanced Dictionary Techniques

• Dictionaries can be sorted by keys or values using the

  sorted()

  function and a key function
  • Example:

    sorted(dictionary.items(), key=lambda x: x[1])

    sorts the dictionary by values
• The

  defaultdict

  from the

  collections

  module automatically initializes missing keys with a default value or factory function
  • Useful for counting or grouping elements without explicitly checking for key existence
• The

  Counter

  class from the

  collections

  module is a subclass of

  dict

  used for counting hashable objects
  • Provides methods like

    most_common()

    to retrieve the most common elements and their counts
• Dictionaries can be serialized and deserialized using the

  json

  module for data exchange or storage

  • json.dumps(dictionary)

    converts a dictionary to a JSON string

  • json.loads(json_string)

    converts a JSON string back to a dictionary