Python, arquivos e pastas

Quase sempre um programa de computador precisa recuperar dados ou informações previamente existentes, processá-los de algum modo e retornar um resultado que deve ficar armazenado para uso futuro. Esses dados podem ser lidos em papel impresso ou digitados pelo usuário. O resultado final também pode ser impresso ou exibido na tela. Mas, como maior frequência a informação inicial e final é lida e gravada em disco, em arquivos de texto ou binários, planilhas e bancos de dados (entre outros muitos formatos).

O objeto arquivo (file)

Abrir e ler um arquivo:

No Python existem diversas funções no módulo básico para abrir, manipular e escrever em arquivos. Um arquivo aberto é um objeto que pode ser atribuído à uma variável e, por meio dessa variável, as propriedades e métodos do objeto podem ser acessadas. A função open() estabelece uma conexão com o arquivo no disco.

obj = open('caminho_para_arquivo', modo)

Os modos são listados abaixo.

Por ex., suponha que existe na pasta de trabalho um arquivo com nome alunos.txt contendo informações sobre alunos de um curso. Seu conteúdo pode ser exibido da seguinte forma:

» objeto_arquivo = open('alunos.txt', 'r')
» texto = objeto_arquivo.read()
» objeto_arquivo.close()
» print(texto)

↳ id, nome     , cidade         , idade , nota
↳ 10, Pedro    , São Paulo      , 34    , 83.0
↳ 11, Maria    , São Paulo      , 23    , 59.0
↳ 12, Janaina  , Rio de Janeiro , 32    , 86.0
↳ 13, Wong     , Brasília       , 43    , 89.0
↳ 14, Roberto  , Salvador       , 38    , 98.0
↳ 15, Marco    , Curitiba       , 31    , 61.0
↳ 16, Paula    , Belo Horizonte , 34    , 44.0


O método read() lê o arquivo inteiro e o retorna para a variável texto que passa a conter um vínculo com o arquivo no disco.

Após o uso o arquivo deve ser fechado com o método close(). O fechamento do objeto libera recursos da máquina, permite que o arquivo seja acessado por outro bloco de código. Em alguns casos alterações feitas ao arquivo no programa podem não ser gravadas em disco até que eles seja fechado. Um problema técnico, como a falta de energia, pode ocasionar em perda de dados.

Estritamente dizendo o mais adequado para lidar com arquivos seria um bloco de código do seguinte tipo.

» try:
»     f = open("data.txt", "w")
»     # código com as operações necessárias usando o arquivo f
» finally:
»     f.close()

Isso evita a possibilidade de que algum erro faça com que o comando de fechamento seja pulado. Uma forma mais compacta de escrever isso, e que evita o problema citado, usa o comando with. No Python a declaração with é usada para manipular exceções e tornar o código mais enxuto e de fácil leitura.

# exemplo de código usando with
» with open('data.txt', 'r') as f:
»     # codigo usando o arquivo f
»     # (pronto!)

O fechamento nesse caso é automático. O comando with facilita a escrita do código que envolve recursos que devem ser finalizados. Essa finalização significa liberação de recursos de memória e garantia de que erros desnecessários sejam introduzidos.

Ler linhas de um arquivo:

Também é possível ler o arquivo com readlines() que retorna uma lista de linhas que podem ser percorridas depois.

# todas as linhas do arquivo são impressas dessa forma    
» with open('alunos.txt', 'r') as f:
»     linhas = f.readlines()
» for linha in linhas:
»     print(linha, end ='')
# as linhas acima são impressas (mas foram aqui omitidas)

# como readlines() retorna uma lista de linhas
# ele pode ser usado para contar quantas linhas existem no arquivo
» with open('alunos.txt', 'r') as f:
»     print(len(f.readlines()))
↳ 8    

Uma forma alternativa consiste em ler o arquivo uma linha de cada vez, processando as linhas na medida em que são lidas.

» with open('alunos.txt', 'r') as f:
»     print('1-', f.readline(), end='')
»     print('2-', f.readline(), end='')

↳ 1- id, nome     , cidade         , idade , nota
↳ 2- 10, Pedro    , São Paulo      , 34    , 83.0

Uma linha é o texto que termina em um sinal de quebra linha.

Quebras de linhas (end of line, EOL) são caracteres especiais inseridos em arquivos para indicar o final de uma linha e o início de outra. Esses caracateres não são vistos nos editores mas marcam os finais de cada linha. Alimentação de linha (line feed, LF) e retorno de carro (carriage return, CR) são usados, dependendo do sistema operacional. LF é representado por \n, 0x0A em hexadecimal ou 10 decimal. CR é representado por \r, 0x0D em hexadecimal ou 13 decimal. O Linux (e outros sistemas derivados do UNIX) usa \n. O Windows usa \r\n e o OSX usa \r.

A cada uso do método .readline() uma nova linha é recuperada, até o fim do arquivo. A operação pode ser repetida até que uma string nula seja retornada. Ao final o iterador fica vazio e deve ser lido novamente caso outra iteração seja necessária. Com essa forma de leitura as linhas são lidas uma de cada vez e a requisição de memória é menor.

» with open('alunos.txt', 'r') as f:
»     while True:
»         linha = f.readline()
»         if not linha:
»             break
»         print(linha, end='')

# Observe que readline() é o método default do objeto arquivo.
# Isso significa que o mesmo resultado pode ser obtido com as linhas

» with open('alunos.txt', 'r') as f:
»     for linha in f:
»         print(linha, end='')


Em ambos os casos o arquivo dos alunos é exibido. O teste de final de arquivo pode ser excluído porque o iterador se esgota ao final e o laço for é abandonado.

Observe que a linha if not linha: tem o mesmo efeito que if linha == '':. Ao final da iteração uma string vazia é retornada e strings vazias são avaliadas como False em testes booleanos.

Gravar em um arquivo:

No código abaixo um arquivo é aberto para gravação.

» texto = (
»     'Texto a ser gravado em disco\n'
»     'pode conter quantas linhas se desejar\n'
»     'novas linhas são inseridas com \'newline\''
» )
» arquivo = open('teste_gravar.txt', 'w')
» arquivo.write(texto)
» arquivo.close()

# a mesma operação usando with
» with open('teste_gravar.txt', 'w') as arquivo:
»     arquivo.write(texto)

Após a execução dessas linhas um arquivo teste_gravar.txt será encontrado na pasta de trabalho. No texto a ser inserido novas linhas são criadas após o sinal de newline (\n).

Gravação incremental em um arquivo:

Para acrescentar linhas ao arquivo, sem apagar as já existentes, usamos o parâmetro ‘a’ (de append):

# para acrescentar um novo aluno ao arquivo alunos.txt:
» novo_aluno = '17, Ana      , Belo Horizonte , 21    , 78.5\n'
» with open('alunos.txt', 'a') as f:
»     f.write(novo_aluno)
# a nova aluna, Ana e seus dados, fica acrescentada ao final do texto.

Observe que write() não insere quebras de linha automaticamente. Por isso terminamos a linha com o sinal de nova linha \n. Dessa forma novo texto inserido posteriormente já se inicia em linha própria.

Outra forma de iterar sobre as linhas de um arquivo consiste em tratar o objeto de arquivo o como um iterador em um laço for. O ex. mostra que readlines() retorna um iterável que pode ser percorrido dentro de laço for:

» with open('alunos.txt', 'r') as f:
»     for linha in f.readlines():
»         print(linha)
# o arquivo inteiro é exibido (mas omitido aqui)

Todo o texto lido em um arquivo dessa forma é uma string, mesmo que composto de dígitos. Se inteiros e números de ponto flutuante estão no texto e devem ser usados como números, por ex. para um cálculo, eles devem ser convertidos usando-se as conversões int() e float(), respectivamente.

Em exemplo disso segue abaixo. Usamos o arquivo dos alunos para ler as idades e as notas, que são convertidas para inteiro e flutuante, respectivamente.

» with open('alunos.txt', 'r') as f:
»     maior, nota_media, n = 0, 0, 0
»     f.readline()
»     for linha in f:
»         palavras = linha.split(',')
»         n +=1
»         nota_media += float(palavras[4])
»         idade = int(palavras[3])
»         if idade > maior:
»             maior = idade
»             nome = palavras[1]
» print('%s é o aluno mais velho, com %d anos.' % (nome.strip(), maior))
» print('A nota média entre %d alunos é %2.1f' % (n, nota_media/n))

↳ Wong é o aluno mais velho, com 43 anos.
↳ A nota média entre 7 alunos é 74.3

O método split(',') quebra a linhas em palavras, partindo cada uma nas vígulas e retornando uma lista. palavra[3] é a idade, palavra[4] a nota. A maior idade e o nome do aluno mais velho são armazenados dentro do teste final.

Propriedades de arquivos e leitura incremental:

Para os exemplos abaixo um novo arquivo com 3 linhas é gravado.

» lista = ['Esta é a linha 1\n',
»          'Esta é a linha 2\n',
»          'Esta é a linha 3\n'
»         ]
» with open('novo.txt', 'w') as f:
»     f.writelines(lista)
» with open('novo.txt', 'r') as f:
» with open('novo.txt', 'r') as f:
»     print(f.read())

↳ Esta é a linha 1
↳ Esta é a linha 2
↳ Esta é a linha 3

Um objeto de arquivo tem diversas propriedades, entre elas file.name, o nome do arquivo, file.closed que é True se o arquivo está fechado (embora a variável continue apontando para o objeto), e file.mode que contém o modo em que ele foi aberto.

» with open('novo.txt', 'r') as f:
»     info = 'O arquivo "'+ f.name + '" está ' + ('fechado' if f.closed else 'aberto')
»     info += ' no modo %s' % f.mode
»     print(info)
» print('Agora o arquivo está ' + ('fechado' if f.closed else 'aberto'))

↳ O arquivo "novo.txt" está aberto no modo r
↳ Agora o arquivo está fechado

Leitura incremental de um arquivo:

A abertura de um arquivo com muitas linhas, ou uma linha muito longa sem quebras pode esgotar os recursos de memória de seu computador. Para evitar esse problema tanto readline ou readlines aceitam um argumento opcional estabelecendo quanto dado deve ser lido de cada vez. É possível ler um arquivo de modo incremental com arquivo.read(n) onde n é o número de bytes lidos (que resulta em um caracter simples). Como a primeira linha contém 16 caracteres (‘Esta é a linha 1’) ela é esgotada em duas iterações.

» with open('novo.txt', 'r') as f:
»     print(f.read(8))
»     print(f.read(8))

↳ Esta é a
↳  linha 1

Após as 2 leituras no código anterior o ponteiro (cursor) está posicionado sobre o byte 17. Essa posição pode ser lida e alterada, usando-se os métodos tell() e seek(). Nas linhas abaixo 17 bytes são lidos e impressos na linha 1. A linha 2 mostra a posição do ponteiro, 18. seek()

» with open('linhas.txt', 'r') as f:
»     print('1 : ', f.read(17), end='')
»     print('2 : ', f.tell())
»     f.seek(0, 0)
»     print('3 : ', f.read(17), end='')
»     f.seek(36, 0)
»     print('4 : ',  f.read(17), end='')

↳ 1 :  Esta é a linha 1
↳ 2 :  18
↳ 3 :  Esta é a linha 1
↳ 4 :  Esta é a linha 3

No exemplo seguinte a primeira linha é lida inteira e apenas 10 caracteres da segunda linha.

» with open('alunos.txt', 'r') as f:
»     txt1 = f.readline()
»     txt2 = f.readline(10)
» print(txt1, end = '')
» print(txt2)

↳ id, nome     , cidade         , idade , nota
↳ 10, Pedro    , São Paulo

Métodos de arquivo

Método Descrição
open(arquivo, mode) Abre o arquivo (descrição dos parâmetros abaixo)

Os seguintes parâmetros são usados com open():

Parâmetro Descrição
arquivo caminho completo e nome do arquivo
mode Uma string que define em que modo o arquivo será aberto

O parâmetro mode pode ser:

Parâmetro Descrição
r para leitura – O ponteiro é colocado no início do arquivo. Default.
r+ para leitura e gravação. O ponteiro fica no início do arquivo.
w apenas para gravação. Substitui arquivo existente, cria novo se o arquivo não existir.
w+ escrita e leitura. Substitui arquivo existente, cria novo se arquivo não existir.
rb para leitura em formato binário. O ponteiro fica no início do arquivo.
rb+ para leitura e escrita em formato binário.
wb+ para escrita e leitura em formato binário. Substitui o arquivo existente. Cria novo se não existir.
a para anexar. Conteúdo existente fica inalterado e o ponteiro fica no final do arquivo. Cria novo se não existir.
ab um arquivo para anexar em formato binário. O ponteiro fica no final do arquivo. Cria novo se não existir.
a+ para anexar e ler. O ponteiro fica no final do arquivo, se arquivo existir. Cria novo se não existir.
ab+ anexar e ler em formato binário. O ponteiro no final do arquivo. Cria novo se não existir.
x cria novo arquivo lançando erro se já existir.

São métodos do objeto file:

Método Descrição
close() fecha o arquivo; sem efeito se arq. já está fechado
detach() retorna o fluxo bruto separado do buffer
fileno() retorna número inteiro diferente para cada arquivo aberto
flush() descarrega no disco as alterações no buffer
isatty() retorna True se o fluxo de arquivo é interativo
next(arquivo) itera sobre arquivo, lançando erro no final
read() retorna o conteúdo do arquivo
readable() retorna True se o fluxo do arquivo pode ser lido
readline() retorna uma única linha do arquivo
readlines() retorna lista com todas as linhas do arquivo
search() localiza item no arquivo e retorna sua posição
searchable() retorna True se o arquivo é pesquisável, por ex. com seek()
tell() retorna a posição atual do arquivo
truncate([tamanho]) redimensiona (truncando) o arquivo para um tamanho especificado
writable() retorna True se o arquivo pode receber gravações
write() grava a string especificada no arquivo
writelines() escreve a sequencia no arquivo. Qualquer objeto iterável composto por strings pode ser usado

Módulo os


Vimos que existem diversas funções e outros objetos no módulo básico que são carregados juntamente com o próprio Python. No entanto muitos outros módulos podem sem anexados no código, inclusive módulos na chamada biblioteca padrão. Módulos podem ser escritos pelo usuário e importados em seu código ou compartilhados. Além disso, outros módulos podem ser instalados, inclusive desenvolvido por terceiros.

De particular interesse para a manipulação de arquivos é o módulo os que contém as funcões básicas de interação com o sistema operacional. Para habilitar o uso de módulos instalados usamos import nome_do_modulo.

Listar pastas e arquivos:

Por exemplo, após a importação de os podemos usar o método os.listdir(pasta) que retorna uma lista com o conteúdo da pasta especificada.

» import os
» pasta ='/home/guilherme/Projetos/Python'
» lista_arquivos = os.listdir(pasta)
» print(lista_arquivos)
↳ ['arquivos', 'wallpaper.py', 'turtle.py', 'numpy_02.py', 'NLP', 'output', 'osDir.py',
↳  'lerShelfFile.py', 'guessNumber.py', ...]

Embora esse método ainda esteja disponível, no Python 3.5 foi inserido uma nova forma de obter esse resultado por meio de os.scandir() que retorna um iterável. Os elementos desse iterável possuem diversas propriedades, entre elas name, usada para recuperar o nome do arquivo ou pasta.

» arquivos = os.scandir(pasta)
» for t in arquivos:
»     print(t.name)
» arquivos
↳ wallpaper.py
↳ turtle.py
↳ numpy_02.py
↳ NLP
↳ output
↳ osDir.py
↳ ...

Observação (Windows): Como o caracter \ tem significado especial (escape) no Python é necessário escrever caminhos no Windows de uma forma especial, de uma das duas formas:

» caminho = r'C:\Windows\Temp'
# ou
» caminho = 'C:\\Windows\\Temp'

No código abaixo usamos os.path.join(local, t) que faz a concatenação correta do caminho com o nome do arquivo, agindo de forma diferente de acordo com o sistema operacional. O método os.path.split age de forma inversa, retornando uma tupla que contém a caminho e o nome do arquivo. Depois de extraído o nome do arquivo podemos obter uma tupla com nome separado da extensão usando os.path.splitext.

# como funciona os.path.join (no linux ou OSX)
» os.path.join('caminho_completo', 'nome_do_arquivo')
↳ 'caminho_completo/nome_do_arquivo'

# separando caminho do arquivo
» os.path.split('/home/usuario/Documentos/Artigo.txt')
↳ ('/home/usuario/Documentos', 'Artigo.txt')

# separando a extensão
» os.path.splitext('image.jpeg')
↳ ('image', '.jpeg')

# no windows uma string diferente seria retornada com join
» os.path.join('caminho_completo', 'nome_do_arquivo')
↳ 'caminho_completo\\nome_do_arquivo'

Filtrar pastas e arquivos:

Para investigar se o elemento retornado por listdir é um arquivo podemos usar os.path.isfile(), e os.path.isdir() para pastas (diretórios).

# para filtrar os arquivos
» local = '.'
» for t in os.listdir(local):
»     if os.path.isfile(os.path.join(local, t)):
»         print(t)
↳ arquivo001.txt
↳ arquivo002.txt
↳ jupyter001.ipynb
↳ teste.csv

# para filtrar as pastas
» for t in os.listdir(local):
»     if os.path.isdir(os.path.join(local, t)):
»         print(t)
↳ .ipynb_checkpoints
↳ dados

# para listar arquivos dentro da pasta 'dados'
» local = './dados'
» for t in os.listdir(local):
»     if os.path.isfile(os.path.join(local, t)):
»         print(t)
↳ nums.csv
↳ alunos.pkl

A mesma operação feita usando os.scandir()

# usando scandir
» local = '.'
» with os.scandir(local) as arqs:
»     for arq in arqs:
»         if arq.is_file():
»             print('arquivo:', arq.name)
»         elif arq.is_dir():
»             print('pasta:  ', arq.name)
↳ arquivo: pandas001.ipynb
↳ arquivo: python001.ipynb
↳ arquivo: teste_gravar
↳ arquivo: alunos.txt
↳ arquivo: teste_novo.csv
↳ pasta:   .ipynb_checkpoints
↳ arquivo: teste.py
↳ arquivo: alunos.csv
↳ pasta:   dados
↳ ...            

Claro que essa mesma lista pode ser obtida através de uma compreensão de lista, o que ilustra mais uma vez o poder de concisão dessa construção.

# para arquivos
» lst_arquivos = [t.name for t in os.scandir(local) if t.is_file()]
» lst_arquivos
↳ [pandas001.ipynb, python001.ipynb, teste_gravar, alunos.txt,
↳  teste_novo.csv, teste.py, alunos.csv]

# para as pastas
» [t.name for t in os.scandir(local) if t.is_dir()]
↳ ['.ipynb_checkpoints', 'dados']

A recuperação dos nomes dos arquivos, associada a testes de string com esses nomes, permite uma filtragem mais específica de arquivos retornados. No exemplo abaixo usamos .endswith para verificar se os arquivos possuem uma extensão determinada (no caso ‘.csv’). No segundo exemplo usamos compreensão de lista e testamos a substring após o último ponto.

# usando .endswith()
» print('Arquivos com extensão csv:')
» with os.scandir(local) as arqs:
»     for arq in arqs:
»         if arq.is_file() and  arq.name.endswith('.csv'):
»             print(arq.name)
Arquivos com extensão csv:
↳ teste_novo.csv
↳ alunos.csv

# alternativamente, usando compreensão de lista e .split('.')
» [arq.name for arq in os.scandir(local) if arq.is_file() if arq.name.split('.')[-1]=='txt']
↳ ['alunos.txt']

O método os.scandir() não recupera apenas os nomes dos arquivos. Cada objeto do ScandirIterator possue o método .stat() que retorna informações sobre o arquivo ou pasta ao qual se refere, como tamanho do arquivo. O atributo st_mtime, por ex., contém a hora da última alteração.

No exemplo seguinte fazemos uma iteração sobre os arquivos e pastas em local e imprimimos a data de sua última alteração.

# atributo de arquivos: tempo desde última alteração
» with os.scandir(local) as arquivos:
»     for arq in arquivos:
»         info = arq.stat()
»         print(info.st_mtime)
↳ 1612654770.8688447
↳ 1615833776.4532673
↳ 1611327215.6848917
↳ ...

O retorno é dado em segundos desde a época, uma medida de tempo também chamada de Unix time que consiste no número de segundos decorridos desde Zero Horas do dia 1 de Janeiro de 1970 (UTC, longitude 0°) e pode ser convertido em uma data mais legível através de diversas funções de tratamento de datas e horas.

No código seguinte lemos os arquivos na pasta local e retornamos seu nome e data de última modificação, convertida em forma mais legível usano uma função do módulo datetime. Veremos mais tarde outras funcionalidades desse módulo.

» from datetime import datetime

» def converter_data(timestamp):
»     d = datetime.utcfromtimestamp(timestamp)
»     return d.strftime('%d/%m/%Y')

» def ler_arquivos():
»     arquivos = os.scandir(local)
»     for arq in arquivos:
»         if arq.is_file():
»             info = arq.stat()
»             print(f'{arq.name}\t\t Modificado em: {converter_data(info.st_mtime)}')

↳ Pandas001.ipynb      Modificado em: 06/02/2021
↳ Python001.ipynb      Modificado em: 15/03/2021
↳ teste_gravar         Modificado em: 15/03/2021
↳ alunos.txt           Modificado em: 16/03/2021
↳ teste_novo.csv       Modificado em: 16/11/2020
↳ ...

Os argumentos passados para strftime() são: %d o dia do mês, %m o número do mês e %Y o ano, com 4 dígitos. Várias outras formatações são possíveis.

O módulo os contém os métodos os.getcwd() para ler a pasta ativa no momento, e os.chdir(‘nova_pasta’) para trocar para uma nova pasta.

» import os
» os.getcwd()
↳ '/home/guilherme/Projetos/Phylos.net'

» os.chdir('/home/guilherme/Music')
» os.getcwd()
↳ '/home/guilherme/Music'

Também podemos criar novas pastas. Para isso usamos os.mkdir() (cria uma pasta) e os.makedirs() (cria várias pastas). Podemos criar, dentro da pasta atual, a pasta exemplo e exemplo/textos.

» import os
» os.mkdir('exemplo')
» os.mkdir('exemplo/textos')

# a tentativa de criar uma pasta existente resulta em erro
» os.mkdir('exemplo')
↳ FileExistsError: [Errno 17] File exists: 'exemplo'
Figura 1

Várias pastas e subpastas podem ser criadas simultaneamente. O comando abaixo cria três pastas.

» os.makedirs('2021/03/22')

A estrutura de pastas criada na pasta atual é ilustrada na figura 1:

Os seguintes comandos ilustram operações feitas com métodos de os:

# armazena pasta de trabalho inicial
» pasta_trabalho = os.getcwd()
# altera pasta atual para outra
» os.chdir('/home/guilherme/Music')
# cria subpastas na pasta atual (resultado na figura)
» os.makedirs('subpasta10/subpasta11/subpasta12')

# retorna para a pasta de trabalho
» os.chdir(pasta_trabalho)

# cria sub pasta
» os.mkdir('teste')

# muda pasta atual ('.' é atalho para pasta atual)
» os.chdir('./teste')
# verifica qual é a pasta atual
» os.getcwd()
↳ '/home/guilherme/Projetos/Artigos/teste'

# volta para pasta no nível acima ('..' é atalho para pasta 'mãe')
» os.chdir('..')

# renomeia pasta
» os.rename('teste', 'novo')

# os.remove só apaga arquivos
» os.remove('novo') # só pode apagar arquivo
↳ IsADirectoryError: [Errno 21] Is a directory: 'novo'

» os.remove('aluno.txt') # só pode apagar arquivo
# o arquivo 'aluno.txt' foi apagado (se existe)

# para apagar uma pasta use rmdir
» os.rmdir('novo')
# a pasta 'novo' foi apagada

O método os.remove(arquivo) lança um erro se o arquivo não existe ou se é uma pasta. Para evitar essa possibilidade usamos um try ou testamos previamente o arquivo. Para apagar pastas e subpastas podemos percorrer cada uma delas (veja método abaixo) ou usar o módulo shutil.

» arquivo_apagar = 'home/data.txt'
# testa a existência da arquivo
» if os.path.isfile(arquivo_apagar):
»     os.remove(arquivo_apagar)
» else:
»     print(f'O arquivo: {data_file} não existe ou é uma pasta')

Para apagar uma pasta podemos usar os.rmdir() ou shutil.rmtree().

» apagar_pasta = 'documentos/pasta'
» try:
»     os.rmdir(apagar_pasta)
» except OSError as e:
»     print(f'Error: {apagar_pasta} : {e.strerror}')

# apagar pastas e subpastas, mesmo que não estejam vazias
» import shutil
» apagar_pasta = 'documentos/pasta'
» try:
»     shutil.rmtree(apagar_pasta)
» except OSError as e:
»     print(f'Error: {apagar_pasta} : {e.strerror}')  
Figura 2

Percorrendo a árvore de pastas:

Não é rara a necessidade de percorrer as pastas e subpastas em uma estrutura de diretórios, eventualmente executando uma tarefa nos arquivos no disco ou fazendo buscas. O método os.walk() pode auxiliar nessa tarefa, percorrendo a árvores de pastas tanto da pasta raiz para as subpastas (de cima para baixo, top down) quanto no sentido inverso (bottom up). Por default os.walk(pasta) faz várias iterações em pasta e subpastas, até esgotar a árvore, de mãe para filhos. Em cada iteração retorna:

  • uma string com o nome da pasta atual
  • uma lista de suas subpastas
  • uma lista dos arquivos da pasta atual

