# 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: 2024-11-21 16:38-0300\n"

"PO-Revision-Date: 2023-10-22 21:17-0500\n"

"Last-Translator: Marco Richetta <marcorichetta@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.16.0\n"

#: ../Doc/library/ast.rst:2

#, fuzzy

msgid ":mod:`!ast` --- Abstract Syntax Trees"

msgstr ":mod:`ast` --- Árboles de sintaxis abstracta"

#: ../Doc/library/ast.rst:14

msgid "**Source code:** :source:`Lib/ast.py`"

msgstr "**Código fuente:** :source:`Lib/ast.py`"

#: ../Doc/library/ast.rst:18

msgid ""

"The :mod:`ast` module helps Python applications to process trees of the "

"Python abstract syntax grammar. The abstract syntax itself might change "

"with each Python release; this module helps to find out programmatically "

"what the current grammar looks like."

msgstr ""

"El módulo :mod:`ast` ayuda a las aplicaciones de Python a procesar árboles "

"de la gramática de sintaxis abstracta de Python. La sintaxis abstracta en sí "

"misma puede cambiar con cada versión de Python; Este módulo ayuda a "

"descubrir mediante programación cómo se ve la gramática actual."

#: ../Doc/library/ast.rst:23

msgid ""

"An abstract syntax tree can be generated by passing :data:`ast."

"PyCF_ONLY_AST` as a flag to the :func:`compile` built-in function, or using "

"the :func:`parse` helper provided in this module. The result will be a tree "

"of objects whose classes all inherit from :class:`ast.AST`. An abstract "

"syntax tree can be compiled into a Python code object using the built-in :"

"func:`compile` function."

msgstr ""

"Se puede generar un árbol de sintaxis abstracta pasando :data:`ast."

"PyCF_ONLY_AST` como un indicador de la función incorporada :func:`compile`, "

"o usando el ayudante :func:`parse` provisto en este módulo. El resultado "

"será un árbol de objetos cuyas clases todas heredan de :class:`ast.AST`. Se "

"puede compilar un árbol de sintaxis abstracta en un objeto de código Python "

"utilizando la función incorporada :func:`compile`."

#: ../Doc/library/ast.rst:33

msgid "Abstract Grammar"

msgstr "Gramática abstracta"

#: ../Doc/library/ast.rst:35

msgid "The abstract grammar is currently defined as follows:"

msgstr "La gramática abstracta se define actualmente de la siguiente manera:"

#: ../Doc/library/ast.rst:37

msgid ""

"-- ASDL's 4 builtin types are:\n"

"-- identifier, int, string, constant\n"

"\n"

"module Python\n"

"{\n"

" mod = Module(stmt* body, type_ignore* type_ignores)\n"

" | Interactive(stmt* body)\n"

" | Expression(expr body)\n"

" | FunctionType(expr* argtypes, expr returns)\n"

"\n"

" stmt = FunctionDef(identifier name, arguments args,\n"

" stmt* body, expr* decorator_list, expr? returns,\n"

" string? type_comment, type_param* type_params)\n"

" | AsyncFunctionDef(identifier name, arguments args,\n"

" stmt* body, expr* decorator_list, expr? "

"returns,\n"

" string? type_comment, type_param* type_params)\n"

"\n"

" | ClassDef(identifier name,\n"

" expr* bases,\n"

" keyword* keywords,\n"

" stmt* body,\n"

" expr* decorator_list,\n"

" type_param* type_params)\n"

" | Return(expr? value)\n"

"\n"

" | Delete(expr* targets)\n"

" | Assign(expr* targets, expr value, string? type_comment)\n"

" | TypeAlias(expr name, type_param* type_params, expr value)\n"

" | AugAssign(expr target, operator op, expr value)\n"

" -- 'simple' indicates that we annotate simple name without parens\n"

" | AnnAssign(expr target, expr annotation, expr? value, int "

"simple)\n"

"\n"

" -- use 'orelse' because else is a keyword in target languages\n"

" | For(expr target, expr iter, stmt* body, stmt* orelse, string? "

"type_comment)\n"

" | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, "

"string? type_comment)\n"

" | While(expr test, stmt* body, stmt* orelse)\n"

" | If(expr test, stmt* body, stmt* orelse)\n"

" | With(withitem* items, stmt* body, string? type_comment)\n"

" | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"

"\n"

" | Match(expr subject, match_case* cases)\n"

"\n"

" | Raise(expr? exc, expr? cause)\n"

" | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* "

"finalbody)\n"

" | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* "

"finalbody)\n"

" | Assert(expr test, expr? msg)\n"

"\n"

" | Import(alias* names)\n"

" | ImportFrom(identifier? module, alias* names, int? level)\n"

"\n"

" | Global(identifier* names)\n"

" | Nonlocal(identifier* names)\n"

