# 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: 2021-03-19 11:16+0100\n"

"PO-Revision-Date: 2021-08-02 01:28+0200\n"

"Last-Translator: Cristián Maureira-Fredes <cmaureirafredes@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.8.0\n"

"X-Generator: Poedit 3.0\n"

#: ../Doc/c-api/intro.rst:8

msgid "Introduction"

msgstr "Introducción"

#: ../Doc/c-api/intro.rst:10

msgid ""

"The Application Programmer's Interface to Python gives C and C++ programmers "

"access to the Python interpreter at a variety of levels. The API is equally "

"usable from C++, but for brevity it is generally referred to as the Python/C "

"API. There are two fundamentally different reasons for using the Python/C "

"API. The first reason is to write *extension modules* for specific purposes; "

"these are C modules that extend the Python interpreter. This is probably "

"the most common use. The second reason is to use Python as a component in a "

"larger application; this technique is generally referred to as :dfn:"

"`embedding` Python in an application."

msgstr ""

"La interfaz del programador de aplicaciones (API) con Python brinda a los "

"programadores de C y C++ acceso al intérprete de Python en una variedad de "

"niveles. La API es igualmente utilizable desde C++, pero por brevedad "

"generalmente se conoce como la API Python/C. Hay dos razones "

"fundamentalmente diferentes para usar la API Python/C. La primera razón es "

"escribir *módulos de extensión* para propósitos específicos; Estos son "

"módulos C que extienden el intérprete de Python. Este es probablemente el "

"uso más común. La segunda razón es usar Python como componente en una "

"aplicación más grande; Esta técnica se conoce generalmente como integración "

"(:dfn:`embedding`) Python en una aplicación."

#: ../Doc/c-api/intro.rst:20

msgid ""

"Writing an extension module is a relatively well-understood process, where a "

"\"cookbook\" approach works well. There are several tools that automate the "

"process to some extent. While people have embedded Python in other "

"applications since its early existence, the process of embedding Python is "

"less straightforward than writing an extension."

msgstr ""

"Escribir un módulo de extensión es un proceso relativamente bien entendido, "

"donde un enfoque de \"libro de cocina\" (*cookbook*) funciona bien. Hay "

"varias herramientas que automatizan el proceso hasta cierto punto. Si bien "

"las personas han integrado Python en otras aplicaciones desde su existencia "

"temprana, el proceso de integrar Python es menos sencillo que escribir una "

"extensión."

#: ../Doc/c-api/intro.rst:26

msgid ""

"Many API functions are useful independent of whether you're embedding or "

"extending Python; moreover, most applications that embed Python will need "

"to provide a custom extension as well, so it's probably a good idea to "

"become familiar with writing an extension before attempting to embed Python "

"in a real application."

msgstr ""

"Muchas funciones API son útiles independientemente de si está integrando o "

"extendiendo Python; Además, la mayoría de las aplicaciones que integran "

"Python también necesitarán proporcionar una extensión personalizada, por lo "

"que probablemente sea una buena idea familiarizarse con la escritura de una "

"extensión antes de intentar integrar Python en una aplicación real."

#: ../Doc/c-api/intro.rst:34

msgid "Coding standards"

msgstr "Estándares de codificación"

#: ../Doc/c-api/intro.rst:36

msgid ""

"If you're writing C code for inclusion in CPython, you **must** follow the "

"guidelines and standards defined in :PEP:`7`. These guidelines apply "

"regardless of the version of Python you are contributing to. Following "

"these conventions is not necessary for your own third party extension "

"modules, unless you eventually expect to contribute them to Python."

msgstr ""

"Si está escribiendo código C para su inclusión en CPython, **debe** seguir "

"las pautas y estándares definidos en :PEP:`7`. Estas pautas se aplican "

"independientemente de la versión de Python a la que esté contribuyendo. "

"Seguir estas convenciones no es necesario para sus propios módulos de "

"extensión de terceros, a menos que eventualmente espere contribuir con ellos "

"a Python."

#: ../Doc/c-api/intro.rst:46

msgid "Include Files"

msgstr "Archivos de cabecera (*Include*)"

#: ../Doc/c-api/intro.rst:48

msgid ""

"All function, type and macro definitions needed to use the Python/C API are "

"included in your code by the following line::"

msgstr ""

"Todas las definiciones de función, tipo y macro necesarias para usar la API "

"Python/C se incluyen en su código mediante la siguiente línea::"

#: ../Doc/c-api/intro.rst:54

msgid ""

"This implies inclusion of the following standard headers: ``<stdio.h>``, "

"``<string.h>``, ``<errno.h>``, ``<limits.h>``, ``<assert.h>`` and ``<stdlib."

"h>`` (if available)."

msgstr ""

"Esto implica la inclusión de los siguientes archivos de encabezado estándar: "

"``<stdio.h>``, ``<string.h>``, ``<errno.h>``, ``<limits.h>``, ``<assert.h>`` "

"y ``<stdlib.h>`` (si está disponible)."

#: ../Doc/c-api/intro.rst:60

msgid ""

"Since Python may define some pre-processor definitions which affect the "

"standard headers on some systems, you *must* include :file:`Python.h` before "

"any standard headers are included."

msgstr ""

"Dado que Python puede definir algunas definiciones de preprocesador que "

"afectan los encabezados estándar en algunos sistemas, *debe* incluir :file:"

"`Python.h` antes de incluir encabezados estándar."

#: ../Doc/c-api/intro.rst:64

msgid ""

"It is recommended to always define ``PY_SSIZE_T_CLEAN`` before including "

"``Python.h``. See :ref:`arg-parsing` for a description of this macro."

msgstr ""

"Se recomienda definir siempre ``PY_SSIZE_T_CLEAN`` antes de incluir ``Python."

"h``. Consulte :ref:`arg-parsing` para obtener una descripción de este macro."

#: ../Doc/c-api/intro.rst:67

msgid ""

"All user visible names defined by Python.h (except those defined by the "

"included standard headers) have one of the prefixes ``Py`` or ``_Py``. "

"Names beginning with ``_Py`` are for internal use by the Python "

"implementation and should not be used by extension writers. Structure member "

"names do not have a reserved prefix."

msgstr ""

"Todos los nombres visibles del usuario definidos por ``Python.h`` (excepto "

"los definidos por los encabezados estándar incluidos) tienen uno de los "

"prefijos ``Py`` o ``_Py``. Los nombres que comienzan con ``_Py`` son para "

"uso interno de la implementación de Python y no deben ser utilizados por "

"escritores de extensiones. Los nombres de miembros de estructura no tienen "

