Você está na página 1de 97

Capítulo 1- Introdução à Python

Apostila de Introdução à
Linguagem Python
~2~
Minicurso de Python para não Reptilianos
Universidade Federal de Uberlândia
Campus Patos de Minas
2021

por Otávio Augusto Rocha da Cruz


e Marina Albernaz Ferreira

Revisão Final:
Prof. Dr. Daniel Costa Ramos
Sumário
CAPÍTULO 1- INTRODUÇÃO À PYTHON ................................................................................................... 4
1.1. História ................................................................................................................... 4
1.2. Por que utilizar python? .......................................................................................... 5
1.3. Comunidade ............................................................................................................ 6
CAPÍTULO 2- COMO PROGRAMAR EM PYTHON ..................................................................................... 8
2.1. Google Colaboratory (Colab) ................................................................................... 8
2.1.1. Interface ....................................................................................................................... 10
2.1.2. Atalhos ......................................................................................................................... 12
2.2. Instalação do Python.............................................................................................. 13
CAPÍTULO 3- ATRIBUIÇÕES, ENTRADA E SAÍDA DE DADOS .................................................................. 14
3.1. Variáveis e Tipos de Dados..................................................................................... 14
3.2. Declarações de Variáveis ........................................................................................ 17
3.3. Trabalhando com Strings ....................................................................................... 18
3.4. Escrita e Entrada de Dados .................................................................................... 20
3.5. Conversão de Dados............................................................................................... 22
CAPÍTULO 4- MATEMÁTICA E PYTHON ................................................................................................. 24
4.1. Operadores Aritméticos ......................................................................................... 24
4.2. Ordem de Precedência ........................................................................................... 24
CAPÍTULO 5- UM POUCO MAIS SOBRE PYTHON................................................................................... 26
5.1. Indentação (recuo) ................................................................................................. 26
CAPÍTULO 6- EXPRESSÕES BOOLEANAS E CONDICIONAIS .................................................................... 27
6.1. Operadores Relacionais ......................................................................................... 27
6.2. Operadores Lógicos ............................................................................................... 27
6.2.1. AND .............................................................................................................................. 27
6.2.2. OR................................................................................................................................. 28
6.3. Estrutura Condicional ........................................................................................... 28
6.3.1. IF ELSE ....................................................................................................................... 28
CAPÍTULO 7- LAÇOS DE REPETIÇÕES ..................................................................................................... 30
7.1. Estrutura de repetição ........................................................................................... 30
7.1.1. FOR .............................................................................................................................. 30
7.1.2. WHILE......................................................................................................................... 32
CAPÍTULO 8 – SEQUÊNCIA DE DADOS EM PYTHON .............................................................................. 35
8.1. Tuplas ................................................................................................................... 35
8.1.1. Manipulando tuplas .................................................................................................... 37
8.2. Listas .................................................................................................................... 42
8.2.1. Manipulando Listas .................................................................................................... 43
8.3. Dicionários ............................................................................................................ 52
8.3.1. Manipulando Dicionários ........................................................................................... 54
8.3.2. Trabalhando com listas e dicionários ........................................................................ 56
CAPÍTULO 9 - FUNÇÕES ......................................................................................................................... 60
9.1. Introdução ............................................................................................................ 60
9.2. Funções e Seus Argumentos ................................................................................... 62
9.3. Return................................................................................................................... 64
9.4. Formas de Chamar uma Função ............................................................................ 65
9.5. Escopos de Variáveis.............................................................................................. 66
CAPÍTULO 10 - DOCUMENTAÇÃO ......................................................................................................... 70
10.1. Docstring ........................................................................................................... 70
10.1.1. Formatos de Docstring................................................................................................ 71
10.2. Analisando Documentações – Função help() ........................................................ 72
CAPÍTULO 11- ORGANIZANDO NOSSOS PROJETOS .............................................................................. 74
11.1. Módulos ............................................................................................................. 74
11.2. Importações ....................................................................................................... 76
11.3. Mais a Fundo: Como Funciona a Importação ...................................................... 78
11.4. Exemplo de Importação - Cores no Terminal ...................................................... 79
11.5. Modularização - Criando Módulos...................................................................... 81
11.6. Pacotes .............................................................................................................. 84
CAPÍTULO 12- ERROS E EXCEÇÕES ........................................................................................................ 87
12.1. Erros ................................................................................................................. 87
12.2. Exceções ............................................................................................................ 88
12.3. Classes de Exceção ............................................................................................. 89
12.4. Lidando com Exceções - Bloco try-except ............................................................ 90
12.5. Mais Blocos - else e finally .................................................................................. 92
REFERÊNCIAS......................................................................................................................................... 94
Capítulo 1- Introdução à Python

CAPÍTULO 1- INTRODUÇÃO À PYTHON

1.1. História

Python foi criado no final dos anos oitenta (1989) por Guido van Rossum no Centro de
Matemática e Tecnologia da Informação (CWI, Centrum
Wiskunde e Informatica), na Holanda, como sucessor da
linguagem de programação ABC. Ele tinha como objetivo
criar uma linguagem de script simples que possuísse algumas
das melhores propriedades de ABC. A origem do nome vem
do gosto de seu criador pelos humoristas britânicos Monty
Python (também conhecido coletivamente como Pythons),
muito relevantes no cenário de comédia da época. As duas
cobras da logo vieram, apesar do nome não ter se originado do
Guido van Rossum - criador da
réptil e, do criador não ter a intenção de associá-los, quando a linguagem Python

editora O’Reilly, que possui a tradição de utilizar animais nas capas de seus livros, colocou
uma cobra na capa do seu primeiro livro "Programming Python".

Em 2001 foi criada a Python Software Foundation (PSF), uma organização sem fins lucrativos
constituída por membros da equipe de desenvolvimento. Ela tem como objetivo ser dona de
qualquer propriedade intelectual relacionada ao Python, e tem como missão promover e

~4~
Capítulo 1- Introdução à Python
proteger o avanço da linguagem Python, além de suportar e auxiliar o crescimento de
comunidades de programadores Python. Como sociedade sem fins lucrativos ela possui
diversos patrocinadores, como: CCP Games; Globo; Google; Lucasfilm; Microsoft; O’Reilly
Media, Inc..

1.2. Por que utilizar python?

A linguagem Python se destaca em várias áreas: manipulação de dados, inteligência artificial,


processamento de imagem, áudio e vídeo (usado pelo Spotify) e automatização de processos.
Destaca-se as seguintes características da linguagem Python:
1. Linguagem de propósito geral: não foi criada para uso específico, como linguagens
criadas para desenvolvimento web;

2. Fácil e intuitiva o que resulta em um desenvolvimento ágil;

3. Multiplataforma: roda em qualquer sistema operacional;

4. Batteries Included: sua forma básica já tem a maior parte das funcionalidades;

5. Open source;

6. Organizada: possui uma sintaxe que torna o código mais organizado e “bonito”;

7. Orientada a objeto;

8. Muitas bibliotecas, ou seja, ela possui bastante suporte.

9. Por suportar números grandes é comumente aplicada em Inteligência artificial,


biotecnologia e computação 3D.

Para quem gosta de jogos, ela é usada em muitos jogos conceituados, tais como Civilization IV
e Battlefield 2.

~5~
Capítulo 1- Introdução à Python

À esquerda Battlefield 2 e à direita civilization IV .

1.3. Comunidade

Geralmente, ao iniciar o aprendizado de uma nova linguagem, nos deparamos com alguns
obstáculos como, por exemplo, a dificuldade em entender a sintaxe, ou as mensagens de erro,
ou até não conseguimos nem achar o erro. Quando isso acontece temos algumas alternativas:

1. Primeiro: fechar a IDE e ir jogar um Dota, um LoL, um WoW �� (mas você é mais
forte que essa tentação. Esperamos isso, pelo menos!)

2. Segundo: procurar na documentação/referência e tentar encontrar a solução do


impasse por conta própria.

3. Terceiro: procurar uma comunidade e torcer para que uma boa alma lhe ajude ou que
alguém já tenha tido o problema em algum fórum.

