FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
python-docs-ko/tutorial/modules.po at 3.13 · python/python-docs-ko · GitHub
python
python-docs-ko
Repository navigation
Code
Issues
377
(377)
Pull requests
1
(1)
Actions
Security and quality
Insights
Expand file tree
Breadcrumbs
python-docs-ko
/
tutorial
/
modules.po
Copy path
More file actions
More file actions
Latest commit
History
History
History
1248 lines (1130 loc) · 59.9 KB
Breadcrumbs
python-docs-ko
/
tutorial
/
modules.po
Copy path
File metadata and controls
1248 lines (1130 loc) · 59.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
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#
SOME DESCRIPTIVE TITLE.
#
Copyright (C) 2001-2017, Python Software Foundation
#
This file is distributed under the same license as the Python package.
#
FIRST AUTHOR <EMAIL@ADDRESS>, 2017.
#
msgid ""
msgstr ""
"
Project-Id-Version
:
Python 3.6\n
"
"
Report-Msgid-Bugs-To
:
\n
"
"
POT-Creation-Date
:
2025-04-17 23:44+0000\n
"
"
PO-Revision-Date
:
YEAR-MO-DA HO:MI+ZONE\n
"
"
Last-Translator
:
Dong-gweon Oh <flowdas@gmail.com>\n
"
"
Language-Team
:
Korean (https://python.flowdas.com)\n
"
"
MIME-Version
:
1.0\n
"
"
Content-Type
:
text/plain; charset=utf-8\n
"
"
Content-Transfer-Encoding
:
8bit\n
"
"
Generated-By
:
Babel 2.17.0\n
"
#:
../../tutorial/modules.rst:5
msgid
"Modules"
msgstr
"모듈"
#:
../../tutorial/modules.rst:7
msgid
""
"If you quit from the Python interpreter and enter it again, the "
"definitions you have made (functions and variables) are lost. Therefore, "
"if you want to write a somewhat longer program, you are better off using "
"a text editor to prepare the input for the interpreter and running it "
"with that file as input instead. This is known as creating a *script*. "
"As your program gets longer, you may want to split it into several files "
"for easier maintenance. You may also want to use a handy function that "
"you've written in several programs without copying its definition into "
"each program."
msgstr
""
"파이썬 인터프리터를 종료한 후에 다시 들어가면, 여러분이 만들었던 정의들이 사라집니다 (함수나 변수들). 그래서, 좀 긴 프로그램을"
" 쓰고자 한다면, 대신 인터프리터 입력을 편집기를 사용해서 준비한 후에 그 파일을 입력으로 사용해서 실행하는 것이 좋습니다. 이렇게"
" 하는 것을 *스크립트* 를 만든다고 합니다. 프로그램이 길어짐에 따라, 유지를 쉽게 하려고 여러 개의 파일로 나누고 싶을 수 "
"있습니다. 여러 프로그램에서 썼던 편리한 함수를 각 프로그램에 정의를 복사하지 않고도 사용하고 싶을 수도 있습니다."
#:
../../tutorial/modules.rst:16
msgid
""
"To support this, Python has a way to put definitions in a file and use "
"them in a script or in an interactive instance of the interpreter. Such a"
" file is called a *module*; definitions from a module can be *imported* "
"into other modules or into the *main* module (the collection of variables"
" that you have access to in a script executed at the top level and in "
"calculator mode)."
msgstr
""
"이런 것을 지원하기 위해, 파이썬은 정의들을 파일에 넣고 스크립트나 인터프리터의 대화형 모드에서 사용할 수 있는 방법을 제공합니다."
" 그런 파일을 *모듈* 이라고 부릅니다; 모듈로부터 정의들이 다른 모듈이나 *메인* 모듈로 *임포트* 될 수 있습니다 (메인 모듈은"
" 최상위 수준에서 실행되는 스크립트나 계산기 모드에서 액세스하는 변수들의 컬렉션입니다)."
#:
../../tutorial/modules.rst:22
msgid
""
"A module is a file containing Python definitions and statements. The "
"file name is the module name with the suffix :file:`.py` appended. "
"Within a module, the module's name (as a string) is available as the "
"value of the global variable ``__name__``. For instance, use your "
"favorite text editor to create a file called :file:`fibo.py` in the "
"current directory with the following contents::"
msgstr
""
"모듈은 파이썬 정의와 문장들을 담고 있는 파일입니다. 파일의 이름은 모듈 이름에 확장자 :file:`.py` 를 붙입니다. 모듈 "
"내에서, 모듈의 이름은 전역 변수 ``__name__`` 으로 제공됩니다. 예를 들어, 여러분이 좋아하는 편집기로 "
":file:`fibo.py` 라는 이름의 파일을 현재 디렉터리에 만들고 다음과 같은 내용으로 채웁니다::"
#:
../../tutorial/modules.rst:28
msgid
""
"# Fibonacci numbers module\n"
"\n"
"def fib(n): # write Fibonacci series up to n\n"
" a, b = 0, 1\n"
" while a < n:\n"
" print(a, end=' ')\n"
" a, b = b, a+b\n"
" print()\n"
"\n"
"def fib2(n): # return Fibonacci series up to n\n"
" result = []\n"
" a, b = 0, 1\n"
" while a < n:\n"
" result.append(a)\n"
" a, b = b, a+b\n"
" return result"
msgstr
""
"# 피보나치 수 모듈\n"
"\n"
"def fib(n): # n 보다 작은 피보나치 수열을 인쇄합니다\n"
" a, b = 0, 1\n"
" while a < n:\n"
" print(a, end=' ')\n"
" a, b = b, a+b\n"
" print()\n"
"\n"
"def fib2(n): # n 보다 작은 피보나치 수열을 돌려줍니다\n"
" result = []\n"
" a, b = 0, 1\n"
" while a < n:\n"
" result.append(a)\n"
" a, b = b, a+b\n"
" return result"
#:
../../tutorial/modules.rst:45
msgid
""
"Now enter the Python interpreter and import this module with the "
"following command::"
msgstr
"이제 파이썬 인터프리터에 들어가서 이 모듈을 다음과 같은 명령으로 임포트 합니다::"
#:
../../tutorial/modules.rst:48
msgid
">>> import fibo"
msgstr
">>> import fibo"
#:
../../tutorial/modules.rst:50
msgid
""
"This does not add the names of the functions defined in ``fibo`` "
"directly to the current :term:`namespace` (see :ref:`tut-scopes` for more"
" details); it only adds the module name ``fibo`` there. Using the module "
"name you can access the functions::"
msgstr
""
"이렇게 한다고 ``fibo`` 에 정의된 함수들의 이름을 현재 :term:`이름 공간 <namespace>`
\\
에 직접 추가하지는 "
"않습니다 (자세한 내용은 :ref:`tut-scopes`
\\
를 참조하세요); 오직 모듈 이름 ``fibo`` 만 추가할 뿐입니다. "
"이 모듈 이름을 사용해서 함수들을 액세스할 수 있습니다::"
#:
../../tutorial/modules.rst:55
msgid
""
">>> fibo.fib(1000)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n"
">>> fibo.fib2(100)\n"
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"
">>> fibo.__name__\n"
"'fibo'"
msgstr
""
">>> fibo.fib(1000)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987\n"
">>> fibo.fib2(100)\n"
"[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"
">>> fibo.__name__\n"
"'fibo'"
#:
../../tutorial/modules.rst:62
msgid
"If you intend to use a function often you can assign it to a local name::"
msgstr
"함수를 자주 사용할 거라면 지역 이름으로 대입할 수 있습니다::"
#:
../../tutorial/modules.rst:64
msgid
""
">>> fib = fibo.fib\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr
""
">>> fib = fibo.fib\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
#:
../../tutorial/modules.rst:72
msgid
"More on Modules"
msgstr
"모듈 더 보기"
#:
../../tutorial/modules.rst:74
msgid
""
"A module can contain executable statements as well as function "
"definitions. These statements are intended to initialize the module. They"
" are executed only the *first* time the module name is encountered in an "
"import statement. [#]_ (They are also run if the file is executed as a "
"script.)"
msgstr
""
"모듈은 함수 정의뿐만 아니라 실행 가능한 문장들도 포함할 수 있습니다. 이 문장들은 모듈을 초기화하는 데 사용됩니다. 이것들은 "
"임포트 문에서 모듈 이름이 *처음* 등장할 때만 실행됩니다. [#]_ (이것들은 파일이 스크립트로 실행될 때도 실행됩니다.)"
#:
../../tutorial/modules.rst:79
msgid
""
"Each module has its own private namespace, which is used as the global "
"namespace by all functions defined in the module. Thus, the author of a "
"module can use global variables in the module without worrying about "
"accidental clashes with a user's global variables. On the other hand, if "
"you know what you are doing you can touch a module's global variables "
"with the same notation used to refer to its functions, "
"``modname.itemname``."
msgstr
""
"각 모듈은 자신만의 이름 공간을 갖고 있는데, 그 모듈에서 정의된 함수들의 전역 이름 공간으로 사용됩니다. 그래서, 모듈의 저자는 "
"사용자의 전역 변수와 우연히 충돌할 것을 걱정하지 않고 전역 변수를 사용할 수 있습니다. 반면에, 여러분이 무얼 하는지 안다면, "
"모듈의 함수를 참조하는데 사용된 것과 같은 표기법으로 모듈의 전역 변수들을 건드릴 수 있습니다, "
"``modname.itemname``."
#:
../../tutorial/modules.rst:86
msgid
""
"Modules can import other modules. It is customary but not required to "
"place all :keyword:`import` statements at the beginning of a module (or "
"script, for that matter). The imported module names, if placed at the "
"top level of a module (outside any functions or classes), are added to "
"the module's global namespace."
msgstr
""
"모듈은 다른 모듈들을 임포트할 수 있습니다. 모든 :keyword:`import` 문들을 모듈의 처음에 놓는 것이 관례지만 반드시 "
"그래야 하는 것은 아닙니다 (그 점에 관한 한 스크립트도 마찬가집니다). 임포트되는 모듈 이름은, 모듈의 최상위 수준(함수나 "
"클래스의 바깥)에 배치되면, 임포트하는 모듈의 전역 이름 공간에 추가됩니다."
#:
../../tutorial/modules.rst:91
msgid
""
"There is a variant of the :keyword:`import` statement that imports names "
"from a module directly into the importing module's namespace. For "
"example::"
msgstr
""
"모듈에 들어있는 이름들을 직접 임포트하는 모듈의 이름 공간으로 임포트하는 :keyword:`import` 문의 변종이 있습니다. "
"예를 들어::"
#:
../../tutorial/modules.rst:94
msgid
""
">>> from fibo import fib, fib2\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr
""
">>> from fibo import fib, fib2\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
#:
../../tutorial/modules.rst:98
msgid
""
"This does not introduce the module name from which the imports are taken "
"in the local namespace (so in the example, ``fibo`` is not defined)."
msgstr
"이것은 지역 이름 공간에 임포트되는 모듈의 이름을 만들지 않습니다 (그래서 이 예에서는, ``fibo`` 가 정의되지 않습니다)."
#:
../../tutorial/modules.rst:101
msgid
"There is even a variant to import all names that a module defines::"
msgstr
"모듈이 정의하는 모든 이름을 임포트하는 변종도 있습니다::"
#:
../../tutorial/modules.rst:103
msgid
""
">>> from fibo import *\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr
""
">>> from fibo import *\n"
">>> fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
#:
../../tutorial/modules.rst:107
msgid
""
"This imports all names except those beginning with an underscore (``_``)."
" In most cases Python programmers do not use this facility since it "
"introduces an unknown set of names into the interpreter, possibly hiding "
"some things you have already defined."
msgstr
""
"이것은 밑줄 (``_``) 로 시작하는 것들을 제외한 모든 이름을 임포트 합니다. 대부분 파이썬 프로그래머들은 이 기능을 사용하지 "
"않는데, 인터프리터로 알려지지 않은 이름들의 집합을 도입하게 되어, 여러분이 이미 정의한 것들을 가리게 될 수 있기 때문입니다."
#:
../../tutorial/modules.rst:112
msgid
""
"Note that in general the practice of importing ``*`` from a module or "
"package is frowned upon, since it often causes poorly readable code. "
"However, it is okay to use it to save typing in interactive sessions."
msgstr
""
"일반적으로 모듈이나 패키지에서 ``*`` 를 임포트하는 것은 눈살을 찌푸리게 한다는 것에 유의하세요, 종종 읽기에 편하지 않은 "
"코드를 만들기 때문입니다. 하지만, 대화형 세션에서 입력을 줄이고자 사용하는 것은 상관없습니다."
#:
../../tutorial/modules.rst:116
msgid
""
"If the module name is followed by :keyword:`!as`, then the name following"
" :keyword:`!as` is bound directly to the imported module."
msgstr
"모듈 이름 다음에 :keyword:`!as` 가 올 경우, :keyword:`!as` 다음의 이름을 임포트한 모듈에 직접 연결합니다."
#:
../../tutorial/modules.rst:121
msgid
""
">>> import fibo as fib\n"
">>> fib.fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr
""
">>> import fibo as fib\n"
">>> fib.fib(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
#:
../../tutorial/modules.rst:125
msgid
""
"This is effectively importing the module in the same way that ``import "
"fibo`` will do, with the only difference of it being available as "
"``fib``."
msgstr
""
"이것은 ``import fibo`` 가하는 것과 같은 방식으로 모듈을 임포트 하는데, 유일한 차이점은 그 모듈을 ``fib`` 라는"
" 이름으로 사용할 수 있다는 것입니다."
#:
../../tutorial/modules.rst:128
msgid
"It can also be used when utilising :keyword:`from` with similar effects::"
msgstr
":keyword:`from`
\\
을 써서 비슷한 효과를 낼 때도 사용할 수 있습니다::"
#:
../../tutorial/modules.rst:130
msgid
""
">>> from fibo import fib as fibonacci\n"
">>> fibonacci(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
msgstr
""
">>> from fibo import fib as fibonacci\n"
">>> fibonacci(500)\n"
"0 1 1 2 3 5 8 13 21 34 55 89 144 233 377"
#:
../../tutorial/modules.rst:137
msgid
""
"For efficiency reasons, each module is only imported once per interpreter"
" session. Therefore, if you change your modules, you must restart the "
"interpreter -- or, if it's just one module you want to test "
"interactively, use :func:`importlib.reload`, e.g. ``import importlib; "
"importlib.reload(modulename)``."
msgstr
""
"효율성의 이유로, 각 모듈은 인터프리터 세션마다 한 번만 임포트됩니다. 그래서, 여러분이 모듈을 수정하면, 인터프리터를 다시 "
"시작시켜야 합니다 --- 또는, 대화형으로 시험하는 모듈이 하나뿐이라면, :func:`importlib.reload` 를 "
"사용하세요. 예를 들어, ``import importlib; importlib.reload(modulename)``."
#:
../../tutorial/modules.rst:147
msgid
"Executing modules as scripts"
msgstr
"모듈을 스크립트로 실행하기"
#:
../../tutorial/modules.rst:149
msgid
"When you run a Python module with ::"
msgstr
"여러분이 파이썬 모듈을 이렇게 실행하면 ::"
#:
../../tutorial/modules.rst:151
msgid
"python fibo.py <arguments>"
msgstr
"python fibo.py <arguments>"
#:
../../tutorial/modules.rst:153
msgid
""
"the code in the module will be executed, just as if you imported it, but "
"with the ``__name__`` set to ``
\"
__main__
\"
``. That means that by adding"
" this code at the end of your module::"
msgstr
""
"모듈에 있는 코드는, 그것을 임포트할 때처럼 실행됩니다. 하지만 ``__name__`` 은 ``
\"
__main__
\"
`` 로 "
"설정됩니다. 이것은, 이 코드를 모듈의 끝에 붙여서::"
#:
../../tutorial/modules.rst:157
msgid
""
"if __name__ ==
\"
__main__
\"
:\n"
" import sys\n"
" fib(int(sys.argv[1]))"
msgstr
""
"if __name__ ==
\"
__main__
\"
:\n"
" import sys\n"
" fib(int(sys.argv[1]))"
#:
../../tutorial/modules.rst:161
msgid
""
"you can make the file usable as a script as well as an importable module,"
" because the code that parses the command line only runs if the module is"
" executed as the
\"
main
\"
file:"
msgstr
""
"파일을 임포트할 수 있는 모듈뿐만 아니라 스크립트로도 사용할 수 있도록 만들 수 있음을 의미하는데, 오직 모듈이
\"
메인
\"
파일로"
" 실행될 때만 명령행을 파싱하는 코드가 실행되기 때문입니다:"
#:
../../tutorial/modules.rst:165
msgid
""
"$ python fibo.py 50\n"
"0 1 1 2 3 5 8 13 21 34"
msgstr
""
"$ python fibo.py 50\n"
"0 1 1 2 3 5 8 13 21 34"
#:
../../tutorial/modules.rst:170
msgid
"If the module is imported, the code is not run::"
msgstr
"모듈이 임포트될 때, 코드는 실행되지 않습니다::"
#:
../../tutorial/modules.rst:172
msgid
""
">>> import fibo\n"
">>>"
msgstr
""
">>> import fibo\n"
">>>"
#:
../../tutorial/modules.rst:175
msgid
""
"This is often used either to provide a convenient user interface to a "
"module, or for testing purposes (running the module as a script executes "
"a test suite)."
msgstr
""
"이것은 종종 모듈에 대한 편리한 사용자 인터페이스를 제공하거나 테스트 목적으로 사용됩니다 (모듈을 스크립트로 실행하면 테스트 "
"스위트를 실행하기)."
#:
../../tutorial/modules.rst:182
msgid
"The Module Search Path"
msgstr
"모듈 검색 경로"
#:
../../tutorial/modules.rst:186
msgid
""
"When a module named :mod:`!spam` is imported, the interpreter first "
"searches for a built-in module with that name. These module names are "
"listed in :data:`sys.builtin_module_names`. If not found, it then "
"searches for a file named :file:`spam.py` in a list of directories given "
"by the variable :data:`sys.path`. :data:`sys.path` is initialized from "
"these locations:"
msgstr
""
":mod:`!spam` 이라는 이름의 모듈이 임포트될 때, 인터프리터는 먼저 그 이름의 내장 모듈을 찾습니다. 이 모듈 이름들은 "
":data:`sys.builtin_module_names`
\\
에 나열됩니다. 발견되지 않으면, 변수 :data:`sys.path` "
"로 주어지는 디렉터리들에서 :file:`spam.py` 라는 이름의 파일을 찾습니다. :data:`sys.path` 는 이 위치들로"
" 초기화됩니다:"
#:
../../tutorial/modules.rst:192
msgid
""
"The directory containing the input script (or the current directory when "
"no file is specified)."
msgstr
"입력 스크립트를 포함하는 디렉터리 (또는 파일이 지정되지 않았을 때는 현재 디렉터리)."
#:
../../tutorial/modules.rst:194
msgid
""
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as "
"the shell variable :envvar:`PATH`)."
msgstr
":envvar:`PYTHONPATH` (디렉터리 이름들의 목록, 셸 변수 :envvar:`PATH` 와 같은 문법)."
#:
../../tutorial/modules.rst:196
msgid
""
"The installation-dependent default (by convention including a ``site-"
"packages`` directory, handled by the :mod:`site` module)."
msgstr
"설치 의존적인 기본값 (관례에 따라 ``site-packages`` 디렉터리를 포함합니다, :mod:`site` 모듈이 처리합니다)."
#:
../../tutorial/modules.rst:199
msgid
"More details are at :ref:`sys-path-init`."
msgstr
"자세한 내용은 :ref:`sys-path-init`
\\
에서 확인할 수 있습니다."
#:
../../tutorial/modules.rst:202
msgid
""
"On file systems which support symlinks, the directory containing the "
"input script is calculated after the symlink is followed. In other words "
"the directory containing the symlink is **not** added to the module "
"search path."
msgstr
""
"심볼릭 링크를 지원하는 파일 시스템에서, 입력 스크립트를 포함하는 디렉터리는 심볼릭 링크를 변환한 후에 계산됩니다. 다른 말로, "
"심볼릭 링크를 포함하는 디렉터리는 모듈 검색 경로에 포함되지 **않습니다**."
#:
../../tutorial/modules.rst:206
msgid
""
"After initialization, Python programs can modify :data:`sys.path`. The "
"directory containing the script being run is placed at the beginning of "
"the search path, ahead of the standard library path. This means that "
"scripts in that directory will be loaded instead of modules of the same "
"name in the library directory. This is an error unless the replacement is"
" intended. See section :ref:`tut-standardmodules` for more information."
msgstr
""
"초기화 후에, 파이썬 프로그램은 :data:`sys.path` 를 수정할 수 있습니다. 스크립트를 포함하는 디렉터리는 검색 경로의 "
"처음에, 표준 라이브러리 경로의 앞에 놓입니다. 이것은 같은 이름일 경우 라이브러리 디렉터리에 있는 것 대신 스크립트를 포함하는 "
"디렉터리의 것이 로드된다는 뜻입니다. 이 치환이 의도된 것이 아니라면 에러입니다. 더 자세한 정보는 :ref:`tut-"
"standardmodules` 을 보세요."
#:
../../tutorial/modules.rst:219
msgid
"
\"
Compiled
\"
Python files"
msgstr
"
\"
컴파일된
\"
파이썬 파일"
#:
../../tutorial/modules.rst:221
#,
python-brace-format
msgid
""
"To speed up loading modules, Python caches the compiled version of each "
"module in the ``__pycache__`` directory under the name "
":file:`module.{version}.pyc`, where the version encodes the format of the"
" compiled file; it generally contains the Python version number. For "
"example, in CPython release 3.3 the compiled version of spam.py would be "
"cached as ``__pycache__/spam.cpython-33.pyc``. This naming convention "
"allows compiled modules from different releases and different versions of"
" Python to coexist."
msgstr
""
"모듈 로딩을 빠르게 하려고, 파이썬은 ``__pycache__`` 디렉터리에 각 모듈의 컴파일된 버전을 "
":file:`module.{version}.pyc` 라는 이름으로 캐싱합니다. version 은 컴파일된 파일의 형식을 지정합니다;"
" 일반적으로 파이썬의 버전 번호를 포함합니다. 예를 들어, CPython 배포 3.3 에서 spam.py 의 컴파일된 버전은 "
"``__pycache__/spam.cpython-33.pyc`` 로 캐싱 됩니다. 이 명명법은 서로 다른 파이썬 배포와 버전의 "
"컴파일된 모듈들이 공존할 수 있도록 합니다."
#:
../../tutorial/modules.rst:229
msgid
""
"Python checks the modification date of the source against the compiled "
"version to see if it's out of date and needs to be recompiled. This is a"
" completely automatic process. Also, the compiled modules are platform-"
"independent, so the same library can be shared among systems with "
"different architectures."
msgstr
""
"파이썬은 소스의 수정 시간을 컴파일된 버전과 비교해서 시효가 지나 다시 컴파일해야 하는지 검사합니다. 이것은 완전히 자동화된 "
"과정입니다. 또한, 컴파일된 모듈은 플랫폼 독립적이기 때문에, 같은 라이브러리를 서로 다른 아키텍처를 갖는 시스템들에서 공유할 수 "
"있습니다."
#:
../../tutorial/modules.rst:234
msgid
""
"Python does not check the cache in two circumstances. First, it always "
"recompiles and does not store the result for the module that's loaded "
"directly from the command line. Second, it does not check the cache if "
"there is no source module. To support a non-source (compiled only) "
"distribution, the compiled module must be in the source directory, and "
"there must not be a source module."
msgstr
""
"파이썬은 두 가지 상황에서 캐시를 검사하지 않습니다. 첫째로, 명령행에서 직접 로드되는 모듈들은 항상 재컴파일하고 그 결과를 "
"저장하지 않습니다. 둘째로, 소스 모듈이 없으면 캐시를 검사하지 않습니다. 소스 없는 (컴파일된 파일만 있는) 배포를 지원하려면, "
"컴파일된 모듈이 소스 디렉터리에 있어야 하고, 소스 모듈이 없어야 합니다."
#:
../../tutorial/modules.rst:241
msgid
"Some tips for experts:"
msgstr
"전문가를 위한 몇 가지 팁"
#:
../../tutorial/modules.rst:243
msgid
""
"You can use the :option:`-O` or :option:`-OO` switches on the Python "
"command to reduce the size of a compiled module. The ``-O`` switch "
"removes assert statements, the ``-OO`` switch removes both assert "
"statements and __doc__ strings. Since some programs may rely on having "
"these available, you should only use this option if you know what you're "
"doing.
\"
Optimized
\"
modules have an ``opt-`` tag and are usually "
"smaller. Future releases may change the effects of optimization."
msgstr
""
"컴파일된 모듈의 크기를 줄이려면 파이썬 명령에 :option:`-O` 나 :option:`-OO` 스위치를 사용할 수 있습니다. "
"``-O`` 스위치는 assert 문을 제거하고, ``-OO`` 스위치는 assert 문과 __doc__ 문자열을 모두 제거합니다."
" 어떤 프로그램들은 이것들에 의존하기 때문에, 무엇을 하고 있는지 아는 경우만 이 옵션을 사용해야 합니다.
\"
최적화된
\"
모듈은 "
"``opt-`` 태그를 갖고, 보통 더 작습니다. 미래의 배포에서는 최적화의 효과가 변경될 수 있습니다."
#:
../../tutorial/modules.rst:251
msgid
""
"A program doesn't run any faster when it is read from a ``.pyc`` file "
"than when it is read from a ``.py`` file; the only thing that's faster "
"about ``.pyc`` files is the speed with which they are loaded."
msgstr
""
"``.py`` 파일에서 읽을 때보다 ``.pyc`` 파일에서 읽을 때 프로그램이 더 빨리 실행되지는 않습니다; ``.pyc`` "
"파일에서 더 빨라지는 것은 로드되는 속도뿐입니다."
#:
../../tutorial/modules.rst:255
msgid
""
"The module :mod:`compileall` can create .pyc files for all modules in a "
"directory."
msgstr
"모듈 :mod:`compileall` 은 디렉터리에 있는 모든 모듈의 .pyc 파일들을 만들 수 있습니다."
#:
../../tutorial/modules.rst:258
msgid
""
"There is more detail on this process, including a flow chart of the "
"decisions, in :pep:`3147`."
msgstr
"이 절차에 대한 더 자세한 정보, 결정들의 순서도를 포함합니다, 는 :pep:`3147` 에 나옵니다."
#:
../../tutorial/modules.rst:265
msgid
"Standard Modules"
msgstr
"표준 모듈들"
#:
../../tutorial/modules.rst:269
msgid
""
"Python comes with a library of standard modules, described in a separate "
"document, the Python Library Reference (
\"
Library Reference
\"
hereafter)."
" Some modules are built into the interpreter; these provide access to "
"operations that are not part of the core of the language but are "
"nevertheless built in, either for efficiency or to provide access to "
"operating system primitives such as system calls. The set of such "
"modules is a configuration option which also depends on the underlying "
"platform. For example, the :mod:`winreg` module is only provided on "
"Windows systems. One particular module deserves some attention: "
":mod:`sys`, which is built into every Python interpreter. The variables "
"``sys.ps1`` and ``sys.ps2`` define the strings used as primary and "
"secondary prompts::"
msgstr
""
"파이썬은 표준 모듈들의 라이브러리가 함께 오는데, 별도의 문서 파이썬 라이브러리 레퍼런스 (이후로는
\"
라이브러리 레퍼런스
\"
) "
"에서 설명합니다. 어떤 모듈들은 인터프리터에 내장됩니다; 이것들은 언어의 핵심적인 부분은 아니지만 그런데도 내장된 연산들에 대한 "
"액세스를 제공하는데, 효율이나 시스템 호출과 같은 운영 체제 기본 요소들에 대한 액세스를 제공하기 위함입니다. 그런 모듈들의 집합은"
" 설정 옵션인데 기반 플랫폼 의존적입니다. 예를 들어, :mod:`winreg` 모듈은 윈도우 시스템에서만 제공됩니다. 특별한 모듈"
" 하나는 주목을 받을 필요가 있습니다: :mod:`sys`. 모든 파이썬 인터프리터에 내장됩니다. 변수 ``sys.ps1`` 와 "
"``sys.ps2`` 는 기본과 보조 프롬프트로 사용되는 문자열을 정의합니다::"
#:
../../tutorial/modules.rst:281
msgid
""
">>> import sys\n"
">>> sys.ps1\n"
"'>>> '\n"
">>> sys.ps2\n"
"'... '\n"
">>> sys.ps1 = 'C> '\n"
"C> print('Yuck!')\n"
"Yuck!\n"
"C>"
msgstr
""
">>> import sys\n"
">>> sys.ps1\n"
"'>>> '\n"
">>> sys.ps2\n"
"'... '\n"
">>> sys.ps1 = 'C> '\n"
"C> print('Yuck!')\n"
"Yuck!\n"
"C>"
#:
../../tutorial/modules.rst:292
msgid
""
"These two variables are only defined if the interpreter is in interactive"
" mode."
msgstr
"이 두 개의 변수들은 인터프리터가 대화형 모드일 때만 정의됩니다."
#:
../../tutorial/modules.rst:294
msgid
""
"The variable ``sys.path`` is a list of strings that determines the "
"interpreter's search path for modules. It is initialized to a default "
"path taken from the environment variable :envvar:`PYTHONPATH`, or from a "
"built-in default if :envvar:`PYTHONPATH` is not set. You can modify it "
"using standard list operations::"
msgstr
""
"변수 ``sys.path`` 는 인터프리터의 모듈 검색 경로를 결정하는 문자열들의 리스트입니다. 환경 변수 "
":envvar:`PYTHONPATH` 에서 취한 기본 경로나, :envvar:`PYTHONPATH` 가 설정되지 않는 경우 내장 "
"기본값으로 초기화됩니다. 표준 리스트 연산을 사용해서 수정할 수 있습니다::"
#:
../../tutorial/modules.rst:300
msgid
""
">>> import sys\n"
">>> sys.path.append('/ufs/guido/lib/python')"
msgstr
""
">>> import sys\n"
">>> sys.path.append('/ufs/guido/lib/python')"
#:
../../tutorial/modules.rst:307
msgid
"The :func:`dir` Function"
msgstr
":func:`dir` 함수"
#:
../../tutorial/modules.rst:309
msgid
""
"The built-in function :func:`dir` is used to find out which names a "
"module defines. It returns a sorted list of strings::"
msgstr
"내장 함수 :func:`dir` 은 모듈이 정의하는 이름들을 찾는 데 사용됩니다. 문자열들의 정렬된 리스트를 돌려줍니다::"
#:
../../tutorial/modules.rst:312
msgid
""
">>> import fibo, sys\n"
">>> dir(fibo)\n"
"['__name__', 'fib', 'fib2']\n"
">>> dir(sys)\n"
"['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',\n"
" '__interactivehook__', '__loader__', '__name__', '__package__', "
"'__spec__',\n"
" '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',\n"
" '_clear_type_cache', '_current_frames', '_debugmallocstats', "
"'_framework',\n"
" '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',\n"
" 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',\n"
" 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',\n"
" 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', "
"'exc_info',\n"
" 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', "
"'float_info',\n"
" 'float_repr_style', 'get_asyncgen_hooks', "
"'get_coroutine_origin_tracking_depth',\n"
" 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',\n"
" 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',\n"
" 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',\n"
" 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',\n"
" 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',\n"
" 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',\n"
" 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', "
"'pycache_prefix',\n"
" 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', "
"'setdlopenflags',\n"
" 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', "
"'stderr',\n"
" 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', "
"'version_info',\n"
" 'warnoptions']"
msgstr
""
">>> import fibo, sys\n"
">>> dir(fibo)\n"
"['__name__', 'fib', 'fib2']\n"
">>> dir(sys)\n"
"['__breakpointhook__', '__displayhook__', '__doc__', '__excepthook__',\n"
" '__interactivehook__', '__loader__', '__name__', '__package__', "
"'__spec__',\n"
" '__stderr__', '__stdin__', '__stdout__', '__unraisablehook__',\n"
" '_clear_type_cache', '_current_frames', '_debugmallocstats', "
"'_framework',\n"
" '_getframe', '_git', '_home', '_xoptions', 'abiflags', 'addaudithook',\n"
" 'api_version', 'argv', 'audit', 'base_exec_prefix', 'base_prefix',\n"
" 'breakpointhook', 'builtin_module_names', 'byteorder', 'call_tracing',\n"
" 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', "
"'exc_info',\n"
" 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', "
"'float_info',\n"
" 'float_repr_style', 'get_asyncgen_hooks', "
"'get_coroutine_origin_tracking_depth',\n"
" 'getallocatedblocks', 'getdefaultencoding', 'getdlopenflags',\n"
" 'getfilesystemencodeerrors', 'getfilesystemencoding', 'getprofile',\n"
" 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval',\n"
" 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',\n"
" 'intern', 'is_finalizing', 'last_traceback', 'last_type', 'last_value',\n"
" 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks',\n"
" 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', "
"'pycache_prefix',\n"
" 'set_asyncgen_hooks', 'set_coroutine_origin_tracking_depth', "
"'setdlopenflags',\n"
" 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', "
"'stderr',\n"
" 'stdin', 'stdout', 'thread_info', 'unraisablehook', 'version', "
"'version_info',\n"
" 'warnoptions']"
#:
../../tutorial/modules.rst:338
msgid
""
"Without arguments, :func:`dir` lists the names you have defined "
"currently::"
msgstr
"인자가 없으면, :func:`dir` 는 현재 정의한 이름들을 나열합니다::"
#:
../../tutorial/modules.rst:340
msgid
""
">>> a = [1, 2, 3, 4, 5]\n"
">>> import fibo\n"
">>> fib = fibo.fib\n"
">>> dir()\n"
"['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']"
msgstr
""
">>> a = [1, 2, 3, 4, 5]\n"
">>> import fibo\n"
">>> fib = fibo.fib\n"
">>> dir()\n"
"['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']"
#:
../../tutorial/modules.rst:346
msgid
"Note that it lists all types of names: variables, modules, functions, etc."
msgstr
"모든 형의 이름을 나열한다는 것에 유의해야 합니다: 변수, 모듈, 함수, 등등."
#:
../../tutorial/modules.rst:350
msgid
""
":func:`dir` does not list the names of built-in functions and variables."
" If you want a list of those, they are defined in the standard module "
":mod:`builtins`::"
msgstr
""
":func:`dir` 은 내장 함수와 변수들의 이름을 나열하지 않습니다. 그것들의 목록을 원한다면, 표준 모듈 "
":mod:`builtins` 에 정의되어 있습니다::"
#:
../../tutorial/modules.rst:354
msgid
""
">>> import builtins\n"
">>> dir(builtins)\n"
"['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',\n"
" 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',\n"
" 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',\n"
" 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',\n"
" 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',\n"
" 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',\n"
" 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',\n"
" 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',\n"
" 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',\n"
" 'MemoryError', 'NameError', 'None', 'NotADirectoryError', "
"'NotImplemented',\n"
" 'NotImplementedError', 'OSError', 'OverflowError',\n"
" 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',\n"
" 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',\n"
" 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',\n"
" 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',\n"
" 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',\n"
" 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', "
"'UserWarning',\n"
" 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',\n"
" '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',\n"
" 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',\n"
" 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',\n"
" 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',"
"\n"
" 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', "
"'hasattr',\n"
" 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',"
"\n"
" 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',\n"
" 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', "
"'property',\n"
" 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',"
"\n"
" 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', "
"'vars',\n"
" 'zip']"
msgstr
""
">>> import builtins\n"
">>> dir(builtins)\n"
"['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',\n"
" 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning',\n"
" 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',\n"
" 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning',\n"
" 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False',\n"
" 'FileExistsError', 'FileNotFoundError', 'FloatingPointError',\n"
" 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',\n"
" 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError',\n"
" 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError',\n"
" 'MemoryError', 'NameError', 'None', 'NotADirectoryError', "
"'NotImplemented',\n"
" 'NotImplementedError', 'OSError', 'OverflowError',\n"
" 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError',\n"
" 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning',\n"
" 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError',\n"
" 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError',\n"
" 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError',\n"
" 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', "
"'UserWarning',\n"
" 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__build_class__',\n"
" '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',\n"
" 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable',\n"
" 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits',\n"
" 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit',"
"\n"
" 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', "
"'hasattr',\n"
" 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',"
"\n"
" 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview',\n"
" 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', "
"'property',\n"
" 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',"
"\n"
" 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', "
"'vars',\n"
" 'zip']"
#:
../../tutorial/modules.rst:389
msgid
"Packages"
msgstr
"패키지"
#:
../../tutorial/modules.rst:391
msgid
""
"Packages are a way of structuring Python's module namespace by using "
"
\"
dotted module names
\"
. For example, the module name :mod:`!A.B` "
"designates a submodule named ``B`` in a package named ``A``. Just like "
"the use of modules saves the authors of different modules from having to "
"worry about each other's global variable names, the use of dotted module "
"names saves the authors of multi-module packages like NumPy or Pillow "
"from having to worry about each other's module names."
msgstr
""
"패키지는
\"
점으로 구분된 모듈 이름
\"
를 써서 파이썬의 모듈 이름 공간을 구조화하는 방법입니다. 예를 들어, 모듈 이름 "
":mod:`!A.B` 는 ``A`` 라는 이름의 패키지에 있는 ``B`` 라는 이름의 서브 모듈을 가리킵니다. 모듈의 사용이 다른 "
"모듈의 저자들이 서로의 전역 변수 이름들을 걱정할 필요 없게 만드는 것과 마찬가지로, 점으로 구분된 모듈의 이름들은 NumPy 나 "
"Pillow 과 같은 다중 모듈 패키지들의 저자들이 서로의 모듈 이름들을 걱정할 필요 없게 만듭니다."
#:
../../tutorial/modules.rst:399
msgid
""
"Suppose you want to design a collection of modules (a
\"
package
\"
) for "
"the uniform handling of sound files and sound data. There are many "
"different sound file formats (usually recognized by their extension, for "
"example: :file:`.wav`, :file:`.aiff`, :file:`.au`), so you may need to "
"create and maintain a growing collection of modules for the conversion "
"between the various file formats. There are also many different "
"operations you might want to perform on sound data (such as mixing, "
"adding echo, applying an equalizer function, creating an artificial "
"stereo effect), so in addition you will be writing a never-ending stream "
"of modules to perform these operations. Here's a possible structure for "
"your package (expressed in terms of a hierarchical filesystem):"
msgstr
""
"음향 파일과 과 음향 데이터의 일관된 처리를 위한 모듈들의 컬렉션 (
\"
패키지
\"
) 을 설계하길 원한다고 합시다. 여러 종류의 음향"
" 파일 형식이 있으므로 (보통 확장자로 구분됩니다, 예를 들어: :file:`.wav`, :file:`.aiff`, "
":file:`.au`), 다양한 파일 형식 간의 변환을 위해 계속 늘어나는 모듈들의 컬렉션을 만들고 유지할 필요가 있습니다. 또한,"
" 음향 데이터에 적용하고자 하는 많은 종류의 연산들도 있으므로 (믹싱, 에코 넣기, 이퀄라이저 기능 적용, 인공적인 스테레오 효과 "
"만들기와 같은), 이 연산들을 수행하기 위한 모듈들을 끊임없이 작성하게 될 것입니다. 패키지를 이렇게 구성해 볼 수 있습니다 "
"(계층적 파일 시스템으로 표현했습니다):"
#:
../../tutorial/modules.rst:410
msgid
""
"sound/ Top-level package\n"
" __init__.py Initialize the sound package\n"
" formats/ Subpackage for file format conversions\n"
" __init__.py\n"
" wavread.py\n"
" wavwrite.py\n"
" aiffread.py\n"
" aiffwrite.py\n"
" auread.py\n"
" auwrite.py\n"
" ...\n"
" effects/ Subpackage for sound effects\n"
" __init__.py\n"
" echo.py\n"
" surround.py\n"
" reverse.py\n"
" ...\n"
" filters/ Subpackage for filters\n"
" __init__.py\n"
" equalizer.py\n"
" vocoder.py\n"
" karaoke.py\n"
" ..."
msgstr
""
"sound/ 최상위 패키지\n"
" __init__.py sound 패키지 초기화\n"
" formats/ 파일 형식 변환을 위한 서브 패키지\n"
" __init__.py\n"
" wavread.py\n"
" wavwrite.py\n"
" aiffread.py\n"
" aiffwrite.py\n"
" auread.py\n"
" auwrite.py\n"
" ...\n"
" effects/ 음향 효과를 위한 서브 패키지\n"
" __init__.py\n"
" echo.py\n"
" surround.py\n"
" reverse.py\n"
" ...\n"
" filters/ 필터를 위한 서브 패키지\n"
" __init__.py\n"
" equalizer.py\n"
" vocoder.py\n"
" karaoke.py\n"
" ..."
#:
../../tutorial/modules.rst:436
msgid
""
"When importing the package, Python searches through the directories on "
"``sys.path`` looking for the package subdirectory."
msgstr
"패키지를 임포트할 때, 파이썬은 ``sys.path`` 에 있는 디렉터리들을 검색하면서 패키지 서브 디렉터리를 찾습니다."
#:
../../tutorial/modules.rst:439
msgid
""
"The :file:`__init__.py` files are required to make Python treat "
"directories containing the file as packages (unless using a "
":term:`namespace package`, a relatively advanced feature). This prevents "
"directories with a common name, such as ``string``, from unintentionally "
"hiding valid modules that occur later on the module search path. In the "
"simplest case, :file:`__init__.py` can just be an empty file, but it can "
"also execute initialization code for the package or set the ``__all__`` "
"variable, described later."
msgstr
""
"파이썬이 디렉터리를 패키지로 취급하게 만들기 위해서 :file:`__init__.py` 파일이 필요합니다 (비교적 고급 기능인 "
":term:`이름 공간 패키지 <namespace package>`
\\
를 사용하지 않는다면). 이렇게 하면 ``string`` 처럼"
" 흔히 쓰는 이름의 디렉터리가, 의도하지 않게 모듈 검색 경로의 뒤에 등장하는 올바른 모듈들을 가리는 일을 방지합니다. 가장 간단한"
" 경우, :file:`__init__.py` 는 그냥 빈 파일일 수 있지만, 패키지의 초기화 코드를 실행하거나 뒤에서 설명하는 "
"``__all__`` 변수를 설정할 수 있습니다."
#:
../../tutorial/modules.rst:447
msgid
""
"Users of the package can import individual modules from the package, for "
"example::"
msgstr
"패키지 사용자는 패키지로부터 개별 모듈을 임포트할 수 있습니다, 예를 들어::"
#:
../../tutorial/modules.rst:450
msgid
"import sound.effects.echo"
msgstr
"import sound.effects.echo"
#:
../../tutorial/modules.rst:452
msgid
""
"This loads the submodule :mod:`!sound.effects.echo`. It must be "
"referenced with its full name. ::"
msgstr
"이것은 서브 모듈 :mod:`!sound.effects.echo` 를 로드합니다. 전체 이름으로 참조되어야 합니다. ::"
#:
../../tutorial/modules.rst:455
msgid
"sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)"
msgstr
"sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)"
#:
../../tutorial/modules.rst:457
msgid
"An alternative way of importing the submodule is::"
msgstr
"서브 모듈을 임포트하는 다른 방법은 이렇습니다::"
#:
../../tutorial/modules.rst:459
msgid
"from sound.effects import echo"
msgstr
"from sound.effects import echo"
#:
../../tutorial/modules.rst:461
msgid
""
"This also loads the submodule :mod:`!echo`, and makes it available "
"without its package prefix, so it can be used as follows::"
msgstr
""
"이것도 서브 모듈 :mod:`!echo` 를 로드하고, 패키지 접두어 없이 사용할 수 있게 합니다. 그래서 이런 식으로 사용할 수 "
"있습니다::"
#:
../../tutorial/modules.rst:464
msgid
"echo.echofilter(input, output, delay=0.7, atten=4)"
msgstr
"echo.echofilter(input, output, delay=0.7, atten=4)"
#:
../../tutorial/modules.rst:466
msgid
""
"Yet another variation is to import the desired function or variable "
"directly::"
msgstr
"또 다른 방법은 원하는 함수나 변수를 직접 임포트하는 것입니다::"
#:
../../tutorial/modules.rst:468
msgid
"from sound.effects.echo import echofilter"
msgstr
"from sound.effects.echo import echofilter"
#:
../../tutorial/modules.rst:470
msgid
""
"Again, this loads the submodule :mod:`!echo`, but this makes its function"
" :func:`!echofilter` directly available::"
msgstr
""
"또다시, 이것은 서브 모듈 :mod:`!echo` 를 로드하지만, 함수 :func:`!echofilter` 를 직접 사용할 수 있게"
" 만듭니다::"
#:
../../tutorial/modules.rst:473
msgid
"echofilter(input, output, delay=0.7, atten=4)"
msgstr
"echofilter(input, output, delay=0.7, atten=4)"
#:
../../tutorial/modules.rst:475
msgid
""
"Note that when using ``from package import item``, the item can be either"
" a submodule (or subpackage) of the package, or some other name defined "
"in the package, like a function, class or variable. The ``import`` "
"statement first tests whether the item is defined in the package; if not,"
" it assumes it is a module and attempts to load it. If it fails to find "
"it, an :exc:`ImportError` exception is raised."
msgstr
""
"``from package import item`` 를 사용할 때, item은 패키지의 서브 모듈 (또는 서브 패키지)일 수도 있고"
" 함수, 클래스, 변수 등 패키지에 정의된 다른 이름들일 수도 있음에 유의하세요. ``import`` 문은 먼저 item이 패키지에"
" 정의되어 있는지 검사하고, 그렇지 않으면 모듈이라고 가정하고 로드를 시도합니다. 찾지 못한다면, :exc:`ImportError`"
" 예외를 일으킵니다."
#:
../../tutorial/modules.rst:482
msgid
""
"Contrarily, when using syntax like ``import item.subitem.subsubitem``, "
"each item except for the last must be a package; the last item can be a "
"module or a package but can't be a class or function or variable defined "
"in the previous item."
msgstr
""
"이에 반하여, ``import item.subitem.subsubitem`` 와 같은 문법을 사용할 때, 마지막 것을 제외한 각 "
"항목은 반드시 패키지여야 합니다; 마지막 항목은 모듈이나 패키지가 될 수 있지만, 앞의 항목에서 정의된 클래스, 함수, 변수 등이 "
"될 수는 없습니다."
#:
../../tutorial/modules.rst:491
msgid
"Importing
\\
* From a Package"
msgstr
"패키지에서
\\
* 임포트 하기"
#:
../../tutorial/modules.rst:495
msgid
""
View remainder of file in raw view
Back
|
FazBrowse Home
|
New Git URL