# 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: 2022-11-05 13:47-0300\n"

"Last-Translator: Sofía Denner <sofi.denner@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/faq/library.rst:5

msgid "Library and Extension FAQ"

msgstr "Preguntas frecuentes sobre bibliotecas y extensiones"

#: ../Doc/faq/library.rst:8

msgid "Contents"

msgstr "Contenidos"

#: ../Doc/faq/library.rst:12

msgid "General Library Questions"

msgstr "Cuestiones generales sobre bibliotecas"

#: ../Doc/faq/library.rst:15

msgid "How do I find a module or application to perform task X?"

msgstr "¿Cómo encuentro un módulo o aplicación para ejecutar la tarea X?"

#: ../Doc/faq/library.rst:17

msgid ""

"Check :ref:`the Library Reference <library-index>` to see if there's a "

"relevant standard library module. (Eventually you'll learn what's in the "

"standard library and will be able to skip this step.)"

msgstr ""

"Vea la :ref:`referencia de bibliotecas <library-index>` para comprobar si "

"existe un módulo relevante en la biblioteca estándar. (Eventualmente "

"aprenderá lo que hay en la biblioteca estándar y será capaz de saltarse este "

"paso.)"

#: ../Doc/faq/library.rst:21

msgid ""

"For third-party packages, search the `Python Package Index <https://pypi."

"org>`_ or try `Google <https://www.google.com>`_ or another web search "

"engine. Searching for \"Python\" plus a keyword or two for your topic of "

"interest will usually find something helpful."

msgstr ""

"Para paquetes de terceros, busque `Python Package Index <https://pypi.org>`_ "

"o pruebe `Google <https://www.google.com>`_ u otro motor de búsqueda web. La "

"búsqueda de \"Python\" más una palabra clave o dos para su tema de interés "

"generalmente encontrará algo útil."

#: ../Doc/faq/library.rst:28

msgid "Where is the math.py (socket.py, regex.py, etc.) source file?"

msgstr ""

"¿Dónde está el fichero fuente *math.py* (*socket.py*, *regex.py*, etc.)?"

#: ../Doc/faq/library.rst:30

msgid ""

"If you can't find a source file for a module it may be a built-in or "

"dynamically loaded module implemented in C, C++ or other compiled language. "

"In this case you may not have the source file or it may be something like :"

"file:`mathmodule.c`, somewhere in a C source directory (not on the Python "

"Path)."

msgstr ""

"Si no puede encontrar un fichero fuente para un módulo, puede ser un módulo "

"incorporado o cargado dinámicamente implementado en C, C++ u otro lenguaje "

"compilado. En este caso puede no disponer del fichero fuente o puede ser "

"algo como :file:`mathmodule.c`, en algún lugar de un directorio fuente C "

"(fuera del Python *Path*)."

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

msgid "There are (at least) three kinds of modules in Python:"

msgstr "Hay (al menos) tres tipos de módulos en Python:"

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

msgid "modules written in Python (.py);"

msgstr "módulos escritos en Python (.py);"

#: ../Doc/faq/library.rst:38

msgid ""

"modules written in C and dynamically loaded (.dll, .pyd, .so, .sl, etc);"

msgstr ""

"módulos escritos en C y cargados dinámicamente (*.dll, .pyd, .so, .sl*, "

"etc.);"

#: ../Doc/faq/library.rst:39

msgid ""

"modules written in C and linked with the interpreter; to get a list of "

"these, type::"

msgstr ""

"módulos escritos en C y enlazados con el intérprete; para obtener una lista "

"de estos, escriba::"

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

msgid ""

"import sys\n"

"print(sys.builtin_module_names)"

msgstr ""

#: ../Doc/faq/library.rst:47

msgid "How do I make a Python script executable on Unix?"

msgstr "¿Cómo hago ejecutable un script Python en Unix?"

#: ../Doc/faq/library.rst:49

msgid ""

"You need to do two things: the script file's mode must be executable and the "

"first line must begin with ``#!`` followed by the path of the Python "

"interpreter."

msgstr ""

"Necesita hacer dos cosas: el modo del fichero del script debe ser ejecutable "

"y la primera línea debe comenzar con ``#!`` seguido de la ruta al intérprete "

"de Python."

#: ../Doc/faq/library.rst:53

msgid ""

"The first is done by executing ``chmod +x scriptfile`` or perhaps ``chmod "

"755 scriptfile``."

msgstr ""

"Lo primero se hace ejecutando ``chmod +x scriptfile`` o bien ``chmod 755 "

"scriptfile``."

#: ../Doc/faq/library.rst:56

msgid ""

"The second can be done in a number of ways. The most straightforward way is "

"to write ::"

msgstr ""

"Lo segundo se puede hacer de distintas maneras. La manera más directa es "

"escribir ::"

#: ../Doc/faq/library.rst:59

msgid "#!/usr/local/bin/python"

msgstr ""

#: ../Doc/faq/library.rst:61

msgid ""

"as the very first line of your file, using the pathname for where the Python "

"interpreter is installed on your platform."

msgstr ""

"en la primera línea de su fichero, usando la ruta donde está instalado el "

"intérprete de Python en su plataforma."

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

msgid ""

"If you would like the script to be independent of where the Python "

"interpreter lives, you can use the :program:`env` program. Almost all Unix "

"variants support the following, assuming the Python interpreter is in a "

"directory on the user's :envvar:`PATH`::"

msgstr ""

"Si quiere que el script sea independiente de donde se ubique el intérprete "

"de Python, puede usar el programa :program:`env`. Casi todas las variantes "

"de Unix soportan lo siguiente, asumiendo que el intérprete de Python está en "

"un directorio del :envvar:`PATH` de usuario:"

#: ../Doc/faq/library.rst:69

msgid "#!/usr/bin/env python"

msgstr ""

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

msgid ""

"*Don't* do this for CGI scripts. The :envvar:`PATH` variable for CGI "

"scripts is often very minimal, so you need to use the actual absolute "

"pathname of the interpreter."

msgstr ""

"*No* haga esto para scripts CGI. La variable :envvar:`PATH` para scripts CGI "

"es mínima, así que necesita usar la ruta real absoluta al intérprete."

#: ../Doc/faq/library.rst:75

msgid ""

"Occasionally, a user's environment is so full that the :program:`/usr/bin/"

"env` program fails; or there's no env program at all. In that case, you can "

"try the following hack (due to Alex Rezinsky):"

msgstr ""

"Ocasionalmente, un entorno de usuario está tan lleno que el programa :"

"program:`/usr/bin/env` falla; o bien no existe el programa env. En ese caso, "

"puede intentar el siguiente truco (gracias a Alex Rezinsky):"

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

msgid ""

"#! /bin/sh\n"

"\"\"\":\"\n"

"exec python $0 ${1+\"$@\"}\n"

"\"\"\""

msgstr ""

#: ../Doc/faq/library.rst:86

msgid ""

"The minor disadvantage is that this defines the script's __doc__ string. "

"However, you can fix that by adding ::"

msgstr ""

"Una pequeña desventaja es que esto define el *__doc__* del script. Sin "

"embargo, puede arreglarlo añadiendo ::"

#: ../Doc/faq/library.rst:89

msgid "__doc__ = \"\"\"...Whatever...\"\"\""

msgstr ""

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

msgid "Is there a curses/termcap package for Python?"

msgstr "¿Hay un paquete curses/termcap para Python?"

#: ../Doc/faq/library.rst:98

msgid ""

"For Unix variants: The standard Python source distribution comes with a "

"curses module in the :source:`Modules` subdirectory, though it's not "

"compiled by default. (Note that this is not available in the Windows "

"distribution -- there is no curses module for Windows.)"

msgstr ""

"Para variantes Unix: La distribución estándar de Python viene con un módulo "

"curses en el subdirectorio :source:`Modules`, aunque no está compilado por "

"defecto. (Nótese que esto no está disponible en la distribución Windows — no "

"hay módulo curses para Windows.)"

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

msgid ""

"The :mod:`curses` module supports basic curses features as well as many "

"additional functions from ncurses and SYSV curses such as colour, "

"alternative character set support, pads, and mouse support. This means the "

"module isn't compatible with operating systems that only have BSD curses, "

"but there don't seem to be any currently maintained OSes that fall into this "

"category."

msgstr ""

"El módulo :mod:`curses` soporta características básicas de cursores así como "

"muchas funciones adicionales de ncurses y cursores SYSV como color, soporte "

"para conjuntos de caracteres alternativos, pads, y soporte para ratón. Esto "

"significa que el módulo no es compatible con sistemas operativos que sólo "

"tienen cursores BSD, pero no parece que ningún sistema operativo actualmente "

"mantenido caiga dentro de esta categoría."

#: ../Doc/faq/library.rst:111

msgid "Is there an equivalent to C's onexit() in Python?"

msgstr "¿Hay un equivalente en Python al onexit() de C?"

#: ../Doc/faq/library.rst:113

#, fuzzy

msgid ""

"The :mod:`atexit` module provides a register function that is similar to "

"C's :c:func:`!onexit`."

msgstr ""

"El módulo :mod:`atexit` proporciona una función de registro que es similar "

"a :c:func:`onexit` de C."

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

msgid "Why don't my signal handlers work?"

msgstr "¿Por qué no funcionan mis manejadores de señales?"

#: ../Doc/faq/library.rst:120

msgid ""

"The most common problem is that the signal handler is declared with the "

"wrong argument list. It is called as ::"

msgstr ""

"El problema más común es que el manejador de señales esté declarado con la "

"lista incorrecta de argumentos. Se llama como ::"

#: ../Doc/faq/library.rst:123

msgid "handler(signum, frame)"

msgstr ""

#: ../Doc/faq/library.rst:125

msgid "so it should be declared with two parameters::"

msgstr "así que debería declararse con dos argumentos::"

#: ../Doc/faq/library.rst:127

msgid ""

"def handler(signum, frame):\n"

" ..."

msgstr ""

#: ../Doc/faq/library.rst:132

msgid "Common tasks"

msgstr "Tareas comunes"

#: ../Doc/faq/library.rst:135

msgid "How do I test a Python program or component?"

msgstr "¿Cómo pruebo un programa o un componente Python?"

#: ../Doc/faq/library.rst:137

msgid ""

"Python comes with two testing frameworks. The :mod:`doctest` module finds "

"examples in the docstrings for a module and runs them, comparing the output "

"with the expected output given in the docstring."

msgstr ""

"Python viene con dos *frameworks* de *testing*. El módulo :mod:`doctest` "

"encuentra ejemplos en los docstrings para un módulo y los ejecuta, "

"comparando la salida con la salida esperada especificada en la cadena de "

