6. Introducing Dictionaries (36m) Flashcards
What are dictionaries in python?
In Python, a dictionary is an unordered collection of key-value pairs. It is a versatile and powerful data structure that allows you to store, retrieve, and manipulate data efficiently. Dictionaries are also known as associative arrays or hash maps in other programming languages.
Here are some key features of dictionaries in Python:
1. Key-Value Pairs: Each element in a dictionary is a key-value pair, where the key is unique and used to access its associated value. The key and value can be of any immutable data type, such as strings, numbers, or tuples.
2. Mutable: Dictionaries are mutable, which means you can modify them by adding, updating, or deleting key-value pairs.
3. Unordered: Unlike sequences like lists or tuples, dictionaries are not ordered. The elements in a dictionary are not stored in a specific order, and you access them by their keys rather than their positions.
4. Dynamic: Dictionaries can dynamically grow or shrink as you add or remove elements. They provide a flexible way to organize and manage data.
5. Fast Lookup: Dictionaries use a hash-based indexing mechanism, allowing for fast lookup and retrieval of values based on their keys. This makes dictionaries suitable for scenarios that require efficient searching or mapping operations.
Here’s an example of a dictionary in Python:
~~~
student = {
“name”: “John Doe”,
“age”: 20,
“grade”: “A”,
“courses”: [“Math”, “English”, “Science”]
}
~~~
In this example, student is a dictionary with keys (“name”, “age”, “grade”, “courses”) and their associated values. You can access the values by using the corresponding keys. For example, student[“name”] would return the value “John Doe”.
Dictionaries are widely used for various purposes, such as storing and retrieving data, mapping relationships, caching information, and organizing structured data. They provide a powerful tool for working with flexible and dynamic collections of data in Python.
Explain the following code:
course = {"teacher":"Ashley", "course":"Introducing Dictionaries", "level":"Beginner"}
print(course["teacher"])
The given code demonstrates the use of dictionaries in Python.
In Python, a dictionary is a data structure that stores a collection of key-value pairs. Each key-value pair is called an item, and the key is used to access the corresponding value.
In this code, a dictionary named course is created with three key-value pairs: “teacher”, “course”, and “level”. The keys are strings, and the values can be of any data type. Here’s what each key-value pair represents:
- “teacher”: The value associated with this key is “Ashley”. This indicates that the teacher of the course is Ashley.
- “course”: The value associated with this key is “Introducing Dictionaries”. This represents the name of the course.
- “level”: The value associated with this key is “Beginner”. This indicates the level of the course.
After creating the dictionary, the code prints the value corresponding to the key “teacher” using the print() function. It accesses the value by using square brackets ([]) and providing the key inside them, like course[“teacher”].
So, when the code is executed, it will output:Ashley
This means that the teacher of the course is Ashley.
what does .keys() method do in Python?
In Python, the .keys() method is used to retrieve a list-like view of all the keys in a dictionary. It returns a view object that provides access to the keys of the dictionary.
Here’s an example to illustrate its usage:
~~~
course = {“teacher”: “Ashley”, “course”: “Introducing Dictionaries”, “level”: “Beginner”}
keys = course.keys()
print(keys)
~~~
Output:
~~~
dict_keys([‘teacher’, ‘course’, ‘level’])
~~~
In the example, the .keys() method is called on the course dictionary, which returns a view object containing the keys of the dictionary. This view object behaves like a list in some ways, although it is not an actual list.
In this case, the keys variable holds the view object returned by .keys(), and when it is printed, it displays the keys enclosed in dict_keys([]).
You can use this view object to perform various operations, such as iterating over the keys using a loop or converting it to a list using the list() function if necessary.
~~~
# Iterating over the keys
for key in course.keys():
print(key)
Converting the keys to a list
key_list = list(course.keys())
print(key_list)
~~~
Output:
~~~
teacher
course
level
[‘teacher’, ‘course’, ‘level’]
~~~
Overall, the .keys() method provides a convenient way to access the keys of a dictionary, allowing you to perform operations or extract information based on the keys.
what does .values() do in Python?
In Python, the .values() method is used to retrieve a list-like view of all the values in a dictionary. It returns a view object that provides access to the values of the dictionary.
Here’s an example to illustrate its usage:
~~~
course = {“teacher”: “Ashley”, “course”: “Introducing Dictionaries”, “level”: “Beginner”}
values = course.values()
print(values)
~~~
Output:
~~~
dict_values([‘Ashley’, ‘Introducing Dictionaries’, ‘Beginner’])
~~~
In the example, the .values() method is called on the course dictionary, which returns a view object containing the values of the dictionary. This view object behaves like a list in some ways, although it is not an actual list.
In this case, the values variable holds the view object returned by .values(), and when it is printed, it displays the values enclosed in dict_values([]).
You can use this view object to perform various operations, such as iterating over the values using a loop or converting it to a list using the list() function if necessary.
# Iterating over the values
for value in course.values():
print(value)
Converting the values to a list
value_list = list(course.values())
print(value_list)
Output:
~~~
Ashley
Introducing Dictionaries
Beginner
[‘Ashley’, ‘Introducing Dictionaries’, ‘Beginner’]
~~~
Overall, the .values() method provides a convenient way to access the values of a dictionary, allowing you to perform operations or extract information based on the values.
What does sorted() do in python? and explain the following code:
course = {"teacher":"Ashley", "course":"Introducing Dictionaries", "level":"Beginner"}
keys = sorted(course.keys())
print(keys)
In Python, the sorted() function is used to sort iterable objects, such as lists, tuples, or dictionary keys, in ascending order. It takes an iterable as an argument and returns a new sorted list containing the elements of the original iterable.
In the given code:
The dictionary course is defined with three key-value pairs. The .keys() method is used to retrieve a view object of all the keys in the dictionary. Then, the sorted() function is applied to the view object returned by course.keys().
The sorted() function sorts the keys alphabetically in ascending order and returns a new list of sorted keys. Finally, the sorted keys are printed using the print() function.
Output:
~~~
[‘course’, ‘level’, ‘teacher’]
~~~
In this case, the sorted keys are [‘course’, ‘level’, ‘teacher’], which is the alphabetical order of the original keys of the dictionary.
It’s worth noting that the sorted() function does not modify the original dictionary or change the order of the key-value pairs in the dictionary itself. It only returns a sorted list of keys based on the specified sorting criteria.
- Create a dictionary with the following key value pairs: 1) key: ‘name’, value: ‘’, 2) key: ‘topic’, value: ‘python’. Assign this dictionary to a variable called student.
- On an empty line beneath the existing code, create a variable called topic and assign to this variable the value of the topic key in the student dictionary.
Answer to 1:
~~~
student = {‘name’:’’, ‘topic’:’python’}
~~~
Answer to 2:
~~~
student = {‘name’:’’, ‘topic’:’python’}
topic = student[‘topic’]
~~~
In the following code:
course = {'teacher':'Ashley', 'title':'Introducing Dictionaries', 'level':'Beginner'}
Do the following:
1. Change teacher name to ‘Treasure’
2. Change level to ‘Intermediate’
3. Add a key called stages with value 2.
4. Delete the stages key.
The code to the task in interactive python is:
For 1:
~~~
course[‘teacher’] = ‘treasure’
~~~
For 2:
~~~
course[‘level’] = ‘intermediate’
~~~
For 3:
~~~
course[‘stages’] = 2
~~~
For 4:
~~~
del(course[‘stages’])
~~~
Explain the following code:
course = {'teacher':'Ashley', 'title':'Introducing Dictionaries', 'level':'Beginner'}
for item in course:
print(item)
print(course[item])
The given code demonstrates how to iterate over a dictionary in Python using a for loop.
First, a dictionary named course is defined with three key-value pairs: ‘teacher’, ‘title’, and ‘level’. Each key represents a specific attribute of the course, and the corresponding value provides the associated information.
The for loop is then used to iterate over the dictionary course. In each iteration, the loop variable item takes on the keys of the dictionary.
Within the loop, there are two print() statements:
1. print(item) - This line prints the current key (item) being processed in the loop. It represents the attribute of the course, such as ‘teacher’, ‘title’, or ‘level’.
2. print(course[item]) - This line prints the value associated with the current key (item). It accesses the value of the dictionary course by using the current key (item) in square brackets. It represents the corresponding information for the attribute, such as the teacher’s name, the course title, or the level of the course.
Here’s the output you would get when running this code:
~~~
teacher
Ashley
title
Introducing Dictionaries
level
Beginner
~~~
As the loop iterates over the dictionary, it prints each key and its corresponding value on separate lines. This allows you to see the attributes of the course and the associated information in a structured manner.
what does .items() do in python?
In Python, the .items() method is used to retrieve a list-like view of all the key-value pairs in a dictionary. It returns a view object that provides access to the key-value pairs of the dictionary.
Here’s an example to illustrate its usage:
~~~
course = {“teacher”: “Ashley”, “course”: “Introducing Dictionaries”, “level”: “Beginner”}
items = course.items()
print(items)
~~~
Output:
~~~
dict_items([(‘teacher’, ‘Ashley’), (‘course’, ‘Introducing Dictionaries’), (‘level’, ‘Beginner’)])
~~~
In the example, the .items() method is called on the course dictionary, which returns a view object containing the key-value pairs of the dictionary. This view object behaves like a list of tuples, where each tuple represents a key-value pair.
In this case, the items variable holds the view object returned by .items(), and when it is printed, it displays the key-value pairs enclosed in dict_items([]).
You can use this view object to perform various operations, such as iterating over the key-value pairs using a loop or converting it to a list using the list() function if necessary.
~~~
# Iterating over the key-value pairs
for key, value in course.items():
print(key, value)
Converting the key-value pairs to a list
item_list = list(course.items())
print(item_list)
~~~
Output:
~~~
teacher Ashley
course Introducing Dictionaries
level Beginner
[(‘teacher’, ‘Ashley’), (‘course’, ‘Introducing Dictionaries’), (‘level’, ‘Beginner’)]
~~~
Overall, the .items() method provides a convenient way to access the key-value pairs of a dictionary, allowing you to perform operations or extract information based on both the keys and values.
Explain the following code:
course = {'teacher':'Ashley', 'title':'Introducing Dictionaries', 'level':'Beginner'}
for key, value in course.items():
print(key)
print(value)
The given code demonstrates how to iterate over a dictionary in Python using a for loop with the .items() method.
First, a dictionary named course is defined with three key-value pairs: ‘teacher’, ‘title’, and ‘level’. Each key represents a specific attribute of the course, and the corresponding value provides the associated information.
The for loop is then used to iterate over the dictionary course.items(). The .items() method returns a view object that represents the key-value pairs of the dictionary.
Within the loop, there are two loop variables: key and value. In each iteration, key takes on the keys of the dictionary, and value takes on the corresponding values.
The loop body contains two print() statements:
- print(key) - This line prints the current key (key) being processed in the loop. It represents the attribute of the course, such as ‘teacher’, ‘title’, or ‘level’.
- print(value) - This line prints the current value (value) associated with the current key. It represents the corresponding information for the attribute, such as the teacher’s name, the course title, or the level of the course.
Here’s the output you would get when running this code:
~~~
teacher
Ashley
title
Introducing Dictionaries
level
Beginner
~~~
As the loop iterates over the dictionary’s key-value pairs, it prints each key and its corresponding value on separate lines. This allows you to see the attributes of the course and their associated information in a structured manner, similar to the previous example.
Write a for loop that iterates over the provided dictionary. The body of the loop should have two print statements: one to print the key and one to print the value of the current item.
pets = {'name':'Ernie', 'animal':'dog', 'breed':'Pug', 'age':2}
Answer :
pets = {'name':'Ernie', 'animal':'dog', 'breed':'Pug', 'age':2}
for key, value in pets.items():
print(key)
print(value)
Explain the following code:
def print_teacher(name, job, topic):
print(name)
print(job)
print(topic)
print_teacher('Ashley', 'Instructor', 'Python')
print_teacher(name='Ashley', job='Instructor', topic='Python')
The given code demonstrates the usage of a function in Python with both positional and keyword arguments.
First, a function named print_teacher is defined using the def keyword. It takes three parameters: name, job, and topic. Inside the function, it prints the values of these parameters using the print() function.
After defining the function, it is called twice:
- print_teacher(‘Ashley’, ‘Instructor’, ‘Python’): In this call, positional arguments are used. The values ‘Ashley’, ‘Instructor’, and ‘Python’ are passed to the function in the same order as the parameters are defined. This means that ‘Ashley’ will be assigned to the name parameter, ‘Instructor’ to the job parameter, and ‘Python’ to the topic parameter. The function is then executed, printing these values.
Output:
~~~
Ashley
Instructor
Python
~~~
- print_teacher(name=’Ashley’, job=’Instructor’, topic=’Python’): In this call, keyword arguments are used. Each argument is explicitly specified using the parameter name followed by =. This means that the values are assigned to the corresponding parameters based on their names, regardless of the order. The function is executed again, printing the values provided.
Output:
~~~
Ashley
Instructor
Python
~~~
In both cases, the function print_teacher is called with the specified arguments, and it prints the values of the name, job, and topic parameters in the order they are called.
Using both positional and keyword arguments provides flexibility when calling functions. Positional arguments rely on the order of the parameters, while keyword arguments allow you to explicitly specify which argument corresponds to each parameter, making the code more readable and reducing the chances of passing arguments in the wrong order.
What are kwargs in Python? And explain the following code:
def print_teacher(**kwargs):
for key, value in kwargs.items():
print(f'{key}: {value}')
print_teacher(name='Ashley', job='Instructor', topic='Python')
In Python, **kwargs is a special syntax used to define a function that accepts a variable number of keyword arguments. The term “kwargs” is short for “keyword arguments.”
When **kwargs is used in the function definition, it allows you to pass any number of keyword arguments to the function. These keyword arguments are then collected into a dictionary, where the keys are the argument names and the values are the corresponding argument values.
Now, let’s explain the given code:
* The code defines a function named print_teacher that accepts keyword arguments using **kwargs as its parameter. Inside the function, a for loop is used to iterate over the items of the kwargs dictionary. The items() method returns a view object that represents the key-value pairs of the dictionary.
- Within the loop, there are two loop variables: key and value. In each iteration, key represents the argument name, and value represents the corresponding argument value.
- The loop body contains a print() statement that formats and prints the key-value pairs in the format key: value.
- When the function is called with keyword arguments, such as name=’Ashley’, job=’Instructor’, topic=’Python’, the keyword arguments are collected into the kwargs dictionary. In this case, kwargs will be {‘name’: ‘Ashley’, ‘job’: ‘Instructor’, ‘topic’: ‘Python’}.
- The function is then executed, and the for loop iterates over the key-value pairs of the kwargs dictionary. It prints each key-value pair in the specified format.
Output:
~~~
name: Ashley
job: Instructor
topic: Python
~~~
As a result, the function print_teacher displays the key-value pairs of the keyword arguments provided when calling the function. This allows you to pass a flexible number of keyword arguments and process them within the function.
What is Unpacking with Dictionaries?
And explain the following code:
teacher = {
'name': 'Ashley',
'job': 'Instructor',
'topic': 'Python'
}
def print_teacher(name, job, topic):
print(name)
print(job)
print(topic)
print_teacher(**teacher)
Unpacking dictionaries is the opposite of packing them. It can be used if you have an existing dictionary that you would like to send to a function.
Consider this code:
teacher = {
'name':'Ashley',
'job':'Instructor',
'topic':'Python'
}
def print_teacher(name, job, topic):
print(name)
print(job)
print(topic)
First, we have a dictionary called teacher that holds three key:value pairs: name, job, and topic, each with corresponding values.
Then, we have a function called print_teacher that receives three arguments, name, job, and topic.
To pass the data from the teacher dictionary to this function, we can use unpacking to easily and quickly extrapolate the data into a format the function will accept.
To do that, we use a function call where the passed argument is **teacher.
This ** unpacks all the key:value pairs in the teacher dictionary into three keyword arguments, which are then accepted by the function into the three corresponding parameters.
**Explaining the code:
**
Let’s break down the code step by step:
~~~
teacher = {
‘name’: ‘Ashley’,
‘job’: ‘Instructor’,
‘topic’: ‘Python’
}
~~~
In this code snippet, a dictionary named teacher is defined. It contains three key-value pairs: ‘name’ with the value ‘Ashley’, ‘job’ with the value ‘Instructor’, and ‘topic’ with the value ‘Python’. This dictionary holds information about a teacher.
~~~
def print_teacher(name, job, topic):
print(name)
print(job)
print(topic)
~~~
Here, a function named print_teacher is defined. It takes three parameters: name, job, and topic. Inside the function, it simply prints each parameter value using the print() function.
~~~
print_teacher(**teacher)
~~~
The print_teacher() function is called with **teacher as an argument. This is known as dictionary unpacking. It passes the key-value pairs of the teacher dictionary as keyword arguments to the function.
When the function is called with **teacher, it is equivalent to calling print_teacher(name=’Ashley’, job=’Instructor’, topic=’Python’). The function receives the values from the teacher dictionary and assigns them to the respective parameter names.
As a result, the print_teacher() function prints the values of the name, job, and topic parameters, which are ‘Ashley’, ‘Instructor’, and ‘Python’ respectively.
Output:
~~~
Ashley
Instructor
Python
~~~
So, when the code is executed, it will output the three values, each on a separate line, as specified in the print_teacher() function.
