-
-
Notifications
You must be signed in to change notification settings - Fork 40
Expand file tree
/
Copy pathdesign.po
More file actions
1331 lines (1192 loc) · 60.7 KB
/
design.po
File metadata and controls
1331 lines (1192 loc) · 60.7 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
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Claudio Rogerio Carvalho Filho <excriptbrasil@gmail.com>, 2020
# Fernando, 2020
# Aline Balogh <linecrist@hotmail.com>, 2020
# Amanda Savluchinske <amandasavluchinske@gmail.com>, 2020
# Vitor Buxbaum Orlandi, 2023
# Rafael Fontenelle <rffontenelle@gmail.com>, 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 11:53+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 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"
#: ../../faq/design.rst:3
msgid "Design and History FAQ"
msgstr "FAQ sobre design e histórico"
#: ../../faq/design.rst:6
msgid "Contents"
msgstr "Conteúdo"
#: ../../faq/design.rst:11
msgid "Why does Python use indentation for grouping of statements?"
msgstr "Por que o Python usa indentação para agrupamento de instruções?"
#: ../../faq/design.rst:13
msgid ""
"Guido van Rossum believes that using indentation for grouping is extremely "
"elegant and contributes a lot to the clarity of the average Python program. "
"Most people learn to love this feature after a while."
msgstr ""
"Guido van Rossum acredita que usar indentação para agrupamento é "
"extremamente elegante e contribui muito para a clareza de programa Python "
"mediano. Muitas pessoas aprendem a amar esta ferramenta depois de um tempo."
#: ../../faq/design.rst:17
msgid ""
"Since there are no begin/end brackets there cannot be a disagreement between "
"grouping perceived by the parser and the human reader. Occasionally C "
"programmers will encounter a fragment of code like this::"
msgstr ""
"Uma vez que não há colchetes de início / fim, não pode haver um desacordo "
"entre o agrupamento percebido pelo analisador sintático e pelo leitor "
"humano. Ocasionalmente, programadores C irão encontrar um fragmento de "
"código como este::"
#: ../../faq/design.rst:26
msgid ""
"Only the ``x++`` statement is executed if the condition is true, but the "
"indentation leads you to believe otherwise. Even experienced C programmers "
"will sometimes stare at it a long time wondering why ``y`` is being "
"decremented even for ``x > y``."
msgstr ""
#: ../../faq/design.rst:31
msgid ""
"Because there are no begin/end brackets, Python is much less prone to coding-"
"style conflicts. In C there are many different ways to place the braces. If "
"you're used to reading and writing code that uses one style, you will feel "
"at least slightly uneasy when reading (or being required to write) another "
"style."
msgstr ""
#: ../../faq/design.rst:36
msgid ""
"Many coding styles place begin/end brackets on a line by themselves. This "
"makes programs considerably longer and wastes valuable screen space, making "
"it harder to get a good overview of a program. Ideally, a function should "
"fit on one screen (say, 20--30 lines). 20 lines of Python can do a lot more "
"work than 20 lines of C. This is not solely due to the lack of begin/end "
"brackets -- the lack of declarations and the high-level data types are also "
"responsible -- but the indentation-based syntax certainly helps."
msgstr ""
"Muitos estilos de codificação colocam chaves de início / fim em uma linha "
"sozinhos. Isto torna os programas consideravelmente mais longos e desperdiça "
"espaço valioso na tela, dificultando a obtenção de uma boa visão geral de um "
"programa. Idealmente, uma função deve caber em uma tela (digamos, 20 a 30 "
"linhas). 20 linhas de Python podem fazer muito mais trabalho do que 20 "
"linhas de C. Isso não se deve apenas à falta de colchetes de início/fim -- a "
"falta de declarações e os tipos de dados de alto nível também são "
"responsáveis -- mas a sintaxe baseada em indentação certamente ajuda."
#: ../../faq/design.rst:46
msgid "Why am I getting strange results with simple arithmetic operations?"
msgstr ""
"Por que eu estou recebendo resultados estranhos com simples operações "
"aritméticas?"
#: ../../faq/design.rst:48
msgid "See the next question."
msgstr "Veja a próxima questão."
#: ../../faq/design.rst:52
msgid "Why are floating-point calculations so inaccurate?"
msgstr "Por que o cálculo de pontos flutuantes são tão imprecisos?"
#: ../../faq/design.rst:54
msgid "Users are often surprised by results like this::"
msgstr "Usuários são frequentemente surpreendidos por resultados como este::"
#: ../../faq/design.rst:59
msgid ""
"and think it is a bug in Python. It's not. This has little to do with "
"Python, and much more to do with how the underlying platform handles "
"floating-point numbers."
msgstr ""
"e pensam que isto é um bug do Python. Não é não. Isto tem pouco a ver com o "
"Python, e muito mais a ver com como a estrutura da plataforma lida com "
"números em ponto flutuante."
#: ../../faq/design.rst:63
msgid ""
"The :class:`float` type in CPython uses a C ``double`` for storage. "
"A :class:`float` object's value is stored in binary floating-point with a "
"fixed precision (typically 53 bits) and Python uses C operations, which in "
"turn rely on the hardware implementation in the processor, to perform "
"floating-point operations. This means that as far as floating-point "
"operations are concerned, Python behaves like many popular languages "
"including C and Java."
msgstr ""
"O tipo :class:`float` no CPython usa um ``double`` do C para armazenamento. "
"O valor de um objeto :class:`float` é armazenado em ponto flutuante binário "
"com uma precisão fixa (normalmente 53 bits) e Python usa operações C, que "
"por sua vez dependem da implementação de hardware no processador, para "
"realizar operações de ponto flutuante. Isso significa que, no que diz "
"respeito às operações de ponto flutuante, Python se comporta como muitas "
"linguagens populares, incluindo C e Java."
#: ../../faq/design.rst:70
msgid ""
"Many numbers that can be written easily in decimal notation cannot be "
"expressed exactly in binary floating-point. For example, after::"
msgstr ""
"Muitos números podem ser escritos facilmente em notação decimal, mas não "
"podem ser expressados exatamente em ponto flutuante binário. Por exemplo, "
"após::"
#: ../../faq/design.rst:75
msgid ""
"the value stored for ``x`` is a (very good) approximation to the decimal "
"value ``1.2``, but is not exactly equal to it. On a typical machine, the "
"actual stored value is::"
msgstr ""
"o valor armazenado para ``x`` é uma (ótima) aproximação para o valor decimal "
"``1.2``, mas não é exatamente igual. Em uma máquina típica, o valor real "
"armazenado é::"
#: ../../faq/design.rst:81
msgid "which is exactly::"
msgstr "que é exatamente::"
#: ../../faq/design.rst:85
msgid ""
"The typical precision of 53 bits provides Python floats with 15--16 decimal "
"digits of accuracy."
msgstr ""
"A precisão típica de 53 bits fornece floats do Python com precisão de 15 a "
"16 dígitos decimais."
#: ../../faq/design.rst:88
msgid ""
"For a fuller explanation, please see the :ref:`floating point arithmetic "
"<tut-fp-issues>` chapter in the Python tutorial."
msgstr ""
"Para uma explicação mais completa, consulte o capítulo de :ref:`aritmética "
"de ponto flutuante <tut-fp-issues>` no tutorial Python."
#: ../../faq/design.rst:93
msgid "Why are Python strings immutable?"
msgstr "Por que strings do Python são imutáveis?"
#: ../../faq/design.rst:95
msgid "There are several advantages."
msgstr "Existem várias vantagens."
#: ../../faq/design.rst:97
msgid ""
"One is performance: knowing that a string is immutable means we can allocate "
"space for it at creation time, and the storage requirements are fixed and "
"unchanging. This is also one of the reasons for the distinction between "
"tuples and lists."
msgstr ""
"Uma delas é o desempenho: saber que uma string é imutável significa que "
"podemos alocar espaço para ela no momento da criação, e os requisitos de "
"armazenamento são fixos e imutáveis. Esta é também uma das razões para a "
"distinção entre tuplas e listas."
#: ../../faq/design.rst:102
msgid ""
"Another advantage is that strings in Python are considered as \"elemental\" "
"as numbers. No amount of activity will change the value 8 to anything else, "
"and in Python, no amount of activity will change the string \"eight\" to "
"anything else."
msgstr ""
"Outra vantagem é que strings em Python são consideradas tão “elementares” "
"quanto números. Nenhuma atividade alterará o valor 8 para qualquer outra "
"coisa e, em Python, nenhuma atividade alterará a string “oito” para qualquer "
"outra coisa."
#: ../../faq/design.rst:110
msgid "Why must 'self' be used explicitly in method definitions and calls?"
msgstr ""
"Por que o 'self' deve ser usado explicitamente em definições de método e "
"chamadas?"
#: ../../faq/design.rst:112
msgid ""
"The idea was borrowed from Modula-3. It turns out to be very useful, for a "
"variety of reasons."
msgstr ""
"A ideia foi emprestada do Modula-3. Acontece dela ser muito útil, por vários "
"motivos."
#: ../../faq/design.rst:115
msgid ""
"First, it's more obvious that you are using a method or instance attribute "
"instead of a local variable. Reading ``self.x`` or ``self.meth()`` makes it "
"absolutely clear that an instance variable or method is used even if you "
"don't know the class definition by heart. In C++, you can sort of tell by "
"the lack of a local variable declaration (assuming globals are rare or "
"easily recognizable) -- but in Python, there are no local variable "
"declarations, so you'd have to look up the class definition to be sure. "
"Some C++ and Java coding standards call for instance attributes to have an "
"``m_`` prefix, so this explicitness is still useful in those languages, too."
msgstr ""
"Primeiro, é mais óbvio que você está usando um método ou atributo de "
"instância em vez de uma variável local. Ler ``self.x`` ou ``self.meth()`` "
"deixa absolutamente claro que uma variável de instância ou método é usado "
"mesmo se você não souber a definição da classe de cor. Em C++, você pode "
"perceber pela falta de uma declaração de variável local (presumindo que "
"globais são raras ou facilmente reconhecíveis) -- mas no Python não há "
"declarações de variáveis locais, então você teria que procurar a definição "
"de classe para tenha certeza. Alguns padrões de codificação C++ e Java "
"exigem que atributos de instância tenham um prefixo ``m_``, portanto, essa "
"explicitação ainda é útil nessas linguagens também."
#: ../../faq/design.rst:125
msgid ""
"Second, it means that no special syntax is necessary if you want to "
"explicitly reference or call the method from a particular class. In C++, if "
"you want to use a method from a base class which is overridden in a derived "
"class, you have to use the ``::`` operator -- in Python you can write "
"``baseclass.methodname(self, <argument list>)``. This is particularly "
"useful for :meth:`__init__` methods, and in general in cases where a derived "
"class method wants to extend the base class method of the same name and thus "
"has to call the base class method somehow."
msgstr ""
#: ../../faq/design.rst:134
msgid ""
"Finally, for instance variables it solves a syntactic problem with "
"assignment: since local variables in Python are (by definition!) those "
"variables to which a value is assigned in a function body (and that aren't "
"explicitly declared global), there has to be some way to tell the "
"interpreter that an assignment was meant to assign to an instance variable "
"instead of to a local variable, and it should preferably be syntactic (for "
"efficiency reasons). C++ does this through declarations, but Python doesn't "
"have declarations and it would be a pity having to introduce them just for "
"this purpose. Using the explicit ``self.var`` solves this nicely. "
"Similarly, for using instance variables, having to write ``self.var`` means "
"that references to unqualified names inside a method don't have to search "
"the instance's directories. To put it another way, local variables and "
"instance variables live in two different namespaces, and you need to tell "
"Python which namespace to use."
msgstr ""
"Finalmente, por exemplo, variáveis, ele resolve um problema sintático com "
"atribuição: uma vez que variáveis locais em Python são (por definição!) "
"aquelas variáveis às quais um valor é atribuído em um corpo de função (e que "
"não são explicitamente declaradas globais), é necessário deve haver alguma "
"forma de dizer ao interpretador que uma atribuição deveria ser atribuída a "
"uma variável de instância em vez de a uma variável local, e deve ser "
"preferencialmente sintática (por razões de eficiência). C++ faz isso através "
"de declarações, mas Python não possui declarações e seria uma pena ter que "
"introduzi-las apenas para esse fim. Usar o ``self.var`` explícito resolve "
"isso muito bem. Da mesma forma, para usar variáveis de instância, ter que "
"escrever ``self.var`` significa que referências a nomes não qualificados "
"dentro de um método não precisam pesquisar nos diretórios da instância. Em "
"outras palavras, variáveis locais e variáveis de instância residem em dois "
"espaço de nomes diferentes, e você precisa informar ao Python qual espaço de "
"nomes usar."
#: ../../faq/design.rst:152
msgid "Why can't I use an assignment in an expression?"
msgstr "Por que não posso usar uma atribuição em uma expressão?"
#: ../../faq/design.rst:154
msgid "Starting in Python 3.8, you can!"
msgstr "A partir do Python 3.8, você pode!"
#: ../../faq/design.rst:156
msgid ""
"Assignment expressions using the walrus operator `:=` assign a variable in "
"an expression::"
msgstr ""
"Expressões de atribuição usando o operador morsa `\\:=` atribuem uma "
"variável em uma expressão::"
#: ../../faq/design.rst:162
msgid "See :pep:`572` for more information."
msgstr "Veja :pep:`572` para mais informações."
#: ../../faq/design.rst:167
msgid ""
"Why does Python use methods for some functionality (e.g. list.index()) but "
"functions for other (e.g. len(list))?"
msgstr ""
"Por que o Python usa métodos para algumas funcionalidades (ex: "
"lista.index()) mas funções para outras (ex: len(lista))?"
#: ../../faq/design.rst:169
msgid "As Guido said:"
msgstr "Como Guido disse:"
#: ../../faq/design.rst:171
msgid ""
"(a) For some operations, prefix notation just reads better than postfix -- "
"prefix (and infix!) operations have a long tradition in mathematics which "
"likes notations where the visuals help the mathematician thinking about a "
"problem. Compare the easy with which we rewrite a formula like x*(a+b) into "
"x*a + x*b to the clumsiness of doing the same thing using a raw OO notation."
msgstr ""
"(a) Para algumas operações, a notação de prefixo é melhor lida do que as "
"operações de prefixo (e infixo!) têm uma longa tradição em matemática que "
"gosta de notações onde os recursos visuais ajudam o matemático a pensar "
"sobre um problema. Compare a facilidade com que reescrevemos uma fórmula "
"como x*(a+b) em x*a + x*b com a falta de jeito de fazer a mesma coisa usando "
"uma notação OO bruta."
#: ../../faq/design.rst:178
msgid ""
"(b) When I read code that says len(x) I *know* that it is asking for the "
"length of something. This tells me two things: the result is an integer, and "
"the argument is some kind of container. To the contrary, when I read "
"x.len(), I have to already know that x is some kind of container "
"implementing an interface or inheriting from a class that has a standard "
"len(). Witness the confusion we occasionally have when a class that is not "
"implementing a mapping has a get() or keys() method, or something that isn't "
"a file has a write() method."
msgstr ""
"(b) Quando leio o código que diz len(x) eu *sei* que ele está perguntando o "
"comprimento de alguma coisa. Isso me diz duas coisas: o resultado é um "
"número inteiro e o argumento é algum tipo de contêiner. Pelo contrário, "
"quando leio x.len(), já devo saber que x é algum tipo de contêiner "
"implementando uma interface ou herdando de uma classe que possui um len() "
"padrão. Veja a confusão que ocasionalmente temos quando uma classe que não "
"está implementando um mapeamento tem um método get() ou keys(), ou algo que "
"não é um arquivo tem um método write()."
#: ../../faq/design.rst:205
msgid "https://mail.python.org/pipermail/python-3000/2006-November/004643.html"
msgstr ""
"https://mail.python.org/pipermail/python-3000/2006-November/004643.html"
#: ../../faq/design.rst:191
msgid "Why is join() a string method instead of a list or tuple method?"
msgstr ""
"Por que o join() é um método de string em vez de ser um método de lista ou "
"tupla?"
#: ../../faq/design.rst:193
msgid ""
"Strings became much more like other standard types starting in Python 1.6, "
"when methods were added which give the same functionality that has always "
"been available using the functions of the string module. Most of these new "
"methods have been widely accepted, but the one which appears to make some "
"programmers feel uncomfortable is::"
msgstr ""
"Strings se tornaram muito parecidas com outros tipos padrão a partir do "
"Python 1.6, quando métodos que dão a mesma funcionalidade que sempre esteve "
"disponível utilizando as funções do módulo de string foram adicionados. A "
"maior parte desses novos métodos foram amplamente aceitos, mas o que parece "
"deixar alguns programadores desconfortáveis é::"
#: ../../faq/design.rst:201
msgid "which gives the result::"
msgstr "que dá o resultado::"
#: ../../faq/design.rst:205
msgid "There are two common arguments against this usage."
msgstr "Existem dois argumentos comuns contra esse uso."
#: ../../faq/design.rst:207
msgid ""
"The first runs along the lines of: \"It looks really ugly using a method of "
"a string literal (string constant)\", to which the answer is that it might, "
"but a string literal is just a fixed value. If the methods are to be allowed "
"on names bound to strings there is no logical reason to make them "
"unavailable on literals."
msgstr ""
"O primeiro segue as linhas de: \"Parece muito feio usar um método de uma "
"string literal (constante de string)\", para o qual a resposta é que pode, "
"mas uma string literal é apenas um valor fixo. Se os métodos devem ser "
"permitidos em nomes vinculados a strings, não há razão lógica para torná-los "
"indisponíveis em literais."
#: ../../faq/design.rst:213
msgid ""
"The second objection is typically cast as: \"I am really telling a sequence "
"to join its members together with a string constant\". Sadly, you aren't. "
"For some reason there seems to be much less difficulty with "
"having :meth:`~str.split` as a string method, since in that case it is easy "
"to see that ::"
msgstr ""
"A segunda objeção é normalmente formulada como: \"Na verdade, estou dizendo "
"a uma sequência para unir seus membros com uma constante de string\". "
"Infelizmente, você não está. Por alguma razão parece haver muito menos "
"dificuldade em ter :meth:`~str.split` como um método string, já que nesse "
"caso é fácil ver que ::"
#: ../../faq/design.rst:220
msgid ""
"is an instruction to a string literal to return the substrings delimited by "
"the given separator (or, by default, arbitrary runs of white space)."
msgstr ""
"é uma instrução para uma string literal para retornar as substrings "
"delimitadas pelo separador fornecido (ou, por padrão, execuções arbitrárias "
"de espaço em branco)."
#: ../../faq/design.rst:223
msgid ""
":meth:`~str.join` is a string method because in using it you are telling the "
"separator string to iterate over a sequence of strings and insert itself "
"between adjacent elements. This method can be used with any argument which "
"obeys the rules for sequence objects, including any new classes you might "
"define yourself. Similar methods exist for bytes and bytearray objects."
msgstr ""
":meth:`~str.join` é um método de string porque ao usá-lo você está dizendo à "
"string separadora para iterar sobre uma sequência de strings e se inserir "
"entre elementos adjacentes. Este método pode ser usado com qualquer "
"argumento que obedeça às regras para objetos sequência, incluindo quaisquer "
"novas classes que você mesmo possa definir. Existem métodos semelhantes para "
"bytes e objetos bytearray."
#: ../../faq/design.rst:231
msgid "How fast are exceptions?"
msgstr "Quão rápidas são as exceções?"
#: ../../faq/design.rst:233
msgid ""
"A try/except block is extremely efficient if no exceptions are raised. "
"Actually catching an exception is expensive. In versions of Python prior to "
"2.0 it was common to use this idiom::"
msgstr ""
"Um bloco de try/except é extremamente eficiente se nenhuma exceção for "
"levantada. Na verdade, capturar uma exceção custa caro. Em versões do Python "
"anteriores a 2.0 era comum utilizar esse idioma::"
#: ../../faq/design.rst:243
msgid ""
"This only made sense when you expected the dict to have the key almost all "
"the time. If that wasn't the case, you coded it like this::"
msgstr ""
"Isso somente fazia sentido quando você esperava que o dicionário tivesse uma "
"chave quase que toda vez. Se esse não fosse o caso, você escrevia desta "
"maneira::"
#: ../../faq/design.rst:251
msgid ""
"For this specific case, you could also use ``value = dict.setdefault(key, "
"getvalue(key))``, but only if the ``getvalue()`` call is cheap enough "
"because it is evaluated in all cases."
msgstr ""
"Para este caso específico, você também pode usar ``value = "
"dict.setdefault(key, getvalue(key))``, mas apenas se a chamada "
"``getvalue()`` tiver pouco custosa o suficiente porque é avaliada em todos "
"os casos."
#: ../../faq/design.rst:257
msgid "Why isn't there a switch or case statement in Python?"
msgstr "Por que não existe uma instrução de switch ou case no Python?"
#: ../../faq/design.rst:259
msgid ""
"You can do this easily enough with a sequence of ``if... elif... elif... "
"else``. There have been some proposals for switch statement syntax, but "
"there is no consensus (yet) on whether and how to do range tests. "
"See :pep:`275` for complete details and the current status."
msgstr ""
#: ../../faq/design.rst:264
msgid ""
"For cases where you need to choose from a very large number of "
"possibilities, you can create a dictionary mapping case values to functions "
"to call. For example::"
msgstr ""
"Para casos em que você precisa escolher entre um grande número de "
"possibilidades, você pode criar um dicionário mapeando valores de caso para "
"funções a serem chamadas. Por exemplo::"
#: ../../faq/design.rst:278
msgid ""
"For calling methods on objects, you can simplify yet further by using "
"the :func:`getattr` built-in to retrieve methods with a particular name::"
msgstr ""
"Para chamar métodos em objetos, você pode simplificar ainda mais usando olá "
"função embutida :func:`getattr` para recuperar métodos com um nome "
"específico::"
#: ../../faq/design.rst:290
msgid ""
"It's suggested that you use a prefix for the method names, such as "
"``visit_`` in this example. Without such a prefix, if values are coming "
"from an untrusted source, an attacker would be able to call any method on "
"your object."
msgstr ""
"É sugerido que você use um prefixo para os nomes dos métodos, como "
"``visit_`` neste exemplo. Sem esse prefixo, se os valores vierem de uma "
"fonte não confiável, um invasor poderá chamar qualquer método no seu objeto."
#: ../../faq/design.rst:296
msgid ""
"Can't you emulate threads in the interpreter instead of relying on an OS-"
"specific thread implementation?"
msgstr ""
"Você não pode emular threads no interpretador em vez de confiar em uma "
"implementação de thread específica do sistema operacional?"
#: ../../faq/design.rst:298
msgid ""
"Answer 1: Unfortunately, the interpreter pushes at least one C stack frame "
"for each Python stack frame. Also, extensions can call back into Python at "
"almost random moments. Therefore, a complete threads implementation "
"requires thread support for C."
msgstr ""
"Resposta 1: Infelizmente, o interpretador envia pelo menos um quadro de "
"pilha C para cada quadro de pilha Python. Além disso, as extensões podem "
"retornar ao Python em momentos quase aleatórios. Portanto, uma implementação "
"completa de threads requer suporte de thread para C."
#: ../../faq/design.rst:303
msgid ""
"Answer 2: Fortunately, there is `Stackless Python <https://github.com/"
"stackless-dev/stackless/wiki>`_, which has a completely redesigned "
"interpreter loop that avoids the C stack."
msgstr ""
"Resposta 2: Felizmente, existe o `Stackless Python <https://github.com/"
"stackless-dev/stackless/wiki>`_, que tem um laço de interpretador "
"completamente redesenhado que evita a pilha C."
#: ../../faq/design.rst:308
msgid "Why can't lambda expressions contain statements?"
msgstr "Por que expressões lambda não podem conter instruções?"
#: ../../faq/design.rst:310
msgid ""
"Python lambda expressions cannot contain statements because Python's "
"syntactic framework can't handle statements nested inside expressions. "
"However, in Python, this is not a serious problem. Unlike lambda forms in "
"other languages, where they add functionality, Python lambdas are only a "
"shorthand notation if you're too lazy to define a function."
msgstr ""
"Expressões lambda no Python não podem conter instruções porque o framework "
"sintático do Python não consegue manipular instruções aninhadas dentro de "
"expressões. No entanto, no Python, isso não é um problema sério. "
"Diferentemente das formas de lambda em outras linguagens, onde elas "
"adicionam funcionalidade, lambdas de Python são apenas notações "
"simplificadas se você tiver muita preguiça de definir uma função."
#: ../../faq/design.rst:316
msgid ""
"Functions are already first class objects in Python, and can be declared in "
"a local scope. Therefore the only advantage of using a lambda instead of a "
"locally-defined function is that you don't need to invent a name for the "
"function -- but that's just a local variable to which the function object "
"(which is exactly the same type of object that a lambda expression yields) "
"is assigned!"
msgstr ""
"Funções já são objetos de primeira classe em Python, e podem ser declaradas "
"em um escopo local. Portanto a única vantagem de usar um lambda em vez de "
"uma função definida localmente é que você não precisa inventar um nome para "
"a função -- mas esta só é uma variável local para a qual o objeto da função "
"(que é exatamente do mesmo tipo de um objeto que uma expressão lambda "
"carrega) é atribuído!"
#: ../../faq/design.rst:324
msgid "Can Python be compiled to machine code, C or some other language?"
msgstr ""
"O Python pode ser compilado para linguagem de máquina, C ou alguma outra "
"linguagem?"
#: ../../faq/design.rst:326
msgid ""
"`Cython <http://cython.org/>`_ compiles a modified version of Python with "
"optional annotations into C extensions. `Nuitka <http://www.nuitka.net/>`_ "
"is an up-and-coming compiler of Python into C++ code, aiming to support the "
"full Python language. For compiling to Java you can consider `VOC <https://"
"voc.readthedocs.io>`_."
msgstr ""
#: ../../faq/design.rst:334
msgid "How does Python manage memory?"
msgstr "Como o Python gerencia memória?"
#: ../../faq/design.rst:336
msgid ""
"The details of Python memory management depend on the implementation. The "
"standard implementation of Python, :term:`CPython`, uses reference counting "
"to detect inaccessible objects, and another mechanism to collect reference "
"cycles, periodically executing a cycle detection algorithm which looks for "
"inaccessible cycles and deletes the objects involved. The :mod:`gc` module "
"provides functions to perform a garbage collection, obtain debugging "
"statistics, and tune the collector's parameters."
msgstr ""
"Os detalhes do gerenciamento de memória Python dependem da implementação. A "
"implementação padrão do Python, :term:`CPython`, usa contagem de referências "
"para detectar objetos inacessíveis, e outro mecanismo para coletar ciclos de "
"referência, executando periodicamente um algoritmo de detecção de ciclo que "
"procura por ciclos inacessíveis e exclui os objetos envolvidos. O "
"módulo :mod:`gc` fornece funções para realizar uma coleta de lixo, obter "
"estatísticas de depuração e ajustar os parâmetros do coletor."
#: ../../faq/design.rst:344
msgid ""
"Other implementations (such as `Jython <http://www.jython.org>`_ or `PyPy "
"<http://www.pypy.org>`_), however, can rely on a different mechanism such as "
"a full-blown garbage collector. This difference can cause some subtle "
"porting problems if your Python code depends on the behavior of the "
"reference counting implementation."
msgstr ""
#: ../../faq/design.rst:350
msgid ""
"In some Python implementations, the following code (which is fine in "
"CPython) will probably run out of file descriptors::"
msgstr ""
"Em algumas implementações do Python, o código a seguir (que funciona bem no "
"CPython) provavelmente ficará sem descritores de arquivo:"
#: ../../faq/design.rst:357
msgid ""
"Indeed, using CPython's reference counting and destructor scheme, each new "
"assignment to *f* closes the previous file. With a traditional GC, however, "
"those file objects will only get collected (and closed) at varying and "
"possibly long intervals."
msgstr ""
#: ../../faq/design.rst:362
msgid ""
"If you want to write code that will work with any Python implementation, you "
"should explicitly close the file or use the :keyword:`with` statement; this "
"will work regardless of memory management scheme::"
msgstr ""
"Se você quiser escrever um código que funcione com qualquer implementação "
"Python, você deve fechar explicitamente o arquivo ou usar a "
"instrução :keyword:`with`; isso funcionará independentemente do esquema de "
"gerenciamento de memória::"
#: ../../faq/design.rst:372
msgid "Why doesn't CPython use a more traditional garbage collection scheme?"
msgstr ""
"Por que o CPython não usa uma forma mais tradicional de esquema de coleta de "
"lixo?"
#: ../../faq/design.rst:374
msgid ""
"For one thing, this is not a C standard feature and hence it's not portable. "
"(Yes, we know about the Boehm GC library. It has bits of assembler code for "
"*most* common platforms, not for all of them, and although it is mostly "
"transparent, it isn't completely transparent; patches are required to get "
"Python to work with it.)"
msgstr ""
"Por um lado, este não é um recurso padrão C e, portanto, não é portátil. "
"(Sim, sabemos sobre a biblioteca Boehm GC. Ela possui pedaços de código "
"assembler para a *maioria* das plataformas comuns, não para todas elas, e "
"embora seja em sua maioria transparente, não é completamente transparente; "
"são necessários patches para obter Python para trabalhar com isso.)"
#: ../../faq/design.rst:380
msgid ""
"Traditional GC also becomes a problem when Python is embedded into other "
"applications. While in a standalone Python it's fine to replace the "
"standard malloc() and free() with versions provided by the GC library, an "
"application embedding Python may want to have its *own* substitute for "
"malloc() and free(), and may not want Python's. Right now, CPython works "
"with anything that implements malloc() and free() properly."
msgstr ""
#: ../../faq/design.rst:389
msgid "Why isn't all memory freed when CPython exits?"
msgstr "Por que toda memória não é liberada quando o CPython fecha?"
#: ../../faq/design.rst:391
msgid ""
"Objects referenced from the global namespaces of Python modules are not "
"always deallocated when Python exits. This may happen if there are circular "
"references. There are also certain bits of memory that are allocated by the "
"C library that are impossible to free (e.g. a tool like Purify will complain "
"about these). Python is, however, aggressive about cleaning up memory on "
"exit and does try to destroy every single object."
msgstr ""
"Os objetos referenciados nos espaço de nomes globais dos módulos Python nem "
"sempre são desalocados quando o Python é encerrado. Isso pode acontecer se "
"houver referências circulares. Existem também certos bits de memória "
"alocados pela biblioteca C que são impossíveis de liberar (por exemplo, uma "
"ferramenta como o Purify reclamará disso). Python é, no entanto, agressivo "
"quanto à limpeza de memória na saída e tenta destruir todos os objetos."
#: ../../faq/design.rst:398
msgid ""
"If you want to force Python to delete certain things on deallocation use "
"the :mod:`atexit` module to run a function that will force those deletions."
msgstr ""
"Se você quiser forçar o Python a excluir certas coisas na desalocação, use o "
"módulo :mod:`atexit` para executar uma função que forçará essas exclusões."
#: ../../faq/design.rst:403
msgid "Why are there separate tuple and list data types?"
msgstr "Por que existem tipos de dados separados para tuplas e listas?"
#: ../../faq/design.rst:405
msgid ""
"Lists and tuples, while similar in many respects, are generally used in "
"fundamentally different ways. Tuples can be thought of as being similar to "
"Pascal records or C structs; they're small collections of related data which "
"may be of different types which are operated on as a group. For example, a "
"Cartesian coordinate is appropriately represented as a tuple of two or three "
"numbers."
msgstr ""
#: ../../faq/design.rst:412
msgid ""
"Lists, on the other hand, are more like arrays in other languages. They "
"tend to hold a varying number of objects all of which have the same type and "
"which are operated on one-by-one. For example, ``os.listdir('.')`` returns "
"a list of strings representing the files in the current directory. "
"Functions which operate on this output would generally not break if you "
"added another file or two to the directory."
msgstr ""
#: ../../faq/design.rst:419
msgid ""
"Tuples are immutable, meaning that once a tuple has been created, you can't "
"replace any of its elements with a new value. Lists are mutable, meaning "
"that you can always change a list's elements. Only immutable elements can "
"be used as dictionary keys, and hence only tuples and not lists can be used "
"as keys."
msgstr ""
"As tuplas são imutáveis, o que significa que, uma vez criada uma tupla, você "
"não pode substituir nenhum de seus elementos por um novo valor. As listas "
"são mutáveis, o que significa que você sempre pode alterar os elementos de "
"uma lista. Somente elementos imutáveis podem ser usados como chaves de "
"dicionário e, portanto, apenas tuplas e não listas podem ser usadas como "
"chaves."
#: ../../faq/design.rst:426
msgid "How are lists implemented in CPython?"
msgstr "Como as listas são implementadas no CPython?"
#: ../../faq/design.rst:428
msgid ""
"CPython's lists are really variable-length arrays, not Lisp-style linked "
"lists. The implementation uses a contiguous array of references to other "
"objects, and keeps a pointer to this array and the array's length in a list "
"head structure."
msgstr ""
"As listas do CPython são, na verdade, vetores de comprimento variável, "
"listas vinculadas não no estilo Lisp. A implementação usa um vetor contíguo "
"de referências a outros objetos e mantém um ponteiro para esse vetor e o "
"comprimento de vetor em uma estrutura de cabeçalho de lista."
#: ../../faq/design.rst:432
msgid ""
"This makes indexing a list ``a[i]`` an operation whose cost is independent "
"of the size of the list or the value of the index."
msgstr ""
"Isso torna a indexação de uma lista ``a[i]`` uma operação cujo custo é "
"independente do tamanho da lista ou do valor do índice."
#: ../../faq/design.rst:435
msgid ""
"When items are appended or inserted, the array of references is resized. "
"Some cleverness is applied to improve the performance of appending items "
"repeatedly; when the array must be grown, some extra space is allocated so "
"the next few times don't require an actual resize."
msgstr ""
"Quando itens são anexados ou inseridos, o vetor de referências é "
"redimensionado. Alguma inteligência é aplicada para melhorar o desempenho de "
"anexar itens repetidamente; quando o vetor precisa ser aumentado, algum "
"espaço extra é alocado para que as próximas vezes não exijam um "
"redimensionamento real."
#: ../../faq/design.rst:442
msgid "How are dictionaries implemented in CPython?"
msgstr "Como são os dicionários implementados no CPython?"
#: ../../faq/design.rst:444
msgid ""
"CPython's dictionaries are implemented as resizable hash tables. Compared "
"to B-trees, this gives better performance for lookup (the most common "
"operation by far) under most circumstances, and the implementation is "
"simpler."
msgstr ""
"Os dicionários do CPython são implementados como tabelas hash "
"redimensionáveis. Em comparação com árvores B, isso oferece melhor "
"desempenho para pesquisa (de longe a operação mais comum) na maioria das "
"circunstâncias, e a implementação é mais simples."
#: ../../faq/design.rst:448
msgid ""
"Dictionaries work by computing a hash code for each key stored in the "
"dictionary using the :func:`hash` built-in function. The hash code varies "
"widely depending on the key and a per-process seed; for example, \"Python\" "
"could hash to -539294296 while \"python\", a string that differs by a single "
"bit, could hash to 1142331976. The hash code is then used to calculate a "
"location in an internal array where the value will be stored. Assuming that "
"you're storing keys that all have different hash values, this means that "
"dictionaries take constant time -- O(1), in Big-O notation -- to retrieve a "
"key."
msgstr ""
#: ../../faq/design.rst:459
msgid "Why must dictionary keys be immutable?"
msgstr "Por que chaves de dicionário devem ser imutáveis?"
#: ../../faq/design.rst:461
msgid ""
"The hash table implementation of dictionaries uses a hash value calculated "
"from the key value to find the key. If the key were a mutable object, its "
"value could change, and thus its hash could also change. But since whoever "
"changes the key object can't tell that it was being used as a dictionary "
"key, it can't move the entry around in the dictionary. Then, when you try "
"to look up the same object in the dictionary it won't be found because its "
"hash value is different. If you tried to look up the old value it wouldn't "
"be found either, because the value of the object found in that hash bin "
"would be different."
msgstr ""
"A implementação da tabela hash de dicionários usa um valor hash calculado a "
"partir do valor da chave para encontrar a chave. Se a chave fosse um objeto "
"mutável, seu valor poderia mudar e, portanto, seu hash também poderia mudar. "
"Mas como quem altera o objeto-chave não pode saber que ele estava sendo "
"usado como chave de dicionário, ele não pode mover a entrada no dicionário. "
"Então, quando você tentar procurar o mesmo objeto no dicionário, ele não "
"será encontrado porque seu valor de hash é diferente. Se você tentasse "
"procurar o valor antigo, ele também não seria encontrado, porque o valor do "
"objeto encontrado naquele hash seria diferente."
#: ../../faq/design.rst:470
msgid ""
"If you want a dictionary indexed with a list, simply convert the list to a "
"tuple first; the function ``tuple(L)`` creates a tuple with the same entries "
"as the list ``L``. Tuples are immutable and can therefore be used as "
"dictionary keys."
msgstr ""
"Se você deseja que um dicionário seja indexado com uma lista, simplesmente "
"converta primeiro a lista em uma tupla; a função ``tuple(L)`` cria uma tupla "
"com as mesmas entradas da lista ``L``. As tuplas são imutáveis e, portanto, "
"podem ser usadas como chaves de dicionário."
#: ../../faq/design.rst:474
msgid "Some unacceptable solutions that have been proposed:"
msgstr "Algumas soluções inaceitáveis que foram propostas:"
#: ../../faq/design.rst:476
msgid ""
"Hash lists by their address (object ID). This doesn't work because if you "
"construct a new list with the same value it won't be found; e.g.::"
msgstr ""
"Listas de hash por endereço (ID do objeto). Isto não funciona porque se você "
"construir uma nova lista com o mesmo valor ela não será encontrada; por "
"exemplo.::"
#: ../../faq/design.rst:482
msgid ""
"would raise a :exc:`KeyError` exception because the id of the ``[1, 2]`` "
"used in the second line differs from that in the first line. In other "
"words, dictionary keys should be compared using ``==``, not "
"using :keyword:`is`."
msgstr ""
"levantaria uma exceção :exc:`KeyError` porque o id do ``[1, 2]`` usado na "
"segunda linha difere daquele da primeira linha. Em outras palavras, as "
"chaves de dicionário devem ser comparadas usando ``==``, não "
"usando :keyword:`is`."
#: ../../faq/design.rst:486
msgid ""
"Make a copy when using a list as a key. This doesn't work because the list, "
"being a mutable object, could contain a reference to itself, and then the "
"copying code would run into an infinite loop."
msgstr ""
"Fazer uma cópia ao usar uma lista como chave. Isso não funciona porque a "
"lista, sendo um objeto mutável, poderia conter uma referência a si mesma e "
"então o código copiado entraria em um laço infinito."
#: ../../faq/design.rst:490
msgid ""
"Allow lists as keys but tell the user not to modify them. This would allow "
"a class of hard-to-track bugs in programs when you forgot or modified a list "
"by accident. It also invalidates an important invariant of dictionaries: "
"every value in ``d.keys()`` is usable as a key of the dictionary."
msgstr ""
"Permitir listas como chaves, mas dizer ao usuário para não modificá-las. "
"Isso permitiria uma classe de bugs difíceis de rastrear em programas quando "
"você esquecesse ou modificasse uma lista por acidente. Também invalida uma "
"importante invariante dos dicionários: todo valor em ``d.keys()`` pode ser "
"usado como chave do dicionário."
#: ../../faq/design.rst:495
msgid ""
"Mark lists as read-only once they are used as a dictionary key. The problem "
"is that it's not just the top-level object that could change its value; you "
"could use a tuple containing a list as a key. Entering anything as a key "
"into a dictionary would require marking all objects reachable from there as "
"read-only -- and again, self-referential objects could cause an infinite "
"loop."
msgstr ""
"Marcar listas como somente leitura quando forem usadas como chave de "
"dicionário. O problema é que não é apenas o objeto de nível superior que "
"pode alterar seu valor; você poderia usar uma tupla contendo uma lista como "
"chave. Inserir qualquer coisa como chave em um dicionário exigiria marcar "
"todos os objetos acessíveis a partir daí como somente leitura -- e, "
"novamente, objetos autorreferenciais poderiam causar um laço infinito."
#: ../../faq/design.rst:501
msgid ""
"There is a trick to get around this if you need to, but use it at your own "
"risk: You can wrap a mutable structure inside a class instance which has "
"both a :meth:`__eq__` and a :meth:`__hash__` method. You must then make "
"sure that the hash value for all such wrapper objects that reside in a "
"dictionary (or other hash based structure), remain fixed while the object is "
"in the dictionary (or other structure). ::"
msgstr ""
#: ../../faq/design.rst:525
msgid ""
"Note that the hash computation is complicated by the possibility that some "
"members of the list may be unhashable and also by the possibility of "
"arithmetic overflow."
msgstr ""
"Observe que o cálculo do hash é complicado pela possibilidade de que alguns "
"membros da lista possam ser não não-hasheável e também pela possibilidade de "
"estouro aritmético."
#: ../../faq/design.rst:529
msgid ""
"Furthermore it must always be the case that if ``o1 == o2`` (ie "
"``o1.__eq__(o2) is True``) then ``hash(o1) == hash(o2)`` (ie, "
"``o1.__hash__() == o2.__hash__()``), regardless of whether the object is in "
"a dictionary or not. If you fail to meet these restrictions dictionaries "
"and other hash based structures will misbehave."
msgstr ""
"Além disso, deve ser sempre o caso que se ``o1 == o2`` (ou seja, "
"``o1.__eq__(o2) is True``) então ``hash(o1) == hash(o2)`` (ou seja, "
"``o1.__hash__() == o2.__hash__()``), independentemente de o objeto estar em "
"um dicionário ou não. Se você não cumprir essas restrições, os dicionários e "
"outras estruturas baseadas em hash se comportarão mal."
#: ../../faq/design.rst:534
msgid ""
"In the case of ListWrapper, whenever the wrapper object is in a dictionary "
"the wrapped list must not change to avoid anomalies. Don't do this unless "
"you are prepared to think hard about the requirements and the consequences "
"of not meeting them correctly. Consider yourself warned."
msgstr ""
#: ../../faq/design.rst:541
msgid "Why doesn't list.sort() return the sorted list?"
msgstr "Por que lista.sort() não retorna a lista ordenada?"
#: ../../faq/design.rst:543
msgid ""
"In situations where performance matters, making a copy of the list just to "
"sort it would be wasteful. Therefore, :meth:`list.sort` sorts the list in "
"place. In order to remind you of that fact, it does not return the sorted "
"list. This way, you won't be fooled into accidentally overwriting a list "
"when you need a sorted copy but also need to keep the unsorted version "
"around."
msgstr ""
"Em situações nas quais desempenho importa, fazer uma cópia da lista só para "
"ordenar seria desperdício. Portanto, :meth:`lista.sort` ordena a lista. De "
"forma a lembrá-lo desse fato, isso não retorna a lista ordenada. Desta "
"forma, você não vai ser confundido a acidentalmente sobrescrever uma lista "
"quando você precisar de uma cópia ordenada mas também precisar manter a "
"versão não ordenada."
#: ../../faq/design.rst:549
msgid ""
"If you want to return a new list, use the built-in :func:`sorted` function "
"instead. This function creates a new list from a provided iterable, sorts "
"it and returns it. For example, here's how to iterate over the keys of a "
"dictionary in sorted order::"
msgstr ""
"Se você quiser retornar uma nova lista, use a função embutida :func:`sorted` "
"ao invés. Essa função cria uma nova lista a partir de um iterável provido, o "