# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# Hildeberto Abreu Magalhes , 2020
# Tiago Henrique , 2020
# Claudio Rogerio Carvalho Filho , 2020
# Adorilson Bezerra , 2020
# Rafael Fontenelle , 2024
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-08-16 17:24+0000\n"
"PO-Revision-Date: 2020-05-30 12:16+0000\n"
"Last-Translator: Rafael Fontenelle , 2024\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../tutorial/modules.rst:5
msgid "Modules"
msgstr "Mdulos"

#: ../../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 ""
"Ao sair e entrar de novo no interpretador Python, as definies anteriores "
"(funes e variveis) so perdidas. Portanto, se quiser escrever um programa "
"maior, ser mais eficiente usar um editor de texto para preparar as entradas "
"para o interpretador, e execut-lo usando o arquivo como entrada. Isso  "
"conhecido como criar um *script*. Se o programa se torna ainda maior,  uma "
"boa prtica dividi-lo em arquivos menores, para facilitar a manuteno. "
"Tambm  prefervel usar um arquivo separado para uma funo que voc "
"escreveria em vrios programas diferentes, para no copiar a definio de "
"funo em cada um deles."

#: ../../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 ""
"Para permitir isso, Python tem uma maneira de colocar as definies em um "
"arquivo e ento us-las em um script ou em uma execuo interativa do "
"interpretador. Tal arquivo  chamado de *mdulo*; definies de um mdulo "
"podem ser *importadas* para outros mdulos, ou para o mdulo *principal* (a "
"coleo de variveis a que voc tem acesso num script executado como um "
"programa e no modo calculadora)."

#: ../../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 ""
"Um mdulo  um arquivo contendo definies e instrues Python. O nome do "
"arquivo  o nome do mdulo acrescido do sufixo :file:`.py`. Dentro de um "
"mdulo, o nome do mdulo (como uma string) est disponvel como o valor da "
"varivel global ``__name__``. Por exemplo, use seu editor de texto favorito "
"para criar um arquivo chamado :file:`fibo.py` no diretrio atual com o "
"seguinte contedo::"

#: ../../tutorial/modules.rst:45
msgid ""
"Now enter the Python interpreter and import this module with the following "
"command::"
msgstr ""
"Agora, entre no interpretador Python e importe esse mdulo com o seguinte\n"
"comando::"

#: ../../tutorial/modules.rst:50
msgid ""
"This does not enter the names of the functions defined in ``fibo``  directly "
"in the current symbol table; it only enters the module name ``fibo`` there. "
"Using the module name you can access the functions::"
msgstr ""
"Isso no coloca os nomes das funes definidas em ``fibo`` diretamente na "
"tabela de smbolos atual; isso coloca somente o nome do mdulo ``fibo``. "
"Usando o nome do mdulo voc pode acessar as funes::"

#: ../../tutorial/modules.rst:61
msgid ""
"If you intend to use a function often you can assign it to a local name::"
msgstr ""
"Se voc pretende usar uma funo muitas vezes, voc pode atribui-l a um "
"nome local::"

#: ../../tutorial/modules.rst:71
msgid "More on Modules"
msgstr "Mais sobre mdulos"

#: ../../tutorial/modules.rst:73
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 ""
"Um mdulo pode conter tanto instrues executveis quanto definies de "
"funes e classes. Essas instrues servem para inicializar o mdulo. Eles "
"so executados somente na *primeira* vez que o mdulo  encontrado em uma "
"instruo de importao. [#]_ (Tambm rodam se o arquivo  executado como um "
"script.)"

#: ../../tutorial/modules.rst:78
msgid ""
"Each module has its own private symbol table, which is used as the global "
"symbol table 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 ""
"Cada mdulo tem sua prpria tabela de smbolos privada, que  usada como "
"tabela de smbolos global para todas as funes definidas no mdulo. Assim, "
"o autor de um mdulo pode usar variveis globais no seu mdulo sem se "
"preocupar com conflitos acidentais com as variveis globais do usurio. Por "
"outro lado, se voc precisar usar uma varivel global de um mdulo, poder "
"faz-lo com a mesma notao usada para se referir s suas funes, "
"``nomemodulo.nomeitem``."

