50+ Exercícios Resolvidos e Comentados em Python - Fernando Feltrin - Amostra

3. 50+
EXERCÍCIOS RESOLVIDOS E
COMENTADOS EM PYTHON
Nível Especialista
FERNANDO FELTRIN

4. AVISOS
Este livro conta com mecanismo antipirataria Amazon Kindle Protect
DRM. Cada cópia possui um identificador próprio rastreável, a distribuição
ilegal deste conteúdo resultará nas medidas legais cabíveis.
É permitido o uso de trechos do conteúdo para uso como fonte desde
que dados os devidos créditos ao autor.

5. SOBRE O AUTOR
Fernando Feltrin é Engenheiro da Computação com especializações na área de
ciência de dados e inteligência artificial, Professor livre-docente de nível
técnico e superior, Autor de mais de 30 livros sobre programação de
computadores e responsável pelo desenvolvimento e implementação de
ferramentas voltadas a modelos de redes neurais artificiais aplicadas à
radiologia médica (diagnóstico por imagem).

6. LIVROS

7. Disponível em: Amazon.com.br
Coletâneas PYTHON TOTAL
Disponível em: Amazon.com.br

8. SISTEMÁTICA
Este livro é um tratado prático, logo, seu formato é um tanto quanto diferente
do convencional por se tratar de um compêndio de exercícios resolvidos e
comentados.
Sendo assim, todos os exercícios estarão dispostos no molde acima
representado, facilitando o entendimento dos mesmos de acordo com este
padrão.

9. ÍNDICE
Sumário
AVISOS 4
SOBRE O AUTOR 5
LIVROS 6
SISTEMÁTICA 8
ÍNDICE 9
INTRODUÇÃO 15
PYTHON AVANÇADO / ESPECIALISTA 16
1 – Declare ao menos 4 variáveis, de tipos de dados diferentes, utilizando a
notação de tipagem estática:...................................................................... 16
2 – Crie uma função personalizada qualquer que possui tipo de dado
esperado para seu campo de parâmetros / argumentos. Configure tal função
para que também retorne um tipo de dado manualmente definido:........ 17
3 – Ao importar / transferir dados textuais de bancos de dados para outra
estrutura de armazenamento de dados, eventualmente espaços em branco
podem causar exceções por serem considerados como caracteres válidos ou
inválidos dependendo o contexto. Como tratar espaços em branco em
strings? Apresente ao menos duas soluções:............................................. 18
4 – Ao se trabalhar com dados que posteriormente serão sincronizados com
uma base de dados, pode ser uma boa prática já realizar a validação de tais
dados no momento de suas entradas, haja visto que as bases de dados
relacionais em sua maioria trabalham com dados tipados em seus campos
de suas tabelas. Crie uma solução simples para validação de dados de
entrada para um dicionário que cadastra clientes para um sistema: ........ 20
5 – A partir de um dicionário contendo algumas chaves e seus respectivos
valores, como exibir em tela ou atribuir a outra variável o nome de suas
chaves e valores:......................................................................................... 23

10. 6 – A linguagem de programação Python vem com “baterias embutidas”, e
este jargão basicamente diz como tal biblioteca possui todo o necessário
para que você de fato saia criando suas aplicações. Complementar a isto,
existem uma série de bibliotecas, módulos e pacotes que adicionam novas
ferramentas e funcionalidades ao núcleo da linguagem. Como instalar um
pacote criado por um usuário em uma instalação local da linguagem Python:
.................................................................................................................... 25
7 – Como criar um ambiente virtualizado dedicado para um projeto?...... 27
8 – Crie uma função personalizada que recebe dois parâmetros, sendo o
primeiro obrigatoriamente posicional:....................................................... 28
9 – Na mesma lógica do exercício anterior, crie uma função personalizada
que recebe dois parâmetros, sendo ao menos o primeiro obrigatoriamente
nomeado:.................................................................................................... 29
10 – Ainda nos mesmos moldes do exercício anterior, crie uma função
personalizada que recebe três parâmetros, sendo o primeiro
obrigatoriamente posicional e o último obrigatoriamente nomeado:....... 30
11 – Crie um mecanismo de busca linear para iterar sobre elementos de uma
lista. Este programa deve ter capacidade de pesquisar um nome entre
nomes cadastrados em uma lista, retornando se tal nome se faz presente:
.................................................................................................................... 31
12 – Nos mesmos moldes do exercício anterior, crie um mecanismo de busca
binária para iterar sobre elementos de uma lista. Este programa deve ter
capacidade de pesquisar um nome entre nomes cadastrados em uma lista,
retornando se tal nome se faz presente:.................................................... 33
13 – Ainda na mesma sistemática do exercício anterior, crie um mecanismo
de busca binária para iterar sobre elementos de uma lista de tal modo que
o sistema de busca funcione de forma assíncrona. Este programa deve ter
capacidade de pesquisar um nome entre nomes cadastrados em uma lista,
retornando se tal nome se faz presente:.................................................... 36
14 – Escalonando de complexidade, crie um mecanismo de busca via árvore
binária para iterar sobre elementos de uma lista. Este programa deve ter
capacidade de pesquisar um nome entre nomes cadastrados em uma lista,
retornando se tal nome se faz presente:.................................................... 38

