Index and slice assignments

First up in this category is a twist on the indexing and slicing we’ve already explored. When using a list, you can change its contents by assigning to either a particular item (offset) or an entire section (slice):

>>> L = ['code', 'Code', 'CODE!']
>>> L[1] = 'Hack'                     # Index assignment
>>> L                                 # Replaces item 1
['code', 'Hack', 'CODE!']

>>> L[0:2] = ['write', 'Python']      # Slice assignment: "delete+insert"
>>> L                                 # Replaces items 0,1
['write', 'Python', 'CODE!']

Both index and slice assignments are in-place changes—they modify the subject list directly, rather than generating a new list object for the result. Index assignment in Python works much as it does in most other languages: Python replaces the single object reference at the designated offset with a new one; the offset’s reference is changed.

Slice assignment, the last operation in the preceding example, replaces an entire section of a list in a single step. Because it can be a bit complex, it is perhaps best thought of as a combination of two steps:

1. Deletion. The slice you specify to the left of the = is deleted.

2. Insertion. The new items contained in the iterable object to the right of the = are inserted into the list on the left, at the place where the old slice was deleted.²

This isn’t what really happens, but it can help clarify why the number of items inserted doesn’t have to match the number of items deleted. For instance, given a list L of two or more items, an assignment L[1:2]=[4,5] replaces one item with two—it’s as though Python first deletes the one-item slice at [1:2] (from offset 1, up to but not including offset 2), then inserts both 4 and 5 where the deleted slice used to be. The net effect makes the list larger.

This also explains why the second slice assignment in the following is really an insert—Python replaces an empty slice at [1:1] with two items; and why the third is really a deletion—Python deletes the slice (the item at offset 1), and then inserts nothing:

>>> L = [1, 2, 3]
>>> L[1:2] = [4, 5]                   # Replacement/insertion
>>> L
[1, 4, 5, 3]
>>> L[1:1] = [6, 7]                   # Insertion (replace nothing)
>>> L
[1, 6, 7, 4, 5, 3]
>>> L[1:2] = []                       # Deletion (insert nothing)
>>> L
[1, 7, 4, 5, 3]

In effect, slice assignment replaces an entire section, or “column,” all at once—even if the column or its replacement is empty. Because the length of the sequence being assigned does not have to match the length of the slice being assigned to, slice assignment can be used to replace (by overwriting), expand (by inserting), or shrink (by deleting) the subject list. It’s a powerful operation, but frankly, one that you may not see very often in practice. There are often more straightforward and mnemonic ways to replace, insert, and delete (including concatenation expressions, and the insert, pop, and remove list methods coming up soon), which Python programmers tend to prefer in practice.

On the other hand, this operation can be used as a sort of in-place concatenation at the front of the list—per the next section’s method coverage, something the list’s extend does more mnemonically but at list end:

>>> L = [1]
>>> L[:0] = [2, 3, 4]          # Insert all at :0, an empty slice at front
>>> L
[2, 3, 4, 1]
>>> L[len(L):] = [5, 6, 7]     # Insert all at len(L):, an empty slice at end
>>> L
[2, 3, 4, 1, 5, 6, 7]
>>> L.extend([8, 9, 10])       # Insert all at end, named method (see also +=)
>>> L
[2, 3, 4, 1, 5, 6, 7, 8, 9, 10]

List method calls

Like strings, Python list objects also support type-specific method calls, most of which change the subject list itself:

>>> L = ['write']
>>> L.append('Python')                     # Append: add one item at the end
>>> L
['write', 'Python']
>>> L.extend(['code', 'goodly'])           # Extend: add many items at the end
>>> L
['write', 'Python', 'code', 'goodly']
>>> L.sort()                               # Sort: order list items ('P' < 'c')
>>> L
['Python', 'code', 'goodly', 'write']

Methods were introduced in Chapter 7. In brief, they are functions (really, object attributes that reference functions) which are associated with and act upon particular subject objects (the objects through which they are called). Methods provide type-specific tools; the list methods presented here, for instance, are generally available only for lists.

Demoed in the preceding code, append is perhaps the most commonly used list method. It simply tacks a single item (really, an object reference) onto the end of the subject list in place, and the list expands to make room for the addition. Unlike concatenation, append expects you to pass in one object, not a list, and uses it literally. In fact, the effect of L.append(X) is similar to L+[X], but the former changes L in place, while the latter makes a new list.³

