Scribd
Upload
2 views

tp07-dictionaries

dictionaries in python

Uploaded by

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

tp07-dictionaries

dictionaries in python

Uploaded by

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

Fundamentos de Programação

António J. R. Neves
João Rodrigues

Departamento de Electrónica, Telecomunicações e Informática


Universidade de Aveiro
Resumo

• Dictionaries
Dictionaries

Data Types

Simple types
(bool, int, float, complex)

Compound types (collections)

Sequences:
(list, tuple, str)

Sets: Mappings:
(set, frozenset) Dictionaries (dict)
Dictionaries

• A dictionary is an unordered, associative collection of


unique items.
• Collection because it may contain zero or more items.
• Associative because each item associates a key to a value.
• Unique because no two items can have the same key.
• Unordered because the order of the items does not matter for equality.
However, items are kept in insertion order (guaranteed since Python 3.7).

• Dictionaries are also called associative arrays or maps.


• Because they establish a mapping between keys and values.

• Dictionary items are also called key-value pairs.


• More on dictionaries in the official Python tutorial.
Dictionaries: creating and accessing items

• A dictionary may be created using braces (curly brackets).


eng2sp={'one': 'uno', 'two': 'dos', 'three': 'tres'}
shop = {'eggs': 12, 'sugar': 1.0, 'coffee': 3}

• An empty dictionary may be created with {} or dict().


• To access the value for a given key, use square brackets.
shop['sugar'] #-> 1.0
eng2sp['two'] #-> 'dos' Play ▶

• Dictionaries are mutable.


shop['bread'] = 6 # Add a new key-value association
shop['eggs'] = 24 # Change the value for an existing key
Dictionaries: value and key types

• Values in a dictionary can be of any type.


shop['eggs'] = [1, 'a']
shop['eggs'] = {'brown': 6, 'white': [2, 3]}

• Keys may be ints, floats, strings, tuples or essentially any


other immutable objects. So, lists are not valid keys!
eng2sp[4] = 'quatro' # integer key is fine
d[(12,25)] = 'Christmas' # tuple key is fine
d[[1,2]] = 'A' #-> TypeError: unhashable type

• Actually, keys must be hashable. In practice, this means:


• keys must be immutable scalars or
• immutable collections containing only hashable elements.
d[(1,[2,3])] = 'quatro' #-> TypeError: unhashable type
Dictionaries versus lists

• When accessing items, a dictionary is a kind of generalized


list. In a list, the indices must be integers. In a dictionary,
keys can be other kinds of object.
lst = [50, 51, 52]
dic = {'um':1, 'vinte':20, 'mil':1000}
lst[1] #-> 51
dic['mil'] #-> 1000

• Unlike lists, the order of items in a dictionary is irrelevant.


{'a':1, 'b':2} == {'b':2, 'a':1} #-> True
[1, 2] == [2, 1] #-> False

• And you cannot take slices from dictionaries!


d = {10:'dez', 20:'vinte', 1000:'mil'}
d[10:20] # NONSENSE! -> TypeError
Dictionary operations

• The len function returns the number of key-value pairs.


• The in operator tells you whether something appears as a
key in the dictionary. (This is fast!)
'two' in eng2sp #-> True ('two' is a key)
'uno' in eng2sp #-> False ('uno' is not a key)

• Three methods return sequences of keys, values and items.


d.keys() #-> [10, 20, 1000]
d.values() #-> ['dez', 'vinte', 'mil']
d.items() #-> [(10, 'dez'), (20, 'vinte'), (1000, 'mil')]

• So, to see whether something is a value in the dictionary,


you could use (but this is slow):
'uno' in eng2sp.values() #-> True
Dictionary methods

• Trying to access an inexistent key is an error.


d[10] #-> 'dez' Play ▶
d[0] #-> KeyError

• But using the get method will return a default value.


d.get(10) #-> 'dez' (same as d[10])
d.get(0) #-> None (no error!)
d.get(0, 'nada') #-> 'nada' (no error)
0 in d #-> False (.get did not change d)
print(d) # {10:'dez', 20:'vinte', 1000:'mil'}

