• lot (a list of two-item tuples):

lot = [ ('a', 'b'), ('c', 'd'), ('e', 'f') ]
dict(lot)Copy Code

• tol (a tuple of two-item lists):

tol = ( ['a', 'b'], ['c', 'd'], ['e', 'f'] )
dict(tol)Copy Code

• los (a list of two-character strings):

los = [ 'ab', 'cd', 'ef' ]
dict(los)Copy Code

• tos (a tuple of two-character strings):

tos = ( 'ab', 'cd', 'ef' )
dict(tos)Copy Code

• Here, we want to add Rochester, NY.
  • Here's an attempt to add it, but it spelled wrong:

st_city['NY'] = 'Rocjester'
st_cityCopy Code

• Here's some repair code:

st_city['NY'] = 'Rochester'
st_cityCopy Code

• Remember that dictionary keys must be unique.
  • That's why we used state names for keys instead of city names.
  • If we use a key more than once, the last value wins:

city_st = {
  'Rochester': 'MN',
  'Laramie': 'WY',
  'Denver': 'CO',
  'Rochester': 'NY'
  }
city_stCopy Code

• If the key is not present in the dictionary, we'll get an exception:

city_st['Buffalo']Copy Code

• There are two good ways to avoid this: in and get()

• Test for the key at the outset by using in:

'Buffalo' in city_stCopy Code

• Use the special dictionary get() function.
  • If the key exists, we get its value:

city_st.get('Denver')Copy Code

• Use the special dictionary get() function.
  • If the key does not exist and the optional value is provided, we get the optional value:

city_st.get('Buffalo', 'Not in city_st')Copy Code

• Use the special dictionary get() function.
  • If the key does not exist and the optional value is not provided, we get None, which displays nothing in the console.

city_st.get('Buffalo')Copy Code

Get All Values with values()

• To obtain all the values in a dictionary, use values():

signals = {'green': 'go', 
           'yellow': 'go faster', 
           'red': 'smile for the camera'}
signals.values()
list( signals.values() )   # to turn the result into a list object.Copy Code

Get All Key-Value Pairs with items()

• When we want to get all the key-value pairs from a dictionary, use the items() function:

signals = {'green': 'go', 
           'yellow': 'go faster', 
           'red': 'smile for the camera'}
signals.items()
list( signals.items() )   # to turn the result into a list object.Copy Code

Get Length with len()

• Count your key-value pairs:

signals = {'green': 'go', 
           'yellow': 'go faster', 
           'red': 'smile for the camera'}
len(signals)Copy Code

Combine Dictionaries with {**a, **b}

• Starting with Python 3.5, there's a new way to merge dictionaries, using the **:

first = {'a': 'agony', 'b': 'bliss'}
second = {'b': 'bagels', 'c': 'candy'}
{**first, **second}
third = {'d': 'donuts'}
{**first, **third, **second}Copy Code

Combine Dictionaries with update()

• We can use the update() function to copy the keys and values of one dictionary into another.
  • Let's update st_city with other_city

st_city = { 'MN': 'Rochester',
            'WY': 'Laramie',
            'CO': 'Denver',
            'NY': 'Rochester' }
other_city = {'MA': 'Boston'}
st_city.update(other_city)Copy Code

Combine Dictionaries with update()

• What happens if the second dictionary has the same key as the dictionary into which it's being merged?

first = {'a': 1, 'b': 2}
second = {'b': 'platypus'}
first.update(second)
firstCopy Code

Get an Item by Key and Delete It with pop()

• pop() combines get() and del.
  • If we give pop() a key and it exists in the dictionary, it returns the matching value and deletes the key-value pair.
  • If the key doesn't exist but we give pop() a second default argument, all is well and the dictionary is not changed:

len(st_city)
st_city.pop('MN')   # Check len(st_city)
st_city.pop('MN')   # If it doesn't exist, it raises an exception:
st_city.pop('MN', 'Not exist')Copy Code

Delete All Items with clear()

• To delete all keys and values from a dictionary, use clear() or just reassign an empty dictionary ({}) to the name:

st_city.clear()
st_city
st_city = { 'MN': 'Rochester',
            'WY': 'Laramie',
            'CO': 'Denver',
            'NY': 'Rochester' }
st_city = {}
st_cityCopy Code

Test for a Key with in

• If we want to know whether a key exists in a dictionary, use in:

st_city = { 'MN': 'Rochester',
            'WY': 'Laramie',
            'CO': 'Denver',
            'NY': 'Rochester' }