"un prefijo reservado."

#: ../Doc/c-api/intro.rst:74

msgid ""

"User code should never define names that begin with ``Py`` or ``_Py``. This "

"confuses the reader, and jeopardizes the portability of the user code to "

"future Python versions, which may define additional names beginning with one "

"of these prefixes."

msgstr ""

"El código de usuario nunca debe definir nombres que comiencen con ``Py`` o "

"``_Py``. Esto confunde al lector y pone en peligro la portabilidad del "

"código de usuario para futuras versiones de Python, que pueden definir "

"nombres adicionales que comienzan con uno de estos prefijos."

#: ../Doc/c-api/intro.rst:79

#, python-format

msgid ""

"The header files are typically installed with Python. On Unix, these are "

"located in the directories :file:`{prefix}/include/pythonversion/` and :file:"

"`{exec_prefix}/include/pythonversion/`, where :envvar:`prefix` and :envvar:"

"`exec_prefix` are defined by the corresponding parameters to Python's :"

"program:`configure` script and *version* is ``'%d.%d' % sys."

"version_info[:2]``. On Windows, the headers are installed in :file:"

"`{prefix}/include`, where :envvar:`prefix` is the installation directory "

"specified to the installer."

msgstr ""

"Los archivos de encabezado generalmente se instalan con Python. En Unix, "

"estos se encuentran en los directorios :file:`{prefix}/include/pythonversion/"

"` y :file:`{exec_prefix}/include/pythonversion/`, donde :envvar:`prefix` y :"

"envvar:`exec_prefix` están definidos por los parámetros correspondientes al "

"programa de Python :program:`configure` y *version* es ``'%d.%d' % sys."

"version_info[:2]``. En Windows, los encabezados se instalan en :file:"

"`{prefix}/include`, donde :envvar:`prefix` es el directorio de instalación "

"especificado para el instalador."

#: ../Doc/c-api/intro.rst:88

msgid ""

"To include the headers, place both directories (if different) on your "

"compiler's search path for includes. Do *not* place the parent directories "

"on the search path and then use ``#include <pythonX.Y/Python.h>``; this will "

"break on multi-platform builds since the platform independent headers under :"

"envvar:`prefix` include the platform specific headers from :envvar:"

"`exec_prefix`."

msgstr ""

"Para incluir los encabezados, coloque ambos directorios (si son diferentes) "

"en la ruta de búsqueda de su compilador para incluir. *No* coloque los "

"directorios principales en la ruta de búsqueda y luego use ``#include "

"<pythonX.Y/Python.h>``; esto se romperá en las compilaciones multiplataforma "

"ya que los encabezados independientes de la plataforma bajo :envvar:`prefix` "

"incluyen los encabezados específicos de la plataforma de :envvar:"

"`exec_prefix`."

#: ../Doc/c-api/intro.rst:95

msgid ""

"C++ users should note that although the API is defined entirely using C, the "

"header files properly declare the entry points to be ``extern \"C\"``. As a "

"result, there is no need to do anything special to use the API from C++."

msgstr ""

"Los usuarios de C++ deben tener en cuenta que aunque la API se define "

"completamente usando C, los archivos de encabezado declaran correctamente "

"que los puntos de entrada son ``extern \"C\"``. Como resultado, no es "

"necesario hacer nada especial para usar la API desde C++."

#: ../Doc/c-api/intro.rst:101

msgid "Useful macros"

msgstr "Macros útiles"

#: ../Doc/c-api/intro.rst:103

msgid ""

"Several useful macros are defined in the Python header files. Many are "

"defined closer to where they are useful (e.g. :c:macro:`Py_RETURN_NONE`). "

"Others of a more general utility are defined here. This is not necessarily "

"a complete listing."

msgstr ""

"Varias macros útiles se definen en los archivos de encabezado de Python. "

"Muchos se definen más cerca de donde son útiles (por ejemplo :c:macro:"

"`Py_RETURN_NONE`). Otros de una utilidad más general se definen aquí. Esto "

"no es necesariamente una lista completa."

#: ../Doc/c-api/intro.rst:110

msgid ""

"Use this when you have a code path that cannot be reached by design. For "

"example, in the ``default:`` clause in a ``switch`` statement for which all "

"possible values are covered in ``case`` statements. Use this in places "

"where you might be tempted to put an ``assert(0)`` or ``abort()`` call."

msgstr ""

"Use esto cuando tenga una ruta de código a la que no se pueda acceder por "

"diseño. Por ejemplo, en la cláusula ``default:`` en una declaración "

"``switch`` para la cual todos los valores posibles están cubiertos en "

"declaraciones ``case``. Use esto en lugares donde podría tener la tentación "

"de poner una llamada ``assert(0)`` o ``abort()``."

#: ../Doc/c-api/intro.rst:115

msgid ""

"In release mode, the macro helps the compiler to optimize the code, and "

"avoids a warning about unreachable code. For example, the macro is "

"implemented with ``__builtin_unreachable()`` on GCC in release mode."

msgstr ""

"En el modo de lanzamiento, la macro ayuda al compilador a optimizar el "

"código y evita una advertencia sobre el código inalcanzable. Por ejemplo, la "

"macro se implementa con ``__builtin_unreachable()`` en GCC en modo de "

"lanzamiento."

#: ../Doc/c-api/intro.rst:119

msgid ""

"A use for ``Py_UNREACHABLE()`` is following a call a function that never "

"returns but that is not declared :c:macro:`_Py_NO_RETURN`."

msgstr ""

"Un uso de ``Py_UNREACHABLE()`` es seguir una llamada a una función que nunca "

"retorna pero que no está declarada :c:macro:`_Py_NO_RETURN`."

#: ../Doc/c-api/intro.rst:122

msgid ""

"If a code path is very unlikely code but can be reached under exceptional "

"case, this macro must not be used. For example, under low memory condition "

"or if a system call returns a value out of the expected range. In this "

"case, it's better to report the error to the caller. If the error cannot be "

"reported to caller, :c:func:`Py_FatalError` can be used."

msgstr ""

"Si una ruta de código es un código muy poco probable pero se puede acceder "

"en casos excepcionales, esta macro no debe utilizarse. Por ejemplo, en "

"condiciones de poca memoria o si una llamada al sistema retorna un valor "

"fuera del rango esperado. En este caso, es mejor informar el error a la "

"persona que llama. Si no se puede informar del error a la persona que llama, "

"se puede utilizar :c:func:`Py_FatalError`."

#: ../Doc/c-api/intro.rst:132

msgid "Return the absolute value of ``x``."

