inputoutput.po

# 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-18 10:24-0300\n"
"Last-Translator: Carlos A. Crespo <lvccrespo@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/tutorial/inputoutput.rst:5
msgid "Input and Output"
msgstr "Entrada y salida"

#: ../Doc/tutorial/inputoutput.rst:7
msgid ""
"There are several ways to present the output of a program; data can be "
"printed in a human-readable form, or written to a file for future use. This "
"chapter will discuss some of the possibilities."
msgstr ""
"Hay diferentes métodos de presentar la salida de un programa; los datos "
"pueden ser impresos de una forma legible por humanos, o escritos a un "
"archivo para uso futuro. Este capítulo discutirá algunas de las "
"posibilidades."

#: ../Doc/tutorial/inputoutput.rst:15
msgid "Fancier Output Formatting"
msgstr "Formateo elegante de la salida"

#: ../Doc/tutorial/inputoutput.rst:17
msgid ""
"So far we've encountered two ways of writing values: *expression statements* "
"and the :func:`print` function.  (A third way is using the :meth:`~io."
"TextIOBase.write` method of file objects; the standard output file can be "
"referenced as ``sys.stdout``. See the Library Reference for more information "
"on this.)"
msgstr ""
"Hasta ahora encontramos dos maneras de escribir valores: *declaraciones de "
"expresión* y la función :func:`print`. (Una tercera manera es usando el "
"método :meth:`~io.TextIOBase.write` de los objetos tipo archivo; el archivo "
"de salida estándar puede referenciarse como ``sys.stdout``. Mirá la "
"Referencia de la Biblioteca para más información sobre esto)."

#: ../Doc/tutorial/inputoutput.rst:22
msgid ""
"Often you'll want more control over the formatting of your output than "
"simply printing space-separated values. There are several ways to format "
"output."
msgstr ""
"A menudo se querrá tener más control sobre el formato de la salida, y no "
"simplemente imprimir valores separados por espacios. Para ello, hay varias "
"maneras de dar formato a la salida."

#: ../Doc/tutorial/inputoutput.rst:25
msgid ""
"To use :ref:`formatted string literals <tut-f-strings>`, begin a string with "
"``f`` or ``F`` before the opening quotation mark or triple quotation mark. "
"Inside this string, you can write a Python expression between ``{`` and ``}"
"`` characters that can refer to variables or literal values."
msgstr ""
"Para usar :ref:`literales de cadena formateados <tut-f-strings>`, comience "
"una cadena con ``f`` o ``F`` antes de la comilla de apertura o comillas "
"triples. Dentro de esta cadena,  se puede escribir una expresión de Python "
"entre los caracteres ``{`` y ``}`` que pueden hacer referencia a variables o "
"valores literales."

#: ../Doc/tutorial/inputoutput.rst:32
msgid ""
">>> year = 2016\n"
">>> event = 'Referendum'\n"
">>> f'Results of the {year} {event}'\n"
"'Results of the 2016 Referendum'"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:37
#, fuzzy
msgid ""
"The :meth:`str.format` method of strings requires more manual effort.  "
"You'll still use ``{`` and ``}`` to mark where a variable will be "
"substituted and can provide detailed formatting directives, but you'll also "
"need to provide the information to be formatted. In the following code block "
"there are two examples of how to format variables:"
msgstr ""
"El método :meth:`str.format` requiere más esfuerzo manual. Se seguirá usando "
"``{`` y ``}`` para marcar dónde se sustituirá una variable y puede "
"proporcionar directivas de formato detalladas, pero también se debe "
"proporcionar la información de lo que se va a formatear."

#: ../Doc/tutorial/inputoutput.rst:46
msgid ""
">>> yes_votes = 42_572_654\n"
">>> total_votes = 85_705_149\n"
">>> percentage = yes_votes / total_votes\n"
">>> '{:-9} YES votes  {:2.2%}'.format(yes_votes, percentage)\n"
"' 42572654 YES votes  49.67%'"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:52
msgid ""
"Notice how the ``yes_votes`` are padded with spaces and a negative sign only "
"for negative numbers. The example also prints ``percentage`` multiplied by "
"100, with 2 decimal places and followed by a percent sign (see :ref:"
"`formatspec` for details)."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:57
msgid ""
"Finally, you can do all the string handling yourself by using string slicing "
"and concatenation operations to create any layout you can imagine.  The "
"string type has some methods that perform useful operations for padding "
"strings to a given column width."
msgstr ""
"Por último, puede realizar todo el control de cadenas usted mismo mediante "
"operaciones de concatenación y segmentación de cadenas para crear cualquier "
"diseño que se pueda imaginar.  El tipo de cadena tiene algunos métodos que "
"realizan operaciones útiles para rellenar cadenas a un ancho de columna "
"determinado."

#: ../Doc/tutorial/inputoutput.rst:62
msgid ""
"When you don't need fancy output but just want a quick display of some "
"variables for debugging purposes, you can convert any value to a string with "
"the :func:`repr` or :func:`str` functions."
msgstr ""
"Cuando no necesita una salida elegante, pero solo desea una visualización "
"rápida de algunas variables con fines de depuración, puede convertir "
"cualquier valor en una cadena con las funciones :func:`repr` o :func:`str`."

#: ../Doc/tutorial/inputoutput.rst:66
msgid ""
"The :func:`str` function is meant to return representations of values which "
"are fairly human-readable, while :func:`repr` is meant to generate "
"representations which can be read by the interpreter (or will force a :exc:"
"`SyntaxError` if there is no equivalent syntax).  For objects which don't "
"have a particular representation for human consumption, :func:`str` will "
"return the same value as :func:`repr`.  Many values, such as numbers or "
"structures like lists and dictionaries, have the same representation using "
"either function.  Strings, in particular, have two distinct representations."
msgstr ""
"La función :func:`str` retorna representaciones de los valores que son "
"bastante legibles por humanos, mientras que :func:`repr` genera "
"representaciones que pueden ser leídas por el intérprete (o forzarían un :"
"exc:`SyntaxError` si no hay sintaxis equivalente). Para objetos que no "
"tienen una representación en particular para consumo humano, :func:`str` "
"retornará el mismo valor que :func:`repr`. Muchos valores, como números o "
"estructuras como listas y diccionarios, tienen la misma representación "
"usando cualquiera de las dos funciones.  Las cadenas, en particular, tienen "
"dos representaciones distintas."

#: ../Doc/tutorial/inputoutput.rst:75
msgid "Some examples::"
msgstr "Algunos ejemplos::"

#: ../Doc/tutorial/inputoutput.rst:77
msgid ""
">>> s = 'Hello, world.'\n"
">>> str(s)\n"
"'Hello, world.'\n"
">>> repr(s)\n"
"\"'Hello, world.'\"\n"
">>> str(1/7)\n"
"'0.14285714285714285'\n"
">>> x = 10 * 3.25\n"
">>> y = 200 * 200\n"
">>> s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'\n"
">>> print(s)\n"
"The value of x is 32.5, and y is 40000...\n"
">>> # The repr() of a string adds string quotes and backslashes:\n"
">>> hello = 'hello, world\\n'\n"
">>> hellos = repr(hello)\n"
">>> print(hellos)\n"
"'hello, world\\n'\n"
">>> # The argument to repr() may be any Python object:\n"
">>> repr((x, y, ('spam', 'eggs')))\n"
"\"(32.5, 40000, ('spam', 'eggs'))\""
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:98
msgid ""
"The :mod:`string` module contains a :class:`~string.Template` class that "
"offers yet another way to substitute values into strings, using placeholders "
"like ``$x`` and replacing them with values from a dictionary, but offers "
"much less control of the formatting."
msgstr ""
"El módulo :mod:`string` contiene una clase :class:`~string.Template` que "
"ofrece otra forma de sustituir valores en cadenas, utilizando marcadores de "
"posición como ``$x`` y reemplazarlos con valores desde un diccionario, pero "
"esto ofrece mucho menos control en el formato."

#: ../Doc/tutorial/inputoutput.rst:107
msgid "Formatted String Literals"
msgstr "Formatear cadenas literales"

#: ../Doc/tutorial/inputoutput.rst:109
msgid ""
":ref:`Formatted string literals <f-strings>` (also called f-strings for "
"short) let you include the value of Python expressions inside a string by "
"prefixing the string with ``f`` or ``F`` and writing expressions as "
"``{expression}``."
msgstr ""
":ref:`Literales de cadena formateados <f-strings>` (también llamados f-"
"strings para abreviar) le permiten incluir el valor de las expresiones de "
"Python dentro de una cadena prefijando la cadena con ``f`` o ``F`` y "
"escribiendo expresiones como ``{expresion}``."

#: ../Doc/tutorial/inputoutput.rst:114
msgid ""
"An optional format specifier can follow the expression. This allows greater "
"control over how the value is formatted. The following example rounds pi to "
"three places after the decimal::"
msgstr ""
"La expresión puede ir seguida de un especificador de formato opcional . Esto "
"permite un mayor control sobre cómo se formatea el valor. En el ejemplo "
"siguiente se redondea pi a tres lugares después del decimal::"

#: ../Doc/tutorial/inputoutput.rst:118
msgid ""
">>> import math\n"
">>> print(f'The value of pi is approximately {math.pi:.3f}.')\n"
"The value of pi is approximately 3.142."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:122
msgid ""
"Passing an integer after the ``':'`` will cause that field to be a minimum "
"number of characters wide.  This is useful for making columns line up. ::"
msgstr ""
"Pasar un entero después de ``':'`` hará que ese campo sea un número mínimo "
"de caracteres de ancho. Esto es útil para hacer que las columnas se "
"alineen. ::"

#: ../Doc/tutorial/inputoutput.rst:125
msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}\n"
">>> for name, phone in table.items():\n"
"...     print(f'{name:10} ==> {phone:10d}')\n"
"...\n"
"Sjoerd     ==>       4127\n"
"Jack       ==>       4098\n"
"Dcab       ==>       7678"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:133
msgid ""
"Other modifiers can be used to convert the value before it is formatted. ``'!"
"a'`` applies :func:`ascii`, ``'!s'`` applies :func:`str`, and ``'!r'`` "
"applies :func:`repr`::"
msgstr ""
"Se pueden utilizar otros modificadores para convertir el valor antes de "
"formatearlo. ``'!a'`` se aplica :func:`ascii`, ``'!s'`` se aplica :func:"
"`str`, y ``'!r'`` se aplica :func:`repr`::"

