Extending and Embedding Python

Release 3.13.2

Guido van Rossum and the Python development team

fevereiro 07, 2025

Python Software Foundation

Email: docs@python.org
 Sumário

1 Ferramentas de terceiros recomendadas 3

2 Criando extensões sem ferramentas de terceiros 5

2.1 Estendendo Python com C ou C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Um Exemplo Simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Intermezzo: Errors and Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1.3 Back to the Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1.4 The Module’s Method Table and Initialization Function . . . . . . . . . . . . . . . . . . 9
2.1.5 Compilation and Linkage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.6 Calling Python Functions from C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1.7 Extracting Parameters in Extension Functions . . . . . . . . . . . . . . . . . . . . . . . 14
2.1.8 Keyword Parameters for Extension Functions . . . . . . . . . . . . . . . . . . . . . . . . 15
2.1.9 Building Arbitrary Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.10 Contagens de referê ncias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.11 Writing Extensions in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.1.12 Providing a C API for an Extension Module . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2 Definindo Tipos de Extensã o: Tutorial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2.1 O bá sico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.2.2 Adicionando dados e mé todos ao exemplo bá sico . . . . . . . . . . . . . . . . . . . . . . 27
2.2.3 Fornecendo controle mais preciso sobre atributos de dados . . . . . . . . . . . . . . . . . 34
2.2.4 Apoiando a coleta de lixo cíclica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.2.5 Criando subclasses de outros tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
2.3 Defining Extension Types: Assorted Topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.3.1 Finalization and De-allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.3.2 Object Presentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.3.3 Attribute Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.3.4 Object Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
2.3.5 Abstract Protocol Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.3.6 Weak Reference Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.3.7 More Suggestions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.4 Construindo extensõ es C e C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
2.4.1 Construindo extensõ es C e C ++ com setuptools . . . . . . . . . . . . . . . . . . . . . . 57
2.5 Construindo Extensõ es C e C++ no Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2.5.1 Uma abordagem de livro de receitas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2.5.2 Diferenças entre o Unix e o Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
2.5.3 Usando DLLs na prá tica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

3 Incorporando o tempo de execução do CPython em uma aplicação maior 59

3.1 Incorporando o Python numa Outra Aplicaçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.1.1 Very High Level Embedding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.1.2 Beyond Very High Level Embedding: An overview . . . . . . . . . . . . . . . . . . . . . 61

i
 3.1.3 Pure Embedding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.1.4 Extending Embedded Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.1.5 Embedding Python in C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
3.1.6 Compiling and Linking under Unix-like systems . . . . . . . . . . . . . . . . . . . . . . 64

A Glossário 67

B Sobre esta documentação 85

B.1 Contribuidores da documentaçã o do Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