No terceiro ponto, duas coisas podem acontecer:

 Sua dúvida ser acolhida e respondida; ou

 Sua dúvida cai no limbo das questões não resolvidas do Stack Overflow.

No caso do Python, sua dúvida dificilmente cairá no limbo e veja abaixo o porquê!

~6~
Capítulo 1- Introdução à Python

Essa Figura mostra o crescimento de criação de tópicos em questões relacionadas à Python. Ou


seja, pelo gráfico cerca de 10.5% das visualizações mensais do Stack Overflow são em tópicos
relacionados à Python! Isso é MUITA COISA! E indica uma comunidade bastante ativa.

~7~
Capítulo 2- Como programar em Python

CAPÍTULO 2- COMO PROGRAMAR EM PYTHON

2.1. Google Colaboratory (Colab)

O Colaboratory é um ambiente de notebook Jupyter gratuito


desenvolvido pela Google que não requer configuração e é
executado inteiramente na nuvem. Com ele é possível escrever
e executar códigos, salvar e compartilhar suas análises e
acessar poderosos recursos de computação, tudo gratuitamente
no seu navegador. Só é preciso ter internet e uma conta no
Google 😎 !!

Para abrir um novo notebook (área de desenvolvimento do Colab) basta pesquisar por Google
Colaboratory no navegador de internet e clicar no primeiro link.

É importante que você esteja logado na sua conta do Google!!! Usar o Chrome pode facilitar
as coisas, mas é possível acessar de qualquer navegador!!

~8~
Capítulo 2- Como programar em Python

Entrando no Colab você terá acesso a um pequeno tutorial, com o nome “Olá, este é o
Colaboratory ”, onde tem algumas explicações básicas sobre a ferramenta e também o que é
possível fazer no Colab. Também é possível ter acesso à Exemplos e notebooks anteriores, que
ficam salvos no Google Drive, além de códigos do GitHub. Há a possibilidade, também, de
fazer upload de notebooks que estão na sua máquina.

Mas enfim, como nosso foco é desenvolver um código do zero, basta clicar no botão “Novo
Notebook”, indicado na figura abaixo.

~9~
Capítulo 2- Como programar em Python

2.1.1. Interface

A interface do Colab é bem limpa e intuitiva. Ela possui uma “área de desenvolvimento”, onde
você vai escrever o código. Note que há um “play” no início, este é o botão de execução do
código, ele executa tudo que estiver dentro deste bloco.

Para dar um nome ao seu trabalho, basta substituir o “Untitled”, no canto superior esquerdo,
pelo nome que deseja dar à sua aplicação. O botão “+Código” adiciona uma nova célula de
código.

~ 10 ~
Capítulo 2- Como programar em Python

Lembrando que as células são separadas, logo cada “play”, executa somente o que está na
respectiva célula. É importante saber que a saída (resultado da compilação do código), vai
aparecer abaixo da célula executada.

O botão “+Texto” adiciona uma célula de texto, onde você pode adicionar informações ou
mesmo nomear as seções que seguem. O texto é editável.

~ 11 ~
Capítulo 2- Como programar em Python

À direita de cada célula, seja ela de texto ou de código, é possível ver uma série de ícones. Eles,
respectivamente, servem para: enviar a célula para cima ou para baixo, gerar um link da célula
para compartilhamento, adicionar um comentário, abrir as configurações do editor, espelhar
célula na guia, apagar a célula, e, ainda, têm opções de copiar, cortar ou adicionar um
formulário. São bem úteis quando criamos uma célula sem querer ou até mesmo para
administrar e ordenar o nosso código!

Existem vários outros utilitários na interface do Colab, porém não serão introduzidos nesta

apostila! Exercite a sua curiosidade e pesquise! 😉

2.1.2. Atalhos

Os atalhos do Colab estão todos descritos na aba Ferramentas > Atalhos do teclado.

Algumas indicações para usar durante o minicurso:

Atalho Descrição
Alt + Enter Executar célula e inserir nova célula
Executar célula e selecionar a célula
Shift + Enter
seguinte
Ctrl + Z Desfazer
Esc Remover foco da célula atual
A Cria célula de código acima
B Cria célula de código abaixo

~ 12 ~
Capítulo 2- Como programar em Python

2.2. Instalação do Python

Para aqueles que preferem utilizar uma plataforma “offline”, é necessário a instalação do
Python 3 no seu computador. Lembrando que o Python 2 também é uma opção, mas se tornou
obsoleto e não recebe mais atualizações. Siga este tutorial para efetuar a instalação.

Ao instalar o Python no Windows reinicie o computador. Se a instalação for bem-sucedida o


comando python no CMD do Windows deve mostrar a versão instalada no computador.

Com a instalação o usuário terá disponível 3 aplicações:

O IDLE é um ambiente de desenvolvimento integrado que é lançado junto à ferramenta, desde


a versão 2.3. Ele tem dois modos:

 O modo iterativo ou shell: é comumente usado como uma espécie de área de teste. Ele
funciona em modo interativo, ou seja, tudo o que é digitado é executado naquele
momento.
 Modo criação de script: O script é a sequência de passos que o computador vai
interpretar, ou seja, é um editor de texto simples onde o programador irá escrever,
editar, salvar e reeditar sempre que necessário.

~ 13 ~
Capítulo 2- Como programar em Python

Algumas das plataformas de desenvolvimento são:

~ 14 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

CAPÍTULO 3- ATRIBUIÇÕES, ENTRADA E SAÍDA DE DADOS

3.1. Variáveis e Tipos de Dados

O tipo é uma forma de classificar as informações. As linguagens de programação normalmente


trazem implementado o que é chamado de tipos primitivos, isto é, o tipo de dado mais genérico
possível. No nosso caso, vamos ver: int, float, bool, str e complex. Lembrando que python é
case sensitive, ou seja, diferencia letras maiúsculas de minúsculas, e que é uma linguagem de
tipagem dinâmica, isso quer dizer que não precisamos especificar o tipo de variável em sua
declaração, o tipo é inferido/compreendido ao atribuirmos o valor.

❖ String

Na programação String representa um conjunto de caracteres disposto numa determinada


ordem. Em Python uma variável do tipo String é representada como str (visivelmente a
abreviação de String).

❖ Inteiros

Chamados de integer trata-se de dados compostos por caracteres numéricos (algarismo),


positivos, negativos ou nulo inteiros, ou seja, os números pertencentes ao conjunto dos números
inteiros (Z). Em Python uma variável do tipo Integer é representada como int (visivelmente a
abreviação de Integer).

Obs.: Um cuidado que se deve tomar é que o tipo inteiro int é de precisão infinita, ou seja,
pode gerar um número inteiro que ocupe toda a memória do computador.

~ 14 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

❖ Ponto Flutuante

Variáveis de ponto flutuante têm o ponto ‘.’ para separar as casas decimais ao invés da vírgula
‘,’ que estamos habituados a utilizar. São conhecidos como float ou double, sendo sua
representação em Python como float.

❖ Boolean

É um tipo de dado primitivo que possui dois valores, que podem ser considerados como 0 ou
1, falso (False) ou verdadeiro (True) respectivamente. Em Python uma variável do tipo Boolean
é representada como bool (abreviação de Boolean).

Obs.: Em Python, quando se declara um valor numérico diferente de 0 para uma variável do
tipo bool está armazenado valor como True caso contrário armazena valor como False. E,
quando se atribui algum caractere para uma variável do tipo bool está armazenado valor como
True, caso seja uma String vazia, armazena valor como False.

❖ Números complexos

Números complexos, em Python denominado como complex, são números da forma a + bj ou,
ainda, <parte real> + <parte imaginária>j.

As variáveis em Python são do tipo imutável, ou seja, não suportam modificações, daí o nome
imutável. Na prática, os tipos imutáveis não podem ter partes de seu valor modificado (ou altera
tudo, declarando novamente o valor da variável, ou não se altera nada). Ou seja, não
conseguimos alterar um caractere de uma string, por exemplo, pois estaríamos tentando mudar
uma variável já existente, que é imutável:

~ 15 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

Na imagem é dito que “O tipo string não suporta atribuição de item”, portanto não é possível
alterar apenas uma posição da variável entrada. Para tal, precisamos atribuir novamente o valor
da variável entrada. É importante destacar que ser imutável quer dizer que não é possível
alterar seu valor no local (endereço de memória).

A variável só pode ser modificada quando seu valor é armazenado em um novo endereço de
memória, como o exemplo a seguir (o comando id aponta o endereço de memória em que está
armazenada a variável), onde o valor inicial de “string” está em um endereço de memória
(value_1), e depois, quando é adicionado um segundo valor à variável (“there”), ela muda sua
alocação para outro endereço de memória (value_2), passando a ter o novo valor.

Quando um objeto imutável perde seu identificador de variável, o interpretador Python pode
excluir o objeto para recuperar a memória do computador que ele ocupou e usá-lo para outra
coisa. Ao contrário de algumas outras linguagens de programação, você (como programador)
não precisa se preocupar em excluir objetos antigos - Python cuida disso para você por meio
de um processo chamado “coleta de lixo”.

~ 16 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

3.2. Declarações de Variáveis

Variáveis são um dos recursos mais básicos das linguagens de programação. Utilizadas para
armazenar valores em memória, elas nos permitem gravar e ler esses dados com facilidade a
partir de um nome definido por nós.

Nesse exemplo foram feitas quatro atribuições. Na linha 1 foi atribuída uma string para uma
nova variável chamada mensagem. Na linha 2 foi atribuído o valor inteiro 25 para n e na terceira
linha foi atribuído um valor decimal para a variável pi. Já na linha 4, foi atribuído à z um valor
complexo. Não sei se vocês perceberam, mas em Python não é necessário “;” ao final de cada
comando, pode colocar se quiser, mas não precisa.

Observe que no exemplo não foi necessário fazer uma declaração explícita de cada variável,
indicando o tipo ao qual ela pertence, pois isso é definido pelo valor que ela armazena. O
método type() a seguir retorna o tipo de objeto especificado.

~ 17 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

3.3. Trabalhando com Strings

Strings estão entre os tipos mais populares em Python. Uma string pode ser tratada como uma
espécie de lista, onde cada caractere corresponde a uma posição.

As strings são manipuláveis e existem várias operações e funções aplicáveis a este tipo de
variável, conforme à necessidade da aplicação. A seguir temos alguns exemplos de
manipulação de strings.

 Concatenação:

~ 18 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

 Tamanho:

 Acessando posições:

 Pesquisar:

 Encontrar a posição da string na frase:

~ 19 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

 split(): Separa uma string conforme o argumento:

 Procurar + substituir:

Curiosidade: É possível “multiplicar” strings por números quando se deseja que ela seja
repetida várias vezes.

3.4. Escrita e Entrada de Dados

 Escrita: usa-se a função print().

~ 20 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

Para imprimir um texto:

Como opção, para não utilizar muitos \n (comando para saltar uma linha):

Existem diversas formas para se imprimir valor de uma ou mais variável, veja alguns:

Mas, vamos adotar nesta apostila (pelo menos na maior parte das vezes) as f-Strings:

~ 21 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

 Leitura: usa-se a função input(). O tipo de retorno da função é uma string.

3.5. Conversão de Dados

Para converter uma variável de determinado tipo para outro, por exemplo, um número do tipo
string, obtido por um input(), para o tipo inteiro (int), basta usar a função int(), na qual o
argumento é a própria variável. A tabela abaixo indica as funções de conversão de tipos.

Funções Descrições

Retorna o equivalente da Coerção de um argumento inteiro para string


bin()
binária

bool() Retorna o equivalente da Coerção de o argumento para Boolean

Retorna o equivalente da Coerção um argumento inteiro em um caractere


chr()
referente a tabela ASCII

~ 22 ~
Capítulo 3- Atribuições, Entradas e Saída de Dados

complex() Retorna um número complexo construído a partir do argumento

float() Retorna um objeto de ponto flutuante construído a partir do argumento

hex() Converte o número inteiro do argumento em uma sequência hexadecimal

int() Retorna um objeto inteiro construído a partir do argumento

Retorna o equivalente da conversão de um número inteiro em uma cadeia


oct()
octal

str() Retorna uma versão de string do argumento

Desafios:

1. Escreva um programa que resolva uma equação de segundo grau. Aaahh, sem usar
importação de módulos (tipo a math).

Obs.: O programa não precisa calcular para deltas negativos.

~ 23 ~
Capítulo 4- Matemática e Python

CAPÍTULO 4- MATEMÁTICA E PYTHON

4.1. Operadores Aritméticos

Os operadores aritméticos são aqueles utilizados para executar alguma operação.

Operação Definição Descrição

a+b adição Soma entre a e b

a-b subtração Diferença entre a e b

a*b multiplicação Produto entre a e b

a/b divisão Divisão entre a e b

a // b divisão inteira Divisão inteira entre a e b

a%b módulo Resto da divisão entre a e b

a ** b exponenciação a elevado a potência de b

4.2.Ordem de Precedência

Quando uma expressão contém mais de um operador, a ordem da avaliação depende da ordem
das operações. Para operadores matemáticos, o Python segue a convenção matemática. O
acrônimo PEMDAS pode ser útil para lembrar das regras. PEMDAS é a sigla para
“Parênteses”, “Expoentes”, “Multiplicação”, “Divisão”, “Adição” e “Subtração”. Essa ordem
representa a sequência de operações matemáticas que você deve efetuar para resolver uma
expressão e chegar ao resultado correto.

~ 24 ~
Capítulo 4- Matemática e Python

~ 25 ~
Capítulo 5- Um pouco mais sobre Python

CAPÍTULO 5- UM POUCO MAIS SOBRE PYTHON

5.1. Indentação (recuo)

Em ciência da computação, indentação (recuo, neologismo derivado da palavra em inglês


indentation) é um termo aplicado ao código fonte de um programa para ressaltar ou definir a
estrutura do algoritmo. Basicamente, consiste em afastar o texto da sua margem.

Na maioria das linguagens de programação, a indentação é empregada com o objetivo de


ressaltar a estrutura do algoritmo, aumentando assim a legibilidade, do código. Em algumas
linguagens, entretanto, a indentação é obrigatória. Python, Occam e Haskell, por exemplo,
utilizam a mudança de indentação para definir a hierarquia dentre blocos de código. Caso não
preste atenção erros como esse podem acontecer:

~ 26 ~
Capítulo 6- Expressões Booleanas e Condicionais

CAPÍTULO 6- EXPRESSÕES BOOLEANAS E CONDICIONAIS

6.1. Operadores Relacionais

Os operadores relacionais são operadores que obtém uma determinada relação do membro a
esquerda (um operando) com o membro a direita (outro operando). Veja abaixo alguns:

Descrição Operador

Maior que >

Menor que <

Igual a ==

Maior ou igual a >=

Menor ou igual a <=

Diferente !=

Verifica se o valor A está contido em um conjunto in

Verifica se o valor A não está contido em um conjunto not in

6.2. Operadores Lógicos

Os operadores lógicos, permite-nos unir 2 expressões ligando-as com os conectivos lógicos


matemáticos que são, o conectivo E (and) e o conectivo OU (or). A união das expressões forma
uma nova expressão que é composta por 2 ou mais sub-expressões. O resultado lógico de
expressões compostas será a relação entre as sub-expressões. Como estudamos, toda expressão
lógica avaliada resultará num valor lógico.

6.2.1. AND

O conectivo lógico E (and), une a expressão a da esquerda a expressão a sua direita.


Considerando, por exemplo, duas expressões, A e B. Nas situações em que A for verdadeiro e

~ 27 ~
Capítulo 6- Expressões Booleanas e Condicionais

B também, o resultado, segundo a tabela lógica abaixo, será também verdadeiro (True). Caso
contrário, é falso (False).

6.2.2. OR