#: ../Doc/tutorial/inputoutput.rst:137
msgid ""
">>> animals = 'eels'\n"
">>> print(f'My hovercraft is full of {animals}.')\n"
"My hovercraft is full of eels.\n"
">>> print(f'My hovercraft is full of {animals!r}.')\n"
"My hovercraft is full of 'eels'."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:143
msgid ""
"The ``=`` specifier can be used to expand an expression to the text of the "
"expression, an equal sign, then the representation of the evaluated "
"expression:"
msgstr ""
"El especificador ``=`` puede utilizarse para expandir una expresión al texto "
"de la expresión, un signo igual y, a continuación, la representación de la "
"expresión evaluada:"

#: ../Doc/tutorial/inputoutput.rst:152
msgid ""
"See :ref:`self-documenting expressions <bpo-36817-whatsnew>` for more "
"information on the ``=`` specifier. For a reference on these format "
"specifications, see the reference guide for the :ref:`formatspec`."
msgstr ""
"Véase :ref:`expresiones auto-documentadas <bpo-36817-whatsnew>` para más "
"información en el especificador ``=``. Para obtener una referencia sobre "
"estas especificaciones de formato, consulte la guía de referencia para :ref:"
"`formatspec`."

#: ../Doc/tutorial/inputoutput.rst:159
msgid "The String format() Method"
msgstr "El método format() de cadenas"

#: ../Doc/tutorial/inputoutput.rst:161
msgid "Basic usage of the :meth:`str.format` method looks like this::"
msgstr "El uso básico del método :meth:`str.format` es como esto::"

#: ../Doc/tutorial/inputoutput.rst:163
msgid ""
">>> print('We are the {} who say \"{}!\"'.format('knights', 'Ni'))\n"
"We are the knights who say \"Ni!\""
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:166
msgid ""
"The brackets and characters within them (called format fields) are replaced "
"with the objects passed into the :meth:`str.format` method.  A number in the "
"brackets can be used to refer to the position of the object passed into the :"
"meth:`str.format` method. ::"
msgstr ""
"Las llaves y caracteres dentro de las mismas (llamados campos de formato) "
"son reemplazadas con los objetos pasados en el método :meth:`str.format`.  "
"Un número en las llaves se refiere a la posición del objeto pasado en el "
"método :meth:`str.format`. ::"

#: ../Doc/tutorial/inputoutput.rst:171
msgid ""
">>> print('{0} and {1}'.format('spam', 'eggs'))\n"
"spam and eggs\n"
">>> print('{1} and {0}'.format('spam', 'eggs'))\n"
"eggs and spam"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:176
msgid ""
"If keyword arguments are used in the :meth:`str.format` method, their values "
"are referred to by using the name of the argument. ::"
msgstr ""
"Si se usan argumentos nombrados en el método :meth:`str.format`, sus valores "
"se referencian usando el nombre del argumento. ::"

#: ../Doc/tutorial/inputoutput.rst:179
msgid ""
">>> print('This {food} is {adjective}.'.format(\n"
"...       food='spam', adjective='absolutely horrible'))\n"
"This spam is absolutely horrible."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:183
msgid "Positional and keyword arguments can be arbitrarily combined::"
msgstr ""
"Se pueden combinar arbitrariamente argumentos posicionales y nombrados::"

#: ../Doc/tutorial/inputoutput.rst:185
msgid ""
">>> print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',\n"
"...                                                    other='Georg'))\n"
"The story of Bill, Manfred, and Georg."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:189
msgid ""
"If you have a really long format string that you don't want to split up, it "
"would be nice if you could reference the variables to be formatted by name "
"instead of by position.  This can be done by simply passing the dict and "
"using square brackets ``'[]'`` to access the keys. ::"
msgstr ""
"Si tiene una cadena de caracteres de formato realmente larga que no desea "
"dividir, sería bueno si pudiera hacer referencia a las variables que se "
"formatearán por nombre en lugar de por posición. Esto se puede hacer "
"simplemente pasando el diccionario y usando corchetes ``'[]'`` para acceder "
"a las claves. ::"

#: ../Doc/tutorial/inputoutput.rst:194
msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '\n"
"...       'Dcab: {0[Dcab]:d}'.format(table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:199
msgid ""
"This could also be done by passing the ``table`` dictionary as keyword "
"arguments with the ``**`` notation. ::"
msgstr ""
"Esto se podría hacer, también, pasando el diccionario ``table`` como "
"argumentos por palabra clave con la notación '**'. ::"

#: ../Doc/tutorial/inputoutput.rst:202
msgid ""
">>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}\n"
">>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'."
"format(**table))\n"
"Jack: 4098; Sjoerd: 4127; Dcab: 8637678"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:206
#, fuzzy
msgid ""
"This is particularly useful in combination with the built-in function :func:"
"`vars`, which returns a dictionary containing all local variables::"
msgstr ""
"Esto es particularmente útil en combinación con la función integrada :func:"
"`vars`, que retorna un diccionario conteniendo todas las variables locales."

#: ../Doc/tutorial/inputoutput.rst:209
msgid ""
">>> table = {k: str(v) for k, v in vars().items()}\n"
">>> message = \" \".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])\n"
">>> print(message.format(**table))\n"
"__name__: __main__; __doc__: None; __package__: None; __loader__: ..."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:214
msgid ""
"As an example, the following lines produce a tidily aligned set of columns "
"giving integers and their squares and cubes::"
msgstr ""
"Como ejemplo, las siguientes líneas producen un conjunto ordenado de "
"columnas que dan enteros y sus cuadrados y cubos::"

#: ../Doc/tutorial/inputoutput.rst:217
msgid ""
">>> for x in range(1, 11):\n"
"...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:231
msgid ""
"For a complete overview of string formatting with :meth:`str.format`, see :"
"ref:`formatstrings`."
msgstr ""
"Para una completa descripción del formateo de cadenas con :meth:`str."
"format`, ver :ref:`string-formatting`."

#: ../Doc/tutorial/inputoutput.rst:236
msgid "Manual String Formatting"
msgstr "Formateo manual de cadenas"

#: ../Doc/tutorial/inputoutput.rst:238
msgid "Here's the same table of squares and cubes, formatted manually::"
msgstr ""
"Aquí está la misma tabla de cuadrados y cubos, formateados manualmente::"

#: ../Doc/tutorial/inputoutput.rst:240
msgid ""
">>> for x in range(1, 11):\n"
"...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')\n"
"...     # Note use of 'end' on previous line\n"
"...     print(repr(x*x*x).rjust(4))\n"
"...\n"
" 1   1    1\n"
" 2   4    8\n"
" 3   9   27\n"
" 4  16   64\n"
" 5  25  125\n"
" 6  36  216\n"
" 7  49  343\n"
" 8  64  512\n"
" 9  81  729\n"
"10 100 1000"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:256
msgid ""
"(Note that the one space between each column was added by the way :func:"
"`print` works: it always adds spaces between its arguments.)"
msgstr ""
"(Nótese que el espacio existente entre cada columna es añadido debido a como "
"funciona :func:`print`: siempre añade espacios entre sus argumentos.)"

#: ../Doc/tutorial/inputoutput.rst:259
msgid ""
"The :meth:`str.rjust` method of string objects right-justifies a string in a "
"field of a given width by padding it with spaces on the left. There are "
"similar methods :meth:`str.ljust` and :meth:`str.center`. These methods do "
"not write anything, they just return a new string. If the input string is "
"too long, they don't truncate it, but return it unchanged; this will mess up "
"your column lay-out but that's usually better than the alternative, which "
"would be lying about a value. (If you really want truncation you can always "
"add a slice operation, as in ``x.ljust(n)[:n]``.)"
msgstr ""
"El método :meth:`str.rjust` de los objetos cadena justifica a la derecha en "
"un campo de anchura predeterminada rellenando con espacios a la izquierda. "
"Métodos similares a este son :meth:`str.ljust` y :meth:`str.center`. Estos "
"métodos no escriben nada, simplemente retornan una nueva cadena. Si la "
"cadena de entrada es demasiado larga no la truncarán sino que la retornarán "
"sin cambios; esto desordenará la disposición de la columna que es, "
"normalmente, mejor que la alternativa, la cual podría falsear un valor. (Si "
"realmente deseas truncar siempre puedes añadir una operación de rebanado, "
"como en ``x.ljust(n)[:n]``.)"

#: ../Doc/tutorial/inputoutput.rst:268
msgid ""
"There is another method, :meth:`str.zfill`, which pads a numeric string on "
"the left with zeros.  It understands about plus and minus signs::"
msgstr ""
"Hay otro método, :meth:`str.zfill`, el cual rellena una cadena numérica a la "
"izquierda con ceros. Entiende signos positivos y negativos::"

#: ../Doc/tutorial/inputoutput.rst:271
msgid ""
">>> '12'.zfill(5)\n"
"'00012'\n"
">>> '-3.14'.zfill(7)\n"
"'-003.14'\n"
">>> '3.14159265359'.zfill(5)\n"
"'3.14159265359'"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:280
msgid "Old string formatting"
msgstr "Viejo formateo de cadenas"

#: ../Doc/tutorial/inputoutput.rst:282
#, fuzzy, python-format
msgid ""
"The % operator (modulo) can also be used for string formatting. Given "
"``format % values`` (where *format* is a string), ``%`` conversion "
"specifications in *format* are replaced with zero or more elements of "
"*values*. This operation is commonly known as string interpolation. For "
"example::"
msgstr ""
"El operador % (módulo) también se puede utilizar para formatear cadenas de "
"caracteres. Dados los ``'cadena de caracteres' % valores``, las instancias "
"de ``%`` en ``cadena de caracteres`` se reemplazan con cero o más elementos "
"de ``valores``. Esta operación se conoce comúnmente como interpolación de "
"cadenas. Por ejemplo::"

#: ../Doc/tutorial/inputoutput.rst:289
#, python-format
msgid ""
">>> import math\n"
">>> print('The value of pi is approximately %5.3f.' % math.pi)\n"
"The value of pi is approximately 3.142."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:293
msgid ""
"More information can be found in the :ref:`old-string-formatting` section."
msgstr ""
"Podés encontrar más información en la sección :ref:`old-string-formatting`."

#: ../Doc/tutorial/inputoutput.rst:299
msgid "Reading and Writing Files"
msgstr "Leyendo y escribiendo archivos"

#: ../Doc/tutorial/inputoutput.rst:305
msgid ""
":func:`open` returns a :term:`file object`, and is most commonly used with "
"two positional arguments and one keyword argument: ``open(filename, mode, "
"encoding=None)``"
msgstr ""
"La función :func:`open` retorna un :term:`file object`, y se usa normalmente "
"con dos argumentos posicionales y un argumento nombrado: "
"``open(nombre_de_archivo, modo, encoding=None)``"

