# 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: 2020-05-05 12:54+0200\n"
"PO-Revision-Date: 2020-05-09 13:56+0200\n"
"Last-Translator: \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.8.0\n"
"X-Generator: Poedit 2.3\n"
#: ../Doc/tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr "Una introduccin informal a Python"
#: ../Doc/tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
"En los siguientes ejemplos, la entrada y la salida se distinguen por la "
"presencia o ausencia de prompts (:term:`>>>` y :term:`...`): para repetir el "
"ejemplo, escribe todo despus del prompt, cuando aparece; las lneas que no "
"comienzan con un prompt son emitidas desde el intrprete. Ten en cuenta que "
"un prompt secundario solo en una linea de ejemplo significa que debes "
"escribir una lnea en blanco. Esto se utiliza para finalizar un comando "
"multilnea."
#: ../Doc/tutorial/introduction.rst:16
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments. Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line. A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal. A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
"Muchos de los ejemplos de este manual, incluso aquellos ingresados en el "
"prompt interactivo, incluyen comentarios. Los comentarios en Python "
"comienzan con el carcter numeral, ``#``, y se extienden hasta el final "
"visible de la lnea. Un comentario quizs aparezca al comienzo de la lnea o "
"seguido de espacios en blanco o cdigo, pero no dentro de una cadena de "
"caracteres. Un carcter numeral dentro de una cadena de caracteres es slo "
"un carcter numeral. Ya que los comentarios son para aclarar cdigo y no son "
"interpretados por Python, pueden omitirse cuando se escriben los ejemplos."
#: ../Doc/tutorial/introduction.rst:24
msgid "Some examples::"
msgstr "Algunos ejemplos::"
#: ../Doc/tutorial/introduction.rst:35
msgid "Using Python as a Calculator"
msgstr "Usando Python como una calculadora"
#: ../Doc/tutorial/introduction.rst:37
msgid ""
"Let's try some simple Python commands. Start the interpreter and wait for "
"the primary prompt, ``>>>``. (It shouldn't take long.)"
msgstr ""
"Probemos algunos comandos simples de Python. Inicia el intrprete y espere "
"el prompt primario, ``>>>``. (No debera tardar mucho.)"
#: ../Doc/tutorial/introduction.rst:44
msgid "Numbers"
msgstr "Nmeros"
#: ../Doc/tutorial/introduction.rst:46
msgid ""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value. Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
"El intrprete puede utilizarse como una simple calculadora; puedes "
"introducir una expresin y este escribir los valores. La sintaxis es "
"sencilla: los operadores ``+``, ``-``, ``*`` y ``/``funcionan como en la "
"mayora de los lenguajes (por ejemplo, Pascal o C); los parntesis (``()``) "
"pueden ser usados para agrupar. Por ejemplo::"
#: ../Doc/tutorial/introduction.rst:61
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
"`float`. We will see more about numeric types later in the tutorial."
msgstr ""
"Los nmeros enteros (ej. ``2``, ``4``, ``20``) tienen tipo :class:`int`, los "
"que tienen una parte fraccionaria (por ejemplo ``5.0``, ``1.6``) tiene el "
"tipo :class:`float`. Vamos a ver ms acerca de los tipos numricos ms "
"adelante en el tutorial."
#: ../Doc/tutorial/introduction.rst:65
msgid ""
"Division (``/``) always returns a float. To do :term:`floor division` and "
"get an integer result (discarding any fractional result) you can use the ``//"
"`` operator; to calculate the remainder you can use ``%``::"
msgstr ""
"La divisin (``/``) siempre retorna un punto flotante. Para hacer :term:"
"`floor division` y obtener un resultado entero (descartando cualquier "
"resultado fraccionario) puede usarse el operador ``//``; para calcular el "
"resto puedes usar ``%``::"
#: ../Doc/tutorial/introduction.rst:79
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr ""
"Con Python, es posible usar el operador ``**`` para calcular potencias [#]_::"
#: ../Doc/tutorial/introduction.rst:86
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
"El signo igual (``=``) se usa para asignar un valor a una variable. Ningn "
"resultado se mostrar antes del siguiente prompt interactivo::"
#: ../Doc/tutorial/introduction.rst:94
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
"Si una variable no est \"definida\" (no se le ha asignado un valor), al "
"intentar usarla dar un error::"
#: ../Doc/tutorial/introduction.rst:102
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
"Hay soporte completo de punto flotante; operadores con operando mezclados "
"convertirn los enteros a punto flotante::"
#: ../Doc/tutorial/introduction.rst:108
msgid ""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``. This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
"En el modo interactivo, la ltima expresin impresa se asigna a la variable "
"``_``. Esto significa que cuando se est utilizando Python como "
"calculadora, es ms fcil seguir calculando, por ejemplo::"
#: ../Doc/tutorial/introduction.rst:121
msgid ""
"This variable should be treated as read-only by the user. Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
"Esta variable debe ser tratada como de slo lectura por el usuario. No le "
"asignes explcitamente un valor; crears una variable local independiente "
"con el mismo nombre enmascarando la variable con el comportamiento mgico."
#: ../Doc/tutorial/introduction.rst:125
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
"Fraction`. Python also has built-in support for :ref:`complex numbers "
"`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr ""
"Adems de :class:`int` y :class:`float`, Python admite otros tipos de "
"nmeros, como :class:`~decimal.Decimal` y :class:`~fractions.Fraction`. "
"Python tambin tiene soporte incorporado para :ref:`complex numbers "
"`, y usa el sufijo ``j`` o ``J`` para indicar la parte "
"imaginaria (por ejemplo, ``3+5j``)."
#: ../Doc/tutorial/introduction.rst:135
msgid "Strings"
msgstr "Cadenas de caracteres"
#: ../Doc/tutorial/introduction.rst:137
msgid ""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways. They can be enclosed in single quotes (``'...'``) or "
"double quotes (``\"...\"``) with the same result [#]_. ``\\`` can be used "
"to escape quotes::"
msgstr ""
"Adems de nmeros, Python puede manipular cadenas de texto, las cuales "
"pueden ser expresadas de distintas formas. Pueden estar encerradas en "
"comillas simples (``'...'``) o dobles (``\"...\"``) con el mismo resultado "
"[#]_. ``\\`` puede ser usado para escapar comillas::"
#: ../Doc/tutorial/introduction.rst:155
msgid ""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes. While this might sometimes "
"look different from the input (the enclosing quotes could change), the two "
"strings are equivalent. The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes. The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
"En el intrprete interactivo, la salida de caracteres est encerrada en "
"comillas y los caracteres especiales se escapan con barras invertidas. "
"Aunque esto a veces se vea diferente de la entrada (las comillas que "
"encierran pueden cambiar), las dos cadenas son equivalentes. La cadena se "
"encierra en comillas dobles si la cadena contiene una comilla simple y "
"ninguna doble, de lo contrario es encerrada en comillas simples. La funcin :"
"func:`print` produce una salida ms legible, omitiendo las comillas que la "
"encierran e imprimiendo caracteres especiales y escapados::"
#: ../Doc/tutorial/introduction.rst:175
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"Si no quieres que los caracteres precedidos por ``\\`` se interpreten como "
"caracteres especiales, puedes usar *cadenas sin formato* agregando una ``r`` "
"antes de la primera comilla::"
#: ../Doc/tutorial/introduction.rst:185
msgid ""
"String literals can span multiple lines. One way is using triple-quotes: ``"
"\"\"\"...\"\"\"`` or ``'''...'''``. End of lines are automatically included "
"in the string, but it's possible to prevent this by adding a ``\\`` at the "
"end of the line. The following example::"
msgstr ""
"Las cadenas de texto literales pueden contener mltiples lneas. Una forma "
"es usar triples comillas: ``\"\"\"...\"\"\"`` o ``'''...'''``. Los fin de "
"lnea son incluidos automticamente, pero es posible prevenir esto agregando "
"una ``\\`` al final de la lnea. Por ejemplo:"
#: ../Doc/tutorial/introduction.rst:196
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
"produce la siguiente salida (tened en cuenta que la lnea inicial no est "
"incluida):"
#: ../Doc/tutorial/introduction.rst:204
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
"Las cadenas se pueden concatenar (pegar juntas) con el operador ``+`` y se "
"pueden repetir con ``*``::"
#: ../Doc/tutorial/introduction.rst:211
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
"Dos o ms *cadenas literales* (es decir, las encerradas entre comillas) una "
"al lado de la otra se concatenan automticamente. ::"
#: ../Doc/tutorial/introduction.rst:217
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr ""
"Esta caracterstica es particularmente til cuando quieres dividir cadenas "
"largas::"
#: ../Doc/tutorial/introduction.rst:224
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr ""
"Esto solo funciona con dos literales, no con variables ni expresiones::"
#: ../Doc/tutorial/introduction.rst:238
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr ""
"Si quieres concatenar variables o una variable y un literal, usa ``+``::"
#: ../Doc/tutorial/introduction.rst:243
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
"Las cadenas de texto se pueden *indexar* (subndices), el primer carcter de "
"la cadena tiene el ndice 0. No hay un tipo de dato diferente para los "
"caracteres; un carcter es simplemente una cadena de longitud uno::"
#: ../Doc/tutorial/introduction.rst:253
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"Los ndices quizs sean nmeros negativos, para empezar a contar desde la "
"derecha::"
#: ../Doc/tutorial/introduction.rst:262
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr ""
"Nota que -0 es lo mismo que 0, los ndice negativos comienzan desde -1."
#: ../Doc/tutorial/introduction.rst:264
msgid ""
"In addition to indexing, *slicing* is also supported. While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
"Adems de los ndices, las *rebanadas* tambin estn soportadas. Mientras "
"que los ndices se utilizar para obtener caracteres individuales, las "
"*rebanadas* te permiten obtener partes de las cadenas de texto::"
#: ../Doc/tutorial/introduction.rst:272
msgid ""
"Note how the start is always included, and the end always excluded. This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
"Nota cmo el inicio siempre se incluye y el final siempre se excluye. Esto "
"asegura que ``s[:i] + s[i:]`` siempre sea igual a ``s``::"
#: ../Doc/tutorial/introduction.rst:280
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"Los ndices de las rebanadas tienen valores por defecto tiles; el valor por "
"defecto para el primer ndice es cero, el valor por defecto para el segundo "
"ndice es la longitud de la cadena a rebanar. ::"
#: ../Doc/tutorial/introduction.rst:290
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
"Una forma de recordar cmo funcionan las rebanadas es pensar que los ndices "
"apuntan *entre* caracteres, con el borde izquierdo del primer carcter "
"numerado 0. Luego, el punto derecho del ltimo carcter de una cadena de *n* "
"caracteres tiene un ndice *n*, por ejemplo ::"
#: ../Doc/tutorial/introduction.rst:301
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
"La primera fila de nmeros da la posicin de los ndices 0...6 en la cadena; "
"La segunda fila da los correspondientes indices negativos. La rebanada desde "
"*i* hasta *j* consta de todos los caracteres entre los bordes etiquetados "
"*i* y *j*, respectivamente."
#: ../Doc/tutorial/introduction.rst:306
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds. For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
"Para ndices no negativos, la longitud de la rebanada es la diferencia de "
"los ndices, si ambos estn dentro de los lmites. Por ejemplo, la longitud "
"de ``word[1:3]`` es 2."
#: ../Doc/tutorial/introduction.rst:310
msgid "Attempting to use an index that is too large will result in an error::"
msgstr "Intentar usar un ndice que es muy grande resultar en un error::"
#: ../Doc/tutorial/introduction.rst:317
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
"Sin embargo, los ndices de rebanadas fuera de rango se manejan "
"satisfactoriamente cuando se usan para rebanar::"
#: ../Doc/tutorial/introduction.rst:325
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"Las cadenas de Python no se pueden modificar, son :term:`immutable`. Por "
"eso, asignar a una posicin indexada de la cadena resulta en un error:"
#: ../Doc/tutorial/introduction.rst:337
msgid "If you need a different string, you should create a new one::"
msgstr "Si necesitas una cadena diferente, deberas crear una nueva::"
#: ../Doc/tutorial/introduction.rst:344
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr "La funcin incorporada :func:`len` retorna la longitud de una cadena::"
#: ../Doc/tutorial/introduction.rst:355
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"
#: ../Doc/tutorial/introduction.rst:354
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
"Las cadenas de texto son ejemplos de *tipos secuencias* y soportan las "
"operaciones comunes para esos tipos."
#: ../Doc/tutorial/introduction.rst:359
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"
#: ../Doc/tutorial/introduction.rst:358
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
"Las cadenas de texto soportan una gran cantidad de mtodos para "
"transformaciones bsicas y bsqueda."
#: ../Doc/tutorial/introduction.rst:362
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"
#: ../Doc/tutorial/introduction.rst:362
msgid "String literals that have embedded expressions."
msgstr "Literales de cadena que tienen expresiones embebidas."
#: ../Doc/tutorial/introduction.rst:365
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"
#: ../Doc/tutorial/introduction.rst:365
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
"Aqu se da informacin sobre formateo de cadenas de texto con :meth:`str."
"format`."
#: ../Doc/tutorial/introduction.rst:368
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"
#: ../Doc/tutorial/introduction.rst:368
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
"Aqu se describen con ms detalle las antiguas operaciones para formateo "
"utilizadas cuando una cadena de texto est a la izquierda del operador ``%``."
#: ../Doc/tutorial/introduction.rst:375
msgid "Lists"
msgstr "Listas"
#: ../Doc/tutorial/introduction.rst:377
msgid ""
"Python knows a number of *compound* data types, used to group together other "
"values. The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets. Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
"Python tiene varios tipos de datos *compuestos*, utilizados para agrupar "
"otros valores. El ms verstil es la *lista*, la cual puede ser escrita como "
"una lista de valores separados por coma (tems) entre corchetes. Las listas "
"pueden contener tems de diferentes tipos, pero usualmente los tems son del "
"mismo tipo. ::"
#: ../Doc/tutorial/introduction.rst:386
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
"Al igual que las cadenas (y todas las dems tipos integrados :term:"
"`sequence`), las listas se pueden indexar y segmentar:"
#: ../Doc/tutorial/introduction.rst:396
msgid ""
"All slice operations return a new list containing the requested elements. "
"This means that the following slice returns a :ref:`shallow copy "
"` of the list::"
msgstr ""
"Todas las operaciones de rebanado retornan una nueva lista que contiene los "
"elementos pedidos. Esto significa que la siguiente rebanada retorna una :ref:"
"`shallow copy ` de la lista::"
#: ../Doc/tutorial/introduction.rst:403
msgid "Lists also support operations like concatenation::"
msgstr "Las listas tambin admiten operaciones como concatenacin::"
#: ../Doc/tutorial/introduction.rst:408
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
"A diferencia de las cadenas, que son :term:`immutable`, las listas son de "
"tipo :term:`mutable`, es decir, es posible cambiar su contenido::"
#: ../Doc/tutorial/introduction.rst:418
msgid ""
"You can also add new items at the end of the list, by using the :meth:`~list."
"append` *method* (we will see more about methods later)::"
msgstr ""
"Tambin puede agregar nuevos elementos al final de la lista, utilizando el "
"*mtodo* :meth:`~list.append` (vamos a ver ms sobre los mtodos luego)::"
#: ../Doc/tutorial/introduction.rst:426
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
"Tambin es posible asignar a una rebanada, y esto incluso puede cambiar la "
"longitud de la lista o vaciarla totalmente::"
#: ../Doc/tutorial/introduction.rst:445
msgid "The built-in function :func:`len` also applies to lists::"
msgstr "La funcin predefinida :func:`len` tambin sirve para las listas ::"
#: ../Doc/tutorial/introduction.rst:451
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr ""
"Es posible anidar listas (crear listas que contengan otras listas), por "
"ejemplo::"
#: ../Doc/tutorial/introduction.rst:467
msgid "First Steps Towards Programming"
msgstr "Primeros pasos hacia la programacin"
#: ../Doc/tutorial/introduction.rst:469
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together. For instance, we can write an initial sub-sequence of the "
"`Fibonacci series `_ as "
"follows::"
msgstr ""
"Por supuesto, podemos usar Python para tareas ms complicadas que sumar dos "
"y dos. Por ejemplo, podemos escribir una parte inicial de la serie de "
"Fibonacci `_ as::"
#: ../Doc/tutorial/introduction.rst:489
msgid "This example introduces several new features."
msgstr "Este ejemplo introduce varias caractersticas nuevas."
#: ../Doc/tutorial/introduction.rst:491
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1. On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place. The right-"
"hand side expressions are evaluated from the left to the right."
msgstr ""
"La primera lnea contiene una *asignacin mltiple*: las variables ``a`` y "
"``b`` obtienen simultneamente los nuevos valores 0 y 1. En la ltima lnea "
"esto se usa nuevamente, demostrando que las expresiones de la derecha son "
"evaluadas primero antes de que se realice cualquiera de las asignaciones. "
"Las expresiones del lado derecho se evalan de izquierda a derecha."
#: ../Doc/tutorial/introduction.rst:497
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true. In Python, like in C, any non-zero integer value is "
"true; zero is false. The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false. The test used in the example is a simple comparison. The "
"standard comparison operators are written the same as in C: ```` (greater than), ``==`` (equal to), ``=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
"El bucle :keyword:`while` se ejecuta mientras la condicin (aqu: ``a < "
"10``) sea verdadera. En Python, como en C, cualquier valor entero que no sea "
"cero es verdadero; cero es falso. La condicin tambin puede ser una cadena "
"de texto o una lista, de hecho, cualquier secuencia; cualquier cosa con una "
"longitud distinta de cero es verdadera, las secuencias vacas son falsas. La "
"prueba utilizada en el ejemplo es una comparacin simple. Los operadores de "
"comparacin estndar se escriben igual que en C: ```` "
"(mayor que), ``==`` (igual a), ``=`` (mayor "
"que o igual a) y ``!=`` (distinto a)."
#: ../Doc/tutorial/introduction.rst:506
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements. At the interactive prompt, you have to type a tab or "
"space(s) for each indented line. In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility. When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line). Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
"El cuerpo del bucle est *indentado*: la indentacin es la forma que usa "
"Python para agrupar declaraciones. En el intrprete interactivo debes "
"teclear un tabulador o espacio(s) para cada lnea indentada. En la prctica "
"vas a preparar entradas ms complicadas para Python con un editor de texto; "
"todos los editores de texto modernos tienen la facilidad de agregar la "
"indentacin automticamente. Cuando se ingresa una instruccin compuesta de "
"forma interactiva, se debe finalizar con una lnea en blanco para indicar "
"que est completa (ya que el analizador no puede adivinar cuando tecleaste "
"la ltima lnea). Nota que cada lnea de un bloque bsico debe estar "
"sangrada de la misma forma."
#: ../Doc/tutorial/introduction.rst:515
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating point quantities, and strings. Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
"La funcin :func:`print` escribe el valor de los argumentos que se le dan. "
"Difiere de simplemente escribir la expresin que se quiere mostrar (como "
"hicimos antes en los ejemplos de la calculadora) en la forma en que maneja "
"mltiples argumentos, cantidades de punto flotante y cadenas. Las cadenas de "
"texto son impresas sin comillas y un espacio en blanco se inserta entre los "
"elementos, as puedes formatear cosas de una forma agradable::"
#: ../Doc/tutorial/introduction.rst:526
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
"El parmetro nombrado *end* puede usarse para evitar el salto de linea al "
"final de la salida, o terminar la salida con una cadena diferente:"
#: ../Doc/tutorial/introduction.rst:538
msgid "Footnotes"
msgstr "Notas al pie"
#: ../Doc/tutorial/introduction.rst:539
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
"Debido a que ``**`` tiene una prioridad mayor que ```-``, ``-3**2`` se "
"interpretar como ``-(3**2)``, por lo tanto dar como resultado ``-9``. Para "
"evitar esto y obtener ``9``, puedes usar ``(-3)**2``."
#: ../Doc/tutorial/introduction.rst:543
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"A diferencia de otros lenguajes, caracteres especiales como ``\\n`` tienen "
"el mismo significado con simple(``'...'``) y dobles (``\"...\"``) comillas. "
"La nica diferencia entre las dos es que dentro de las comillas simples no "
"existe la necesidad de escapar ``\"`` (pero tienes que escapar ``\\'``) y "
"viceversa."