O conectivo lógico OU (or) liga a expressão a da esquerda a expressão a sua direita. É


necessário que apenas uma expressão seja verdadeira para que toda a expressão também seja.

6.3. Estrutura Condicional

Uma Estrutura de Condição, como o próprio nome já diz, verifica a condição dos argumentos
passados e, executa um comando caso a condição seja verdadeira, como por exemplo, a
estrutura do IF ELSE, que executa um determinado comando se (IF) algo for cumprido, senão
(ELSE) ela executa um comando diferente.

6.3.1. IF ELSE

O IF é uma estrutura de condição que permite avaliar uma expressão e, de acordo com seu
resultado executar determinada(s) ação(ões). Agora, trazendo essa analogia para a informática,
temos, por exemplo:

~ 28 ~
Capítulo 6- Expressões Booleanas e Condicionais

Ressalta-se que para Python o uso de indentação é obrigatório. Veja o último print(‘-’*25 +
‘FIM’), por exemplo, ele aparece em todas as situações, pois segue o curso normal do código.

Existem estruturas para a condição IF: a estrutura simples, com um IF, a estrutura composta,
com IF ELSE, e, por fim, as estruturas aninhadas, IF ELSE IF, ou IF ELIF (simplificação usada
em java para designar ELSE IF).

~ 29 ~
Capítulo 7- Laços de Repetições

CAPÍTULO 7- LAÇOS DE REPETIÇÕES

7.1. Estrutura de repetição

A estrutura de repetição é um recurso das linguagens de programação responsável por executar


um bloco de código repetidas vezes enquanto determinada condição é atendida.

Neste caso duas estruturas muito usadas são o laço FOR, em que para a determinada condição,
o laço vai repetir o mesmo código até que essa condição seja completamente cumprida, e o
WHILE que, enquanto uma condição for verdadeira o código vai se repetir.

7.1.1. FOR

O FOR é usado quando se deseja realizar iterações sobre um bloco de código um número
determinado de vezes.

Os valores podem ser especificados como um intervalo com início, fim e incremento, usando
range(). Essa função termina em fim -1.

~ 30 ~
Capítulo 7- Laços de Repetições

Caso necessário, podemos utilizar a cláusula break para interromper o laço e continue para
pular para a próxima iteração.

Podemos, também, colocar um bloco de código dentro de um ELSE, para que este seja
executado ao final do laço caso ele não seja interrompido por um break.

~ 31 ~
Capítulo 7- Laços de Repetições

Desafios:

1. Mostre a tabuada de um número que o usuário escolher.

2. Desenvolva um programa que leia o primeiro termo e a razão de uma PA. Mostre os
10 primeiros termos dessa PA.

3. Crie um programa que leia o ano de nascimento de sete pessoas. Mostre quantas pessoas
ainda não atingiram a maioridade e quantas já atingiram

4. Exiba em ordem decrescente todos os números de 500 até 10.

5. Ler do teclado a idade e o sexo de 5 pessoas, calcule e imprima: idade média das
mulheres, idade do homem mais velho e idade média do grupo.

6. Faça um programa que receba uma palavra, escrita pelo usuário, e soletre essa palavra.

7.1.2. WHILE

O comando WHILE faz com que um conjunto de instruções seja executado enquanto uma
condição é atendida. Quando o resultado dessa condição passa a ser falso, a execução do loop
é interrompida

~ 32 ~
Capítulo 7- Laços de Repetições

Desafios:

1. Construa um programa onde o computador “pense” em um número inteiro aleatório


de 0 a 10 no qual o usuário deve tentar acertar. Mostre quantas tentativas foram
necessárias para acertar.

2. Faça um programa leia um número qualquer e mostre seu fatorial.

3. Escreva um programa que leia um número inteiro n e mostre na tela os n primeiros


elementos de uma sequência de Fibonacci.

4. Crie um programa onde o computador e o usuário joguem par ou ímpar. O


computador deve escolher um número aleatório e a pessoa deve digitar um número

~ 33 ~
Capítulo 7- Laços de Repetições

inteiro e se deseja ímpar ou par, mostre o resultado e só pare quando o usuário perder.
Mostre quantas vezes o usuário ganhou.

5. Crie um programa que simule um caixa eletrônico. O usuário informa o valor que
deseja sacar e o programa informa quantas cédulas (de 50, 20, 10 e 1) serão entregues.

~ 34 ~
Capítulo 8 – Sequência de Dados em Python

CAPÍTULO 8 – SEQUÊNCIA DE DADOS EM PYTHON

Existem quatro tipos de armazenamento de dados com diferentes características e usabilidades.


São elas as tuplas, que são sequências imutáveis, as listas, que armazenam muitos itens em
uma única variável, com ordenação, os dicionários, que não possuem ordem e são mutáveis
mas, não aceitam itens duplicados e os conjuntos, que assim como as listas, armazenam vários
itens em uma única variável, porém, não são indexados nem ordenados. Os conjuntos não
serão abordados nesta apostila.

8.1. Tuplas

A tupla é uma sequência de valores, que podem ser indexados por números inteiros. É
comumente utilizada para representar uma lista de valores que podem ser de qualquer tipo. As
tuplas são imutáveis.

Tradução literal: “TypeError: o objeto 'tuple' não suporta a atribuição de itens”.

~ 35 ~
Capítulo 8 – Sequência de Dados em Python

Há duas formas de se declarar uma tupla. A primeira delas é:

Mas, embora não seja necessário, é convencional colocar tuplas entre parênteses:

Para criar uma tupla com um único elemento, temos que incluir uma vírgula. Sem a vírgula,
Python entende como uma string:

As tuplas podem ser indexadas por números positivos (começando em 0), que é a forma
tradicional, ou por números negativos, onde o último elemento da tupla corresponde ao maior
valor, -1.

Frequentemente usamos tuplas em estruturas de repetição

~ 36 ~
Capítulo 8 – Sequência de Dados em Python

Phillip J. Eby quando perguntado sobre a remoção das tuplas disse: “É um equívoco pensar nas
tuplas como listas constantes. As listas são destinadas a serem sequências homogêneas,
enquanto que os Tuplas são estruturas de dados heterogêneas. ”

A diferença básica conceitual de tuplas e listas é que as tuplas geralmente contêm uma
sequência heterogênea de elementos, ou seja, elementos de diversos tipos e significados. E
as listas, por outro lado, são mais próprias para armazenamento de valores de mesmo
significado, isto é, homogêneos. Isso não significa que uma lista não possa armazenar valores
de diferentes tipos, mas que esse é comumente o sentido dado a ela.

8.1.1. Manipulando tuplas


 Slicing (fatiar):

Utilizando, por default, o incremento +1 temos a seguinte situação:

~ 37 ~
Capítulo 8 – Sequência de Dados em Python

Mass, se tiver a necessidade de percorrer a tupla (ou qualquer sequência) no sentido contrário
é totalmente possível, basta utilizar um incremento negativo.

~ 38 ~
Capítulo 8 – Sequência de Dados em Python

 len() e for

 enumerate (sequence, start): é uma das funções internas do Python. Sendo start
opcional, por default é igual a 0. Retorna um objeto enumerado. No caso, esse objeto é
uma lista de tuplas, cada uma contendo um par, índice e valor.

 sorted (iterable, key=None, reverse=False)


 iterable - Uma sequência (string, tupla, lista) ou coleção (conjunto, dicionário,
conjunto congelado) ou qualquer outro iterador.
 reverse (Opcional) - Se True, classificada em ordem decrescente. Se não for
fornecido o valor padrão é False.
 key (opcional) - uma função que serve como chave para a comparação de
classificação. O padrão é None.

Aqui, por exemplo, len() é usada para contar o comprimento de um objeto. A tupla é
classificada com base no comprimento do elemento, da contagem mais baixa para a mais alta.

~ 39 ~
Capítulo 8 – Sequência de Dados em Python

 tupla.count(elemento)

Em termos simples, pesquisa o elemento fornecido em uma tupla e retorna quantas vezes o
elemento ocorreu.

 tupla.index(elemento, inicio, fim): retorna o índice da primeira ocorrência de elemento,