#: ../Doc/tutorial/inputoutput.rst:311
msgid ">>> f = open('workfile', 'w', encoding=\"utf-8\")"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:318
msgid ""
"The first argument is a string containing the filename.  The second argument "
"is another string containing a few characters describing the way in which "
"the file will be used.  *mode* can be ``'r'`` when the file will only be "
"read, ``'w'`` for only writing (an existing file with the same name will be "
"erased), and ``'a'`` opens the file for appending; any data written to the "
"file is automatically added to the end.  ``'r+'`` opens the file for both "
"reading and writing. The *mode* argument is optional; ``'r'`` will be "
"assumed if it's omitted."
msgstr ""
"El primer argumento es una cadena que contiene el nombre del fichero. El "
"segundo argumento es otra cadena que contiene unos pocos caracteres "
"describiendo la forma en que el fichero será usado. *mode* puede ser ``'r'`` "
"cuando el fichero solo se leerá, ``'w'`` para solo escritura (un fichero "
"existente con el mismo nombre se borrará) y ``'a'`` abre el fichero para "
"agregar; cualquier dato que se escribe en el fichero se añade "
"automáticamente al final. ``'r+'`` abre el fichero tanto para lectura como "
"para escritura. El argumento *mode* es opcional; se asume que se usará "
"``'r'`` si se omite."

#: ../Doc/tutorial/inputoutput.rst:327
msgid ""
"Normally, files are opened in :dfn:`text mode`, that means, you read and "
"write strings from and to the file, which are encoded in a specific "
"*encoding*. If *encoding* is not specified, the default is platform "
"dependent (see :func:`open`). Because UTF-8 is the modern de-facto standard, "
"``encoding=\"utf-8\"`` is recommended unless you know that you need to use a "
"different encoding. Appending a ``'b'`` to the mode opens the file in :dfn:"
"`binary mode`. Binary mode data is read and written as :class:`bytes` "
"objects. You can not specify *encoding* when opening file in binary mode."
msgstr ""
"Normalmente, los ficheros se abren en :dfn:`modo texto`, es decir, se leen y "
"escriben cadenas desde y hacia el fichero, que están codificadas en una "
"*codificación* específica. Si no se especifica *codificación*, el valor por "
"defecto depende de la plataforma (véase :func:`open`). Dado que UTF-8 es el "
"estándar moderno de facto, se recomienda ``encoding=\"utf-8\"`` a menos que "
"sepa que necesita usar una codificación diferente. Añadiendo ``'b'`` al modo "
"se abre el fichero en :dfn:`modo binario`. Los datos en modo binario se leen "
"y escriben como objetos :class:`bytes`. No se puede especificar "
"*codificación* al abrir un fichero en modo binario."

#: ../Doc/tutorial/inputoutput.rst:337
msgid ""
"In text mode, the default when reading is to convert platform-specific line "
"endings (``\\n`` on Unix, ``\\r\\n`` on Windows) to just ``\\n``.  When "
"writing in text mode, the default is to convert occurrences of ``\\n`` back "
"to platform-specific line endings.  This behind-the-scenes modification to "
"file data is fine for text files, but will corrupt binary data like that in :"
"file:`JPEG` or :file:`EXE` files.  Be very careful to use binary mode when "
"reading and writing such files."
msgstr ""
"Cuando se lee en modo texto, por defecto se convierten los fin de lineas que "
"son específicos a las plataformas (``\\n`` en Unix, ``\\r\\n`` en Windows) a "
"solamente ``\\n``. Cuando se escribe en modo texto, por defecto se "
"convierten los ``\\n`` a los fin de linea específicos de la plataforma. Este "
"cambio automático está bien para archivos de texto, pero corrompería datos "
"binarios como los de archivos :file:`JPEG` o :file:`EXE`. Asegúrese de usar "
"modo binario cuando lea y escriba tales archivos."

#: ../Doc/tutorial/inputoutput.rst:345
msgid ""
"It is good practice to use the :keyword:`with` keyword when dealing with "
"file objects.  The advantage is that the file is properly closed after its "
"suite finishes, even if an exception is raised at some point.  Using :"
"keyword:`!with` is also much shorter than writing equivalent :keyword:"
"`try`\\ -\\ :keyword:`finally` blocks::"
msgstr ""
"Es una buena práctica usar la declaración :keyword:`with` cuando manejamos "
"objetos archivo. Tiene la ventaja de que el archivo es cerrado "
"apropiadamente luego de que el bloque termina, incluso si se generó una "
"excepción. También es mucho más corto que escribir los equivalentes bloques :"
"keyword:`try`\\ -\\ :keyword:`finally` ::"

#: ../Doc/tutorial/inputoutput.rst:351
msgid ""
">>> with open('workfile', encoding=\"utf-8\") as f:\n"
"...     read_data = f.read()\n"
"\n"
">>> # We can check that the file has been automatically closed.\n"
">>> f.closed\n"
"True"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:358
msgid ""
"If you're not using the :keyword:`with` keyword, then you should call ``f."
"close()`` to close the file and immediately free up any system resources "
"used by it."
msgstr ""
"Si no está utilizando la palabra clave :keyword:`with`, entonces debe llamar "
"a ``f.close()`` para cerrar el archivo y liberar inmediatamente los recursos "
"del sistema utilizados por él."

#: ../Doc/tutorial/inputoutput.rst:363
msgid ""
"Calling ``f.write()`` without using the :keyword:`!with` keyword or calling "
"``f.close()`` **might** result in the arguments of ``f.write()`` not being "
"completely written to the disk, even if the program exits successfully."
msgstr ""
"Llamar a ``f.write()`` sin usar la palabra clave :keyword:`!with` o sin "
"llamar a ``f.close()`` **podría** dar como resultado que los argumentos de "
"``f.write()`` no se escriban completamente en disco, incluso si el programa "
"se termina correctamente."

