Scribd
Upload
62 views

Dictionaries: Keeping Track of Pairs: Dict Tuple

This document provides an introduction to dictionaries in Python. It discusses how dictionaries allow the modeling of relationships between pairs of things through key-value pairs. Some basic dictionary operations are described, such as creating, accessing values, updating, and checking membership. The document also covers that dictionaries have fast lookup times and that their keys can be any immutable type, including tuples. It provides examples of iterating over dictionaries and using a dictionary to count the frequencies of items in a list.

Uploaded by

Faded Rianbow
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
62 views

Dictionaries: Keeping Track of Pairs: Dict Tuple

This document provides an introduction to dictionaries in Python. It discusses how dictionaries allow the modeling of relationships between pairs of things through key-value pairs. Some basic dictionary operations are described, such as creating, accessing values, updating, and checking membership. The document also covers that dictionaries have fast lookup times and that their keys can be any immutable type, including tuples. It provides examples of iterating over dictionaries and using a dictionary to count the frequencies of items in a list.

Uploaded by

Faded Rianbow
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 10

Introduction to Computing Using Pytho

Dictionaries: Keeping track


of pairs
Class dict
Class tuple

Introduction to Computing Using Pytho

The dictionary: An
associative data type
Many things in the world come in pairs, where
Thing 1 is associated with Thing 2. For
example
A word and its definition
A person and the person's birthday
A living thing and its species
The Python class dictionary models such
relationships flexibly and efficiently
>>> definitions = {'modest':'unassuming', 'eat':'chew and swallow'}
>>> bdays = {'Napoleon':'15 Aug 1769', 'Lady Gaga':'Mar 28 1986'}
>>> species = {'Fido':'dog', 'Finny':'catfish', 'Pepe Le Pew':'skunk'}

Dictionary: Syntax and types


This is the syntax of a dictionary:
A dictionary is enclosed in curly brackets. The empty
dictionary is denoted {}.
A dictionary is a set of key:value pairs. Each key and
its value are separated by a colon (':').
Key:value pairs are separated by commas.

Permitted types of keys and values:


A key can be any immutable type for example, a
string, a number or a tuple. A key cannot be a
mutable type, such as a list.
A dictionary may contain keys of different types,
but
Each key in a dictionary must be unique
A value can be any type we have learned a string,

Dictionary: Basic operations


>>> # create an empty dictionary
>>> d = {}
>>> # add a key:value pair, using index and assignment operators
>>> d['NJIT'] = 'tech'
>>> # look up the value of a key using the index ([]) operator
>>> d['NJIT']
'tech'
>>> # change a value by assigning a new value
>>> d['NJIT'] = 'tech school'
>>> d['NJIT']
'tech school'
>>> # remove a key:value pair and return its value
>>> njitSchoolType = d.pop('NJIT')
>>> njitSchoolType
'tech school'
>>> d
{}

Dictionary: More things you


can do

>>> # find the size (number of key:value pairs) of a dictionary


>>> d = {1:'for the money', 'two':'for the show'}
>>> len(d)
2
>>> # test for the membership (presence) of a key
>>> 1 in d
True
>>> 2 in d
False
>>>
>>>
>>>
>>>
{1:

# incorporate dictionary d2 into dictionary d


d2 = {'Twain':'Mark'}
d.update(d2)
d
'for the money', 'Twain': 'Mark', 'two': 'for the show'}

>>> # note that dictionary d2 is not changed


>>> d2
{'Twain':'Mark'}

Introduction to Computing Using Pytho

Dictionary properties: Order


and speed
The order that a dictionary stores keys is not
>>>
d = {1:'for the money', 'two':'for the show'}
guaranteed
>>>
>>>
>>>
{1:
>>>
>>>

d2 = {'Twain':'Mark'}
d.update(d2)
d
'for the money', 'Twain': 'Mark', 'two': 'for the show'}
# Note that the key:value pair 'Twain':'Mark' from d2 has been
# inserted between the pairs already in d

Dictionary lookup (amazingly!) does not get


slower as the dictionary gets bigger
>>> # Inserting ten million elements may take a few seconds
>>> d = {}
>>> for i in range(10000000):
d[i] = str(i)
>>> # Retrieving one element from among 10,000,000 is immediate
>>> d[5000000]
'5000000'

Introduction to Computing Using Pytho

Iterating over a dictionary


Iterate over dictionary keys like this
>>> # Use the dictionary method d.keys()
>>> d = {'tree':'oak', 'fish':'guppy', 'dog':'boxer', 'cat':'tabby'}
>>> for thing in d.keys():
if 't' in thing:
print(thing, end=' ')
cat tree
>>> # Note: for thing in d: is the same as for thing in d.keys()

Iterate over dictionary values like this


>>> # Use the dictionary method d.values()
>>> for value in d.values():
if 'y' in value:
print(value, end=' ')
guppy tabby

Introduction to Computing Using Pytho

The tuple as a dictionary key


A tuple is almost the same as a list, except
that it is immutable. A tuple is delimited by
parentheses where a list has square brackets
>>> # This is a list of int's
>>> intList = [1, 2, 3]
>>> # Attempting to use a list as a key will result in an error
>>> d = {intList: "some int's"}
Traceback (most recent call last):
File "<pyshell#193>", line 1, in <module>
d = {intList:"some int's"}
TypeError: unhashable type: 'list'
>>> # Solution: Use a tuple as a key instead
>>> intTuple = (1, 2, 3) # or intTuple = tuple(intList)
>>> d = {intTuple: "some int's"}
>>> d
{(1, 2, 3): "some int's"}

Introduction to Computing Using Pytho

Example: Keeping count(s)

Problem: you want to count how many times each item in a list occurs,
but you don't know the items in advance. For example, for this list
>>> grades = [95, 96, 100, 85, 95, 90, 95, 100, 100]

a good solution might look like this 100

Complications:

96

95

90

85

until you see the list, you don't know what counters to
create
you'd like to be able to access the count of an item via the
item itself

Solution: create a dictionary in which each distinct item is a key and


its count is the associated value

Introduction to Computing Using Pytho

A dictionary as a collection
of counters
def frequency(itemList):
'''Compute the frequency of each item in
itemList. Return the result as a dictionary
in which each distinct item in itemList is a
key and the item's frequency (count) is the
associated value.'''
counters = {}
for item in itemList:
# if the item hasn't been seen before
if item not in counters:
# add the item to the dictionary
# and set its count to 1
counters[item] = 1
# otherwise, increment the count of item
else:
counters[item] += 1
return counters

You might also like