#: ../../tutorial/modules.rst:85
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 are placed in the importing "
"module's global symbol table."
msgstr ""
"Mdulos podem importar outros mdulos.  costume, porm no obrigatrio, "
"colocar todos os comandos :keyword:`import` no incio do mdulo (ou script , "
"se preferir). As definies do mdulo importado so colocadas na tabela de "
"smbolos global do mdulo que faz a importao."

#: ../../tutorial/modules.rst:90
msgid ""
"There is a variant of the :keyword:`import` statement that imports names "
"from a module directly into the importing module's symbol table.  For "
"example::"
msgstr ""
"Existe uma variante do comando :keyword:`import` que importa definies de "
"um mdulo diretamente para a tabela de smbolos do mdulo importador. Por "
"exemplo::"

#: ../../tutorial/modules.rst:97
msgid ""
"This does not introduce the module name from which the imports are taken in "
"the local symbol table (so in the example, ``fibo`` is not defined)."
msgstr ""
"Isso no coloca o nome do mdulo de onde foram feitas as importaes na "
"tabela de smbolos local (assim, no exemplo, ``fibo`` no est definido)."

#: ../../tutorial/modules.rst:100
msgid "There is even a variant to import all names that a module defines::"
msgstr ""
"Existe ainda uma variante que importa todos os nomes definidos em um mdulo::"

#: ../../tutorial/modules.rst:106
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 ""
"Isso importa todos as declaraes de nomes, exceto aqueles que iniciam com "
"um sublinhado (``_``). Na maioria dos casos, programadores Python no usam "
"esta facilidade porque ela introduz um conjunto desconhecido de nomes no "
"ambiente, podendo esconder outros nomes previamente definidos."

#: ../../tutorial/modules.rst:111
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 ""
"Note que, em geral, a prtica do ``import *`` de um mdulo ou pacote  "
"desaprovada, uma vez que muitas vezes dificulta a leitura do cdigo. "
"Contudo,  aceitvel para diminuir a digitao em sesses interativas."

#: ../../tutorial/modules.rst:115
msgid ""
"If the module name is followed by :keyword:`!as`, then the name "
"following :keyword:`!as` is bound directly to the imported module."
msgstr ""
"Se o nome do mdulo  seguido pela palavra-chave :keyword:`!as`, o nome a "
"seguir  vinculado diretamente ao mdulo importado."

#: ../../tutorial/modules.rst:124
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 ""
"Isto efetivamente importa o mdulo, da mesma maneira que ``import fibo`` "
"far, com a nica diferena de estar disponvel com o nome ``fib``."

#: ../../tutorial/modules.rst:127
msgid ""
"It can also be used when utilising :keyword:`from` with similar effects::"
msgstr ""
"Tambm pode ser utilizado com a palavra-chave :keyword:`from`, com efeitos "
"similares::"

#: ../../tutorial/modules.rst:136
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 ""
" Por razes de eficincia, cada mdulo  importado uma nica vez por sesso "
"do interpretador. Portanto, se voc alterar seus mdulos, voc deve "
"reiniciar o interpretador -- ou, se  somente um mdulo que voc quer testar "
"interativamente, use a funo :func:`reload`, ex. ``import importlib; "
"importlib.reload(nomemodulo)``."

#: ../../tutorial/modules.rst:146
msgid "Executing modules as scripts"
msgstr "Executando mdulos como scripts"

#: ../../tutorial/modules.rst:148
msgid "When you run a Python module with ::"
msgstr "Quando voc rodar um mdulo Python com ::"

#: ../../tutorial/modules.rst:152
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 ""
"o cdigo no mdulo ser executado, da mesma forma que quando  importado, "
"mas com a varivel ``__name__`` com valor ``\"__main__\"``. Isto significa "
"que adicionando este cdigo ao final do seu mdulo::"

#: ../../tutorial/modules.rst:160
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 ""
"voc pode tornar o arquivo utilizvel tanto como script quanto como um "
"mdulo importvel, porque o cdigo que analisa a linha de comando s roda se "
"o mdulo  executado como arquivo \"principal\":"

#: ../../tutorial/modules.rst:169
msgid "If the module is imported, the code is not run::"
msgstr "Se o mdulo  importado, o cdigo no  executado::"

#: ../../tutorial/modules.rst:174
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 ""
"Isso  frequentemente usado para fornecer uma interface de usurio "
"conveniente para um mdulo, ou para realizar testes (rodando o mdulo como "
"um script executa um conjunto de testes)."