Depois a iteração passa para uma subpasta (no modo de cima para baixo) ou para a pasta mãe. Para percorrer a árvore no sentido de baixo para cima usamos o parâmetro para baixo os.walk(pasta, topdown=False). No código abaixo percorremos a árvore (lembrando que ‘.’ simboliza pasta ativa atual. O teste if not sub_pastas resulta True se a lista está vazia. O resultado exibido supõe uma estrura de pastas como na figura 2.

# usando os.walk() para listas arquivos e pastas
» for pasta, sub_pastas, arquivos in os.walk('.'):
»     if not sub_pastas:
»         print('A pasta:', pasta, 'não possui subpastas')
»     else:    
»         print('A pasta:', pasta, 'possui as subpastas:')
»         for sub in sub_pastas:
»             print('\t\t',sub)
»     if not arquivos:
»         print('\t não possui arquivos')
»     else:    
»         print('\t e os arquivos:')    
»         for nome_arquivo in arquivos:
»             print('\t\t', nome_arquivo)

↳ A pasta: . possui as subpastas:
↳        pasta_1
↳        pasta_2
↳    e os arquivos:
↳        texto.txt
↳ A pasta: ./pasta_1 não possui subpastas.
↳    e os arquivos:
↳        arquivo1.py
↳        arquivo2.py         
↳        arquivo3.py
↳ A pasta: ./pasta_2 não possui subpastas.
↳    e os arquivos:
↳        arquivo4.py
↳        arquivo5.py         
↳        arquivo6.py

Informações do sistema operacional:

O módulo os possui muitos outros métodos. Por exemplo, os.uname() retorna o sistema operacional, nome de usuário e dados da versão do sistema usado.

» for t in os.uname():
»     print(t)
↳ Linux
↳ guilherme-Lenovo
↳ 5.8.0-45-generic
↳ #51-Ubuntu SMP Fri Feb 19 13:24:51 UTC 2021
↳ x86_64

Métodos de OS

Alguns dod métodos de OS.

Método Descrição
chdir(“novaPasta”) mudar a pasta ativa para novaPasta. Se novaPasta = “..” vai para pasta mãe
getcwd() ler diretório (pasta) atual
listdir(“pasta”) lista arquivos e subpastas de “pasta”
makedirs(sequencia) criar pastas com nomes em sequencia
mkdir(“nomeDaPasta”) criar uma pasta
remove(arquivo) apagar arquivo
removedirs(caminho) apagar pastas recursivamente
rmdir(“pastaRemover”) apagar pasta “pastaRemover”. Não pode ser pasta atual ou estar em uso por ouro processo
rename(“nomeAntigo”,”nomeNovo”) renomear pasta “nomeAntigo” para “nomeNovo”
uname() retorna dados sobre o sistema operacional, usuário e máquina usada
🔺Início do artigo

Bibliografia

Consulte a bibliografia no final do primeiro artigo dessa série.

Python, Compreensão de listas


Sobre tuplas e Zips

Algumas propriedades extras sobre tuplas são listadas aqui. Além disso usamos a fução zip() para unir objetos iteráveis de modo a poderem ser percorridos simultaneamante.

# Uma tupla não precisa de parenteses
» t = 1, 2, 3, 4
» t
↳ (1, 2, 3, 4)
» type(t)
↳ tuple
# podemos usar tuplas para declarações múltiplas
» x, y = 45, 78
» print(x,y, x+y)
↳ 45 78 123
# E percorrer uma tupla (ou lista) em um loop for
» t = [('a', 0, True), ('b', 1, False), ('c', 2, True)]
» for letra, num, b in t:
»     if b: print (num, letra)
↳ 0 a
↳ 2 c

# qualquer sequência pode ser usada no construtor de tuplas
» t = tuple('palavras')
» t
↳ ('p', 'a', 'l', 'a', 'v', 'r', 'a', 's')

# uma tupla de 1 elemento deve conter (,)
» t = ('a',)
» t
↳ ('a',)

» type(t)
↳ tuple

# tuplas para 'swap' de variáveis
» a = 'both'
» b = 'ambos'
print(a,b)
↳ both ambos
» a, b = b, a
» print(a,b)
↳ ambos both

Funções retornam uma variável. No entanto essa variável pode ser uma tupla (ou outro objeto mais complexo) o que tem o efeito de ter uma função retornando mais de um valor. Por exemplo, divmod(a,b) retorna uma tupla com o resultado inteira da divisão e o resto. Funções do usuário pode fazer o mesmo.

» divmod(10,3)
↳ (3, 1)

» div, resto = divmod(10,3)
» print(div)
» print(resto)
↳ 3
1

# Um exemplo de uma função que retorna uma sequência
» def min_max(seq):
»     return min(seq), max(seq)
»
» seq = (23,45,23,78,1,23,0,-34)
» min_max(seq)
↳ (-34, 78)

» seq = {23,45,23,78,1,23,0,-34}
» min_max(seq)
↳ (-34, 78)

# funções com n argumentos
» def imprima_tudo(*args):
»     print(args)

» imprima_tudo(1,2, '3', True)
↳ (1, 2, '3', True)

# sem * temos um erro
» def imprima(args):
»     print(args)
» imprima(1,2)
↳
---------------------------------------------------------------------------
TypeError: imprima() takes 1 positional argument but 2 were given

Função zip()

Uma função interna interessante e útil é zip(). Ela recebe como argumentos duas ou mais sequências e as compacta em um objeto zip que é um iterador de tuplas, onde cada tupla contem um elemento de cada sequência usada como parâmetro. Ela retorna um iterador de tuplas, onde a i-ésima tupla contém o i-ésimo elemento de cada uma das sequências ou iteráveis fornecidas em seu argumento. Se as sequências não tem o mesmo comprimento o iterador retornado tem o comprimento da menor. Se nenhum argumento for fornecido ela retorna um iterador vazio. Com um único argumento iterável, ele retorna um iterador de tuplas de um elemento.

» seq1 = 'Blade'
» seq2 = 'Runner'
» zipado = zip(seq1, seq2)
» print(zipado)
↳ <zip object at 0x7f27c9f77500>

# use a função tuple() para visualizar o objeto zip
» print(tuple(zipado))
↳ (('B', 'R'), ('l', 'u'), ('a', 'n'), ('d', 'n'), ('e', 'e'))

# usando a mesma variável já definida
» for letra1, letra2 in zipado:
»     print(letra1, letra2)
↳ B R
↳ l u
↳ a n
↳ d n
↳ e e

# um objeto zip pode ser passado como argumento na construção
# de uma lista gerando uma lista de tuplas
» s1 = [1, 2, 3]
» s2 = ['a', 'b', 'c']
» list(zip(s1, s2))
↳ [(1, 'a'), (2, 'b'), (3, 'c')]

# várias sequências podem ser fornecidas
» s1 = 'Margem'
» s2 = 'direita'
» s3 = 'do rio'
» zip123 = zip(s1, s2, s3)
» for a,b,c in zip123:
»     print(a, b, c)
↳ M d d
↳ a i o
↳ r r
↳ g e r
↳ e i i
↳ m t o

No útimo exemplo a sequência s2 tem maior comprimento que as demais. A letra final ‘a’ foi ignorada.

Suponha que desejamos analisar duas sequências e verificar se elas possuem elementos iguais em uma mesma posição. No exemplo abaixo fazemos este teste usando zip() e definindo uma função que retorna True se houver essa coincidência. Observe que a função é abandonada na ocorrência da primeira coincidência.

Pode ocorrer que precisamos saber qual é a posição desse (ou de vários elementos comuns). Para isso usamos enumerate(). Ela tem a seguinte forma:

enumerate(iteravel, inicio=0)

onde iteravel é uma sequência ou qualquer objeto iterável. Ela retorna pares iteráveis contendo o elemento e sua posição, começando em início (com default 0) e o elemento da sequência.

# função que retorna True se houver coincidência de elementos (ou False se não houver)
» def mesmo_elemento(t1, t2):
» for i, j in zip(t1, t2):
»     if i == j:
»         return True
» return False

» t1 = [1,2,3,4,5,6,7,8,9]
» t2 = [9,8,7,6,5,4,3,2,1]
» mesmo_elemento(t1,t2)
↳ True

# Para informar a posição da coincidência usamos enumerate
» for index, element in enumerate('abc'):
»     print(index, element)
↳ 0 a
↳ 1 b
↳ 2 c

» type(enumerate('abdc'))
↳ enumerate

# Repetindo o exemplo anterior, queremos descobrir se duas sequências
# possuem elementos comuns na mesma posição, e que posição é essa

» def posicao_elemento(t1, t2):
»     ''' retorna dictionary com indice e elemento onde elemento de t1 é igual ao de t2 '''
»     dict = {}
»     if len(t2) < len(t1):
»         (t1, t2) = (t2, t1)
»     for index, i in enumerate(t1):
»         if i == t2[index]:
»             dict[index] = i
»     return dict

» t2 = [1,2,3,4,5,6,7,6,9]
» t1 = [9,8,7,4,3,4,5,6,7,8,9,0,23,45]
» posicao_elemento(t1,t2)
↳ {3: 4, 7: 6}

» t1 = 'josefina'
» t2 = 'gasolina cara'
» posicao_elemento(t1,t2)
↳ {2: 's', 5: 'i', 6: 'n', 7: 'a'}

A linha if len(t2) < len(t1): (t1, t2) = (t2, t1) garante que t2 tenha o maior comprimento. Caso contrário o teste i == t2[index] poderia poderia dar erro ao tentar obter elemento inexistente de t2.

Compreensão de Listas (List Comprehensions)

Suponha que queremos uma lista com os quadrados de todos os números de 0 até 10. Podemos conseguir isso usando um laço for:

» quadrados = []
» for i in range(11):
»     quadrados.append(i**2)
»
» quadrados
↳ [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Há uma forma alternativa no Python para conseguir o mesmo resultado chamada compreensão de listas (list comprehensions).
Sua sintaxe básica é

[expressão(item) for item in lista if condição].

» quads = [i**2 for i in range(1, 11)]
» quads
↳ [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Essa forma permite que se escreva um código mais compacto, legível e eficiente (portanto de mais rápida execução).
A expressão pode ser uma função do usuário. No exemplo usamos a função já definida anteriormente para o cálculo de fatoriais:

» def fatorial(n):
»     if n <= 1: return 1
»     else: return n*fatorial(n-1)
»
# exibindo os fatoriais de ímpares de 1 a 9
» fats = [fatorial(i) for i in [1, 3, 5, 7, 9]]
» fats
↳ [1, 6, 120, 5040, 362880]

# atuando sobre strings
» palavras = ['Organização', 'Nações', 'Unidas']
» letras = [l[0] for l in palavras]
» letras
↳ ['O', 'N', 'U']

» tamanho = [len(p) for p in palavras]
» tamanho
↳ [11, 6, 6]

Uma ou mais condições pode ser incluída na lista a ser iterada.

[expressao(item) for item in lista if condição1 if condição2 ...]

No exemplo abaixo usamos i%2, que é o resto da divisão de i por 2. Se esse resto for 0 o número é par.

# ex.: lista dos números pares de 0 até 10, exclusive
# i%2 == 0 significa que o número é par
» num = [i for i in range(10) if i%2==0 ]
» print(num)
↳ [0, 2, 4, 6, 8]

# um exemplo com strings: apenas as palavras com comprimento maior que 5
» palavras = ['casa', 'aleatório', 'rudimentar', 'longo']
» [p for p in palavras if len(p) > 5 ]
↳ ['aleatório', 'rudimentar']

# Várias condições podem ser impostas simultaneamente
# São retornados os múltiplos de 2 e 3 simultaneamente, i.e. os múltiplos de 6.
» print([i for i in range(50) if i%2==0 if i%3==0])
↳ [0, 6, 12, 18, 24, 30, 36, 42, 48]

# a expressão na lista pode conter 'if else':
# a abaixo expressão retorna 'abacaxi' para números pares,
# 'laranja' para múltiplos de 3 e 'caqui' para todos os demais
» fruits = ['abacaxi' if i%2==0 else 'laranja' if i%3==0 else 'caqui' for i in range(10)]
» print(fruits)
↳ ['abacaxi', 'caqui', 'abacaxi', 'laranja', 'abacaxi', 'caqui', 'abacaxi', 'caqui', 'abacaxi', 'laranja']

# As listas podem ser aninhadas. Abaixo a lista externa percorre letras,
# a lista interna percorre números
» matriz = [[i+j for i in 'abcd'] for j in '1234']
» matriz
↳ [['a1', 'b1', 'c1', 'd1'],
   ['a2', 'b2', 'c2', 'd2'],
   ['a3', 'b3', 'c3', 'd3'],
   ['a4', 'b4', 'c4', 'd4']]

Um teste pode ser negado com o operador lógico not (que inverte o booleano). Usamos também o método string.isalpha() que retorna True se string for formado apenas de caracteres (sem dígitos ou pontuações).

# teste not in
# isalpha() retorna True se a string é composta de caracteres alfabéticos
» vogais = {'a', 'e', 'i', 'o', 'u'}
» texto = 'Aprenda todas as regras e transgrida algumas 1234.'
» letras = set(texto.lower())
» consoantes = {letra for letra in letras if letra not in vogais if letra.isalpha()}
» consoantes
↳ {'d', 'g', 'l', 'm', 'n', 'p', 'r', 's', 't'}

# na expressão seguinte um set de tuplas é gerado
{(i, j) for i in range(3, 5) for j in range(2)}
↳ {(3, 0), (3, 1), (4, 0), (4, 1)}

» print([i+j for i in 'abcd' for j in 'efgh'])
↳ ['ae', 'af', 'ag', 'ah', 'be', 'bf', 'bg', 'bh', 'ce', 'cf', 'cg', 'ch', 'de', 'df', 'dg', 'dh']

» substantivo = ['pão', 'pé', 'carro', 'bolo', 'mato']
» adjetivo = ['pequeno', 'bonito', 'bom', 'caro']
» ['%s %s' % (s, a) for s in substantivo for a in adjetivo if s[0] == a[0]]
↳ ['pão pequeno', 'pé pequeno', 'carro caro', 'bolo bonito', 'bolo bom']

# Podemos calcular o produto escalar de 2 vetores
» u = [1,3,4,5,6]
» v = [-1,0,9,-3,2]
» sum([a+b for a,b in zip(u,v)])
↳ 26

No cálculo do produto escalar zip(u,v) contém 5 pares que são somados formando uma lista de 5 elementos. A função sum(lista) soma esses 5 elementos.

Compreensão com dicionários

Compreensão de listas podem ser aplicadas a dicionários, alterando tanto suas chaves como valores. Lembrando dic.items() retorna uma tupla chave:valor do dicionário.

# uma compreensão para duplicar os valores em um dicionário
» dic1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
» duplo_dic1 = {k:v*2 for (k,v) in dic1.items()}
» duplo_dic1
↳ {'a': 2, 'b': 4, 'c': 6, 'd': 8, 'e': 10}

# altera texto nas chaves
» R_dic1 = {'R'+k : v*2 for (k,v) in dic1.items()}
» R_dic1
↳ {'Ra': 2, 'Rb': 4, 'Rc': 6, 'Rd': 8, 'Re': 10}

» s_dic = {l.upper(): l*3 for l in 'dna'}
» print (s_dic)
↳ {'D': 'ddd', 'N': 'nnn', 'A': 'aaa'}

# queremos construir um dicionário onde a chave é um
# par entre 1 e 10, inclusive, e o valor é seu quadrado.
# Obs. percorrer i = 1, ..., 5 e tomar seu dobro garante que usamos apenas os pares
» dic_2 = {}
» for i in range(1,6):
»     dic_2[i*2] = (i*2)**2
» dic_2
↳ {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

# alternativamente, com compreensão
» dic_3 = {n:n**2 for n in range(1,11) if n%2 == 0}
» dic_3
↳ {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

# o mesmo resultado será obtido com
» dic_4 = {2*n:(2*n)**2 for n in range(1,6)}
» dic_4
↳ {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

# Podemos usar compreensões para filtrar elementos de um dicionário
» dic_4a = {k:v for (k,v) in dic_4.items() if v>36}
» dic_4a
↳ {8: 64, 10: 100}

» dic_4b = {k:v for (k,v) in dic_4.items() if v>16 if v<100}
» dic_4b
↳ {6: 36, 8: 64}

# duas condições podem ser usadas
» dic_4b = {k:v for (k,v) in dic_4.items() if v>16 if v<100}
» dic_4b
↳ {6: 36, 8: 64}

# duas condições, sobre chave e valor
» dic_4c = {k:v for (k,v) in dic_4.items() if v>15 if v<90}
» dic_4c
↳ {4: 16, 6: 36, 8: 64}

# o valor é (im)par para chave (im)par
» dic_par_impar = {i:('par' if i%2==0 else 'impar') for i in range(5)}
» dic_par_impar
↳ {0: 'par', 1: 'impar', 2: 'par', 3: 'impar', 4: 'par'}

Algumas vezes pode ser útil usar zip() para construir dicionários através de uma compreensão.

# Lists to represent keys and values
» keys = [101, 201, 301, 401, 501]
» values = ['inglês', 'francês', 'alemão', 'russo', 'espanhol']

# keys e values são colocados em um único iterável (um objeto zip)
» dic_5 = { k:v for (k,v) in zip(keys, values)}
» print(dic_5)
↳ {101: 'inglês', 201: 'francês', 301: 'alemão', 401: 'russo', 501: 'espanhol'}

# Claro que o iterável poderia ser dado diretamente como parâmetro do construtor
» dic_6 = dict(zip(keys, values))
» print(dic_6)
↳ {101: 'inglês', 201: 'francês', 301: 'alemão', 401: 'russo', 501: 'espanhol'}

# dicionários aninhados
» dicionario = {i: {j: i*j for j in range(1, 6)} for i in range(2, 5)}
» print(dicionario)
↳ {2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}, 3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15}, 4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20}}

Nesse dicionário as chaves vão de 2 até 4 e seus valores são outros dicionários.

Compreensões de listas e de dicionários são formas elegantes e de fácil leitura. No entanto, se forem muito complexas elas podem tornar o código difícil de ler e de debugar (encontrar eventuais erros). Devemos nos lembrar que outras pessoas podem necessitar ler o nosso código, ou você mesmo, daqui a um tempo, quando dificilmente se lembrará do raciocínio que te levou à construção de bloco sofisticados e elegantes.

Função filter()

A função tem a forma de

filter(funcao, sequencia)

e constroi um iterador usando uma função booleana (que retorna True ou False) e uma sequência ou um iterável qualquer. Ela testa cada elemento da sequência usando a função e retorna apenas os elementos avaliados como True.

» idades = [5, 12, 17, 18, 24, 32]
» def maior(x):
»     if x < 18:
»         return False
»     else:
»         return True

» adultos = filter(maior, idades)
» for x in adultos:
»     print(x)
↳ 18
↳ 24
↳ 32

# observe que a função acima poderia ser escrita simplesmente como
» def maior(x):
»     return x ≥ 18

No próximo exemplo temos uma lista de dicionários. Cada entrada dessa lista é um dicionário contendo dados sobre um animal. O código define uma função pesquisa que recebe essa lista e procura quais de suas entradas contém algum valor com o substring busca.

» bicharada = [
»   {'nome': 'Asdrubal', 'especie': 'tubarão', 'peso': '290', 'habitat': 'oceano'},
»   {'nome': 'Ana Lee', 'especie': 'caranquejo', 'peso': '1.2', 'habitat': 'oceano'},
»   {'nome': 'Raul', 'especie': 'urso', 'peso': '180', 'habitat': 'floresta'},
»   {'nome': 'Joana', 'especie': 'raposa', 'peso': '21', 'habitat': 'floresta'},
»   {'nome': 'Omar Lee', 'especie': 'golfinho', 'peso': '120', 'habitat': 'oceano'},
»   {'nome': 'Tulio', 'especie': 'rato', 'peso': '1.4', 'habitat': 'doméstico'}
» ]

» def pesquisa(lista, busca):
»     def meu_iterador(x):
»         for v in x.values():
»             if busca in v:
»                 return True
»         return False
»     return filter(meu_iterador, lista)

» lista_filtrada = pesquisa(bicharada, 'tuba')
» for t in lista_filtrada:
»     print(t)
↳ {'nome': 'Asdrubal', 'especie': 'tubarão', 'peso': '290', 'habitat': 'oceano'}

» lista_filtrada = pesquisa(bicharada, 'Lee')
» for t in lista_filtrada:
»     print(t)
↳ {'nome': 'Ana Lee', 'especie': 'caranquejo', 'peso': '1.2', 'habitat': 'oceano'}
↳ {'nome': 'Omar Lee', 'especie': 'golfinho', 'peso': '120', 'habitat': 'oceano'}

Sugestão: altere o código acima para encontrar parte de um valor dentro de um campo especificado. Encontre o animal cujo habitat contém a substring ‘ocea’.

Iteradores (iterators)

No Python um iterador é um objeto que contém um número contável de elementos que podem ser iterados, ou seja, que podem ser acessados e lidos um de cada vez. Além dos laços for e das compreensões de listas e sequências no Python podemos utilizar iteradores para percorrer seuências. Eles pode ser construídos com a função

nome_iterador = iter(sequencia, marcador).

O parâmetro marcador é opcional e …..

O iterador tem o método _next()_ que fornece o próximo elemento. Uma exceção StopIteration é lançada no final, quando todos os elementos foram percorridos. O iterador é esgotado e, portanto, só pode ser percorrido uma vez.

Exemplos de uso estão no código abaixo. Lista são convertidas em iteradores, que são percorridos com next().
Se a iteração não é interrompida antes do fim um erro é lançado. Um erro é gerado no final e sua captura é usada para interromper o laço.

# Uma lista é convertida em um iterador
lista = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
it = iter(lista)
for k in range(len(lista)):
    print(next(it), end=' ')
a b c d e f g h

# queremos separar números positivos e negativos de uma lista
# o erro no final da iteração é usado para interromper o laço
» original = [1,6,-8,-3,0, -2, 9, 76, -45]
» positivos = []
» negativos = []
» t = iter(original)
» try:
»     while True:
»         x = next(t)
»         if x >= 0:
»             positivos.append(x)
»         else:
»             negativos.append(x)
» except StopIteration:
»     print('São positivos:' , positivos, '\nSão negativos:' , negativos)

↳ São positivos: [1, 6, 0, 9, 76]
↳ São negativos: [-8, -3, -2, -45]

Embora a mesma funcionalidade possa ser conseguida de formas diferentes a transformação de um objeto iterável em um iterador é bastante útil para se escrever classes e métodos definidos pelo programador, como veremos.

Funções Lambda

Funções são boas formas de escrever código de fácil reutilização. No entanto, algumas vezes precisamos de definir um operador de forma compacta e que será utilizado apenas naquele ponto do código. As funções lambda (ou funções anônimas) permitem a criação de funções (que sequer recebem um nome) mas agem da forma desejada sobre seus argumentos.

Funções lambda tem uma sintaxe concisa:

lambda <arg1, ..., argn> : < expressão >

Elas só podem conter uma única expressão, nenhuma declaração, deve ser escrita em linha única e não comportam anotações. São exemplos simples de funções lambda:

# uma função bem simples é a identidade.
# a definição usual seria
» def id(x):
»     return x

# usando função lambda
» i = lambda x: x
» i(9)
↳ 9

# a função não precisa ser associada a uma variável
» (lambda x: abs(x))(-9)
↳ 9

# outros ex. Soma e multiplicação
» x = lambda a, b : a + b
» x(5,7)
↳ 12

# múltiplos argumentos não são envoltos em parênteses
» exp = lambda x,y : x**y
» exp(2,3)
↳ 8

» mix = lambda x,y,z : (x**y)/z
» mix(3,4,5)
↳ 16.2

# qualquer tipo de objeto pode ser passado como argumento
# no exemplo uma tupla é passada
» u = (4,7)
» (lambda x: x[0]*x[1])(u)
↳ 28

# uma função lamba que age sobre strings
# .title torna o primeiro caracter maiúsculo
» nome_autor = lambda nome, sobrenome: f'Autor: {nome.title()} {sobrenome.title()}'
» nome_autor('richard','dawkins')
↳ 'Autor: Richard Dawkins'

Um exemplo de uso frequente consiste no uso de lambdas para fornecer um critério de ordenamento.
Vimos que a função sorted(sequencia, key) pode ordenar uma sequência de acordo com um critério dado em key. No caso abaixo a cada tupla é associado o produto de seus pares, e a ordenação é feita nessa métrica.

» p = [(3, 3), (4, 2), (2, 2), (5, 2), (1, 7)] 
» sorted(p, key=lambda x: x[0]*x[1])
↳ [(2, 2), (1, 7), (4, 2), (3, 3), (5, 2)]

# dados vetores no espaço, ordená-los em ordem crescente de módulo
# a função lambda calcula o quadrado do módulo
» v =[(1,5,3), (1,8,2), (7,8,9), (2,4,3), (2,2,-1)]
» sorted(v, key=lambda x: x[0]**2+x[1]**2+x[2]**2)
↳ [(2, 2, -1), (2, 4, 3), (1, 5, 3), (1, 8, 2), (7, 8, 9)]

No exemplo seguinte definimos uma função que recebe um argumento e opera nele com uma função lambda. Essa última, por sua vez, recebe outro argumento. O exemplo também ilustra o fato de que uma função é um objeto e pode ser atribuída à uma variável.

# queremos uma função que multiplica seu argumento por um número especificado
# n pode ser visto como um parâmetro
» def vezes_n(n):
»     return lambda a : a * n

» funcao_duplicar = vezes_n(2)
» funcao_triplicar = vezes_n(3)
» funcao_x1000 = vezes_n(1000)

» funcao_duplicar(23)
↳ 46

» funcao_triplicar(15)
↳ 45

» funcao_x1000(12.345)
↳ 12345.0

A minha_funcao abaixo é uma função lambda com dois argumentos sendo um deles outra função. No primeiro caso 2 + 2*10 = 22. No segundo caso 4 + (4)**3 -6 = 62.

» minha_funcao = lambda x, f: x + f(x)
» minha_funcao(2, lambda x: x*10 )
↳ 22
» minha_funcao(4, lambda x: x**3-6)
↳ 62

Função map()

Lambdas são muito usadas junto com a função map() que tem a seguinte assinatura:

map(funcao, iteravel1, ..., iteraveln).

Os dois argumentos são obrigatórios. A função percorre os iteráveis fornecidas usando a função especificada. Essa função deve usar um elemento de cada iterável. Ela usa um algoritmo otimizado para realizar sua transformação, o que a torna mais eficiente e rápida do que laços usuais do Python.

Ela retorna um objeto iterável map que pode ser convertido em lista com list(). Alguns exemplos:

# a operação abaixo concatena duas strings
» def concatena(a, b):
»     return (a + ' ' + b)
» iter1 = ('banana', 'laranja', 'uva')
» iter2 = ('nanica', 'bahia', 'syrah')
» x = map(concatena, iter1, iter2)

# para ver o resultado podemos percorrer a iterável gerada
# cada i no laço é uma única string (como 'banana nanica')
» for i in x:
»     print(i)
↳ banana nanica
↳ laranja bahia
↳ uva syrah

# a funcão pow(x,y) retorna x^y (x elevado a y)
# duas sequências devem ser dadas em map
» y = map(pow, [6,7,8],[3,2,1])
» for i in y:
»     print(i, end=' - ')
↳ 216 - 49 - 8 -

# a função pode ser uma lambda
# duplicar cada elemento da lista
» lista = [10, 25, 17, 9, 30, -5]
» lista_2 = map(lambda n : n*2, lista)
# para exibir a sequência retornada podemos transformá-la em uma lista
» list(lista_2)
↳ [20, 50, 34, 18, 60, -10]

O uso de funções lambda pode tornar mais compacto o uso de map.

# para retornar uma lista de quadrados
» def quadrado(n):
»     return n**2
» numeros = [1, 2, 3, 4, 5]
» quadrados = map(quadrado, numeros)
» list(quadrados)
↳ [1, 4, 9, 16, 25]

# o mesmo resultado pode ser conseguido usando lambdas
» list(map(lambda x:x**2, range(1,6)))
↳ [1, 4, 9, 16, 25]

# abs() é função interna, que retorna valor absoluto
» nums = [-5, -3, -1, 0, 1, 3, 5]
» absolutos = list(map(abs, nums))
» absolutos
↳ [5, 3, 1, 0, 1, 3, 5]

# somar e multiplicar com 3 listas
» list(map(lambda i, j, k: i+j*k, [2, 4], [1, 3], [7, 8]))
↳ [9, 28]

# strip() remove string dados nas extremidades da string
» traco = ['---12356.876-', '-casa-da-vó---', '-mil-', '---']
» list(map(lambda s: s.strip("-"), traco))
↳ ['12356.876', 'casa-da-vó', 'mil', '']

# função recebe um número e retorna tuplas de 3 elementos
» def pot_1_2_3(x):
»     return x, x ** 2, x ** 3
» numeros = [1, 2, 3, 4]
» list(map(pot_1_2_3, numeros))
↳ [(1, 1, 1), (2, 4, 8), (3, 9, 27), (4, 16, 64)]

# a mesma coisa usando lambda
» list(map(lambda x: (x, x**2, x**3), numeros))
↳ [(1, 1, 1), (2, 4, 8), (3, 9, 27), (4, 16, 64)]

Em muitos casos uma compreensão de lista faz o mesmo que uma iteração via map(). No entanto é útil conhecer a função não apenas para poder ler e compreender código escrito por outras pessoas mas também para eventuais situações onde ela pode ser mais simples ou mais eficaz.

🔺Início do artigo

Bibliografia

Consulte a bibliografia no final do primeiro artigo dessa série.

Python, Resumo

Conteúdo

  • Métodos de Conjuntos (sets)
  • Métodos de Dicionários (dictionaries)
  • Métodos de Arquivos (files)
  • Métodos da biblioteca os
  • Palavras reservadas

    Palavras reservadas (ou keywords) que são nomes que fazem parte da sintaxe da linguagem e não podem ser utilizadas para nomes de variáveis.

    Palavras reservadas do python
    and except lambda with
    as finally nonlocal while
    assert false None yield
    break for not
    class from or
    continue global pass
    def if raise
    del import return
    elif in True
    else is try

    Funções Internas

    Segue uma lista de funções internas ou pré-programadas do Python. Muitas outras podem ser acrescentadas à uma sessão através da importação de módulos externos.

    Função ação (retorna)
    abs() valor absoluto de um número
    all() True se todos os itens em um objeto iterável forem verdadeiros
    any() True se qualquer item em um objeto iterável for verdadeiro
    ascii() uma versão legível de um objeto (trocando caracteres não ascii por caracteres de escape)
    bin() versão binária de um número
    bool() valor booleano do objeto especificado
    bytearray() uma matriz de bytes
    bytes() um objeto bytes
    callable() True se o objeto especificado pode ser chamado, caso contrário, False
    chr() um caractere do código Unicode especificado.
    classmethod() converte um método em um método de classe
    compile() fonte especificada como um objeto, pronto para ser executado
    complex() um número complexo
    delattr() exclui o atributo especificado(propriedade ou método) do objeto
    dict() um dicionário(Array)
    dir() uma lista das propriedades e métodos do objeto
    divmod() quociente e resto quando o argumento1 é dividido pelo argumento2
    enumerate() pega uma coleção(por exemplo, uma tupla) e retorna como um objeto enumerado
    eval() avalia e executa uma expressão
    exec() executa o código(ou objeto) especificado
    filter() usa uma função de filtro para excluir itens em um objeto iterável
    float() um número de ponto flutuante
    format() formata um valor especificado
    frozenset() um objeto frozenset
    getattr() o valor do atributo especificado (propriedade ou método)
    globals() a tabela de símbolos global atual como um dicionário
    hasattr() True se o objeto especificado tem o atributo especificado(propriedade / método)
    hash() o valor hash de um objeto especificado
    help() exibe ajuda embutido
    hex() converte um número em seu valor hexadecimal
    id() o id de um objeto
    input() permite entrada do usuário
    int() um número inteiro
    isinstance() True se o objeto é instância de outro objeto especificado
    issubclass() True se a classe é subclasse de objeto especificado
    iter() um objeto iterador
    len() o comprimento de um objeto
    list() uma lista
    locals() um dicionário atualizado da tabela de símbolos local atual
    map() o iterador com a função especificada aplicada a cada item
    max() o maior item em um iterável
    memoryview() um objeto de visualização de memória
    min() o menor item em um iterável
    next() o próximo item em um iterável
    object() um novo objeto
    oct() converte um número em um octal
    open() abre um arquivo e retorna objeto de arquivo
    ord() converte um inteiro que representa o Unicode do caractere especificado
    pow() o valor de x à potência de y
    print() imprime no dispositivo de saída padrão
    property() obtém, define ou exclui uma propriedade
    range() uma sequência de números, começando em 0 e incrementos em 1 (por padrão)
    repr() uma representação legível de um objeto
    reversed() um iterador reverso
    round() arredonda um número
    set() um objeto de conjunto
    setattr() define um atributo (propriedade/método) de um objeto
    slice() um objeto de fatia
    sorted() uma lista ordenada
    @staticmethod() Converte um método em um método estático
    str() um objeto de string
    sum() soma os itens de um iterador
    super() um objeto que representa a classe pai
    tuple() uma tupla
    type() o tipo de um objeto
    vars() a propriedade __dict__ de um objeto
    zip() um iterador, de dois ou mais iteradores

    Métodos de Strings

    Método descrição
    capitalize() converte 1º caracter em maiúsculo
    casefold() converte string em minúsculas
    center() retorna string centralizada
    count() retorna número de ocorrências de um valor especificado na string
    endswith() retorna True se string termina com valor especificado
    find() busca por valor especificado na string e retorna the posição se encontrado
    format() Formata de acordo com valores especificados
    index() busca por valor especificado na string e retorna the posição se encontrado
    isalnum() retorna True se todos os caracteres são alfa-numéricos
    isalpha() retorna True se todos os caracteres são alfabéticos
    isdecimal() retorna True se todos os caracteres são decimais
    isdigit() retorna True se todos os caracteres são dígitos
    islower() retorna True se todos os caracteres são minúsculos
    isnumeric() retorna True se todos os caracteres são numéricos
    isspace() retorna True se todos os caracteres são espaços
    istitle() retorna True se a string segue regra de títulos
    isupper() retorna True se todos os caracteres são maiúsculos
    join() reune elementos de um iterável no final da string
    ljust() retorna a string justificada à esquerda
    lower() converte a string para minúsculas
    lstrip() retorna a string sem espaços à esquerda
    partition() retorna tuple partindo a string em 3 partes
    replace() substitui trecho da string por outro especificado
    rfind() busca trecho especificado value e retorna última posição
    rindex() busca trecho especificado value e retorna última posição
    rjust() retorna string justificada à direita
    rsplit() quebra a string no separador especificado, retornando lista
    rstrip() retorna a string sem espaços à direita
    split() quebra a string no separador especificado, retornando lista
    splitlines() quebra a string nas quebras de linha, retornando lista
    startswith() retorna True se string começa com valor especificado
    strip() retorna a string sem espaços laterais
    swapcase() inverte minúsculas e maiúsculas
    title() converte em maiúscula o 1º caracter de cada palavra
    upper() converte a string em maiúsculas
    zfill() preencha com número de zeros especificado, no início

    Métodos de Listas (lists)

    Método ação
    append() insere elementos na lista
    clear() remove todos os elementos na lista
    copy() retorna uma cópia da lista
    count() returns número de elementos com valor especificado
    extend() insere os elementos de outra lista (ou iterável) ao final da lista
    index() returna o índice do 1º elemento com valor especificado
    insert() insere elemento em posição especificada
    pop() remove elemento em posição especificada
    remove() remove elemento em posição especificada por índice
    reverse() inverte a ordem da lista
    sort() ordena a lista

    Além desses as seguintes funções são úteis para se tratar com sequências:

    Função Descrição
    cmp(x, y) compara dois valores
    len(seq) retorna o comprimento da sequência
    list(seq) converte uma sequência em lista
    max(args) retorna o valor máximo na sequência
    min(args) retorna o valor mínimo na sequência
    eversed(seq) permite a iteração sobre valores na sequência
    sorted(seq) retorna lista ordenada dos elementos na sequência
    tuple(seq) converte a sequência em uma tuple

    Métodos das Tuplas (tuples)

    Método Descrição
    count() retorna quantas vezes um valor especificado ocorre na tupla
    index() procura por valor especificado e retorna sua posição

    Métodos de Conjuntos (sets)

    Método Descrição
    add() insere elemento no set
    clear() remove todos os elementos do set
    copy() retorna cópia do set
    difference() retorna um set com a diferença entre 2 ou mais sets
    difference_update() remove elementos incluidos no segundo set
    discard() remove item especificado
    intersection() retorna o set interseção de 2 sets
    intersection_update() remove items do set não presentes no segundo set especificado
    isdisjoint() retorna True se os 2 sets são disjuntos
    issubset() retorna True se o set é subconjunto do segundo set
    issuperset() retorna True se o set contém o segundo set
    pop() remove (e retorna) um elemento arbitrário do set
    remove() remove o elemento especificado
    symmetric_difference() retorna o set com a diferença simétrica de dois sets
    symmetric_difference_update() insere a diferença simétrica desse set em outro
    union() retorna um set com a união dos sets
    update() atualiza o primeiro set com sua união com um ou mais sets

    Métodos de Dicionários (dictionaries)

    Método Descrição
    clear() remove todos os elementos from the dictionário
    copy() retorna uma cópia do dicionário
    fromchaves() retorna dicionário com chaves e valores especificados
    get() retorna o valor relativo a chave dada, ou valor default dado
    items() retorna uma lista contendo uma tupla para cada par chave:valor
    chaves() retorna lista com as chaves do dicionário
    pop() remove o elemento relativo à chave especificada
    popitem() remove o último par chave:valor inserido
    setdefault() retorna o valor relativo à chave dada. Se a chave não existe insere chave:valor
    update() Atualiza o dicionário com pares chave:valor dados
    valors() retorna uma lista com os valores do dicionário

    Métodos de Arquivos (files)

    Método Descrição
    open(arquivo, modo) Abre o arquivo (descrição dos parâmetros abaixo)

    Os seguintes valores são válidos para modo.

    Parâmetro Descrição
    r para leitura – O ponteiro é colocado no início do arquivo. Default.
    r+ para leitura e gravação. O ponteiro fica no início do arquivo.
    w apenas para gravação. Substitui arquivo existente, cria novo se o arquivo não existir.
    w+ escrita e leitura. Substitui arquivo existente, cria novo se arquivo não existir.
    rb para leitura em formato binário. O ponteiro fica no início do arquivo.
    rb+ para leitura e escrita em formato binário.
    wb+ para escrita e leitura em formato binário. Substitui o arquivo existente. Cria novo se não existir.
    a para anexar. O ponteiro fica no final do arquivo, se o arquivo existir. Cria novo se existir.
    ab um arquivo para anexar em formato binário. O ponteiro fica no final do arquivo. Cria novo se não existir.
    a+ para anexar e ler. O ponteiro fica no final do arquivo, se arquivo existir. Cria novo se não existir.
    ab+ anexar e ler em formato binário. O ponteiro no final do arquivo. Cria novo se não existir.
    x cria novo arquivo lançando erro se já existir.
    Método Descrição
    close() fecha o arquivo; sem efeito se arq. já está fechado
    detach() retorna o fluxo bruto separado do buffer
    fileno() retorna número inteiro diferente para cada arquivo aberto
    flush() descarrega no disco as alterações no buffer
    isatty() retorna True se o fluxo de arquivo é interativo
    next(arquivo) itera sobre arquivo, lançando erro no final
    read() retorna o conteúdo do arquivo
    readable() retorna True se o fluxo do arquivo pode ser lido
    readline() retorna uma única linha do arquivo
    readlines() retorna lista com todas as linhas do arquivo
    search() localiza item no arquivo e retorna sua posição
    searchable() retorna True se o arquivo é pesquisável, por ex. com seek()
    tell() retorna a posição atual do arquivo
    truncate([tamanho]) redimensiona (truncando) o arquivo para um tamanho especificado
    writable() retorna True se o arquivo pode receber gravações
    write() grava a string especificada no arquivo
    writelines() escreve a sequencia no arquivo. Qualquer objeto iterável composto por strings pode ser usado

    Métodos de OS

    Método Descrição
    chdir(“novaPasta”) mudar a pasta ativa para novaPasta. Se novaPasta = “..” vai para pasta mãe
    getcwd() ler diretório (pasta) atual
    listdir(“pasta”) lista arquivos e subpastas de “pasta”
    makedirs(sequencia) criar pastas com nomes em sequencia
    mkdir(“nomeDaPasta”) criar uma pasta
    remove(arquivo) apagar arquivo
    removedirs(caminho) apagar pastas recursivamente
    rmdir(“pastaRemover”) apagar pasta “pastaRemover”. Não pode ser pasta atual ou estar em uso por ouro processo
    rename(“nomeAntigo”,”nomeNovo”) renomear pasta “nomeAntigo” para “nomeNovo”
    uname() retorna dados sobre o sistema operacional, usuário e máquina usada
    🔺Início do artigo

    Bibliografia

    Consulte a bibliografia no final do primeiro artigo dessa série.

    Python, Sequências e Coleções


    Sequências e coleções

    No Python sequências são conjuntos de elementos ordenados que podem ser acessados em sua ordem (o que chamamos de iteráveis. Já vimos que strings são sequências. Por ex., print('Casa da Mãe Joana'[3]) resulta em 'a'.

    range(), na verdade não é uma função mas uma classe, algo que veremos mais tarde. Ela fornece objetos que produzem os elementos sob demanda, sem precisar guardar todos na memória.

    Outra sequência de uso comum é range, que é o tipo de objeto retornado pela “função” range(). Ela tem a seguinte sintaxe ou assinatura:

    range(inicio, fim, passo)

    onde inicio e passo são opcionais. Ela gera uma sequência de inicio até fim (exclusivo) com intervalo de passo.

    » faixa = range(2,20, 3)
    » print('o objeto é', faixa)
    » print('o tipo do objeto é', faixa)
    » print('o segundo elemento é', faixa[1])
    ↳ o objeto é range(2, 20, 3)
    ↳ o tipo do objeto é <class 'range'>
    ↳ o segundo elemento é 5
    
    # podemos iterar pelos itens de faixa
    » for t in faixa:
    »     print(t, end=' ')
    ↳ 2 5 8 11 14 17 
    

    Coleções são conteineres de dados. No módulo básico do Python existem quatro tipos de dados em coleções:

    • Lista (list): ordenada e mutável, pode ter membros duplicados.
    • Tupla (tuple): ordenada e imutável, pode ter membros duplicados.
    • Conjunto (set): não ordenada e não indexada, sem membros duplicados.
    • Dicionário (dictionary): não ordenada, mutável, sem membros duplicados.


    Existe um módulo chamado collections com outros tipos de conteineres com estruturas de dados mais específicas como, por exemplo, uma tupla nomeada e um dicionário ordenado.

    Listas

    Além dos objetos já vistos, muitos outros são pre-programados no núcleo básico do Python. A listas (lists) são sequências ordenadas de objetos que podem ser acessados por meio de seu índice (ou index), um marcador de sua posição. Os objetos que a compõem que não precisam ser mesmo tipo, são delimitados por colchetes e separados por vírgulas.

    lista = [valor_0, ..., valor_n]

    As listas são mutáveis, podem ser encolhidas ou expandidas e ter seus elementos substituídos.

    Exemplos de listas são dados a seguir:

    » lista1 = ['Maria', 25]
    » lista2 = ['José', 27]
    » lista3 = [lista1, lista2]
    » print(lista1[0])
    » print(lista1[0])
    ↳ Maria
    ↳ 25
    
    # lista3 é uma lista de listas
    » print(lista3)
    ↳ [['Maria', 25], ['José', 27]]
    
    # o 2&orm; elemento da 2&orf; lista é
    » print(lista3[1][1])
    ↳ 27
    

    Da mesma forma que sequências de caracteres (nas strings), elementos em listas e tuplas podem ser acessados por meio de seus índices. Fatias (ou slices) lista[i:j] se iniciam no i-ésimo elemento, até o j-ésimo, exclusive, de forma que len(lista[i:j]) = j-i. Índices negativos contam a pertir do final.

    » lista4 = [10, 23,45,56,67,78,89,90]
    » lista4[1:3]
    ↳ [23, 45]
    
    # omitindo o 1º índice
    » lista4[:2]
    ↳ [10, 23]
    
    # omitindo o 2º índice
    » lista4[4:]
    ↳ [67, 78, 89, 90]
    
    # o último elemento
    » lista4[-1]
    ↳ 90
    
    » lista4[-4:-2]
    ↳ [67, 78]
    
    # len fornece o número de elementos na lista
    » len(lista4[3:7])
    ↳ 4
    
    # um 3&rdm; parâmetro indica o "passo"
    » lista4[::2]
    ↳ [10, 56, 89]
    
    # um passo negativo indica contagem do fim para o início
    » lista4[::-1]
    ↳ [90, 89, 78, 67, 56, 45, 23, 10]
    


    Vimos que a ausência do 1º índice assume o início, a ausência do 2º assume o final. O 3º indica para pular um número de elementos.

    Se uma função retorna uma lista (ou uma sequência qualquer), ela pode ser diretamente indexada. Por ex., se um código se refere ao mês abreviado em 3 letras em várias partes pode ser útil colocar em uma função a lista de meses.

    » def mes_abrev():
    »     m = ['jan','fev','mar','abr','mai','jun','jul','ago','set','out','nov','dez',]
    »     return m
    
    # para pegar o segundo mês:
    » mes_abrev()[1]
    ↳ 'fev'
    
    # para pegar o 1º trimestre:
    » mes_abrev()[:3]
    ↳ ['jan', 'fev', 'mar']
    
    # para pegar o último trimestre:
    » mes_abrev()[-3:]
    ↳ ['out', 'nov', 'dez']
    

    Assim como ocorre com strings, listas podem ser somadas (concatenadas) e multiplicadas por um número (repetidas). O efeito é o mesmo.

    » lista5 = [0, 1, 2, 3, 4]
    » lista6 = [10, 11, 12, 13, 14]
    » lista5 + lista6
    ↳ [0, 1, 2, 3, 4, 10, 11, 12, 13, 14]
    
    » lista5 * 2
    ↳ [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
    

    Uma lista pode ser inicializada vazia ou com um número dado de itens.

    # lista vazia    
    » lista_vazia = []
    » lista_vazia
    ↳ []
    
    # elementos podem ser inseridos com o método append
    » lista_vazia.append(12)
    » lista_vazia.append(13)
    » lista_vazia
    ↳ [12, 13]
    
    # o mesmo efeito seria obtido com concatenação
    » lista_vazia.clear()     # a lista volta a ser vazia
    » lista_vazia += [12, 13]
    » lista_vazia
    ↳ [12, 13]
    
    # lista com 5 entradas
    » lista_none = [None]*5
    » lista_none
    ↳ [None, None, None, None, None]
    

    Sendo mutáveis listas podem ser alteradas in place tendo qualquer de seus valores trocados sem a necessidade de criação de nova lista. count(item) retorna quantas vezes item aparece na lista. index(item) retorna o índice onde item aparece.

    » palavras = ['palha', 'grande', 'casa', 'dado', 'pequeno', 'coisa', 'gado', 'fato', 'gato', 'lá' ]
    » print('A terceira palavra é ---| %s |---' % palavras[2] )
    ↳ A terceira palavra é ---| casa |---
    
    » palavras[2] = 'house'
    » print('A terceira palavra é ---| %s |---' % palavras[2] )
    ↳ A terceira palavra é ---| house |---
    
    # inserindo mais uma 'house'
    » palavras[3] = 'house'
    » palavras.count('house')
    ↳ 2
    
    # o índice de 'coisa'
    » palavras.index('coisa')
    ↳ 5
    
    # index retorna a 1ª ocorrência
    » palavras.index('house')
    ↳ 2
    
    # inserir um objeto na posição 3
    » palavras.insert(3, 'estrela')
    » print(palavras)
    ↳ ['pequeno', 'palha', 'lá', 'estrela', 'house', 'house', 'grande', 'gato', 'gado', 'fato', 'coisa']
    
    # extrai e retira elemento por índice
    » saiu = palavras.pop(3)
    » print(saiu)
    ↳ estrela
    
    # a lista fica sem esse elemento
    » print(palavras)
    ↳ ['pequeno', 'palha', 'lá', 'house', 'house', 'grande', 'gato', 'gado', 'fato', 'coisa']
    
    # remove não retorna o item removido
    » palavras.remove('house')
    » print(palavras)
    ↳ ['pequeno', 'palha', 'lá', 'house', 'grande', 'gato', 'gado', 'fato', 'coisa']
    
    # o item deve estar na lista ou exceção será lançada
    » palavras.remove('pedra')
    ↳ ValueError: list.remove(x): x not in list
    

    O método .sort() ordena itens de uma lista. Ele admite os parâmetros opcionais key, reverse que podem ser usados para fazer ordenamentos diferentes que o default. Por ex., se key = len o ordenamento se dará por comprimento das palavras, da menor para a maior. Se, além disso reverse = True o ordenamento se dará no sentido contrário. Também se pode definir uma função customizada para fazer essa ordenação.

    # ordenar
    » palavras.sort()
    » print(palavras)
    ↳ ['coisa', 'fato', 'gado', 'gato', 'grande', 'house', 'house', 'lá', 'palha', 'pequeno']
    
    # outra form de ordenar item em qualquer sequência o a função sorted()
    » sorted(palavras)
    ↳ ['coisa', 'fato', 'gado', 'gato', 'grande', 'lá', 'palha', 'pequeno']
    # a lista palavras não é alterada
    
    # inverter a ordenação
    » palavras.reverse()
    » print(palavras)
    ↳ ['pequeno', 'palha', 'lá', 'house', 'house', 'grande', 'gato', 'gado', 'fato', 'coisa']
    
    » palavras.sort(key= len)
    » palavras
    ↳ ['lá', 'gato', 'gado', 'fato', 'palha', 'coisa', 'grande', 'pequeno']
    
    » palavras.sort(key= len, reverse=True)
    ↳ ['pequeno', 'grande', 'palha', 'coisa', 'gato', 'gado', 'fato', 'lá']
    

    Métodos das listas (lists)

    Método ação
    append() insere elementos na lista
    clear() remove todos os elementos na lista
    copy() retorna uma cópia da lista
    count() returns número de elementos com valor especificado
    extend() insere os elementos de outra lista (ou iterável) ao final da lista
    index() returna o índice do 1º elemento com valor especificado
    insert() insere elemento em posição especificada
    pop() remove elemento em posição especificada
    remove() remove elemento em posição especificada por índice
    reverse() inverte a ordem da lista
    sort() ordena a lista

    Além desses as seguintes funções são úteis para se tratar com sequências:

    Função Descrição
    cmp(x, y) compara dois valores
    len(seq) retorna o comprimento da sequência
    list(seq) converte uma sequência em lista
    max(args) retorna o valor máximo na sequência
    min(args) retorna o valor mínimo na sequência
    reversed(seq) permite a iteração sobre valores na sequência
    sorted(seq) retorna lista ordenada dos elementos na sequência
    tuple(seq) converte a sequência em uma tuple

    É possível testar se um determinado elemento é membro da lista:

    » 'gado' in palavras
    ↳ True
    
    » 'pedra' in palavras
    ↳ False
    
    » usuarios = [
    »   ['alberto', '1234'],
    »   ['mario', '6282'],
    »   ['maria', '5274'],
    »   ['joana', '9943']
    » ]
    » nome = input('Nome do usuário: ')
    » pin = input('Código PIN: ')
    » msg = 'Accesso liberado' if [nome, pin] in usuarios else 'Acesso negado'
    » print(msg)
    
    # uma entrada de dados que não corresponde a nenhuma entrada da lista
    ↳ Nome do usuário: lucas
    ↳ Código PIN: 1234
    ↳ Acesso negado
    
    # dados de usuário cadastrado
    ↳ Nome do usuário: joana
    ↳ Código PIN: 9943
    ↳ Accesso liberado
    

    Assim como existe uma função interna len() que retorna o comprimentop de sequências, temos também max(), min() que retornam o maior e menor valor dentro da lista. Essas funções funcionam também com string, ordenando-as em ordem alfabética.

    » numeros = [100, 23, 987]
    » print(len(numeros))
    ↳ 3
    
    » print(max(numeros))
    ↳ 987
    
    » print(min(numeros))
    ↳ 23
    
    » print(max(2, 3))
    ↳ 3
    
    » print(min(9, 3, 2, 5))
    ↳ 2
    
    # min e max fazem comparações entre strings:
    » palavras
    ↳ ['pequeno', 'palha', 'lá', 'grande', 'gato', 'gado', 'fato', 'coisa']
    
    » min(palavras)
    ↳ 'coisa'
    
    » max(palavras)
    ↳ 'pequeno'
    

    Tuplas

    Tuplas (tuples) são sequências ordenadas de objetos que podem ser acessados por meio de seu índice (ou index), um marcador de sua posição. Os objetos que a compõem não precisam ser mesmo tipo, são delimitados por colchetes e separados por vírgulas.

    lista = (valor_0, ..., valor_n)

    Tuplas e listas se comportam de modo análogo, exceto em que tuplas são imutáveis (como as strings), não podem ser alteradas após sua criação.Existem razões técnicas para a existência de tuplas e não é raro que um método retorne uma tupla ou as demande como parâmetro. Daí a necessidade de conhecê-las.

    # é comum usar tuplas na formatação de strings:
    » print('Essa frase %s %d %s %s %s.' % ('lê', 4, 'palavras','na','tupla'))
    ↳ Essa frase lê 4 palavras na tupla.
    
    # elementos são acessados por índice
    » tupla = (0,1,2,3,4,'cinco')
    » tupla[5]
    ↳ 'cinco'
    
    # tuplas são imutáveis
    » tupla[5] = 5
    ↳ TypeError: 'tuple' object does not support item assignment
    
    # um erro é lançado se o índice não existe no objeto 
    » tupla[6]
    ↳ IndexError: tuple index out of range
    
    # tuplas são iteráveis
    » for t in tupla:
    »     print(t, end=', ')
    ↳ 0, 1, 2, 3, 4, cinco,
    
    # a função len funciona para tuplas
    » print(tupla[len(tupla) - 1])
    ↳ cinco
    
    # é o mesmo que
    » print(tupla[- 1])
    ↳ cinco
    
    # tuplas podem conter outras tuplas como elemento
    » a = ('primeiro', 'segundo', 'terceiro')
    » b = (a, 'segundo elemento de b')
    » print('%s' %b[1])
    ↳ segundo elemento de b
    
    » print('%s' % b[0][0])
    ↳ primeiro
    
    » print('%s' % b[0][1])
    ↳ segundo
    
    » print('%s' % b[0][2])
    ↳ terceiro
    

    Métodos das Tuplas (tuples)

    Método Descrição
    count() retorna quantas vezes um valor especificado ocorre na tupla
    index() procura por valor especificado e retorna sua posição

    Conjuntos (sets)

    Conjuntos (sets) são coleções não ordenadas de objetos únicos e imutáveis. Conjuntos podem ser criados listando-se diretamente os elementos ou passando-se uma sequência pelo construtor set().

    conjunto = {e_1, ..., e_n}

    conjunto = set(sequencia)

    Por exemplo, abaixo dois sets são criados e as operações de interseção, união e diferença são mostradas. Nenhuma dessa operações alteram os sets envolvidos.

    # dois sets são criados
    » X = {'a', 'b', 'c', 'd'}
    » Y = set('cdef')
    » print(X, Y)
    ↳ {'d', 'c', 'b', 'a'} {'f', 'c', 'd', 'e'}
    
    # a interseção é obtida com &
    » X & Y
    ↳ {'c', 'd'}
    
    # a união com |
    » X | Y
    ↳ {'a', 'b', 'c', 'd', 'e', 'f'}
    
    # a diferença de conjuntos
    » X-Y
    ↳ {'a', 'b'}
    
    # compreension list:
    » Z = {i**2 for i in [1,2,3,4] }
    » Z
    ↳ {1, 4, 9, 16}
    
    » type(Z)
    ↳ set
    
    # os elementos podem ser percorridos um a um
    » for i in Z:
    »     print(i, end=', ')
    ↳ 16, 1, 4, 9, 
    
    # testes para pertinência
    » 16 in Z
    ↳ True
    » 5 in Z
    ↳ False
    

    Alternativamente as operações de interseção, união e diferença são feitas com métodos da classe. O set X fica alterado na operação.

    » X = {'a', 'b', 'c', 'd'}
    » Y = {'c', 'd', 'e', 'f'}
    
    # a união de dois sets (fica armazenada em X)
    » X.union(Y)
    » print(X)
    ↳ {'a', 'b', 'c', 'd', 'e', 'f'}
    
    » X = {'a', 'b', 'c', 'd'}
    » Y = {'c', 'd', 'e', 'f'}
    
    # elementos que não são comuns
    » X.symmetric_difference_update(Y)
    » print(X)
    ↳ {'a', 'b', 'e', 'f'}
    
    » X = {'a', 'b', 'c', 'd'}
    » Y = {'c', 'd', 'e', 'f'}
    # elementos em ambos os sets (interseção)
    » X.intersection_update(Y)
    » print(X)
    ↳ {'c', 'd'}
    

    Outros métodos de sets são mostrados.

    # o comprimento é o número de elementos
    » len(Z)
    ↳ 4
    
    # novos elementos podem ser adicionados
    » Z.add(133)
    » Z
    ↳ {1, 4, 9, 16, 133}
    
    # qualquer sequência pode ser adicionada
    » qualquer =[1, 100, 'coisa']
    » Z.update(qualquer)
    » Z
    ↳ {1, 100, 133, 16, 4, 9, 'coisa'}
    
    # um elemento pode ser removido
    » Z.remove('coisa')
    » Z
    ↳ {1, 4, 9, 16, 100, 133}
    
    # um erro é lançado com remove se elemento não existe
    » Z.remove(45)
    ↳ KeyError: 45
    
    # também se pode remover com discard
    » Z.discard(133)
    » Z
    ↳ {1, 4, 9, 16, 100}
    
    # nenhum erro é lançado com discard
    » Z.discard(45)
    
    # para limpar todos os elementos do set
    » Z.clear()
    » Z
    ↳ set()
    
    # para apagar a variável
    » del Z
    » Z
    ↳ NameError: name 'Z' is not defined
    

    Suponha que temos uma lista longa de elementos muitos dos quais podem ser repetidos e queremos que essa lista não contenha repetições. Uma forma de fazer essa limpeza seria transformando a lista em set (que não contém repetições) e depois retornando os dados para uma lista, caso isso seja necessário.

    # queremos remover as repetições de
    » lista_original = [1,2,3,4,4,3,2,1,6,6,7,8,8,8,9]
    » conjunto = set(lista_original)
    » lista_nova= list(conjunto)
    » lista_nova
    ↳ [1, 2, 3, 4, 6, 7, 8, 9]
    

    Seguem mais algumas ilustrações de uso de métodos de sets.

    # cria um set usando compreensão de lista
    » nSet = {i**3 for i in range(4)}
    » nSet
    ↳ {0, 1, 8, 27}
    
    # método pop()
    » print(nSet.pop())
    » print(nSet)
    ↳ 0
    ↳ {1, 27, 8}
    
    » print(nSet.pop())
    » print(nSet)
    ↳ 1
    ↳ {27, 8}
    
    # subset e suoerset
    » A = {1,2}
    » B = {1,2,3}
    » A.issubset(B)
    ↳ True
    
    » A.issuperset(B)
    ↳ False
    
    » B.issuperset(A)
    ↳ True
    

    Métodos dos conjuntos (set)

    Método Descrição
    add() insere elemento no set
    clear() remove todos os elementos do set
    copy() retorna cópia do set
    difference() retorna um set com a diferença entre 2 ou mais sets
    difference_update() remove elementos incluidos no segundo set
    discard() remove item especificado
    intersection() retorna o set interseção de 2 sets
    intersection_update() remove items do set não presentes no segundo set especificado
    isdisjoint() retorna True se os 2 sets são disjuntos
    issubset() retorna True se o set é subconjunto do segundo set
    issuperset() retorna True se o set contém o segundo set
    pop() remove (e retorna) um elemento arbitrário do set
    remove() remove o elemento especificado
    symmetric_difference() retorna o set com a diferença simétrica de dois sets
    symmetric_difference_update() insere a diferença simétrica desse set em outro
    union() retorna um set com a união dos sets
    update() atualiza o primeiro set com sua união com um ou mais sets

    Dicionários (dictionaries)

    Dicionários (dictionaries) são coleções de dados armazenados em pares chave: valor (key: value). A coleção é mutável, ordenada (a partir de Python 3.7) e não admitem valores duplicados. A chave de um dicionário funciona como um índice que permite a recuperação do valor a ele associado. Eles têm a forma geral de

    dict = {key_1:value_1, ..., key_1:value_1}

    As chaves são ordenadas e podem ser diversos tipos. Valores podem ser de qualquer tipo e podem ser alterados. Por exemplo:

    # inicializando um dicionário
    » dic = {'casa':'house', 'cachorro':'dog', 'caneta':'pencil','carro':'car'}
    » dic
    ↳ {'casa': 'house', 'cachorro': 'dog', 'caneta': 'pencil', 'carro': 'car'}
    
    » print(type(dic)) 
    ↳ <class 'dict'>
    
    # acessando o valor com chave = 'caneta'
    » dic['caneta']
    ↳ 'pencil'
    
    # a função len retorna quantos pares existem no dicionário
    » len(dic)
    ↳ 4
    
    # chaves duplicadas são substituídas
    » dic2 = {"nome" : "Pedro",
    »         "sobrenome" : "Pedro",
    »         "idade" : 23,
    »         "idade" : 27
    »         }
    » idade = dic2['idade']
    » print(idade)
    ↳ 27
    

    Um dicionário pode ser criado recebendo uma lista de tuplas em seu construtor, como se mostra no primeiro exemplo abaixo.
    No exemplo seguinte tuplas são usadas como chaves.

    # t é uma lista de tuplas
    » t = [(0, 'zero'),(1, 'um'),(2, 'dois'),(3, 'tres'),(4, 'quatro')]
    » d = dict(t)
    » print(d)
    ↳ {0: 'zero', 1: 'um', 2: 'dois', 3: 'tres', 4: 'quatro'}
    
    » d[3]
    ↳ 'tres'
    
    # usando tuplas como chaves (listas não podem ser usadas)
    » tele = dict()
    » tele['Dirac','Paul'] = 1234567
    » tele['Feynman','Richard'] = 3337773
    » tele['Bohr','Niels'] = 1111111
    » tele['Einstein','Albert'] = 7777777
    
    » print(tele)
    ↳ {('Dirac', 'Paul'): 1234567, ('Feynman', 'Richard'): 3337773, ('Bohr', 'Niels'): 1111111, ('Einstein', 'Albert'): 7777777}
    
    # o dicionário pode ser percorrido lendo-se os dois valores da tupla
    » for a,b in tele:
    »     print(a,b, tele[a,b] )
    ↳ Dirac Paul 1234567
    ↳ Feynman Richard 3337773
    ↳ Bohr Niels 1111111
    ↳ Einstein Albert 7777777
    
    # o dicionário também pode ser percorrido lendo-se a tupla
    » for t in tele:
    »     print(t, tele[t] )
    
    ↳ ('Dirac', 'Paul') 1234567
    ↳ ('Feynman', 'Richard') 3337773
    ↳ ('Bohr', 'Niels') 1111111
    ↳ ('Einstein', 'Albert') 7777777
    
    # para recuperar um valor é necessário fornecer a tupla inteira
    » c = ('Bohr','Niels')
    » tele[c]
    ↳ 1111111
    

    Se as chaves são strings simples elas podem ser especificadas como argumentos nomeados. Abaixo uma lista de IDHs dos estados do sudeste. Não existe um índice numérico associado aos elementos dos dicionários embora objetos de qualquer tipo (imutável) podem ser usados como chave. Dicionários mantém a ordem em que foram criados mas sempre retornam o mesmo valor para cada chave.

    » idh = dict(
    »     SP=0.833,
    »     RJ=0.832,
    »     ES=0.802,
    »     MG=0.800
    » )
    » idh
    ↳ {'SP': 0.833, 'RJ': 0.832, 'ES': 0.802, 'MG': 0.8}
    
    # dicionários não podem ser acessados por índices
    » idh[1]
    ↳ KeyError: 1
    
    » d = {0: 'a', 1: 'b', 2: 'c', 3: 'd'}
    » d[3]
    ↳ 'd'
    
    # O dicionário mantém a ordem de criação
    » d = {2: 'c', 1: 'b', 0: 'a',  3: 'd'}
    » d[3]
    ↳ 'd'
    
    # o dicionário abaixo é inicializado vazio e preenchido de modo incremental
    » pessoa = {}
    » pessoa['nome'] = 'Edvaldo'
    » pessoa['sobrenome'] = 'Santos'
    » pessoa['idade'] = 41
    » pessoa['profissao'] = 'dentista'
    » pessoa['filhos'] = {'João':3, 'Ana':7, 'Marco':10 }
    » pessoa['irmaos'] = ['Paulo', 'Eliane']
    
    » pessoa
    ↳ {'nome': 'Edvaldo',
    ↳  'sobrenome': 'Santos',
    ↳  'idade': 41,
    ↳  'profissao': 'dentista',
    ↳  'filhos': {'João': 3, 'Ana': 7, 'Marco': 10},
    ↳  'irmaos': ['Paulo', 'Eliane']}
    

    O dicionário pessoa tem uma lista associada ao valor irmaos e um dicionário associado ao valor filhos. A idade do filho que se chama Marco é pessoa['filhos']['Marco']. Naturalmente que uma estrutura muito complexa de vários itens aninhados pode ser difícil de manipular, portanto o bom senso deve prevalecer na construção desses objetos.

    Valores são mutáveis (podem ser alterados). Chaves e valores podem ser percorridos separadamente ou como tuplas.

    » dic2 = {"nome" : "Pedro",
    »         "sobrenome" : "Pedro",
    »         "idade" : 27
    »         }
    
    # os valores são mutáveis
    » dic2['sobrenome'] = 'Alves'
    » dic2
    ↳ {'nome': 'Pedro', 'sobrenome': 'Alves', 'idade': 27}
    
    # as chaves podem ser lidas como uma lista
    » chaves = dic2.keys()
    » chaves
    ↳ dict_keys(['nome', 'sobrenome', 'idade'])
    
    » for chave in chaves:
    »     print(dic2[chave])
    ↳ Pedro
    ↳ Alves
    ↳ 27
    
    # os valores podem ser lidos como uma lista
    » valores = dic2.values()
    » valores
    ↳ dict_values(['Pedro', 'Alves', 27])
    
    # percorrendo os valores
    » for t in valores:
    »     print(t)
    ↳ Pedro
    ↳ Alves
    ↳ 27
    
    # percorrendo as chaves
    » for t in chaves:
    »     print(t)
    ↳ nome
    ↳ sobrenome
    ↳ idade
    
    # valores e chaves podem ser lidos como uma lista de tuplas
    » itn = dic2.items()
    » itn
    ↳ dict_items([('nome', 'Pedro'), ('sobrenome', 'Alves'), ('idade', 27)])
    
    # os pares podem ser percorridos
    » for (k,v) in itn:
    »     print(k,v)
    ↳ nome Pedro
    ↳ sobrenome Alves
    ↳ idade 27
    
    # verificando se uma chave está no dicionário
    » if 'idade' in dic2:
    »     print('idade é uma das chaves')
    ↳ idade é uma das chaves
    
    » if 'peso' in dic2:
    »     print('peso é uma das chaves')
    # nada é impresso
    

    Diversos métodos são pré-programados com a classe dos dicionários. Vemos abaixo o uso de pop(), popitem() e copy(). Uma lista de métodos pode ser vista no final dessa seção.

    # o método update serve para alterar o valor atribuído a uma chave
    # e/ou inserir um novo par chave:valor
    » dic2.update({'idade':19, 'sexo':'masc'})
    » dic2
    ↳ {'nome': 'Pedro', 'sobrenome': 'Alves', 'idade': 19, 'sexo': 'masc'}
    
    # um par chave valor pode ser inserido diretamente
    » dic2['telefone'] = '21-991111110'
    » dic2
    ↳ {'nome': 'Pedro',
    ↳  'sobrenome': 'Alves',
    ↳  'idade': 19,
    ↳  'sexo': 'masc',
    ↳  'telefone': '21-991111110'}
    
    # um par pode ser removido pela chave
    » dic2.pop('sexo')
    » dic2
    ↳ {'nome': 'Pedro',
    ↳  'sobrenome': 'Alves',
    ↳  'idade': 19,
    ↳  'telefone': '21-991111110'}
    
    # o método popitem() remove o último item inserido (após versão 3.7)
    » dic2.popitem()
    ↳ ('telefone', '21-991111110')
    
    # dic2 fica alterado
    » dic2
    ↳ {'nome': 'Pedro', 'sobrenome': 'Alves', 'idade': 19}
    
    # cópias de dicionários
    # a atribuição abaixo atribui a dic3 o mesmo objeto que dic2
    » dic3 = dic2
    » dic3['idade'] = 67
    
    # dic2 fica alterado
    » dic2
    ↳ {'nome': 'Pedro', 'sobrenome': 'Alves', 'idade': 67}
    
    # para criar cópia independente (criando um novo objeto) usamos
    » dic4 = dic2.copy()
    # ou, usando o instanciador do objeto
    » dic4 = dict(dic2)
    
    # agora dic4 pode ser alterado sem afetar dic2
    » dic4['idade'] = 3
    » dic2
    ↳ {'nome': 'Pedro', 'sobrenome': 'Alves', 'idade': 67}
    

    Dicionários podem ser aninhados ou seja, um dicionário pode conter outros dicionários como itens.

    # o construtor pode receber diretamente os dicionários
    » irmaos = {
    »          1:{'nome':'Maria' , 'nasc':1989},
    »          2:{'nome':'Marcos' , 'nasc':1991},
    »          3:{'nome':'Marla' , 'nasc':2000},
    »          }
    
    # talvez seja mais legível definir separadamente (o que é equivalente)
    » irmao1 ={'nome':'Maria' , 'nasc':1989}
    » irmao2 = {'nome':'Marcos' , 'nasc':1991}
    » irmao3 ={'nome':'Marla' , 'nasc':2000}
    » irmaos = {1:irmao1, 2:irmao2,3:irmao3}
    
    # em qualquer dos casos ficamos com o dicionário
    » irmaos
    ↳ {1: {'nome': 'Maria', 'nasc': 1989},
    ↳  2: {'nome': 'Marcos', 'nasc': 1991},
    ↳  3: {'nome': 'Marla', 'nasc': 2000}}
    
    # para acessar a data de nascimento do segundo irmão fazemos
    » irmaos[2]['nasc']
    ↳ 1991
    # lembrando que, nesse caso, 2 não é um índice mas a chave do dicionário.
    

    Vamos usar um dicionário para contar quantas letras existem em uma palavra ou frase. Para isso criamos um dicionário vazio e iteramos pelas letras da palavra, usando a letra como índice e contagem como valor. A operação palavra.lower().replace(' ', '') transforma todas as letras em minúsculas e elimina espaços. set(palavra) pega as letras da palavra sem repetições. O método string.count(sub) conta quantas vezes a substring sub aparece na string.

    # dicionário (contar quantas letras há em uma palavra)
    » def letras(palavra):
    »     ''' recebe parametro palavra (string)
    » 
    »     retorna dicionário {letra: contagem}
    »     onde contagem é o número de letras = letra
    »     Todas as letras são transformadas em minúscula
    »     espaços são ignorados
    »     '''
    »     palavra = palavra.lower().replace(' ', '')
    »     contagem = {}
    »     for t in set(palavra):
    »         contagem[t] = palavra.count(t)
    »     return contagem
    
    # quais e quantas letras
    » dic = letras('Oftalmotorrinolaringologista') 
    » print(dic)
    ↳ {'o': 6, 'f': 1, 't': 3, 'a': 3, 'l': 3, 'm': 1, 'r': 3, 'i': 3, 'n': 2, 'g': 2, 's': 1}
    
    # quantas letras 't'?
    » dic['t']
    ↳ 3
    
    # o método get(chave, default) retorna o valor relativo à chave
    # ou o valor default, caso a chave não seja encontrada
    » dicOftal.get('t',0)
    ↳ 3
    # não existe a letra 'b'
    » dicOftal.get('b',0)
    ↳ 0
    
    # espaços são ignorados
    » print(letras('Rio de Janeiro'))
    ↳ {'r': 2, 'i': 2, 'o': 2, 'd': 1, 'e': 2, 'j': 1, 'a': 1, 'n': 1}
    

    Métodos dos dicionários (dictionary)

    Método Descrição
    clear() remove todos os elementos from the dictionário
    copy() retorna uma cópia do dicionário
    fromchaves() retorna dicionário com chaves e valores especificados
    get() retorna o valor relativo a chave dada, ou valor default dado
    items() retorna uma lista contendo uma tupla para cada par chave:valor
    chaves() retorna lista com as chaves do dicionário
    pop() remove o elemento relativo à chave especificada
    popitem() remove o último par chave:valor inserido
    setdefault() retorna o valor relativo à chave dada. Se a chave não existe insere chave:valor
    update() Atualiza o dicionário com pares chave:valor dados
    valors() retorna uma lista com os valores do dicionário
    🔺Início do artigo

    Bibliografia

    Consulte a bibliografia no final do primeiro artigo dessa série.

    Python, testes, laços e funções

    Python

    Testes lógicos e Laços

    As linhas de código em um programa são executadas de cima para baixo, na ordem em que aparecem. Muitas tarefas podem ser executadas com esse esquema de coisas. No entanto a funcionalidade do código fica muito aumentada quando se insere os testes lógicos e laços.

    if, elif, else

    É possível alterar a ordem de execução de um programa usando testes e laços (loops). Para ver isso usaremos o comando input() que abre um caixa de interação com o usuário para ler um input de teclado. Em seguida um teste é realizado com a valor digitado pelo usuário e ocorre uma ramificação na execução do código, dependendo do valor inserido.

    » i = int(input('Digite um número: '))
    » if i > 10:
    »    print(i, 'é maior que 10.')
    » else:
    »    print(i, 'não é maior que 10!')
    
    ↳ Digite um número: 6
    ↳ 6 não é maior que 10!
    
    ↳ Digite um número: 12
    ↳ 12 é maior que 10.
    

    A sintaxe completa do teste lógico é:

    if booleano_1:
        execute_1
    elif booleano_2:
        execute_2
    ... outros elifs, se necessário
    else:
        execute_3
    

    Note que booleano_1 (e 2) são booleanos (True ou False) ou expressões que são avaliadas como booleanos. As linhas execute_1 (2 ou 3) são quaisquer comandos ou sequência de comandos. Se booleano_1 for True o código em execute_1 é executado e o teste é abandonado (nenhuma das demais linhas são executadas). Se booleano_2 (após elif) for True o código em execute_2 é executado. Se nenhum dos testes resultar em True o código depois de else é executado. Tanto elif quanto else são opcionais.

    No Python o escopo de cada teste ou laço é marcado por indentação (espaços ou tabs), e não por chaves {}, como é mais comum em outras linguagens de programação. É costume se usar 4 espaços, e não tabulações para marcar esse escopo. Outro exemplo:

    » i = int(input('Digite um número: '))
    » if i < 10:
    »    print(i, 'é menor que 10.')
    » elif i < 20:
    »    print(i, 'é maior ou igual a 10 mas menor que 20!')
    » elif i < 30:
    »    print(i, 'é maior ou igual a 20 mas menor que 30!')    
    » else:
    »    print(i, 'é maior ou igual a 30!')
    
    ↳ Digite um número: 17
    ↳ 17 é maior ou igual a 10 mas menor que 20!
    

    Observe que, como o número digitado foi i = 17 o segundo teste foi satisfeito e as demais linhas ignoradas.

    O operador ternário também é útil para gerar código sintético e de fácil leitura. Ele tem a seguinte sintaxe:
    valor_1 if teste else valor_2. Ele retorna valor_1 se a teste for verdadeira, valor_1 se falsa.

    # operador ternário
    » i = 3
    » texto = 'MAIOR que 5' if i > 5 else 'MENOR ou IGUAL a 5'
    » print(texto)
    ↳ MENOR ou IGUAL a 5
    

    O mesmo teste admite outra sintaxe que é menos usada mas aparece em alguns códigos. Ela pode ajudar a tornar legígel o código, dependendo da situação. Ela tem a seguinte forma: de (valor_2, valor_1)[teste], retornando valor_1 se [teste] for verdadeiro, ou valor_2 se for falso.

    » for i in range(5):
    »     txt = str(i) + ' é ' + ('impar', 'par')[i % 2 == 0]
    »     print(txt)
        
    ↳ 0 é par
      1 é impar
      2 é par
      3 é impar
      4 é par
    

    O método str() transforma a variável de inteiro em texto para que possa ser concatenada com outras strings. O teste verifica se o resto da divisão de i por 2 é zero, ou seja, se i é par ou não.

    Testes lógicos compostos podem ser implementados com os operadores lógicos and, or e not:

    and or not
    True and True = True True or True = True not True = False
    True and False = False True or False = True not False = True
    False and True = False False or True = True
    False and False = False False or False = False

    Laços for e while


    Outra estrutura útil de controle do fluxo de execução do código são os laços for. Eles servem para percorrer valores dentro de um objeto iterável.

    » for letra in 'Python':
    »    # dentro do loop letra = P, y, t, h, o, n, sucessivamente
    »    if letra == 'y':
    »        print('Chegamos na letra', letra)
    ↳ Chegamos na letra y
    

    A variável letra assume os valores P, y, t, h, o, n, sucessivamente mas apenas quando é a letra y uma mensagem é impressa. Observe os oito espaços abaixo do teste if.

    É comum que uma operação tenha que ser repetida um determinado número de vezes. Isso pode ser feito criando um objeto iterável e percorrendo seus valores.

    # primeiro percorremos uma tupla
    » for t in (1,3,5,7,9):
    »    print(t, end=', ')
    ↳ 1, 3, 5, 7, 9,
    
    # criamos uma 'faixa' de números (range) de 0 a 10, exclusive
    » for t in range(10):
    »     print(t, end=', ')
    ↳ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
    

    Nos dois casos acima usamos o parâmetro end para a função print para que ela não insira uma quebra de linha após cada impressão, que é o comportamento default. A instrução else pode ser usada para inserir código a ser executado no final do loop.

    » alunos = ['Martha', 'Renato', 'Paula']
    » for n in alunos:
    »      print(n, end=", ")
    » else:
    »      print("Todos os nomes foram listados!")
    
    ↳ Martha Renato Paula 
    ↳ Todos os nomes foram listados!
    

    Instruções break, continue e pass são usadas dentro de laços para alterar o fluxo de execução. break interrompe o laço, continue instrui pela continuação e passserve apenas para marcar uma posição nas linhas de código, sem executar nenhuma tarefa. No exemplo abaixo o laço for percorre números de 0 até 99. O laço é abandonado quando num = 50.

    » for num in range(100):
    »     if num < 50:
    »         continue
    »     else:
    »         break
    » print(num)
    ↳ 50
    

    Também são permitidos laços while que executam operações enquanto uma condição for verdadeira. No exemplo abaixo inicializamos a variável i = 1 e percorremos o laço enquanto i < 10. Dentro do laço a variável é impressa e incrementada de 1. O caracter especial “\n” serve para que uma quebra de linha seja inserida.

    » i = 1
    » while i < 10:
    »     print(i, end=' ')
    »     i += 1
    » print('\nFim do loop. i =', i)
    ↳ 1 2 3 4 5 6 7 8 9 
    ↳ Fim do loop. i = 10
    

    Não é raro criarmos um laço infinito a ser abandonado sob condição dada.

    » num = 0
    » while True:
    »     num +=1
    »     if num == 50:
    »         print('cinquenta')
    »     if num >= 100:
    »         break
    » print(num)
    ↳ cinquenta
    ↳ 100
    

    Advertência: Sempre que se usa laços deve-se ter certeza de que o laço termina após um número finito de iterações. Caso contrário a execução do código entra em um loop infinito que pode exigir uma interrupção forçada. Por exemplo, o código abaixo entra em um loop infinito.

    » while True:
    »     pass
    

    Para interromper esse loop você pode apertar CTRL-C se estiver em sessão interativa do Python. No Jupyter Notebook aperte ■ na barra de ferramentas ou I-I com o cursor no modo de controle da célula.

    Funções


    Uma outra alternativa para alterar o fluxo de execução do código são as funções. Sempre que um bloco de código (um conjunto de operações) deve ser executado várias vezes esse bloco pode ser colocado dentro de uma função. As funções podem ser muito úteis para reaproveitamente do código dentro do módulo que em se está trabalhando ou mesmo em outros módulos diferentes. Funções são criadas e executadas da seguinte forma:

    # definição
    def nome_da_funcao(argumentos):
        operações # usando os argumentos
        return valor# uso da funçãonome_da_funcao(argumentos)
    

    Nessa definição argumentos são um ou diversos objetos de quaisquer tipo que contém as informações que serão usadas no corpo da função. As operações podem conter instruções de qualquer tipo, tais como a impressão de texto, de leitura ou gravação de arquivos, ou o cálculo de valor a ser retornado pela função. A instrução return é opcional.

    » def minha_funcao(numero1, numero2):
    »     resultado = numero1 ** numero2
    »     return resultado
    
    # para calcular 23
    » minha_funcao(2,3)
    ↳ 8
    
    # a chamada à função pode ser usada dentro de um cálculo
    » minha_funcao(2,10) - 24
    ↳ 1000
    

    Os argumentos (ou parâmetros) das funções podem ter um valor default. Os parâmetros com valor default devem sempre ser inseridos por último, na definição da função.

    » def outra_funcao(numero1, numero2 = 3):
    »     return numero1 ** numero2
    
    # se numero2 for omitida ela assume o valor default
    » outra_funcao(6,)
    ↳ 216
    
    # se numero2 for fornecida o valor default é sobrescrito
    » outra_funcao(6,2)
    ↳ 36
    

    Parâmetros podem ser chamados por palavras chaves (keywords). Nesse caso eles podem aparecer em qualquer ordem, desde que nomeados durante a chamada à função.

    » def funcao(a, b):
    »     return 10 * a + b
    
    # chamando a função sem usar palavras chaves
    » funcao(10, 5)
    ↳ 105
    
    # usando as palavras chaves
    » funcao(b = 2, a = 11)
    ↳ 112
    

    Finalmente se pode passar um número arbitrário de argumentos passando um objeto iterável para a função. Isso é útil quando se escreve uma função que deve agir sobe um número desconhecido de argumentos. Isso é feito colocando-se um asterisco (*) antes do parâmetro.

    » def somar(*numeros):
    »     soma = 0
    »     for num in numeros:
    »         soma += num
    »     return soma
    
    # exemplo de uso
    » somar(1,34,67,23,876)
    ↳ 1001
    

    Para consolidar o conceito de função vamos considerar o exemplo de uma função para calcular o fatorial de um número inteiro. Por definição o fatorial de n é n! = 1 * 2 * 3 * … * n e 0! = 1.

    » def fatorial(n):
    »     fat = 1
    »     while n > 1:
    »         fat *= n
    »         n -= 1
    »     return fat
    
    » fatorial(11)
    ↳ 39916800
    

    Lembrando, n -= 1 é o mesmo que n = n – 1 e fat *= n é fat = fat * n. O loop while só é executado se n = 2 ou maior. Dentro do loop a variável é decrementada de 1 e o produto armazenado em fat.

    Uma definição mais elegante pode ser obtida usando recursividade. A função pode fazer uma chamada a si mesma.

    » def fatorial_recursivo(n):
    »     if n ≤ 1:
    »         return 1
    »     else:
    »         return n * fatorial_recursivo(n-1)
    
    » recur_fatorial(3)
    ↳ 6 
    

    No entanto, é muito comum que uma função de muito uso já esteja incluída em alguma biblioteca do Python, como é o caso da função fatorial que está na biblioteca math. Para usar um recurso que está em uma biblioteca externa ao núcleo básico do Python usamos import.

    » import math
    » math.factorial(11)
    ↳ 39916800
    

    Docstrings

    No Python você pode, e deve, inserir strings de documentação (docstrings) em suas funções para informar o que ela faz, que parâmetros recebe e que tipo dado ela retorna. Essa documentação pode ser consultada no momento em que se pretende usar a função. Docstrings também são inseridos em módulos, classes e métodos do Python.

    A documentação de um objeto é definida inserindo-se uma string na primeira linha de sua definição, como um comentário.

    def uma_funcao(parametros):
        ''' Essa função recebe parâmetros tal e tal; e retorna qual
        '''
        < corpo de função >
        return qual
    

    Docstrings podem ser visualizadas com a propriedade __doc__ do objeto.

    » def quadrado(n):
    »     '''Recebe um número n, retorna n ao quadrado.'''
    »     return n**2
    
    » print(quadrado.__doc__)
    ↳ Recebe um número n, retorna n ao quadrado
    

    Por convenção docstrings devem começar com uma letra maiúscula e terminar com um ponto e a primeira linha deve conter uma breve descrição da função. Caso existam mais de uma linha a segunda deve ficar em branco, separando o resumo do resto da descrição. As demais linhas a devem descrever as convenções de chamada da função, os parâmetros e seu retorno. Ela também deve explicitar as exceções que podem ser lançadas na sua execução.

    As funções pré definidas no python, assim como as importadas, podem igualmente ter suas docstrings consultadas.

    Docstrings também podem ser consultadas com a função help(). Abaixo um exemplo de uma docstring bem estruturada, e o uso de help.

    » def soma_inteiros(i, j):
    »     '''
    »     Retorna a soma de dois inteiros.
    » 
    »             Parâmetros:
    »                     i (int): inteiro
    »                     j (int): inteiro
    »             Retorna:
    »                     string com texto: A soma i + j = soma.
    »     '''
    »     txt = 'A soma %d + %d = %d'% (i,j,i+j)
    »     return txt
    
    » soma_inteiros(45,54)
    
    ↳ 'A soma 45 + 54 = 99'
    
    » help(soma_inteiros)
    
    ↳ Help on function soma_inteiros in module __main__:
    
      soma_inteiros(i, j)
          Retorna a soma de dois inteiros.
        
                  Parâmetros:
                          i (int): inteiro
                          j (int): inteiro
        
                  Retorna:
                          string com texto: A soma i + j = soma.
    

    No Jupyter Notebook a doscstring é exibida pressionando-se Shift-Tab após o nome da função ou objeto.

    Gerenciando erros

    Naturalmente cometemos erros quando escrevemos código. Nesses casos o python gera uma resposta que pode nos ajudar a corrigir o problema. No python erros são denominados exceções.

    Suponha que executamos o seguinte código:

    » x = input('Digite um número: ')
    » y = x + 10
    » print('O valor de y é %d' % y)
    # o usuário insere o dígito 4 e obtém a resposta
    ↳ x =input('Digite um número: ')
     ----> y = x + 10
           print('O valor de y é %d' % y)
     TypeError: can only concatenate str (not "int") to str
    


    Um erro de tipo foi lançado, TypeError pois o resultado do comando input é uma string, um texto, mesmo que o usuário tenha digitado ‘4’. O erro ocorreu na linha que tenta somar uma string a um número. Vemos que a resposta a um erro é útil e informa onde ele ocorreu. Muitas vezes são dadas sugestões de possíveis reformas ou até mesmo indicações para os manuais. No caso acima esse erro poderia ser resolvido com a inserção da conversão x = int(input('Digite um número: ')) que converteria a string ‘4’ em um dígito 4. Mas, o problema não estaria resolvido se o usuário resolver digitar ‘a’, por exemplo.

    # a string 'a' não pode ser convertida em um inteiro
    » int('a')
    ↳ ValueError: invalid literal for int() with base 10: 'a'
    

    Esse tipo de problema pode ser contornado com as cláusulas try, except, else, finally. Coloque o comando onde um erro pode ocorrer dentro de uma cláusula try.

    » saida = ''    
    » x = input('Digite um número: ')
    » try:
    »     x = int(x)
    » except:
    »     saida = 'Ocorreu um erro.Digite um número, não letra.'
    » else:
    »     y = x + 10
    »     saida = 'O valor da soma é %d' % y
    » finally:
    »     print(saida)
    

    Havendo erro o fluxo de execução é transferido para except, caso contrário para else. Em qualquer dos casos o código após finally é executado.

    # o usuário digita 4:
    ↳ Digite um número: 4
    ↳ O valor da soma é 14
    
    # o usuário digita a:
    ↳ Digite um número: a
    ↳ Ocorreu um erro.Digite um número, não letra.
    

    Existem muitos erros de execução pré-definidos no python. Suponha que exista uma função previamente definida, onde erros de alguns tipos podem ocorrer:

    » try:
    »     execute_alguma_coisa()
    » except SyntaxError:
    »     print('Ocorreu um erro de sintaxe')
    » except TypeError:
    »     print('Erro de tipo de variável!')
    » except ValueError:
    »     print('Um erro de valor!')
    » except ZeroDivisionError:
    »     print('Não é permitido dividor por zero!')
    » else:
    »     print('Relaxa, nada errado aconteceu!')
    » finally:
    »     print('Chegamos ao final...')    
    

    Erros podem ser lançados a força pelo programador, para fins de depuração ou outro motivo qualquer.

    » raise MemoryError("Acabou a memória")
    ↳ MemoryError: Acabou a memória
    
    » raise ValueError("Erro de valor")
    ↳ ValueError: Erro de valor
    
    🔺Início do artigo

    Bibliografia

    Consulte a bibliografia no final do primeiro artigo dessa série.

    Python, strings


    Strings

    Strings são variáveis usadas para armazenar texto. No Python elas são sequências, coleções de caracteres ordenada por posição. A manipulação de strings é um dos pontos fortes do python e existem diversas funções para isso.

    No python strings são definidas com aspas simples (') ou aspas duplas ("). Aspas triplas (''' ou """) podem ser usadas para definir strings longas. String dentro de parentêses são concatenadas, o que é útil para se escrever uma string longa sem perder a legibilidade.

    » string_1 = 'casa'
    » string_2 = ' da mãe Joana'
    » string_longa = '''
                 este é um 
                 exemplo de uma
                 string longa!
                 '''
    » print(string_longa)
    ↳ este é um
           exemplo de uma
           string longa!
    
    » outra_longa = (
         'https://www.phylos.net/'
         '2020-12-16/'
         'pacote-factoranalyser/'
         )
    » print(outra_longa)
    ↳  'https://www.phylos.net/2020-12-16/pacote-factoranalyser/'
    

    Vamos ver alguns exemplos de strings e de suas manipulações:

    # a sequência pode ser percorrida
    » for letra in "banana":
    »     print(letra, end=' ')
    ↳ b a n a n a 
    # usamos end=' ' para evitar quebras de linhas e inserir espaços no lugar
    
    # definimos uma variável de string
    » palavra = 'Pindamonhangaba!'
    
    # len() fornece seu comprimento (quantos caracteres)
    » len(palavra)
    ↳ 16
    # um caracter pode ser obtido por seu índice
    » print(palavra[0], palavra[15])
    ↳ P !
    # índices negativos contam do fim para o início
    » print(palavra[-1])
    ↳ !
    » print(palavra[-2])
    ↳ a
    # palavra[-1] equivale a
    » palavra[len(palavra)-1]
    ↳ '!'
    
    # uma 'fatia' (slice)
    » palavra[1:4]
    ↳ 'ind'
    
    # se o segundo índice for omitido a fatia vai até o fim
    » palavra[5:]
    ↳ 'monhangaba!'
    
    # se o primeiro índice for omitido a fatia começa no início
    » palavra[:5]
    ↳ 'Pinda'
    
    » palavra[:]
    ↳ 'Pindamonhangaba!'
    
    » len(palavra[1:4])
    ↳ 3
    

    Vimos nos exemplos acima que uma fatia (ou slice) palavra[i:f] se inicia em i e termina em f, exclusive. Os índices, e todas as contagens em python se iniciam em 0. A posição final não é incluida de forma que len(palavra[i:j]) = j-1.

    Os operadores + e * (adição e multiplicação) tem significado especial quando os operandos são strings. + promove a concatenação de strings e * retorna uma repetição.

    # Operações com palavras
    » p1 = 'casa'
    » p2 = 'da mãe Joana'
    
    # '+' faz uma concatenação
    » p1 + ' ' + p2
    ↳ 'casa da mãe Joana'
    
    # '*' repete a string
    » p1 * 5
    ↳ 'casacasacasacasacasa'
    

    Alguns operadores lógicos também são permitidos.

    » palavra1 = 'teste'
    » palavra2 = 'Teste'
    
    » palavra1 == palavra2
    ↳ False
    
    » palavra1 != palavra2
    ↳ True
    
    » 't' in palavra1
    ↳ True
    
    » 'y' not in palavra1
    ↳ True
    

    Observe que nenhuma das operações realizadas até agora afetam o conteúdo da variável. Ao contrário, cada uma delas produz uma nova string. Dizemos que strings são imutáveis no python. Como são imutáveis uma string não pode ser alterada in loco. No exemplo abaixo, para alterar ‘rato’ para ‘pato’ é necessário construir nova string e atribuí-la à variável.

    # Strings são imutáveis
    » str = 'rato'
    » str[0]
    ↳ 'r'
    
    # a tentativa de alterar a string resulta em erro
    » str[0] = 'p'
    ↳ TypeError: 'str' object does not support item assignment
    
    # para trocar 'r' por 'p'
    » str = 'p' + str[1:]
    » str
    ↳ 'pato'
    

    Métodos das strings

    Claro que o leitor não precisa se preocupar em memorizar todas essas funções. Uma leitura serve para se ter conhecimento das possibilidades.

    Como objetos, as strings possuem métodos e propriedades (coisas que veremos com mais detalhes mais tarde). A lista abaixo contém alguns métodos.

    Método descrição
    capitalize() converte 1º caracter em maiúsculo
    casefold() converte string em minúsculas
    center() retorna string centralizada
    count() retorna número de ocorrências de um valor especificado na string
    endswith() retorna True se string termina com valor especificado
    find() busca por valor especificado na string e retorna the posição se encontrado
    format() Formata de acordo com valores especificados
    index() busca por valor especificado na string e retorna the posição se encontrado
    isalnum() retorna True se todos os caracteres são alfa-numéricos
    isalpha() retorna True se todos os caracteres são alfabéticos
    isdecimal() retorna True se todos os caracteres são decimais
    isdigit() retorna True se todos os caracteres são dígitos
    islower() retorna True se todos os caracteres são minúsculos
    isnumeric() retorna True se todos os caracteres são numéricos
    isspace() retorna True se todos os caracteres são espaços
    istitle() retorna True se a string segue regra de títulos
    isupper() retorna True se todos os caracteres são maiúsculos
    join() reune elementos de um iterável no final da string
    ljust() retorna a string justificada à esquerda
    lower() converte a string para minúsculas
    lstrip() retorna a string sem espaços à esquerda
    partition() retorna tuple partindo a string em 3 partes
    replace() substitui trecho da string por outro especificado
    rfind() busca trecho especificado value e retorna última posição
    rindex() busca trecho especificado value e retorna última posição
    rjust() retorna string justificada à direita
    rsplit() quebra a string no separador especificado, retornando lista
    rstrip() retorna a string sem espaços à direita
    split() quebra a string no separador especificado, retornando lista
    splitlines() quebra a string nas quebras de linha, retornando lista
    startswith() retorna True se string começa com valor especificado
    strip() retorna a string sem espaços laterais
    swapcase() inverte minúsculas e maiúsculas
    title() converte em maiúscula o 1º caracter de cada palavra
    upper() converte a string em maiúsculas
    zfill() preencha com número de zeros especificado, no início

    Nota sobre o método format() abaixo. Alguns exemplos de uso são apresentados a seguir.

    » str = 'uma palavra qualquer'
    # tornar a primeira letra maiúscula
    » str.capitalize()
    ↳ 'Uma palavra qualquer'
    
    # contar quantas letras 'a' existem na string
    » str.count('a')
    ↳ 5
    
    # a string termina com 'r'?
    » str.endswith('r')
    ↳ True
    
    # em que posição 'qu' está na string
    » str.find('qu')
    ↳ 12
    
    # se o trecho procurado não existe na string
    » str.find('y')
    ↳ -1
    
    » str.isnumeric()
    ↳ False
    
    » '1234567890'.isnumeric()
    ↳ True
    
    » str.replace('palavra','coisa')
    'uma coisa qualquer'
    
    » str.startswith('un')
    ↳ False
    
    # join é usada para concatenar strings
    » uma_tupla = ('Carro', 'Casa', 'Gado')
    » x = '-'.join(uma_tupla)
    » print(x)
    ↳ Carro-Casa-Gado
    
    # exemplo de uso para join, construindo uma tabela html
    » html = '<table><tr><td>'
    » html += '</td><td>'.join(uma_tupla)
    » html += '</td></tr></table>'
    » print(html)
    ↳ <table><tr><td>Carro</td><td>Casa</td><td>Gado</td></tr></table>
    
    # lembrando que x = 'Carro-Casa-Gado'
    » for txt in x.split('-'):
    »     print(txt)
    ↳ Carro
           Casa
           Gado
    
    # quebrando uma frase em palavras
    » frase = 'A segunda palavra da frase'
    » frase.split(' ')[1]
    ↳ 'segunda'
    

    No exemplo abaixo str é quebrada nos espaços, pegando cada palavra em separado. O primeiro caso imprime a palavra que começa com ‘r’ e termina com ‘a’. O segundo imprime a palavra que começa com ‘p’ e não termina com ‘a’.

    » str = 'pato pata rato rata'
    
    » for palavra in str.split(' '):
    »     if palavra.startswith('r') and palavra.endswith('a'):
    »         print(palavra)
    ↳ rata
    
    » for palavra in str.split(' '):
    »     if palavra.startswith('p') and not palavra.endswith('a'):
    »         print(palavra)
    ↳ pato
    

    Existem alguns mecanismos de apoio à formatação de strings, particularmente útil na impressão de resultados. Os sinais especiais %d e %s podem ser usados na montagem de strings, o primeiro como substituto de um dígito, o segundo de texto. %f informa a substituição por número de ponto flutuante %.nf ponto flutuante com n casas decimais, %E de número com notação científica (usando potências de 10).

    » s1 = 'Uma string com um dígito e texto: dígito: %d; texto: %s' % (10, 'dez')
    » print(s1)
    ↳ Uma string com um dígito e texto: dígito: 10; texto: dez
    
    print('Um inteiro convertido em ponto flutuante: %f' % 5)
    ↳ Um inteiro convertido em ponto flutuante: 5.000000
    
    print('Exibir o número %.02f com 2 casas decimais' % 25.123456)
    ↳ Exibir o número 25.12 com 2 casas decimais
    
    print('Um número com notação científica: %E' % 6.789E7)
    ↳ Um número com notação científica: 6.789000E+07
    

    Um método mais moderno de formatação consiste um usar string.format(), que permite código mais legível.

    # marcadores nomeados são supridos por format
    » txt1 = "Eu me chamo {nome} e tenho {idade} anos.".format(nome = 'João', idade = 36)
    
    # os lugares podem ser marcados numericamente
    » txt2 = "Moro em {0}, {1} há {2} anos.".format('Brasília', 'DF', 20)
    
    # ou marcados apenas por sua ordem de aparecimento
    » txt3 = "{} são convertidos em {}. Exemplo: {}.".format('Dígitos', 'strings', 100)
    
    » print(txt1)
    ↳ Eu me chamo João e tenho 36 anos.
    
    » print(txt2)
    ↳ Moro em Brasília, DF há 20 anos.
    
    » print(txt3)
    ↳ Dígitos são convertidos em strings. Exemplo: 100.
    
    # controle do número de casas decimais
    » txt4 = 'Esse livro custa R$ {preco:.2f} com desconto!'.format(preco = 49.8)
    » print(txt4) 
    ↳ Esse livro custa R$ 49.80 com desconto!
    

    Também existe o chamado método de interpolação de strings que usa o prefixo f para que a string possa incorporar variáveis.

    » nome = 'Albert'
    » sobrenome = 'Einstein'
    » ano = 1879
    » print(f'O físico {nome} {sobrenome} nasceu em {ano}')
    ↳ O físico Albert Einstein nasceu em 1879
    
    # podemos inserir operações dentro da string de formatação
    » a = 214
    » b = 3
    » print(f'{a} multiplicado por {b} é {a * b}.')
    ↳ 214 multiplicado por 3 é 642.
    

    Observe que strings justapostas são concatenadas. No entanto isso gera um código menos claro. O método de interpolação torna o código de mais fácil entendimento.

    print('Paul ''Adrien ''Maurice ''Dirac' ' nascido em ' '1902')
    Paul Adrien Maurice Dirac nascido em 1902
    
    fisico = 'P. A. M. Dirac'
    ano = 1902
    print(f'O físico {fisico} nascem em {ano}' )
    O físico P. A. M. Dirac nascem em 1902
    

    Caracteres de escape

    Caracteres especiais podem ser inseridos em uma string por meio de “escapes”. Por exemplo, para usar aspas em uma string podemos fazer o seguinte:

    # inserindo aspas simples em string
    » print('O cara se chama O\'Maley')
    ↳ O cara se chama O'Maley
    
    # o mesmo poderia ser feito com aspas duplas
    » print("O cara se chama O'Maley")
    ↳ O cara se chama O'Maley
    
    » print("E seu primeiro nome é \"George\"")
    ↳ E seu primeiro nome é "George"
    
    # quebra de linha
    » print('linha1\nlinha2')
    ↳ linha1
    ↳ linha2
    
    código significado
    \’ aspas simples
    \” aspas duplas
    \\ barra invertida
    \n nova linha
    \r retorno de “carro”
    \t tab, tabulação
    \b backspace, volta 1 espaço
    \f form feed
    \ooo valor octal
    \xhh valor hexadecimal
    🔺Início do artigo

    Continue a leituira: Python, testes, laços e funções

    Bibliografia

    Consulte a bibliografia no final do primeiro artigo dessa série.

    Python, uma introdução

    Programação

    Um computador é uma máquina eletrônica com capacidade para armazenar valores numéricos em formato binário e instruções de manipulação desses valores armazenados. Informações não numéricas, como letras, palavras e imagens, precisam ser convertidas em binários para que possam ser tratados. Nos primeiros tempos da computação a interação com as máquinas era muito difícil e um programador tinha que escrever códigos muito complexos, como diretamente em linguagem de máquina ou assembly. Hoje, após muito aperfeiçoamento, as linguagens modernas abstraem as camadas mais complexas de interação com o computador. O código tem a aparência de uma linguagem natural humana e pode ser lido quase como um texto comum.

    Um exemplo pode ilustrar essa descrição. Considere que uma pessoa possui uma caixa cheia de bolas pretas e brancas. Ela quer saber qual é a porcentagem de bolas pretas, no total. Uma possível solução seria o seguinte procedimento, usando um bloco de notas para registrar bolas pretas e brancas:

    1. tire uma bola da caixa,
    2. verifique se é preta,
    3. se for preta faça uma marca para bolas pretas, caso contrário para as brancas,
    4. sem retornar a bola, verifique se ainda restam bolas na caixa,
    5. se ainda restam bolas, volte para a etapa (1),
    6. se acabaram as bolas, conte quantas marcas foram feitas para cada cor,
    7. calcule porcentagem = pretas/(pretas+brancas)*100 e anote esse resultado.

    Esse procedimento é chamado de algoritmo. A lista de tarefas é análoga à um programa de computador. As marcas feitas para contagem das bolas brancas e pretas são análogas às variáveis do programa.

    Jupyter

    O Python pode ser executado de várias formas diferentes. Existem bons editores e IDEs (Integrated Devolopment Environment) tais como o Pycharm, Geany, Spyder. Para esse tutorial usaremos o Jupyter Notebook. Para maiores informações sobre o Jupyter leia nesse site sobre sua instalação e execução.

    Resumindo, sua instalação pode ser feita instalando-se o Anaconda:

    • Baixe a versão mais recente do Anaconda aqui. Existem instaladores gráficos para Linux, Windows e MacOS.
    • Instale seguindo as instruções na página de download ou contidas no arquivo instalador executável.
    • ou … usuários que conhecem Python e que preferem gerenciar seus pacotes manualmente, pode apenas usar:
      pip3 install jupyter.

    Python

    Python é uma linguagem de programação de alto nível, interpretada e de propósito geral, criada por Guido van Rossum em 1985 e em franco desenvolvimento desde então. Ela está disponível sob a licença GPL (GNU General Public License). Ela permite o uso interativo, com o usuário digitando as linhas de código e obtendo o resultado imediatamente, ou através de lotes (batches), com as linhas de código armazenadas em arquivos e executadas em grupo. Apesar de ser chamada de linguagem de script é possível criar aplicativos completos, na web ou para desktop, com interfaces gráficas modernas e eficientes. Além disso existe a possibilidade de gerar arquivos compilados e executáveis usando Cython.

    Uma grande quantidade de bibliotecas ou módulos que podem ser importados e executados nas sessões do python o tornam atraente para o gerenciamento de bancos de dados, de imagens, a mineração de dados, análise e plotagem sofisticada, inteligência artificial e aprendizado de máquina, além de várias outras aplicações. Você pode procurar por bibliotecas em
    Find, install and publish Python packages with the Python Package Index

    Python é uma linguagem orientada a objetos (um conceito a ser estudado mais tarde) e todos de seus elementos são objetos. Seus conceitos básicos são de rápido aprendizado, apesar da existência das várias bibliotecas para uso específico que podem ser um pouco mais complexas, como ocorre com o pandas.

    Variáveis e operações básicas

    Convenção: Usaremos nesse texto a seguinte convenção: linhas iniciadas com » marcam o código inserido para execução. No Jupyter Notebook são as linhas de código dentro das células. marca os outputs, as linhas de resposta do código. Linhas, ou trechos de linha, iniciadas com # são comentários não executados.

    # Essa linha é um comentário    
    » x = 15        # inserindo um inteiro
    » print(x)
    ↳ 15
    

    Você pode usar o python para fazer operações matemáticas como um calculadora, embora isso raramente seja algo muito útil. Mais interessante é a possibilidade de criar variáveis que armazenam dados. No python uma variável é criada no momento em que se atribui a ela um valor, sem necessidade de informar de que tipo será (o que chamamos de tipagem dinâmica).

    # inicializamos duas variáveis numéricas e uma com uma palavra
    » x = 15           # um número inteiro
    » y = 4.2          # um número de ponto flutuante
    » z = 'Pedro'      # uma palavra ou 'string'
    
    # para ver o conteúdo das variáveis podemos usar o método print
    » print(x)
    ↳ 15
    » print(y)
    ↳ 4.2
    » print(z)
    ↳ Pedro
    
    # podemos ver de que tipo são essas variáveis
    » print(type(x))
    ↳ <class 'int'>
    
    » print(type(y))
    ↳ <class 'float'>
    
    » print(type(z))
    ↳ <class 'str'>
    
    # variáveis podem ser apagadas com
    » del x
    » print(x)
    ↳ NameError: name 'x' is not defined 
    

    O comando print() é uma função interna do python, e serve para exibir o conteúdo de seu parâmetro, no caso as variáveis x, y, z. Quando usamos o Jupyter Notebook uma variável ou expressão avaliada na última linha de uma célula é exibida quando a célula é executada, sem a necessidade de print.

    Usamos type() para ver o tipo de conteúdo armazendo. Os tipos básicos do Python são:

    Tipo Exemplos Nome no Python
    Inteiros 1, -1, 67, -9900 int
    Inteiros longos 123L, -999L long integer
    Ponto flutuante 1.0, 3.14, 345.6, -99.9 double float
    Complexos complex(1, 3), complex(“1+2j”), 1 + j complex
    Booleano True, False bool
    String ‘casa’, “teste de string” string, object

    Com esses tipos básicos se constroi objetos mais complexos, como

    Tipo Exemplos Nome no Python
    Lista [‘a’, ‘b’, ‘c’, ‘d’], [1, 2, 3] list
    Tupla (‘a’, ‘b’, ‘c’, ‘d’), (1, 2, 3) tuple
    Dicionário {1: ‘um’, 2: ‘dois’} dictionary

    Qualquer objeto do python pode ser associado a uma variável, que passa a ser uma representante ou “referência de acesso” a esse objeto. Os nomes de variáveis devem obedecer a algumas regras:

    • só podem conter números, letras e sublinhados (underscores)(A-z, 0-9 e _)
    • deve começar com uma letra ou sublinhado
    • maiúsculas e minúsculas são diferenciadas

    A diferenciação de maiúsculas de minúsculas é válida para toda a linguagem. As variáveis idade, Idade, IDADE são três variáveis diferentes. Além disso existem as palavras reservadas (keywords) que são nomes que fazem parte da sintaxe da linguagem e não podem ser utilizadas para nomes de variáveis:

    Palavras reservadas do python
    and except lambda with
    as finally nonlocal while
    assert false None yield
    break for not
    class from or
    continue global pass
    def if raise
    del import return
    elif in True
    else is try

    Como assumem o lugar dos objetos as variáveis podem ser usadas em lugar deles. Por ex., a operação abaixo faz um cálculo usando 2 variáveis e atribuindo o valor à uma terceria.

    » largura = 2.20
    » altura = 1.10
    » area_retangulo = largura * altura
    » print("A área de retângulo é: " , area_retangulo)
    ↳ A área de retângulo é: 2.42
    

    Nomes de variáveis devem ser escolhidos de forma concisa e elucidativa de seu uso.

    Os seguintes operadores matemáticos formam a base para as operações numéricas usuais.

    Operador significado exemplo
    + Adição x + y
    Subtração x – y
    * Multiplicação x * y
    / Divisão x / y
    % Módulo (resto da divisão inteira) x % y
    ** Exponentiação x ** y
    // divisão inteira x // y

    Para verificar seu comportamento vamos fazer alguns testes.

    # no python se pode declarar 2 variáveis (ou mais) simultaneamente
    » x, y = 3, 8
    » x+y
    ↳ 11
    » x-y
    ↳ -5
    » x*y
    ↳ 24
    » y**x
    ↳ 512
    » x/y
    ↳ 0.375
    # 3 dividido por 8 é 0, com resto 3
    » x % y
    ↳ 0
    » x//y
    ↳ 3
    

    Terminologia: Um comando ou declaração (statement, em inglês) é uma linha com uma instrução única. No código abaixo temos 4 declarações:

    » incremento = 0.2
    » valor = 10
    » valor = valor + incremento
    » print (valor)
    ↳ 10.20
    

    Observe que, diferente das operações matemáticas usuais, a declaração x = x + 1 significa “somar 1 ao valor de x e substituir o resultado em x“.

    Um atalho ou shortcut possível e muito usado é o seguinte:

    # ao invés de escrever
    » i = i + 1
    # podemos escrever, como o mesmo efeito
    » i += 1
    # portanto
    » valor = valor + incremento
    # pode ser escrito como
    » valor += incremento
    

    Outros operadores análogos podem ser usados.

    Operador Exemplo Equivale a
    += Soma a += 2 a = a + 2
    -= Subtração a -= 2 a = a – 2
    *= Multiplicação a *= 2 a = a * 2
    /= Divisão a /= 2 a = a / 2
    %= Módulo a %= 2 a = a % 2
    **= Expoente a **= 2 a = a ** 2
    //= Divisão inteira a //= 2 a = a // 2

    Além dos operadores matemáticos temos os operadores lógicos. Os resultados de operações lógicas são booleanos (True ou False) e eles são a base das decisões feitas em códigos. Alguns desses operadores podem ser usados, como veremos, em outros objetos que não apenas números.

    Operador Significado Exemplo
    > maior que x > y
    >= maior ou igual a x ≥ y
    < menor que x < y
    >= menor ou igual a x ≤ y
    == igual a x == y
    != diferente de x != y

    Exemplos de uso de operações lógicas:

    » num1 = 12
    » num2 = 25
    
    » print(num1 > num2)
    ↳ False
    
    » print(num2 == num1 *2 +1)
    ↳ True
    
    » string1 = 'isso'
    » string2 = 'esse'
    » print(string1 != string2)
    ↳ True
    

    Execução do código em python


    Foi sugerido o uso do Jupyter Notebook para o aprendizado do conteúdo nesse artigo. Isso permite interatividade e facilidade de instalação dos pacotes, bem como uma boa visualização das saídas de código. No entanto muitas vezes é necessário rodar blocos grandes de código sem preocupação com resultados e saídas intermediárias.

    Arquivos contendo comandos python e gravados com a extensão *.py podem ser executados em qualquer máquina que tenha o intérprete instalado. Por exemplo, suponha que temos na pasta de trabalho ativa o arquivo teste.csv e queremos alterar o seu nome. Usando um editor ASCII qualquer, como o Notepad do Windows, Geany ou Gedit no Linux e TextEdit no Mac, gravamos um arquivo com o nome de alterarNome.py, com o seguinte conteúdo:

    #!/usr/bin/env python
    import os
    
    for arq in os.listdir():
        print(arq)
    
    nome_antigo = 'teste.csv'
    nome_novo = 'teste_novo.csv'
    os.rename(nome_antigo, nome_novo)
    

    Para executar esse arquivo abrimos uma sessão do terminal e digitamos:

    » python alterarNome.py
    

    A primeira linha contém o shebang (#!) com a instrução de onde está instalado o python em seu computador. Depois é importada a biblioteca os que contém comandos de interação com o sistema operacional. Seu método os.listdir() retorna uma lista com os arquivos na pasta atual, que são impressos dento do laço for. Se existir na pasta um arquivo teste.csv ele será renomeado para teste_novo.csv. Uma mensagem de erro será exibida se o arquivo teste.csv não existir.

    Continue lendo…

    Python, strings

    🔺Início do artigo

    Bibliografia

    Python.org

    Livros

    • Barry, Paul: Head First Python, O’Reilly, Sebastopol, 2011.
    • Ceder, Vernon: The Quick Python Book, 2 ed., Manning Publications Co., Greenwich, 2010.
    • Downey, Allen: How to Think Like a Computer Scientist, Cambridge University Press, Nova Iorque, 2009.
    • Hall, Tim; Stacey, J-P: Python 3 for Absolute Beginners, Apress, Nova Iorque, 2009.
    • Hetland, Magnus Lie: Beginning Python, From Novice to Professional, Apress, Nova Iorque, 2005.
    • Lambert, Kenneth: Fundamentals of Python: From First Programs Through Data Structures, Cengage, Boston, 2010.
    • Lee, Kent D.: Python Programming Fundamentals, Springer-Verlag, Londres, 2011.
    • Lutz, Mark:Learning Python, 4ª Edição, O’Reilly, Sebastopol, 2005.
    • Payne, James: Beginning Python, Using Python 2.6 and Python 3.1, Wiley, Indianoplis, 2010.
    • Summerfield, Mark: Programming in Python 3, a complete introduction to the Python language, Pearson, Boston, 2010.

    Recursos na internet

    Pandas – Dataframes


    Dataframes do pandas


    Um dataframe é uma forma de armazenar dados em forma tabular, como em uma planilha. O dataframe do pandas consiste em uma coleção de Series que são dispostas como suas colunas. A cada linha está associado um índice que serve para ordenar e selecionar dados. Como Series, cada coluna tem um tipo definido. No entanto, não é necessário que todas as colunas tenham o mesmo tipo e portanto dados de tipos diferentes podem ser armazenados.

    Muitas operações com dataframes levam em consideração o eixo ou axis. O default é axis = 0 (ou axis = 'index') o que indica operação sobre as linhas. axis = 1 (ou axis = 'column') indica operação realizada sobre as colunas.

    O método mais comum de se criar um dataframe consiste em passar um dicionário e uma lista de índices para o construtor.

    In [1]: import pandas as pd
    In [2]: import numpy as np
    In [3]: dados = {
                    'nome': ['Pedro', 'Maria', 'Janaina', 'Wong', 'Roberto', 'Marco', 'Paula'],
                    'cidade': ['São Paulo', 'São Paulo', 'Rio de Janeiro', 'Brasília',
                               'Salvador', 'Curitiba', 'Belo Horizonte'],
                    'idade': [34, 23, 32, 43, 38, 31, 34],
                    'nota': [83.0, 59.0, 86.0, 89.0, 98.0, 61.0, 44.0]
                    }
    
    In [4]: ids = [10, 11, 12, 13, 14, 15, 16]
    In [5]: dfAlunos = pd.DataFrame(data=dados, index=ids)
    Out[5]:
    

    nome cidade idade nota
    10 Pedro São Paulo 34 83.0
    11 Maria São Paulo 23 59.0
    12 Janaina Rio de Janeiro 32 86.0
    13 Wong Brasília 43 89.0
    14 Roberto Salvador 38 98.0
    15 Marco Curitiba 31 61.0
    16 Paula Belo Horizonte 34 44.0

    No caso acima usamos um dict onde as chaves são os nomes dos campos ou colunas. À cada chave está associada uma lista cujos valores se tornam os valores das linhas, em cada coluna. A lista de índices foi fornecida separadamente. Se a lista ids não tivesse sido fornecida os índices do dataframe seriam inteiros, começando em 0.

    Dataframes possuem a propriedade shape que contém as dimensões do objeto e os métodos head(n) e tail(n) que permitem, respectivamente, a visualização das n primeiras ou últimas linhas. Ao carregar um dataframe é sempre útil visualizar suas primeiras linhas e nomes de colunas. Também pode ser útil visualizar a matriz sob forma transposta, dada por dfAlunos.T.

    In [6]: dfAlunos.shape
    Out[6]: (7, 4)
    # o que significa que temos 7 linhas, com 4 campos ou colunas.
    
    # para visualizar apenas as 2 primeiras linhas
    In [7]: dfAlunos.head(2)
    Out[7]:
    
    nome cidade idade nota
    10 Pedro São Paulo 34 83.0
    11 Maria São Paulo 23 59.0
    # para visualizar apenas as 2 últimas linhas
    In [8]: dfAlunos.tail(2)
    Out[8]:
    
    nome cidade idade nota
    15 Marco Curitiba 31 61.0
    16 Paula Belo Horizonte 34 44.0
    # A transposta:
    In [9]: dfAlunos.T
    Out[9]:
    
    10 11 12 13 14 15 16
    nome Pedro Maria Janaina Wong Roberto Marco Paula
    cidade São Paulo São Paulo Rio de Janeiro Brasília Salvador Curitiba Belo Horizonte
    idade 34 23 32 43 38 31 34
    nota 83 59 86 89 98 61 44

    Os nomes das colunas podem ser obtidos em uma lista, em um nome específico. Devemos nos lembrar que cada coluna do dataframe é uma Series. Portanto valem para elas os métodos e propriedades das Series.

    In[10]: dfAlunos.columns
    Out[10]:
    Index(['nome', 'cidade', 'idade', 'nota'], dtype='object')
    
    # O nome da segunda coluna (lembrando que se conta a partir de 0)
    In [10]: dfAlunos.columns[1]
    Out[10]: 'cidade'
    
    # Selecionando a coluna 'cidade'
    In [11]: dfAlunos['cidade']
    Out[11]:
    10         São Paulo
    11         São Paulo
    12    Rio de Janeiro
    13          Brasília
    14          Salvador
    15          Curitiba
    16    Belo Horizonte
    Name: cidade, dtype: object
    
    # cada coluna é uma Series
    In [12]: type(dfAlunos['cidade'])
    Out[12]: pandas.core.series.Series
    
    # os métodos das Series se aplicam
    In [13]: dfAlunos['cidade'].value_counts()
    Out[13]:
    São Paulo         2
    Curitiba          1
    Rio de Janeiro    1
    Belo Horizonte    1
    Salvador          1
    Brasília          1
    Name: cidade, dtype: int64
    
    # valores únicos podem ser obtidos com unique()
    In [14]: dfAlunos['cidade'].unique()
    Out[14]:
    array(['São Paulo', 'Rio de Janeiro', 'Brasília', 'Salvador', 'Curitiba',
           'Belo Horizonte'], dtype=object)
    
    # também podemos transformar esses valores em um set
    In [15]: set(dfAlunos['cidade'])
    Out[15]:
    {'Belo Horizonte',
     'Brasília',
     'Curitiba',
     'Rio de Janeiro',
     'Salvador',
     'São Paulo'}
    

    Observe que dfAlunos['cidade'] retorna uma Series, que é a coluna especificada do DF. Já o comando dfAlunos[['cidade']] retorna um dataframe com uma única coluna. É sempre importante saber com que tipo de objeto estamos lidando. Para isso podemos usar type() para conhecer esse tipo. Por exemplo, type(dfAlunos[['cidade']]) retorna pandas.core.frame.DataFrame . Observe que strings são listadas apenas como objects (sem discriminação de serem strings).

    Também se pode usar a notação de ponto, dfAlunos.cidade, para obter a mesma coluna.

    Como dissemos, o objeto DataFrame do pandas é formado por colunas que são Series, cada uma delas contendo elementos do mesmo tipo. As linhas podem, portanto, conter elementos de tipos diferentes. Para ver os tipos de cada coluna podemos examinar a propriedade dtype ou o método .info() que fornece uma visão geral sobre os dados, inclusive sobre a existência de valores nulos nos dados.

    In [16]: dfAlunos.dtypes
    Out[16]:
    nome       object
    cidade     object
    idade       int64
    nota      float64
    dtype: object
    
    # Uma visão geral sobre os dados pode ser obtido com .info()
    In [17]: dfAlunos.info()
    Out[17]:
    <class 'pandas.core.frame.DataFrame'>
    Int64Index: 7 entries, 10 to 16
    Data columns (total 4 columns):
     #   Column  Non-Null Count  Dtype
    ---  ------  --------------  -----
     0   nome    7 non-null      object
     1   cidade  7 non-null      object
     2   idade   7 non-null      int64
     3   nota    7 non-null      float64
    dtypes: float64(1), int64(1), object(2)
    memory usage: 600.0+ bytes
    

    A descrição estatística dos campos numéricos é obtida com .describe() que fornece a contagem de itens, o valor médio, o desvio padrão, os quantis e máximos e mínimos. O método .corr() fornece o Coeficiente de Correlação de Pearson para todas as colunas numéricas da tabela. O resultado é um número no intervalo [-1, 1] que descreve a relação linear entre as variáveis.

    # describe: resumo estatístico dos campos numéricos
    In [18]: dfAlunos.describe()
    Out[18]:
    
    idade nota
    count 7.000000 7.000000
    mean 33.571429 74.285714
    std 6.187545 19.661420
    min 23.000000 44.000000
    25% 31.500000 60.000000
    50% 34.000000 83.000000
    75% 36.000000 87.500000
    max 43.000000 98.000000
    In [19]: dfAlunos.corr()
    Out[19]:
    
    idade nota
    idade 1.000000 0.564238
    nota 0.564238 1.000000

    Para acrescentar uma ou mais linhas (registros) ao dataframe podemos criar um novo dataframe com quantas linhas forem necessárias e concatená-lo com o antigo usando o método .concat().

    # criamos dataframe para a aluna Juliana e seus dados
    In [20]: dfInserir = pd.DataFrame([('Juliana','Curitiba',28,80.0)],
                                 columns=['nome','cidade','idade','nota'],
                                 index=[100])
    In [21]: pd.concat([dfAlunos, dfInserir])
    Out[21]:
    
    nome cidade idade nota
    10 Pedro São Paulo 34 83.0
    11 Maria São Paulo 23 59.0
    12 Janaina Rio de Janeiro 32 86.0
    13 Wong Brasília 43 89.0
    14 Roberto Salvador 38 98.0
    15 Marco Curitiba 31 61.0
    16 Paula Belo Horizonte 34 44.0
    100 Juliana Curitiba 28 80.0

    Observe que o dataframe original não foi modificado. Caso se pretenda que modificação se torne permanente você deve atribuir o resultado retornado a uma novo (ou o mesmo) dataframe, como em dfAlunos = pd.concat([dfAlunos, dfInserir]).

    Muitas vezes queremos que a novo dataframe criado ignore os índice das duas tabelas concatenadas. Nesse caso podemos ignorar os índices antigos e substituí-los por novos índices fornecidos, ou deixar que sejam preenchidos automaticamente.

    In [22]: df = pd.concat([dfAlunos, dfInserir], ignore_index=True)
    In [23]: df.index
    Out[23]:
    RangeIndex(start=0, stop=8, step=1)
    # os índices são inteiros de 0 até 8 (exclusive)
    

    Uma nova coluna pode ser inserida, inclusive usando valores obtidos nas linhas. Na operação abaixo inserimos o campo ‘calculado’ que é igual à multiplicação dos campos ‘nota’ * ‘idade’, que não tem significado e é feito apenas como demonstração.

    In [24]: dfAlunos['calculado']=dfAlunos['nota'] * dfAlunos['idade']
    In [25]: dfAlunos
    Out[24]:
    
    nome cidade idade nota calculado
    10 Pedro São Paulo 34 83.0 2822.0
    11 Maria São Paulo 23 59.0 1357.0
    12 Janaina Rio de Janeiro 32 86.0 2752.0
    13 Wong Brasília 43 89.0 3827.0
    14 Roberto Salvador 38 98.0 3724.0
    15 Marco Curitiba 31 61.0 1891.0
    16 Paula Belo Horizonte 34 44.0 1496.0

    Como essa nova coluna não tem nenhum significado vamos apagá-la usando .drop().

    # a operação seguinte retorna o dataframe sem a coluna 'calculado', mas não altera a original
    In [26]: dfAlunos.drop(['calculado'], axis=1)
    # para alterar o dataframe usamos o parâmetro inplace=True
    In [27]: dfAlunos.drop(['calculado'], axis=1, inplace=True)
    

    Agora o dataframe tem a mesma estrutura de colunas original. Muitas operações do pandas retornam o resultado sobre o objeto sem alterá-lo. Algumas delas admitem o parâmetro inplace que, se True, faz a alteração do objeto in loco.

    Para selecionar mais de uma coluna passamos uma lista com os nomes dos campos entre os colchetes.

    In [28]: lista = ['nome','idade']
    # a linha abaixo é idêntica à dfAlunos[['nome','idade']]
    In [29]: dfAlunos[lista]
    Out[29]:
    
    nome idade
    10 Pedro 34
    11 Maria 23
    12 Janaina 32
    13 Wong 43
    14 Roberto 38
    15 Marco 31
    16 Paula 34


    Podemos obter somas dos termos, tanto no sentido das linhas quanto das colunas, o que servirá como exemplo do uso do parâmetro axis. Relembrando:

    axis = 0 (axis = ‘index’) opera sobre todas as linhas de cada coluna
    axis = 1 (axis = ‘column’) opera sobre todas as colunas de cada linha

    Para mostrar isso vamos construir um dataframe contendo apenas os dados numéricos, com os campos ‘idade’ e ‘nota’. Em seguida aplicamos sum(axis=0) para obter a soma das idades e notas, e sum(axis=1) para a soma
    de cada linha.

    In [30]: dfNumerico=dfAlunos[['idade', 'nota']]
    In [31]: dfNumerico.sum(axis=0)
    Out[31]:
    idade         235.0
    nota          520.0
    dtype: float64
    
    In [32]: dfNumerico.sum(axis=1)
    Out[32]:
    10    117.0
    11     82.0
    12    118.0
    13    132.0
    14    136.0
    15     92.0
    16     78.0
    dtype: float64
    

    Importando um arquivo externo

    É comum que os dados estejam inicialmente em forma de texto com os dados gravados em linhas e com valores separados por vírgula (um arquivo csv, comma separated values) ou outros separadores, tais como tabulação ou ponto e vírgula (;). Também não é raro que dados importados de outras fontes possam ser convertidos nesse formato.

    Suponha que tenhamos no disco, na pasta de trabalho de sua sessão, um arquivo com o seguinte conteúdo:

        id, nome, cidade, idade, nota
        10, Pedro, São Paulo, 34, 83.0
        11, Maria, São Paulo, 23, 59.0
        12, Janaina, Rio de Janeiro, 32, 86.0
        13, Wong, Brasília, 43, 89.0
        14, Roberto, Salvador, 38, 98.0
        15, Marco, Curitiba, 31, 61.0
        16, Paula, Belo Horizonte, 34, 44.0
    

    Não é importante que as colunas estejam organizadas em forma de colunas. Para importar esses dados para dentro de um dataframe usamos o método do pandas .read_csv(arq), onde arq é o nome completo do arquivo a ser lido (inclusive com seu caminho).

    In [30]: dfNovoAlunos = pd.read_csv('./alunos.csv')
    In [32]: dfNovoAlunos
    Out[32]:
    
    id nome cidade idade nota
    0 10 Pedro São Paulo 34 83.0
    1 11 Maria São Paulo 23 59.0
    2 12 Janaina Rio de Janeiro 32 86.0
    3 13 Wong Brasília 43 89.0
    4 14 Roberto Salvador 38 98.0
    5 15 Marco Curitiba 31 61.0
    6 16 Paula Belo Horizonte 34 44.0

    Vemos que o campo ‘id’ foi lido como um campo comum. Ele pode ser transformado por meio da seguinte operação que transforma esse campo em índice efetivo:

    # torne o campo id o índice
    In [33]: dfNovoAlunos.set_index('id', inplace=True)
    In [34]: dfNovoAlunos.head(2)
    Out[34]: 
    
    nome cidade idade nota
    id
    10 Pedro São Paulo 34 83.0
    11 Maria São Paulo 23 59.0

    Alternativamente podemos ler o arquivo csv usando diretamente a primeira coluna como índice, informado pelo parâmetro index_col. Se o arquivo não contiver vírgulas separando os campos e sim outro sinal qualquer, como ; ou tabulações, passamos essa informação usando o parâmetro sep. Na última importação usamos url, a URL completa do arquivo, que pode estar em qualquer ponto disponivel da rede.

    # para usar a 1a coluna como índice
    dfNovoAlunos = pd.read_csv('./alunos.csv', index_col=0)
    # para ler arquivo em url, usando tab como separador
    dfOutroDF = pd.read_csv(url, sep='\t')
    

    Vimos que, se nenhum argumento for passado, a primeira linha do arquivo é tomada como contendo os nomes (ou headers) das colunas. Para evitar isso passamos o parâmetro header = None. Nesse caso o nome das colunas é substituído por números.

    Suponha que o arquivo nums.csv, com o conteúdo abaixo, esteja gravado no disco.

        11,12,13,14
        21,22,23,24
        31,32,33,34

    Ele pode ser lido da seguinte forma:

    # informa que 1a linha não é header
    In [35]: dfNone = pd.read_csv('./dados/nums.csv', header=None)
    
    # insere o nome ou labels para as colunas
    In [36]: dfNames = pd.read_csv('./dados/nums.csv', names=('A', 'B', 'C', 'D'))
    
    # exibe os dois dataframes
    In [37]: display('sem headers:', dfNone, 'com headers:', dfNames)
    Out[37]:
    

    ‘sem headers:’

    0 1 2 3
    0 11 12 13 14
    1 21 22 23 24
    2 31 32 33 34

    ‘com headers:’

    A B C D
    0 11 12 13 14
    1 21 22 23 24
    2 31 32 33 34

    Finalmente, se o cabeçalho contendo os títulos das colunas não está na primeira linha podemos passar o parâmetro header=n. A n-ésima linha será tomada como cabeçalho e todas as linhas anteriores serão ignoradas.

    In [38]: dfPula2 = pd.read_csv('./dados/nums.csv', header=2)
    

    Gravando o dataframe em arquivos pickle

    Após várias manipulações, que podem ser demoradas dependendo do tamanho dos dataframes e complexidade das operações, temos um novo dataframe que, para ser recuperado em uma sessão posterior, deve passar por todas as etapas realizadas. Para evitar isso e garantir o armazenamento desses dados podemos gravá-lo em um pickle

    pd.to_pickle(dfNovoAlunos, './dados/Alunos.pkl')
    In [39]: del dfNovoAlunos
    In [40]: dfLido = pd.read_pickle('./dados/Alunos.pkl')
    

    dfLido será um dataframe idêntico ao dfNovoAlunos gravado em etapa anterior. A pasta de destino deve existir ou uma exceção será lançada.

    to_pickle Grava um objeto do pandas em arquivo pickled
    read_pickle Ler arquivo pickle recuperando objeto
    DataFrame.to_hdf Grava um objeto do pandas em arquivo HDF5
    read_hdf Ler arquivo hdf recuperando objeto
    DataFrame.to_sql Grava dataframe em um banco de dados sql
    read_sql Ler arquivo sql recuperando objeto
    DataFrame.to_parquet Grava dataframe em formato parquet binário.
    read_parquet Ler arquivo parquet recuperando objeto
    🔺Início do artigo

    Bibliografia

    Consulte bibliografia completa em Pandas, Introdução neste site.

    Nesse site:

    Introdução ao Pandas – Series

    O que é pandas?

    Pandas é uma biblioteca do Python, de código aberto e com licença BSD, desenvolvida e mantida pelo PуDаtа Dеvеlорmеnt Tеаm. Ela fornece ferramentas de manipulação e análise estatística de dados, com capacidade de exibição gráfica, com extração de dados análogos (mas não idênticos) aos de consultas sql. [veja nesse site, sql.]

    A biblioteca foi construída com Cython e, por isso, é bastante rápida. Ela se destinava inicialmente ao uso no setor financeiro para análise de séries temporiais, tendo se tornado uma ferramenta de uso comum na manipulação de dados, particularmente em data science e machine learning. Ela tem sido usada para substituir as planilhas do Excel, para processar dados sob forma tabular, importando com facilidade dados de arquivos csv ou json.

    Os experimentos abaixo foram realizados no Jupyter Notebook. Você encontra nesse site um artigo sobre instalação e uso do Jupyter Notebook. As linhas de código e suas respostas, quando existirem, serão representadas da seguinte forma:

    # Linhas de comentários (não serão numeradas)   
    In [n]: Linha de input n
    Out[n]: Output da linha n
    

    NumPy e matplotlib

    NumPy é a abreviação de Numerical Python, a biblioteca base da computação numérica em Python. Ela fornece as estruturas de dados e algoritmos necessários para a maioria das aplicações científicas e de engenharia utilizando cálculo numérico. Entre outros objetos NumPy NumPy fornece

    • o objeto multidimensional ndarray onde se pode aplicar operações vetorializadas rápidas e eficientes,
    • um conjunto de funções para cálculos elementares com vetores e matrizes,
    • ferramentas de leitura e gravação de dados,
    • operações da álgebra linear, transformada de Fourier e geração de números aleatórios,
    • interação com C e C++.

    Para dados numéricos as matrizes do NumPy são armazenadas e manipuladas de modo mais eficiente do que as demais estruturas do Python. Além disso códigos escritos em linguagens de baixo nível, como C ou Fortran, podem operar diretamente nos dados armazenados com o NumPy. Por isso muitas ferramentas de computação numérica do Python usam as matrizes NumPy como um estrutura de dados primária.

    matplotlib é a biblioteca Python mais popular usada para a produção de gráficos e visualização de dados. Ela pode ser usada na geração de gráficos estáticos ou animados e visualização interativa.

    Pandas

    O pandas se utiliza basicamente de 3 objetos de armazenamento de dados com as seguintes estuturas:

    Estrutura de dados dos objetos do pandas
    Nome dimensões tabela
    Series 1D coluna (vetor)
    DataFrame 2D tabela (matriz)
    Panel 3D várias tabelas (matriz multidimensional)

    As series e os dataframes são utilizados com maior frequência.

    Para usar as bibliotecas dentro do código começamos com as importações

    In [1]: import pandas as pd
    In [2]: import numpy as np
    

    Series

    Uma series é um objeto unidimensional tipo um vetor que contém uma sequência de objetos do mesmo tipo. A essa sequência está associado um outro vetor de labels chamado de índice (index). O método básico de criação de séries é da seguinte forma:

    s = pd.Series(data, index=index)

    onde data pode ser um dict (um dicionário do Python), uma lista ou ndarray do numPy ou um escalar. index é uma lista de índices que, se omitida, é preenchida com inteiros iniciando em 0.

    In [3]: serie1 = pd.Series([-1, 9, 0, 2, 5])
    Out[3]:
     0   -1
     1    9
     2    0
     3    2
     4    5
    

    À esquerda estão listados os índices que, por default, são uma lista de inteiros começando por 0. Os valores podem ser listados com .values e os índices com .index.

    In [4]: serie1.values
    Out[4]: array([-1,  9,  0,  2,  5])
    
    In [5]: serie1.index
    Out[5]: RangeIndex(start=0, stop=5, step=1)
    

    Os índices podem ser inseridos manualmente e não precisam ser inteiros. No input [8] um valor da serie é recuperado por seu índice, que é um string.

    In [6]: serie2 = pd.Series([4, 7, -5, 3], index=['a', 'b', 'c', 'd'])
    In [7]: serie2
    Out[7]: 
    a    4
    b    7
    c   -5
    d    3
    dtype: int64
    
    In [8]: serie2['c']
    Out[8]: -5
    

    Uma série pode ser filtrada por meio de um argumento passado como outra serie booleana. Além disso operações podem ser realizadas sobre todos os elementos da série.

    # O teste seguinte gera uma série de booleanos
    In [9]: serie2 > 3
    Out[9]: 
    a     True
    b     True
    c    False
    d    False
    dtype: bool
    
    # Essa serie de True e False filtra a serie original
    In [10]: serie2[serie2 > 3]
    Out[10]:
    a    4
    b    7
    dtype: int64
    
    # Operações podem, ser realizadas sobre todos os elementos
    In [11]: serie2 * 3
    Out[11]: a    12
    b    21
    c   -15
    d     9
    dtype: int64
    
    # Numpy tem a função exponencial
    In [12]: np.exp(serie2)
    Out[12]:
    a      54.598150
    b    1096.633158
    c       0.006738
    d      20.085537
    dtype: float64
    

    Uma série se comporta, em muitos sentidos, como um dicionário. Uma série pode ser criada passando-se um dicionário como argumento para pd.Series().

    In [13]: populacao = {
               'Sudeste': 89012240, 
               'Nordeste': 57374243,
               'Sul': 30192315,
               'Norte': 18672591,
               'Centro-Oeste':16504303
             }
    
    In [14]: serie3 = pd.Series(populacao)
    
    In [15]: serie3
    Out[15]:
    Sudeste         89012240
    Nordeste        57374243
    Sul             30192315
    Norte           18672591
    Centro-Oeste    16504303
    dtype: int64 
    
    # A ordem dos itens na série pode ser alterada fornecendo uma lista para o argumento index:
    In [16]: ordem_alfabetica = ['Brasil', 'Nordeste', 'Norte', 'Centro-Oeste', 'Sudeste', 'Sul']
    In [17]: serie4 = pd.Series(populacao, index=ordem_alfabetica)
    In [18]: serie4
    Out[18]:
    Brasil               NaN
    Nordeste        57374243
    Norte           18672591
    Centro-Oeste    16504303
    Sudeste         89012240
    Sul             30192315
    dtype: int64
    
    # para verificar queis valores são nulos (NaN)
    In [19]: pd.isnull(serie4)
    Out[19]:
    Brasil           True
    Nordeste        False
    Norte           False
    Centro-Oeste    False
    Sudeste         False
    Sul             False
    dtype: bool
    
    # os seguintes registros são NaN
    In [20]: serie4[pd.isnull(serie4)]
    Out[20]:
    Brasil   NaN
    dtype: float64
    
    In [21]: serie4[pd.notnull(serie4)]
    Out[20]:
    Nordeste        57374243.0
    Norte           18672591.0
    Centro-Oeste    16504303.0
    Sudeste         89012240.0
    Sul             30192315.0
    dtype: float64
    
    In [21]: 'Brasil' in serie4
    Out[21]: True
    In [22]'USA' in serie4
    Out[22] False
    
    In [23]: serie4['USA']
    Out[23]: KeyError
    

    Como não existe no dicionário um valor para o índice ‘Brasil’ a série atribuiu o valor NaN (Not a Number para essa chave, a forma de NumPy e pandas parea indicar a ausência de um valor. O método retorna True ou False para cada item da série e pd.notnull() o seu inverso booleano. Alternativamente se pode usar o método das séries serie4.isnull().

    Em diversos aspectos uma serie se parece com um dict. Por ex., podemos testar a existência de uma chave usando o comando in, como em In[21]. A tentativa de recuperar um valor com índice não existente, em In [23], gera uma exceção (um erro do Python).

    Observe que uma series tem propriedades de numpy ndarray, mas é um objeto de tipo diferente. Se um ndarray é necessário use .to_numpy().

    In [24]: type(serie4)
    Out[24]: pandas.core.series.Series
    
    In [25]: type(serie4.to_numpy())
    Out[25]: numpy.ndarray
    

    Series podem ser fatiadas com a notação serie[i:f] onde serão retornadas a i-ésima linha até a f-ésima, exclusive. Se i for omitido a lista se inicia em 0, se f for omitido ela termina no final.

    In [26]: serie4
    Out[26]:
    Brasil                 NaN
    Nordeste        57374243.0
    Norte           18672591.0
    Centro-Oeste    16504303.0
    Sudeste         89012240.0
    Sul             30192315.0
    dtype: float64
    
    In [27]: serie4[2:5]
    Out[27]:
    Norte           18672591.0
    Centro-Oeste    16504303.0
    Sudeste         89012240.0
    dtype: float64
    
    In [28]: serie4[:2]
    Out[28]: 
    Brasil             NaN
    Nordeste    57374243.0
    dtype: float64
    
    In [29]: serie4[4:]
    Out[29]: 
    Sudeste    89012240.0
    Sul        30192315.0
    dtype: float64
    

    O resultado de operações envolvendo mais de uma serie alinha os valores por chaves (como uma UNION). Valores não presentes em um dos operandos terá NaN como resultado.

    In [29]: serie5 = pd.Series([2, -1, -2, 1], index=['a', 'b', 'c', 'd'])
    In [29]: serie6 = pd.Series([3, 4, 7, -1], index=['e', 'c', 'b', 'f'])
    Out[29]: display(serie5, serie6)
    a    2
    b   -1
    c   -2
    d    1
    dtype: int64
    
    e    3
    c    4
    b    7
    f   -1
    dtype: int64
    
    In [29]: serie5 + serie6
    Out[29]:
    a    NaN
    b    6.0
    c    2.0
    d    NaN
    e    NaN
    f    NaN
    dtype: float64
    

    Series possuem a propriedade name que pode ser atribuída na construção ou posteriormente com .rename().

    In [30]: serie7 = pd.Series(np.random.randn(5), name='randomica')
    In [31]: serie7
    Out[31]:
    0   -1.703662
    1    1.406167
    2    0.966557
    3   -0.557846
    4   -0.264914
    Name: randomica, dtype: float64
    
    In [32]: serie7.name
    Out[32]:
    'randomica'
    
    In [33]: serie7= serie7.rename('aleatoria')
    In [34]: serie7.name
    Out[34]:
    'aleatoria'
    

    O nome de uma série se torna seu índice ou nome de coluna caso ela seja usada para formar um DataFrame.

    Atributos e Métodos das Series

    Os atributos e métodos mais comuns e úteis das Series estão listados abaixo. Para uma lista completa consulte pandas.Series: API Reference.

    Atributos

    Atributo Descrição
    at Accesso a um valor específico em uma par linha/coluna
    attrs Retorna ditionario de atributos globais da series
    axes Retorna lista de labels do eixo das linhas
    dtype Retorna o tipo (dtype) dos objetos armazenados
    flags Lista as propriedades do objeto
    hasnans Informa se existem NaNs
    iat Acessa valor usando um inteiro como índice
    iloc Seleciona por posição usando índice inteiro
    index Retorna lita de índices
    is_monotonic Booleano: True se valores crescem de forma monotônica
    is_monotonic_decreasing Booleano: True se valores decrescem de forma monotônica
    is_unique Booleano: True se valores na series são únicos
    loc Acessa linhas e colunas por labels oo array booleano
    name O nome da Series
    nbytes Número de bytes nos dados armazenados
    shape Retorna uma tuple com forma (dimensões) dos dados
    size Número de elementos nos dados
    values Retorna Series como ndarray

    Métodos

    Método Descrição
    abs() Retorna a Series com valor absoluto para cada elemento
    add(serie2) Soma a serie com serie2, elemento a elemento
    add_prefix(‘prefixo’) Adiciona prefixo aos labels com string ‘prefixo’
    add_suffix(‘sufixo’) Adiciona sufixo aos labels com string ‘sufixo’
    agg([func, axis]) Agrega usando func sobre o eixo especificado
    align(serie2) Alinha 2 objetos em seus eixos usando método especificado
    all([axis, bool_only, skipna, level]) Retorna se todos os elementos são True
    any([axis, bool_only, skipna, level]) Retorna se algum elemento é True
    append(to_append[, ignore_index, …]) Concatena 2 ou mais Series
    apply(func[, convert_dtype, args]) Aplica func sobre todos os valores da series
    argmax([axis, skipna]) Retorna posição (índice inteiro) do valor mais alto da Series.
    argmin([axis, skipna]) Retorna posição (índice inteiro) do menor valor da Series.
    argsort([axis, kind, order]) Retorna índices inteiros que ordenam valores da Series
    asfreq(freq) Converte TimeSeries para frequência especificada.
    asof(where[, subset]) Retorna última linha anterores à ocorrência de NaNs antes de ‘where’
    astype(dtype[, copy, errors]) Transforma objeto object para um dtype
    at_time(time[, asof, axis]) Seleciona valores em determinada hora (ex., 9:30AM)
    backfill([axis, inplace, limit, downcast]) Alias para DataFrame.fillna() usando method=’bfill’
    between(min, max) Retorna Series booleana satisfazendo min <= series <= max.
    between_time(inicio, fim) Seleciona valores com tempo entre inicio e fim
    bfill([axis, inplace, limit, downcast]) Alias para DataFrame.fillna() usando method=’bfill’
    clip([min, max, axis, inplace]) Inclui apenas valores no intervalo
    combine(serie2, func[, fill_value]) Combina a Series com serie2 ou escalar, usando func
    compare(serie2[, align_axis, keep_shape, …]) Compara com serie2 exibindo differenças
    copy([deep]) Faça uma cópia desse objeto, índices e valores
    corr(serie2) Calcula a correlação com serie2, excluindo NaNs
    count([level]) Retorna número de observações na Series, excluindo NaN/nulls
    cov(serie2[, min_periods, ddof]) Calcula covariância da Series, excluindo NaN/nulls
    cummax([axis, skipna]) Retorna máximo cumulativo
    cummin([axis, skipna]) Retorna mínimo cumulativo
    cumprod([axis, skipna]) Retorna o produto cumulativo
    cumsum([axis, skipna]) Retorna a soma cumulativa
    describe([percentiles, include, exclude, …]) Gera descrição estatística
    div(serie2) Retorna divisão de ponto flutuante da series por serie2, elemento a elemento
    divmod(serie2) Retorna divisão inteira e módulo da séries por serie2, elemento a elemento
    dot(serie2) Calcula o produto interno entre a Series e serie2
    drop([labels]) Retorna Series com labels removidos
    drop_duplicates([keep, inplace]) Retorna Series após remoção de valores duplicados
    dropna() Retorna Series após remoçaõ de valores faltantes
    duplicated([keep]) Mostra os valores duplicados na Series
    eq(serie2) Retorna Series de boolenos comparando elemento a elemento com serie2
    equals(serie2) Boolenao: True se os dois objetos contém os mesmos elementos
    ewm([com, span, halflife, alpha, …]) Calcula exponencial com peso
    explode([ignore_index]) Transforma cada elemento de um objeto tipo lista em uma linha
    fillna([value, method, axis, inplace, …]) Substitui valores NA/NaN usando método especificado
    first(offset) Seleciona período inicial de uma série temporal usando offset.
    first_valid_index() Retorna o índice do primeiro valor não NA/null
    floordiv(serie2) Retorna divisão inteira da series por serie2, elemento a elemento
    ge(serie2) Retorna serie booleana comparando se series é maior ou igual a serie2, elemento a elemento
    get(key) Retorna item correspondente à key
    groupby([by, axis, level, as_index, sort, …]) Agrupa a Series
    gt(serie2[, level, fill_value, axis]) Retorna serie booleana comparando se series é maior que serie2, elemento a elemento
    head([n]) Retorna os n primeiros valores
    hist() Plota histograma da series usando matplotlib.
    idxmax([axis, skipna]) Retorna o label do item de maior valor
    idxmin([axis, skipna]) Retorna o label do item de menor valor
    interpolate([method, axis, limit, inplace, …]) Preenche valores NaN usando metodo de interpolação
    isin(valores) Booleano, se elementos da Series estão contidos em valores
    isna() Booleano, se existem valores ausentes
    isnull() Booleano, se existem valores nulos
    item() Retorna primeiro elemento dos dados como escalar do Python
    items() Iteração (lazy) sobre a tupla (index, value)
    iteritems() Iteração (lazy) sobre a tupla (index, value)
    keys() Alias de index
    kurt([axis, skipna, level, numeric_only]) Retorna kurtosis imparcial
    kurtosis([axis, skipna, level, numeric_only]) Retorna kurtosis imparcial
    last(offset) Seleciona período final de uma série temporal usando offset
    last_valid_index() Retorna o índice do último valor não NA/null
    le(serie2) Retorna serie booleana comparando se series é menor ou igual a serie2, elemento a elemento
    lt(serie2[, level, fill_value, axis]) Retorna serie booleana comparando se series é menor que serie2, elemento a elemento
    mad([axis, skipna, level]) Retorna o desvio médio absoluto dos valores da series
    mask(cond[, serie2, inplace, axis, level, …]) Substitui valores sob condição dada
    max([axis, skipna, level, numeric_only]) Retorna o valor máximo
    mean([axis, skipna, level, numeric_only]) Retorna a média dos valores
    median([axis, skipna, level, numeric_only]) Retorna a mediana dos valores
    memory_usage([index, deep]) Retorna a memória usada pela Series
    min([axis, skipna, level, numeric_only]) Retorna o menor dos valores da series
    mod(serie2[, level, fill_value, axis]) Retorna Modulo de series por serie2, elemento a elemento
    mode([dropna]) Retorna a moda da Series
    mul(serie2[, level, fill_value, axis]) Retorna a multiplicação de series por serie2, elemento a elemento
    multiply(serie2[, level, fill_value, axis]) Retorna a multiplicação de series por serie2, elemento a elemento
    ne(serie2[, level, fill_value, axis]) Retorna comparação booleana de series com serie2, elemento a elemento
    nlargest([n, keep]) Retorna os n maiores elementos
    notna() Booleano, se existem valores não faltantes ou nulos
    notnull() Idem
    nsmallest([n, keep]) Retorna os n menores elementos
    nunique([dropna]) Retorna quantos elementos únicos existem na series
    pad([axis, inplace, limit, downcast]) O mesmo que DataFrame.fillna() usando method=’ffill’
    plot O mesmo que pandas.plotting._core.PlotAccessor
    pop(item) Elimina valor da série com indice=item e retorna valor eliminado
    pow(serie2) Retorna exponential de series por serie2, elemento a elemento
    prod([axis, skipna, level, numeric_only, …]) Retorna o produto dos elemetos da series
    product([axis, skipna, level, numeric_only, …]) Idem
    quantile([q, interpolation]) Retorna valor na quantil dado
    ravel([order]) Retorna os dados como um ndarray
    rdiv(serie2[, level, fill_value, axis]) Executa a divisão de ponto flutuante de series por serie2, elemento a elemento
    rdivmod(serie2) Retorna divisão inteira e módulo de series por serie2, elemento a elemento
    reindex([index]) Ajusta a Series ao novo índice
    reindex_like(serie2[, method, copy, limit, …]) Retorna um objeto com índices em acordo com serie2
    rename([index, axis, copy, inplace, level, …]) Altera o nome ou labels dos índices
    reorder_levels(order) Reajusta níveis de índices usando order
    repeat(repeats[, axis]) Repete elementos da Series
    replace([to_replace, value, inplace, limit, …]) Substitui valores em to_replace por value
    reset_index([level, drop, name, inplace]) Gera nova Series reinicializando os índices
    rfloordiv(serie2[, level, fill_value, axis]) Retorna divisão inteira de series por serie2, elemento a elemento
    rmod(serie2[, level, fill_value, axis]) Retorna Modulo da divisão da series por serie2, elemento a elemento
    rmul(serie2[, level, fill_value, axis]) Retorna multiplicação da series por serie2, elemento a elemento
    round([n]) Arredonda valores da Series para n casas decimais.
    rpow(serie2[, level, fill_value, axis]) Retorna a exponential de series por serie2, elemento a elemento
    rsub(serie2[, level, fill_value, axis]) Retorna subtraction da series por serie2, elemento a elemento
    rtruediv(serie2[, level, fill_value, axis]) Retorna divisão de ponto flutuante de series por serie2, elemento a elemento
    sample([n, frac, replace, weights, …]) Retorna uma amostra randomizada de items da Series
    searchsorted(value[, side, sorter]) Encontra índices de elementos de devem ser inseridos para manter a ordem
    sem([axis, skipna, level, ddof, numeric_only]) Retorna erro padrão imparcial da média
    skew([axis, skipna, level, numeric_only]) Retorna inclinação imparcial
    sort_index([axis, level, ascending, …]) Reorganiza Series usando os labels dos índices
    sort_values([axis, ascending, inplace, …]) Reorganiza Series usando seus valores
    std([axis, skipna, level, ddof, numeric_only]) Retorna o desvio padrão da amostra
    str Utiliza funções de string sobre elementos das series (se string). Ex. series.str.split(“-“)
    sub(serie2) Retorna subtração de series por serie2, elemento a elemento
    subtract(serie2) Idem
    sum([axis, skipna, level, numeric_only, …]) Retorna soma dos valores da Series
    tail([n]) Retorna os últimos n elemetnos
    to_clipboard([excel, sep]) Copia o object para o clipboard do sistema
    to_csv([path_or_buf, sep, na_rep, …]) Grava o object como arquivo csv (valores separados por vírgula)
    to_dict([into]) Converte a Series para dicionário {label -> value}
    to_excel(excel_writer[, sheet_name, na_rep, …]) Grava objeto como uma planilha do Excel
    to_frame([name]) Converte Series em DataFrame
    to_hdf(path_or_buf, key[, mode, complevel, …]) Grava dados da Series em arquivo HDF5 usando HDFStore
    to_json([path_or_buf, orient, date_format, …]) Converte o objeto em uma string JSON
    to_latex([buf, columns, col_space, header, …]) Renderiza objeto para LaTeX tabular, longtable, ou table/tabular aninhado.
    to_lista() Retorna a lista dos valores
    to_markdown([buf, mode, index, storage_options]) Escreve a Series em formato Markdown
    to_numpy([dtype, copy, na_value]) Converte a series em NumPy ndarray
    to_pickle(path[, compression, protocol, …]) Grava objeto serializado em arquivo Pickle
    to_sql(name, con[, schema, if_exists, …]) Grava elementos em forma de um database SQL
    to_string([buf, na_rep, float_format, …]) Constroi uma representação string da Series
    tolist() Retorna uma lista dos valores
    transform(func[, axis]) Executa func sobre elementos da serie
    truediv(serie2) Retorna divisão de ponto flutuante de series por serie2, elemento a elemento
    truncate([before, after, axis, copy]) Trunca a Series antes e após índices dados
    unique() Retorna os valores da Series, sem repetições
    update(serie2) Modifica a Series usando valores em serie2, sob índices especificados
    value_counts([normalize, sort, ascending, …]) Retorna Series com a contagem de valores únicos
    var([axis, skipna, level, ddof, numeric_only]) Retorna a variância imparcial dos valores da Series
    view([dtype]) Cria uma nova “view” da Series
    where(cond[, serie2, inplace, axis, level, …]) Substitui valores a condição cond é False
    🔺Início do artigo

    Bibliografia

    • Blair,Steve: Python Data Science, The Ultimate Handbook for Beginners on How to Explore NumPy for Numerical Data, Pandas for Data Analysis, IPython, Scikit-Learn and Tensorflow for Machine Learning and Business, edição do autor disponível na Amazon, 2019.
    • Harrison, Matt: Learning Pandas, Python Tools for Data Munging, Data Analysis, and Visualization,
      edição do autor, 2016.
    • McKinney, Wes: pandas: powerful Python data analysistoolkit, Release 1.2.1
      publicação do Pandas Development Team, revisado em 2021.
    • McKinney, Wes: Python for Data Analysis, Data Wrangling with Pandas, NumPy,and IPython
      O’Reilly Media, 2018.
    • Pandas: página oficial, acessada em janeiro de 2021.
    • Pandas User Guide, acessada em fevereiro de 2021.
    • Miller, Curtis: On Data Analysis with NumPy and pandas, Packt Publishing, Birmingham, 2018.

    pandas e sql comparados



    Esse texto descreve os dataframes do pandas em comparação com as consultas SQL (Structured Query Language), explorando similaridades e diferenças entre os dois sistemas de consulta e extração de dados. Ele serve para descrever as funcionalidades de busca e edição do pandas e pode ser particularmente útil para aqueles que conhecem SQL e pretendem usar o pandas.

    Para realizar os experimentos abaixo usamos o Jupyter Notebook, um aplicativo que roda dentro de um navegador, que pode ser facilmente instalado e permite a reprodução se todo o código aqui descrito. Você pode ler mais sobre Jupyter Notebook e Linguagem de Consultas SQL nesse site.

    Esse texto é baseado em parte do manual do pandas e expandido. Ele usa um conjunto de dados baixados do github renomeado aqui para dfGorjeta. Nomes e valores dos campos foram traduzidos para o português.

    # importar as bibliotecas necessárias
    import pandas as pd
    import numpy as np
    
    url = "https://raw.github.com/pandas-dev/pandas/master/pandas/tests/io/data/csv/tips.csv"
    
    dfGorjeta = pd.read_csv(url)
    dfGorjeta.head()
    
    total_bill tip sex smoker day time size
    0 16.99 1.01 Female No Sun Dinner 2
    1 10.34 1.66 Male No Sun Dinner 3
    2 21.01 3.50 Male No Sun Dinner 3
    3 23.68 3.31 Male No Sun Dinner 2
    4 24.59 3.61 Female No Sun Dinner 4

    Para efeito de testar os comandos do dataframe vamos alterar os nomes dos campos e traduzir os conteúdos dos dados. Para descobrir quais são os valores dos campos, sem repetições, transformamos as séries em sets, uma vez que valores de um set (conjunto) não se repetem.

    print(set(dfGorjeta["sexo"]))
    print(set(dfGorjeta["fumante"]))
    print(set(dfGorjeta["dia"]))
    print(set(dfGorjeta["hora"]))
    
    {‘Male’, ‘Female’}
    {‘No’, ‘Yes’}
    {‘Sat’, ‘Sun’, ‘Fri’, ‘Thur’}
    {‘Lunch’, ‘Dinner’}

    No código seguinte alteramos os nomes de campos e traduzimos o conteúdo. A sintaxe da operação de edição do dataframe será discutida mais tarde no artigo:

    # muda os nomes dos campos
    dfGorjeta.rename(columns={"total_bill":"valor_conta", "tip":"gorjeta",
                            "smoker":"fumante", "sex":"sexo","day":"dia",
                            "time":"hora","size":"pessoas"}, inplace=True)
    
    # traduzindo os valores dos campos:
    dfGorjeta.loc[dfGorjeta["fumante"] == "No", "fumante"] = "não"
    dfGorjeta.loc[dfGorjeta["fumante"] == "Yes", "fumante"] = "sim"
    dfGorjeta.loc[dfGorjeta["sexo"] == "Female", "sexo"] = "mulher"
    dfGorjeta.loc[dfGorjeta["sexo"] == "Male", "sexo"] = "homem"
    dfGorjeta.loc[dfGorjeta["hora"] == "Dinner", "hora"] = "jantar"
    dfGorjeta.loc[dfGorjeta["hora"] == "Lunch", "hora"] = "almoço"
    dfGorjeta.loc[dfGorjeta["dia"] == "Fri", "dia"] = "sex"
    dfGorjeta.loc[dfGorjeta["dia"] == "Sat", "dia"] = "sab"
    dfGorjeta.loc[dfGorjeta["dia"] == "Sun", "dia"] = "dom"
    dfGorjeta.loc[dfGorjeta["dia"] == "Thur", "dia"] = "qui"
    
    # Temos agora o seguinte dataframe
    dfGorjeta
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    0 16.99 1.01 mulher não dom jantar 2
    1 10.34 1.66 homem não dom jantar 3
    2 21.01 3.50 homem não dom jantar 3
    3 23.68 3.31 homem não dom jantar 2
    4 24.59 3.61 mulher não dom jantar 4
    239 29.03 5.92 homem não sab jantar 3
    240 27.18 2.00 mulher sim sab jantar 2
    241 22.67 2.00 homem sim sab jantar 2
    242 17.82 1.75 homem não sab jantar 2
    243 18.78 3.00 mulher não qui jantar 2

    As consultas SQL realizadas a seguir pressupõe a existência de um banco de dados com o mesmo nome, a mesma estrutura e dados que o dataframe dfGorjetas.

    SELECT

    Nas consultas SQL as seleções são feitas com uma lista de nomes de campos que se deseja retornar, separados por vírgula, ou através do atalho * (asterisco) para selecionar todas as colunas. No pandas a seleção de colunas é feita passando-se uma lista de nomes de campos para o DataFrame. Uma chamada ao dataframe sem uma lista de nomes de colunas resulta no retorno de todas as colunas, da mesma forma que usar * no SQL.

    –– sql: consulta (query) usando select
    SELECT valor_conta, gorjeta, fumante, hora FROM dfGorjeta LIMIT 5;
    
    # pandas:
    dfGorjeta[["valor_conta", "gorjeta", "hora"]].head()
    
    valor_conta gorjeta hora
    0 16.99 1.01 jantar
    1 10.34 1.66 jantar
    2 21.01 3.50 jantar
    3 23.68 3.31 jantar
    4 24.59 3.61 jantar

    O método head(n) limita o retorno do dataframe às n primeiras linhas. n = 5 é o default. Para listar as últimas linhas usamos tail(n). Linhas também podem ser selecionadas por chamadas ao sei indice.

    # Para acessar as últimas linhas do dataframe podemos usar
    # dfGorjeta[["valor_conta", "gorjeta", "hora"]].tail()
    
    # selecionando linhas por meio de seu índice.
    dfGorjeta.iloc[[1,239,243]]
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    1 10.34 1.66 homem não dom jantar 3
    239 29.03 5.92 homem não sab jantar 3
    243 18.78 3.00 mulher não qui jantar 2

    Os dataframes possuem a propriedade shape que contém sua dimensionalidade. No nosso caso temos

    dfGorjeta.shape
    (244, 7)

    o que significa que são 244 linhas em 7 campos.

    No SQL você pode retornar uma coluna resultado de um cálculo usando elementos de outras colunas. No pandas podemos usar o método assign() para inserir uma coluna calculada:

    –– sql:
    SELECT *, gorjeta/valor_conta*100 as percentual FROM dfGorjeta LIMIT 4;
    
    # pandas: método assign()
    dfGorjeta.assign(percentual = dfGorjeta["gorjeta"] / dfGorjeta["valor_conta" *100]).head(4)
    
    valor_conta gorjeta sexo fumante dia hora pessoas percentual
    0 16.99 1.01 mulher não dom jantar 2 5.944673
    1 10.34 1.66 homem não dom jantar 3 16.054159
    2 21.01 3.50 homem não dom jantar 3 16.658734
    3 23.68 3.31 homem não dom jantar 2 13.978041

    Essa coluna é retornada mas não fica anexada ao dataframe. Para anexar uma coluna ao dataframe podemos atribuir o resultado do cálculo a uma nova coluna:

    dfGorjeta["percentual"] = dfGorjeta["gorjeta"] / dfGorjeta["valor_conta"] * 100
    print("Nessa estapa temos as colunas:\n", dfGorjeta.columns)
    
    # Vamos apagar a coluna recém criada para manter a simplicidade da tabela
    dfGorjeta.drop(["percentual"], axis=1, inplace=True)
    
    Nessa estapa temos as colunas:
    Index([‘valor_conta’, ‘gorjeta’, ‘sexo’, ‘fumante’, ‘dia’, ‘hora’, ‘pessoas’, ‘percentual’],
    dtype=’object’)

    WHERE


    Filtragem de dados em consultas SQL são feitas através da cláusula WHERE. DataFrames podem ser filtrados de várias formas diferentes. O indexamento com valores booleanos é provavelmente o mais simples:

    –– cláusula WHERE do sql
    SELECT * FROM dfGorjeta WHERE hora = "jantar" LIMIT 5;
    
    # filtragem por indexamento no pandas
    dfGorjeta[dfGorjeta["hora"] == "jantar"].head(5)
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    0 16.99 1.01 mulher não dom jantar 2
    1 10.34 1.66 homem não dom jantar 3
    2 21.01 3.50 homem não dom jantar 3
    3 23.68 3.31 homem não dom jantar 2
    4 24.59 3.61 mulher não dom jantar 4

    A consulta acima funciona da seguinte forma:

    # is_jantar é uma série contendo True e False (True para jantares, False para almoços)
    is_jantar = dfGorjeta["hora"] == "jantar"
    # usamos display para exibir a contagem de falsos/verdadeiros
    display("Quantos jantares/almoços:", is_jantar.value_counts())
    
    # para negar a série inteira, invertendo True ↔ False usamos ~ (til)
    # a linha abaixo imprime o número de almoços na tabela
    print("A lista contém %d almoços" % dfGorjeta[~is_jantar]["hora"].count())
    
    # também podemos obter a lista das entradas que não correspondem a "jantar" usando
    # dfGorjeta[dfGorjeta["hora"] != "jantar"]
    
    ‘Quantos jantares/almoços:’
    True 176
    False 68
    Name: hora, dtype: int64A lista contém 68 almoços

    Quando essa série é passada para o dataframe apenas as linhas correspondentes à True são retornados. A última consulta é equivalente à dfGorjeta[~is_jantar].head().

    No SQL podemos procurar por partes de uma string com a cláusula LIKE. No pandas transformamos o campo dfGorjeta["sexo"]em uma string que possui o método startswith("string").

    –– sql: SELECT TOP 2 sexo, valor_conta FROM dfGorjeta WHERE sexo LIKE 'ho%';
    
    dfGorjeta.loc[dfGorjeta['sexo'].str.startswith('ho'),['sexo','valor_conta']].head(2)
    

    que retorna as 2 primeiras linhas em que o campo sexo começa com o texto “ho”.

    Também podemos procurar por campos que estão incluidos em um conjunto de valores:

    –– sql:
    SELECT * FROM dfGorjeta WHERE dia IN ('sab', 'dom');
    dfGorjeta.loc[dfGorjeta['dia'].isin(["dom", "sab"])]

    que retorna todas as linhas em que o campo dia é “dom” ou “sab”.

    Assim como se pode usar operadores lógicos AND e OR nas consultas SQL para inserir múltiplas condições, o mesmo pode ser feito com dataframes usando | (OR) e & (AND). Por ex., para listar as gorjetas com valor superior à $5.00 dadas em jantares:

    –– SQL: múltiplas condições em WHERE
    SELECT * FROM dfGorjeta WHERE hora = 'jantar' AND gorjeta > 6.00;
    # no pandas
    dfGorjeta[(dfGorjeta["hora"] == "jantar") & (dfGorjeta["gorjeta"] > 6.00)]
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    23 39.42 7.58 homem não sab jantar 4
    59 48.27 6.73 homem não sab jantar 4
    170 50.81 10.00 homem sim sab jantar 3
    183 23.17 6.50 homem sim dom jantar 4
    212 48.33 9.00 homem não sab jantar 4
    214 28.17 6.50 mulher sim sab jantar 3

    Podemos obter uma lista dos dados correspondentes a gorjetas dadas por grupos com 5 ou mais pessoas ou com contas de valor acima de $45.00, limitada aos 4 primeiros registros:

    –– SQL:
    SELECT * FROM dfGorjeta WHERE pessoas >= 5 OR valor_conta > 45 LIMIT 4;
    # pandas
    dfGorjeta[(dfGorjeta["pessoas"] >= 5) | (dfGorjeta["valor_conta"] > 45)].head(4)
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    59 48.27 6.73 homem não sab jantar 4
    125 29.80 4.20 mulher não qui almoço 6
    141 34.30 6.70 homem não qui almoço 6
    142 41.19 5.00 homem não qui almoço 5

    Dados ausentes são representados por NULL no, uma marca especial para indicar que um valor não existe no banco de dados. Nos dataframes do pandas o mesmo papel é desempenhado por NaN (Not a Number). Esses marcadores podem surgir, por ex., na leitura de um arquivo csv (valores separados por vírgulas) quando um valor está ausente ou não é um valor numérico em uma coluna de números. Para verificar o comportamento do pandas com NaN criamos um dataframe com valores ausentes. Verificações de nulos é feita com os métodos notna() e isna().

    frame = pd.DataFrame({"col1": ["A", "B", np.NaN, "C", "D"], "col2": ["F", np.NaN, "G", "H", "I"]})
    frame
    
    col1 col2
    0 A F
    1 B NaN
    2 NaN G
    3 C H
    4 D I

    Se temos um banco de dados SQLcom essa estrutura e conteúdo podemos extrair as linhas onde col2 é NULL usando a consulta:

    –– sql
    SELECT * FROM frame WHERE col2 IS NULL;
    # no case do pandas usamos
    frame[frame["col2"].isna()]
    
    col1 col2
    1 B NaN

    De forma análoga, podemos extrair as linhas para as quais col1 não é NULL. No pandas usamos notna().

    –– sql
    SELECT * FROM frame WHERE col1 IS NOT NULL;
    # pandas: linhas em que col1 não é nula
    frame[frame["col1"].notna()]
    
    col1 col2
    0 A F
    1 B NaN
    3 C H
    4 D I

    GROUP BY


    No SQL consultas com agrupamentos são feitas usando-se as operações GROUP BY. No pandas existe o método groupby() que tipicamente particiona o conjunto de dados em grupos e aplica alguma função (em geral de agregamento), combinando depois os grupos resultantes.

    Um exemplo comum é o de particionar os dados em grupos menores e contar os elementos desses grupos. Voltando ao nosso dataframe dfGorjeta podemos consultar quantas gorjetas foram dadas por grupos de cada sexo:

    –– sql
    SELECT sexo, count(*) FROM dfGorjeta GROUP BY sexo;
    # o equivalente em pandas seria
    dfGorjeta.groupby("sexo").size()
    
    sexo
    mulher 87
    homem 157
    dtype: int64

    O resultado é uma series cujos valores podem ser retornados por seu nome de index ou pelo número desse indice.

    print("A lista contém %d homens" % dfGorjeta.groupby("sexo").size()[0])
    print("\t\t e %d mulheres" % dfGorjeta.groupby("sexo").size()["mulher"])
    
    A lista contém 157 homens
    e 87 mulheres

    É possível aplicar o método count() para cada coluna, individualmente:

    dfGorjeta.groupby("sexo").count()
    
    valor_conta gorjeta fumante almoço hora pessoas
    sexo
    mulher 87 87 87 87 87 87
    homem 157 157 157 157 157 157

    Observe que no código do pandas usamos size() e não count(). Isso foi feito porque o método count() é aplicado sobre cada coluna e retorna tantos valores quantas colunas existem, com valores não null.

    Também se pode aplicar o método count() para uma coluna específica:

    # para contar valores em uma única coluna primeiro ela é selecionada, depois contada
    dfGorjeta.groupby("sexo")["valor_conta"].count()
    
    sexo
    mulher 87
    homem 157
    Name: valor_conta, dtype: int64

    Existem diversas funções de agregamento. São elas:

    função descrição
    mean() calcula médias para cada grupo
    sum() soma dos valores do grupo
    size() *tamanhos dos grupos
    count() número de registros no grupo
    std() desvio padrão dos grupos
    var() variância dos grupos
    sem() erro padrão da média dos grupos
    describe() gera estatísticas descritivas
    first() primeiro valor no grupo
    last() último valor no grupo
    nth() n-ésimo valor (ou subconjunto se n for uma lista)
    min() valor mínimo no grupo
    max() valor máximo no grupo

    * A função size() retorna o número de linhas em uma serie e o número de linhas × colunas em dataframes.

    Para obter um resumo estatístico relativo ao campo gorjeta, agrupado pelo campo sexo podemos usar:

    dfGorjeta.groupby("sexo")["gorjeta"].describe()
    count mean std min 25% 50% 75% max
    sexo
    homem 157.0 3.089618 1.489102 1.0 2.0 3.00 3.76 10.0
    mulher 87.0 2.833448 1.159495 1.0 2.0 2.75 3.50 6.5

    Múltiplas funções podem ser aplicadas de uma vez. Suponha que queremos determinar como os valores das gorjetas variam por dia da semana. O método agg() (de agregar) permite que se passe um dicionário para o dataframe agrupado, indicando que função deve ser aplicada a cada coluna.

    –– sql (agrupe os dados por dia, calcule a média para cada dia e o número de entradas contadas)
    SELECT dia, AVG(gorjeta), COUNT(*) FROM dfGorjeta GROUP BY dia;
    # na pandas, use mean no campo gorjeta, size no campo dia
    dfGorjeta.groupby("dia").agg({"gorjeta": np.mean, "dia": np.size})
    
    gorjeta dia
    dia
    dom 3.255132 76
    qui 2.771452 62
    sab 2.993103 87
    sex 2.734737 19

    Também é possível realizar o agrupamento por mais de uma coluna. Para fazer isso passamos uma lista de colunas para o método groupby().

    –– agrupe primeiro por "fumante", depois por "dia"
    –– realize a contagem dos registros e a média das gorjetas
    SELECT fumante, dia, COUNT(*), AVG(gorjeta) FROM dfGorjeta GROUP BY fumante, dia;
    # no pandas
    dfGorjeta.groupby(["fumante", "dia"]).agg({"gorjeta": [np.size, np.mean]})
    
    gorjeta
    size mean
    fumante dia
    não dom 57.0 3.167895
    qui 45.0 2.673778
    sab 45.0 3.102889
    sex 4.0 2.812500
    sim dom 19.0 3.516842
    qui 17.0 3.030000
    sab 42.0 2.875476
    sex 15.0 2.714000

    JOIN

    No SQL tabelas podem ser juntadas ou agrupadas através da cláusula JOIN. Junções podem ser LEFT, RIGHT, INNER, FULL. No pandas se usa os métodos join() ou merge(). Por defaultjoin() juntará os DataFrames por seus índices. Cada método tem parâmetros que permitem escolher o tipo da junção (LEFT, RIGHT, INNER, FULL), ou as colunas que devem ser juntadas (por nome das colunas ou índices). [Linguagem de Consultas SQL]

    # para os exercícios que se seguem criamos os dataframes
    df1 = pd.DataFrame({"key": ["A", "B", "C", "D"], "value":  [11, 12, 13, 14]})
    df2 = pd.DataFrame({"key": ["B", "D", "D", "E"], "value":  [21, 22, 23, 24]})
    # para exibir esses dataframes com formatação usamos display()
    display(df1)
    display(df2)
    
    key value
    0 A 11
    1 B 12
    2 C 13
    3 D 14
    key value
    0 B 21
    1 D 22
    2 D 23
    3 E 24

    Como antes supomos a existência de duas tabelas de dados sql como as mesmas estruturas e dados para considerarmos as várias formas de JOINs.

    INNER JOIN

    –– junção das duas tabelas ligadas por suas chaves - key
    SELECT * FROM df1 INNER JOIN df2 ON df1.key = df2.key;
    # por default merge() faz um INNER JOIN
    pd.merge(df1, df2, on="key")
    
    key value_x value_y
    0 B 12 21
    1 D 14 22
    2 D 14 23

    O método merge() também oferece parâmetros para que sejam feitas junções de uma coluna de um dataframe com o índice de outro dataframe. Para ver isso vamos criar outro dataframe a partir de df2, usando o campo key como índice.

    # novo dataframe tem campo "key" como índice
    df2_indice = df2.set_index("key")
    display(df2_indice)
    pd.merge(df1, df2_indice, left_on="key", right_index=True)
    
    value
    key
    B 21
    D 22
    D 23
    E 24
    key value_x value_y
    1 B 12 21
    3 D 14 22
    3 D 14 23

    LEFT OUTER JOIN

    A junção LEFT OUTER JOIN recupera todos as campos à esquerda, existindo ou não uma linha correspondente à direita. O parâmetro how="left" é o equivalente no pandas.

    –– sql: recupera todos os valores de df1 existindo ou não correspondente em df2
    SELECT * FROM df1 LEFT OUTER JOIN df2 ON df1.key = df2.key;
    # pandas: how="left" equivale a LEFT OUTER JOIN
    pd.merge(df1, df2, on="key", how="left")
    
    key value_x value_y
    0 A 11 NaN
    1 B 12 21
    2 C 13 NaN
    3 D 14 22
    4 D 14 23

    Observe que df2 não possui campos com key = "A" ou key = "C" e, por isso o dataframe resultante tem NaN nessas entradas. key = "A". Como df2 tem 2 linhas para key = "D" a linha aparece duplicada para essa key em df1.

    RIGHT JOIN

    A junção RIGH OUTER JOIN recupera todos as campos à direita, existindo ou não uma linha correspondente à esquerda. O parâmetro how="right" é o equivalente no pandas.

    –– sql: recupera todos os registros em df2
    SELECT * FROM df1 RIGHT OUTER JOIN df2 ON df1.key = df2.key;
    # pandas: how="right" equivale a RIGHT OUTER JOIN
    pd.merge(df1, df2, on="key", how="right")
    
    key value_x value_y
    0 B 12 21
    1 D 14 22
    2 D 14 23
    3 E NaN 24

    FULL JOIN

    A junção FULL OUTER JOIN recupera todos as campos à direita ou à esquerda, representando como NaN os valores ausentes em uma ou outra. Todos as linhas das duas tabelas são retornadas com junção onde a campo key existe em ambas. O parâmetro how="outer" é o equivalente no pandas. Observe que nem todos os gerenciadores de bancos de dados permitem essa operação.

    –– sql: retorna todos os registros em ambas as tabelas
    SELECT * FROM df1 FULL OUTER JOIN df2 ON df1.key = df2.key;
    # pandas: how="outer" é o equivalente em dataframes
    pd.merge(df1, df2, on="key", how="outer")
    
    key value_x value_y
    0 A 11 NaN
    1 B 12 21
    2 C 13 NaN
    3 D 14 22
    4 D 14 23
    5 E NaN 24

    UNION

    Para os exemplos seguintes definimos mais 2 dataframes:

    df3 = pd.DataFrame({"cidade": ["Rio de Janeiro", "São Paulo", "Belo Horizonte"], "nota": [1, 2, 3]})
    df4 = pd.DataFrame({"cidade": ["Rio de Janeiro", "Curitiba", "Brasília"], "nota": [1, 4, 5]})
    

    No SQL a clásula UNION ALL é usada para juntar as linhas retornadas em dois (ou mais) instruções de SELECT. Linhas duplicadas são mantidas. O mesmo efeito pode ser conseguido no pandas usando-se o método concat().

    –– sql: UNION ALL
    SELECT city, rank FROM df3 UNION ALL SELECT cidade, nota FROM df4;
    # pandas: concat
    pd.concat([df3, df4])
    
    cidade nota
    0 Rio de Janeiro 1
    1 São Paulo 2
    2 Belo Horizonte 3
    0 Rio de Janeiro 1
    1 Curitiba 14
    2 Brasília 5

    No SQL a cláusula UNION tem o mesmo efeito que UNION ALL mas remove as linhas duplicadas. No pandas isso pode ser conseguido se fazendo a conactenação concat() seguida de drop_duplicates().

    –– SQL UNION
    SELECT city, rank FROM df1 UNION SELECT city, rank FROM df2;
    –– o registro duplicado no Rio de Janeiro fica excluído
    # pandas: concat() seguido de drop_duplicates()
    pd.concat([df1, df2]).drop_duplicates()
    
    cidade nota
    0 Rio de Janeiro 1
    1 São Paulo 2
    2 Belo Horizonte 3
    1 Curitiba 14
    2 Brasília 5

    Outras funções analíticas e de agregamento

    Para os próximos exemplos vamos retornar ao nosso dataframe dfGorjeta: para listar as 5 gorjetas mais altas, no MySQL (a sintaxe varia de um para outro gerenciador).

    –– MySQL: retorna todos os campos em ordem decrescente, 5 linhas
    SELECT * FROM dfGorjeta ORDER BY gorjeta DESC LIMIT 10 OFFSET 5;
    # pandas: seleciona 15 maiores e exibe as 10 de menor valor
    dfGorjeta.nlargest(15, columns="gorjeta").tail(10)
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    183 23.17 6.50 homem sim Dom jantar 4
    214 28.17 6.50 mulher sim sab jantar 3
    47 32.40 6.00 homem não Dom jantar 4
    239 29.03 5.92 homem não sab jantar 3
    88 24.71 5.85 homem não Thur almoço 2
    181 23.33 5.65 homem sim Dom jantar 2
    44 30.40 5.60 homem não Dom jantar 4
    52 34.81 5.20 mulher não Dom jantar 4
    85 34.83 5.17 mulher não Thur almoço 4
    211 25.89 5.16 homem sim sab jantar 4

    UPDATE

    Há muitas formas de alterar um valor em um campo de um dataframe. Por exemplo, abaixo realizamos uma alteração em todos os valores de gorjeta sempre que gorjeta < 2.

    –– sql: em todas as linhas duplique a gorjeta se gorjeta for menor que 1.1
    UPDATE dfGorjeta SET gorjeta = gorjeta*2 WHERE gorjeta < 1.1;
    # pandas: o mesmo resultado pode ser obtido da aseguinte forma
    # dfGorjeta.loc[dfGorjeta["gorjeta"] < 1.1, "gorjeta"] *= 2
    

    Para explicar com mais detalhes o funcionamento deste código, armazenamos abaixo a lista dos índices das linhas de gorjetas mais baixas e exibimos essas linhas. Em seguida multiplicamos apenas as gorjetas dessas linhas por 2 e examinamos o resultado:

    indices = dfGorjeta[dfGorjeta["gorjeta"] < 1.1].index
    print("Índices de gorjetas < 1.1:", indices)
    display("Lista de gorjetas < 1.1", dfGorjeta.iloc[indices])
    # multiplica essas gorjetas por 2
    dfGorjeta.loc[dfGorjeta["gorjeta"] < 1.1, "gorjeta"] *= 2
    # lista as mesmas linhas após a operação
    display("Gorjetas após a operação:", dfGorjeta.iloc[indices])
    
    Índices de gorjetas < 1.1: Int64
    Index([0, 67, 92, 111, 236], dtype=’int64′)
    ‘Lista de gorjetas < 1.1’

    valor_conta gorjeta sexo fumante dia hora pessoas
    0 16.99 1.01 mulher não dom jantar 2
    67 3.07 1.00 mulher sim sab jantar 1
    92 5.75 1.00 mulher sim sex jantar 2
    111 7.25 1.00 mulher não sab jantar 1
    236 12.60 1.00 homem sim sab jantar 2

    ‘Gorjetas após a operação:’

    valor_conta gorjeta sexo fumante dia hora pessoas
    0 16.99 2.02 mulher não dom jantar 2
    67 3.07 2.00 mulher sim sab jantar 1
    92 5.75 2.00 mulher sim sex jantar 2
    111 7.25 2.00 mulher não sab jantar 1
    236 12.60 2.00 homem sim sab jantar 2
    –– sql: alterar um campo de uma linha específica (supondo a existência de um campo id)
    UPDATE dfGorjeta SET sexo = 'NI' WHERE id = 239
    # para alterar o campo sexo para 'NI' (não informado)
    dfGorjeta.loc[239, 'sexo'] ='NI'
    

    DELETE

    Existem muitas formas de se excluir linhas de um dataframe mas é comum a prática de selecionar as linhas que devem ser mantidas e copiar para um novo dataframe.

    –– sql: linhas são apagadas sob um certo critério
    DELETE FROM dfGorjeta WHERE gorjeta > 9;
    # pandas: como novo dataframe tem o mesmo nome do original, o antigo é sobrescrito e perdido
    dfTop = dfGorjeta.loc[dfGorjeta["gorjeta"] > 9]
    dfTop
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    170 50.81 10.0 homem sim sab jantar 3

    Também é possível apagar linhas usando seu índice:

    # apagar linha com index = 4, inplace para substituir o dataframe
    dfGorjeta.drop(index=4, inplace=True)
    # apagar linhas com index = 0 até 3
    dfGorjeta.drop(index=[0, 1, 2, 3], inplace=True)
    dfGorjeta.head()
    
    valor_conta gorjeta sexo fumante dia hora pessoas
    5 25.29 4.71 homem não dom jantar 4
    6 8.77 12.00 homem não dom jantar 2
    7 26.88 3.12 homem não dom jantar 4
    8 15.04 1.96 homem não dom jantar 2
    9 14.78 3.23 homem não dom jantar 2
    🔺Início do artigo

    Bibliografia

    • McKinney, Wes: Python for Data Analysis, Data Wrangling with Pandas, NumPy,and IPython
      O’Reilly Media, 2018.
    • Pandas: página oficial, acessada em janeiro de 2021.