FAQ de Bibliotecas e Extensões
******************************


Questões gerais sobre bibliotecas
=================================


Como encontrar um módulo ou aplicação para realizar uma tarefa X?
-----------------------------------------------------------------

Verifique a Referência de Bibliotecas para ver se há um módulo
relevante da biblioteca padrão. (Eventualmente, você aprenderá o que
está na biblioteca padrão e poderá pular esta etapa.)

Para pacotes de terceiros, pesquise no Python Package Index ou tente
no Google ou outro buscador na web. Pesquisando por "Python" mais uma
ou dois argumentos nomeados do seu tópico de interesse geralmente
encontrará algo útil.


Onde está o código-fonte do math.py (socket.py, regex.py, etc.)?
----------------------------------------------------------------

Se você não conseguir encontrar um arquivo de origem para um módulo,
ele pode ser um módulo embutido ou carregado dinamicamente,
implementado em C, C++ ou outra linguagem compilada. Nesse caso, você
pode não ter o arquivo de origem ou pode ser algo como "mathmodule.c",
em algum lugar do diretório de origem C (não no caminho do Python).

Existem (pelo menos) três tipos de módulos no Python:

1. módulos escritos em Python (.py)

2. módulos escritos em C e carregados dinamicamente (.dll, .pyd, .so,
   .sl, etc.);

3. módulos escritos em C e vinculados ao interpretador; para obter uma
   dessas listas, digite:

      import sys
      print(sys.builtin_module_names)


Como tornar um script Python executável no Unix?
------------------------------------------------

Você precisa fazer duas coisas: o arquivo do script deve ser
executável e a primeira linha deve começar com "#!" seguido do caminho
do interpretador Python.

Inicialmente, execute o "chmod +x scriptfile" ou, talvez, o "chmod 755
scriptfile".

A segunda coisa pode ser feita de várias maneiras. A maneira mais
direta é escrever

   #!/usr/local/bin/python

como a primeira linha do seu arquivo, usando o endereço do caminho
onde o interpretador Python está instalado.

Se você deseja que o script seja independente de onde o interpretador
Python mora, você pode usar o programa **env**. Quase todas as
variantes do Unix suportam o seguinte, assumindo que o interpretador
Python esteja em um diretório no "PATH" do usuário:

   #!/usr/bin/env python

Não faça isso para CGI scripts. A variável "PATH" para CGI scripts é
normalmente muito pequena, portanto, você precisa usar o caminho
completo do interpretador.

Ocasionalmente, o ambiente de um usuário está tão cheio que o programa
**/usr/bin/env** falha; ou não há nenhum programa env. Nesse caso,
você pode tentar o seguinte hack (graças a Alex Rezinsky):

   #! /bin/sh
   """:"
   exec python $0 ${1+"$@"}
   """

Uma pequena desvantagem é que isso define o script's __doc__ string.
Entretanto, você pode corrigir isso adicionando

   __doc__ = """...Whatever..."""


Existe um pacote de curses/termcap para Python?
-----------------------------------------------

Para variantes Unix: A distribuição fonte padrão do Python vem com um
módulo do curses no subdiretório Modules, embora não seja compilado
por padrão.  (Observe que isso não está disponível na distribuição do
Windows -- não há módulo curses para o Windows.)

O módulo "curses" provê recursos básicos de curses, bem como muitas
funções adicionais de ncurses e curses SYSV, como cor, suporte a
conjuntos de caracteres alternativos, pads e suporte a mouse. Isso
significa que o módulo não é compatível com sistemas operacionais que
possuem apenas maldições BSD, mas não parece haver nenhum sistema
operacional mantido atualmente que se enquadre nesta categoria.


Existe a função onexit() equivalente ao C no Python?
----------------------------------------------------

O módulo "atexit" fornece uma função de registro similar ao "onexit()"
do C.


Por que o meu manipulador de sinal não funciona?
------------------------------------------------

