-
-
Notifications
You must be signed in to change notification settings - Fork 41
Expand file tree
/
Copy pathinterpreter.po
More file actions
259 lines (235 loc) · 12.5 KB
/
interpreter.po
File metadata and controls
259 lines (235 loc) · 12.5 KB
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
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2017
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:46+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: Hildeberto Abreu Magalhães <hildeberto@gmail.com>\n"
"Language-Team: Portuguese (Brazil) (http://www.transifex.com/python-doc/python-27/language/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=2; plural=(n > 1);\n"
#: ../../tutorial/interpreter.rst:5
msgid "Using the Python Interpreter"
msgstr "Utilizando o Interpretador Python"
#: ../../tutorial/interpreter.rst:11
msgid "Invoking the Interpreter"
msgstr "Disparando o interpretador"
#: ../../tutorial/interpreter.rst:13
msgid ""
"The Python interpreter is usually installed as :file:`/usr/local/bin/python`"
" on those machines where it is available; putting :file:`/usr/local/bin` in "
"your Unix shell's search path makes it possible to start it by typing the "
"command ::"
msgstr ""
"O interpretador é frequentemente instalado como :file:`/usr/local/bin/python`\n"
"nas máquinas onde está disponível; adicionando :file:`/usr/local/bin` ao\n"
"caminho de busca (search path) da shell de seu UNIX torna-se possível\n"
"iniciá-lo digitando::"
#: ../../tutorial/interpreter.rst:19
msgid ""
"to the shell. Since the choice of the directory where the interpreter lives"
" is an installation option, other places are possible; check with your local"
" Python guru or system administrator. (E.g., :file:`/usr/local/python` is a"
" popular alternative location.)"
msgstr ""
"no console. Considerando que a escolha do diretório\n"
"de instalação é uma opção de instalação, outras localizações são possíveis;\n"
"verifique com seu guru local de Python ou com o administrador do sistema.\n"
"(Ex.: :file:`/usr/local/python` é uma alternativa popular para instalação.)"
#: ../../tutorial/interpreter.rst:24
msgid ""
"On Windows machines, the Python installation is usually placed in "
":file:`C:\\\\Python27`, though you can change this when you're running the "
"installer. To add this directory to your path, you can type the following "
"command into the command prompt in a DOS box::"
msgstr ""
"Em computadores com Windows, Python é instalado geralmente em\n"
":file:`C:\\\\Python27`, apesar de você poder mudar isso enquanto está executando o\n"
"instalador. Para adicionar esse diretório ao path, você pode digitar o\n"
"seguinte comando no console::"
#: ../../tutorial/interpreter.rst:31
msgid ""
"Typing an end-of-file character (:kbd:`Control-D` on Unix, :kbd:`Control-Z` "
"on Windows) at the primary prompt causes the interpreter to exit with a zero"
" exit status. If that doesn't work, you can exit the interpreter by typing "
"the following command: ``quit()``."
msgstr ""
"Digitando um caractere EOF (end-of-file; fim de arquivo: :kbd:`Control-D` em\n"
"Unix, :kbd:`Control-Z` em Windows) diretamente no prompt força o interpretador\n"
"a sair com status de saída zero. Se isso não funcionar, você pode sair do\n"
"interpretador digitando o seguinte: ``quit()``."
#: ../../tutorial/interpreter.rst:36
msgid ""
"The interpreter's line-editing features usually aren't very sophisticated. "
"On Unix, whoever installed the interpreter may have enabled support for the "
"GNU readline library, which adds more elaborate interactive editing and "
"history features. Perhaps the quickest check to see whether command line "
"editing is supported is typing :kbd:`Control-P` to the first Python prompt "
"you get. If it beeps, you have command line editing; see Appendix "
":ref:`tut-interacting` for an introduction to the keys. If nothing appears "
"to happen, or if ``^P`` is echoed, command line editing isn't available; "
"you'll only be able to use backspace to remove characters from the current "
"line."
msgstr ""
"As características de edição de linha não são muito sofisticadas. Sobre UNIX,\n"
"quem instalou o interpretador talvez tenha habilitado o suporte à biblioteca\n"
"GNU readline, que adiciona facilidades mais elaboradas de edição e histórico\n"
"de comandos. Teclar :kbd:`Control-P` no primeiro prompt oferecido pelo Python\n"
"é, provavelmente, a maneira mais rápida de verificar se a edição de linha de\n"
"comando é suportada. Se escutar um *beep*, você tem edição de linha de\n"
"comando; veja o Apêndice :ref:`tut-interacting` para uma introdução às teclas\n"
"especiais. Se nada acontecer, ou se ^P aparecer na tela, a opção de edição não\n"
"está disponível; você apenas poderá usar o backspace para remover caracteres\n"
"da linha atual."
#: ../../tutorial/interpreter.rst:46
msgid ""
"The interpreter operates somewhat like the Unix shell: when called with "
"standard input connected to a tty device, it reads and executes commands "
"interactively; when called with a file name argument or with a file as "
"standard input, it reads and executes a *script* from that file."
msgstr ""
"O interpretador trabalha de forma semelhante a uma shell de UNIX: quando\n"
"disparado com a saída padrão conectada a um console de terminal (dispositivo\n"
"tty), ele lê e executa comandos interativamente; quando disparado com um nome\n"
"de arquivo como parâmetro ou com redirecionamento da entrada padrão para ler\n"
"um arquivo, o interpretador irá ler e executar o *script* contido em tal\n"
"arquivo."
#: ../../tutorial/interpreter.rst:51
msgid ""
"A second way of starting the interpreter is ``python -c command [arg] ...``,"
" which executes the statement(s) in *command*, analogous to the shell's "
":option:`-c` option. Since Python statements often contain spaces or other "
"characters that are special to the shell, it is usually advised to quote "
"*command* in its entirety with single quotes."
msgstr ""
"Uma segunda forma de rodar o interpretador é ``python -c *comando* [arg] ...``,\n"
"que executa um ou mais comandos especificados na posição *comando*,\n"
"analogamente à opção de shell :option:`-c`. Considerando que comandos Python\n"
"frequentemente têm espaços em branco (ou outros caracteres que são\n"
"especiais para a shell) é aconselhável que o *comando* esteja dentro de aspas\n"
"duplas."
#: ../../tutorial/interpreter.rst:57
msgid ""
"Some Python modules are also useful as scripts. These can be invoked using "
"``python -m module [arg] ...``, which executes the source file for *module* "
"as if you had spelled out its full name on the command line."
msgstr ""
"Alguns módulos Python são também úteis como scripts. Estes podem ser chamados\n"
"usando ``python -m *módulo* [arg] ...``, que executa o arquivo fonte do\n"
"*módulo* como se você tivesse digitado seu caminho completo na linha de\n"
"comando."
#: ../../tutorial/interpreter.rst:61
msgid ""
"When a script file is used, it is sometimes useful to be able to run the "
"script and enter interactive mode afterwards. This can be done by passing "
":option:`-i` before the script."
msgstr ""
"Quando um arquivo de script é utilizado, as vezes é útil executá-lo e logo em\n"
"seguida entrar em modo interativo. Isto pode ser feito acrescentando o\n"
"argumento :option:`-i` antes do nome do script."
#: ../../tutorial/interpreter.rst:65
msgid "All command-line options are described in :ref:`using-on-general`."
msgstr ""
#: ../../tutorial/interpreter.rst:71
msgid "Argument Passing"
msgstr "Passagem de argumentos"
#: ../../tutorial/interpreter.rst:73
msgid ""
"When known to the interpreter, the script name and additional arguments "
"thereafter are turned into a list of strings and assigned to the ``argv`` "
"variable in the ``sys`` module. You can access this list by executing "
"``import sys``. The length of the list is at least one; when no script and "
"no arguments are given, ``sys.argv[0]`` is an empty string. When the script"
" name is given as ``'-'`` (meaning standard input), ``sys.argv[0]`` is set "
"to ``'-'``. When :option:`-c` *command* is used, ``sys.argv[0]`` is set to "
"``'-c'``. When :option:`-m` *module* is used, ``sys.argv[0]`` is set to "
"the full name of the located module. Options found after :option:`-c` "
"*command* or :option:`-m` *module* are not consumed by the Python "
"interpreter's option processing but left in ``sys.argv`` for the command or"
" module to handle."
msgstr ""
"Quando são de conhecimento do interpretador, o nome do script e demais\n"
"argumentos da linha de comando da shell são acessíveis ao próprio script\n"
"através da variável ``argv`` do módulo ``sys``, que é uma lista de strings.\n"
"Essa lista tem sempre ao menos um elemento; quando nenhum script ou argumento\n"
"forem passados para o interpretador, ``sys.argv[0]`` será uma string vazia.\n"
"Quando o nome do script for ``-`` (significando entrada padrão), o conteúdo de\n"
"sys.argv[0] será ``'-'``. Quando for utilizado :option:`-c` *comando*,\n"
"``sys.argv[0]`` conterá ``'-c'``. Quando for utilizado :option:`-m` *módulo*,\n"
"``sys.argv[0]`` conterá o caminho completo do módulo localizado. Opções\n"
"especificadas após :option:`-c` *comando* ou :option:`-m` *módulo* não serão\n"
"consumidas pelo interpretador mas deixadas em ``sys.argv`` para serem tratadas\n"
"pelo comando ou módulo."
#: ../../tutorial/interpreter.rst:89
msgid "Interactive Mode"
msgstr "Modo interativo"
#: ../../tutorial/interpreter.rst:91
msgid ""
"When commands are read from a tty, the interpreter is said to be in "
"*interactive mode*. In this mode it prompts for the next command with the "
"*primary prompt*, usually three greater-than signs (``>>>``); for "
"continuation lines it prompts with the *secondary prompt*, by default three "
"dots (``...``). The interpreter prints a welcome message stating its version"
" number and a copyright notice before printing the first prompt:"
msgstr ""
"Quando os comandos são lidos a partir do console (tty), diz-se que o\n"
"interpretador está em modo interativo. Nesse modo ele solicita um próximo\n"
"comando através do *prompt primário*, tipicamente três sinais de maior\n"
"(``>>>``); para linhas de continuação do comando atual, o *prompt secundário*\n"
"padrão é formado por três pontos (``...``). O interpretador exibe uma\n"
"mensagem de boas vindas, informando seu número de versão e um aviso de\n"
"copyright antes de exibir o primeiro prompt::"
#: ../../tutorial/interpreter.rst:105
msgid ""
"Continuation lines are needed when entering a multi-line construct. As an "
"example, take a look at this :keyword:`if` statement::"
msgstr ""
"Linhas de continuação são necessárias em construções multi-linha. Como\n"
"exemplo, dê uma olhada nesse comando :keyword:`if`::"
#: ../../tutorial/interpreter.rst:115
msgid "For more on interactive mode, see :ref:`tut-interac`."
msgstr ""
"Para mais informações sobre o modo interativo, veja :ref:`tut-interac`. "
#: ../../tutorial/interpreter.rst:121
msgid "The Interpreter and Its Environment"
msgstr "O interpretador e seu ambiente"
#: ../../tutorial/interpreter.rst:127
msgid "Source Code Encoding"
msgstr "Edição de Código Fonte"
#: ../../tutorial/interpreter.rst:129
msgid ""
"By default, Python source files are treated as encoded in ASCII. To declare "
"an encoding other than the default one, a special comment line should be "
"added as the *first* line of the file. The syntax is as follows::"
msgstr ""
#: ../../tutorial/interpreter.rst:135
msgid ""
"where *encoding* is one of the valid :mod:`codecs` supported by Python."
msgstr ""
"onde *encoding* é uma das :mod:`codecs` válidas suportada pelo Python."
#: ../../tutorial/interpreter.rst:137
msgid ""
"For example, to declare that Windows-1252 encoding is to be used, the first "
"line of your source code file should be::"
msgstr ""
"Por exemplo, para declarar que a codificação Windows-1252 deve ser usada, a "
"primeira linha do seu arquivo fonte deve ser::"
#: ../../tutorial/interpreter.rst:142
msgid ""
"One exception to the *first line* rule is when the source code starts with a"
" :ref:`UNIX \"shebang\" line <tut-scripts>`. In this case, the encoding "
"declaration should be added as the second line of the file. For example::"
msgstr ""
"Uma exceção para a regra da *primeira linha* é quando o código fonte inicia "
"com uma :ref:`UNIX \"shebang\" line <tut-scripts>`. Nesse caso, a "
"declaração de codificação deve ser adicionada como a segunda linha do "
"arquivo. Por exemplo::"