• The setdefault method is similar, but it also creates a


new item if it was missing!
d.setdefault(0, 'nada') #-> 'nada'
0 in d #-> True
print(d) # {10:'dez', 20:'vinte', 1000:'mil' 0:'nada'}
Dictionary methods (2)

• Use pop(key) to remove the item with the given key and
return its value.
d = {10:'dez', 20:'vinte', 1000:'mil'}
Play ▶
x = d.pop(10) #-> x == 'dez'
print(d) # {20:'vinte', 1000: 'mil'}

• We can also delete an item with the del operator.


del d[20]
print(d) # {1000:'mil'}

• The popitem() method removes one (unspecified) item


from the dictionary, and returns its (key, value) pair.
d = {10:'dez', 20:'vinte', 1000:'mil'}
t = d.popitem() #-> (1000,'mil')
print(d) # {10:’dez’, 20:'vinte'}
Dictionary traversal

• The for instruction may be used to traverse dictionary keys.


shop = {'eggs':24, 'bread':6,
'coffee':3, 'sugar':1.0} eggs 24
for k in shop: bread 6
Play ▶ sugar 1.0
print(k, shop[k]) coffee 3

• This is equivalent to:


for k in shop.keys():
print(k, shop[k])

• We may also traverse (key, value) pairs directly:


for k, v in shop.items():
print(k, v)
Dictionaries: examples

• Suppose you are given a string and you want to count how
many times each letter appears there:
message = 'parrot'
d = dict()
for c in message:
if c not in d:
d[c] = 1
else:
d[c] += 1 Play ▶

• To show the results, traverse the keys with a for statement:


for c in d:
print(c, d[c])
Dictionaries: examples (2)

• Create a dictionary that maps from frequencies to letters:


inverse = dict()
for key in d:
val = d[key]
if val not in inverse:
inverse[val] = [key]
else:
inverse[val].append(key)

print(d) # from previous slide


{'a': 1, 'p': 1, 'r': 2, 't': 1, 'o': 1}
print(inverse)
{1: ['a', 'p', 't', 'o'], 2: ['r']}
Dictionaries: updating

• Many algorithms require updating a dictionary one item at a


time.
• This can be done in several alternative, but equivalent ways.
• Example: counting characters in a message.

#A #B
d = {} d = {}
for c in message: for c in message:
if c not in d: if c not in d:
d[c] = 1 d[c] = 0
else: d[c] += 1
d[c] += 1

#C #D
d = {} d = {}
for c in message: for c in message:
d[c] = d.get(c, 0) + 1 d.setdefault(c, 0)
d[c] += 1
Dictionaries: updating (2)

• Example: grouping words in lists according to word length.

#A #B
d = {} d = {}
for w in wordlist: for w in wordlist:
k = len(w) k = len(w)
if k not in d: if k not in d:
d[k] = [w] d[k] = []
else: d[k].append(w)
d[k].append(w)

#C #D
d = {} d = {}
for w in wordlist: for w in wordlist:
k = len(w) k = len(w)
d[k] = d.get(k, []) d.setdefault(k, []).append(w)
Play ▶
d[k].append(w)

wordlist=['to','be','or','not','to','be','that','is','the','question']
#A, B, C or D...
d -> {2: ['to', 'be', 'or', 'to', 'be', 'is'], 3: ['not', 'the'],
4: ['that'], 8: ['question']}
Dictionaries and lists of tuples

• Method items returns a sequence of tuples, where each


tuple is a key-value pair.
d = {'a':0, 'b':1, 'c':2}
t = d.items() #-> dict_items(('a', 0), ('c', 2), ('b', 1))

• We can use a list of tuples to initialize a new dictionary:


t = [('a', 0), ('c', 2), ('b', 1)]
d = dict(t) #-> {'a': 0, 'c': 2, 'b': 1}

• Combining items, tuple assignment and for:


for key, val in d.items():
print(val, key)
Exercises

• Do these Codecheck exercises.

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy