Desbravando Python - Introdução

Iniciando a nossa jornada na linguagem Python.

Nesse post vamos introduzir uma nova idéia chamado de Desbravando Python, que tem o objetivo
de entrar na documentação Python, e abordar de forma simples os seus recursos. Vamos focar na
versão 3.5 da linguagem, então se até lá tiver melhorias e novas funcionalidades, saiba que não
entrará enquanto conseguir passar por toda a referência da biblioteca que oferece. Vai ser um
caminho longo, mas vai ser bem interessante ;)
Poderia partir somente para o básico da ferramenta, mas como uma das destacadas características
do Python é suas baterias incluídas, nada mais interessante que aprofundar e entender todas elas (ou
pelo menos a maioria rs). Abaixo segue a sequência de posts que compõem a série. Essa ordem foi
baseado no índice da documentação, em cada item e/ou subitem, será um post único.
• Funções Built-in
• Parte 01
• Parte 02
• Parte 03
• Parte 04
• Parte 05
• Constantes Built-in
• Tipos Built-in
• Testando valores verdadeiros
• Operações booleanas - and, or, not
• Comparações
• Tipos numéricos
• Tipos iteradores
• Tipos sequenciais
• Tipos de cadeias de caracteres
• Tipos de sequências binárias
• Tipos de set
• Tipos de mapeamento
• Tipos de gerenciamento de contexto
• Outros tipos built-in
• Atributos especiais
• Exceções built-in
• Classes base
• Exceções concretas
• Avisos
• Hierarquia de exceções
• Serviços de processamento de textos
• string - Operações comuns de string
• re - Operações com expressões regulares
• difflib - Auxiliares para computing deltas
• textwrap - Quebras de texto e preenchimento
 • unicodedata - Banco de dados unicode
• stringprep - Preparação de string unicode para Internet
• readline - Interface de linha de comando
• rlcompleter - Função de auto-complete para readline
• Serviços e dados binários
• struct - Tratando valores Python e structs da linguagem C
• codecs - Registro de codecs e classes base
• Tipos de dados
• datetime - Tipos de data e hora básicos
• calendar - Funções gerais de calendários
• collections - Módulo especializado para tipos de dados como dict, list, set e tuple.
• collections.abc - Classes abstratas para containers de dados para collections
• heapq - Módulo para aplicação do algoritmo de heap queue
• bisect - Módulo para aplicação do algoritmo array bisection
• array - Módulo para tratamento eficiente de arrays de valores numéricos
• weakref - Referência weak
• types - Criação de tipos dinamicos e nomes para tipos built-in
• copy - Operações de deep copy e shallow
• pprint - Impressão organizada de dados
• reprlib - Implementação alternativa do repr()
• enum - Suporte para enumerations
• Módulos matemáticos e numéricos
• numbers - Base de classes abstratos para outras operações numéricas
• math - Funções matemáticas
• cmath - Funções matemáticas para número complexos
• decimal - Módulo para suporte de números decimais e flutuantes
• fractions - Números racionais
• random - Geração de números pseudo-aleatórios
• statistics - Funções matemáticas para estatistica
• Módulos para programação funcional
• itertools - Funções para criação de iteradores e loopings eficientes
• functools - Funções de primeira ordem e operações de objetos callable
• operator - Operações padrões como funções
• Acesso de arquivos e diretórios
• pathlib - Caminho do sistema de arquivos orientado a objetos
• os.path - Manipulações comuns de caminho de diretórios
• fileinput - Iteração de linhas sobre multiplos input streams
• stat - Interpretando resultados do stat()
• filecmp - Comparações de arquivos e diretórios
• tempfile - Gerando arquivos e diretórios temporários
• glob - Estilo Unix de padrões para caminho de diretórios
• fnmatch - Padrões de comparação para nome de arquivos Unix
• linecache - Acesso randômico de linhas de textos
• shutil - Operação de arquivos de alto nível
• macpath - Funções de manipulação de caminhos para Mac OS 9
• Persistência de dados
 • pickle - Serialização de objetos Python
• copyreg - Funções para suporte de registros pickle
• shelve - Persistência de objetos Python
• marshal - Serialização de objetos internos do Python
• dbm - Interface para "base de dados" Unix
• sqlite3 - Interface DB-API 2.0 para banco de dados SQLite
• Arquivamento e compressão de dados
• zlib - Compressão compatível com gzip
• gzip - Suporte para arquivos gzip
• bz2 - Suporte para compressão bzip2
• lzma - Compressão usando algoritmo LZMA
• zipfile - Trabalhando com arquivos ZIP
• tarfile - Leitura e escrita de arquivos tar
• Formatos de arquivos
• csv - Leitura e escrita de arquivos CSV
• configparser - Parseamento de arquivos de configuração
• netrc - Processamento de arquivos netrc
• xdrlib - Codificação e Decodificação de dados XDR
• plistlib - Geração e parseamento de arquivos .plist para Mac OS X
• Serviços de criptografia
• hashlib - Tratamento de mensagens e hashes seguras
• hmac - Hashing chaveada para mensagens de autenticação
• Serviços genéricos de Sistemas Operacionais
• os - Interface diversos do Sistema Operacional
• io - Ferramentas base para trabalho com streams
• time - Acesso a tempo e conversões
• argparse - Parseamento de opções e linha de comando, argumentos e subcomandos
• getopt - Parseamento no estilo C para opções de linha de comando
• logging - Facilitador de logging para Python
• logging.config - Configuração de logging
• logging.handlers - Manipulação de logging
• getpass - Entrada de senha portável
• curses - Manipulação de caracteres para displays
• curses.textpad - Widget de entrada de texto para programas cursivos
• curses.ascii - Pilha de painel de extensão para curses
• platform - Acesso aos dados da plataforma
• errno - Padrão de símbolos de sistema errno
• ctypes - Biblioteca de funções externas para Python
• Execução concorrente
• threading - Paralelismo baseado em thread
• multiprocessing - Paralelismo baseado em processo
• O pacote concurrent
• concurrent.futures - Executando tarefas paralelas
• subprocess - Gerenciamento de subprocessos
• sched - Agendamento de eventos
• queue - Classe de file sincronizada
 • dummy-threading - Substituto para o módulo threading
• thread - API baixo nível para threading
• dummy-thread - Substituto para o módulo thread
• Processo de comunicação e rede
• socket - Interface de rede de baixo nível
• ssl - Wrapper TLS/SSL para objetos socket
• select - Módulo par multiplexing de I/O de alto nível
• selectors - Multiplexing de I/O de alto nível
• asyncio - I/O assíncrono, loop de eventos, coroutines e tarefas
• asynchat - Comandos de socket assíncrono para handler de comando/resposta
• signal - Definição de manipulador para eventos assíncronos
• nmap - Suporte de arquivo memory-mapped
• Manipulação de dados da Internet
• email - Pacote para manipulação MIME e e-mail
• json - Codificação e decodificação JSON
• mailcap - Manipulação de arquivos mailcap
• mailbox - Manipulação no mailboxes em vários formatos
• mimetypes - Mapeamento de nome de arquivos para tipos MIME
• base64 - Codificando dados de Base16, Base32, Base64, Base85
• binhex - Codificação e decodificação de arquivos binhex4
• binascii - Conversão entre ASCII e dados binários
• quopri - Codificação e decodificação de dados de extensão de e-mail
• uu - Codificação e decodificação e arquivos uuencode
• Ferramentas de processamento de marcação estruturada (Structured Markup)
• html - Suporte a linguagem HTML
• html.parser - Parseamento de HTML e XHTML
• html.entities - Definições de entidades gerais do HTML
• Módulos de processamento XML
• xml.etree.ElementTree - API do ElementTree XML
• xml.dom - API do Document Object Model (DOM)
• xml.dom.minidom - Implementação mínima do DOM
• xml.dom.pulldom - Suporte para gerar árvore parcial do DOM
• xml.sax - Suporte para parseamento do SAX2
• xml.sax.handler - Classes base para manipulação do SAX
• xml.sax.saxutils - Utilitários SAX
• xml.sax.xmlreader - Interface para parsers XML
• xml.parsers.expat - Parseamento rápido de XML usando Expat
• Protocolo para Internet e Suporte
• webbrowser - Conveniente controlador web-browser
• cgi - Suporte para Common Gateway Interface (CGI)
• cgitb - Gerenciador de Traceback para scripgs CGI
• wsgiref - Implementação e utilitários da referência WSGI
• urllib - Módulo para manipulação de URLs
• urllib.request - Biblioteca para abertura de URLs
• urllib.response - Classe de resposta usado pelo urllib
• urllib.parse - Parseamento de URLs dentro de componentes
 • urllib.error - Classes de exceção disparados pelo urllib.request
• urllib.robotparser - Parseamento para robot.txt
• http - Módulo HTTP
• http.client - Cliente para protocolo HTTP
• ftplib - Cliente do protocolo FTP
• poplib - Cliente do protocolo POP3
• imaplib - Cliente do protocolo IMAP4
• nntplib - Cliente do protocolo NNTP
• smtplib - Cliente do protocolo SMTP
• smtpd - Servidor SMTP
• telnetlib - Cliente Telnet
• uuid - Objetos UUID de acordo com o RFC 4122
• socketserver - Um framework para servidores de rede
• http.server - Servidores HTTP
• http.cookies - Gerenciamento do estado HTTP
• http.cookiejar - Manipulação de cookies para clientes HTTP
• xmlrpc - Servidor XMLRPC e módulos cliente
• xmlrpc.client - Acesso do cliente XML-RPC
• xmlrpc.server - Servidores XML-RPC básicos
• ipaddress - Biblioteca de manipulação IPv4/IPv6
• Serviços de multimídia
• audioop - Manipulação de dados de áudio raw
• aifc - Leitura e escrita de arquivos AIFF e AIFC
• sunau - Leitura e escrita de arquivos Sun AU
• wave - Leitura e escrita de arquivos WAV
• chunk - Leitura de dados do IFF chunked
• colorsys - Conversões entre sistemas de cores
• imghdr - Determinação do tipo de imagem
• sndhdr - Determina o tipo de som
• ossaudiodev - Acesso de dispositivos de áudio OSS compatíveis
• Internacionalização
• gettext - Serviços de Internacionalização multilíngue
• locale - Serviços de Internacionalização
• Frameworks de Programas
• turtle - Gráficos Turtle
• cmd - Suporte a interpretador de comando orientados a linha
• shlex - Análise léxica simples
• Interface gráfica do utilizador com Tk
• tkinter - Interface python com Tcl/Tk
• tkinter.ttk - Widgets tematizados para Tk
• tkinger.tix - Extensão de widgets para Tk
• tkinter.scrolledtext - Widget de texto com scroll
• IDLE - Ambiente integrado de desenvolvimento Python para Aprendizado
• Outros pacotes de interface gráfica do utilizador
• Ferramentas de desenvolvimento
• typing - Suporte para type hints
 • pydoc - Gerador de documentação and sistema de ajuda online
• doctest - Exemplos de testes interativos para Python
• unittest - Framework de testes unitários
• unittest.mock - Biblioteca de objetos "mocados"
• unittest.mock - Primeiros passos
• 2to3 - Tradução do código do Python 2 para 3 automático
• test - Pacote de testes de regressão para Python
• test.support - Utilitários para ambiente de teste Python
• Debugging e Profiling
• bdb - Framework debugger
• faulthandler - Descarregamento de traceback
• pdb - Debugger Python
• Profilers python
• timeit - Mensuração do tempo de execução de pequenos pedaços de código
• trace - Módulo que permite rastrear execução do programa
• tracemalloc - Módulo que permite rastrear blocos de memória alocados pelo Python
• Distribuição e empacotamento do software
• distutils - Construindo e instalando módulos Python
• ensurepip - Inicialização o instalador pip
• venv - Criação de ambientes virtualizados
• zipapp - Módulo que disponibiliza ferramenta para criacao de arquivo zip com
código Python
• Serviços de execução Python
• sys - Funções e parametros específicos do sistemas
• sysconfig - Provêm acesso acesso a informações de configuração do Python
• builtins - Objetos built-in
• --main-- - Ambiente de script alto nível
• warnings - Controle de alertas
• contextlib - Utilitários para declaração de contexto usando with
• abc - Base de classes abstratas
• atexit - Manipulação de saída
• traceback - Imprimir ou recuperar stack traceback
• --future-- - Definições de declarações futuras
• gc - Interface para Garbage Collector
• inspect - Inspeção de objetos vivos
• site - Configurações específica de pesquisa de módulos locais
• fpectl - Controle de exceção de pontos flutuantes
• Interpretadores customizados Python
• code - Classe base do interpretador
• codeop - Código python do compilador
• Importando módulos
• zipimport - Importando módulos de arquivos ZIP
• pkgutil - Extensão de pacote utilitário
• modulefinder - Procura de módulos usados pelo script
• runpy - Localizando e executando módulos Python
• importlib - A implementação do import
 • Serviços da linguagem Python