11. 15 – Crie um sistema simples que simule uma matriz de uma distribuidora
com algumas filiais utilizando do padrão de projeto Singleton, de modo que
cada filial possa realizar pedidos independentes entre si, todos processados
na matriz: .................................................................................................... 42
16 – Após a importação de uma biblioteca (sugestão: biblioteca OpenCV),
extraia e exiba em tela ao menos 5 metadados de relevância:.................. 47
17 – Ainda no contexto do exercício anterior, como descobrir e exibir em
tela uma listagem de todas as dependências da biblioteca OpenCV:........ 49
18 – Declare duas variáveis, atribuindo quaisquer dados / valores para as
mesmas, mapeando em seguida seu identificador de alocação em memória.
Altere os atributos de ao menos uma das variáveis, verificando se a nível de
objeto carregado em memória houve alguma alteração: .......................... 50
19 – Supondo que estamos a trabalhar em um sistema que a cada iteração
atualiza os dados necessários em um banco de dados, crie uma solução
simples que descarrega da memória manualmente o(s) objeto(s) sem
atividade / que não são necessários:.......................................................... 54
20 – Crie um mecanismo capaz de executar uma função em paralelismo
sobre um contêiner de dados (uma lista de números) de modo que o
número de instruções de execução possa ser configurado manualmente:56
21 – Aprimore a estrutura de código do exercício anterior, escalonando de
complexidade, fazendo com que cada parte / bloco de processamento seja
realizada utilizando separadamente de um núcleo do processador e de um
espaço de memória independente:............................................................ 61
22 – Crie uma solução simples simulando um sistema bancário. O sistema
deve ser capaz de efetuar depósitos, saques e transferências entre contas,
sincronizando os dados destas operações com um banco de dados:........ 64
23 – Supondo que temos dados cadastrais de clientes armazenados em um
dicionário, como converter este dicionário para uma array de alta
performance? Realize a comparação do tempo de execução da requisição
de dados do dicionário e da array de alta performance:............................ 69
24 – Utilizando apenas da sintaxe (nenhuma biblioteca, módulo, pacote ou
ferramenta auxiliar) crie 4 tipos de strings diferentes. Por fim, exiba em tela
seu tipo, justificando sua resposta: ............................................................ 73

12. 25 – Como tornar uma estrutura de código simples em um script de
execução independente? Supondo uma aplicação simples que quando
inicializada, recebe do usuário seu nome, exibindo seu nome em uma
saudação via terminal:................................................................................ 75
VISÃO COMPUTACIONAL 77
1 – Carregue uma imagem qualquer e a exiba em tela utilizando apenas
ferramentas embutidas da linguagem Python: .......................................... 77
2 – Utilizando apenas da biblioteca Pillow, carregue uma imagem qualquer,
aplicando sobre a mesma um filtro de borramento suave, em seguida, exiba
em tela esta imagem:.................................................................................. 78
3 – Carregue uma imagem qualquer, convertendo a mesma para a escala de
cinza, por fim, exiba em tela esta imagem: ................................................ 80
4 – Carregue uma imagem qualquer, realizando o espelhamento da mesma,
finalizando com a exibição de tal imagem em tela:.................................... 82
5 – Carregue uma imagem qualquer, reajustando o contraste da mesma
configurando um clareamento, finalize com a exibição de tal imagem em
tela: ............................................................................................................. 84
6 – Carregue uma imagem qualquer, reajuste o contraste da mesma
configurando um clareamento, aplique uma angulação de 15 graus e recorte
dando enfoque à região central da mesma, finalizando com a exibição de tal
imagem em tela: ......................................................................................... 86
MACHINE LEARNING 90
1 – Crie um perceptron simples, de apenas uma camada, dotado da
capacidade de encontrar padrões relacionando duas arrays de mesmo
tamanho:..................................................................................................... 90
2 – Crie um perceptron simples, de uma camada, e o treine para reconhecer
os padrões de uma tabela lógica AND:....................................................... 93
REDES NEURAIS ARTIFICIAIS 98
Mini Projeto – Crie uma arquitetura de rede neural artificial capaz de
aprender padrões a partir da base de dados MNIST:................................. 98
QUESTÕES RÁPIDAS 113