" | Expr(expr value)\n"

" | Pass | Break | Continue\n"

"\n"

" -- col_offset is the byte offset in the utf8 string the parser "

"uses\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" -- BoolOp() can use left & right?\n"

" expr = BoolOp(boolop op, expr* values)\n"

" | NamedExpr(expr target, expr value)\n"

" | BinOp(expr left, operator op, expr right)\n"

" | UnaryOp(unaryop op, expr operand)\n"

" | Lambda(arguments args, expr body)\n"

" | IfExp(expr test, expr body, expr orelse)\n"

" | Dict(expr* keys, expr* values)\n"

" | Set(expr* elts)\n"

" | ListComp(expr elt, comprehension* generators)\n"

" | SetComp(expr elt, comprehension* generators)\n"

" | DictComp(expr key, expr value, comprehension* generators)\n"

" | GeneratorExp(expr elt, comprehension* generators)\n"

" -- the grammar constrains where yield expressions can occur\n"

" | Await(expr value)\n"

" | Yield(expr? value)\n"

" | YieldFrom(expr value)\n"

" -- need sequences for compare to distinguish between\n"

" -- x < 4 < 3 and (x < 4) < 3\n"

" | Compare(expr left, cmpop* ops, expr* comparators)\n"

" | Call(expr func, expr* args, keyword* keywords)\n"

" | FormattedValue(expr value, int conversion, expr? format_spec)\n"

" | JoinedStr(expr* values)\n"

" | Constant(constant value, string? kind)\n"

"\n"

" -- the following expression can appear in assignment context\n"

" | Attribute(expr value, identifier attr, expr_context ctx)\n"

" | Subscript(expr value, expr slice, expr_context ctx)\n"

" | Starred(expr value, expr_context ctx)\n"

" | Name(identifier id, expr_context ctx)\n"

" | List(expr* elts, expr_context ctx)\n"

" | Tuple(expr* elts, expr_context ctx)\n"

"\n"

" -- can appear only in Subscript\n"

" | Slice(expr? lower, expr? upper, expr? step)\n"

"\n"

" -- col_offset is the byte offset in the utf8 string the parser "

"uses\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" expr_context = Load | Store | Del\n"

"\n"

" boolop = And | Or\n"

"\n"

" operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift\n"

" | RShift | BitOr | BitXor | BitAnd | FloorDiv\n"

"\n"

" unaryop = Invert | Not | UAdd | USub\n"

"\n"

" cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn\n"

"\n"

" comprehension = (expr target, expr iter, expr* ifs, int is_async)\n"

"\n"

" excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)\n"

" attributes (int lineno, int col_offset, int? end_lineno, "

"int? end_col_offset)\n"

"\n"

" arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,\n"

" expr* kw_defaults, arg? kwarg, expr* defaults)\n"

"\n"

" arg = (identifier arg, expr? annotation, string? type_comment)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" -- keyword arguments supplied to call (NULL identifier for **kwargs)\n"

" keyword = (identifier? arg, expr value)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" -- import name with optional 'as' alias.\n"

" alias = (identifier name, identifier? asname)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? "

"end_col_offset)\n"

"\n"

" withitem = (expr context_expr, expr? optional_vars)\n"

"\n"

" match_case = (pattern pattern, expr? guard, stmt* body)\n"

"\n"

" pattern = MatchValue(expr value)\n"

" | MatchSingleton(constant value)\n"

" | MatchSequence(pattern* patterns)\n"

" | MatchMapping(expr* keys, pattern* patterns, identifier? rest)\n"

" | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, "

"pattern* kwd_patterns)\n"

"\n"

" | MatchStar(identifier? name)\n"

" -- The optional \"rest\" MatchMapping parameter handles "

"capturing extra mapping keys\n"

"\n"

" | MatchAs(pattern? pattern, identifier? name)\n"

" | MatchOr(pattern* patterns)\n"

"\n"

" attributes (int lineno, int col_offset, int end_lineno, int "

"end_col_offset)\n"

"\n"

" type_ignore = TypeIgnore(int lineno, string tag)\n"

"\n"

" type_param = TypeVar(identifier name, expr? bound, expr? default_value)\n"

" | ParamSpec(identifier name, expr? default_value)\n"

" | TypeVarTuple(identifier name, expr? default_value)\n"

" attributes (int lineno, int col_offset, int end_lineno, int "

"end_col_offset)\n"

"}\n"

msgstr ""

#: ../Doc/library/ast.rst:42

msgid "Node classes"

msgstr "Clases nodo"

#: ../Doc/library/ast.rst:46

#, fuzzy

msgid ""

"This is the base of all AST node classes. The actual node classes are "

"derived from the :file:`Parser/Python.asdl` file, which is reproduced :ref:"