• parser - Acesso python para parse tree
• ast - Syntax tree abstrato
• symtable - Acesso a tabela de símbolos do compilador
• symbol - Constantes usados com parse trees no Python
• token - Constantes usados com parse trees no Python
• keyword - Testes para palavras-chave do Python
• tokenize - Tokenizador para código-fonte Python
• tabnanny - Detecção de endentação ambígua
• pyclbr - Classe python de suporte a a informações sobre classes, métodos a funções
de alto nível
• py-compile - Compilação do código fonte Python
• compileall - Biblioteca de compilação binária com Python
• dis - Disassembler para bytecodes Python
• pickletools - Ferramenta para desenvolvedores pickle
• Serviços diversos
• formatter - Formatando saídas genéricas
• Serviços específicos para MS Windows
• msilib - Leitura e escrita de arquivos Microsoft Installer
• msvcrt - Rotinas úteis para MS VC++ runtime
• winreg - Acesso aos registros Windows
• winsound - Interface de som para Windows
• Serviços especifícos Unix
• posix - Chamadas de sistema mais comuns para o padrão POSIX
• pwd - Banco de dados de senhas
• spwd - Banco de dados de senhas no estilo shadow
• grp - Banco de dados de grupos
• crypt - Função para chacagem de senhas Unix
• termios - Controle de tty no estilo POSIX
• tty - Funções para controle de terminal
• pty - Utilitários para pseudo-terminais
• fcntl - Chamadas de sistemas de fcntl e ioctl
• pipes - Interface para shell pipelines
• resource - Informações de uso de recursos
• nis - Interface para Sun's NIS (Yellow Pages)
• syslog - Biblioteca de rotinas para acesso ao syslog Unix
• Módulos substituídos
• optparse - Parser de opções para linhas de comando
• imp - Acesso interno ao import

Desbravando Python - Funções Built-in: Parte

01
Nesse post vamos focar nas funções built-in do Python. Serão divididos em cinco partes.
O qué esses built-ins?
Quando for programar módulos e scripts, eles vão estar sempre disponíveis, ou seja, não precisa
fazer importação dos mesmos, porque estão embutidos. Então vamos para elas.
• Função abs()
• Função all()
• Função any()
• Função ascii()
• Função bin()
• Função bool()
• Função bytearray()
• Função bytes()
• Função callable()
• Função chr()
• Função classmethod()
• Função compile()
• Função complex()
• Função delattr()

abs(x)¶
Link: https://docs.python.org/3/library/functions.html#abs
Essa função retorna um valor absoluto de um número. Ele aceita como argumento números inteiros
ou de ponto flutuante. Mas se o valor do argumento for um número complexo, sua magnitude vai
ser retornada.
In [5]:
# Números inteiros
abs(2)

Out[5]:
2

In [6]:
# Números do tipo ponto flutuante
abs(3.1416)

Out[6]:
3.1416

In [10]:
# Números complexos
abs(2j)

Out[10]:
2.0
all(iterable)¶
Link: https://docs.python.org/3/library/functions.html#all Ele retorna True se todos os elementos
de um iterável forem verdadeiros, ou se ele estiver vazio. É equivalente a isso:
In [12]:
def all(iterable):
for element in iterable:
if not element:
return False
return True

Segue um exemplo de como essa função funciona:

In [17]:
# Criando uma nova lista
lista = [1, 2, 3, 4, 5, 6]
all(lista)

Out[17]:
True

In [25]:
# Criando uma lista vazia
lista_vazia = []
all(lista_vazia)

Out[25]:
True

Como pode ver, valores que em operações lógicas, retornam True. No caso de uma lista vazia,
sendo vazia, não tem valores que podem remeter a algum valor falso. Agora no próximo caso é
diferente:
In [26]:
# Criando lista com valores que em operações lógicas retorna sempre falso
lista = [None, 0, '']
all(lista)

Out[26]:
False

E se tivéssemos valores que remetem a resultados verdadeiros e falsos?

In [35]:
# Criando lista com valores que em operações lógicas retornam falso ou
verdadeiro
lista = [None, 0, 1, '', 2, "teste"]
all(lista)

Out[35]:
False

Como pode ver, para retornar verdadeiro todos os valores precisam remetar a True em operações
lógicas.

any(iterable)¶
Link: https://docs.python.org/3/library/functions.html#any
Jà no caso dessa função, se existir algum valor que em operações lógicas retornam verdadeiro, o seu
retorno será também verdadeiro. Ele funcionaria dessa forma:
In [37]:
def any(iterable):
for element in iterable:
if element:
return True
return False

Segue um exemplo:
In [39]:
# Criando uma lista
lista = [1, 2, 3]
any(lista)

Out[39]:
True

In [41]:
# Criando uma lista vazia
lista = []
any(lista)

Out[41]:
False

Como pode ver, como não existe qualquer valor que retorne True, ele irá retornar False. Agora
se existir pelo menos um valor?
In [43]:
# Criando lista
lista = [0, None, False, '', 1]
any(lista)

Out[43]:
True