'NY' in st_city
'WY' in st_city
'CA' in st_cityCopy Code

Assign with =

• If we make a change to a dictionary, it will be reflected in all the names that refer to it:

signals = { 'green': 'go',
            'yellow': 'go faster',
            'red': 'smile for the camera' }
save_signals = signals
signals['blue'] = 'confuse everyone'
signalsCopy Code

• What are in save_signals now?

Copy with copy()

• To actually copy keys and values from a dictionary to another dictionary and avoid this, we can use copy():

signals = { 'green': 'go',
            'yellow': 'go faster',
            'red': 'smile for the camera' }
original_signals = signals.copy()
signals['blue'] = 'confuse everyone'
signalsCopy Code

• What are in original_signals now?

Copy Everything with deepcopy()

• Suppose that the value for red in signals was a list instead of a single string:

signals = { 'green': 'go',
            'yellow': 'go faster',
            'red': ['stop', 'smile'] }
signals_copy = signals.copy()
signalsCopy Code

• What are in signals_copy?

Copy Everything with deepcopy()

• Let's change one of the values in the red list:

signals = { 'green': 'go',
            'yellow': 'go faster',
            'red': ['stop', 'smile'] }
signals_copy = signals.copy()
signals['red'][1] = 'sweat'
signalsCopy Code

• What are in signals_copy?

Copy Everything with deepcopy()

• To avoid this, we can use deepcopy():

import copy
signals = { 'green': 'go',
            'yellow': 'go faster',
            'red': ['stop', 'smile'] }
signals_deepcopy = copy.deepcopy(signals)
signals
signals_deepcopy
signals['red'][1] = 'sweat'
signalsCopy Code

• What are in signals_deepcopy?

Iterate with for and in

• Iterating over a dictionary (or its keys() function) returns the keys.

accusation = {'room': 'ballroom', 
              'weapon': 'lead pipe',
              'person': 'Col. Mustard'}
for card in accusation: # or, for card in accusation.keys():
    print(card)Copy Code

Iterate with for and in

• To iterate over the values rather than the keys, we use the dictionary's values() function:

accusation = {'room': 'ballroom', 
              'weapon': 'lead pipe',
              'person': 'Col. Mustard'}
for value in accusation.values():
    print(value)Copy Code

Iterate with for and in

• To return both the key and value as a tuple, we can use the items() function:

accusation = {'room': 'ballroom', 
              'weapon': 'lead pipe',
              'person': 'Col. Mustard'}
for item in accusation.items():
    print(item)Copy Code

Iterate with for and in

• For each tuple returned by items(), let's assign the first value (the key) to card, and the second (the value) to contents:

accusation = {'room': 'ballroom', 
              'weapon': 'lead pipe',
              'person': 'Col. Mustard'}
for card, contents in accusation.items():
    print('Card', card, 'has the contents', contents)Copy Code

Dictionary Comprehensions

• Dictionaries also have comprehensions.
  • The simplest form of dictionary comprehension looks like this:

Dictionary Comprehensions

• Let's run a loop over each of the seven letters in the string 'letters' and counting how many times that letter appears.

word = 'letters'
letter_counts = {letter: word.count(letter) for letter in word}
letter_countsCopy Code

• How many times do we count 't' here?

Dictionary Comprehensions

• Let's run a loop over each of the seven letters in the string 'letters' and counting how many times that letter appears.

word = 'letters'
letter_counts = {letter: word.count(letter) for letter in set(word)}
letter_countsCopy Code

• How many times do we count 't' here?

Dictionary Comprehensions

• Dictionary comprehensions can also have if tests and multiple for clauses:

vowels = 'aeiou'
word = 'onomatopoeia'
vowel_counts = {letter: word.count(letter) for letter in set(word) 
                                           if letter in vowels}
vowel_countsCopy Code

Convert with set()

• We can create a set from a list, string, tuple, or dictionary, discarding any duplicate values.

set( 'letters' )   
set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] )
set( ('Ummagumma', 'Echoes', 'Atom Heart Mother') )
set( {'apple': 'red', 'orange': 'orange', 'cherry': 'red'} )Copy Code

• Sets are unordered.

Get Length with len()

• Let's count our reindeer:

reindeer = set( ['Dasher', 'Dancer', 'Prancer', 'Mason-Dixon'] )
len(reindeer)Copy Code

Add an Item with add()

• Throw another item into a set with the set add() method

