-
-
Notifications
You must be signed in to change notification settings - Fork 37
Expand file tree
/
Copy pathfunctional.po
More file actions
2320 lines (2068 loc) · 107 KB
/
functional.po
File metadata and controls
2320 lines (2068 loc) · 107 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
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# mollinaca, 2021
# tomo, 2021
# Atsuo Ishimoto <atsuoishimoto@gmail.com>, 2022
# 菊池 健志, 2023
# TENMYO Masakazu, 2024
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-05-09 14:19+0000\n"
"PO-Revision-Date: 2021-06-28 00:53+0000\n"
"Last-Translator: TENMYO Masakazu, 2024\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
#: ../../howto/functional.rst:5
msgid "Functional Programming HOWTO"
msgstr "関数型プログラミング HOWTO"
#: ../../howto/functional.rst:0
msgid "Author"
msgstr "著者"
#: ../../howto/functional.rst:7
msgid "A. M. Kuchling"
msgstr "A. M. Kuchling"
#: ../../howto/functional.rst:0
msgid "Release"
msgstr "リリース"
#: ../../howto/functional.rst:8
msgid "0.32"
msgstr "0.32"
#: ../../howto/functional.rst:10
msgid ""
"In this document, we'll take a tour of Python's features suitable for "
"implementing programs in a functional style. After an introduction to the "
"concepts of functional programming, we'll look at language features such as :"
"term:`iterator`\\s and :term:`generator`\\s and relevant library modules "
"such as :mod:`itertools` and :mod:`functools`."
msgstr ""
"この文書では、関数型スタイルでプログラムを実装するのにピッタリな Python の機"
"能を見てまわることにしましょう。まず関数型プログラミングという概念を紹介した"
"あと、 :term:`iterator` や :term:`generator` のような言語機能、および :mod:"
"`itertools` や :mod:`functools` といった関連するライブラリモジュールを見るこ"
"とにします。"
#: ../../howto/functional.rst:18
msgid "Introduction"
msgstr "はじめに"
#: ../../howto/functional.rst:20
msgid ""
"This section explains the basic concept of functional programming; if you're "
"just interested in learning about Python language features, skip to the next "
"section on :ref:`functional-howto-iterators`."
msgstr ""
"この章は関数型プログラミングの基本概念を説明します; Python の言語機能について"
"だけ知りたい人は、次の章の :ref:`functional-howto-iterators` まで飛ばしてくだ"
"さい。"
#: ../../howto/functional.rst:24
msgid ""
"Programming languages support decomposing problems in several different ways:"
msgstr ""
"プログラミング言語とは問題を分解するものですが、各言語がサポートする分解方法"
"にはいくつかの種類があります:"
#: ../../howto/functional.rst:26
msgid ""
"Most programming languages are **procedural**: programs are lists of "
"instructions that tell the computer what to do with the program's input. C, "
"Pascal, and even Unix shells are procedural languages."
msgstr ""
"ほとんどのプログラミング言語は **手続き型** です: プログラムは、入力に対して"
"行うべきことをコンピュータに教える指示リストとなります。 C, Pascal, さらには "
"Unix シェルまでもが手続き型言語に入ります。"
#: ../../howto/functional.rst:30
msgid ""
"In **declarative** languages, you write a specification that describes the "
"problem to be solved, and the language implementation figures out how to "
"perform the computation efficiently. SQL is the declarative language you're "
"most likely to be familiar with; a SQL query describes the data set you want "
"to retrieve, and the SQL engine decides whether to scan tables or use "
"indexes, which subclauses should be performed first, etc."
msgstr ""
"**宣言型** 言語で書くのは、解くべき問題を説明する仕様書であって、それを効率的"
"に計算処理する方法を見付けるのは言語実装の役目です。SQL はおそらく一番よく知"
"られた宣言型言語です; SQL のクエリは取得したいデータセットを説明しているだけ"
"で、テーブルを走査するかインデックスを使うか、どのサブクローズから実行するか"
"等々を決めるのは SQL エンジンなのです。"
#: ../../howto/functional.rst:37
msgid ""
"**Object-oriented** programs manipulate collections of objects. Objects "
"have internal state and support methods that query or modify this internal "
"state in some way. Smalltalk and Java are object-oriented languages. C++ "
"and Python are languages that support object-oriented programming, but don't "
"force the use of object-oriented features."
msgstr ""
"**オブジェクト指向** プログラムはオブジェクトの集まりを操作します。オブジェク"
"トには内部状態があり、その状態を調べたり色々と変更したりするためのメソッドが"
"あります。Smalltalk や Java はオブジェクト指向言語です。 C++ と Python はオブ"
"ジェクト指向プログラミングをサポートしていますが、関連する機能を使わなくても"
"構わないようになっています。"
#: ../../howto/functional.rst:43
msgid ""
"**Functional** programming decomposes a problem into a set of functions. "
"Ideally, functions only take inputs and produce outputs, and don't have any "
"internal state that affects the output produced for a given input. Well-"
"known functional languages include the ML family (Standard ML, OCaml, and "
"other variants) and Haskell."
msgstr ""
"**関数型** プログラミングは問題をいくつかの関数にわけて考えます。理想的に言う"
"と、関数は入力を受けて出力を吐くだけで、同じ入力に対して異なる出力をするよう"
"な内部状態を一切持ちません。有名な関数型言語には ML 一家 (Standard ML, OCaml "
"等々) と Haskell があります。"
#: ../../howto/functional.rst:49
msgid ""
"The designers of some computer languages choose to emphasize one particular "
"approach to programming. This often makes it difficult to write programs "
"that use a different approach. Other languages are multi-paradigm languages "
"that support several different approaches. Lisp, C++, and Python are multi-"
"paradigm; you can write programs or libraries that are largely procedural, "
"object-oriented, or functional in all of these languages. In a large "
"program, different sections might be written using different approaches; the "
"GUI might be object-oriented while the processing logic is procedural or "
"functional, for example."
msgstr ""
"設計者が特定のアプローチを強調することにした言語もありますが、そうすると大抵"
"は、別のアプローチを使うプログラムを書きにくくなります。複数のアプローチに対"
"応した言語もあり、Lisp, C++, Python はそうしたマルチパラダイム言語です; この"
"中のどれを使っても、基本的に手続き型な、または基本的にオブジェクト指向な、と"
"か、基本的に関数型なプログラムやライブラリを書くことができます。大きなプログ"
"ラムでは、各部で別々のアプローチを使って書くことがあるかもしれません; GUI は"
"オブジェクト指向で、でも処理ロジックは手続き型や関数型で、といったようにで"
"す。"
#: ../../howto/functional.rst:60
msgid ""
"In a functional program, input flows through a set of functions. Each "
"function operates on its input and produces some output. Functional style "
"discourages functions with side effects that modify internal state or make "
"other changes that aren't visible in the function's return value. Functions "
"that have no side effects at all are called **purely functional**. Avoiding "
"side effects means not using data structures that get updated as a program "
"runs; every function's output must only depend on its input."
msgstr ""
"関数型プログラムでは、入力は一連の関数を通って流れていきます。それぞれの関数"
"は入力に何らかの作業をして出力します。関数型スタイルにおいては、内部状態を変"
"えてしまったり、返り値に現れない変更をしたりといった副作用のある関数はやめる"
"ように言われています。副作用のまったくない関数は **純粋関数型** であるとされ"
"ます。副作用をなくすということは、プログラムの実行中に順次変化していくデータ"
"構造を持たない、つまり各関数の出力はその入力にしか影響を受けてはいけないとい"
"うことです。"
#: ../../howto/functional.rst:68
msgid ""
"Some languages are very strict about purity and don't even have assignment "
"statements such as ``a=3`` or ``c = a + b``, but it's difficult to avoid all "
"side effects, such as printing to the screen or writing to a disk file. "
"Another example is a call to the :func:`print` or :func:`time.sleep` "
"function, neither of which returns a useful value. Both are called only for "
"their side effects of sending some text to the screen or pausing execution "
"for a second."
msgstr ""
"ある言語では純粋さにとても厳しく ``a=3`` や ``c = a + b`` のような代入文すら"
"存在しないほどですが、画面への表示やディスクファイルへの書き込みなど、すべて"
"の副作用を避けるのは難しいです。別の例として、 :func:`print` や :func:`time."
"sleep` 関数の呼び出しもありますが、どちらも有用な値を返しません。画面にテキス"
"トを送ったり、実行を 1 秒間停めたりといった副作用のためだけに呼ばれるのです。"
#: ../../howto/functional.rst:75
msgid ""
"Python programs written in functional style usually won't go to the extreme "
"of avoiding all I/O or all assignments; instead, they'll provide a "
"functional-appearing interface but will use non-functional features "
"internally. For example, the implementation of a function will still use "
"assignments to local variables, but won't modify global variables or have "
"other side effects."
msgstr ""
"関数型スタイルで書いた Python プログラムはふつう、I/O や代入を完全になくすと"
"いった極端なところまでは行かずに、関数型っぽく見えるインターフェースを提供し"
"つつも内部では非関数型の機能を使います。たとえば、関数内でローカル変数の代入"
"は使いますが、グローバル変数は変更せず、他の副作用もないように実装するので"
"す。"
#: ../../howto/functional.rst:81
msgid ""
"Functional programming can be considered the opposite of object-oriented "
"programming. Objects are little capsules containing some internal state "
"along with a collection of method calls that let you modify this state, and "
"programs consist of making the right set of state changes. Functional "
"programming wants to avoid state changes as much as possible and works with "
"data flowing between functions. In Python you might combine the two "
"approaches by writing functions that take and return instances representing "
"objects in your application (e-mail messages, transactions, etc.)."
msgstr ""
"関数型プログラミングはオブジェクト指向プログラミングの反対と考えることもでき"
"ます。オブジェクト指向において、オブジェクトは内部状態とそれを変更するメソッ"
"ドコールの入ったカプセルであり、プログラムはその状態を適正に変化させていく手"
"順です。一方で、関数型プログラミングは可能なかぎり状態の変更を避け、関数どう"
"しの間を流れるデータだけを扱おうとします。Python ではこの二つのアプローチを結"
"び合わせることができます。アプリケーション内のオブジェクト (メール、トランザ"
"クション、等々) を表現したインスタンスを、関数が受け渡しするようにするので"
"す。"
#: ../../howto/functional.rst:90
msgid ""
"Functional design may seem like an odd constraint to work under. Why should "
"you avoid objects and side effects? There are theoretical and practical "
"advantages to the functional style:"
msgstr ""
"関数型デザインは、わけのわからない制約に見えるかもしれません。どうしてオブ"
"ジェクトも副作用もないほうが良いのでしょうか。実は、関数型スタイルには理論と"
"実践に基づく次の利点があるのです:"
#: ../../howto/functional.rst:94
msgid "Formal provability."
msgstr "形式的証明可能性。"
#: ../../howto/functional.rst:95
msgid "Modularity."
msgstr "モジュラー性。"
#: ../../howto/functional.rst:96
msgid "Composability."
msgstr "結合性。"
#: ../../howto/functional.rst:97
msgid "Ease of debugging and testing."
msgstr "デバッグやテストの簡単さ。"
#: ../../howto/functional.rst:101
msgid "Formal provability"
msgstr "形式的証明可能性"
#: ../../howto/functional.rst:103
msgid ""
"A theoretical benefit is that it's easier to construct a mathematical proof "
"that a functional program is correct."
msgstr ""
"理論面の利点としては、プログラムが正しいことの数学的証明を他より簡単に構築で"
"きるという点があります。"
#: ../../howto/functional.rst:106
msgid ""
"For a long time researchers have been interested in finding ways to "
"mathematically prove programs correct. This is different from testing a "
"program on numerous inputs and concluding that its output is usually "
"correct, or reading a program's source code and concluding that the code "
"looks right; the goal is instead a rigorous proof that a program produces "
"the right result for all possible inputs."
msgstr ""
"研究者たちは長いあいだ、プログラムが正しいことを数学的に証明する方法の発見に"
"血道をあげてきました。これは、色々な入力でテストして出力が正しかったからまあ"
"正しいだろう、と結論するのとも違いますし、ソースコードを読んで「間違いはなさ"
"そうだ」と言うのとも別の話です; 目指すのは、出現しうる入力すべてに対してプロ"
"グラムが正しい結果を出すことの厳密な証明なのです。"
#: ../../howto/functional.rst:113
msgid ""
"The technique used to prove programs correct is to write down "
"**invariants**, properties of the input data and of the program's variables "
"that are always true. For each line of code, you then show that if "
"invariants X and Y are true **before** the line is executed, the slightly "
"different invariants X' and Y' are true **after** the line is executed. "
"This continues until you reach the end of the program, at which point the "
"invariants should match the desired conditions on the program's output."
msgstr ""
"プログラムを証明するために使われているのは **不変式** を書き出していくという"
"テクニックで、不変式とは入力データやプログラム変数のうち常に真である性質のこ"
"とです。コードの一行一行で、 **実行前** の不変式 X と Y が真なら **実行後に"
"** ちょっと違う不変式 X' と Y' が真になることを示していき、これをプログラムの"
"終わりまで続けるわけです。すると最終的な不変式はプログラムの出力に合った条件"
"になっているはずです。"
#: ../../howto/functional.rst:121
msgid ""
"Functional programming's avoidance of assignments arose because assignments "
"are difficult to handle with this technique; assignments can break "
"invariants that were true before the assignment without producing any new "
"invariants that can be propagated onward."
msgstr ""
"関数型プログラミングが代入を嫌うのは、この不変式テクニックでは代入を扱いにく"
"いからです; 代入は、それまで真だった不変式を壊しておいて、自分は次の行に伝え"
"てゆける不変式を生み出さないことがあるのです。"
#: ../../howto/functional.rst:126
msgid ""
"Unfortunately, proving programs correct is largely impractical and not "
"relevant to Python software. Even trivial programs require proofs that are "
"several pages long; the proof of correctness for a moderately complicated "
"program would be enormous, and few or none of the programs you use daily "
"(the Python interpreter, your XML parser, your web browser) could be proven "
"correct. Even if you wrote down or generated a proof, there would then be "
"the question of verifying the proof; maybe there's an error in it, and you "
"wrongly believe you've proved the program correct."
msgstr ""
"残念ながら、プログラムの証明はだいたい実際的でもありませんし、Python ソフト"
"ウェアにも関係ありません。本当に簡単なプログラムでも、証明には数ページにわた"
"る論文が必要なのです; ある程度の複雑なプログラムではもう尋常でない長さになっ"
"てしまうので、日常で使っているプログラム (Python インタプリタ、XML パーサ、"
"ウェブブラウザ) はほとんど、あるいはすべて、正しさを証明するのは不可能でしょ"
"う。仮に証明を書き出したり生成したりしても、その証明を検証するための疑いが残"
"ります; 証明に間違いがあるかもしれず、その場合は証明したと自分で勝手に思い込"
"んでいただけになるのです。"
#: ../../howto/functional.rst:137
msgid "Modularity"
msgstr "モジュラー性"
#: ../../howto/functional.rst:139
msgid ""
"A more practical benefit of functional programming is that it forces you to "
"break apart your problem into small pieces. Programs are more modular as a "
"result. It's easier to specify and write a small function that does one "
"thing than a large function that performs a complicated transformation. "
"Small functions are also easier to read and to check for errors."
msgstr ""
"より実用的には、関数型プログラミングをすると問題を細かく切り分けることになる"
"という利点があります。結果としてプログラムはモジュラー化されます。複雑な変形"
"を施す大きな関数を書くより、一つのことに絞ってそれだけをする小さな関数のほう"
"が書きやすいものです。それに、小さいほうが読むのもエラーをチェックするのも簡"
"単です。"
#: ../../howto/functional.rst:147
msgid "Ease of debugging and testing"
msgstr "デバッグやテストの簡単さ"
#: ../../howto/functional.rst:149
msgid "Testing and debugging a functional-style program is easier."
msgstr "テストやデバッグも関数型プログラムなら簡単です。"
#: ../../howto/functional.rst:151
msgid ""
"Debugging is simplified because functions are generally small and clearly "
"specified. When a program doesn't work, each function is an interface point "
"where you can check that the data are correct. You can look at the "
"intermediate inputs and outputs to quickly isolate the function that's "
"responsible for a bug."
msgstr ""
"関数が一般的に小さくて明確に意味付けされているので、デバッグ方法は単純です。"
"プログラムが正しく動かないときには、関数ひとつひとつがデータの正しさをチェッ"
"クするポイントになるので、それぞれの時点における入力と出力を見ていけば、バグ"
"の原因となる関数を素早く切り出すことができるのです。"
#: ../../howto/functional.rst:156
msgid ""
"Testing is easier because each function is a potential subject for a unit "
"test. Functions don't depend on system state that needs to be replicated "
"before running a test; instead you only have to synthesize the right input "
"and then check that the output matches expectations."
msgstr ""
"ひとつひとつの関数がユニットテストの対象になり得るわけですから、テストも簡単"
"です。関数はシステムの状態に依存しませんので、テストの実行前にそうした状態を"
"再現する必要はありません; 単に適切な入力を合成して、出力が期待どおりかどうか"
"チェックするだけで良いのです。"
#: ../../howto/functional.rst:163
msgid "Composability"
msgstr "結合性"
#: ../../howto/functional.rst:165
msgid ""
"As you work on a functional-style program, you'll write a number of "
"functions with varying inputs and outputs. Some of these functions will be "
"unavoidably specialized to a particular application, but others will be "
"useful in a wide variety of programs. For example, a function that takes a "
"directory path and returns all the XML files in the directory, or a function "
"that takes a filename and returns its contents, can be applied to many "
"different situations."
msgstr ""
"関数型スタイルのプログラムを作っていると、色々な入力や出力のために色々な関数"
"を書くことになります。仕方なく特定のアプリケーションに特化した関数を書くこと"
"もあるでしょうけれど、広範なプログラムに使える関数もあることでしょう。たとえ"
"ば、ディレクトリ名を受け取ってその中の XML ファイル一覧を返す関数や、ファイル"
"名を受け取って内容を返す関数などは、多様な場面に適用できそうです。"
#: ../../howto/functional.rst:172
msgid ""
"Over time you'll form a personal library of utilities. Often you'll "
"assemble new programs by arranging existing functions in a new configuration "
"and writing a few functions specialized for the current task."
msgstr ""
"時たつうちに自分の特製ライブラリやユーティリティが充実してくると、新しいプロ"
"グラムも、既存の関数を調整して少し今回に特化した関数を書くだけで組み立てられ"
"るようになります。"
#: ../../howto/functional.rst:180
msgid "Iterators"
msgstr "イテレータ (iterator)"
#: ../../howto/functional.rst:182
msgid ""
"I'll start by looking at a Python language feature that's an important "
"foundation for writing functional-style programs: iterators."
msgstr ""
"まずは関数型スタイルのプログラムを書く際の基礎となる重要な Python 機能から見"
"ていきましょう: イテレータです。"
#: ../../howto/functional.rst:185
msgid ""
"An iterator is an object representing a stream of data; this object returns "
"the data one element at a time. A Python iterator must support a method "
"called :meth:`~iterator.__next__` that takes no arguments and always returns "
"the next element of the stream. If there are no more elements in the "
"stream, :meth:`~iterator.__next__` must raise the :exc:`StopIteration` "
"exception. Iterators don't have to be finite, though; it's perfectly "
"reasonable to write an iterator that produces an infinite stream of data."
msgstr ""
"イテレータは連続データを表現するオブジェクトです; このオブジェクトは一度に一"
"つの要素ずつデータを返します。 Python のイテレータは :meth:`~iterator."
"__next__` という、引数を取らず次の要素を返すメソッドを必ずサポートしていま"
"す。データストリームに要素が残っていない場合、 :meth:`~iterator.__next__` は"
"必ず :exc:`StopIteration` 例外を出します。ただし、イテレータの長さは有限であ"
"る必要はありません; 無限のストリームを生成するイテレータを書くというのもまっ"
"たく理に適ったことです。"
#: ../../howto/functional.rst:193
msgid ""
"The built-in :func:`iter` function takes an arbitrary object and tries to "
"return an iterator that will return the object's contents or elements, "
"raising :exc:`TypeError` if the object doesn't support iteration. Several "
"of Python's built-in data types support iteration, the most common being "
"lists and dictionaries. An object is called :term:`iterable` if you can get "
"an iterator for it."
msgstr ""
"ビルトインの :func:`iter` 関数は任意のオブジェクトを受けて、 その中身や要素を"
"返すイテレータを返そうとします。引数のオブジェクトが イテレータを作れないとき"
"は :exc:`TypeError` を投げます。Python の ビルトインなデータ型にもいくつかイ"
"テレータ化のできるものがあり、 中でもよく使われるのはリストと辞書です。イテ"
"レータを作れる オブジェクトは :term:`iterable` オブジェクトと呼ばれます。"
#: ../../howto/functional.rst:200
msgid "You can experiment with the iteration interface manually:"
msgstr "手を動かしてイテレータ化の実験をしてみましょう:"
#: ../../howto/functional.rst:218
msgid ""
"Python expects iterable objects in several different contexts, the most "
"important being the :keyword:`for` statement. In the statement ``for X in "
"Y``, Y must be an iterator or some object for which :func:`iter` can create "
"an iterator. These two statements are equivalent::"
msgstr ""
"Python は色々な文脈でイテラブルなオブジェクトを期待しますが、 最も重要なの"
"は :keyword:`for` 文です。 ``for X in Y`` という文の Y は、 イテレータか、あ"
"るいは :func:`iter` でイテレータを作れるオブジェクトである必要があります。次"
"の二つは同じ意味になります::"
#: ../../howto/functional.rst:224
msgid ""
"for i in iter(obj):\n"
" print(i)\n"
"\n"
"for i in obj:\n"
" print(i)"
msgstr ""
#: ../../howto/functional.rst:230
msgid ""
"Iterators can be materialized as lists or tuples by using the :func:`list` "
"or :func:`tuple` constructor functions:"
msgstr ""
"イテレータは :func:`list` や :func:`tuple` といったコンストラクタ関数を使って"
"リストやタプルに具現化することができます:"
#: ../../howto/functional.rst:239
msgid ""
"Sequence unpacking also supports iterators: if you know an iterator will "
"return N elements, you can unpack them into an N-tuple:"
msgstr ""
"シーケンスのアンパックもイテレータに対応しています: イテレータが N 個の要素を"
"返すということが事前にわかっていれば、N-タプルにアンパックすることができます:"
#: ../../howto/functional.rst:248
msgid ""
"Built-in functions such as :func:`max` and :func:`min` can take a single "
"iterator argument and will return the largest or smallest element. The "
"``\"in\"`` and ``\"not in\"`` operators also support iterators: ``X in "
"iterator`` is true if X is found in the stream returned by the iterator. "
"You'll run into obvious problems if the iterator is infinite; :func:`max`, :"
"func:`min` will never return, and if the element X never appears in the "
"stream, the ``\"in\"`` and ``\"not in\"`` operators won't return either."
msgstr ""
"ビルトイン関数の :func:`max` や :func:`min` なども、イテレータ一つだけを引数"
"に取って最大・最小の要素を返すことができます。 ``\"in\"`` や ``\"not in\"`` "
"演算子もイテレータに対応しています: ``X in iterator`` は、そのイテレータから"
"返るストリームに X があれば真です。ですからイテレータが無限長だと、当然ながら"
"問題に直面します; :func:`max`, :func:`min` はいつまでも戻って来ませんし、 要"
"素 X がストリームに出てこなければ ``\"in\"``, ``\"not in\"`` オペレータも戻り"
"ません。"
#: ../../howto/functional.rst:256
msgid ""
"Note that you can only go forward in an iterator; there's no way to get the "
"previous element, reset the iterator, or make a copy of it. Iterator "
"objects can optionally provide these additional capabilities, but the "
"iterator protocol only specifies the :meth:`~iterator.__next__` method. "
"Functions may therefore consume all of the iterator's output, and if you "
"need to do something different with the same stream, you'll have to create a "
"new iterator."
msgstr ""
"イテレータは次に進むことしかできませんのでご注意ください; 前の要素を手に入れ"
"たり、イテレータをリセットしたり、コピーを作ったりする方法はありません。イテ"
"レータがオブジェクトとしてそうした追加機能を 持つことはできますが、プロトコル"
"では :meth:`~iterator.__next__` メソッドのことしか指定されていません。ですか"
"ら関数はイテレータの出力を使い尽くして しまうかもしれませんし、同じストリーム"
"に何か別のことをする 必要があるなら新しいイテレータを作らなくてはいけません。"
#: ../../howto/functional.rst:266
msgid "Data Types That Support Iterators"
msgstr "イテレータ対応のデータ型"
#: ../../howto/functional.rst:268
msgid ""
"We've already seen how lists and tuples support iterators. In fact, any "
"Python sequence type, such as strings, will automatically support creation "
"of an iterator."
msgstr ""
"リストやタプルがイテレータに対応している方法については既に見ましたが、実のと"
"ころ Python のシーケンス型はどれでも、たとえば文字列なども、自動でイテレータ"
"生成に対応しています。"
#: ../../howto/functional.rst:272
msgid ""
"Calling :func:`iter` on a dictionary returns an iterator that will loop over "
"the dictionary's keys::"
msgstr ""
"辞書に対して :func:`iter` すると、辞書のキーでループを回すイテレータが返され"
"ます::"
#: ../../howto/functional.rst:275
msgid ""
">>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,\n"
"... 'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}\n"
">>> for key in m:\n"
"... print(key, m[key])\n"
"Jan 1\n"
"Feb 2\n"
"Mar 3\n"
"Apr 4\n"
"May 5\n"
"Jun 6\n"
"Jul 7\n"
"Aug 8\n"
"Sep 9\n"
"Oct 10\n"
"Nov 11\n"
"Dec 12"
msgstr ""
#: ../../howto/functional.rst:292
msgid ""
"Note that starting with Python 3.7, dictionary iteration order is guaranteed "
"to be the same as the insertion order. In earlier versions, the behaviour "
"was unspecified and could vary between implementations."
msgstr ""
"Python 3.7 から、辞書の反復順序は挿入順序と同じであることが保証されていること"
"に注意してください。\n"
"以前のバージョンでは、その振る舞いは仕様が定められておらず、実装ごとに異なる"
"ことがありました。"
#: ../../howto/functional.rst:296
msgid ""
"Applying :func:`iter` to a dictionary always loops over the keys, but "
"dictionaries have methods that return other iterators. If you want to "
"iterate over values or key/value pairs, you can explicitly call the :meth:"
"`~dict.values` or :meth:`~dict.items` methods to get an appropriate iterator."
msgstr ""
"辞書は :func:`iter` を適用するとキーでループを回しますが、辞書には他のイテ"
"レータを返すメソッドもあります。明示的に値、あるいはキーと値のペアでイテレー"
"トしたければ、:meth:`~dict.values`, :meth:`~dict.items` というメソッドでイテ"
"レータを作ることができます。"
#: ../../howto/functional.rst:302
msgid ""
"The :func:`dict` constructor can accept an iterator that returns a finite "
"stream of ``(key, value)`` tuples:"
msgstr ""
"逆に :func:`dict` コンストラクタは、有限な ``(key, value)`` タプルのストリー"
"ムを返すイテレータを受け入れることができます:"
#: ../../howto/functional.rst:309
msgid ""
"Files also support iteration by calling the :meth:`~io.TextIOBase.readline` "
"method until there are no more lines in the file. This means you can read "
"each line of a file like this::"
msgstr ""
"ファイルも、最後の行まで :meth:`~io.TextIOBase.readline` メソッドを呼んでいく"
"ことでイテレータ化に対応しています。つまりこうやってファイルの各行を読んでい"
"くことができるわけです::"
#: ../../howto/functional.rst:313
msgid ""
"for line in file:\n"
" # do something for each line\n"
" ..."
msgstr ""
#: ../../howto/functional.rst:317
msgid ""
"Sets can take their contents from an iterable and let you iterate over the "
"set's elements::"
msgstr ""
"セットはイテラブルを受け取れますし、そのセットの要素でイテレートすることもで"
"きます::"
#: ../../howto/functional.rst:320
msgid ""
">>> S = {2, 3, 5, 7, 11, 13}\n"
">>> for i in S:\n"
"... print(i)\n"
"2\n"
"3\n"
"5\n"
"7\n"
"11\n"
"13"
msgstr ""
#: ../../howto/functional.rst:333
msgid "Generator expressions and list comprehensions"
msgstr "ジェネレータ式とリスト内包表記"
#: ../../howto/functional.rst:335
msgid ""
"Two common operations on an iterator's output are 1) performing some "
"operation for every element, 2) selecting a subset of elements that meet "
"some condition. For example, given a list of strings, you might want to "
"strip off trailing whitespace from each line or extract all the strings "
"containing a given substring."
msgstr ""
"イテレータの出力に対してよく使う操作トップ 2 は、(1) ひとつずつ全要素に操作を"
"実行する、および (2) 条件に合う要素でサブセットを作る、です。たとえば文字列の"
"リストなら、各行のうしろに付いた邪魔なホワイトスペースを削りたいとか、特定の"
"文字列を含む部分をピックアップしたいなどと思うかもしれません。"
#: ../../howto/functional.rst:341
msgid ""
"List comprehensions and generator expressions (short form: \"listcomps\" and "
"\"genexps\") are a concise notation for such operations, borrowed from the "
"functional programming language Haskell (https://www.haskell.org/). You can "
"strip all the whitespace from a stream of strings with the following code::"
msgstr ""
"リスト内包表記とジェネレータ式 (略して「listcomp」と「genexp」) は、そうした"
"操作向けの簡潔な表記方法です。これは関数型プログラミング言語 Haskell "
"(https://www.haskell.org/) にインスパイアされました。文字列のストリームからホ"
"ワイトスペースをすべて削るのは次のコードでできます::"
#: ../../howto/functional.rst:346
msgid ""
">>> line_list = [' line 1\\n', 'line 2 \\n', ' \\n', '']\n"
"\n"
">>> # Generator expression -- returns iterator\n"
">>> stripped_iter = (line.strip() for line in line_list)\n"
"\n"
">>> # List comprehension -- returns list\n"
">>> stripped_list = [line.strip() for line in line_list]"
msgstr ""
#: ../../howto/functional.rst:354
msgid ""
"You can select only certain elements by adding an ``\"if\"`` condition::"
msgstr "特定の要素だけを選び出すのは ``\"if\"`` 条件式を付けることで可能です::"
#: ../../howto/functional.rst:356
msgid ""
">>> stripped_list = [line.strip() for line in line_list\n"
"... if line != \"\"]"
msgstr ""
#: ../../howto/functional.rst:359
msgid ""
"With a list comprehension, you get back a Python list; ``stripped_list`` is "
"a list containing the resulting lines, not an iterator. Generator "
"expressions return an iterator that computes the values as necessary, not "
"needing to materialize all the values at once. This means that list "
"comprehensions aren't useful if you're working with iterators that return an "
"infinite stream or a very large amount of data. Generator expressions are "
"preferable in these situations."
msgstr ""
"リスト内包表記を使うと Python リストが返って来ます; ``stripped_list`` は実行"
"結果の行が入ったリストであって、イテレータではありません。ジェネレータ式はイ"
"テレータを返し、これだと必要に応じてだけ値を算出しますので、すべての値を一度"
"に出す必要がありません。つまりリスト内包表記のほうは、無限長ストリームや膨大"
"なデータを返すようなイテレータを扱う際には、あまり役に立たないということで"
"す。そういった状況ではジェネレータ式のほうが好ましいと言えます。"
#: ../../howto/functional.rst:366
msgid ""
"Generator expressions are surrounded by parentheses (\"()\") and list "
"comprehensions are surrounded by square brackets (\"[]\"). Generator "
"expressions have the form::"
msgstr ""
"ジェネレータ式は丸括弧 \"()\" で囲まれ、リスト内包表記は角括弧 \"[]\" で囲ま"
"れます。ジェネレータ式の形式は次のとおりです::"
#: ../../howto/functional.rst:370
msgid ""
"( expression for expr in sequence1\n"
" if condition1\n"
" for expr2 in sequence2\n"
" if condition2\n"
" for expr3 in sequence3\n"
" ...\n"
" if condition3\n"
" for exprN in sequenceN\n"
" if conditionN )"
msgstr ""
#: ../../howto/functional.rst:380
msgid ""
"Again, for a list comprehension only the outside brackets are different "
"(square brackets instead of parentheses)."
msgstr ""
"リスト内包表記も、外側の括弧が違うだけ (丸ではなく角括弧) で、あとは同じで"
"す。"
#: ../../howto/functional.rst:383
msgid ""
"The elements of the generated output will be the successive values of "
"``expression``. The ``if`` clauses are all optional; if present, "
"``expression`` is only evaluated and added to the result when ``condition`` "
"is true."
msgstr ""
"生成される出力は ``expression`` 部分の値を要素として並べたものになります。 "
"``if`` 節はすべて、なくても大丈夫です; あれば ``condition`` が真のときだけ "
"``expression`` が評価されて出力に追加されます。"
#: ../../howto/functional.rst:387
msgid ""
"Generator expressions always have to be written inside parentheses, but the "
"parentheses signalling a function call also count. If you want to create an "
"iterator that will be immediately passed to a function you can write::"
msgstr ""
"ジェネレータ式は常に括弧の中に書かなければなりませんが、関数コールの目印に"
"なっている括弧でも大丈夫です。関数にすぐ渡すイテレータを作りたければこう書け"
"るのです::"
#: ../../howto/functional.rst:391
msgid "obj_total = sum(obj.count for obj in list_all_objects())"
msgstr ""
#: ../../howto/functional.rst:393
msgid ""
"The ``for...in`` clauses contain the sequences to be iterated over. The "
"sequences do not have to be the same length, because they are iterated over "
"from left to right, **not** in parallel. For each element in ``sequence1``, "
"``sequence2`` is looped over from the beginning. ``sequence3`` is then "
"looped over for each resulting pair of elements from ``sequence1`` and "
"``sequence2``."
msgstr ""
"``for...in`` 節は複数つなげられますが、どれにも、イテレートするためのシーケン"
"スが含まれています。それらのシーケンスは並行して **ではなく** 、左から右へ順"
"番にイテレートされるので、長さが同じである必要はありません。 ``sequence1`` の"
"各要素ごとに毎回最初から ``sequence2`` をループで回すのです。その後 "
"``sequence1`` と ``sequence2`` から出た要素ペアごとに、 ``sequence3`` でルー"
"プします。"
#: ../../howto/functional.rst:399
msgid ""
"To put it another way, a list comprehension or generator expression is "
"equivalent to the following Python code::"
msgstr ""
"別の書き方をすると、リスト内包表記やジェネレータ式は次の Python コードと同じ"
"意味になります::"
#: ../../howto/functional.rst:402
msgid ""
"for expr1 in sequence1:\n"
" if not (condition1):\n"
" continue # Skip this element\n"
" for expr2 in sequence2:\n"
" if not (condition2):\n"
" continue # Skip this element\n"
" ...\n"
" for exprN in sequenceN:\n"
" if not (conditionN):\n"
" continue # Skip this element\n"
"\n"
" # Output the value of\n"
" # the expression."
msgstr ""
#: ../../howto/functional.rst:416
msgid ""
"This means that when there are multiple ``for...in`` clauses but no ``if`` "
"clauses, the length of the resulting output will be equal to the product of "
"the lengths of all the sequences. If you have two lists of length 3, the "
"output list is 9 elements long:"
msgstr ""
"つまり、複数の ``for...in`` 節があって ``if`` がないときの最終出力は、長さが"
"各シーケンス長の積に等しくなるということです。長さ 3 のリスト二つなら、出力リ"
"ストの長さは 9 要素です:"
#: ../../howto/functional.rst:428
msgid ""
"To avoid introducing an ambiguity into Python's grammar, if ``expression`` "
"is creating a tuple, it must be surrounded with parentheses. The first list "
"comprehension below is a syntax error, while the second one is correct::"
msgstr ""
"Python の文法に曖昧さを紛れ込ませないように、 ``expression`` でタプルを作るな"
"ら括弧で囲わなくてはなりません。下にあるリスト内包表記で、最初のは構文エラー"
"ですが、二番目は有効です::"
#: ../../howto/functional.rst:432
msgid ""
"# Syntax error\n"
"[x, y for x in seq1 for y in seq2]\n"
"# Correct\n"
"[(x, y) for x in seq1 for y in seq2]"
msgstr ""
#: ../../howto/functional.rst:439
msgid "Generators"
msgstr "ジェネレータ (generator)"
#: ../../howto/functional.rst:441
msgid ""
"Generators are a special class of functions that simplify the task of "
"writing iterators. Regular functions compute a value and return it, but "
"generators return an iterator that returns a stream of values."
msgstr ""
"ジェネレータは、イテレータを書く作業を簡単にする、特殊な関数です。標準的な関"
"数は値を計算して返しますが、ジェネレータが返すのは、一連の値を返すイテレータ"
"です。"
#: ../../howto/functional.rst:445
msgid ""
"You're doubtless familiar with how regular function calls work in Python or "
"C. When you call a function, it gets a private namespace where its local "
"variables are created. When the function reaches a ``return`` statement, "
"the local variables are destroyed and the value is returned to the caller. "
"A later call to the same function creates a new private namespace and a "
"fresh set of local variables. But, what if the local variables weren't "
"thrown away on exiting a function? What if you could later resume the "
"function where it left off? This is what generators provide; they can be "
"thought of as resumable functions."
msgstr ""
"Python や C の標準的な関数コールについては、よくご存じに違いありません。関数"
"を呼ぶと、ローカル変数を作るプライベートな名前空間ができますね。その関数が "
"``return`` 文まで来ると、ローカル変数が破壊されてから、返り値が呼び出し元に返"
"ります。次に同じ関数をもう一度呼ぶと、新しいプライベート名前空間に新規のロー"
"カル変数が作られるのです。しかし、関数を出るときにローカル変数を捨てなければ"
"どうなるでしょうか。その出ていったところから関数を続行できたとしたら、どうで"
"しょう。これこそジェネレータが提供する機能です; すなわち、ジェネレータは続行"
"できる関数と考えることができます。"
#: ../../howto/functional.rst:454
msgid "Here's the simplest example of a generator function:"
msgstr "ごく単純なジェネレータ関数の例がこちらにあります:"
#: ../../howto/functional.rst:460
msgid ""
"Any function containing a :keyword:`yield` keyword is a generator function; "
"this is detected by Python's :term:`bytecode` compiler which compiles the "
"function specially as a result."
msgstr ""
":keyword:`yield` キーワードを含む関数はすべてジェネレータ関数です; Python "
"の :term:`bytecode` コンパイラがこれを検出して、特別な方法でコンパイルしてく"
"れるのです。"
#: ../../howto/functional.rst:464
msgid ""
"When you call a generator function, it doesn't return a single value; "
"instead it returns a generator object that supports the iterator protocol. "
"On executing the ``yield`` expression, the generator outputs the value of "
"``i``, similar to a ``return`` statement. The big difference between "
"``yield`` and a ``return`` statement is that on reaching a ``yield`` the "
"generator's state of execution is suspended and local variables are "
"preserved. On the next call to the generator's :meth:`~generator.__next__` "
"method, the function will resume executing."
msgstr ""
"ジェネレータ関数は、呼ばれたときに一回だけ値を返すのではなく、イテレータ プロ"
"トコルに対応したオブジェクトを返します。上の例で ``yield`` を実行したとき、 "
"ジェネレータは ``return`` 文のようにして ``i`` の値を出力します。 ``yield`` "
"と ``return`` 文の大きな違いは、 ``yield`` に到達した段階でジェネレータの実行"
"状態が一時停止になって、ローカル変数が保存される点です。 次回そのジェネレータ"
"の :meth:`~generator.__next__` を呼ぶと、そこから関数が実行を再開します。"
#: ../../howto/functional.rst:473
msgid "Here's a sample usage of the ``generate_ints()`` generator:"
msgstr "上記 ``generate_ints()`` ジェネレータの使用例はこちらです:"
#: ../../howto/functional.rst:490
msgid ""
"You could equally write ``for i in generate_ints(5)``, or ``a, b, c = "
"generate_ints(3)``."
msgstr ""
"同じく ``for i in generate_ints(5)`` や ``a, b, c = generate_ints(3)`` といっ"
"た書き方もできます。"
#: ../../howto/functional.rst:493
msgid ""
"Inside a generator function, ``return value`` causes "
"``StopIteration(value)`` to be raised from the :meth:`~generator.__next__` "
"method. Once this happens, or the bottom of the function is reached, the "
"procession of values ends and the generator cannot yield any further values."
msgstr ""
"ジェネレータ関数の中では、``return value`` は :meth:`~generator.__next__` メ"
"ソッドから送出された ``StopIteration(value)`` を引き起こします。これが発生し"
"た場合や、関数の終わりに到達した場合は、値の生成が終了してジェネレーターがそ"
"れ以上の値を返さない。"
#: ../../howto/functional.rst:498
msgid ""
"You could achieve the effect of generators manually by writing your own "
"class and storing all the local variables of the generator as instance "
"variables. For example, returning a list of integers could be done by "
"setting ``self.count`` to 0, and having the :meth:`~iterator.__next__` "
"method increment ``self.count`` and return it. However, for a moderately "
"complicated generator, writing a corresponding class can be much messier."
msgstr ""
"自分でクラスを書いて、ジェネレータで言うところのローカル変数をインスタンス変"
"数として全部保管しておけば、同じ効果を得ることは可能です。たとえば整数のリス"
"トを返すのは、 ``self.count`` を 0 にして、 :meth:`~iterator.__next__` メソッ"
"ドが ``self.count`` をインクリメントして返すようにすればできます。しかしなが"
"ら、ある程度複雑なジェネレータになってくると、同じことをするクラスを書くのは"
"格段にややこしいことになります。"
#: ../../howto/functional.rst:506
msgid ""
"The test suite included with Python's library, :source:`Lib/test/"
"test_generators.py`, contains a number of more interesting examples. Here's "
"one generator that implements an in-order traversal of a tree using "
"generators recursively. ::"
msgstr ""
"Python のライブラリに含まれているテストスイート :source:`Lib/test/"
"test_generators.py` には、ほかにも興味深い例が数多く入っています。これは二分"
"木の通りがけ順 (in-order) 探索を再帰で実装したジェネレータです。 ::"
#: ../../howto/functional.rst:511
msgid ""
"# A recursive generator that generates Tree leaves in in-order.\n"
"def inorder(t):\n"
" if t:\n"
" for x in inorder(t.left):\n"
" yield x\n"
"\n"
" yield t.label\n"
"\n"
" for x in inorder(t.right):\n"
" yield x"
msgstr ""
#: ../../howto/functional.rst:522
msgid ""
"Two other examples in ``test_generators.py`` produce solutions for the N-"
"Queens problem (placing N queens on an NxN chess board so that no queen "
"threatens another) and the Knight's Tour (finding a route that takes a "
"knight to every square of an NxN chessboard without visiting any square "
"twice)."
msgstr ""
"ほかにも ``test_generators.py`` には、N-Queens 問題 (N×N コマのチェス盤に、互"
"いに攻撃できないような配置で N 個のクイーンを置く) やナイト・ツアー (N×N 盤の"
"全コマをナイトが一度ずつ通るような経路を探す) の解を出す例が入っています。"
#: ../../howto/functional.rst:530
msgid "Passing values into a generator"
msgstr "ジェネレータに値を渡す"
#: ../../howto/functional.rst:532
msgid ""
"In Python 2.4 and earlier, generators only produced output. Once a "
"generator's code was invoked to create an iterator, there was no way to pass "
"any new information into the function when its execution is resumed. You "
"could hack together this ability by making the generator look at a global "
"variable or by passing in some mutable object that callers then modify, but "
"these approaches are messy."
msgstr ""
"Python 2.4 までのジェネレータは出力することしかできませんでした。ジェネレータ"
"のコードを実行してイテレータを作ってしまったあとで、その関数を再開するときに"
"新しい情報を渡す手段はなかったのです。ジェネレータがグローバル変数を見るよう"
"にしたり、ミュータブルなオブジェクトを渡しておいて呼び出し元であとからそれを"
"変更したり、といったハックは可能でしたが、どれもゴチャゴチャしていますね。"
#: ../../howto/functional.rst:539
msgid ""
"In Python 2.5 there's a simple way to pass values into a generator. :keyword:"
"`yield` became an expression, returning a value that can be assigned to a "
"variable or otherwise operated on::"