#: ../../tutorial/modules.rst:181
msgid "The Module Search Path"
msgstr "O caminho de busca dos mdulos"

#: ../../tutorial/modules.rst:185
msgid ""
"When a module named :mod:`spam` is imported, the interpreter first searches "
"for a built-in module with that name. 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 ""
"Quando um mdulo chamado :mod:`spam`  importado, o interpretador procura um "
"mdulo embutido com este nome. Se no encontra, procura um arquivo "
"chamado :file:`spam.py` em uma lista de diretrios includos na "
"varivel :data:`sys.path`. A :data:`sys.path`  inicializada com estes "
"locais:"

#: ../../tutorial/modules.rst:190
msgid ""
"The directory containing the input script (or the current directory when no "
"file is specified)."
msgstr ""
"O diretrio que contm o script importador (ou o diretrio atual quando "
"nenhum arquivo  especificado)."

#: ../../tutorial/modules.rst:192
msgid ""
":envvar:`PYTHONPATH` (a list of directory names, with the same syntax as the "
"shell variable :envvar:`PATH`)."
msgstr ""
"A varivel de ambiente :envvar:`PYTHONPATH` (uma lista de nomes de "
"diretrios, com a mesma sintaxe da varivel de ambiente :envvar:`PATH`)."

#: ../../tutorial/modules.rst:194
msgid "The installation-dependent default."
msgstr "Padres dependentes da instalao."

#: ../../tutorial/modules.rst:197
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 ""
"Nos sistemas de arquivos que suportam links simblicos, o diretrio contendo "
"o script de entrada  resultante do diretrio apontado pelo link simblico. "
"Em outras palavras o diretrio que contm o link simblico **no**  "
"adicionado ao caminho de busca de mdulos."

#: ../../tutorial/modules.rst:201
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 ""
"Aps a inicializao, programas Python podem modificar :data:`sys.path`. O "
"diretrio que contm o script sendo executado  colocado no incio da lista "
"de caminhos,  frente do caminho da biblioteca padro. Isto significa que "
"mdulos nesse diretrio sero carregados, no lugar de mdulos com o mesmo "
"nome na biblioteca padro. Isso costuma ser um erro, a menos que seja "
"intencional. Veja a seo :ref:`tut-standardmodules` para mais informaes."

#: ../../tutorial/modules.rst:212
msgid "\"Compiled\" Python files"
msgstr "Arquivos Python \"compilados\""

#: ../../tutorial/modules.rst:214
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 ""
"Para acelerar o carregamento de mdulos, o Python guarda verses compiladas "
"de cada mdulo no diretrio ``__pycache__`` com o nome :file:`modulo."
"{verso}.pyc`, onde a verso corresponde ao formato do arquivo compilado; "
"geralmente contm o nmero da verso Python utilizada. Por exemplo, no "
"CPython release 3.3 a verso compilada de spam.py ser guardada como "
"``__pycache__/spam.cpython-33.pyc``. Esta conveno de nomes permite a "
"coexistncia de mdulos compilados de diferentes releases e verses de "
"Python."

#: ../../tutorial/modules.rst:222
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 ""
"O Python verifica a data de modificao do arquivo fonte mediante a verso "
"compilada, para ver se est desatualizada e precisa ser recompilada.  um "
"processo completamente automtico. Alm disso, os mdulos compilados so "
"independentes de plataforma, portanto a mesma biblioteca pode ser "
"compartilhada entre sistemas de arquiteturas diferentes."

#: ../../tutorial/modules.rst:227
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 ""
"O Python no verifica as verses compiladas em duas circunstncias. "
"Primeiro, sempre recompila e no armazena o resultado para mdulos "
"carregados diretamente da linha de comando. Segundo, no verifica se no "
"houver um mdulo fonte. Para suportar uma distribuio sem fontes (somente "
"as verses compiladas), o mdulo compilado deve estar no diretrio de "
"fontes, e no deve haver um mdulo fonte."

#: ../../tutorial/modules.rst:234
msgid "Some tips for experts:"
msgstr "Algumas dicas para especialistas:"