"`above <abstract-grammar>`. They are defined in the :mod:`!_ast` C module "

"and re-exported in :mod:`ast`."

msgstr ""

"Esta es la base de todas las clases de nodo AST. Las clases de nodo reales "

"se derivan del archivo :file:`Parser/Python.asdl`, que se reproduce :ref:"

"`abajo <abstract-grammar>`. Se definen en el módulo :mod:`_ast` C y se "

"reexportan en :mod:`ast`."

#: ../Doc/library/ast.rst:51

msgid ""

"There is one class defined for each left-hand side symbol in the abstract "

"grammar (for example, :class:`ast.stmt` or :class:`ast.expr`). In addition, "

"there is one class defined for each constructor on the right-hand side; "

"these classes inherit from the classes for the left-hand side trees. For "

"example, :class:`ast.BinOp` inherits from :class:`ast.expr`. For production "

"rules with alternatives (aka \"sums\"), the left-hand side class is "

"abstract: only instances of specific constructor nodes are ever created."

msgstr ""

"Hay una clase definida para cada símbolo del lado izquierdo en la gramática "

"abstracta (por ejemplo, :class:`ast.stmt` o :class:`ast.expr`). Además, hay "

"una clase definida para cada constructor en el lado derecho; estas clases "

"heredan de las clases para los árboles del lado izquierdo. Por ejemplo, :"

"class:`ast.BinOp` hereda de :class:`ast.expr`. Para las reglas de producción "

"con alternativas (también conocidas como \"sumas\"), la clase del lado "

"izquierdo es abstracta: solo se crean instancias de nodos de constructor "

"específicos."

#: ../Doc/library/ast.rst:64

#, fuzzy

msgid ""

"Each concrete class has an attribute :attr:`!_fields` which gives the names "

"of all child nodes."

msgstr ""

"Cada clase concreta tiene un atributo :attr:`_fields` que proporciona los "

"nombres de todos los nodos secundarios."

#: ../Doc/library/ast.rst:67

msgid ""

"Each instance of a concrete class has one attribute for each child node, of "

"the type as defined in the grammar. For example, :class:`ast.BinOp` "

"instances have an attribute :attr:`left` of type :class:`ast.expr`."

msgstr ""

"Cada instancia de una clase concreta tiene un atributo para cada nodo "

"secundario, del tipo definido en la gramática. Por ejemplo, las instancias :"

"class:`ast.BinOp` tienen un atributo :attr:`left` de tipo :class:`ast.expr`."

#: ../Doc/library/ast.rst:71

msgid ""

"If these attributes are marked as optional in the grammar (using a question "

"mark), the value might be ``None``. If the attributes can have zero-or-more "

"values (marked with an asterisk), the values are represented as Python "

"lists. All possible attributes must be present and have valid values when "

"compiling an AST with :func:`compile`."

msgstr ""

"Si estos atributos están marcados como opcionales en la gramática (usando un "

"signo de interrogación), el valor podría ser ``None``. Si los atributos "

"pueden tener cero o más valores (marcados con un asterisco), los valores se "

"representan como listas de Python. Todos los atributos posibles deben estar "

"presentes y tener valores válidos al compilar un AST con :func:`compile`."

#: ../Doc/library/ast.rst:79

msgid ""

"The :attr:`!_field_types` attribute on each concrete class is a dictionary "

"mapping field names (as also listed in :attr:`_fields`) to their types."

msgstr ""

#: ../Doc/library/ast.rst:82

msgid ""

">>> ast.TypeVar._field_types\n"

"{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr "

"| None}"

msgstr ""

#: ../Doc/library/ast.rst:94

msgid ""

"Instances of :class:`ast.expr` and :class:`ast.stmt` subclasses have :attr:"

"`lineno`, :attr:`col_offset`, :attr:`end_lineno`, and :attr:`end_col_offset` "

"attributes. The :attr:`lineno` and :attr:`end_lineno` are the first and "

"last line numbers of source text span (1-indexed so the first line is line "

"1) and the :attr:`col_offset` and :attr:`end_col_offset` are the "

"corresponding UTF-8 byte offsets of the first and last tokens that generated "

"the node. The UTF-8 offset is recorded because the parser uses UTF-8 "

"internally."

msgstr ""

"Las instancias de las subclases :class:`ast.expr` y :class:`ast.stmt` tienen "

"atributos :attr:`lineno`, :attr:`col_offset`, :attr:`lineno`, y :attr:"

"`col_offset`. :attr:`lineno` y :attr:`end_lineno` son los números de la "

"primera y última línea del intervalo de texto de origen (1 indexado, por lo "

"que la primera línea es la línea 1), y :attr:`col_offset` y :attr:"

"`end_col_offset` son las correspondientes compensaciones de bytes UTF-8 del "

"primer y último token que generó el nodo. El desplazamiento UTF-8 se "