C História e Licença 87
C.1 Histó ria do software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
C.2 Termos e condiçõ es para acessar ou usar Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
C.2.1 PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 . . . . . . . . . . . . . 88
C.2.2 ACORDO DE LICENCIAMENTO DA BEOPEN.COM PARA PYTHON 2.0 . . . . . . 89
C.2.3 CONTRATO DE LICENÇA DA CNRI PARA O PYTHON 1.6.1 . . . . . . . . . . . . 90
C.2.4 ACORDO DE LICENÇA DA CWI PARA PYTHON 0.9.0 A 1.2 . . . . . . . . . . . . . 91
C.2.5 ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION . 91
C.3 Licenças e Reconhecimentos para Software Incorporado . . . . . . . . . . . . . . . . . . . . . . 91
C.3.1 Mersenne Twister . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
C.3.2 Soquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
C.3.3 Serviços de soquete assíncrono . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
C.3.4 Gerenciamento de cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
C.3.5 Rastreamento de execuçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
C.3.6 Funçõ es UUencode e UUdecode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
C.3.7 Chamadas de procedimento remoto XML . . . . . . . . . . . . . . . . . . . . . . . . . 95
C.3.8 test_epoll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
C.3.9 kqueue de seleçã o . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
C.3.10 SipHash24 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
C.3.11 strtod e dtoa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
C.3.12 OpenSSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
C.3.13 expat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
C.3.14 libffi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
C.3.15 zlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
C.3.16 cfuhash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
C.3.17 libmpdec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
C.3.18 Conjunto de testes C14N do W3C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
C.3.19 mimalloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
C.3.20 asyncio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
C.3.21 Global Unbounded Sequences (GUS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

D Direitos autorais 107

Índice 109

ii
 Extending and Embedding Python, Release 3.13.2

Neste documento descreveremos o desenvolvimento de mó dulos com C ou C++ para adicionar recursos ao interpre-
tador Python criando novos mó dulos. Esses mó dulos podem nã o somente definir novas funçõ es, mas també m novos
tipos de objetos e seu conjunto de mé todos. O documento també m descreve como incorporar o interpretador Python
em outro aplicativo, de forma a utilizá -lo como sendo um idiota estendido. Por fim, estudaremos como podemos
compilar e fazer a vinculaçã o dos mó dulos de extensã o para que estes possam ser carregados dinamicamente (em
tempo de execuçã o) pelo interpretador, caso o sistema operacional subjacente suportar esse recurso.
Este documento pressupõ e conhecimentos bá sicos sobre Python. Para uma introduçã o informal à linguagem, consulte
tutorial-index. reference-index fornece uma definiçã o mais formal da linguagem. library-index documenta os tipos,
funçõ es e mó dulos de objetos existentes (embutidos e escritos em Python) que dã o à linguagem sua ampla gama de
aplicaçõ es.
Para uma descriçã o detalhada de toda a API Python/C, consulte o c-api-index separado.

Sumário 1
Extending and Embedding Python, Release 3.13.2

2 Sumário
 CAPÍTULO 1

Ferramentas de terceiros recomendadas

Esse guia cobre apenas as ferramentas bá sicas para a criaçã o de extensõ es fornecidas como parte desta versã o do
CPython. Ferramentas de terceiros como Cython, cffi, SWIG e Numba oferecem abordagens mais simples e sofisti-
cadas para criar extensõ es C e C++ para Python.

µ Ver também

Guia do Usuário de Empacotamento do Python: Extensões Binárias

O Guia do Usuá rio de Empacotamento do Python nã o abrange apenas vá rias ferramentas disponíveis que
simplificam a criaçã o de extensõ es biná rias, mas també m discute os vá rios motivos pelos quais a criaçã o
de um mó dulo de extensã o pode ser desejá vel em primeiro lugar.

3
Extending and Embedding Python, Release 3.13.2

4 Capítulo 1. Ferramentas de terceiros recomendadas

 CAPÍTULO 2

Criando extensões sem ferramentas de terceiros

Esta seçã o do guia aborda a criaçã o de extensõ es C e C++ sem assistê ncia de ferramentas de terceiros. Destina-se
principalmente aos criadores dessas ferramentas, em vez de ser uma maneira recomendada de criar suas pró prias
extensõ es C.

2.1 Estendendo Python com C ou C++

É muito fá cil adicionar novos mó dulos embutidos ao Python, se você souber programar em C. Você pode adicionar
módulos de extensão para fazer duas coisas que nã o podem ser feitas diretamente no Python: eles podem implementar
novos nos tipos de objetos embutidos e eles podem chamar funçõ es da biblioteca C e chamadas do sistema.
Para dar suporte a extensõ es, a API do Python API (Application Programmers Interface) define um conjunto de
funçõ es, macros e variá veis que fornecem acesso à maior parte dos aspectos do sistema de tempo de execuçã o do
Python. A API do Python pode ser incorporada em um arquivo fonte em C com a inclusã o do cabeçalho "Python.
h".
A compilaçã o de um mó dulo de extensã o depende do uso pretendido e da configuraçã o do sistema; detalhes serã o
dados nos pró ximos capítulos.

® Nota

A interface de extensõ es em C é específica para o CPython, e mó dulos de extensã o nã o funcionam em outras
implementaçõ es do Python. Em muitos casos, é possível evitar a criaçã o destas extensõ es em C e preservar a
portabilidade para outras implementaçõ es. Por exemplo, se o seu caso de uso for o de fazer chamadas a funçõ es
em bibliotecas C ou chamadas de sistema, considere utilizar o mó dulo ctypes ou a biblioteca cffi ao invé s de
escrever có digo C personalizado. Esses mó dulos permitem escrever có digo Python que pode interoperar com
có digo C e que é mais portá vel entre implementaçõ es do Python do que escrever e compilar um mó dulo de
extensã o em C.

2.1.1 Um Exemplo Simples

Vamos criar um mó dulo de extensã o chamado spam (a comida favorita dos fã s de Monty Python…) e digamos que
nosso objetivo seja criar uma interface em Python para a funçã o da biblioteca C system()1 . Essa funçã o toma uma
string de caracteres terminada em nulo como argumento e retorna um nú mero inteiro. Queremos que essa funçã o
seja chamá vel a partir do Python como abaixo:
1 An interface for this function already exists in the standard module os — it was chosen as a simple and straightforward example.

5
Extending and Embedding Python, Release 3.13.2

>>> import spam

>>> status = spam.system("ls -l")

Comece criando um arquivo chamado spammodule.c. (Historicamente, se um mó dulo for chamado spam, o arquivo
C contendo sua implementaçã o é chamado spammodule.c; se o nome do mó dulo for muito longo, como spammify,
o nome do arquivo pode ser só spammify.c.)
As duas primeiras linhas do nosso arquivo podem ser:

#define PY_SSIZE_T_CLEAN
#include <Python.h>

o que carrega a API do Python (você pode adicionar um comentá rio descrevendo o propó sito do mó dulo e uma nota
de copyright, se desejar).

® Nota

Uma vez que Python pode definir algumas definiçõ es de pré -processador que afetam os cabeçalhos padrã o em
alguns sistemas, você deve incluir Python.h antes de quaisquer cabeçalhos padrã o serem incluídos.
#define PY_SSIZE_T_CLEAN was used to indicate that Py_ssize_t should be used in some APIs instead
of int. It is not necessary since Python 3.13, but we keep it here for backward compatibility. See arg-parsing-
-string-and-buffers for a description of this macro.

All user-visible symbols defined by Python.h have a prefix of Py or PY, except those defined in standard header
files. For convenience, and since they are used extensively by the Python interpreter, "Python.h" includes a few
standard header files: <stdio.h>, <string.h>, <errno.h>, and <stdlib.h>. If the latter header file does not
exist on your system, it declares the functions malloc(), free() and realloc() directly.
The next thing we add to our module file is the C function that will be called when the Python expression spam.
system(string) is evaluated (we’ll see shortly how it ends up being called):

static PyObject *
spam_system(PyObject *self, PyObject *args)
{
const char *command;
int sts;

if (!PyArg_ParseTuple(args, "s", &command))

return NULL;
sts = system(command);
return PyLong_FromLong(sts);
}

There is a straightforward translation from the argument list in Python (for example, the single expression "ls -l")
to the arguments passed to the C function. The C function always has two arguments, conventionally named self and
args.
The self argument points to the module object for module-level functions; for a method it would point to the object
instance.
The args argument will be a pointer to a Python tuple object containing the arguments. Each item of the tuple
corresponds to an argument in the call’s argument list. The arguments are Python objects — in order to do anything
with them in our C function we have to convert them to C values. The function PyArg_ParseTuple() in the Python
API checks the argument types and converts them to C values. It uses a template string to determine the required
types of the arguments as well as the types of the C variables into which to store the converted values. More about
this later.
PyArg_ParseTuple() returns true (nonzero) if all arguments have the right type and its components have been
stored in the variables whose addresses are passed. It returns false (zero) if an invalid argument list was passed. In

6 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

the latter case it also raises an appropriate exception so the calling function can return NULL immediately (as we saw
in the example).

2.1.2 Intermezzo: Errors and Exceptions

An important convention throughout the Python interpreter is the following: when a function fails, it should set an
exception condition and return an error value (usually -1 or a NULL pointer). Exception information is stored in
three members of the interpreter’s thread state. These are NULL if there is no exception. Otherwise they are the
C equivalents of the members of the Python tuple returned by sys.exc_info(). These are the exception type,
exception instance, and a traceback object. It is important to know about them to understand how errors are passed
around.
The Python API defines a number of functions to set various types of exceptions.
The most common one is PyErr_SetString(). Its arguments are an exception object and a C string. The exception
object is usually a predefined object like PyExc_ZeroDivisionError. The C string indicates the cause of the error
and is converted to a Python string object and stored as the “associated value” of the exception.
Another useful function is PyErr_SetFromErrno(), which only takes an exception argument and constructs the
associated value by inspection of the global variable errno. The most general function is PyErr_SetObject(),
which takes two object arguments, the exception and its associated value. You don’t need to Py_INCREF() the
objects passed to any of these functions.
You can test non-destructively whether an exception has been set with PyErr_Occurred(). This returns the current
exception object, or NULL if no exception has occurred. You normally don’t need to call PyErr_Occurred() to see
whether an error occurred in a function call, since you should be able to tell from the return value.
When a function f that calls another function g detects that the latter fails, f should itself return an error value
(usually NULL or -1). It should not call one of the PyErr_* functions — one has already been called by g. f’s caller
is then supposed to also return an error indication to its caller, again without calling PyErr_*, and so on — the most
detailed cause of the error was already reported by the function that first detected it. Once the error reaches the
Python interpreter’s main loop, this aborts the currently executing Python code and tries to find an exception handler
specified by the Python programmer.
(There are situations where a module can actually give a more detailed error message by calling another PyErr_*
function, and in such cases it is fine to do so. As a general rule, however, this is not necessary, and can cause
information about the cause of the error to be lost: most operations can fail for a variety of reasons.)
To ignore an exception set by a function call that failed, the exception condition must be cleared explicitly by calling
PyErr_Clear(). The only time C code should call PyErr_Clear() is if it doesn’t want to pass the error on to the
interpreter but wants to handle it completely by itself (possibly by trying something else, or pretending nothing went
wrong).
Every failing malloc() call must be turned into an exception — the direct caller of malloc() (or realloc())
must call PyErr_NoMemory() and return a failure indicator itself. All the object-creating functions (for example,
PyLong_FromLong()) already do this, so this note is only relevant to those who call malloc() directly.

Also note that, with the important exception of PyArg_ParseTuple() and friends, functions that return an integer
status usually return a positive value or zero for success and -1 for failure, like Unix system calls.
Finally, be careful to clean up garbage (by making Py_XDECREF() or Py_DECREF() calls for objects you have
already created) when you return an error indicator!
The choice of which exception to raise is entirely yours. There are predeclared C objects corresponding to all built-in
Python exceptions, such as PyExc_ZeroDivisionError, which you can use directly. Of course, you should choose
exceptions wisely — don’t use PyExc_TypeError to mean that a file couldn’t be opened (that should probably be
PyExc_OSError). If something’s wrong with the argument list, the PyArg_ParseTuple() function usually raises
PyExc_TypeError. If you have an argument whose value must be in a particular range or must satisfy other
conditions, PyExc_ValueError is appropriate.
You can also define a new exception that is unique to your module. For this, you usually declare a static object variable
at the beginning of your file:

2.1. Estendendo Python com C ou C++ 7

Extending and Embedding Python, Release 3.13.2

static PyObject *SpamError;

and initialize it in your module’s initialization function (PyInit_spam()) with an exception object:

PyMODINIT_FUNC
PyInit_spam(void)
{
PyObject *m;

m = PyModule_Create(&spammodule);
if (m == NULL)
return NULL;

SpamError = PyErr_NewException("spam.error", NULL, NULL);

if (PyModule_AddObjectRef(m, "error", SpamError) < 0) {
Py_CLEAR(SpamError);
Py_DECREF(m);
return NULL;
}

return m;
}

Note that the Python name for the exception object is spam.error. The PyErr_NewException() function may
create a class with the base class being Exception (unless another class is passed in instead of NULL), described in
bltin-exceptions.
Note also that the SpamError variable retains a reference to the newly created exception class; this is intentional!
Since the exception could be removed from the module by external code, an owned reference to the class is needed to
ensure that it will not be discarded, causing SpamError to become a dangling pointer. Should it become a dangling
pointer, C code which raises the exception could cause a core dump or other unintended side effects.
We discuss the use of PyMODINIT_FUNC as a function return type later in this sample.
The spam.error exception can be raised in your extension module using a call to PyErr_SetString() as shown
below:

static PyObject *
spam_system(PyObject *self, PyObject *args)
{
const char *command;
int sts;

if (!PyArg_ParseTuple(args, "s", &command))

return NULL;
sts = system(command);
if (sts < 0) {
PyErr_SetString(SpamError, "System command failed");
return NULL;
}
return PyLong_FromLong(sts);
}

2.1.3 Back to the Example

Going back to our example function, you should now be able to understand this statement:

if (!PyArg_ParseTuple(args, "s", &command))

return NULL;

8 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

It returns NULL (the error indicator for functions returning object pointers) if an error is detected in the argument
list, relying on the exception set by PyArg_ParseTuple(). Otherwise the string value of the argument has been
copied to the local variable command. This is a pointer assignment and you are not supposed to modify the string to
which it points (so in Standard C, the variable command should properly be declared as const char *command).
The next statement is a call to the Unix function system(), passing it the string we just got from
PyArg_ParseTuple():

sts = system(command);

Our spam.system() function must return the value of sts as a Python object. This is done using the function
PyLong_FromLong().

return PyLong_FromLong(sts);

In this case, it will return an integer object. (Yes, even integers are objects on the heap in Python!)
If you have a C function that returns no useful argument (a function returning void), the corresponding Python
function must return None. You need this idiom to do so (which is implemented by the Py_RETURN_NONE macro):

Py_INCREF(Py_None);
return Py_None;

Py_None is the C name for the special Python object None. It is a genuine Python object rather than a NULL pointer,
which means “error” in most contexts, as we have seen.

2.1.4 The Module’s Method Table and Initialization Function

I promised to show how spam_system() is called from Python programs. First, we need to list its name and address
in a “method table”:

static PyMethodDef SpamMethods[] = {

...
{"system", spam_system, METH_VARARGS,
"Execute a shell command."},
...
{NULL, NULL, 0, NULL} /* Sentinel */
};

Note the third entry (METH_VARARGS). This is a flag telling the interpreter the calling convention to be used for the
C function. It should normally always be METH_VARARGS or METH_VARARGS | METH_KEYWORDS; a value of 0
means that an obsolete variant of PyArg_ParseTuple() is used.
When using only METH_VARARGS, the function should expect the Python-level parameters to be passed in as a tuple
acceptable for parsing via PyArg_ParseTuple(); more information on this function is provided below.
The METH_KEYWORDS bit may be set in the third field if keyword arguments should be passed to the function. In
this case, the C function should accept a third PyObject * parameter which will be a dictionary of keywords. Use
PyArg_ParseTupleAndKeywords() to parse the arguments to such a function.
The method table must be referenced in the module definition structure:

static struct PyModuleDef spammodule = {

PyModuleDef_HEAD_INIT,
"spam", /* name of module */
spam_doc, /* module documentation, may be NULL */
-1, /* size of per-interpreter state of the module,
or -1 if the module keeps state in global variables. */
SpamMethods
};

2.1. Estendendo Python com C ou C++ 9

Extending and Embedding Python, Release 3.13.2

This structure, in turn, must be passed to the interpreter in the module’s initialization function. The initialization
function must be named PyInit_name(), where name is the name of the module, and should be the only non-
-static item defined in the module file:
PyMODINIT_FUNC
PyInit_spam(void)
{
return PyModule_Create(&spammodule);
}

Note that PyMODINIT_FUNC declares the function as PyObject * return type, declares any special linkage decla-
rations required by the platform, and for C++ declares the function as extern "C".
When the Python program imports module spam for the first time, PyInit_spam() is called. (See below for
comments about embedding Python.) It calls PyModule_Create(), which returns a module object, and inserts
built-in function objects into the newly created module based upon the table (an array of PyMethodDef structures)
found in the module definition. PyModule_Create() returns a pointer to the module object that it creates. It may
abort with a fatal error for certain errors, or return NULL if the module could not be initialized satisfactorily. The init
function must return the module object to its caller, so that it then gets inserted into sys.modules.
When embedding Python, the PyInit_spam() function is not called automatically unless there’s an entry in the
PyImport_Inittab table. To add the module to the initialization table, use PyImport_AppendInittab(),
optionally followed by an import of the module:

#define PY_SSIZE_T_CLEAN
#include <Python.h>

int
main(int argc, char *argv[])
{
PyStatus status;
PyConfig config;
PyConfig_InitPythonConfig(&config);

/* Add a built-in module, before Py_Initialize */

if (PyImport_AppendInittab("spam", PyInit_spam) == -1) {
fprintf(stderr, "Error: could not extend in-built modules table\n");
exit(1);
}

/* Pass argv[0] to the Python interpreter */

status = PyConfig_SetBytesString(&config, &config.program_name, argv[0]);
if (PyStatus_Exception(status)) {
goto exception;
}

/* Initialize the Python interpreter. Required.

If this step fails, it will be a fatal error. */
status = Py_InitializeFromConfig(&config);
if (PyStatus_Exception(status)) {
goto exception;
}
PyConfig_Clear(&config);

/* Optionally import the module; alternatively,

import can be deferred until the embedded script
imports it. */
PyObject *pmodule = PyImport_ImportModule("spam");
if (!pmodule) {
(continua na pró xima pá gina)

10 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

PyErr_Print();
fprintf(stderr, "Error: could not import module 'spam'\n");
}

// ... use Python C API here ...

return 0;

exception:
PyConfig_Clear(&config);
Py_ExitStatusException(status);
}

® Nota

Removing entries from sys.modules or importing compiled modules into multiple interpreters within a pro-
cess (or following a fork() without an intervening exec()) can create problems for some extension modules.
Extension module authors should exercise caution when initializing internal data structures.

A more substantial example module is included in the Python source distribution as Modules/xxmodule.c. This
file may be used as a template or simply read as an example.

® Nota

Unlike our spam example, xxmodule uses multi-phase initialization (new in Python 3.5), where a PyModuleDef
structure is returned from PyInit_spam, and creation of the module is left to the import machinery. For details
on multi-phase initialization, see PEP 489.

2.1.5 Compilation and Linkage

There are two more things to do before you can use your new extension: compiling and linking it with the Python
system. If you use dynamic loading, the details may depend on the style of dynamic loading your system uses; see the
chapters about building extension modules (chapter Construindo extensões C e C++) and additional information that
pertains only to building on Windows (chapter Construindo Extensões C e C++ no Windows) for more information
about this.
If you can’t use dynamic loading, or if you want to make your module a permanent part of the Python interpreter,
you will have to change the configuration setup and rebuild the interpreter. Luckily, this is very simple on Unix: just
place your file (spammodule.c for example) in the Modules/ directory of an unpacked source distribution, add a
line to the file Modules/Setup.local describing your file:

spam spammodule.o

and rebuild the interpreter by running make in the toplevel directory. You can also run make in the Modules/
subdirectory, but then you must first rebuild Makefile there by running ‘make Makefile’. (This is necessary each
time you change the Setup file.)
If your module requires additional libraries to link with, these can be listed on the line in the configuration file as
well, for instance:

spam spammodule.o -lX11

2.1. Estendendo Python com C ou C++ 11

Extending and Embedding Python, Release 3.13.2

2.1.6 Calling Python Functions from C

So far we have concentrated on making C functions callable from Python. The reverse is also useful: calling Python
functions from C. This is especially the case for libraries that support so-called “callback” functions. If a C interface
makes use of callbacks, the equivalent Python often needs to provide a callback mechanism to the Python program-
mer; the implementation will require calling the Python callback functions from a C callback. Other uses are also
imaginable.
Fortunately, the Python interpreter is easily called recursively, and there is a standard interface to call a Python
function. (I won’t dwell on how to call the Python parser with a particular string as input — if you’re interested, have
a look at the implementation of the -c command line option in Modules/main.c from the Python source code.)
Calling a Python function is easy. First, the Python program must somehow pass you the Python function object.
You should provide a function (or some other interface) to do this. When this function is called, save a pointer to the
Python function object (be careful to Py_INCREF() it!) in a global variable — or wherever you see fit. For example,
the following function might be part of a module definition:

static PyObject *my_callback = NULL;

static PyObject *
my_set_callback(PyObject *dummy, PyObject *args)
{
PyObject *result = NULL;
PyObject *temp;

if (PyArg_ParseTuple(args, "O:set_callback", &temp)) {

if (!PyCallable_Check(temp)) {
PyErr_SetString(PyExc_TypeError, "parameter must be callable");
return NULL;
}
Py_XINCREF(temp); /* Add a reference to new callback */
Py_XDECREF(my_callback); /* Dispose of previous callback */
my_callback = temp; /* Remember new callback */
/* Boilerplate to return "None" */
Py_INCREF(Py_None);
result = Py_None;
}
return result;
}

This function must be registered with the interpreter using the METH_VARARGS flag; this is described in section
The Module’s Method Table and Initialization Function. The PyArg_ParseTuple() function and its arguments are
documented in section Extracting Parameters in Extension Functions.
The macros Py_XINCREF() and Py_XDECREF() increment/decrement the reference count of an object and are safe
in the presence of NULL pointers (but note that temp will not be NULL in this context). More info on them in section
Contagens de referências.
Later, when it is time to call the function, you call the C function PyObject_CallObject(). This function has
two arguments, both pointers to arbitrary Python objects: the Python function, and the argument list. The argument
list must always be a tuple object, whose length is the number of arguments. To call the Python function with no
arguments, pass in NULL, or an empty tuple; to call it with one argument, pass a singleton tuple. Py_BuildValue()
returns a tuple when its format string consists of zero or more format codes between parentheses. For example:

int arg;
PyObject *arglist;
PyObject *result;
...
arg = 123;
...
(continua na pró xima pá gina)

12 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

/* Time to call the callback */
arglist = Py_BuildValue("(i)", arg);
result = PyObject_CallObject(my_callback, arglist);
Py_DECREF(arglist);

PyObject_CallObject() returns a Python object pointer: this is the return value of the Python func-
tion. PyObject_CallObject() is “reference-count-neutral” with respect to its arguments. In the exam-
ple a new tuple was created to serve as the argument list, which is Py_DECREF()-ed immediately after the
PyObject_CallObject() call.

The return value of PyObject_CallObject() is “new”: either it is a brand new object, or it is an existing object
whose reference count has been incremented. So, unless you want to save it in a global variable, you should somehow
Py_DECREF() the result, even (especially!) if you are not interested in its value.

Before you do this, however, it is important to check that the return value isn’t NULL. If it is, the Python function
terminated by raising an exception. If the C code that called PyObject_CallObject() is called from Python, it
should now return an error indication to its Python caller, so the interpreter can print a stack trace, or the calling
Python code can handle the exception. If this is not possible or desirable, the exception should be cleared by calling
PyErr_Clear(). For example:

if (result == NULL)
return NULL; /* Pass error back */
...use result...
Py_DECREF(result);

Depending on the desired interface to the Python callback function, you may also have to provide an argument list to
PyObject_CallObject(). In some cases the argument list is also provided by the Python program, through the
same interface that specified the callback function. It can then be saved and used in the same manner as the function
object. In other cases, you may have to construct a new tuple to pass as the argument list. The simplest way to do this
is to call Py_BuildValue(). For example, if you want to pass an integral event code, you might use the following
code:

PyObject *arglist;
...
arglist = Py_BuildValue("(l)", eventcode);
result = PyObject_CallObject(my_callback, arglist);
Py_DECREF(arglist);
if (result == NULL)
return NULL; /* Pass error back */
/* Here maybe use the result */
Py_DECREF(result);

Note the placement of Py_DECREF(arglist) immediately after the call, before the error check! Also note that
strictly speaking this code is not complete: Py_BuildValue() may run out of memory, and this should be checked.
You may also call a function with keyword arguments by using PyObject_Call(), which supports arguments and
keyword arguments. As in the above example, we use Py_BuildValue() to construct the dictionary.

PyObject *dict;
...
dict = Py_BuildValue("{s:i}", "name", val);
result = PyObject_Call(my_callback, NULL, dict);
Py_DECREF(dict);
if (result == NULL)
return NULL; /* Pass error back */
/* Here maybe use the result */
Py_DECREF(result);

2.1. Estendendo Python com C ou C++ 13

Extending and Embedding Python, Release 3.13.2

2.1.7 Extracting Parameters in Extension Functions

The PyArg_ParseTuple() function is declared as follows:

int PyArg_ParseTuple(PyObject *arg, const char *format, ...);

The arg argument must be a tuple object containing an argument list passed from Python to a C function. The format
argument must be a format string, whose syntax is explained in arg-parsing in the Python/C API Reference Manual.
The remaining arguments must be addresses of variables whose type is determined by the format string.
Note that while PyArg_ParseTuple() checks that the Python arguments have the required types, it cannot check
the validity of the addresses of C variables passed to the call: if you make mistakes there, your code will probably
crash or at least overwrite random bits in memory. So be careful!
Note que quaisquer referê ncias a objeto Python que sã o fornecidas ao chamador sã o referê ncias emprestadas; nã o
decremente a contagem de referê ncias delas!
Some example calls:

#define PY_SSIZE_T_CLEAN
#include <Python.h>

int ok;
int i, j;
long k, l;
const char *s;
Py_ssize_t size;

ok = PyArg_ParseTuple(args, ""); /* No arguments */

/* Python call: f() */

ok = PyArg_ParseTuple(args, "s", &s); /* A string */

/* Possible Python call: f('whoops!') */

ok = PyArg_ParseTuple(args, "lls", &k, &l, &s); /* Two longs and a string */

/* Possible Python call: f(1, 2, 'three') */

ok = PyArg_ParseTuple(args, "(ii)s#", &i, &j, &s, &size);

/* A pair of ints and a string, whose size is also returned */
/* Possible Python call: f((1, 2), 'three') */

{
const char *file;
const char *mode = "r";
int bufsize = 0;
ok = PyArg_ParseTuple(args, "s|si", &file, &mode, &bufsize);
/* A string, and optionally another string and an integer */
/* Possible Python calls:
f('spam')
f('spam', 'w')
f('spam', 'wb', 100000) */
}

{
int left, top, right, bottom, h, v;
ok = PyArg_ParseTuple(args, "((ii)(ii))(ii)",
&left, &top, &right, &bottom, &h, &v);
/* A rectangle and a point */
(continua na pró xima pá gina)

14 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

/* Possible Python call:
f(((0, 0), (400, 300)), (10, 10)) */
}

{
Py_complex c;
ok = PyArg_ParseTuple(args, "D:myfunction", &c);
/* a complex, also providing a function name for errors */
/* Possible Python call: myfunction(1+2j) */
}

2.1.8 Keyword Parameters for Extension Functions

The PyArg_ParseTupleAndKeywords() function is declared as follows:

int PyArg_ParseTupleAndKeywords(PyObject *arg, PyObject *kwdict,

const char *format, char * const *kwlist, ...);

The arg and format parameters are identical to those of the PyArg_ParseTuple() function. The kwdict parameter
is the dictionary of keywords received as the third parameter from the Python runtime. The kwlist parameter is a
NULL-terminated list of strings which identify the parameters; the names are matched with the type information from
format from left to right. On success, PyArg_ParseTupleAndKeywords() returns true, otherwise it returns false
and raises an appropriate exception.

® Nota

Nested tuples cannot be parsed when using keyword arguments! Keyword parameters passed in which are not
present in the kwlist will cause TypeError to be raised.

Here is an example module which uses keywords, based on an example by Geoff Philbrick (philbrick@hks.com):

#define PY_SSIZE_T_CLEAN
#include <Python.h>

static PyObject *
keywdarg_parrot(PyObject *self, PyObject *args, PyObject *keywds)
{
int voltage;
const char *state = "a stiff";
const char *action = "voom";
const char *type = "Norwegian Blue";

static char *kwlist[] = {"voltage", "state", "action", "type", NULL};

if (!PyArg_ParseTupleAndKeywords(args, keywds, "i|sss", kwlist,

&voltage, &state, &action, &type))
return NULL;

printf("-- This parrot wouldn't %s if you put %i Volts through it.\n",

action, voltage);
printf("-- Lovely plumage, the %s -- It's %s!\n", type, state);

Py_RETURN_NONE;
}

(continua na pró xima pá gina)

2.1. Estendendo Python com C ou C++ 15

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

static PyMethodDef keywdarg_methods[] = {
/* The cast of the function is necessary since PyCFunction values
* only take two PyObject* parameters, and keywdarg_parrot() takes
* three.
*/
{"parrot", (PyCFunction)(void(*)(void))keywdarg_parrot, METH_VARARGS | METH_
,→KEYWORDS,

"Print a lovely skit to standard output."},

{NULL, NULL, 0, NULL} /* sentinel */
};

static struct PyModuleDef keywdargmodule = {

PyModuleDef_HEAD_INIT,
"keywdarg",
NULL,
-1,
keywdarg_methods
};

PyMODINIT_FUNC
PyInit_keywdarg(void)
{
return PyModule_Create(&keywdargmodule);
}

2.1.9 Building Arbitrary Values

This function is the counterpart to PyArg_ParseTuple(). It is declared as follows:

PyObject *Py_BuildValue(const char *format, ...);

It recognizes a set of format units similar to the ones recognized by PyArg_ParseTuple(), but the arguments
(which are input to the function, not output) must not be pointers, just values. It returns a new Python object, suitable
for returning from a C function called from Python.
One difference with PyArg_ParseTuple(): while the latter requires its first argument to be a tuple (since Python
argument lists are always represented as tuples internally), Py_BuildValue() does not always build a tuple. It
builds a tuple only if its format string contains two or more format units. If the format string is empty, it returns
None; if it contains exactly one format unit, it returns whatever object is described by that format unit. To force it to
return a tuple of size 0 or one, parenthesize the format string.
Examples (to the left the call, to the right the resulting Python value):

Py_BuildValue("") None
Py_BuildValue("i", 123) 123
Py_BuildValue("iii", 123, 456, 789) (123, 456, 789)
Py_BuildValue("s", "hello") 'hello'
Py_BuildValue("y", "hello") b'hello'
Py_BuildValue("ss", "hello", "world") ('hello', 'world')
Py_BuildValue("s#", "hello", 4) 'hell'
Py_BuildValue("y#", "hello", 4) b'hell'
Py_BuildValue("()") ()
Py_BuildValue("(i)", 123) (123,)
Py_BuildValue("(ii)", 123, 456) (123, 456)
Py_BuildValue("(i,i)", 123, 456) (123, 456)
Py_BuildValue("[i,i]", 123, 456) [123, 456]
Py_BuildValue("{s:i,s:i}",
(continua na pró xima pá gina)

16 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

"abc", 123, "def", 456) {'abc': 123, 'def': 456}
Py_BuildValue("((ii)(ii)) (ii)",
1, 2, 3, 4, 5, 6) (((1, 2), (3, 4)), (5, 6))

2.1.10 Contagens de referências

In languages like C or C++, the programmer is responsible for dynamic allocation and deallocation of memory on
the heap. In C, this is done using the functions malloc() and free(). In C++, the operators new and delete are
used with essentially the same meaning and we’ll restrict the following discussion to the C case.
Every block of memory allocated with malloc() should eventually be returned to the pool of available memory
by exactly one call to free(). It is important to call free() at the right time. If a block’s address is forgotten but
free() is not called for it, the memory it occupies cannot be reused until the program terminates. This is called a
memory leak. On the other hand, if a program calls free() for a block and then continues to use the block, it creates
a conflict with reuse of the block through another malloc() call. This is called using freed memory. It has the same
bad consequences as referencing uninitialized data — core dumps, wrong results, mysterious crashes.
Common causes of memory leaks are unusual paths through the code. For instance, a function may allocate a block
of memory, do some calculation, and then free the block again. Now a change in the requirements for the function
may add a test to the calculation that detects an error condition and can return prematurely from the function. It’s
easy to forget to free the allocated memory block when taking this premature exit, especially when it is added later
to the code. Such leaks, once introduced, often go undetected for a long time: the error exit is taken only in a small
fraction of all calls, and most modern machines have plenty of virtual memory, so the leak only becomes apparent
in a long-running process that uses the leaking function frequently. Therefore, it’s important to prevent leaks from
happening by having a coding convention or strategy that minimizes this kind of errors.
Since Python makes heavy use of malloc() and free(), it needs a strategy to avoid memory leaks as well as the
use of freed memory. The chosen method is called reference counting. The principle is simple: every object contains
a counter, which is incremented when a reference to the object is stored somewhere, and which is decremented when
a reference to it is deleted. When the counter reaches zero, the last reference to the object has been deleted and the
object is freed.
An alternative strategy is called automatic garbage collection. (Sometimes, reference counting is also referred to as
a garbage collection strategy, hence my use of “automatic” to distinguish the two.) The big advantage of automatic
garbage collection is that the user doesn’t need to call free() explicitly. (Another claimed advantage is an impro-
vement in speed or memory usage — this is no hard fact however.) The disadvantage is that for C, there is no truly
portable automatic garbage collector, while reference counting can be implemented portably (as long as the functions
malloc() and free() are available — which the C Standard guarantees). Maybe some day a sufficiently portable
automatic garbage collector will be available for C. Until then, we’ll have to live with reference counts.
While Python uses the traditional reference counting implementation, it also offers a cycle detector that works to
detect reference cycles. This allows applications to not worry about creating direct or indirect circular references;
these are the weakness of garbage collection implemented using only reference counting. Reference cycles consist
of objects which contain (possibly indirect) references to themselves, so that each object in the cycle has a reference
count which is non-zero. Typical reference counting implementations are not able to reclaim the memory belonging
to any objects in a reference cycle, or referenced from the objects in the cycle, even though there are no further
references to the cycle itself.
The cycle detector is able to detect garbage cycles and can reclaim them. The gc module exposes a way to run
the detector (the collect() function), as well as configuration interfaces and the ability to disable the detector at
runtime.

Reference Counting in Python

There are two macros, Py_INCREF(x) and Py_DECREF(x), which handle the incrementing and decrementing of
the reference count. Py_DECREF() also frees the object when the count reaches zero. For flexibility, it doesn’t call
free() directly — rather, it makes a call through a function pointer in the object’s type object. For this purpose (and
others), every object also contains a pointer to its type object.

2.1. Estendendo Python com C ou C++ 17

Extending and Embedding Python, Release 3.13.2

The big question now remains: when to use Py_INCREF(x) and Py_DECREF(x)? Let’s first introduce some terms.
Nobody “owns” an object; however, you can own a reference to an object. An object’s reference count is now defined
as the number of owned references to it. The owner of a reference is responsible for calling Py_DECREF() when the
reference is no longer needed. Ownership of a reference can be transferred. There are three ways to dispose of an
owned reference: pass it on, store it, or call Py_DECREF(). Forgetting to dispose of an owned reference creates a
memory leak.
It is also possible to borrow2 a reference to an object. The borrower of a reference should not call Py_DECREF().
The borrower must not hold on to the object longer than the owner from which it was borrowed. Using a borrowed
reference after the owner has disposed of it risks using freed memory and should be avoided completely3 .
The advantage of borrowing over owning a reference is that you don’t need to take care of disposing of the reference
on all possible paths through the code — in other words, with a borrowed reference you don’t run the risk of leaking
when a premature exit is taken. The disadvantage of borrowing over owning is that there are some subtle situations
where in seemingly correct code a borrowed reference can be used after the owner from which it was borrowed has
in fact disposed of it.
A borrowed reference can be changed into an owned reference by calling Py_INCREF(). This does not affect the
status of the owner from which the reference was borrowed — it creates a new owned reference, and gives full owner
responsibilities (the new owner must dispose of the reference properly, as well as the previous owner).

Ownership Rules
Whenever an object reference is passed into or out of a function, it is part of the function’s interface specification
whether ownership is transferred with the reference or not.
Most functions that return a reference to an object pass on ownership with the reference. In particular, all functions
whose function it is to create a new object, such as PyLong_FromLong() and Py_BuildValue(), pass ownership
to the receiver. Even if the object is not actually new, you still receive ownership of a new reference to that object.
For instance, PyLong_FromLong() maintains a cache of popular values and can return a reference to a cached item.
Many functions that extract objects from other objects also transfer ownership with the reference, for instance
PyObject_GetAttrString(). The picture is less clear, here, however, since a few common routines are ex-
ceptions: PyTuple_GetItem(), PyList_GetItem(), PyDict_GetItem(), and PyDict_GetItemString()
all return references that you borrow from the tuple, list or dictionary.
The function PyImport_AddModule() also returns a borrowed reference, even though it may actually create the
object it returns: this is possible because an owned reference to the object is stored in sys.modules.
When you pass an object reference into another function, in general, the function borrows the reference from you —
if it needs to store it, it will use Py_INCREF() to become an independent owner. There are exactly two important
exceptions to this rule: PyTuple_SetItem() and PyList_SetItem(). These functions take over ownership of
the item passed to them — even if they fail! (Note that PyDict_SetItem() and friends don’t take over ownership
— they are “normal.”)
When a C function is called from Python, it borrows references to its arguments from the caller. The caller owns a
reference to the object, so the borrowed reference’s lifetime is guaranteed until the function returns. Only when such a
borrowed reference must be stored or passed on, it must be turned into an owned reference by calling Py_INCREF().
The object reference returned from a C function that is called from Python must be an owned reference — ownership
is transferred from the function to its caller.

Thin Ice
There are a few situations where seemingly harmless use of a borrowed reference can lead to problems. These all
have to do with implicit invocations of the interpreter, which can cause the owner of a reference to dispose of it.
The first and most important case to know about is using Py_DECREF() on an unrelated object while borrowing a
reference to a list item. For instance:
2 The metaphor of “borrowing” a reference is not completely correct: the owner still has a copy of the reference.
3 Checking that the reference count is at least 1 does not work — the reference count itself could be in freed memory and may thus be reused
for another object!

18 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

void
bug(PyObject *list)
{
PyObject *item = PyList_GetItem(list, 0);

PyList_SetItem(list, 1, PyLong_FromLong(0L));
PyObject_Print(item, stdout, 0); /* BUG! */
}

This function first borrows a reference to list[0], then replaces list[1] with the value 0, and finally prints the
borrowed reference. Looks harmless, right? But it’s not!
Let’s follow the control flow into PyList_SetItem(). The list owns references to all its items, so when item 1 is
replaced, it has to dispose of the original item 1. Now let’s suppose the original item 1 was an instance of a user-
-defined class, and let’s further suppose that the class defined a __del__() method. If this class instance has a
reference count of 1, disposing of it will call its __del__() method.
Since it is written in Python, the __del__() method can execute arbitrary Python code. Could it perhaps do
something to invalidate the reference to item in bug()? You bet! Assuming that the list passed into bug() is
accessible to the __del__() method, it could execute a statement to the effect of del list[0], and assuming this
was the last reference to that object, it would free the memory associated with it, thereby invalidating item.
The solution, once you know the source of the problem, is easy: temporarily increment the reference count. The
correct version of the function reads:

void
no_bug(PyObject *list)
{
PyObject *item = PyList_GetItem(list, 0);

Py_INCREF(item);
PyList_SetItem(list, 1, PyLong_FromLong(0L));
PyObject_Print(item, stdout, 0);
Py_DECREF(item);
}

This is a true story. An older version of Python contained variants of this bug and someone spent a considerable
amount of time in a C debugger to figure out why his __del__() methods would fail…
The second case of problems with a borrowed reference is a variant involving threads. Normally, multiple threads in
the Python interpreter can’t get in each other’s way, because there is a global lock protecting Python’s entire object
space. However, it is possible to temporarily release this lock using the macro Py_BEGIN_ALLOW_THREADS, and to
re-acquire it using Py_END_ALLOW_THREADS. This is common around blocking I/O calls, to let other threads use
the processor while waiting for the I/O to complete. Obviously, the following function has the same problem as the
previous one:

void
bug(PyObject *list)
{
PyObject *item = PyList_GetItem(list, 0);
Py_BEGIN_ALLOW_THREADS
...some blocking I/O call...
Py_END_ALLOW_THREADS
PyObject_Print(item, stdout, 0); /* BUG! */
}

2.1. Estendendo Python com C ou C++ 19

Extending and Embedding Python, Release 3.13.2

NULL Pointers
In general, functions that take object references as arguments do not expect you to pass them NULL pointers, and will
dump core (or cause later core dumps) if you do so. Functions that return object references generally return NULL
only to indicate that an exception occurred. The reason for not testing for NULL arguments is that functions often
pass the objects they receive on to other function — if each function were to test for NULL, there would be a lot of
redundant tests and the code would run more slowly.
It is better to test for NULL only at the “source:” when a pointer that may be NULL is received, for example, from
malloc() or from a function that may raise an exception.

The macros Py_INCREF() and Py_DECREF() do not check for NULL pointers — however, their variants
Py_XINCREF() and Py_XDECREF() do.

The macros for checking for a particular object type (Pytype_Check()) don’t check for NULL pointers — again,
there is much code that calls several of these in a row to test an object against various different expected types, and
this would generate redundant tests. There are no variants with NULL checking.
The C function calling mechanism guarantees that the argument list passed to C functions (args in the examples) is
never NULL — in fact it guarantees that it is always a tuple4 .
It is a severe error to ever let a NULL pointer “escape” to the Python user.

2.1.11 Writing Extensions in C++

It is possible to write extension modules in C++. Some restrictions apply. If the main program (the Python interpreter)
is compiled and linked by the C compiler, global or static objects with constructors cannot be used. This is not a
problem if the main program is linked by the C++ compiler. Functions that will be called by the Python interpreter
(in particular, module initialization functions) have to be declared using extern "C". It is unnecessary to enclose
the Python header files in extern "C" {...} — they use this form already if the symbol __cplusplus is defined
(all recent C++ compilers define this symbol).

2.1.12 Providing a C API for an Extension Module

Many extension modules just provide new functions and types to be used from Python, but sometimes the code in
an extension module can be useful for other extension modules. For example, an extension module could implement
a type “collection” which works like lists without order. Just like the standard Python list type has a C API which
permits extension modules to create and manipulate lists, this new collection type should have a set of C functions
for direct manipulation from other extension modules.
At first sight this seems easy: just write the functions (without declaring them static, of course), provide an
appropriate header file, and document the C API. And in fact this would work if all extension modules were always
linked statically with the Python interpreter. When modules are used as shared libraries, however, the symbols defined
in one module may not be visible to another module. The details of visibility depend on the operating system; some
systems use one global namespace for the Python interpreter and all extension modules (Windows, for example),
whereas others require an explicit list of imported symbols at module link time (AIX is one example), or offer a
choice of different strategies (most Unices). And even if symbols are globally visible, the module whose functions
one wishes to call might not have been loaded yet!
Portability therefore requires not to make any assumptions about symbol visibility. This means that all symbols in
extension modules should be declared static, except for the module’s initialization function, in order to avoid name
clashes with other extension modules (as discussed in section The Module’s Method Table and Initialization Function).
And it means that symbols that should be accessible from other extension modules must be exported in a different
way.
Python provides a special mechanism to pass C-level information (pointers) from one extension module to another
one: Capsules. A Capsule is a Python data type which stores a pointer (void*). Capsules can only be created and
accessed via their C API, but they can be passed around like any other Python object. In particular, they can be
assigned to a name in an extension module’s namespace. Other extension modules can then import this module,
retrieve the value of this name, and then retrieve the pointer from the Capsule.
4 These guarantees don’t hold when you use the “old” style calling convention — this is still found in much existing code.

20 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

There are many ways in which Capsules can be used to export the C API of an extension module. Each function
could get its own Capsule, or all C API pointers could be stored in an array whose address is published in a Capsule.
And the various tasks of storing and retrieving the pointers can be distributed in different ways between the module
providing the code and the client modules.
Whichever method you choose, it’s important to name your Capsules properly. The function PyCapsule_New()
takes a name parameter (const char*); you’re permitted to pass in a NULL name, but we strongly encourage you
to specify a name. Properly named Capsules provide a degree of runtime type-safety; there is no feasible way to tell
one unnamed Capsule from another.
In particular, Capsules used to expose C APIs should be given a name following this convention:

modulename.attributename

The convenience function PyCapsule_Import() makes it easy to load a C API provided via a Capsule, but only
if the Capsule’s name matches this convention. This behavior gives C API users a high degree of certainty that the
Capsule they load contains the correct C API.
The following example demonstrates an approach that puts most of the burden on the writer of the exporting module,
which is appropriate for commonly used library modules. It stores all C API pointers (just one in the example!) in an
array of void pointers which becomes the value of a Capsule. The header file corresponding to the module provides
a macro that takes care of importing the module and retrieving its C API pointers; client modules only have to call
this macro before accessing the C API.
The exporting module is a modification of the spam module from section Um Exemplo Simples. The function spam.
system() does not call the C library function system() directly, but a function PySpam_System(), which would
of course do something more complicated in reality (such as adding “spam” to every command). This function
PySpam_System() is also exported to other extension modules.

The function PySpam_System() is a plain C function, declared static like everything else:

static int
PySpam_System(const char *command)
{
return system(command);
}

The function spam_system() is modified in a trivial way:

static PyObject *
spam_system(PyObject *self, PyObject *args)
{
const char *command;
int sts;

if (!PyArg_ParseTuple(args, "s", &command))

return NULL;
sts = PySpam_System(command);
return PyLong_FromLong(sts);
}

In the beginning of the module, right after the line

#include <Python.h>

two more lines must be added:

#define SPAM_MODULE
#include "spammodule.h"

The #define is used to tell the header file that it is being included in the exporting module, not a client module.
Finally, the module’s initialization function must take care of initializing the C API pointer array:

2.1. Estendendo Python com C ou C++ 21

Extending and Embedding Python, Release 3.13.2

PyMODINIT_FUNC
PyInit_spam(void)
{
PyObject *m;
static void *PySpam_API[PySpam_API_pointers];
PyObject *c_api_object;

m = PyModule_Create(&spammodule);
if (m == NULL)
return NULL;

/* Initialize the C API pointer array */

PySpam_API[PySpam_System_NUM] = (void *)PySpam_System;

/* Create a Capsule containing the API pointer array's address */

c_api_object = PyCapsule_New((void *)PySpam_API, "spam._C_API", NULL);

if (PyModule_Add(m, "_C_API", c_api_object) < 0) {

Py_DECREF(m);
return NULL;
}

return m;
}

Note that PySpam_API is declared static; otherwise the pointer array would disappear when PyInit_spam()
terminates!
The bulk of the work is in the header file spammodule.h, which looks like this:

#ifndef Py_SPAMMODULE_H
#define Py_SPAMMODULE_H
#ifdef __cplusplus
extern "C" {
#endif

/* Header file for spammodule */

/* C API functions */
#define PySpam_System_NUM 0
#define PySpam_System_RETURN int
#define PySpam_System_PROTO (const char *command)

/* Total number of C API pointers */

#define PySpam_API_pointers 1

#ifdef SPAM_MODULE
/* This section is used when compiling spammodule.c */

static PySpam_System_RETURN PySpam_System PySpam_System_PROTO;

#else
/* This section is used in modules that use spammodule's API */

static void **PySpam_API;

(continua na pró xima pá gina)

22 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

#define PySpam_System \
(*(PySpam_System_RETURN (*)PySpam_System_PROTO) PySpam_API[PySpam_System_NUM])

/* Return -1 on error, 0 on success.

* PyCapsule_Import will set an exception if there's an error.
*/
static int
import_spam(void)
{
PySpam_API = (void **)PyCapsule_Import("spam._C_API", 0);
return (PySpam_API != NULL) ? 0 : -1;
}

#endif

#ifdef __cplusplus
}
#endif

#endif /* !defined(Py_SPAMMODULE_H) */

All that a client module must do in order to have access to the function PySpam_System() is to call the function
(or rather macro) import_spam() in its initialization function:

PyMODINIT_FUNC
PyInit_client(void)
{
PyObject *m;

m = PyModule_Create(&clientmodule);
if (m == NULL)
return NULL;
if (import_spam() < 0)
return NULL;
/* additional initialization can happen here */
return m;
}

The main disadvantage of this approach is that the file spammodule.h is rather complicated. However, the basic
structure is the same for each function that is exported, so it has to be learned only once.
Finally it should be mentioned that Capsules offer additional functionality, which is especially useful for memory
allocation and deallocation of the pointer stored in a Capsule. The details are described in the Python/C API Reference
Manual in the section capsules and in the implementation of Capsules (files Include/pycapsule.h and Objects/
pycapsule.c in the Python source code distribution).

2.2 Definindo Tipos de Extensão: Tutorial

O Python permite que o gravador de um mó dulo de extensã o C defina novos tipos que podem ser manipulados a
partir do có digo Python, da mesma forma que os tipos embutidos str e list. O có digo para todos os tipos de
extensã o segue um padrã o, mas há alguns detalhes que você precisa entender antes de começar. Este documento é
uma introduçã o suave ao tó pico.

2.2. Definindo Tipos de Extensão: Tutorial 23

Extending and Embedding Python, Release 3.13.2

2.2.1 O básico
The CPython runtime sees all Python objects as variables of type PyObject*, which serves as a “base type” for all
Python objects. The PyObject structure itself only contains the object’s reference count and a pointer to the object’s
“type object”. This is where the action is; the type object determines which (C) functions get called by the interpreter
when, for instance, an attribute gets looked up on an object, a method called, or it is multiplied by another object.
These C functions are called “type methods”.
Entã o, se você quiser definir um novo tipo de extensã o, você precisa criar um novo objeto de tipo.
This sort of thing can only be explained by example, so here’s a minimal, but complete, module that defines a new
type named Custom inside a C extension module custom:

® Nota

What we’re showing here is the traditional way of defining static extension types. It should be adequate for most
uses. The C API also allows defining heap-allocated extension types using the PyType_FromSpec() function,
which isn’t covered in this tutorial.

#define PY_SSIZE_T_CLEAN
#include <Python.h>

typedef struct {
PyObject_HEAD
/* Type-specific fields go here. */
} CustomObject;

static PyTypeObject CustomType = {

.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "custom.Custom",
.tp_doc = PyDoc_STR("Custom objects"),
.tp_basicsize = sizeof(CustomObject),
.tp_itemsize = 0,
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_new = PyType_GenericNew,
};

static PyModuleDef custommodule = {

.m_base = PyModuleDef_HEAD_INIT,
.m_name = "custom",
.m_doc = "Example module that creates an extension type.",
.m_size = -1,
};

PyMODINIT_FUNC
PyInit_custom(void)
{
PyObject *m;
if (PyType_Ready(&CustomType) < 0)
return NULL;

m = PyModule_Create(&custommodule);
if (m == NULL)
return NULL;

if (PyModule_AddObjectRef(m, "Custom", (PyObject *) &CustomType) < 0) {

Py_DECREF(m);
return NULL;
(continua na pró xima pá gina)

24 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

}

return m;
}

Agora isso é um pouco para ser absorvido de uma só vez, mas esperamos que os bits pareçam familiares no capítulo
anterior. Este arquivo define trê s coisas:
1. What a Custom object contains: this is the CustomObject struct, which is allocated once for each Custom
instance.
2. How the Custom type behaves: this is the CustomType struct, which defines a set of flags and function
pointers that the interpreter inspects when specific operations are requested.
3. How to initialize the custom module: this is the PyInit_custom function and the associated custommodule
struct.
O primeiro bit é

typedef struct {
PyObject_HEAD
} CustomObject;

This is what a Custom object will contain. PyObject_HEAD is mandatory at the start of each object struct and
defines a field called ob_base of type PyObject, containing a pointer to a type object and a reference count (these
can be accessed using the macros Py_TYPE and Py_REFCNT respectively). The reason for the macro is to abstract
away the layout and to enable additional fields in debug builds.

® Nota

There is no semicolon above after the PyObject_HEAD macro. Be wary of adding one by accident: some
compilers will complain.

Of course, objects generally store additional data besides the standard PyObject_HEAD boilerplate; for example,
here is the definition for standard Python floats:

typedef struct {
PyObject_HEAD
double ob_fval;
} PyFloatObject;

O segundo bit é a definiçã o do objeto de tipo.

static PyTypeObject CustomType = {

.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "custom.Custom",
.tp_doc = PyDoc_STR("Custom objects"),
.tp_basicsize = sizeof(CustomObject),
.tp_itemsize = 0,
.tp_flags = Py_TPFLAGS_DEFAULT,
.tp_new = PyType_GenericNew,
};

® Nota

We recommend using C99-style designated initializers as above, to avoid listing all the PyTypeObject fields
that you don’t care about and also to avoid caring about the fields’ declaration order.

2.2. Definindo Tipos de Extensão: Tutorial 25

Extending and Embedding Python, Release 3.13.2

The actual definition of PyTypeObject in object.h has many more fields than the definition above. The remaining
fields will be filled with zeros by the C compiler, and it’s common practice to not specify them explicitly unless you
need them.
Vamos separá -lo, um campo de cada vez

.ob_base = PyVarObject_HEAD_INIT(NULL, 0)

This line is mandatory boilerplate to initialize the ob_base field mentioned above.

.tp_name = "custom.Custom",

The name of our type. This will appear in the default textual representation of our objects and in some error messages,
for example:

>>> "" + custom.Custom()

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "custom.Custom") to str