O maior problema é que o manipulador de sinal é declarado com uma
lista de argumentos incorretos. Isso é chamado como

   handler(signum, frame)

portanto, isso deve ser declarado com dois parâmetros:

   def handler(signum, frame):
       ...


Tarefas comuns
==============


Como testar um programa ou componente Python?
---------------------------------------------

A Python vem com dois frameworks de teste. O módulo "doctest" busca
por exemplos nas docstrings de um módulo e os executa, comparando o
resultado com a saída esperada informada na docstring.

O módulo "unittest" é uma estrutura de teste mais sofisticada,
modelada nas estruturas de teste do Java e do Smalltalk.

Para facilitar os testes, você deve usar um bom design modular em seu
programa. Seu programa deve ter quase todas as funcionalidades
encapsuladas em funções ou métodos de classe -- e isso às vezes tem o
efeito surpreendente e agradável de fazer o programa executar mais
rápido (porque os acessos às variáveis locais são mais rápidos que os
acessos globais). Além disso, o programa deve evitar depender de
variáveis globais mutantes, pois isso torna os testes muito mais
difíceis de serem realizados.

A lógica principal do seu programa pode tão simples quanto

   if __name__ == "__main__":
       main_logic()

no botão do módulo principal do seus programa.

Depois que seu programa estiver organizado como uma coleção tratável
de comportamentos de funções e classes, você deverá escrever funções
de teste que exercitem os comportamentos. Um conjunto de testes que
automatiza uma sequência de testes pode ser associado a cada módulo.
Parece muito trabalhoso, mas como o Python é tão conciso e flexível, é
surpreendentemente fácil. Você pode tornar a codificação muito mais
agradável e divertida escrevendo suas funções de teste em paralelo com
o "código de produção", pois isso torna mais fácil encontrar bugs e
até mesmo falhas de design mais cedo.

Os "módulos de suporte" que não se destinam a ser o módulo principal
de um programa podem incluir um autoteste do módulo.

   if __name__ == "__main__":
       self_test()

Mesmo quando as interfaces externas não estiverem disponíveis, os
programas que interagem com interfaces externas complexas podem ser
testados usando as interfaces "falsas" implementadas no Python.


Como faço para criar uma documentação de doc strings?
-----------------------------------------------------

O módulo "pydoc" pode criar HTML a partir das strings de documentos em
seu código-fonte Python. Uma alternativa para criar documentação de
API puramente a partir de docstrings é epydoc. Sphinx também pode
incluir conteúdo docstring.


Como faço para pressionar uma tecla de cada vez?
------------------------------------------------

Para variantes do Unix existem várias soluções. Apesar de ser um
módulo grande para aprender, é simples fazer isso usando o módulo
curses.


Threads
=======


Como faço para programar usando threads?
----------------------------------------

Certifique-se de usar o módulo "threading" e não o módulo "_thread". O
módulo "threading" constrói abstrações convenientes sobre as
primitivas de baixo nível fornecidas pelo módulo "_thread".


Nenhuma de minhas threads parece funcionar, por que?
----------------------------------------------------

Assim que a thread principal acaba, todas as threads são eliminadas.
Sua thread principal está sendo executada tão rápida que não está
dando tempo para realizar qualquer trabalho.

Uma solução simples é adicionar um tempo de espera no final do
programa até que todos os threads sejam concluídos:

   import threading, time

   def thread_task(name, n):
       for i in range(n):
           print(name, i)

   for i in range(10):
       T = threading.Thread(target=thread_task, args=(str(i), i))
       T.start()

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

Mas agora (em muitas plataformas) as threads não funcionam em
paralelo, mas parecem funcionar sequencialmente, um de cada vez! O
motivo é que o agendador de threads do sistema operacional não inicia
uma nova thread até que a thread anterior seja bloqueada.