msgstr "Retorna el valor absoluto de ``x``."

#: ../Doc/c-api/intro.rst:138

msgid "Return the minimum value between ``x`` and ``y``."

msgstr "Retorna el valor mínimo entre ``x`` e ``y``."

#: ../Doc/c-api/intro.rst:144

msgid "Return the maximum value between ``x`` and ``y``."

msgstr "Retorna el valor máximo entre ``x`` e ``y``."

#: ../Doc/c-api/intro.rst:150

msgid ""

"Convert ``x`` to a C string. E.g. ``Py_STRINGIFY(123)`` returns ``\"123\"``."

msgstr ""

"Convierte ``x`` en una cadena de caracteres C. Por ejemplo, "

"``Py_STRINGIFY(123)`` retorna ``\"123\"``."

#: ../Doc/c-api/intro.rst:157

msgid "Return the size of a structure (``type``) ``member`` in bytes."

msgstr "Retorna el tamaño de una estructura (``type``) ``member`` en bytes."

#: ../Doc/c-api/intro.rst:163

msgid ""

"Argument must be a character or an integer in the range [-128, 127] or [0, "

"255]. This macro returns ``c`` cast to an ``unsigned char``."

msgstr ""

"El argumento debe ser un carácter o un número entero en el rango [-128, 127] "

"o [0, 255]. Este macro retorna la conversión ``c`` a un ``unsigned char``."

#: ../Doc/c-api/intro.rst:168

msgid ""

"Like ``getenv(s)``, but returns ``NULL`` if :option:`-E` was passed on the "

"command line (i.e. if ``Py_IgnoreEnvironmentFlag`` is set)."

msgstr ""

"Al igual que ``getenv(s)``, pero retorna ``NULL`` si: la opción :option:`-E` "

"se pasó en la línea de comando (es decir, si se establece "

"``Py_IgnoreEnvironmentFlag``)."

#: ../Doc/c-api/intro.rst:173

msgid ""

"Use this for unused arguments in a function definition to silence compiler "

"warnings. Example: ``int func(int a, int Py_UNUSED(b)) { return a; }``."

msgstr ""

"Use esto para argumentos no utilizados en una definición de función para "

"silenciar las advertencias del compilador. Ejemplo: ``int func(int a, int "

"Py_UNUSED(b)) {return a; }``."

#: ../Doc/c-api/intro.rst:180

msgid ""

"Use this for deprecated declarations. The macro must be placed before the "

"symbol name."

msgstr ""

"Use esto para declaraciones obsoletas. El macro debe colocarse antes del "

"nombre del símbolo."

#: ../Doc/c-api/intro.rst:183 ../Doc/c-api/intro.rst:198

#: ../Doc/c-api/intro.rst:216

msgid "Example::"

msgstr "Ejemplo::"

#: ../Doc/c-api/intro.rst:187

msgid "MSVC support was added."

msgstr "Soporte para MSVC fue agregado."

#: ../Doc/c-api/intro.rst:192

msgid ""

"Creates a variable with name ``name`` that can be used in docstrings. If "

"Python is built without docstrings, the value will be empty."

msgstr ""

"Crea una variable con el nombre ``name`` que se puede usar en *docstrings*. "

"Si Python se construye sin *docstrings*, el valor estará vacío."

#: ../Doc/c-api/intro.rst:195

msgid ""

"Use :c:macro:`PyDoc_STRVAR` for docstrings to support building Python "

"without docstrings, as specified in :pep:`7`."

msgstr ""

"Utilice :c:macro:`PyDoc_STRVAR` para que los *docstrings* admitan la "

"construcción de Python sin *docstrings*, como se especifica en :pep:`7`."

#: ../Doc/c-api/intro.rst:210

msgid ""

"Creates a docstring for the given input string or an empty string if "

"docstrings are disabled."

msgstr ""

"Crea un *docstring* para la cadena de caracteres de entrada dada o una "

"cadena vacía si los *docstrings* están deshabilitados."

#: ../Doc/c-api/intro.rst:213

msgid ""

"Use :c:macro:`PyDoc_STR` in specifying docstrings to support building Python "

"without docstrings, as specified in :pep:`7`."

msgstr ""

"Utilice :c:macro:`PyDoc_STR` al especificar *docstrings* para admitir la "

"construcción de Python sin *docstrings*, como se especifica en :pep:`7`."

#: ../Doc/c-api/intro.rst:227

msgid "Objects, Types and Reference Counts"

msgstr "Objetos, tipos y conteos de referencias"

#: ../Doc/c-api/intro.rst:231

msgid ""

"Most Python/C API functions have one or more arguments as well as a return "

"value of type :c:type:`PyObject*`. This type is a pointer to an opaque data "

"type representing an arbitrary Python object. Since all Python object types "

"are treated the same way by the Python language in most situations (e.g., "

"assignments, scope rules, and argument passing), it is only fitting that "

"they should be represented by a single C type. Almost all Python objects "

"live on the heap: you never declare an automatic or static variable of type :"

"c:type:`PyObject`, only pointer variables of type :c:type:`PyObject*` can "

"be declared. The sole exception are the type objects; since these must "

"never be deallocated, they are typically static :c:type:`PyTypeObject` "

"objects."

msgstr ""

"La mayoría de las funciones de Python/C API tienen uno o más argumentos, así "

"como un valor de retorno de tipo :c:type:`PyObject*`. Este tipo es un "

"puntero a un tipo de datos opaco que representa un objeto arbitrario de "

"Python. Dado que todos los tipos de objetos Python son tratados de la misma "

"manera por el lenguaje Python en la mayoría de las situaciones (por ejemplo, "

"asignaciones, reglas de alcance y paso de argumentos), es apropiado que "

"estén representados por un solo tipo C. Casi todos los objetos de Python "

"viven en el montículo (*heap*): nunca declaras una variable automática o "

"estática de tipo :c:type:`PyObject`, solo se pueden declarar variables de "

"puntero de tipo :c:type:`PyObject*`. La única excepción son los objetos "

"tipo; como nunca deben desasignarse, son típicamente objetos estáticos :c:"

"type:`PyTypeObject`."

#: ../Doc/c-api/intro.rst:242

msgid ""

"All Python objects (even Python integers) have a :dfn:`type` and a :dfn:"

"`reference count`. An object's type determines what kind of object it is (e."

"g., an integer, a list, or a user-defined function; there are many more as "

"explained in :ref:`types`). For each of the well-known types there is a "

"macro to check whether an object is of that type; for instance, "

"``PyList_Check(a)`` is true if (and only if) the object pointed to by *a* is "

