# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , 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 \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:` `\\ "
" ( :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 "
msgstr "python fibo.py "
#: ../../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:` `\\ ). ``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 ""
"Now what happens when the user writes ``from sound.effects import *``? "
"Ideally, one would hope that this somehow goes out to the filesystem, "
"finds which submodules are present in the package, and imports them all."
" This could take a long time and importing sub-modules might have "
"unwanted side-effects that should only happen when the sub-module is "
"explicitly imported."
msgstr ""
" ``from sound.effects import *`` ? , "
" , . "
" "
"."
#: ../../tutorial/modules.rst:501
msgid ""
"The only solution is for the package author to provide an explicit index "
"of the package. The :keyword:`import` statement uses the following "
"convention: if a package's :file:`__init__.py` code defines a list named "
"``__all__``, it is taken to be the list of module names that should be "
"imported when ``from package import *`` is encountered. It is up to the "
"package author to keep this list up-to-date when a new version of the "
"package is released. Package authors may also decide not to support it, "
"if they don't see a use for importing \\* from their package. For "
"example, the file :file:`sound/effects/__init__.py` could contain the "
"following code::"
msgstr ""
" . :keyword:`import` "
" : :file:`__init__.py` ``__all__`` , "
"``from package import *`` . "
" . \\* "
" , . , "
":file:`sound/effects/__init__.py` ::"
#: ../../tutorial/modules.rst:511
msgid "__all__ = [\"echo\", \"surround\", \"reverse\"]"
msgstr "__all__ = [\"echo\", \"surround\", \"reverse\"]"
#: ../../tutorial/modules.rst:513
msgid ""
"This would mean that ``from sound.effects import *`` would import the "
"three named submodules of the :mod:`!sound.effects` package."
msgstr ""
" ``from sound.effects import *`` :mod:`!sound.effects` "
" ."
#: ../../tutorial/modules.rst:516
msgid ""
"Be aware that submodules might become shadowed by locally defined names. "
"For example, if you added a ``reverse`` function to the "
":file:`sound/effects/__init__.py` file, the ``from sound.effects import "
"*`` would only import the two submodules ``echo`` and ``surround``, but "
"*not* the ``reverse`` submodule, because it is shadowed by the locally "
"defined ``reverse`` function::"
msgstr ""
" . , ``reverse`` "
":file:`sound/effects/__init__.py` , ``from sound.effects import "
"*``\\ ``echo``\\ ``surround`` , ``reverse`` "
" **. ``reverse`` ::"
#: ../../tutorial/modules.rst:523
msgid ""
"__all__ = [\n"
" \"echo\", # refers to the 'echo.py' file\n"
" \"surround\", # refers to the 'surround.py' file\n"
" \"reverse\", # !!! refers to the 'reverse' function now !!!\n"
"]\n"
"\n"
"def reverse(msg: str): #