"documentación."

#: ../Doc/faq/library.rst:141

msgid ""

"The :mod:`unittest` module is a fancier testing framework modelled on Java "

"and Smalltalk testing frameworks."

msgstr ""

"El módulo :mod:`unittest` es un *framework* de *testing* más agradable y "

"modelado sobre los *frameworks* de *testing* de Java y Smalltalk."

#: ../Doc/faq/library.rst:144

msgid ""

"To make testing easier, you should use good modular design in your program. "

"Your program should have almost all functionality encapsulated in either "

"functions or class methods -- and this sometimes has the surprising and "

"delightful effect of making the program run faster (because local variable "

"accesses are faster than global accesses). Furthermore the program should "

"avoid depending on mutating global variables, since this makes testing much "

"more difficult to do."

msgstr ""

"Para hacer más fácil el *testing*, debería usar un buen diseño modular en su "

"programa. Su programa debería tener casi toda la funcionalidad encapsulada "

"en funciones o en métodos de clases — y esto algunas veces tiene el efecto "

"sorprendente y encantador de que su programa funcione más rápido (porque los "

"accesos a las variables locales son más rápidas que los accesos a las "

"variables globales). Además el programa debería evitar depender de la "

"mutación de variables globales, ya que esto dificulta mucho más hacer el "

"*testing*."

#: ../Doc/faq/library.rst:152

msgid "The \"global main logic\" of your program may be as simple as ::"

msgstr ""

"La \"lógica global principal\" de su programa puede ser tan simple como ::"

#: ../Doc/faq/library.rst:154

msgid ""

"if __name__ == \"__main__\":\n"

" main_logic()"

msgstr ""

#: ../Doc/faq/library.rst:157

msgid "at the bottom of the main module of your program."

msgstr "al final del módulo principal de su programa."

#: ../Doc/faq/library.rst:159

msgid ""

"Once your program is organized as a tractable collection of function and "

"class behaviours, you should write test functions that exercise the "

"behaviours. A test suite that automates a sequence of tests can be "

"associated with each module. This sounds like a lot of work, but since "

"Python is so terse and flexible it's surprisingly easy. You can make coding "

"much more pleasant and fun by writing your test functions in parallel with "

"the \"production code\", since this makes it easy to find bugs and even "

"design flaws earlier."

msgstr ""

"Una vez que su programa esté organizado en una colección manejable de "

"funciones y comportamientos de clases, usted debería escribir funciones de "

"comprobación que ejerciten los comportamientos. Se puede asociar un conjunto "

"de pruebas a cada módulo. Esto suena a mucho trabajo, pero gracias a que "

"Python es tan conciso y flexible, se hace sorprendentemente fácil. Puede "

"codificar de manera mucho más agradable y divertida escribiendo funciones de "

"comprobación en paralelo con el \"código de producción\", ya que esto "

"facilita encontrar antes errores e incluso fallos de diseño."

#: ../Doc/faq/library.rst:167

msgid ""

"\"Support modules\" that are not intended to be the main module of a program "

"may include a self-test of the module. ::"

msgstr ""

"Los \"módulos de soporte\" que no tienen la intención de estar en el módulo "

"principal de un programa pueden incluir un auto *test* del módulo. ::"

#: ../Doc/faq/library.rst:170

msgid ""

"if __name__ == \"__main__\":\n"

" self_test()"

msgstr ""

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

msgid ""

"Even programs that interact with complex external interfaces may be tested "

"when the external interfaces are unavailable by using \"fake\" interfaces "

"implemented in Python."

msgstr ""

"Incluso los programas que interactúan con interfaces externas complejas se "

"pueden comprobar cuando las interfaces externas no están disponibles usando "

"interfaces \"simuladas\" implementadas en Python."

#: ../Doc/faq/library.rst:179

msgid "How do I create documentation from doc strings?"

msgstr "¿Cómo creo documentación a partir de los docstrings?"

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

msgid ""

"The :mod:`pydoc` module can create HTML from the doc strings in your Python "

"source code. An alternative for creating API documentation purely from "

"docstrings is `epydoc <https://epydoc.sourceforge.net/>`_. `Sphinx <https://"

"www.sphinx-doc.org>`_ can also include docstring content."

msgstr ""

"El módulo :mod:`pydoc` puede crear HTML desde los docstrings existentes en "

"su código fuente Python. Una alternativa para crear documentación API "

"estrictamente desde docstrings es `epydoc <http://epydoc.sourceforge.net/"

">`_. `Sphinx <http://sphinx-doc.org>`_ también puede incluir contenido "

"docstring."

#: ../Doc/faq/library.rst:188

msgid "How do I get a single keypress at a time?"

msgstr "¿Cómo consigo presionar una única tecla cada vez?"

#: ../Doc/faq/library.rst:190

msgid ""

"For Unix variants there are several solutions. It's straightforward to do "

"this using curses, but curses is a fairly large module to learn."

msgstr ""

"Para variantes Unix hay varias soluciones. Lo más directo es hacerlo usando "

"cursores, pero curses es un módulo bastante amplio para aprenderlo."

#: ../Doc/faq/library.rst:234

msgid "Threads"

msgstr "Hilos"

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

msgid "How do I program using threads?"

msgstr "¿Cómo programo usando hilos?"

#: ../Doc/faq/library.rst:239

msgid ""

"Be sure to use the :mod:`threading` module and not the :mod:`_thread` "

