FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
python-docs-zh-tw/tutorial/introduction.po at weblate · python/python-docs-zh-tw · GitHub
python
python-docs-zh-tw
Repository navigation
Code
Issues
33
(33)
Pull requests
12
(12)
Discussions
Actions
Wiki
Security and quality
Insights
Expand file tree
Breadcrumbs
python-docs-zh-tw
/
tutorial
/
introduction.po
Copy path
More file actions
More file actions
Latest commit
History
History
History
690 lines (616 loc) · 27.9 KB
Breadcrumbs
python-docs-zh-tw
/
tutorial
/
introduction.po
Copy path
File metadata and controls
690 lines (616 loc) · 27.9 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
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
#
SOME DESCRIPTIVE TITLE.
#
Copyright (C) 2001-2022, Python Software Foundation
#
This file is distributed under the same license as the Python package.
#
#
Translators:
#
Ching-Hao Liu <chinghao.liu@gmail.com>, 2018
#
Liang-Bo Wang <me@liang2.tw>, 2016
#
Liang-Bo Wang <me@liang2.tw>, 2016
msgid ""
msgstr ""
"
Project-Id-Version
:
Python 3.10\n
"
"
Report-Msgid-Bugs-To
:
\n
"
"
POT-Creation-Date
:
2021-10-21 15:40+0000\n
"
"
PO-Revision-Date
:
2021-06-08 13:21+0800\n
"
"
Last-Translator
:
Ching-Hao Liu <chinghao.liu@gmail.com>\n
"
"
Language-Team
:
Chinese - TAIWAN (https://github.com/python/python-docs-zh-
"
"
tw)\n
"
"
Language
:
zh_TW\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
"
"
X-Generator
:
Poedit 2.4.3\n
"
#:
../../tutorial/introduction.rst:5
msgid
"An Informal Introduction to Python"
msgstr
"一個非正式的 Python 簡介"
#:
../../tutorial/introduction.rst:7
msgid
""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr
""
"在下面的例子中，輸入與輸出的區別在於有無提示符（prompt，
\\
:term:`>>>` 和 :"
"term:`...`
\\
）：如果要重做範例，你必須在提示符出現的時候，輸入提示符後方的所"
"有內容；那些非提示符開始的文字行是直譯器的輸出。注意到在範例中，若出現單行只"
"有次提示符時，代表該行你必須直接換行；這被使用在多行指令結束輸入時。"
#:
../../tutorial/introduction.rst:16
msgid
""
"You can toggle the display of prompts and output by clicking on ``>>>`` in "
"the upper-right corner of an example box. If you hide the prompts and "
"output for an example, then you can easily copy and paste the input lines "
"into your interpreter."
msgstr
""
#:
../../tutorial/introduction.rst:23
msgid
""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments. Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line. A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal. A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr
""
"在本手冊中的許多範例中，即便他們為互動式地輸入，仍然包含註解。Python 中的註"
"解 (comments) 由 hash 字元 ``#`` 開始一直到該行結束。註解可以從該行之首、空白"
"後、或程式碼之後開始，但不會出現在字串文本 (string literal) 之中。hash 字元在"
"字串文本之中時仍視為一 hash 字元。因為註解只是用來說明程式而不會被 Python 解"
"讀，在練習範例時不一定要輸入。"
#:
../../tutorial/introduction.rst:31
msgid
"Some examples::"
msgstr
""
"一些範例如下：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:42
msgid
"Using Python as a Calculator"
msgstr
"把 Python 當作計算機使用"
#:
../../tutorial/introduction.rst:44
msgid
""
"Let's try some simple Python commands. Start the interpreter and wait for "
"the primary prompt, ``>>>``. (It shouldn't take long.)"
msgstr
""
"讓我們來試試一些簡單的 Python 指令。啟動直譯器並等待第一個主提示符 ``>>>`` 出"
"現。（應該不會等太久）"
#:
../../tutorial/introduction.rst:51
msgid
"Numbers"
msgstr
"數字 (Number)"
#:
../../tutorial/introduction.rst:53
msgid
""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value. Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr
""
"直譯器如同一台簡單的計算機：你可以輸入一個 expression（運算式），它會寫出該式"
"的值。Expression 的語法很使用：運算子 ``+``、``-``、``*`` 和 ``/`` 的行為如同"
"大多數的程式語言（例如：Pascal 或 C）；括號 ``()`` 可以用來分群。例如：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:68
msgid
""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
"`float`. We will see more about numeric types later in the tutorial."
msgstr
""
"整數數字（即 ``2``、``4``、``20``）為 :class:`int` 型態，數字有小數點部份的"
"（即 ``5.0``、``1.6``）為 :class:`float` 型態。我們將在之後的教學中看到更多數"
"字相關的型態。"
#:
../../tutorial/introduction.rst:72
msgid
""
"Division (``/``) always returns a float. To do :term:`floor division` and "
"get an integer result (discarding any fractional result) you can use the ``//"
"`` operator; to calculate the remainder you can use ``%``::"
msgstr
""
"除法 (``/``) 永遠回傳一個 float。如果要做 :term:`floor division` 並拿到整數的"
"結果（即去除所有小數點的部份），你可以使用 ``//`` 運算子；計算餘數可以使用 ``"
"%``：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:86
msgid
""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr
""
"在 Python 中，計算冪次 (powers) 可以使用 ``**`` 運算子 [#]_：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:93
msgid
""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr
""
"等於符號 (``=``) 可以用於為變數賦值。賦值完之後，在下個指示符前並不會顯示任何"
"結果：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:101
msgid
""
"If a variable is not
\"
defined
\"
(assigned a value), trying to use it will "
"give you an error::"
msgstr
""
"如果一個變數未被「定義 (defined)」（即變數未被賦值），試著使用它時會出現一個"
"錯誤：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:109
msgid
""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr
""
"浮點數的運算有完善的支援，運算子 (operator) 遇上混合的運算元 (operand) 時會把"
"整數的運算元轉換為浮點數：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:115
msgid
""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``. This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr
""
"在互動式模式中，最後一個印出的運算式的結果會被指派至變數 ``_`` 中。這表示當你"
"把 Python 當作桌上計算機使用者，要接續計算變得容易許多：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:128
msgid
""
"This variable should be treated as read-only by the user. Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr
""
"這個變數應該被使用者視為只能讀取。不應該明確地為它賦值 --- 你可以創一個獨立但"
"名稱相同的本地變數來覆蓋掉預設變數和它的神奇行為。"
#:
../../tutorial/introduction.rst:132
msgid
""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
"Fraction`. Python also has built-in support for :ref:`complex numbers "
"<typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr
""
"除了 :class:`int` 和 :class:`float`，Python 還支援了其他的數字型態，包含 :"
"class:`~decimal.Decimal` 和 :class:`~fractions.Fraction`。Python 亦內建支援"
"
\\
:ref:`複數 (complex numbers) <typesnumeric>`，並使用 ``j`` 和 ``J`` 後綴來"
"指定虛數的部份（即 ``3+5j``）。"
#:
../../tutorial/introduction.rst:142
msgid
"Strings"
msgstr
"字串 (String)"
#:
../../tutorial/introduction.rst:144
msgid
""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways. They can be enclosed in single quotes (``'...'``) or "
"double quotes (``
\"
...
\"
``) with the same result [#]_. ``
\\
`` can be used "
"to escape quotes::"
msgstr
""
"除了數字之外，Python 也可以操作字串，而表達字串有數種方式。它們可以用包含在單"
"引號 (``'...'``) 或雙引號 (``
\"
...
\"
``) 之中，兩者會得到相同的結果
\\
[#]_"
"
\\
。使用 ``
\\
`` 跳脫出現於字串中的引號：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:162
msgid
""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes. While this might sometimes "
"look different from the input (the enclosing quotes could change), the two "
"strings are equivalent. The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes. The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr
""
"在互動式的直譯器中，輸出的字串會被引號包圍且特殊符號會使用反斜線 (``
\\
``) 跳"
"脫。雖然這有時會讓它看起來跟輸入的字串不相同（包圍用的引號可能會改變），輸入"
"和輸出兩字串實為相同。一般來說，字串包含單引號而沒有雙引號時，會使用雙引號包"
"圍字串。函式 :func:`print` 會產生更易讀的輸出，它會去除掉包圍的引號，並且直接"
"印出被跳脫的字元和特殊字元：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:182
msgid
""
"If you don't want characters prefaced by ``
\\
`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr
""
"如果你不希望字元前出現 ``
\\
`` 就被當成特殊字元時，可以改使用 *raw string*，在"
"第一個包圍引號前加上 ``r`` ：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:192
msgid
""
"String literals can span multiple lines. One way is using triple-quotes: ``"
"
\"\"\"
...
\"\"\"
`` or ``'''...'''``. End of lines are automatically included "
"in the string, but it's possible to prevent this by adding a ``
\\
`` at the "
"end of the line. The following example::"
msgstr
""
"字串文本可以跨越數行。其中一方式是使用三個重覆引號：
\\
``
\"\"\"
...
\"\"\"
`` "
"或 ``'''...'''``
\\
。此時換行會被自動加入字串值中，但也可以在換行前加入 ``"
"
\\
`` 來取消這個行為。在以下的例子中：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:203
msgid
""
"produces the following output (note that the initial newline is not "
"included):"
msgstr
"會產生以下的輸出（注意第一個換行並沒有被包含進字串值中）："
#:
../../tutorial/introduction.rst:211
msgid
""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr
""
"字串可以使用 ``+`` 運算子連接 (concatenate)，並用 ``*`` 重覆該字串的內容：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:218
msgid
""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr
""
"兩個以上相鄰的字串文本（*string literal*，即被引號包圍的字串）會被自動連接起"
"來：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:224
msgid
""
"This feature is particularly useful when you want to break long strings::"
msgstr
""
"當你想要分段一個非常長的字串時，兩相鄰字串值自動連接的特性十分有用：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:231
msgid
""
"This only works with two literals though, not with variables or expressions::"
msgstr
""
"但這特性只限於兩相鄰的字串值間，而非兩相鄰變數或表達式：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:245
msgid
""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr
""
"如果要連接變數們或一個變數與一個字串值，使用 ``+``：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:250
msgid
""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr
""
"字串可以被「索引 *indexed*」(下標，即 subscripted)，第一個字元的索引值為 0。"
"沒有獨立表示字元的型別；一個字元就是一個大小為 1 的字串：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:260
msgid
""
"Indices may also be negative numbers, to start counting from the right::"
msgstr
""
"索引值可以是負的，此時改成從右開始計數：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:269
msgid
"Note that since -0 is the same as 0, negative indices start from -1."
msgstr
"注意到因為 -0 等同於 0，負的索引值由 -1 開始。"
#:
../../tutorial/introduction.rst:271
msgid
""
"In addition to indexing, *slicing* is also supported. While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr
""
"除了索引外，字串亦支援「切片 *slicing*」。索引用來拿到單獨的字元，而切片則可"
"以讓你拿到子字串 (substring)：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:279
msgid
""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr
""
"切片索引 (slice indices) 有很常用的預設值，省略起點索引值時預設為 0，而省略第"
"二個索引值時預設整個字串被包含在 slice 中：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:289
msgid
""
"Note how the start is always included, and the end always excluded. This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr
""
"注意到起點永遠被包含，而結尾永遠不被包含。這確保了 ``s[:i] + s[i:]`` 永遠等"
"於 ``s``：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:297
msgid
""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr
""
"這裡有個簡單記住 slice 是如何運作的方式。想像 slice 的索引值指著字元們之間，"
"其中第一個字元的左側邊緣由 0 計數。則 *n* 個字元的字串中最後一個字元的右側邊"
"緣會有索引值 *n*，例如：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:308
msgid
""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr
""
"第一行數字給定字串索引值為 0...6 的位置；第二行則標示了負索引值的位置。由 "
"*i* 至 *j* 的 slice 包含了標示 *i* 和 *j* 邊緣間的所有字元。"
#:
../../tutorial/introduction.rst:313
msgid
""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds. For example, the length of "
"``word[1:3]`` is 2."
msgstr
""
"對非負數的索引值而言，一個 slice 的長度等於其索引值之差，如果索引值落在字串邊"
"界內。例如，``word[1:3]`` 的長度是 2。"
#:
../../tutorial/introduction.rst:317
msgid
"Attempting to use an index that is too large will result in an error::"
msgstr
""
"嘗試使用一個過大的索引值會造成錯誤：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:324
msgid
""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr
""
"然而，超出範圍的索引值在 slice 中會被妥善的處理：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:332
msgid
""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr
""
"Python 字串無法被改變 --- 它們是 :term:`immutable`。因此，嘗試對字串中某個索"
"引位置賦值會產生錯誤：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:344
msgid
"If you need a different string, you should create a new one::"
msgstr
""
"如果你需要一個不一樣的字串，你必須建立一個新的：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:351
msgid
"The built-in function :func:`len` returns the length of a string::"
msgstr
""
"內建的函式 :func:`len` 回傳一個字串的長度：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:362
msgid
":ref:`textseq`"
msgstr
":ref:`textseq`"
#:
../../tutorial/introduction.rst:361
msgid
""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr
"字串是 *sequence 型別*
\\
的範例之一，並支援該型別常用的操作。"
#:
../../tutorial/introduction.rst:366
msgid
":ref:`string-methods`"
msgstr
":ref:`string-methods`"
#:
../../tutorial/introduction.rst:365
msgid
""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr
"字串支援非常多種基本轉換和搜尋的 method（方法）。"
#:
../../tutorial/introduction.rst:369
msgid
":ref:`f-strings`"
msgstr
":ref:`f-strings`"
#:
../../tutorial/introduction.rst:369
msgid
"String literals that have embedded expressions."
msgstr
"包含有運算式的字串文本。"
#:
../../tutorial/introduction.rst:372
msgid
":ref:`formatstrings`"
msgstr
":ref:`formatstrings`"
#:
../../tutorial/introduction.rst:372
msgid
"Information about string formatting with :meth:`str.format`."
msgstr
"關於透過 :meth:`str.format` 字串格式化 (string formatting) 的資訊。"
#:
../../tutorial/introduction.rst:375
msgid
":ref:`old-string-formatting`"
msgstr
":ref:`old-string-formatting`"
#:
../../tutorial/introduction.rst:375
msgid
""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr
""
"在字串為 ``%`` 運算子的左運算元時，將觸發舊的字串格式化操作，更多的細節在本連"
"結中介紹。"
#:
../../tutorial/introduction.rst:382
msgid
"Lists"
msgstr
"List（串列）"
#:
../../tutorial/introduction.rst:384
msgid
""
"Python knows a number of *compound* data types, used to group together other "
"values. The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets. Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr
""
"Python 理解數種複合型資料型別，用來組合不同的數值。當中最多樣變化的型別為 "
"*list*，可以寫成一系列以逗號分隔的數值（稱之元素，即 item），包含在方括號之"
"中。List 可以包合不同型別的元素，但通常這些元素會有相同的型別：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:393
msgid
""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr
""
"如同字串（以及其他內建的 :term:`sequence` 型別），list 可以被索引和切片 "
"(slice)：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:403
msgid
""
"All slice operations return a new list containing the requested elements. "
"This means that the following slice returns a :ref:`shallow copy "
"<shallow_vs_deep_copy>` of the list::"
msgstr
""
"所有切片操作都會回傳一個新的 list ，包含要求的元素。這意謂著以下這個切片回傳"
"了原本 list 的 :ref:`淺複製 <shallow_vs_deep_copy>` ：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:410
msgid
"Lists also support operations like concatenation::"
msgstr
""
"List 對支援如接合 (concatenation) 等操作：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:415
msgid
""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr
""
"不同於字串是 :term:`immutable`，list 是 :term:`mutable` 型別，即改變 list 的"
"內容是可能的：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:425
msgid
""
"You can also add new items at the end of the list, by using the :meth:`~list."
"append` *method* (we will see more about methods later)::"
msgstr
""
"你也可以在 list 的最後加入新元素，透過使用 :meth:`~list.append` *方法* "
"(method)（我們稍後會看到更多方法的說明）：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:433
msgid
""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr
""
"也可以對 slice 賦值，這能改變 list 的大小，甚至是清空一個 list：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:452
msgid
"The built-in function :func:`len` also applies to lists::"
msgstr
""
"內建的函式 :func:`len` 亦可以作用在 list 上：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:458
msgid
""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr
""
"也可以嵌套多層 list （建立 list 包含其他 list），例如：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:474
msgid
"First Steps Towards Programming"
msgstr
"初探程式設計的前幾步"
#:
../../tutorial/introduction.rst:476
msgid
""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together. For instance, we can write an initial sub-sequence of the "
"`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_number>`_ as "
"follows::"
msgstr
""
"當然，我們可以用 Python 來處理比 2 加 2 更複雜的工作。例如，我們可以印出
\\
`"
"費氏數列 <https://zh.wikipedia.org/zh-tw/"
"%E6%96%90%E6%B3%A2%E9%82%A3%E5%A5%91%E6%95%B0%E5%88%97>`_
\\
的首幾項序列：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:496
msgid
"This example introduces several new features."
msgstr
"這例子引入了許多新的特性。"
#:
../../tutorial/introduction.rst:498
msgid
""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1. On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place. The right-"
"hand side expressions are evaluated from the left to the right."
msgstr
""
"第一行出現了多重賦值：變數 ``a`` 與 ``b`` 同時得到了新的值 0 與 1。在最後一行"
"同樣的賦值再被使用了一次，示範了等號的右項運算 (expression) 會先被計算 "
"(evaluate)，賦值再發生。右項的運算式由左至右依序被計算。"
#:
../../tutorial/introduction.rst:504
msgid
""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true. In Python, like in C, any non-zero integer value is "
"true; zero is false. The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false. The test used in the example is a simple comparison. The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr
""
":keyword:`while` 迴圈只要它的條件為真（此範例：``a < 10``），將會一直重覆執"
"行。在 Python 中如同 C 語言，任何非零的整數值為真 (true)；零為假 (false)。條"
"件可以是字串、list、甚至是任何序列型別；任何非零長度的序列為真，空的序列即為"
"假。本例子使用的條件是個簡單的比較。標準的比較運算子 (comparison operators) "
"使用如同 C 語言一樣的符號：
\\
``<``
\\
（小於）、
\\
``>``
\\
（大於）、
\\
"
"``==``
\\
（等於）、
\\
``<=``
\\
（小於等於）、
\\
``>=``
\\
（大於等於）以及 ``!"
"=``
\\
（不等於）。"
#:
../../tutorial/introduction.rst:513
msgid
""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements. At the interactive prompt, you have to type a tab or "
"space(s) for each indented line. In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility. When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line). Note "
"that each line within a basic block must be indented by the same amount."
msgstr
""
"迴圈的主體會
\\
*縮排*
\\
：縮排在 Python 中用來關連一群陳述式。在互動式提示符"
"中，你必須在迴圈內的每一行一開始鍵入 tab 或者（數個）空白來維持縮排。實務上，"
"你會先在文字編輯器中準備好比較複雜的輸入；多數編輯器都有自動縮排的功能。當一"
"個複合陳述式以互動地方式輸入，必須在結束時多加一行空行來代表結束（因為語法剖"
"析器無法判斷你何時輸入複合陳述的最後一行）。注意在一個縮排段落內的縮排方式與"
"數量必須維持一致。"
#:
../../tutorial/introduction.rst:522
msgid
""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating point quantities, and strings. Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr
""
":func:`print` 函式印出它接收到引數（們）的值。不同於先前僅我們寫下想要的運算"
"（像是先前的計算機範例），它可以處理複數個引數、浮點數數值和字串。印出的字串"
"將不帶有引號，並且不同項目間會插入一個空白，因此可以讓你容易格式化輸出，例"
"如：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:533
msgid
""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr
""
"關鍵字引數 *end* 可以被用來避免額外的換行符加入到輸出中，或者以不同的字串結束"
"輸出：\n"
"\n"
"::"
#:
../../tutorial/introduction.rst:545
msgid
"Footnotes"
msgstr
"註解"
#:
../../tutorial/introduction.rst:546
msgid
""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr
""
"因為 ``**`` 擁有較 ``-`` 高的優先次序，
\\
``-3**2`` 會被解釋為 ``-(3**2)`` 並"
"得到 ``-9``
\\
。如果要避免這樣的優先順序以得到 ``9``，你可以使用 ``(-3)**2``"
"
\\
。"
#:
../../tutorial/introduction.rst:550
msgid
""
"Unlike other languages, special characters such as ``
\\
n`` have the same "
"meaning with both single (``'...'``) and double (``
\"
...
\"
``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``
\"
`` (but you have to escape ``
\\
'``) and vice versa."
msgstr
""
"不像其他語言，特殊符號如 ``
\\
n`` 在單 (``'...'``) 和雙 (``
\"
...
\"
``) 引號中有"
"相同的意思。兩種引號的唯一差別，在於使用單引號時，不需要跳脫 ``
\"
``
\\
（但必"
"須跳脫 ``
\\
'``
\\
），反之亦同。"
Back
|
FazBrowse Home
|
New Git URL