Uma solução simples é adicionar um pequeno tempo de espera no início
da função:

   def thread_task(name, n):
       time.sleep(0.001)  # <--------------------!
       for i in range(n):
           print(name, i)

   for i in range(10):
       T = threading.Thread(target=thread_task, args=(str(i), i))
       T.start()

   time.sleep(10)

Em vez de tentar adivinhar um bom valor de atraso para "time.sleep()",
é melhor usar algum tipo de mecanismo de semáforo. Uma ideia é usar o
módulo "queue" para criar um objeto fila, deixar cada thread anexar um
token à fila quando terminar e deixar a thread principal ler tantos
tokens da fila quantos threads houver.


Como distribuo o trabalho entre várias threads de trabalho?
-----------------------------------------------------------

A maneira mais fácil é usar o módulo "concurrent.futures",
especialmente a classe "ThreadPoolExecutor".

Ou, se quiser um controle preciso sobre o algoritmo de despacho, você
pode escrever sua própria lógica manualmente. Use o módulo "queue"
para criar uma fila contendo uma lista de tarefas. A classe "Queue"
mantém uma lista de objetos e possui um método ".put(obj)" que
adiciona itens à fila e um método ".get()" para retorná-los. A classe
cuidará da trava necessário para garantir que cada trabalho seja
entregue exatamente uma vez.

Aqui está um exemplo simples:

   import threading, queue, time

   # The worker thread gets jobs off the queue.  When the queue is empty, it
   # assumes there will be no more work and exits.
   # (Realistically workers will run until terminated.)
   def worker():
       print('Running worker')
       time.sleep(0.1)
       while True:
           try:
               arg = q.get(block=False)
           except queue.Empty:
               print('Worker', threading.current_thread(), end=' ')
               print('queue empty')
               break
           else:
               print('Worker', threading.current_thread(), end=' ')
               print('running with argument', arg)
               time.sleep(0.5)

   # Create queue
   q = queue.Queue()

   # Start a pool of 5 workers
   for i in range(5):
       t = threading.Thread(target=worker, name='worker %i' % (i+1))
       t.start()

   # Begin adding work to the queue
   for i in range(50):
       q.put(i)

   # Give threads time to run
   print('Main thread sleeping')
   time.sleep(5)

Quando executado, isso produzirá a seguinte saída:

   Running worker
   Running worker
   Running worker
   Running worker
   Running worker
   Main thread sleeping
   Worker <Thread(worker 1, started 130283832797456)> running with argument 0
   Worker <Thread(worker 2, started 130283824404752)> running with argument 1
   Worker <Thread(worker 3, started 130283816012048)> running with argument 2
   Worker <Thread(worker 4, started 130283807619344)> running with argument 3
   Worker <Thread(worker 5, started 130283799226640)> running with argument 4
   Worker <Thread(worker 1, started 130283832797456)> running with argument 5
   ...

Consulte a documentação do módulo para mais detalhes; a classe "Queue"
fornece uma interface com recursos.


Que tipos de variáveis globais mutáveis são seguras para thread?
----------------------------------------------------------------

Uma *trava global do interpretador* (GIL) é usada internamente para
garantir que apenas um thread seja executado na VM Python por vez. Em
geral, Python oferece alternar entre threads apenas entre instruções
de bytecode; a frequência com que ele muda pode ser definida via
"sys.setswitchinterval()". Cada instrução de bytecode e, portanto,
todo o código de implementação C alcançado por cada instrução é,
portanto, atômico do ponto de vista de um programa Python.

Em teoria, isso significa que uma contabilidade exata requer um
entendimento exato da implementação do bytecode PVM. Na prática, isso
significa que as operações em variáveis compartilhadas de tipos de
dados integrados (inteiros, listas, dicionarios, etc.) que "parecem
atômicas" realmente são.

Por exemplo, as seguintes operações são todas atômicas (L, L1, L2 são
listas, D, D1, D2 são dicionários, x, y são objetos, i, j são
inteiros):

   L.append(x)
   L1.extend(L2)
   x = L[i]
   x = L.pop()
   L1[i:j] = L2
   L.sort()
   x = y
   x.field = y
   D[x] = y
   D1.update(D2)
   D.keys()

Esses não são:

   i = i+1
   L.append(L[-1])
   L[i] = L[j]
   D[x] = D[x] + 1

Operações que substituem outros objetos podem invocar o método
"__del__()" desses outros objetos quando sua contagem de referências
chega a zero, e isso pode afetar as coisas. Isto é especialmente
verdadeiro para as atualizações em massa de dicionários e listas. Em
caso de dúvida, use um mutex!


Não podemos remover a Trava Global do interpretador?
----------------------------------------------------

A *trava global do interpretador* (GIL) é frequentemente vista como um
obstáculo para a implantação do Python em máquinas servidoras
multiprocessadas de ponta, porque um programa Python multi-threaded
efetivamente usa apenas uma CPU, devido à insistência de que (quase)
todo código Python só pode ser executado enquanto a GIL é mantida.

With the approval of **PEP 703** work is now underway to remove the
GIL from the CPython implementation of Python.  Initially it will be
implemented as an optional compiler flag when building the
interpreter, and so separate builds will be available with and without
the GIL.  Long-term, the hope is to settle on a single build, once the
performance implications of removing the GIL are fully understood.
Python 3.13 is likely to be the first release containing this work,
although it may not be completely functional in this release.

The current work to remove the GIL is based on a fork of Python 3.9
with the GIL removed by Sam Gross. Prior to that, in the days of
Python 1.5, Greg Stein actually implemented a comprehensive patch set
(the "free threading" patches) that removed the GIL and replaced it
with fine-grained locking.  Adam Olsen did a similar experiment in his
python-safethread project.  Unfortunately, both of these earlier
experiments exhibited a sharp drop in single-thread performance (at
least 30% slower), due to the amount of fine-grained locking necessary
to compensate for the removal of the GIL.  The Python 3.9 fork is the
first attempt at removing the GIL with an acceptable performance
impact.

The presence of the GIL in current Python releases doesn't mean that
you can't make good use of Python on multi-CPU machines! You just have
to be creative with dividing the work up between multiple *processes*
rather than multiple *threads*.  The "ProcessPoolExecutor" class in
the new "concurrent.futures" module provides an easy way of doing so;
the "multiprocessing" module provides a lower-level API in case you
want more control over dispatching of tasks.

O uso criterioso de extensões C também ajudará; se você usar uma
extensão C para executar uma tarefa demorada, a extensão poderá
liberar a GIL enquanto o thread de execução estiver no código C e
permitir que outros threads realizem algum trabalho. Alguns módulos de
biblioteca padrão como "zlib" e "hashlib" já fazem isso.

An alternative approach to reducing the impact of the GIL is to make
the GIL a per-interpreter-state lock rather than truly global. This
was first implemented in Python 3.12 and is available in the C API. A
Python interface to it is expected in Python 3.13. The main limitation
to it at the moment is likely to be 3rd party extension modules, since
these must be written with multiple interpreters in mind in order to
be usable, so many older extension modules will not be usable.


Entrada e Saída
===============


Como faço para excluir um arquivo? (E outras perguntas sobre arquivos)
----------------------------------------------------------------------

Use "os.remove(filename)" ou "os.unlink(filename)";para documentação,
veja o módulo "os". As duas funções são idênticas; "unlink()" é
simplesmente o nome da chamada do sistema para esta função no Unix.

To remove a directory, use "os.rmdir()"; use "os.mkdir()" to create
one. "os.makedirs(path)" will create any intermediate directories in
"path" that don't exist. "os.removedirs(path)" will remove
intermediate directories as long as they're empty; if you want to
delete an entire directory tree and its contents, use
"shutil.rmtree()".

Para renomear um arquivos, use "os.rename(old_path, new_path)".