"registra porque el analizador utiliza UTF-8 internamente."

#: ../Doc/library/ast.rst:103

msgid ""

"Note that the end positions are not required by the compiler and are "

"therefore optional. The end offset is *after* the last symbol, for example "

"one can get the source segment of a one-line expression node using "

"``source_line[node.col_offset : node.end_col_offset]``."

msgstr ""

"Tenga en cuenta que el compilador no requiere las posiciones finales y, por "

"lo tanto, son opcionales. El desplazamiento final es *después* del último "

"símbolo, por ejemplo, uno puede obtener el segmento fuente de un nodo de "

"expresión de una línea usando ``source_line[node.col_offset: node."

"end_col_offset]``."

#: ../Doc/library/ast.rst:108

msgid ""

"The constructor of a class :class:`ast.T` parses its arguments as follows:"

msgstr ""

"El constructor de una clase :class:`ast.T` analiza sus argumentos de la "

"siguiente manera:"

#: ../Doc/library/ast.rst:110

msgid ""

"If there are positional arguments, there must be as many as there are items "

"in :attr:`T._fields`; they will be assigned as attributes of these names."

msgstr ""

"Si hay argumentos posicionales, debe haber tantos como elementos en :attr:`T."

"_fields`; serán asignados como atributos de estos nombres."

#: ../Doc/library/ast.rst:112

msgid ""

"If there are keyword arguments, they will set the attributes of the same "

"names to the given values."

msgstr ""

"Si hay argumentos de palabras clave, establecerán los atributos de los "

"mismos nombres a los valores dados."

#: ../Doc/library/ast.rst:115

msgid ""

"For example, to create and populate an :class:`ast.UnaryOp` node, you could "

"use ::"

msgstr ""

"Por ejemplo, para crear y completar un nodo :class:`ast.UnaryOp`, puede "

"usar ::"

#: ../Doc/library/ast.rst:118

msgid ""

"node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),\n"

" lineno=0, col_offset=0)"

msgstr ""

#: ../Doc/library/ast.rst:121

msgid ""

"If a field that is optional in the grammar is omitted from the constructor, "

"it defaults to ``None``. If a list field is omitted, it defaults to the "

"empty list. If a field of type :class:`!ast.expr_context` is omitted, it "

"defaults to :class:`Load() <ast.Load>`. If any other field is omitted, a :"

"exc:`DeprecationWarning` is raised and the AST node will not have this "

"field. In Python 3.15, this condition will raise an error."

msgstr ""

#: ../Doc/library/ast.rst:130

msgid "Class :class:`ast.Constant` is now used for all constants."

msgstr "La clase :class:`ast.Constant` ahora se usa para todas las constantes."

#: ../Doc/library/ast.rst:134

msgid ""

"Simple indices are represented by their value, extended slices are "

"represented as tuples."

msgstr ""

"Los índices simples se representan por su valor, los segmentos extendidos se "

"representan como tuplas."

#: ../Doc/library/ast.rst:139

#, fuzzy

msgid ""

"Old classes :class:`!ast.Num`, :class:`!ast.Str`, :class:`!ast.Bytes`, :"

"class:`!ast.NameConstant` and :class:`!ast.Ellipsis` are still available, "

"but they will be removed in future Python releases. In the meantime, "

"instantiating them will return an instance of a different class."

msgstr ""

"Las clases antiguas :class:`ast. Num`, :class:`ast. Str`, :class:`ast. "

"Bytes`, :class:`ast. NameConstant` y :class:`ast.Ellipsis` todavía están "

"disponibles, pero se eliminarán en futuras versiones de Python. Mientras "

"tanto, crear sus instancias retornará una instancia de una clase diferente."

#: ../Doc/library/ast.rst:146

#, fuzzy

msgid ""

"Old classes :class:`!ast.Index` and :class:`!ast.ExtSlice` are still "

"available, but they will be removed in future Python releases. In the "

"meantime, instantiating them will return an instance of a different class."

msgstr ""

"Las clases antiguas :class:`ast.Index` y :class:`ast.ExtSlice` todavía están "

"disponibles, pero se eliminarán en futuras versiones de Python. Mientras "

"tanto, crear sus instancias retornará una instancia de una clase diferente."

#: ../Doc/library/ast.rst:153

msgid ""

"Previous versions of Python allowed the creation of AST nodes that were "

"missing required fields. Similarly, AST node constructors allowed arbitrary "

"keyword arguments that were set as attributes of the AST node, even if they "

"did not match any of the fields of the AST node. This behavior is deprecated "

"and will be removed in Python 3.15."

msgstr ""

#: ../Doc/library/ast.rst:160

msgid ""

"The descriptions of the specific node classes displayed here were initially "

"adapted from the fantastic `Green Tree Snakes <https://greentreesnakes."