#: ../Doc/tutorial/inputoutput.rst:371
msgid ""
"After a file object is closed, either by a :keyword:`with` statement or by "
"calling ``f.close()``, attempts to use the file object will automatically "
"fail. ::"
msgstr ""
"Después de que un objeto de archivo es cerrado, ya sea por :keyword:`with` o "
"llamando a ``f.close()``, intentar volver a utilizarlo fallará "
"automáticamente::"

#: ../Doc/tutorial/inputoutput.rst:375
msgid ""
">>> f.close()\n"
">>> f.read()\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"ValueError: I/O operation on closed file."
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:385
msgid "Methods of File Objects"
msgstr "Métodos de los objetos Archivo"

#: ../Doc/tutorial/inputoutput.rst:387
msgid ""
"The rest of the examples in this section will assume that a file object "
"called ``f`` has already been created."
msgstr ""
"El resto de los ejemplos en esta sección asumirán que ya se creó un objeto "
"archivo llamado ``f``."

#: ../Doc/tutorial/inputoutput.rst:390
msgid ""
"To read a file's contents, call ``f.read(size)``, which reads some quantity "
"of data and returns it as a string (in text mode) or bytes object (in binary "
"mode). *size* is an optional numeric argument.  When *size* is omitted or "
"negative, the entire contents of the file will be read and returned; it's "
"your problem if the file is twice as large as your machine's memory. "
"Otherwise, at most *size* characters (in text mode) or *size* bytes (in "
"binary mode) are read and returned. If the end of the file has been reached, "
"``f.read()`` will return an empty string (``''``).  ::"
msgstr ""
"Para leer el contenido de una archivo utiliza ``f.read(size)``, el cual lee "
"alguna cantidad de datos y los retorna como una cadena (en modo texto) o un "
"objeto de bytes (en modo binario). *size* es un argumento numérico opcional. "
"Cuando se omite *size* o es negativo, el contenido entero del archivo será "
"leído y retornado; es tu problema si el archivo es el doble de grande que la "
"memoria de tu máquina. De otra manera, son leídos y retornados como máximo "
"*size* caracteres (en modo texto) o *size* bytes (en modo binario). Si se "
"alcanzó el fin del archivo, ``f.read()`` retornará una cadena vacía "
"(``''``). ::"

#: ../Doc/tutorial/inputoutput.rst:399
msgid ""
">>> f.read()\n"
"'This is the entire file.\\n'\n"
">>> f.read()\n"
"''"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:404
msgid ""
"``f.readline()`` reads a single line from the file; a newline character "
"(``\\n``) is left at the end of the string, and is only omitted on the last "
"line of the file if the file doesn't end in a newline.  This makes the "
"return value unambiguous; if ``f.readline()`` returns an empty string, the "
"end of the file has been reached, while a blank line is represented by "
"``'\\n'``, a string containing only a single newline.  ::"
msgstr ""
"``f.readline()`` lee una sola linea del archivo; el carácter de fin de linea "
"(``\\n``) se deja al final de la cadena, y sólo se omite en la última linea "
"del archivo si el mismo no termina en un fin de linea. Esto hace que el "
"valor de retorno no sea ambiguo; si ``f.readline()`` retorna una cadena "
"vacía, es que se alcanzó el fin del archivo, mientras que una linea en "
"blanco es representada por ``'\\n'``, una cadena conteniendo sólo un único "
"fin de linea. ::"

#: ../Doc/tutorial/inputoutput.rst:411
msgid ""
">>> f.readline()\n"
"'This is the first line of the file.\\n'\n"
">>> f.readline()\n"
"'Second line of the file\\n'\n"
">>> f.readline()\n"
"''"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:418
msgid ""
"For reading lines from a file, you can loop over the file object. This is "
"memory efficient, fast, and leads to simple code::"
msgstr ""
"Para leer líneas de un archivo, puedes iterar sobre el objeto archivo. Esto "
"es eficiente en memoria, rápido, y conduce a un código más simple::"

#: ../Doc/tutorial/inputoutput.rst:421
msgid ""
">>> for line in f:\n"
"...     print(line, end='')\n"
"...\n"
"This is the first line of the file.\n"
"Second line of the file"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:427
msgid ""
"If you want to read all the lines of a file in a list you can also use "
"``list(f)`` or ``f.readlines()``."
msgstr ""
"Si querés leer todas las líneas de un archivo en una lista también podés "
"usar ``list(f)`` o ``f.readlines()``."

#: ../Doc/tutorial/inputoutput.rst:430
msgid ""
"``f.write(string)`` writes the contents of *string* to the file, returning "
"the number of characters written. ::"
msgstr ""
"``f.write(cadena)`` escribe el contenido de la *cadena* al archivo, "
"retornando la cantidad de caracteres escritos. ::"

#: ../Doc/tutorial/inputoutput.rst:433
msgid ""
">>> f.write('This is a test\\n')\n"
"15"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:436
msgid ""
"Other types of objects need to be converted -- either to a string (in text "
"mode) or a bytes object (in binary mode) -- before writing them::"
msgstr ""
"Otros tipos de objetos necesitan ser convertidos -- tanto a una cadena (en "
"modo texto) o a un objeto de bytes (en modo binario) -- antes de "
"escribirlos::"