To truncate a file, open it using "f = open(filename, "rb+")", and use
"f.truncate(offset)"; offset defaults to the current seek position.
There's also "os.ftruncate(fd, offset)" for files opened with
"os.open()", where *fd* is the file descriptor (a small integer).

The "shutil" module also contains a number of functions to work on
files including "copyfile()", "copytree()", and "rmtree()".


Como eu copio um arquivo?
-------------------------

The "shutil" module contains a "copyfile()" function. Note that on
Windows NTFS volumes, it does not copy alternate data streams nor
resource forks on macOS HFS+ volumes, though both are now rarely used.
It also doesn't copy file permissions and metadata, though using
"shutil.copy2()" instead will preserve most (though not all) of it.


Como leio (ou escrevo) dados binários?
--------------------------------------

To read or write complex binary data formats, it's best to use the
"struct" module.  It allows you to take a string containing binary
data (usually numbers) and convert it to Python objects; and vice
versa.

For example, the following code reads two 2-byte integers and one
4-byte integer in big-endian format from a file:

   import struct

   with open(filename, "rb") as f:
       s = f.read(8)
       x, y, z = struct.unpack(">hhl", s)

The '>' in the format string forces big-endian data; the letter 'h'
reads one "short integer" (2 bytes), and 'l' reads one "long integer"
(4 bytes) from the string.

For data that is more regular (e.g. a homogeneous list of ints or
floats), you can also use the "array" module.

Nota:

  To read and write binary data, it is mandatory to open the file in
  binary mode (here, passing ""rb"" to "open()").  If you use ""r""
  instead (the default), the file will be open in text mode and
  "f.read()" will return "str" objects rather than "bytes" objects.


Por que não consigo usar os.read() em um encadeamento com os.popen()?
---------------------------------------------------------------------

"os.read()" is a low-level function which takes a file descriptor, a
small integer representing the opened file.  "os.popen()" creates a
high-level file object, the same type returned by the built-in
"open()" function. Thus, to read *n* bytes from a pipe *p* created
with "os.popen()", you need to use "p.read(n)".


Como acesso a porta serial (RS232)?
-----------------------------------

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

   pyserial

Para Unix, veja uma postagem da Usenet de Mitch Chapman:

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


Por que o sys.stdout (stdin, stderr) não fecha?
-----------------------------------------------

Python *file objects* are a high-level layer of abstraction on low-
level C file descriptors.

For most file objects you create in Python via the built-in "open()"
function, "f.close()" marks the Python file object as being closed
from Python's point of view, and also arranges to close the underlying
C file descriptor.  This also happens automatically in "f"'s
destructor, when "f" becomes garbage.

But stdin, stdout and stderr are treated specially by Python, because
of the special status also given to them by C.  Running
"sys.stdout.close()" marks the Python-level file object as being
closed, but does *not* close the associated C file descriptor.

To close the underlying C file descriptor for one of these three, you
should first be sure that's what you really want to do (e.g., you may
confuse extension modules trying to do I/O).  If it is, use
"os.close()":

   os.close(stdin.fileno())
   os.close(stdout.fileno())
   os.close(stderr.fileno())

Ou você pode usar as constantes numérias 0, 1 e 2, respectivamente.


Programação Rede / Internet
===========================


Quais ferramentas WWW existem no Python?
----------------------------------------

See the chapters titled Protocolos de Internet e Suporte and Manuseio
de Dados na Internet in the Library Reference Manual.  Python has many
modules that will help you build server-side and client-side web
systems.

Um resumo dos frameworks disponíveis é disponibilizado por Paul Boddie
em https://wiki.python.org/moin/WebProgramming.


Qual módulo devo usar para ajudar na geração do HTML?
-----------------------------------------------------

Você pode encontrar uma coleção de links úteis na página wiki
WebProgramming.


Como envio um e-mail de um script Python?
-----------------------------------------

Use a biblioteca padrão do módulo "smtplib".

Aqui está um remetente de e-mail interativo muito simples. Este método
funcionará em qualquer host que suporte o protocolo SMTP.

   import sys, smtplib

   fromaddr = input("From: ")
   toaddrs  = input("To: ").split(',')
   print("Enter message, end with ^D:")
   msg = ''
   while True:
       line = sys.stdin.readline()
       if not line:
           break
       msg += line

   # The actual mail send
   server = smtplib.SMTP('localhost')
   server.sendmail(fromaddr, toaddrs, msg)
   server.quit()

A Unix-only alternative uses sendmail.  The location of the sendmail
program varies between systems; sometimes it is "/usr/lib/sendmail",
sometimes "/usr/sbin/sendmail".  The sendmail manual page will help
you out.  Here's some sample code:

   import os

   SENDMAIL = "/usr/sbin/sendmail"  # sendmail location
   p = os.popen("%s -t -i" % SENDMAIL, "w")
   p.write("To: receiver@example.com\n")
   p.write("Subject: test\n")
   p.write("\n")  # blank line separating headers from body
   p.write("Some text\n")
   p.write("some more text\n")
   sts = p.close()
   if sts != 0:
       print("Sendmail exit status", sts)


Como evito o bloqueio no método connect() de um soquete?
--------------------------------------------------------

O módulo "select" é normalmente usado para ajudar com E/S assíncrona
nos soquetes.

To prevent the TCP connect from blocking, you can set the socket to
non-blocking mode.  Then when you do the "connect()", you will either
connect immediately (unlikely) or get an exception that contains the
error number as ".errno". "errno.EINPROGRESS" indicates that the
connection is in progress, but hasn't finished yet.  Different OSes
will return different values, so you're going to have to check what's
returned on your system.

You can use the "connect_ex()" method to avoid creating an exception.
It will just return the errno value. To poll, you can call
"connect_ex()" again later -- "0" or "errno.EISCONN" indicate that
you're connected -- or you can pass this socket to "select.select()"
to check if it's writable.

Nota:

  The "asyncio" module provides a general purpose single-threaded and
  concurrent asynchronous library, which can be used for writing non-
  blocking network code. The third-party Twisted library is a popular
  and feature-rich alternative.


Base de Dados
=============


Existem interfaces para banco de dados em Python?
-------------------------------------------------

Sim.

Interfaces to disk-based hashes such as "DBM" and "GDBM" are also
included with standard Python.  There is also the "sqlite3" module,
which provides a lightweight disk-based relational database.

Suporte para a maioria dos bancos de dados relacionais está
disponível. Para mais detalhes, veja a página wiki DatabaseProgramming
para detalhes.


Como você implementa objetos persistentes no Python?
----------------------------------------------------

The "pickle" library module solves this in a very general way (though
you still can't store things like open files, sockets or windows), and
the "shelve" library module uses pickle and (g)dbm to create
persistent mappings containing arbitrary Python objects.


Matemáticos e Numéricos
=======================


Como gero número aleatórios no Python?
--------------------------------------

O módulo padrão "random" implementa um gerador de números aleatórios.
O uso é simples:

   import random
   random.random()

Isso retorna um número flutuante aleatório no intervalo [0, 1).

Existem também muitos outros geradores aleatórios neste módulo, como:

* "randrange(a, b)" escolhe um número inteiro no intervalo entre [a,
  b).

* "uniform(a, b)" escolhe um número float no intervalo [a, b).

* "normalvariate(mean, sdev)" samples the normal (Gaussian)
  distribution.

Algumas funções de nível elevado operam diretamente em sequencia,
como:

* "choice(S)" chooses a random element from a given sequence.

* "shuffle(L)" shuffles a list in-place, i.e. permutes it randomly.

Existe também uma classe "Random" que você pode instanciar para criar
vários geradores de números aleatórios independentes.