"readthedocs.io/en/latest/>`__ project and all its contributors."

msgstr ""

"Las descripciones de las clases de nodo específicas mostradas aquí fueron "

"adaptadas inicialmente del fantástico proyecto `Green Tree Snakes <https://"

"greentreesnakes.readthedocs.io/en/latest/>`__ y todos sus contribuidores."

#: ../Doc/library/ast.rst:169

msgid "Root nodes"

msgstr "Nodos raíz"

#: ../Doc/library/ast.rst:173

msgid ""

"A Python module, as with :ref:`file input <file-input>`. Node type generated "

"by :func:`ast.parse` in the default ``\"exec\"`` *mode*."

msgstr ""

"Un módulo de Python, como con :ref:`archivo-entrada <file-input>`. Tipo de "

"nodo generado por :func:`ast.parse` en el modo por defecto ``\"exec\"`` "

"*mode*.*mode*."

#: ../Doc/library/ast.rst:176

#, fuzzy

msgid "``body`` is a :class:`list` of the module's :ref:`ast-statements`."

msgstr "*body* es una :class:`list` de las :ref:`ast-statements` del módulo."

#: ../Doc/library/ast.rst:178

#, fuzzy

msgid ""

"``type_ignores`` is a :class:`list` of the module's type ignore comments; "

"see :func:`ast.parse` for more details."

msgstr ""

"*type_ignores* es una :class:`list` de los comentarios para ignorar tipos "

"del módulo; véase :func:`ast.parse` para más detalles."

#: ../Doc/library/ast.rst:181

msgid ""

">>> print(ast.dump(ast.parse('x = 1'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1))])"

msgstr ""

#: ../Doc/library/ast.rst:194

msgid ""

"A single Python :ref:`expression input <expression-input>`. Node type "

"generated by :func:`ast.parse` when *mode* is ``\"eval\"``."

msgstr ""

"Una única :ref:`expression input <expression-input>` de Python. Tipo de nodo "

"generado por :func:`ast.parse` cuando *mode* es ``\"eval\"``."

#: ../Doc/library/ast.rst:197

#, fuzzy

msgid ""

"``body`` is a single node, one of the :ref:`expression types <ast-"

"expressions>`."

msgstr ""

"*body* es un único nodo, uno de los :ref:`tipos de expresión <ast-"

"expressions>`."

#: ../Doc/library/ast.rst:200 ../Doc/library/ast.rst:270

msgid ""

">>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Constant(value=123))"

msgstr ""

#: ../Doc/library/ast.rst:209

msgid ""

"A single :ref:`interactive input <interactive>`, like in :ref:`tut-interac`. "

"Node type generated by :func:`ast.parse` when *mode* is ``\"single\"``."

msgstr ""

"Una única :ref:`entrada interactiva <interactive>`, como en :ref:`tut-"

"interac`. Tipo de nodo generado por :func:`ast.parse` cuando *mode* es "

"``\"single\"``."

#: ../Doc/library/ast.rst:212

#, fuzzy

msgid "``body`` is a :class:`list` of :ref:`statement nodes <ast-statements>`."

msgstr ""

"*body* es una :class:`list` de :ref:`nodos de declaración <ast-statements>`."

#: ../Doc/library/ast.rst:214

msgid ""

">>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))\n"

"Interactive(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1)),\n"

" Assign(\n"

" targets=[\n"

" Name(id='y', ctx=Store())],\n"

" value=Constant(value=2))])"

msgstr ""

#: ../Doc/library/ast.rst:231

msgid ""

"A representation of an old-style type comments for functions, as Python "

"versions prior to 3.5 didn't support :pep:`484` annotations. Node type "

"generated by :func:`ast.parse` when *mode* is ``\"func_type\"``."

msgstr ""

"Una interpretación de un comentario de tipo de estilo antiguo para "

"funciones, ya que las versiones de Python anteriores a la 3.5 no soportaban "

"anotaciones :pep:`484`. Tipo de nodo generado por :func:`ast.parse` cuando "

"*mode* es ``\"func_type\"``."

#: ../Doc/library/ast.rst:235

msgid "Such type comments would look like this::"

msgstr "Los comentarios de este tipo tendrían el siguiente aspecto::"

#: ../Doc/library/ast.rst:237

msgid ""

"def sum_two_number(a, b):\n"

" # type: (int, int) -> int\n"

" return a + b"

msgstr ""

#: ../Doc/library/ast.rst:241

#, fuzzy

msgid ""

"``argtypes`` is a :class:`list` of :ref:`expression nodes <ast-expressions>`."

msgstr ""

"*argtypes* es una :class:`list` de :ref:`nodos de expresión <ast-"

"expressions>`."

#: ../Doc/library/ast.rst:243

#, fuzzy