#: ../Doc/tutorial/inputoutput.rst:439
msgid ""
">>> value = ('the answer', 42)\n"
">>> s = str(value)  # convert the tuple to string\n"
">>> f.write(s)\n"
"18"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:444
msgid ""
"``f.tell()`` returns an integer giving the file object's current position in "
"the file represented as number of bytes from the beginning of the file when "
"in binary mode and an opaque number when in text mode."
msgstr ""
"``f.tell()`` retorna un entero que indica la posición actual en el archivo "
"representada como número de bytes desde el comienzo del archivo en modo "
"binario y un número opaco en modo texto."

#: ../Doc/tutorial/inputoutput.rst:448
msgid ""
"To change the file object's position, use ``f.seek(offset, whence)``.  The "
"position is computed from adding *offset* to a reference point; the "
"reference point is selected by the *whence* argument.  A *whence* value of 0 "
"measures from the beginning of the file, 1 uses the current file position, "
"and 2 uses the end of the file as the reference point.  *whence* can be "
"omitted and defaults to 0, using the beginning of the file as the reference "
"point. ::"
msgstr ""
"Para cambiar la posición del objeto archivo, utiliza ``f.seek(offset, "
"whence)``. La posición es calculada agregando el *offset* a un punto de "
"referencia; el punto de referencia se selecciona del argumento *whence*. Un "
"valor *whence* de 0 mide desde el comienzo del archivo, 1 usa la posición "
"actual del archivo, y 2 usa el fin del archivo como punto de referencia.  "
"*whence* puede omitirse, el valor por defecto es 0, usando el comienzo del "
"archivo como punto de referencia. ::"

#: ../Doc/tutorial/inputoutput.rst:455
msgid ""
">>> f = open('workfile', 'rb+')\n"
">>> f.write(b'0123456789abcdef')\n"
"16\n"
">>> f.seek(5)      # Go to the 6th byte in the file\n"
"5\n"
">>> f.read(1)\n"
"b'5'\n"
">>> f.seek(-3, 2)  # Go to the 3rd byte before the end\n"
"13\n"
">>> f.read(1)\n"
"b'd'"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:467
msgid ""
"In text files (those opened without a ``b`` in the mode string), only seeks "
"relative to the beginning of the file are allowed (the exception being "
"seeking to the very file end with ``seek(0, 2)``) and the only valid "
"*offset* values are those returned from the ``f.tell()``, or zero. Any other "
"*offset* value produces undefined behaviour."
msgstr ""
"En los archivos de texto (aquellos que se abrieron sin una ``b`` en el "
"modo), se permiten solamente desplazamientos con ``seek`` relativos al "
"comienzo (con la excepción de ir justo al final con ``seek(0, 2)``) y los "
"únicos valores de *desplazamiento* válidos son aquellos retornados por ``f."
"tell()``, o cero. Cualquier otro valor de *desplazamiento* produce un "
"comportamiento indefinido."

#: ../Doc/tutorial/inputoutput.rst:473
msgid ""
"File objects have some additional methods, such as :meth:`~io.IOBase.isatty` "
"and :meth:`~io.IOBase.truncate` which are less frequently used; consult the "
"Library Reference for a complete guide to file objects."
msgstr ""
"Los objetos archivo tienen algunos métodos más, como :meth:`~io.IOBase."
"isatty` y :meth:`~io.IOBase.truncate` que son usados menos frecuentemente; "
"consultá la Referencia de la Biblioteca para una guía completa sobre los "
"objetos archivo."

#: ../Doc/tutorial/inputoutput.rst:481
msgid "Saving structured data with :mod:`json`"
msgstr "Guardar datos estructurados con :mod:`json`"

#: ../Doc/tutorial/inputoutput.rst:485
msgid ""
"Strings can easily be written to and read from a file.  Numbers take a bit "
"more effort, since the :meth:`~io.TextIOBase.read` method only returns "
"strings, which will have to be passed to a function like :func:`int`, which "
"takes a string like ``'123'`` and returns its numeric value 123.  When you "
"want to save more complex data types like nested lists and dictionaries, "
"parsing and serializing by hand becomes complicated."
msgstr ""
"Las cadenas pueden fácilmente escribirse y leerse de un archivo. Los números "
"toman algo más de esfuerzo, ya que el método :meth:`~io.TextIOBase.read` "
"sólo retorna cadenas, que tendrán que ser pasadas a una función como :func:"
"`int`, que toma una cadena como ``'123'`` y retorna su valor numérico 123. "
"Sin embargo, cuando querés guardar tipos de datos más complejos como listas, "
"diccionarios, o instancias de clases, las cosas se ponen más complicadas."

#: ../Doc/tutorial/inputoutput.rst:492
msgid ""
"Rather than having users constantly writing and debugging code to save "
"complicated data types to files, Python allows you to use the popular data "
"interchange format called `JSON (JavaScript Object Notation) <https://json."
"org>`_.  The standard module called :mod:`json` can take Python data "
"hierarchies, and convert them to string representations; this process is "
"called :dfn:`serializing`.  Reconstructing the data from the string "
"representation is called :dfn:`deserializing`.  Between serializing and "
"deserializing, the string representing the object may have been stored in a "
"file or data, or sent over a network connection to some distant machine."
msgstr ""
"En lugar de tener a los usuarios constantemente escribiendo y debugueando "
"código para guardar tipos de datos complicados, Python te permite usar el "
"popular formato intercambiable de datos llamado `JSON (JavaScript Object "
"Notation) <http://json.org>`_. El módulo estándar llamado :mod:`json` puede "
"tomar datos de Python con una jerarquía, y convertirlo a representaciones de "
"cadena de caracteres; este proceso es llamado :dfn:`serialización`. "
"Reconstruir los datos desde la representación de cadena de caracteres es "
"llamado :dfn:`deserialización`. Entre serialización y deserialización, la "
"cadena de caracteres representando el objeto quizás haya sido guardado en un "
"archivo o datos, o enviado a una máquina distante por una conexión de red."