13. 1 – Qual é o tipo de dado usado para representar uma sequência imutável
de elementos em Python?........................................................................ 113
2 – Qual é a função usada para obter o comprimento de uma lista em
Python? ..................................................................................................... 113
3 – Em Python, qual palavra-chave é usada para definir uma função?.... 114
4 – Qual é o operador usado para realizar a multiplicação de dois números
em Python?............................................................................................... 114
5 – Qual método é usado para adicionar um elemento no final de uma lista
em Python?............................................................................................... 115
6 – Qual declaração é usada para criar uma exceção personalizada em
Python? ..................................................................................................... 115
7 – Qual função é usada para ler a entrada do usuário a partir do teclado em
Python (considerando a versão 3 da linguagem)?.................................... 115
8 – Em Python, qual método é usado para remover o último elemento de
uma lista e retorná-lo?.............................................................................. 116
9 – Qual módulo é usado para lidar com arquivos e diretórios em Python?
.................................................................................................................. 116
10 – Qual é o operador de atribuição usado para declarar variáveis simples
em Python?............................................................................................... 117
11 – Em Python, qual função é usada para ordenar uma lista em ordem
crescente?................................................................................................. 117
12 – Qual método é usado para converter uma string em letras maiúsculas
em Python?............................................................................................... 118
13 – Em Python, qual estrutura de dados é usada para mapear chaves para
valores?..................................................................................................... 118
14 – Qual notação é usada para criar um laço de repetição "for" em Python?
.................................................................................................................. 119
15 – Em Python, qual é a maneira correta de abrir um arquivo chamado
"dados.txt" para leitura?........................................................................... 119
16 – Qual método é usado para verificar se uma chave existe em um
dicionário em Python?.............................................................................. 119

14. 17 – Em Python, como você copia o conteúdo de uma lista chamada
lista1 para outra lista chamada lista2?.......................................... 120
18 – Em Python, qual é a função utilizada para encontrar o valor mínimo de
um conjunto de números?........................................................................ 120
19 – Em Python, qual declaração é usada para sair de um loop de repetição
antecipadamente?.................................................................................... 121
20 – Qual é o método usado para dividir uma string em uma lista de
substrings com base em um separador em Python?................................ 121
Gabarito .................................................................................................... 122
CONCLUSÃO 123
LIVROS 124
CURSO 126

15. INTRODUÇÃO
Se tratando de programação, independentemente da linguagem, um
dos maiores erros dos estudantes ou entusiastas da área é o fato de os
mesmos apenas se limitarem a replicar os exemplos dos conceitos da
linguagem, não praticando de fato, seja explorando outras possibilidades de
mesmo propósito, seja não resolvendo exercícios que estimulem a aplicação
da lógica e implementação das ferramentas que a linguagem de programação
oferece para resolução de problemas computacionais.
Sendo assim, o intuito deste pequeno livro é trazer à tona desde os
conceitos mais básicos da linguagem Python até tópicos específicos e
avançados por meio de exercícios, de modo que cada conceito será revisado
conforme a necessidade de sua aplicação, assim como para programadores
que já possuem uma bagagem de conhecimento, tais exemplos servirão para
os mesmos realizar engenharia reversa nos conceitos entendendo os porquês
de cada estrutura de código.
Esse livro foi escrito de forma que os exercícios estão dispostos de
forma gradual no que diz respeito à sua dificuldade, todo e qualquer exercício
terá suas devidas explicações para cada linha de código, porém de forma
gradual à medida que avançaremos pelos exercícios iremos cada vez nos
atendo mais às suas particularidades do que conceitos iniciais. Em função
disso, faça os exercícios em sua ordem, não avançando quando encontrada
alguma dificuldade, assim como quando se sentir confiável, tente outros
métodos de resolução dos mesmos exercícios.
Dessa forma, garanto que você aprenderá de uma vez por todas como
aplicar seus conhecimentos em problemas computacionais reais.
Então... vamos direto para prática!