msgid "``returns`` is a single :ref:`expression node <ast-expressions>`."

msgstr "*returns* es un único :ref:`nodo de expresión <ast-expressions>`."

#: ../Doc/library/ast.rst:245

msgid ""

">>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), "

"indent=4))\n"

"FunctionType(\n"

" argtypes=[\n"

" Name(id='int', ctx=Load()),\n"

" Name(id='str', ctx=Load())],\n"

" returns=Subscript(\n"

" value=Name(id='List', ctx=Load()),\n"

" slice=Name(id='int', ctx=Load()),\n"

" ctx=Load()))"

msgstr ""

#: ../Doc/library/ast.rst:261

msgid "Literals"

msgstr "Literales"

#: ../Doc/library/ast.rst:265

msgid ""

"A constant value. The ``value`` attribute of the ``Constant`` literal "

"contains the Python object it represents. The values represented can be "

"simple types such as a number, string or ``None``, but also immutable "

"container types (tuples and frozensets) if all of their elements are "

"constant."

msgstr ""

"Un valor constante. El atributo ``value`` del literal ``Constant`` contiene "

"el objeto de Python que este representa. Los valores representados pueden "

"ser de tipos simple como un número, una cadena de caracteres o ``None``; "

"pero también pueden ser de tipos de contenedores inmutables (tuplas y "

"``frozensets``) si todos sus elementos son constantes."

#: ../Doc/library/ast.rst:279

msgid ""

"Node representing a single formatting field in an f-string. If the string "

"contains a single formatting field and nothing else the node can be isolated "

"otherwise it appears in :class:`JoinedStr`."

msgstr ""

"Nodo que representa un único campo de formato en una ``f-string``. Si la "

"cadena de caracteres contiene un único campo de formato y nada más, el nodo "

"puede estar aislado de otra manera aparece en :class:`JoinedStr`."

#: ../Doc/library/ast.rst:283

msgid ""

"``value`` is any expression node (such as a literal, a variable, or a "

"function call)."

msgstr ""

"``value`` es cualquier nodo de expresión (como un literal, una variable o "

"una llamada a función)."

#: ../Doc/library/ast.rst:285

msgid "``conversion`` is an integer:"

msgstr "``conversion`` es un entero:"

#: ../Doc/library/ast.rst:287

msgid "-1: no formatting"

msgstr "-1: sin formato"

#: ../Doc/library/ast.rst:288

msgid "115: ``!s`` string formatting"

msgstr "115: ``!s`` formato de cadena de caracteres"

#: ../Doc/library/ast.rst:289

msgid "114: ``!r`` repr formatting"

msgstr "114: ``!r`` formato repr"

#: ../Doc/library/ast.rst:290

msgid "97: ``!a`` ascii formatting"

msgstr "97: ``!a`` formato ascii"

#: ../Doc/library/ast.rst:292

msgid ""

"``format_spec`` is a :class:`JoinedStr` node representing the formatting of "

"the value, or ``None`` if no format was specified. Both ``conversion`` and "

"``format_spec`` can be set at the same time."

msgstr ""

"``format_spec`` es un nodo :class:`JoinedStr` que representa el formato del "

"valor, o ``None`` si no se ha especificado un formato. Ambos, ``conversion`` "

"y ``format_spec``, pueden estar especificados al mismo tiempo."

#: ../Doc/library/ast.rst:299

msgid ""

"An f-string, comprising a series of :class:`FormattedValue` and :class:"

"`Constant` nodes."

msgstr ""

"Un f-string que comprende una serie de nodos :class:`FormattedValue` y :"

"class:`Constant`."

#: ../Doc/library/ast.rst:302

msgid ""

">>> print(ast.dump(ast.parse('f\"sin({a}) is {sin(a):.3}\"', mode='eval'), "

"indent=4))\n"

"Expression(\n"

" body=JoinedStr(\n"

" values=[\n"

" Constant(value='sin('),\n"

" FormattedValue(\n"

" value=Name(id='a', ctx=Load()),\n"

" conversion=-1),\n"

" Constant(value=') is '),\n"

" FormattedValue(\n"

" value=Call(\n"

" func=Name(id='sin', ctx=Load()),\n"

" args=[\n"

" Name(id='a', ctx=Load())]),\n"

" conversion=-1,\n"

" format_spec=JoinedStr(\n"

" values=[\n"

" Constant(value='.3')]))]))"

msgstr ""

#: ../Doc/library/ast.rst:327

msgid ""

"A list or tuple. ``elts`` holds a list of nodes representing the elements. "

"``ctx`` is :class:`Store` if the container is an assignment target (i.e. "

"``(x,y)=something``), and :class:`Load` otherwise."

msgstr ""

"Una lista o tupla. ``elts`` contiene una lista de nodos que representa a los "