"a Python list."

msgstr ""

"Todos los objetos de Python (incluso los enteros de Python) tienen un tipo (:"

"dfn:`type`) y un conteo de referencia (:dfn:`reference count`). El tipo de "

"un objeto determina qué tipo de objeto es (por ejemplo, un número entero, "

"una lista o una función definida por el usuario; hay muchos más como se "

"explica en :ref:`types`). Para cada uno de los tipos conocidos hay un macro "

"para verificar si un objeto es de ese tipo; por ejemplo, ``PyList_Check(a)`` "

"es verdadero si (y solo si) el objeto al que apunta *a* es una lista de "

"Python."

#: ../Doc/c-api/intro.rst:253

msgid "Reference Counts"

msgstr "Conteo de Referencias"

#: ../Doc/c-api/intro.rst:255

msgid ""

"The reference count is important because today's computers have a finite "

"(and often severely limited) memory size; it counts how many different "

"places there are that have a reference to an object. Such a place could be "

"another object, or a global (or static) C variable, or a local variable in "

"some C function. When an object's reference count becomes zero, the object "

"is deallocated. If it contains references to other objects, their "

"reference count is decremented. Those other objects may be deallocated in "

"turn, if this decrement makes their reference count become zero, and so on. "

"(There's an obvious problem with objects that reference each other here; "

"for now, the solution is \"don't do that.\")"

msgstr ""

"El conteo de referencia es importante porque las computadoras de hoy tienen "

"un tamaño de memoria finito (y a menudo muy limitado); cuenta cuántos "

"lugares diferentes hay los cuales tienen una referencia a un objeto. Tal "

"lugar podría ser otro objeto, o una variable C global (o estática), o una "

"variable local en alguna función C. Cuando el recuento de referencia de un "

"objeto se convierte en cero, el objeto se desasigna. Si contiene referencias "

"a otros objetos, su recuento de referencias se reduce. Esos otros objetos "

"pueden ser desasignados a su vez, si esta disminución hace que su recuento "

"de referencia sea cero, y así sucesivamente. (Hay un problema obvio con los "

"objetos que se refieren entre sí aquí; por ahora, la solución es \"no hagas "

"eso\")."

#: ../Doc/c-api/intro.rst:270

msgid ""

"Reference counts are always manipulated explicitly. The normal way is to "

"use the macro :c:func:`Py_INCREF` to increment an object's reference count "

"by one, and :c:func:`Py_DECREF` to decrement it by one. The :c:func:"

"`Py_DECREF` macro is considerably more complex than the incref one, since it "

"must check whether the reference count becomes zero and then cause the "

"object's deallocator to be called. The deallocator is a function pointer "

"contained in the object's type structure. The type-specific deallocator "

"takes care of decrementing the reference counts for other objects contained "

"in the object if this is a compound object type, such as a list, as well as "

"performing any additional finalization that's needed. There's no chance "

"that the reference count can overflow; at least as many bits are used to "

"hold the reference count as there are distinct memory locations in virtual "

"memory (assuming ``sizeof(Py_ssize_t) >= sizeof(void*)``). Thus, the "

"reference count increment is a simple operation."

msgstr ""

"Los conteos de referencias siempre se manipulan explícitamente. La forma "

"normal es usar el macro :c:func:`Py_INCREF` para incrementar el conteo de "

"referencia de un objeto en uno, y :c:func:`Py_DECREF` para disminuirlo en "

"uno. El macro :c:func:`Py_DECREF` es considerablemente más compleja que la "

"*incref*, ya que debe verificar si el recuento de referencia se convierte en "

"cero y luego hacer que se llame al desasignador (*deallocator*) del objeto. "

"El desasignador es un puntero de función contenido en la estructura de tipo "

"del objeto. El desasignador específico del tipo se encarga de disminuir los "

"recuentos de referencia para otros objetos contenidos en el objeto si este "

"es un tipo de objeto compuesto, como una lista, así como realizar cualquier "

"finalización adicional que sea necesaria. No hay posibilidad de que el "

"conteo de referencia se desborde; se utilizan al menos tantos bits para "

"contener el recuento de referencia como ubicaciones de memoria distintas en "

"la memoria virtual (suponiendo ``sizeof(Py_ssize_t) >= sizeof(void*)``). Por "

"lo tanto, el incremento del recuento de referencia es una operación simple."

#: ../Doc/c-api/intro.rst:284

msgid ""

"It is not necessary to increment an object's reference count for every "

"local variable that contains a pointer to an object. In theory, the "

"object's reference count goes up by one when the variable is made to point "

"to it and it goes down by one when the variable goes out of scope. "

"However, these two cancel each other out, so at the end the reference count "

"hasn't changed. The only real reason to use the reference count is to "

"prevent the object from being deallocated as long as our variable is "

"pointing to it. If we know that there is at least one other reference to "

"the object that lives at least as long as our variable, there is no need to "

"increment the reference count temporarily. An important situation where "

"this arises is in objects that are passed as arguments to C functions in an "

"extension module that are called from Python; the call mechanism guarantees "

"to hold a reference to every argument for the duration of the call."

msgstr ""

"No es necesario incrementar el conteo de referencia de un objeto para cada "

"variable local que contiene un puntero a un objeto. En teoría, el conteo de "

"referencia del objeto aumenta en uno cuando se hace que la variable apunte "

"hacia él y disminuye en uno cuando la variable se sale del alcance. Sin "

"embargo, estos dos se cancelan entre sí, por lo que al final el recuento de "

"referencias no ha cambiado. La única razón real para usar el recuento de "

"referencia es evitar que el objeto pierda su asignación mientras nuestra "

"variable lo apunte. Si sabemos que hay al menos otra referencia al objeto "

"que vive al menos tanto como nuestra variable, no hay necesidad de "

"incrementar el recuento de referencias temporalmente. Una situación "

"importante donde esto surge es en los objetos que se pasan como argumentos a "

"las funciones de C en un módulo de extensión que se llama desde Python; El "

"mecanismo de llamada garantiza mantener una referencia a cada argumento "

"durante la duración de la llamada."

#: ../Doc/c-api/intro.rst:298

msgid ""

"However, a common pitfall is to extract an object from a list and hold on to "

"it for a while without incrementing its reference count. Some other "

"operation might conceivably remove the object from the list, decrementing "

"its reference count and possibly deallocating it. The real danger is that "

"innocent-looking operations may invoke arbitrary Python code which could do "

"this; there is a code path which allows control to flow back to the user "

"from a :c:func:`Py_DECREF`, so almost any operation is potentially dangerous."