Temos o valor 1 que retorna True, então a função também vai retornar verdadeiro.
ascii(object)¶
Link: https://docs.python.org/3/library/functions.html#ascii
Como a função repr() que vamos explicar mais a frente, ele retorna um string que contêm uma
representação impressa de um objeto. Mas pode ocorrer de retornar caracteres "não-ASCII"
também.
In [46]:
ascii(str)

Out[46]:
"<class 'str'>"

bin(x)¶
Link: https://docs.python.org/3/library/functions.html#bin
Converte um número inteiro para um string binário. Se x não for um objeto do tipo inteiro, ele deve
implementar o método __index__() para retornar um inteiro.

In [48]:
bin(2)

Out[48]:
'0b10'

In [56]:
class NonInteger(object):
def __index__(self):
return 2

bin(NonInteger())

Out[56]:
'0b10'

class bool(x)¶
Link: https://docs.python.org/3/library/functions.html#bool
Retorna um valor booleano, ou seja um True ou False. O valor de x será convertido para o
procedimento de teste padrão de veracidade, ou melhor, efetuar uma verificação lógica da mesma.
Se x é falso ou for omitido, ele retornará False, caso contrário retornará True.

In [64]:
# Valores que retornam True
var1 = 10
var2 = 'ABC'
var3 = 10.123
print("bool() de var1: ", bool(var1))
print("bool() de var2: ", bool(var2))
print("bool() de var3: ", bool(var3))

bool() de var1: True

bool() de var2: True
bool() de var3: True

In [66]:
# Valores que retornam False
var1 = None
var2 = 0
var3 = ''
var4 = []

print("bool() de var1: ", bool(var1))

print("bool() de var2: ", bool(var2))
print("bool() de var3: ", bool(var3))
print("bool() de var4: ", bool(var4))

bool() de var1: False

bool() de var2: False
bool() de var3: False
bool() de var4: False

O bool() é uma subclasse de int. Nós vamos explicar melhor na seção de Tipos numéricos,
então ignore isso por enquando, mas lembre-se que ela não pode ser estendida:
In [58]:
class NotWorkBoolSubClass(bool):
pass

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-58-b7e68adf59a1> in <module>()
----> 1 class NotWorkBoolSubClass(bool):
2 pass

TypeError: type 'bool' is not an acceptable base type

class bytearray([source[, encoding[, errors]]])¶

Link: https://docs.python.org/3/library/functions.html#bytearray
Ele retorna um novo array de bytes.
A classe bytearray é uma sequência mutável de inteiros em um intervalo de 0 <= x < 256.
In [68]:
# Criando nova lista
lista = [1, 2, 3]
bytearray(lista)

Out[68]:
bytearray(b'\x01\x02\x03')
Parâmetros variados e opcionais podem ser usados para inicializar o array de diferentes maneiras:
1 - Se for um string, você deve declarar sua codificação. bytearray() deve converter sua
string para bytes usando str.encode()

In [71]:
bytearray("Conteudo a ser convertido")

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-71-697e34fada0a> in <module>()
----> 1 bytearray("Conteudo a ser convertido")

TypeError: string argument without an encoding

In [73]:
bytearray("Conteudo a ser convertido", "utf-8")

Out[73]:
bytearray(b'Conteudo a ser convertido')

2 - Se for um inteiro, o array deve conter o tamanho do número e ser inicializado com byte
nulo.
In [81]:
var1 = bytearray(2)
var2 = bytearray(4)

print(var1)
print(var2)

bytearray(b'\x00\x00')
bytearray(b'\x00\x00\x00\x00')

3 - Se for um objeto em conformidade com interface buffer, um buffer somente leitura de um

objeto deve ser usado para inicializar o array de bytes
In [87]:
bytearray(range(10))