"module. The :mod:`threading` module builds convenient abstractions on top of "

"the low-level primitives provided by the :mod:`_thread` module."

msgstr ""

"Asegúrese de usar el módulo :mod:`threading` y no el módulo :mod:`_thread`. "

"El módulo :mod:`threading` construye abstracciones convenientes sobre las "

"primitivas de bajo nivel proporcionadas por el módulo :mod:`_thread`."

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

msgid "None of my threads seem to run: why?"

msgstr "Ninguno de mis hilos parece funcionar: ¿por qué?"

#: ../Doc/faq/library.rst:247

msgid ""

"As soon as the main thread exits, all threads are killed. Your main thread "

"is running too quickly, giving the threads no time to do any work."

msgstr ""

"Tan pronto como el hilo principal termine, se matan todos los hilos. Su hilo "

"principal está corriendo demasiado rápido, sin dar tiempo a los hilos para "

"hacer algún trabajo."

#: ../Doc/faq/library.rst:250

msgid ""

"A simple fix is to add a sleep to the end of the program that's long enough "

"for all the threads to finish::"

msgstr ""

"Una solución sencilla es añadir un *sleep* al final del programa que sea "

"suficientemente largo para que todos los hilos terminen::"

#: ../Doc/faq/library.rst:253

msgid ""

"import threading, time\n"

"\n"

"def thread_task(name, n):\n"

" for i in range(n):\n"

" print(name, i)\n"

"\n"

"for i in range(10):\n"

" T = threading.Thread(target=thread_task, args=(str(i), i))\n"

" T.start()\n"

"\n"

"time.sleep(10) # <---------------------------!"

msgstr ""

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

msgid ""

"But now (on many platforms) the threads don't run in parallel, but appear to "

"run sequentially, one at a time! The reason is that the OS thread scheduler "

"doesn't start a new thread until the previous thread is blocked."

msgstr ""

"Por ahora (en muchas plataformas) los hilos no corren en paralelo, sino que "

"parece que corren secuencialmente, ¡uno a la vez! La razón es que el "

"planificador de hilos del sistema operativo no inicia un nuevo hilo hasta "

"que el hilo anterior está bloqueado."

#: ../Doc/faq/library.rst:269

msgid "A simple fix is to add a tiny sleep to the start of the run function::"

msgstr ""

"Una solución sencilla es añadir un pequeño *sleep* al comienzo de la función "

"run::"

#: ../Doc/faq/library.rst:271

msgid ""

"def thread_task(name, n):\n"

" time.sleep(0.001) # <--------------------!\n"

" for i in range(n):\n"

" print(name, i)\n"

"\n"

"for i in range(10):\n"

" T = threading.Thread(target=thread_task, args=(str(i), i))\n"

" T.start()\n"

"\n"

"time.sleep(10)"

msgstr ""

#: ../Doc/faq/library.rst:282

msgid ""

"Instead of trying to guess a good delay value for :func:`time.sleep`, it's "

"better to use some kind of semaphore mechanism. One idea is to use the :mod:"

"`queue` module to create a queue object, let each thread append a token to "

"the queue when it finishes, and let the main thread read as many tokens from "

"the queue as there are threads."

msgstr ""

"En vez de intentar adivinar un valor de retardo adecuado para :func:`time."

"sleep`, es mejor usar algún tipo de mecanismo de semáforo. Una idea es usar "

"el módulo :mod:`queue` para crear un objeto cola, permitiendo que cada hilo "

"añada un *token* a la cola cuando termine, y permitiendo al hilo principal "

"leer tantos tokens de la cola como hilos haya."

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

msgid "How do I parcel out work among a bunch of worker threads?"

msgstr "¿Cómo puedo dividir trabajo entre un grupo de hilos?"

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

msgid ""

"The easiest way is to use the :mod:`concurrent.futures` module, especially "

"the :mod:`~concurrent.futures.ThreadPoolExecutor` class."

msgstr ""

"La manera más fácil es usar el nuevo módulo :mod:`concurrent.futures`, "

"especialmente el módulo :mod:`~concurrent.futures.ThreadPoolExecutor`."

#: ../Doc/faq/library.rst:295

msgid ""

"Or, if you want fine control over the dispatching algorithm, you can write "

"your own logic manually. Use the :mod:`queue` module to create a queue "

"containing a list of jobs. The :class:`~queue.Queue` class maintains a list "

"of objects and has a ``.put(obj)`` method that adds items to the queue and a "

"``.get()`` method to return them. The class will take care of the locking "

"necessary to ensure that each job is handed out exactly once."

msgstr ""

"O, si quiere tener un control más preciso sobre el algoritmo de despacho, "

"puede escribir su propia lógica manualmente. Use el módulo :mod:`queue` para "

"crear una cola que contenga una lista de trabajos. La clase :class:`~queue."

"Queue` mantiene una lista de objetos y tiene un método ``.put(obj)`` que "

"añade elementos a la cola y un método ``.get()`` que los retorna. Esta clase "

"se encargará de los bloqueos necesarios para asegurar que cada trabajo se "

"reparte exactamente una vez."

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

msgid "Here's a trivial example::"

msgstr "Aquí hay un ejemplo trivial::"

#: ../Doc/faq/library.rst:304

#, python-format

msgid ""

"import threading, queue, time\n"

"\n"

"# The worker thread gets jobs off the queue. When the queue is empty, it\n"

