• To make a tuple with one or more elements, follow each element with a comma.
  • This works for one-element tuples:

one_geneseo = 'Geneseo',Copy Code

• We could enclose them in parentheses and still get the same tuple:

one_geneseo = ('Geneseo',)Copy Code

• If we have a single thing in parentheses and omit that comma, we would not get a tuple, but just the thing.

one_geneseo = ('Geneseo')Copy Code

• If we have more than one element, follow all but the last one with a comma:

suny_tuple = 'Geneseo', 'Borckport', 'Oswego'Copy Code

• We often don’t need parentheses when we define a tuple, but using parentheses is a little safer, and it helps to make the tuple more visible:

suny_tuple = ('Geneseo', 'Borckport', 'Oswego')Copy Code

• We do need the parentheses for cases in which commas might also have another use.

one_geneseo = 'Geneseo',
type(one_geneseo)
type('Groucho',)
type(('Groucho',))Copy Code

• Tuples let us assign multiple variables at once:

suny_tuple = ('Geneseo', 'Borckport', 'Oswego')
a, b, c = suny_tuple
a
b
cCopy Code

• This is sometimes called tuple unpacking.

• We can use tuples to exchange values in one statement without using a temporary variable:

password = 'swordfish'
icecream = 'tuttifrutti'
password, icecream = icecream, password
password
icecreamCopy Code

Combine Tuples by Using +

• This is similar to combining strings:

('Geneseo',) + ('Borckport', 'Oswego')Copy Code

Duplicate Items with *

• This is like repeated use of +:

('yada',) * 3Copy Code

Compare Tuples

• This works much like list comparisons:

a = (7, 2)
b = (7, 2, 9)
a == b
a <= b
a < bCopy Code

Iterate with for and in

• Tuple iteration is like iteration of other types:

words = ('fresh','out', 'of', 'ideas')
for word in words:
    print(word)Copy Code

Modify a Tuple

• We can’t!
  • Like strings, tuples are immutable, so we can’t change an existing one.
  • As we saw just before, we can concatenate (combine) tuples to make a new one, as we can with strings:

t1 = ('Fee', 'Fie', 'Foe')
id(t1)
t2 = ('Flop',)
t1 + t2
t1 += t2
id(t1)Copy Code

Create or Convert with list()

• We can also make an empty list with the list() function.

• list() function also converts other iterable data types (such as tuples, strings, sets, and dictionaries) to lists.

another_empty_list = list()
another_empty_list
list('cat')
a_tuple = ('ready', 'fire', 'aim')
list(a_tuple)Copy Code

Create from a String with split()

• We can use split() to chop a string into a list by some separator:

coffee_day = '10/1/2022'
coffee_day.split('/')
splitme = 'a/b//c/d///e'
splitme.split('/')
splitme.split('//')Copy Code

Get an Item with a Slice

• We can extract a subsequence of a list by using a slice:

suny = ['Geneseo', 'Brockport', 'Oswego']
suny[0:2]    # A slice of a list is also a list.Copy Code

suny[::2]
suny[::-2]
suny[::-1]Copy Code

suny[4:]
suny[-6:]
suny[-6:-2]
suny[-6:-4]Copy Code

Reverse a list with reverse()

• To reverse a list in place, use list.reverse():

suny.reverse()
sunyCopy Code

Add an Item to the End with append()

• The append() function adds items to the end of the list.

suny = ['Geneseo', 'Brockport', 'Oswego']
suny.append('Buffalo')
suny
suny = ['Geneseo', 'Brockport', 'Oswego']
others = ['Buffalo', 'Cortland']
suny.append(others)
sunyCopy Code

Add an Item by Offset with insert()

• When we want to add an item before any offset in the list, we can use insert().

suny = ['Geneseo', 'Brockport', 'Oswego']
suny.insert(2, 'Buffalo')
suny
suny.insert(10, 'Cortland')
sunyCopy Code

Duplicate All Items with *