"elementos. ``ctx`` es :class:`Store` si el contenedor es un objetivo de "

"asignación (por ejemplo ``(x,y)=something``), y :class:`Load` en cualquier "

"otro caso."

#: ../Doc/library/ast.rst:331

msgid ""

">>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))\n"

"Expression(\n"

" body=List(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))\n"

">>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Tuple(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))"

msgstr ""

#: ../Doc/library/ast.rst:353

msgid "A set. ``elts`` holds a list of nodes representing the set's elements."

msgstr ""

"Un set. ``elts`` contiene una lista de nodos que representa a un set de "

"elementos."

#: ../Doc/library/ast.rst:355

msgid ""

">>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Set(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)]))"

msgstr ""

#: ../Doc/library/ast.rst:368

msgid ""

"A dictionary. ``keys`` and ``values`` hold lists of nodes representing the "

"keys and the values respectively, in matching order (what would be returned "

"when calling :code:`dictionary.keys()` and :code:`dictionary.values()`)."

msgstr ""

"Un diccionario. ``keys`` y ``values`` contienen listas de nodos que "

"representan las claves y los valores respectivamente en el orden "

"correspondiente (el orden que retornaría :code:`dictionary.keys()` y :code:"

"`dictionary.values()`)."

#: ../Doc/library/ast.rst:372

msgid ""

"When doing dictionary unpacking using dictionary literals the expression to "

"be expanded goes in the ``values`` list, with a ``None`` at the "

"corresponding position in ``keys``."

msgstr ""

"Cuando se desempaqueta un diccionario utilizando literales de diccionario, "

"la expresión a ser expandida va en la lista ``values``, con ``None`` en la "

"posición correspondiente en ``keys``."

#: ../Doc/library/ast.rst:376

msgid ""

">>> print(ast.dump(ast.parse('{\"a\":1, **d}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Dict(\n"

" keys=[\n"

" Constant(value='a'),\n"

" None],\n"

" values=[\n"

" Constant(value=1),\n"

" Name(id='d', ctx=Load())]))"

msgstr ""

#: ../Doc/library/ast.rst:390

msgid "Variables"

msgstr "Variables"

#: ../Doc/library/ast.rst:394

msgid ""

"A variable name. ``id`` holds the name as a string, and ``ctx`` is one of "

"the following types."

msgstr ""

"Un nombre de variable. ``id`` contiene el nombre de una cadena de caracteres "

"y ``ctx`` es uno de los siguientes tipos."

#: ../Doc/library/ast.rst:402

msgid ""

"Variable references can be used to load the value of a variable, to assign a "

"new value to it, or to delete it. Variable references are given a context to "

"distinguish these cases."

msgstr ""

"Referencias a variables que pueden ser usadas para cargar el valor de una "

"variable, asignar un nuevo valor o borrarlo. Las referencias a variables "

"reciben un contexto para distinguir entre estos casos."

#: ../Doc/library/ast.rst:406

msgid ""

">>> print(ast.dump(ast.parse('a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Expr(\n"

" value=Name(id='a', ctx=Load()))])\n"

"\n"

">>> print(ast.dump(ast.parse('a = 1'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='a', ctx=Store())],\n"

" value=Constant(value=1))])\n"

"\n"

">>> print(ast.dump(ast.parse('del a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Delete(\n"

" targets=[\n"

" Name(id='a', ctx=Del())])])"

msgstr ""

#: ../Doc/library/ast.rst:432

msgid ""

"A ``*var`` variable reference. ``value`` holds the variable, typically a :"

"class:`Name` node. This type must be used when building a :class:`Call` node "

"with ``*args``."

msgstr ""

"Una referencia a variable ``*var``. ``value`` contiene la variable, "

"típicamente un nodo :class:`Name`. Este tipo puede ser usado cuando se "

"construye un nodo :class:`Call` con ``*args``."

#: ../Doc/library/ast.rst:436

msgid ""

">>> print(ast.dump(ast.parse('a, *b = it'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Tuple(\n"

" elts=[\n"

" Name(id='a', ctx=Store()),\n"

" Starred(\n"

" value=Name(id='b', ctx=Store()),\n"

" ctx=Store())],\n"

" ctx=Store())],\n"

" value=Name(id='it', ctx=Load()))])"

msgstr ""

#: ../Doc/library/ast.rst:456

msgid "Expressions"

msgstr "Expresiones"

#: ../Doc/library/ast.rst:460

msgid ""

"When an expression, such as a function call, appears as a statement by "

"itself with its return value not used or stored, it is wrapped in this "

"container. ``value`` holds one of the other nodes in this section, a :class:"

"`Constant`, a :class:`Name`, a :class:`Lambda`, a :class:`Yield` or :class:"

"`YieldFrom` node."

msgstr ""

"Cuando una expresión, como un llamado a función, aparece como una "