"# assumes there will be no more work and exits.\n"

"# (Realistically workers will run until terminated.)\n"

"def worker():\n"

" print('Running worker')\n"

" time.sleep(0.1)\n"

" while True:\n"

" try:\n"

" arg = q.get(block=False)\n"

" except queue.Empty:\n"

" print('Worker', threading.current_thread(), end=' ')\n"

" print('queue empty')\n"

" break\n"

" else:\n"

" print('Worker', threading.current_thread(), end=' ')\n"

" print('running with argument', arg)\n"

" time.sleep(0.5)\n"

"\n"

"# Create queue\n"

"q = queue.Queue()\n"

"\n"

"# Start a pool of 5 workers\n"

"for i in range(5):\n"

" t = threading.Thread(target=worker, name='worker %i' % (i+1))\n"

" t.start()\n"

"\n"

"# Begin adding work to the queue\n"

"for i in range(50):\n"

" q.put(i)\n"

"\n"

"# Give threads time to run\n"

"print('Main thread sleeping')\n"

"time.sleep(5)"

msgstr ""

#: ../Doc/faq/library.rst:340

msgid "When run, this will produce the following output:"

msgstr "Cuando se ejecute, esto producirá la siguiente salida:"

#: ../Doc/faq/library.rst:342

msgid ""

"Running worker\n"

"Running worker\n"

"Running worker\n"

"Running worker\n"

"Running worker\n"

"Main thread sleeping\n"

"Worker <Thread(worker 1, started 130283832797456)> running with argument 0\n"

"Worker <Thread(worker 2, started 130283824404752)> running with argument 1\n"

"Worker <Thread(worker 3, started 130283816012048)> running with argument 2\n"

"Worker <Thread(worker 4, started 130283807619344)> running with argument 3\n"

"Worker <Thread(worker 5, started 130283799226640)> running with argument 4\n"

"Worker <Thread(worker 1, started 130283832797456)> running with argument 5\n"

"..."

msgstr ""

#: ../Doc/faq/library.rst:358

msgid ""

"Consult the module's documentation for more details; the :class:`~queue."

"Queue` class provides a featureful interface."

msgstr ""

"Consulte la documentación del módulo para más detalles; la clase :class:"

"`~queue.Queue` proporciona una interfaz llena de características."

#: ../Doc/faq/library.rst:363

msgid "What kinds of global value mutation are thread-safe?"

msgstr "¿Qué tipos de mutación de valores globales son *thread-safe*?"

#: ../Doc/faq/library.rst:365

msgid ""

"A :term:`global interpreter lock` (GIL) is used internally to ensure that "

"only one thread runs in the Python VM at a time. In general, Python offers "

"to switch among threads only between bytecode instructions; how frequently "

"it switches can be set via :func:`sys.setswitchinterval`. Each bytecode "

"instruction and therefore all the C implementation code reached from each "

"instruction is therefore atomic from the point of view of a Python program."

msgstr ""

"Un :term:`global interpreter lock` (GIL) se usa internamente para asegurar "

"que sólo un hilo corre a la vez en la VM de Python. En general, Python "

"ofrece cambiar entre hilos sólo en instrucciones bytecode; la frecuencia con "

"la que cambia se puede fijar vía :func:`sys.setswitchinterval`. Cada "

"instrucción bytecode y por lo tanto, toda la implementación de código C "

"alcanzada por cada instrucción, es atómica desde el punto de vista de un "

"programa Python."

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

msgid ""

"In theory, this means an exact accounting requires an exact understanding of "

"the PVM bytecode implementation. In practice, it means that operations on "

"shared variables of built-in data types (ints, lists, dicts, etc) that "

"\"look atomic\" really are."

msgstr ""

"En teoría, esto significa que un informe exacto requiere de un conocimiento "

"exacto de la implementación en bytecode de la PVM. En la práctica, esto "

"significa que las operaciones entre variables compartidas de tipos de datos "

"*built-in* (enteros, listas, diccionarios, etc.) que \"parecen atómicas\" "

"realmente lo son."

#: ../Doc/faq/library.rst:377

msgid ""

"For example, the following operations are all atomic (L, L1, L2 are lists, "

"D, D1, D2 are dicts, x, y are objects, i, j are ints)::"

msgstr ""

"Por ejemplo, las siguientes operaciones son todas atómicas (L, L1, L2 son "

"listas, D, D1, D2 son diccionarios, *x, y* son objetos, *i, j* son enteros)::"

#: ../Doc/faq/library.rst:380

msgid ""

"L.append(x)\n"

"L1.extend(L2)\n"

"x = L[i]\n"

"x = L.pop()\n"

"L1[i:j] = L2\n"

"L.sort()\n"

"x = y\n"

"x.field = y\n"

"D[x] = y\n"

"D1.update(D2)\n"

"D.keys()"

msgstr ""

#: ../Doc/faq/library.rst:392

msgid "These aren't::"

msgstr "Estas no lo son::"

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

msgid ""

"i = i+1\n"

"L.append(L[-1])\n"

"L[i] = L[j]\n"

"D[x] = D[x] + 1"

msgstr ""

#: ../Doc/faq/library.rst:399

#, fuzzy

msgid ""

"Operations that replace other objects may invoke those other objects' :meth:"

"`~object.__del__` method when their reference count reaches zero, and that "

"can affect things. This is especially true for the mass updates to "