s = set((1,2,3))
s
s.add(4)
sCopy Code

Delete an Item with remove()

• We can delete a value from a set by value:

s = set((1,2,3))
s.remove(3)
sCopy Code

Iterate with for and in

• We can iterate over all items in a set:

furniture = set(('sofa', 'ottoman', 'table'))
for piece in furniture:
    print(piece)Copy Code

• Print drinks that contain vodka:

for name, contents in drinks.items():
    if 'vodka' in contents:
        print(name)Copy Code

• Print drinks that neither contain either cream nor vermouth but do vodka:

for name, contents in drinks.items():
    if 'vodka' in contents \
        and not ('vermouth' in contents or 'cream' in contents):
        print(name)Copy Code

• We get the intersection (members common to both sets) with the special punctuation symbol &.
  • The set intersection() function does the same.

a & b
a.intersection(b)
bruss & wrussCopy Code

• Let's get the union (members of either set) by using | or the set union() function:

a | b
a.union(b)
bruss | wrussCopy Code

• The difference (members of the first set but not the second) is obtained by using the character - or the difference() function:

a - b
a.difference(b)
bruss - wruss
wruss - brussCopy Code

• The exclusive or (items in one set or the other, but not both) uses ^ or symmetric_difference():

a ^ b
a.symmetric_difference(b)
bruss ^ wrussCopy Code

• We can check whether one set is a subset of another (all members of the first set are also in the second set) by using <= or issubset():

a <= b
a.issubset(b)
bruss <= wruss
a <= a   # any set is a subset of itself?
a.issubset(a)Copy Code

• To be a proper subset, the second set needs to have all the members of the first and more.
  • Calculate it by using <:

a < b
b < a
bruss < wrussCopy Code

• A superset is the opposite of a subset (all members of the second set are also members of the first). This uses >= or issuperset():

a >= b
a.issuperset(b)
wruss >= bruss
a >= a   # any set is a superset of itself?
a.issuperset(a)Copy Code

• To be a proper superset, the first set needs to have all the members of the second and more.
  • Calculate it by using >:

a > b
wruss > bruss
a > aCopy Code

• What if we want to check for combinations of set values?
  • Suppose that we want to find any drink that has orange juice or vermouth.
  • Let's use the set intersection operator, which is an ampersand (&):

for name, contents in drinks.items():
    if contents & {'vermouth', 'orange juice'}:
        print(name)Copy Code

• Let's rewrite the example from the previous section, in which we wanted vodka but neither cream nor vermouth:

for name, contents in drinks.items():
    if 'vodka' in contents and not contents & {'vermouth', 'cream'}:
        print(name)Copy Code

Create an Immutable Set with frozenset()

• If we want to create a set that can't be changed, call the frozenset() function with any iterable argument:

frozenset([3, 2, 1])
frozenset(set([2, 1, 3]))
frozenset({3, 1, 2})
frozenset( (2, 3, 1) )
fs = frozenset([3, 2, 1])
fs
fs.add(4)Copy Code

• For all but sets, we access a single element with square brackets.
  • For the list and the tuple, the value between the square brackets is an integer offset.
  • For the dictionary, we access a single element with a key.

marx_list[2]
marx_tuple[2]
marx_dict['Harpo']
'Harpo' in marx_setCopy Code

• For the list, the tuple, and the dictionary, the result is a value.
• For the set, the result is either there or it's not; there's no index or key.

• We can make a tuple that contains each list as an element:

tuple_of_lists = newyork, california, texas
tuple_of_listsCopy Code

• We can make a list that contains the three lists:

list_of_lists = [newyork, california, texas]
list_of_listsCopy Code

• Finally, let's create a dictionary of lists.
  • In this example, let's use the abbreviated name of the state as the key and the list of cities as the value:

dict_of_lists = {'NY': newyork, 'CA': california, 'TX': texas}
dict_of_listsCopy Code

• Let's define a very simple function that has no parameters.

def do_nothing():
    pass      # indention is needed hereCopy Code

• We use the pass statement when we want Python to do nothing.
  • It's the equivalent of This page intentionally left blank.

• We call the do_nothing() function just by typing its name and parentheses.

do_nothing()Copy Code

• Let's try a function that has no parameters but returns a value:

def agree():
    return TrueCopy Code

• We can call the agree() function and test its returned value by using if:

if agree():
    print('Splendid!')
else:
    print('That was unexpected.')Copy Code

• What did we get back?