Note that the name is a dotted name that includes both the module name and the name of the type within the module.
The module in this case is custom and the type is Custom, so we set the type name to custom.Custom. Using the
real dotted import path is important to make your type compatible with the pydoc and pickle modules.

.tp_basicsize = sizeof(CustomObject),
.tp_itemsize = 0,

This is so that Python knows how much memory to allocate when creating new Custom instances. tp_itemsize
is only used for variable-sized objects and should otherwise be zero.

® Nota

If you want your type to be subclassable from Python, and your type has the same tp_basicsize as its base
type, you may have problems with multiple inheritance. A Python subclass of your type will have to list your
type first in its __bases__, or else it will not be able to call your type’s __new__() method without getting an
error. You can avoid this problem by ensuring that your type has a larger value for tp_basicsize than its base
type does. Most of the time, this will be true anyway, because either your base type will be object, or else you
will be adding data members to your base type, and therefore increasing its size.

We set the class flags to Py_TPFLAGS_DEFAULT.

.tp_flags = Py_TPFLAGS_DEFAULT,

All types should include this constant in their flags. It enables all of the members defined until at least Python 3.3. If
you need further members, you will need to OR the corresponding flags.
We provide a doc string for the type in tp_doc.

.tp_doc = PyDoc_STR("Custom objects"),

To enable object creation, we have to provide a tp_new handler. This is the equivalent of the Python method
__new__(), but has to be specified explicitly. In this case, we can just use the default implementation provided by
the API function PyType_GenericNew().

.tp_new = PyType_GenericNew,

Everything else in the file should be familiar, except for some code in PyInit_custom():

if (PyType_Ready(&CustomType) < 0)
return;

26 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

This initializes the Custom type, filling in a number of members to the appropriate default values, including ob_type
that we initially set to NULL.

if (PyModule_AddObjectRef(m, "Custom", (PyObject *) &CustomType) < 0) {

Py_DECREF(m);
return NULL;
}

This adds the type to the module dictionary. This allows us to create Custom instances by calling the Custom class:

>>> import custom

>>> mycustom = custom.Custom()

That’s it! All that remains is to build it; put the above code in a file called custom.c,

[build-system]
requires = ["setuptools"]
build-backend = "setuptools.build_meta"

[project]
name = "custom"
version = "1"

in a file called pyproject.toml, and

from setuptools import Extension, setup

setup(ext_modules=[Extension("custom", ["custom.c"])])

in a file called setup.py; then typing

$ python -m pip install .

in a shell should produce a file custom.so in a subdirectory and install it; now fire up Python — you should be able
to import custom and play around with Custom objects.
Isso nã o foi tã o difícil, foi?
Naturalmente, o tipo personalizado atual é bastante desinteressante. Nã o tem dados e nã o faz nada. Nã o pode nem
ser subclassificado.

2.2.2 Adicionando dados e métodos ao exemplo básico

Let’s extend the basic example to add some data and methods. Let’s also make the type usable as a base class. We’ll
create a new module, custom2 that adds these capabilities:

#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h> /* for offsetof() */

typedef struct {
PyObject_HEAD
PyObject *first; /* first name */
PyObject *last; /* last name */
int number;
} CustomObject;

static void
Custom_dealloc(CustomObject *self)
{
Py_XDECREF(self->first);
(continua na pró xima pá gina)

2.2. Definindo Tipos de Extensão: Tutorial 27

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

Py_XDECREF(self->last);
Py_TYPE(self)->tp_free((PyObject *) self);
}

static PyObject *
Custom_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
CustomObject *self;
self = (CustomObject *) type->tp_alloc(type, 0);
if (self != NULL) {
self->first = PyUnicode_FromString("");
if (self->first == NULL) {
Py_DECREF(self);
return NULL;
}
self->last = PyUnicode_FromString("");
if (self->last == NULL) {
Py_DECREF(self);
return NULL;
}
self->number = 0;
}
return (PyObject *) self;
}

static int
Custom_init(CustomObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"first", "last", "number", NULL};
PyObject *first = NULL, *last = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist,

&first, &last,
&self->number))
return -1;

if (first) {
Py_XSETREF(self->first, Py_NewRef(first));
}
if (last) {
Py_XSETREF(self->last, Py_NewRef(last));
}
return 0;
}

static PyMemberDef Custom_members[] = {

{"first", Py_T_OBJECT_EX, offsetof(CustomObject, first), 0,
"first name"},
{"last", Py_T_OBJECT_EX, offsetof(CustomObject, last), 0,
"last name"},
{"number", Py_T_INT, offsetof(CustomObject, number), 0,
"custom number"},
{NULL} /* Sentinel */
};

static PyObject *
(continua na pró xima pá gina)

28 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

Custom_name(CustomObject *self, PyObject *Py_UNUSED(ignored))
{
if (self->first == NULL) {
PyErr_SetString(PyExc_AttributeError, "first");
return NULL;
}
if (self->last == NULL) {
PyErr_SetString(PyExc_AttributeError, "last");
return NULL;
}
return PyUnicode_FromFormat("%S %S", self->first, self->last);
}

static PyMethodDef Custom_methods[] = {

{"name", (PyCFunction) Custom_name, METH_NOARGS,
"Return the name, combining the first and last name"
},
{NULL} /* Sentinel */
};

static PyTypeObject CustomType = {

.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "custom2.Custom",
.tp_doc = PyDoc_STR("Custom objects"),
.tp_basicsize = sizeof(CustomObject),
.tp_itemsize = 0,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
.tp_new = Custom_new,
.tp_init = (initproc) Custom_init,
.tp_dealloc = (destructor) Custom_dealloc,
.tp_members = Custom_members,
.tp_methods = Custom_methods,
};

static PyModuleDef custommodule = {

.m_base =PyModuleDef_HEAD_INIT,
.m_name = "custom2",
.m_doc = "Example module that creates an extension type.",
.m_size = -1,
};

PyMODINIT_FUNC
PyInit_custom2(void)
{
PyObject *m;
if (PyType_Ready(&CustomType) < 0)
return NULL;

m = PyModule_Create(&custommodule);
if (m == NULL)
return NULL;

if (PyModule_AddObjectRef(m, "Custom", (PyObject *) &CustomType) < 0) {

Py_DECREF(m);
return NULL;
}
(continua na pró xima pá gina)

2.2. Definindo Tipos de Extensão: Tutorial 29

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

return m;
}

Esta versã o do mó dulo possui vá rias alteraçõ es.

The Custom type now has three data attributes in its C struct, first, last, and number. The first and last variables are
Python strings containing first and last names. The number attribute is a C integer.
A estrutura do objeto é atualizada de acordo

typedef struct {
PyObject_HEAD
PyObject *first; /* first name */
PyObject *last; /* last name */
int number;
} CustomObject;

Because we now have data to manage, we have to be more careful about object allocation and deallocation. At a
minimum, we need a deallocation method:

static void
Custom_dealloc(CustomObject *self)
{
Py_XDECREF(self->first);
Py_XDECREF(self->last);
Py_TYPE(self)->tp_free((PyObject *) self);
}

which is assigned to the tp_dealloc member:

.tp_dealloc = (destructor) Custom_dealloc,

This method first clears the reference counts of the two Python attributes. Py_XDECREF() correctly handles the case
where its argument is NULL (which might happen here if tp_new failed midway). It then calls the tp_free member
of the object’s type (computed by Py_TYPE(self)) to free the object’s memory. Note that the object’s type might
not be CustomType, because the object may be an instance of a subclass.

® Nota

The explicit cast to destructor above is needed because we defined Custom_dealloc to take a
CustomObject * argument, but the tp_dealloc function pointer expects to receive a PyObject * argu-
ment. Otherwise, the compiler will emit a warning. This is object-oriented polymorphism, in C!

We want to make sure that the first and last names are initialized to empty strings, so we provide a tp_new imple-
mentation:

static PyObject *
Custom_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
CustomObject *self;
self = (CustomObject *) type->tp_alloc(type, 0);
if (self != NULL) {
self->first = PyUnicode_FromString("");
if (self->first == NULL) {
Py_DECREF(self);
return NULL;
(continua na pró xima pá gina)

30 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

}
self->last = PyUnicode_FromString("");
if (self->last == NULL) {
Py_DECREF(self);
return NULL;
}
self->number = 0;
}
return (PyObject *) self;
}

and install it in the tp_new member:

.tp_new = Custom_new,

The tp_new handler is responsible for creating (as opposed to initializing) objects of the type. It is exposed in Python
as the __new__() method. It is not required to define a tp_new member, and indeed many extension types will
simply reuse PyType_GenericNew() as done in the first version of the Custom type above. In this case, we use
the tp_new handler to initialize the first and last attributes to non-NULL default values.
tp_new is passed the type being instantiated (not necessarily CustomType, if a subclass is instantiated) and any
arguments passed when the type was called, and is expected to return the instance created. tp_new handlers always
accept positional and keyword arguments, but they often ignore the arguments, leaving the argument handling to
initializer (a.k.a. tp_init in C or __init__ in Python) methods.

® Nota

tp_new shouldn’t call tp_init explicitly, as the interpreter will do it itself.

The tp_new implementation calls the tp_alloc slot to allocate memory:

self = (CustomObject *) type->tp_alloc(type, 0);

Since memory allocation may fail, we must check the tp_alloc result against NULL before proceeding.

® Nota

We didn’t fill the tp_alloc slot ourselves. Rather PyType_Ready() fills it for us by inheriting it from our base
class, which is object by default. Most types use the default allocation strategy.

® Nota

If you are creating a co-operative tp_new (one that calls a base type’s tp_new or __new__()), you must not
try to determine what method to call using method resolution order at runtime. Always statically determine what
type you are going to call, and call its tp_new directly, or via type->tp_base->tp_new. If you do not do
this, Python subclasses of your type that also inherit from other Python-defined classes may not work correctly.
(Specifically, you may not be able to create instances of such subclasses without getting a TypeError.)

We also define an initialization function which accepts arguments to provide initial values for our instance:

static int
Custom_init(CustomObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"first", "last", "number", NULL};
(continua na pró xima pá gina)

2.2. Definindo Tipos de Extensão: Tutorial 31

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

PyObject *first = NULL, *last = NULL, *tmp;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOi", kwlist,

&first, &last,
&self->number))
return -1;

if (first) {
tmp = self->first;
Py_INCREF(first);
self->first = first;
Py_XDECREF(tmp);
}
if (last) {
tmp = self->last;
Py_INCREF(last);
self->last = last;
Py_XDECREF(tmp);
}
return 0;
}

by filling the tp_init slot.

.tp_init = (initproc) Custom_init,

The tp_init slot is exposed in Python as the __init__() method. It is used to initialize an object after it’s created.
Initializers always accept positional and keyword arguments, and they should return either 0 on success or -1 on error.
Unlike the tp_new handler, there is no guarantee that tp_init is called at all (for example, the pickle module by
default doesn’t call __init__() on unpickled instances). It can also be called multiple times. Anyone can call the
__init__() method on our objects. For this reason, we have to be extra careful when assigning the new attribute
values. We might be tempted, for example to assign the first member like this:

if (first) {
Py_XDECREF(self->first);
Py_INCREF(first);
self->first = first;
}

But this would be risky. Our type doesn’t restrict the type of the first member, so it could be any kind of object.
It could have a destructor that causes code to be executed that tries to access the first member; or that destructor
could release the Global interpreter Lock and let arbitrary code run in other threads that accesses and modifies our
object.
Para sermos paranoicos e nos protegermos contra essa possibilidade, quase sempre realocamos os membros antes de
decrementar suas contagens de referê ncia. Quando nã o temos que fazer isso?
• quando sabemos absolutamente que a contagem de referê ncia é maior que 1;
• when we know that deallocation of the object1 will neither release the GIL nor cause any calls back into our
type’s code;
• when decrementing a reference count in a tp_dealloc handler on a type which doesn’t support cyclic garbage
collection2 .
We want to expose our instance variables as attributes. There are a number of ways to do that. The simplest way is
to define member definitions:
1 Isso é verdade quando sabemos que o objeto é um tipo bá sico, como uma string ou um float.
2 We relied on this in the tp_dealloc handler in this example, because our type doesn’t support garbage collection.

32 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

static PyMemberDef Custom_members[] = {

{"first", Py_T_OBJECT_EX, offsetof(CustomObject, first), 0,
"first name"},
{"last", Py_T_OBJECT_EX, offsetof(CustomObject, last), 0,
"last name"},
{"number", Py_T_INT, offsetof(CustomObject, number), 0,
"custom number"},
{NULL} /* Sentinel */
};

and put the definitions in the tp_members slot:

.tp_members = Custom_members,

Each member definition has a member name, type, offset, access flags and documentation string. See the Generic
Attribute Management section below for details.
A disadvantage of this approach is that it doesn’t provide a way to restrict the types of objects that can be assigned
to the Python attributes. We expect the first and last names to be strings, but any Python objects can be assigned.
Further, the attributes can be deleted, setting the C pointers to NULL. Even though we can make sure the members
are initialized to non-NULL values, the members can be set to NULL if the attributes are deleted.
We define a single method, Custom.name(), that outputs the objects name as the concatenation of the first and last
names.

static PyObject *
Custom_name(CustomObject *self, PyObject *Py_UNUSED(ignored))
{
if (self->first == NULL) {
PyErr_SetString(PyExc_AttributeError, "first");
return NULL;
}
if (self->last == NULL) {
PyErr_SetString(PyExc_AttributeError, "last");
return NULL;
}
return PyUnicode_FromFormat("%S %S", self->first, self->last);
}

The method is implemented as a C function that takes a Custom (or Custom subclass) instance as the first argument.
Methods always take an instance as the first argument. Methods often take positional and keyword arguments as
well, but in this case we don’t take any and don’t need to accept a positional argument tuple or keyword argument
dictionary. This method is equivalent to the Python method:

def name(self):
return "%s %s" % (self.first, self.last)

Note that we have to check for the possibility that our first and last members are NULL. This is because they can
be deleted, in which case they are set to NULL. It would be better to prevent deletion of these attributes and to restrict
the attribute values to be strings. We’ll see how to do that in the next section.
Agora que definimos o mé todo, precisamos criar uma array de definiçõ es de mé todos:

static PyMethodDef Custom_methods[] = {

{"name", (PyCFunction) Custom_name, METH_NOARGS,
"Return the name, combining the first and last name"
},
{NULL} /* Sentinel */
};

2.2. Definindo Tipos de Extensão: Tutorial 33

Extending and Embedding Python, Release 3.13.2

(note that we used the METH_NOARGS flag to indicate that the method is expecting no arguments other than self)
and assign it to the tp_methods slot:

.tp_methods = Custom_methods,

Finally, we’ll make our type usable as a base class for subclassing. We’ve written our methods carefully so far so that
they don’t make any assumptions about the type of the object being created or used, so all we need to do is to add
the Py_TPFLAGS_BASETYPE to our class flag definition:

.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,

We rename PyInit_custom() to PyInit_custom2(), update the module name in the PyModuleDef struct, and
update the full class name in the PyTypeObject struct.
Finally, we update our setup.py file to include the new module,

from setuptools import Extension, setup

setup(ext_modules=[
Extension("custom", ["custom.c"]),
Extension("custom2", ["custom2.c"]),
])

and then we re-install so that we can import custom2:

$ python -m pip install .

2.2.3 Fornecendo controle mais preciso sobre atributos de dados

In this section, we’ll provide finer control over how the first and last attributes are set in the Custom example.
In the previous version of our module, the instance variables first and last could be set to non-string values or
even deleted. We want to make sure that these attributes always contain strings.

#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h> /* for offsetof() */

typedef struct {
PyObject_HEAD
PyObject *first; /* first name */
PyObject *last; /* last name */
int number;
} CustomObject;

static void
Custom_dealloc(CustomObject *self)
{
Py_XDECREF(self->first);
Py_XDECREF(self->last);
Py_TYPE(self)->tp_free((PyObject *) self);
}

static PyObject *
Custom_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
CustomObject *self;
self = (CustomObject *) type->tp_alloc(type, 0);
if (self != NULL) {
self->first = PyUnicode_FromString("");
(continua na pró xima pá gina)

34 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

if (self->first == NULL) {
Py_DECREF(self);
return NULL;
}
self->last = PyUnicode_FromString("");
if (self->last == NULL) {
Py_DECREF(self);
return NULL;
}
self->number = 0;
}
return (PyObject *) self;
}

static int
Custom_init(CustomObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"first", "last", "number", NULL};
PyObject *first = NULL, *last = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|UUi", kwlist,

&first, &last,
&self->number))
return -1;

if (first) {
Py_SETREF(self->first, Py_NewRef(first));
}
if (last) {
Py_SETREF(self->last, Py_NewRef(last));
}
return 0;
}

static PyMemberDef Custom_members[] = {

{"number", Py_T_INT, offsetof(CustomObject, number), 0,
"custom number"},
{NULL} /* Sentinel */
};

static PyObject *
Custom_getfirst(CustomObject *self, void *closure)
{
return Py_NewRef(self->first);
}

static int
Custom_setfirst(CustomObject *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "Cannot delete the first attribute");
return -1;
}
if (!PyUnicode_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"The first attribute value must be a string");
(continua na pró xima pá gina)

2.2. Definindo Tipos de Extensão: Tutorial 35

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

return -1;
}
Py_SETREF(self->first, Py_NewRef(value));
return 0;
}

static PyObject *
Custom_getlast(CustomObject *self, void *closure)
{
return Py_NewRef(self->last);
}

static int
Custom_setlast(CustomObject *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "Cannot delete the last attribute");
return -1;
}
if (!PyUnicode_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"The last attribute value must be a string");
return -1;
}
Py_SETREF(self->last, Py_NewRef(value));
return 0;
}

static PyGetSetDef Custom_getsetters[] = {

{"first", (getter) Custom_getfirst, (setter) Custom_setfirst,
"first name", NULL},
{"last", (getter) Custom_getlast, (setter) Custom_setlast,
"last name", NULL},
{NULL} /* Sentinel */
};

static PyObject *
Custom_name(CustomObject *self, PyObject *Py_UNUSED(ignored))
{
return PyUnicode_FromFormat("%S %S", self->first, self->last);
}

static PyMethodDef Custom_methods[] = {

{"name", (PyCFunction) Custom_name, METH_NOARGS,
"Return the name, combining the first and last name"
},
{NULL} /* Sentinel */
};

static PyTypeObject CustomType = {

.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "custom3.Custom",
.tp_doc = PyDoc_STR("Custom objects"),
.tp_basicsize = sizeof(CustomObject),
.tp_itemsize = 0,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
(continua na pró xima pá gina)

36 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

.tp_new = Custom_new,
.tp_init = (initproc) Custom_init,
.tp_dealloc = (destructor) Custom_dealloc,
.tp_members = Custom_members,
.tp_methods = Custom_methods,
.tp_getset = Custom_getsetters,
};

static PyModuleDef custommodule = {

.m_base = PyModuleDef_HEAD_INIT,
.m_name = "custom3",
.m_doc = "Example module that creates an extension type.",
.m_size = -1,
};

PyMODINIT_FUNC
PyInit_custom3(void)
{
PyObject *m;
if (PyType_Ready(&CustomType) < 0)
return NULL;

m = PyModule_Create(&custommodule);
if (m == NULL)
return NULL;

if (PyModule_AddObjectRef(m, "Custom", (PyObject *) &CustomType) < 0) {

Py_DECREF(m);
return NULL;
}

return m;
}

To provide greater control, over the first and last attributes, we’ll use custom getter and setter functions. Here
are the functions for getting and setting the first attribute:

static PyObject *
Custom_getfirst(CustomObject *self, void *closure)
{
Py_INCREF(self->first);
return self->first;
}

static int
Custom_setfirst(CustomObject *self, PyObject *value, void *closure)
{
PyObject *tmp;
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "Cannot delete the first attribute");
return -1;
}
if (!PyUnicode_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"The first attribute value must be a string");
return -1;
(continua na pró xima pá gina)

2.2. Definindo Tipos de Extensão: Tutorial 37

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

}
tmp = self->first;
Py_INCREF(value);
self->first = value;
Py_DECREF(tmp);
return 0;
}

The getter function is passed a Custom object and a “closure”, which is a void pointer. In this case, the closure is
ignored. (The closure supports an advanced usage in which definition data is passed to the getter and setter. This
could, for example, be used to allow a single set of getter and setter functions that decide the attribute to get or set
based on data in the closure.)
The setter function is passed the Custom object, the new value, and the closure. The new value may be NULL, in
which case the attribute is being deleted. In our setter, we raise an error if the attribute is deleted or if its new value
is not a string.
We create an array of PyGetSetDef structures:

static PyGetSetDef Custom_getsetters[] = {

{"first", (getter) Custom_getfirst, (setter) Custom_setfirst,
"first name", NULL},
{"last", (getter) Custom_getlast, (setter) Custom_setlast,
"last name", NULL},
{NULL} /* Sentinel */
};

e registra isso num slot tp_getset:

.tp_getset = Custom_getsetters,

The last item in a PyGetSetDef structure is the “closure” mentioned above. In this case, we aren’t using a closure,
so we just pass NULL.
També m removemos as definiçõ es de membros para esses atributos:

static PyMemberDef Custom_members[] = {

{"number", Py_T_INT, offsetof(CustomObject, number), 0,
"custom number"},
{NULL} /* Sentinel */
};

We also need to update the tp_init handler to only allow strings3 to be passed:

static int
Custom_init(CustomObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"first", "last", "number", NULL};
PyObject *first = NULL, *last = NULL, *tmp;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|UUi", kwlist,

&first, &last,
&self->number))
return -1;

(continua na pró xima pá gina)

3 Agora sabemos que o primeiro e ú ltimo membros sã o strings, entã o talvez pudé ssemos ter menos cuidado com a diminuiçã o de suas contagens

de referê ncia, no entanto, aceitamos instâ ncias de subclasses de string. Mesmo que a desalocaçã o de cadeias normais nã o retorne aos nossos objetos,
nã o podemos garantir que a desalocaçã o de uma instâ ncia de uma subclasse de cadeias de caracteres nã o retornará aos nossos objetos.

38 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

if (first) {
tmp = self->first;
Py_INCREF(first);
self->first = first;
Py_DECREF(tmp);
}
if (last) {
tmp = self->last;
Py_INCREF(last);
self->last = last;
Py_DECREF(tmp);
}
return 0;
}

With these changes, we can assure that the first and last members are never NULL so we can remove checks for
NULL values in almost all cases. This means that most of the Py_XDECREF() calls can be converted to Py_DECREF()
calls. The only place we can’t change these calls is in the tp_dealloc implementation, where there is the possibility
that the initialization of these members failed in tp_new.
We also rename the module initialization function and module name in the initialization function, as we did before,
and we add an extra definition to the setup.py file.

2.2.4 Apoiando a coleta de lixo cíclica

Python has a cyclic garbage collector (GC) that can identify unneeded objects even when their reference counts are
not zero. This can happen when objects are involved in cycles. For example, consider:

>>> l = []
>>> l.append(l)
>>> del l

In this example, we create a list that contains itself. When we delete it, it still has a reference from itself. Its reference
count doesn’t drop to zero. Fortunately, Python’s cyclic garbage collector will eventually figure out that the list is
garbage and free it.
In the second version of the Custom example, we allowed any kind of object to be stored in the first or last
attributes4 . Besides, in the second and third versions, we allowed subclassing Custom, and subclasses may add
arbitrary attributes. For any of those two reasons, Custom objects can participate in cycles:

>>> import custom3

>>> class Derived(custom3.Custom): pass
...
>>> n = Derived()
>>> n.some_attribute = n

To allow a Custom instance participating in a reference cycle to be properly detected and collected by the cyclic GC,
our Custom type needs to fill two additional slots and to enable a flag that enables these slots:

#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stddef.h> /* for offsetof() */

typedef struct {
PyObject_HEAD
(continua na pró xima pá gina)
4 Alé m disso, mesmo com nossos atributos restritos a instâ ncias de strings, o usuá rio poderia passar arbitrariamente subclasses str e, portanto,

ainda criar ciclos de referê ncia.

2.2. Definindo Tipos de Extensão: Tutorial 39

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

PyObject *first; /* first name */
PyObject *last; /* last name */
int number;
} CustomObject;

static int
Custom_traverse(CustomObject *self, visitproc visit, void *arg)
{
Py_VISIT(self->first);
Py_VISIT(self->last);
return 0;
}

static int
Custom_clear(CustomObject *self)
{
Py_CLEAR(self->first);
Py_CLEAR(self->last);
return 0;
}

static void
Custom_dealloc(CustomObject *self)
{
PyObject_GC_UnTrack(self);
Custom_clear(self);
Py_TYPE(self)->tp_free((PyObject *) self);
}

static PyObject *
Custom_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
CustomObject *self;
self = (CustomObject *) type->tp_alloc(type, 0);
if (self != NULL) {
self->first = PyUnicode_FromString("");
if (self->first == NULL) {
Py_DECREF(self);
return NULL;
}
self->last = PyUnicode_FromString("");
if (self->last == NULL) {
Py_DECREF(self);
return NULL;
}
self->number = 0;
}
return (PyObject *) self;
}

