-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy path12-tuple.html
654 lines (636 loc) · 46.3 KB
/
12-tuple.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
<!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>Tuples — 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: data structure selection" href="13-case-struct.html" />
<link rel="prev" title="Dictionaries" href="11-dict.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="tuples">
<h1>Tuples<a class="headerlink" href="#tuples" title="Permalink to this headline">¶</a></h1>
<p>This chapter presents one more built-in type, the tuple, and then shows
how lists, dictionaries, and tuples work together. I also present a
useful feature for variable-length argument lists, the gather and
scatter operators.</p>
<p>One note: there is no consensus on how to pronounce “tuple”. Some people
say “tuh-ple”, which rhymes with “supple”. But in the context of
programming, most people say “too-ple”, which rhymes with “quadruple”.</p>
<div class="section" id="tuples-are-immutable">
<h2>Tuples are immutable<a class="headerlink" href="#tuples-are-immutable" title="Permalink to this headline">¶</a></h2>
<p>A tuple is a sequence of values. The values can be any type, and they
are indexed by integers, so in that respect tuples are a lot like lists.
The important difference is that tuples are immutable.</p>
<p>Syntactically, a tuple is a comma-separated list of values:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">,</span> <span class="s">'d'</span><span class="p">,</span> <span class="s">'e'</span>
</pre></div>
</div>
<p>Although it is not necessary, it is common to enclose tuples in
parentheses:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="p">(</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">,</span> <span class="s">'d'</span><span class="p">,</span> <span class="s">'e'</span><span class="p">)</span>
</pre></div>
</div>
<p>To create a tuple with a single element, you have to include a final
comma:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t1</span> <span class="o">=</span> <span class="s">'a'</span><span class="p">,</span>
<span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">t1</span><span class="p">)</span>
<span class="go"><class 'tuple'></span>
</pre></div>
</div>
<p>A value in parentheses is not a tuple:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t2</span> <span class="o">=</span> <span class="p">(</span><span class="s">'a'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">t2</span><span class="p">)</span>
<span class="go"><class 'str'></span>
</pre></div>
</div>
<p>Another way to create a tuple is the built-in function tuple. With no
argument, it creates an empty tuple:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">t</span>
<span class="go">()</span>
</pre></div>
</div>
<p>If the argument is a sequence (string, list or tuple), the result is a
tuple with the elements of the sequence:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="s">'lupins'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">t</span>
<span class="go">('l', 'u', 'p', 'i', 'n', 's')</span>
</pre></div>
</div>
<p>Because tuple is the name of a built-in function, you should avoid using
it as a variable name.</p>
<p>Most list operators also work on tuples. The bracket operator indexes an
element:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="p">(</span><span class="s">'a'</span><span class="p">,</span> <span class="s">'b'</span><span class="p">,</span> <span class="s">'c'</span><span class="p">,</span> <span class="s">'d'</span><span class="p">,</span> <span class="s">'e'</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="go">'a'</span>
</pre></div>
</div>
<p>And the slice operator selects a range of elements.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="mi">3</span><span class="p">]</span>
<span class="go">('b', 'c')</span>
</pre></div>
</div>
<p>But if you try to modify one of the elements of the tuple, you get an
error:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s">'A'</span>
<span class="go">TypeError: object doesn't support item assignment</span>
</pre></div>
</div>
<p>Because tuples are immutable, you can’t modify the elements. But you can
replace one tuple with another:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="p">(</span><span class="s">'A'</span><span class="p">,)</span> <span class="o">+</span> <span class="n">t</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="gp">>>> </span><span class="n">t</span>
<span class="go">('A', 'b', 'c', 'd', 'e')</span>
</pre></div>
</div>
<p>This statement makes a new tuple and then makes t refer to it.</p>
<p>The relational operators work with tuples and other sequences; Python
starts by comparing the first element from each sequence. If they are
equal, it goes on to the next elements, and so on, until it finds
elements that differ. Subsequent elements are not considered (even if
they are really big).</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="p">(</span><span class="mi">0</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="o"><</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2000000</span><span class="p">)</span> <span class="o"><</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</div>
<div class="section" id="tuple-assignment">
<h2>Tuple assignment<a class="headerlink" href="#tuple-assignment" title="Permalink to this headline">¶</a></h2>
<p>It is often useful to swap the values of two variables. With
conventional assignments, you have to use a temporary variable. For
example, to swap a and b:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">temp</span> <span class="o">=</span> <span class="n">a</span>
<span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="n">b</span>
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="n">temp</span>
</pre></div>
</div>
<p>This solution is cumbersome; <strong>tuple assignment</strong> is more elegant:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="n">b</span><span class="p">,</span> <span class="n">a</span>
</pre></div>
</div>
<p>The left side is a tuple of variables; the right side is a tuple of
expressions. Each value is assigned to its respective variable. All the
expressions on the right side are evaluated before any of the
assignments.</p>
<p>The number of variables on the left and the number of values on the
right have to be the same:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span>
<span class="go">ValueError: too many values to unpack</span>
</pre></div>
</div>
<p>More generally, the right side can be any kind of sequence (string, list
or tuple). For example, to split an email address into a user name and a
domain, you could write:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">addr</span> <span class="o">=</span> <span class="s">'[email protected]'</span>
<span class="gp">>>> </span><span class="n">uname</span><span class="p">,</span> <span class="n">domain</span> <span class="o">=</span> <span class="n">addr</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s">'@'</span><span class="p">)</span>
</pre></div>
</div>
<p>The return value from split is a list with two elements; the first
element is assigned to uname, the second to domain.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">uname</span>
<span class="go">'monty'</span>
<span class="gp">>>> </span><span class="n">domain</span>
<span class="go">'python.org'</span>
</pre></div>
</div>
</div>
<div class="section" id="tuples-as-return-values">
<h2>Tuples as return values<a class="headerlink" href="#tuples-as-return-values" title="Permalink to this headline">¶</a></h2>
<p>Strictly speaking, a function can only return one value, but if the
value is a tuple, the effect is the same as returning multiple values.
For example, if you want to divide two integers and compute the quotient
and remainder, it is inefficient to compute x/y and then x%y. It is
better to compute them both at the same time.</p>
<p>The built-in function divmod takes two arguments and returns a tuple of
two values, the quotient and remainder. You can store the result as a
tuple:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="nb">divmod</span><span class="p">(</span><span class="mi">7</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">t</span>
<span class="go">(2, 1)</span>
</pre></div>
</div>
<p>Or use tuple assignment to store the elements separately:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">quot</span><span class="p">,</span> <span class="n">rem</span> <span class="o">=</span> <span class="nb">divmod</span><span class="p">(</span><span class="mi">7</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">quot</span>
<span class="go">2</span>
<span class="gp">>>> </span><span class="n">rem</span>
<span class="go">1</span>
</pre></div>
</div>
<p>Here is an example of a function that returns a tuple:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">min_max</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">min</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">max</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
</pre></div>
</div>
<p>max and min are built-in functions that find the largest and smallest
elements of a sequence. <code class="docutils literal"><span class="pre">min_max</span></code> computes both and returns a tuple of
two values.</p>
</div>
<div class="section" id="variable-length-argument-tuples">
<h2>Variable-length argument tuples<a class="headerlink" href="#variable-length-argument-tuples" title="Permalink to this headline">¶</a></h2>
<p>Functions can take a variable number of arguments. A parameter name that
begins with <strong>gathers</strong> arguments into a tuple. For example, printall
takes any number of arguments and prints them:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">printall</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">):</span>
<span class="k">print</span><span class="p">(</span><span class="n">args</span><span class="p">)</span>
</pre></div>
</div>
<p>The gather parameter can have any name you like, but args is
conventional. Here’s how the function works:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">printall</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mf">2.0</span><span class="p">,</span> <span class="s">'3'</span><span class="p">)</span>
<span class="go">(1, 2.0, '3')</span>
</pre></div>
</div>
<p>The complement of gather is <strong>scatter</strong>. If you have a sequence of
values and you want to pass it to a function as multiple arguments, you
can use the operator. For example, divmod takes exactly two arguments;
it doesn’t work with a tuple:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="p">(</span><span class="mi">7</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">divmod</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="go">TypeError: divmod expected 2 arguments, got 1</span>
</pre></div>
</div>
<p>But if you scatter the tuple, it works:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">divmod</span><span class="p">(</span><span class="o">*</span><span class="n">t</span><span class="p">)</span>
<span class="go">(2, 1)</span>
</pre></div>
</div>
<p>Many of the built-in functions use variable-length argument tuples. For
example, max and min can take any number of arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">max</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="mi">3</span><span class="p">)</span>
<span class="go">3</span>
</pre></div>
</div>
<p>But sum does not.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">sum</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="mi">3</span><span class="p">)</span>
<span class="go">TypeError: sum expected at most 2 arguments, got 3</span>
</pre></div>
</div>
<p>As an exercise, write a function called sumall that takes any number of
arguments and returns their sum.</p>
</div>
<div class="section" id="lists-and-tuples">
<h2>Lists and tuples<a class="headerlink" href="#lists-and-tuples" title="Permalink to this headline">¶</a></h2>
<p>zip is a built-in function that takes two or more sequences and returns
a list of tuples where each tuple contains one element from each
sequence. The name of the function refers to a zipper, which joins and
interleaves two rows of teeth.</p>
<p>This example zips a string and a list:</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">'abc'</span>
<span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</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="gp">>>> </span><span class="nb">zip</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">t</span><span class="p">)</span>
<span class="go"><zip object at 0x7f7d0a9e7c48></span>
</pre></div>
</div>
<p>The result is a <strong>zip object</strong> that knows how to iterate through the
pairs. The most common use of zip is in a for loop:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">for</span> <span class="n">pair</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">t</span><span class="p">):</span>
<span class="gp">... </span> <span class="k">print</span><span class="p">(</span><span class="n">pair</span><span class="p">)</span>
<span class="gp">...</span>
<span class="go">('a', 0)</span>
<span class="go">('b', 1)</span>
<span class="go">('c', 2)</span>
</pre></div>
</div>
<p>A zip object is a kind of <strong>iterator</strong>, which is any object that
iterates through a sequence. Iterators are similar to lists in some
ways, but unlike lists, you can’t use an index to select an element from
an iterator.</p>
<p>If you want to use list operators and methods, you can use a zip object
to make a list:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">t</span><span class="p">))</span>
<span class="go">[('a', 0), ('b', 1), ('c', 2)]</span>
</pre></div>
</div>
<p>The result is a list of tuples; in this example, each tuple contains a
character from the string and the corresponding element from the list.</p>
<p>If the sequences are not the same length, the result has the length of
the shorter one.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="s">'Anne'</span><span class="p">,</span> <span class="s">'Elk'</span><span class="p">))</span>
<span class="go">[('A', 'E'), ('n', 'l'), ('n', 'k')]</span>
</pre></div>
</div>
<p>You can use tuple assignment in a for loop to traverse a list of tuples:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">t</span> <span class="o">=</span> <span class="p">[(</span><span class="s">'a'</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</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="p">(</span><span class="s">'c'</span><span class="p">,</span> <span class="mi">2</span><span class="p">)]</span>
<span class="k">for</span> <span class="n">letter</span><span class="p">,</span> <span class="n">number</span> <span class="ow">in</span> <span class="n">t</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="n">number</span><span class="p">,</span> <span class="n">letter</span><span class="p">)</span>
</pre></div>
</div>
<p>Each time through the loop, Python selects the next tuple in the list
and assigns the elements to letter and number. The output of this loop
is:</p>
<div class="highlight-python"><div class="highlight"><pre>0 a
1 b
2 c
</pre></div>
</div>
<p>If you combine zip, for and tuple assignment, you get a useful idiom for
traversing two (or more) sequences at the same time. For example,
<code class="docutils literal"><span class="pre">has_match</span></code> takes two sequences, t1 and t2, and returns True if there
is an index i such that t1[i] == t2[i]:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">def</span> <span class="nf">has_match</span><span class="p">(</span><span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">):</span>
<span class="k">for</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">):</span>
<span class="k">if</span> <span class="n">x</span> <span class="o">==</span> <span class="n">y</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">True</span>
<span class="k">return</span> <span class="bp">False</span>
</pre></div>
</div>
<p>If you need to traverse the elements of a sequence and their indices,
you can use the built-in function enumerate:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">index</span><span class="p">,</span> <span class="n">element</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="s">'abc'</span><span class="p">):</span>
<span class="k">print</span><span class="p">(</span><span class="n">index</span><span class="p">,</span> <span class="n">element</span><span class="p">)</span>
</pre></div>
</div>
<p>The result from enumerate is an enumerate object, which iterates a
sequence of pairs; each pair contains an index (starting from 0) and an
element from the given sequence. In this example, the output is</p>
<div class="highlight-python"><div class="highlight"><pre>0 a
1 b
2 c
</pre></div>
</div>
<p>Again.</p>
</div>
<div class="section" id="dictionaries-and-tuples">
<h2>Dictionaries and tuples<a class="headerlink" href="#dictionaries-and-tuples" title="Permalink to this headline">¶</a></h2>
<p>Dictionaries have a method called items that returns a sequence of
tuples, where each tuple is a key-value pair.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">d</span> <span class="o">=</span> <span class="p">{</span><span class="s">'a'</span><span class="p">:</span><span class="mi">0</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="s">'c'</span><span class="p">:</span><span class="mi">2</span><span class="p">}</span>
<span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="n">d</span><span class="o">.</span><span class="n">items</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">t</span>
<span class="go">dict_items([('c', 2), ('a', 0), ('b', 1)])</span>
</pre></div>
</div>
<p>The result is a <code class="docutils literal"><span class="pre">dict_items</span></code> object, which is an iterator that
iterates the key-value pairs. You can use it in a for loop like this:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">d</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
<span class="gp">... </span> <span class="k">print</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>
<span class="gp">...</span>
<span class="go">c 2</span>
<span class="go">a 0</span>
<span class="go">b 1</span>
</pre></div>
</div>
<p>As you should expect from a dictionary, the items are in no particular
order.</p>
<p>Going in the other direction, you can use a list of tuples to initialize
a new dictionary:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="p">[(</span><span class="s">'a'</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="s">'c'</span><span class="p">,</span> <span class="mi">2</span><span class="p">),</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="gp">>>> </span><span class="n">d</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">d</span>
<span class="go">{'a': 0, 'c': 2, 'b': 1}</span>
</pre></div>
</div>
<p>Combining dict with zip yields a concise way to create a dictionary:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">d</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="s">'abc'</span><span class="p">,</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">)))</span>
<span class="gp">>>> </span><span class="n">d</span>
<span class="go">{'a': 0, 'c': 2, 'b': 1}</span>
</pre></div>
</div>
<p>The dictionary method update also takes a list of tuples and adds them,
as key-value pairs, to an existing dictionary.</p>
<p>It is common to use tuples as keys in dictionaries (primarily because
you can’t use lists). For example, a telephone directory might map from
last-name, first-name pairs to telephone numbers. Assuming that we have
defined last, first and number, we could write:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="n">directory</span><span class="p">[</span><span class="n">last</span><span class="p">,</span> <span class="n">first</span><span class="p">]</span> <span class="o">=</span> <span class="n">number</span>
</pre></div>
</div>
<p>The expression in brackets is a tuple. We could use tuple assignment to
traverse this dictionary.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">last</span><span class="p">,</span> <span class="n">first</span> <span class="ow">in</span> <span class="n">directory</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="n">first</span><span class="p">,</span> <span class="n">last</span><span class="p">,</span> <span class="n">directory</span><span class="p">[</span><span class="n">last</span><span class="p">,</span><span class="n">first</span><span class="p">])</span>
</pre></div>
</div>
<p>This loop traverses the keys in directory, which are tuples. It assigns
the elements of each tuple to last and first, then prints the name and
corresponding telephone number.</p>
<p>There are two ways to represent tuples in a state diagram. The more
detailed version shows the indices and elements just as they appear in a
list. For example, the tuple <code class="docutils literal"><span class="pre">('Cleese',</span> <span class="pre">'John')</span></code> would appear as in
Figure [fig.tuple1].</p>
<div class="figure" id="id1">
<img alt="State diagram." src="_images/tuple1.pdf" />
<p class="caption"><span class="caption-text">State diagram.</span></p>
</div>
<p>But in a larger diagram you might want to leave out the details. For
example, a diagram of the telephone directory might appear as in
Figure [fig.dict2].</p>
<div class="figure" id="id2">
<img alt="State diagram." src="_images/dict2.pdf" />
<p class="caption"><span class="caption-text">State diagram.</span></p>
</div>
<p>Here the tuples are shown using Python syntax as a graphical shorthand.
The telephone number in the diagram is the complaints line for the BBC,
so please don’t call it.</p>
</div>
<div class="section" id="sequences-of-sequences">
<h2>Sequences of sequences<a class="headerlink" href="#sequences-of-sequences" title="Permalink to this headline">¶</a></h2>
<p>I have focused on lists of tuples, but almost all of the examples in
this chapter also work with lists of lists, tuples of tuples, and tuples
of lists. To avoid enumerating the possible combinations, it is
sometimes easier to talk about sequences of sequences.</p>
<p>In many contexts, the different kinds of sequences (strings, lists and
tuples) can be used interchangeably. So how should you choose one over
the others?</p>
<p>To start with the obvious, strings are more limited than other sequences
because the elements have to be characters. They are also immutable. If
you need the ability to change the characters in a string (as opposed to
creating a new string), you might want to use a list of characters
instead.</p>
<p>Lists are more common than tuples, mostly because they are mutable. But
there are a few cases where you might prefer tuples:</p>
<ol class="arabic simple">
<li>In some contexts, like a return statement, it is syntactically
simpler to create a tuple than a list.</li>
<li>If you want to use a sequence as a dictionary key, you have to use an
immutable type like a tuple or string.</li>
<li>If you are passing a sequence as an argument to a function, using
tuples reduces the potential for unexpected behavior due to aliasing.</li>
</ol>
<p>Because tuples are immutable, they don’t provide methods like sort and
reverse, which modify existing lists. But Python provides the built-in
function sorted, which takes any sequence and returns a new list with
the same elements in sorted order, and reversed, which takes a sequence
and returns an iterator that traverses the list in reverse order.</p>
</div>
<div class="section" id="debugging">
<h2>Debugging<a class="headerlink" href="#debugging" title="Permalink to this headline">¶</a></h2>
<p>Lists, dictionaries and tuples are examples of <strong>data structures</strong>; in
this chapter we are starting to see compound data structures, like lists
of tuples, or dictionaries that contain tuples as keys and lists as
values. Compound data structures are useful, but they are prone to what
I call <strong>shape errors</strong>; that is, errors caused when a data structure
has the wrong type, size, or structure. For example, if you are
expecting a list with one integer and I give you a plain old integer
(not in a list), it won’t work.</p>
<p>To help debug these kinds of errors, I have written a module called
structshape that provides a function, also called structshape, that
takes any kind of data structure as an argument and returns a string
that summarizes its shape. You can download it from
<a class="reference external" href="http://thinkpython2.com/code/structshape.py">http://thinkpython2.com/code/structshape.py</a></p>
<p>Here’s the result for a simple list:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">structshape</span> <span class="kn">import</span> <span class="n">structshape</span>
<span class="gp">>>> </span><span class="n">t</span> <span class="o">=</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="mi">3</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">structshape</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="go">'list of 3 int'</span>
</pre></div>
</div>
<p>A fancier program might write “list of 3 int<em>s</em>”, but it was easier
not to deal with plurals. Here’s a list of lists:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t2</span> <span class="o">=</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="p">[</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">]]</span>
<span class="gp">>>> </span><span class="n">structshape</span><span class="p">(</span><span class="n">t2</span><span class="p">)</span>
<span class="go">'list of 3 list of 2 int'</span>
</pre></div>
</div>
<p>If the elements of the list are not the same type, structshape groups
them, in order, by type:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t3</span> <span class="o">=</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="mi">3</span><span class="p">,</span> <span class="mf">4.0</span><span class="p">,</span> <span class="s">'5'</span><span class="p">,</span> <span class="s">'6'</span><span class="p">,</span> <span class="p">[</span><span class="mi">7</span><span class="p">],</span> <span class="p">[</span><span class="mi">8</span><span class="p">],</span> <span class="mi">9</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">structshape</span><span class="p">(</span><span class="n">t3</span><span class="p">)</span>
<span class="go">'list of (3 int, float, 2 str, 2 list of int, int)'</span>
</pre></div>
</div>
<p>Here’s a list of tuples:</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">'abc'</span>
<span class="gp">>>> </span><span class="n">lt</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">zip</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">s</span><span class="p">))</span>
<span class="gp">>>> </span><span class="n">structshape</span><span class="p">(</span><span class="n">lt</span><span class="p">)</span>
<span class="go">'list of 3 tuple of (int, str)'</span>
</pre></div>
</div>
<p>And here’s a dictionary with 3 items that map integers to strings.</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">d</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="n">lt</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">structshape</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>
<span class="go">'dict of 3 int->str'</span>
</pre></div>
</div>
<p>If you are having trouble keeping track of your data structures,
structshape can help.</p>
</div>
<div class="section" id="glossary">
<span id="glossary12"></span><h2>Glossary<a class="headerlink" href="#glossary" title="Permalink to this headline">¶</a></h2>
<dl class="docutils">
<dt>tupla (<em>tuple</em>)</dt>
<dd>An immutable sequence of elements.</dd>
<dt>desempacotamento de tupla (<em>tuple assignment</em>)</dt>
<dd>An assignment with a sequence on the right side and a tuple of variables on the left. The right side is evaluated and then its elements are assigned to the variables on the left.</dd>
<dt>reunir (<em>gather</em>)</dt>
<dd>The operation of assembling a variable-length argument tuple.</dd>
<dt>explodir (<em>scatter</em>)</dt>
<dd>The operation of treating a sequence as a list of arguments.</dd>
<dt>objeto <code class="docutils literal"><span class="pre">zip</span></code> (<code class="docutils literal"><span class="pre">zip</span></code> <em>object</em>)</dt>
<dd>The result of calling a built-in function zip; an object that iterates through a sequence of tuples.</dd>
<dt>iterador (<em>iterator</em>)</dt>
<dd>An object that can iterate through a sequence, but which does not provide list operators and methods.</dd>
<dt>estrutura de dados (<em>data structure</em>)</dt>
<dd>A collection of related values, often organized in lists, dictionaries, tuples, etc.</dd>
<dt>errro estrutural (<em>shape error</em>)</dt>
<dd>An error caused because a value has the wrong shape; that is, the wrong type or size.</dd>
</dl>
</div>
<div class="section" id="exercises">
<h2>Exercises<a class="headerlink" href="#exercises" title="Permalink to this headline">¶</a></h2>
<p>Write a function called <code class="docutils literal"><span class="pre">most_frequent</span></code> that takes a string and prints
the letters in decreasing order of frequency. Find text samples from
several different languages and see how letter frequency varies between
languages. Compare your results with the tables at
<a class="reference external" href="http://en.wikipedia.org/wiki/Letter_frequencies">http://en.wikipedia.org/wiki/Letter_frequencies</a>. Solution:
<a class="reference external" href="http://thinkpython2.com/code/most_frequent.py">http://thinkpython2.com/code/most_frequent.py</a>.</p>
<p>[anagrams]</p>
<p>More anagrams!</p>
<ol class="arabic">
<li><p class="first">Write a program that reads a word list from a file (see
Section [wordlist]) and prints all the sets of words that are
anagrams.</p>
<p>Here is an example of what the output might look like:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="p">[</span><span class="s">'deltas'</span><span class="p">,</span> <span class="s">'desalt'</span><span class="p">,</span> <span class="s">'lasted'</span><span class="p">,</span> <span class="s">'salted'</span><span class="p">,</span> <span class="s">'slated'</span><span class="p">,</span> <span class="s">'staled'</span><span class="p">]</span>
<span class="p">[</span><span class="s">'retainers'</span><span class="p">,</span> <span class="s">'ternaries'</span><span class="p">]</span>
<span class="p">[</span><span class="s">'generating'</span><span class="p">,</span> <span class="s">'greatening'</span><span class="p">]</span>
<span class="p">[</span><span class="s">'resmelts'</span><span class="p">,</span> <span class="s">'smelters'</span><span class="p">,</span> <span class="s">'termless'</span><span class="p">]</span>
</pre></div>
</div>
<p>Hint: you might want to build a dictionary that maps from a
collection of letters to a list of words that can be spelled with
those letters. The question is, how can you represent the collection
of letters in a way that can be used as a key?</p>
</li>
<li><p class="first">Modify the previous program so that it prints the longest list of
anagrams first, followed by the second longest, and so on.</p>
</li>
<li><p class="first">In Scrabble a “bingo” is when you play all seven tiles in your rack,
along with a letter on the board, to form an eight-letter word. What
collection of 8 letters forms the most possible bingos? Hint: there
are seven.</p>
<p>Solution: <a class="reference external" href="http://thinkpython2.com/code/anagram_sets.py">http://thinkpython2.com/code/anagram_sets.py</a>.</p>
</li>
</ol>
<p>Two words form a “metathesis pair” if you can transform one into the
other by swapping two letters; for example, “converse” and “conserve”.
Write a program that finds all of the metathesis pairs in the
dictionary. Hint: don’t test all pairs of words, and don’t test all
possible swaps. Solution: <a class="reference external" href="http://thinkpython2.com/code/metathesis.py">http://thinkpython2.com/code/metathesis.py</a>.
Credit: This exercise is inspired by an example at <a class="reference external" href="http://puzzlers.org">http://puzzlers.org</a>.</p>
<p>Here’s another Car Talk Puzzler
(<a class="reference external" href="http://www.cartalk.com/content/puzzlers">http://www.cartalk.com/content/puzzlers</a>):</p>
<blockquote>
<div><p>What is the longest English word, that remains a valid English word,
as you remove its letters one at a time?</p>
<p>Now, letters can be removed from either end, or the middle, but you
can’t rearrange any of the letters. Every time you drop a letter,
you wind up with another English word. If you do that, you’re
eventually going to wind up with one letter and that too is going to
be an English word—one that’s found in the dictionary. I want to
know what’s the longest word and how many letters does it have?</p>
<p>I’m going to give you a little modest example: Sprite. Ok? You start
off with sprite, you take a letter off, one from the interior of the
word, take the r away, and we’re left with the word spite, then we
take the e off the end, we’re left with spit, we take the s off,
we’re left with pit, it, and I.</p>
</div></blockquote>
<p>Write a program to find all words that can be reduced in this way, and
then find the longest one.</p>
<p>This exercise is a little more challenging than most, so here are some
suggestions:</p>
<ol class="arabic simple">
<li>You might want to write a function that takes a word and computes a
list of all the words that can be formed by removing one letter.
These are the “children” of the word.</li>
<li>Recursively, a word is reducible if any of its children are
reducible. As a base case, you can consider the empty string
reducible.</li>
<li>The wordlist I provided, words.txt, doesn’t contain single letter
words. So you might want to add “I”, “a”, and the empty string.</li>
<li>To improve the performance of your program, you might want to memoize
the words that are known to be reducible.</li>
</ol>
<p>Solution: <a class="reference external" href="http://thinkpython2.com/code/reducible.py">http://thinkpython2.com/code/reducible.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="#">Tuples</a><ul>
<li><a class="reference internal" href="#tuples-are-immutable">Tuples are immutable</a></li>
<li><a class="reference internal" href="#tuple-assignment">Tuple assignment</a></li>
<li><a class="reference internal" href="#tuples-as-return-values">Tuples as return values</a></li>
<li><a class="reference internal" href="#variable-length-argument-tuples">Variable-length argument tuples</a></li>
<li><a class="reference internal" href="#lists-and-tuples">Lists and tuples</a></li>
<li><a class="reference internal" href="#dictionaries-and-tuples">Dictionaries and tuples</a></li>
<li><a class="reference internal" href="#sequences-of-sequences">Sequences of sequences</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="11-dict.html" title="previous chapter">Dictionaries</a></li>
<li>Next: <a href="13-case-struct.html" title="next chapter">Case study: data structure selection</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/12-tuple.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/12-tuple.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>