"declaración por sí misma sin que su valor de retorno se use o se almacene, "

"está dentro de este contenedor. ``value`` contiene uno de los otros nodos en "

"esta sección, un nodo :class:`Constant`, :class:`Name`, :class:`Lambda`, :"

"class:`Yield` o :class:`YieldFrom`."

#: ../Doc/library/ast.rst:465

msgid ""

">>> print(ast.dump(ast.parse('-a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Expr(\n"

" value=UnaryOp(\n"

" op=USub(),\n"

" operand=Name(id='a', ctx=Load())))])"

msgstr ""

#: ../Doc/library/ast.rst:478

msgid ""

"A unary operation. ``op`` is the operator, and ``operand`` any expression "

"node."

msgstr ""

"Una operación unaria. ``op`` es el operador y ``operand`` es cualquier nodo "

"de expresión."

#: ../Doc/library/ast.rst:487

msgid ""

"Unary operator tokens. :class:`Not` is the ``not`` keyword, :class:`Invert` "

"is the ``~`` operator."

msgstr ""

"Tokens de operador unario. :class:`Not` es la palabra clave ``not``, :class:"

"`Invert` es el operador ``~``."

#: ../Doc/library/ast.rst:490

msgid ""

">>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))\n"

"Expression(\n"

" body=UnaryOp(\n"

" op=Not(),\n"

" operand=Name(id='x', ctx=Load())))"

msgstr ""

#: ../Doc/library/ast.rst:501

msgid ""

"A binary operation (like addition or division). ``op`` is the operator, and "

"``left`` and ``right`` are any expression nodes."

msgstr ""

"Una operación binaria (como la suma o división(. ``op`` es el operador, y "

"``left`` y ``right`` son cualquier nodo de expresión."

#: ../Doc/library/ast.rst:504

msgid ""

">>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BinOp(\n"

" left=Name(id='x', ctx=Load()),\n"

" op=Add(),\n"

" right=Name(id='y', ctx=Load())))"

msgstr ""

#: ../Doc/library/ast.rst:528

msgid "Binary operator tokens."

msgstr "Tokens de operador binario."

#: ../Doc/library/ast.rst:533

msgid ""

"A boolean operation, 'or' or 'and'. ``op`` is :class:`Or` or :class:`And`. "

"``values`` are the values involved. Consecutive operations with the same "

"operator, such as ``a or b or c``, are collapsed into one node with several "

"values."

msgstr ""

"Una operación booleana, 'or' y 'and'. ``op`` es :class:`Or` o :class:`And`. "

"``values`` son los valores involucrados. Operaciones consecutivas con el "

"mismo operador, como ``a or b or c``, colapsan en un nodo con varios valores."

#: ../Doc/library/ast.rst:538

msgid "This doesn't include ``not``, which is a :class:`UnaryOp`."

msgstr "Esto no incluye ``not``, el cual es un :class:`UnaryOp`."

#: ../Doc/library/ast.rst:540

msgid ""

">>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BoolOp(\n"

" op=Or(),\n"

" values=[\n"

" Name(id='x', ctx=Load()),\n"

" Name(id='y', ctx=Load())]))"

msgstr ""

#: ../Doc/library/ast.rst:554

msgid "Boolean operator tokens."

msgstr "Tokens de operador booleano."

#: ../Doc/library/ast.rst:559

msgid ""

"A comparison of two or more values. ``left`` is the first value in the "

"comparison, ``ops`` the list of operators, and ``comparators`` the list of "

"values after the first element in the comparison."

msgstr ""

"Una comparación de dos o más valores. ``left`` es el primer valor en la "

"comparación, ``ops`` es la lista de operadores, y ``comparators`` es la "

"lista de valores después de el primer elemento en la comparación."

#: ../Doc/library/ast.rst:563

msgid ""

">>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Compare(\n"

" left=Constant(value=1),\n"

" ops=[\n"

" LtE(),\n"

" Lt()],\n"

" comparators=[\n"

" Name(id='a', ctx=Load()),\n"

" Constant(value=10)]))"

msgstr ""

#: ../Doc/library/ast.rst:588

msgid "Comparison operator tokens."

msgstr "Tokens de operador de comparación."

#: ../Doc/library/ast.rst:593

msgid ""

"A function call. ``func`` is the function, which will often be a :class:"

"`Name` or :class:`Attribute` object. Of the arguments:"

msgstr ""

"Un llamado a función. ``func`` is la función, la cual suele ser un objeto :"

"class:`Name` o :class:`Attribute`. De los argumentos:"

#: ../Doc/library/ast.rst:596

msgid "``args`` holds a list of the arguments passed by position."

msgstr "``args`` contiene una lista de argumentos pasados por posición."

#: ../Doc/library/ast.rst:597

msgid ""