static int
Custom_init(CustomObject *self, PyObject *args, PyObject *kwds)
{
static char *kwlist[] = {"first", "last", "number", NULL};
PyObject *first = NULL, *last = NULL;

(continua na pró xima pá gina)

40 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

if (!PyArg_ParseTupleAndKeywords(args, kwds, "|UUi", kwlist,
&first, &last,
&self->number))
return -1;

if (first) {
Py_SETREF(self->first, Py_NewRef(first));
}
if (last) {
Py_SETREF(self->last, Py_NewRef(last));
}
return 0;
}

static PyMemberDef Custom_members[] = {

{"number", Py_T_INT, offsetof(CustomObject, number), 0,
"custom number"},
{NULL} /* Sentinel */
};

static PyObject *
Custom_getfirst(CustomObject *self, void *closure)
{
return Py_NewRef(self->first);
}

static int
Custom_setfirst(CustomObject *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "Cannot delete the first attribute");
return -1;
}
if (!PyUnicode_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"The first attribute value must be a string");
return -1;
}
Py_XSETREF(self->first, Py_NewRef(value));
return 0;
}

static PyObject *
Custom_getlast(CustomObject *self, void *closure)
{
return Py_NewRef(self->last);
}

static int
Custom_setlast(CustomObject *self, PyObject *value, void *closure)
{
if (value == NULL) {
PyErr_SetString(PyExc_TypeError, "Cannot delete the last attribute");
return -1;
}
if (!PyUnicode_Check(value)) {
(continua na pró xima pá gina)

2.2. Definindo Tipos de Extensão: Tutorial 41

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

PyErr_SetString(PyExc_TypeError,
"The last attribute value must be a string");
return -1;
}
Py_XSETREF(self->last, Py_NewRef(value));
return 0;
}

static PyGetSetDef Custom_getsetters[] = {

{"first", (getter) Custom_getfirst, (setter) Custom_setfirst,
"first name", NULL},
{"last", (getter) Custom_getlast, (setter) Custom_setlast,
"last name", NULL},
{NULL} /* Sentinel */
};

static PyObject *
Custom_name(CustomObject *self, PyObject *Py_UNUSED(ignored))
{
return PyUnicode_FromFormat("%S %S", self->first, self->last);
}

static PyMethodDef Custom_methods[] = {

{"name", (PyCFunction) Custom_name, METH_NOARGS,
"Return the name, combining the first and last name"
},
{NULL} /* Sentinel */
};

static PyTypeObject CustomType = {

.ob_base = PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "custom4.Custom",
.tp_doc = PyDoc_STR("Custom objects"),
.tp_basicsize = sizeof(CustomObject),
.tp_itemsize = 0,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
.tp_new = Custom_new,
.tp_init = (initproc) Custom_init,
.tp_dealloc = (destructor) Custom_dealloc,
.tp_traverse = (traverseproc) Custom_traverse,
.tp_clear = (inquiry) Custom_clear,
.tp_members = Custom_members,
.tp_methods = Custom_methods,
.tp_getset = Custom_getsetters,
};

static PyModuleDef custommodule = {

.m_base = PyModuleDef_HEAD_INIT,
.m_name = "custom4",
.m_doc = "Example module that creates an extension type.",
.m_size = -1,
};

PyMODINIT_FUNC
PyInit_custom4(void)
{
(continua na pró xima pá gina)

42 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

PyObject *m;
if (PyType_Ready(&CustomType) < 0)
return NULL;

m = PyModule_Create(&custommodule);
if (m == NULL)
return NULL;

if (PyModule_AddObjectRef(m, "Custom", (PyObject *) &CustomType) < 0) {

Py_DECREF(m);
return NULL;
}

return m;
}

First, the traversal method lets the cyclic GC know about subobjects that could participate in cycles:

static int
Custom_traverse(CustomObject *self, visitproc visit, void *arg)
{
int vret;
if (self->first) {
vret = visit(self->first, arg);
if (vret != 0)
return vret;
}
if (self->last) {
vret = visit(self->last, arg);
if (vret != 0)
return vret;
}
return 0;
}

For each subobject that can participate in cycles, we need to call the visit() function, which is passed to the
traversal method. The visit() function takes as arguments the subobject and the extra argument arg passed to the
traversal method. It returns an integer value that must be returned if it is non-zero.
Python provides a Py_VISIT() macro that automates calling visit functions. With Py_VISIT(), we can minimize
the amount of boilerplate in Custom_traverse:

static int
Custom_traverse(CustomObject *self, visitproc visit, void *arg)
{
Py_VISIT(self->first);
Py_VISIT(self->last);
return 0;
}

® Nota

The tp_traverse implementation must name its arguments exactly visit and arg in order to use Py_VISIT().

Second, we need to provide a method for clearing any subobjects that can participate in cycles:

2.2. Definindo Tipos de Extensão: Tutorial 43

Extending and Embedding Python, Release 3.13.2

static int
Custom_clear(CustomObject *self)
{
Py_CLEAR(self->first);
Py_CLEAR(self->last);
return 0;
}

Notice the use of the Py_CLEAR() macro. It is the recommended and safe way to clear data attributes of arbitrary
types while decrementing their reference counts. If you were to call Py_XDECREF() instead on the attribute before
setting it to NULL, there is a possibility that the attribute’s destructor would call back into code that reads the attribute
again (especially if there is a reference cycle).

® Nota

You could emulate Py_CLEAR() by writing:

PyObject *tmp;
tmp = self->first;
self->first = NULL;
Py_XDECREF(tmp);

Nevertheless, it is much easier and less error-prone to always use Py_CLEAR() when deleting an attribute. Don’t
try to micro-optimize at the expense of robustness!

The deallocator Custom_dealloc may call arbitrary code when clearing attributes. It means the circular GC can be
triggered inside the function. Since the GC assumes reference count is not zero, we need to untrack the object from
the GC by calling PyObject_GC_UnTrack() before clearing members. Here is our reimplemented deallocator
using PyObject_GC_UnTrack() and Custom_clear:

static void
Custom_dealloc(CustomObject *self)
{
PyObject_GC_UnTrack(self);
Custom_clear(self);
Py_TYPE(self)->tp_free((PyObject *) self);
}

Finally, we add the Py_TPFLAGS_HAVE_GC flag to the class flags:

.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,

That’s pretty much it. If we had written custom tp_alloc or tp_free handlers, we’d need to modify them for
cyclic garbage collection. Most extensions will use the versions automatically provided.

2.2.5 Criando subclasses de outros tipos

It is possible to create new extension types that are derived from existing types. It is easiest to inherit from the built in
types, since an extension can easily use the PyTypeObject it needs. It can be difficult to share these PyTypeObject
structures between extension modules.
In this example we will create a SubList type that inherits from the built-in list type. The new type will be
completely compatible with regular lists, but will have an additional increment() method that increases an internal
counter:

>>> import sublist

>>> s = sublist.SubList(range(3))
>>> s.extend(s)
(continua na pró xima pá gina)

44 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

>>> print(len(s))
6
>>> print(s.increment())
1
>>> print(s.increment())
2

#define PY_SSIZE_T_CLEAN
#include <Python.h>

typedef struct {
PyListObject list;
int state;
} SubListObject;

static PyObject *
SubList_increment(SubListObject *self, PyObject *unused)
{
self->state++;
return PyLong_FromLong(self->state);
}

static PyMethodDef SubList_methods[] = {

{"increment", (PyCFunction) SubList_increment, METH_NOARGS,
PyDoc_STR("increment state counter")},
{NULL},
};

static int
SubList_init(SubListObject *self, PyObject *args, PyObject *kwds)
{
if (PyList_Type.tp_init((PyObject *) self, args, kwds) < 0)
return -1;
self->state = 0;
return 0;
}

static PyTypeObject SubListType = {

PyVarObject_HEAD_INIT(NULL, 0)
.tp_name = "sublist.SubList",
.tp_doc = PyDoc_STR("SubList objects"),
.tp_basicsize = sizeof(SubListObject),
.tp_itemsize = 0,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
.tp_init = (initproc) SubList_init,
.tp_methods = SubList_methods,
};

static PyModuleDef sublistmodule = {

PyModuleDef_HEAD_INIT,
.m_name = "sublist",
.m_doc = "Example module that creates an extension type.",
.m_size = -1,
};

PyMODINIT_FUNC
(continua na pró xima pá gina)

2.2. Definindo Tipos de Extensão: Tutorial 45

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

PyInit_sublist(void)
{
PyObject *m;
SubListType.tp_base = &PyList_Type;
if (PyType_Ready(&SubListType) < 0)
return NULL;

m = PyModule_Create(&sublistmodule);
if (m == NULL)
return NULL;

if (PyModule_AddObjectRef(m, "SubList", (PyObject *) &SubListType) < 0) {

Py_DECREF(m);
return NULL;
}

return m;
}

As you can see, the source code closely resembles the Custom examples in previous sections. We will break down
the main differences between them.

typedef struct {
PyListObject list;
int state;
} SubListObject;

The primary difference for derived type objects is that the base type’s object structure must be the first value. The
base type will already include the PyObject_HEAD() at the beginning of its structure.
When a Python object is a SubList instance, its PyObject * pointer can be safely cast to both PyListObject
* and SubListObject *:

static int
SubList_init(SubListObject *self, PyObject *args, PyObject *kwds)
{
if (PyList_Type.tp_init((PyObject *) self, args, kwds) < 0)
return -1;
self->state = 0;
return 0;
}

We see above how to call through to the __init__() method of the base type.
This pattern is important when writing a type with custom tp_new and tp_dealloc members. The tp_new handler
should not actually create the memory for the object with its tp_alloc, but let the base class handle it by calling its
own tp_new.
The PyTypeObject struct supports a tp_base specifying the type’s concrete base class. Due to cross-platform
compiler issues, you can’t fill that field directly with a reference to PyList_Type; it should be done later in the
module initialization function:

PyMODINIT_FUNC
PyInit_sublist(void)
{
PyObject* m;
SubListType.tp_base = &PyList_Type;
if (PyType_Ready(&SubListType) < 0)
(continua na pró xima pá gina)

46 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

return NULL;

m = PyModule_Create(&sublistmodule);
if (m == NULL)
return NULL;

if (PyModule_AddObjectRef(m, "SubList", (PyObject *) &SubListType) < 0) {

Py_DECREF(m);
return NULL;
}

return m;
}

Before calling PyType_Ready(), the type structure must have the tp_base slot filled in. When we are deriving an
existing type, it is not necessary to fill out the tp_alloc slot with PyType_GenericNew() – the allocation function
from the base type will be inherited.
After that, calling PyType_Ready() and adding the type object to the module is the same as with the basic Custom
examples.

2.3 Defining Extension Types: Assorted Topics

This section aims to give a quick fly-by on the various type methods you can implement and what they do.
Here is the definition of PyTypeObject, with some fields only used in debug builds omitted:
typedef struct _typeobject {
PyObject_VAR_HEAD
const char *tp_name; /* For printing, in format "<module>.<name>" */
Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */

/* Methods to implement standard operations */

destructor tp_dealloc;
Py_ssize_t tp_vectorcall_offset;
getattrfunc tp_getattr;
setattrfunc tp_setattr;
PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
or tp_reserved (Python 3) */
reprfunc tp_repr;

/* Method suites for standard classes */

PyNumberMethods *tp_as_number;
PySequenceMethods *tp_as_sequence;
PyMappingMethods *tp_as_mapping;

/* More standard operations (here for binary compatibility) */

hashfunc tp_hash;
ternaryfunc tp_call;
reprfunc tp_str;
getattrofunc tp_getattro;
setattrofunc tp_setattro;

/* Functions to access object as input/output buffer */

(continua na pró xima pá gina)

2.3. Defining Extension Types: Assorted Topics 47

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

PyBufferProcs *tp_as_buffer;

/* Flags to define presence of optional/expanded features */

unsigned long tp_flags;

const char *tp_doc; /* Documentation string */

/* Assigned meaning in release 2.0 */

/* call function for all accessible objects */
traverseproc tp_traverse;

/* delete references to contained objects */

inquiry tp_clear;

/* Assigned meaning in release 2.1 */

/* rich comparisons */
richcmpfunc tp_richcompare;

/* weak reference enabler */

Py_ssize_t tp_weaklistoffset;

/* Iterators */
getiterfunc tp_iter;
iternextfunc tp_iternext;

/* Attribute descriptor and subclassing stuff */

struct PyMethodDef *tp_methods;
struct PyMemberDef *tp_members;
struct PyGetSetDef *tp_getset;
// Strong reference on a heap type, borrowed reference on a static type
struct _typeobject *tp_base;
PyObject *tp_dict;
descrgetfunc tp_descr_get;
descrsetfunc tp_descr_set;
Py_ssize_t tp_dictoffset;
initproc tp_init;
allocfunc tp_alloc;
newfunc tp_new;
freefunc tp_free; /* Low-level free-memory routine */
inquiry tp_is_gc; /* For PyObject_IS_GC */
PyObject *tp_bases;
PyObject *tp_mro; /* method resolution order */
PyObject *tp_cache;
PyObject *tp_subclasses;
PyObject *tp_weaklist;
destructor tp_del;

/* Type attribute cache version tag. Added in version 2.6 */

unsigned int tp_version_tag;

destructor tp_finalize;
vectorcallfunc tp_vectorcall;

/* bitset of which type-watchers care about this type */

unsigned char tp_watched;
} PyTypeObject;

48 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

Now that’s a lot of methods. Don’t worry too much though – if you have a type you want to define, the chances are
very good that you will only implement a handful of these.
As you probably expect by now, we’re going to go over this and give more information about the various handlers.
We won’t go in the order they are defined in the structure, because there is a lot of historical baggage that impacts
the ordering of the fields. It’s often easiest to find an example that includes the fields you need and then change the
values to suit your new type.

const char *tp_name; /* For printing */

The name of the type – as mentioned in the previous chapter, this will appear in various places, almost entirely for
diagnostic purposes. Try to choose something that will be helpful in such a situation!

Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */

These fields tell the runtime how much memory to allocate when new objects of this type are created. Python has
some built-in support for variable length structures (think: strings, tuples) which is where the tp_itemsize field
comes in. This will be dealt with later.

const char *tp_doc;

Here you can put a string (or its address) that you want returned when the Python script references obj.__doc__
to retrieve the doc string.
Now we come to the basic type methods – the ones most extension types will implement.

2.3.1 Finalization and De-allocation

destructor tp_dealloc;

This function is called when the reference count of the instance of your type is reduced to zero and the Python
interpreter wants to reclaim it. If your type has memory to free or other clean-up to perform, you can put it here.
The object itself needs to be freed here as well. Here is an example of this function:

static void
newdatatype_dealloc(newdatatypeobject *obj)
{
free(obj->obj_UnderlyingDatatypePtr);
Py_TYPE(obj)->tp_free((PyObject *)obj);
}

If your type supports garbage collection, the destructor should call PyObject_GC_UnTrack() before clearing any
member fields:

static void
newdatatype_dealloc(newdatatypeobject *obj)
{
PyObject_GC_UnTrack(obj);
Py_CLEAR(obj->other_obj);
...
Py_TYPE(obj)->tp_free((PyObject *)obj);
}

One important requirement of the deallocator function is that it leaves any pending exceptions alone. This is important
since deallocators are frequently called as the interpreter unwinds the Python stack; when the stack is unwound due to
an exception (rather than normal returns), nothing is done to protect the deallocators from seeing that an exception has
already been set. Any actions which a deallocator performs which may cause additional Python code to be executed
may detect that an exception has been set. This can lead to misleading errors from the interpreter. The proper way
to protect against this is to save a pending exception before performing the unsafe action, and restoring it when done.
This can be done using the PyErr_Fetch() and PyErr_Restore() functions:

2.3. Defining Extension Types: Assorted Topics 49

Extending and Embedding Python, Release 3.13.2

static void
my_dealloc(PyObject *obj)
{
MyObject *self = (MyObject *) obj;
PyObject *cbresult;

if (self->my_callback != NULL) {
PyObject *err_type, *err_value, *err_traceback;

/* This saves the current exception state */

PyErr_Fetch(&err_type, &err_value, &err_traceback);

cbresult = PyObject_CallNoArgs(self->my_callback);
if (cbresult == NULL)
PyErr_WriteUnraisable(self->my_callback);
else
Py_DECREF(cbresult);

/* This restores the saved exception state */

PyErr_Restore(err_type, err_value, err_traceback);

Py_DECREF(self->my_callback);
}
Py_TYPE(obj)->tp_free((PyObject*)self);
}

® Nota

There are limitations to what you can safely do in a deallocator function. First, if your type supports garbage
collection (using tp_traverse and/or tp_clear), some of the object’s members can have been cleared or
finalized by the time tp_dealloc is called. Second, in tp_dealloc, your object is in an unstable state: its
reference count is equal to zero. Any call to a non-trivial object or API (as in the example above) might end up
calling tp_dealloc again, causing a double free and a crash.
Starting with Python 3.4, it is recommended not to put any complex finalization code in tp_dealloc, and instead
use the new tp_finalize type method.

µ Ver também

PEP 442 explains the new finalization scheme.

2.3.2 Object Presentation

In Python, there are two ways to generate a textual representation of an object: the repr() function, and the str()
function. (The print() function just calls str().) These handlers are both optional.

reprfunc tp_repr;
reprfunc tp_str;

The tp_repr handler should return a string object containing a representation of the instance for which it is called.
Here is a simple example:

static PyObject *
newdatatype_repr(newdatatypeobject *obj)
{
(continua na pró xima pá gina)

50 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

return PyUnicode_FromFormat("Repr-ified_newdatatype{{size:%d}}",
obj->obj_UnderlyingDatatypePtr->size);
}

If no tp_repr handler is specified, the interpreter will supply a representation that uses the type’s tp_name and a
uniquely identifying value for the object.
The tp_str handler is to str() what the tp_repr handler described above is to repr(); that is, it is called when
Python code calls str() on an instance of your object. Its implementation is very similar to the tp_repr function,
but the resulting string is intended for human consumption. If tp_str is not specified, the tp_repr handler is used
instead.
Here is a simple example:

static PyObject *
newdatatype_str(newdatatypeobject *obj)
{
return PyUnicode_FromFormat("Stringified_newdatatype{{size:%d}}",
obj->obj_UnderlyingDatatypePtr->size);
}

2.3.3 Attribute Management

For every object which can support attributes, the corresponding type must provide the functions that control how the
attributes are resolved. There needs to be a function which can retrieve attributes (if any are defined), and another to
set attributes (if setting attributes is allowed). Removing an attribute is a special case, for which the new value passed
to the handler is NULL.
Python supports two pairs of attribute handlers; a type that supports attributes only needs to implement the functions
for one pair. The difference is that one pair takes the name of the attribute as a char*, while the other accepts a
PyObject*. Each type can use whichever pair makes more sense for the implementation’s convenience.

getattrfunc tp_getattr; /* char * version */

setattrfunc tp_setattr;
/* ... */
getattrofunc tp_getattro; /* PyObject * version */
setattrofunc tp_setattro;

If accessing attributes of an object is always a simple operation (this will be explained shortly), there are generic
implementations which can be used to provide the PyObject* version of the attribute management functions. The
actual need for type-specific attribute handlers almost completely disappeared starting with Python 2.2, though there
are many examples which have not been updated to use some of the new generic mechanism that is available.

Generic Attribute Management

Most extension types only use simple attributes. So, what makes the attributes simple? There are only a couple of
conditions that must be met:
1. The name of the attributes must be known when PyType_Ready() is called.
2. No special processing is needed to record that an attribute was looked up or set, nor do actions need to be taken
based on the value.
Note that this list does not place any restrictions on the values of the attributes, when the values are computed, or
how relevant data is stored.
When PyType_Ready() is called, it uses three tables referenced by the type object to create descriptors which are
placed in the dictionary of the type object. Each descriptor controls access to one attribute of the instance object.
Each of the tables is optional; if all three are NULL, instances of the type will only have attributes that are inherited
from their base type, and should leave the tp_getattro and tp_setattro fields NULL as well, allowing the base
type to handle attributes.

2.3. Defining Extension Types: Assorted Topics 51

Extending and Embedding Python, Release 3.13.2

The tables are declared as three fields of the type object:

struct PyMethodDef *tp_methods;

struct PyMemberDef *tp_members;
struct PyGetSetDef *tp_getset;

If tp_methods is not NULL, it must refer to an array of PyMethodDef structures. Each entry in the table is an
instance of this structure:

typedef struct PyMethodDef {

const char *ml_name; /* method name */
PyCFunction ml_meth; /* implementation function */
int ml_flags; /* flags */
const char *ml_doc; /* docstring */
} PyMethodDef;

One entry should be defined for each method provided by the type; no entries are needed for methods inherited from
a base type. One additional entry is needed at the end; it is a sentinel that marks the end of the array. The ml_name
field of the sentinel must be NULL.
The second table is used to define attributes which map directly to data stored in the instance. A variety of primitive
C types are supported, and access may be read-only or read-write. The structures in the table are defined as:

typedef struct PyMemberDef {

const char *name;
int type;
int offset;
int flags;
const char *doc;
} PyMemberDef;

For each entry in the table, a descriptor will be constructed and added to the type which will be able to extract a value
from the instance structure. The type field should contain a type code like Py_T_INT or Py_T_DOUBLE; the value
will be used to determine how to convert Python values to and from C values. The flags field is used to store flags
which control how the attribute can be accessed: you can set it to Py_READONLY to prevent Python code from setting
it.
An interesting advantage of using the tp_members table to build descriptors that are used at runtime is that any
attribute defined this way can have an associated doc string simply by providing the text in the table. An application
can use the introspection API to retrieve the descriptor from the class object, and get the doc string using its __doc__
attribute.
As with the tp_methods table, a sentinel entry with a ml_name value of NULL is required.

Type-specific Attribute Management

For simplicity, only the char* version will be demonstrated here; the type of the name parameter is the only diffe-
rence between the char* and PyObject* flavors of the interface. This example effectively does the same thing as
the generic example above, but does not use the generic support added in Python 2.2. It explains how the handler
functions are called, so that if you do need to extend their functionality, you’ll understand what needs to be done.
The tp_getattr handler is called when the object requires an attribute look-up. It is called in the same situations
where the __getattr__() method of a class would be called.
Aqui está um exemplo:

static PyObject *
newdatatype_getattr(newdatatypeobject *obj, char *name)
{
if (strcmp(name, "data") == 0)
{
(continua na pró xima pá gina)

52 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

return PyLong_FromLong(obj->data);
}

PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.400s'",
Py_TYPE(obj)->tp_name, name);
return NULL;
}

The tp_setattr handler is called when the __setattr__() or __delattr__() method of a class instance
would be called. When an attribute should be deleted, the third parameter will be NULL. Here is an example that
simply raises an exception; if this were really all you wanted, the tp_setattr handler should be set to NULL.

static int
newdatatype_setattr(newdatatypeobject *obj, char *name, PyObject *v)
{
PyErr_Format(PyExc_RuntimeError, "Read-only attribute: %s", name);
return -1;
}

2.3.4 Object Comparison

richcmpfunc tp_richcompare;

The tp_richcompare handler is called when comparisons are needed. It is analogous to the rich comparison
methods, like __lt__(), and also called by PyObject_RichCompare() and PyObject_RichCompareBool().
This function is called with two Python objects and the operator as arguments, where the operator is one of Py_EQ,
Py_NE, Py_LE, Py_GE, Py_LT or Py_GT. It should compare the two objects with respect to the specified operator and
return Py_True or Py_False if the comparison is successful, Py_NotImplemented to indicate that comparison
is not implemented and the other object’s comparison method should be tried, or NULL if an exception was set.
Here is a sample implementation, for a datatype that is considered equal if the size of an internal pointer is equal:

static PyObject *
newdatatype_richcmp(newdatatypeobject *obj1, newdatatypeobject *obj2, int op)
{
PyObject *result;
int c, size1, size2;

/* code to make sure that both arguments are of type

newdatatype omitted */

size1 = obj1->obj_UnderlyingDatatypePtr->size;
size2 = obj2->obj_UnderlyingDatatypePtr->size;

switch (op) {
case Py_LT: c = size1 < size2; break;
case Py_LE: c = size1 <= size2; break;
case Py_EQ: c = size1 == size2; break;
case Py_NE: c = size1 != size2; break;
case Py_GT: c = size1 > size2; break;
case Py_GE: c = size1 >= size2; break;
}
result = c ? Py_True : Py_False;
Py_INCREF(result);
(continua na pró xima pá gina)

2.3. Defining Extension Types: Assorted Topics 53

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

return result;
}

2.3.5 Abstract Protocol Support

Python supports a variety of abstract ‘protocols;’ the specific interfaces provided to use these interfaces are docu-
mented in abstract.
A number of these abstract interfaces were defined early in the development of the Python implementation. In parti-
cular, the number, mapping, and sequence protocols have been part of Python since the beginning. Other protocols
have been added over time. For protocols which depend on several handler routines from the type implementation,
the older protocols have been defined as optional blocks of handlers referenced by the type object. For newer pro-
tocols there are additional slots in the main type object, with a flag bit being set to indicate that the slots are present
and should be checked by the interpreter. (The flag bit does not indicate that the slot values are non-NULL. The flag
may be set to indicate the presence of a slot, but a slot may still be unfilled.)

PyNumberMethods *tp_as_number;
PySequenceMethods *tp_as_sequence;
PyMappingMethods *tp_as_mapping;

If you wish your object to be able to act like a number, a sequence, or a mapping object, then you place the address
of a structure that implements the C type PyNumberMethods, PySequenceMethods, or PyMappingMethods,
respectively. It is up to you to fill in this structure with appropriate values. You can find examples of the use of each
of these in the Objects directory of the Python source distribution.

hashfunc tp_hash;

This function, if you choose to provide it, should return a hash number for an instance of your data type. Here is a
simple example:

static Py_hash_t
newdatatype_hash(newdatatypeobject *obj)
{
Py_hash_t result;
result = obj->some_size + 32767 * obj->some_number;
if (result == -1)
result = -2;
return result;
}

Py_hash_t is a signed integer type with a platform-varying width. Returning -1 from tp_hash indicates an error,
which is why you should be careful to avoid returning it when hash computation is successful, as seen above.

ternaryfunc tp_call;

This function is called when an instance of your data type is “called”, for example, if obj1 is an instance of your data
type and the Python script contains obj1('hello'), the tp_call handler is invoked.
This function takes three arguments:
1. self is the instance of the data type which is the subject of the call. If the call is obj1('hello'), then self is
obj1.
2. args is a tuple containing the arguments to the call. You can use PyArg_ParseTuple() to extract the argu-
ments.
3. kwds is a dictionary of keyword arguments that were passed. If this is non-NULL and you support keyword
arguments, use PyArg_ParseTupleAndKeywords() to extract the arguments. If you do not want to support
keyword arguments and this is non-NULL, raise a TypeError with a message saying that keyword arguments
are not supported.

54 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

Here is a toy tp_call implementation:

static PyObject *
newdatatype_call(newdatatypeobject *obj, PyObject *args, PyObject *kwds)
{
PyObject *result;
const char *arg1;
const char *arg2;
const char *arg3;

if (!PyArg_ParseTuple(args, "sss:call", &arg1, &arg2, &arg3)) {

return NULL;
}
result = PyUnicode_FromFormat(
"Returning -- value: [%d] arg1: [%s] arg2: [%s] arg3: [%s]\n",
obj->obj_UnderlyingDatatypePtr->size,
arg1, arg2, arg3);
return result;
}