#: ../../tutorial/modules.rst:236
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 ""
"Voc pode usar as opes :option:`-O` ou :option:`-OO` no comando Python "
"para reduzir o tamanho de um mdulo compilado. A opo ``-O`` remove as "
"instrues assert, e a opo ``-OO`` remove, alm das instrues assert, as "
"strings de documentaes. Como alguns programas podem contar com essa "
"disponibilidade, s use essa opo se souber o que est fazendo. Mdulos "
"\"otimizados\" tem uma marcao ``opt-`` e so geralmente de menor tamanho. "
"Futuros releases podem mudar os efeitos da otimizao."

#: ../../tutorial/modules.rst:244
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 ""
"Um programa no roda mais rpido quando  lido de um arquivo ``.pyc`` do que "
"quando lido de um arquivo ``.py``; a nica coisa que  mais rpida com "
"arquivos ``.pyc``  sua velocidade de carregamento."

#: ../../tutorial/modules.rst:248
msgid ""
"The module :mod:`compileall` can create .pyc files for all modules in a "
"directory."
msgstr ""
"O mdulo :mod:`compileall` pode criar arquivos .pyc para todos os mdulos de "
"um diretrio."

#: ../../tutorial/modules.rst:251
msgid ""
"There is more detail on this process, including a flow chart of the "
"decisions, in :pep:`3147`."
msgstr ""
"H mais detalhes desse processo, incluindo um fluxograma de decises, "
"no :pep:`3147`."

#: ../../tutorial/modules.rst:258
msgid "Standard Modules"
msgstr "Mdulos padres"

#: ../../tutorial/modules.rst:262
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 ""
"O Python traz uma biblioteca padro de mdulos, descrita em um documento em "
"separado, a Referncia da Biblioteca Python (doravante Referncia da "
"Biblioteca). Alguns mdulos esto embutidos no interpretador; estes "
"possibilitam acesso a operaes que no so parte do ncleo da linguagem, "
"mas esto no interpretador seja por eficincia ou para permitir o acesso a "
"chamadas do sistema operacional. O conjunto destes mdulos  uma opo de "
"configurao que depende tambm da plataforma utilizada. Por exemplo, o "
"mdulo :mod:`winreg` s est disponvel em sistemas Windows. Existe um "
"mdulo que requer especial ateno: :mod:`sys`, que  embutido em qualquer "
"interpretador Python. As variveis ``sys.ps1`` e ``sys.ps2`` definem as "
"strings utilizadas como prompt primrio e secundrio::"

#: ../../tutorial/modules.rst:285
msgid ""
"These two variables are only defined if the interpreter is in interactive "
"mode."
msgstr ""
"Essas variveis s esto definidas se o interpretador est em modo "
"interativo."

#: ../../tutorial/modules.rst:287
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 ""
"A varivel ``sys.path`` contm uma lista de strings que determina os "
"caminhos de busca de mdulos conhecidos pelo interpretador. Ela  "
"inicializada para um caminho padro, determinado pela varivel de "
"ambiente :envvar:`PYTHONPATH`, ou por um valor padro embutido, "
"se :envvar:`PYTHONPATH` no estiver definida. Voc pode modific-la com as "
"operaes tpicas de lista, por exemplo::"

#: ../../tutorial/modules.rst:300
msgid "The :func:`dir` Function"
msgstr "A funo :func:`dir`"

#: ../../tutorial/modules.rst:302
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 ""
"A funo embutida :func:`dir`  usada para descobrir quais nomes so "
"definidos por um mdulo. Ela devolve uma lista ordenada de strings::"

#: ../../tutorial/modules.rst:327
msgid ""
"Without arguments, :func:`dir` lists the names you have defined currently::"
msgstr "Sem argumentos, :func:`dir` lista os nomes atualmente definidos::"

#: ../../tutorial/modules.rst:335
msgid ""
"Note that it lists all types of names: variables, modules, functions, etc."
msgstr ""
"Observe que ela lista todo tipo de nomes: variveis, mdulos, funes, etc."