a partir da posição inicial até a posição fim.

Procura o elemento especificado em uma tupla e retorna sua posição.

 Operadores com tuplas


 Replicação

 Concatenação

~ 40 ~
Capítulo 8 – Sequência de Dados em Python

 Uma coisa meio louca: uma lista dentro de uma tupla:

Isso lembra as tabelas de um banco de dados relacional.

~ 41 ~
Capítulo 8 – Sequência de Dados em Python

 Uso da tupla em um for

A tupla pode ser utilizada como uma condição dentro de um for, por exemplo, veja que:

Veja na Figura abaixo que sim assume os valores de simbolos, como simbolo[0] e simbolo[1],
determinando a quantidade de vezes que o laço for vai se repetir. Como símbolos possui 3
elementos, ele vai se repetir 3 vezes, uma para cada elemento.

Desafios:

1. Crie uma tupla totalmente preenchida por extenso, de zero a vinte. O programa deverá
ler um número do teclado (de 0 a 20) e mostrá-lo por extenso

2. Crie uma tupla preenchida com os 20 primeiros times da tabela do ‘brasileirão’ na


ordem de colocação. Mostre: os 5 primeiros colocados; os 3 últimos colocados; os times
em ordem alfabética; e em que posição está determinado time que o usuário deseja
saber.

8.2. Listas

Lista é uma estrutura de dados mutável onde a ordenação natural é estabelecida pela ordem de
entrada. Podemos, por exemplo, incluir, alterar, excluir e pesquisar elementos de uma lista.
Uma lista sempre vai estar delimitada entre dois colchetes ‘[]’

~ 42 ~
Capítulo 8 – Sequência de Dados em Python

8.2.1. Manipulando Listas


 Adicionando elemento a uma lista

Pode-se ‘’adicionar’’ temporariamente um elemento no final ou no início de uma lista usando


o operador ‘+’, como uma espécie de concatenação.

Ou, ainda, podemos adicionar elementos de uma lista em outra lista, resultando em uma lista
que contém ambos os elementos das duas listas

~ 43 ~
Capítulo 8 – Sequência de Dados em Python

Mas, esses dois modos não são muito usuais, digamos que provavelmente um programador não
usaria assim (mas fica aí como curiosidade). Um programador (�����) provavelmente
usaria append ou insert:

 append(elemento)
 elemento - elemento a ser adicionado na lista.

O método adiciona elemento ao final da lista

Pode ser bem útil em iterações

 insert (índice, elemento)


 índice - posição em que um elemento precisa ser inserido.
 elemento - este é o elemento a ser inserido na lista.

A função insere um elemento na lista em uma posição escolhida.

~ 44 ~
Capítulo 8 – Sequência de Dados em Python

Imagine, por exemplo, que exista uma lista lanches assim:

Ao inserirmos um cachorro quente na posição 0 da na nossa lista:

Teremos a inserção do elemento cachorro quente e a “reindexação” da lista:

~ 45 ~
Capítulo 8 – Sequência de Dados em Python

 Excluir elemento(s):
 remove(elemento)

Usa um elemento como argumento e remove, o primeiro com o mesmo “nome”, da lista, caso
exista. Caso não exista, lança uma exceção do tipo ValueError: o elemento não está na lista.

 del(índice)
o índice – índice do elemento que se deseja excluir.

Remove o item correspondente ao índice passado no argumento do método. Lança a exceção


IndexError, caso o índice não exista.

~ 46 ~
Capítulo 8 – Sequência de Dados em Python

 pop(índice = default último elemento)

Obs.: del e pop lidam com o índice. A única diferença entre os dois é que pop retorna o
elemento excluído e del não retorna nada.

 Pesquisar

 Acessando um elemento:

~ 47 ~
Capítulo 8 – Sequência de Dados em Python

 Slicing uma lista (lembra matlab):

Lista_Name[start:stop:step]

Start - início do recorte da lista (default = 0).

Stop - fim do recorte da lista (default = -1).

Step - intervalo que queremos saltar (default = 1).

 Quer descobrir se um dado elemento está em uma lista?

 Encontrar o elemento especificado em uma lista e retorna sua posição.


o index(elemento)

 Modificar
 Modificando um elemento

~ 48 ~
Capítulo 8 – Sequência de Dados em Python

Outros métodos:

 sort(reverse, key): Ordenar os elementos de uma determinada lista em uma ordem


específica.
 reverse (True | default = False) - Caso seja True ordenará a lista por ordem
decrescente. O padrão é crescente.
 key - Uma função para especificar os critérios de classificação.

E, também, funciona o método sorted, como visto em tuplas.

 clear(): limpa uma lista.

 enumerate(list)

 len(list): retorna o tamanho da lista.

~ 49 ~
Capítulo 8 – Sequência de Dados em Python

 Lista de listas

Nesse último caso, e assume uma lista de estudantes em cada iteração.

Tome cuidado! Ao igualar uma lista a outra você está criando um vínculo entre elas, mexer
em uma afeta a outra

~ 50 ~
Capítulo 8 – Sequência de Dados em Python

Masss não fique triste! Podemos fazer uma cópia:

~ 51 ~
Capítulo 8 – Sequência de Dados em Python

Desafios:

1. Crie um programa no qual o usuário possa digitar cinco valores numéricos e cadastre-
os conforme seu valor (em ordem), sem usar o sort().

2. Leia vários números (quantos o usuário quiser) depois mostre: quantos números a lista
tem; mostre a lista ordenada em forma decrescente; e confira se o valor 6 está ou não
na lista, se estiver mostre em qual posição está.

3. Faça um programa que leia o nome e duas notas de alunos de uma sala. Mostre os nomes
e a média de cada aluno. Possibilite a consulta, pelo usuário, das notas que um
determinado aluno tirou.

8.3. Dicionários

Todos os tipos de dados compostos que estudamos em detalhes até agora são coleções
sequenciais. Isto significa que os itens na coleção estão ordenados da esquerda para a direita e
eles usam números inteiros como índices para acessar os valores que eles contêm.

Dicionário é um tipo diferente de coleção. Ele é um tipo de mapeamento nativo do Python. Um


mapa é uma coleção associativa desordenada. No Python, usamos chaves ({}) para construir
nossos dicionários. Veja um exemplo:

A associação, ou mapeamento, é uma coleção de associações entre pares (chave-valor), chave,


que pode ser qualquer tipo imutável, e valor, que pode ser qualquer objeto de dados do Python.

~ 52 ~
Capítulo 8 – Sequência de Dados em Python

Algumas funções básicas:

 dict.keys(): retorna a lista de chaves contidas em um dicionário.


 dict.values(): retorna a lista de valores contidos em um dicionário.
 dict.items(): retorna uma lista de tuplas, onde cada tupla é composta por dois valores: a
chave e o valor mapeado respectivamente.

Podemos usar um for para imprimir as chaves e os valores de um dicionário

‘chave’ recebe toda a tupla retornada por ‘items()’

~ 53 ~
Capítulo 8 – Sequência de Dados em Python

Como se ‘chave’ recebe tupla[0] e valor tupla[1]

8.3.1. Manipulando Dicionários


Um dicionário é mutável, logo, podemos, por exemplo, adicionar novo par de valores. Novos
valores podem ser acrescentados a um dicionário fazendo atribuição a uma chave ainda não
definida.

Ou alterar um valor de uma chave existente

 Acessando o valor em um dicionário

 get(key, value): Retorna o valor da chave especificada se a chave existir no


dicionário.

~ 54 ~
Capítulo 8 – Sequência de Dados em Python

Ou

 Excluindo
 del
o Excluindo um par de valores a partir de uma chave

o Excluindo todo o dicionário:

~ 55 ~
Capítulo 8 – Sequência de Dados em Python

 Usando dict.pop(key):

 Juntando dicts

E se quiséssemos atualizar um primeiro dicionário para que contenha também os valores de um


segundo dicionário. Para isso, temos um método próprio, update(), que é mais fácil que usar
um loop para ir adicionando.

