-
-
Notifications
You must be signed in to change notification settings - Fork 40
Expand file tree
/
Copy pathintroduction.po
More file actions
677 lines (602 loc) · 29.8 KB
/
introduction.po
File metadata and controls
677 lines (602 loc) · 29.8 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
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
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2026, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-03-05 18:13+0000\n"
"PO-Revision-Date: 2025-09-22 15:58+0000\n"
"Last-Translator: python-doc bot, 2025\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/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "Uma introdução informal ao Python"
#: ../../tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"Nos exemplos seguintes, pode-se distinguir entrada e saída pela presença ou "
"ausência dos prompts (:term:`>>>` e :term:`...`): para repetir o exemplo, "
"você deve digitar tudo após o prompt, quando o mesmo aparece; linhas que não "
"começarem com um prompt são na verdade as saídas geradas pelo interpretador. "
"Observe que quando aparece uma linha contendo apenas o prompt secundário "
"você deve digitar uma linha em branco; é assim que se encerra um comando de "
"múltiplas linhas."
#: ../../tutorial/introduction.rst:16
msgid ""
"You can toggle the display of prompts and output by clicking on ``>>>`` in "
"the upper-right corner of an example box. If you hide the prompts and "
"output for an example, then you can easily copy and paste the input lines "
"into your interpreter."
msgstr ""
"Você pode alternar a exibição de prompts e saída clicando em ``>>>`` no "
"canto superior direito de uma caixa de exemplo. Se você ocultar os prompts e "
"a saída para um exemplo, poderá copiar e colar facilmente as linhas de "
"entrada no seu interpretador."
#: ../../tutorial/introduction.rst:23
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments. Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line. A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal. A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
"Muitos exemplos neste manual, mesmo aqueles inscritos na linha de comando "
"interativa, incluem comentários. Comentários em Python começam com o "
"caractere cerquilha ``#`` e estende até o final da linha. Um comentário pode "
"aparecer no inicio da linha ou após espaço em branco ou código, mas não "
"dentro de uma string literal. O caractere cerquilha dentro de uma string "
"literal é apenas uma cerquilha. Como os comentários são para esclarecer o "
"código e não são interpretados pelo Python, eles podem ser omitidos ao "
"digitar exemplos."
#: ../../tutorial/introduction.rst:31
msgid "Some examples::"
msgstr "Alguns exemplos:"
#: ../../tutorial/introduction.rst:42
msgid "Using Python as a Calculator"
msgstr "Usando Python como uma calculadora"
#: ../../tutorial/introduction.rst:44
msgid ""
"Let's try some simple Python commands. Start the interpreter and wait for "
"the primary prompt, ``>>>``. (It shouldn't take long.)"
msgstr ""
"Vamos experimentar alguns comandos simples em Python. Inicie o interpretador "
"e aguarde o prompt primário, ``>>>``. (Não deve demorar muito.)"
#: ../../tutorial/introduction.rst:51
msgid "Numbers"
msgstr "Números"
#: ../../tutorial/introduction.rst:53
msgid ""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value. Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
"O interpretador funciona como uma calculadora bem simples: você pode digitar "
"uma expressão e o resultado será apresentado. A sintaxe de expressões é a "
"usual: operadores ``+``, ``-``, ``*`` e ``/`` funcionam da mesma forma que "
"em outras linguagens tradicionais (por exemplo, Pascal ou C); parênteses "
"(``()``) podem ser usados para agrupar expressões. Por exemplo::"
#: ../../tutorial/introduction.rst:68
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
"`float`. We will see more about numeric types later in the tutorial."
msgstr ""
"Os números inteiros (por exemplo, ``2``, ``4`` e ``20``) são do tipo :class:"
"`int`, aqueles com parte fracionária (por exemplo, ``5.0`` e ``1.6``) são do "
"tipo :class:`float`. Veremos mais sobre tipos numéricos posteriormente neste "
"tutorial."
#: ../../tutorial/introduction.rst:72
msgid ""
"Division (``/``) always returns a float. To do :term:`floor division` and "
"get an integer result you can use the ``//`` operator; to calculate the "
"remainder you can use ``%``::"
msgstr ""
"Divisão (``/``) sempre retorna ponto flutuante (float). Para fazer uma :term:"
"`divisão pelo piso` e receber um inteiro como resultado você pode usar o "
"operador ``//``; para calcular o resto você pode usar o ``%``::"
#: ../../tutorial/introduction.rst:86
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
"Com Python, é possível usar o operador ``**`` para calcular potências [#]_::"
#: ../../tutorial/introduction.rst:93
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
"O sinal de igual (``'='``) é usado para atribuir um valor a uma variável. "
"Depois de uma atribuição, nenhum resultado é exibido antes do próximo "
"prompt::"
#: ../../tutorial/introduction.rst:101
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"Se uma variável não é \"definida\" (não tem um valor atribuído), tentar "
"utilizá-la levantará um erro::"
#: ../../tutorial/introduction.rst:109
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
"Há suporte completo para ponto flutuante (*float*); operadores com operandos "
"de diferentes tipos convertem o inteiro para ponto flutuante::"
#: ../../tutorial/introduction.rst:115
msgid ""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``. This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
"No modo interativo, o valor da última expressão exibida é atribuída a "
"variável ``_``. Assim, ao utilizar Python como uma calculadora, fica mais "
"fácil prosseguir com os cálculos, por exemplo::"
#: ../../tutorial/introduction.rst:128
msgid ""
"This variable should be treated as read-only by the user. Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
"Essa variável especial deve ser tratada como *somente para leitura* pelo "
"usuário. Nunca lhe atribua explicitamente um valor --- do contrário, estaria "
"criando uma outra variável (homônima) independente, que mascararia a "
"variável especial com seu comportamento mágico."
#: ../../tutorial/introduction.rst:132
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
"Fraction`. Python also has built-in support for :ref:`complex numbers "
"<typesnumeric>`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr ""
"Além de :class:`int` e :class:`float`, o Python oferece suporte a outros "
"tipos de números, tais como :class:`~decimal.Decimal` e :class:`~fractions."
"Fraction`. O Python também possui suporte embutido a :ref:`números complexos "
"<typesnumeric>`, e usa os sufixos ``j`` ou ``J`` para indicar a parte "
"imaginária (por exemplo, ``3+5j``)."
#: ../../tutorial/introduction.rst:142
msgid "Strings"
msgstr "Strings"
#: ../../tutorial/introduction.rst:144
msgid ""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways. They can be enclosed in single quotes (``'...'``) or "
"double quotes (``\"...\"``) with the same result [#]_. ``\\`` can be used "
"to escape quotes::"
msgstr ""
"Além de números, Python também pode manipular strings (sequências de "
"caracteres), que podem ser expressas de diversas formas. Elas podem ser "
"delimitadas por aspas simples (``'...'``) ou duplas (``\"...\"``) e teremos "
"o mesmo resultado [#]_. ``\\`` pode ser usada para escapar aspas::"
#: ../../tutorial/introduction.rst:162
msgid ""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes. While this might sometimes "
"look different from the input (the enclosing quotes could change), the two "
"strings are equivalent. The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes. The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
"Na interpretação interativa, a string de saída é delimitada com aspas e "
"caracteres especiais são escapados com barras invertidas. Embora isso possa "
"às vezes parecer diferente da entrada (as aspas podem mudar), as duas "
"strings são equivalentes. A string é delimitada com aspas duplas se a string "
"contiver uma única aspa simples e nenhuma aspa dupla, caso contrário, ela é "
"delimitada com aspas simples. A função :func:`print` produz uma saída mais "
"legível, ao omitir as aspas e ao imprimir caracteres escapados e especiais::"
#: ../../tutorial/introduction.rst:182
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"Caso não queira que os caracteres precedidos por ``\\`` sejam interpretados "
"como caracteres especiais, você pode usar *strings brutas* (*raw*, em "
"inglês) adicionando um ``r`` antes da primeira aspa::"
#: ../../tutorial/introduction.rst:192
msgid ""
"There is one subtle aspect to raw strings: a raw string may not end in an "
"odd number of ``\\`` characters; see :ref:`the FAQ entry <faq-programming-"
"raw-string-backslash>` for more information and workarounds."
msgstr ""
"Há um aspecto sutil nas strings brutas: uma string bruta não pode terminar "
"em um número ímpar de caracteres ``\\``; consulte :ref:`o FAQ relacionado "
"<faq-programming-raw-string-backslash>` para mais informações e soluções "
"alternativas."
#: ../../tutorial/introduction.rst:197
msgid ""
"String literals can span multiple lines. One way is using triple-quotes: "
"``\"\"\"...\"\"\"`` or ``'''...'''``. End of lines are automatically "
"included in the string, but it's possible to prevent this by adding a ``\\`` "
"at the end of the line. The following example::"
msgstr ""
"As strings literais podem abranger várias linhas. Uma maneira é usar as "
"aspas triplas: ``\"\"\"...\"\"\"`` ou ``'''...'''``. O fim das linhas é "
"incluído automaticamente na string, mas é possível evitar isso adicionando "
"uma ``\\`` no final. O seguinte exemplo::"
#: ../../tutorial/introduction.rst:208
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
"produz a seguinte saída (observe que a linha inicial não está incluída):"
#: ../../tutorial/introduction.rst:216
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
"Strings podem ser concatenadas (coladas) com o operador ``+``, e repetidas "
"com ``*``::"
#: ../../tutorial/introduction.rst:223
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
"Duas ou mais *strings literais* (ou seja, entre aspas) ao lado da outra são "
"automaticamente concatenados. ::"
#: ../../tutorial/introduction.rst:229
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr ""
"Esse recurso é particularmente útil quando você quer quebrar strings longas::"
#: ../../tutorial/introduction.rst:236
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"Isso só funciona com duas strings literais, não com variáveis ou expressões::"
#: ../../tutorial/introduction.rst:250
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
"Se você quiser concatenar variáveis ou uma variável e uma literal, use "
"``+``::"
#: ../../tutorial/introduction.rst:255
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
"As strings podem ser *indexadas* (subscritas), com o primeiro caractere como "
"índice 0. Não existe um tipo específico para caracteres; um caractere é "
"simplesmente uma string cujo tamanho é 1::"
#: ../../tutorial/introduction.rst:265
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"Índices também podem ser números negativos para iniciar a contagem pela "
"direita::"
#: ../../tutorial/introduction.rst:274
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr "Note que dado que -0 é o mesmo que 0, índices negativos começam em -1."
#: ../../tutorial/introduction.rst:276
msgid ""
"In addition to indexing, *slicing* is also supported. While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
"Além da indexação, o *fatiamento* também é permitido. Enquanto a indexação "
"seja usada para obter caracteres individuais, *fatiar* permite que você "
"obtenha uma substring:"
#: ../../tutorial/introduction.rst:284
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"Os índices do fatiamento possuem padrões úteis; um primeiro índice omitido "
"padrão é zero, um segundo índice omitido é por padrão o tamanho da string "
"sendo fatiada::"
#: ../../tutorial/introduction.rst:294
msgid ""
"Note how the start is always included, and the end always excluded. This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
"Observe como o início sempre está incluído, e o fim sempre é excluído. Isso "
"garante que ``s[:i] + s[i:]`` seja sempre igual a ``s``::"
#: ../../tutorial/introduction.rst:302
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
"Uma maneira de lembrar como fatias funcionam é pensar que os índices indicam "
"posições *entre* caracteres, onde a borda esquerda do primeiro caractere é "
"0. Assim, a borda direita do último caractere de uma string de comprimento "
"*n* tem índice *n*, por exemplo::"
#: ../../tutorial/introduction.rst:313
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
"A primeira fileira de números indica a posição dos índices 0...6 na string; "
"a segunda fileira indica a posição dos respectivos índices negativos. Uma "
"fatia de *i* a *j* consiste em todos os caracteres entre as bordas *i* e "
"*j*, respectivamente."
#: ../../tutorial/introduction.rst:318
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds. For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
"Para índices positivos, o comprimento da fatia é a diferença entre os "
"índices, se ambos estão dentro dos limites da string. Por exemplo, o "
"comprimento de ``word[1:3]`` é 2."
#: ../../tutorial/introduction.rst:322
msgid "Attempting to use an index that is too large will result in an error::"
msgstr ""
"A tentativa de usar um índice que seja muito grande resultará em um erro::"
#: ../../tutorial/introduction.rst:329
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"No entanto, os índices de fatiamento fora do alcance são tratados "
"graciosamente (N.d.T: o termo original “gracefully” indica robustez no "
"tratamento de erros) quando usados para fatiamento. Um índice maior que o "
"comprimento é trocado pelo comprimento, um limite superior menor que o "
"limite inferior produz uma string vazia::"
#: ../../tutorial/introduction.rst:337
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"As strings do Python não podem ser alteradas --- uma string é :term:"
"`imutável`. Portanto, atribuir a uma posição indexada na sequência resulta "
"em um erro::"
#: ../../tutorial/introduction.rst:349
msgid "If you need a different string, you should create a new one::"
msgstr "Se você precisar de uma string diferente, deverá criar uma nova::"
#: ../../tutorial/introduction.rst:356
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "A função embutida :func:`len` devolve o comprimento de uma string::"
#: ../../tutorial/introduction.rst:367
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"
#: ../../tutorial/introduction.rst:366
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"As strings são exemplos de *tipos de sequências* e suportam as operações "
"comumente suportadas por esses tipos."
#: ../../tutorial/introduction.rst:371
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"
#: ../../tutorial/introduction.rst:370
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
"As strings suportam uma grande quantidade de métodos para transformações "
"básicas e busca."
#: ../../tutorial/introduction.rst:374
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"
#: ../../tutorial/introduction.rst:374
msgid "String literals that have embedded expressions."
msgstr "Strings literais que possuem expressões embutidas."
#: ../../tutorial/introduction.rst:377
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"
#: ../../tutorial/introduction.rst:377
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
"Informações sobre formatação de string com o método :meth:`str.format`."
#: ../../tutorial/introduction.rst:380
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"
#: ../../tutorial/introduction.rst:380
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
"As antigas operações de formatação invocadas quando as strings são o "
"operando esquerdo do operador ``%`` são descritas com mais detalhes aqui."
#: ../../tutorial/introduction.rst:387
msgid "Lists"
msgstr "Listas"
#: ../../tutorial/introduction.rst:389
msgid ""
"Python knows a number of *compound* data types, used to group together other "
"values. The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets. Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
"Python inclui diversas estruturas de dados *compostas*, usadas para agrupar "
"outros valores. A mais versátil é *list* (lista), que pode ser escrita como "
"uma lista de valores (itens) separados por vírgula, entre colchetes. Os "
"valores contidos na lista não precisam ser todos do mesmo tipo. ::"
#: ../../tutorial/introduction.rst:398
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
"Como strings (e todos os tipos embutidos de :term:`sequência`), listas pode "
"ser indexados e fatiados::"
#: ../../tutorial/introduction.rst:408
msgid ""
"All slice operations return a new list containing the requested elements. "
"This means that the following slice returns a :ref:`shallow copy "
"<shallow_vs_deep_copy>` of the list::"
msgstr ""
"Todas as operações de fatiamento devolvem uma nova lista contendo os "
"elementos solicitados. Isso significa que o seguinte fatiamento devolve uma :"
"ref:`cópia rasa <shallow_vs_deep_copy>` da lista::"
#: ../../tutorial/introduction.rst:415
msgid "Lists also support operations like concatenation::"
msgstr "As listas também suportam operações como concatenação::"
#: ../../tutorial/introduction.rst:420
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
"Diferentemente de strings, que são :term:`imutáveis<immutable>`, listas são :"
"term:`mutáveis<mutable>`, ou seja, é possível alterar elementos individuais "
"de uma lista::"
#: ../../tutorial/introduction.rst:430
msgid ""
"You can also add new items at the end of the list, by using the :meth:`~list."
"append` *method* (we will see more about methods later)::"
msgstr ""
"Você também pode adicionar novos itens no final da lista, usando o *método* :"
"meth:`~list.append` (estudaremos mais a respeito dos métodos "
"posteriormente)::"
#: ../../tutorial/introduction.rst:438
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"Atribuição a fatias também é possível, e isso pode até alterar o tamanho da "
"lista ou remover todos os itens dela::"
#: ../../tutorial/introduction.rst:457
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "A função embutida :func:`len` também se aplica a listas::"
#: ../../tutorial/introduction.rst:463
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
"É possível aninhar listas (criar listas contendo outras listas), por "
"exemplo::"
#: ../../tutorial/introduction.rst:479
msgid "First Steps Towards Programming"
msgstr "Primeiros passos para a programação"
#: ../../tutorial/introduction.rst:481
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together. For instance, we can write an initial sub-sequence of the "
"`Fibonacci series <https://en.wikipedia.org/wiki/Fibonacci_number>`_ as "
"follows::"
msgstr ""
"Claro, podemos usar o Python para tarefas mais complicadas do que somar 2+2. "
"Por exemplo, podemos escrever o início da `sequência de Fibonacci <https://"
"pt.wikipedia.org/wiki/Sequ%C3%AAncia_de_Fibonacci>`_ assim::"
#: ../../tutorial/introduction.rst:501
msgid "This example introduces several new features."
msgstr "Este exemplo introduz diversas características ainda não mencionadas."
#: ../../tutorial/introduction.rst:503
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1. On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place. The right-"
"hand side expressions are evaluated from the left to the right."
msgstr ""
"A primeira linha contém uma atribuição múltipla: as variáveis ``a`` e ``b`` "
"recebem simultaneamente os novos valores 0 e 1. Na última linha há outro "
"exemplo de atribuição múltipla demonstrando que expressões do lado direito "
"são sempre avaliadas primeiro, antes da atribuição. As expressões do lado "
"direito são avaliadas da esquerda para a direita."
#: ../../tutorial/introduction.rst:509
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true. In Python, like in C, any non-zero integer value is "
"true; zero is false. The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false. The test used in the example is a simple comparison. The "
"standard comparison operators are written the same as in C: ``<`` (less "
"than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
"to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
"O laço de repetição :keyword:`while` executa enquanto a condição (aqui: ``a "
"< 10``) permanece verdadeira. Em Python, como em C, qualquer valor inteiro "
"que não seja zero é considerado verdadeiro; zero é considerado falso. A "
"condição pode também ser uma cadeia de caracteres ou uma lista, ou qualquer "
"sequência; qualquer coisa com um tamanho maior que zero é verdadeiro, "
"enquanto sequências vazias são falsas. O teste usado no exemplo é uma "
"comparação simples. Os operadores padrões de comparação são os mesmos de C: "
"``<`` (menor que), ``>`` (maior que), ``==`` (igual), ``<=`` (menor ou "
"igual), ``>=`` (maior ou igual) e ``!=`` (diferente)."
#: ../../tutorial/introduction.rst:518
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements. At the interactive prompt, you have to type a tab or "
"space(s) for each indented line. In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility. When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line). Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"O *corpo* do laço é *indentado*: indentação em Python é a maneira de agrupar "
"comandos em blocos. No console interativo padrão você terá que digitar tab "
"ou espaços para indentar cada linha. Na prática você vai preparar scripts "
"Python mais complicados em um editor de texto; a maioria dos editores de "
"texto tem facilidades de indentação automática. Quando um comando composto é "
"digitado interativamente, deve ser finalizado por uma linha em branco (já "
"que o interpretador não tem como adivinhar qual é a última linha do "
"comando). Observe que toda linha de um mesmo bloco de comandos deve ter a "
"mesma indentação."
#: ../../tutorial/introduction.rst:527
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating point quantities, and strings. Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
"A função :func:`print` escreve o valor dos argumentos fornecidos. É "
"diferente de apenas escrever a expressão no interpretador (como fizemos "
"anteriormente nos exemplos da calculadora) pela forma como lida com "
"múltiplos argumentos, quantidades de ponto flutuante e strings. As strings "
"são impressas sem aspas, e um espaço é inserido entre os itens, assim você "
"pode formatar bem o resultado, dessa forma::"
#: ../../tutorial/introduction.rst:538
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
"O argumento nomeado *end* pode ser usado para evitar uma nova linha após a "
"saída ou finalizar a saída com uma string diferente::"
#: ../../tutorial/introduction.rst:550
msgid "Footnotes"
msgstr "Notas de rodapé"
#: ../../tutorial/introduction.rst:551
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
"Uma vez que ``**`` tem precedência mais alta que ``-``, ``-3**2`` será "
"interpretado como ``-(3**2)`` e assim resultará em ``-9``. Para evitar isso "
"e obter ``9``, você pode usar ``(-3)**2``."
#: ../../tutorial/introduction.rst:555
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"Ao contrário de outras linguagens, caracteres especiais como ``\\n`` têm o "
"mesmo significado com as aspas simples (``'...'``) e duplas (``\"...\"``) . "
"A única diferença entre as duas é que, dentro de aspas simples, você não "
"precisa escapar o ``\"`` (mas você deve escapar a ``\\'``) e vice-versa."