/* Iterators */
getiterfunc tp_iter;
iternextfunc tp_iternext;

These functions provide support for the iterator protocol. Both handlers take exactly one parameter, the instance for
which they are being called, and return a new reference. In the case of an error, they should set an exception and
return NULL. tp_iter corresponds to the Python __iter__() method, while tp_iternext corresponds to the
Python __next__() method.
Any iterable object must implement the tp_iter handler, which must return an iterator object. Here the same
guidelines apply as for Python classes:
• For collections (such as lists and tuples) which can support multiple independent iterators, a new iterator should
be created and returned by each call to tp_iter.
• Objects which can only be iterated over once (usually due to side effects of iteration, such as file objects) can
implement tp_iter by returning a new reference to themselves – and should also therefore implement the
tp_iternext handler.

Any iterator object should implement both tp_iter and tp_iternext. An iterator’s tp_iter handler should
return a new reference to the iterator. Its tp_iternext handler should return a new reference to the next object in
the iteration, if there is one. If the iteration has reached the end, tp_iternext may return NULL without setting
an exception, or it may set StopIteration in addition to returning NULL; avoiding the exception can yield slightly
better performance. If an actual error occurs, tp_iternext should always set an exception and return NULL.

2.3.6 Weak Reference Support

One of the goals of Python’s weak reference implementation is to allow any type to participate in the weak reference
mechanism without incurring the overhead on performance-critical objects (such as numbers).

µ Ver também

Documentaçã o do mó dulo weakref.

For an object to be weakly referenceable, the extension type must set the Py_TPFLAGS_MANAGED_WEAKREF bit of
the tp_flags field. The legacy tp_weaklistoffset field should be left as zero.
Concretely, here is how the statically declared type object would look:

2.3. Defining Extension Types: Assorted Topics 55

Extending and Embedding Python, Release 3.13.2

static PyTypeObject TrivialType = {

PyVarObject_HEAD_INIT(NULL, 0)
/* ... other members omitted for brevity ... */
.tp_flags = Py_TPFLAGS_MANAGED_WEAKREF | ...,
};

The only further addition is that tp_dealloc needs to clear any weak references (by calling
PyObject_ClearWeakRefs()):

static void
Trivial_dealloc(TrivialObject *self)
{
/* Clear weakrefs first before calling any destructors */
PyObject_ClearWeakRefs((PyObject *) self);
/* ... remainder of destruction code omitted for brevity ... */
Py_TYPE(self)->tp_free((PyObject *) self);
}

2.3.7 More Suggestions

In order to learn how to implement any specific method for your new data type, get the CPython source code.
Go to the Objects directory, then search the C source files for tp_ plus the function you want (for example,
tp_richcompare). You will find examples of the function you want to implement.

When you need to verify that an object is a concrete instance of the type you are implementing, use the
PyObject_TypeCheck() function. A sample of its use might be something like the following:

if (!PyObject_TypeCheck(some_object, &MyType)) {
PyErr_SetString(PyExc_TypeError, "arg #1 not a mything");
return NULL;
}

µ Ver também

Download CPython source releases.

https://www.python.org/downloads/source/
The CPython project on GitHub, where the CPython source code is developed.
https://github.com/python/cpython

2.4 Construindo extensões C e C++

Uma extensã o C para CPython é uma biblioteca compartilhada (por exemplo, um arquivo .so no Linux, .pyd no
Windows), que exporta uma função de inicialização.
Para ser importá vel, a biblioteca compartilhada deve estar disponível em PYTHONPATH, e deve ser nomeada apó s o
nome do mó dulo, com uma extensã o apropriada. Ao usar setuptools, o nome do arquivo correto é gerado automati-
camente.
A funçã o de inicializaçã o tem a assinatura:
PyObject *PyInit_modulename(void)

Ela retorna um mó dulo totalmente inicializado ou uma instâ ncia de PyModuleDef. Veja initializing-modules para
detalhes.
Para mó dulos com nomes somente ASCII, a funçã o deve ser nomeada PyInit_<nomemódulo>, com
<nomemódulo> substituído pelo nome do mó dulo. Ao usar multi-phase-initialization, nomes de mó dulos nã o ASCII

56 Capítulo 2. Criando extensões sem ferramentas de terceiros

 Extending and Embedding Python, Release 3.13.2

sã o permitidos. Neste caso, o nome da funçã o de inicializaçã o é PyInitU_<nomemódulo>, com <nomemódulo>
codificado usando a codificaçã o punycode do Python com hifenes substituídos por sublinhados. Em Python:

def nome_func_iniciadora(nome):
try:
sufixo = b'_' + nome.encode('ascii')
except UnicodeEncodeError:
sufixo = b'U_' + nome.encode('punycode').replace(b'-', b'_')
return b'PyInit' + sufixo

É possível exportar vá rios mó dulos de uma ú nica biblioteca compartilhada, definindo vá rias funçõ es de inicializaçã o.
No entanto, importá -los requer o uso de links simbó licos ou um importador personalizado, porque por padrã o apenas
a funçã o correspondente ao nome do arquivo é encontrada. Veja a seçã o “Multiple modules in one library” na PEP
489 para detalhes.

2.4.1 Construindo extensões C e C ++ com setuptools

O Python 3.12 e mais recente nã o vê m mais com distutils. Consulte a documentaçã o setuptools em https:
//setuptools.readthedocs.io/en/latest/setuptools.html para saber mais sobre como construir e distribuir extensõ es
C/C++ com setuptools.

2.5 Construindo Extensões C e C++ no Windows

Este capítulo explica brevemente como criar um mó dulo de extensã o do Windows para Python usando o Microsoft
Visual C++ e segue com informaçõ es mais detalhadas sobre como ele funciona. O material explicativo é ú til para
o programador do Windows aprender a construir extensõ es Python e o programador Unix interessado em produzir
software que possa ser construído com sucesso no Unix e no Windows.
Os autores de mó dulos sã o encorajados a usar a abordagem distutils para construir mó dulos de extensã o, em vez
daquele descrito nesta seçã o. Você ainda precisará do compilador C que foi usado para construir o Python; normal-
mente o Microsoft Visual C++.

® Nota

Este capítulo menciona vá rios nomes de arquivos que incluem um nú mero de versã o do Python codificado. Es-
ses nomes de arquivos sã o representados com o nú mero da versã o mostrado como XY; na prá tica, 'X' será o
nú mero da versã o principal e 'Y' será o nú mero da versã o secundá ria da versã o do Python com a qual você está
trabalhando. Por exemplo, se você estiver usando o Python 2.2.1, XY será 22.

2.5.1 Uma abordagem de livro de receitas

Existem duas abordagens para construir mó dulos de extensã o no Windows, assim como no Unix: use o pacote
setuptools para controlar o processo de construçã o ou faça as coisas manualmente. A abordagem setuptools
funciona bem para a maioria das extensõ es; documentaçã o sobre o uso de setuptools para construir e empacotar
mó dulos de extensã o está disponível em Construindo extensões C e C ++ com setuptools. Se você achar que realmente
precisa fazer as coisas manualmente, pode ser instrutivo estudar o arquivo do projeto para o mó dulo de biblioteca
padrã o winsound.

2.5.2 Diferenças entre o Unix e o Windows

O Unix e o Windows usam paradigmas completamente diferentes para o carregamento do có digo em tempo de
execuçã o. Antes de tentar construir um mó dulo que possa ser carregado dinamicamente, esteja ciente de como o seu
sistema funciona.
No Unix, um arquivo de objeto compartilhado (.so) conté m có digo a ser usado pelo programa e també m os nomes
de funçõ es e dados que ele espera encontrar no programa. Quando o arquivo é associado ao programa, todas as
referê ncias a essas funçõ es e dados no có digo do arquivo sã o alteradas para apontar para os locais reais no programa
em que as funçõ es e os dados sã o colocados na memó ria. Isso é basicamente uma operaçã o de vinculaçã o.

2.5. Construindo Extensões C e C++ no Windows 57

Extending and Embedding Python, Release 3.13.2

No Windows, um arquivo de biblioteca de vínculo dinâ mico (.dll) nã o possui referê ncias pendentes. Em vez disso,
um acesso a funçõ es ou dados passa por uma tabela de pesquisa. Portanto, o có digo DLL nã o precisa ser corrigido
no tempo de execuçã o para se referir à memó ria do programa; em vez disso, o có digo já usa a tabela de pesquisa da
DLL e a tabela de pesquisa é modificada em tempo de execuçã o para apontar para as funçõ es e dados.
No Unix, existe apenas um tipo de arquivo de biblioteca (.a) que conté m có digo de vá rios arquivos de objetos (.o).
Durante a etapa da vinculaçã o para criar um arquivo de objeto compartilhado (.so), o vinculador pode achar que nã o
sabe onde um identificador está definido. O vinculador procurará nos arquivos de objeto nas bibliotecas; se encontrar,
incluirá todo o có digo desse arquivo de objeto.
No Windows, existem dois tipos de biblioteca, uma biblioteca está tica e uma biblioteca de importaçã o (ambas chama-
das .lib). Uma biblioteca está tica é como um arquivo Unix .a; conté m có digo a ser incluído conforme necessá rio.
Uma biblioteca de importaçã o é basicamente usada apenas para garantir ao vinculador que um determinado identifi-
cador é legal e estará presente no programa quando a DLL for carregada. Portanto, o vinculador usa as informaçõ es
da biblioteca de importaçã o para construir a tabela de pesquisa para o uso de identificadores que nã o estã o incluí-
dos na DLL. Quando uma aplicaçã o ou uma DLL é vinculado, pode ser gerada uma biblioteca de importaçã o, que
precisará ser usada para todas as DLLs futuras que dependem dos símbolos na aplicaçã o ou DLL.
Suponha que você esteja construindo dois mó dulos de carregamento dinâ mico, B e C, que devem compartilhar outro
bloco de có digo A. No Unix, você não passaria A.a ao ligador para B.so e C.so; isso faria com que fosse incluído
duas vezes, para que B e C tivessem sua pró pria có pia. No Windows, a construçã o A.dll també m construirá A.lib.
Você passa A.lib ao ligador para B e C. A.lib nã o conté m có digo; apenas conté m informaçõ es que serã o usadas
em tempo de execuçã o para acessar o có digo de A.
No Windows, usar uma biblioteca de importaçã o é como usar import spam; fornece acesso aos nomes de spam,
mas nã o cria uma có pia separada. No Unix, vincular a uma biblioteca é mais como from spam import *; ele cria
uma có pia separada.

2.5.3 Usando DLLs na prática

O Python para Windows é criado no Microsoft Visual C++; o uso de outros compiladores pode ou nã o funcionar. O
restante desta seçã o é específico do MSVC++.
Ao criar DLLs no Windows, você deve passar pythonXY.lib para o ligador. Para construir duas DLLs, spam e ni
(que usa funçõ es C encontradas em spam), você pode usar estes comandos:

cl /LD /I/python/include spam.c ../libs/pythonXY.lib

cl /LD /I/python/include ni.c spam.lib ../libs/pythonXY.lib

O primeiro comando criou trê s arquivos: spam.obj, spam.dll e spam.lib. O spam.dll nã o conté m nenhuma
funçã o Python (como PyArg_ParseTuple()), mas sabe como encontrar o có digo Python graças a pythonXY.
lib.

O segundo comando criou ni.dll (e .obj e .lib), que sabe como encontrar as funçõ es necessá rias do spam e
també m do executá vel do Python.
Nem todo identificador é exportado para a tabela de pesquisa. Se você deseja que outros mó du-
los (incluindo Python) possam ver seus identificadores, é necessá rio dizer _declspec(dllexport),
como em void _declspec(dllexport) initspam(void) ou PyObject _declspec(dllexport)
*NiGetSpamData(void).

O Developer Studio incluirá muitas bibliotecas importadas que você realmente nã o precisa, adicionando cerca de
100K ao seu executá vel. Para se livrar delas, use a caixa de diá logo de configuraçõ es do projeto, na aba vincular,
para especificar ignorar bibliotecas padrão. Adicione o msvcrtxx.lib correto à lista de bibliotecas.

58 Capítulo 2. Criando extensões sem ferramentas de terceiros

 CAPÍTULO 3

Incorporando o tempo de execução do CPython em uma aplicação maior

Às vezes, em vez de criar uma extensã o que é executada dentro do interpretador Python como a aplicaçã o principal,
é desejá vel incorporar o tempo de execuçã o do CPython em uma aplicaçã o maior. Esta seçã o aborda alguns dos
detalhes envolvidos para fazer isso com ê xito.

3.1 Incorporando o Python numa Outra Aplicação

Os capítulos anteriores discutiram como estender o Python, ou seja, como expandir a funcionalidade do Python
anexando uma biblioteca de funçõ es em C a ele. També m é possível fazer o inverso: enriquecer sua aplicaçã o em
C/C++ incorporando o Python nela. A incorporaçã o fornece à sua aplicaçã o a capacidade de implementar parte
da funcionalidade da aplicaçã o em Python em vez de C ou C++. Isso pode ser usado para diversos propó sitos; um
exemplo seria permitir que os usuá rios personalizem a aplicaçã o de acordo com suas necessidades escrevendo alguns
scripts em Python. Você també m pode usá -la se parte da funcionalidade puder ser escrita em Python mais facilmente.
Incorporar o Python é semelhante a estendê -lo, mas nã o exatamente. A diferença é que, ao estender o Python,
o programa principal da aplicaçã o ainda é o interpretador Python, enquanto que, se você incorporar o Python, o
programa principal pode nã o ter nada a ver com o Python — em vez disso, algumas partes da aplicaçã o chamam
ocasionalmente o interpretador Python para executar algum có digo Python.
So if you are embedding Python, you are providing your own main program. One of the things this main program
has to do is initialize the Python interpreter. At the very least, you have to call the function Py_Initialize().
There are optional calls to pass command line arguments to Python. Then later you can call the interpreter from any
part of the application.
There are several different ways to call the interpreter: you can pass a string containing Python statements to
PyRun_SimpleString(), or you can pass a stdio file pointer and a file name (for identification in error messa-
ges only) to PyRun_SimpleFile(). You can also call the lower-level operations described in the previous chapters
to construct and use Python objects.

µ Ver também

c-api-index
The details of Python’s C interface are given in this manual. A great deal of necessary information can be
found here.

59
Extending and Embedding Python, Release 3.13.2

3.1.1 Very High Level Embedding

The simplest form of embedding Python is the use of the very high level interface. This interface is intended to
execute a Python script without needing to interact with the application directly. This can for example be used to
perform some operation on a file.

#define PY_SSIZE_T_CLEAN
#include <Python.h>

int
main(int argc, char *argv[])
{
PyStatus status;
PyConfig config;
PyConfig_InitPythonConfig(&config);

/* optional but recommended */

status = PyConfig_SetBytesString(&config, &config.program_name, argv[0]);
if (PyStatus_Exception(status)) {
goto exception;
}

status = Py_InitializeFromConfig(&config);
if (PyStatus_Exception(status)) {
goto exception;
}
PyConfig_Clear(&config);

PyRun_SimpleString("from time import time,ctime\n"

"print('Today is', ctime(time()))\n");
if (Py_FinalizeEx() < 0) {
exit(120);
}
return 0;

exception:
PyConfig_Clear(&config);
Py_ExitStatusException(status);
}

® Nota

#define PY_SSIZE_T_CLEAN was used to indicate that Py_ssize_t should be used in some APIs instead
of int. It is not necessary since Python 3.13, but we keep it here for backward compatibility. See arg-parsing-
-string-and-buffers for a description of this macro.

Setting PyConfig.program_name should be called before Py_InitializeFromConfig() to inform the inter-

preter about paths to Python run-time libraries. Next, the Python interpreter is initialized with Py_Initialize(),
followed by the execution of a hard-coded Python script that prints the date and time. Afterwards, the
Py_FinalizeEx() call shuts the interpreter down, followed by the end of the program. In a real program, you
may want to get the Python script from another source, perhaps a text-editor routine, a file, or a database. Getting
the Python code from a file can better be done by using the PyRun_SimpleFile() function, which saves you the
trouble of allocating memory space and loading the file contents.

60 Capítulo 3. Incorporando o tempo de execução do CPython em uma aplicação maior

 Extending and Embedding Python, Release 3.13.2

3.1.2 Beyond Very High Level Embedding: An overview

The high level interface gives you the ability to execute arbitrary pieces of Python code from your application, but
exchanging data values is quite cumbersome to say the least. If you want that, you should use lower level calls. At
the cost of having to write more C code, you can achieve almost anything.
It should be noted that extending Python and embedding Python is quite the same activity, despite the different intent.
Most topics discussed in the previous chapters are still valid. To show this, consider what the extension code from
Python to C really does:
1. Convert data values from Python to C,
2. Perform a function call to a C routine using the converted values, and
3. Convert the data values from the call from C to Python.
When embedding Python, the interface code does:
1. Convert data values from C to Python,
2. Perform a function call to a Python interface routine using the converted values, and
3. Convert the data values from the call from Python to C.
As you can see, the data conversion steps are simply swapped to accommodate the different direction of the cross-
-language transfer. The only difference is the routine that you call between both data conversions. When extending,
you call a C routine, when embedding, you call a Python routine.
This chapter will not discuss how to convert data from Python to C and vice versa. Also, proper use of references
and dealing with errors is assumed to be understood. Since these aspects do not differ from extending the interpreter,
you can refer to earlier chapters for the required information.

3.1.3 Pure Embedding

The first program aims to execute a function in a Python script. Like in the section about the very high level interface,
the Python interpreter does not directly interact with the application (but that will change in the next section).
The code to run a function defined in a Python script is:

#define PY_SSIZE_T_CLEAN
#include <Python.h>

int
main(int argc, char *argv[])
{
PyObject *pName, *pModule, *pFunc;
PyObject *pArgs, *pValue;
int i;

if (argc < 3) {
fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
return 1;
}

Py_Initialize();
pName = PyUnicode_DecodeFSDefault(argv[1]);
/* Error checking of pName left out */

pModule = PyImport_Import(pName);
Py_DECREF(pName);

if (pModule != NULL) {
pFunc = PyObject_GetAttrString(pModule, argv[2]);
(continua na pró xima pá gina)

3.1. Incorporando o Python numa Outra Aplicação 61

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

/* pFunc is a new reference */

if (pFunc && PyCallable_Check(pFunc)) {

pArgs = PyTuple_New(argc - 3);
for (i = 0; i < argc - 3; ++i) {
pValue = PyLong_FromLong(atoi(argv[i + 3]));
if (!pValue) {
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, i, pValue);
}
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
printf("Result of call: %ld\n", PyLong_AsLong(pValue));
Py_DECREF(pValue);
}
else {
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr,"Call failed\n");
return 1;
}
}
else {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
}
Py_XDECREF(pFunc);
Py_DECREF(pModule);
}
else {
PyErr_Print();
fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
return 1;
}
if (Py_FinalizeEx() < 0) {
return 120;
}
return 0;
}

This code loads a Python script using argv[1], and calls the function named in argv[2]. Its integer arguments are
the other values of the argv array. If you compile and link this program (let’s call the finished executable call), and
use it to execute a Python script, such as:

def multiply(a,b):
print("Will compute", a, "times", b)
c = 0
for i in range(0, a):
(continua na pró xima pá gina)

62 Capítulo 3. Incorporando o tempo de execução do CPython em uma aplicação maior

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

c = c + b
return c

then the result should be:

$ call multiply multiply 3 2

Will compute 3 times 2
Result of call: 6

Although the program is quite large for its functionality, most of the code is for data conversion between Python and
C, and for error reporting. The interesting part with respect to embedding Python starts with

Py_Initialize();
pName = PyUnicode_DecodeFSDefault(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);

After initializing the interpreter, the script is loaded using PyImport_Import(). This routine needs a Python string
as its argument, which is constructed using the PyUnicode_FromString() data conversion routine.

pFunc = PyObject_GetAttrString(pModule, argv[2]);

/* pFunc is a new reference */

if (pFunc && PyCallable_Check(pFunc)) {

...
}
Py_XDECREF(pFunc);

Once the script is loaded, the name we’re looking for is retrieved using PyObject_GetAttrString(). If the name
exists, and the object returned is callable, you can safely assume that it is a function. The program then proceeds by
constructing a tuple of arguments as normal. The call to the Python function is then made with:

pValue = PyObject_CallObject(pFunc, pArgs);

Upon return of the function, pValue is either NULL or it contains a reference to the return value of the function. Be
sure to release the reference after examining the value.

3.1.4 Extending Embedded Python

Until now, the embedded Python interpreter had no access to functionality from the application itself. The Python
API allows this by extending the embedded interpreter. That is, the embedded interpreter gets extended with routines
provided by the application. While it sounds complex, it is not so bad. Simply forget for a while that the application
starts the Python interpreter. Instead, consider the application to be a set of subroutines, and write some glue code
that gives Python access to those routines, just like you would write a normal Python extension. For example:

static int numargs=0;

/* Return the number of arguments of the application command line */

static PyObject*
emb_numargs(PyObject *self, PyObject *args)
{
if(!PyArg_ParseTuple(args, ":numargs"))
return NULL;
return PyLong_FromLong(numargs);
}

static PyMethodDef EmbMethods[] = {

(continua na pró xima pá gina)

3.1. Incorporando o Python numa Outra Aplicação 63

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

{"numargs", emb_numargs, METH_VARARGS,
"Return the number of arguments received by the process."},
{NULL, NULL, 0, NULL}
};

static PyModuleDef EmbModule = {

PyModuleDef_HEAD_INIT, "emb", NULL, -1, EmbMethods,
NULL, NULL, NULL, NULL
};

static PyObject*
PyInit_emb(void)
{
return PyModule_Create(&EmbModule);
}

Insert the above code just above the main() function. Also, insert the following two statements before the call to
Py_Initialize():

numargs = argc;
PyImport_AppendInittab("emb", &PyInit_emb);

These two lines initialize the numargs variable, and make the emb.numargs() function accessible to the embedded
Python interpreter. With these extensions, the Python script can do things like

import emb
print("Number of arguments", emb.numargs())

In a real application, the methods will expose an API of the application to Python.

3.1.5 Embedding Python in C++

It is also possible to embed Python in a C++ program; precisely how this is done will depend on the details of the
C++ system used; in general you will need to write the main program in C++, and use the C++ compiler to compile
and link your program. There is no need to recompile Python itself using C++.

3.1.6 Compiling and Linking under Unix-like systems

It is not necessarily trivial to find the right flags to pass to your compiler (and linker) in order to embed the Python in-
terpreter into your application, particularly because Python needs to load library modules implemented as C dynamic
extensions (.so files) linked against it.
To find out the required compiler and linker flags, you can execute the pythonX.Y-config script which is generated
as part of the installation process (a python3-config script may also be available). This script has several options,
of which the following will be directly useful to you:
• pythonX.Y-config --cflags will give you the recommended flags when compiling:

$ /opt/bin/python3.11-config --cflags
-I/opt/include/python3.11 -I/opt/include/python3.11 -Wsign-compare -DNDEBUG -
,→g -fwrapv -O3 -Wall

• pythonX.Y-config --ldflags --embed will give you the recommended flags when linking:

$ /opt/bin/python3.11-config --ldflags --embed

-L/opt/lib/python3.11/config-3.11-x86_64-linux-gnu -L/opt/lib -lpython3.11 -
,→lpthread -ldl -lutil -lm

64 Capítulo 3. Incorporando o tempo de execução do CPython em uma aplicação maior

 Extending and Embedding Python, Release 3.13.2

® Nota

To avoid confusion between several Python installations (and especially between the system Python and your own
compiled Python), it is recommended that you use the absolute path to pythonX.Y-config, as in the above
example.

If this procedure doesn’t work for you (it is not guaranteed to work for all Unix-like platforms; however, we welcome
bug reports) you will have to read your system’s documentation about dynamic linking and/or examine Python’s
Makefile (use sysconfig.get_makefile_filename() to find its location) and compilation options. In this
case, the sysconfig module is a useful tool to programmatically extract the configuration values that you will want
to combine together. For example:

>>> import sysconfig

>>> sysconfig.get_config_var('LIBS')
'-lpthread -ldl -lutil'
>>> sysconfig.get_config_var('LINKFORSHARED')
'-Xlinker -export-dynamic'

3.1. Incorporando o Python numa Outra Aplicação 65

Extending and Embedding Python, Release 3.13.2

66 Capítulo 3. Incorporando o tempo de execução do CPython em uma aplicação maior

 APÊNDICE A

Glossário

>>>
O prompt padrã o do console interativo do Python. Normalmente visto em exemplos de có digo que podem ser
executados interativamente no interpretador.
...
Pode se referir a:
• O prompt padrã o do console interativo do Python ao inserir o có digo para um bloco de có digo recuado,
quando dentro de um par de delimitadores correspondentes esquerdo e direito (parê nteses, colchetes,
chaves ou aspas triplas) ou apó s especificar um decorador.
• A constante embutida Ellipsis.
classe base abstrata
Classes bases abstratas complementam tipagem pato, fornecendo uma maneira de definir interfaces quando
outras té cnicas, como hasattr(), seriam desajeitadas ou sutilmente erradas (por exemplo, com mé todos
má gicos). ABCs introduzem subclasses virtuais, classes que nã o herdam de uma classe mas ainda sã o reconhe-
cidas por isinstance() e issubclass(); veja a documentaçã o do mó dulo abc. Python vem com muitas
ABCs embutidas para estruturas de dados (no mó dulo collections.abc), nú meros (no mó dulo numbers),
fluxos (no mó dulo io), localizadores e carregadores de importaçã o (no mó dulo importlib.abc). Você pode
criar suas pró prias ABCs com o mó dulo abc.
anotação
Um ró tulo associado a uma variá vel, um atributo de classe ou um parâ metro de funçã o ou valor de retorno,
usado por convençã o como dica de tipo.
Anotaçõ es de variá veis locais nã o podem ser acessadas em tempo de execuçã o, mas anotaçõ es de variá veis
globais, atributos de classe e funçõ es sã o armazenadas no atributo especial __annotations__ de mó dulos,
classes e funçõ es, respectivamente.
Veja anotação de variável, anotação de função, PEP 484 e PEP 526, que descrevem esta funcionalidade.
Veja també m annotations-howto para as melhores prá ticas sobre como trabalhar com anotaçõ es.
argumento
Um valor passado para uma função (ou método) ao chamar a funçã o. Existem dois tipos de argumento:
• argumento nomeado: um argumento precedido por um identificador (por exemplo, name=) na chamada
de uma funçã o ou passada como um valor em um dicioná rio precedido por **. Por exemplo, 3 e 5 sã o
ambos argumentos nomeados na chamada da funçã o complex() a seguir:

67
Extending and Embedding Python, Release 3.13.2

complex(real=3, imag=5)
complex(**{'real': 3, 'imag': 5})

• argumento posicional: um argumento que nã o é um argumento nomeado. Argumentos posicionais po-
dem aparecer no início da lista de argumentos e/ou podem ser passados com elementos de um iterável
precedido por *. Por exemplo, 3 e 5 sã o ambos argumentos posicionais nas chamadas a seguir:

complex(3, 5)
complex(*(3, 5))