"dictionaries and lists. When in doubt, use a mutex!"

msgstr ""

"Las operaciones que reemplazan otros objetos pueden invocar el método :meth:"

"`__del__` de esos otros objetos cuando su número de referencias alcance "

"cero, y eso puede afectar a otras cosas. Esto es especialmente cierto para "

"las actualizaciones en masa de diccionarios y listas. Cuando se esté en "

"duda, ¡use un mutex!"

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

msgid "Can't we get rid of the Global Interpreter Lock?"

msgstr "¿Podemos deshacernos del *Global Interpreter Lock*?"

#: ../Doc/faq/library.rst:408

msgid ""

"The :term:`global interpreter lock` (GIL) is often seen as a hindrance to "

"Python's deployment on high-end multiprocessor server machines, because a "

"multi-threaded Python program effectively only uses one CPU, due to the "

"insistence that (almost) all Python code can only run while the GIL is held."

msgstr ""

"El :term:`global interpreter lock` (GIL) se percibe a menudo como un "

"obstáculo en el despliegue de Python sobre máquinas servidoras finales de "

"múltiples procesadores, porque un programa Python multihilo efectivamente "

"sólo usa una CPU, debido a la exigencia de que (casi) todo el código Python "

"sólo puede correr mientras el GIL esté activado."

#: ../Doc/faq/library.rst:413

msgid ""

"With the approval of :pep:`703` work is now underway to remove the GIL from "

"the CPython implementation of Python. Initially it will be implemented as "

"an optional compiler flag when building the interpreter, and so separate "

"builds will be available with and without the GIL. Long-term, the hope is "

"to settle on a single build, once the performance implications of removing "

"the GIL are fully understood. Python 3.13 is likely to be the first release "

"containing this work, although it may not be completely functional in this "

"release."

msgstr ""

#: ../Doc/faq/library.rst:422

#, fuzzy, python-format

msgid ""

"The current work to remove the GIL is based on a `fork of Python 3.9 with "

"the GIL removed <https://github.com/colesbury/nogil>`_ by Sam Gross. Prior "

"to that, in the days of Python 1.5, Greg Stein actually implemented a "

"comprehensive patch set (the \"free threading\" patches) that removed the "

"GIL and replaced it with fine-grained locking. Adam Olsen did a similar "

"experiment in his `python-safethread <https://code.google.com/archive/p/"

"python-safethread>`_ project. Unfortunately, both of these earlier "

"experiments exhibited a sharp drop in single-thread performance (at least "

"30% slower), due to the amount of fine-grained locking necessary to "

"compensate for the removal of the GIL. The Python 3.9 fork is the first "

"attempt at removing the GIL with an acceptable performance impact."

msgstr ""

"En los días de Python 1.5, Greg Stein de hecho implementó un conjunto amplio "

"de parches (los parches \"libres de hilo\") que eliminaba el GIL y lo "

"reemplazaba con un bloqueo de grano fino. Adam Olsen hizo recientemente un "

"experimento similar con su proyecto `python-safethread <https://code.google."

"com/archive/p/python-safethread>`_. Desafortunadamente, ambos experimentos "

"mostraron una aguda caída en el rendimiento (al menos del 30% o más baja), "

"debido a la cantidad de bloqueos de grano fino necesarios para compensar la "

"eliminación del GIL."

#: ../Doc/faq/library.rst:437

#, fuzzy

msgid ""

"The presence of the GIL in current Python releases doesn't mean that you "

"can't make good use of Python on multi-CPU machines! You just have to be "

"creative with dividing the work up between multiple *processes* rather than "

"multiple *threads*. The :class:`~concurrent.futures.ProcessPoolExecutor` "

"class in the new :mod:`concurrent.futures` module provides an easy way of "

"doing so; the :mod:`multiprocessing` module provides a lower-level API in "

"case you want more control over dispatching of tasks."

msgstr ""

"¡Esto no significa que no pueda hacer buen uso de Python en máquinas de "

"múltiples CPU! Usted sólo tiene que ser creativo a la hora de dividir el "

"trabajo entre múltiples *procesos* en vez de entre múltiples *hilos*. La "

"clase :class:`~concurrent.futures.ProcessPoolExecutor` del nuevo módulo :mod:"

"`concurrent.futures` proporciona una manera sencilla de hacer esto; el "

"módulo :mod:`multiprocessing` proporciona una API de bajo nivel en caso de "

"que se quiera tener un mayor control sobre el despacho de las tareas."

#: ../Doc/faq/library.rst:446

msgid ""

"Judicious use of C extensions will also help; if you use a C extension to "

"perform a time-consuming task, the extension can release the GIL while the "

"thread of execution is in the C code and allow other threads to get some "

"work done. Some standard library modules such as :mod:`zlib` and :mod:"

"`hashlib` already do this."

msgstr ""

"El uso sensato de extensiones C también ayudará; si usa una extensión C para "

"ejecutar una tarea que consume mucho tiempo, la extensión puede liberar al "

"GIL mientras el hilo de ejecución esté en el código C y permite a otros "

"hilos hacer trabajo. Algunos módulos de la biblioteca estándar tales como :"

"mod:`zlib` y :mod:`hashlib` ya lo hacen."

#: ../Doc/faq/library.rst:452

msgid ""

"An alternative approach to reducing the impact of the GIL is to make the GIL "

"a per-interpreter-state lock rather than truly global. This was :ref:`first "