16. PYTHON AVANÇADO / ESPECIALISTA
1 – Declare ao menos 4 variáveis, de tipos de dados diferentes, utilizando a
notação de tipagem estática:
Python é uma linguagem de programação de tipagem dinâmica, por
conta disso, o tipo de dado pode variar dinamicamente de acordo com o
comportamento esperado de um objeto em seu contexto de inserção. Porém,
nada impede que utilizemos de certas notações aplicadas para assim tentar
regrar o comportamento de um determinado objeto / variável.
A forma mais comum utilizada para este fim é utilizando da função /
método de classe que atribui manualmente um dado / valor a uma variável /
objeto. Por exemplo, declarando uma variável via “num1 = int(2001) estamos
reforçando que 2001, apesar da sintaxe já de um número de tipo inteiro, é de
fato um tipo inteiro independentemente do contexto.
Uma forma um pouco mais avançada de definir o tipo de um dado
manualmente é fazendo o uso do gerador daquele tipo de variável / objeto em
Python. Nesta notação, acessamos propriedades internas às classes
construtoras de objetos que irão regrar e proteger os dados de uma variável /
objeto para que tenham um determinado comportamento de acordo com sua
notação de tipo
Usando desse método é possível indiretamente definir manualmente o
tipo de dado que uma determinada variável receberá. Reforçando que a

17. tipagem de dados em Python é dinâmica, podemos com os métodos explicados
anteriormente modificar a tipagem de uma variável / objeto, porém, caso
alguma incompatibilidade surja, o interpretador irá contornar tentando ler o
dado / valor pela sua forma mais básica, ou seja, pela sua forma sintática,
antes mesmo de gerar algum erro ou exceção.
Finalizando nosso raciocínio neste ponto, apenas como exemplo,
declaradas 4 variáveis variavel1, variavel2, variavel3 e variavel4, com
diferentes tipos de dados, por meio da função print( ) podemos consultar dos
metadados deste código o metadado __annotations__ que retorna todos
objetos criados e prontos para uso, com seus respectivos tipos de dado, onde
podemos ver como esperado os dados de acordo com seu identificador.
Não havendo nenhum erro de sintaxe, ao executar este código o retorno será:
{'variavel1': <class 'set'>, 'variavel2': <class 'list'>, 'variavel3': <class 'tuple'>,
'variavel4': <class 'dict'>}
2 – Crie uma função personalizada qualquer que possui tipo de dado esperado
para seu campo de parâmetros / argumentos. Configure tal função para que
também retorne um tipo de dado manualmente definido:
Se tratando da tipagem de um determinado dado, uma possibilidade
que temos, muito comumente usada, é usar de tipagem para os dados que
serão repassados como parâmetros de uma função.
Resolvendo a tarefa proposta pela questão, criamos uma função
chamada dobro_valor( ) que recebe um valor numérico e retorna seu valor
multiplicado por 2.

18. O ponto aqui é que, assim como mostrado anteriormente, usando da
notação na própria criação da variável é possível definir seu tipo. Nesse caso
em particular, no campo onde serão definidos os parâmetros dessa função
temos a variável num, que pela notação num: int, deve receber um dado / valor
do tipo int.
Em seguida é usado do apontador “ -> “ seguido de float, dessa forma
definimos que o tipo de dado a ser retornado por essa função será do tipo float.
Novamente, caso os dados usados nesta função não respeitem essas
notações, o interpretador antes de gerar algum erro tentará contornar
qualquer incompatibilidade adotando a forma sintática original do dado sendo
repassado para a função.
3 – Ao importar / transferir dados textuais de bancos de dados para outra
estrutura de armazenamento de dados, eventualmente espaços em branco
podem causar exceções por serem considerados como caracteres válidos ou
inválidos dependendo o contexto. Como tratar espaços em branco em strings?
Apresente ao menos duas soluções:
Partindo diretamente para a resolução do problema proposto, como primeira
forma, e mais básica a ser utilizada para remover os espaços desnecessários
em uma string, vamos fazer o uso do método strip( ).