msgstr ""

"Sin embargo, una trampa común es extraer un objeto de una lista y mantenerlo "

"por un tiempo sin incrementar su conteo de referencia. Es posible que alguna "

"otra operación elimine el objeto de la lista, disminuya su conteo de "

"referencias y posiblemente lo desasigne. El peligro real es que las "

"operaciones de aspecto inocente pueden invocar código arbitrario de Python "

"que podría hacer esto; hay una ruta de código que permite que el control "

"vuelva al usuario desde a :c:func:`Py_DECREF`, por lo que casi cualquier "

"operación es potencialmente peligrosa."

#: ../Doc/c-api/intro.rst:306

msgid ""

"A safe approach is to always use the generic operations (functions whose "

"name begins with ``PyObject_``, ``PyNumber_``, ``PySequence_`` or "

"``PyMapping_``). These operations always increment the reference count of "

"the object they return. This leaves the caller with the responsibility to "

"call :c:func:`Py_DECREF` when they are done with the result; this soon "

"becomes second nature."

msgstr ""

"Un enfoque seguro es utilizar siempre las operaciones genéricas (funciones "

"cuyo nombre comienza con ``PyObject_``, ``PyNumber_``, ``PySequence_`` o "

"``PyMapping_``). Estas operaciones siempre incrementan el recuento de "

"referencia del objeto que retornan. Esto deja a la persona que llama con la "

"responsabilidad de llamar :c:func:`Py_DECREF` cuando hayan terminado con el "

"resultado; Esto pronto se convierte en una segunda naturaleza."

#: ../Doc/c-api/intro.rst:316

msgid "Reference Count Details"

msgstr "Detalles del conteo de referencia"

#: ../Doc/c-api/intro.rst:318

msgid ""

"The reference count behavior of functions in the Python/C API is best "

"explained in terms of *ownership of references*. Ownership pertains to "

"references, never to objects (objects are not owned: they are always "

"shared). \"Owning a reference\" means being responsible for calling "

"Py_DECREF on it when the reference is no longer needed. Ownership can also "

"be transferred, meaning that the code that receives ownership of the "

"reference then becomes responsible for eventually decref'ing it by calling :"

"c:func:`Py_DECREF` or :c:func:`Py_XDECREF` when it's no longer needed---or "

"passing on this responsibility (usually to its caller). When a function "

"passes ownership of a reference on to its caller, the caller is said to "

"receive a *new* reference. When no ownership is transferred, the caller is "

"said to *borrow* the reference. Nothing needs to be done for a borrowed "

"reference."

msgstr ""

"El comportamiento del conteo de referencias de funciones en la API de Python/"

"C se explica mejor en términos de *propiedad de las referencias*. La "

"propiedad pertenece a referencias, nunca a objetos (los objetos no son "

"propiedad: siempre se comparten). \"Poseer una referencia\" significa ser "

"responsable de llamar a ``Py_DECREF`` cuando ya no se necesita la "

"referencia. La propiedad también se puede transferir, lo que significa que "

"el código que recibe la propiedad de la referencia se hace responsable de "

"eventualmente decretarla llamando a :c:func:`Py_DECREF` o :c:func:"

"`Py_XDECREF` cuando ya no es necesario --- o transmitir esta responsabilidad "

"(generalmente a la persona que llama). Cuando una función transfiere la "

"propiedad de una referencia a su llamador, se dice que el que llama recibe "

"una *nueva* referencia. Cuando no se transfiere ninguna propiedad, se dice "

"que la persona que llama *toma prestada* la referencia. No es necesario "

"hacer nada para obtener una referencia prestada."

#: ../Doc/c-api/intro.rst:331

msgid ""

"Conversely, when a calling function passes in a reference to an object, "

"there are two possibilities: the function *steals* a reference to the "

"object, or it does not. *Stealing a reference* means that when you pass a "

"reference to a function, that function assumes that it now owns that "

"reference, and you are not responsible for it any longer."

msgstr ""

"Por el contrario, cuando una función de llamada pasa una referencia a un "

"objeto, hay dos posibilidades: la función *roba* una referencia al objeto, o "

"no lo hace. *Robar una referencia* significa que cuando pasa una referencia "

"a una función, esa función asume que ahora posee esa referencia, y usted ya "

"no es responsable de ella."

#: ../Doc/c-api/intro.rst:341

msgid ""

"Few functions steal references; the two notable exceptions are :c:func:"

"`PyList_SetItem` and :c:func:`PyTuple_SetItem`, which steal a reference to "

"the item (but not to the tuple or list into which the item is put!). These "

"functions were designed to steal a reference because of a common idiom for "

"populating a tuple or list with newly created objects; for example, the code "

"to create the tuple ``(1, 2, \"three\")`` could look like this (forgetting "

"about error handling for the moment; a better way to code this is shown "

"below)::"

msgstr ""

"Pocas funciones roban referencias; las dos excepciones notables son :c:func:"

"`PyList_SetItem` y :c:func:`PyTuple_SetItem`, que roban una referencia al "

"elemento (¡pero no a la tupla o lista en la que se coloca el elemento!). "

"Estas funciones fueron diseñadas para robar una referencia debido a un "

"idioma común para poblar una tupla o lista con objetos recién creados; por "

"ejemplo, el código para crear la tupla ``(1, 2, \"tres\")`` podría verse así "

"(olvidando el manejo de errores por el momento; una mejor manera de "

"codificar esto se muestra a continuación)::"

#: ../Doc/c-api/intro.rst:356

msgid ""

"Here, :c:func:`PyLong_FromLong` returns a new reference which is immediately "

"stolen by :c:func:`PyTuple_SetItem`. When you want to keep using an object "

"although the reference to it will be stolen, use :c:func:`Py_INCREF` to grab "

"another reference before calling the reference-stealing function."

msgstr ""

"Aquí :c:func:`PyLong_FromLong` retorna una nueva referencia que es "

"inmediatamente robada por :c:func:`PyTuple_SetItem`. Cuando quiera seguir "

"usando un objeto aunque se le robe la referencia, use :c:func:`Py_INCREF` "

"para tomar otra referencia antes de llamar a la función de robo de "

"referencias."

#: ../Doc/c-api/intro.rst:361

msgid ""

"Incidentally, :c:func:`PyTuple_SetItem` is the *only* way to set tuple "

"items; :c:func:`PySequence_SetItem` and :c:func:`PyObject_SetItem` refuse to "

"do this since tuples are an immutable data type. You should only use :c:"

"func:`PyTuple_SetItem` for tuples that you are creating yourself."