• We saw that we can duplicate a string’s characters with *. The same works for a list:

["blah"] * 3
suny = ['Geneseo', 'Brockport', 'Oswego']
suny * 2Copy Code

Combine Lists by Using extend() or +

• We can merge one list into another by using extend() or +.

suny = ['Geneseo', 'Brockport', 'Oswego']
others = ['Buffalo', 'Cortland']
suny.extend(others)
suny
suny = ['Geneseo', 'Brockport', 'Oswego']
others = ['Buffalo', 'Cortland']
suny += others
sunyCopy Code

Change an Item by [offset]

• Just as we can get the value of a list item by its offset, we can change it:

suny = ['Geneseo', 'Brockport', 'Oswego']
suny[2] = 'Buffalo'
sunyCopy Code

• We can change how many items a list contains as well as the items themselves.

Delete an Item by Offset with del

• We can use a del statement to delete an item by its position in a list.

suny = ['Geneseo', 'Brockport', 'Oswego', 'Rochester']
suny[-1]
del suny[-1]    
sunyCopy Code

Delete an Item by Value with remove()

• If we're not sure or don’t care where the item is in the list, we can use remove() to delete it by value.

suny = ['Geneseo', 'Brockport', 'Oswego', 'Rochester']
suny.remove('Rochester')
suny
suny = ['Geneseo', 'Brockport', 'Oswego', 'Rochester', 'Rochester']
suny.remove('Rochester')
sunyCopy Code

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

• We can get an item from a list and delete it from the list at the same time by using pop().
  • If we call pop() with an offset, it will return the item at that offset; with no argument, it uses -1.

suny = ['Geneseo', 'Brockport', 'Oswego', 'Rochester']
suny.pop()
suny
suny.pop(1)
sunyCopy Code

Delete All Items with clear()

• We can use clear() to clear a list of all its elements:

suny_roc = ['Rochester', 'Rochester', 'Rochester', 'Rochester']
suny.clear()
sunyCopy Code

Test for a Value with in

• The way to check for the existence of a value in a list is using in:

suny = ['Geneseo', 'Brockport', 'Oswego', 'Buffalo']
'Geneseo' in suny
'Rochester' in suny
words = ['a', 'deer', 'a' 'male', 'deer']
'deer' in wordsCopy Code

Count Occurrences of a Value with count()

• To count how many times a particular value occurs in a list, we can use count():

suny = ['Geneseo', 'Brockport', 'Oswego', 'Buffalo']
suny.count('Geneseo')
suny.count('Rochester')
mcdonald = ['cheeseburger', 'cheeseburger', 'cheeseburger']
mcdonald.count('cheeseburger')Copy Code

Convert a List to a String with join()

• join() is a string method, not a list method.

suny = ['Geneseo', 'Brockport', 'Oswego', 'Buffalo']
', '.join(suny)Copy Code

• We can’t say suny.join(', ').

• The argument to join() is a string or any iterable sequence of strings (including a list), and its output is a string.

Reorder Items with sort() or sorted()

• We may often need to sort the items in a list by their values rather than their offsets.
  • The list method sort() sorts the list itself, in place.
  • The general function sorted() returns a sorted copy of the list.

suny = ['Geneseo', 'Brockport', 
        'Oswego']
sorted_suny = sorted(suny)
sorted_suny
sunyCopy Code

suny.sort()
sunyCopy Code

Reorder Items with sort() or sorted()

• The default sort order is ascending, but we can add the argument reverse=True to set it to descending.

numbers = [2, 1, 4.0, 3]
numbers.sort()
numbers
numbers = [2, 1, 4.0, 3]
numbers.sort(reverse=True)
numbersCopy Code

suny = ['Geneseo', 'Brockport', 
        'Oswego']
sorted_suny = sorted(suny, 
                     reverse=True)
sorted_sunyCopy Code

Get Length with len()

• len() returns the number of items in a list:

suny = ['Geneseo', 'Brockport', 'Oswego']
len(suny)Copy Code