#: ../../tutorial/modules.rst:339
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` no lista os nomes de variveis e funes embutidas. Esta lista "
"est disponvel no mdulo padro :mod:`builtins`::"

#: ../../tutorial/modules.rst:378
msgid "Packages"
msgstr "Pacotes"

#: ../../tutorial/modules.rst:380
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 ""
"Os pacotes so uma maneira de estruturar o \"espao de nomes\" dos mdulos "
"Python, usando \"nomes de mdulo com pontos\". Por exemplo, o nome do "
"mdulo :mod:`A.B` designa um submdulo chamado ``B``, em um pacote chamado "
"``A``. Assim como o uso de mdulos evita que os autores de mdulos "
"diferentes tenham que se preocupar com nomes de variveis globais, o uso de "
"nomes de mdulos com pontos evita que os autores de pacotes com muitos "
"mdulos, como NumPy ou Pillow, tenham que se preocupar com os nomes dos "
"mdulos uns dos outros."

#: ../../tutorial/modules.rst:388
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 ""
"Suponha que voc queira projetar uma coleo de mdulos (um \"pacote\") para "
"o gerenciamento uniforme de arquivos de som. Existem muitos formatos "
"diferentes (normalmente identificados pela extenso do nome de arquivo, por "
"exemplo :file:`.wav`, :file:`.aiff`, :file:`.au`), de forma que voc pode "
"precisar criar e manter uma crescente coleo de mdulos de converso entre "
"formatos. Ainda podem existir muitas operaes diferentes, passveis de "
"aplicao sobre os arquivos de som (mixagem, eco, equalizao, efeito stereo "
"artificial). Logo, possivelmente voc tambm estar escrevendo uma coleo "
"sempre crescente de mdulos para aplicar estas operaes. Eis uma possvel "
"estrutura para o seu pacote (expressa em termos de um sistema de arquivos "
"hierrquico)::"

#: ../../tutorial/modules.rst:425
msgid ""
"When importing the package, Python searches through the directories on "
"``sys.path`` looking for the package subdirectory."
msgstr ""
"Ao importar esse pacote, Python busca pelo subdiretrio com mesmo nome, nos "
"diretrios listados em ``sys.path``."

#: ../../tutorial/modules.rst:428
msgid ""
"The :file:`__init__.py` files are required to make Python treat directories "
"containing the file as packages.  This prevents directories with a common "
"name, such as ``string``, 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 ""
"Os arquivos :file:`__init__.py` so necessrios para que o Python trate "
"diretrios contendo o arquivo como pacotes. Isso previne que diretrios com "
"um nome comum, como ``string``, ocultem, involuntariamente, mdulos vlidos "
"que ocorrem posteriormente no caminho de busca do mdulo. No caso mais "
"simples, :file:`__init__.py` pode ser apenas um arquivo vazio, mas pode "
"tambm executar cdigo de inicializao do pacote, ou configurar a varivel "
"``__all__``, descrita mais adiante."

#: ../../tutorial/modules.rst:435
msgid ""
"Users of the package can import individual modules from the package, for "
"example::"
msgstr "Usurios do pacote podem importar mdulos individuais, por exemplo::"

#: ../../tutorial/modules.rst:440
msgid ""
"This loads the submodule :mod:`sound.effects.echo`.  It must be referenced "
"with its full name. ::"
msgstr ""
"Isso carrega o submdulo :mod:`sound.effects.echo`. Ele deve ser "
"referenciado com seu nome completo, como em::"

#: ../../tutorial/modules.rst:445
msgid "An alternative way of importing the submodule is::"
msgstr "Uma maneira alternativa para a importao desse mdulo ::"

#: ../../tutorial/modules.rst:449
msgid ""
"This also loads the submodule :mod:`echo`, and makes it available without "
"its package prefix, so it can be used as follows::"
msgstr ""
"Isso carrega o submdulo :mod:`echo` sem necessidade de mencionar o prefixo "
"do pacote no momento da utilizao, assim::"

#: ../../tutorial/modules.rst:454
msgid ""
"Yet another variation is to import the desired function or variable "
"directly::"
msgstr "Tambm  possvel importar diretamente uma nica varivel ou funo::"

#: ../../tutorial/modules.rst:458
msgid ""
"Again, this loads the submodule :mod:`echo`, but this makes its "
"function :func:`echofilter` directly available::"
msgstr ""
"Novamente, isso carrega o submdulo :mod:`echo`, mas a "
"funo :func:`echofilter` est acessvel diretamente sem prefixo::"

#: ../../tutorial/modules.rst:463
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 ""
"Observe que ao utilizar ``from pacote import item``, o item pode ser um "
"subpacote, submdulo, classe, funo ou varivel. A instruo ``import`` "
"primeiro testa se o item est definido no pacote, seno presume que  um "
"mdulo e tenta carreg-lo. Se falhar em encontrar o mdulo, uma "
"exceo :exc:`ImportError`  levantada."

#: ../../tutorial/modules.rst:470
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 ""
"Em oposio, em uma construo como ``import item.subitem.subsubitem``, cada "
"item, com exceo do ltimo, deve ser um pacote. O ltimo pode ser tambm um "
"pacote ou mdulo, mas nunca uma classe, funo ou varivel contida em um "
"mdulo."

#: ../../tutorial/modules.rst:479
msgid "Importing \\* From a Package"
msgstr "Importando \\* de um pacote"

#: ../../tutorial/modules.rst:483
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 ""
"Agora, o que acontece quando um usurio escreve ``from sound.effects import "
"*`` ? Idealmente, poderia se esperar que este comando vasculhasse o sistema "
"de arquivos, encontrasse todos os submdulos presentes no pacote, e os "
"importasse. Isso poderia demorar muito e a importao de submdulos pode "
"ocasionar efeitos colaterais, que somente deveriam ocorrer quando o "
"submdulo  explicitamente importado."

#: ../../tutorial/modules.rst:489
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 ""
"A nica soluo  o autor do pacote fornecer um ndice explcito do pacote. "
"A instruo :keyword:`import` usa a seguinte conveno: se o "
"arquivo :file:`__init__.py` do pacote define uma lista chamada ``__all__``, "
"ento esta lista indica os nomes dos mdulos a serem importados quando a "
"instruo ``from pacote import *``  acionada. Fica a cargo do autor do "
"pacote manter esta lista atualizada, inclusive fica a seu critrio excluir "
"inteiramente o suporte a importao direta de todo o pacote atravs de "
"``from pacote import *``. Por exemplo, o arquivo :file:`sounds/effects/"
"__init__.py` poderia conter apenas::"