Out[87]:
bytearray(b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t')

4 - Se for um iterável, ele deve ser um iterável de inteiros no intervalo e 0 <= x < 256, que são
usados como conteúdos iniciais de um array
In [89]:
values = bytearray([3000, 4000, 5000])

---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-89-c18c149f2bad> in <module>()
----> 1 values = bytearray([3000, 4000, 5000])
ValueError: byte must be in range(0, 256)

5 - Sem algum argumento, o array de tamanho zero é criado.

In [92]:
result = bytearray()

print(result)
print(len(result))

bytearray(b'')
0

bytes([source[, encoding[, errors]]])¶

Link: https://docs.python.org/3/library/functions.html#bytes
Retorna um novo objeto de bytes, que é uma sequência imutável de inteiros em um intervalo de 0
<= x < 256.
In [95]:
bytes(10)

Out[95]:
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'

O bytes é uma versão imutável do bytesarray, e tem os mesmos métodos não-mutávels e a

mesma indexação e comportamento de slicing.
In [98]:
foo = bytearray(5)
foo.pop()

Out[98]:
0

In [100]:
foo = bytes(5)
foo.pop()

---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-100-64564ad0bf45> in <module>()
1 foo = bytes(5)
----> 2 foo.pop()

AttributeError: 'bytes' object has no attribute 'pop'

In [103]:
foo = bytes(5)
foo[2:]
Out[103]:
b'\x00\x00\x00'

callable(object)¶
Link: https://docs.python.org/3/library/functions.html#callable
Ele retorna True se o argumento aparenta ser callable, e é false se não for. Mas é bom lembrar que,
se ele retornar verdadeiro, é possível que a chamada desse objeto falhe, mas se ele for falso,
chamando o objeto nunca poderá ser bem sucedido. Note que classes que são callable é quando elas
possuem o método __call__().

In [105]:
callable(str)

Out[105]:
True

In [107]:
callable(2)

Out[107]:
False

chr(i)¶
Link: https://docs.python.org/3/library/functions.html#chr
Retorna uma representação em string de um caractere a partir do código Unicode, que é o inteiro i.
Segue um exemplo:
In [110]:
print(chr(97))
print(chr(8364))

a
€

O inverso disso é feito pela função ord().

classmethod(function)¶
Link: https://docs.python.org/3/library/functions.html#classmethod
Ele cria um método de classe. Esse método de classe recebe implicitamente a classe como primeiro
argumento, assim como um método de instância recebe a instância pela palavra-chave self. Para
declarar um método de classe faça da seguinte forma:
In [3]:
class C:
@classmethod
def f(cls, arg1, arg2, **kwargs):
pass

O classmethod é um decorador, então pode ser usado para outros métodos que deseja. Ele pode ser
chamado através da classe direito, ou pela instância. Segue um exemplo:
In [11]:
# Criando a classe C
class C:
@classmethod
def f(cls, message):
print("Funcao f() sendo executada: {0}".format(message))

# Executando o método de classe

C.f("Pela classe direta")
C().f("Pela instancia criada")

Funcao f() sendo executada: Pela classe direta

Funcao f() sendo executada: Pela instancia criada

Observação: Métodos de classe são diferentes dos métodos estáticos do C++ ou Java. Se deseja
procurar esse tipo de método veja staticmethod() nesse post.

compile(source, filename, mode, flags=0, _dontinherit=False,

optimize=-1)¶
Link: https://docs.python.org/3/library/functions.html#compile
Compila o código-fonte em uma fonte ou em um objeto AST. Objetos de código podem ser
executados pelos exec() ou eval(). O parâmetro source pode ser um string normal, um string byte ou
um objeto AST.
In [10]:
fonte = "print('Hello World')"

# Cria um objeto code object para ser executado pelo exec futuramente
source = compile(fonte, 'foo.py', 'exec')

O argumento filename deve ser o arquivo que deve conter o código a ser lido. Jà o argumento mode
especifica que tipo de código deve ser compilado, ele pode ser exec se a fonte consiste em uma
sequência de declarações, eval que consistem em uma expressão simples ou single se consistema
em uma simples declaração interativa.
Segue um exemplo:
In [12]:
source = compile("var = 3\nprint('Valor e: {0}'.format(var))", 'modulefoo',
'exec')
exec(source)

Valor e: 3
Como vimos, criamos um objeto que contém o código python, e definimos um exemplo de módulo
chamado de modulefoo. Esse nosso módulo representa um arquivo, mas ele fica na memória para
ser executado pelo exec, como especificamos na função compile. Esse tipo de função é bem vindo
em situações que precisa de um script customizado, como em metaprogramação.

complex([real[, imag]])¶
Link: https://docs.python.org/3/library/functions.html#complex
Retorna um número complexo com o valor real mais imag*1j ou converte uma string ou um número
para número complexo. Se o primeiro parâmetro for um string, ele irá ser interpretado como um
número complexo e a função deve ser chamada sem um segundo parâmetro. Já o segundo
parâmetro, não pode ser uma string, então fique atento a isso.
Cada argumento pode ser qualquer tipo numérico (incluindo o próprio complexo). Se o parâmetro
imag for omitido, o padrão é zero e o construtor serve uma conversão numérica do tipo int e float.
Se ambos os argumentos são omitidos, ele retorna 0j.

In [20]:
# Inserindo um número inteiro, sem imag
complex(2)

Out[20]:
(2+0j)

In [21]:
# Inserindo uma string que tem formato de
# um número complexo
complex('1+2j')

Out[21]:
(1+2j)

In [22]:
# Criando número complexo passando o valor
# e o imag
complex(4, 2)

Out[22]:
(4+2j)

In [24]:
# Criando número complexo sem valor
complex()

Out[24]:
0j
delattr(object, name)¶
Link: https://docs.python.org/3/library/functions.html#delattr
Remove um atributo de um objeto. Faz o contrário do setattr(), que insere atributos em um objeto. O
primeiro parâmetro é o objeto instanciado, e o segundo é uma string que representa o nome de um
dos atributos que a possui.
The string must be the name of one of the object’s attributes. The function deletes the named
attribute, provided the object allows it. For example, delattr(x, 'foobar') is equivalent to del x.foobar.
In [30]:
class ObjectFoo(object):
def __init__(self, *args, **kwargs):
self.attr1 = 'attr_foo'
self.attr2 = 'attr_bar'

def test(self):
print("Foo bar")

foo = ObjectFoo()
print("Atributo foo.attr1: ", foo.attr1)

delattr(foo, 'attr1')
print("Atributo foo.attr1: ", foo.attr1)

Atributo foo.attr1: attr_foo

---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-30-481db05efb93> in <module>()
11
12 delattr(foo, 'attr1')
---> 13 print("Atributo foo.attr1: ", foo.attr1)

AttributeError: 'ObjectFoo' object has no attribute 'attr1'

A função delattr é equivalente a isso:

In [32]:
class ObjectFoo(object):
def __init__(self, *args, **kwargs):
self.attr1 = 'attr_foo'
self.attr2 = 'attr_bar'

def test(self):
print("Foo bar")

foo = ObjectFoo()
print("Atributo foo.attr1: ", foo.attr1)

del foo.attr1
print("Atributo foo.attr1: ", foo.attr1)

Atributo foo.attr1: attr_foo

---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-32-ca6ae27f44ba> in <module>()
 11
12 del foo.attr1
---> 13 print("Atributo foo.attr1: ", foo.attr1)

AttributeError: 'ObjectFoo' object has no attribute 'attr1'

class dict(**kwarg)¶

class dict(mapping, **kwarg)¶

class dict(iterable, **kwarg)¶

Link: https://docs.python.org/3/library/functions.html#func-dict
Cria um novo dicionário. O objeto dict é uma classe de dicionário, mas vamos focar nele no post
de Tipos de Mapeamento - dict.
In [36]:
# Criando dicionario

dict1 = dict(foo=1, bar=2)

dict1

Out[36]:
{'bar': 2, 'foo': 1}

In [37]:
# Criando dicionario a partir de outro e estendendo-o
dict1 = dict(foo=1, bar=2)
other_dict = dict(dict1, key_1="other")
other_dict

Out[37]:
{'bar': 2, 'foo': 1, 'key_1': 'other'}

In [45]:
# Criando um novo dicionário a partir de uma lista
lista = [("foo", 1), ("bar", 1), ("foobar", 1)]
new_dict = dict(lista, other_key="value")
new_dict

Out[45]:
{'bar': 1, 'foo': 1, 'foobar': 1, 'other_key': 'value'}

dir([object])¶
Link: https://docs.python.org/3/library/functions.html#dir
Sem argumento ele lista os nomes no escopo local.
In [47]:
dir()

Out[47]:
['In',
'ObjectFoo',
'Out',
'_',
'_13',
'_14',
'_15',
'_16',
'_17',
'_18',
'_19',
'_20',
'_21',
'_22',
'_23',
'_24',
'_3',
'_34',
'_36',
'_37',
'_4',
'_44',
'_45',
'_46',
'_5',
'__',
'___',
'__builtin__',
'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_i10',
'_i11',
'_i12',
'_i13',
'_i14',
'_i15',
'_i16',
'_i17',
'_i18',
'_i19',
'_i2',
'_i20',
'_i21',
'_i22',
'_i23',
'_i24',
'_i25',
'_i26',
'_i27',
'_i28',
 '_i29',
'_i3',
'_i30',
'_i31',
'_i32',
'_i33',
'_i34',
'_i35',
'_i36',
'_i37',
'_i38',
'_i39',
'_i4',
'_i40',
'_i41',
'_i42',
'_i43',
'_i44',
'_i45',
'_i46',
'_i47',
'_i5',
'_i6',
'_i7',
'_i8',
'_i9',
'_ih',
'_ii',
'_iii',
'_oh',
'_sh',
'dict1',
'exit',
'fonte',
'foo',
'get_ipython',
'lista',
'new_dict',
'other_dict',
'quit',
'source',
'var']

Como pode ver, alguns objetos e classes que criamos nesse post, ele ficou disponível no escopo
local. Agora quando passa um objeto como argumento, ele lista os atributos disponíveis do mesmo.
In [49]:
instance = ObjectFoo()
dir(instance)

Out[49]:
['__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
 '__hash__',
'__init__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'attr1',
'attr2',
'test']

Se o objeto tem um método chamado __dir__(), esse método deve ser chamado e deve retornar
uma lista de atributos. Isto habilita os objetos de implementarem as funções customizadas de
__getattr__() ou __getattribute__(), para ser a forma da função dir() reportar
esses atributos.
Se o objeto não prover __dir__(), a função tenta fazer o melhor para coletar informações sobre
o objeto passado pelo atributo __dict__, se definido, e do tipo do objeto. A lista resultando não é
necessariamente completo, e pode ser impreciso quando ele tem o __getattr__() customizado.

O mecanismo padrão do dir() pode ser diferente com variados tipos de objetos, sendo que mais
uma vez as tentativas de serem dados relevantes do que as mais completas. Assim:
• Se o objeto é um objeto de um módulo, a lista vai conter os nomes dos atributos do módulo;
• Se o objeto é um type ou objeto de classe, a lista vai conter os nomes dos seus atributos, e
recursivamente os atributos das suas classes base;
• Caso contrário, as listas vão conter os nomes dos atributos do objeto, da sua classe e de
forma recurso, vindo das classes base.

Desbravando Python - Funções Built-in: Parte

02
Nesse segundo post de funções built-in, vamos trazer funções em alguns tipos de dados, execução
de expressões Python e muito mais.
• Função dict()
• Função dir()
• Função divmod()
• Função enumerate()
• Função eval()
• Função exec()
• Função filter()
• Função float()
• Função format()
 • Função frozenset()
• Função getattr()
• Função globals()
• Função hasattr()
• Função hash()

class dict(**kwarg)¶

class dict(mapping, **kwarg)¶

class dict(iterable, **kwarg)¶

Link: https://docs.python.org/3/library/functions.html#func-dict
Cria um novo dicionário. O objeto dict é uma classe de dicionário, mas vamos focar nele no post
de Tipos de Mapeamento - dict.
In [36]:
# Criando dicionario

dict1 = dict(foo=1, bar=2)

dict1

Out[36]:
{'bar': 2, 'foo': 1}

In [37]:
# Criando dicionario a partir de outro e estendendo-o
dict1 = dict(foo=1, bar=2)
other_dict = dict(dict1, key_1="other")
other_dict

Out[37]:
{'bar': 2, 'foo': 1, 'key_1': 'other'}

In [45]:
# Criando um novo dicionário a partir de uma lista
lista = [("foo", 1), ("bar", 1), ("foobar", 1)]
new_dict = dict(lista, other_key="value")
new_dict

Out[45]:
{'bar': 1, 'foo': 1, 'foobar': 1, 'other_key': 'value'}

dir([object])¶
Link: https://docs.python.org/3/library/functions.html#dir
Sem argumento ele lista os nomes no escopo local.
In [47]:
dir()

Out[47]:
['In',
'ObjectFoo',
'Out',
'_',
'_13',
'_14',
'_15',
'_16',
'_17',
'_18',
'_19',
'_20',
'_21',
'_22',
'_23',
'_24',
'_3',
'_34',
'_36',
'_37',
'_4',
'_44',
'_45',
'_46',
'_5',
'__',
'___',
'__builtin__',
'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_i10',
'_i11',
'_i12',
'_i13',
'_i14',
'_i15',
'_i16',
'_i17',
'_i18',
'_i19',
'_i2',
'_i20',
'_i21',
'_i22',
'_i23',
'_i24',
'_i25',
'_i26',
'_i27',
'_i28',
 '_i29',
'_i3',
'_i30',
'_i31',
'_i32',
'_i33',
'_i34',
'_i35',
'_i36',
'_i37',
'_i38',
'_i39',
'_i4',
'_i40',
'_i41',
'_i42',
'_i43',
'_i44',
'_i45',
'_i46',
'_i47',
'_i5',
'_i6',
'_i7',
'_i8',
'_i9',
'_ih',
'_ii',
'_iii',
'_oh',
'_sh',
'dict1',
'exit',
'fonte',
'foo',
'get_ipython',
'lista',
'new_dict',
'other_dict',
'quit',
'source',
'var']

Como pode ver, alguns objetos e classes que criamos nesse post, ele ficou disponível no escopo
local. Agora quando passa um objeto como argumento, ele lista os atributos disponíveis do mesmo.
In [49]:
instance = ObjectFoo()
dir(instance)

Out[49]:
['__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
 '__hash__',
'__init__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'attr1',
'attr2',
'test']

Se o objeto tem um método chamado __dir__(), esse método deve ser chamado e deve retornar
uma lista de atributos. Isto habilita os objetos de implementarem as funções customizadas de
__getattr__() ou __getattribute__(), para ser a forma da função dir() reportar
esses atributos.
Se o objeto não prover __dir__(), a função tenta fazer o melhor para coletar informações sobre
o objeto passado pelo atributo __dict__, se definido, e do tipo do objeto. A lista resultando não é
necessariamente completo, e pode ser impreciso quando ele tem o __getattr__() customizado.

O mecanismo padrão do dir() pode ser diferente com variados tipos de objetos, sendo que mais
uma vez as tentativas de serem dados relevantes do que as mais completas. Assim:
• Se o objeto é um objeto de um módulo, a lista vai conter os nomes dos atributos do módulo;
• Se o objeto é um type ou objeto de classe, a lista vai conter os nomes dos seus atributos, e
recursivamente os atributos das suas classes base;
• Caso contrário, as listas vão conter os nomes dos atributos do objeto, da sua classe e de
forma recurso, vindo das classes base.

divmod(a, b)¶
Link: https://docs.python.org/3/library/functions.html#divmod
Pega dois argumentos que são números não complexos, e retorna um par de números que consistem
no quociente e o resto de uma divisão inteira.
Com tipos de operandos misturados, as regras para operadores aritméticos binários são aplicados.
Para inteiros, o resultado é o mesmo que (a // b, a % b). Para números de ponto flutuante o
resultado é (q, a % b), onde q é usualmente math.floor(a / b), mas pode ser menos que
um. Em qualquer caso, q * b + a % b está muito perto de a, se a % b for diferente de zero e
que tem o mesmo sinal como b, e 0 <= abs(a % b) < abs(b).
In [2]:
divmod(2, 2)

Out[2]:
(1, 0)

In [4]:
divmod (2, 2.222)

Out[4]:
(0.0, 2.0)

In [6]:
divmod(0, 2)

Out[6]:
(0, 0)

enumerate(iterable, start=0)¶
Link: https://docs.python.org/3/library/functions.html#enumerate
Retorna um objeto enumerate. O argumento iterable deve ser uma sequência, um iterator, ou outro
objeto que suporte iteração. O método __next__() do iterador retornado pelo enumerate()
retorna uma tupla, contendo um contador (do parâmetro start é do padrão 0) e os valores obtidos
por ir percorrendo sobre o iterador.
In [8]:
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))