Argumentos sã o atribuídos à s variá veis locais nomeadas no corpo da funçã o. Veja a seçã o calls para as regras
de atribuiçã o. Sintaticamente, qualquer expressã o pode ser usada para representar um argumento; avaliada a
expressã o, o valor é atribuído à variá vel local.
Veja també m o termo parâmetro no glossá rio, a pergunta no FAQ sobre a diferença entre argumentos e parâ -
metros e PEP 362.
gerenciador de contexto assíncrono
Um objeto que controla o ambiente visto numa instruçã o async with por meio da definiçã o dos mé todos
__aenter__() e __aexit__(). Introduzido pela PEP 492.

gerador assíncrono
Uma funçã o que retorna um iterador gerador assíncrono. É parecida com uma funçã o de corrotina definida
com async def exceto pelo fato de conter instruçõ es yield para produzir uma sé rie de valores que podem
ser usados em um laço async for.
Normalmente se refere a uma funçã o geradora assíncrona, mas pode se referir a um iterador gerador assín-
crono em alguns contextos. Em casos em que o significado nã o esteja claro, usar o termo completo evita a
ambiguidade.
Uma funçã o geradora assíncrona pode conter expressõ es await e també m as instruçõ es async for e async
with.

iterador gerador assíncrono

Um objeto criado por uma funçã o geradora assíncrona.
Este é um iterador assíncrono que, quando chamado usando o mé todo __anext__(), retorna um objeto
aguardá vel que executará o corpo da funçã o geradora assíncrona até a pró xima expressã o yield.
Cada yield suspende temporariamente o processamento, lembrando o estado de execuçã o (incluindo variá veis
locais e instruçõ es try pendentes). Quando o iterador gerador assíncrono é efetivamente retomado com outro
aguardá vel retornado por __anext__(), ele inicia de onde parou. Veja PEP 492 e PEP 525.
iterável assíncrono
Um objeto que pode ser usado em uma instruçã o async for. Deve retornar um iterador assíncrono do seu
mé todo __aiter__(). Introduzido por PEP 492.
iterador assíncrono
Um objeto que implementa os mé todos __aiter__() e __anext__(). __anext__() deve retornar um
objeto aguardável. async for resolve os aguardá veis retornados por um mé todo __anext__() do iterador
assíncrono até que ele levante uma exceçã o StopAsyncIteration. Introduzido pela PEP 492.
atributo
Um valor associado a um objeto que é geralmente referenciado pelo nome separado por um ponto. Por exemplo,
se um objeto o tem um atributo a esse seria referenciado como o.a.
É possível dar a um objeto um atributo cujo nome nã o seja um identificador conforme definido por identifiers,
por exemplo usando setattr(), se o objeto permitir. Tal atributo nã o será acessível usando uma expressã o
pontilhada e, em vez disso, precisaria ser recuperado com getattr().
aguardável
Um objeto que pode ser usado em uma expressã o await. Pode ser uma corrotina ou um objeto com um
mé todo __await__(). Veja també m a PEP 492.

68 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

BDFL
Abreviaçã o da expressã o da língua inglesa “Benevolent Dictator for Life” (em portuguê s, “Ditador Benevolente
Vitalício”), referindo-se a Guido van Rossum, criador do Python.
arquivo binário
Um objeto arquivo capaz de ler e gravar em objetos bytes ou similar. Exemplos de arquivos biná rios sã o arquivos
abertos no modo biná rio ('rb', 'wb' ou 'rb+'), sys.stdin.buffer, sys.stdout.buffer, e instâ ncias
de io.BytesIO e gzip.GzipFile.
Veja també m arquivo texto para um objeto arquivo capaz de ler e gravar em objetos str.
referência emprestada
Na API C do Python, uma referê ncia emprestada é uma referê ncia a um objeto que nã o é dona da referê ncia.
Ela se torna um ponteiro solto se o objeto for destruído. Por exemplo, uma coleta de lixo pode remover a
ú ltima referência forte para o objeto e assim destruí-lo.
Chamar Py_INCREF() na referência emprestada é recomendado para convertê -lo, internamente, em uma
referência forte, exceto quando o objeto nã o pode ser destruído antes do ú ltimo uso da referê ncia emprestada.
A funçã o Py_NewRef() pode ser usada para criar uma nova referência forte.
objeto byte ou similar
Um objeto com suporte ao o bufferobjects e que pode exportar um buffer C contíguo. Isso inclui todos os
objetos bytes, bytearray e array.array, alé m de muitos objetos memoryview comuns. Objetos byte
ou similar podem ser usados para vá rias operaçõ es que funcionam com dados biná rios; isso inclui compactaçã o,
salvamento em um arquivo biná rio e envio por um soquete.
Algumas operaçõ es precisam que os dados biná rios sejam mutá veis. A documentaçã o geralmente se refere
a eles como “objetos byte ou similar para leitura e escrita”. Exemplos de objetos de buffer mutá vel incluem
bytearray e um memoryview de um bytearray. Outras operaçõ es exigem que os dados biná rios sejam
armazenados em objetos imutá veis (“objetos byte ou similar para somente leitura”); exemplos disso incluem
bytes e a memoryview de um objeto bytes.

bytecode
O có digo-fonte Python é compilado para bytecode, a representaçã o interna de um programa em Python no
interpretador CPython. O bytecode també m é mantido em cache em arquivos .pyc e .pyo, de forma que
executar um mesmo arquivo é mais rá pido na segunda vez (a recompilaçã o dos fontes para bytecode nã o é
necessá ria). Esta “linguagem intermediá ria” é adequada para execuçã o em uma máquina virtual, que executa
o có digo de má quina correspondente para cada bytecode. Tenha em mente que nã o se espera que bytecodes
sejam executados entre má quinas virtuais Python diferentes, nem que se mantenham está veis entre versõ es de
Python.
Uma lista de instruçõ es bytecode pode ser encontrada na documentaçã o para o mó dulo dis.
chamável
Um chamá vel é um objeto que pode ser chamado, possivelmente com um conjunto de argumentos (veja ar-
gumento), com a seguinte sintaxe:

chamavel(argumento1, argumento2, argumentoN)

Uma função, e por extensã o um método, é um chamá vel. Uma instâ ncia de uma classe que implementa o
mé todo __call__() també m é um chamá vel.
função de retorno
També m conhecida como callback, é uma funçã o sub-rotina que é passada como um argumento a ser executado
em algum ponto no futuro.
classe
Um modelo para criaçã o de objetos definidos pelo usuá rio. Definiçõ es de classe normalmente conté m defini-
çõ es de mé todos que operam sobre instâ ncias da classe.
variável de classe
Uma variá vel definida em uma classe e destinada a ser modificada apenas no nível da classe (ou seja, nã o em
uma instâ ncia da classe).

69
Extending and Embedding Python, Release 3.13.2

variável de clausura
Uma variável livre referenciada de um escopo aninhado que é definida em um escopo externo em vez de ser
resolvida em tempo de execuçã o a partir dos espaços de nomes embutido ou globais. Pode ser explicitamente
definida com a palavra reservada nonlocal para permitir acesso de gravaçã o, ou implicitamente definida se
a variá vel estiver sendo somente lida.
Por exemplo, na funçã o interna no có digo a seguir, tanto x quanto print sã o variáveis livres, mas somente
x é uma variável de clausura:

def externa():
x = 0
def interna():
nonlocal x
x += 1
print(x)
return interna

Devido ao atributo codeobject.co_freevars (que, apesar do nome, inclui apenas os nomes das variá veis
de clausura em vez de listar todas as variá veis livres referenciadas), o termo mais geral variável livre à s vezes
é usado mesmo quando o significado pretendido é se referir especificamente à s variá veis de clausura.
número complexo
Uma extensã o ao familiar sistema de nú meros reais em que todos os nú meros sã o expressos como uma soma
de uma parte real e uma parte imaginá ria. Nú meros imaginá rios sã o mú ltiplos reais da unidade imaginá ria
(a raiz quadrada de -1), normalmente escrita como i em matemá tica ou j em engenharia. O Python tem
suporte nativo para nú meros complexos, que sã o escritos com esta ú ltima notaçã o; a parte imaginá ria escrita
com um sufixo j, p.ex., 3+1j. Para ter acesso aos equivalentes para nú meros complexos do mó dulo math,
utilize cmath. O uso de nú meros complexos é uma funcionalidade matemá tica bastante avançada. Se você
nã o sabe se irá precisar deles, é quase certo que você pode ignorá -los sem problemas.
contexto
Este termo tem diferentes significados dependendo de onde e como ele é usado. Alguns significados comuns:
• O estado ou ambiente temporá rio estabelecido por um gerenciador de contexto por meio de uma instruçã o
with.

• A coleçã o de ligaçõ es de chave-valor associadas a um objeto contextvars.Context específico e

acessadas por meio de objetos ContextVar. Veja també m variável de contexto.
• Um objeto contextvars.Context. Veja també m contexto atual.
protocolo de gerenciamento de contexto
Os mé todos __enter__() e __exit__() chamados pela instruçã o with. Veja PEP 343.
gerenciador de contexto
Um objeto que implementa o protocolo de gerenciamento de contexto e controla o ambiente visto em uma
instruçã o with. Veja PEP 343.
variável de contexto
Uma variá vel cujo valor depende de qual contexto é o contexto atual. Os valores sã o acessados por meio de
objetos contextvars.ContextVar. Variá veis de contexto sã o usadas principalmente para isolar o estado
entre tarefas assíncronas simultâ neas.
contíguo
Um buffer é considerado contíguo exatamente se for contíguo C ou contíguo Fortran. Os buffers de dimensã o
zero sã o contíguos C e Fortran. Em vetores unidimensionais, os itens devem ser dispostos na memó ria pró ximos
um do outro, em ordem crescente de índices, começando do zero. Em vetores multidimensionais contíguos C,
o ú ltimo índice varia mais rapidamente ao visitar itens em ordem de endereço de memó ria. No entanto, nos
vetores contíguos do Fortran, o primeiro índice varia mais rapidamente.
corrotina
Corrotinas sã o uma forma mais generalizada de sub-rotinas. Sub-rotinas tem a entrada iniciada em um ponto,
e a saída em outro ponto. Corrotinas podem entrar, sair, e continuar em muitos pontos diferentes. Elas podem
ser implementadas com a instruçã o async def. Veja també m PEP 492.

70 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

função de corrotina
Uma funçã o que retorna um objeto do tipo corrotina. Uma funçã o de corrotina pode ser definida com a instru-
çã o async def, e pode conter as palavras chaves await, async for, e async with. Isso foi introduzido
pela PEP 492.
CPython
A implementaçã o canô nica da linguagem de programaçã o Python, como disponibilizada pelo python.org.
O termo “CPython” é usado quando necessá rio distinguir esta implementaçã o de outras como Jython ou
IronPython.
contexto atual
O contexto (objeto contextvars.Context) que é usado atualmente pelos objetos ContextVar para acessar
(obter ou definir) os valores de variáveis de contexto. Cada thread tem seu pró prio contexto atual. Frameworks
para executar tarefas assíncronas (veja asyncio) associam cada tarefa a um contexto que se torna o contexto
atual sempre que a tarefa inicia ou retoma a execuçã o.
decorador
Uma funçã o que retorna outra funçã o, geralmente aplicada como uma transformaçã o de funçã o usando a
sintaxe @wrapper. Exemplos comuns para decoradores sã o classmethod() e staticmethod().
A sintaxe do decorador é meramente um açú car sintá tico, as duas definiçõ es de funçõ es a seguir sã o semanti-
camente equivalentes:

def f(arg):
...
f = staticmethod(f)

@staticmethod
def f(arg):
...

O mesmo conceito existe para as classes, mas nã o é comumente utilizado. Veja a documentaçã o de definiçõ es
de funçã o e definiçõ es de classe para obter mais informaçõ es sobre decoradores.
descritor
Qualquer objeto que define os mé todos __get__(), __set__() ou __delete__(). Quando um atributo
de classe é um descritor, seu comportamento de associaçã o especial é acionado no acesso a um atributo.
Normalmente, ao se utilizar a.b para se obter, definir ou excluir, um atributo dispara uma busca no objeto
chamado b no dicioná rio de classe de a, mas se b for um descritor, o respectivo mé todo descritor é chamado.
Compreender descritores é a chave para um profundo entendimento de Python pois eles sã o a base de muitas
funcionalidades incluindo funçõ es, mé todos, propriedades, mé todos de classe, mé todos está ticos e referê ncias
para superclasses.
Para obter mais informaçõ es sobre os mé todos dos descritores, veja: descriptors ou o Guia de Descritores.
dicionário
Um vetor associativo em que chaves arbitrá rias sã o mapeadas para valores. As chaves podem ser quaisquer
objetos que possuam os mé todos __hash__() e __eq__(). Isso é chamado de hash em Perl.
compreensão de dicionário
Uma maneira compacta de processar todos ou parte dos elementos de um iterá vel e retornar um dicioná rio com
os resultados. results = {n: n ** 2 for n in range(10)} gera um dicioná rio contendo a chave n
mapeada para o valor n ** 2. Veja comprehensions.
visão de dicionário
Os objetos retornados por dict.keys(), dict.values() e dict.items() sã o chamados de visõ es de
dicioná rio. Eles fornecem uma visã o dinâ mica das entradas do dicioná rio, o que significa que quando o di-
cioná rio é alterado, a visã o reflete essas alteraçõ es. Para forçar a visã o de dicioná rio a se tornar uma lista
completa use list(dictview). Veja dict-views.
docstring
Abreviatura de “documentation string” (string de documentaçã o). Uma string literal que aparece como pri-
meira expressã o numa classe, funçã o ou mó dulo. Ainda que sejam ignoradas quando a suíte é executada, é

71
Extending and Embedding Python, Release 3.13.2

reconhecida pelo compilador que a coloca no atributo __doc__ da classe, funçã o ou mó dulo que a encapsula.
Como ficam disponíveis por meio de introspecçã o, docstrings sã o o lugar canô nico para documentaçã o do
objeto.
tipagem pato
També m conhecida como duck-typing, é um estilo de programaçã o que nã o verifica o tipo do objeto para
determinar se ele possui a interface correta; em vez disso, o mé todo ou atributo é simplesmente chamado
ou utilizado (“Se se parece com um pato e grasna como um pato, entã o deve ser um pato.”) Enfatizando
interfaces ao invé s de tipos específicos, o có digo bem desenvolvido aprimora sua flexibilidade por permitir
substituiçã o polimó rfica. Tipagem pato evita necessidade de testes que usem type() ou isinstance().
(Note, poré m, que a tipagem pato pode ser complementada com o uso de classes base abstratas.) Ao invé s
disso, sã o normalmente empregados testes hasattr() ou programaçã o EAFP.
EAFP
Iniciais da expressã o em inglê s “easier to ask for forgiveness than permission” que significa “é mais fá cil pedir
perdã o que permissã o”. Este estilo de codificaçã o comum no Python presume a existê ncia de chaves ou atribu-
tos vá lidos e captura exceçõ es caso essa premissa se prove falsa. Este estilo limpo e rá pido se caracteriza pela
presença de vá rias instruçõ es try e except. A té cnica diverge do estilo LBYL, comum em outras linguagens
como C, por exemplo.
expressão
Uma parte da sintaxe que pode ser avaliada para algum valor. Em outras palavras, uma expressã o é a acumula-
çã o de elementos de expressã o como literais, nomes, atributos de acesso, operadores ou chamadas de funçõ es,
todos os quais retornam um valor. Em contraste com muitas outras linguagens, nem todas as construçõ es
de linguagem sã o expressõ es. També m existem instruções, as quais nã o podem ser usadas como expressõ es,
como, por exemplo, while. Atribuiçõ es també m sã o instruçõ es, nã o expressõ es.
módulo de extensão
Um mó dulo escrito em C ou C++, usando a API C do Python para interagir tanto com có digo de usuá rio
quanto do nú cleo.
f-string
Literais string prefixadas com 'f' ou 'F' sã o conhecidas como “f-strings” que é uma abreviaçã o de formatted
string literals. Veja també m PEP 498.
objeto arquivo
Um objeto que expõ e uma API orientada a arquivos (com mé todos tais como read() ou write()) para
um recurso subjacente. Dependendo da maneira como foi criado, um objeto arquivo pode mediar o acesso a
um arquivo real no disco ou outro tipo de dispositivo de armazenamento ou de comunicaçã o (por exemplo a
entrada/saída padrã o, buffers em memó ria, soquetes, pipes, etc.). Objetos arquivo també m sã o chamados de
objetos arquivo ou similares ou fluxos.
Atualmente há trê s categorias de objetos arquivo: arquivos binários brutos, arquivos binários em buffer e
arquivos textos. Suas interfaces estã o definidas no mó dulo io. A forma canô nica para criar um objeto arquivo
é usando a funçã o open().
objeto arquivo ou similar
Um sinô nimo do termo objeto arquivo.
tratador de erros e codificação do sistema de arquivos
Tratador de erros e codificaçã o usado pelo Python para decodificar bytes do sistema operacional e codificar
Unicode para o sistema operacional.
A codificaçã o do sistema de arquivos deve garantir a decodificaçã o bem-sucedida de todos os bytes abaixo
de 128. Se a codificaçã o do sistema de arquivos falhar em fornecer essa garantia, as funçõ es da API podem
levantar UnicodeError.
As funçõ es sys.getfilesystemencoding() e sys.getfilesystemencodeerrors() podem ser usa-
das para obter o tratador de erros e codificaçã o do sistema de arquivos.
O tratador de erros e codificação do sistema de arquivos sã o configurados na inicializaçã o do Python pela funçã o
PyConfig_Read(): veja os membros filesystem_encoding e filesystem_errors do PyConfig.

Veja també m codificação da localidade.

72 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

localizador
Um objeto que tenta encontrar o carregador para um mó dulo que está sendo importado.
Existem dois tipos de localizador: localizadores de metacaminho para uso com sys.meta_path, e localiza-
dores de entrada de caminho para uso com sys.path_hooks.
Veja finders-and-loaders e importlib para muito mais detalhes.
divisão pelo piso
Divisã o matemá tica que arredonda para baixo para o inteiro mais pró ximo. O operador de divisã o pelo piso é
//. Por exemplo, a expressã o 11 // 4 retorna o valor 2 ao invé s de 2.75, que seria retornado pela divisã o
de ponto flutuante. Note que (-11) // 4 é -3 porque é -2.75 arredondado para baixo. Consulte a PEP
238.
threads livres
Um modelo de threads onde mú ltiplas threads podem simultaneamente executar bytecode Python no mesmo
interpretador. Isso está em contraste com a trava global do interpretador que permite apenas uma thread por
vez executar bytecode Python. Veja PEP 703.
variável livre
Formalmente, conforme definido no modelo de execuçã o de linguagem, uma variá vel livre é qualquer variá vel
usada em um espaço de nomes que nã o seja uma variá vel local naquele espaço de nomes. Veja variável de
clausura para um exemplo. Pragmaticamente, devido ao nome do atributo codeobject.co_freevars, o
termo també m é usado algumas vezes como sinô nimo de variável de clausura.
função
Uma sé rie de instruçõ es que retorna algum valor para um chamador. També m pode ser passado zero ou mais
argumentos que podem ser usados na execuçã o do corpo. Veja també m parâmetro, método e a seçã o function.
anotação de função
Uma anotação de um parâ metro de funçã o ou valor de retorno.
Anotaçõ es de funçã o sã o comumente usados por dicas de tipo: por exemplo, essa funçã o espera receber dois
argumentos int e també m é esperado que devolva um valor int:

def soma_dois_numeros(a: int, b: int) -> int:

return a + b

A sintaxe de anotaçã o de funçã o é explicada na seçã o function.

Veja anotação de variável e PEP 484, que descrevem esta funcionalidade. Veja també m annotations-howto
para as melhores prá ticas sobre como trabalhar com anotaçõ es.
__future__
A instruçã o future, from __future__ import <feature>, direciona o compilador a compilar o mó dulo
atual usando sintaxe ou semâ ntica que será padrã o em uma versã o futura de Python. O mó dulo __future__
documenta os possíveis valores de feature. Importando esse mó dulo e avaliando suas variá veis, você pode ver
quando um novo recurso foi inicialmente adicionado à linguagem e quando será (ou se já é ) o padrã o:

>>> import __future__

>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

coleta de lixo
També m conhecido como garbage collection, é o processo de liberar a memó ria quando ela nã o é mais utilizada.
Python executa a liberaçã o da memó ria atravé s da contagem de referê ncias e um coletor de lixo cíclico que é
capaz de detectar e interromper referê ncias cíclicas. O coletor de lixo pode ser controlado usando o mó dulo
gc.

gerador
Uma funçã o que retorna um iterador gerador. É parecida com uma funçã o normal, exceto pelo fato de conter
expressõ es yield para produzir uma sé rie de valores que podem ser usados em um laço “for” ou que podem
ser obtidos um de cada vez com a funçã o next().

73
Extending and Embedding Python, Release 3.13.2

Normalmente refere-se a uma funçã o geradora, mas pode referir-se a um iterador gerador em alguns contextos.
Em alguns casos onde o significado desejado nã o está claro, usar o termo completo evita ambiguidade.
iterador gerador
Um objeto criado por uma funçã o geradora.
Cada yield suspende temporariamente o processamento, memorizando o estado da execuçã o (incluindo va-
riá veis locais e instruçõ es try pendentes). Quando o iterador gerador retorna, ele se recupera do ú ltimo ponto
onde estava (em contrapartida as funçõ es que iniciam uma nova execuçã o a cada vez que sã o invocadas).
expressão geradora
Uma expressão que retorna um iterador. Parece uma expressã o normal, seguido de uma clá usula for definindo
uma variá vel de laço, um intervalo, e uma clá usula if opcional. A expressã o combinada gera valores para uma
funçã o encapsuladora:

>>> sum(i*i for i in range(10)) # soma dos quadrados 0, 1, 4, ... 81

285

função genérica
Uma funçã o composta por vá rias funçõ es implementando a mesma operaçã o para diferentes tipos. Qual im-
plementaçã o deverá ser usada durante a execuçã o é determinada pelo algoritmo de despacho.
Veja també m a entrada despacho único no glossá rio, o decorador functools.singledispatch(), e a PEP
443.
tipo genérico
Um tipo que pode ser parametrizado; tipicamente uma classe contê iner tal como list ou dict. Usado para
dicas de tipo e anotações.
Para mais detalhes, veja tipo apelido gené rico, PEP 483, PEP 484, PEP 585, e o mó dulo typing.
GIL
Veja trava global do interpretador.
trava global do interpretador
O mecanismo utilizado pelo interpretador CPython para garantir que apenas uma thread execute o bytecode
Python por vez. Isto simplifica a implementaçã o do CPython ao fazer com que o modelo de objetos (incluindo
tipos embutidos críticos como o dict) ganhem segurança implícita contra acesso concorrente. Travar todo o
interpretador facilita que o interpretador em si seja multitarefa, à s custas de muito do paralelismo já provido
por má quinas multiprocessador.
No entanto, alguns mó dulos de extensã o, tanto da biblioteca padrã o quanto de terceiros, sã o desenvolvidos de
forma a liberar a GIL ao realizar tarefas computacionalmente muito intensas, como compactaçã o ou cá lculos
de hash. Alé m disso, a GIL é sempre liberado nas operaçõ es de E/S.
A partir de Python 3.13, o GIL pode ser desabilitado usando a configuraçã o de construçã o --disable-gil.
Depois de construir Python com essa opçã o, o có digo deve ser executado com a opçã o -X gil=0 ou a variá vel
de ambiente PYTHON_GIL=0 deve estar definida. Esse recurso provê um desempenho melhor para aplicaçõ es
com mú ltiplas threads e torna mais fá cil o uso eficiente de CPUs com mú ltiplos nú cleos. Para mais detalhes,
veja PEP 703.
pyc baseado em hash
Um arquivo de cache em bytecode que usa hash ao invé s do tempo, no qual o arquivo de có digo-fonte foi
modificado pela ú ltima vez, para determinar a sua validade. Veja pyc-invalidation.
hasheável
Um objeto é hasheável se tem um valor de hash que nunca muda durante seu ciclo de vida (precisa ter um
mé todo __hash__()) e pode ser comparado com outros objetos (precisa ter um mé todo __eq__()). Objetos
hasheá veis que sã o comparados como iguais devem ter o mesmo valor de hash.
A hasheabilidade faz com que um objeto possa ser usado como uma chave de dicioná rio e como um membro
de conjunto, pois estas estruturas de dados utilizam os valores de hash internamente.
A maioria dos objetos embutidos imutá veis do Python sã o hasheá veis; containers mutá veis (tais como listas
ou dicioná rios) nã o sã o; containers imutá veis (tais como tuplas e frozensets) sã o hasheá veis apenas se os seus

74 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

elementos sã o hasheá veis. Objetos que sã o instâ ncias de classes definidas pelo usuá rio sã o hasheá veis por
padrã o. Todos eles comparam de forma desigual (exceto entre si mesmos), e o seu valor hash é derivado a
partir do seu id().
IDLE
Um ambiente de desenvolvimento e aprendizado integrado para Python. idle é um editor bá sico e um ambiente
interpretador que vem junto com a distribuiçã o padrã o do Python.
imortal
Objetos imortais sã o um detalhe da implementaçã o do CPython introduzida na PEP 683.
Se um objeto é imortal, sua contagem de referências nunca é modificada e, portanto, nunca é desalocado en-
quanto o interpretador está em execuçã o. Por exemplo, True e None sã o imortais no CPython.
imutável
Um objeto que possui um valor fixo. Objetos imutá veis incluem nú meros, strings e tuplas. Estes objetos nã o
podem ser alterados. Um novo objeto deve ser criado se um valor diferente tiver de ser armazenado. Objetos
imutá veis tê m um papel importante em lugares onde um valor constante de hash seja necessá rio, como por
exemplo uma chave em um dicioná rio.
caminho de importação
Uma lista de localizaçõ es (ou entradas de caminho) que sã o buscadas pelo localizador baseado no caminho por
mó dulos para importar. Durante a importaçã o, esta lista de localizaçõ es usualmente vem a partir de sys.path,
mas para subpacotes ela també m pode vir do atributo __path__ de pacotes-pai.
importação
O processo pelo qual o có digo Python em um mó dulo é disponibilizado para o có digo Python em outro mó dulo.
importador
Um objeto que localiza e carrega um mó dulo; Tanto um localizador e o objeto carregador.
interativo
Python tem um interpretador interativo, o que significa que você pode digitar instruçõ es e expressõ es no prompt
do interpretador, executá -los imediatamente e ver seus resultados. Apenas execute python sem argumentos
(possivelmente selecionando-o a partir do menu de aplicaçõ es de seu sistema operacional). O interpretador
interativo é uma maneira poderosa de testar novas ideias ou aprender mais sobre mó dulos e pacotes (lembre-se
do comando help(x)). Para saber mais sobre modo interativo, veja tut-interac.
interpretado
Python é uma linguagem interpretada, em oposiçã o à quelas que sã o compiladas, embora esta distinçã o possa
ser nebulosa devido à presença do compilador de bytecode. Isto significa que os arquivos-fontes podem ser
executados diretamente sem necessidade explícita de se criar um arquivo executá vel. Linguagens interpretadas
normalmente tê m um ciclo de desenvolvimento/depuraçã o mais curto que as linguagens compiladas, apesar
de seus programas geralmente serem executados mais lentamente. Veja també m interativo.
desligamento do interpretador
Quando solicitado para desligar, o interpretador Python entra em uma fase especial, onde ele gradualmente
libera todos os recursos alocados, tais como mó dulos e vá rias estruturas internas críticas. Ele també m faz
diversas chamadas para o coletor de lixo. Isto pode disparar a execuçã o de có digo em destrutores definidos
pelo usuá rio ou funçã o de retorno de referê ncia fraca. Có digo executado durante a fase de desligamento pode
encontrar diversas exceçõ es, pois os recursos que ele depende podem nã o funcionar mais (exemplos comuns
sã o os mó dulos de bibliotecas, ou os mecanismos de avisos).
A principal razã o para o interpretador desligar, é que o mó dulo __main__ ou o script sendo executado ter-
minou sua execuçã o.
iterável
Um objeto capaz de retornar seus membros um de cada vez. Exemplos de iterá veis incluem todos os tipos de
sequê ncia (tais como list, str e tuple) e alguns tipos de nã o-sequê ncia, como o dict, objetos arquivos,
alé m dos objetos de quaisquer classes que você definir com um mé todo __iter__() ou __getitem__()
que implementam a semâ ntica de sequência .
Iterá veis podem ser usados em um laço for e em vá rios outros lugares em que uma sequê ncia é necessá ria
(zip(), map(), …). Quando um objeto iterá vel é passado como argumento para a funçã o embutida iter(),
ela retorna um iterador para o objeto. Este iterador é adequado para se varrer todo o conjunto de valores. Ao

