Repository navigation
Expand file tree
/
Copy pathsimple_stmts.po
More file actions
2209 lines (1915 loc) · 87.2 KB
/
Copy pathsimple_stmts.po
File metadata and controls
2209 lines (1915 loc) · 87.2 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: 2026-02-26 18:44-0300\n"
"PO-Revision-Date: 2021-08-02 19:21+0200\n"
"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@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.18.0\n"
#: ../Doc/reference/simple_stmts.rst:6
msgid "Simple statements"
msgstr "Declaraciones simples"
#: ../Doc/reference/simple_stmts.rst:10
msgid ""
"A simple statement is comprised within a single logical line. Several simple "
"statements may occur on a single line separated by semicolons. The syntax "
"for simple statements is:"
msgstr ""
"Una declaración simple se compone dentro de una sola línea lógica. Pueden "
"producirse varias declaraciones simples en una sola línea separada por punto "
"y coma. La sintaxis de las declaraciones simples es:"
#: ../Doc/reference/simple_stmts.rst:37
msgid "Expression statements"
msgstr "Declaraciones de tipo expresión"
#: ../Doc/reference/simple_stmts.rst:44
msgid ""
"Expression statements are used (mostly interactively) to compute and write a "
"value, or (usually) to call a procedure (a function that returns no "
"meaningful result; in Python, procedures return the value ``None``). Other "
"uses of expression statements are allowed and occasionally useful. The "
"syntax for an expression statement is:"
msgstr ""
"Las declaraciones de tipo expresión son usadas (en su mayoría "
"interactivamente) para computar y escribir un valor, o (usualmente) para "
"llamar a un método (una función que no retorna un resultado significativo; "
"en Python, los métodos retornan el valor ``None``). Otros usos de las "
"declaraciones de tipo expresión son permitidas y ocasionalmente útiles. La "
"sintaxis para una declaración de tipo expresión es:"
#: ../Doc/reference/simple_stmts.rst:53
msgid ""
"An expression statement evaluates the expression list (which may be a single "
"expression)."
msgstr ""
"Una declaración de tipo expresión evalúa la lista de expresiones (que puede "
"ser una única expresión)."
#: ../Doc/reference/simple_stmts.rst:65
msgid ""
"In interactive mode, if the value is not ``None``, it is converted to a "
"string using the built-in :func:`repr` function and the resulting string is "
"written to standard output on a line by itself (except if the result is "
"``None``, so that procedure calls do not cause any output.)"
msgstr ""
"En modo interactivo, si el valor no es ``None``, es convertido a cadena de "
"caracteres usando la función built-in :func:`repr` y la cadena resultante es "
"escrita en la salida estándar en una línea por si sola (excepto si el "
"resultado es ``None``, entonces el procedimiento llamado no produce ninguna "
"salida.)"
#: ../Doc/reference/simple_stmts.rst:73
msgid "Assignment statements"
msgstr "Declaraciones de asignación"
#: ../Doc/reference/simple_stmts.rst:83
msgid ""
"Assignment statements are used to (re)bind names to values and to modify "
"attributes or items of mutable objects:"
msgstr ""
"Las declaraciones de asignación son usadas para (volver a) unir nombres a "
"valores y para modificar atributos o elementos de objetos mutables:"
#: ../Doc/reference/simple_stmts.rst:97
msgid ""
"(See section :ref:`primaries` for the syntax definitions for *attributeref*, "
"*subscription*, and *slicing*.)"
msgstr ""
"(Ver sección :ref:`primaries` para las definiciones de sintaxis para "
"*attributeref*, *subscription*, y *slicing*.)"
#: ../Doc/reference/simple_stmts.rst:100
msgid ""
"An assignment statement evaluates the expression list (remember that this "
"can be a single expression or a comma-separated list, the latter yielding a "
"tuple) and assigns the single resulting object to each of the target lists, "
"from left to right."
msgstr ""
"Una declaración de asignación evalúa la lista de expresiones (recuerda que "
"ésta puede ser una única expresión o una lista separada por comas, la última "
"produce una tupla) y asigna el único objeto resultante a cada una de las "
"listas de objetivos, de izquierda a derecha."
#: ../Doc/reference/simple_stmts.rst:109
msgid ""
"Assignment is defined recursively depending on the form of the target "
"(list). When a target is part of a mutable object (an attribute reference, "
"subscription or slicing), the mutable object must ultimately perform the "
"assignment and decide about its validity, and may raise an exception if the "
"assignment is unacceptable. The rules observed by various types and the "
"exceptions raised are given with the definition of the object types (see "
"section :ref:`types`)."
msgstr ""
"Las asignaciones son definidas recursivamente dependiendo de la forma del "
"objetivo (lista). Cuando el objetivo es parte de un objeto mutable (una "
"referencia a un atributo, una subscripción o un segmento), el objeto mutable "
"finalmente debe realizar la asignación y decidir sobre su validez, y puede "
"lanzar una excepción si la asignación no es aceptable. Las reglas observadas "
"por varios tipos y las excepciones lanzadas se dan con la definición de los "
"tipos de objeto (ver sección :ref:`types`)."
#: ../Doc/reference/simple_stmts.rst:122
msgid ""
"Assignment of an object to a target list, optionally enclosed in parentheses "
"or square brackets, is recursively defined as follows."
msgstr ""
"La asignación de un objeto a una lista de destino, opcionalmente entre "
"paréntesis o corchetes, se define de forma recursiva de la siguiente manera."
#: ../Doc/reference/simple_stmts.rst:125
msgid ""
"If the target list is a single target with no trailing comma, optionally in "
"parentheses, the object is assigned to that target."
msgstr ""
"Si la lista de destino es un único objeto sin terminar en coma, "
"opcionalmente entre paréntesis, el objeto es asignado a ese objetivo."
#: ../Doc/reference/simple_stmts.rst:128
msgid "Else:"
msgstr "Sino:"
#: ../Doc/reference/simple_stmts.rst:130
msgid ""
"If the target list contains one target prefixed with an asterisk, called a "
"\"starred\" target: The object must be an iterable with at least as many "
"items as there are targets in the target list, minus one. The first items "
"of the iterable are assigned, from left to right, to the targets before the "
"starred target. The final items of the iterable are assigned to the targets "
"after the starred target. A list of the remaining items in the iterable is "
"then assigned to the starred target (the list can be empty)."
msgstr ""
"Si la lista de objetivos contiene un objetivo prefijado con un asterisco, "
"llamado objetivo “destacado”: El objeto debe ser iterable con al menos "
"tantos elementos como objetivos en la lista de objetivos, menos uno. Los "
"primeros elementos del iterable se asignan, de izquierda a derecha, a los "
"objetivos antes del objetivo destacado. Los elementos finales del iterable "
"se asignan a los objetivos después del objetivo destacado. Luego se asigna "
"una lista de los elementos restantes en el iterable al objetivo destacado "
"(la lista puede estar vacía)."
#: ../Doc/reference/simple_stmts.rst:138
msgid ""
"Else: The object must be an iterable with the same number of items as there "
"are targets in the target list, and the items are assigned, from left to "
"right, to the corresponding targets."
msgstr ""
"Sino: el objeto debe ser iterable con el mismo número de elementos que los "
"elementos en la lista de objetivos, y los elementos son asignados a sus "
"respectivos objetivos de izquierda a derecha."
#: ../Doc/reference/simple_stmts.rst:142
msgid ""
"Assignment of an object to a single target is recursively defined as follows."
msgstr ""
"La asignación de un objeto a un único objetivo se define a continuación de "
"manera recursiva."
#: ../Doc/reference/simple_stmts.rst:144
msgid "If the target is an identifier (name):"
msgstr "Si el objetivo es un identificador (nombre):"
#: ../Doc/reference/simple_stmts.rst:146
msgid ""
"If the name does not occur in a :keyword:`global` or :keyword:`nonlocal` "
"statement in the current code block: the name is bound to the object in the "
"current local namespace."
msgstr ""
"Si el nombre no ocurre en una declaración :keyword:`global` o :keyword:"
"`nonlocal` en el actual bloque de código: el nombre es unido al objeto del "
"actual espacio de nombres local."
#: ../Doc/reference/simple_stmts.rst:150
msgid ""
"Otherwise: the name is bound to the object in the global namespace or the "
"outer namespace determined by :keyword:`nonlocal`, respectively."
msgstr ""
"Por otra parte: el nombre es unido al objeto en el nombre de espacio global "
"o el nombre de espacio exterior determinado por :keyword:`nonlocal`, "
"respectivamente."
#: ../Doc/reference/simple_stmts.rst:155
msgid ""
"The name is rebound if it was already bound. This may cause the reference "
"count for the object previously bound to the name to reach zero, causing the "
"object to be deallocated and its destructor (if it has one) to be called."
msgstr ""
"El nombre se vuelve a unir si ya ha estado unido. Esto puede hacer que el "
"recuento de referencia para el objeto previamente vinculado al nombre llegue "
"a cero, provocando que el objeto se desasigne y se llame a su destructor (si "
"tiene uno)."
#: ../Doc/reference/simple_stmts.rst:161
msgid ""
"If the target is an attribute reference: The primary expression in the "
"reference is evaluated. It should yield an object with assignable "
"attributes; if this is not the case, :exc:`TypeError` is raised. That "
"object is then asked to assign the assigned object to the given attribute; "
"if it cannot perform the assignment, it raises an exception (usually but not "
"necessarily :exc:`AttributeError`)."
msgstr ""
"Si el destino es una referencia de atributo: se evalúa la expresión primaria "
"en la referencia. Debe producir un objeto con atributos asignables; si este "
"no es el caso, una excepción :exc:`TypeError` es lanzada. Luego se le pide "
"a ese objeto que asigne el objeto asignado al atributo dado; si no puede "
"realizar la tarea, lanza una excepción (generalmente pero no necesariamente :"
"exc:`AttributeError`)."
#: ../Doc/reference/simple_stmts.rst:170
msgid ""
"Note: If the object is a class instance and the attribute reference occurs "
"on both sides of the assignment operator, the right-hand side expression, "
"``a.x`` can access either an instance attribute or (if no instance attribute "
"exists) a class attribute. The left-hand side target ``a.x`` is always set "
"as an instance attribute, creating it if necessary. Thus, the two "
"occurrences of ``a.x`` do not necessarily refer to the same attribute: if "
"the right-hand side expression refers to a class attribute, the left-hand "
"side creates a new instance attribute as the target of the assignment::"
msgstr ""
"Nota: Si el objeto es una instancia de clase y la referencia de atributo "
"ocurre en ambos lados del operador de asignación, la expresión del lado "
"derecho, ``a.x`` puede acceder a un atributo de instancia o (si no existe un "
"atributo de instancia) a una clase atributo. El objetivo del lado izquierdo "
"``a.x`` siempre se establece como un atributo de instancia, creándolo si es "
"necesario. Por lo tanto, las dos ocurrencias de ``a.x`` no necesariamente se "
"refieren al mismo atributo: si la expresión del lado derecho se refiere a un "
"atributo de clase, el lado izquierdo crea un nuevo atributo de instancia "
"como el objetivo de la asignación::"
#: ../Doc/reference/simple_stmts.rst:179
msgid ""
"class Cls:\n"
" x = 3 # class variable\n"
"inst = Cls()\n"
"inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:184
msgid ""
"This description does not necessarily apply to descriptor attributes, such "
"as properties created with :func:`property`."
msgstr ""
"Esta descripción no se aplica necesariamente a los atributos del descriptor, "
"como las propiedades creadas con :func:`property`."
#: ../Doc/reference/simple_stmts.rst:191
msgid ""
"If the target is a subscription: The primary expression in the reference is "
"evaluated. It should yield either a mutable sequence object (such as a "
"list) or a mapping object (such as a dictionary). Next, the subscript "
"expression is evaluated."
msgstr ""
"Si el objetivo es una suscripción: se evalúa la expresión primaria en la "
"referencia. Debe producir un objeto de secuencia mutable (como una lista) o "
"un objeto de mapeo (como un diccionario). A continuación, se evalúa la "
"expresión del subíndice."
#: ../Doc/reference/simple_stmts.rst:200
msgid ""
"If the primary is a mutable sequence object (such as a list), the subscript "
"must yield an integer. If it is negative, the sequence's length is added to "
"it. The resulting value must be a nonnegative integer less than the "
"sequence's length, and the sequence is asked to assign the assigned object "
"to its item with that index. If the index is out of range, :exc:"
"`IndexError` is raised (assignment to a subscripted sequence cannot add new "
"items to a list)."
msgstr ""
"Si el primario es un objeto de secuencia mutable (como una lista), el "
"subíndice debe producir un número entero. Si es negativo, se le suma la "
"longitud de la secuencia. El valor resultante debe ser un número entero no "
"negativo menor que la longitud de la secuencia, y se le pide a la secuencia "
"que asigne el objeto asignado a su elemento con ese índice. Si el índice "
"está fuera de rango, :exc:`IndexError` se lanza (la asignación a una "
"secuencia suscrita no puede agregar nuevos elementos a una lista)."
#: ../Doc/reference/simple_stmts.rst:211
#, fuzzy
msgid ""
"If the primary is a mapping object (such as a dictionary), the subscript "
"must have a type compatible with the mapping's key type, and the mapping is "
"then asked to create a key/value pair which maps the subscript to the "
"assigned object. This can either replace an existing key/value pair with "
"the same key value, or insert a new key/value pair (if no key with the same "
"value existed)."
msgstr ""
"Si el principal es un objeto de mapeo (como un diccionario), el subíndice "
"debe tener un tipo compatible con el tipo de clave del mapeo, y luego se le "
"pide al mapeo que cree un par clave / dato que mapee el subíndice al objeto "
"asignado. Esto puede reemplazar un par clave / valor existente con el mismo "
"valor clave o insertar un nuevo par clave / valor (si no existía ninguna "
"clave con el mismo valor)."
#: ../Doc/reference/simple_stmts.rst:217
#, fuzzy
msgid ""
"For user-defined objects, the :meth:`~object.__setitem__` method is called "
"with appropriate arguments."
msgstr ""
"Para objetos definidos por el usuario, se llama al método :meth:"
"`__setitem__` con los argumentos apropiados."
#: ../Doc/reference/simple_stmts.rst:222
msgid ""
"If the target is a slicing: The primary expression in the reference is "
"evaluated. It should yield a mutable sequence object (such as a list). The "
"assigned object should be a sequence object of the same type. Next, the "
"lower and upper bound expressions are evaluated, insofar they are present; "
"defaults are zero and the sequence's length. The bounds should evaluate to "
"integers. If either bound is negative, the sequence's length is added to "
"it. The resulting bounds are clipped to lie between zero and the sequence's "
"length, inclusive. Finally, the sequence object is asked to replace the "
"slice with the items of the assigned sequence. The length of the slice may "
"be different from the length of the assigned sequence, thus changing the "
"length of the target sequence, if the target sequence allows it."
msgstr ""
"Si el destino es un rebanado (*slicing*): la expresión principal de la "
"referencia es evaluada. Debería producir un objeto de secuencia mutable "
"(como una lista). El objeto asignado debe ser un objeto de secuencia del "
"mismo tipo. A continuación, se evalúan las expresiones de límite superior e "
"inferior, en la medida en que estén presentes; los valores predeterminados "
"son cero y la longitud de la secuencia. Los límites deben evaluarse a "
"números enteros. Si alguno de los límites es negativo, se le suma la "
"longitud de la secuencia. Los límites resultantes se recortan para que se "
"encuentren entre cero y la longitud de la secuencia, inclusive. Finalmente, "
"se solicita al objeto de secuencia que reemplace el segmento con los "
"elementos de la secuencia asignada. La longitud del corte puede ser "
"diferente de la longitud de la secuencia asignada, cambiando así la longitud "
"de la secuencia objetivo, si la secuencia objetivo lo permite."
#: ../Doc/reference/simple_stmts.rst:236
msgid ""
"In the current implementation, the syntax for targets is taken to be the "
"same as for expressions, and invalid syntax is rejected during the code "
"generation phase, causing less detailed error messages."
msgstr ""
"En la implementación actual, se considera que la sintaxis de los objetivos "
"es la misma que la de las expresiones y se rechaza la sintaxis no válida "
"durante la fase de generación del código, lo que genera mensajes de error "
"menos detallados."
#: ../Doc/reference/simple_stmts.rst:240
msgid ""
"Although the definition of assignment implies that overlaps between the left-"
"hand side and the right-hand side are 'simultaneous' (for example ``a, b = "
"b, a`` swaps two variables), overlaps *within* the collection of assigned-to "
"variables occur left-to-right, sometimes resulting in confusion. For "
"instance, the following program prints ``[0, 2]``::"
msgstr ""
"Aunque la definición de asignación implica que las superposiciones entre el "
"lado izquierdo y el lado derecho son ‘simultáneas’ (por ejemplo, ``a, b = b, "
"a`` intercambia dos variables), las superposiciones *dentro* de la colección "
"de las variables asignadas ocurren de izquierda a derecha, lo que a veces "
"genera confusión. Por ejemplo, el siguiente programa imprime ``[0, 2]``::"
#: ../Doc/reference/simple_stmts.rst:246
msgid ""
"x = [0, 1]\n"
"i = 0\n"
"i, x[i] = 1, 2 # i is updated, then x[i] is updated\n"
"print(x)"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:254
msgid ":pep:`3132` - Extended Iterable Unpacking"
msgstr ":pep:`3132` - Desembalaje Iterable Extendido"
#: ../Doc/reference/simple_stmts.rst:255
msgid "The specification for the ``*target`` feature."
msgstr "La especificación para la función ``*target``."
#: ../Doc/reference/simple_stmts.rst:261
msgid "Augmented assignment statements"
msgstr "Declaraciones de asignación aumentada"
#: ../Doc/reference/simple_stmts.rst:279
msgid ""
"Augmented assignment is the combination, in a single statement, of a binary "
"operation and an assignment statement:"
msgstr ""
"La asignación aumentada es la combinación, en una sola declaración, de una "
"operación binaria y una declaración de asignación:"
#: ../Doc/reference/simple_stmts.rst:288
msgid ""
"(See section :ref:`primaries` for the syntax definitions of the last three "
"symbols.)"
msgstr ""
"(Ver sección :ref:`primaries` para la definición de la sintaxis de los tres "
"últimos símbolos.)"
#: ../Doc/reference/simple_stmts.rst:291
msgid ""
"An augmented assignment evaluates the target (which, unlike normal "
"assignment statements, cannot be an unpacking) and the expression list, "
"performs the binary operation specific to the type of assignment on the two "
"operands, and assigns the result to the original target. The target is only "
"evaluated once."
msgstr ""
"Una asignación aumentada evalúa el destino (que, a diferencia de las "
"declaraciones de asignación normales, no puede ser un desempaquetado) y la "
"lista de expresiones, realiza la operación binaria específica del tipo de "
"asignación en los dos operandos y asigna el resultado al destino original. "
"El objetivo sólo se evalúa una vez."
#: ../Doc/reference/simple_stmts.rst:296
#, fuzzy
msgid ""
"An augmented assignment statement like ``x += 1`` can be rewritten as ``x = "
"x + 1`` to achieve a similar, but not exactly equal effect. In the augmented "
"version, ``x`` is only evaluated once. Also, when possible, the actual "
"operation is performed *in-place*, meaning that rather than creating a new "
"object and assigning that to the target, the old object is modified instead."
msgstr ""
"Una declaración de asignación aumentada como ``x += 1`` puede ser reescriba "
"como ``x = x + 1`` para alcanzar un efecto similar pero no exactamente "
"igual. En la versión aumentada, ``x`` es evaluada una única vez. Además, "
"cuando es posible, la operación real se realiza *in-place*, lo que significa "
"que en lugar de crear un nuevo objeto y asignarlo al objetivo, el objeto "
"anterior se modifica."
#: ../Doc/reference/simple_stmts.rst:302
msgid ""
"Unlike normal assignments, augmented assignments evaluate the left-hand side "
"*before* evaluating the right-hand side. For example, ``a[i] += f(x)`` "
"first looks-up ``a[i]``, then it evaluates ``f(x)`` and performs the "
"addition, and lastly, it writes the result back to ``a[i]``."
msgstr ""
"A diferencia de las asignaciones normales, las asignaciones aumentadas "
"evalúan el lado izquierdo *antes* de evaluar el lado derecho. Por ejemplo, "
"``a[i] += f(x)`` primero busca ``a[i]``, entonces evalúa ``f(x)`` y realiza "
"la suma, y finalmente, vuelve a escribir el resultado en ``a[i]``."
#: ../Doc/reference/simple_stmts.rst:307
msgid ""
"With the exception of assigning to tuples and multiple targets in a single "
"statement, the assignment done by augmented assignment statements is handled "
"the same way as normal assignments. Similarly, with the exception of the "
"possible *in-place* behavior, the binary operation performed by augmented "
"assignment is the same as the normal binary operations."
msgstr ""
"Con la excepción de la asignación a tuplas y múltiples objetivos en una sola "
"instrucción, la asignación realizada por las instrucciones de asignación "
"aumentada se maneja de la misma manera que las asignaciones normales. De "
"manera similar, con la excepción del posible comportamiento *in situ*, la "
"operación binaria realizada por la asignación aumentada es la misma que las "
"operaciones binarias normales."
#: ../Doc/reference/simple_stmts.rst:313
msgid ""
"For targets which are attribute references, the same :ref:`caveat about "
"class and instance attributes <attr-target-note>` applies as for regular "
"assignments."
msgstr ""
"Para destinos que son referencias a atributos, lo mismo que :ref:`caveat "
"about class and instance attributes <attr-target-note>` se aplica para "
"asignaciones regulares."
#: ../Doc/reference/simple_stmts.rst:320
msgid "Annotated assignment statements"
msgstr "Declaraciones de asignación anotadas"
#: ../Doc/reference/simple_stmts.rst:327
msgid ""
":term:`Annotation <variable annotation>` assignment is the combination, in a "
"single statement, of a variable or attribute annotation and an optional "
"assignment statement:"
msgstr ""
"Asignación :term:`Annotation <variable annotation>` es la combinación, en "
"una única declaración, de una variable o anotación de atributo y una "
"declaración de asignación opcional:"
#: ../Doc/reference/simple_stmts.rst:334
#, fuzzy
msgid ""
"The difference from normal :ref:`assignment` is that only a single target is "
"allowed."
msgstr ""
"La diferencia respecto a :ref:`assignment` normal es que sólo se permite un "
"único objetivo."
#: ../Doc/reference/simple_stmts.rst:336
#, fuzzy
msgid ""
"The assignment target is considered \"simple\" if it consists of a single "
"name that is not enclosed in parentheses. For simple assignment targets, if "
"in class or module scope, the annotations are gathered in a lazily "
"evaluated :ref:`annotation scope <annotation-scopes>`. The annotations can "
"be evaluated using the :attr:`~object.__annotations__` attribute of a class "
"or module, or using the facilities in the :mod:`annotationlib` module."
msgstr ""
"Para nombres simples como destinos de asignación, si están en el ámbito de "
"clase o módulo, las anotaciones se evalúan y almacenan en una clase especial "
"o atributo de módulo :attr:`__annotations__` que es una asignación de "
"diccionario de nombres de variables (alterados si son privados) a "
"anotaciones evaluadas. Este atributo se puede escribir y se crea "
"automáticamente al comienzo de la ejecución del cuerpo del módulo o la "
"clase, si las anotaciones se encuentran estáticamente."
#: ../Doc/reference/simple_stmts.rst:345
#, fuzzy
msgid ""
"If the assignment target is not simple (an attribute, subscript node, or "
"parenthesized name), the annotation is never evaluated."
msgstr ""
"Para expresiones como destinos de asignaciones, las anotaciones se evalúan "
"si están en ámbitos de clase o módulo pero no se almacenan."
#: ../Doc/reference/simple_stmts.rst:348
msgid ""
"If a name is annotated in a function scope, then this name is local for that "
"scope. Annotations are never evaluated and stored in function scopes."
msgstr ""
"Si se anota un nombre en el ámbito de una función, este nombre es local para "
"ese ámbito. Las anotaciones nunca se evalúan y almacenan en ámbitos de "
"función."
#: ../Doc/reference/simple_stmts.rst:351
#, fuzzy
msgid ""
"If the right hand side is present, an annotated assignment performs the "
"actual assignment as if there was no annotation present. If the right hand "
"side is not present for an expression target, then the interpreter evaluates "
"the target except for the last :meth:`~object.__setitem__` or :meth:`~object."
"__setattr__` call."
msgstr ""
"Si el lado derecho está presente, una tarea anotada realiza la tarea real "
"antes de evaluar las anotaciones (cuando corresponda). Si el lado derecho no "
"está presente para un destino de expresión, entonces el intérprete evalúa el "
"destino excepto por la última llamada :meth:`__setitem__` o :meth:"
"`__setattr__`."
#: ../Doc/reference/simple_stmts.rst:359
msgid ":pep:`526` - Syntax for Variable Annotations"
msgstr ":pep:`526` - Sintaxis para anotaciones de variable"
#: ../Doc/reference/simple_stmts.rst:360
msgid ""
"The proposal that added syntax for annotating the types of variables "
"(including class variables and instance variables), instead of expressing "
"them through comments."
msgstr ""
"La propuesta que agregó sintaxis para anotar los tipos de variables "
"(incluidas variables de clase y variables de instancia), en lugar de "
"expresarlas a través de comentarios."
#: ../Doc/reference/simple_stmts.rst:364
msgid ":pep:`484` - Type hints"
msgstr ":pep:`484` - Indicadores de tipo"
#: ../Doc/reference/simple_stmts.rst:365
msgid ""
"The proposal that added the :mod:`typing` module to provide a standard "
"syntax for type annotations that can be used in static analysis tools and "
"IDEs."
msgstr ""
"La propuesta que agregó el módulo :mod:`typing` para proporcionar una "
"sintaxis estándar para las anotaciones de tipo para ser utilizadas en "
"herramientas de análisis estático e IDEs."
#: ../Doc/reference/simple_stmts.rst:369
#, fuzzy
msgid ""
"Now annotated assignments allow the same expressions in the right hand side "
"as regular assignments. Previously, some expressions (like un-parenthesized "
"tuple expressions) caused a syntax error."
msgstr ""
"Ahora, las asignaciones anotadas permiten las mismas expresiones en el lado "
"derecho que las asignaciones regulares. Anteriormente, algunas expresiones "
"(como las expresiones de tupla sin paréntesis) provocaban un error de "
"sintaxis."
#: ../Doc/reference/simple_stmts.rst:374
msgid ""
"Annotations are now lazily evaluated in a separate :ref:`annotation scope "
"<annotation-scopes>`. If the assignment target is not simple, annotations "
"are never evaluated."
msgstr ""
#: ../Doc/reference/simple_stmts.rst:382
msgid "The :keyword:`!assert` statement"
msgstr "La declaración :keyword:`!assert`"
#: ../Doc/reference/simple_stmts.rst:389
msgid ""
"Assert statements are a convenient way to insert debugging assertions into a "
"program:"
msgstr ""
"Las declaraciones de afirmación son una forma conveniente de insertar "
"afirmaciones de depuración en un programa:"
#: ../Doc/reference/simple_stmts.rst:395
msgid "The simple form, ``assert expression``, is equivalent to ::"
msgstr "La forma simple, ``assert expressionn``, es equivalente a ::"
#: ../Doc/reference/simple_stmts.rst:397
msgid ""
"if __debug__:\n"
" if not expression: raise AssertionError"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:400
msgid ""
"The extended form, ``assert expression1, expression2``, is equivalent to ::"
msgstr ""
"La forma extendida, ``assert expression1, expression2``, es equivalente a ::"
#: ../Doc/reference/simple_stmts.rst:402
msgid ""
"if __debug__:\n"
" if not expression1: raise AssertionError(expression2)"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:409
#, fuzzy
msgid ""
"These equivalences assume that :const:`__debug__` and :exc:`AssertionError` "
"refer to the built-in variables with those names. In the current "
"implementation, the built-in variable ``__debug__`` is ``True`` under normal "
"circumstances, ``False`` when optimization is requested (command line "
"option :option:`-O`). The current code generator emits no code for an :"
"keyword:`assert` statement when optimization is requested at compile time. "
"Note that it is unnecessary to include the source code for the expression "
"that failed in the error message; it will be displayed as part of the stack "
"trace."
msgstr ""
"Estas equivalencias asumen que :const:`__debug__` y :exc:`AssertionError` se "
"refieren a las variables integradas con esos nombres. En la implementación "
"actual, la variable incorporada :const:`__debug__` es ``True`` en "
"circunstancias normales, ``False`` cuando se solicita la optimización "
"(opción de línea de comando :option:`-O`). El generador de código actual no "
"emite código para una declaración de aserción cuando se solicita la "
"optimización en tiempo de compilación. Tenga en cuenta que no es necesario "
"incluir el código fuente de la expresión que falló en el mensaje de error; "
"se mostrará como parte del seguimiento de la pila."
#: ../Doc/reference/simple_stmts.rst:418
msgid ""
"Assignments to :const:`__debug__` are illegal. The value for the built-in "
"variable is determined when the interpreter starts."
msgstr ""
"Asignaciones a :const:`__debug__` son ilegales. El valor para la variable "
"se determina cuando arranca el intérprete."
#: ../Doc/reference/simple_stmts.rst:425
msgid "The :keyword:`!pass` statement"
msgstr "La declaración :keyword:`!pass`"
#: ../Doc/reference/simple_stmts.rst:435
msgid ""
":keyword:`pass` is a null operation --- when it is executed, nothing "
"happens. It is useful as a placeholder when a statement is required "
"syntactically, but no code needs to be executed, for example::"
msgstr ""
":keyword:`pass` es una operación nula --- cuando se ejecuta, no sucede nada. "
"Es útil como marcador de posición cuando se requiere una declaración "
"sintácticamente, pero no es necesario ejecutar código, por ejemplo::"
#: ../Doc/reference/simple_stmts.rst:439
msgid ""
"def f(arg): pass # a function that does nothing (yet)\n"
"\n"
"class C: pass # a class with no methods (yet)"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:447
msgid "The :keyword:`!del` statement"
msgstr "La declaración :keyword:`!del`"
#: ../Doc/reference/simple_stmts.rst:457
msgid ""
"Deletion is recursively defined very similar to the way assignment is "
"defined. Rather than spelling it out in full details, here are some hints."
msgstr ""
"La eliminación se define de forma recursiva de manera muy similar a la forma "
"en que se define la asignación. En lugar de explicarlo con todos los "
"detalles, aquí hay algunas sugerencias."
#: ../Doc/reference/simple_stmts.rst:460
msgid ""
"Deletion of a target list recursively deletes each target, from left to "
"right."
msgstr ""
"La eliminación de una lista de objetivos elimina cada objetivo de forma "
"recursiva, de izquierda a derecha."
#: ../Doc/reference/simple_stmts.rst:466
#, fuzzy
msgid ""
"Deletion of a name removes the binding of that name from the local or global "
"namespace, depending on whether the name occurs in a :keyword:`global` "
"statement in the same code block. Trying to delete an unbound name raises "
"a :exc:`NameError` exception."
msgstr ""
"La eliminación de un nombre elimina la vinculación de ese nombre del espacio "
"de nombres local o global, dependiendo de si el nombre aparece en una "
"declaración :keyword:`global` en el mismo bloque de código. Si el nombre no "
"está vinculado, se lanzará una excepción :exc:`NameError`."
#: ../Doc/reference/simple_stmts.rst:473
msgid ""
"Deletion of attribute references, subscriptions and slicings is passed to "
"the primary object involved; deletion of a slicing is in general equivalent "
"to assignment of an empty slice of the right type (but even this is "
"determined by the sliced object)."
msgstr ""
"La supresión de referencias de atributo, suscripciones y rebanadas se pasa "
"al objeto primario involucrado; la eliminación de una rebanada es en general "
"equivalente a la asignación de una rebanada vacía del tipo correcto (pero "
"incluso esto está determinado por el objeto rebanado)."
#: ../Doc/reference/simple_stmts.rst:478
msgid ""
"Previously it was illegal to delete a name from the local namespace if it "
"occurs as a free variable in a nested block."
msgstr ""
"Anteriormente era ilegal eliminar un nombre del espacio de nombres local si "
"aparece como una variable libre en un bloque anidado."
#: ../Doc/reference/simple_stmts.rst:486
msgid "The :keyword:`!return` statement"
msgstr "La declaración :keyword:`!return`"
#: ../Doc/reference/simple_stmts.rst:496
msgid ""
":keyword:`return` may only occur syntactically nested in a function "
"definition, not within a nested class definition."
msgstr ""
"El :keyword:`return` sólo puede ocurrir sintácticamente anidado en una "
"definición de función, no dentro de una definición de clase anidada."
#: ../Doc/reference/simple_stmts.rst:499
msgid ""
"If an expression list is present, it is evaluated, else ``None`` is "
"substituted."
msgstr ""
"Si una lista de expresiones es presente, ésta es evaluada, sino es "
"substituida por ``None`` ."
#: ../Doc/reference/simple_stmts.rst:501
msgid ""
":keyword:`return` leaves the current function call with the expression list "
"(or ``None``) as return value."
msgstr ""
":keyword:`return` deja la llamada a la función actual con la lista de "
"expresiones (o ``None``) como valor de retorno."
#: ../Doc/reference/simple_stmts.rst:506
msgid ""
"When :keyword:`return` passes control out of a :keyword:`try` statement with "
"a :keyword:`finally` clause, that :keyword:`!finally` clause is executed "
"before really leaving the function."
msgstr ""
"Cuando :keyword:`return` pasa el control de una sentencia :keyword:`try` con "
"una cláusula :keyword:`finally`, esa cláusula :keyword:`!finally` se ejecuta "
"antes de dejar realmente la función."
#: ../Doc/reference/simple_stmts.rst:510
msgid ""
"In a generator function, the :keyword:`return` statement indicates that the "
"generator is done and will cause :exc:`StopIteration` to be raised. The "
"returned value (if any) is used as an argument to construct :exc:"
"`StopIteration` and becomes the :attr:`StopIteration.value` attribute."
msgstr ""
"En una función generadora, la declaración :keyword:`return` indica que el "
"generador ha acabado y hará que :exc:`StopIteration` se lance. El valor "
"retornado (si lo hay) se utiliza como argumento para construir :exc:"
"`StopIteration` y se convierte en el atributo :attr:`StopIteration.value`."
#: ../Doc/reference/simple_stmts.rst:515
msgid ""
"In an asynchronous generator function, an empty :keyword:`return` statement "
"indicates that the asynchronous generator is done and will cause :exc:"
"`StopAsyncIteration` to be raised. A non-empty :keyword:`!return` statement "
"is a syntax error in an asynchronous generator function."
msgstr ""
"En una función de generador asíncrono, una declaración :keyword:`return` "
"vacía indica que el generador asíncrono ha acabado y va a lanzar un :exc:"
"`StopAsyncIteration`. Una declaración :keyword:`!return` no vacía es un "
"error de sintaxis en una función generadora asíncrona."
#: ../Doc/reference/simple_stmts.rst:523
msgid "The :keyword:`!yield` statement"
msgstr "La declaración :keyword:`!yield`"
#: ../Doc/reference/simple_stmts.rst:535
#, fuzzy
msgid ""
"A :keyword:`yield` statement is semantically equivalent to a :ref:`yield "
"expression <yieldexpr>`. The ``yield`` statement can be used to omit the "
"parentheses that would otherwise be required in the equivalent yield "
"expression statement. For example, the yield statements ::"
msgstr ""
"La declaración :keyword:`yield` es semánticamente equivalente a :ref:`yield "
"expression <yieldexpr>`. Una declaración de producción se puede utilizar "
"para omitir los paréntesis que de otro modo serían necesarios en la "
"declaración de expresión de producción equivalente. Por ejemplo, las "
"declaraciones de producción ::"
#: ../Doc/reference/simple_stmts.rst:540
msgid ""
"yield <expr>\n"
"yield from <expr>"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:543
msgid "are equivalent to the yield expression statements ::"
msgstr "son equivalentes a las funciones que producen declaraciones ::"
#: ../Doc/reference/simple_stmts.rst:545
msgid ""
"(yield <expr>)\n"
"(yield from <expr>)"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:548
#, fuzzy
msgid ""
"Yield expressions and statements are only used when defining a :term:"
"`generator` function, and are only used in the body of the generator "
"function. Using :keyword:`yield` in a function definition is sufficient to "
"cause that definition to create a generator function instead of a normal "
"function."
msgstr ""
"Expresiones y declaraciones productoras se usan únicamente para definir una "
"función :term:`generator`, y son utilizadas únicamente en el cuerpo de una "
"función generadora. Usar producción en una definición de función es "
"suficiente para hacer que esa definición cree una función generadora en "
"lugar de una función normal."
#: ../Doc/reference/simple_stmts.rst:553
msgid ""
"For full details of :keyword:`yield` semantics, refer to the :ref:"
"`yieldexpr` section."
msgstr ""
"Para todos los detalles de la semántica de :keyword:`yield`, referirse a la "
"sección :ref:`yieldexpr`."
#: ../Doc/reference/simple_stmts.rst:559
msgid "The :keyword:`!raise` statement"
msgstr "La declaración :keyword:`!raise`"
#: ../Doc/reference/simple_stmts.rst:570
msgid ""
"If no expressions are present, :keyword:`raise` re-raises the exception that "
"is currently being handled, which is also known as the *active exception*. "
"If there isn't currently an active exception, a :exc:`RuntimeError` "
"exception is raised indicating that this is an error."
msgstr ""
"Si no hay expresiones presentes, :keyword:`raise` vuelve a lanzar la "
"excepción que se está manejando actualmente, que también se conoce como "
"*excepción activa*. Si actualmente no hay una excepción activa, se lanza una "
"excepción :exc:`RuntimeError` que indica que se trata de un error."
#: ../Doc/reference/simple_stmts.rst:575
msgid ""
"Otherwise, :keyword:`raise` evaluates the first expression as the exception "
"object. It must be either a subclass or an instance of :class:"
"`BaseException`. If it is a class, the exception instance will be obtained "
"when needed by instantiating the class with no arguments."
msgstr ""
"De lo contrario, :keyword:`raise` evalúa la primera expresión como el objeto "
"de excepción. Debe ser una subclase o una instancia de :class:"
"`BaseException`. Si es una clase, la instancia de excepción se obtendrá "
"cuando sea necesario creando una instancia de la clase sin argumentos."
#: ../Doc/reference/simple_stmts.rst:580
msgid ""
"The :dfn:`type` of the exception is the exception instance's class, the :dfn:"
"`value` is the instance itself."
msgstr ""
"El :dfn:`type` de la excepción es la instancia de la clase excepción, el :"
"dfn:`value` es la propia instancia."
#: ../Doc/reference/simple_stmts.rst:585
#, fuzzy
msgid ""
"A traceback object is normally created automatically when an exception is "
"raised and attached to it as the :attr:`~BaseException.__traceback__` "
"attribute. You can create an exception and set your own traceback in one "
"step using the :meth:`~BaseException.with_traceback` exception method (which "
"returns the same exception instance, with its traceback set to its "
"argument), like so::"
msgstr ""
"Normalmente, un objeto de rastreo se crea automáticamente cuando se lanza "
"una excepción y se le adjunta como el atributo :attr:`__traceback__`, que se "
"puede escribir. Puede crear una excepción y configurar su propio rastreo en "
"un solo paso usando el método de excepción :meth:`~BaseException."
"with_traceback` (que retorna la misma instancia de excepción, con su rastreo "
"establecido en su argumento), así:"
#: ../Doc/reference/simple_stmts.rst:591
msgid "raise Exception(\"foo occurred\").with_traceback(tracebackobj)"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:597
#, fuzzy
msgid ""
"The ``from`` clause is used for exception chaining: if given, the second "
"*expression* must be another exception class or instance. If the second "
"expression is an exception instance, it will be attached to the raised "
"exception as the :attr:`~BaseException.__cause__` attribute (which is "
"writable). If the expression is an exception class, the class will be "
"instantiated and the resulting exception instance will be attached to the "
"raised exception as the :attr:`!__cause__` attribute. If the raised "
"exception is not handled, both exceptions will be printed:"
msgstr ""
"La cláusula ``from`` se utiliza para el encadenamiento de excepciones: si se "
"proporciona, el segundo *expression* debe ser otra clase o instancia de "
"excepción. Si la segunda expresión es una instancia de excepción, se "
"adjuntará a la excepción generada como el atributo :attr:`__cause__` (que se "
"puede escribir). Si la expresión es una clase de excepción, se creará una "
"instancia de la clase y la instancia de excepción resultante se adjuntará a "
"la excepción generada como el atributo :attr:`__cause__`. Si no se maneja la "
"excepción generada, se imprimirán ambas excepciones:"
#: ../Doc/reference/simple_stmts.rst:606
msgid ""
">>> try:\n"
"... print(1 / 0)\n"
"... except Exception as exc:\n"
"... raise RuntimeError(\"Something bad happened\") from exc\n"
"...\n"
"Traceback (most recent call last):\n"
" File \"<stdin>\", line 2, in <module>\n"
" print(1 / 0)\n"
" ~~^~~\n"
"ZeroDivisionError: division by zero\n"
"\n"
"The above exception was the direct cause of the following exception:\n"
"\n"
"Traceback (most recent call last):\n"
" File \"<stdin>\", line 4, in <module>\n"
" raise RuntimeError(\"Something bad happened\") from exc\n"
"RuntimeError: Something bad happened"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:626
#, fuzzy
msgid ""
"A similar mechanism works implicitly if a new exception is raised when an "
"exception is already being handled. An exception may be handled when an :"
"keyword:`except` or :keyword:`finally` clause, or a :keyword:`with` "
"statement, is used. The previous exception is then attached as the new "
"exception's :attr:`~BaseException.__context__` attribute:"
msgstr ""
"Un mecanismo similar funciona implícitamente si se genera una nueva "
"excepción cuando ya se está manejando una excepción. Se puede manejar una "
"excepción cuando se usa una cláusula :keyword:`except` o :keyword:`finally`, "
"o una declaración :keyword:`with`. La excepción anterior se adjunta como el "
"atributo :attr:`__context__` de la nueva excepción:"
#: ../Doc/reference/simple_stmts.rst:632
msgid ""
">>> try:\n"
"... print(1 / 0)\n"
"... except:\n"
"... raise RuntimeError(\"Something bad happened\")\n"
"...\n"
"Traceback (most recent call last):\n"
" File \"<stdin>\", line 2, in <module>\n"
" print(1 / 0)\n"
" ~~^~~\n"
"ZeroDivisionError: division by zero\n"
"\n"
"During handling of the above exception, another exception occurred:\n"
"\n"
"Traceback (most recent call last):\n"
" File \"<stdin>\", line 4, in <module>\n"
" raise RuntimeError(\"Something bad happened\")\n"
"RuntimeError: Something bad happened"
msgstr ""
#: ../Doc/reference/simple_stmts.rst:652
#, fuzzy
msgid ""