#: ../Doc/tutorial/inputoutput.rst:503
msgid ""
"The JSON format is commonly used by modern applications to allow for data "
"exchange.  Many programmers are already familiar with it, which makes it a "
"good choice for interoperability."
msgstr ""
"El formato JSON es comúnmente usado por aplicaciones modernas para permitir "
"el intercambio de datos. Muchos programadores ya están familiarizados con "
"él, lo cual lo convierte en una buena opción para la interoperabilidad."

#: ../Doc/tutorial/inputoutput.rst:507
msgid ""
"If you have an object ``x``, you can view its JSON string representation "
"with a simple line of code::"
msgstr ""
"Si tienes un objeto ``x``, puedes ver su representación JSON con una simple "
"línea de código::"

#: ../Doc/tutorial/inputoutput.rst:510
msgid ""
">>> import json\n"
">>> x = [1, 'simple', 'list']\n"
">>> json.dumps(x)\n"
"'[1, \"simple\", \"list\"]'"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:515
msgid ""
"Another variant of the :func:`~json.dumps` function, called :func:`~json."
"dump`, simply serializes the object to a :term:`text file`.  So if ``f`` is "
"a :term:`text file` object opened for writing, we can do this::"
msgstr ""
"Otra variante de la función :func:`~json.dumps`, llamada :func:`~json.dump`, "
"simplemente serializa el objeto a un :term:`archivo de texto`. Así que, si "
"``f`` es un objeto :term:`archivo de texto` abierto para escritura, podemos "
"hacer::"

#: ../Doc/tutorial/inputoutput.rst:519
msgid "json.dump(x, f)"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:521
msgid ""
"To decode the object again, if ``f`` is a :term:`binary file` or :term:`text "
"file` object which has been opened for reading::"
msgstr ""
"Para decodificar un objeto nuevamente, si ``f`` es un objeto :term:`binary "
"file` o :term:`text file` que fue abierto para lectura::"

#: ../Doc/tutorial/inputoutput.rst:524
msgid "x = json.load(f)"
msgstr ""

#: ../Doc/tutorial/inputoutput.rst:527
msgid ""
"JSON files must be encoded in UTF-8. Use ``encoding=\"utf-8\"`` when opening "
"JSON file as a :term:`text file` for both of reading and writing."
msgstr ""
"Los archivos JSON deben estar codificados en UTF-8. Utilice "
"``encoding=\"utf-8\"`` al abrir un archivo JSON como :term:`text file` tanto "
"para lectura como para escritura."

#: ../Doc/tutorial/inputoutput.rst:530
msgid ""
"This simple serialization technique can handle lists and dictionaries, but "
"serializing arbitrary class instances in JSON requires a bit of extra "
"effort. The reference for the :mod:`json` module contains an explanation of "
"this."
msgstr ""
"La simple técnica de serialización puede manejar listas y diccionarios, pero "
"serializar instancias de clases arbitrarias en JSON requiere un poco de "
"esfuerzo extra. La referencia del módulo :mod:`json` contiene una "
"explicación de esto."

#: ../Doc/tutorial/inputoutput.rst:536
msgid ":mod:`pickle` - the pickle module"
msgstr ":mod:`pickle` - El módulo *pickle*"

#: ../Doc/tutorial/inputoutput.rst:538
msgid ""
"Contrary to :ref:`JSON <tut-json>`, *pickle* is a protocol which allows the "
"serialization of arbitrarily complex Python objects.  As such, it is "
"specific to Python and cannot be used to communicate with applications "
"written in other languages.  It is also insecure by default: deserializing "
"pickle data coming from an untrusted source can execute arbitrary code, if "
"the data was crafted by a skilled attacker."
msgstr ""
"Contrariamente a :ref:`JSON <tut-json>`, *pickle* es un protocolo que "
"permite la serialización de objetos Python arbitrariamente complejos. Como "
"tal, es específico de Python y no se puede utilizar para comunicarse con "
"aplicaciones escritas en otros lenguajes. También es inseguro de forma "
"predeterminada: deserializar los datos de *pickle* procedentes de un origen "
"que no es de confianza puede ejecutar código arbitrario, si los datos fueron "
"creados por un atacante experto."

#: ../Doc/tutorial/inputoutput.rst:301
msgid "built-in function"
msgstr "función incorporada"

#: ../Doc/tutorial/inputoutput.rst:301
msgid "open"
msgstr "open"

#: ../Doc/tutorial/inputoutput.rst:301
msgid "object"
msgstr "object"

#: ../Doc/tutorial/inputoutput.rst:301
msgid "file"
msgstr "file"

#: ../Doc/tutorial/inputoutput.rst:483
msgid "module"
msgstr "módulo"

#: ../Doc/tutorial/inputoutput.rst:483
msgid "json"
msgstr "json"