Out[8]:
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

In [10]:
list(enumerate(seasons, start=1))

Out[10]:
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Essa função é o equivalente a isso:

In [12]:
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1

eval(expression, globals=None, locals=None)¶

Link: https://docs.python.org/3/library/functions.html#eval
Essa função é usado para executar expressões python que são passados via string para o argumento
expression. Caso queria passar variaveis globais e locais é só passar um dicionário para os
argumentos globals e locals respectivamente.
In [20]:
x = 1
eval('x+1')

Out[20]:
2

Se o dicionário local for omitido, o padrão será o dicionário global. Se ambos os argumentos forem
omitidos, a expressão será executada no ambiente aonde o eval() foi chamado. O valor de
retorno é o resultado da expressão avaliada. Erros de sintaxe são reportados como exceções.
Essa função pode ser usado para executar objetos code (como criamos pela função compile()),
assim, passando esse tipo de objeto vai ser substituido pela string que usamos antes. Se o objeto
code foi compilado usando o argumento 'exec', o valor de retorno da função eval() será None.

exec(object[, globals[, locals]])¶

Link: https://docs.python.org/3/library/functions.html#exec
Essa função suporta execução dinâmica de código Python. O parâmetro object deve ser um string
ou um objeto code. Se for um string, ele é parseado como uma declação python em que é executado
(a não ser que ocorra um erro de sintaxe). Se for um objeto code, ele é simplesmente executado. Em
todos os casos, o código executado é esperado que seja válido para uma entrada de arquivo. Tenha
cuidado com as declaração return e yield, que não pode ser usados fora das definições da
função, mesmo no contexto do código passado para o exec(). O valor retornado é None.