By contrast, the extend method adds multiple items at the end of the list, again in place. Technically, extend always iterates through and adds each item in the passed iterable object, whereas append simply adds a single item as is without iterating—a distinction that will be more meaningful in Chapter 14. For now, it’s enough to know that extend adds many items, and append adds one. Also ahead: Chapter 11 covers the += statement, which does in-place assignment for lists too, and is yet another way to add many items that redundantly mirrors extend.

The sort method orders the list’s items but merits a section of its own.

Sorting lists

As we’ve just witnessed, sort orders a list in place. It’s a common tool that uses Python standard comparison tests (string comparisons in most examples here, but other objects work in sorts too), and by default sorts in ascending order. You can modify sort behavior by passing in keyword arguments—a special name=value syntax in function calls that we’ve used in earlier chapters, gives values by name, and is often used for configuration options.

In sorts, the reverse argument allows sorts to be made in descending instead of ascending order, and the key argument gives a one-argument function that returns the value to be used in sorting—the string object’s standard lower case converter in the following (though its newer casefold may handle some types of Unicode text better):

>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort()                                # Sort with mixed case
>>> L
['ABD', 'aBe', 'abc']

>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort(key=str.lower)                   # Normalize to lowercase
>>> L
['abc', 'ABD', 'aBe']

>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort(key=str.lower, reverse=True)     # And change sort order
>>> L
['aBe', 'ABD', 'abc']

The sort key argument can also be useful when sorting lists of dictionaries, to select a sort value by indexing each dictionary on a field along the way. We’ll study dictionaries later in this chapter, and you’ll learn more about keyword function arguments in Part IV.

Two notes of caution here: first, sorts won’t work by default with mixed types. In Python, magnitude comparison of mixed types is an error, as it’s generally ambiguous. Because sorting uses these comparisons internally, though, sorting mixed-type lists fails by proxy. To work around this limitation, use the key argument to code value transformations during the sort. The following simply converts all items to strings with the str built-in, but key can be an arbitrary function of your making (and is often coded inline with the lambda expression you’ll meet later in this book):

>>> L = [1, 'hack', 2]            # Mixed-type sorts fail by default
>>> L.sort()
TypeError: '<' not supported between instances of 'str' and 'int'

>>> L.sort(key=str)
>>> L                             # Enable mixed-type sorts: all str
[1, 2, 'hack']

Second, beware that append, extend, and sort change the associated list object in place, but don’t return the modified list as a result (technically, they return the None placeholder object introduced in Chapter 4). If you run L=L.append(X), you won’t get the modified value of L; in fact, you’ll lose the reference to the list altogether! When you use methods like these, objects are changed as a side effect, so there’s no reason to reassign.

Partly because of such constraints, sorting is also available in Python as the sorted built-in function, which sorts any collection (not just lists) and returns a new list for the result (instead of changing the collection in place):

>>> L = ['abc', 'ABD', 'aBe']
>>> sorted(L)                                      # Sorting built-in function
['ABD', 'aBe', 'abc']
>>> L                                              # L is not modified
['abc', 'ABD', 'aBe']

>>> sorted(L, key=str.lower, reverse=True)         # Same arguments as list.sort
['aBe', 'ABD', 'abc']

>>> L = ['abc', 'ABD', 'aBe']
>>> sorted([x.lower() for x in L], reverse=True)   # Pretransform items: differs!
['abe', 'abd', 'abc']

Notice the last example here—we can convert to lowercase prior to the sort with a list comprehension (introduced in in Chapter 4 and expanded shortly), but the result does not contain the original list’s values as it does with the key argument. The latter is applied temporarily during the sort, instead of changing the values to be sorted altogether. As we move along, you’ll see roles in which the sorted built-in can sometimes be more useful than the sort method.

List comprehensions and maps

The last items in Table 8-1, list comprehensions and map calls, were also introduced in Chapter 4 and are covered in full in Chapters 14 and 20. Their basic usage is straightforward, though—list comprehensions are close kin to for loops, and build a new list by applying an expression to each item in a sequence (really, any iterable):

>>> res = [x * 4 for x in 'code']            # List comprehension
>>> res
['cccc', 'oooo', 'dddd', 'eeee']

As a preview, this expression is equivalent to a for loop that builds up a list of results manually with the append we met earlier, but as you’ll learn in later chapters, list comprehensions are simpler to code and may run faster:

>>> res = []                                 # Equivalent loop code
>>> for x in 'code':                         # Append expression results 
...     res.append(x * 4)                    
... 
>>> res
['cccc', 'oooo', 'dddd', 'eeee']

Comprehension also support extensions like if filters and nested for loops, and the map built-in function does similar work, but applies a function instead of an expression to items in a sequence (or other iterable) and collects all the results in a new list—if we wrap it in list to force it to produce all its results:

>>> [x * 4 for x in 'program' if x >= 'p']   # Filter items with if clauses
['pppp', 'rrrr', 'rrrr']

>>> [x + y for x in 'py' for y in '312']     # Nested loops: see Chapter 14!
['p3', 'p1', 'p2', 'y3', 'y1', 'y2']

>>> list(map(abs, [−1, −2, 0, 1, 2]))        # Map a function across a sequence
[1, 2, 0, 1, 2]

While these are powerful tools, their loop equivalents also make them optional. Stay tuned for the related dictionary comprehension later in this chapter, and much more on comprehensions and maps later in this book.

List-literal unpacking

As of Python 3.5, list literals also support a * syntax that unpacks the contents of any iterable (including sequences like lists and strings) at the top level of the list being created. The effect flattens the starred item in the new list:

>>> L = ['code', 'hack']
>>> [L, 2, 3, L]
[['code', 'hack'], 2, 3, ['code', 'hack']]   # Normal assignments nest items

>>> [*L, 2, 3, *L]                           # Iterable unpacking in list literal
['code', 'hack', 2, 3, 'code', 'hack']

>>> S = 'code'                               # Any sequence (or other iterable)
>>> [*'Py', *S, *range(3)]
['P', 'y', 'c', 'o', 'd', 'e', 0, 1, 2]

Importantly, and as is so often true in Python today, * unpacking is never required. The following simple concatenation, for example, has the same effect as the preceding’s first * unpacking—which is redundant in this case:

>>> L + [2, 3] + L                           # What * unpacking does, for lists                      
['code', 'hack', 2, 3, 'code', 'hack']

For nonlist iterables, unpacking without * requires conversions because + expects lists on both sides, but it’s not much extra work, especially given the rarity of such code:

>>> list('Py') + list(S) + list(range(3))    # What * unpacking does, for nonlists
['P', 'y', 'c', 'o', 'd', 'e', 0, 1, 2]

Loops can achieve the same goals as unpacking too; they may be more verbose, but are also more general purpose:

>>> M = []
>>> for x in ('Py', S, range(3)): M.extend(x)        # Loops v special-case hacks
... 
>>> M
['P', 'y', 'c', 'o', 'd', 'e', 0, 1, 2]

Notice two things about this example. First, it codes a tuple of three items as the sequence that the for loop steps through (the tuple’s outer parentheses are optional but explicit). Second, the for loop in this code avoids a line by moving its body up to its header, using a syntax rule we’ll define formally in the next part of this book (tl;dr: this works only for simple statements, like calls to print and extend).

Because we’re not quite ready for the full iteration story, we’ll postpone further details for now, but watch for similar unpacking expressions for dictionaries later in this chapter. Here, though, you should already be able to weigh for yourself whether the alternatives to * unpacking were sufficiently subpar to warrant the convolution.

Dictionary-literal unpacking

As of Python 3.5, dictionary literals also support a special ** syntax that unpacks the contents of another dictionary in its top level, similar to the * in list literals we met earlier. Any number of ** can appear in a literal to unpack any number of dictionaries, and the rightmost’s value wins when keys collide:

>>> D = dict(a=4, c=3)
>>> {'a': 1, 'b': 2, **D}                     # Dictionary-literal unpacking
{'a': 4, 'b': 2, 'c': 3}

>>> dict(a=1, b=2) | D                        # Same, but with union operator
{'a': 4, 'b': 2, 'c': 3}

As shown, the effect of ** is similar to both the update method we met earlier and the dictionary | union covered ahead and might avoid a follow-up update call in some contexts. It’s also related to the extended-unpacking assignment statement you’ll meet in Chapter 11.

The ** also works in dict, but simply because ** unpacks keyword arguments in any function call (as usual in Python, this relies on larger concepts we’ll reach later in this book). Unlike in {} literals though, ** in dict fails if any key appears twice:

>>> dict(a=1, **{'b': 2}, **dict(c=3))        # Works in dict(), as in all calls
{'a': 1, 'b': 2, 'c': 3}                      # As long as no keys are repeated!
 
>>> dict(a=1, b=2, **dict(a=4, c=3))
TypeError: dict() got multiple values for keyword argument 'a'

The examples so far demo the many basic ways to create dictionaries, but there is yet another that’s even more powerful, as the next section will explain.

Mapping values to keys

Notice how the prior table maps years to titles, but not vice versa. If you want to map the other way—titles to years—you can either code the dictionary differently:

>>> table = {'Learning Python, 6th Edition': 2024,         # Title => year
             'Learning Python, 5th Edition': 2013,
             'Learning Python':              1999}

>>> table['Learning Python']                               # Key => value
1999

Or use other dictionary methods like items that give searchable sequences (the list call is required in the following because items returns an iterable view, a topic coming up shortly):

>>> list(table.items())[:2]
[('Learning Python, 6th Edition', 2024), ('Learning Python, 5th Edition', 2013)]

>>> [title for (title, year) in table.items() if year == 1999]     # Value => key
['Learning Python']

The last command here uses the list comprehension we explored earlier, as well as tuple assignment mentioned earlier and covered in this book’s next part (synopsis: it unpacks items into variables). The combo scans the (key, value) pairs returned by the dictionary’s items method, selecting keys for values matching a search target (1999).

The net effect of all this is to index backward—from value to key, instead of key to value. This is useful if you want to store data just once and map backward from values only rarely (searching through sequences like this is generally much slower than a direct key-to-value index, though not all programs need to care).

In fact, although dictionaries by nature map keys to values unidirectionally, there are multiple ways to map values back to keys with a bit of extra generalizable code:

>>> K = 'Learning Python'
>>> V = 1999
>>> table[K]              # Key = >Value (normal usage)
1999

>>> [key for (key, value) in table.items() if value == V]         # Value => Key
['Learning Python'] 

>>> [key for key in table.keys() if table[key] == V]              # Same: keys()
['Learning Python']

Note that both of the last two commands return a list of titles: in dictionaries, there’s just one value per key, but there may be many keys per value if a given value is be stored under multiple keys, and a value might be a collection itself to represent many values per key. It’s also possible to invert a dictionary for indexing values by zipping its values and keys—but only if its values are all immutable and don’t appear in multiple keys:

>>> dict(zip(table.values(), table.keys()))[1999]      # Key/value inversion?
'Learning Python'

Sharp-eyed readers may notice that this yields a dictionary with integer keys, which works naturally per a tip in the next section. For more on this front, watch for a less lossy dictionary inversion function in Chapter 32’s mapattrs.py example—code that would surely stretch this preview past its breaking point if included here. For this chapter’s purposes, let’s wrap up by adding in a few pragmatic pieces to the dictionary puzzle.

Using dictionaries to simulate flexible lists: Integer keys

The last point in the preceding list is important enough to demonstrate with a few examples. When you use lists, it is illegal to assign to an offset that is off the end of the list:

>>> L = []
>>> L[99] = 'hack'
IndexError: list assignment index out of range

Although you can use repetition to preallocate as big a list as you’ll need (e.g., [0]*100), you can also do something that looks similar with dictionaries that does not require such space allocations—and potential waste. By using integer keys, dictionaries can emulate lists that seem to grow on offset assignment:

>>> D = {}
>>> D[99] = 'hack'
>>> D[99]
'hack'
>>> D
{99: 'hack'}

Here, it looks as if D is a 100-item list, but it’s really a dictionary with a single entry; the value of the key 99 is the string 'spam'. You can access this structure with offsets much like a list, catching nonexistent keys with get or in tests if required, but you don’t have to allocate space for all the positions to which you might need to assign values in the future. When used like this, dictionaries are like more flexible equivalents of lists:

>>> D[62] = 'code'
>>> D[30] = 'write'
>>> D[62]
'code'
>>> D
{99: 'hack', 62: 'code', 30: 'write'}

As another example, we might also employ integer keys in the first book book-database code we wrote earlier to avoid quoting the year, albeit at the expense of expressiveness (integer keys cannot contain nondigit characters):

