# 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: 2022-10-25 19:47+0200\n" "PO-Revision-Date: 2021-12-09 10:48+0800\n" "Last-Translator: Rodrigo Tobar \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.10.3\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: ````, " "````, ````, ````, ```` and ```` (if available)." msgstr "" "Esto implica la inclusión de los siguientes archivos de encabezado estándar: " "````, ````, ````, ````, ```` " "y ```` (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 ``; 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 " "``; 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 "Return the absolute value of ``x``." msgstr "Retorna el valor absoluto de ``x``." #: ../Doc/c-api/intro.rst:116 msgid "" "Ask the compiler to always inline a static inline function. The compiler can " "ignore it and decides to not inline the function." msgstr "" #: ../Doc/c-api/intro.rst:119 msgid "" "It can be used to inline performance critical static inline functions when " "building Python in debug mode with function inlining disabled. For example, " "MSC disables function inlining when building in debug mode." msgstr "" #: ../Doc/c-api/intro.rst:123 msgid "" "Marking blindly a static inline function with Py_ALWAYS_INLINE can result in " "worse performances (due to increased code size for example). The compiler is " "usually smarter than the developer for the cost/benefit analysis." msgstr "" #: ../Doc/c-api/intro.rst:127 msgid "" "If Python is :ref:`built in debug mode ` (if the ``Py_DEBUG`` " "macro is defined), the :c:macro:`Py_ALWAYS_INLINE` macro does nothing." msgstr "" #: ../Doc/c-api/intro.rst:130 msgid "It must be specified before the function return type. Usage::" msgstr "" #: ../Doc/c-api/intro.rst:138 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:143 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:146 ../Doc/c-api/intro.rst:232 #: ../Doc/c-api/intro.rst:250 msgid "Example::" msgstr "Ejemplo::" #: ../Doc/c-api/intro.rst:150 msgid "MSVC support was added." msgstr "Soporte para MSVC fue agregado." #: ../Doc/c-api/intro.rst:155 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:160 msgid "Return the maximum value between ``x`` and ``y``." msgstr "Retorna el valor máximo entre ``x`` e ``y``." #: ../Doc/c-api/intro.rst:166 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:172 msgid "Return the minimum value between ``x`` and ``y``." msgstr "Retorna el valor mínimo entre ``x`` e ``y``." #: ../Doc/c-api/intro.rst:178 msgid "" "Disable inlining on a function. For example, it reduces the C stack " "consumption: useful on LTO+PGO builds which heavily inline code (see :issue:" "`33720`)." msgstr "" #: ../Doc/c-api/intro.rst:182 msgid "Usage::" msgstr "" #: ../Doc/c-api/intro.rst:190 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:197 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:202 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:206 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:209 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:219 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:226 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:229 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:244 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:247 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:262 msgid "Objects, Types and Reference Counts" msgstr "Objetos, tipos y conteos de referencias" #: ../Doc/c-api/intro.rst:266 #, fuzzy msgid "" "Most Python/C API functions have one or more arguments as well as a return " "value of type :c:expr:`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:expr:`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:277 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:288 msgid "Reference Counts" msgstr "Conteo de Referencias" #: ../Doc/c-api/intro.rst:290 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:305 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:319 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:333 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:341 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:351 msgid "Reference Count Details" msgstr "Detalles del conteo de referencia" #: ../Doc/c-api/intro.rst:353 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 :term:" "`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 disminuirla llamando a :c:func:`Py_DECREF` o :c:func:" "`Py_XDECREF` cuando ya no es necesario --- o transmitiendo 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 :term:`referencia prestada " "`." #: ../Doc/c-api/intro.rst:366 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:376 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:391 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:396 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:401 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:404 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:415 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:445 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:454 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:466 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:530 msgid "Types" msgstr "Tipos" #: ../Doc/c-api/intro.rst:532 #, fuzzy 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:expr:`int`, :c:expr:`long`, :c:expr:" "`double` and :c:expr:`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:542 msgid "" "A signed integral type such that ``sizeof(Py_ssize_t) == sizeof(size_t)``. " "C99 doesn't define such a thing directly (size_t is an unsigned integral " "type). See :pep:`353` for details. ``PY_SSIZE_T_MAX`` is the largest " "positive value of type :c:type:`Py_ssize_t`." msgstr "" #: ../Doc/c-api/intro.rst:551 msgid "Exceptions" msgstr "Excepciones" #: ../Doc/c-api/intro.rst:553 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:561 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:576 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:586 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:598 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:609 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:618 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:633 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:685 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:699 msgid "Embedding Python" msgstr "Integración de Python" #: ../Doc/c-api/intro.rst:701 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:714 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:719 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, setting :c:member:`PyConfig.argv` and :c:member:`PyConfig.parse_argv` " "must be set: see :ref:`Python Initialization Configuration `." msgstr "" #: ../Doc/c-api/intro.rst:724 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 " "encuentra el ejecutable llamado :file:`python` en la ruta de búsqueda del " "comando *shell* (la variable de entorno :envvar:`PATH`)." #: ../Doc/c-api/intro.rst:733 msgid "" "For instance, if the Python executable is found in :file:`/usr/local/bin/" "python`, it will assume that the libraries are in :file:`/usr/local/lib/" "python{X.Y}`. (In fact, this particular path is also the \"fallback\" " "location, used when no executable file named :file:`python` is found along :" "envvar:`PATH`.) The user can override this behavior by setting the " "environment variable :envvar:`PYTHONHOME`, or insert additional directories " "in front of the standard path by setting :envvar:`PYTHONPATH`." msgstr "" "Por ejemplo, si el ejecutable de Python se encuentra en :file:`/usr/local/" "bin/python`, se supondrá que las bibliotecas están en :file:`/usr/local/lib/" "python{X.Y}`. (De hecho, esta ruta particular también es la ubicación " "\"alternativa\", utilizada cuando no se encuentra un archivo ejecutable " "llamado :file:`python` junto con :envvar:`PATH`.) El usuario puede anular " "este comportamiento configurando la variable de entorno :envvar:" "`PYTHONHOME`, o inserte directorios adicionales delante de la ruta estándar " "estableciendo :envvar:`PYTHONPATH`." #: ../Doc/c-api/intro.rst:748 msgid "" "The embedding application can steer the search by calling " "``Py_SetProgramName(file)`` *before* calling :c:func:`Py_Initialize`. Note " "that :envvar:`PYTHONHOME` still overrides this and :envvar:`PYTHONPATH` is " "still inserted in front of the standard path. An application that requires " "total control has to provide its own implementation of :c:func:" "`Py_GetPath`, :c:func:`Py_GetPrefix`, :c:func:`Py_GetExecPrefix`, and :c:" "func:`Py_GetProgramFullPath` (all defined in :file:`Modules/getpath.c`)." msgstr "" "La aplicación de integración puede dirigir la búsqueda llamando a " "``Py_SetProgramName(file)`` *antes* llamando :c:func:`Py_Initialize`. Tenga " "en cuenta que :envvar:`PYTHONHOME` todavía anula esto y :envvar:`PYTHONPATH` " "todavía se inserta frente a la ruta estándar. Una aplicación que requiere un " "control total debe proporcionar su propia implementación de :c:func:" "`Py_GetPath`, :c:func:`Py_GetPrefix`, :c:func:`Py_GetExecPrefix`, y :c:func:" "`Py_GetProgramFullPath` (todo definido en :file:`Modules/getpath.c`)." #: ../Doc/c-api/intro.rst:758 msgid "" "Sometimes, it is desirable to \"uninitialize\" Python. For instance, the " "application may want to start over (make another call to :c:func:" "`Py_Initialize`) or the application is simply done with its use of Python " "and wants to free memory allocated by Python. This can be accomplished by " "calling :c:func:`Py_FinalizeEx`. The function :c:func:`Py_IsInitialized` " "returns true if Python is currently in the initialized state. More " "information about these functions is given in a later chapter. Notice that :" "c:func:`Py_FinalizeEx` does *not* free all memory allocated by the Python " "interpreter, e.g. memory allocated by extension modules currently cannot be " "released." msgstr "" "A veces, es deseable \"no inicializar\" Python. Por ejemplo, la aplicación " "puede querer comenzar de nuevo (hacer otra llamada a :c:func:" "`Py_Initialize`) o la aplicación simplemente se hace con el uso de Python y " "quiere liberar memoria asignada por Python. Esto se puede lograr llamando a :" "c:func:`Py_FinalizeEx`. La función :c:func:`Py_IsInitialized` retorna " "verdadero si Python se encuentra actualmente en el estado inicializado. Se " "proporciona más información sobre estas funciones en un capítulo posterior. " "Tenga en cuenta que :c:func:`Py_FinalizeEx` *no* libera toda la memoria " "asignada por el intérprete de Python, por ejemplo, la memoria asignada por " "los módulos de extensión actualmente no se puede liberar." #: ../Doc/c-api/intro.rst:772 msgid "Debugging Builds" msgstr "Depuración de compilaciones" #: ../Doc/c-api/intro.rst:774 msgid "" "Python can be built with several macros to enable extra checks of the " "interpreter and extension modules. These checks tend to add a large amount " "of overhead to the runtime so they are not enabled by default." msgstr "" "Python se puede construir con varios macros para permitir verificaciones " "adicionales del intérprete y los módulos de extensión. Estas comprobaciones " "tienden a agregar una gran cantidad de sobrecarga al tiempo de ejecución, " "por lo que no están habilitadas de forma predeterminada." #: ../Doc/c-api/intro.rst:778 #, fuzzy msgid "" "A full list of the various types of debugging builds is in the file :file:" "`Misc/SpecialBuilds.txt` in the Python source distribution. Builds are " "available that support tracing of reference counts, debugging the memory " "allocator, or low-level profiling of the main interpreter loop. Only the " "most frequently used builds will be described in the remainder of this " "section." msgstr "" "Una lista completa de los diversos tipos de compilaciones de depuración se " "encuentra en el archivo :file:`Misc/SpecialBuilds.txt` en la distribución " "fuente de Python. Hay compilaciones disponibles que admiten el rastreo de " "los conteos de referencia, la depuración del asignador de memoria o la " "creación de perfiles de bajo nivel del bucle principal del intérprete. Solo " "las compilaciones más utilizadas se describirán en el resto de esta sección." #: ../Doc/c-api/intro.rst:784 msgid "" "Compiling the interpreter with the :c:macro:`Py_DEBUG` macro defined " "produces what is generally meant by :ref:`a debug build of Python `. :c:macro:`Py_DEBUG` is enabled in the Unix build by adding :option:" "`--with-pydebug` to the :file:`./configure` command. It is also implied by " "the presence of the not-Python-specific :c:macro:`_DEBUG` macro. When :c:" "macro:`Py_DEBUG` is enabled in the Unix build, compiler optimization is " "disabled." msgstr "" "Compilar el intérprete con el macro :c:macro:`Py_DEBUG` definido produce lo " "que generalmente se entiende por :ref:`una compilación de depuración de " "Python `. :c:macro:`Py_DEBUG` se habilita en la compilación de " "Unix agregando :option:`--with-pydebug` al comando :file:`./configure`. " "También está implícito en la presencia del macro no específico de Python :c:" "macro:`_DEBUG`. Cuando :c:macro:`Py_DEBUG` está habilitado en la compilación " "de Unix, la optimización del compilador está deshabilitada." #: ../Doc/c-api/intro.rst:792 msgid "" "In addition to the reference count debugging described below, extra checks " "are performed, see :ref:`Python Debug Build `." msgstr "" "Además de la depuración del recuento de referencia que se describe a " "continuación, se realizan verificaciones adicionales, véase :ref:" "`compilaciones de depuración `." #: ../Doc/c-api/intro.rst:795 msgid "" "Defining :c:macro:`Py_TRACE_REFS` enables reference tracing (see the :option:" "`configure --with-trace-refs option <--with-trace-refs>`). When defined, a " "circular doubly linked list of active objects is maintained by adding two " "extra fields to every :c:type:`PyObject`. Total allocations are tracked as " "well. Upon exit, all existing references are printed. (In interactive mode " "this happens after every statement run by the interpreter.)" msgstr "" "Definiendo :c:macro:`Py_TRACE_REFS` habilita el rastreo de referencias " "(véase la opción :option:`configure --with-trace-refs <--with-trace-refs>`). " "Cuando se define, se mantiene una lista circular doblemente vinculada de " "objetos activos al agregar dos campos adicionales a cada :c:type:`PyObject`. " "También se realiza un seguimiento de las asignaciones totales. Al salir, se " "imprimen todas las referencias existentes. (En modo interactivo, esto sucede " "después de cada declaración ejecutada por el intérprete)." #: ../Doc/c-api/intro.rst:802 msgid "" "Please refer to :file:`Misc/SpecialBuilds.txt` in the Python source " "distribution for more detailed information." msgstr "" "Consulte :file:`Misc/SpecialBuilds.txt` en la distribución fuente de Python " "para obtener información más detallada." #~ 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`."