O método update () adiciona elemento(s) ao dicionário se a chave não estiver no dicionário. Se


a chave estiver no dicionário, ela atualizará a chave com o novo valor.

8.3.2. Trabalhando com listas e dicionários

Frequentemente utilizamos uma lista de dicionários. Como, por exemplo, imagine uma
locadora, que possuí diversos filmes e precisa organizá-los

~ 56 ~
Capítulo 8 – Sequência de Dados em Python

Podemos fazer

Dessa forma se um cliente chegar procurando um filme podemos pesquisar no sistema da


seguinte forma

~ 57 ~
Capítulo 8 – Sequência de Dados em Python

Além disso, podemos usar a função append() para adicionar um dicionário a uma lista

Mas temos um pequeno probleminha, dessa forma foi criado um vínculo entre a lista e os
dicionários, se tornando algo semelhante à um ponteiro em C (um ponteiro “aponta” para uma
variável quando possui o endereço dela), de forma que alterações em um afeta o outro

Como resolver? Vamos usar uma funçãozinha chamada copy()

Podemos, também, ter uma lista em um dicionário, veja o exemplo do Script abaixo

~ 58 ~
Capítulo 8 – Sequência de Dados em Python

Ao executar temos:

Desafios:

1. Faça um programa que leia o nome, sexo e idade de pessoas. Depois mostre quantas
pessoas tem; a média de idades, quantas mulheres tem; e as pessoas que estão acima
dessa média.

2. Crie um programa para a CBF que leia o nome de jogadores, quantos jogos ele jogou e
quantos gols fez em cada jogo. No final mostre uma tabela com o nome, gols marcados
em cada jogo e o total de jogo de cada jogador. Possibilita, também, a pesquisa do
histórico de gols de cada jogador.

Têm uns exercícios legais: https://panda.ime.usp.br/pensepy/static/pensepy/11-


Dicionarios/dicionarios.html

~ 59 ~
Capítulo 9 - Funções

CAPÍTULO 9 - FUNÇÕES

9.1. Introdução

Funções são conhecidas por diversos nomes em linguagens de programação como sub-rotinas,
rotinas, procedimentos, métodos e subprogramas. A ideia mais primitiva das funções é o
agrupamento de instruções, proporcionando um meio simples de execução sequencial e que
pode ser invocado de qualquer parte a qualquer momento. Dessa forma, toda função irá possuir
um bloco de instrução e quando invocada, o cursor de execução do programa se posicionará na
primeira linha desse bloco e a execução ocorrerá de cima para baixo, uma instrução após outra,
e, após a execução da última instrução, o cursor volta e o programa continua de onde parou.

De maneira geral, uma função é uma estrutura para agrupar um conjunto de instruções que
podem ser reutilizadas, podemos chamá-la mais de uma vez, o que significa que não precisamos
escrever o mesmo código novamente, o que proporciona uma maior rapidez, facilidade de
compreensão e organização ao programa. De forma geral uma função é “programada” da
seguinte forma:

~ 60 ~
Capítulo 9 - Funções

def nome (arg,arg,... arg):

comando

...

comando

Onde nome é o nome da função, args são especificações de argumentos da função e comando
contêm as instruções a ser executadas quando a função é invocada. Uma função pode ter
nenhum ou vários argumentos.

Por questões estéticas e de organização podemos soltar duas linhas após a declaração de uma
função:

Obs: A mensagem “expected 2 blank lines after class or function definition” aparece apenas
em algumas plataformas, no caso do exemplo, na IDE PyCharm. O Colab não indica a
necessidade de soltar linhas depois da função.

~ 61 ~
Capítulo 9 - Funções

9.2. Funções e Seus Argumentos

Quando não conhecemos a quantidade de argumentos podemos fazer algo do tipo (empacotar
parâmetros)

Como podemos ver, dessa forma temos uma tupla de n valores:

ou, ainda, podemos ter um dicionário:

~ 62 ~
Capítulo 9 - Funções

ou, ainda (de novo?), passar uma lista de valores

É possível atribuir um valor default (valor padrão) a argumentos. Se chamarmos a função sem
especificar o argumento, o valor default é usado.

~ 63 ~
Capítulo 9 - Funções

9.3. Return

Outra importante forma de se utilizar uma função é para retornar valores. Podemos, por
exemplo, usar uma variável para guardar o valor retornado de uma função

Ou apenas imprimir o valor na tela

~ 64 ~
Capítulo 9 - Funções

9.4. Formas de Chamar uma Função

Podemos chamar uma função de forma implícita (também conhecido como positional
argument), como já fizemos, ou de forma explícita (também conhecido como keyword
argument). Na imagem a seguir são apresentados os dois modos.

Implícito

Explícito

~ 65 ~
Capítulo 9 - Funções

9.5. Escopos de Variáveis

Escopo, também chamado de espaço de nomes ou namespace, é o nome que se dá ao conjunto


de nomes acessíveis de um determinado ponto de um programa. Um programa começa em um
escopo (chamado escopo global) enquanto que cada função acrescenta um escopo próprio
(local). Módulos e classes também definem escopos. Variáveis definidas em funções são locais,
isto quer dizer que só podem ser usadas dentro do bloco em que foram definidas.

Isso é válido

~ 66 ~
Capítulo 9 - Funções

Mas isso não.

Em resumo, os escopos internos possuem as variáveis dos escopos externos, mas o contrário
não é válido. Mas e se tivermos a “mesma” variável internamente e externamente?

~ 67 ~
Capítulo 9 - Funções

Hummm... então, quando executamos a função criamos uma outra variável, de mesmo nome
(lembre-se imutabilidade).

BUTTTTTTTTTTTTTTTTT, podemos resolver esse problema e modificar a variável global


nome ou qualquer outra que desejarmos

~ 68 ~
Capítulo 9 - Funções

~ 69 ~
Capítulo 10 - Documentação

CAPÍTULO 10 - DOCUMENTAÇÃO

10.1. Docstring

Python Docstring é a string de documentação que é literal, e ocorre logo após a definição de
classe, módulo, função ou método. Os documentos podem ser acessados a partir do atributo
doc, __doc__, para qualquer objeto Python e também com a função help().

Além disso, as Docstrings são ótimas para entender a funcionalidade da parte maior do código,
ou seja, o objetivo geral de qualquer classe, módulo ou função, enquanto os comentários são
usados para código, instrução e expressões que tendem a ser pequenas.

 Sintaxe:
 A primeira linha deve ser uma descrição curta.
 As linhas a seguir devem conter um ou mais parágrafos que descrevem as
convenções de chamada do objeto, seus efeitos colaterais, etc.

Exemplo usando o formato Epytext

~ 70 ~
Capítulo 10 - Documentação

10.1.1. Formatos de Docstring

Existem muitos formatos de Docstrings disponíveis, mas é sempre melhor usar os formatos que
são facilmente reconhecidos pelo analisador de Docstring e também pelos colegas cientistas /
programadores de dados. Não há regras e regulamentos para selecionar um formato da
Docstring.

Por exemplo, estilo do Google com tipos em docstrings:

~ 71 ~
Capítulo 10 - Documentação

De forma mais geral:

10.2. Analisando Documentações – Função help()

A ajuda interativa help(object: opcional) retorna a documentação do Python de um objeto,


método, atributo, etc. Basta escrever help(), sem argumento, pressionar o botão ‘Enter’ e
digitar o nome de qualquer palavra-chave, tópico ou módulo para obter ajuda na gravação do
programa Python e para sair ou retornar ao intérprete, basta digitar quit ou q.

Desafios:

1. Faça um programa que tenha uma função chamada contador() que recebe três
parâmetros: início, fim e passo (vale negativo) e realize a contagem de acordo com os
valores determinados pelo usuário.

~ 72 ~
Capítulo 10 - Documentação

2. Crie uma função chamada calculadora, que recebe dois valores e o operador de uma
conta matemática, todos digitados pelo usuário. Imprima o resultado da operação para
o usuário

