Repository navigation
Expand file tree
/
Copy pathcompound_stmts.po
More file actions
3152 lines (2731 loc) · 126 KB
/
Copy pathcompound_stmts.po
File metadata and controls
3152 lines (2731 loc) · 126 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: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2022-01-06 10:25-0300\n"
"Last-Translator: Carlos A. Crespo <lvccrespo@gmail.com>\n"
"Language: es_AR\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.13.0\n"
#: ../Doc/reference/compound_stmts.rst:5
msgid "Compound statements"
msgstr "Sentencias compuestas"
#: ../Doc/reference/compound_stmts.rst:9
msgid ""
"Compound statements contain (groups of) other statements; they affect or "
"control the execution of those other statements in some way. In general, "
"compound statements span multiple lines, although in simple incarnations a "
"whole compound statement may be contained in one line."
msgstr ""
"Las sentencias compuestas contienen (grupos de) otras sentencias; estas "
"afectan o controlan la ejecución de esas otras sentencias de alguna manera. "
"En general, las sentencias compuestas abarcan varias líneas, aunque en "
"representaciones simples una sentencia compuesta completa puede estar "
"contenida en una línea."
#: ../Doc/reference/compound_stmts.rst:14
msgid ""
"The :keyword:`if`, :keyword:`while` and :keyword:`for` statements implement "
"traditional control flow constructs. :keyword:`try` specifies exception "
"handlers and/or cleanup code for a group of statements, while the :keyword:"
"`with` statement allows the execution of initialization and finalization "
"code around a block of code. Function and class definitions are also "
"syntactically compound statements."
msgstr ""
"Las sentencias :keyword:`if`, :keyword:`while` y :keyword:`for` implementan "
"construcciones de control de flujo tradicionales. :keyword:`try` especifica "
"gestores de excepción o código de limpieza para un grupo de sentencias, "
"mientras que las sentencias :keyword:`with` permite la ejecución del código "
"de inicialización y finalización alrededor de un bloque de código. Las "
"definiciones de función y clase también son sentencias sintácticamente "
"compuestas."
#: ../Doc/reference/compound_stmts.rst:26
msgid ""
"A compound statement consists of one or more 'clauses.' A clause consists "
"of a header and a 'suite.' The clause headers of a particular compound "
"statement are all at the same indentation level. Each clause header begins "
"with a uniquely identifying keyword and ends with a colon. A suite is a "
"group of statements controlled by a clause. A suite can be one or more "
"semicolon-separated simple statements on the same line as the header, "
"following the header's colon, or it can be one or more indented statements "
"on subsequent lines. Only the latter form of a suite can contain nested "
"compound statements; the following is illegal, mostly because it wouldn't be "
"clear to which :keyword:`if` clause a following :keyword:`else` clause would "
"belong::"
msgstr ""
"Una sentencia compuesta consta de una o más 'cláusulas'. Una cláusula consta "
"de un encabezado y una 'suite'. Los encabezados de cláusula de una "
"declaración compuesta particular están todos en el mismo nivel de "
"indentación. Cada encabezado de cláusula comienza con una palabra clave de "
"identificación única y termina con dos puntos. Una suite es un grupo de "
"sentencias controladas por una cláusula. Una suite puede ser una o más "
"sentencias simples separadas por punto y coma en la misma línea como el "
"encabezado, siguiendo los dos puntos del encabezado, o puede ser una o puede "
"ser una o más declaraciones indentadas en líneas posteriores. Solo la última "
"forma de una suite puede contener sentencias compuestas anidadas; lo "
"siguiente es ilegal, principalmente porque no estaría claro a qué cláusula :"
"keyword:`if` seguido de la cláusula :keyword:`else` hace referencia::"
#: ../Doc/reference/compound_stmts.rst:39
msgid ""
"Also note that the semicolon binds tighter than the colon in this context, "
"so that in the following example, either all or none of the :func:`print` "
"calls are executed::"
msgstr ""
"También tenga en cuenta que el punto y coma se une más apretado que los dos "
"puntos en este contexto, de modo que en el siguiente ejemplo, todas o "
"ninguna de las llamadas :func:`print` se ejecutan::"
#: ../Doc/reference/compound_stmts.rst:45
msgid "Summarizing:"
msgstr "Resumiendo:"
#: ../Doc/reference/compound_stmts.rst:69
msgid ""
"Note that statements always end in a ``NEWLINE`` possibly followed by a "
"``DEDENT``. Also note that optional continuation clauses always begin with "
"a keyword that cannot start a statement, thus there are no ambiguities (the "
"'dangling :keyword:`else`' problem is solved in Python by requiring nested :"
"keyword:`if` statements to be indented)."
msgstr ""
"Tenga en cuenta que las sentencias siempre terminan en un ``NEWLINE`` "
"posiblemente seguida de ``DEDENT``. También tenga en cuenta que las "
"cláusulas de continuación opcionales siempre comienzan con una palabra clave "
"que no puede iniciar una sentencia, por lo tanto, no hay ambigüedades (el "
"problema de 'colgado :keyword:`if`' se resuelve en Python al requerir que "
"las sentencias anidadas :keyword:`if` deben estar indentadas)."
#: ../Doc/reference/compound_stmts.rst:75
msgid ""
"The formatting of the grammar rules in the following sections places each "
"clause on a separate line for clarity."
msgstr ""
"El formato de las reglas gramaticales en las siguientes secciones coloca "
"cada cláusula en una línea separada para mayor claridad."
#: ../Doc/reference/compound_stmts.rst:84
msgid "The :keyword:`!if` statement"
msgstr "La sentencia :keyword:`!if`"
#: ../Doc/reference/compound_stmts.rst:92
msgid "The :keyword:`if` statement is used for conditional execution:"
msgstr "La sentencia :keyword:`if` se usa para la ejecución condicional:"
#: ../Doc/reference/compound_stmts.rst:99
msgid ""
"It selects exactly one of the suites by evaluating the expressions one by "
"one until one is found to be true (see section :ref:`booleans` for the "
"definition of true and false); then that suite is executed (and no other "
"part of the :keyword:`if` statement is executed or evaluated). If all "
"expressions are false, the suite of the :keyword:`else` clause, if present, "
"is executed."
msgstr ""
"Selecciona exactamente una de las suites evaluando las expresiones una por "
"una hasta que se encuentre una verdadera (vea la sección :ref:`booleans` "
"para la definición de verdadero y falso); entonces esa suite se ejecuta (y "
"ninguna otra parte de la sentencia :keyword:`if` se ejecuta o evalúa). Si "
"todas las expresiones son falsas, se ejecuta la suite de cláusulas :keyword:"
"`else`, si está presente."
#: ../Doc/reference/compound_stmts.rst:109
msgid "The :keyword:`!while` statement"
msgstr "La sentencia :keyword:`!while`"
#: ../Doc/reference/compound_stmts.rst:117
msgid ""
"The :keyword:`while` statement is used for repeated execution as long as an "
"expression is true:"
msgstr ""
"La sentencia :keyword:`while` se usa para la ejecución repetida siempre que "
"una expresión sea verdadera:"
#: ../Doc/reference/compound_stmts.rst:124
msgid ""
"This repeatedly tests the expression and, if it is true, executes the first "
"suite; if the expression is false (which may be the first time it is tested) "
"the suite of the :keyword:`!else` clause, if present, is executed and the "
"loop terminates."
msgstr ""
"Esto prueba repetidamente la expresión y, si es verdadera, ejecuta la "
"primera suite; si la expresión es falsa (que puede ser la primera vez que se "
"prueba), se ejecuta el conjunto de cláusulas :keyword:`!else`, si está "
"presente, y el bucle termina."
#: ../Doc/reference/compound_stmts.rst:133
msgid ""
"A :keyword:`break` statement executed in the first suite terminates the loop "
"without executing the :keyword:`!else` clause's suite. A :keyword:"
"`continue` statement executed in the first suite skips the rest of the suite "
"and goes back to testing the expression."
msgstr ""
"La sentencia :keyword:`break` ejecutada en la primer suite termina el bucle "
"sin ejecutar la suite de cláusulas :keyword:`!else`. La sentencia :keyword:"
"`continue` ejecutada en la primera suite omite el resto de la suite y vuelve "
"a probar la expresión."
#: ../Doc/reference/compound_stmts.rst:142
msgid "The :keyword:`!for` statement"
msgstr "La sentencia :keyword:`!for`"
#: ../Doc/reference/compound_stmts.rst:153
msgid ""
"The :keyword:`for` statement is used to iterate over the elements of a "
"sequence (such as a string, tuple or list) or other iterable object:"
msgstr ""
"La sentencia :keyword:`for` se usa para iterar sobre los elementos de una "
"secuencia (como una cadena de caracteres, tupla o lista) u otro objeto "
"iterable:"
#: ../Doc/reference/compound_stmts.rst:160
msgid ""
"The ``starred_list`` expression is evaluated once; it should yield an :term:"
"`iterable` object. An :term:`iterator` is created for that iterable. The "
"first item provided by the iterator is then assigned to the target list "
"using the standard rules for assignments (see :ref:`assignment`), and the "
"suite is executed. This repeats for each item provided by the iterator. "
"When the iterator is exhausted, the suite in the :keyword:`!else` clause, if "
"present, is executed, and the loop terminates."
msgstr ""
"La expresión ``starred_list`` se evalúa una vez; debería producir un objeto :"
"term:`iterable`. Se crea un :term:`iterator` para ese iterable. A "
"continuación, el primer elemento proporcionado por el iterador se asigna a "
"la lista de destino utilizando las reglas estándar para las asignaciones "
"(consulte :ref:`assignment`) y se ejecuta la suite. Esto se repite para cada "
"elemento proporcionado por el iterador. Cuando se agota el iterador, se "
"ejecuta el conjunto de la cláusula :keyword:`!else`, si está presente, y el "
"ciclo termina."
#: ../Doc/reference/compound_stmts.rst:173
msgid ""
"A :keyword:`break` statement executed in the first suite terminates the loop "
"without executing the :keyword:`!else` clause's suite. A :keyword:"
"`continue` statement executed in the first suite skips the rest of the suite "
"and continues with the next item, or with the :keyword:`!else` clause if "
"there is no next item."
msgstr ""
"La sentencia :keyword:`break` ejecutada en la primera suite termina el bucle "
"sin ejecutar el conjunto de cláusulas :keyword:`!else`. La sentencia :"
"keyword:`continue` ejecutada en la primera suite omite el resto de las "
"cláusulas y continúa con el siguiente elemento, o con la cláusula :keyword:`!"
"else` si no hay un elemento siguiente."
#: ../Doc/reference/compound_stmts.rst:179
msgid ""
"The for-loop makes assignments to the variables in the target list. This "
"overwrites all previous assignments to those variables including those made "
"in the suite of the for-loop::"
msgstr ""
"El bucle ``for`` realiza asignaciones a las variables en la lista. Esto "
"sobrescribe todas las asignaciones anteriores a esas variables, incluidas "
"las realizadas en la suite del bucle ``for``::"
#: ../Doc/reference/compound_stmts.rst:193
#, fuzzy
msgid ""
"Names in the target list are not deleted when the loop is finished, but if "
"the sequence is empty, they will not have been assigned to at all by the "
"loop. Hint: the built-in type :func:`range` represents immutable arithmetic "
"sequences of integers. For instance, iterating ``range(3)`` successively "
"yields 0, 1, and then 2."
msgstr ""
"Los nombres en la lista no se eliminan cuando finaliza el bucle, pero si la "
"secuencia está vacía, el bucle no les habrá asignado nada. Sugerencia: la "
"función incorporada :func:`range` retorna un iterador de enteros adecuado "
"para emular el efecto de Pascal ``for i := a to b do``; por ejemplo, "
"``list(range(3))`` retorna la lista ``[0, 1, 2]``."
#: ../Doc/reference/compound_stmts.rst:198
msgid "Starred elements are now allowed in the expression list."
msgstr ""
"Los elementos destacados ahora están permitidos en la lista de expresiones."
#: ../Doc/reference/compound_stmts.rst:205
msgid "The :keyword:`!try` statement"
msgstr "La sentencia :keyword:`!try`"
#: ../Doc/reference/compound_stmts.rst:215
msgid ""
"The :keyword:`!try` statement specifies exception handlers and/or cleanup "
"code for a group of statements:"
msgstr ""
"La sentencia :keyword:`!try` especifica controladores de excepciones y/o "
"código de limpieza para un grupo de sentencias:"
#: ../Doc/reference/compound_stmts.rst:231
msgid ""
"Additional information on exceptions can be found in section :ref:"
"`exceptions`, and information on using the :keyword:`raise` statement to "
"generate exceptions may be found in section :ref:`raise`."
msgstr ""
"Se puede encontrar información adicional sobre las excepciones en la "
"sección :ref:`exceptions`, e información sobre el uso de la sentencia :"
"keyword:`raise`, para lanzar excepciones se puede encontrar en la sección :"
"ref:`raise`."
#: ../Doc/reference/compound_stmts.rst:239
msgid ":keyword:`!except` clause"
msgstr "Cláusula :keyword:`!except`"
#: ../Doc/reference/compound_stmts.rst:241
msgid ""
"The :keyword:`!except` clause(s) specify one or more exception handlers. "
"When no exception occurs in the :keyword:`try` clause, no exception handler "
"is executed. When an exception occurs in the :keyword:`!try` suite, a search "
"for an exception handler is started. This search inspects the :keyword:`!"
"except` clauses in turn until one is found that matches the exception. An "
"expression-less :keyword:`!except` clause, if present, must be last; it "
"matches any exception. For an :keyword:`!except` clause with an expression, "
"that expression is evaluated, and the clause matches the exception if the "
"resulting object is \"compatible\" with the exception. An object is "
"compatible with an exception if the object is the class or a :term:`non-"
"virtual base class <abstract base class>` of the exception object, or a "
"tuple containing an item that is the class or a non-virtual base class of "
"the exception object."
msgstr ""
"Las cláusulas :keyword:`!except` especifican uno o más controladores de "
"excepciones. Cuando no se produce ninguna excepción en la cláusula :keyword:"
"`try`, no se ejecuta ningún controlador de excepciones. Cuando ocurre una "
"excepción en la suite :keyword:`!try`, se inicia una búsqueda de un "
"controlador de excepciones. Esta búsqueda inspecciona las cláusulas :keyword:"
"`!except` a su vez hasta que se encuentra una que coincida con la excepción. "
"Una cláusula :keyword:`!except` sin expresión, si está presente, debe ser la "
"última; coincide con cualquier excepción. Para una cláusula :keyword:`!"
"except` con una expresión, esa expresión se evalúa y la cláusula coincide "
"con la excepción si el objeto resultante es \"compatible\" con la excepción. "
"Un objeto es compatible con una excepción si el objeto es la clase o un :"
"term:`non-virtual base class <abstract base class>` del objeto de excepción, "
"o una tupla que contiene un elemento que es la clase o una clase base no "
"virtual del objeto de excepción."
#: ../Doc/reference/compound_stmts.rst:256
msgid ""
"If no :keyword:`!except` clause matches the exception, the search for an "
"exception handler continues in the surrounding code and on the invocation "
"stack. [#]_"
msgstr ""
"Si ninguna cláusula :keyword:`!except` coincide con la excepción, la "
"búsqueda de un controlador de excepciones continúa en el código circundante "
"y en la pila de invocaciones. [#]_"
#: ../Doc/reference/compound_stmts.rst:260
msgid ""
"If the evaluation of an expression in the header of an :keyword:`!except` "
"clause raises an exception, the original search for a handler is canceled "
"and a search starts for the new exception in the surrounding code and on the "
"call stack (it is treated as if the entire :keyword:`try` statement raised "
"the exception)."
msgstr ""
"Si la evaluación de una expresión en el encabezado de una cláusula :keyword:"
"`!except` genera una excepción, la búsqueda original de un controlador se "
"cancela y comienza una búsqueda de la nueva excepción en el código "
"circundante y en la pila de llamadas (se trata como si toda la sentencia :"
"keyword:`try` generara la excepción)."
#: ../Doc/reference/compound_stmts.rst:268
msgid ""
"When a matching :keyword:`!except` clause is found, the exception is "
"assigned to the target specified after the :keyword:`!as` keyword in that :"
"keyword:`!except` clause, if present, and the :keyword:`!except` clause's "
"suite is executed. All :keyword:`!except` clauses must have an executable "
"block. When the end of this block is reached, execution continues normally "
"after the entire :keyword:`try` statement. (This means that if two nested "
"handlers exist for the same exception, and the exception occurs in the :"
"keyword:`!try` clause of the inner handler, the outer handler will not "
"handle the exception.)"
msgstr ""
"Cuando se encuentra una cláusula :keyword:`!except` coincidente, la "
"excepción se asigna al destino especificado después de la palabra clave :"
"keyword:`!as` en esa cláusula :keyword:`!except`, si está presente, y se "
"ejecuta el conjunto de la cláusula :keyword:`!except`. Todas las cláusulas :"
"keyword:`!except` deben tener un bloque ejecutable. Cuando se alcanza el "
"final de este bloque, la ejecución continúa normalmente después de la "
"instrucción :keyword:`try` completa. (Esto significa que si existen dos "
"controladores anidados para la misma excepción y la excepción se produce en "
"la cláusula :keyword:`!try` del controlador interno, el controlador externo "
"no controlará la excepción)."
#: ../Doc/reference/compound_stmts.rst:279
msgid ""
"When an exception has been assigned using ``as target``, it is cleared at "
"the end of the :keyword:`!except` clause. This is as if ::"
msgstr ""
"Cuando se ha asignado una excepción mediante ``as target``, se borra al "
"final de la cláusula :keyword:`!except`. Esto es como si ::"
#: ../Doc/reference/compound_stmts.rst:285
msgid "was translated to ::"
msgstr "fue traducido a ::"
#: ../Doc/reference/compound_stmts.rst:293
msgid ""
"This means the exception must be assigned to a different name to be able to "
"refer to it after the :keyword:`!except` clause. Exceptions are cleared "
"because with the traceback attached to them, they form a reference cycle "
"with the stack frame, keeping all locals in that frame alive until the next "
"garbage collection occurs."
msgstr ""
"Esto significa que la excepción debe asignarse a un nombre diferente para "
"poder hacer referencia a ella después de la cláusula :keyword:`!except`. Las "
"excepciones se borran porque con el rastreo adjunto, forman un ciclo de "
"referencia con el marco de la pila, manteniendo todos los locales en ese "
"marco vivos hasta que ocurra la próxima recolección de elementos no "
"utilizados."
#: ../Doc/reference/compound_stmts.rst:303
msgid ""
"Before an :keyword:`!except` clause's suite is executed, the exception is "
"stored in the :mod:`sys` module, where it can be accessed from within the "
"body of the :keyword:`!except` clause by calling :func:`sys.exception`. When "
"leaving an exception handler, the exception stored in the :mod:`sys` module "
"is reset to its previous value::"
msgstr ""
#: ../Doc/reference/compound_stmts.rst:334
msgid ":keyword:`!except*` clause"
msgstr "Cláusula :keyword:`!except*`"
#: ../Doc/reference/compound_stmts.rst:336
msgid ""
"The :keyword:`!except*` clause(s) are used for handling :exc:"
"`ExceptionGroup`\\s. The exception type for matching is interpreted as in "
"the case of :keyword:`except`, but in the case of exception groups we can "
"have partial matches when the type matches some of the exceptions in the "
"group. This means that multiple :keyword:`!except*` clauses can execute, "
"each handling part of the exception group. Each clause executes at most once "
"and handles an exception group of all matching exceptions. Each exception "
"in the group is handled by at most one :keyword:`!except*` clause, the first "
"that matches it. ::"
msgstr ""
"La(s) cláusula(s) :keyword:`!except*` se utilizan para manejar :exc:"
"`ExceptionGroup`\\s. El tipo de excepción para la coincidencia se interpreta "
"como en el caso de :keyword:`except`, pero en el caso de los grupos de "
"excepción podemos tener coincidencias parciales cuando el tipo coincide con "
"algunas de las excepciones del grupo. Esto significa que se pueden ejecutar "
"varias cláusulas :keyword:`!except*`, cada una de las cuales maneja parte "
"del grupo de excepciones. Cada cláusula se ejecuta como máximo una vez y "
"maneja un grupo de excepciones de todas las excepciones coincidentes. Cada "
"excepción en el grupo es manejada por una cláusula :keyword:`!except*` como "
"máximo, la primera que coincida. ::"
#: ../Doc/reference/compound_stmts.rst:364
#, fuzzy
msgid ""
"Any remaining exceptions that were not handled by any :keyword:`!except*` "
"clause are re-raised at the end, along with all exceptions that were raised "
"from within the :keyword:`!except*` clauses. If this list contains more than "
"one exception to reraise, they are combined into an exception group."
msgstr ""
"Cualquier excepción restante que no haya sido manejada por ninguna cláusula :"
"keyword:`!except*` se vuelve a generar al final, se combina en un grupo de "
"excepciones junto con todas las excepciones que se generaron desde dentro de "
"las cláusulas :keyword:`!except*`."
#: ../Doc/reference/compound_stmts.rst:370
msgid ""
"If the raised exception is not an exception group and its type matches one "
"of the :keyword:`!except*` clauses, it is caught and wrapped by an exception "
"group with an empty message string. ::"
msgstr ""
"Si la excepción generada no es un grupo de excepciones y su tipo coincide "
"con una de las cláusulas :keyword:`!except*`, un grupo de excepciones la "
"captura y la encapsula con una cadena de mensaje vacía. ::"
#: ../Doc/reference/compound_stmts.rst:381
msgid ""
"An :keyword:`!except*` clause must have a matching type, and this type "
"cannot be a subclass of :exc:`BaseExceptionGroup`. It is not possible to "
"mix :keyword:`except` and :keyword:`!except*` in the same :keyword:`try`. :"
"keyword:`break`, :keyword:`continue` and :keyword:`return` cannot appear in "
"an :keyword:`!except*` clause."
msgstr ""
"Una cláusula :keyword:`!except*` debe tener un tipo coincidente y este tipo "
"no puede ser una subclase de :exc:`BaseExceptionGroup`. No es posible "
"mezclar :keyword:`except` y :keyword:`!except*` en el mismo :keyword:`try`. :"
"keyword:`break`, :keyword:`continue` y :keyword:`return` no pueden aparecer "
"en una cláusula :keyword:`!except*`."
#: ../Doc/reference/compound_stmts.rst:398
msgid ":keyword:`!else` clause"
msgstr "La sentencia :keyword:`!else`"
#: ../Doc/reference/compound_stmts.rst:400
msgid ""
"The optional :keyword:`!else` clause is executed if the control flow leaves "
"the :keyword:`try` suite, no exception was raised, and no :keyword:"
"`return`, :keyword:`continue`, or :keyword:`break` statement was executed. "
"Exceptions in the :keyword:`!else` clause are not handled by the preceding :"
"keyword:`except` clauses."
msgstr ""
"La cláusula opcional :keyword:`!else` se ejecuta si el flujo de control sale "
"de la suite :keyword:`try`, no se produjo ninguna excepción, y no se ejecutó "
"la sentencia :keyword:`return`, :keyword:`continue` o :keyword:`break`. Las "
"excepciones en la cláusula :keyword:`!else` no se gestionaron con las "
"cláusulas precedentes :keyword:`except`."
#: ../Doc/reference/compound_stmts.rst:412
msgid ":keyword:`!finally` clause"
msgstr "Cláusula :keyword:`!finally`"
#: ../Doc/reference/compound_stmts.rst:414
msgid ""
"If :keyword:`!finally` is present, it specifies a 'cleanup' handler. The :"
"keyword:`try` clause is executed, including any :keyword:`except` and :"
"keyword:`else` clauses. If an exception occurs in any of the clauses and is "
"not handled, the exception is temporarily saved. The :keyword:`!finally` "
"clause is executed. If there is a saved exception it is re-raised at the "
"end of the :keyword:`!finally` clause. If the :keyword:`!finally` clause "
"raises another exception, the saved exception is set as the context of the "
"new exception. If the :keyword:`!finally` clause executes a :keyword:"
"`return`, :keyword:`break` or :keyword:`continue` statement, the saved "
"exception is discarded::"
msgstr ""
"Si :keyword:`!finally` está presente, especifica un controlador de "
"'limpieza'. Se ejecuta la cláusula :keyword:`try`, incluidas las cláusulas :"
"keyword:`except` y :keyword:`else`. Si ocurre una excepción en cualquiera de "
"las cláusulas y no se maneja, la excepción se guarda temporalmente. Se "
"ejecuta la cláusula :keyword:`!finally`. Si hay una excepción guardada, se "
"vuelve a generar al final de la cláusula :keyword:`!finally`. Si la "
"cláusula :keyword:`!finally` genera otra excepción, la excepción guardada se "
"establece como el contexto de la nueva excepción. Si la cláusula :keyword:`!"
"finally` ejecuta una sentencia :keyword:`return`, :keyword:`break` o :"
"keyword:`continue`, la excepción guardada se descarta:"
#: ../Doc/reference/compound_stmts.rst:433
msgid ""
"The exception information is not available to the program during execution "
"of the :keyword:`!finally` clause."
msgstr ""
"La información de excepción no está disponible para el programa durante la "
"ejecución de la cláusula :keyword:`!finally`."
#: ../Doc/reference/compound_stmts.rst:441
msgid ""
"When a :keyword:`return`, :keyword:`break` or :keyword:`continue` statement "
"is executed in the :keyword:`try` suite of a :keyword:`!try`...\\ :keyword:`!"
"finally` statement, the :keyword:`!finally` clause is also executed 'on the "
"way out.'"
msgstr ""
"Cuando se ejecuta una sentencia :keyword:`return`, :keyword:`break` o :"
"keyword:`continue` en el conjunto :keyword:`try` de una sentencia :keyword:`!"
"try`...\\ :keyword:`!finally`, la cláusula :keyword:`!finally` también se "
"ejecuta 'al salir'."
#: ../Doc/reference/compound_stmts.rst:445
msgid ""
"The return value of a function is determined by the last :keyword:`return` "
"statement executed. Since the :keyword:`!finally` clause always executes, "
"a :keyword:`!return` statement executed in the :keyword:`!finally` clause "
"will always be the last one executed::"
msgstr ""
"El valor de retorno de una función está determinado por la última "
"instrucción :keyword:`return` ejecutada. Dado que la cláusula :keyword:`!"
"finally` siempre se ejecuta, una sentencia :keyword:`!return` ejecutada en "
"la cláusula :keyword:`!finally` siempre será la última en ejecutarse:"
#: ../Doc/reference/compound_stmts.rst:459
msgid ""
"Prior to Python 3.8, a :keyword:`continue` statement was illegal in the :"
"keyword:`!finally` clause due to a problem with the implementation."
msgstr ""
"Antes de Python 3.8, una declaración :keyword:`continue` era ilegal en la "
"cláusula :keyword:`!finally` debido a un problema con la implementación."
#: ../Doc/reference/compound_stmts.rst:468
msgid "The :keyword:`!with` statement"
msgstr "La sentencia :keyword:`!with`"
#: ../Doc/reference/compound_stmts.rst:477
msgid ""
"The :keyword:`with` statement is used to wrap the execution of a block with "
"methods defined by a context manager (see section :ref:`context-managers`). "
"This allows common :keyword:`try`...\\ :keyword:`except`...\\ :keyword:"
"`finally` usage patterns to be encapsulated for convenient reuse."
msgstr ""
"La sentencia :keyword:`with` se usa para ajustar la ejecución de un bloque "
"con métodos definidos por un administrador de contexto (ver sección :ref:"
"`context-managers`). Esto permite que los patrones de uso comunes :keyword:"
"`try`...\\ :keyword:`except`...\\ :keyword:`finally` se encapsulen para una "
"reutilización conveniente."
#: ../Doc/reference/compound_stmts.rst:487
msgid ""
"The execution of the :keyword:`with` statement with one \"item\" proceeds as "
"follows:"
msgstr ""
"La ejecución de la sentencia :keyword:`with` con un \"item\" se realiza de "
"la siguiente manera:"
#: ../Doc/reference/compound_stmts.rst:489
msgid ""
"The context expression (the expression given in the :token:`~python-grammar:"
"with_item`) is evaluated to obtain a context manager."
msgstr ""
"La expresión de contexto (la expresión dada en :token:`~python-grammar:"
"with_item`) se evalúa para obtener un administrador de contexto."
#: ../Doc/reference/compound_stmts.rst:492
msgid "The context manager's :meth:`__enter__` is loaded for later use."
msgstr ""
"El administrador de contexto :meth:`__enter__` se carga para su uso "
"posterior."
#: ../Doc/reference/compound_stmts.rst:494
msgid "The context manager's :meth:`__exit__` is loaded for later use."
msgstr ""
"El administrador de contexto :meth:`__exit__` se carga para su uso posterior."
#: ../Doc/reference/compound_stmts.rst:496
msgid "The context manager's :meth:`__enter__` method is invoked."
msgstr "Se invoca el método del administrador de contexto :meth:`__enter__`."
#: ../Doc/reference/compound_stmts.rst:498
msgid ""
"If a target was included in the :keyword:`with` statement, the return value "
"from :meth:`__enter__` is assigned to it."
msgstr ""
"Si se incluyó el destino en la sentencia :keyword:`with`, se le asigna el "
"valor de retorno de :meth:`__enter__`."
#: ../Doc/reference/compound_stmts.rst:503
#, fuzzy
msgid ""
"The :keyword:`with` statement guarantees that if the :meth:`__enter__` "
"method returns without an error, then :meth:`__exit__` will always be "
"called. Thus, if an error occurs during the assignment to the target list, "
"it will be treated the same as an error occurring within the suite would be. "
"See step 7 below."
msgstr ""
"La sentencia :keyword:`with` garantiza que si el método :meth:`__enter__` "
"regresa sin error, entonces siempre se llamará a :meth:`__exit__`. Por lo "
"tanto, si se produce un error durante la asignación a la lista de destino, "
"se tratará de la misma manera que si se produciría un error dentro de la "
"suite. Vea el paso 6 a continuación."
#: ../Doc/reference/compound_stmts.rst:509
msgid "The suite is executed."
msgstr "La suite se ejecuta."
#: ../Doc/reference/compound_stmts.rst:511
msgid ""
"The context manager's :meth:`__exit__` method is invoked. If an exception "
"caused the suite to be exited, its type, value, and traceback are passed as "
"arguments to :meth:`__exit__`. Otherwise, three :const:`None` arguments are "
"supplied."
msgstr ""
"Se invoca el método del administrador de contexto :meth:`__exit__`. Si una "
"excepción causó la salida de la suite, su tipo, valor y rastreo se pasan "
"como argumentos a :meth:`__exit__`. De lo contrario, se proporcionan tres "
"argumentos :const:`None`."
#: ../Doc/reference/compound_stmts.rst:516
msgid ""
"If the suite was exited due to an exception, and the return value from the :"
"meth:`__exit__` method was false, the exception is reraised. If the return "
"value was true, the exception is suppressed, and execution continues with "
"the statement following the :keyword:`with` statement."
msgstr ""
"Si se salió de la suite debido a una excepción, y el valor de retorno del "
"método :meth:`__exit__` fue falso, la excepción se vuelve a plantear. Si el "
"valor de retorno era verdadero, la excepción se suprime y la ejecución "
"continúa con la sentencia que sigue a la sentencia :keyword:`with`."
#: ../Doc/reference/compound_stmts.rst:521
msgid ""
"If the suite was exited for any reason other than an exception, the return "
"value from :meth:`__exit__` is ignored, and execution proceeds at the normal "
"location for the kind of exit that was taken."
msgstr ""
"Si se salió de la suite por cualquier motivo que no sea una excepción, el "
"valor de retorno de :meth:`__exit__` se ignora y la ejecución continúa en la "
"ubicación normal para el tipo de salida que se tomó."
#: ../Doc/reference/compound_stmts.rst:525
#: ../Doc/reference/compound_stmts.rst:1534
#: ../Doc/reference/compound_stmts.rst:1575
msgid "The following code::"
msgstr "El siguiente código::"
#: ../Doc/reference/compound_stmts.rst:530
#: ../Doc/reference/compound_stmts.rst:555
#: ../Doc/reference/compound_stmts.rst:1580
msgid "is semantically equivalent to::"
msgstr "es semánticamente equivalente a::"
#: ../Doc/reference/compound_stmts.rst:549
msgid ""
"With more than one item, the context managers are processed as if multiple :"
"keyword:`with` statements were nested::"
msgstr ""
"Con más de un elemento, los administradores de contexto se procesan como si "
"varias sentencias :keyword:`with` estuvieran anidadas::"
#: ../Doc/reference/compound_stmts.rst:561
msgid ""
"You can also write multi-item context managers in multiple lines if the "
"items are surrounded by parentheses. For example::"
msgstr ""
"También puedes escribir administradores de contexto de múltiples ítems en "
"múltiples lineas si los ítems están entre paréntesis. Por ejemplo::"
#: ../Doc/reference/compound_stmts.rst:570
msgid "Support for multiple context expressions."
msgstr "Soporte para múltiples expresiones de contexto."
#: ../Doc/reference/compound_stmts.rst:573
msgid ""
"Support for using grouping parentheses to break the statement in multiple "
"lines."
msgstr ""
"Soporte para el uso de paréntesis de agrupación para separar la declaración "
"en múltiples líneas."
#: ../Doc/reference/compound_stmts.rst:579
msgid ":pep:`343` - The \"with\" statement"
msgstr ":pep:`343` - La sentencia \"with\""
#: ../Doc/reference/compound_stmts.rst:579
msgid ""
"The specification, background, and examples for the Python :keyword:`with` "
"statement."
msgstr ""
"La especificación, antecedentes y ejemplos de la sentencia de Python :"
"keyword:`with`."
#: ../Doc/reference/compound_stmts.rst:585
msgid "The :keyword:`!match` statement"
msgstr "La sentencia :keyword:`!match`"
#: ../Doc/reference/compound_stmts.rst:599
msgid "The match statement is used for pattern matching. Syntax:"
msgstr ""
"La declaración match es usada para coincidencia de patrones. Sintaxis:"
#: ../Doc/reference/compound_stmts.rst:608
msgid ""
"This section uses single quotes to denote :ref:`soft keywords <soft-"
"keywords>`."
msgstr ""
"Esta sección utiliza comillas simples para denotar las :ref:`palabras clave "
"suaves <soft-keywords>`."
# Se utilizó valor de búsqueda para traducir *subject value* basándose en la
# traducción francesa *champ de recherche*.
#: ../Doc/reference/compound_stmts.rst:611
msgid ""
"Pattern matching takes a pattern as input (following ``case``) and a subject "
"value (following ``match``). The pattern (which may contain subpatterns) is "
"matched against the subject value. The outcomes are:"
msgstr ""
"La coincidencia de patrones toma un patrón como entrada (delante de "
"``case``) y un valor de búsqueda (delante de ``match``). El patrón (que "
"puede contener subpatrones) es comparado con el valor de búsqueda. Los "
"resultados son:"
#: ../Doc/reference/compound_stmts.rst:615
msgid "A match success or failure (also termed a pattern success or failure)."
msgstr ""
"Una coincidencia exitosa o fallida (también llamada éxito o fracaso de un "
"patrón)."
#: ../Doc/reference/compound_stmts.rst:617
msgid ""
"Possible binding of matched values to a name. The prerequisites for this "
"are further discussed below."
msgstr ""
"Una posible vinculación de los valores coincidentes con un nombre. Los "
"requisitos previos para esto se discuten abajo."
#: ../Doc/reference/compound_stmts.rst:620
msgid ""
"The ``match`` and ``case`` keywords are :ref:`soft keywords <soft-keywords>`."
msgstr ""
"Las palabras clave ``match`` y ``case`` son :ref:`palabras clave suaves "
"<soft-keywords>`."
#: ../Doc/reference/compound_stmts.rst:624
#: ../Doc/reference/compound_stmts.rst:1179
msgid ":pep:`634` -- Structural Pattern Matching: Specification"
msgstr ":pep:`634` -- Coincidencia de patrones estructurales: Especificación"
#: ../Doc/reference/compound_stmts.rst:625
#: ../Doc/reference/compound_stmts.rst:1180
msgid ":pep:`636` -- Structural Pattern Matching: Tutorial"
msgstr ":pep:`636` -- Coincidencia de patrones estructurales: Tutorial"
#: ../Doc/reference/compound_stmts.rst:629
msgid "Overview"
msgstr "Resumen"
#: ../Doc/reference/compound_stmts.rst:631
msgid "Here's an overview of the logical flow of a match statement:"
msgstr ""
"A continuación, un resumen del flujo lógico de una declaración de "
"coincidencia:"
#: ../Doc/reference/compound_stmts.rst:634
msgid ""
"The subject expression ``subject_expr`` is evaluated and a resulting subject "
"value obtained. If the subject expression contains a comma, a tuple is "
"constructed using :ref:`the standard rules <typesseq-tuple>`."
msgstr ""
"Se evalúa la expresión ``subject_expr`` y se obtiene un valor sujeto "
"resultante. Si la expresión contiene una coma, se construye una tupla "
"utilizando :ref:`las reglas estándar <typesseq-tuple>`."
#: ../Doc/reference/compound_stmts.rst:638
msgid ""
"Each pattern in a ``case_block`` is attempted to match with the subject "
"value. The specific rules for success or failure are described below. The "
"match attempt can also bind some or all of the standalone names within the "
"pattern. The precise pattern binding rules vary per pattern type and are "
"specified below. **Name bindings made during a successful pattern match "
"outlive the executed block and can be used after the match statement**."
msgstr ""
"Se intenta coincidir cada patrón en un ``case_block`` con el valor sujeto. "
"Las reglas específicas para el éxito o el fracaso se describen abajo. El "
"intento de coincidencia también puede enlazar algunos o todos los nombres "
"independientes dentro del patrón. Las reglas precisas de enlace de patrones "
"varían según el tipo de patrón y se especifican a continuación. **Los "
"enlaces de nombre realizados durante una coincidencia de patrones exitosa "
"sobreviven al bloque ejecutado y se pueden usar después de la declaración de "
"coincidencia**."
#: ../Doc/reference/compound_stmts.rst:647
msgid ""
"During failed pattern matches, some subpatterns may succeed. Do not rely on "
"bindings being made for a failed match. Conversely, do not rely on "
"variables remaining unchanged after a failed match. The exact behavior is "
"dependent on implementation and may vary. This is an intentional decision "
"made to allow different implementations to add optimizations."
msgstr ""
"Durante las coincidencias de patrones fallidas, algunos subpatrones pueden "
"tener éxito. No confíe en que los enlaces se realicen para una coincidencia "
"fallida. Por el contrario, no confíe en que las variables permanezcan sin "
"cambios después de una coincidencia fallida. El comportamiento exacto "
"depende de la implementación y puede variar. Esta es una decisión "
"intencional para permitir que diferentes implementaciones añadan "
"optimizaciones."
#: ../Doc/reference/compound_stmts.rst:654
msgid ""
"If the pattern succeeds, the corresponding guard (if present) is evaluated. "
"In this case all name bindings are guaranteed to have happened."
msgstr ""
"Si el patrón es exitoso, se evalúa la protección correspondiente (si está "
"presente). En este caso se garantiza que todos los enlaces de nombres han "
"ocurrido."
#: ../Doc/reference/compound_stmts.rst:657
msgid ""
"If the guard evaluates as true or is missing, the ``block`` inside "
"``case_block`` is executed."
msgstr ""
"Si la protección se evalúa como verdadera o no existe, se ejecuta el "
"``block`` dentro de ``case_block``."
#: ../Doc/reference/compound_stmts.rst:660
msgid "Otherwise, the next ``case_block`` is attempted as described above."
msgstr ""
"En caso contrario, se intenta con el siguiente ``case_block`` como se ha "
"descrito anteriormente."
#: ../Doc/reference/compound_stmts.rst:662
msgid "If there are no further case blocks, the match statement is completed."
msgstr ""
"Si no hay más bloques de casos, la declaración de coincidencia se completa."
#: ../Doc/reference/compound_stmts.rst:666
msgid ""
"Users should generally never rely on a pattern being evaluated. Depending "
"on implementation, the interpreter may cache values or use other "
"optimizations which skip repeated evaluations."
msgstr ""
"Por lo general, los usuarios no deben confiar en que se evalúe un patrón. "
"Dependiendo de la implementación, el intérprete puede almacenar en caché los "
"valores o utilizar otras optimizaciones que omitan las evaluaciones "
"repetidas."
#: ../Doc/reference/compound_stmts.rst:670
msgid "A sample match statement::"
msgstr "Un ejemplo de declaración de coincidencia::"
#: ../Doc/reference/compound_stmts.rst:686
msgid ""
"In this case, ``if flag`` is a guard. Read more about that in the next "
"section."
msgstr ""
"En este caso, ``if flag`` es una protección. Lea más sobre eso en la "
"siguiente sección."
#: ../Doc/reference/compound_stmts.rst:689
msgid "Guards"
msgstr "Protecciones"
#: ../Doc/reference/compound_stmts.rst:696
msgid ""
"A ``guard`` (which is part of the ``case``) must succeed for code inside the "
"``case`` block to execute. It takes the form: :keyword:`if` followed by an "
"expression."
msgstr ""
"Una ``guard`` (que es parte del ``case``) debe ser exitosa para que el "
"código dentro de ``case`` sea ejecutado. Toma la forma: :keyword:`if` "
"seguida de una expresión."
#: ../Doc/reference/compound_stmts.rst:701
msgid "The logical flow of a ``case`` block with a ``guard`` follows:"
msgstr ""
"El flujo lógico de un bloque ``case`` con una ``guard`` es el siguiente:"
#: ../Doc/reference/compound_stmts.rst:703
msgid ""
"Check that the pattern in the ``case`` block succeeded. If the pattern "
"failed, the ``guard`` is not evaluated and the next ``case`` block is "
"checked."
msgstr ""
"Se comprueba que el patrón del bloque ``case`` fue exitoso. Si el patrón "
"falló, el ``guard`` no se evalúa y se comprueba el siguiente bloque ``case``."
#: ../Doc/reference/compound_stmts.rst:707
msgid "If the pattern succeeded, evaluate the ``guard``."
msgstr "Si el patrón tuvo éxito, se evalúa el ``guard``."
#: ../Doc/reference/compound_stmts.rst:709
msgid ""
"If the ``guard`` condition evaluates as true, the case block is selected."
msgstr ""
"Si la condición del ``guard`` es verdadera, se selecciona el bloque de ese "
"caso."
#: ../Doc/reference/compound_stmts.rst:712
msgid ""
"If the ``guard`` condition evaluates as false, the case block is not "
"selected."
msgstr ""
"Si la condición del ``guard`` es falsa, el bloque de ese caso no es "
"seleccionado."
#: ../Doc/reference/compound_stmts.rst:715
msgid ""
"If the ``guard`` raises an exception during evaluation, the exception "
"bubbles up."
msgstr ""
"Si el ``guard`` lanza una excepción durante la evaluación, se levanta la "
"excepción."
#: ../Doc/reference/compound_stmts.rst:718
msgid ""
"Guards are allowed to have side effects as they are expressions. Guard "
"evaluation must proceed from the first to the last case block, one at a "
"time, skipping case blocks whose pattern(s) don't all succeed. (I.e., guard "
"evaluation must happen in order.) Guard evaluation must stop once a case "
"block is selected."
msgstr ""
"Se permite que las protecciones tengan efectos secundarios, ya que son "
"expresiones. La evaluación de la protección debe ir desde el primer al "
"último bloque de casos, uno a la vez, saltando los bloques de casos cuyo(s) "
"patrón(es) no tenga(n) éxito. (Es decir, la evaluación de las protecciones "
"debe realizarse en orden.) La evaluación de las protecciones debe detenerse "
"una vez que se selecciona un bloque de casos."
#: ../Doc/reference/compound_stmts.rst:728
msgid "Irrefutable Case Blocks"
msgstr "Bloques de Casos Irrefutables"
#: ../Doc/reference/compound_stmts.rst:732
msgid ""
"An irrefutable case block is a match-all case block. A match statement may "
"have at most one irrefutable case block, and it must be last."
msgstr ""
"Un bloque de casos irrefutable es un bloque de casos que coincide con todo. "
"Una declaración de coincidencia puede tener como máximo un bloque de casos "
"irrefutable, y debe ser el último."
#: ../Doc/reference/compound_stmts.rst:735
msgid ""
"A case block is considered irrefutable if it has no guard and its pattern is "
"irrefutable. A pattern is considered irrefutable if we can prove from its "
"syntax alone that it will always succeed. Only the following patterns are "
"irrefutable:"
msgstr ""
"Un bloque de casos se considera irrefutable si no tiene protección y su "
"patrón es irrefutable. Un patrón se considera irrefutable si podemos "
"demostrar, sólo por su sintaxis, que siempre tendrá éxito. Sólo los "
"siguientes patrones son irrefutables:"
#: ../Doc/reference/compound_stmts.rst:740
msgid ":ref:`as-patterns` whose left-hand side is irrefutable"
msgstr ":ref:`as-patterns` cuyo lado izquierdo es irrefutable"
#: ../Doc/reference/compound_stmts.rst:742
msgid ":ref:`or-patterns` containing at least one irrefutable pattern"
msgstr ":ref:`or-patterns` que contienen al menos un patrón irrefutable"
#: ../Doc/reference/compound_stmts.rst:744
msgid ":ref:`capture-patterns`"
msgstr ":ref:`capture-patterns`"
#: ../Doc/reference/compound_stmts.rst:746
msgid ":ref:`wildcard-patterns`"
msgstr ":ref:`wildcard-patterns`"
#: ../Doc/reference/compound_stmts.rst:748
msgid "parenthesized irrefutable patterns"
msgstr "patrones irrefutables entre paréntesis"
#: ../Doc/reference/compound_stmts.rst:752
msgid "Patterns"
msgstr "Patrones"
#: ../Doc/reference/compound_stmts.rst:759
msgid "This section uses grammar notations beyond standard EBNF:"
msgstr ""
"Esta sección utiliza notaciones gramaticales más allá del estándar EBNF:"
#: ../Doc/reference/compound_stmts.rst:761