msgstr ""

"Por cierto, :c:func:`PyTuple_SetItem` es la *única* forma de establecer "

"elementos de tupla; :c:func:`PySequence_SetItem` y :c:func:"

"`PyObject_SetItem` se niegan a hacer esto ya que las tuplas son un tipo de "

"datos inmutable. Solo debe usar :c:func:`PyTuple_SetItem` para las tuplas "

"que está creando usted mismo."

#: ../Doc/c-api/intro.rst:366

msgid ""

"Equivalent code for populating a list can be written using :c:func:"

"`PyList_New` and :c:func:`PyList_SetItem`."

msgstr ""

"El código equivalente para llenar una lista se puede escribir usando :c:func:"

"`PyList_New` y :c:func:`PyList_SetItem`."

#: ../Doc/c-api/intro.rst:369

msgid ""

"However, in practice, you will rarely use these ways of creating and "

"populating a tuple or list. There's a generic function, :c:func:"

"`Py_BuildValue`, that can create most common objects from C values, directed "

"by a :dfn:`format string`. For example, the above two blocks of code could "

"be replaced by the following (which also takes care of the error checking)::"

msgstr ""

"Sin embargo, en la práctica, rara vez utilizará estas formas de crear y "

"completar una tupla o lista. Hay una función genérica, :c:func:"

"`Py_BuildValue`, que puede crear los objetos más comunes a partir de valores "

"C, dirigidos por un una cadena de caracteres de formato (:dfn:`format "

"string`). Por ejemplo, los dos bloques de código anteriores podrían "

"reemplazarse por lo siguiente (que también se ocupa de la comprobación de "

"errores)::"

#: ../Doc/c-api/intro.rst:380

msgid ""

"It is much more common to use :c:func:`PyObject_SetItem` and friends with "

"items whose references you are only borrowing, like arguments that were "

"passed in to the function you are writing. In that case, their behaviour "

"regarding reference counts is much saner, since you don't have to increment "

"a reference count so you can give a reference away (\"have it be stolen\"). "

"For example, this function sets all items of a list (actually, any mutable "

"sequence) to a given item::"

msgstr ""

"Es mucho más común usar :c:func:`PyObject_SetItem` y amigos con elementos "

"cuyas referencias solo está prestando, como argumentos que se pasaron a la "

"función que está escribiendo. En ese caso, su comportamiento con respecto a "

"los recuentos de referencias es mucho más sensato, ya que no tiene que "

"incrementar un recuento de referencias para poder regalar una referencia "

"(\"robarla\"). Por ejemplo, esta función establece todos los elementos de "

"una lista (en realidad, cualquier secuencia mutable) en un elemento dado::"

#: ../Doc/c-api/intro.rst:410

msgid ""

"The situation is slightly different for function return values. While "

"passing a reference to most functions does not change your ownership "

"responsibilities for that reference, many functions that return a reference "

"to an object give you ownership of the reference. The reason is simple: in "

"many cases, the returned object is created on the fly, and the reference "

"you get is the only reference to the object. Therefore, the generic "

"functions that return object references, like :c:func:`PyObject_GetItem` "

"and :c:func:`PySequence_GetItem`, always return a new reference (the caller "

"becomes the owner of the reference)."

msgstr ""

"La situación es ligeramente diferente para los valores de retorno de la "

"función. Si bien pasar una referencia a la mayoría de las funciones no "

"cambia sus responsabilidades de propiedad para esa referencia, muchas "

"funciones que retornan una referencia a un objeto le otorgan la propiedad de "

"la referencia. La razón es simple: en muchos casos, el objeto retornado se "

"crea sobre la marcha, y la referencia que obtiene es la única referencia al "

"objeto. Por lo tanto, las funciones genéricas que retornan referencias de "

"objeto, como :c:func:`PyObject_GetItem` y :c:func:`PySequence_GetItem`, "

"siempre retornan una nueva referencia (la entidad que llama se convierte en "

"el propietario de la referencia)."

#: ../Doc/c-api/intro.rst:419

msgid ""

"It is important to realize that whether you own a reference returned by a "

"function depends on which function you call only --- *the plumage* (the type "

"of the object passed as an argument to the function) *doesn't enter into it!"

"* Thus, if you extract an item from a list using :c:func:`PyList_GetItem`, "

"you don't own the reference --- but if you obtain the same item from the "

"same list using :c:func:`PySequence_GetItem` (which happens to take exactly "

"the same arguments), you do own a reference to the returned object."

msgstr ""

"Es importante darse cuenta de que si posee una referencia retornada por una "

"función depende de a qué función llame únicamente --- *el plumaje* (el tipo "

"del objeto pasado como argumento a la función) *no entra en él!* Por lo "

"tanto, si extrae un elemento de una lista usando :c:func:`PyList_GetItem`, "

"no posee la referencia --- pero si obtiene el mismo elemento de la misma "

"lista usando :c:func:`PySequence_GetItem` (que toma exactamente los mismos "

"argumentos), usted posee una referencia al objeto retornado."

#: ../Doc/c-api/intro.rst:431

msgid ""

"Here is an example of how you could write a function that computes the sum "

"of the items in a list of integers; once using :c:func:`PyList_GetItem`, "

"and once using :c:func:`PySequence_GetItem`. ::"

msgstr ""

"Aquí hay un ejemplo de cómo podría escribir una función que calcule la suma "

"de los elementos en una lista de enteros; una vez usando :c:func:"

"`PyList_GetItem`, y una vez usando :c:func:`PySequence_GetItem`. ::"

#: ../Doc/c-api/intro.rst:495

msgid "Types"

msgstr "Tipos"

#: ../Doc/c-api/intro.rst:497

msgid ""

"There are few other data types that play a significant role in the Python/C "

"API; most are simple C types such as :c:type:`int`, :c:type:`long`, :c:type:"

"`double` and :c:type:`char*`. A few structure types are used to describe "

"static tables used to list the functions exported by a module or the data "

"attributes of a new object type, and another is used to describe the value "

"of a complex number. These will be discussed together with the functions "

"that use them."

msgstr ""

"Hay algunos otros tipos de datos que juegan un papel importante en la API de "

"Python/C; la mayoría son tipos C simples como :c:type:`int`, :c:type:"

"`long`, :c:type:`double` y :c:type:`char*`. Algunos tipos de estructura se "

"usan para describir tablas estáticas que se usan para enumerar las funciones "

"exportadas por un módulo o los atributos de datos de un nuevo tipo de "

"objeto, y otro se usa para describir el valor de un número complejo. Estos "

"serán discutidos junto con las funciones que los usan."