#: ../../tutorial/modules.rst:501
msgid ""
"This would mean that ``from sound.effects import *`` would import the three "
"named submodules of the :mod:`sound` package."
msgstr ""
"Isso significaria que ``from sound.effects import *`` importaria apenas os "
"trs submdulos especificados no pacote :mod:`sound`."

#: ../../tutorial/modules.rst:504
msgid ""
"If ``__all__`` is not defined, the statement ``from sound.effects import *`` "
"does *not* import all submodules from the package :mod:`sound.effects` into "
"the current namespace; it only ensures that the package :mod:`sound.effects` "
"has been imported (possibly running any initialization code "
"in :file:`__init__.py`) and then imports whatever names are defined in the "
"package.  This includes any names defined (and submodules explicitly loaded) "
"by :file:`__init__.py`.  It also includes any submodules of the package that "
"were explicitly loaded by previous :keyword:`import` statements.  Consider "
"this code::"
msgstr ""
"Se ``__all__`` no estiver definido, o comando ``from sound.effects import "
"*`` no importa todos os submdulos do pacote :mod:`sound.effects` no espao "
"de nomes atual. H apenas garantia que o pacote :mod:`sound.effects` foi "
"importado (possivelmente executando qualquer cdigo de inicializao "
"em :file:`__init__.py`) juntamente com os nomes definidos no pacote. Isso "
"inclui todo nome definido em :file:`__init__.py` bem como em qualquer "
"submdulo importado a partir deste. Tambm inclui quaisquer submdulos do "
"pacote que tenham sido carregados explicitamente por "
"comandos :keyword:`import` anteriores. Considere o cdigo abaixo::"

#: ../../tutorial/modules.rst:517
msgid ""
"In this example, the :mod:`echo` and :mod:`surround` modules are imported in "
"the current namespace because they are defined in the :mod:`sound.effects` "
"package when the ``from...import`` statement is executed.  (This also works "
"when ``__all__`` is defined.)"
msgstr ""
"Nesse exemplo, os nomes :mod:`echo` e :mod:`surround` so importados no "
"espao de nomes atual, no momento em que o comando ``from...import``  "
"executado, pois esto definidos no pacote :mod:`sound.effects`. (Isso tambm "
"funciona quando ``__all__`` estiver definida.)"

#: ../../tutorial/modules.rst:522
msgid ""
"Although certain modules are designed to export only names that follow "
"certain patterns when you use ``import *``, it is still considered bad "
"practice in production code."
msgstr ""
"Apesar de que certos mdulos so projetados para exportar apenas nomes "
"conforme algum critrio quando se faz ``import *``, ainda assim essa sintaxe "
" considerada uma prtica ruim em cdigo de produo."