75
Extending and Embedding Python, Release 3.13.2

usar iterá veis, normalmente nã o é necessá rio chamar iter() ou lidar com os objetos iteradores em si. A
instruçã o for faz isso automaticamente para você , criando uma variá vel temporá ria para armazenar o iterador
durante a execuçã o do laço. Veja també m iterador, sequência, e gerador.
iterador
Um objeto que representa um fluxo de dados. Repetidas chamadas ao mé todo __next__() de um iterador
(ou passando o objeto para a funçã o embutida next()) vã o retornar itens sucessivos do fluxo. Quando nã o
houver mais dados disponíveis uma exceçã o StopIteration será levantada. Neste ponto, o objeto iterador
se esgotou e quaisquer chamadas subsequentes a seu mé todo __next__() vã o apenas levantar a exceçã o
StopIteration novamente. Iteradores precisam ter um mé todo __iter__() que retorne o objeto iterador
em si, de forma que todo iterador també m é iterá vel e pode ser usado na maioria dos lugares em que um iterá vel
é requerido. Uma notá vel exceçã o é có digo que tenta realizar passagens em mú ltiplas iteraçõ es. Um objeto
contê iner (como uma list) produz um novo iterador a cada vez que você passá -lo para a funçã o iter() ou
utilizá -lo em um laço for. Tentar isso com o mesmo iterador apenas iria retornar o mesmo objeto iterador
esgotado já utilizado na iteraçã o anterior, como se fosse um contê iner vazio.
Mais informaçõ es podem ser encontradas em typeiter.
O CPython nã o aplica consistentemente o requisito de que um iterador defina __iter__(). E també m observe
que o CPython com threads livres nã o garante a segurança do thread das operaçõ es do iterador.
função chave
Uma funçã o chave ou funçã o colaçã o é um chamá vel que retorna um valor usado para ordenaçã o ou classifi-
caçã o. Por exemplo, locale.strxfrm() é usada para produzir uma chave de ordenaçã o que leva o locale
em consideraçã o para fins de ordenaçã o.
Uma porçã o de ferramentas no Python aceitam funçõ es chave para controlar como os elementos sã o orde-
nados ou agrupados. Algumas delas incluem min(), max(), sorted(), list.sort(), heapq.merge(),
heapq.nsmallest(), heapq.nlargest() e itertools.groupby().

Há vá rias maneiras de se criar funçõ es chave. Por exemplo, o mé todo str.lower() pode servir como uma
funçã o chave para ordenaçõ es insensíveis à caixa. Alternativamente, uma funçã o chave ad-hoc pode ser cons-
truída a partir de uma expressã o lambda, como lambda r: (r[0], r[2]). Alé m disso, operator.
attrgetter(), operator.itemgetter() e operator.methodcaller() sã o trê s construtores de fun-
çã o chave. Consulte o guia de Ordenaçã o para ver exemplos de como criar e utilizar funçõ es chave.
argumento nomeado
Veja argumento.
lambda
Uma funçã o de linha anô nima consistindo de uma ú nica expressão, que é avaliada quando a funçã o é chamada.
A sintaxe para criar uma funçã o lambda é lambda [parameters]: expression
LBYL
Iniciais da expressã o em inglê s “look before you leap”, que significa algo como “olhe antes de pisar”. Este estilo
de codificaçã o testa as pré -condiçõ es explicitamente antes de fazer chamadas ou buscas. Este estilo contrasta
com a abordagem EAFP e é caracterizada pela presença de muitas instruçõ es if.
Em um ambiente multithread, a abordagem LBYL pode arriscar a introduçã o de uma condiçã o de corrida
entre “o olhar” e “o pisar”. Por exemplo, o có digo if key in mapping: return mapping[key] pode
falhar se outra thread remover key do mapping apó s o teste, mas antes da olhada. Esse problema pode ser
resolvido com travas ou usando a abordagem EAFP.
lista
Uma sequência embutida no Python. Apesar do seu nome, é mais pró ximo de um vetor em outras linguagens
do que uma lista encadeada, como o acesso aos elementos é da ordem O(1).
compreensão de lista
Uma maneira compacta de processar todos ou parte dos elementos de uma sequê ncia e retornar os resultados
em uma lista. result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0] gera
uma lista de strings contendo nú meros hexadecimais (0x..) no intervalo de 0 a 255. A clá usula if é opcional.
Se omitida, todos os elementos no range(256) serã o processados.
carregador
Um objeto que carrega um mó dulo. Ele deve definir os mé todos exec_module() e create_module() para

76 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

implementar a interface Loader. Um carregador é normalmente retornado por um localizador. Veja també m:
• finders-and-loaders
• importlib.abc.Loader
• PEP 302
codificação da localidade
No Unix, é a codificaçã o da localidade do LC_CTYPE, que pode ser definida com locale.
setlocale(locale.LC_CTYPE, new_locale).

No Windows, é a pá gina de có digo ANSI (ex: "cp1252").

No Android e no VxWorks, o Python usa "utf-8" como a codificaçã o da localidade.
locale.getencoding() pode ser usado para obter a codificaçã o da localidade.

Veja també m tratador de erros e codificação do sistema de arquivos.

método mágico
Um sinô nimo informal para um método especial.
mapeamento
Um objeto contê iner que tem suporte a pesquisas de chave arbitrá ria e implementa os mé todos especificados nas
collections.abc.Mapping ou collections.abc.MutableMapping classes base abstratas. Exemplos
incluem dict, collections.defaultdict, collections.OrderedDict e collections.Counter.
localizador de metacaminho
Um localizador retornado por uma busca de sys.meta_path. Localizadores de metacaminho sã o relaciona-
dos a, mas diferentes de, localizadores de entrada de caminho.
Veja importlib.abc.MetaPathFinder para os mé todos que localizadores de metacaminho implementam.
metaclasse
A classe de uma classe. Definiçõ es de classe criam um nome de classe, um dicioná rio de classe e uma lista
de classes base. A metaclasse é responsá vel por receber estes trê s argumentos e criar a classe. A maioria das
linguagens de programaçã o orientadas a objetos provê uma implementaçã o default. O que torna o Python
especial é o fato de ser possível criar metaclasses personalizadas. A maioria dos usuá rios nunca vai preci-
sar deste recurso, mas quando houver necessidade, metaclasses possibilitam soluçõ es poderosas e elegantes.
Metaclasses tê m sido utilizadas para gerar registros de acesso a atributos, para incluir proteçã o contra acesso
concorrente, rastrear a criaçã o de objetos, implementar singletons, dentre muitas outras tarefas.
Mais informaçõ es podem ser encontradas em metaclasses.
método
Uma funçã o que é definida dentro do corpo de uma classe. Se chamada como um atributo de uma instâ ncia
daquela classe, o mé todo receberá a instâ ncia do objeto como seu primeiro argumento (que comumente é
chamado de self). Veja função e escopo aninhado.
ordem de resolução de métodos
Ordem de resoluçã o de mé todos é a ordem em que os membros de uma classe base sã o buscados durante a
pesquisa. Veja python_2.3_mro para detalhes do algoritmo usado pelo interpretador do Python desde a versã o
2.3.
módulo
Um objeto que serve como uma unidade organizacional de có digo Python. Os mó dulos tê m um espaço de
nomes contendo objetos Python arbitrá rios. Os mó dulos sã o carregados pelo Python atravé s do processo de
importação.
Veja també m pacote.
spec de módulo
Um espaço de nomes que conté m as informaçõ es relacionadas à importaçã o usadas para carregar um mó dulo.
Uma instâ ncia de importlib.machinery.ModuleSpec.
Veja també m module-specs.

77
Extending and Embedding Python, Release 3.13.2

MRO
Veja ordem de resolução de métodos.
mutável
Objeto mutá vel é aquele que pode modificar seus valor mas manter seu id(). Veja també m imutável.
tupla nomeada
O termo “tupla nomeada” é aplicado a qualquer tipo ou classe que herda de tupla e cujos elementos indexá veis
també m sã o acessíveis usando atributos nomeados. O tipo ou classe pode ter outras funcionalidades també m.
Diversos tipos embutidos sã o tuplas nomeadas, incluindo os valores retornados por time.localtime() e
os.stat(). Outro exemplo é sys.float_info:

>>> sys.float_info[1] # acesso indexado

1024
>>> sys.float_info.max_exp # acesso a campo nomeado
1024
>>> isinstance(sys.float_info, tuple) # tipo de tupla
True

Algumas tuplas nomeadas sã o tipos embutidos (tal como os exemplos acima). Alternativamente, uma tupla
nomeada pode ser criada a partir de uma definiçã o de classe regular, que herde de tuple e que defina campos
nomeados. Tal classe pode ser escrita a mã o, ou ela pode ser criada herdando typing.NamedTuple ou com
uma funçã o fá brica collections.namedtuple(). As duas ú ltimas té cnicas també m adicionam alguns
mé todos extras, que podem nã o ser encontrados quando foi escrita manualmente, ou em tuplas nomeadas
embutidas.
espaço de nomes
O lugar em que uma variá vel é armazenada. Espaços de nomes sã o implementados como dicioná rios. Exis-
tem os espaços de nomes local, global e nativo, bem como espaços de nomes aninhados em objetos (em
mé todos). Espaços de nomes suportam modularidade ao prevenir conflitos de nomes. Por exemplo, as fun-
çõ es __builtin__.open() e os.open() sã o diferenciadas por seus espaços de nomes. Espaços de nomes
també m auxiliam na legibilidade e na manutenibilidade ao torar mais claro quais mó dulos implementam uma
funçã o. Escrever random.seed() ou itertools.izip(), por exemplo, deixa claro que estas funçõ es sã o
implementadas pelos mó dulos random e itertools respectivamente.
pacote de espaço de nomes
Um pacote da PEP 420 que serve apenas como container para sub pacotes. Pacotes de espaços de nomes
podem nã o ter representaçã o física, e especificamente nã o sã o como um pacote regular porque eles nã o tem
um arquivo __init__.py.
Veja també m módulo.
escopo aninhado
A habilidade de referir-se a uma variá vel em uma definiçã o de fechamento. Por exemplo, uma funçã o definida
dentro de outra pode referenciar variá veis da funçã o externa. Perceba que escopos aninhados por padrã o
funcionam apenas por referê ncia e nã o por atribuiçã o. Variá veis locais podem ler e escrever no escopo mais
interno. De forma similar, variá veis globais podem ler e escrever para o espaço de nomes global. O nonlocal
permite escrita para escopos externos.
classe estilo novo
Antigo nome para o tipo de classes agora usado para todos os objetos de classes. Em versõ es anteriores
do Python, apenas classes estilo podiam usar recursos novos e versá teis do Python, tais como __slots__,
descritores, propriedades, __getattribute__(), mé todos de classe, e mé todos está ticos.
objeto
Qualquer dado que tenha estado (atributos ou valores) e comportamento definidos (mé todos). També m a
ú ltima classe base de qualquer classe estilo novo.
escopo otimizado
Um escopo no qual os nomes das variá veis locais de destino sã o conhecidos de forma confiá vel pelo compi-
lador quando o có digo é compilado, permitindo a otimizaçã o do acesso de leitura e gravaçã o a esses nomes.
Os espaços de nomes locais para funçõ es, geradores, corrotinas, compreensõ es e expressõ es geradoras sã o

78 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

otimizados desta forma. Nota: a maioria das otimizaçõ es de interpretador sã o aplicadas a todos os escopos,
apenas aquelas que dependem de um conjunto conhecido de nomes de variá veis locais e nã o locais sã o restritas
a escopos otimizados.
pacote
Um módulo Python é capaz de conter submó dulos ou recursivamente, subpacotes. Tecnicamente, um pacote
é um mó dulo Python com um atributo __path__.
Veja també m pacote regular e pacote de espaço de nomes.
parâmetro
Uma entidade nomeada na definiçã o de uma função (ou mé todo) que específica um argumento (ou em alguns
casos, argumentos) que a funçã o pode receber. Existem cinco tipos de parâ metros:
• posicional-ou-nomeado: especifica um argumento que pode ser tanto posicional quanto nomeado. Esse
é o tipo padrã o de parâ metro, por exemplo foo e bar a seguir:

def func(foo, bar=None): ...

• somente-posicional: especifica um argumento que pode ser fornecido apenas por posiçã o. Parâ metros
somente-posicionais podem ser definidos incluindo o caractere / na lista de parâ metros da definiçã o da
funçã o apó s eles, por exemplo somentepos1 e somentepos2 a seguir:

def func(somentepos1, somentepos2, /, posicional_ou_nomeado): ...

• somente-nomeado: especifica um argumento que pode ser passado para a funçã o somente por nome.
Parâ metros somente-nomeados podem ser definidos com um simples parâ metro var-posicional ou um *
antes deles na lista de parâ metros na definiçã o da funçã o, por exemplo somente_nom1 and somente_nom2
a seguir:

def func(arg, *, somente_nom1, somente_nom2): ...

• var-posicional: especifica que uma sequê ncia arbitrá ria de argumentos posicionais pode ser fornecida
(em adiçã o a qualquer argumento posicional já aceito por outros parâ metros). Tal parâ metro pode ser
definido colocando um * antes do nome do parâ metro, por exemplo args a seguir:

def func(*args, **kwargs): ...

• var-nomeado: especifica que, arbitrariamente, muitos argumentos nomeados podem ser fornecidos (em
adiçã o a qualquer argumento nomeado já aceito por outros parâ metros). Tal parâ metro pode definido
colocando-se ** antes do nome, por exemplo kwargs no exemplo acima.
Parâ metros podem especificar tanto argumentos opcionais quanto obrigató rios, assim como valores padrã o
para alguns argumentos opcionais.
Veja també m o termo argumento no glossá rio, a pergunta do FAQ sobre a diferença entre argumentos e parâ -
metros, a classe inspect.Parameter, a seçã o function e a PEP 362.
entrada de caminho
Um local ú nico no caminho de importação que o localizador baseado no caminho consulta para encontrar
mó dulos a serem importados.
localizador de entrada de caminho
Um localizador retornado por um chamá vel em sys.path_hooks (ou seja, um gancho de entrada de caminho)
que sabe como localizar os mó dulos entrada de caminho.
Veja importlib.abc.PathEntryFinder para os mé todos que localizadores de entrada de caminho im-
plementam.
gancho de entrada de caminho
Um chamá vel na lista sys.path_hooks que retorna um localizador de entrada de caminho caso saiba como
localizar mó dulos em uma entrada de caminho específica.
localizador baseado no caminho
Um dos localizadores de metacaminho padrã o que procura por um caminho de importação de mó dulos.

79
Extending and Embedding Python, Release 3.13.2

objeto caminho ou similar

Um objeto representando um caminho de sistema de arquivos. Um objeto caminho ou similar é ou um objeto
str ou bytes representando um caminho, ou um objeto implementando o protocolo os.PathLike. Um
objeto que suporta o protocolo os.PathLike pode ser convertido para um arquivo de caminho do sistema
str ou bytes, atravé s da chamada da funçã o os.fspath(); os.fsdecode() e os.fsencode() podem
ser usadas para garantir um str ou bytes como resultado, respectivamente. Introduzido na PEP 519.
PEP
Proposta de melhoria do Python. Uma PEP é um documento de design que fornece informaçã o para a co-
munidade Python, ou descreve uma nova funcionalidade para o Python ou seus predecessores ou ambientes.
PEPs devem prover uma especificaçã o té cnica concisa e um racional para funcionalidades propostas.
PEPs tê m a intençã o de ser os mecanismos primá rios para propor novas funcionalidades significativas, para
coletar opiniõ es da comunidade sobre um problema, e para documentar as decisõ es de design que foram
adicionadas ao Python. O autor da PEP é responsá vel por construir um consenso dentro da comunidade e
documentar opiniõ es dissidentes.
Veja PEP 1.
porção
Um conjunto de arquivos em um ú nico diretó rio (possivelmente armazenado em um arquivo zip) que contri-
buem para um pacote de espaço de nomes, conforme definido em PEP 420.
argumento posicional
Veja argumento.
API provisória
Uma API provisó ria é uma API que foi deliberadamente excluída das bibliotecas padrõ es com compatibilidade
retroativa garantida. Enquanto mudanças maiores para tais interfaces nã o sã o esperadas, contanto que elas
sejam marcadas como provisó rias, mudanças retroativas incompatíveis (até e incluindo a remoçã o da interface)
podem ocorrer se consideradas necessá rias pelos desenvolvedores principais. Tais mudanças nã o serã o feitas
gratuitamente – elas irã o ocorrer apenas se sé rias falhas fundamentais forem descobertas, que foram esquecidas
anteriormente a inclusã o da API.
Mesmo para APIs provisó rias, mudanças retroativas incompatíveis sã o vistas como uma “soluçã o em ú ltimo
caso” - cada tentativa ainda será feita para encontrar uma resoluçã o retroativa compatível para quaisquer pro-
blemas encontrados.
Esse processo permite que a biblioteca padrã o continue a evoluir com o passar do tempo, sem se prender em
erros de design problemá ticos por períodos de tempo prolongados. Veja PEP 411 para mais detalhes.
pacote provisório
Veja API provisória.
Python 3000
Apelido para a linha de lançamento da versã o do Python 3.x (cunhada há muito tempo, quando o lançamento
da versã o 3 era algo em um futuro muito distante.) Esse termo possui a seguinte abreviaçã o: “Py3k”.
Pythônico
Uma ideia ou um pedaço de có digo que segue de perto as formas de escritas mais comuns da linguagem
Python, ao invé s de implementar có digos usando conceitos comuns a outras linguagens. Por exemplo, um
formato comum em Python é fazer um laço sobre todos os elementos de uma iterá vel usando a instruçã o for.
Muitas outras linguagens nã o tê m esse tipo de construçã o, entã o as pessoas que nã o estã o familiarizadas com
o Python usam um contador numé rico:

for i in range(len(comida)):
print(comida[i])

Ao contrá rio do mé todo mais limpo, Pythô nico:

for parte in comida:

print(parte)

80 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

nome qualificado
Um nome pontilhado (quando 2 termos sã o ligados por um ponto) que mostra o “path” do escopo global de um
mó dulo para uma classe, funçã o ou mé todo definido num determinado mó dulo, conforme definido pela PEP
3155. Para funçõ es e classes de nível superior, o nome qualificado é o mesmo que o nome do objeto:

>>> class C:
... class D:
... def metodo(self):
... pass
...
>>> C.__qualname__
'C'
>>> C.D.__qualname__
'C.D'
>>> C.D.metodo.__qualname__
'C.D.metodo'

Quando usado para se referir a mó dulos, o nome totalmente qualificado significa todo o caminho pontilhado
para o mó dulo, incluindo quaisquer pacotes pai, por exemplo: email.mime.text:

>>> import email.mime.text

>>> email.mime.text.__name__
'email.mime.text'

contagem de referências
O nú mero de referê ncias a um objeto. Quando a contagem de referê ncias de um objeto cai para zero, ele é
desalocado. Alguns objetos sã o imortais e tê m contagens de referê ncias que nunca sã o modificadas e, portanto,
os objetos nunca sã o desalocados. A contagem de referê ncias geralmente nã o é visível para o có digo Python,
mas é um elemento-chave da implementaçã o do CPython. Os programadores podem chamar a funçã o sys.
getrefcount() para retornar a contagem de referê ncias para um objeto específico.

pacote regular
Um pacote tradicional, como um diretó rio contendo um arquivo __init__.py.
Veja també m pacote de espaço de nomes.
REPL
Um acrô nimo para “read–eval–print loop”, outro nome para o console interativo do interpretador.
__slots__
Uma declaraçã o dentro de uma classe que economiza memó ria pré -declarando espaço para atributos de ins-
tâ ncias, e eliminando dicioná rios de instâ ncias. Apesar de popular, a té cnica é um tanto quanto complicada
de acertar, e é melhor se for reservada para casos raros, onde existe uma grande quantidade de instâ ncias em
uma aplicaçã o onde a memó ria é crítica.
sequência
Um iterável com suporte para acesso eficiente a seus elementos atravé s de índices inteiros via mé todo es-
pecial __getitem__() e que define o mé todo __len__() que devolve o tamanho da sequê ncia. Alguns
tipos de sequê ncia embutidos sã o: list, str, tuple, e bytes. Note que dict també m tem suporte para
__getitem__() e __len__(), mas é considerado um mapeamento e nã o uma sequê ncia porque a busca
usa uma chave hasheável arbitrá ria em vez de inteiros.
A classe base abstrata collections.abc.Sequence define uma interface mais rica que vai alé m
de apenas __getitem__() e __len__(), adicionando count(), index(), __contains__(), e
__reversed__(). Tipos que implementam essa interface podem ser explicitamente registrados usando
register(). Para mais documentaçã o sobre mé todos de sequê ncias em geral, veja Operaçõ es comuns de
sequê ncias.
compreensão de conjunto
Uma maneira compacta de processar todos ou parte dos elementos em iterá vel e retornar um conjunto com
os resultados. results = {c for c in 'abracadabra' if c not in 'abc'} gera um conjunto de
strings {'r', 'd'}. Veja comprehensions.

81
Extending and Embedding Python, Release 3.13.2

despacho único
Uma forma de despacho de função genérica onde a implementaçã o é escolhida com base no tipo de um ú nico
argumento.
fatia
Um objeto geralmente contendo uma parte de uma sequência. Uma fatia é criada usando a notaçã o de subscrito
[] pode conter també m até dois pontos entre nú meros, como em variable_name[1:3:5]. A notaçã o de
suporte (subscrito) utiliza objetos slice internamente.
suavemente descontinuado
Uma API suavemente descontinuada nã o deve ser usada em có digo novo, mas é seguro para có digo já existente
usá -la. A API continua documentada e testada, mas nã o será aprimorada mais.
A descontinuaçã o suave, diferentemente da descontinuaçã o normal, nã o planeja remover a API e nã o emitirá
avisos.
Veja PEP 387: Descontinuaçã o suave.
método especial
Um mé todo que é chamado implicitamente pelo Python para executar uma certa operaçã o em um tipo, como
uma adiçã o por exemplo. Tais mé todos tem nomes iniciando e terminando com dois underscores. Mé todos
especiais estã o documentados em specialnames.
instrução
Uma instruçã o é parte de uma suíte (um “bloco” de có digo). Uma instruçã o é ou uma expressão ou uma de
vá rias construçõ es com uma palavra reservada, tal como if, while ou for.
verificador de tipo estático
Uma ferramenta externa que lê o có digo Python e o analisa, procurando por problemas como tipos incorretos.
Consulte també m dicas de tipo e o mó dulo typing.
referência forte
Na API C do Python, uma referê ncia forte é uma referê ncia a um objeto que pertence ao có digo que conté m a
referê ncia. A referê ncia forte é obtida chamando Py_INCREF() quando a referê ncia é criada e liberada com
Py_DECREF() quando a referê ncia é excluída.
A funçã o Py_NewRef() pode ser usada para criar uma referê ncia forte para um objeto. Normalmente, a
funçã o Py_DECREF() deve ser chamada na referê ncia forte antes de sair do escopo da referê ncia forte, para
evitar o vazamento de uma referê ncia.
Veja també m referência emprestada.
codificador de texto
Uma string em Python é uma sequê ncia de pontos de có digo Unicode (no intervalo U+0000–U+10FFFF). Para
armazenar ou transferir uma string, ela precisa ser serializada como uma sequê ncia de bytes.
A serializaçã o de uma string em uma sequê ncia de bytes é conhecida como “codificaçã o” e a recriaçã o da string
a partir de uma sequê ncia de bytes é conhecida como “decodificaçã o”.
Há uma variedade de diferentes serializaçõ es de texto codecs, que sã o coletivamente chamadas de “codificaçõ es
de texto”.
arquivo texto
Um objeto arquivo apto a ler e escrever objetos str. Geralmente, um arquivo texto, na verdade, acessa um
fluxo de dados de bytes e captura o codificador de texto automaticamente. Exemplos de arquivos texto sã o:
arquivos abertos em modo texto ('r' or 'w'), sys.stdin, sys.stdout, e instâ ncias de io.StringIO.
Veja també m arquivo binário para um objeto arquivo apto a ler e escrever objetos byte ou similar.
aspas triplas
Uma string que está definida com trê s ocorrê ncias de aspas duplas (”) ou apó strofos (‘). Enquanto elas nã o
fornecem nenhuma funcionalidade nã o disponível com strings de aspas simples, elas sã o ú teis para inú meras
razõ es. Elas permitem que você inclua aspas simples e duplas nã o escapadas dentro de uma string, e elas
podem utilizar mú ltiplas linhas sem o uso de caractere de continuaçã o, fazendo-as especialmente ú teis quando
escrevemos documentaçã o em docstrings.

82 Apêndice A. Glossário
 Extending and Embedding Python, Release 3.13.2

tipo
O tipo de um objeto Python determina qual classe de objeto ele é ; cada objeto tem um tipo. Um tipo de objeto
é acessível pelo atributo __class__ ou pode ser recuperado com type(obj).
apelido de tipo
Um sinô nimo para um tipo, criado atravé s da atribuiçã o do tipo para um identificador.
Apelidos de tipo sã o ú teis para simplificar dicas de tipo. Por exemplo:

def remove_tons_de_cinza(
cores: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
pass

pode tornar-se mais legível desta forma:

Cor = tuple[int, int, int]

def remove_tons_de_cinza(cores: list[Cor]) -> list[Cor]:

pass

Veja typing e PEP 484, a qual descreve esta funcionalidade.

dica de tipo
Uma anotação que especifica o tipo esperado para uma variá vel, um atributo de classe, ou um parâ metro de
funçã o ou um valor de retorno.
Dicas de tipo sã o opcionais e nã o sã o forçadas pelo Python, mas elas sã o ú teis para verificadores de tipo estático.
Eles també m ajudam IDEs a completar e refatorar có digo.
Dicas de tipos de variá veis globais, atributos de classes, e funçõ es, mas nã o de variá veis locais, podem ser
acessadas usando typing.get_type_hints().
Veja typing e PEP 484, a qual descreve esta funcionalidade.
novas linhas universais
Uma maneira de interpretar fluxos de textos, na qual todos estes sã o reconhecidos como caracteres de fim de
linha: a convençã o para fim de linha no Unix '\n', a convençã o no Windows '\r\n', e a antiga convençã o
no Macintosh '\r'. Veja PEP 278 e PEP 3116, bem como bytes.splitlines() para uso adicional.
anotação de variável
Uma anotação de uma variá vel ou um atributo de classe.
Ao fazer uma anotaçã o de uma variá vel ou um atributo de classe, a atribuiçã o é opcional:

class C:
campo: 'anotação'

Anotaçõ es de variá veis sã o normalmente usadas para dicas de tipo: por exemplo, espera-se que esta variá vel
receba valores do tipo int:

contagem: int = 0

A sintaxe de anotaçã o de variá vel é explicada na seçã o annassign.

Veja anotação de função, PEP 484 e PEP 526, que descrevem esta funcionalidade. Veja també m annotations-
-howto para as melhores prá ticas sobre como trabalhar com anotaçõ es.
ambiente virtual
Um ambiente de execuçã o isolado que permite usuá rios Python e aplicaçõ es instalarem e atualizarem pacotes
Python sem interferir no comportamento de outras aplicaçõ es Python em execuçã o no mesmo sistema.
Veja també m venv.
máquina virtual
Um computador definido inteiramente em software. A má quina virtual de Python executa o bytecode emitido
pelo compilador de bytecode.

83
Extending and Embedding Python, Release 3.13.2

Zen do Python
Lista de princípios de projeto e filosofias do Python que sã o ú teis para a compreensã o e uso da linguagem. A
lista é exibida quando se digita “import this” no console interativo.

84 Apêndice A. Glossário
 APÊNDICE B

Sobre esta documentação

A documentaçã o do Python é gerada a partir de fontes reStructuredText usando Sphinx, um gerador de documentaçã o
criado originalmente para Python e agora mantido como um projeto independente.
O desenvolvimento da documentaçã o e de suas ferramentas é um esforço totalmente voluntá rio, como Python em
si. Se você quer contribuir, por favor dê uma olhada na pá gina reporting-bugs para informaçõ es sobre como fazer.
Novos voluntá rios sã o sempre bem-vindos!
Agradecimentos especiais para:
• Fred L. Drake, Jr., o criador do primeiro conjunto de ferramentas para documentar Python e autor de boa
parte do conteú do;
• O projeto Docutils por criar reStructuredText e o pacote Docutils;
• Fredrik Lundh, pelo seu projeto de referê ncia alternativa em Python, do qual Sphinx pegou muitas boas ideias.

B.1 Contribuidores da documentação do Python

Muitas pessoas tem contribuído para a linguagem Python, sua biblioteca padrã o e sua documentaçã o. Veja
Misc/ACKS na distribuiçã o do có digo do Python para ver uma lista parcial de contribuidores.
Tudo isso só foi possível com o esforço e a contribuiçã o da comunidade Python, por isso temos essa maravilhosa
documentaçã o – Obrigado a todos!

85
Extending and Embedding Python, Release 3.13.2

86 Apêndice B. Sobre esta documentação

 APÊNDICE C

História e Licença

C.1 História do software

Python foi criado no início dos anos 1990 por Guido van Rossum no Stichting Mathematisch Centrum (CWI, veja
https://www.cwi.nl) na Holanda como sucessor de uma linguagem chamada ABC. Guido continua sendo o principal
autor do Python, embora inclua muitas contribuiçõ es de outros.
Em 1995, Guido continuou seu trabalho em Python na Corporation for National Research Initiatives (CNRI, veja
https://www.cnri.reston.va.us) em Reston, Virgínia, onde lançou vá rias versõ es do software.
Em maio de 2000, Guido e a equipe de desenvolvimento do nú cleo Python mudaram-se para BeOpen.com para
formar a equipe BeOpen PythonLabs. Em outubro do mesmo ano, a equipe PythonLabs mudou-se para a Di-
gital Creations, que se tornou Zope Corporation. Em 2001, a Python Software Foundation (PSF, veja https:
//www.python.org/psf/) foi formada, uma organizaçã o sem fins lucrativos criada especificamente para possuir Pro-
priedade Intelectual relacionada ao Python. A Zope Corporation era um membro patrocinador da PSF.
Todas as versõ es do Python sã o de có digo aberto (consulte https://opensource.org para a definiçã o de có digo aberto).
Historicamente, a maioria, mas nã o todas, versõ es do Python també m sã o compatíveis com GPL; a tabela abaixo
resume os vá rios lançamentos.

Versão Derivada de Ano Proprietário Compatível com a GPL? (1)

0.9.0 a 1.2 n/a 1991-1995 CWI sim
1.3 a 1.5.2 1.2 1995-1999 CNRI sim
1.6 1.5.2 2000 CNRI nã o
2.0 1.6 2000 BeOpen.com nã o
1.6.1 1.6 2001 CNRI sim (2)
2.1 2.0+1.6.1 2001 PSF nã o
2.0.1 2.0+1.6.1 2001 PSF sim
2.1.1 2.1+2.0.1 2001 PSF sim
2.1.2 2.1.1 2002 PSF sim
2.1.3 2.1.2 2002 PSF sim
2.2 e acima 2.1.1 2001-agora PSF sim

® Nota

87
Extending and Embedding Python, Release 3.13.2

(1) Compatível com a GPL nã o significa que estamos distribuindo Python sob a GPL. Todas as licenças do
Python, ao contrá rio da GPL, permitem distribuir uma versã o modificada sem fazer alteraçõ es em có digo
aberto. As licenças compatíveis com a GPL possibilitam combinar o Python com outro software lançado
sob a GPL; os outros nã o.
(2) De acordo com Richard Stallman, 1.6.1 nã o é compatível com GPL, porque sua licença tem uma clá usula
de escolha de lei. De acordo com a CNRI, no entanto, o advogado de Stallman disse ao advogado da CNRI
que 1.6.1 “nã o é incompatível” com a GPL.

Graças aos muitos voluntá rios externos que trabalharam sob a direçã o de Guido para tornar esses lançamentos pos-
síveis.

C.2 Termos e condições para acessar ou usar Python

O software e a documentaçã o do Python sã o licenciados sob a Python Software Foundation License Versã o 2.
A partir do Python 3.8.6, exemplos, receitas e outros có digos na documentaçã o sã o licenciados duplamente sob o
Licença PSF versã o 2 e a Licença BSD de Zero Cláusula.
Alguns softwares incorporados ao Python estã o sob licenças diferentes. As licenças sã o listadas com o có digo abran-
gido por essa licença. Veja Licenças e Reconhecimentos para Software Incorporado para uma lista incompleta dessas
licenças.

C.2.1 PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2

1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
the Individual or Organization ("Licensee") accessing and otherwise using this
software ("Python") in source or binary form and its associated documentation.

2. Subject to the terms and conditions of this License Agreement, PSF hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python alone or in any derivative
version, provided, however, that PSF's License Agreement and PSF's notice of
copyright, i.e., "Copyright © 2001-2024 Python Software Foundation; All Rights
Reserved" are retained in Python alone or in any derivative version
prepared by Licensee.

3. In the event Licensee prepares a derivative work that is based on or

incorporates Python or any part thereof, and wants to make the
derivative work available to others as provided herein, then Licensee hereby
agrees to include in any such work a brief summary of the changes made to␣
,→Python.

4. PSF is making Python available to Licensee on an "AS IS" basis.

PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON

FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.
(continua na pró xima pá gina)

88 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

7. Nothing in this License Agreement shall be deemed to create any relationship

of agency, partnership, or joint venture between PSF and Licensee. This License
Agreement does not grant permission to use PSF trademarks or trade name in a
trademark sense to endorse or promote products or services of Licensee, or any
third party.

8. By copying, installing or otherwise using Python, Licensee agrees

to be bound by the terms and conditions of this License Agreement.

C.2.2 ACORDO DE LICENCIAMENTO DA BEOPEN.COM PARA PYTHON 2.0

ACORDO DE LICENCIAMENTO DA BEOPEN DE FONTE ABERTA DO PYTHON VERSÃO 1

1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an office at

160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization
("Licensee") accessing and otherwise using this software in source or binary
form and its associated documentation ("the Software").

2. Subject to the terms and conditions of this BeOpen Python License Agreement,
BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license
to reproduce, analyze, test, perform and/or display publicly, prepare derivative
works, distribute, and otherwise use the Software alone or in any derivative
version, provided, however, that the BeOpen Python License is retained in the
Software, alone or in any derivative version prepared by Licensee.

3. BeOpen is making the Software available to Licensee on an "AS IS" basis.

BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF
EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING,
MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF
ADVISED OF THE POSSIBILITY THEREOF.

5. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

6. This License Agreement shall be governed by and interpreted in all respects

by the law of the State of California, excluding conflict of law provisions.
Nothing in this License Agreement shall be deemed to create any relationship of
agency, partnership, or joint venture between BeOpen and Licensee. This License
Agreement does not grant permission to use BeOpen trademarks or trade names in a
trademark sense to endorse or promote products or services of Licensee, or any
third party. As an exception, the "BeOpen Python" logos available at
http://www.pythonlabs.com/logos.html may be used according to the permissions
granted on that web page.

7. By copying, installing or otherwise using the software, Licensee agrees to be

bound by the terms and conditions of this License Agreement.

C.2. Termos e condições para acessar ou usar Python 89

Extending and Embedding Python, Release 3.13.2

C.2.3 CONTRATO DE LICENÇA DA CNRI PARA O PYTHON 1.6.1

1. This LICENSE AGREEMENT is between the Corporation for National Research
Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191
("CNRI"), and the Individual or Organization ("Licensee") accessing and
otherwise using Python 1.6.1 software in source or binary form and its
associated documentation.

2. Subject to the terms and conditions of this License Agreement, CNRI hereby
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
analyze, test, perform and/or display publicly, prepare derivative works,
distribute, and otherwise use Python 1.6.1 alone or in any derivative version,
provided, however, that CNRI's License Agreement and CNRI's notice of copyright,
i.e., "Copyright © 1995-2001 Corporation for National Research Initiatives; All
Rights Reserved" are retained in Python 1.6.1 alone or in any derivative version
prepared by Licensee. Alternately, in lieu of CNRI's License Agreement,
Licensee may substitute the following text (omitting the quotes): "Python 1.6.1
is made available subject to the terms and conditions in CNRI's License
Agreement. This Agreement together with Python 1.6.1 may be located on the
internet using the following unique, persistent identifier (known as a handle):
1895.22/1013. This Agreement may also be obtained from a proxy server on the
internet using the following URL: http://hdl.handle.net/1895.22/1013".

3. In the event Licensee prepares a derivative work that is based on or

incorporates Python 1.6.1 or any part thereof, and wants to make the derivative
work available to others as provided herein, then Licensee hereby agrees to
include in any such work a brief summary of the changes made to Python 1.6.1.

4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" basis. CNRI
MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,
BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.

5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR
ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE
THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

6. This License Agreement will automatically terminate upon a material breach of

its terms and conditions.

7. This License Agreement shall be governed by the federal intellectual property

law of the United States, including without limitation the federal copyright
law, and, to the extent such U.S. federal law does not apply, by the law of the
Commonwealth of Virginia, excluding Virginia's conflict of law provisions.
Notwithstanding the foregoing, with regard to derivative works based on Python
1.6.1 that incorporate non-separable material that was previously distributed
under the GNU General Public License (GPL), the law of the Commonwealth of
Virginia shall govern this License Agreement only as to issues arising under or
with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in
this License Agreement shall be deemed to create any relationship of agency,
partnership, or joint venture between CNRI and Licensee. This License Agreement
does not grant permission to use CNRI trademarks or trade name in a trademark
sense to endorse or promote products or services of Licensee, or any third
party.

(continua na pró xima pá gina)

90 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

8. By clicking on the "ACCEPT" button where indicated, or by copying, installing
or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and
conditions of this License Agreement.

C.2.4 ACORDO DE LICENÇA DA CWI PARA PYTHON 0.9.0 A 1.2

Copyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The
Netherlands. All rights reserved.

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted, provided that
the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and that
the name of Stichting Mathematisch Centrum or CWI not be used in advertising or
publicity pertaining to distribution of the software without specific, written
prior permission.

STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT
OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.

C.2.5 ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTA-

TION
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

C.3 Licenças e Reconhecimentos para Software Incorporado

Esta seçã o é uma lista incompleta, mas crescente, de licenças e reconhecimentos para softwares de terceiros incor-
porados na distribuiçã o do Python.

C.3.1 Mersenne Twister

A extensã o C _random subjacente ao mó dulo random inclui có digo baseado em um download de http://www.math.
sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html. A seguir estã o os comentá rios literais do có digo ori-
ginal:
A C-program for MT19937, with initialization improved 2002/1/26.
Coded by Takuji Nishimura and Makoto Matsumoto.

Before using, initialize the state by using init_genrand(seed)

(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 91

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

or init_by_array(init_key, key_length).

Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

3. The names of its contributors may not be used to endorse or promote

products derived from this software without specific prior written
permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Any feedback is very welcome.

http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)

C.3.2 Soquetes
O mó dulo socket usa as funçõ es getaddrinfo() e getnameinfo(), que sã o codificadas em arquivos de origem
separados do Projeto WIDE, https://www.wide.ad.jp/.

Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the project nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
(continua na pró xima pá gina)

92 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.3 Serviços de soquete assíncrono

Os mó dulos test.support.asynchat e test.support.asyncore contê m o seguinte aviso:
Copyright 1996 by Sam Rushing

All Rights Reserved

Permission to use, copy, modify, and distribute this software and

its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of Sam
Rushing not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

SAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
NO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

C.3.4 Gerenciamento de cookies

O mó dulo http.cookies conté m o seguinte aviso:
Copyright 2000 by Timothy O'Malley <timo@alum.mit.edu>

All Rights Reserved

Permission to use, copy, modify, and distribute this software

and its documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appear in all
copies and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Timothy O'Malley not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

Timothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS

(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 93

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.

C.3.5 Rastreamento de execução

O mó dulo trace conté m o seguinte aviso:

portions copyright 2001, Autonomous Zones Industries, Inc., all rights...

err... reserved and offered to the public under the terms of the
Python 2.2 license.
Author: Zooko O'Whielacronx
http://zooko.com/
mailto:zooko@zooko.com

Copyright 2000, Mojam Media, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1999, Bioreason, Inc., all rights reserved.

Author: Andrew Dalke

Copyright 1995-1997, Automatrix, Inc., all rights reserved.

Author: Skip Montanaro

Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.

Permission to use, copy, modify, and distribute this Python software and
its associated documentation for any purpose without fee is hereby
granted, provided that the above copyright notice appears in all copies,
and that both that copyright notice and this permission notice appear in
supporting documentation, and that the name of neither Automatrix,
Bioreason or Mojam Media be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.

C.3.6 Funções UUencode e UUdecode

O codec uu conté m o seguinte aviso:

Copyright 1994 by Lance Ellinghouse

Cathedral City, California Republic, United States of America.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Lance Ellinghouse
not be used in advertising or publicity pertaining to distribution
of the software without specific, written prior permission.
LANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE
(continua na pró xima pá gina)

94 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Modified by Jack Jansen, CWI, July 1995:

- Use binascii module to do the actual line-by-line conversion
between ascii and binary. This results in a 1000-fold speedup. The C
version is still 5 times faster, though.
- Arguments more compliant with Python standard

C.3.7 Chamadas de procedimento remoto XML

O mó dulo xmlrpc.client conté m o seguinte aviso:
The XML-RPC client interface is

Copyright (c) 1999-2002 by Secret Labs AB

Copyright (c) 1999-2002 by Fredrik Lundh

By obtaining, using, and/or copying this software and/or its

associated documentation, you agree that you have read, understood,
and will comply with the following terms and conditions:

Permission to use, copy, modify, and distribute this software and

its associated documentation for any purpose and without fee is
hereby granted, provided that the above copyright notice appears in
all copies, and that both that copyright notice and this permission
notice appear in supporting documentation, and that the name of
Secret Labs AB or the author not be used in advertising or publicity
pertaining to distribution of the software without specific, written
prior permission.

SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
ABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.

C.3.8 test_epoll
O mó dulo test.test_epoll conté m o seguinte aviso:
Copyright (c) 2001-2006 Twisted Matrix Laboratories.

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 95

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3.9 kqueue de seleção

O mó dulo select conté m o seguinte aviso para a interface do kqueue:
Copyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes
All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.10 SipHash24
O arquivo Python/pyhash.c conté m a implementaçã o de Marek Majkowski do algoritmo SipHash24 de Dan
Bernstein. Conté m a seguinte nota:
<MIT License>
Copyright (c) 2013 Marek Majkowski <marek@popcount.org>

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
(continua na pró xima pá gina)

96 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

</MIT License>

Original location:
https://github.com/majek/csiphash/

Solution inspired by code from:

Samuel Neves (supercop/crypto_auth/siphash24/little)
djb (supercop/crypto_auth/siphash24/little2)
Jean-Philippe Aumasson (https://131002.net/siphash/siphash24.c)

C.3.11 strtod e dtoa

O arquivo Python/dtoa.c, que fornece as funçõ es C dtoa e strtod para conversã o de duplas de C para e de strings,
é derivado do arquivo com o mesmo nome de David M. Gay, atualmente disponível em https://web.archive.org/
web/20220517033456/http://www.netlib.org/fp/dtoa.c. O arquivo original, conforme recuperado em 16 de março
de 2009, conté m os seguintes avisos de direitos autorais e de licenciamento:
/****************************************************************
*
* The author of this software is David M. Gay.
*
* Copyright (c) 1991, 2000, 2001 by Lucent Technologies.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose without fee is hereby granted, provided that this entire notice
* is included in all copies of any software which is or includes a copy
* or modification of this software and in all copies of the supporting
* documentation for such software.
*
* THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
* WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY
* REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
* OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
*
***************************************************************/

C.3.12 OpenSSL
Os mó dulos hashlib, posix e ssl usam a biblioteca OpenSSL para desempenho adicional se forem disponibi-
lizados pelo sistema operacional. Alé m disso, os instaladores do Windows e do Mac OS X para Python podem
incluir uma có pia das bibliotecas do OpenSSL, portanto incluímos uma có pia da licença do OpenSSL aqui: Para o
lançamento do OpenSSL 3.0, e lançamentos posteriores derivados deste, se aplica a Apache License v2:

Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by

the copyright owner that is granting the License.
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 97

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity

exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical

transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or

Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object

form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including

the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity

on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of

this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
(continua na pró xima pá gina)

98 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of

this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the

Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or

Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its

distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.

You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 99

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,

any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or

agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,

whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing

the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

100 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

C.3.13 expat
A extensã o pyexpat é construída usando uma có pia incluída das fontes de expatriadas, a menos que a compilaçã o
esteja configurada --with-system-expat:

Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
and Clark Cooper

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3.14 libffi
A extensã o C _ctypes subjacente ao mó dulo ctypes é construída usando uma có pia incluída das fontes do libffi,
a menos que a construçã o esteja configurada com --with-system-libffi:

Copyright (c) 1996-2008 Red Hat, Inc and others.

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

C.3. Licenças e Reconhecimentos para Software Incorporado 101

Extending and Embedding Python, Release 3.13.2

C.3.15 zlib
A extensã o zlib é construída usando uma có pia incluída das fontes zlib se a versã o do zlib encontrada no sistema
for muito antiga para ser usada na construçã o:

Copyright (C) 1995-2011 Jean-loup Gailly and Mark Adler

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages
arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

Jean-loup Gailly Mark Adler

jloup@gzip.org madler@alumni.caltech.edu

C.3.16 cfuhash
A implementaçã o da tabela de hash usada pelo tracemalloc é baseada no projeto cfuhash:

Copyright (c) 2005 Don Owens

All rights reserved.

This code is released under the BSD license:

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above

copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.

* Neither the name of the author nor the names of its

contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
(continua na pró xima pá gina)

102 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.

C.3.17 libmpdec
A extensã o C _decimal subjacente ao mó dulo decimal é construída usando uma có pia incluída da biblioteca
libmpdec, a menos que a construçã o esteja configurada com --with-system-libmpdec:
Copyright (c) 2008-2020 Stefan Krah. All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

C.3.18 Conjunto de testes C14N do W3C

O conjunto de testes C14N 2.0 no pacote test (Lib/test/xmltestdata/c14n-20/) foi recuperado do site do
W3C em https://www.w3.org/TR/xml-c14n2-testcases/ e é distribuído sob a licença BSD de 3 clá usulas:

Copyright (c) 2013 W3C(R) (MIT, ERCIM, Keio, Beihang),

All Rights Reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:

* Redistributions of works must retain the original copyright notice,

this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the original copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the W3C nor the names of its contributors may be
(continua na pró xima pá gina)

C.3. Licenças e Reconhecimentos para Software Incorporado 103

Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

used to endorse or promote products derived from this work without
specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

C.3.19 mimalloc
Licença MIT:
Copyright (c) 2018-2021 Microsoft Corporation, Daan Leijen

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

C.3.20 asyncio
Partes do mó dulo asyncio sã o incorporadas do uvloop 0.16, que é distribuído sob a licença MIT:

Copyright (c) 2015-2021 MagicStack Inc. http://magic.io

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be

included in all copies or substantial portions of the Software.

(continua na pró xima pá gina)

104 Apêndice C. História e Licença

 Extending and Embedding Python, Release 3.13.2

(continuaçã o da pá gina anterior)

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

C.3.21 Global Unbounded Sequences (GUS)

O arquivo Python/qsbr.c é adaptado do esquema de recuperaçã o de memó ria segura “Global Unbounded Se-
quences” do FreeBSD em subr_smr.c. O arquivo é distribuído sob a licença BSD de 2 clá usulas:

Copyright (c) 2019,2020 Jeffrey Roberson <jeff@FreeBSD.org>

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice unmodified, this list of conditions, and the following
disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

C.3. Licenças e Reconhecimentos para Software Incorporado 105

Extending and Embedding Python, Release 3.13.2

106 Apêndice C. História e Licença

 APÊNDICE D

Direitos autorais

Python e essa documentaçã o é :

Copyright © 2001-2024 Python Software Foundation. Todos os direitos reservados.
Copyright © 2000 BeOpen.com. Todos os direitos reservados.
Copyright © 1995-2000 Corporation for National Research Initiatives. Todos os direitos reservados.
Copyright © 1991-1995 Stichting Mathematisch Centrum. Todos os direitos reservados.

Veja: História e Licença para informaçõ es completas de licença e permissõ es.

107
Extending and Embedding Python, Release 3.13.2

108 Apêndice D. Direitos autorais

 Índice

Não alfabético contíguo C, 70

..., 67 contíguo Fortran, 70
>>>, 67 corrotina, 70
__future__, 73 CPython, 71
__slots__, 81
D
A deallocation, object, 49
aguardável, 68 decorador, 71
ambiente virtual, 83 descritor, 71
anotação, 67 desligamento do interpretador, 75
anotação de função, 73 despacho único, 82
anotação de variável, 83 dica de tipo, 83
apelido de tipo, 83 dicionário, 71
API provisória, 80 divisão pelo piso, 73
argumento, 67 docstring, 71
argumento nomeado, 76
argumento posicional, 80 E
arquivo binário, 69 EAFP, 72
arquivo texto, 82 entrada de caminho, 79
aspas triplas, 82 escopo aninhado, 78
atributo, 68 escopo otimizado, 78
espaço de nomes, 78
B especial
BDFL, 69 método, 82
bytecode, 69 expressão, 72
expressão geradora, 74
C
caminho de importação, 75 F
carregador, 76 f-string, 72
chamável, 69 fatia, 82
classe, 69 finalization, of objects, 49
classe base abstrata, 67 função, 73
classe estilo novo, 78 função chave, 76
codificação da localidade, 77 função de corrotina, 71
codificador de texto, 82 função de retorno, 69
coleta de lixo, 73 função embutida
compreensão de conjunto, 81 repr, 50
compreensão de dicionário, 71 função genérica, 74
compreensão de lista, 76
contagem de referências, 81 G
contexto, 70 gancho de entrada de caminho, 79
contexto atual, 71 gerador, 73
contíguo, 70 gerador assíncrono, 68

109
Extending and Embedding Python, Release 3.13.2

gerenciador de contexto, 70 objeto arquivo ou similar, 72

gerenciador de contexto assíncrono, 68 objeto byte ou similar, 69
GIL, 74 objeto caminho ou similar, 80
ordem de resolução de métodos, 77
H
hasheável, 74 P
pacote, 79
I pacote de espaço de nomes, 78
IDLE, 75 pacote provisório, 80
imortal, 75 pacote regular, 81
importação, 75 parâmetro, 79
importador, 75 PEP, 80
imutável, 75 Philbrick, Geoff, 15
instrução, 82 porção, 80
interativo, 75 Propostas de Melhorias do Python
interpretado, 75 PEP 1, 80
iterador, 76 PEP 238, 73
iterador assíncrono, 68 PEP 278, 83
iterador gerador, 74 PEP 302, 77
iterador gerador assíncrono, 68 PEP 343, 70
iterável, 75 PEP 362, 68, 79
iterável assíncrono, 68 PEP 411, 80
PEP 420, 78, 80
L PEP 442, 50
lambda, 76 PEP 443, 74
LBYL, 76 PEP 483, 74
lista, 76 PEP 484, 67, 73, 74, 83
localizador, 73 PEP 489, 11, 57
localizador baseado no caminho, 79 PEP 492, 68, 70, 71
localizador de entrada de caminho, 79 PEP 498, 72
localizador de metacaminho, 77 PEP 519, 80
PEP 525, 68
M PEP 526, 67, 83
mágico PEP 585, 74
método, 77 PEP 683, 75
mapeamento, 77 PEP 703, 73, 74
máquina virtual, 83 PEP 3116, 83
metaclasse, 77 PEP 3155, 81
método, 77 protocolo de gerenciamento de contexto, 70
especial, 82 PyArg_ParseTuple (C function), 14
mágico, 77 PyArg_ParseTupleAndKeywords (C function), 15
método especial, 82 pyc baseado em hash, 74
método mágico, 77 PyErr_Fetch (C function), 49
módulo, 77 PyErr_Restore (C function), 49
módulo de extensão, 72 PyInit_modulename (C function), 56
MRO, 78 PyObject_CallObject (C function), 12
mutável, 78 Python 3000, 80
PYTHON_GIL, 74
N Pythônico, 80
nome qualificado, 81 PYTHONPATH, 56
novas linhas universais, 83
número complexo, 70 R
referência emprestada, 69
O referência forte, 82
objeto, 78 REPL, 81
deallocation, 49 repr
finalization, 49 função embutida, 50
objeto arquivo, 72

110 Índice
 Extending and Embedding Python, Release 3.13.2

S
sequência, 81
spec de módulo, 77
string
object representation, 50
suavemente descontinuado, 82

T
threads livres, 73
tipagem pato, 72
tipo, 83
tipo genérico, 74
tratador de erros e codificação do
sistema de arquivos, 72
trava global do interpretador, 74
tupla nomeada, 78

V
variável de ambiente
PYTHON_GIL, 74
PYTHONPATH, 56
variável de classe, 69
variável de clausura, 70
variável de contexto, 70
variável livre, 73
verificador de tipo estático, 82
visão de dicionário, 71

Z
Zen do Python, 84

Índice 111