3. Crie um programa que tenha uma função fatorial() que recebe dois parâmetros, o
número que o usuário deseja calcular e um valor lógico opcional, indicando se será
mostrado ou não o processo de cálculo do fatorial.

4. Faça um programa que tenha uma função notas().

Nota: em todos adicione docstring.

~ 73 ~
Capítulo 11- Organizando Nossos Projetos

CAPÍTULO 11- ORGANIZANDO NOSSOS PROJETOS

11.1. Módulos

Segundo o próprio Python “Um módulo é um arquivo que contém definições e instruções
Python. O nome do arquivo é o nome do módulo com o sufixo .py anexado. Portanto, todos os
arquivos com código Python são módulos, mesmo que não sejam importados. E os módulos
são, basicamente, arquivos de código Python cuja interface pode ser importada por outros
módulos contendo definições e instruções.

Podemos acessar a lista de módulos através do comando:

A linguagem Python já traz um conjunto bastante diversificado com centenas de módulos que
formam a denominada biblioteca padrão da linguagem, como pode ser visto ao chamar o help
acima. Basicamente, a Biblioteca Padrão do Python é uma coleção de módulos de script básicos
acessíveis a um programa Python para simplificar o processo de programação e remover a
necessidade de reescrever os comandos mais usados. Eles podem ser usados chamando-
os/importando-os no início de um script.

Podemos usar uma analogia com nosso corpo para entender melhor sobre módulos e pacotes,
imaginem que temos nosso corpo com todas as funcionalidades básicas já “instaladas”. Agora,
imagine que para o funcionamento adequado do corpo necessitamos de comidas e bebidas, que
são módulos extras que precisamos “adicionar” ao nosso corpo.

~ 74 ~
Capítulo 11- Organizando Nossos Projetos

Se adicionarmos o módulo bebidas da Figura acima, por exemplo, temos acesso a cinco
“funcionalidades”, posso beber cerveja, suco (ou sei lá o que é isso), café, limonada e leite. A
ideia é basicamente essa, só que no caso da programação, estamos adicionando funcionalidades
que precisamos para um determinado programa, como por exemplo, se precisamos calcular um
fatorial em um determinado programa, podemos adicionar a módulo math e usar o método
factorial(), contido na mesma, para realizar esses cálculos, caso contrário precisaríamos criar
um método para efetuar cálculo de um fatorial.

~ 75 ~
Capítulo 11- Organizando Nossos Projetos

11.2. Importações

Além da biblioteca padrão, há uma coleção crescente de vários milhares de componentes (de
programas e módulos individuais a pacotes e frameworks de desenvolvimento de aplicativos
inteiros) criados pela comunidade e disponíveis no Python Package Index (PyPI).

Há duas formas de importação. Podemos importar todo um módulo (com todas as


funcionalidades existentes na mesma) ou apenas uma dada funcionalidade.

~ 76 ~
Capítulo 11- Organizando Nossos Projetos

Tome cuidado!! Há uma diferença ao se chamar um método de um dado módulo, ou seja,


quando se importa pedaços do mesmo, de quando se importa todo o módulo. Ao se importar
tudo, para chamar determinado método precisamos coloccar nomDoModulo.função.

~ 77 ~
Capítulo 11- Organizando Nossos Projetos

E ao se importar partes, um método por exemplo, precisamos colocar apenas função.

Esta última não é recomendável, pois pode ocorrer conflito caso haja métodos com o mesmo
nome em mais de um módulo. No caso de existir duas funções com o mesmo nome o Python
interpreta como certa a referente a última importação.

11.3. Mais a Fundo: Como Funciona a Importação

Por padrão, ao tentarmos importar um módulo o interpretador buscará de acordo com a


seguinte ordem:

1. No diretório do módulo importador;

~ 78 ~
Capítulo 11- Organizando Nossos Projetos

2. Nos diretórios definidos na variável de ambiente de sistema PYTHONPATH, se estiver


configurada. Consulte o módulo sys para mais informações;

3. Nos diretórios onde as bibliotecas padrão e pacotes adicionais estão instalados;

4. Nos diretórios definidos nos arquivos texto .pth, que definem um diretório de busca por
linha. O interpretador buscará nesses diretórios por módulos sendo importados.

Todos esses diretórios são incluídos na variável path disponível no módulo sys. Alterar essa
variável também é um modo de alterar os diretórios onde o interpretador buscará pelos módulos
sendo importados.

11.4. Exemplo de Importação - Cores no Terminal

Uma das formas é utilizando caracteres ANSI. Esta forma consiste em colocar um conjunto de
caracteres logo antes do texto que você quer colorir. De forma geral, temos:

\033[style; text; backm

Onde Style é o estilo, podendo ser:

 0 ---» Sem estilo;


 1 ---» Negrito;
 4 ---» Sublinhado;
 7 ---» Inverter back com text.

~ 79 ~
Capítulo 11- Organizando Nossos Projetos

Text é a cor do texto e back é a cor de fundo.

Cor Fonte Fundo


Preto \033[1;30m \033[1;40m
Vermelho \033[1;31m \033[1;41m
Verde \033[1;32m \033[1;42m
Amarelo \033[1;33m \033[1;43m
Azul \033[1;34m \033[1;44m
Magenta \033[1;35m \033[1;45m
Cyan \033[1;36m \033[1;46m
Cinza Claro \033[1;37m \033[1;47m
Cinza Escuro \033[1;90m \033[1;100m
Vermelho Claro \033[1;91m \033[1;101m
Verde Claro \033[1;92m \033[1;102m
Amarelo Claro \033[1;93m \033[1;103m
Azul Claro \033[1;94m \033[1;104m
Magenta Claro \033[1;95m \033[1;105m
Cyan Claro \033[1;96m \033[1;106m
Branco \033[1;97m \033[1;107m
Negrito \033[;1m -
Inverte \033[;7m -
Reset (remove formatação) \033[0;0m -

Exemplo prático:

~ 80 ~
Capítulo 11- Organizando Nossos Projetos

É frequente criar uma lista de cores, dessa forma, não precisamos ficar decorando os códigos
para cada cor, fica relativamente mais fácil. Ou, ainda, instalar outros módulos que trabalham
com cores, por exemplo este

11.5. Modularização - Criando Módulos

Agora que já sabemos como criar nossas próprias funções e importar módulos externos,
podemos discutir um pouco sobre como programadores geralmente organizam seus programas,
uma espécie de boas práticas.

No desenvolvimento de aplicações computacionais, muitas vezes é conveniente dividir o


código fonte em diversos arquivos (módulos), isso é conhecido como modularização. Logo a
modularização consiste em dividir problemas grandes em vários problemas menores, de baixa
complexidade.

~ 81 ~
Capítulo 11- Organizando Nossos Projetos

As vantagens da utilização desse conceito são que: traz uma maior organização; melhora a
compreensão do código; facilita a manutenção e expansão do programa e; possibilita a
reutilização de módulos criados em outros programas, reusabilidade, facilitando o
desenvolvimento.

Se um programa pode ser executado por si só ou importado dentro de outro, como distinguir
as duas situações?

A variável __name__ é definida para cada programa, se é um módulo retorna o nome do


módulo e se é um programa sendo executado retorna __main__.

Para saber se o código está sendo executado como módulo, basta testar: If __name__ ==
'__main__' :

Isso pode ser útil para casos em que não se pretende executar o main de um módulo. Por
exemplo, digamos que não é desejável que se imprima na tela ‘Iniciando o main do modulo’,
mas ao fazermos isso

~ 82 ~
Capítulo 11- Organizando Nossos Projetos

Essa mensagem é impressa, mesmo o modulo não sendo nosso programa principal (main). Para
resolver isso podemos fazer como citado anteriormente

Como visto no exemplo anterior, podemos criar nossos próprios módulos, afinal todo
arquivo.py para o python pode ser um módulo, e, assim, organizarmos nosso projeto como bem
entendermos.

Caso você precisar usar uma variável global de um módulo, poderá fazê-lo com a mesma
notação usada para se referir às suas funções, nomeModulo.nomeItem.

~ 83 ~
Capítulo 11- Organizando Nossos Projetos

11.6. Pacotes

Infelizmente, como nem tudo são flores (lá vem bomba 💣💣), a modularização é limitada.
Chega um ponto, em programas grandes e complexos, em que apenas a modularização não será
suficiente para garantir uma organização “adequada” para nossos projetos. Para esses casos,
vamos utilizar outro conceito como forma de organização, pacotes. Pacotes são comparáveis a
bibliotecas em linguagens como java.

Um pacote é basicamente um diretório, uma pasta, que contém um arquivo chamado


__init__.py, os demais arquivos e diretórios dentro do pacote são encarados recursivamente
como módulos. Dessa forma podemos criar vários pacotes dentro de pacotes, dividindo e
organizando nosso projeto como desejarmos.

Nesta apostila foi usada a IDE Pycharm para a seção de pacotes.

~ 84 ~
Capítulo 11- Organizando Nossos Projetos

O arquivo __init__.py é o “módulo” executado quando chamamos o pacote, ou seja, ele


referencia o pacote (ou responde pelo pacote). Logo, para cada pacote, teríamos, um
__init__.py. No Pycharm ao criar um pacote o __init__.py é criado automaticamente.

Tenha em mente o seguinte: módulos são estruturados em arquivos, enquanto que, pacotes são
estruturados em pastas. Por exemplo, se criarmos um pacote chamado uteis na pasta do nosso
projeto,

que contém um outro pacote chamado números.

Podemos colocar dentro de números funções referentes a contas matemáticas, por exemplo.

~ 85 ~
Capítulo 11- Organizando Nossos Projetos

Dessa forma, ao escrever uma função em __init__.py de números, poderíamos acessar a


função no programa principal da seguinte forma

~ 86 ~
Capítulo 12- Erros E Exceções

CAPÍTULO 12- ERROS E EXCEÇÕES

12.1. Erros

Vamos começar com uma frase inspiradora: “Erros sempre vão acontecer, mas o importante é
saber como lidar com eles. ”

Existem pelo menos dois tipos distintos de erros: sintaxe e exceções. Os erros de sintaxe são,
provavelmente, os mais frequentes entre aqueles que ainda estão aprendendo, este tipo de erro
emite uma mensagem do tipo: SyntaxError: invalid syntax.

Como vocês devem ter percebido, a ocorrência de um erro, sem tratamento, faz com que
o programa encerre abruptamente, veremos que isso acontece para exceções também.

~ 87 ~
Capítulo 12- Erros E Exceções

12.2. Exceções

Às vezes, mesmo que um comando ou expressão estejam sintaticamente corretos, talvez ocorra
um erro na hora de sua execução. Erros detectados durante a execução são chamados exceções
e não são necessariamente fatais (logo, logo veremos por que). Basicamente, uma exceção
representa uma situação que normalmente não ocorre e representa algo de estranho ou
inesperado no sistema. Quando uma exceção não é tratada o programa emite uma mensagem
de erro, para isso dizemos que uma exceção foi lançada. Há muitas exceções internas no Python
que são geradas quando ocorrem erros correspondentes. Por exemplo, se tentarmos dividir um
número por 0 (que atualmente é impossível) temos uma exceção ZeroDivirionError.

Perceba no exemplo acima, que na exceção não há um erro de sintaxe (no sentido de código),
mas sim um erro matemático. Veja, também, em destaque, que o tipo de exceção é exibido
como parte da mensagem, ZeroDivisionError, seguido por um detalhamento da própria
exceção, division by zero.

Já no próximo caso, ao tentarmos transformar um dado do tipo string em inteiro temos outro
tipo de erro, já que “vinte e dois” não é um número e, logo, a conversão não é possível.

E por aí vai, temos diversos tipos de exceções, mas fique com mais ALGUMAS de exemplo:

~ 88 ~
Capítulo 12- Erros E Exceções

Exceção Causa

Gerado quando a atribuição ou referência de atributo falha.


AttributeError

Gerada quando um módulo não pôde ser localizado.


ModuleNotFoundError
Gerado quando o índice de uma sequência está fora do
IndexError intervalo.
Gerado quando uma chave não é encontrada em um
KeyError dicionário.
Gerado quando o usuário pressiona a tecla de interrupção
KeyboardInterrupt (Ctrl + C ou delete).

Gerado quando uma operação fica sem memória.


MemoryError
Gerado quando uma variável não é encontrada no escopo
NameError local ou global.
Gerado quando o resultado de uma operação aritmética é
OverflowError muito grande para ser representado.

Quando uma referência de atributo ou atribuição falha.


AttributeError
Gerado quando um arquivo ou diretório é solicitado, mas
FileNotFoundError não existe.

12.3. Classes de Exceção

As exceções são organizadas por classes, cada classe é responsável por uma gama de exceções
que estão relacionadas. Por exemplo, a classe ArithmeticError é responsável por erros
aritméticos: OverflowError, ZeroDivisionError, FloatingPointError.

A classe BaseException é a raiz de todas as classes de exceção no Python. Ela não se destina a
ser herdado diretamente por classes definidas pelo usuário (para isso, use Exception). A figura
a seguir mostra a hierarquia de classes de exceção no Python.

~ 89 ~
Capítulo 12- Erros E Exceções

12.4. Lidando com Exceções - Bloco try-except

No Python, podemos usar a instrução try-except para manipulação de exceções.

Vamos, então, tentar resolver o problema que tínhamos com a divisão por 0.

~ 90 ~
Capítulo 12- Erros E Exceções

Na linha 14 temos o bloco try, esse bloco contém o código que pode gerar uma exceção. E na
linha 19, temos o bloco except, que contém o código para manipular a exceção. Perceba que
quando ocorre a exceção na linha 17, o programa passa diretamente para a execução do except
e posteriormente continuará executando o restante do programa. Por outro lado, se nenhuma
exceção foi gerada no bloco try, a clausura except é ignorada.

Mas e se, nesse nosso exemplo, ao invés de dividir por zero tentarmos dividir um inteiro por
uma string?

É… o programa até trata o erro, mas trata de forma errada. Da sessão anterior sabemos que os
erros gerados por cada uma das exceções são TypeError e ZeroDivisionError, vamos fazer o
seguinte:

~ 91 ~
Capítulo 12- Erros E Exceções

Dessa forma, o tratamento do erro é direcionado para seu except correspondente.

12.5. Mais Blocos - else e finally


Agora vamos incrementar um pouco mais nosso programa, com novos blocos. Veja a sintaxe:

Dessa forma, temos as seguintes possibilidades

~ 92 ~
Capítulo 12- Erros E Exceções

~ 93 ~
Capítulo 12- Erros E Exceções

Ou seja, os blocos são executados assim:

Desafios:

1. Crie um sistema de cadastro de pessoas. O programa deve ser capaz de salvar e


acessar dados (nome e idade). Esses dados devem estar disponíveis mesmo após o
encerramento da execução do programa.

~ 94 ~
REFERÊNCIAS

[1] https://pythonacademy.com.br/blog/porque-aprender-python-5-motivos-para-
aprender-agora
[2] https://www.udemy.com/course/intro_python/
[3] DevFuriadevfuria.com.br
[4] https://www.youtube.com/watch?v=S9uPNppGsGo&list=PLHz_AreHm4dlKP6QQC
ekuIPky1CiwmdI6&index=1
[5] https://wiki.python.org.br/PythonBrasil
[6] https://www.caelum.com.br/apostila-python-orientacao-objetos/
[7] https://www.devmedia.com.br/
[8] https://stackoverflow.com/
[9] https://www.datacamp.com/home
[10] https://wiki.python.org.br/PythonBrasil
[11] Python Tuples (w3schools.com)
[12] https://www.programiz.com/
[13] https://github.com/google/styleguide/blob/gh-pages/pyguide.md#38-comments-and-
docstrings
[14] https://www.geeksforgeeks.org/
[15] https://medium.com/

~ 94 ~

Você também pode gostar