print(comment)Copy Code

• A function can take any number of input arguments (including zero) of any type.

• It can return any number of output results (also including zero) of any type.

• If a function doesn't call return explicitly, the caller gets the result None.

def do_nothing():
    pass
print(do_nothing())Copy Code

• To distinguish None from a boolean False value, use Python's is operator:

thing = None
if thing is None:
    print("It's some thing")
else:
    print("It's no thing")Copy Code

• We'll need None to distinguish a missing value from an empty value.
• Zero-valued numbers, empty strings (''), lists ([]), tuples ((,)), dictionaries ({}), and sets (set()) are all False, but are not the same as None.

• Let's write a quick function that prints whether its argument is None, True, or False:

def whatis(thing):
    if thing is None:
        print(thing, "is None")
    elif thing:
        print(thing, "is True")
    else:
        print(thing, "is False")Copy Code

• Let's run some sanity tests:

whatis(None)
whatis(True)
whatis(False)Copy Code

• How about some real values?

whatis(0)
whatis(0.0)
whatis('')
whatis("")
whatis('''''')
whatis(())
whatis([])
whatis({})
whatis(set())Copy Code

• How about some real values?

whatis(0.00001)
whatis([0])
whatis([''])
whatis(' ')Copy Code

Positional Arguments

• A downside of positional arguments is that we need to remember the meaning of each position.

menu('beef', 'bagel', 'bordeaux')Copy Code

Keyword Arguments

• To avoid positional argument confusion, we can specify arguments by the names of their corresponding parameters, even in a different order from their definition in the function:

menu(entree='beef', dessert='bagel', wine='bordeaux')
# Specify the wine first, but use keyword arguments for the entree and dessert:
menu('frontenac', dessert='flan', entree='fish')Copy Code

• If we call a function with both positional and keyword arguments, the positional arguments need to come first.

• We can specify default values for parameters.
  • If we provide an argument, it's used instead of the default:

def menu(wine, entree, dessert='pudding'):
    return {'wine': wine, 'entree': entree, 'dessert': dessert}
menu('dunkelfelder', 'duck', 'doughnut')Copy Code

• It would have worked if it had been written like this:

def works(arg):
    result = []
    result.append(arg)
    return result
works('a')
works('b')Copy Code

• The fix is to pass in something else to indicate the first call:

def nonbuggy(arg, result=None):
    if result is None:
        result = []
    result.append(arg)
    print(result)
nonbuggy('a')
nonbuggy('b')Copy Code

• If our function has required positional arguments, as well, put them first; *args goes at the end and grabs all the rest:

def print_more(required1, required2, *args):
    print('Need this one:', required1)
    print('Need this one too:', required2)
    print('All the rest:', args)
print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax')Copy Code

• We can pass positional argument to a function, which will match them inside to positional parameters.

• We can pass a tuple argument to a function, and inside it will be a tuple parameter.

• We can pass positional arguments to a function, and gather them inside as the parameter *args, which resolves to the tuple args.

• We can also "explode" a tuple argument called args to positional parameters *args inside the function, which will be regathered inside into the tuple parameter args:

def print_args(*args):
    print('Positional tuple:', args)
print_args(2, 5, 7, 'x')
args = (2,5,7,'x')
print_args(args)
print_args(*args)Copy Code

• We can only use the * syntax in a function call or definition:

argsCopy Code

• Outside the function, *args explodes the tuple args into comma-separated positional parameters.

• Inside the function, *args gathers all of the positional arguments into a single args tuple.

• We can pass keyword arguments to a function, which will match them inside to keyword parameters.

• We can pass a dictionary argument to a function, and inside it will be dictionary parameters.

• We can pass one or more keyword arguments (name=value) to a function, and gather them inside as **kwargs, which resolves to the dictionary parameter called kwargs.

• Outside a function, **kwargs explodes a dictionary kwargs into name=value arguments.

• Inside a function, **kwargs gathers name=value arguments into the single dictionary parameter kwargs.

data = ['a', 'b', 'c', 'd', 'e', 'f']
print_data(data)
print_data(data, start=4)
print_data(data, end=2)Copy Code

def print_data2(data, *, start, end):
    for value in (data[start:end]):
        print(value)
print_data2(data)
print_data2(data, start=4)
print_data2(data, end=2)
print_data2(data, start = 2, end = 4)Copy Code

• start and end are required arguments, because they doesn't have a default value and they must be specified as a keyword argument when we call the print_data2() function.