-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy path08-string.html
669 lines (642 loc) · 44.9 KB
/
08-string.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Strings — Pense Python 2e documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: './',
VERSION: '2e',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<link rel="top" title="Pense Python 2e documentation" href="index.html" />
<link rel="next" title="Case study: word play" href="09-case-word.html" />
<link rel="prev" title="Iteration" href="07-iteration.html" />
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9">
</head>
<body role="document">
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="strings">
<h1>Strings<a class="headerlink" href="#strings" title="Permalink to this headline">¶</a></h1>
<p>Strings are not like integers, floats, and booleans. A string is a
<strong>sequence</strong>, which means it is an ordered collection of other values.
In this chapter you’ll see how to access the characters that make up a
string, and you’ll learn about some of the methods strings provide.</p>
<div class="section" id="a-string-is-a-sequence">
<h2>A string is a sequence<a class="headerlink" href="#a-string-is-a-sequence" title="Permalink to this headline">¶</a></h2>
<p>A string is a sequence of characters. You can access the characters one
at a time with the bracket operator:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fruit</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="gp">>>> </span><span class="n">letter</span> <span class="o">=</span> <span class="n">fruit</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
<p>The second statement selects character number 1 from fruit and assigns
it to letter.</p>
<p>The expression in brackets is called an <strong>index</strong>. The index indicates
which character in the sequence you want (hence the name).</p>
<p>But you might not get what you expect:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">letter</span>
<span class="go">'a'</span>
</pre></div>
</div>
<p>For most people, the first letter of <code class="docutils literal"><span class="pre">'banana'</span></code> is b, not a. But for
computer scientists, the index is an offset from the beginning of the
string, and the offset of the first letter is zero.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">letter</span> <span class="o">=</span> <span class="n">fruit</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">letter</span>
<span class="go">'b'</span>
</pre></div>
</div>
<p>So b is the 0th letter (“zero-eth”) of <code class="docutils literal"><span class="pre">'banana'</span></code>, a is the 1th letter
(“one-eth”), and n is the 2th letter (“two-eth”).</p>
<p>As an index you can use an expression that contains variables and
operators:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">i</span> <span class="o">=</span> <span class="mi">1</span>
<span class="gp">>>> </span><span class="n">fruit</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="go">'a'</span>
<span class="gp">>>> </span><span class="n">fruit</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span>
<span class="go">'n'</span>
</pre></div>
</div>
<p>But the value of the index has to be an integer. Otherwise you get:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">letter</span> <span class="o">=</span> <span class="n">fruit</span><span class="p">[</span><span class="mf">1.5</span><span class="p">]</span>
<span class="go">TypeError: string indices must be integers</span>
</pre></div>
</div>
</div>
<div class="section" id="len">
<h2>len<a class="headerlink" href="#len" title="Permalink to this headline">¶</a></h2>
<p>len is a built-in function that returns the number of characters in a
string:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fruit</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="gp">>>> </span><span class="nb">len</span><span class="p">(</span><span class="n">fruit</span><span class="p">)</span>
<span class="go">6</span>
</pre></div>
</div>
<p>To get the last letter of a string, you might be tempted to try
something like this:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">length</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">fruit</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">last</span> <span class="o">=</span> <span class="n">fruit</span><span class="p">[</span><span class="n">length</span><span class="p">]</span>
<span class="go">IndexError: string index out of range</span>
</pre></div>
</div>
<p>The reason for the IndexError is that there is no letter in ’banana’
with the index 6. Since we started counting at zero, the six letters are
numbered 0 to 5. To get the last character, you have to subtract 1 from
length:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">last</span> <span class="o">=</span> <span class="n">fruit</span><span class="p">[</span><span class="n">length</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">last</span>
<span class="go">'a'</span>
</pre></div>
</div>
<p>Or you can use negative indices, which count backward from the end of
the string. The expression fruit[-1] yields the last letter, fruit[-2]
yields the second to last, and so on.</p>
</div>
<div class="section" id="traversal-with-a-for-loop">
<h2>Traversal with a for loop<a class="headerlink" href="#traversal-with-a-for-loop" title="Permalink to this headline">¶</a></h2>
<p>A lot of computations involve processing a string one character at a
time. Often they start at the beginning, select each character in turn,
do something to it, and continue until the end. This pattern of
processing is called a <strong>traversal</strong>. One way to write a traversal is
with a while loop:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">index</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">while</span> <span class="n">index</span> <span class="o"><</span> <span class="nb">len</span><span class="p">(</span><span class="n">fruit</span><span class="p">):</span>
<span class="n">letter</span> <span class="o">=</span> <span class="n">fruit</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>
<span class="k">print</span><span class="p">(</span><span class="n">letter</span><span class="p">)</span>
<span class="n">index</span> <span class="o">=</span> <span class="n">index</span> <span class="o">+</span> <span class="mi">1</span>
</pre></div>
</div>
<p>This loop traverses the string and displays each letter on a line by
itself. The loop condition is index < len(fruit), so when index is equal
to the length of the string, the condition is false, and the body of the
loop doesn’t run. The last character accessed is the one with the index
len(fruit)-1, which is the last character in the string.</p>
<p>As an exercise, write a function that takes a string as an argument and
displays the letters backward, one per line.</p>
<p>Another way to write a traversal is with a for loop:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">letter</span> <span class="ow">in</span> <span class="n">fruit</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="n">letter</span><span class="p">)</span>
</pre></div>
</div>
<p>Each time through the loop, the next character in the string is assigned
to the variable letter. The loop continues until no characters are left.</p>
<p>The following example shows how to use concatenation (string addition)
and a for loop to generate an abecedarian series (that is, in
alphabetical order). In Robert McCloskey’s book <em>Make Way for
Ducklings</em>, the names of the ducklings are Jack, Kack, Lack, Mack, Nack,
Ouack, Pack, and Quack. This loop outputs these names in order:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">prefixes</span> <span class="o">=</span> <span class="s">'JKLMNOPQ'</span>
<span class="n">suffix</span> <span class="o">=</span> <span class="s">'ack'</span>
<span class="k">for</span> <span class="n">letter</span> <span class="ow">in</span> <span class="n">prefixes</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="n">letter</span> <span class="o">+</span> <span class="n">suffix</span><span class="p">)</span>
</pre></div>
</div>
<p>The output is:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">Jack</span>
<span class="n">Kack</span>
<span class="n">Lack</span>
<span class="n">Mack</span>
<span class="n">Nack</span>
<span class="n">Oack</span>
<span class="n">Pack</span>
<span class="n">Qack</span>
</pre></div>
</div>
<p>Of course, that’s not quite right because “Ouack” and “Quack” are
misspelled. As an exercise, modify the program to fix this error.</p>
</div>
<div class="section" id="string-slices">
<h2>String slices<a class="headerlink" href="#string-slices" title="Permalink to this headline">¶</a></h2>
<p>A segment of a string is called a <strong>slice</strong>. Selecting a slice is
similar to selecting a character:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="s">'Monty Python'</span>
<span class="gp">>>> </span><span class="n">s</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">5</span><span class="p">]</span>
<span class="go">'Monty'</span>
<span class="gp">>>> </span><span class="n">s</span><span class="p">[</span><span class="mi">6</span><span class="p">:</span><span class="mi">12</span><span class="p">]</span>
<span class="go">'Python'</span>
</pre></div>
</div>
<p>The operator returns the part of the string from the “n-eth” character
to the “m-eth” character, including the first but excluding the last.
This behavior is counterintuitive, but it might help to imagine the
indices pointing <em>between</em> the characters, as in Figure [fig.banana].</p>
<div class="figure" id="id1">
<img alt="Slice indices." src="_images/banana.pdf" />
<p class="caption"><span class="caption-text">Slice indices.</span></p>
</div>
<p>If you omit the first index (before the colon), the slice starts at the
beginning of the string. If you omit the second index, the slice goes to
the end of the string:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fruit</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="gp">>>> </span><span class="n">fruit</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span>
<span class="go">'ban'</span>
<span class="gp">>>> </span><span class="n">fruit</span><span class="p">[</span><span class="mi">3</span><span class="p">:]</span>
<span class="go">'ana'</span>
</pre></div>
</div>
<p>If the first index is greater than or equal to the second the result is
an <strong>empty string</strong>, represented by two quotation marks:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fruit</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="gp">>>> </span><span class="n">fruit</span><span class="p">[</span><span class="mi">3</span><span class="p">:</span><span class="mi">3</span><span class="p">]</span>
<span class="go">''</span>
</pre></div>
</div>
<p>An empty string contains no characters and has length 0, but other than
that, it is the same as any other string.</p>
<p>Continuing this example, what do you think fruit[:] means? Try it and
see.</p>
</div>
<div class="section" id="strings-are-immutable">
<h2>Strings are immutable<a class="headerlink" href="#strings-are-immutable" title="Permalink to this headline">¶</a></h2>
<p>It is tempting to use the operator on the left side of an assignment,
with the intention of changing a character in a string. For example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">greeting</span> <span class="o">=</span> <span class="s">'Hello, world!'</span>
<span class="gp">>>> </span><span class="n">greeting</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s">'J'</span>
<span class="go">TypeError: 'str' object does not support item assignment</span>
</pre></div>
</div>
<p>The “object” in this case is the string and the “item” is the character
you tried to assign. For now, an object is the same thing as a value,
but we will refine that definition later (Section [equivalence]).</p>
<p>The reason for the error is that strings are <strong>immutable</strong>, which means
you can’t change an existing string. The best you can do is create a new
string that is a variation on the original:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">greeting</span> <span class="o">=</span> <span class="s">'Hello, world!'</span>
<span class="gp">>>> </span><span class="n">new_greeting</span> <span class="o">=</span> <span class="s">'J'</span> <span class="o">+</span> <span class="n">greeting</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="gp">>>> </span><span class="n">new_greeting</span>
<span class="go">'Jello, world!'</span>
</pre></div>
</div>
<p>This example concatenates a new first letter onto a slice of greeting.
It has no effect on the original string.</p>
</div>
<div class="section" id="searching">
<h2>Searching<a class="headerlink" href="#searching" title="Permalink to this headline">¶</a></h2>
<p>What does the following function do?</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">find</span><span class="p">(</span><span class="n">word</span><span class="p">,</span> <span class="n">letter</span><span class="p">):</span>
<span class="n">index</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">while</span> <span class="n">index</span> <span class="o"><</span> <span class="nb">len</span><span class="p">(</span><span class="n">word</span><span class="p">):</span>
<span class="k">if</span> <span class="n">word</span><span class="p">[</span><span class="n">index</span><span class="p">]</span> <span class="o">==</span> <span class="n">letter</span><span class="p">:</span>
<span class="k">return</span> <span class="n">index</span>
<span class="n">index</span> <span class="o">=</span> <span class="n">index</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
</pre></div>
</div>
<p>In a sense, find is the inverse of the operator. Instead of taking an
index and extracting the corresponding character, it takes a character
and finds the index where that character appears. If the character is
not found, the function returns -1.</p>
<p>This is the first example we have seen of a return statement inside a
loop. If word[index] == letter, the function breaks out of the loop and
returns immediately.</p>
<p>If the character doesn’t appear in the string, the program exits the
loop normally and returns -1.</p>
<p>This pattern of computation—traversing a sequence and returning when we
find what we are looking for—is called a <strong>search</strong>.</p>
<p>As an exercise, modify find so that it has a third parameter, the index
in word where it should start looking.</p>
</div>
<div class="section" id="looping-and-counting">
<h2>Looping and counting<a class="headerlink" href="#looping-and-counting" title="Permalink to this headline">¶</a></h2>
<p>The following program counts the number of times the letter a appears in
a string:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">word</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="n">count</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">letter</span> <span class="ow">in</span> <span class="n">word</span><span class="p">:</span>
<span class="k">if</span> <span class="n">letter</span> <span class="o">==</span> <span class="s">'a'</span><span class="p">:</span>
<span class="n">count</span> <span class="o">=</span> <span class="n">count</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">print</span><span class="p">(</span><span class="n">count</span><span class="p">)</span>
</pre></div>
</div>
<p>This program demonstrates another pattern of computation called a
<strong>counter</strong>. The variable count is initialized to 0 and then incremented
each time an a is found. When the loop exits, count contains the
result—the total number of a’s.</p>
<p>As an exercise, encapsulate this code in a function named count, and
generalize it so that it accepts the string and the letter as arguments.</p>
<p>Then rewrite the function so that instead of traversing the string, it
uses the three-parameter version of find from the previous section.</p>
</div>
<div class="section" id="string-methods">
<h2>String methods<a class="headerlink" href="#string-methods" title="Permalink to this headline">¶</a></h2>
<p>Strings provide methods that perform a variety of useful operations. A
method is similar to a function—it takes arguments and returns a
value—but the syntax is different. For example, the method upper takes a
string and returns a new string with all uppercase letters.</p>
<p>Instead of the function syntax upper(word), it uses the method syntax
word.upper().</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="gp">>>> </span><span class="n">new_word</span> <span class="o">=</span> <span class="n">word</span><span class="o">.</span><span class="n">upper</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">new_word</span>
<span class="go">'BANANA'</span>
</pre></div>
</div>
<p>This form of dot notation specifies the name of the method, upper, and
the name of the string to apply the method to, word. The empty
parentheses indicate that this method takes no arguments.</p>
<p>A method call is called an <strong>invocation</strong>; in this case, we would say
that we are invoking upper on word.</p>
<p>As it turns out, there is a string method named find that is remarkably
similar to the function we wrote:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="gp">>>> </span><span class="n">index</span> <span class="o">=</span> <span class="n">word</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="s">'a'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">index</span>
<span class="go">1</span>
</pre></div>
</div>
<p>In this example, we invoke find on word and pass the letter we are
looking for as a parameter.</p>
<p>Actually, the find method is more general than our function; it can find
substrings, not just characters:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="s">'na'</span><span class="p">)</span>
<span class="go">2</span>
</pre></div>
</div>
<p>By default, find starts at the beginning of the string, but it can take
a second argument, the index where it should start:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">word</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="s">'na'</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">4</span>
</pre></div>
</div>
<p>This is an example of an <strong>optional argument</strong>; find can also take a
third argument, the index where it should stop:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">name</span> <span class="o">=</span> <span class="s">'bob'</span>
<span class="gp">>>> </span><span class="n">name</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="s">'b'</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">-1</span>
</pre></div>
</div>
<p>This search fails because b does not appear in the index range from 1 to
2, not including 2. Searching up to, but not including, the second index
makes find consistent with the slice operator.</p>
</div>
<div class="section" id="the-in-operator">
<h2>The in operator<a class="headerlink" href="#the-in-operator" title="Permalink to this headline">¶</a></h2>
<p>The word in is a boolean operator that takes two strings and returns
True if the first appears as a substring in the second:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="s">'a'</span> <span class="ow">in</span> <span class="s">'banana'</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="s">'seed'</span> <span class="ow">in</span> <span class="s">'banana'</span>
<span class="go">False</span>
</pre></div>
</div>
<p>For example, the following function prints all the letters from word1
that also appear in word2:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">in_both</span><span class="p">(</span><span class="n">word1</span><span class="p">,</span> <span class="n">word2</span><span class="p">):</span>
<span class="k">for</span> <span class="n">letter</span> <span class="ow">in</span> <span class="n">word1</span><span class="p">:</span>
<span class="k">if</span> <span class="n">letter</span> <span class="ow">in</span> <span class="n">word2</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="n">letter</span><span class="p">)</span>
</pre></div>
</div>
<p>With well-chosen variable names, Python sometimes reads like English.
You could read this loop, “for (each) letter in (the first) word, if
(the) letter (appears) in (the second) word, print (the) letter.”</p>
<p>Here’s what you get if you compare apples and oranges:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">in_both</span><span class="p">(</span><span class="s">'apples'</span><span class="p">,</span> <span class="s">'oranges'</span><span class="p">)</span>
<span class="go">a</span>
<span class="go">e</span>
<span class="go">s</span>
</pre></div>
</div>
</div>
<div class="section" id="string-comparison">
<h2>String comparison<a class="headerlink" href="#string-comparison" title="Permalink to this headline">¶</a></h2>
<p>The relational operators work on strings. To see if two strings are
equal:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">if</span> <span class="n">word</span> <span class="o">==</span> <span class="s">'banana'</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s">'All right, bananas.'</span><span class="p">)</span>
</pre></div>
</div>
<p>Other relational operations are useful for putting words in alphabetical
order:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">if</span> <span class="n">word</span> <span class="o"><</span> <span class="s">'banana'</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s">'Your word, '</span> <span class="o">+</span> <span class="n">word</span> <span class="o">+</span> <span class="s">', comes before banana.'</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">word</span> <span class="o">></span> <span class="s">'banana'</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s">'Your word, '</span> <span class="o">+</span> <span class="n">word</span> <span class="o">+</span> <span class="s">', comes after banana.'</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s">'All right, bananas.'</span><span class="p">)</span>
</pre></div>
</div>
<p>Python does not handle uppercase and lowercase letters the same way
people do. All the uppercase letters come before all the lowercase
letters, so:</p>
<div class="highlight-python"><div class="highlight"><pre>Your word, Pineapple, comes before banana.
</pre></div>
</div>
<p>A common way to address this problem is to convert strings to a standard
format, such as all lowercase, before performing the comparison. Keep
that in mind in case you have to defend yourself against a man armed
with a Pineapple.</p>
</div>
<div class="section" id="debugging">
<h2>Debugging<a class="headerlink" href="#debugging" title="Permalink to this headline">¶</a></h2>
<p>When you use indices to traverse the values in a sequence, it is tricky
to get the beginning and end of the traversal right. Here is a function
that is supposed to compare two words and return True if one of the
words is the reverse of the other, but it contains two errors:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">is_reverse</span><span class="p">(</span><span class="n">word1</span><span class="p">,</span> <span class="n">word2</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">word1</span><span class="p">)</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">word2</span><span class="p">):</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">j</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">word2</span><span class="p">)</span>
<span class="k">while</span> <span class="n">j</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
<span class="k">if</span> <span class="n">word1</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">!=</span> <span class="n">word2</span><span class="p">[</span><span class="n">j</span><span class="p">]:</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">i</span><span class="o">+</span><span class="mi">1</span>
<span class="n">j</span> <span class="o">=</span> <span class="n">j</span><span class="o">-</span><span class="mi">1</span>
<span class="k">return</span> <span class="bp">True</span>
</pre></div>
</div>
<p>The first if statement checks whether the words are the same length. If
not, we can return False immediately. Otherwise, for the rest of the
function, we can assume that the words are the same length. This is an
example of the guardian pattern in Section [guardian].</p>
<p>i and j are indices: i traverses word1 forward while j traverses word2
backward. If we find two letters that don’t match, we can return False
immediately. If we get through the whole loop and all the letters match,
we return True.</p>
<p>If we test this function with the words “pots” and “stop”, we expect the
return value True, but we get an IndexError:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">is_reverse</span><span class="p">(</span><span class="s">'pots'</span><span class="p">,</span> <span class="s">'stop'</span><span class="p">)</span>
<span class="gp">...</span>
<span class="go"> File "reverse.py", line 15, in is_reverse</span>
<span class="go"> if word1[i] != word2[j]:</span>
<span class="go">IndexError: string index out of range</span>
</pre></div>
</div>
<p>For debugging this kind of error, my first move is to print the values
of the indices immediately before the line where the error appears.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">while</span> <span class="n">j</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">j</span><span class="p">)</span> <span class="c"># print here</span>
<span class="k">if</span> <span class="n">word1</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">!=</span> <span class="n">word2</span><span class="p">[</span><span class="n">j</span><span class="p">]:</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">i</span><span class="o">+</span><span class="mi">1</span>
<span class="n">j</span> <span class="o">=</span> <span class="n">j</span><span class="o">-</span><span class="mi">1</span>
</pre></div>
</div>
<p>Now when I run the program again, I get more information:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">is_reverse</span><span class="p">(</span><span class="s">'pots'</span><span class="p">,</span> <span class="s">'stop'</span><span class="p">)</span>
<span class="go">0 4</span>
<span class="gp">...</span>
<span class="go">IndexError: string index out of range</span>
</pre></div>
</div>
<p>The first time through the loop, the value of j is 4, which is out of
range for the string <code class="docutils literal"><span class="pre">'pots'</span></code>. The index of the last character is 3,
so the initial value for j should be len(word2)-1.</p>
<p>If I fix that error and run the program again, I get:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">is_reverse</span><span class="p">(</span><span class="s">'pots'</span><span class="p">,</span> <span class="s">'stop'</span><span class="p">)</span>
<span class="go">0 3</span>
<span class="go">1 2</span>
<span class="go">2 1</span>
<span class="go">True</span>
</pre></div>
</div>
<p>This time we get the right answer, but it looks like the loop only ran
three times, which is suspicious. To get a better idea of what is
happening, it is useful to draw a state diagram. During the first
iteration, the frame for <code class="docutils literal"><span class="pre">is_reverse</span></code> is shown in Figure [fig.state4].</p>
<div class="figure" id="id2">
<img alt="State diagram." src="_images/state4.pdf" />
<p class="caption"><span class="caption-text">State diagram.</span></p>
</div>
<p>I took some license by arranging the variables in the frame and adding
dotted lines to show that the values of i and j indicate characters in
word1 and word2.</p>
<p>Starting with this diagram, run the program on paper, changing the
values of i and j during each iteration. Find and fix the second error
in this function. [isreverse]</p>
</div>
<div class="section" id="glossary">
<span id="glossary08"></span><h2>Glossary<a class="headerlink" href="#glossary" title="Permalink to this headline">¶</a></h2>
<dl class="docutils">
<dt>objeto (<em>object</em>)</dt>
<dd>Something a variable can refer to. For now, you can use “object” and “value” interchangeably.</dd>
<dt>sequência de formatação (<em>sequence</em>)</dt>
<dd>An ordered collection of values where each value is identified by an integer index.</dd>
<dt><em>item</em> (item)</dt>
<dd>One of the values in a sequence.</dd>
<dt>índice (<em>index</em>)</dt>
<dd>An integer value used to select an item in a sequence, such as a character in a string. In Python indices start from 0.</dd>
<dt>código provisório (<em>slice</em>)</dt>
<dd>A part of a string specified by a range of indices.</dd>
<dt>string vazia (<em>empty string</em>)</dt>
<dd>A string with no characters and length 0, represented by two quotation marks.</dd>
<dt>imutável (<em>immutable</em>)</dt>
<dd>The property of a sequence whose items cannot be changed.</dd>
<dt>percorrer (<em>traverse</em>)</dt>
<dd>To iterate through the items in a sequence, performing a similar operation on each.</dd>
<dt>busca (<em>search</em>)</dt>
<dd>A pattern of traversal that stops when it finds what it is looking for.</dd>
<dt>contador (<em>counter</em>)</dt>
<dd>A variable used to count something, usually initialized to zero and then incremented.</dd>
<dt>invocação (<em>invocation</em>)</dt>
<dd>A statement that calls a method.</dd>
<dt>argumento opcional (<em>optional argument</em>)</dt>
<dd>A function or method argument that is not required.</dd>
</dl>
</div>
<div class="section" id="exercises">
<h2>Exercises<a class="headerlink" href="#exercises" title="Permalink to this headline">¶</a></h2>
<p>Read the documentation of the string methods at
<a class="reference external" href="http://docs.python.org/3/library/stdtypes.html#string-methods">http://docs.python.org/3/library/stdtypes.html#string-methods</a>. You might
want to experiment with some of them to make sure you understand how
they work. strip and replace are particularly useful.</p>
<p>The documentation uses a syntax that might be confusing. For example, in
<code class="docutils literal"><span class="pre">find(sub[,</span> <span class="pre">start[,</span> <span class="pre">end]])</span></code>, the brackets indicate optional arguments.
So sub is required, but start is optional, and if you include start,
then end is optional.</p>
<p>There is a string method called count that is similar to the function in
Section [counter]. Read the documentation of this method and write an
invocation that counts the number of a’s in <code class="docutils literal"><span class="pre">'banana'</span></code>.</p>
<p>A string slice can take a third index that specifies the “step size”;
that is, the number of spaces between successive characters. A step size
of 2 means every other character; 3 means every third, etc.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fruit</span> <span class="o">=</span> <span class="s">'banana'</span>
<span class="gp">>>> </span><span class="n">fruit</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">5</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span>
<span class="go">'bnn'</span>
</pre></div>
</div>
<p>A step size of -1 goes through the word backwards, so the slice
<code class="docutils literal"><span class="pre">[::-1]</span></code> generates a reversed string.</p>
<p>Use this idiom to write a one-line version of <code class="docutils literal"><span class="pre">is_palindrome</span></code> from
Exercise [palindrome].</p>
<p>The following functions are all <em>intended</em> to check whether a string
contains any lowercase letters, but at least some of them are wrong. For
each function, describe what the function actually does (assuming that
the parameter is a string).</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">any_lowercase1</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>
<span class="k">if</span> <span class="n">c</span><span class="o">.</span><span class="n">islower</span><span class="p">():</span>
<span class="k">return</span> <span class="bp">True</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="k">def</span> <span class="nf">any_lowercase2</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>
<span class="k">if</span> <span class="s">'c'</span><span class="o">.</span><span class="n">islower</span><span class="p">():</span>
<span class="k">return</span> <span class="s">'True'</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="s">'False'</span>
<span class="k">def</span> <span class="nf">any_lowercase3</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>
<span class="n">flag</span> <span class="o">=</span> <span class="n">c</span><span class="o">.</span><span class="n">islower</span><span class="p">()</span>
<span class="k">return</span> <span class="n">flag</span>
<span class="k">def</span> <span class="nf">any_lowercase4</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="n">flag</span> <span class="o">=</span> <span class="bp">False</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>
<span class="n">flag</span> <span class="o">=</span> <span class="n">flag</span> <span class="ow">or</span> <span class="n">c</span><span class="o">.</span><span class="n">islower</span><span class="p">()</span>
<span class="k">return</span> <span class="n">flag</span>
<span class="k">def</span> <span class="nf">any_lowercase5</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">s</span><span class="p">:</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">c</span><span class="o">.</span><span class="n">islower</span><span class="p">():</span>
<span class="k">return</span> <span class="bp">False</span>
<span class="k">return</span> <span class="bp">True</span>
</pre></div>
</div>
<p>[exrotate] A Caesar cypher is a weak form of encryption that involves
“rotating” each letter by a fixed number of places. To rotate a letter
means to shift it through the alphabet, wrapping around to the beginning
if necessary, so ’A’ rotated by 3 is ’D’ and ’Z’ rotated by 1 is ’A’.</p>
<p>To rotate a word, rotate each letter by the same amount. For example,
“cheer” rotated by 7 is “jolly” and “melon” rotated by -10 is “cubed”.
In the movie <em>2001: A Space Odyssey</em>, the ship computer is called HAL,
which is IBM rotated by -1.</p>
<p>Write a function called <code class="docutils literal"><span class="pre">rotate_word</span></code> that takes a string and an
integer as parameters, and returns a new string that contains the
letters from the original string rotated by the given amount.</p>
<p>You might want to use the built-in function ord, which converts a
character to a numeric code, and chr, which converts numeric codes to
characters. Letters of the alphabet are encoded in alphabetical order,
so for example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">ord</span><span class="p">(</span><span class="s">'c'</span><span class="p">)</span> <span class="o">-</span> <span class="nb">ord</span><span class="p">(</span><span class="s">'a'</span><span class="p">)</span>
<span class="go">2</span>
</pre></div>
</div>
<p>Because <code class="docutils literal"><span class="pre">'c'</span></code> is the two-eth letter of the alphabet. But beware: the
numeric codes for upper case letters are different.</p>
<p>Potentially offensive jokes on the Internet are sometimes encoded in
ROT13, which is a Caesar cypher with rotation 13. If you are not easily
offended, find and decode some of them. Solution:
<a class="reference external" href="http://thinkpython2.com/code/rotate.py">http://thinkpython2.com/code/rotate.py</a>.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h3><a href="index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">Strings</a><ul>
<li><a class="reference internal" href="#a-string-is-a-sequence">A string is a sequence</a></li>
<li><a class="reference internal" href="#len">len</a></li>
<li><a class="reference internal" href="#traversal-with-a-for-loop">Traversal with a for loop</a></li>
<li><a class="reference internal" href="#string-slices">String slices</a></li>
<li><a class="reference internal" href="#strings-are-immutable">Strings are immutable</a></li>
<li><a class="reference internal" href="#searching">Searching</a></li>
<li><a class="reference internal" href="#looping-and-counting">Looping and counting</a></li>
<li><a class="reference internal" href="#string-methods">String methods</a></li>
<li><a class="reference internal" href="#the-in-operator">The in operator</a></li>
<li><a class="reference internal" href="#string-comparison">String comparison</a></li>
<li><a class="reference internal" href="#debugging">Debugging</a></li>
<li><a class="reference internal" href="#glossary">Glossary</a></li>
<li><a class="reference internal" href="#exercises">Exercises</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="index.html">Documentation overview</a><ul>
<li>Previous: <a href="07-iteration.html" title="previous chapter">Iteration</a></li>
<li>Next: <a href="09-case-word.html" title="next chapter">Case study: word play</a></li>
</ul></li>
</ul>
</div>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/08-string.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<form class="search" action="search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
©2015, Allen B. Downey.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 1.3.1</a>
& <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.6</a>
|
<a href="_sources/08-string.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>