#: ../Doc/c-api/intro.rst:509

msgid "Exceptions"

msgstr "Excepciones"

#: ../Doc/c-api/intro.rst:511

msgid ""

"The Python programmer only needs to deal with exceptions if specific error "

"handling is required; unhandled exceptions are automatically propagated to "

"the caller, then to the caller's caller, and so on, until they reach the top-"

"level interpreter, where they are reported to the user accompanied by a "

"stack traceback."

msgstr ""

"El programador de Python solo necesita lidiar con excepciones si se requiere "

"un manejo específico de errores; las excepciones no manejadas se propagan "

"automáticamente a la persona que llama, luego a la persona que llama, y así "

"sucesivamente, hasta que llegan al intérprete de nivel superior, donde se "

"informan al usuario acompañado de un seguimiento de pila (*stack traceback*)."

#: ../Doc/c-api/intro.rst:519

msgid ""

"For C programmers, however, error checking always has to be explicit. All "

"functions in the Python/C API can raise exceptions, unless an explicit claim "

"is made otherwise in a function's documentation. In general, when a "

"function encounters an error, it sets an exception, discards any object "

"references that it owns, and returns an error indicator. If not documented "

"otherwise, this indicator is either ``NULL`` or ``-1``, depending on the "

"function's return type. A few functions return a Boolean true/false result, "

"with false indicating an error. Very few functions return no explicit error "

"indicator or have an ambiguous return value, and require explicit testing "

"for errors with :c:func:`PyErr_Occurred`. These exceptions are always "

"explicitly documented."

msgstr ""

"Para los programadores de C, sin embargo, la comprobación de errores siempre "

"tiene que ser explícita. Todas las funciones en la API Python/C pueden "

"generar excepciones, a menos que se señale explícitamente en la "

"documentación de una función. En general, cuando una función encuentra un "

"error, establece una excepción, descarta cualquier referencia de objeto que "

"posea y retorna un indicador de error. Si no se documenta lo contrario, este "

"indicador es ``NULL`` o ``-1``, dependiendo del tipo de retorno de la "

"función. Algunas funciones retornan un resultado booleano verdadero/falso, "

"con falso que indica un error. Muy pocas funciones no retornan ningún "

"indicador de error explícito o tienen un valor de retorno ambiguo, y "

"requieren pruebas explícitas de errores con :c:func:`PyErr_Occurred`. Estas "

"excepciones siempre se documentan explícitamente."

#: ../Doc/c-api/intro.rst:534

msgid ""

"Exception state is maintained in per-thread storage (this is equivalent to "

"using global storage in an unthreaded application). A thread can be in one "

"of two states: an exception has occurred, or not. The function :c:func:"

"`PyErr_Occurred` can be used to check for this: it returns a borrowed "

"reference to the exception type object when an exception has occurred, and "

"``NULL`` otherwise. There are a number of functions to set the exception "

"state: :c:func:`PyErr_SetString` is the most common (though not the most "

"general) function to set the exception state, and :c:func:`PyErr_Clear` "

"clears the exception state."

msgstr ""

"El estado de excepción se mantiene en el almacenamiento por subproceso (esto "

"es equivalente a usar el almacenamiento global en una aplicación sin "

"subprocesos). Un subproceso puede estar en uno de dos estados: se ha "

"producido una excepción o no. La función :c:func:`PyErr_Occurred` puede "

"usarse para verificar esto: retorna una referencia prestada al objeto de "

"tipo de excepción cuando se produce una excepción, y ``NULL`` de lo "

"contrario. Hay una serie de funciones para establecer el estado de "

"excepción: :c:func:`PyErr_SetString` es la función más común (aunque no la "

"más general) para establecer el estado de excepción, y :c:func:`PyErr_Clear` "

"borra la excepción estado."

#: ../Doc/c-api/intro.rst:544

msgid ""

"The full exception state consists of three objects (all of which can be "

"``NULL``): the exception type, the corresponding exception value, and the "

"traceback. These have the same meanings as the Python result of ``sys."

"exc_info()``; however, they are not the same: the Python objects represent "

"the last exception being handled by a Python :keyword:`try` ... :keyword:"

"`except` statement, while the C level exception state only exists while an "

"exception is being passed on between C functions until it reaches the Python "

"bytecode interpreter's main loop, which takes care of transferring it to "

"``sys.exc_info()`` and friends."

msgstr ""

"El estado de excepción completo consta de tres objetos (todos los cuales "

"pueden ser ``NULL``): el tipo de excepción, el valor de excepción "

"correspondiente y el rastreo. Estos tienen los mismos significados que el "

"resultado de Python de ``sys.exc_info()``; sin embargo, no son lo mismo: los "

"objetos Python representan la última excepción manejada por una declaración "

"de Python :keyword:`try` ... :keyword:`except`, mientras que el estado de "

"excepción de nivel C solo existe mientras se está pasando una excepción "

"entre las funciones de C hasta que llega al bucle principal del intérprete "

"de código de bytes (*bytecode*) de Python, que se encarga de transferirlo a "

"``sys.exc_info()`` y amigos."

#: ../Doc/c-api/intro.rst:556

msgid ""

"Note that starting with Python 1.5, the preferred, thread-safe way to access "

"the exception state from Python code is to call the function :func:`sys."

"exc_info`, which returns the per-thread exception state for Python code. "

"Also, the semantics of both ways to access the exception state have changed "

"so that a function which catches an exception will save and restore its "

"thread's exception state so as to preserve the exception state of its "

"caller. This prevents common bugs in exception handling code caused by an "

"innocent-looking function overwriting the exception being handled; it also "

"reduces the often unwanted lifetime extension for objects that are "

"referenced by the stack frames in the traceback."

msgstr ""

"Tenga en cuenta que a partir de Python 1.5, la forma preferida y segura de "

"subprocesos para acceder al estado de excepción desde el código de Python es "

"llamar a la función :func:`sys.exc_info`, que retorna el estado de excepción "

"por subproceso para el código de Python. Además, la semántica de ambas "

"formas de acceder al estado de excepción ha cambiado de modo que una función "

"que detecta una excepción guardará y restaurará el estado de excepción de su "

"hilo para preservar el estado de excepción de su llamador. Esto evita "

"errores comunes en el código de manejo de excepciones causado por una "

"función de aspecto inocente que sobrescribe la excepción que se maneja; "

"También reduce la extensión de vida útil a menudo no deseada para los "

"objetos a los que hacen referencia los marcos de pila en el rastreo."

#: ../Doc/c-api/intro.rst:567

msgid ""