19. Como exemplo, inicialmente é declarada uma variável de nome
nome_importado que recebe como atributo um suposto nome importado de
algum lugar em notação de string.
Em seguida, declaramos uma nova variável, desta vez nomeada
nome_corrigido que recebe como atributo o retorno do conteúdo de
nome_importado após aplicar diretamente sobre a mesma o método strip( ),
sem parâmetros mesmo.
Desta forma, todos os caracteres “em branco” antes e depois dos caracteres
considerados por padrão como válidos serão automaticamente removidos da
string.
Para realizar uma simples verificação se tais “espaços” foram devidamente
removidos, podemos exibir em tela através do aninhamento das funções print(
) e len( ) o conteúdo das variáveis nome_importado e nome_corrigido, pois
como bem sabemos, “Fernando” possui 8 caracteres.
Não havendo nenhum erro de sintaxe, ao executar o código acima o retorno
será:
13
8
Na primeira linha do retorno temos o tamanho da string atribuída a variável
nome_importado, contendo 13 caracteres. Na segunda linha, o tamanho da
string após corrigida e atribuída a variável nome_corrigido, neste caso,
contendo 8 caracteres.

20. Partindo para a segunda solução, outro método de fácil implementação para
o mesmo propósito é utilizando de expressões regulares.
Para isso, logo de início importamos a biblioteca re. Na sequência, reutilizando
a mesma estrutura de código base anterior, para a variável nome_corrigido
atribuímos o retorno da função re.sub( ), neste caso parametrizada em
justaposição com uma r’string configurada para remoção de espaços através
de s+, seguido do que substituir no lugar dos espaços encontrados, neste caso,
“nada”, por fim a instância dos dados de origem.
Exatamente da mesma forma como para o exemplo anterior, através de duas
funções print(len( )) exibimos em tela os tamanhos das strings atribuídas às
variáveis nome_importado e nome_corrigido.
Não havendo nenhum erro de lógica ou de sintaxe, ao executar este código o
resultado gerado é o mesmo produzido para o exemplo anterior. 13 e 8.
4 – Ao se trabalhar com dados que posteriormente serão sincronizados com
uma base de dados, pode ser uma boa prática já realizar a validação de tais
dados no momento de suas entradas, haja visto que as bases de dados
relacionais em sua maioria trabalham com dados tipados em seus campos de
suas tabelas. Crie uma solução simples para validação de dados de entrada para
um dicionário que cadastra clientes para um sistema:

21. Um dicionário, tipo de dado básico em Python, assim como todos os demais
tipos de dados que formam contêineres de dados desta linguagem, recebe
dados / valores onde seu tipo é dinamicamente definido, normalmente de
acordo com sua sintaxe. Especificamente falando de um dicionário, o mesmo
recebe dados / valores organizados em chaves : valores sendo para estes
campos aceitável qualquer tipo de dado, inclusive outros dicionários.
Uma forma efetiva de realizar uma simples validação, especificando o tipo de
dado esperado para as entradas de um dicionário, é através de um dicionário
tipado, tipo de dado especial fornecido pela biblioteca typing, comumente
utilizado como herança para uma classe, regrando assim o tipo de dado a ser
repassado para os valores das chaves em questão.
Partindo para a resolução da questão, logo na primeira linha da biblioteca
typing importamos as classes List e TypedDict. A própria classe TypedDict
conterá a estrutura de dados base para que possamos criar dados em notação
de dicionário tipado, e List nos será útil para que possamos criar uma “lista de

