Repository navigation
Expand file tree
/
Copy pathporting-code-to-python-3-with-2to3.html
More file actions
1348 lines (1150 loc) · 75.5 KB
/
Copy pathporting-code-to-python-3-with-2to3.html
File metadata and controls
1348 lines (1150 loc) · 75.5 KB
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
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<meta charset=utf-8>
<title>Přepis kódu do Pythonu 3 s využitím 2to3 – Ponořme se do Pythonu 3</title>
<!--[if IE]><script src=j/html5.js></script><![endif]-->
<link rel=stylesheet href=dip3.css>
<style>
</style>
<link rel=stylesheet media='only screen and (max-device-width: 480px)' href=mobile.css>
<link rel=stylesheet media=print href=print.css>
<meta content='initial-scale=1.0' name=viewport>
<body id=appa>
<!-- <form action=http://www.google.com/cse><div><input name=cx type=hidden value=014021643941856155761:l5eihuescdw><input name=ie type=hidden value=UTF-8> <input type=search name=q size=25 placeholder="powered by Google™"> <input name="sa" type="submit" value="Hledej"></div></form> -->
<p>Nacházíte se zde: <a href="index.html">Domů</a> <span class="u">‣</span> <a href="table-of-contents.html#porting-code-to-python-3-with-2to3">Ponořme se do Pythonu 3</a> <span class="u">‣</span>
<p id=level>Úroveň obtížnosti: <span class="u" title="expert">♦♦♦♦♦</span>
<h1>Přepis kódu do Pythonu 3 s využitím <code>2to3</code></h1>
<blockquote class=q>
<p><span class="u">❝</span> Life is pleasant. Death is peaceful. It’s the transition that’s troublesome. <span class="u">❞</span><br>(Život je zábavný. Smrt je klidná. Nepříjemný je ten přechod.)<br>— Isaac Asimov (připsáno)
</blockquote>
<p id=toc>
<h2 id=divingin>Ponořme se</h2>
<p class=f>Mezi Pythonem 2 a Pythonem 3 se toho změnilo tolik, že najdete jen mizivé procento programů, které bez úprav běží v obou verzích. Ale nepropadejte zoufalství! K usnadnění přechodu se Python 3 dodává s pomocným skriptem nazvaným <code>2to3</code>. Když mu předáte svůj zdrojový soubor napsaný pro Python 2 jako vstup, převede automaticky do podoby pro Python 3 vše, co dovede. <a href="case-study-porting-chardet-to-python-3.html#running2to3">Případová studie: Přepis <code>chardet</code> pro Python 3</a> popisuje, jak se skript <code>2to3</code> spouští. Ukazuje také věci, které se automaticky neopraví. V této příloze najdete dokumentaci toho, co <em>dovede</em> opravit automaticky.
<h2 id=print>Příkaz <code>print</code></h2>
<p>V Pythonu 2 byl <code><dfn>print</dfn></code> příkazem. Pokud jsme cokoliv chtěli vytisknout, jednoduše jsme to připsali za klíčové slovo <code>print</code>. V Pythonu 3 je <a href="your-first-python-program.html#divingin"><code>print()</code> funkcí</a>. Pokud chceme cokoliv vytisknout, předáme to funkci <code>print()</code> stejně jako každé jiné funkci.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>print</code>
<td><code class=pp>print()</code>
<tr><th>②
<td><code class=pp>print 1</code>
<td><code class=pp>print(1)</code>
<tr><th>③
<td><code class=pp>print 1, 2</code>
<td><code class=pp>print(1, 2)</code>
<tr><th>④
<td><code class=pp>print 1, 2,</code>
<td><code class=pp>print(1, 2, end=' ')</code>
<tr><th>⑤
<td><code class=pp>print >>sys.stderr, 1, 2, 3</code>
<td><code class=pp>print(1, 2, 3, file=sys.stderr)</code>
</table>
<ol>
<li>Prázdný řádek vytiskneme voláním <code>print()</code> bez zadání argumentů.
<li>Jednu hodnotu vytiskneme voláním <code>print()</code> s jedním argumentem.
<li>Dvě hodnoty oddělené mezerou vytiskneme voláním <code>print()</code> s dvěma argumenty.
<li>V tomhle je malá finta. Pokud jsme v Pythonu 2 ukončili příkaz <code>print</code> čárkou, vytiskly se hodnoty oddělené mezerou, pak se vytiskla ještě jedna koncová mezera a tisk skončil bez generování přechodu na nový řádek. (Z technického hlediska je to o něco komplikovanější. Příkaz <code>print</code> v Pythonu 2 používal nyní již nežádoucí (deprecated) atribut zvaný <var>softspace</var>. Místo skutečného tisku mezery nastavil Python 2 <code>sys.stdout.softspace</code> na 1. Znak mezery ve skutečnosti nebyl vytištěn, dokud se nemělo na stejný řádek tisknout něco dalšího. Pokud další příkaz <code>print</code> tiskl přechod na nový řádek, byl atribut <code>sys.stdout.softspace</code> nastaven na 0 a mezera se nikdy nevytiskla. Tohoto rozdílu byste si pravděpodobně nikdy nevšimli, pokud by vaše aplikace nebyla citlivá na přítomnost nebo nepřítomnost koncových bílých znaků ve výstupu, který byl vygenerován příkazem <code>print</code>.) V Pythonu 3 dosáhneme stejného efektu tím, že funkci <code>print()</code> předáme pojmenovaný argument s hodnotou <code>end=' '</code>. Výchozí hodnotou argumentu <code>end</code> je <code>'\n'</code> (přechod na nový řádek), takže po vytisknutí ostatních argumentů jeho přepsáním potlačíme přechod na nový řádek.
<li>V Pythonu 2 jsme mohli výstup přesměrovat do roury (pipe) — například na <code>sys.stderr</code> — uvedením zápisu <code>>>jméno_roury</code>. V Pythonu 3 dosáhneme stejného efektu předáním odkazu na rouru pojmenovaným argumentem <code>file</code>. Výchozí hodnotou argumentu <code>file</code> je <code>sys.stdout</code> (standardní výstup), takže přepsáním této hodnoty dosáhneme přesměrování do jiné roury.
</ol>
<h2 id=unicodeliteral>Literály Unicode-řetězců</h2>
<p>Python 2 pracoval s dvěma typy řetězců: s <dfn>Unicode</dfn> řetězci a s ne-Unicode řetězci. Python 3 podporuje jediný řetězcový typ: <a href="strings.html#divingin">Unicode řetězce</a>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>u'PapayaWhip'</code>
<td><code class=pp>'PapayaWhip'</code>
<tr><th>②
<td><code class=pp>ur'PapayaWhip\foo'</code>
<td><code class=pp>r'PapayaWhip\foo'</code>
</table>
<ol>
<li>Řetězcové literály s prefixem Unicode jsou jednoduše převedeny na obyčejné řetězcové literály, které v Pythonu 3 vždy vyjadřují Unicode řetězce.
<li>Surové Unicode řetězce (raw; ve kterých Python neprovádí interpretaci zpětného lomítka jako zahájení escape posloupnosti) jsou převedeny na surové řetězce. V Pythonu 3 jsou surové řetězce vždy v Unicode.
</ol>
<h2 id=unicode>Globální funkce <code>unicode()</code></h2>
<p>V Pythonu 2 se pro převod objektů na řetězec používaly dvě globální funkce: <code>unicode()</code> pro převod na Unicode řetězce a <code>str()</code> pro převod na ne-Unicode řetězce. Python 3 má jediný řetězcový typ, <a href="strings.html#divingin">Unicode řetězce</a>, takže vše, co potřebujeme, je funkce <code>str()</code>. (Funkce <code>unicode()</code> už neexistuje.)
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp>unicode(cokoliv)</code>
<td><code class=pp>str(cokoliv)</code>
</table>
<h2 id=long>Datový typ <code>long</code></h2>
<p>Python 2 používal pro celá čísla dva datové typy: <code>int</code> a <code><dfn>long</dfn></code>. Hodnota typu <code>int</code> nemohla být větší než konstanta <a href="#renames"><code>sys.maxint</code></a>, která byla závislá na platformě. „Dlouhá“ čísla byla definována přidáním <code>L</code> na konec čísla a mohla nabývat větších hodnot než čísla typu <code>int</code>. V Pythonu 3 <a href="native-datatypes.html#numbers">je jen jeden celočíselný typ</a>, který se jmenuje <code>int</code> a většinou se chová jako typ <code>long</code> v Pythonu 2. Protože už neexistují dva typy, nemusí se používat speciální syntaxe pro jejich rozlišení.
<p>Přečtěte si: <a href="http://www.python.org/dev/peps/pep-0237/"><abbr>PEP</abbr> 237: Unifying Long Integers and Integers</a>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>x = 1000000000000L</code>
<td><code class=pp>x = 1000000000000</code>
<tr><th>②
<td><code class=pp>x = 0xFFFFFFFFFFFFL</code>
<td><code class=pp>x = 0xFFFFFFFFFFFF</code>
<tr><th>③
<td><code class=pp>long(x)</code>
<td><code class=pp>int(x)</code>
<tr><th>④
<td><code class=pp>type(x) is long</code>
<td><code class=pp>type(x) is int</code>
<tr><th>⑤
<td><code class=pp>isinstance(x, long)</code>
<td><code class=pp>isinstance(x, int)</code>
</table>
<ol>
<li>Z desítkových číselných literálů pro „dlouhý“ integer (long) se staly desítkové literály pro typ integer.
<li>Z šestnáctkových číselných literálů pro „dlouhý“ integer (long) se staly šestnáctkové literály pro typ integer.
<li>V Pythonu 3 přestala existovat původní funkce <code>long()</code>, protože přestal existovat typ long (dlouhý integer). K převodu proměnné na celé číslo použijeme funkci <code>int()</code>.
<li>Pokud chceme zkontrolovat, zda je proměnná typu integer, zjistíme její typ a porovnáváme ho s <code>int</code> (nikoliv s <code>long</code>).
<li>Ke kontrole datového typu můžeme použít i funkci <code>isinstance()</code>. Při zjišťování, zda jde o celočíselný typ, se opět odkážeme na <code>int</code> a ne na <code>long</code>.
</ol>
<h2 id=ne>Porovnání <></h2>
<p>Python 2 podporoval operátor <code><></code> jako synonymum pro <code>!=</code> (porovnání na různost). Python 3 podporuje pouze operátor <code>!=</code> a přestal podporovat <code><></code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>if x <> y:</code>
<td><code class=pp>if x != y:</code>
<tr><th>②
<td><code class=pp>if x <> y <> z:</code>
<td><code class=pp>if x != y != z:</code>
</table>
<ol>
<li>Jednoduché porovnání.
<li>Složitější porovnání mezi třemi hodnotami.
</ol>
<h2 id=has_key>Slovníková metoda <code>has_key()</code></h2>
<p>V Pythonu 2 používaly slovníky metodu <code><dfn>has_key</dfn>()</code> (doslova „má klíč“) pro testování, zda se ve slovníku nachází zadaný klíč. V Pythonu 3 tato metoda přestala existovat. Místo ní musíme používat <a href="native-datatypes.html#mixed-value-dictionaries">operátor <code>in</code></a>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>a_dictionary.has_key('PapayaWhip')</code>
<td><code class=pp>'PapayaWhip' in a_dictionary</code>
<tr><th>②</th>
<td><code class=pp>a_dictionary.has_key(x) or a_dictionary.has_key(y)</code>
<td><code class=pp>x in a_dictionary or y in a_dictionary</code>
<tr><th>③
<td><code class=pp>a_dictionary.has_key(x or y)</code>
<td><code class=pp>(x or y) in a_dictionary</code>
<tr><th>④
<td><code class=pp>a_dictionary.has_key(x + y)</code>
<td><code class=pp>(x + y) in a_dictionary</code>
<tr><th>⑤
<td><code class=pp>x + a_dictionary.has_key(y)</code>
<td><code class=pp>x + (y in a_dictionary)</code>
</table>
<ol>
<li>Nejjednodušší forma.
<li>Operátor <code>in</code> má vyšší prioritu než operátor <code>or</code>, takže podvýrazy <code>x in a_dictionary</code> a <code>y in a_dictionary</code> nemusíme uzavírat do závorek.
<li>Ale na druhou stranu zde ze stejného důvodu <em>musíme</em> uzavřít do závorek <code>x or y</code> — <code>in</code> má vyšší prioritu než <code>or</code>. (Poznámka: Tento kód se od předchozího řádku zcela liší. Python interpretuje nejdříve <code>x or y</code>. Výsledkem je buď <var>x</var> (pokud se <var>x</var> interpretuje <a href="native-datatypes.html#booleans">v booleovském kontextu jako true</a>), nebo <var>y</var>. Potom pro výslednou hodnotu kontroluje, zda se ve slovníku <var>a_dictionary</var> vyskytuje jako klíč.)
<li>Operátor <code>+</code> má vyšší prioritu než operátor <code>in</code>. Z technického hlediska by tento zápis nemusel používat závorky kolem <code>x + y</code>, ale <code>2to3</code> je stejně přidává.
<li>U tohoto zápisu musí být kolem <code>y in a_dictionary</code> závorky určitě uvedeny, protože operátor <code>+</code> má vyšší prioritu než operátor <code>in</code>.
</ol>
<h2 id=dict>Slovníkové metody, které vracejí seznamy</h2>
<p>V Pythonu 2 mnohé slovníkové metody vracely seznamy. Mezi nejpoužívanější metody patřily <code><dfn>keys</dfn>()</code>, <code><dfn>items</dfn>()</code> a <code><dfn>values</dfn>()</code>. V Pythonu 3 všechny tyto metody vracejí dynamické <dfn>pohledy</dfn> (view). V některých situacích to nečiní žádný problém. Pokud je návratová hodnota těchto metod ihned předána jiné funkci, která iteruje přes celou posloupnost, bude jedno, zda je skutečným typem seznam nebo pohled (view). V jiném kontextu to ale může mít velký vliv. Pokud očekáváme kompletní seznam s jednotlivě adresovatelnými prvky, náš kód se zakucká, protože pohledy nepodporují indexování (tj. zpřístupňování prvku přes index).
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>a_dictionary.keys()</code>
<td><code class=pp>list(a_dictionary.keys())</code>
<tr><th>②
<td><code class=pp>a_dictionary.items()</code>
<td><code class=pp>list(a_dictionary.items())</code>
<tr><th>③
<td><code class=pp>a_dictionary.iterkeys()</code>
<td><code class=pp>iter(a_dictionary.keys())</code>
<tr><th>④
<td><code class=pp>[i for i in a_dictionary.iterkeys()]</code>
<td><code class=pp>[i for i in a_dictionary.keys()]</code>
<tr><th>⑤
<td><code class=pp>min(a_dictionary.keys())</code>
<td><i>žádná změna</i>
</table>
<ol>
<li>Skript <code>2to3</code> se přiklání k bezpečnému řešení. Voláním funkce <code>list()</code> převádí hodnotu vracenou metodou <code>keys()</code> na statický seznam. Bude to fungovat vždycky, ale někdy to bude méně efektivní než použití pohledu (view). Převedený kód byste si měli prohlédnout a zvážit, zda je statický seznam nezbytně nutný, nebo zda by nestačil pohled.
<li>Další konverze pohledu na seznam — tentokrát u metody <code>items()</code>. Stejnou věc provede <code>2to3</code> s metodou <code>values()</code>.
<li>Python 3 už nepodporuje metodu <code>iterkeys()</code>. Použijte <code>keys()</code>, a pokud je to nezbytné, udělejte z pohledu iterátor voláním funkce <code>iter()</code>.
<li><code>2to3</code> pozná, když je metoda <code>iterkeys()</code> použita uvnitř generátorové notace seznamu. Převede ji na metodu <code>keys()</code> (neobaluje ji ještě jedním voláním <code>iter()</code>). Funguje to, protože přes pohledy (view) lze iterovat.
<li><code>2to3</code> pozná případ, kdy je metoda <code>keys()</code> předána funkci, která iteruje celou posloupností. V takovém případě se návratová hodnota nemusí konvertovat na seznam. Funkce <code>min()</code> bude vesele iterovat i přes pohled. Týká se to funkcí <code>min()</code>, <code>max()</code>, <code>sum()</code>, <code>list()</code>, <code>tuple()</code>, <code>set()</code>, <code>sorted()</code>, <code>any()</code> a <code>all()</code>.
</ol>
<h2 id=imports>Moduly, které byly přejmenovány nebo reorganizovány</h2>
<p>Několik modulů standardní pythonovské knihovny bylo přejmenováno. Několik vzájemně souvisejících modulů bylo spojeno dohromady nebo bylo reorganizováno tak, aby byly jejich vztahy logičtější.
<h3 id=http><code>http</code></h3>
<p>V Pythonu 3 bylo několik modulů souvisejících s <abbr>HTTP</abbr> spojeno do jednoho balíku nazvaného <code>http</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>import <dfn>httplib</dfn></code>
<td><code class=pp>import http.client</code>
<tr><th>②
<td><code class=pp>import <dfn>Cookie</dfn></code>
<td><code class=pp>import http.cookies</code>
<tr><th>③
<td><code class=pp>import <dfn>cookielib</dfn></code>
<td><code class=pp>import http.cookiejar</code>
<tr><th>④
<td><pre class=pp><code>import <dfn>BaseHTTPServer</dfn>
import <dfn>SimpleHTTPServer</dfn>
import <dfn>CGIHttpServer</dfn></code></pre>
<td><code class=pp>import http.server</code>
</table>
<ol>
<li>Modul <code>http.client</code> implementuje nízkoúrovňovou knihovnu, která vytváří požadavky na <abbr>HTTP</abbr> zdroje a interpretuje související <abbr>HTTP</abbr> odpovědi.
<li>Modul <code>http.cookies</code> poskytuje pythonovské rozhraní pro cookies prohlížeče, které se posílají v <abbr>HTTP</abbr> hlavičce <abbr>HTTP</abbr> hlavička.
<li>Modul <code>http.cookiejar</code> manipuluje se soubory na disku, které oblíbené webové prohlížeče používají k ukládání cookies.
<li>Modul <code>http.server</code> implementuje jednoduchý <abbr>HTTP</abbr> server.
</ol>
<h3 id=urllib><code>urllib</code></h3>
<p>Python 2 obsahoval změť překrývajících se modulů pro rozklad (parse) a kódování <abbr>URL</abbr> a pro získávání příslušného obsahu. V Pythonu 3 byly moduly refaktorizovány a sloučeny do jednoho balíku <code>urllib</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>import <dfn>urllib</dfn></code>
<td><code class=pp>import urllib.request, urllib.parse, urllib.error</code>
<tr><th>②
<td><code class=pp>import <dfn>urllib2</dfn></code>
<td><code class=pp>import urllib.request, urllib.error</code>
<tr><th>③
<td><code class=pp>import <dfn>urlparse</dfn></code>
<td><code class=pp>import urllib.parse</code>
<tr><th>④
<td><code class=pp>import <dfn>robotparser</dfn></code>
<td><code class=pp>import urllib.robotparser</code>
<tr><th>⑤
<td><pre class=pp><code>from urllib import <dfn>FancyURLopener</dfn>
from urllib import urlencode</code></pre>
<td><pre class=pp><code>from urllib.request import FancyURLopener
from urllib.parse import urlencode</code></pre>
<tr><th>⑥
<td><pre class=pp><code>from urllib2 import <dfn>Request</dfn>
from urllib2 import <dfn>HTTPError</dfn></code></pre>
<td><pre class=pp><code>from urllib.request import Request
from urllib.error import HTTPError</code></pre>
</table>
<ol>
<li>Starý modul <code>urllib</code> v Pythonu 2 obsahoval řadu funkcí včetně <code>urlopen()</code> pro načítání dat a <code>splittype()</code>, <code>splithost()</code> a <code>splituser()</code> pro rozklad <abbr>URL</abbr> na podstatné části. Uvnitř nového balíku <code>urllib</code> byly tyto funkce logičtěji přeorganizovány. Skript <code>2to3</code> také změní všechna volání těchto funkcí, aby zohlednil nové schéma pojmenování.
<li>Původní modul <code>urllib2</code> z Pythonu 2 byl v Pythonu 3 vložen do balíčku <code>urllib</code>. Všechny oblíbené věci z <code>urllib2</code> — metoda <code>build_opener()</code>, třídy <code>Request</code> a <code>HTTPBasicAuthHandler</code> a související věci — jsou stále k dispozici.
<li>Modul <code>urllib.parse</code> z Pythonu 3 obsahuje všechny funkce z původního modulu <code>urlparse</code> z Pythonu 2.
<li>Modul <code>urllib.robotparser</code> zpracovává <a href="http://www.robotstxt.org/">soubory <code>robots.txt</code></a>.
<li>Třída <code>FancyURLopener</code>, která obsluhuje <abbr>HTTP</abbr> přesměrování a další stavové kódy, je v novém modulu <code>urllib.request</code> stále k dispozici. Funkce <code>urlencode()</code> se přesunula do <code>urllib.parse</code>.
<li>Třída <code>Request</code> je v <code>urllib.request</code> stále k dispozici, ale konstanty jako <code>HTTPError</code> byly přesunuty do <code>urllib.error</code>.
</ol>
<p>Zmínil jsem se o tom, že <code>2to3</code> přepíše také volání vašich funkcí? Pokud například v kódu pro Python 2 importujete modul <code>urllib</code> a získáváte data voláním <code>urllib.urlopen()</code>, skript <code>2to3</code> opraví jak příkaz import, tak volání funkce.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><pre class=pp><code>import urllib
print urllib.urlopen('http://diveintopython3.org/').read()</code></pre>
<td><pre class=pp><code>import urllib.request, urllib.parse, urllib.error
print(urllib.request.urlopen('http://diveintopython3.org/').read())</code></pre>
</table>
<h3 id=dbm><code>dbm</code></h3>
<p>Všechny klony <abbr>DBM</abbr> se nyní nacházejí jediném balíku <code>dbm</code>. Pokud potřebujeme použít nějakou specifickou variantu, jako například <abbr>GNU</abbr> <abbr>DBM</abbr>, můžeme importovat příslušný modul z balíku <code>dbm</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp>import <dfn>dbm</dfn></code>
<td><code class=pp>import dbm.ndbm</code>
<tr><th>
<td><code class=pp>import <dfn>gdbm</dfn></code>
<td><code class=pp>import dbm.gnu</code>
<tr><th>
<td><code class=pp>import <dfn>dbhash</dfn></code>
<td><code class=pp>import dbm.bsd</code>
<tr><th>
<td><code class=pp>import <dfn>dumbdbm</dfn></code>
<td><code class=pp>import dbm.dumb</code>
<tr><th>
<td><pre class=pp><code>import <dfn>anydbm</dfn>
import whichdb</code></pre>
<td><code class=pp>import dbm</code>
</table>
<h3 id=xmlrpc><code>xmlrpc</code></h3>
<p><abbr>XML-RPC</abbr> je odlehčená (lightweight) metoda pro provádění <abbr>RPC</abbr> (vzdálené volání procedur) přes <abbr>HTTP</abbr>. Klientská knihovna pro <abbr>XML-RPC</abbr> a několik implementací <abbr>XML-RPC</abbr> serveru jsou nyní zkombinovány do jednoho balíčku <code>xmlrpc</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp>import <dfn>xmlrpclib</dfn></code>
<td><code class=pp>import xmlrpc.client</code>
<tr><th>
<td><pre class=pp><code>import <dfn>DocXMLRPCServer</dfn>
import <dfn>SimpleXMLRPCServer</dfn></code></pre>
<td><code class=pp>import xmlrpc.server</code>
</table>
<h3 id=othermodules>Ostatní moduly</h3>
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><pre class=pp><code>try:
import <dfn>cStringIO</dfn> as <dfn>StringIO</dfn>
except ImportError:
import StringIO</code></pre>
<td><code class=pp>import io</code>
<tr><th>②
<td><pre class=pp><code>try:
import cPickle as pickle
except ImportError:
import pickle</code></pre>
<td><code class=pp>import pickle</code>
<tr><th>③
<td><code class=pp>import <dfn>__builtin__</dfn></code>
<td><code class=pp>import builtins</code>
<tr><th>④
<td><code class=pp>import <dfn>copy_reg</dfn></code>
<td><code class=pp>import copyreg</code>
<tr><th>⑤
<td><code class=pp>import <dfn>Queue</dfn></code>
<td><code class=pp>import queue</code>
<tr><th>⑥
<td><code class=pp>import <dfn>SocketServer</dfn></code>
<td><code class=pp>import socketserver</code>
<tr><th>⑦
<td><code class=pp>import <dfn>ConfigParser</dfn></code>
<td><code class=pp>import configparser</code>
<tr><th>⑧
<td><code class=pp>import repr</code>
<td><code class=pp>import reprlib</code>
<tr><th>⑨
<td><code class=pp>import <dfn>commands</dfn></code>
<td><code class=pp>import subprocess</code>
</table>
<ol>
<li>Mezi běžné obraty v Pythonu 2 patřil pokus o <code>import cStringIO as StringIO</code>. Pokud operace selhala, provedl se místo toho příkaz <code>import StringIO</code>. V Pythonu 3 už to nedělejte. Modul <code>io</code> to udělá za vás. Nalezne nejrychlejší dostupnou implementaci a použije ji automaticky.
<li>Podobný obrat se používal pro importování nejrychlejší implementace pickle. V Pythonu 3 už to nedělejte. Modul <code>pickle</code> to udělá za vás.
<li>Modul <code>builtins</code> obsahuje globální funkce, třídy a konstanty, které se používají napříč celým jazykem Python. Redefinicí funkce v modulu <code>builtins</code> provedete redefinici globální funkce úplně všude. Je to přesně tak mocné a děsivé, jak to zní.
<li>Modul <code>copyreg</code> přidává podporu „piklení“ pro uživatelské typy definované v C.
<li>Modul <code>queue</code> implementuje frontu pro více producentů a více konzumentů.
<li>Modul <code>socketserver</code> poskytuje obecné (generické) bázové třídy pro implementaci různých druhů soketových serverů.
<li>Modul <code>configparser</code> zpracovává konfigurační soubory ve stylu <abbr>INI</abbr>.
<li>Modul <code>reprlib</code> reimplementuje zabudovanou funkci <code>repr()</code> s přidaným ovládáním. Lze předepsat, jak dlouhé mohou reprezentace být, než dojde k jejich ořezání.
<li>Modul <code>subprocess</code> umožňuje vytvářet procesy, připojovat se k jejich rourám (pipe) a získávat jejich návratové kódy.
</ol>
<h2 id=import>Relativní importy uvnitř balíčku</h2>
<p>Balíček je skupina souvisejících modulů, které se používají jako celek. Pokud se v Pythonu 2 moduly uvnitř balíčku potřebovaly odkazovat jeden na druhý, používali jsme příkaz <code>import foo</code> nebo <code>from foo import Bar</code>. V Pythonu 2 interpret hledal <code>foo.py</code> nejdříve uvnitř aktuálního balíčku a teprve potom prohledával ostatní adresáře z pythonovské vyhledávací cesty (<code>sys.path</code>). Python 3 funguje trošku jinak. Místo prohledávání aktuálního balíčku začne přímo pythonovskou vyhledávací cestou. Pokud chceme, aby jeden modul uvnitř balíčku importoval jiný modul ze stejného balíčku, musíme explicitně zadat relativní cestu mezi uvedenými moduly.
<p>Dejme tomu, že bychom měli následující balíček s více soubory ve stejném adresáři:
<pre>chardet/
|
+--__init__.py
|
+--constants.py
|
+--mbcharsetprober.py
|
+--universaldetector.py</pre>
<p>Teď předpokládejme, že <code>universaldetector.py</code> potřebuje importovat celý soubor <code>constants.py</code> a jednu třídu z <code>mbcharsetprober.py</code>. Jak to vlastně uděláme?
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>import constants</code>
<td><code class=pp>from . import constants</code>
<tr><th>②
<td><code class=pp>from mbcharsetprober import MultiByteCharSetProber</code>
<td><code class=pp>from .mbcharsetprober import MultiByteCharsetProber</code>
</table>
<ol>
<li>Pokud potřebujeme importovat celý modul odněkud z našeho balíčku, použijeme novou syntaxi <code>from . import</code>. Tečka ve skutečnosti označuje relativní cestu od tohoto souboru (<code>universaldetector.py</code>) k souboru, který chceme importovat (<code>constants.py</code>). V tomto případě se nacházejí ve stejném adresáři, takže použijeme jednu tečku. Importovat můžeme i z rodičovského adresáře (<code>from .. import jinymodul</code>) nebo z podadresáře.
<li>Pokud chceme importovat určitou třídu nebo funkci z jiného modulu přímo do prostoru jmen našeho modulu, přidáme k cílovému modulu jako prefix relativní cestu bez koncového lomítka. V tomto případě se <code>mbcharsetprober.py</code> nachází ve stejném adresáři jako <code>universaldetector.py</code>, takže cestu vyjádříme jednou tečkou. Importovat můžeme i z rodičovského adresáře (<code>from ..jinymodul import JinaTrida</code>) nebo z podadresáře.
</ol>
<h2 id=next>Metoda iterátoru <code>next()</code></h2>
<p>V Pythonu 2 měly iterátory metodu <code><dfn>next</dfn>()</code>, která vracela další položku z posloupnosti. V Pythonu 3 to stále platí, ale máme k dispozici také <a href="generators.html#generators">globální funkci <code>next()</code></a>, která přebírá iterátor jako argument.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>anIterator.next()</code>
<td><code class=pp>next(anIterator)</code>
<tr><th>②
<td><code class=pp>funkce_ktera_vraci_iterator().next()</code>
<td><code class=pp>next(funkce_ktera_vraci_iterator())</code>
<tr><th>③
<td><pre class=pp><code>class A:
def next(self):
pass</code></pre>
<td><pre class=pp><code>class A:
def __next__(self):
pass</code></pre>
<tr><th>④
<td><pre class=pp><code>class A:
def next(self, x, y):
pass</code></pre>
<td><i>žádná změna</i>
<tr><th>⑤
<td><pre class=pp><code>next = 42
for an_iterator in a_sequence_of_iterators:
an_iterator.next()</code></pre>
<td><pre class=pp><code>next = 42
for an_iterator in a_sequence_of_iterators:
an_iterator.__next__()</code></pre>
</table>
<ol>
<li>V nejjednodušším případě nyní místo volání metody iterátoru <code>next()</code> předáváme iterátor globální funkci <code>next()</code>.
<li>Pokud máme funkci, která vrací iterátor, zavoláme ji a výsledek předáme funkci <code>next()</code>. (Skript <code>2to3</code> je dost chytrý na to, aby to převedl správně.)
<li>Pokud definujeme svou vlastní třídu a míníme ji použít jako iterátor, definujeme speciální metodu <code>__next__()</code>.
<li>Pokud definujeme svou vlastní třídu a ta shodou okolností obsahuje metodu pojmenovanou <code>next()</code>, která přebírá jeden nebo víc argumentů, nechá ji skript <code>2to3</code> beze změny. Tato třída nemůže být použita jako iterátor, protože její metoda <code>next()</code> vyžaduje argumenty.
<li>Tohle je trošku ošemetné. Pokud máme lokální proměnnou pojmenovanou <var>next</var>, pak bude mít přednost před novou globální funkcí <code>next()</code>. V takovém případě budeme muset pro získání dalšího prvku posloupnosti volat speciální metodu iterátoru <code>__next__()</code>. (Alternativně bychom mohli refaktorizovat kód tak, že by lokální proměnná nebyla pojmenována <var>next</var>, ale to za nás <code>2to3</code> automaticky neudělá.)
</ol>
<h2 id=filter>Globální funkce <code>filter()</code></h2>
<p>V Pythonu 2 vracela funkce <code><dfn>filter</dfn>()</code> seznam, který byl výsledkem filtrování posloupnosti přes funkci, která pro každý prvek posloupnosti vracela hodnotu <code>True</code> nebo <code>False</code>. V Pythonu 3 funkce <code>filter()</code> nevrací seznam, ale iterátor.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>filter(a_function, a_sequence)</code>
<td><code class=pp>list(filter(a_function, a_sequence))</code>
<tr><th>②
<td><code class=pp>list(filter(a_function, a_sequence))</code>
<td><i>žádná změna</i>
<tr><th>③
<td><code class=pp>filter(None, a_sequence)</code>
<td><code class=pp>[i for i in a_sequence if i]</code>
<tr><th>④
<td><code class=pp>for i in filter(None, a_sequence):</code>
<td><i>žádná změna</i>
<tr><th>⑤
<td><code class=pp>[i for i in filter(a_function, a_sequence)]</code>
<td><i>žádná změna</i>
</table>
<ol>
<li>V nejzákladnějším případě obalí skript <code>2to3</code> volání funkce <code>filter()</code> voláním funkce <code>list()</code>. Tím se provede průchod přes všechny hodnoty a vrátí se skutečný seznam.
<li>Pokud je ale volání funkce <code>filter()</code> <em>už obaleno</em> v <code>list()</code>, nebude <code>2to3</code> dělat nic, protože skutečnost, že <code>filter()</code> vrací iterátor v takovém případě není důležitá.
<li>Speciální syntaxi <code>filter(None, ...)</code> skript <code>2to3</code> nahradí použitím sémanticky shodné generátorové notace seznamu.
<li>V kontextu podobajícímu se cyklům <code>for</code>, kdy stejně dochází k průchodu celou posloupností, není nutné provádět žádné změny.
<li>Ani zde se nemusí dělat žádné změny, protože generátorová notace seznamu bude iterovat přes všechny prvky posloupnosti, a to může udělat, ať už <code>filter()</code> vrací iterátor nebo seznam.
</ol>
<h2 id=map>Globální funkce <code>map()</code></h2>
<p>Funkce <code><dfn>map</dfn>()</code> nyní vrací iterátor. Jde o stejný případ jako u funkce <a href="#filter"><code>filter()</code></a>. (V Pythonu 2 se vracel seznam.)
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>map(a_function, 'PapayaWhip')</code>
<td><code class=pp>list(map(a_function, 'PapayaWhip'))</code>
<tr><th>②
<td><code class=pp>map(None, 'PapayaWhip')</code>
<td><code class=pp>list('PapayaWhip')</code>
<tr><th>③
<td><code class=pp>map(lambda x: x+1, range(42))</code>
<td><code class=pp>[x+1 for x in range(42)]</code>
<tr><th>④
<td><code class=pp>for i in map(a_function, a_sequence):</code>
<td><i>žádná změna</i>
<tr><th>⑤
<td><code class=pp>[i for i in map(a_function, a_sequence)]</code>
<td><i>žádná změna</i>
</table>
<ol>
<li>Stejně jako u <code>filter()</code> v nejzákladnějším případě obalí skript <code>2to3</code> volání funkce <code>map()</code> voláním <code>list()</code>.
<li>Speciální syntaxi <code>map(None, ...)</code>, vyjadřující funkci identity, převede skript <code>2to3</code> na ekvivalentní volání <code>list()</code>.
<li>Pokud je prvním argumentem <code>map()</code> lambda funkce, převede <code>2to3</code> zápis s využitím odpovídající generátorové notace seznamu.
<li>V kontextu jako u cyklů <code>for</code>, které stejně procházejí celou posloupností, není nutné provádět žádné změny.
<li>Ani zde se nemusí dělat žádné změny, protože generátorová notace seznamu předepisuje průchod přes všechny prvky posloupnosti, a to může udělat, ať už <code>map()</code> vrací iterátor nebo seznam.
</ol>
<h2 id=reduce>Globální funkce <code>reduce()</code></h2>
<p>V Pythonu 3 byla funkce <code><dfn>reduce</dfn>()</code> vyňata z globálního prostoru jmen a umístěna do modulu <code>functools</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp>reduce(a, b, c)</code>
<td><pre class=pp><code>from functools import reduce
reduce(a, b, c)</code></pre>
</table>
<h2 id=apply>Globální funkce <code>apply()</code></h2>
<p>V Pythonu 2 existovala globální funkce <code><dfn>apply</dfn>()</code>, která přebírala funkci <var>f</var> a seznam <code>[a, b, c]</code> a vrátila <code>f(a, b, c)</code>. Stejné věci můžeme dosáhnout tím, že funkci zavoláme přímo a před předávaný seznam argumentů připíšeme hvězdičku. V Pythonu 3 již funkce <code>apply()</code> neexistuje. Musíme použít zápis s hvězdičkou.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>apply(a_function, a_list_of_args)</code>
<td><code class=pp>a_function(*a_list_of_args)</code>
<tr><th>②
<td><code class=pp>apply(a_function, a_list_of_args, a_dictionary_of_named_args)</code>
<td><code class=pp>a_function(*a_list_of_args, **a_dictionary_of_named_args)</code>
<tr><th>③
<td><code class=pp>apply(a_function, a_list_of_args + z)</code>
<td><code class=pp>a_function(*a_list_of_args + z)</code>
<tr><th>④
<td><code class=pp>apply(aModule.a_function, a_list_of_args)</code>
<td><code class=pp>aModule.a_function(*a_list_of_args)</code>
</table>
<ol>
<li>V nejjednodušším případě můžeme funkci při volání předat seznam argumentů (skutečný seznam, jako například <code>[a, b, c]</code>) přidáním hvězdičky před seznam (<code>*</code>). Jde o přesný ekvivalent staré funkce <code>apply()</code> z Pythonu 2.
<li>V Pythonu 2 může funkce <code>apply()</code> ve skutečnosti přebírat tři parametry: funkci, seznam argumentů a slovník s pojmenovanými argumenty. V Pythonu 3 můžeme téhož dosáhnout přidáním hvězdičky před seznam argumentů (<code>*</code>) a přidáním dvou hvězdiček před slovník pojmenovaných argumentů (<code>**</code>).
<li>Zde se operátor + používá pro zřetězení seznamů. Operátor <code>+</code> má vyšší prioritu než operátor <code>*</code>, takže kolem <code>a_list_of_args + z</code> nemusíme přidávat závorky.
<li>Skript <code>2to3</code> je dost chytrý na to, aby převedl i složitá volání <code>apply()</code>, včetně volání funkcí z importovaných modulů.
</ol>
<h2 id=intern>Globální funkce <code>intern()</code></h2>
<p>V Pythonu 2 bylo možné „internovat“ řetězec voláním funkce <code><dfn>intern</dfn>()</code>, čímž došlo k optimalizaci výkonu při práci s tímto řetězcem. V Pythonu 3 byla funkce <code>intern()</code> přesunuta do modulu <code>sys</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp>intern(aString)</code>
<td><code class=pp>sys.intern(aString)</code>
</table>
<h2 id=exec>Příkaz <code>exec</code></h2>
<p>Příkaz <code><dfn>exec</dfn></code> se v Pythonu 3 změnil na funkci stejně, jako se na funkci změnil <a href="#print">příkaz <code>print</code></a>. Funkce <code>exec()</code> přebírá řetězec, který obsahuje libovolný pythonovský kód, a provede jej, jako kdyby to byl nějaký příkaz nebo výraz. Funkce <code>exec()</code> se podobá <a href="advanced-iterators.html#eval"><code>eval()</code></a>, ale je ještě mocnější a zlověstnější. Funkce <code>eval()</code> může vyhodnocovat jediný výraz, ale funkce <code>exec()</code> může provést více příkazů, importů, deklarací funkcí — v podstatě celý pythonovský program, předaný jako řetězec.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>exec codeString</code>
<td><code class=pp>exec(codeString)</code>
<tr><th>②
<td><code class=pp>exec codeString in a_global_namespace</code>
<td><code class=pp>exec(codeString, a_global_namespace)</code>
<tr><th>③
<td><code class=pp>exec codeString in a_global_namespace, a_local_namespace</code>
<td><code class=pp>exec(codeString, a_global_namespace, a_local_namespace)</code>
</table>
<ol>
<li>V nejjednodušším případě skript <code>2to3</code> prostě uzavře kód v podobě řetězce do závorek, protože <code>exec()</code> je teď funkce a ne příkaz.
<li>Původní příkaz <code>exec</code> mohl přebírat prostor jmen v podobě soukromého prostředí s globálními jmény, ve kterém se měl kód v podobě řetězce provádět. V Pythonu 3 lze dělat totéž. Prostor jmen se funkci <code>exec()</code> jednoduše předá jako druhý parametr.
<li>Původní příkaz <code>exec</code> umožňoval dokonce přebírat lokální prostor jmen (podobající se prostoru proměnných definovaných uvnitř nějaké funkce). V Pythonu 3 to funkce <code>exec()</code> dokáže také.
</ol>
<h2 id=execfile>Příkaz <code>execfile</code></h2>
<p>Původní příkaz <code>execfile</code>, podobně jako původní <a href="#exec">příkaz <code>exec</code></a>, spouštěl řetězce, ve kterých byl uložen pythonovský kód. Tam, kde <code>exec</code> přebíral řetězec, <code>execfile</code> přebíral jméno souboru. Z Pythonu 3 byl příkaz <code>execfile</code> vyřazen. Pokud opravdu chcete použít soubor s pythonovským kódem a spustit jej (ale nechcete jej přitom jednoduše importovat), můžete stejné funkčnosti dosáhnout otevřením souboru, načtením jeho obsahu, zavoláním globální funkce <code>compile()</code> (aby byl pythonovský interpret donucen kód přeložit) a nakonec zavoláním nové funkce <code>exec()</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp><dfn>execfile</dfn>('a_filename')</code>
<td><code class=pp>exec(compile(open('a_filename').read(), 'a_filename', 'exec'))</code>
</table>
<h2 id=repr><code>repr</code>-literály (zpětné apostrofy)</h2>
<p>V Pythonu 2 bylo možné získat reprezentaci objektu použitím speciální syntaxe, kdy se libovolný objekt obalil <dfn>zpětnými apostrofy</dfn> (backticks; jako například <code>`x`</code>). V Pythonu 3 tato schopnost stále existuje, ale už ji nemůžeme vyvolat použitím zpětných apostrofů. Místo nich musíme použít globální funkci <code>repr()</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>`x`</code>
<td><code class=pp>repr(x)</code>
<tr><th>②
<td><code class=pp>`'PapayaWhip' + `2``</code>
<td><code class=pp>repr('PapayaWhip' + repr(2))</code>
</table>
<ol>
<li>Připomeňme si, že <var>x</var> může být cokoliv — třída, funkce, modul, primitivní datový typ atd. Funkce <code>repr()</code> funguje na všechno.
<li>V Pythonu 2 mohly být zpětné apostrofy zanořeny, což vedlo k tomuto druhu matoucích (ale platných) výrazů. Skript <code>2to3</code> je dost chytrý na to, aby zápis převedl na zanořené volání <code>repr()</code>.
</ol>
<h2 id=except>Příkaz <code>try...except</code></h2>
<p>Syntaxe pro <a href="your-first-python-program.html#exceptions">odchytávání <dfn>výjimek</dfn></a> se mezi verzemi Python 2 a Python 3 mírně změnila.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><pre class=pp><code>try:
import mymodule
<dfn>except</dfn> ImportError, e
pass</code></pre>
<td><pre class=pp><code>try:
import mymodule
except ImportError as e:
pass</code></pre>
<tr><th>②
<td><pre class=pp><code>try:
import mymodule
except (RuntimeError, ImportError), e
pass</code></pre>
<td><pre class=pp><code>try:
import mymodule
except (RuntimeError, ImportError) as e:
pass</code></pre>
<tr><th>③
<td><pre class=pp><code>try:
import mymodule
except ImportError:
pass</code></pre>
<td><i>žádná změna</i>
<tr><th>④
<td><pre class=pp><code>try:
import mymodule
except:
pass</code></pre>
<td><i>žádná změna</i>
</table>
<ol>
<li>Místo čárky se za typem výjimky v Pythonu 3 používá nové klíčové slovo <code>as</code>.
<li>Klíčové slovo <code>as</code> funguje i pro odchytávání více typů výjimek najednou.
<li>Pokud výjimku jen odchytíme, ale ve skutečnosti nás nezajímá možnost přistupování k samotnému <dfn>objektu</dfn> výjimky, pak se syntaxe používaná v Pythonu 2 shoduje se syntaxí v Pythonu 3.
<li>Podobně, pokud používáme záchranu v podobě odchytávání <em>všech</em> výjimek, je syntaxe identická.
</ol>
<blockquote class=note>
<p><span class="u">☞</span>Nouzové odchytávání <em>všech</em> výjimek byste nikdy neměli používat při importování modulů (ani ve většině ostatních případů). Tímto způsobem odchytíte i věci jako <code>KeyboardInterrupt</code> (pokud se uživatel pokoušel o přerušení činnosti programu stiskem <kbd>Ctrl-C</kbd>) a ztížíte si tím ladění.
</blockquote>
<h2 id=raise>Příkaz <code>raise</code></h2>
<p>Syntaxe pro <a href="your-first-python-program.html#exceptions">vyvolávání našich vlastních výjimek</a> se mezi verzemi Python 2 a Python 3 mírně změnila.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp><dfn>raise</dfn> MyException</code>
<td><i>žádná změna</i>
<tr><th>②
<td><code class=pp>raise MyException, 'error message'</code>
<td><code class=pp>raise MyException('error message')</code>
<tr><th>③
<td><code class=pp>raise MyException, 'error message', a_traceback</code>
<td><code class=pp>raise MyException('error message').with_traceback(a_traceback)</code>
<tr><th>④
<td><code class=pp>raise 'error message'</code>
<td><i>nepodporováno</i>
</table>
<ol>
<li>Při použití nejjednodušší formy, vyvolání výjimky bez uživatelské chybové zprávy, se syntaxe nezměnila.
<li>Změny si povšimneme, když chceme vyvolat výjimku s uživatelským chybovým hlášením. Python 2 odděloval třídu výjimky a uživatelskou zprávu čárkou. Python 3 předává chybovou zprávu jako parametr.
<li>Python 2 podporoval při složitější syntaxi vyvolání výjimky s uživatelským zpětným trasováním (stack trace). V Pythonu 3 toho můžeme dosáhnout také, ale syntaxe se docela liší.
<li>V Pythonu 2 jsme mohli vyvolat výjimku, aniž jsme zadávali třídu výjimky. Stačilo zadat chybovou zprávu. V Pythonu 3 to již není možné. Skript <code>2to3</code> vás bude varovat, že nebyl schopen tuto situaci opravit automaticky.
</ol>
<h2 id=throw>Metoda generátorů <code>throw</code></h2>
<p>V Pythonu 2 definovaly generátory metodu <code><dfn>throw</dfn>()</code>. Volání <code>a_generator.throw()</code> vyvolá výjimku v místě, kde se generátor zastavil. Potom se vrací další hodnota, která je vyprodukována (yield) generátorovou funkcí. V Pythonu 3 je uvedená funkčnost stále k dispozici, ale syntaxe se trochu změnila.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>a_generator.throw(MyException)</code>
<td><i>žádná změna</i>
<tr><th>②
<td><code class=pp>a_generator.throw(MyException, 'error message')</code>
<td><code class=pp>a_generator.throw(MyException('error message'))</code>
<tr><th>③
<td><code class=pp>a_generator.throw('error message')</code>
<td><i>nepodporováno</i>
</table>
<ol>
<li>V nejjednodušším případě generátor vyvolává výjimku bez uživatelské chybové zprávy. V tomto případě se syntaxe v Pythonu 3 vůči Pythonu 2 nezměnila.
<li>Pokud generátor vyvolává výjimku <em>s uživatelskou chybovou zprávou</em>, musíme řetězec se zprávou předat vytvářenému objektu výjimky.
<li>Python 2 podporoval vyvolání výjimky, která byla tvořena <em>pouze</em> uživatelským chybovým hlášením. Python 3 toto chování nepodporuje a skript <code>2to3</code> zobrazí varování, které říká, že to budete muset opravit ručně.
</ol>
<h2 id=xrange>Globální funkce <code>xrange()</code></h2>
<p>V Pythonu 2 existovaly dva způsoby získávání hodnot intervalu čísel: funkce <code><dfn>range</dfn>()</code> vracela seznam a funkce <code><dfn>xrange</dfn>()</code>, vracela iterátor. V Pythonu 3 funkce <code>range()</code> vrací iterátor a funkce <code>xrange()</code> už neexistuje.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>xrange(10)</code>
<td><code class=pp>range(10)</code>
<tr><th>②
<td><code class=pp>a_list = range(10)</code>
<td><code class=pp>a_list = list(range(10))</code>
<tr><th>③
<td><code class=pp>[i for i in xrange(10)]</code>
<td><code class=pp>[i for i in range(10)]</code>
<tr><th>④
<td><code class=pp>for i in range(10):</code>
<td><i>žádná změna</i>
<tr><th>⑤
<td><code class=pp>sum(range(10))</code>
<td><i>žádná změna</i>
</table>
<ol>
<li>V nejjednodušším případě skript <code>2to3</code> jednoduše změní <code>xrange()</code> na <code>range()</code>.
<li>Pokud kód pro Python 2 používal <code>range()</code>, pak skript <code>2to3</code> neví, zda jsme skutečně potřebovali seznam, nebo zda by vyhověl iterátor. V rámci opatrnosti se vracená hodnota převádí na seznam voláním funkce <code>list()</code>.
<li>Pokud by byla funkce <code>xrange()</code> použita uvnitř generátorového zápisu seznamu, pak je skript <code>2to3</code> dost chytrý na to, aby funkci <code>range()</code> <em>neobalil</em> voláním <code>list()</code>. Generátorový zápis seznamu bude bez problémů fungovat s iterátorem, který je funkcí <code>range()</code> vrácen.
<li>Bez problémů bude s iterátorem fungovat i cyklus <code>for</code>, takže ani zde není nutné nic měnit.
<li>Funkce <code>sum()</code> pracuje s iterátorem také, takže <code>2to3</code> nemusí nic měnit ani zde. Uvedený přístup se, stejně jako v případě <a href="#dict">metod slovníku, které vracejí pohledy (view) místo seznamů</a>, aplikuje i u funkcí <code>min()</code>, <code>max()</code>, <code>sum()</code>, <code>list()</code>, <code>tuple()</code>, <code>set()</code>, <code>sorted()</code>, <code>any()</code> a <code>all()</code>.
</ol>
<h2 id=raw_input>Globální funkce <code>raw_input()</code> a <code>input()</code></h2>
<p>Python 2 poskytoval pro vyžádání si uživatelského vstupu z příkazové řádky dvě globální funkce. První z nich, zvaná <code>input()</code>, očekávala, že uživatel vloží pythonovský výraz (vrací se jeho výsledek). Druhá z nich, zvaná <code><dfn>raw_input</dfn>()</code>, vracela to, co uživatel napsal. Začátečníky to velmi mátlo a považovalo se to za „bradavici“ (wart) na jazyce. Python 3 tuto nepěknost řeší přejmenováním <code>raw_input()</code> na <code>input()</code>, takže to funguje způsobem, který většina naivně očekává.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>raw_input()</code>
<td><code class=pp>input()</code>
<tr><th>②
<td><code class=pp>raw_input('prompt')</code>
<td><code class=pp>input('prompt')</code>
<tr><th>③
<td><code class=pp>input()</code>
<td><code class=pp>eval(input())</code>
</table>
<ol>
<li>V nejjednodušším případě se <code>raw_input()</code> mění na <code>input()</code>.
<li>V Pythonu 2 mohla funkce <code>raw_input()</code> přebírat vyzývací řetězec jako parametr. Tato možnost je zachována i v Pythonu 3.
<li>Pokud chcete, aby se opravdu vyhodnocoval pythonovský výraz zadaný uživatelem, použijte funkci <code>input()</code> a předejte její výsledek funkci <code>eval()</code>.
</ol>
<h2 id=funcattrs>Atributy funkcí <code>func_*</code></h2>
<p>V Pythonu 2 může kód uvnitř funkce přistupovat ke speciálním atributům, které se týkají funkce samotné. V Pythonu 3 byly tyto speciální atributy funkcí přejmenovány, aby se dostaly do souladu s ostatními atributy.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>a_function.<dfn>func_name</dfn></code>
<td><code class=pp>a_function.__name__</code>
<tr><th>②
<td><code class=pp>a_function.<dfn>func_doc</dfn></code>
<td><code class=pp>a_function.__doc__</code>
<tr><th>③
<td><code class=pp>a_function.<dfn>func_defaults</dfn></code>
<td><code class=pp>a_function.__defaults__</code>
<tr><th>④
<td><code class=pp>a_function.<dfn>func_dict</dfn></code>
<td><code class=pp>a_function.__dict__</code>
<tr><th>⑤
<td><code class=pp>a_function.<dfn>func_closure</dfn></code>
<td><code class=pp>a_function.__closure__</code>
<tr><th>⑥
<td><code class=pp>a_function.<dfn>func_globals</dfn></code>
<td><code class=pp>a_function.__globals__</code>
<tr><th>⑦
<td><code class=pp>a_function.<dfn>func_code</dfn></code>
<td><code class=pp>a_function.__code__</code>
</table>
<ol>
<li>Atribut <code>__name__</code> (dříve <code>func_name</code>) obsahuje jméno funkce.
<li>Atribut <code>__doc__</code> (dříve <code>func_doc</code>) obsahuje <i>dokumentační řetězec</i>, který byl definován ve zdrojovém textu funkce.
<li>Atribut <code>__defaults__</code> (dříve <code>func_defaults</code>) je n-tice obsahující výchozí hodnoty argumentů pro ty z argumentů, pro které byly výchozí hodnoty definovány.
<li>Atribut <code>__dict__</code> (dříve <code>func_dict</code>) je prostor jmen uchovávající libovolné atributy funkce.
<li>Atribut <code>__closure__</code> (dříve <code>func_closure</code>) je n-tice buněk, které obsahují vazby (bindings) na volné proměnné, které se ve funkci používají.
<li>Atribut <code>__globals__</code> (dříve <code>func_globals</code>) je odkaz na globální prostor jmen modulu, ve kterém byla funkce definována.
<li>Atribut <code>__code__</code> (dříve <code>func_code</code>) je objekt kódu (code object), reprezentující přeložené tělo funkce.
</ol>
<h2 id=xreadlines>Metoda <code>xreadlines()</code> V/V objektů</h2>
<p>V Pythonu 2 měly souborové objekty metodu <code><dfn>xreadlines</dfn>()</code>, která vracela iterátor procházející souborem po řádcích. Kromě jiného se to hodilo pro cykly <code>for</code>. Ve skutečnosti to byla tak užitečná metoda, že pozdější verze Pythonu 2 přidaly schopnost iterovat samotným souborovým objektům.
<p>V Pythonu 3 přestala metoda <code>xreadlines()</code> existovat. Skript <code>2to3</code> je schopen převést jednoduché případy, ale v hraničních situacích po vás bude vyžadovat ruční zásah.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>for line in a_file.xreadlines():</code>
<td><code class=pp>for line in a_file:</code>
<tr><th>②
<td><code class=pp>for line in a_file.xreadlines(5):</code>
<td><i>žádná změna (vede k nefunkčnímu kódu)</i>
</table>
<ol>
<li>Pokud jste byli zvyklí volat <code>xreadlines()</code> bez argumentů, převede toto volání skript <code>2to3</code> jen na souborový objekt. V Pythonu 3 zajistí tento zápis stejnou funkčnost: čte se ze souboru řádek po řádku a provádí se tělo cyklu <code>for</code>.
<li>Pokud jste byli zvyklí volat <code>xreadlines()</code> s argumentem (počet řádků, které se mají načíst najednou), pak to skript <code>2to3</code> neopraví a váš kód selže s vysvětlením <code>AttributeError: '_io.TextIOWrapper' object has no attribute 'xreadlines'</code>. Opravu pro Python 3 můžete ručně provést změnou <code>xreadlines()</code> na <code>readlines()</code>. (Metoda <code>readlines()</code> teď vrací iterátor, takže je to stejně efektivní, jako bylo <code>xreadlines()</code> v Pythonu 2.)
</ol>
<p class=c><span style='font-size:56px;line-height:0.88'>☃</span>
<h2 id=tuple_params><code>lambda</code> funkce, které akceptují n-tici místo více parametrů</h2>
<p>V Pythonu 2 jsme mohli definovat anonymní <code><dfn>lambda</dfn></code> funkci, která přebírá více parametrů, tím, že jsme ji definovali jako funkci, která přebírá n-tici s určeným počtem položek. V důsledku toho Python 2 „rozbalil“ n-tici do pojmenovaných argumentů, na které jsme se pak mohli uvnitř <code>lambda</code> funkce odkazovat jménem. V Pythonu 3 můžeme <code>lambda</code> funkci také předávat n-tici, ale pythonovský interpret ji nerozbalí do pojmenovaných argumentů. Místo toho se budeme muset na jednotlivé argumenty odkazovat pozičním indexem.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>lambda (x,): x + f(x)</code>
<td><code class=pp>lambda x1: x1[0] + f(x1[0])</code>
<tr><th>②
<td><code class=pp>lambda (x, y): x + f(y)</code>
<td><code class=pp>lambda x_y: x_y[0] + f(x_y[1])</code>
<tr><th>③
<td><code class=pp>lambda (x, (y, z)): x + y + z</code>
<td><code class=pp>lambda x_y_z: x_y_z[0] + x_y_z[1][0] + x_y_z[1][1]</code>
<tr><th>④
<td><code class=pp>lambda x, y, z: x + y + z</code>
<td><i>žádná změna</i>
</table>
<ol>
<li>Pokud jsme definovali <code>lambda</code> funkci, která přebírá n-tici s jedním prvkem, stane se z ní v Pythonu 3 <code>lambda</code> funkce, která se odkazuje na <var>x1[0]</var>. Jméno <var>x1</var> je generováno skriptem <code>2to3</code> automaticky, na základě pojmenovaných argumentů původní n-tice.
<li><code>lambda</code> funkce s dvouprvkovou n-ticí <var>(x, y)</var> bude převedena na <var>x_y</var> s pozičními argumenty <var>x_y[0]</var> a <var>x_y[1]</var>.
<li>Skript <code>2to3</code> zvládne dokonce <code>lambda</code> funkce s vnořenými n-ticemi pojmenovaných argumentů. Výsledný kód v Pythonu 3 je poněkud nečitelný, ale funguje stejným způsobem, jakým fungoval původní kód v Pythonu 2.
<li>Můžeme definovat <code>lambda</code> funkce, které přebírají víc argumentů. Pokud kolem argumentů neuvedeme závorky, chová se Python 2 k zápisu jako k <code>lambda</code> funkci s více argumenty. Uvnitř <code>lambda</code> funkce se na pojmenované argumenty odkazujeme jménem jako v každé jiné funkci. V Pythonu 3 tato syntaxe pořád funguje.
</ol>
<h2 id=methodattrs>Atributy speciálních metod</h2>
<p>V Pythonu 2 se mohly metody tříd odkazovat na objekt třídy, ve které jsou definovány, a také na samotný objekt metody. Reference <code>im_self</code> odkazovala na objekt instance třídy, <code>im_func</code> na objekt funkce a <code>im_class</code> se odkazuje na třídu objektu <code>im_self</code>. V Pythonu 3 byly tyto speciální atributy metod přejmenovány, aby se dostaly do souladu s pojmenováním ostatních atributů.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp>aClassInstance.aClassMethod.<dfn>im_func</dfn></code>
<td><code class=pp>aClassInstance.aClassMethod.__func__</code>
<tr><th>
<td><code class=pp>aClassInstance.aClassMethod.<dfn>im_self</dfn></code>
<td><code class=pp>aClassInstance.aClassMethod.__self__</code>
<tr><th>
<td><code class=pp>aClassInstance.aClassMethod.<dfn>im_class</dfn></code>
<td><code class=pp>aClassInstance.aClassMethod.__self__.__class__</code>
</table>
<h2 id=nonzero>Speciální metoda <code>__nonzero__</code></h2>
<p>V Pythonu 2 jsme mohli vytvářet své vlastní třídy, které se daly používat v booleovském kontextu. Mohli jsme například vytvořit instanci takové třídy a pak ji použít v příkazu <code>if</code>. Dělalo se to tak, že jsme definovali speciální metodu <code>__nonzero__()</code>, která vracela <code>True</code> nebo <code>False</code>. Ta se volala, kdykoliv byla instance použita v booleovském kontextu. V Pythonu 3 lze dělat totéž, ale jméno metody bylo změněno na <code>__bool__()</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><pre class=pp><code>class A:
def <dfn>__nonzero__</dfn>(self):
pass</code></pre>
<td><pre class=pp><code>class A:
def <dfn>__bool__</dfn>(self):
pass</code></pre>
<tr><th>②
<td><pre class=pp><code>class A:
def __nonzero__(self, x, y):
pass</code></pre>
<td><i>žádná změna</i>
</table>
<ol>
<li>Při vyhodnocování instance v booleovském kontextu se v Pythonu 3 místo <code>__nonzero__()</code> volá metoda <code>__bool__()</code>.
<li>Pokud ale máme definovánu metodu <code>__nonzero__()</code>, která vyžaduje nějaké argumenty, bude nástroj <code>2to3</code> předpokládat, že jsme ji používali pro nějaký jiný účel, a neprovede žádné změny.
</ol>
<h2 id=numliterals>Oktalové literály</h2>
<p>Syntaxe pro zápis čísel v osmičkové soustavě (tj. <dfn>oktalových</dfn>) se mezi Pythonem 2 a Pythonem 3 mírně změnila.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>
<td><code class=pp>x = 0755</code>
<td><code class=pp>x = 0o755</code>
</table>
<h2 id=renames><code>sys.maxint</code></h2>
<p>V souvislosti <a href="#long">se sloučením typů <code>long</code> a <code>int</code></a> pozbyla konstanta <code>sys.maxint</code> vypovídací přesnost. Tato hodnota může být stále užitečná při zjišťování schopností závislých na platformě. Proto byla v Pythonu ponechána, ale byla přejmenována na <code>sys.maxsize</code>.
<table>
<tr><th>Poznámky
<th>Python 2
<th>Python 3
<tr><th>①
<td><code class=pp>from sys import <dfn>maxint</dfn></code>
<td><code class=pp>from sys import <dfn>maxsize</dfn></code>
<tr><th>②
<td><code class=pp>a_function(<dfn>sys.maxint</dfn>)</code>
<td><code class=pp>a_function(<dfn>sys.maxsize</dfn>)</code>
</table>
<ol>
<li>Z <code>maxint</code> se stává <code>maxsize</code>.
<li>Jakékoliv použití <code>sys.maxint</code> se mění na <code>sys.maxsize</code>.
</ol>
<h2 id=callable>Globální funkce <code>callable()</code></h2>
<p>V Pythonu 2 jsme mohli voláním globální funkce <code><dfn>callable</dfn>()</code> zkontrolovat, zda se dá objekt volat (jako funkce). Z Pythonu 3 byla tato globální funkce vyřazena. Pokud chceme zjistit, zda se dá objekt volat, musíme zkontrolovat, zda má speciální metodu <code>__call__()</code>.
<table>
<tr><th>Poznámky
<th>Python 2