"As a general principle, a function that calls another function to perform "

"some task should check whether the called function raised an exception, and "

"if so, pass the exception state on to its caller. It should discard any "

"object references that it owns, and return an error indicator, but it "

"should *not* set another exception --- that would overwrite the exception "

"that was just raised, and lose important information about the exact cause "

"of the error."

msgstr ""

"Como principio general, una función que llama a otra función para realizar "

"alguna tarea debe verificar si la función llamada generó una excepción y, de "

"ser así, pasar el estado de excepción a quien la llama (*caller*). Debe "

"descartar cualquier referencia de objeto que posea y retornar un indicador "

"de error, pero *no* debe establecer otra excepción --- que sobrescribirá la "

"excepción que se acaba de generar y perderá información importante sobre la "

"causa exacta del error."

#: ../Doc/c-api/intro.rst:576

msgid ""

"A simple example of detecting exceptions and passing them on is shown in "

"the :c:func:`sum_sequence` example above. It so happens that this example "

"doesn't need to clean up any owned references when it detects an error. The "

"following example function shows some error cleanup. First, to remind you "

"why you like Python, we show the equivalent Python code::"

msgstr ""

"Un ejemplo simple de detectar excepciones y pasarlas se muestra en el "

"ejemplo :c:func:`sum_sequence` anterior. Sucede que este ejemplo no necesita "

"limpiar ninguna referencia de propiedad cuando detecta un error. La "

"siguiente función de ejemplo muestra algunos errores de limpieza. Primero, "

"para recordar por qué le gusta Python, le mostramos el código Python "

"equivalente::"

#: ../Doc/c-api/intro.rst:591

msgid "Here is the corresponding C code, in all its glory::"

msgstr "Aquí está el código C correspondiente, en todo su esplendor::"

#: ../Doc/c-api/intro.rst:643

msgid ""

"This example represents an endorsed use of the ``goto`` statement in C! It "

"illustrates the use of :c:func:`PyErr_ExceptionMatches` and :c:func:"

"`PyErr_Clear` to handle specific exceptions, and the use of :c:func:"

"`Py_XDECREF` to dispose of owned references that may be ``NULL`` (note the "

"``'X'`` in the name; :c:func:`Py_DECREF` would crash when confronted with a "

"``NULL`` reference). It is important that the variables used to hold owned "

"references are initialized to ``NULL`` for this to work; likewise, the "

"proposed return value is initialized to ``-1`` (failure) and only set to "

"success after the final call made is successful."

msgstr ""

"Este ejemplo representa un uso aprobado de la declaración ``goto`` en C! "

"Ilustra el uso de :c:func:`PyErr_ExceptionMatches` y :c:func:`PyErr_Clear` "

"para manejar excepciones específicas, y el uso de :c:func:`Py_XDECREF` para "

"eliminar referencias propias que pueden ser ``NULL`` (tenga en cuenta la "

"``'X'``' en el nombre; :c:func:`Py_DECREF` se bloqueará cuando se enfrente "

"con una referencia ``NULL``). Es importante que las variables utilizadas "

"para contener referencias propias se inicialicen en ``NULL`` para que esto "

"funcione; Del mismo modo, el valor de retorno propuesto se inicializa a "

"``-1`` (falla) y solo se establece en éxito después de que la última llamada "

"realizada sea exitosa."

#: ../Doc/c-api/intro.rst:657

msgid "Embedding Python"

msgstr "Integración de Python"

#: ../Doc/c-api/intro.rst:659

msgid ""

"The one important task that only embedders (as opposed to extension writers) "

"of the Python interpreter have to worry about is the initialization, and "

"possibly the finalization, of the Python interpreter. Most functionality of "

"the interpreter can only be used after the interpreter has been initialized."

msgstr ""

"La única tarea importante de la que solo tienen que preocuparse los "

"integradores (a diferencia de los escritores de extensión) del intérprete de "

"Python es la inicialización, y posiblemente la finalización, del intérprete "

"de Python. La mayor parte de la funcionalidad del intérprete solo se puede "

"usar después de que el intérprete se haya inicializado."

#: ../Doc/c-api/intro.rst:672

msgid ""

"The basic initialization function is :c:func:`Py_Initialize`. This "

"initializes the table of loaded modules, and creates the fundamental "

"modules :mod:`builtins`, :mod:`__main__`, and :mod:`sys`. It also "

"initializes the module search path (``sys.path``)."

msgstr ""

"La función básica de inicialización es :c:func:`Py_Initialize`. Esto "

"inicializa la tabla de módulos cargados y crea los módulos fundamentales :"

"mod:`builtins`, :mod:`__main__`, y :mod:`sys`. También inicializa la ruta de "

"búsqueda del módulo (``sys.path``)."

#: ../Doc/c-api/intro.rst:679

msgid ""

":c:func:`Py_Initialize` does not set the \"script argument list\" (``sys."

"argv``). If this variable is needed by Python code that will be executed "

"later, it must be set explicitly with a call to ``PySys_SetArgvEx(argc, "

"argv, updatepath)`` after the call to :c:func:`Py_Initialize`."

msgstr ""

":c:func:`Py_Initialize` no establece la \"lista de argumentos de script"

"\" (``sys.argv``). Si el código de Python necesita esta variable que se "

"ejecutará más adelante, debe establecerse explícitamente con una llamada a "

"``PySys_SetArgvEx(argc, argv, updatepath)`` después de la llamada a :c:func:"

"`Py_Initialize`."

#: ../Doc/c-api/intro.rst:684

msgid ""

"On most systems (in particular, on Unix and Windows, although the details "

"are slightly different), :c:func:`Py_Initialize` calculates the module "

"search path based upon its best guess for the location of the standard "

"Python interpreter executable, assuming that the Python library is found in "

"a fixed location relative to the Python interpreter executable. In "

"particular, it looks for a directory named :file:`lib/python{X.Y}` relative "

"to the parent directory where the executable named :file:`python` is found "

"on the shell command search path (the environment variable :envvar:`PATH`)."

msgstr ""

"En la mayoría de los sistemas (en particular, en Unix y Windows, aunque los "

"detalles son ligeramente diferentes), :c:func:`Py_Initialize` calcula la "

"ruta de búsqueda del módulo basándose en su mejor estimación de la ubicación "

"del ejecutable del intérprete de Python estándar, suponiendo que la "

"biblioteca de Python se encuentra en una ubicación fija en relación con el "

"ejecutable del intérprete de Python. En particular, busca un directorio "

"llamado :file:`lib/python{X.Y}` relativo al directorio padre donde se "