This session asks you to get your feet wet with built-in object fundamentals. As before, a few new ideas may pop up along the way, so be sure to flip to Appendix C when you’re done (and even when you’re not).
The basics. Experiment interactively with the common type operations found in this chapter’s tables. To get you started, bring up the Python interactive interpreter, type the expressions below, and try to explain what’s happening in each case:
2 ** 16 2 / 5, 2 / 5.0 "spam" + "eggs" S = "ham" "eggs " + S S * 5 S[:0] "green %s and %s" % ("eggs", S) ('x',)[0] ('x', 'y')[1] L = [1,2,3] + [4,5,6] L, L[:], L[:0], L[-2], L[-2:] ([1,2,3] + [4,5,6])[2:4] [L[2], L[3]] L.reverse(); L L.sort(); L L.index(4) {'a':1, 'b':2}['b'] D = {'x':1, 'y':2, 'z':3} D['w'] = 0 D['x'] + D['w'] D[(1,2,3)] = 4 D.keys(), D.values(), D.has_key((1,2,3)) [[]], ["",[],(),{},None]
Indexing and
slicing. At the interactive prompt, define a list named
L
that contains four strings or numbers (e.g.,
L=[0,1,2,3]
). Now, let’s experiment with
some boundary cases.
What happens when you try to index
out of bounds (e.g., L[4]
)?
What about slicing out of bounds (e.g.,
L[-1000:100]
)?
Finally,
how does Python handle it if you try to extract a sequence in
reverse—with the lower bound greater than the higher bound
(e.g., L[3:1]
)? Hint: try assigning to this slice
(L[3:1] = ['?']
) and see where the value is put.
Do you think this may be the same phenomenon you saw when slicing out
of bounds?
Indexing, slicing, and del. Define
another list L
with four items again, and assign
an empty list to one of its offsets (e.g., L[2] = []
): what happens? Then try assigning an empty list to a
slice (L[2:3] = []
): what happens now? Recall that
slice assignment deletes the slice and inserts the new value where it
used to be. The del
statement deletes offsets,
keys, attributes, and names: try using it on your list to delete an
item (e.g., del L[0]
). What happens if you
del
an entire slice (del L[1:]
)? What happens when you assign a nonsequence to a
slice (L[1:2] = 1
)?
Tuple assignment. What do you think is
happening to X
and Y
when you
type this sequence? We’ll return to this construct in Chapter 3, but it has something to do with the tuples
we’ve seen here.
>>>X = 'spam'
>>>Y = 'eggs'
>>>X, Y = Y, X
Dictionary keys. Consider the following code fragments:
>>>D = {}
>>>D[1] = 'a'
>>>D[2] = 'b'
We learned that dictionaries aren’t accessed by offsets; what’s going on here? Does the following shed any light on the subject? (Hint: strings, integers, and tuples share which type category?)
>>>D[(1, 2, 3)] = 'c'
>>>D
{1: 'a', 2: 'b', (1, 2, 3): 'c'}
Dictionary
indexing. Create a dictionary named D
with three entries, for keys a
,
b
, and c
. What happens if you
try to index a nonexistent key d
(D['d']
)? What does Python do if you try to assign
to a nonexistent key d
(e.g., D['d'] = 'spam'
)? How does this compare to out-of-bounds assignments
and references for lists? Does this sound like the rule for variable
names?
Generic operations. Run interactive tests to answer the following questions.
What happens when you try to use the
+
operator on different/mixed types (e.g., string
+ list, list + tuple)?
Does
+
work when one of the operands is a dictionary?
Does the append
method
work for both lists and strings? How about the using the
keys
method on lists? (Hint: What does
append
assume about its subject object?)
Finally, what type of object do you get back when you slice or concatenate two lists or two strings?
String
indexing. Define a string S
of four
characters: S
=
"spam"
. Then type the following expression:
S[0][0][0][0][0]
. Any clues as to what’s
happening this time? (Hint: recall that a string is a collection of
characters, but Python characters are one-character strings.) Does
this indexing expression still work if you apply it to a list such
as: ['s', 'p', 'a', 'm']
? Why?
Immutable types.
Define a string S
of 4 characters again:
S = "spam"
. Write an assignment that changes the
string to "slam"
, using only slicing and
concatenation. Could you perform the same operation using just
indexing and concatenation? How about index assignment?
Nesting. Write a data-structure that represents your personal information: name (first, middle, last), age, job, address, email ID, and phone number. You may build the data structure with any combination of built-in object types you like: lists, tuples, dictionaries, strings, numbers. Then access the individual components of your data structures by indexing. Do some structures make more sense than others for this object?
Files. Write a script that creates a new output file
called myfile.txt and writes the string
"Hello
file
world!"
in it. Then write another script that
opens myfile.txt, and reads and prints its
contents. Run your two scripts from the system command line. Does the
new file show up in the directory where you ran your scripts? What if
you add a different directory path to the filename passed to
open
?
The dir function revisited. Try typing
the following expressions at the interactive prompt. Starting with
Version 1.5, the dir
function we met in Chapter 1 has been generalized to list all attributes of
any Python object you’re likely to be
interested in. If you’re using an earlier version than 1.5, the
__methods
__ scheme has the same effect.
[].__methods__ # 1.4 or 1.5 dir([]) # 1.5 and later dir({})