FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
python-docs-zh-tw/tutorial/inputoutput.po at copilot/fix-33 · python/python-docs-zh-tw · GitHub
python
python-docs-zh-tw
Repository navigation
Code
Issues
33
(33)
Pull requests
11
(11)
Discussions
Actions
Wiki
Security and quality
Insights
Expand file tree
Breadcrumbs
python-docs-zh-tw
/
tutorial
/
inputoutput.po
Copy path
More file actions
More file actions
Latest commit
History
History
History
1148 lines (1036 loc) · 46.1 KB
Breadcrumbs
python-docs-zh-tw
/
tutorial
/
inputoutput.po
Copy path
File metadata and controls
1148 lines (1036 loc) · 46.1 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
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
#
Copyright (C) 2001-2025, Python Software Foundation
#
This file is distributed under the same license as the Python package.
#
#
Translators:
#
jerrychen <jerrychen.ee@gmail.com>, 2016
#
Steven Hsu <hsuhaochun@gmail.com>, 2021-2022
msgid ""
msgstr ""
"
Project-Id-Version
:
Python 3.13\n
"
"
Report-Msgid-Bugs-To
:
\n
"
"
POT-Creation-Date
:
2024-10-31 00:13+0000\n
"
"
PO-Revision-Date
:
2022-10-05 10:26+0800\n
"
"
Last-Translator
:
Steven Hsu <hsuhaochun@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 3.1.1\n
"
#:
../../tutorial/inputoutput.rst:5
msgid
"Input and Output"
msgstr
"輸入和輸出"
#:
../../tutorial/inputoutput.rst:7
msgid
""
"There are several ways to present the output of a program; data can be "
"printed in a human-readable form, or written to a file for future use. This "
"chapter will discuss some of the possibilities."
msgstr
""
"有數種方式可以顯示程式的輸出；資料可以以人類易讀的形式印出，或是寫入檔案以供"
"未來所使用。這章節會討論幾種不同的方式。"
#:
../../tutorial/inputoutput.rst:15
msgid
"Fancier Output Formatting"
msgstr
"更華麗的輸出格式"
#:
../../tutorial/inputoutput.rst:17
msgid
""
"So far we've encountered two ways of writing values: *expression statements* "
"and the :func:`print` function. (A third way is using "
"the :meth:`~io.TextIOBase.write` method of file objects; the standard output "
"file can be referenced as ``sys.stdout``. See the Library Reference for more "
"information on this.)"
msgstr
""
"目前為止我們已經學過兩種寫值的方式：*運算式陳述 (expression statements)* "
"與 :func:`print` 函式。（第三種方法是使用檔案物件"
"的 :meth:`~io.TextIOBase.write` 方法；標準輸出的檔案是使用 ``sys.stdout`` 來"
"達成的。詳細的資訊請參考對應的函式庫說明。）"
#:
../../tutorial/inputoutput.rst:22
msgid
""
"Often you'll want more control over the formatting of your output than "
"simply printing space-separated values. There are several ways to format "
"output."
msgstr
""
"通常你會想要對輸出格式有更多地控制，而不是僅列印出以空格隔開的值。以下是幾種"
"格式化輸出的方式。"
#:
../../tutorial/inputoutput.rst:25
msgid
""
"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "
"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "
"Inside this string, you can write a Python expression between ``{`` and ``}"
"`` characters that can refer to variables or literal values."
msgstr
""
"要使用
\\
:ref:`格式化字串文本 (formatted string literals) <tut-f-strings>`，"
"需在字串開始前的引號或連續三個引號前加上 ``f`` 或 ``F``。你可以在這個字串中使"
"用 ``{`` 與 ``}`` 包夾 Python 的運算式，引用變數或其他字面值 (literal "
"values)。"
#:
../../tutorial/inputoutput.rst:32
msgid
""
">>> year = 2016\n"
">>> event = 'Referendum'\n"
">>> f'Results of the {year} {event}'\n"
"'Results of the 2016 Referendum'"
msgstr
""
">>> year = 2016\n"
">>> event = 'Referendum'\n"
">>> f'Results of the {year} {event}'\n"
"'Results of the 2016 Referendum'"
#:
../../tutorial/inputoutput.rst:37
msgid
""
"The :meth:`str.format` method of strings requires more manual effort. "
"You'll still use ``{`` and ``}`` to mark where a variable will be "
"substituted and can provide detailed formatting directives, but you'll also "
"need to provide the information to be formatted. In the following code block "
"there are two examples of how to format variables:"
msgstr
""
"字串的 :meth:`str.format` method 需要更多手動操作。你還是可以用 ``{`` 和 ``}"
"`` 標示欲替代變數的位置，且可給予詳細的格式指令，但你也需提供要被格式化的資"
"訊。在以下程式碼區塊中，有兩個如何格式化變數的範例："
#:
../../tutorial/inputoutput.rst:46
msgid
""
">>> yes_votes = 42_572_654\n"
">>> total_votes = 85_705_149\n"
">>> percentage = yes_votes / total_votes\n"
">>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)\n"
"' 42572654 YES votes 49.67%'"
msgstr
""
">>> yes_votes = 42_572_654\n"
">>> total_votes = 85_705_149\n"
">>> percentage = yes_votes / total_votes\n"
">>> '{:-9} YES votes {:2.2%}'.format(yes_votes, percentage)\n"
"' 42572654 YES votes 49.67%'"
#:
../../tutorial/inputoutput.rst:52
msgid
""
"Notice how the ``yes_votes`` are padded with spaces and a negative sign only "
"for negative numbers. The example also prints ``percentage`` multiplied by "
"100, with 2 decimal places and followed by a percent sign "
"(see :ref:`formatspec` for details)."
msgstr
""
"請注意 ``yes_votes`` 如何對於負數用空格和負號填補。該範例還會列出 "
"``percentage`` 乘以 100，並保留 2 位小數且後面跟著一個百分號（有關詳細資訊，"
"請參閱 :ref:`formatspec`）。"
#:
../../tutorial/inputoutput.rst:57
msgid
""
"Finally, you can do all the string handling yourself by using string slicing "
"and concatenation operations to create any layout you can imagine. The "
"string type has some methods that perform useful operations for padding "
"strings to a given column width."
msgstr
""
"最後，你還可以自己用字串切片 (slicing) 和串接 (concatenation) 操作，完成所有"
"的字串處理，建立任何你能想像的排版格式。字串型別有一些 method，能以給定的欄寬"
"填補字串，這些運算也很有用。"
#:
../../tutorial/inputoutput.rst:62
msgid
""
"When you don't need fancy output but just want a quick display of some "
"variables for debugging purposes, you can convert any value to a string with "
"the :func:`repr` or :func:`str` functions."
msgstr
""
"如果你不需要華麗的輸出，只想快速顯示變數以進行除錯，可以用 :func:`repr` "
"或 :func:`str` 函式把任何的值轉換為字串。"
#:
../../tutorial/inputoutput.rst:66
msgid
""
"The :func:`str` function is meant to return representations of values which "
"are fairly human-readable, while :func:`repr` is meant to generate "
"representations which can be read by the interpreter (or will force "
"a :exc:`SyntaxError` if there is no equivalent syntax). For objects which "
"don't have a particular representation for human consumption, :func:`str` "
"will return the same value as :func:`repr`. Many values, such as numbers or "
"structures like lists and dictionaries, have the same representation using "
"either function. Strings, in particular, have two distinct representations."
msgstr
""
":func:`str` 函式的用意是回傳一個人類易讀的表示法，而 :func:`repr` 的用意是產"
"生直譯器可讀取的表示法（如果沒有等效的語法，則造成 :exc:`SyntaxError`）。如果"
"物件沒有人類易讀的特定表示法，:func:`str` 會回傳與 :func:`repr` 相同的值。有"
"許多的值，像是數字，或 list 及 dictionary 等結構，使用這兩個函式會有相同的表"
"示法。而字串，則較為特別，有兩種不同的表示法。"
#:
../../tutorial/inputoutput.rst:75
msgid
"Some examples::"
msgstr
"一些範例： ::"
#:
../../tutorial/inputoutput.rst:77
msgid
""
">>> s = 'Hello, world.'\n"
">>> str(s)\n"
"'Hello, world.'\n"
">>> repr(s)\n"
"
\"
'Hello, world.'
\"
\n"
">>> str(1/7)\n"
"'0.14285714285714285'\n"
">>> x = 10 * 3.25\n"
">>> y = 200 * 200\n"
">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"
">>> print(s)\n"
"The value of x is 32.5, and y is 40000...\n"
">>> # The repr() of a string adds string quotes and backslashes:\n"
">>> hello = 'hello, world
\\
n'\n"
">>> hellos = repr(hello)\n"
">>> print(hellos)\n"
"'hello, world
\\
n'\n"
">>> # The argument to repr() may be any Python object:\n"
">>> repr((x, y, ('spam', 'eggs')))\n"
"
\"
(32.5, 40000, ('spam', 'eggs'))
\"
"
msgstr
""
">>> s = 'Hello, world.'\n"
">>> str(s)\n"
"'Hello, world.'\n"
">>> repr(s)\n"
"
\"
'Hello, world.'
\"
\n"
">>> str(1/7)\n"
"'0.14285714285714285'\n"
">>> x = 10 * 3.25\n"
">>> y = 200 * 200\n"
">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"
">>> print(s)\n"
"The value of x is 32.5, and y is 40000...\n"
">>> # 字串的 repr() 會加上字串引號和反斜線：\n"
">>> hello = 'hello, world
\\
n'\n"
">>> hellos = repr(hello)\n"
">>> print(hellos)\n"
"'hello, world
\\
n'\n"
">>> # repr() 的引數可以是任何 Python 物件：\n"
">>> repr((x, y, ('spam', 'eggs')))\n"
"
\"
(32.5, 40000, ('spam', 'eggs'))
\"
"
#:
../../tutorial/inputoutput.rst:98
msgid
""
"The :mod:`string` module contains a :class:`~string.Template` class that "
"offers yet another way to substitute values into strings, using placeholders "
"like ``$x`` and replacing them with values from a dictionary, but offers "
"much less control of the formatting."
msgstr
""
":mod:`string` 模組包含一個 :class:`~string.Template` class（類別），提供了將"
"值替代為字串的另一種方法。該方法使用 ``$x`` 佔位符號，並以 dictionary 的值進"
"行取代，但對格式的控制明顯較少。"
#:
../../tutorial/inputoutput.rst:114
msgid
"Formatted String Literals"
msgstr
"格式化的字串文本 (Formatted String Literals)"
#:
../../tutorial/inputoutput.rst:116
msgid
""
":ref:`Formatted string literals <f-strings>` (also called f-strings for "
"short) let you include the value of Python expressions inside a string by "
"prefixing the string with ``f`` or ``F`` and writing expressions as "
"``{expression}``."
msgstr
""
":ref:`格式化的字串文本 <f-strings>`
\\
（簡稱為 f-字串），透過在字串加入前綴 "
"``f`` 或 ``F``，並將運算式編寫為 ``{expression}``，讓你可以在字串內加入 "
"Python 運算式的值。"
#:
../../tutorial/inputoutput.rst:121
msgid
""
"An optional format specifier can follow the expression. This allows greater "
"control over how the value is formatted. The following example rounds pi to "
"three places after the decimal::"
msgstr
""
"格式說明符 (format specifier) 是選擇性的，寫在運算式後面，可以更好地控制值的"
"格式化方式。以下範例將 pi 捨入到小數點後三位： ::"
#:
../../tutorial/inputoutput.rst:125
msgid
""
">>> import math\n"
">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"
"The value of pi is approximately 3.142."
msgstr
""
">>> import math\n"
">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"
"The value of pi is approximately 3.142."
#:
../../tutorial/inputoutput.rst:129
msgid
""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide. This is useful for making columns line up. ::"
msgstr
""
"在 ``':'`` 後傳遞一個整數，可以設定該欄位至少為幾個字元寬，常用於將每一欄對"
"齊。 ::"
#:
../../tutorial/inputoutput.rst:132
msgid
""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"
">>> for name, phone in table.items():\n"
"... print(f'{name:10} ==> {phone:10d}')\n"
"...\n"
"Sjoerd ==> 4127\n"
"Jack ==> 4098\n"
"Dcab ==> 7678"
msgstr
""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"
">>> for name, phone in table.items():\n"
"... print(f'{name:10} ==> {phone:10d}')\n"
"...\n"
"Sjoerd ==> 4127\n"
"Jack ==> 4098\n"
"Dcab ==> 7678"
#:
../../tutorial/inputoutput.rst:140
msgid
""
"Other modifiers can be used to convert the value before it is formatted. ``'!"
"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "
"applies :func:`repr`::"
msgstr
""
"還有一些修飾符號可以在格式化前先將值轉換過。``'!a'`` 會套用 :func:`ascii`，"
"``'!s'`` 會套用 :func:`str`，``'!r'`` 會套用 :func:`repr`： ::"
#:
../../tutorial/inputoutput.rst:144
msgid
""
">>> animals = 'eels'\n"
">>> print(f'My hovercraft is full of {animals}.')\n"
"My hovercraft is full of eels.\n"
">>> print(f'My hovercraft is full of {animals!r}.')\n"
"My hovercraft is full of 'eels'."
msgstr
""
">>> animals = 'eels'\n"
">>> print(f'My hovercraft is full of {animals}.')\n"
"My hovercraft is full of eels.\n"
">>> print(f'My hovercraft is full of {animals!r}.')\n"
"My hovercraft is full of 'eels'."
#:
../../tutorial/inputoutput.rst:150
msgid
""
"The ``=`` specifier can be used to expand an expression to the text of the "
"expression, an equal sign, then the representation of the evaluated "
"expression:"
msgstr
""
"``=`` 說明符可用於將一個運算式擴充為該運算式的文字、一個等號、以及對該運算式"
"求值 (evaluate) 後的表示法："
#:
../../tutorial/inputoutput.rst:159
msgid
""
"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "
"information on the ``=`` specifier. For a reference on these format "
"specifications, see the reference guide for the :ref:`formatspec`."
msgstr
""
"更多關於 ``=`` 說明符的資訊請見
\\
:ref:`自文件性運算式 (self-documenting "
"expressions) <bpo-36817-whatsnew>`。若要參考這些格式化字串的規格，詳"
"見 :ref:`formatspec` 參考指南。"
#:
../../tutorial/inputoutput.rst:166
msgid
"The String format() Method"
msgstr
"字串的 format() method"
#:
../../tutorial/inputoutput.rst:168
msgid
"Basic usage of the :meth:`str.format` method looks like this::"
msgstr
":meth:`str.format` method 的基本用法如下： ::"
#:
../../tutorial/inputoutput.rst:170
msgid
""
">>> print('We are the {} who say
\"
{}!
\"
'.format('knights', 'Ni'))\n"
"We are the knights who say
\"
Ni!
\"
"
msgstr
""
">>> print('We are the {} who say
\"
{}!
\"
'.format('knights', 'Ni'))\n"
"We are the knights who say
\"
Ni!
\"
"
#:
../../tutorial/inputoutput.rst:173
msgid
""
"The brackets and characters within them (called format fields) are replaced "
"with the objects passed into the :meth:`str.format` method. A number in the "
"brackets can be used to refer to the position of the object passed into "
"the :meth:`str.format` method. ::"
msgstr
""
"大括號及其內的字元（稱為格式欄位）會被取代為傳遞給 :meth:`str.format` method "
"的物件。大括號中的數字表示該物件在傳遞給 :meth:`str.format` method 時所在的位"
"置。 ::"
#:
../../tutorial/inputoutput.rst:178
msgid
""
">>> print('{0} and {1}'.format('spam', 'eggs'))\n"
"spam and eggs\n"
">>> print('{1} and {0}'.format('spam', 'eggs'))\n"
"eggs and spam"
msgstr
""
">>> print('{0} and {1}'.format('spam', 'eggs'))\n"
"spam and eggs\n"
">>> print('{1} and {0}'.format('spam', 'eggs'))\n"
"eggs and spam"
#:
../../tutorial/inputoutput.rst:183
msgid
""
"If keyword arguments are used in the :meth:`str.format` method, their values "
"are referred to by using the name of the argument. ::"
msgstr
""
"如果在 :meth:`str.format` method 中使用關鍵字引數，可以使用引數名稱去引用它們"
"的值。 ::"
#:
../../tutorial/inputoutput.rst:186
msgid
""
">>> print('This {food} is {adjective}.'.format(\n"
"... food='spam', adjective='absolutely horrible'))\n"
"This spam is absolutely horrible."
msgstr
""
">>> print('This {food} is {adjective}.'.format(\n"
"... food='spam', adjective='absolutely horrible'))\n"
"This spam is absolutely horrible."
#:
../../tutorial/inputoutput.rst:190
msgid
"Positional and keyword arguments can be arbitrarily combined::"
msgstr
"位置引數和關鍵字引數可以任意組合： ::"
#:
../../tutorial/inputoutput.rst:192
msgid
""
">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"
"... other='Georg'))\n"
"The story of Bill, Manfred, and Georg."
msgstr
""
">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"
"... other='Georg'))\n"
"The story of Bill, Manfred, and Georg."
#:
../../tutorial/inputoutput.rst:196
msgid
""
"If you have a really long format string that you don't want to split up, it "
"would be nice if you could reference the variables to be formatted by name "
"instead of by position. This can be done by simply passing the dict and "
"using square brackets ``'[]'`` to access the keys. ::"
msgstr
""
"如果你有一個不想分割的長格式化字串，比較好的方式是按名稱而不是按位置來引用變"
"數。這項操作可以透過傳遞字典 (dict)，並用方括號 ``'[]'`` 使用鍵 (key) 來輕鬆"
"完成。 ::"
#:
../../tutorial/inputoutput.rst:201
msgid
""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"
"... 'Dcab: {0[Dcab]:d}'.format(table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr
""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"
"... 'Dcab: {0[Dcab]:d}'.format(table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
#:
../../tutorial/inputoutput.rst:206
msgid
""
"This could also be done by passing the ``table`` dictionary as keyword "
"arguments with the ``**`` notation. ::"
msgstr
""
"用 '**' 符號，把 ``table`` 字典當作關鍵字引數來傳遞，也有一樣的結果。 ::"
#:
../../tutorial/inputoutput.rst:209
msgid
""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: "
"{Dcab:d}'.format(**table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr
""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: "
"{Dcab:d}'.format(**table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
#:
../../tutorial/inputoutput.rst:213
msgid
""
"This is particularly useful in combination with the built-in "
"function :func:`vars`, which returns a dictionary containing all local "
"variables::"
msgstr
""
"與內建函式 :func:`vars` 組合使用時，這種方式特別實用。該函式可以回傳一個包含"
"所有區域變數的 dictionary： ::"
#:
../../tutorial/inputoutput.rst:216
msgid
""
">>> table = {k: str(v) for k, v in vars().items()}\n"
">>> message =
\"
\"
.join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"
">>> print(message.format(**table))\n"
"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."
msgstr
""
">>> table = {k: str(v) for k, v in vars().items()}\n"
">>> message =
\"
\"
.join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"
">>> print(message.format(**table))\n"
"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."
#:
../../tutorial/inputoutput.rst:221
msgid
""
"As an example, the following lines produce a tidily aligned set of columns "
"giving integers and their squares and cubes::"
msgstr
"例如，下面的程式碼產生一組排列整齊的欄，列出整數及其平方與立方： ::"
#:
../../tutorial/inputoutput.rst:224
msgid
""
">>> for x in range(1, 11):\n"
"... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"
"...\n"
" 1 1 1\n"
" 2 4 8\n"
" 3 9 27\n"
" 4 16 64\n"
" 5 25 125\n"
" 6 36 216\n"
" 7 49 343\n"
" 8 64 512\n"
" 9 81 729\n"
"10 100 1000"
msgstr
""
">>> for x in range(1, 11):\n"
"... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"
"...\n"
" 1 1 1\n"
" 2 4 8\n"
" 3 9 27\n"
" 4 16 64\n"
" 5 25 125\n"
" 6 36 216\n"
" 7 49 343\n"
" 8 64 512\n"
" 9 81 729\n"
"10 100 1000"
#:
../../tutorial/inputoutput.rst:238
msgid
""
"For a complete overview of string formatting with :meth:`str.format`, "
"see :ref:`formatstrings`."
msgstr
""
"關於使用 :meth:`str.format` 進行字串格式化的完整概述，請見"
"
\\
:ref:`formatstrings`。"
#:
../../tutorial/inputoutput.rst:243
msgid
"Manual String Formatting"
msgstr
"手動格式化字串"
#:
../../tutorial/inputoutput.rst:245
msgid
"Here's the same table of squares and cubes, formatted manually::"
msgstr
"下面是以手動格式化完成的同一個平方及立方的表： ::"
#:
../../tutorial/inputoutput.rst:247
msgid
""
">>> for x in range(1, 11):\n"
"... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"
"... # Note use of 'end' on previous line\n"
"... print(repr(x*x*x).rjust(4))\n"
"...\n"
" 1 1 1\n"
" 2 4 8\n"
" 3 9 27\n"
" 4 16 64\n"
" 5 25 125\n"
" 6 36 216\n"
" 7 49 343\n"
" 8 64 512\n"
" 9 81 729\n"
"10 100 1000"
msgstr
""
">>> for x in range(1, 11):\n"
"... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"
"... # 注意前一列使用的 'end'\n"
"... print(repr(x*x*x).rjust(4))\n"
"...\n"
" 1 1 1\n"
" 2 4 8\n"
" 3 9 27\n"
" 4 16 64\n"
" 5 25 125\n"
" 6 36 216\n"
" 7 49 343\n"
" 8 64 512\n"
" 9 81 729\n"
"10 100 1000"
#:
../../tutorial/inputoutput.rst:263
msgid
""
"(Note that the one space between each column was added by the "
"way :func:`print` works: it always adds spaces between its arguments.)"
msgstr
""
"（請注意，使用 :func:`print` 讓每欄之間加入一個空格的方法：這種方法總是在其引"
"數間加入空格。）"
#:
../../tutorial/inputoutput.rst:266
msgid
""
"The :meth:`str.rjust` method of string objects right-justifies a string in a "
"field of a given width by padding it with spaces on the left. There are "
"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "
"not write anything, they just return a new string. If the input string is "
"too long, they don't truncate it, but return it unchanged; this will mess up "
"your column lay-out but that's usually better than the alternative, which "
"would be lying about a value. (If you really want truncation you can always "
"add a slice operation, as in ``x.ljust(n)[:n]``.)"
msgstr
""
"字串物件的 :meth:`str.rjust` method 透過在左側填補空格，使字串以給定的欄寬進"
"行靠右對齊。類似的 method 還有 :meth:`str.ljust` 和 :meth:`str.center`。這些 "
"method 不寫入任何內容，只回傳一個新字串，如果輸入的字串太長，它們不會截斷字"
"串，而是不做任何改變地回傳；雖然這樣會弄亂欄的編排，但這通常還是比另一種情況"
"好，那種情況會讓值變得不正確。（如果你真的想截斷字串，可以加入像 ``x.ljust(n)"
"[:n]`` 這樣的切片運算。）"
#:
../../tutorial/inputoutput.rst:275
msgid
""
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
"the left with zeros. It understands about plus and minus signs::"
msgstr
""
"另一種 method 是 :meth:`str.zfill`，可在數值字串的左邊填補零，且能識別正負"
"號： ::"
#:
../../tutorial/inputoutput.rst:278
msgid
""
">>> '12'.zfill(5)\n"
"'00012'\n"
">>> '-3.14'.zfill(7)\n"
"'-003.14'\n"
">>> '3.14159265359'.zfill(5)\n"
"'3.14159265359'"
msgstr
""
">>> '12'.zfill(5)\n"
"'00012'\n"
">>> '-3.14'.zfill(7)\n"
"'-003.14'\n"
">>> '3.14159265359'.zfill(5)\n"
"'3.14159265359'"
#:
../../tutorial/inputoutput.rst:287
msgid
"Old string formatting"
msgstr
"格式化字串的舊方法"
#:
../../tutorial/inputoutput.rst:289
msgid
""
"The % operator (modulo) can also be used for string formatting. Given "
"``format % values`` (where *format* is a string), ``%`` conversion "
"specifications in *format* are replaced with zero or more elements of "
"*values*. This operation is commonly known as string interpolation. For "
"example::"
msgstr
""
"% 運算子（modulo，模數）也可用於字串格式化。在 ``format % values`` 中（其中 "
"*format* 是個字串），*format* 內的 ``%`` 轉換規格會被 *values* 的零個或多個元"
"素所取代。此運算常被稱為字串插值 (string interpolation)。例如： ::"
#:
../../tutorial/inputoutput.rst:296
msgid
""
">>> import math\n"
">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"
"The value of pi is approximately 3.142."
msgstr
""
">>> import math\n"
">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"
"The value of pi is approximately 3.142."
#:
../../tutorial/inputoutput.rst:300
msgid
""
"More information can be found in the :ref:`old-string-formatting` section."
msgstr
"更多資訊請見 :ref:`old-string-formatting`
\\
小節。"
#:
../../tutorial/inputoutput.rst:306
msgid
"Reading and Writing Files"
msgstr
"讀寫檔案"
#:
../../tutorial/inputoutput.rst:312
msgid
""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two positional arguments and one keyword argument: ``open(filename, mode, "
"encoding=None)``"
msgstr
""
":func:`open` 回傳一個 :term:`file object`，而它最常使用的兩個位置引數和一個關"
"鍵字引數是：``open(filename, mode, encoding=None)``"
#:
../../tutorial/inputoutput.rst:318
msgid
">>> f = open('workfile', 'w', encoding=
\"
utf-8
\"
)"
msgstr
">>> f = open('workfile', 'w', encoding=
\"
utf-8
\"
)"
#:
../../tutorial/inputoutput.rst:325
msgid
""
"The first argument is a string containing the filename. The second argument "
"is another string containing a few characters describing the way in which "
"the file will be used. *mode* can be ``'r'`` when the file will only be "
"read, ``'w'`` for only writing (an existing file with the same name will be "
"erased), and ``'a'`` opens the file for appending; any data written to the "
"file is automatically added to the end. ``'r+'`` opens the file for both "
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
"assumed if it's omitted."
msgstr
""
"第一個引數是一個包含檔案名稱的字串。第二個引數是另一個字串，包含了描述檔案使"
"用方式的幾個字元。*mode* 為 ``'r'`` 時，表示以唯讀模式開啟檔案；為 ``'w'`` "
"時，表示以唯寫模式開啟檔案（已存在的同名檔案會被抹除）；為 ``'a'`` 時，以附加"
"內容為目的開啟檔案，任何寫入檔案的資料會自動被加入到檔案的結尾。``'r+'`` 可以"
"開啟檔案並進行讀取和寫入。*mode* 引數是選擇性的，若省略時會預設為 ``'r'``。"
#:
../../tutorial/inputoutput.rst:334
msgid
""
"Normally, files are opened in :dfn:`text mode`, that means, you read and "
"write strings from and to the file, which are encoded in a specific "
"*encoding*. If *encoding* is not specified, the default is platform "
"dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, "
"``encoding=
\"
utf-8
\"
`` is recommended unless you know that you need to use a "
"different encoding. Appending a ``'b'`` to the mode opens the file "
"in :dfn:`binary mode`. Binary mode data is read and written "
"as :class:`bytes` objects. You can not specify *encoding* when opening file "
"in binary mode."
msgstr
""
"通常，檔案以 :dfn:`text mode` 開啟，意即，從檔案中讀取或寫入字串時，都以特定"
"編碼方式 *encoding* 進行編碼。如未指定 *encoding*，則預設值會取決於系統平台"
"（見 :func:`open`）。因為 UTF-8 是現時的標準，除非你很清楚該用什麼編碼，否則"
"推薦使用 ``encoding=
\"
utf-8
\"
``。在 mode 後面加上 ``'b'`` 會以 :dfn:`binary "
"mode`
\\
（二進制模式）開啟檔案，二進制模式資料以 :class:`bytes` 物件的形式被"
"讀寫。以二進制模式開啟檔案時不可以指定 *encoding*。"
#:
../../tutorial/inputoutput.rst:344
msgid
""
"In text mode, the default when reading is to convert platform-specific line "
"endings (``
\\
n`` on Unix, ``
\\
r
\\
n`` on Windows) to just ``
\\
n``. When "
"writing in text mode, the default is to convert occurrences of ``
\\
n`` back "
"to platform-specific line endings. This behind-the-scenes modification to "
"file data is fine for text files, but will corrupt binary data like that "
"in :file:`JPEG` or :file:`EXE` files. Be very careful to use binary mode "
"when reading and writing such files."
msgstr
""
"在文字模式 (text mode) 下，讀取時會預設把平台特定的行尾符號（Unix 上為 "
"``
\\
n``，Windows 上為 ``
\\
r
\\
n``）轉換為 ``
\\
n``。在文字模式下寫入時，預設會"
"把 ``
\\
n`` 出現之處轉換回平台特定的行尾符號。這種在幕後對檔案資料的修改方式對"
"文字檔案來說沒有問題，但會毀壞像是 :file:`JPEG` 或 :file:`EXE` 檔案中的二進制"
"資料。在讀寫此類檔案時，注意一定要使用二進制模式。"
#:
../../tutorial/inputoutput.rst:352
msgid
""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects. The advantage is that the file is properly closed after its "
"suite finishes, even if an exception is raised at some point. "
"Using :keyword:`!with` is also much shorter than writing "
"equivalent :keyword:`try`
\\
-
\\
:keyword:`finally` blocks::"
msgstr
""
"在處理檔案物件時，使用 :keyword:`with` 關鍵字是個好習慣。優點是，當它的套件結"
"束後，即使在某個時刻引發了例外，檔案仍會正確地被關閉。使用 :keyword:`!with` "
"也比寫等效的 :keyword:`try`
\\
-
\\
:keyword:`finally` 區塊，來得簡短許多： ::"
#:
../../tutorial/inputoutput.rst:358
msgid
""
">>> with open('workfile', encoding=
\"
utf-8
\"
) as f:\n"
"... read_data = f.read()\n"
"\n"
">>> # We can check that the file has been automatically closed.\n"
">>> f.closed\n"
"True"
msgstr
""
">>> with open('workfile', encoding=
\"
utf-8
\"
) as f:\n"
"... read_data = f.read()\n"
"\n"
">>> # 我們可以檢查確認該檔案已經自動被關閉。\n"
">>> f.closed\n"
"True"
#:
../../tutorial/inputoutput.rst:365
msgid
""
"If you're not using the :keyword:`with` keyword, then you should call "
"``f.close()`` to close the file and immediately free up any system resources "
"used by it."
msgstr
""
"如果你沒有使用 :keyword:`with` 關鍵字，則應呼叫 ``f.close()`` 關閉檔案，可以"
"立即釋放被它所使用的系統資源。"
#:
../../tutorial/inputoutput.rst:370
msgid
""
"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "
"``f.close()`` **might** result in the arguments of ``f.write()`` not being "
"completely written to the disk, even if the program exits successfully."
msgstr
""
"呼叫 ``f.write()`` 時，若未使用 :keyword:`!with` 關鍵字或呼叫 ``f.close()``，"
"即使程式成功退出，也
\\
**可能**
\\
導致 ``f.write()`` 的引數沒有被完全寫入硬"
"碟。"
#:
../../tutorial/inputoutput.rst:378
msgid
""
"After a file object is closed, either by a :keyword:`with` statement or by "
"calling ``f.close()``, attempts to use the file object will automatically "
"fail. ::"
msgstr
""
"不論是透過 :keyword:`with` 陳述式，或呼叫 ``f.close()`` 關閉一個檔案物件之"
"後，嘗試使用該檔案物件將會自動失效。 ::"
#:
../../tutorial/inputoutput.rst:382
msgid
""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
" File
\"
<stdin>
\"
, line 1, in <module>\n"
"ValueError: I/O operation on closed file."
msgstr
""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
" File
\"
<stdin>
\"
, line 1, in <module>\n"
"ValueError: I/O operation on closed file."
#:
../../tutorial/inputoutput.rst:392
msgid
"Methods of File Objects"
msgstr
"檔案物件的 method"
#:
../../tutorial/inputoutput.rst:394
msgid
""
"The rest of the examples in this section will assume that a file object "
"called ``f`` has already been created."
msgstr
"本節其餘的範例皆假設一個名為 ``f`` 的檔案物件已被建立。"
#:
../../tutorial/inputoutput.rst:397
msgid
""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string (in text mode) or bytes object (in binary "
"mode). *size* is an optional numeric argument. When *size* is omitted or "
"negative, the entire contents of the file will be read and returned; it's "
"your problem if the file is twice as large as your machine's memory. "
"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "
"binary mode) are read and returned. If the end of the file has been reached, "
"``f.read()`` will return an empty string (``''``). ::"
msgstr
""
"要讀取檔案的內容，可呼叫 ``f.read(size)``，它可讀取一部份的資料，並以字串（文"
"字模式）或位元組串物件（二進制模式）形式回傳。*size* 是個選擇性的數字引數。"
"當 *size* 被省略或為負數時，檔案的全部內容會被讀取並回傳；如果檔案是機器記憶"
"體容量的兩倍大時，這會是你的問題。否則，最多只有等同於 *size* 數量的字元（文"
"字模式）或 *size* 數量的位元組串（二進制模式）會被讀取及回傳。如果之前已經到"
"達檔案的末端，``f.read()`` 會回傳空字串（``''``）。 ::"
#:
../../tutorial/inputoutput.rst:406
msgid
""
">>> f.read()\n"
"'This is the entire file.
\\
n'\n"
">>> f.read()\n"
"''"
msgstr
""
">>> f.read()\n"
"'This is the entire file.
\\
n'\n"
">>> f.read()\n"
"''"
#:
../../tutorial/inputoutput.rst:411
msgid
""
"``f.readline()`` reads a single line from the file; a newline character "
"(``
\\
n``) is left at the end of the string, and is only omitted on the last "
"line of the file if the file doesn't end in a newline. This makes the "
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
"end of the file has been reached, while a blank line is represented by "
"``'
\\
n'``, a string containing only a single newline. ::"
msgstr
""
"``f.readline()`` 從檔案中讀取單獨一行；換行字元（``
\\
n``）會被留在字串的結"
"尾，只有當檔案末端不是換行字元時，它才會在檔案的最後一行被省略。這種方式讓回"
"傳值清晰明確；只要 ``f.readline()`` 回傳一個空字串，就表示已經到達了檔案末"
"端，而空白行的表示法是 ``'
\\
n'``，也就是只含一個換行字元的字串。 ::"
#:
../../tutorial/inputoutput.rst:418
msgid
""
">>> f.readline()\n"
"'This is the first line of the file.
\\
n'\n"
">>> f.readline()\n"
"'Second line of the file
\\
n'\n"
">>> f.readline()\n"
"''"
msgstr
""
">>> f.readline()\n"
"'This is the first line of the file.
\\
n'\n"
">>> f.readline()\n"
"'Second line of the file
\\
n'\n"
">>> f.readline()\n"
"''"
#:
../../tutorial/inputoutput.rst:425
msgid
""
"For reading lines from a file, you can loop over the file object. This is "
"memory efficient, fast, and leads to simple code::"
msgstr
""
"想從檔案中讀取多行時，可以對檔案物件進行迴圈。這種方法能有效地使用記憶體、快"
"速，且程式碼簡潔： ::"
#:
../../tutorial/inputoutput.rst:428
msgid
""
">>> for line in f:\n"
"... print(line, end='')\n"
"...\n"
"This is the first line of the file.\n"
"Second line of the file"
msgstr
""
">>> for line in f:\n"
"... print(line, end='')\n"
"...\n"
"This is the first line of the file.\n"
"Second line of the file"
#:
../../tutorial/inputoutput.rst:434
msgid
""
"If you want to read all the lines of a file in a list you can also use "
"``list(f)`` or ``f.readlines()``."
msgstr
""
"如果你想把一個檔案的所有行讀進一個 list 裡，可以用 ``list(f)`` 或 "
"``f.readlines()``。"
#:
../../tutorial/inputoutput.rst:437
msgid
""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"the number of characters written. ::"
msgstr
""
"``f.write(string)`` 把 *string* 的內容寫入檔案，並回傳寫入的字元數。 ::"
#:
../../tutorial/inputoutput.rst:440
msgid
""
">>> f.write('This is a test
\\
n')\n"
"15"
msgstr
""
">>> f.write('This is a test
\\
n')\n"
"15"
#:
../../tutorial/inputoutput.rst:443
msgid
""
"Other types of objects need to be converted -- either to a string (in text "
"mode) or a bytes object (in binary mode) -- before writing them::"
msgstr
""
"寫入其他類型的物件之前，要先把它們轉換為字串（文字模式）或位元組串物件（二進"
"制模式）： ::"
#:
../../tutorial/inputoutput.rst:446
msgid
""
">>> value = ('the answer', 42)\n"
">>> s = str(value) # convert the tuple to string\n"
">>> f.write(s)\n"
"18"
msgstr
""
">>> value = ('the answer', 42)\n"
">>> s = str(value) # 將元組轉換成字串\n"
">>> f.write(s)\n"
"18"
#:
../../tutorial/inputoutput.rst:451
msgid
""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file represented as number of bytes from the beginning of the file when "
"in binary mode and an opaque number when in text mode."
msgstr
""
"``f.tell()`` 回傳一個整數，它給出檔案物件在檔案中的目前位置，在二進制模式下表"
"示為檔案開始至今的位元組數，在文字模式下表示為一個意義不明的數字。"
#:
../../tutorial/inputoutput.rst:455
msgid
""
"To change the file object's position, use ``f.seek(offset, whence)``. The "
"position is computed from adding *offset* to a reference point; the "
"reference point is selected by the *whence* argument. A *whence* value of 0 "
"measures from the beginning of the file, 1 uses the current file position, "
"and 2 uses the end of the file as the reference point. *whence* can be "
"omitted and defaults to 0, using the beginning of the file as the reference "
"point. ::"
msgstr
""
"使用 ``f.seek(offset, whence)`` 可以改變檔案物件的位置。位置計算方法是從一個"
"參考點增加 *offset* 的偏移量；參考點則由引數 *whence* 來選擇。當 *whence* 值"
"為 0 時，表示使用檔案開頭，1 表示使用目前的檔案位置，2 表示使用檔案末端作為參"
"考點。*whence* 可省略，其預設值為 0，即以檔案開頭作為參考點。 ::"
#:
../../tutorial/inputoutput.rst:462
msgid
""
">>> f = open('workfile', 'rb+')\n"
">>> f.write(b'0123456789abcdef')\n"
"16\n"
">>> f.seek(5) # Go to the 6th byte in the file\n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2) # Go to the 3rd byte before the end\n"
"13\n"
">>> f.read(1)\n"
"b'd'"
msgstr
""
">>> f = open('workfile', 'rb+')\n"
">>> f.write(b'0123456789abcdef')\n"
"16\n"
">>> f.seek(5) # 跳到檔案中的第六個位元組\n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2) # 跳到結尾前的第三個位元組\n"
"13\n"
">>> f.read(1)\n"
"b'd'"
#:
../../tutorial/inputoutput.rst:474
msgid
""
"In text files (those opened without a ``b`` in the mode string), only seeks "
"relative to the beginning of the file are allowed (the exception being "
"seeking to the very file end with ``seek(0, 2)``) and the only valid "
"*offset* values are those returned from the ``f.tell()``, or zero. Any other "
"*offset* value produces undefined behaviour."
msgstr
""
"在文字檔案（開啟時模式字串未加入 ``b`` 的檔案）中，只允許以檔案開頭為參考點進"
"行尋找（但 ``seek(0, 2)`` 尋找檔案最末端是例外），且只有從 ``f.tell()`` 回傳"
"的值，或是 0，才是有效的 *offset* 值。其他任何 *offset* 值都會產生未定義的行"
"為。"
#:
../../tutorial/inputoutput.rst:480
msgid
""
"File objects have some additional methods, such as :meth:`~io.IOBase.isatty` "
"and :meth:`~io.IOBase.truncate` which are less frequently used; consult the "
"Library Reference for a complete guide to file objects."
msgstr
""
"檔案物件還有一些附加的 method，像是較不常使用的 :meth:`~io.IOBase.isatty` "
"和 :meth:`~io.IOBase.truncate`；檔案物件的完整指南詳見程式庫參考手冊。"
#:
../../tutorial/inputoutput.rst:488
msgid
"Saving structured data with :mod:`json`"
msgstr
"使用 :mod:`json` 儲存結構化資料"
#:
../../tutorial/inputoutput.rst:492
msgid
""
"Strings can easily be written to and read from a file. Numbers take a bit "
"more effort, since the :meth:`~io.TextIOBase.read` method only returns "
"strings, which will have to be passed to a function like :func:`int`, which "
"takes a string like ``'123'`` and returns its numeric value 123. When you "
"want to save more complex data types like nested lists and dictionaries, "
"parsing and serializing by hand becomes complicated."
msgstr
""
"字串可以簡單地從檔案中被寫入和讀取。數字則稍嫌麻煩，因"
"為 :meth:`~io.TextIOBase.read` method 只回傳字串，這些字串必須傳遞給"
"像 :func:`int` 這樣的函式，它接受 ``'123'`` 這樣的字串，並回傳數值 123。當你"
"想儲存像是巢狀 list 和 dictionary（字典）等複雜的資料類型時，手動剖析 "
"(parsing) 和序列化 (serializing) 就變得複雜。"
#:
../../tutorial/inputoutput.rst:499
msgid
""
"Rather than having users constantly writing and debugging code to save "
"complicated data types to files, Python allows you to use the popular data "
"interchange format called `JSON (JavaScript Object Notation) <https://"
"json.org>`_. The standard module called :mod:`json` can take Python data "
"hierarchies, and convert them to string representations; this process is "
"called :dfn:`serializing`. Reconstructing the data from the string "
"representation is called :dfn:`deserializing`. Between serializing and "
"deserializing, the string representing the object may have been stored in a "
"file or data, or sent over a network connection to some distant machine."
msgstr
""
"相較於讓使用者不斷地編寫和除錯程式碼才能把複雜的資料類型儲存到檔案，Python 支"
"援一個普及的資料交換格式，稱為 `JSON (JavaScript Object Notation) <https://"
View remainder of file in raw view
Back
|
FazBrowse Home
|
New Git URL