Introduction to Python

davidbpython.com

Containers: Tuples and Sets

tuples and sets: like lists but different

It's helpful to contrast these containers with lists.

• tuples are like lists, but read-only
• sets are like lists, but the items are unordered and unique (no duplicates in a set)

It's easy to remember how to use one of these containers by considering how they differ in behavior.

the tuple container object

A tuple is an immutable, ordered sequence of values.

var2 = (1, 2, 3, 'a', 'b')     # initialize a tuple of values

• immutable means the tuple cannot be changed once initialized
• the best way to think about tuples is that they are identical to lists in every way, except that they are read-only -- they can't be changed
• any value can be included within a tuple
• as with lists, items in a tuple do not need to be of the same type

subscripting a tuple

Subscripting allows us to read individual items from a tuple.

mytuple = (1, 2, 3, 'a', 'b')       # initialize a tuple of values

xx = mytuple[3]                     # 'a'

Note that as with lists, indexing starts at 0, so index 1 is the 2nd item, index 2 is the 3rd item, etc.

slicing a tuple

Slicing a tuple returns a new tuple.

var2 = (1, 2, 3, 'a', 'b')             # initialize a tuple of values

subtuple1 = var2[0:3]                  # (1, 2, 3)

subtuple2 = var2[2:4]                  # (3, 'a')

subtuple3 = var2[3:]                   # ('a', 'b')

Remember the rules of slicing, which are the same as lists and strings:

• indexing begins at 0, so 0 is the first item
• the "upper bound" (2nd integer) is an index one greater than the item that will be returned (non-inclusive)
• to slice off the end, leave off the upper bound

concatenating two tuples with +

Concatenation works in the same way as with lists and strings.

var = ('a', 'b', 'c')
var2 = ('d', 'e', 'f')

var3 = var + var2                  # ('a', 'b', 'c', 'd', 'e', 'f')

Ex. 5.12

set container object

A set is an unordered, unique collection of values.

myset = set()                  # initialize an empty set (note that empty
                               # curly braces are reserved for dicts)

myset = {'a', 9999, 4.3, 'a'}  # initialize a set with items

print(myset)                   # {9999, 4.3, 'a'}

• note that the set has changed the order of items (this may vary from time to time)
• note also that the duplicate 'a' has been eliminated
• this illustrates the two salient characteristics of a set: items are unordered and unique

adding an item to a set

The set changes in place; any duplicate item will be ignored.

myset = set()        # initialize an empty set

myset.add(4.3)       # note well!  we do not assign back to myset
myset.add('a')
myset.add('a')

print(myset)         # {'a', 4.3}    (order is not
                     #                necessarily maintained)

• Note that 'a' was added twice, but only appears once.
• Also note that we do not assign back to myset -- this is because sets are also mutable, so the .add() changes the set in-place.

getting information about a set or tuple

Here are len() and in with a tuple.

# get the length of a set or tuple (compare to len() of a list or string)
myset = {1, 2, 3, 'a', 'b'}

yy = len(myset)                # 5


# test for membership in a set or tuple
mytuple = (1, 2, 3, 'a', 'b')

if 'b' in mytuple:                        # bool, True
    print("'b' can be found in mytuple")

print('b' in mytuple)                     # "True":  the 'in' operator
                                          # actually returns True or False

• note that these operations are identical as for a list
• (Python tries as much as may be possible to unify operations between similar objects)

looping through a set or tuple

The 'for' loop allows us to traverse a set or tuple and work with each item.

mytuple = (1, 2, 3, 'a', 'b')            # could also be a set here

for var in mytuple:
    print(var)                           # prints 1, then 2, then 3,
                                         # then a, then b

• Whether a list, set or tuple, these operations work in the same way.

summary functions: len(), sum(), max(), min()

These functions also work as they do with lists.

Whether a set or tuple, these operations work in the same way.

mytuple = (1, 3, 5, 7, 9)       # initialize a tuple
myset =   {1, 3, 5, 7, 9}       # initialize a set

print(len(mytuple))             # 5  (count of items)
print(sum(myset))               # 25 (sum of values)

print(min(myset))               # 1 (smallest value)
print(max(mytuple))             # 9 (largest value)

sorting a set or tuple

Regardless of type, sorted() returns a list of sorted values.

mytuple = (4, 9, 1.2, -5, 200, 20)       # could also be a set here

smyl = sorted(mytuple)                   # [-5, 1.2, 4, 9, 20, 200]

• Whether a list, tuple or set, these operations work in the same way.
• Note that unlike other operations discussed here, sorted() returns a list. This is always the case sorting any object.

Ex. 5.13

why do we need sets?

The set's duplicate elimination behavior gives us certain advantages.

As we saw, sets have 2 important characteristics:

• all items are unique
• items are not in any particular order

How can we use a set?

• eliminate duplicates from repeating data
• checking for membership with 'in' (is it there?)