Copy with copy(), list(), or a Slice

We can copy the values of a list to an independent, fresh list by using (1) the list copy() method, (2) the list() conversion function, or (3) the list slice [:]:

a = [1, 2, 3]
b = a.copy()
c = list(a)
d = a[:]
a[0] = 'integer lists'Copy Code

Copy with copy(), list(), or a Slice

• Using (1) the list copy() method, (2) the list() conversion function, or (3) the list slice [:] works well if the list values are all immutable.

a = [1, 2, [8, 9]]
b = a.copy()
c = list(a)
d = a[:]
a[2][1] = 10Copy Code

Copy with copy(), list(), or a Slice

• To fix these shallow copies, we need to use the deepcopy() function:

import copy
a = [1, 2, [8, 9]]
b = copy.deepcopy(a)
a[2][1] = 10
a
bCopy Code

Compare Lists

• We can directly compare lists with the comparison operators like ==, <, and so on.

a = [7, 2]
b = [7, 2, 9]
a == b
a <= b
a < bCopy Code

• break ends the for loop and continue steps to the next iteration:

cheeses = ['brie', 'gjetost', 'havarti']
for cheese in cheeses:
    if cheese.startswith('g'):
        print("I won't eat anything that starts with 'g'")
        break
    else:
        print(cheese)Copy Code

• We can still use the optional else if the for completed without a break:

cheeses = ['brie', 'gjetost', 'havarti']
for cheese in cheeses:
    if cheese.startswith('x'):
        print("I won't eat anything that starts with 'x'")
        break
    else:
        print(cheese)
else:
    print("Didn't find anything that started with 'x'")Copy Code

• If the initial for never ran, control goes to the else:

cheeses = []
for cheese in cheeses:
    print('This shop has some lovely', cheese)
    break
else: # no break means no cheese
    print('This is not much of a cheese shop, is it?')Copy Code

• We can use zip() to walk through multiple sequences and make tuples from items at the same offsets.

english = 'Monday', 'Tuesday', 'Wednesday'
french = 'Lundi', 'Mardi', 'Mercredi'
list( zip(english, french) )
dict( zip(english, french) )Copy Code

• We will discuss soon how the dict() function can create dictionaries from two-item sequences like tuples, lists, or strings.

number_list = []
for number in range(1, 6):
    number_list.append(number)
number_listCopy Code

number_list = list(range(1, 6))
number_listCopy Code

number_list = [number for number in range(1,6)]
number_listCopy Code

number_list = [number for number in range(1,6)]
number_listCopy Code

• In the first line, we need the first number variable to produce values for the list: that is, to put a result of the loop into number_list.

• The second number is part of the for loop.

• To show that the first number in example 1 is an expression, try this variant:

number_list = [number - 1 for number in range(1,6)]
number_listCopy Code

• The list comprehension moves the loop inside the square brackets.

• A list comprehension can include a conditional expression, looking something like this:

• Let’s make a new comprehension that builds a list of only the odd numbers between 1 and 5.

a_list = [number for number in range(1,6) if number % 2 == 1]Copy Code

• Now, the comprehension is a little more compact than its traditional counterpart:

a_list = []
for number in range(1,6):
    if number % 2 == 1:
        a_list.append(number)Copy Code

• Let’s use a comprehension and assign it to the variable cells, making it a list of (row, col) tuples:

rows = range(1,4)
cols = range(1,3)
cells = [(row, col) for row in rows for col in cols]
for cell in cells:
    print(cell)Copy Code

• We can also use tuple unpacking to get the row and col values from each tuple as we iterate over the cells list.

rows = range(1,4)
cols = range(1,3)
cells = [(row, col) for row in rows for col in cols]
for row, col in cells:
    print(row, col)Copy Code

• 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('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('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 it doesn’t exist, it raises an exception:
  • 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')
len(st_city)
st_city.pop('MN')
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?

Assign with =

• 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