>>> table = {2024: 'Learning Python, 6th Edition',      # Integers work as keys
             …etc…
>>> table[2024]
'Learning Python, 6th Edition'

Using dictionaries for sparse data structures: Tuple keys

In a similar way, dictionary keys are also commonly leveraged to implement sparse—mostly empty—data structures, such as multidimensional arrays where only a few positions have values stored in them:

>>> Matrix = {}
>>> Matrix[(2, 3, 4)] = 88
>>> Matrix[(7, 8, 9)] = 99
>>> 
>>> X = 2; Y = 3; Z = 4               # A ; separates statements: see Chapter 10
>>> Matrix[(X, Y, Z)]
88
>>> Matrix
{(2, 3, 4): 88, (7, 8, 9): 99}

Here, we’ve used a dictionary to represent a three-dimensional array that is empty except for the two positions (2,3,4) and (7,8,9). The keys are tuples that record the coordinates of nonempty slots. Rather than allocating a large and mostly empty three-dimensional matrix to hold these values, we can use a simple two-item dictionary. In this scheme, accessing an empty slot triggers a nonexistent key exception, as these slots are not physically stored:

>>> Matrix[(2,3,6)]
KeyError: (2, 3, 6)

Avoiding missing-key errors

Errors for nonexistent key fetches like the foregoing are common in sparse matrixes, but you probably won’t want them to shut down your program. There are at least three ways to fill in a default value instead of getting such an error message—you can use the dictionary get method shown earlier to provide a default for keys that do not exist, test for keys ahead of time in if statements, or use a try statement to catch and recover from the error. Though straightforward, the last of these are previews of statement syntax we’ll begin studying in Chapter 10:

>>> Matrix.get((2, 3, 4), 0)           # Exists: fetch and return
88
>>> Matrix.get((2, 3, 6), 0)           # Doesn't exist: use passed default
0
>>> if (2, 3, 6) in Matrix:            # Check for key before fetch
...     print(Matrix[(2, 3, 6)])       # See Chapters 10 and 12 for if/else
... else:
...     print(0)
...
0

>>> try:
...     print(Matrix[(2, 3, 6)])       # Try to index
... except KeyError:                   # Catch and recover
...     print(0)                       # See Chapters 10 and 34 for try/except
...
0

Of these, the get method is the most concise in terms of coding requirements, but the if and try statements are much more general in scope—as you’ll start seeing for yourself soon in Chapter 10.

Nesting in dictionaries

As you can tell, dictionaries can play many roles in Python. In general, they can replace search data structures (because indexing by key is a search operation) and can represent many types of structured information. For example, dictionaries are one of many ways to describe the properties of an item in your program’s domain; that is, they can serve the same role as “records” or “structs” in other language, and JSON content in language-neutral roles. The following, for example, fills out a dictionary describing a book, by assigning to new keys:

>>> rec = {}
>>> rec['title'] = 'Learning Python, 5th Edition'
>>> rec['year']  = 2013
>>> rec['isbn']  = '9781449355739'
>>>
>>> rec['year'], rec['isbn']
(2013, '9781449355739')

Especially when nested, though, Python’s built-in data types allow us to easily represent structured information. The following again uses a dictionary to capture object properties, but it codes it all at once rather than assigning to each key separately, and nests a dictionary and list to represent structured property values:

>>> rec = {'title':  'Learning Python, 5th Edition',
           'date':   {'year': 2013, 'month': 'July'},
           'isbns':  ['1449355730', '9781449355739']}

To fetch components of nested objects, simply string together indexing operations:

>>> rec['title']
'Learning Python, 5th Edition'
>>> rec['isbns']
['1449355730', '9781449355739']
>>> rec['isbns'][1]
'9781449355739'
>>> rec['date']['year']
2013

Although you’ll learn in Part VI that classes (which group both data and logic) can sometimes be better in this record role, dictionaries are an easy-to-use tool for simpler requirements. For more on record representation choices, see also the upcoming sidebar “Why You Will Care: List Versus Dictionary Versus Set.”

Also notice that while we’ve focused on a single “record” with nested data here, there’s no reason we couldn’t nest the record itself in a larger, enclosing database collection coded as a list or dictionary, though an external file or formal database interface often plays the role of top-level container in realistic programs. The following abstract snippets would both print a record’s two-item isbns list if run live and provided with an other record omitted here:

db = []
db.append(rec)             # A list "database"
db.append(other)
db[0]['isbns']

db = {}
db['lp5e'] = rec            # A dictionary "database"
db['lp6e'] = other
db['lp5e']['isbns']

Later in the book you’ll meet tools such as Python’s shelve, which works much the same way, but automatically maps objects to and from files to make them permanent. Python objects really can be database records.

Dictionary key/value/item view objects

When we explored the dictionary keys, values, and items methods earlier, we wrapped their results in list calls for display at the REPL prompt. Technically, this is because these methods return views objects that produce results on demand, instead of physical lists. Displaying their raw values suggests as much, but collects their values anyhow:

>>> D = dict(program=1, script=2, app=3)
>>> D.keys()
dict_keys(['program', 'script', 'app'])

View objects are iterables, which we’ve seen simply means objects that generate result items one at a time, instead of producing the result list all at once in memory. Besides being iterable, dictionary views are insertion ordered, reflect future changes to the dictionary, and support set operations. On the other hand, because they are not lists, they do not directly support operations like indexing or the list sort method, and do not display as a normal list when printed.

We’ll discuss the notion of iterables more formally in Chapter 14, but for our purposes here it’s enough to know that we have to run the results of these three methods through the list built-in if we want to apply list operations or display their values as lists. For example:

>>> D = dict(a=1, b=2, c=3)
>>> D
{'a': 1, 'b': 2, 'c': 3}
 
>>> K = D.keys()                   # Makes a view object, not a list
>>> K
dict_keys(['a', 'b', 'c'])
>>> list(K)                        # Force a real list when needed
['a', 'b', 'c']
 
>>> V = D.values()                 # Ditto for values and items views
>>> V
dict_values([1, 2, 3])
>>> list(V)
[1, 2, 3]
 
>>> D.items()
dict_items([('a', 1), ('b', 2), ('c', 3)])
>>> list(D.items())
[('a', 1), ('b', 2), ('c', 3)]
 
>>> K[0]                           # List operations fail unless converted
TypeError: 'dict_keys' object is not subscriptable
>>> K.sort()
AttributeError: 'dict_keys' object has no attribute 'sort'
>>> list(K)[0], list(K).sort()
('a', None)

Unlike lists, though, dictionary views don’t take up space for their full results, and are not carved in stone when created—they dynamically reflect future changes made to the dictionary after the view object has been created:

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D
{'a': 1, 'b': 2, 'c': 3}

>>> K = D.keys()
>>> V = D.values()
>>> list(K), list(V)              # Views maintain same order as dictionary
(['a', 'b', 'c'], [1, 2, 3])

>>> del D['b']                    # Change the dictionary in place
>>> D
{'a': 1, 'c': 3}

>>> list(K), list(V)              # Reflected in any current view objects
(['a', 'c'], [1, 3])

That said, use cases for dynamic view morph are likely rare. In fact, apart from result displays at the interactive prompt, you probably won’t even notice views very often in practice, because looping constructs in Python automatically force them to produce one result on each:

>>> for k in D.keys(): print(k)    # View iterators used automatically in loops
...                                # But no need to call keys() to iterate on D
a
b
c

As we’ve seen, it’s also often unnecessary to call keys directly in such cases because dictionaries themselves provide implicit key iterators; for better or worse, for k in D is usually as much code as you need to type.

Dictionary views and sets

Though perhaps even more obscure than view objects in general, some dictionary views are also set-like and support set operations such as union and intersection that we used on true sets in Chapter 5. Specifically, views returned by the keys method are set-like, values views are not, and items views are if their (key, value) pairs are unique and hashable (immutable). This reflects logical symmetry: set items are unique and immutable just like dictionary keys, and sets themselves behave like unordered and valueless dictionaries (and are even coded in curly braces).

Here is what keys views look like when used in set operations (continuing the prior section’s session); as also shown, dictionary value views are never set-like, because their items are not necessarily unique or immutable:

>>> K, V
(dict_keys(['a', 'c']), dict_values([1, 3])) 

>>> K | {'x': 4}                   # Keys (and some items) views are set-like
{'x', 'a', 'c'}                    # Results are unordered sets, not views

>>> V | {'x': 4}
TypeError: unsupported operand type(s) for |: 'dict_values' and 'dict'
>>> V | {'x': 4}.values()
TypeError: unsupported operand type(s) for |: 'dict_values' and 'dict_values'

Be careful not to confuse the | here with the dictionary union operation we met earlier in the section “Dictionary ‘Union’ Operator”; when run on a view, | is not a full key-based dictionary merge. In set operations, views may be mixed with other views, sets, and dictionaries, and dictionaries are treated the same as their keys views:

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> D.keys() & D.keys()            # Intersect views
{'b', 'a', 'c'}
>>> D.keys() & {'b'}               # Intersect view and set
{'b'}
>>> D.keys() & {'b': 1}            # Intersect view and dict
{'b'}
>>> D.keys() | {'b', 'c', 'd'}     # Union view and set
{'b', 'a', 'd', 'c'}

Items views are set-like too, but only if they are hashable—that is, if they contain only immutable objects:

>>> {'a': [1, 2]}.items() | {0, 1}     # Immutable value: no set ops
TypeError: unhashable type: 'list'

>>> D = {'a': 1}
>>> D.items()                          # Items set-like if and only if hashable
dict_items([('a', 1)])
>>> D.items() | D.keys()               # Union view and view
{('a', 1), 'a'}
>>> D.items() | D                      # Dictionary treated same as its keys
{('a', 1), 'a'}
 
>>> D.items() | {('c', 3), ('d', 4)}           # Set of key/value pairs
{('a', 1), ('c', 3), ('d', 4)}

>>> dict(D.items() | {('c', 3), ('d', 4)})     # dict accepts iterable sets too
{'a': 1, 'c': 3, 'd': 4}

See Chapter 5’s coverage of sets if you need a refresher on these operations. Their role in dictionary views is probably uncommon and may even be academic; but they work when helpful (and at least you now have a fighting chance when they crop up in sadistic final exams!). Here, let’s wrap up with two more quick coding notes for dictionaries.

Sorting dictionary keys

First of all, keys lists must be sorted when the inherent insertion order doesn’t meet your goals. Beware, though, that a common coding pattern for scanning a collection in sorted order won’t work, because keys does not return a list:

>>> D = {'c': 3, 'b': 2, 'a': 1}
>>> D
{'c': 3, 'b': 2, 'a': 1}
 
>>> Ks = D.keys()                            # Sorting a view object doesn't work!
>>> Ks.sort()
AttributeError: 'dict_keys' object has no attribute 'sort'

To work around this, you can either convert keys to a list manually, or use the sorted call, applied to lists earlier in this chapter, on either a keys view or the dictionary itself:

>>> Ks = list(D.keys())                      # Convert keys to a list
>>> Ks.sort()                                # And then sort with list.sort()
>>> for k in Ks: print(k, D[k])
...
a 1
b 2
c 3

>>> Ks = D.keys()                            # Or use sorted() on the keys view
>>> for k in sorted(Ks): print(k, D[k])      # sorted() accepts any iterable
...                                          # sorted() returns its result
a 1
b 2
c 3

Of these, using the dictionary’s keys iterator is simplest and common, though also arguably implicit:

>>> for k in sorted(D): print(k, D[k])       # Or use sorted() on the dict
...                                          # dict iterators produce keys 
a 1
b 2
c 3

Dictionary magnitude comparisons

Finally, dictionaries can be compared for equality directly with ==, which automatically compares each key/value pair and ignores insertion order:

>>> D1 = dict(a=1, b=2, c=3)
>>> D2 = dict(c=3, b=2, a=1)
>>> D1, D2
({'a': 1, 'b': 2, 'c': 3}, {'c': 3, 'b': 2, 'a': 1})
>>> D1 == D2, D1 != D2
(True, False)

Magnitude comparisons like < and > do not work on dictionaries themselves, though you can implement them by comparing key/value items views manually, if you also sort them to discount any insert-order difference (subtlety: a > on the items results directly runs the set superset test because the views are set-like—not greater-than!):

>>> D1 = dict(a=1, b=2, c=4)
>>> D2 = dict(c=3, b=2, a=1)                   # D1 > D2: D1['c'] > D2['c']
>>> D1 > D2
TypeError: '>' not supported between instances of 'dict' and 'dict'

>>> list(D1.items()), list(D2.items())
([('a', 1), ('b', 2), ('c', 4)], [('c', 3), ('b', 2), ('a', 1)])
 
>>> list(D1.items()) > list(D2.items())        # Fails: insertion order
False
>>> D1.items() > D2.items()                    # Fails: superset, not magnitude
False
>>> sorted(D1.items()) > sorted(D2.items())    # OK: sorted to neutralize order
True

Because we’ll revisit this near the end of the next chapter to reinforce them in the context of comparisons at large, we’ll postpone further coverage here.