{{ message }}
-
-
Notifications
You must be signed in to change notification settings - Fork 412
Expand file tree
/
Copy pathdesign.po
More file actions
1459 lines (1318 loc) · 69.6 KB
/
Copy pathdesign.po
File metadata and controls
1459 lines (1318 loc) · 69.6 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
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/python/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-10-25 19:47+0200\n"
"PO-Revision-Date: 2021-10-22 14:43+0100\n"
"Last-Translator: Claudia Millan <clmilneb@gmail.com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.10.3\n"
#: ../Doc/faq/design.rst:3
msgid "Design and History FAQ"
msgstr "Preguntas frecuentes sobre diseño e historia"
#: ../Doc/faq/design.rst:6
msgid "Contents"
msgstr "Contenido"
#: ../Doc/faq/design.rst:11
msgid "Why does Python use indentation for grouping of statements?"
msgstr "¿Por qué Python usa indentación para agrupar declaraciones?"
#: ../Doc/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 cree que usar indentación para agrupar es extremadamente "
"elegante y contribuye mucho a la claridad del programa Python promedio. La "
"mayoría de las personas aprenden a amar esta característica después de un "
"tiempo."
#: ../Doc/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 ""
"Como no hay corchetes de inicio/fin, no puede haber un desacuerdo entre la "
"agrupación percibida por el analizador y el lector humano. Ocasionalmente, "
"los programadores de C encontrarán un fragmento de código como este::"
#: ../Doc/faq/design.rst:26
msgid ""
"Only the ``x++`` statement is executed if the condition is true, but the "
"indentation leads many to believe otherwise. Even experienced C programmers "
"will sometimes stare at it a long time wondering as to why ``y`` is being "
"decremented even for ``x > y``."
msgstr ""
"Solo se ejecuta la instrucción ``x ++`` si la condición es verdadera, pero "
"la indentación lo lleva a creer lo contrario. Incluso los programadores "
"experimentados de C a veces lo miran durante mucho tiempo preguntándose por "
"qué ``y`` se está disminuyendo incluso para ``x > y``."
#: ../Doc/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. "
"After becoming used to reading and writing code using a particular style, it "
"is normal to feel somewhat uneasy when reading (or being required to write) "
"in a different one."
msgstr ""
"Debido a que no hay corchetes de inicio/fin, Python es mucho menos propenso "
"a conflictos de estilo de codificación. En C hay muchas formas diferentes de "
"colocar llaves. Después de acostumbrarse a leer y escribir código usando un "
"estilo en particular, es normal sentirse algo incómodo al leer (o tener que "
"escribir) en uno diferente."
#: ../Doc/faq/design.rst:38
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 ""
"Muchos estilos de codificación colocan corchetes de inicio / fin en una "
"línea por sí mismos. Esto hace que los programas sean considerablemente más "
"largos y desperdicia un valioso espacio en la pantalla, lo que dificulta "
"obtener una buena visión general de un programa. Idealmente, una función "
"debería caber en una pantalla (por ejemplo, 20-30 líneas). 20 líneas de "
"Python pueden hacer mucho más trabajo que 20 líneas de C. Esto no se debe "
"únicamente a la falta de corchetes de inicio/fin -- la falta de "
"declaraciones y los tipos de datos de alto nivel también son responsables -- "
"sino también la indentación basada en la sintaxis ciertamente ayuda."
#: ../Doc/faq/design.rst:48
msgid "Why am I getting strange results with simple arithmetic operations?"
msgstr ""
"¿Por qué obtengo resultados extraños con operaciones aritméticas simples?"
#: ../Doc/faq/design.rst:50
msgid "See the next question."
msgstr "Ver la siguiente pregunta."
#: ../Doc/faq/design.rst:54
msgid "Why are floating-point calculations so inaccurate?"
msgstr "¿Por qué los cálculos de punto flotante son tan inexactos?"
#: ../Doc/faq/design.rst:56
msgid "Users are often surprised by results like this::"
msgstr "Los usuarios a menudo se sorprenden por resultados como este::"
#: ../Doc/faq/design.rst:61
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 ""
"y creo que es un error en Python. No es. Esto tiene poco que ver con Python, "
"y mucho más con la forma en que la plataforma subyacente maneja los números "
"de punto flotante."
#: ../Doc/faq/design.rst:65
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 ""
"El tipo :class:`float` en CPython usa una C ``double`` para el "
"almacenamiento. Un valor del objeto :class:`float` se almacena en coma "
"flotante binaria con una precisión fija (típicamente 53 bits) y Python usa "
"operaciones C, que a su vez dependen de la implementación de hardware en el "
"procesador, para realizar operaciones de coma flotante. Esto significa que, "
"en lo que respecta a las operaciones de punto flotante, Python se comporta "
"como muchos lenguajes populares, incluidos C y Java."
#: ../Doc/faq/design.rst:72
msgid ""
"Many numbers that can be written easily in decimal notation cannot be "
"expressed exactly in binary floating-point. For example, after::"
msgstr ""
"Muchos números que se pueden escribir fácilmente en notación decimal no se "
"pueden expresar exactamente en coma flotante binaria. Por ejemplo, después "
"de::"
#: ../Doc/faq/design.rst:77
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 ""
"el valor almacenado para ``x`` es una aproximación (muy buena) al valor "
"decimal ``1.2``, pero no es exactamente igual a él. En una máquina típica, "
"el valor real almacenado es::"
#: ../Doc/faq/design.rst:83
msgid "which is exactly::"
msgstr "que es exactamente::"
#: ../Doc/faq/design.rst:87
msgid ""
"The typical precision of 53 bits provides Python floats with 15--16 decimal "
"digits of accuracy."
msgstr ""
"La precisión típica de 53 bits proporciona flotantes Python con 15--16 "
"dígitos decimales de precisión."
#: ../Doc/faq/design.rst:90
msgid ""
"For a fuller explanation, please see the :ref:`floating point arithmetic "
"<tut-fp-issues>` chapter in the Python tutorial."
msgstr ""
"Para obtener una explicación más completa, consulte el capítulo :ref:"
"`aritmética de coma flotante <tut-fp-issues>` en el tutorial de Python."
#: ../Doc/faq/design.rst:95
msgid "Why are Python strings immutable?"
msgstr "¿Por qué las cadenas de caracteres de Python son inmutables?"
#: ../Doc/faq/design.rst:97
msgid "There are several advantages."
msgstr "Hay varias ventajas."
#: ../Doc/faq/design.rst:99
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 ""
"Una es el rendimiento: saber que una cadena es inmutable significa que "
"podemos asignarle espacio en el momento de la creación, y los requisitos de "
"almacenamiento son fijos e inmutables. Esta es también una de las razones "
"para la distinción entre tuplas y listas."
#: ../Doc/faq/design.rst:104
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 ""
"Otra ventaja es que las cadenas en Python se consideran tan \"elementales\" "
"como los números. Ninguna cantidad de actividad cambiará el valor 8 a otra "
"cosa, y en Python, ninguna cantidad de actividad cambiará la cadena \"ocho\" "
"a otra cosa."
#: ../Doc/faq/design.rst:112
msgid "Why must 'self' be used explicitly in method definitions and calls?"
msgstr ""
"¿Por qué debe usarse 'self' explícitamente en las definiciones y llamadas de "
"métodos?"
#: ../Doc/faq/design.rst:114
msgid ""
"The idea was borrowed from Modula-3. It turns out to be very useful, for a "
"variety of reasons."
msgstr ""
"La idea fue tomada de Modula-3. Resulta ser muy útil, por una variedad de "
"razones."
#: ../Doc/faq/design.rst:117
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 ""
"Primero, es más obvio que está utilizando un método o atributo de instancia "
"en lugar de una variable local. Leer ``self.x`` o ``self.meth()`` deja "
"absolutamente claro que se usa una variable de instancia o método incluso si "
"no conoce la definición de clase de memoria. En C++, puede darse cuenta de "
"la falta de una declaración de variable local (suponiendo que los globales "
"son raros o fácilmente reconocibles) -- pero en Python, no hay declaraciones "
"de variables locales, por lo que debería buscar la definición de clase para "
"estar seguro. Algunos estándares de codificación de C++ y Java requieren que "
"los atributos de instancia tengan un prefijo ``m_``, porque el ser explícito "
"también es útil en esos lenguajes."
#: ../Doc/faq/design.rst:127
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 ""
"En segundo lugar, significa que no es necesaria una sintaxis especial si "
"desea hacer referencia explícita o llamar al método desde una clase en "
"particular. En C++, si desea usar un método de una clase base que se anula "
"en una clase derivada, debe usar el operador ``::`` -- en Python puede "
"escribir ``baseclass.methodname(self, <argument list>)``. Esto es "
"particularmente útil para métodos :meth:`__init__`, y en general en los "
"casos en que un método de clase derivada quiere extender el método de clase "
"base del mismo nombre y, por lo tanto, tiene que llamar al método de clase "
"base de alguna manera."
#: ../Doc/faq/design.rst:136
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, para las variables de instancia se resuelve un problema "
"sintáctico con la asignación: dado que las variables locales en Python son "
"(¡por definición!) Aquellas variables a las que se asigna un valor en un "
"cuerpo de función (y que no se declaran explícitamente como globales), tiene "
"que haber una forma de decirle al intérprete que una asignación estaba "
"destinada a asignar a una variable de instancia en lugar de a una variable "
"local, y que preferiblemente debería ser sintáctica (por razones de "
"eficiencia). C++ hace esto a través de declaraciones, pero Python no tiene "
"declaraciones y sería una pena tener que presentarlas solo para este "
"propósito. Usar el ``self.var`` explícito resuelve esto muy bien. Del mismo "
"modo, para usar variables de instancia, tener que escribir ``self.var`` "
"significa que las referencias a nombres no calificados dentro de un método "
"no tienen que buscar en los directorios de la instancia. Para decirlo de "
"otra manera, las variables locales y las variables de instancia viven en dos "
"espacios de nombres diferentes, y debe decirle a Python qué espacio de "
"nombres usar."
#: ../Doc/faq/design.rst:154
msgid "Why can't I use an assignment in an expression?"
msgstr "¿Por qué no puedo usar una tarea en una expresión?"
#: ../Doc/faq/design.rst:156
msgid "Starting in Python 3.8, you can!"
msgstr "¡A partir de Python 3.8, se puede!"
#: ../Doc/faq/design.rst:158
#, fuzzy
msgid ""
"Assignment expressions using the walrus operator ``:=`` assign a variable in "
"an expression::"
msgstr ""
"Asignación de expresiones usando el operador de morsa `:=` asigna una "
"variable en una expresión::"
#: ../Doc/faq/design.rst:164
msgid "See :pep:`572` for more information."
msgstr "Ver :pep:`572` para más información."
#: ../Doc/faq/design.rst:169
msgid ""
"Why does Python use methods for some functionality (e.g. list.index()) but "
"functions for other (e.g. len(list))?"
msgstr ""
"¿Por qué Python usa métodos para alguna funcionalidad (por ejemplo, list."
"index()) pero funciones para otra (por ejemplo, len(list))?"
#: ../Doc/faq/design.rst:171
msgid "As Guido said:"
msgstr "Como dijo Guido:"
#: ../Doc/faq/design.rst:173
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 algunas operaciones, la notación de prefijo solo se lee mejor que "
"postfijo -- las operaciones de prefijo (e ¡infijo!) tienen una larga "
"tradición en matemáticas que le gustan las anotaciones donde las imágenes "
"ayudan al matemático a pensar en un problema. Compare lo fácil con que "
"reescribimos una fórmula como x*(a+b) en x*a + x*b con la torpeza de hacer "
"lo mismo usando una notación OO sin procesar."
#: ../Doc/faq/design.rst:180
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) Cuando leo un código que dice len(x), *sé* que está pidiendo la longitud "
"de algo. Esto me dice dos cosas: el resultado es un número entero y el "
"argumento es algún tipo de contenedor. Por el contrario, cuando leo x.len "
"(), ya debo saber que x es algún tipo de contenedor que implementa una "
"interfaz o hereda de una clase que tiene un estándar len(). Sea testigo de "
"la confusión que ocasionalmente tenemos cuando una clase que no está "
"implementando una asignación tiene un método get() o keys(), o algo que no "
"es un archivo tiene un método write()."
#: ../Doc/faq/design.rst:207
msgid "https://mail.python.org/pipermail/python-3000/2006-November/004643.html"
msgstr ""
"https://mail.python.org/pipermail/python-3000/2006-November/004643.html"
#: ../Doc/faq/design.rst:193
msgid "Why is join() a string method instead of a list or tuple method?"
msgstr ""
"¿Por qué join() es un método de cadena de caracteres en lugar de un método "
"de lista o tupla?"
#: ../Doc/faq/design.rst:195
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 ""
"Las cadenas de caracteres se volvieron mucho más parecidas a otros tipos "
"estándar a partir de Python 1.6, cuando se agregaron métodos que brindan la "
"misma funcionalidad que siempre ha estado disponible utilizando las "
"funciones del módulo de cadenas. La mayoría de estos nuevos métodos han sido "
"ampliamente aceptados, pero el que parece hacer que algunos programadores se "
"sientan incómodos es:"
#: ../Doc/faq/design.rst:203
msgid "which gives the result::"
msgstr "que da el resultado::"
#: ../Doc/faq/design.rst:207
msgid "There are two common arguments against this usage."
msgstr "Hay dos argumentos comunes en contra de este uso."
#: ../Doc/faq/design.rst:209
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 ""
"El primero corre a lo largo de las líneas de: \"Se ve realmente feo el uso "
"de un método de un literal de cadena (constante de cadena)\", a lo que la "
"respuesta es que sí, pero un literal de cadena es solo un valor fijo. Si se "
"permiten los métodos en nombres vinculados a cadenas, no hay razón lógica "
"para que no estén disponibles en literales."
#: ../Doc/faq/design.rst:215
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 ""
"La segunda objeción generalmente se presenta como: \"Realmente estoy "
"diciéndole a una secuencia que una a sus miembros junto con una constante de "
"cadena\". Lamentablemente, no lo estas haciendo. Por alguna razón, parece "
"ser mucho menos difícil tener :meth:`~str.split` como método de cadena, ya "
"que en ese caso es fácil ver que::"
#: ../Doc/faq/design.rst:222
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 ""
"es una instrucción a un literal de cadena para retornar las subcadenas de "
"caracteres delimitadas por el separador dado (o, por defecto, ejecuciones "
"arbitrarias de espacio en blanco)."
#: ../Doc/faq/design.rst:225
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` es un método de cadena de caracteres porque al usarlo le "
"está diciendo a la cadena de separación que itere sobre una secuencia de "
"cadenas y se inserte entre elementos adyacentes. Este método se puede usar "
"con cualquier argumento que obedezca las reglas para los objetos de "
"secuencia, incluidas las clases nuevas que pueda definir usted mismo. "
"Existen métodos similares para bytes y objetos bytearray."
#: ../Doc/faq/design.rst:233
msgid "How fast are exceptions?"
msgstr "¿Qué tan rápido van las excepciones?"
#: ../Doc/faq/design.rst:235
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 ""
"Un bloque try/except es extremadamente eficiente si no se generan "
"excepciones. En realidad, capturar una excepción es costoso. En versiones de "
"Python anteriores a la 2.0, era común usar este modismo::"
#: ../Doc/faq/design.rst:245
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 ""
"Esto solo tenía sentido cuando esperaba que el dict tuviera la clave casi "
"todo el tiempo. Si ese no fuera el caso, lo codificó así:"
#: ../Doc/faq/design.rst:253
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, también podría usar ``value = dict."
"setdefault(key, getvalue(key))``, pero solo si la llamada ``getvalue()`` es "
"lo suficientemente barata porque se evalúa en todos los casos."
#: ../Doc/faq/design.rst:259
msgid "Why isn't there a switch or case statement in Python?"
msgstr "¿Por qué no hay un *switch* o una declaración *case* en Python?"
#: ../Doc/faq/design.rst:261
msgid ""
"You can do this easily enough with a sequence of ``if... elif... elif... "
"else``. For literal values, or constants within a namespace, you can also "
"use a ``match ... case`` statement."
msgstr ""
"Puede hacer esto con bastante facilidad con una secuencia de ``if... "
"elif... elif... else``. Para valores literales, o constantes dentro de un "
"espacio de nombres, también puede usar una declaración ``match ... case``."
#: ../Doc/faq/design.rst:265
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 los casos en los que necesita elegir entre una gran cantidad de "
"posibilidades, puede crear un diccionario que asigne valores de casos a "
"funciones para llamar. Por ejemplo::"
#: ../Doc/faq/design.rst:276
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 invocar métodos en objetos, puede simplificar aún más utilizando :func:"
"`getattr` incorporado para recuperar métodos con un nombre particular::"
#: ../Doc/faq/design.rst:288
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 ""
"Se sugiere que utilice un prefijo para los nombres de los métodos, como "
"``visit_`` en este ejemplo. Sin dicho prefijo, si los valores provienen de "
"una fuente no confiable, un atacante podría invocar cualquier método en su "
"objeto."
#: ../Doc/faq/design.rst:294
msgid ""
"Can't you emulate threads in the interpreter instead of relying on an OS-"
"specific thread implementation?"
msgstr ""
"¿No puede emular hilos en el intérprete en lugar de confiar en una "
"implementación de hilos específica del sistema operativo?"
#: ../Doc/faq/design.rst:296
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 ""
"Respuesta 1: Desafortunadamente, el intérprete empuja al menos un marco de "
"pila C para cada marco de pila de Python. Además, las extensiones pueden "
"volver a llamar a Python en momentos casi aleatorios. Por lo tanto, una "
"implementación completa de subprocesos requiere soporte de subprocesos para "
"C."
#: ../Doc/faq/design.rst:301
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 ""
"Respuesta 2: Afortunadamente, existe `Python sin pila <https://github.com/"
"stackless-dev/stackless/wiki>`_, que tiene un bucle de intérprete "
"completamente rediseñado que evita la pila C."
#: ../Doc/faq/design.rst:306
msgid "Why can't lambda expressions contain statements?"
msgstr "¿Por qué las expresiones lambda no pueden contener sentencias?"
#: ../Doc/faq/design.rst:308
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 ""
"Las expresiones lambda de Python no pueden contener declaraciones porque el "
"marco sintáctico de Python no puede manejar declaraciones anidadas dentro de "
"expresiones. Sin embargo, en Python, este no es un problema grave. A "
"diferencia de las formas lambda en otros lenguajes, donde agregan "
"funcionalidad, las lambdas de Python son solo una notación abreviada si eres "
"demasiado vago para definir una función."
#: ../Doc/faq/design.rst:314
#, fuzzy
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 ""
"Las funciones ya son objetos de primera clase en Python y pueden declararse "
"en un ámbito local. Por lo tanto, la única ventaja de usar una lambda en "
"lugar de una función definida localmente es que no es necesario inventar un "
"nombre para la función, sino que es solo una variable local para la cual el "
"objeto de función (que es exactamente el mismo tipo de se asigna un objeto "
"que produce una expresión lambda)"
#: ../Doc/faq/design.rst:322
msgid "Can Python be compiled to machine code, C or some other language?"
msgstr "¿Se puede compilar Python en código máquina, C o algún otro lenguaje?"
#: ../Doc/faq/design.rst:324
#, fuzzy
msgid ""
"`Cython <https://cython.org/>`_ compiles a modified version of Python with "
"optional annotations into C extensions. `Nuitka <https://www.nuitka.net/>`_ "
"is an up-and-coming compiler of Python into C++ code, aiming to support the "
"full Python language."
msgstr ""
"`Cython <http://cython.org/>`_ compila una versión modificada de Python con "
"anotaciones opcionales en extensiones C. `Nuitka <http://www.nuitka.net/>`_ "
"es un compilador prometedor de Python en código C ++, con el objetivo de "
"soportar el lenguaje completo de Python. Para compilar en Java puede "
"considerar `VOC <https://voc.readthedocs.io>`_."
#: ../Doc/faq/design.rst:331
msgid "How does Python manage memory?"
msgstr "¿Cómo gestiona Python la memoria?"
#: ../Doc/faq/design.rst:333
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 ""
"Los detalles de la administración de memoria de Python dependen de la "
"implementación. La implementación estándar de Python, :term:`CPython`, "
"utiliza el recuento de referencias para detectar objetos inaccesibles, y "
"otro mecanismo para recopilar ciclos de referencia, ejecutando "
"periódicamente un algoritmo de detección de ciclos que busca ciclos "
"inaccesibles y elimina los objetos involucrados. El módulo :mod:`gc` "
"proporciona funciones para realizar una recolección de basura, obtener "
"estadísticas de depuración y ajustar los parámetros del recolector."
#: ../Doc/faq/design.rst:341
#, fuzzy
msgid ""
"Other implementations (such as `Jython <https://www.jython.org>`_ or `PyPy "
"<https://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 ""
"Sin embargo, otras implementaciones (como `Jython <http://www.jython.org>`_ "
"o `PyPy <http://www.pypy.org>`_) pueden confiar en un mecanismo diferente, "
"como recolector de basura. Esta diferencia puede causar algunos problemas "
"sutiles de portabilidad si su código de Python depende del comportamiento de "
"la implementación de conteo de referencias."
#: ../Doc/faq/design.rst:347
msgid ""
"In some Python implementations, the following code (which is fine in "
"CPython) will probably run out of file descriptors::"
msgstr ""
"En algunas implementaciones de Python, el siguiente código (que está bien en "
"CPython) probablemente se quedará sin descriptores de archivo::"
#: ../Doc/faq/design.rst:354
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 ""
"De hecho, utilizando el esquema de conteo de referencias y destructor de "
"CPython, cada nueva asignación a *f* cierra el archivo anterior. Sin "
"embargo, con un GC tradicional, esos objetos de archivo solo se recopilarán "
"(y cerrarán) a intervalos variables y posiblemente largos."
#: ../Doc/faq/design.rst:359
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 ""
"Si desea escribir código que funcione con cualquier implementación de "
"Python, debe cerrar explícitamente el archivo o utilizar una declaración :"
"keyword:`with`; esto funcionará independientemente del esquema de "
"administración de memoria::"
#: ../Doc/faq/design.rst:369
msgid "Why doesn't CPython use a more traditional garbage collection scheme?"
msgstr ""
"¿Por qué CPython no utiliza un esquema de recolección de basura más "
"tradicional?"
#: ../Doc/faq/design.rst:371
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 un lado, esta no es una característica estándar de C y, por lo tanto, no "
"es portátil. (Sí, sabemos acerca de la biblioteca Boehm GC. Tiene fragmentos "
"de código de ensamblador para *la mayoría* de las plataformas comunes, no "
"para todas ellas, y aunque es principalmente transparente, no es "
"completamente transparente; se requieren parches para obtener Python para "
"trabajar con eso)"
#: ../Doc/faq/design.rst:377
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 ""
"El GC tradicional también se convierte en un problema cuando Python está "
"integrado en otras aplicaciones. Mientras que en un Python independiente "
"está bien reemplazar el estándar malloc() y free() con versiones "
"proporcionadas por la biblioteca GC, una aplicación que incruste Python "
"puede querer tener su *propio* sustituto de malloc() y free(), y puede No "
"quiero a Python. En este momento, CPython funciona con todo lo que "
"implementa malloc() y free() correctamente."
#: ../Doc/faq/design.rst:386
msgid "Why isn't all memory freed when CPython exits?"
msgstr "¿Por qué no se libera toda la memoria cuando sale CPython?"
#: ../Doc/faq/design.rst:388
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 ""
"Los objetos a los que se hace referencia desde los espacios de nombres "
"globales de los módulos de Python no siempre se desasignan cuando Python "
"sale. Esto puede suceder si hay referencias circulares. También hay ciertos "
"bits de memoria asignados por la biblioteca de C que son imposibles de "
"liberar (por ejemplo, una herramienta como Purify se quejará de estos). "
"Python es, sin embargo, agresivo sobre la limpieza de la memoria al salir e "
"intenta destruir cada objeto."
#: ../Doc/faq/design.rst:395
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 ""
"Si desea forzar a Python a eliminar ciertas cosas en la desasignación, use "
"el módulo :mod:`atexit` para ejecutar una función que obligará a esas "
"eliminaciones."
#: ../Doc/faq/design.rst:400
msgid "Why are there separate tuple and list data types?"
msgstr "¿Por qué hay tipos de datos separados de tuplas y listas?"
#: ../Doc/faq/design.rst:402
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 ""
"Las listas y las tuplas, si bien son similares en muchos aspectos, "
"generalmente se usan de maneras fundamentalmente diferentes. Se puede pensar "
"que las tuplas son similares a los registros Pascal o estructuras C; son "
"pequeñas colecciones de datos relacionados que pueden ser de diferentes "
"tipos que funcionan como un grupo. Por ejemplo, una coordenada cartesiana se "
"representa adecuadamente como una tupla de dos o tres números."
#: ../Doc/faq/design.rst:409
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 ""
"Las listas, por otro lado, son más como matrices en otros lenguajes. Tienden "
"a contener un número variable de objetos, todos los cuales tienen el mismo "
"tipo y que se operan uno por uno. Por ejemplo, ``os.listdir('.')`` Retorna "
"una lista de cadenas de caracteres que representan los archivos en el "
"directorio actual. Las funciones que operan en esta salida generalmente no "
"se romperían si agregara otro archivo o dos al directorio."
#: ../Doc/faq/design.rst:416
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 ""
"Las tuplas son inmutables, lo que significa que una vez que se ha creado una "
"tupla, no puede reemplazar ninguno de sus elementos con un nuevo valor. Las "
"listas son mutables, lo que significa que siempre puede cambiar los "
"elementos de una lista. Solo los elementos inmutables se pueden usar como "
"claves de diccionario y, por lo tanto, solo las tuplas y no las listas se "
"pueden usar como claves."
#: ../Doc/faq/design.rst:423
msgid "How are lists implemented in CPython?"
msgstr "¿Cómo se implementan las listas en Python?"
#: ../Doc/faq/design.rst:425
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 ""
"Las listas de CPython son realmente matrices de longitud variable, no listas "
"enlazadas al estilo Lisp. La implementación utiliza una matriz contigua de "
"referencias a otros objetos y mantiene un puntero a esta matriz y la "
"longitud de la matriz en una estructura de encabezado de lista."
#: ../Doc/faq/design.rst:429
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 ""
"Esto hace que indexar una lista ``a[i]`` una operación cuyo costo es "
"independiente del tamaño de la lista o del valor del índice."
#: ../Doc/faq/design.rst:432
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 ""
"Cuando se añaden o insertan elementos, la matriz de referencias cambia de "
"tamaño. Se aplica cierta inteligencia para mejorar el rendimiento de la "
"adición de elementos repetidamente; cuando la matriz debe crecer, se asigna "
"un espacio extra para que las próximas veces no requieran un cambio de "
"tamaño real."
#: ../Doc/faq/design.rst:439
msgid "How are dictionaries implemented in CPython?"
msgstr "¿Cómo se implementan los diccionarios en CPython?"
#: ../Doc/faq/design.rst:441
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 ""
"Los diccionarios de CPython se implementan como tablas hash "
"redimensionables. En comparación con los árboles B (*B-trees*), esto "
"proporciona un mejor rendimiento para la búsqueda (la operación más común "
"con diferencia) en la mayoría de las circunstancias, y la implementación es "
"más simple."
#: ../Doc/faq/design.rst:445
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 ""
"Los diccionarios funcionan calculando un código hash para cada clave "
"almacenada en el diccionario utilizando la función incorporada :func:`hash`. "
"El código hash varía ampliamente según la clave y una semilla por proceso; "
"por ejemplo, \"Python\" podría dividir en hash a -539294296 mientras que "
"\"python\", una cadena que difiere en un solo bit, podría dividir en "
"1142331976. El código de resumen se usa para calcular una ubicación en una "
"matriz interna donde se almacenará el valor . Suponiendo que está "
"almacenando claves que tienen valores hash diferentes, esto significa que "
"los diccionarios toman tiempo constante -- O(1), en notación Big-O -- para "
"recuperar una clave."
#: ../Doc/faq/design.rst:456
msgid "Why must dictionary keys be immutable?"
msgstr "¿Por qué las claves del diccionario deben ser inmutables?"
#: ../Doc/faq/design.rst:458
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 ""
"La implementación de la tabla hash de los diccionarios utiliza un valor hash "
"calculado a partir del valor clave para encontrar la clave. Si la clave "
"fuera un objeto mutable, su valor podría cambiar y, por lo tanto, su hash "
"también podría cambiar. Pero dado que quien cambie el objeto clave no puede "
"decir que se estaba utilizando como clave de diccionario, no puede mover la "
"entrada en el diccionario. Luego, cuando intente buscar el mismo objeto en "
"el diccionario, no se encontrará porque su valor hash es diferente. Si trató "
"de buscar el valor anterior, tampoco lo encontraría, porque el valor del "
"objeto que se encuentra en ese hash bin sería diferente."
#: ../Doc/faq/design.rst:467
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 ""
"Si desea un diccionario indexado con una lista, simplemente convierta la "
"lista a una tupla primero; La función ``tuple(L)`` crea una tupla con las "
"mismas entradas que la lista ``L``. Las tuplas son inmutables y, por lo "
"tanto, pueden usarse como claves de diccionario."
#: ../Doc/faq/design.rst:471
msgid "Some unacceptable solutions that have been proposed:"
msgstr "Algunas soluciones inaceptables que se han propuesto:"
#: ../Doc/faq/design.rst:473
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 su dirección (ID de objeto). Esto no funciona porque si "
"construye una nueva lista con el mismo valor, no se encontrará; por ejemplo::"
#: ../Doc/faq/design.rst:479
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 ""
"generaría una excepción :exc:`KeyError` porque la identificación del ``[1, "
"2]`` usado en la segunda línea difiere de la de la primera línea. En otras "
"palabras, las claves del diccionario deben compararse usando ``==``, no "
"usando :keyword:`is`."
#: ../Doc/faq/design.rst:483
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 ""
"Hacer una copia cuando use una lista como clave. Esto no funciona porque la "
"lista, al ser un objeto mutable, podría contener una referencia a sí misma, "
"y luego el código de copia se ejecutaría en un bucle infinito."
#: ../Doc/faq/design.rst:487
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 claves pero decirle al usuario que no las modifique. "
"Esto permitiría una clase de errores difíciles de rastrear en los programas "
"cuando olvidó o modificó una lista por accidente. También invalida una "
"invariante importante de diccionarios: cada valor en ``d.keys()`` se puede "
"usar como una clave del diccionario."
#: ../Doc/faq/design.rst:492
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 las listas como de solo lectura una vez que se usan como clave de "
"diccionario. El problema es que no solo el objeto de nivel superior puede "
"cambiar su valor; podría usar una tupla que contiene una lista como clave. "
"Ingresar cualquier cosa como clave en un diccionario requeriría marcar todos "
"los objetos accesibles desde allí como de solo lectura -- y nuevamente, los "
"objetos autoreferenciados podrían causar un bucle infinito."
#: ../Doc/faq/design.rst:498
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 ""
"Hay un truco para evitar esto si lo necesita, pero úselo bajo su propio "
"riesgo: puede envolver una estructura mutable dentro de una instancia de "
You can’t perform that action at this time.