"implemented in Python 3.12 <whatsnew312-pep684>` and is available in the C "

"API. A Python interface to it is expected in Python 3.13. The main "

"limitation to it at the moment is likely to be 3rd party extension modules, "

"since these must be written with multiple interpreters in mind in order to "

"be usable, so many older extension modules will not be usable."

msgstr ""

#: ../Doc/faq/library.rst:462

msgid "Input and Output"

msgstr "Entrada y salida"

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

msgid "How do I delete a file? (And other file questions...)"

msgstr "¿Cómo borro un fichero? (Y otras preguntas sobre ficheros...)"

#: ../Doc/faq/library.rst:467

msgid ""

"Use ``os.remove(filename)`` or ``os.unlink(filename)``; for documentation, "

"see the :mod:`os` module. The two functions are identical; :func:`~os."

"unlink` is simply the name of the Unix system call for this function."

msgstr ""

"Use ``os.remove(filename)`` o ``os.unlink(filename)``; para la "

"documentación, vea el módulo :mod:`os`. Las dos funciones son idénticas; :"

"func:`~os.unlink` es simplemente el nombre de la llamada al sistema UNIX "

"para esta función."

#: ../Doc/faq/library.rst:471

msgid ""

"To remove a directory, use :func:`os.rmdir`; use :func:`os.mkdir` to create "

"one. ``os.makedirs(path)`` will create any intermediate directories in "

"``path`` that don't exist. ``os.removedirs(path)`` will remove intermediate "

"directories as long as they're empty; if you want to delete an entire "

"directory tree and its contents, use :func:`shutil.rmtree`."

msgstr ""

"Para borrar un directorio, use :func:`os.rmdir`; use :func:`os.mkdir` para "

"crear uno. ``os.makedirs(path)`` creará cualquier directorio intermedio que "

"no exista en ``path``. ``os.removedirs(path)`` borrará los directorios "

"intermedios siempre y cuando estén vacíos; si quiere borrar un árbol de "

"directorios completo y sus contenidos, use :func:`shutil.rmtree`."

#: ../Doc/faq/library.rst:477

msgid "To rename a file, use ``os.rename(old_path, new_path)``."

msgstr "Para renombrar un fichero, use ``os.rename(old_path, new_path)``."

#: ../Doc/faq/library.rst:479

msgid ""

"To truncate a file, open it using ``f = open(filename, \"rb+\")``, and use "

"``f.truncate(offset)``; offset defaults to the current seek position. "

"There's also ``os.ftruncate(fd, offset)`` for files opened with :func:`os."

"open`, where *fd* is the file descriptor (a small integer)."

msgstr ""

"Para truncar un fichero, ábralo usando ``f = open(filename, \"rb+\")``, y "

"use ``f.truncate(offset)``; el desplazamiento toma por defecto la posición "

"actual de búsqueda. También existe ``os.ftruncate(fd, offset)`` para "

"ficheros abiertos con :func:`os.open`, donde *fd* es el descriptor del "

"fichero (un entero pequeño)."

#: ../Doc/faq/library.rst:484

msgid ""

"The :mod:`shutil` module also contains a number of functions to work on "

"files including :func:`~shutil.copyfile`, :func:`~shutil.copytree`, and :"

"func:`~shutil.rmtree`."

msgstr ""

"El módulo :mod:`shutil` también contiene distintas funciones para trabajar "

"con ficheros incluyendo :func:`~shutil.copyfile`, :func:`~shutil.copytree` "

"y :func:`~shutil.rmtree`."

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

msgid "How do I copy a file?"

msgstr "¿Cómo copio un fichero?"

#: ../Doc/faq/library.rst:492

msgid ""

"The :mod:`shutil` module contains a :func:`~shutil.copyfile` function. Note "

"that on Windows NTFS volumes, it does not copy `alternate data streams "

"<https://en.wikipedia.org/wiki/NTFS#Alternate_data_stream_(ADS)>`_ nor "

"`resource forks <https://en.wikipedia.org/wiki/Resource_fork>`__ on macOS "

"HFS+ volumes, though both are now rarely used. It also doesn't copy file "

"permissions and metadata, though using :func:`shutil.copy2` instead will "

"preserve most (though not all) of it."

msgstr ""

"El módulo :mod:`shutil` contiene una función :func:`~shutil.copyfile`. "

"Nótese que en volúmenes de Windows NTFS, no copia los `flujos alternativos "

"de datos (ADS) <https://es.wikipedia.org/wiki/Alternate_Data_Streams>`_ ni "

"las `bifurcaciones de recursos (resource forks) <https://en.wikipedia.org/"

"wiki/Resource_fork>`_ en los volúmenes macOS HFS+, aunque ahora ambos rara "

"vez son utilizados. Además tampoco copia los permisos ni metadatos de los "

"archivos, pero si se usa :func:`shutil.copy2` en su lugar, se preservará la "

"mayor parte (aunque no todo)."

#: ../Doc/faq/library.rst:503

msgid "How do I read (or write) binary data?"

msgstr "¿Cómo leo (o escribo) datos binarios?"

#: ../Doc/faq/library.rst:505

msgid ""

"To read or write complex binary data formats, it's best to use the :mod:"

"`struct` module. It allows you to take a string containing binary data "

"(usually numbers) and convert it to Python objects; and vice versa."

msgstr ""

"Para leer o escribir formatos binarios de datos complejos, es mejor usar el "

"módulo :mod:`struct`. Esto le permite tomar una cadena de texto que contiene "

"datos binarios (normalmente números) y convertirla a objetos de Python; y "

"viceversa."

#: ../Doc/faq/library.rst:509

msgid ""

"For example, the following code reads two 2-byte integers and one 4-byte "

"integer in big-endian format from a file::"

msgstr ""

"Por ejemplo, el siguiente código lee de un fichero dos enteros de 2-bytes y "

"uno de 4-bytes en formato *big-endian*::"

#: ../Doc/faq/library.rst:512

msgid ""

"import struct\n"

"\n"

"with open(filename, \"rb\") as f:\n"

" s = f.read(8)\n"

" x, y, z = struct.unpack(\">hhl\", s)"

msgstr ""

#: ../Doc/faq/library.rst:518

msgid ""

"The '>' in the format string forces big-endian data; the letter 'h' reads "

"one \"short integer\" (2 bytes), and 'l' reads one \"long integer\" (4 "

"bytes) from the string."

msgstr ""

"El '>' en la cadena de formato fuerza los datos a *big-endian*; la letra 'h' "

"lee un \"entero corto\" (2 bytes), y 'l' lee un \"entero largo\" (4 bytes) "

"desde la cadena de texto."

#: ../Doc/faq/library.rst:522

msgid ""

"For data that is more regular (e.g. a homogeneous list of ints or floats), "

"you can also use the :mod:`array` module."

msgstr ""

"Para datos que son más regulares (por ejemplo una lista homogénea de enteros "

"o flotantes), puede también usar el módulo :mod:`array`."

#: ../Doc/faq/library.rst:527

msgid ""

"To read and write binary data, it is mandatory to open the file in binary "

"mode (here, passing ``\"rb\"`` to :func:`open`). If you use ``\"r\"`` "

"instead (the default), the file will be open in text mode and ``f.read()`` "

"will return :class:`str` objects rather than :class:`bytes` objects."

msgstr ""

"Para leer y escribir datos binarios, es obligatorio abrir el fichero en modo "

"binario (aquí, pasando ``\"rb\"`` a :func:`open`). Si, en cambio, usa "

"``\"r\"`` (por defecto), el fichero se abrirá en modo texto y ``f.read()`` "

"retornará objetos :class:`str` en vez de objetos :class:`bytes`."

#: ../Doc/faq/library.rst:535

msgid "I can't seem to use os.read() on a pipe created with os.popen(); why?"

msgstr ""

"No consigo usar os.read() en un *pipe* creado con os.popen(); ¿por qué?"

#: ../Doc/faq/library.rst:537

msgid ""

":func:`os.read` is a low-level function which takes a file descriptor, a "

"small integer representing the opened file. :func:`os.popen` creates a high-"

"level file object, the same type returned by the built-in :func:`open` "

"function. Thus, to read *n* bytes from a pipe *p* created with :func:`os."

"popen`, you need to use ``p.read(n)``."

msgstr ""

":func:`os.read` es una función de bajo nivel que recibe un descriptor de "

"fichero, un entero pequeño representando el fichero abierto. :func:`os."

"popen` crea un objeto fichero de alto nivel, el mismo tipo que retorna la "

"función *built-in* :func:`open`. Así, para leer *n* bytes de un *pipe* *p* "

"creado con :func:`os.popen`, necesita usar ``p.read(n)``."

#: ../Doc/faq/library.rst:623

msgid "How do I access the serial (RS232) port?"

msgstr "¿Cómo accedo al puerto serial (RS232)?"

#: ../Doc/faq/library.rst:625

msgid "For Win32, OSX, Linux, BSD, Jython, IronPython:"

msgstr "Para Win32, OSX, Linux, BSD, Jython, IronPython:"

#: ../Doc/faq/library.rst:627

msgid ":pypi:`pyserial`"

msgstr ""

#: ../Doc/faq/library.rst:629

msgid "For Unix, see a Usenet post by Mitch Chapman:"

msgstr "Para Unix, vea una publicación Usenet de Mitch Chapman:"

#: ../Doc/faq/library.rst:631

msgid "https://groups.google.com/groups?selm=34A04430.CF9@ohioee.com"

msgstr "https://groups.google.com/groups?selm=34A04430.CF9@ohioee.com"

#: ../Doc/faq/library.rst:635

msgid "Why doesn't closing sys.stdout (stdin, stderr) really close it?"

msgstr "¿Por qué al cerrar sys.stdout (stdin, stderr) realmente no se cierran?"

#: ../Doc/faq/library.rst:637

msgid ""

"Python :term:`file objects <file object>` are a high-level layer of "

"abstraction on low-level C file descriptors."

msgstr ""

"Los :term:`objetos de tipo fichero <file object>` en Python son una capa de "

"abstracción de alto nivel sobre los descriptores de ficheros de bajo nivel "

"de C."

#: ../Doc/faq/library.rst:640

msgid ""

"For most file objects you create in Python via the built-in :func:`open` "

"function, ``f.close()`` marks the Python file object as being closed from "

"Python's point of view, and also arranges to close the underlying C file "

"descriptor. This also happens automatically in ``f``'s destructor, when "

"``f`` becomes garbage."

msgstr ""

"Para la mayoría de objetos de tipo fichero que cree en Python vía la función "

"*built-in* :func:`open`, ``f.close()`` marca el objeto de tipo fichero "