22. dicionários tipados”, comportando assim várias inserções de dados no mesmo
contêiner de dados.
Em seguida criamos uma classe de nome Cliente, que herda TypedDict, e
indentado a seu corpo criamos os campos os quais necessidamos, nesse caso,
alguns campos para coleta de dados de supostos clientes. Observe que pela
notação utilizada, os nomes dos campos serão designados como chaves de um
dicionário, e o tipo de dado esperado será o construtor dos valores atrelados
às suas respectivas chaves. Diferentemente de outras estruturas de dados onde
deveríamos criar ao menos um dado padrão válido (seja ele 0, None ou um
dado qualquer a ser substituído), das particularidades envolvendo um
TypedDict basta que seja definido o tipo de dado e nenhuma exceção será
gerada.
Criada a estrutura base, podemos criar o objeto que de fato cria este dicionário
tipado e seu conteúdo.
Para isso, declaramos uma variável de nome clientes, configurando seu tipo de
dado como List[Cliente]. Em outras palavras, aqui estamos utilizando do
construtor de um dicionário tipado aninhado a um construtor de listas de
dicionários tipados, por mais estranho que essa notação possa parecer.
Dessa forma, a variável clientes por sua vez recebe como atributo uma lista
contendo cada cadastro de cliente em notação de dicionário. Todos os
pormenores em relação à construção dos objetos e seus atributos de classe
serão automaticamente resolvidos internamente por List e TypedDict.
Apenas finalizando, caso queiramos consultar um dado específico de dentro
desta lista de dicionários tipados, podemos utilizar do método convencional,
consultando uma chave para receber seu respectivo valor através de um laço
for.
Nesse caso, criamos um simples laço de repetição que percorre todo o
conteúdo da variável clientes, retornando a cada ciclo de repetição um
dicionário à variável temporária cliente.
Indentado a este laço de repetição, criamos uma variável temporária chamada
nome que recebe de cliente, mais especificamente da chave ‘nome’ seu

23. conteúdo, exibindo em tela na sequência este dado através de uma função
print( ).
Neste caso, o retorno será:
Nome: Fernando Feltrin
Nome: Maria Silva
5 – A partir de um dicionário contendo algumas chaves e seus respectivos
valores, como exibir em tela ou atribuir a outra variável o nome de suas chaves
e valores:
Buscando resolver o problema proposto por este exercício, basicamente temos
duas formas de se chegar até a mesma solução, uma simples e direta utilizando
de uma compreensão de listas para se gerar uma lista de tuplas contendo as
chaves e os valores do dicionário para posterior exibição em tela, assim como
podemos utilizar de uma ferramenta da biblioteca typing chamada Mapping,
que permite “o mapeamento” de um dicionário retornando suas chaves e
valores de modo que podemos visualmente tornar esse retorno mais elegante.
Como primeira solução, inicialmente é declarada uma variável nomeada
dicionario_001 que contém como atributo um dicionário contendo alguns
registros organizados em suas chaves e valores.

24. Na sequência, é declarada outra variável, dessa vez chamada dados, que
através de uma compreensão de listas percorre a cada ciclo de repetição um
item de dicionario_001, desempacotando o mesmo em uma tupla, retornando
esta tupla como um elemento de uma lista.
Por fim, através de uma função print( ) exibimos em tela o conteúdo de dados.
Neste caso, o retorno será:
[('nome', 'Fernando Feltrin'), ('fone', 55991257259), ('profissao', 'Eng. da
Computação')]
Partindo para a solução mais elaborada, do módulo abc da biblioteca
collections importamos a ferramenta Mapping.
Em seguida, criamos uma função chamada dict_map( ) que como parâmetro
recebe um dicionario, sendo este por padrão um objeto do tipo Mapping.
Aproveitando o contexto, apenas configuramos que tal função, por conta de
que seu propósito apenas será de exibir um conteúdo em tela, não gerará
nenhum retorno, uma boa prática por questões de evitar sobrecarregar o
garbage collector do Python.

25. Dentro do corpo dessa função, inserimos um simples laço de repetição que
percorre cada chave e cada valor dos itens do dicionário utilizado / repassado
como parâmetro para esta função.
Por fim, como desfecho programado para tal laço de repetição, criamos uma
função print( ) que através de uma f’string exibe em tela de forma mais
elaborada o conteúdo mapeado do dicionário em questão.
Diretamente do corpo / escopo global do código chamamos a função
dict_map( ), por sua vez parametrizada com a variável dicionario_001.
O retorno agora será:
Chave: nome, Valor: Fernando Feltrin
Chave: fone, Valor: 55991257259
Chave: profissao, Valor: Eng. da Computação
Desta forma, temos uma melhor apresentação da estrutura do dicionário em
questão.
6 – A linguagem de programação Python vem com “baterias embutidas”, e este
jargão basicamente diz como tal biblioteca possui todo o necessário para que
você de fato saia criando suas aplicações. Complementar a isto, existem uma
série de bibliotecas, módulos e pacotes que adicionam novas ferramentas e
funcionalidades ao núcleo da linguagem. Como instalar um pacote criado por
um usuário em uma instalação local da linguagem Python: