Repository navigation
Expand file tree
/
Copy pathdatastructures.po
More file actions
801 lines (712 loc) · 42.1 KB
/
Copy pathdatastructures.po
File metadata and controls
801 lines (712 loc) · 42.1 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
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2020
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 16:06+0000\n"
"PO-Revision-Date: 2020-05-30 12:16+0000\n"
"Last-Translator: tomo, 2020\n"
"Language-Team: Japanese (https://www.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"
#: ../../tutorial/datastructures.rst:5
msgid "Data Structures"
msgstr "データ構造"
#: ../../tutorial/datastructures.rst:7
msgid ""
"This chapter describes some things you've learned about already in more "
"detail, and adds some new things as well."
msgstr ""
"この章では、すでに学んだことについてより詳しく説明するとともに、いくつか新し"
"いことを追加します。"
#: ../../tutorial/datastructures.rst:13
msgid "More on Lists"
msgstr "リスト型についてもう少し"
#: ../../tutorial/datastructures.rst:15
msgid ""
"The list data type has some more methods. Here are all of the methods of "
"list objects:"
msgstr ""
"リストデータ型には、他にもいくつかメソッドがあります。リストオブジェクトのす"
"べてのメソッドを以下に示します:"
#: ../../tutorial/datastructures.rst:22
msgid ""
"Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``."
msgstr "リストの末尾に要素を一つ追加します。``a[len(a):] = [x]`` と等価です。"
#: ../../tutorial/datastructures.rst:28
msgid ""
"Extend the list by appending all the items from the iterable. Equivalent to "
"``a[len(a):] = iterable``."
msgstr ""
"イテラブルのすべての要素を対象のリストに追加し、リストを拡張します。"
"``a[len(a):] = iterable`` と等価です。"
#: ../../tutorial/datastructures.rst:35
msgid ""
"Insert an item at a given position. The first argument is the index of the "
"element before which to insert, so ``a.insert(0, x)`` inserts at the front "
"of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
msgstr ""
"指定した位置に要素を挿入します。第 1 引数は、リストのインデクスで、そのインデ"
"クスを持つ要素の直前に挿入が行われます。従って、 ``a.insert(0, x)`` はリスト"
"の先頭に挿入を行います。また ``a.insert(len(a), x)`` は ``a.append(x)`` と等"
"価です。"
#: ../../tutorial/datastructures.rst:43
msgid ""
"Remove the first item from the list whose value is equal to *x*. It raises "
"a :exc:`ValueError` if there is no such item."
msgstr ""
"リスト中で *x* と等しい値を持つ最初の要素を削除します。該当する要素がなけれ"
"ば :exc:`ValueError` が送出されます。"
#: ../../tutorial/datastructures.rst:50
msgid ""
"Remove the item at the given position in the list, and return it. If no "
"index is specified, ``a.pop()`` removes and returns the last item in the "
"list. (The square brackets around the *i* in the method signature denote "
"that the parameter is optional, not that you should type square brackets at "
"that position. You will see this notation frequently in the Python Library "
"Reference.)"
msgstr ""
"リスト中の指定された位置にある要素をリストから削除して、その要素を返します。"
"インデクスが指定されなければ、 ``a.pop()`` はリストの末尾の要素を削除して返し"
"ます。この場合も要素は削除されます。 (メソッドの用法 (signature) で *i* の両"
"側にある角括弧は、この引数がオプションであることを表しているだけなので、角括"
"弧を入力する必要はありません。この表記法は Python Library Reference の中で頻"
"繁に見ることになるでしょう。)"
#: ../../tutorial/datastructures.rst:60
msgid "Remove all items from the list. Equivalent to ``del a[:]``."
msgstr "リスト中の全ての要素を削除します。``del a[:]`` と等価です。"
#: ../../tutorial/datastructures.rst:66
msgid ""
"Return zero-based index in the list of the first item whose value is equal "
"to *x*. Raises a :exc:`ValueError` if there is no such item."
msgstr ""
"リスト中で *x* と等しい値を持つ最初の要素の位置をゼロから始まる添字で返しま"
"す。 該当する要素がなければ :exc:`ValueError` が送出されます。"
#: ../../tutorial/datastructures.rst:69
msgid ""
"The optional arguments *start* and *end* are interpreted as in the slice "
"notation and are used to limit the search to a particular subsequence of the "
"list. The returned index is computed relative to the beginning of the full "
"sequence rather than the *start* argument."
msgstr ""
"任意の引数である *start* と *end* はスライス記法として解釈され、リストの探索"
"範囲を指定できます。返される添字は、*start* 引数からの相対位置ではなく、リス"
"ト全体の先頭からの位置になります。"
#: ../../tutorial/datastructures.rst:78
msgid "Return the number of times *x* appears in the list."
msgstr "リストでの *x* の出現回数を返します。"
#: ../../tutorial/datastructures.rst:84
msgid ""
"Sort the items of the list in place (the arguments can be used for sort "
"customization, see :func:`sorted` for their explanation)."
msgstr ""
"リストの項目を、インプレース演算 (in place、元のデータを演算結果で置き換える"
"やりかた) でソートします。引数はソート方法のカスタマイズに使えます。 :func:"
"`sorted` の説明を参照してください。"
#: ../../tutorial/datastructures.rst:91
msgid "Reverse the elements of the list in place."
msgstr "リストの要素を、インプレース演算で逆順にします。"
#: ../../tutorial/datastructures.rst:97
msgid "Return a shallow copy of the list. Equivalent to ``a[:]``."
msgstr "リストの浅い (shallow) コピーを返します。``a[:]`` と等価です。"
#: ../../tutorial/datastructures.rst:100
msgid "An example that uses most of the list methods::"
msgstr "以下にリストのメソッドをほぼ全て使った例を示します::"
#: ../../tutorial/datastructures.rst:123
msgid ""
"You might have noticed that methods like ``insert``, ``remove`` or ``sort`` "
"that only modify the list have no return value printed -- they return the "
"default ``None``. [1]_ This is a design principle for all mutable data "
"structures in Python."
msgstr ""
"``insert``, ``remove``, ``sort`` などのリストを操作するメソッドの戻り値が表示"
"されていないことに気が付いたかもしれません。これらのメソッドは ``None`` を返"
"しています。[1]_ これは Python の変更可能なデータ構造全てについての設計上の原"
"則となっています。"
#: ../../tutorial/datastructures.rst:128
msgid ""
"Another thing you might notice is that not all data can be sorted or "
"compared. For instance, ``[None, 'hello', 10]`` doesn't sort because "
"integers can't be compared to strings and *None* can't be compared to other "
"types. Also, there are some types that don't have a defined ordering "
"relation. For example, ``3+4j < 5+7j`` isn't a valid comparison."
msgstr ""
"気がつくかもしれないもう一つのことは、すべてのデータをソートまたは比較できる"
"わけではないということです。例えば、整数は文字列と比較できず、 *None* は他の"
"型と比較できないため、 ``[None, 'hello', 10]`` はソートされません。また、定義"
"された順序関係を持たないタイプもあります。たとえば、 ``3+4j < 5+7j`` は有効な"
"比較ではありません。"
#: ../../tutorial/datastructures.rst:139
msgid "Using Lists as Stacks"
msgstr "リストをスタックとして使う"
#: ../../tutorial/datastructures.rst:144
msgid ""
"The list methods make it very easy to use a list as a stack, where the last "
"element added is the first element retrieved (\"last-in, first-out\"). To "
"add an item to the top of the stack, use :meth:`append`. To retrieve an "
"item from the top of the stack, use :meth:`pop` without an explicit index. "
"For example::"
msgstr ""
"リスト型のメソッドのおかげで、簡単にリストをスタックとして使えます。スタック"
"では、最後に追加された要素が最初に取り出されます (\"last-in, first-out\")。ス"
"タックの一番上に要素を追加するには :meth:`append` を使います。スタックの一番"
"上から要素を取り出すには :meth:`pop` をインデクスを指定せずに使います。例えば"
"以下のようにします::"
#: ../../tutorial/datastructures.rst:169
msgid "Using Lists as Queues"
msgstr "リストをキューとして使う"
#: ../../tutorial/datastructures.rst:173
msgid ""
"It is also possible to use a list as a queue, where the first element added "
"is the first element retrieved (\"first-in, first-out\"); however, lists are "
"not efficient for this purpose. While appends and pops from the end of list "
"are fast, doing inserts or pops from the beginning of a list is slow "
"(because all of the other elements have to be shifted by one)."
msgstr ""
"リストをキュー (queue) として使うことも可能です。この場合、最初に追加した要素"
"を最初に取り出します (\"first-in, first-out\")。しかし、リストでは効率的にこ"
"の目的を達成することが出来ません。追加（append）や取り出し（pop）をリストの末"
"尾に対して行うと速いのですが、挿入（insert）や取り出し（pop）をリストの先頭に"
"対して行うと遅くなってしまいます（他の要素をひとつずつずらす必要があるからで"
"す）。"
#: ../../tutorial/datastructures.rst:179
msgid ""
"To implement a queue, use :class:`collections.deque` which was designed to "
"have fast appends and pops from both ends. For example::"
msgstr ""
"キューの実装には、 :class:`collections.deque` を使うと良いでしょう。このクラ"
"スは良く設計されていて、高速な追加（append）と取り出し（pop）を両端に対して実"
"現しています。例えば以下のようにします::"
#: ../../tutorial/datastructures.rst:197
msgid "List Comprehensions"
msgstr "リストの内包表記"
#: ../../tutorial/datastructures.rst:199
msgid ""
"List comprehensions provide a concise way to create lists. Common "
"applications are to make new lists where each element is the result of some "
"operations applied to each member of another sequence or iterable, or to "
"create a subsequence of those elements that satisfy a certain condition."
msgstr ""
"リスト内包表記はリストを生成する簡潔な手段を提供しています。主な利用場面は、"
"あるシーケンスや iterable (イテレート可能オブジェクト) のそれぞれの要素に対し"
"てある操作を行った結果を要素にしたリストを作ったり、ある条件を満たす要素だけ"
"からなる部分シーケンスを作成することです。"
#: ../../tutorial/datastructures.rst:204
msgid "For example, assume we want to create a list of squares, like::"
msgstr "例えば、次のような平方のリストを作りたいとします::"
#: ../../tutorial/datastructures.rst:213
msgid ""
"Note that this creates (or overwrites) a variable named ``x`` that still "
"exists after the loop completes. We can calculate the list of squares "
"without any side effects using::"
msgstr ""
"これはループが終了した後にも存在する ``x`` という名前の変数を作る (または上書"
"きする) ことに注意してください。以下のようにして平方のリストをいかなる副作用"
"もなく計算することができます::"
#: ../../tutorial/datastructures.rst:219
msgid "or, equivalently::"
msgstr "もしくは、以下でも同じです::"
#: ../../tutorial/datastructures.rst:223
msgid "which is more concise and readable."
msgstr "これはより簡潔で読みやすいです。"
#: ../../tutorial/datastructures.rst:225
msgid ""
"A list comprehension consists of brackets containing an expression followed "
"by a :keyword:`!for` clause, then zero or more :keyword:`!for` or :keyword:`!"
"if` clauses. The result will be a new list resulting from evaluating the "
"expression in the context of the :keyword:`!for` and :keyword:`!if` clauses "
"which follow it. For example, this listcomp combines the elements of two "
"lists if they are not equal::"
msgstr ""
"リスト内包表記は、括弧の中の 式、 :keyword:`!for` 句、そして0個以上の :"
"keyword:`!for` か :keyword:`!if` 句で構成されます。\n"
"リスト内包表記の実行結果は、 :keyword:`!for` と :keyword:`!if` 句のコンテキス"
"ト中で式を評価した結果からなる新しいリストです。\n"
"例えば、次のリスト内包表記は2つのリストの要素から、違うもの同士をペアにしま"
"す。"
#: ../../tutorial/datastructures.rst:235
msgid "and it's equivalent to::"
msgstr "これは次のコードと等価です::"
#: ../../tutorial/datastructures.rst:246
msgid ""
"Note how the order of the :keyword:`for` and :keyword:`if` statements is the "
"same in both these snippets."
msgstr ""
":keyword:`for` と :keyword:`if` 文が両方のコードで同じ順序になっていることに"
"注目してください。"
#: ../../tutorial/datastructures.rst:249
msgid ""
"If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), "
"it must be parenthesized. ::"
msgstr ""
"式がタプルの場合 (例: 上の例で式が ``(x, y)`` の場合) は、タプルに円括弧が必"
"要です。 ::"
#: ../../tutorial/datastructures.rst:280
msgid ""
"List comprehensions can contain complex expressions and nested functions::"
msgstr "リスト内包表記の式には、複雑な式や関数呼び出しのネストができます::"
#: ../../tutorial/datastructures.rst:287
msgid "Nested List Comprehensions"
msgstr "ネストしたリストの内包表記"
#: ../../tutorial/datastructures.rst:289
msgid ""
"The initial expression in a list comprehension can be any arbitrary "
"expression, including another list comprehension."
msgstr ""
"リスト内包表記中の最初の式は任意の式なので、そこに他のリスト内包表記を書くこ"
"ともできます。"
#: ../../tutorial/datastructures.rst:292
msgid ""
"Consider the following example of a 3x4 matrix implemented as a list of 3 "
"lists of length 4::"
msgstr "次の、長さ4のリスト3つからなる、3x4 の matrix について考えます::"
#: ../../tutorial/datastructures.rst:301
msgid "The following list comprehension will transpose rows and columns::"
msgstr "次のリスト内包表記は、matrix の行と列を入れ替えます::"
#: ../../tutorial/datastructures.rst:306
msgid ""
"As we saw in the previous section, the nested listcomp is evaluated in the "
"context of the :keyword:`for` that follows it, so this example is equivalent "
"to::"
msgstr ""
"前の節で見たように、ネストしたリスト内包表記は、続く :keyword:`for` のコンテ"
"キストの中で評価されます。なので、この例は次のコードと等価です::"
#: ../../tutorial/datastructures.rst:317
msgid "which, in turn, is the same as::"
msgstr "これをもう一度変換すると、次のコードと等価になります::"
#: ../../tutorial/datastructures.rst:330
msgid ""
"In the real world, you should prefer built-in functions to complex flow "
"statements. The :func:`zip` function would do a great job for this use case::"
msgstr ""
"実際には複雑な流れの式よりも組み込み関数を使う方が良いです。この場合 :func:"
"`zip` 関数が良い仕事をしてくれるでしょう::"
#: ../../tutorial/datastructures.rst:336
msgid ""
"See :ref:`tut-unpacking-arguments` for details on the asterisk in this line."
msgstr ""
"この行にあるアスタリスクの詳細については :ref:`tut-unpacking-arguments` を参"
"照してください。"
#: ../../tutorial/datastructures.rst:341
msgid "The :keyword:`!del` statement"
msgstr ":keyword:`!del` 文"
#: ../../tutorial/datastructures.rst:343
msgid ""
"There is a way to remove an item from a list given its index instead of its "
"value: the :keyword:`del` statement. This differs from the :meth:`pop` "
"method which returns a value. The :keyword:`!del` statement can also be "
"used to remove slices from a list or clear the entire list (which we did "
"earlier by assignment of an empty list to the slice). For example::"
msgstr ""
"リストから要素を削除する際、値を指定する代わりにインデックスを指定する方法が"
"あります。それが :keyword:`del` 文です。これは :meth:`pop` メソッドと違い、値"
"を返しません。 :keyword:`!del` 文はリストからスライスを除去したり、リスト全体"
"を削除することもできます(以前はスライスに空のリストを代入して行っていまし"
"た)。例えば以下のようにします::"
#: ../../tutorial/datastructures.rst:360
msgid ":keyword:`del` can also be used to delete entire variables::"
msgstr ":keyword:`del` は変数全体の削除にも使えます::"
#: ../../tutorial/datastructures.rst:364
msgid ""
"Referencing the name ``a`` hereafter is an error (at least until another "
"value is assigned to it). We'll find other uses for :keyword:`del` later."
msgstr ""
"この文の後で名前 ``a`` を参照すると、(別の値を ``a`` に代入するまで) エラーに"
"なります。 :keyword:`del` の別の用途についてはまた後で取り上げます。"
#: ../../tutorial/datastructures.rst:371
msgid "Tuples and Sequences"
msgstr "タプルとシーケンス"
#: ../../tutorial/datastructures.rst:373
msgid ""
"We saw that lists and strings have many common properties, such as indexing "
"and slicing operations. They are two examples of *sequence* data types "
"(see :ref:`typesseq`). Since Python is an evolving language, other sequence "
"data types may be added. There is also another standard sequence data type: "
"the *tuple*."
msgstr ""
"リストや文字列には、インデクスやスライスを使った演算のように、数多くの共通の"
"性質があることを見てきました。これらは *シーケンス (sequence)* データ型 (:"
"ref:`typesseq` を参照) の二つの例です。 Python はまだ進歩の過程にある言語なの"
"で、他のシーケンスデータ型が追加されるかもしれません。標準のシーケンス型はも"
"う一つあります: *タプル (tuple)* 型です。"
#: ../../tutorial/datastructures.rst:379
msgid ""
"A tuple consists of a number of values separated by commas, for instance::"
msgstr ""
"タプルはコンマで区切られたいくつかの値からなります。例えば以下のように書きま"
"す::"
#: ../../tutorial/datastructures.rst:401
msgid ""
"As you see, on output tuples are always enclosed in parentheses, so that "
"nested tuples are interpreted correctly; they may be input with or without "
"surrounding parentheses, although often parentheses are necessary anyway (if "
"the tuple is part of a larger expression). It is not possible to assign to "
"the individual items of a tuple, however it is possible to create tuples "
"which contain mutable objects, such as lists."
msgstr ""
"ご覧のとおり、タプルの表示には常に丸括弧がついていて、タプルのネストが正しく"
"解釈されるようになっています。タプルを書くときは必ずしも丸括弧で囲まなくても"
"いいですが、(タプルが大きな式の一部だった場合は) 丸括弧が必要な場合もありま"
"す。タプルの要素を代入することはできません。しかし、タプルにリストのような変"
"更可能型を含めることはできます。"
#: ../../tutorial/datastructures.rst:408
msgid ""
"Though tuples may seem similar to lists, they are often used in different "
"situations and for different purposes. Tuples are :term:`immutable`, and "
"usually contain a heterogeneous sequence of elements that are accessed via "
"unpacking (see later in this section) or indexing (or even by attribute in "
"the case of :func:`namedtuples <collections.namedtuple>`). Lists are :term:"
"`mutable`, and their elements are usually homogeneous and are accessed by "
"iterating over the list."
msgstr ""
"タプルはリストと似ていますが、たいてい異なる場面と異なる目的で利用されます。"
"タプルは :term:`不変 <immutable>` で、複数の型の要素からなることもあり、要素"
"はアンパック(この節の後半に出てきます)操作やインデックス (あるいは :func:"
"`namedtuples <collections.namedtuple>` の場合は属性)でアクセスすることが多い"
"です。一方、リストは :term:`可変 <mutable>` で、要素はたいてい同じ型のオブ"
"ジェクトであり、たいていイテレートによってアクセスします。"
#: ../../tutorial/datastructures.rst:416
msgid ""
"A special problem is the construction of tuples containing 0 or 1 items: the "
"syntax has some extra quirks to accommodate these. Empty tuples are "
"constructed by an empty pair of parentheses; a tuple with one item is "
"constructed by following a value with a comma (it is not sufficient to "
"enclose a single value in parentheses). Ugly, but effective. For example::"
msgstr ""
"問題は 0 個または 1 個の項目からなるタプルの構築です。これらの操作を行うた"
"め、構文には特別な細工がされています。空のタプルは空の丸括弧ペアで構築できま"
"す。一つの要素を持つタプルは、値の後ろにコンマを続ける (単一の値を丸括弧で囲"
"むだけでは不十分です) ことで構築できます。美しくはないけれども、効果的です。"
"例えば以下のようにします::"
#: ../../tutorial/datastructures.rst:431
msgid ""
"The statement ``t = 12345, 54321, 'hello!'`` is an example of *tuple "
"packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
"together in a tuple. The reverse operation is also possible::"
msgstr ""
"文 ``t = 12345, 54321, 'hello!'`` は *タプルのパック (tuple packing)* の例で"
"す。値 ``12345``, ``54321``, ``'hello!'`` が一つのタプルにパックされます。逆"
"の演算も可能です::"
#: ../../tutorial/datastructures.rst:437
msgid ""
"This is called, appropriately enough, *sequence unpacking* and works for any "
"sequence on the right-hand side. Sequence unpacking requires that there are "
"as many variables on the left side of the equals sign as there are elements "
"in the sequence. Note that multiple assignment is really just a combination "
"of tuple packing and sequence unpacking."
msgstr ""
"この操作は、*シーケンスのアンパック (sequence unpacking)* とでも呼ぶべきもの"
"で、右辺には全てのシーケンス型を使うことができます。シーケンスのアンパックで"
"は、等号の左辺に列挙されている変数が、右辺のシーケンスの長さと同じ数だけある"
"ことが要求されます。複数同時の代入が実はタプルのパックとシーケンスのアンパッ"
"クを組み合わせたものに過ぎないことに注意してください。"
#: ../../tutorial/datastructures.rst:447
msgid "Sets"
msgstr "集合型"
#: ../../tutorial/datastructures.rst:449
msgid ""
"Python also includes a data type for *sets*. A set is an unordered "
"collection with no duplicate elements. Basic uses include membership "
"testing and eliminating duplicate entries. Set objects also support "
"mathematical operations like union, intersection, difference, and symmetric "
"difference."
msgstr ""
"Python には、 *集合 (set)* を扱うためのデータ型もあります。集合とは、重複する"
"要素をもたない、順序づけられていない要素の集まりです。 Set オブジェクトは、"
"和 (union)、積 (intersection)、差 (difference)、対称差 (symmetric difference)"
"といった数学的な演算もサポートしています。"
#: ../../tutorial/datastructures.rst:454
msgid ""
"Curly braces or the :func:`set` function can be used to create sets. Note: "
"to create an empty set you have to use ``set()``, not ``{}``; the latter "
"creates an empty dictionary, a data structure that we discuss in the next "
"section."
msgstr ""
"中括弧、または :func:`set` 関数は set を生成するために使用することができま"
"す。注: 空集合を作成するためには ``set()`` を使用しなければなりません (``{}"
"`` ではなく)。後者は空の辞書を作成します。辞書は次のセクションで議論するデー"
"タ構造です。"
#: ../../tutorial/datastructures.rst:458
msgid "Here is a brief demonstration::"
msgstr "簡単なデモンストレーションを示します::"
#: ../../tutorial/datastructures.rst:483
msgid ""
"Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
"are also supported::"
msgstr ""
":ref:`リスト内包 <tut-listcomps>` と同様に、 set 内包もサポートされています::"
#: ../../tutorial/datastructures.rst:494
msgid "Dictionaries"
msgstr "辞書型 (dictionary)"
#: ../../tutorial/datastructures.rst:496
msgid ""
"Another useful data type built into Python is the *dictionary* (see :ref:"
"`typesmapping`). Dictionaries are sometimes found in other languages as "
"\"associative memories\" or \"associative arrays\". Unlike sequences, which "
"are indexed by a range of numbers, dictionaries are indexed by *keys*, which "
"can be any immutable type; strings and numbers can always be keys. Tuples "
"can be used as keys if they contain only strings, numbers, or tuples; if a "
"tuple contains any mutable object either directly or indirectly, it cannot "
"be used as a key. You can't use lists as keys, since lists can be modified "
"in place using index assignments, slice assignments, or methods like :meth:"
"`append` and :meth:`extend`."
msgstr ""
"もう一つ、有用な型が Python に組み込まれています。それは *辞書 (dictionary)* "
"(:ref:`typesmapping` を参照)です。辞書は他の言語にも \"連想記憶 (associated "
"memory)\" や \"連想配列 (associative array)\" という名前で存在することがあり"
"ます。ある範囲の数でインデクス化されているシーケンスと異なり、辞書は *キー "
"(key)* でインデクス化されています。このキーは何らかの変更不能な型になります。"
"文字列、数値は常にキーにすることができます。タプルは、文字列、数値、その他の"
"タプルのみを含む場合はキーにすることができます。直接、あるいは間接的に変更可"
"能なオブジェクトを含むタプルはキーにできません。リストをキーとして使うことは"
"できません。これは、リストにスライスやインデクス指定の代入を行ったり、 :meth:"
"`append` や :meth:`extend` のようなメソッドを使うと、インプレースで変更するこ"
"とができるためです。"
#: ../../tutorial/datastructures.rst:507
msgid ""
"It is best to think of a dictionary as a set of *key: value* pairs, with the "
"requirement that the keys are unique (within one dictionary). A pair of "
"braces creates an empty dictionary: ``{}``. Placing a comma-separated list "
"of key:value pairs within the braces adds initial key:value pairs to the "
"dictionary; this is also the way dictionaries are written on output."
msgstr ""
"辞書は *キー(key): 値(value)* のペアの集合であり、キーが (辞書の中で)一意でな"
"ければならない、と考えるとよいでしょう。波括弧 (brace) のペア: ``{}`` は空の"
"辞書を生成します。カンマで区切られた key: value のペアを波括弧ペアの間に入れ"
"ると、辞書の初期値となる key: value が追加されます; この表現方法は出力時に辞"
"書が書き出されるのと同じ方法です。"
#: ../../tutorial/datastructures.rst:513
msgid ""
"The main operations on a dictionary are storing a value with some key and "
"extracting the value given the key. It is also possible to delete a key:"
"value pair with ``del``. If you store using a key that is already in use, "
"the old value associated with that key is forgotten. It is an error to "
"extract a value using a non-existent key."
msgstr ""
"辞書での主な操作は、ある値を何らかのキーを付けて記憶することと、キーを指定し"
"て値を取り出すことです。 ``del`` で key: value のペアを削除することもできま"
"す。すでに使われているキーを使って値を記憶すると、以前そのキーに関連づけられ"
"ていた値は忘れ去られてしまいます。存在しないキーを使って値を取り出そうとする"
"とエラーになります。"
#: ../../tutorial/datastructures.rst:519
msgid ""
"Performing ``list(d)`` on a dictionary returns a list of all the keys used "
"in the dictionary, in insertion order (if you want it sorted, just use "
"``sorted(d)`` instead). To check whether a single key is in the dictionary, "
"use the :keyword:`in` keyword."
msgstr ""
"辞書オブジェクトに対し ``list(d)`` を実行すると、辞書で使われている全てのキー"
"からなるリストをキーが挿入された順番で返します (ソートされたリストが欲しい場"
"合は、代わりに ``sorted(d)`` を使ってください)。ある単一のキーが辞書にあるか"
"どうか調べるには、 :keyword:`in` キーワードを使います。"
#: ../../tutorial/datastructures.rst:524
msgid "Here is a small example using a dictionary::"
msgstr "以下に、辞書を使った簡単な例を示します::"
#: ../../tutorial/datastructures.rst:545
msgid ""
"The :func:`dict` constructor builds dictionaries directly from sequences of "
"key-value pairs::"
msgstr ""
":func:`dict` コンストラクタは、キーと値のペアのタプルを含むリストから辞書を生"
"成します::"
#: ../../tutorial/datastructures.rst:551
msgid ""
"In addition, dict comprehensions can be used to create dictionaries from "
"arbitrary key and value expressions::"
msgstr "さらに、辞書内包表現を使って、任意のキーと値のペアから辞書を作れます::"
#: ../../tutorial/datastructures.rst:557
msgid ""
"When the keys are simple strings, it is sometimes easier to specify pairs "
"using keyword arguments::"
msgstr ""
"キーが単純な文字列の場合、キーワード引数を使って定義する方が単純な場合もあり"
"ます::"
#: ../../tutorial/datastructures.rst:567
msgid "Looping Techniques"
msgstr "ループのテクニック"
#: ../../tutorial/datastructures.rst:569
msgid ""
"When looping through dictionaries, the key and corresponding value can be "
"retrieved at the same time using the :meth:`items` method. ::"
msgstr ""
"辞書に対してループを行う際、 :meth:`items` メソッドを使うと、キーとそれに対応"
"する値を同時に取り出せます。 ::"
#: ../../tutorial/datastructures.rst:579
msgid ""
"When looping through a sequence, the position index and corresponding value "
"can be retrieved at the same time using the :func:`enumerate` function. ::"
msgstr ""
"シーケンスにわたるループを行う際、 :func:`enumerate` 関数を使うと、要素のイン"
"デックスと要素を同時に取り出すことができます。 ::"
#: ../../tutorial/datastructures.rst:589
msgid ""
"To loop over two or more sequences at the same time, the entries can be "
"paired with the :func:`zip` function. ::"
msgstr ""
"二つまたはそれ以上のシーケンス型を同時にループするために、関数 :func:`zip` を"
"使って各要素をひと組みにすることができます。 ::"
#: ../../tutorial/datastructures.rst:601
msgid ""
"To loop over a sequence in reverse, first specify the sequence in a forward "
"direction and then call the :func:`reversed` function. ::"
msgstr ""
"シーケンスを逆方向に渡ってループするには、まずシーケンスの範囲を順方向に指定"
"し、次いで関数 :func:`reversed` を呼び出します。 ::"
#: ../../tutorial/datastructures.rst:613
msgid ""
"To loop over a sequence in sorted order, use the :func:`sorted` function "
"which returns a new sorted list while leaving the source unaltered. ::"
msgstr ""
"シーケンスをソートされた順序でループするには、 :func:`sorted` 関数を使いま"
"す。この関数は元の配列を変更せず、ソート済みの新たな配列を返します。 ::"
#: ../../tutorial/datastructures.rst:625
msgid ""
"It is sometimes tempting to change a list while you are looping over it; "
"however, it is often simpler and safer to create a new list instead. ::"
msgstr ""
"ときどきループ内でリストを変更したい誘惑に駆られるでしょうが、代わりに新しい"
"リストを作ってしまうほうがより簡単で安全なことが、ままあります ::"
#: ../../tutorial/datastructures.rst:642
msgid "More on Conditions"
msgstr "条件についてもう少し"
#: ../../tutorial/datastructures.rst:644
msgid ""
"The conditions used in ``while`` and ``if`` statements can contain any "
"operators, not just comparisons."
msgstr ""
"``while`` や ``if`` 文で使った条件 (condition) には、値の比較だけでなく、他の"
"演算子も使うことができます。"
#: ../../tutorial/datastructures.rst:647
msgid ""
"The comparison operators ``in`` and ``not in`` check whether a value occurs "
"(does not occur) in a sequence. The operators ``is`` and ``is not`` compare "
"whether two objects are really the same object; this only matters for "
"mutable objects like lists. All comparison operators have the same "
"priority, which is lower than that of all numerical operators."
msgstr ""
"比較演算子 ``in`` および ``not in`` は、ある値があるシーケンス中に存在するか "
"(または存在しないか) どうかを調べます。演算子 ``is`` および ``is not`` は、二"
"つのオブジェクトが実際に同じオブジェクトであるかどうかを調べます。この比較"
"は、リストのような変更可能なオブジェクトにだけ意味があります。全ての比較演算"
"子は同じ優先順位を持っており、ともに数値演算子よりも低い優先順位となります。"
"(訳注: ``is`` は、 ``is None`` のように、シングルトンの変更不能オブジェクトと"
"の比較に用いる場合もあります。(「変更可能なオブジェクトにだけ意味があります」"
"の部分を削除することを Doc-SIG に提案中。))"
#: ../../tutorial/datastructures.rst:653
msgid ""
"Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` "
"is less than ``b`` and moreover ``b`` equals ``c``."
msgstr ""
"比較は連結させることができます。例えば、 ``a < b == c`` は、 ``a`` が ``b`` "
"より小さく、かつ ``b`` と ``c`` が等しいかどうかをテストします。"
#: ../../tutorial/datastructures.rst:656
msgid ""
"Comparisons may be combined using the Boolean operators ``and`` and ``or``, "
"and the outcome of a comparison (or of any other Boolean expression) may be "
"negated with ``not``. These have lower priorities than comparison "
"operators; between them, ``not`` has the highest priority and ``or`` the "
"lowest, so that ``A and not B or C`` is equivalent to ``(A and (not B)) or "
"C``. As always, parentheses can be used to express the desired composition."
msgstr ""
"ブール演算子 ``and`` や ``or`` で比較演算を組み合わせることができます。そし"
"て、比較演算 (あるいは何らかのブール式) の結果の否定は ``not`` でとれます。こ"
"れらの演算子は全て、比較演算子よりも低い優先順位になっています。 ``A and not "
"B or C`` と ``(A and (not B)) or C`` が等価になるように、ブール演算子の中"
"で、 ``not`` の優先順位が最も高く、 ``or`` が最も低くなっています。もちろん、"
"丸括弧を使えば望みの組み合わせを表現できます。"
#: ../../tutorial/datastructures.rst:663
msgid ""
"The Boolean operators ``and`` and ``or`` are so-called *short-circuit* "
"operators: their arguments are evaluated from left to right, and evaluation "
"stops as soon as the outcome is determined. For example, if ``A`` and ``C`` "
"are true but ``B`` is false, ``A and B and C`` does not evaluate the "
"expression ``C``. When used as a general value and not as a Boolean, the "
"return value of a short-circuit operator is the last evaluated argument."
msgstr ""
"ブール演算子 ``and`` と ``or`` は、いわゆる *短絡 (short-circuit)* 演算子で"
"す。これらの演算子の引数は左から右へと順に評価され、結果が確定した時点で評価"
"を止めます。例えば、 ``A`` と ``C`` は真で ``B`` が偽のとき、 ``A and B and "
"C`` は式 ``C`` を評価しません。一般に、短絡演算子の戻り値をブール値ではなくて"
"一般的な値として用いると、値は最後に評価された引数になります。"
#: ../../tutorial/datastructures.rst:670
msgid ""
"It is possible to assign the result of a comparison or other Boolean "
"expression to a variable. For example, ::"
msgstr "比較や他のブール式の結果を変数に代入することもできます。例えば、 ::"
#: ../../tutorial/datastructures.rst:678
msgid ""
"Note that in Python, unlike C, assignment inside expressions must be done "
"explicitly with the :ref:`walrus operator <why-can-t-i-use-an-assignment-in-"
"an-expression>` ``:=``. This avoids a common class of problems encountered "
"in C programs: typing ``=`` in an expression when ``==`` was intended."
msgstr ""
"Pythonでは、Cとは異なり、式の中での代入は :ref:`セイウチ演算子 <why-can-t-i-"
"use-an-assignment-in-an-expression>` ``:=`` を使用して明示的に行う必要がある"
"ことに注意してください。これにより、 ``==`` が意図されていたところに ``=`` を"
"入力してしまうという、Cプログラムで発生する一般的なクラスの問題を回避できま"
"す。"
#: ../../tutorial/datastructures.rst:688
msgid "Comparing Sequences and Other Types"
msgstr "シーケンスとその他の型の比較"
#: ../../tutorial/datastructures.rst:689
msgid ""
"Sequence objects typically may be compared to other objects with the same "
"sequence type. The comparison uses *lexicographical* ordering: first the "
"first two items are compared, and if they differ this determines the outcome "
"of the comparison; if they are equal, the next two items are compared, and "
"so on, until either sequence is exhausted. If two items to be compared are "
"themselves sequences of the same type, the lexicographical comparison is "
"carried out recursively. If all items of two sequences compare equal, the "
"sequences are considered equal. If one sequence is an initial sub-sequence "
"of the other, the shorter sequence is the smaller (lesser) one. "
"Lexicographical ordering for strings uses the Unicode code point number to "
"order individual characters. Some examples of comparisons between sequences "
"of the same type::"
msgstr ""
"概して、シーケンスオブジェクトは、同じシーケンス型の他のオブジェクトと比較で"
"きます。比較には *辞書的な (lexicographical)* 順序が用いられます。まず、最初"
"の二つの要素を比較し、その値が等しくなければその時点で比較結果が決まります。"
"等しければ次の二つの要素を比較し、以降シーケンスの要素が尽きるまで続けます。"
"比較しようとする二つの要素がいずれも同じシーケンス型であれば、そのシーケンス"
"間での辞書比較を再帰的に行います。二つのシーケンスの全ての要素の比較結果が等"
"しくなれば、シーケンスは等しいとみなされます。片方のシーケンスがもう一方の先"
"頭部分にあたる部分シーケンスならば、短い方のシーケンスが小さいシーケンスとみ"
"なされます。文字列に対する辞書的な順序づけには、個々の文字ごとに ASCII 順序を"
"用います。以下に、同じ型のオブジェクトを持つシーケンス間での比較を行った例を"
"示します:: "
#: ../../tutorial/datastructures.rst:709
msgid ""
"Note that comparing objects of different types with ``<`` or ``>`` is legal "
"provided that the objects have appropriate comparison methods. For example, "
"mixed numeric types are compared according to their numeric value, so 0 "
"equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, "
"the interpreter will raise a :exc:`TypeError` exception."
msgstr ""
"違う型のオブジェクト同士を ``<`` や ``>`` で比較することも、それらのオブジェ"
"クトが適切な比較メソッドを提供しているのであれば許可されます。例えば、異なる"
"数値型同士の比較では、その数値によって比較が行われます。例えば、 0 と 0.0 は"
"等価です。一方、適切な比較順序がない場合は、インタープリターは :exc:"
"`TypeError` 例外を発生させます。"
#: ../../tutorial/datastructures.rst:717
msgid "Footnotes"
msgstr "脚注"
#: ../../tutorial/datastructures.rst:718
msgid ""
"Other languages may return the mutated object, which allows method chaining, "
"such as ``d->insert(\"a\")->remove(\"b\")->sort();``."
msgstr ""
"他の言語では変更可能なオブジェクトを返して、``d->insert(\"a\")-"
">remove(\"b\")->sort();`` のようなメソッドチェインを許している場合もありま"
"す。"