Em todos os casos, se as partes opcionais foram omitidos, o código é executado no escopo atual. Se
somente for passado valores globais, ele deve ser um ducionário, que deve ser usado tanto para
variáveis globais e locais. Se for passado globais e locals, eles serão usados para o que foi definidos.
Lembre-se que globais e locais a nível de módulo é o mesmo dicionário. Se o exec retorna dois
objetos separados como globais e locais, o código deve ser executado como se tivesse sido
incorporado em uma definição de classe.
Se o dicionário de globais não tiver um valor para a chave __builtins__, uma referência para o
dicionário do módulo built-in é inserido. Dessa forma, você pode controlar os builtins que são
disponíveis para serem executados no código, inserido seu próprio dicionário __builtins__
dentro de globals antes de passar para o exec().

In [75]:
exec('x+1')
print(x)

In [77]:
code = """
def ola_mundo():
print('Ola Mundo!')
"""
exec(code)

ola_mundo()

Ola Mundo!

filter(function, iterable)¶
Link: https://docs.python.org/3/library/functions.html#filter
Constrói um iterador em cima dos elementos do parâmetro iterable, para que retorne True. Esse
iterável deve ser uma sequência, um container que suporta iteração ou um iterador simplesmente. Se
o parâmetro function for None, a função de indentidade é assumida, ou seja, todos os elementos
que são iteráveis irá retornar False.

In [25]:
def eh_par(value):
if value % 2 == 0:
return True
return False

numeros = [0, 1, 2, 3, 4]
resultado = filter(eh_par, numeros)

Note que o filter(function, iterable) é equivalente uma expressão geradora item

for item in iterable if function(item)) se a função não for None. Caso
contrário equivale a (item for item in iterable if item), em caso de que a função
for None.