#: ../../tutorial/modules.rst:526
msgid ""
"Remember, there is nothing wrong with using ``from package import "
"specific_submodule``!  In fact, this is the recommended notation unless the "
"importing module needs to use submodules with the same name from different "
"packages."
msgstr ""
"Lembre-se, no h nada errado em usar ``from pacote import "
"submodulo_especifico``! De fato, essa  a notao recomendada, a menos que o "
"mdulo importado necessite usar submdulos com o mesmo nome, de diferentes "
"pacotes."

#: ../../tutorial/modules.rst:533
msgid "Intra-package References"
msgstr "Referncias em um mesmo pacote"

#: ../../tutorial/modules.rst:535
msgid ""
"When packages are structured into subpackages (as with the :mod:`sound` "
"package in the example), you can use absolute imports to refer to submodules "
"of siblings packages.  For example, if the "
"module :mod:`sound.filters.vocoder` needs to use the :mod:`echo` module in "
"the :mod:`sound.effects` package, it can use ``from sound.effects import "
"echo``."
msgstr ""
"Quando pacotes so estruturados em subpacotes (como no pacote :mod:`sound` "
"do exemplo), pode-se usar a sintaxe de importaes absolutas para se referir "
"aos submdulos de pacotes irmos (o que na prtica  uma forma de fazer um "
"import relativo, a partir da base do pacote). Por exemplo, se o "
"mdulo :mod:`sound.filters.vocoder` precisa usar o mdulo :mod:`echo` do "
"pacote :mod:`sound.effects`,  preciso import-lo com ``from sound.effects "
"import echo``."

#: ../../tutorial/modules.rst:541
msgid ""
"You can also write relative imports, with the ``from module import name`` "
"form of import statement.  These imports use leading dots to indicate the "
"current and parent packages involved in the relative import.  From "
"the :mod:`surround` module for example, you might use::"
msgstr ""
"Tambm  possvel escrever imports relativos, com a forma ``from modulo "
"import nome``. Esses imports usam pontos para indicar o pacote pai e o "
"atual, envolvidos no import relativo. Do mdulo :mod:`surround`, por "
"exemplo, pode-se usar::"

#: ../../tutorial/modules.rst:550
msgid ""
"Note that relative imports are based on the name of the current module.  "
"Since the name of the main module is always ``\"__main__\"``, modules "
"intended for use as the main module of a Python application must always use "
"absolute imports."
msgstr ""
"Note que imports relativos so baseados no nome do mdulo atual. Uma vez que "
"o nome do mdulo principal  sempre ``\"__main__\"``, mdulos destinados ao "
"uso como mdulo principal de um aplicativo Python devem sempre usar imports "
"absolutos."

#: ../../tutorial/modules.rst:556
msgid "Packages in Multiple Directories"
msgstr "Pacotes em mltiplos diretrios"

#: ../../tutorial/modules.rst:558
msgid ""
"Packages support one more special attribute, :attr:`__path__`.  This is "
"initialized to be a list containing the name of the directory holding the "
"package's :file:`__init__.py` before the code in that file is executed.  "
"This variable can be modified; doing so affects future searches for modules "
"and subpackages contained in the package."
msgstr ""
"Pacotes possuem mais um atributo especial, :attr:`__path__`. Inicializado "
"como uma lista contendo o nome do diretrio onde est o "
"arquivo :file:`__init__.py` do pacote, antes do cdigo naquele arquivo ser "
"executado. Esta varivel pode ser modificada; isso afeta a busca futura de "
"mdulos e subpacotes contidos no pacote."

#: ../../tutorial/modules.rst:564
msgid ""
"While this feature is not often needed, it can be used to extend the set of "
"modules found in a package."
msgstr ""
"Apesar de no ser muito usado, esse mecanismo permite estender o conjunto de "
"mdulos encontrados em um pacote."

#: ../../tutorial/modules.rst:569
msgid "Footnotes"
msgstr "Notas de rodap"

#: ../../tutorial/modules.rst:570
msgid ""
"In fact function definitions are also 'statements' that are 'executed'; the "
"execution of a module-level function definition enters the function name in "
"the module's global symbol table."
msgstr ""
"[#] Na verdade, definies de funes tambm so 'instrues' que so "
"'executados'; a execuo da definio de uma funo coloca o nome da funo "
"na tabela de smbolos global do mdulo."