In [32]:
numeros = [0, 1, 2, 3, 4]
resultado = filter(lambda num: True if num % 2 == 0 else False, numeros)

numeros_pares = [numero for numero in resultado]

print(numeros_pares)

[0, 2, 4]

class float([x])¶
Link: https://docs.python.org/3/library/functions.html#float
Retorna um numéro de ponto flutuante construído por um número ou string enviado ao parâmetro x.
Se o argumento é um string, ele deve conter um número decimal, opcionalmente precedido por um
sinal, e opcionalmente embarcado com espaços. O sinal opcional deve ser + ou -; um sinal + não
tem efeito no valor produzido. O argumento pode ter um string representando NaN (not-a-number),
ou um positivo e negativo infinito. Mais precisamente, a entrada deve estar em conformidado com a
gramática abaixo:
sign ::= "+" | "-"
infinity ::= "Infinity" | "inf"
nan ::= "nan"
numeric_value ::= floatnumber | infinity | nan
numeric_string ::= [sign] numeric_value

Aqui o floatnumber é uma forma literal do python para pontos flufuantes, descritos em Pontos
flutuantes literais. Caso não seja significante, então poe exemplo, "inf", "Inf" e "iNfINity" são todos
grafias aceitáveis para infinito positivo.
Por outro lado, se o argumento é um inteiro ou um número de ponto flutuantes, esse número do tipo
float com o mesmo valor (com ponto de precisão do Python) é retornado. Se o argumento é fora do
intervalo do tipo float da linguagem, um OverflowError deve ser disparado.

Para objetos comuns Python, o nosso objeto x por exemplo, ao ser usado em float(x) vai ser
delegado para a função especial __float__().

Se não tiver nenhum argumento para a função, é retornado o valor 0.0.

Segue alguns exemplos:
In [36]:
print("float('+1.23'): ", float('+1.23'))

print("float(' -12345\\n'): ", float(' -12345\n'))

print("float('1e-003'): ", float('1e-003'))

print("float('+1E6'): ", float('+1E6'))

print("float('+Infinity'): ", float('+Infinity'))

print("float('-Infinity'): ", float('-Infinity'))

float('+1.23'): 1.23
float(' -12345\n'): -12345.0
float('1e-003'): 0.001
float('+1E6'): 1000000.0
float('+Infinity'): inf
float('-Infinity'): -inf

format(value [, format__spec])¶
Link: https://docs.python.org/3/library/functions.html#format
Converte o parâmetro value para um formato representável, controlado parâmetro format_spec.
A intepretação desse formato vai depender do tipo de valor passado para o primeiro parâmetro. No
entanto possui uma sintaxe de formato padrão que é usado pelas funções built-in e que deve ser
levado em consideração. Veja mais sobre eles na seção Mini-linguagem de especificação de
formatos.
Segue alguns exemplos:
In [47]:
print("Número inteiro: ", format(2))
print("Número de ponto flutuante: ", format(2, 'f'))

print("Número binário: ", format(4, 'b'))

print("Número octal: ", format(9, 'o'))

print("Número hexadecimal: ", format(12, 'X'))

Número inteiro: 2
Número de ponto flutuante: 2.000000
Número binário: 100
Número octal: 11
Número hexadecimal: C

class frozenset([iterable])¶
Link: https://docs.python.org/3/library/functions.html#func-frozenset
Retorna um novo objeto frozenset, opcionalmente com elementos retirados do parâmetro
iterable. O frozenset é uma classe built-in. Para mais informações é explicado veja frozenset e
Tipos Set - set, frozen, que terá o link em breve.

getattr(object, name[, default])¶

Link: https://docs.python.org/3/library/functions.html#getattr
Retorna o valor de um atributo nomedo em um objeto que foi passado no parâmetro object. O
atributo name é um string que representa o nome desse atributo. Caso esse atributo não exista, é
retornado o valor padrão definido no parâmetro default, caso contrário um AttributeError é
disparado. O getattr(foo, 'x') é equivalente a foo.x. Veja o exemplo abaixo:

In [50]:
class Foo(object):
def __init__(self):
self.attrA = 'Foo'
self.attrB = 'Bar'

foo = Foo()
getattr(foo, 'attrA')

Out[50]:
'Foo'

In [55]:
# Passando o valor default em caso de não encontrar
# o atributo

getattr(foo, 'attrC', 'Nenhum atributo encontrado')

Out[55]:
'Nenhum atributo encontrado'

In [57]:
# Se o atributo não for encontrado, como
# não foi passado um valor default, a exceção
# AttributeError será disparado.

getattr(foo, 'attrX')

---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-57-2a88621c904c> in <module>()
3 # AttributeError será disparado.
4
----> 5 getattr(foo, 'attrX')

AttributeError: 'Foo' object has no attribute 'attrX'

globals()¶
Link: https://docs.python.org/3/library/functions.html#globals
Retorna um dicionário representando a tabela de símbolos globais que existem. Será sempre um
dicionário de símbolos do módulo atual (dentro de uma função ou método, esse é o módulo onde ele
é definido, não o módulo que é chamado).

hasattr(object, name)¶
Link: https://docs.python.org/3/library/functions.html#hasattr
Verifica se determinado atributo name existe no objeto object. Os argumentos devem ser um objeto
e uma string, respectivamente. Como falado, se encontrado o retorno da função é True, e caso
contrário é retornado False.

In [60]:
hasattr(foo, 'attrA')

Out[60]:
True

In [62]:
hasattr(foo, 'otherAttr')

Out[62]:
False

hash(object)¶
Link: https://docs.python.org/3/library/functions.html#hash
Retorna o valor hash do objeto passado no parâmetro object. O valor hash são inteiros e eles são
usados para facilmente comparar chaves de dicionários durante uma análise do dicionário. Valores
numéricos que comparam sua igualdade são do mesmo valor hash (mesmo se eles são de tipos
diferentes, como o caso de 1 e 1.0).
In [67]:
print("hash(1): ", hash(1))

print("hash(1.000): ", hash(1.000))

print("hash(foo)", hash(foo))

hash(1): 1
hash(1.000): 1
hash(foo) -9223363277595646492