Aula 01 - Apostila Introdutória

Fundamentos essenciais de Python
Direitos desta edição reservados

A Voitto Treinamento e Desenvolvimento
www.voitto.com.br
Supervisão editorial: Thiago Coutinho de Oliveira

Apresentação do curso: Iago Gomes de Lima Rosa
Produção de conteúdo: Iago Gomes de Lima Rosa e Ruan Medina Carvalho
Iago Rosa e Ruan Medina são mestrandos em Modelagem Computacional no Programa de Pós-Graduação
de Modelagem Computacional (PPGMC) na Universidade Federal de Juiz de Fora (UFJF), se formaram em
Ciências Exatas e, posteriormente, Engenharia Computacional pela mesma universidade. Iago trabalha,
atualmente, na linha de pesquisa em Sistemas Computacionais Aplicados, com com foco em Data Science,
Machine Learning e Modelos Baseados em Agentes aplicado ao Sistema Bancário e integra o Grupo de
Pesquisa em Moeda e Desenvolvimento da Universidade Federal Rural do Rio de Janeiro (UFRRJ). Ruan
Medina também trabalha na linha de pesquisa de Sistemas Computacionais Aplicados, porém focado em
Modelagem e Dinâmica Molecular. Ambos possuem experiência em educação em tecnologia e inovação
como membros egressos do Grupo de Educação Tutorial em Engenharia Computacional (GET-EngComp).
É PROIBIDA A REPRODUÇÃO
Nenhuma parte desta obra poderá ser reproduzida, copiada, transcrita ou mesmo
transmitida por meios eletrônicos ou gravações sem a permissão, por escrito, do editor. Os
infratores serão punidos pela Lei n° 9.610/98
Sumário
Sumário............................................................................................................................................................................. 3
0. Introdução ao curso.................................................................................................................................................... 6
0.1. Sobre o Python................................................................................................................................................. 6
0.1.1. História.................................................................................................................................................... 6
0.1.2. O que é o Python?................................................................................................................................. 6
0.2. Onde é usado.................................................................................................................................................... 7
0.2.1. Python + Linux....................................................................................................................................... 8
0.3. Apresentação do curso.................................................................................................................................... 8
1. Configuração do ambiente de desenvolvimento.................................................................................................... 9
1.1. Conhecendo o Anaconda................................................................................................................................ 9
1.2. Configurando o ambiente............................................................................................................................... 9
1.3. Conhecendo o Jupyter................................................................................................................................... 13
1.4. Conhecendo o Spyder................................................................................................................................... 13
2. Variáveis e comunicação com o usuário................................................................................................................ 14
2.1. O que são variáveis?.......................................................................................................................................14
2.2. Criando variáveis............................................................................................................................................ 14
2.2.1. Regras para declaração de variáveis................................................................................................. 14
2.2.2. Criando variáveis................................................................................................................................. 15
2.2.3. Declaração de múltiplas variáveis..................................................................................................... 16
2.3. Funções de impressão e captura de dados................................................................................................ 16
2.4. Funções nativas para variáveis......................................................................................................................17
2.5. Operações aritméticas................................................................................................................................... 20
2.5.1. Ordem de precedência....................................................................................................................... 21
2.6. Exercícios......................................................................................................................................................... 21
3. Operadores lógicos, relacionais e estruturas condicionais..................................................................................22
3.1. Operadores lógicos........................................................................................................................................ 22
3.1.1. And........................................................................................................................................................ 22
3.1.2. Or........................................................................................................................................................... 22
3.1.3. Not......................................................................................................................................................... 23
3.1.4. Tabela da verdade............................................................................................................................... 23
3.1.5. Ordem de precedência....................................................................................................................... 23
3.2. Expressões relacionais................................................................................................................................... 23
3.3. Resumo de precedência e exemplos........................................................................................................... 24
3.4. Estruturas condicionais if, else e elif............................................................................................................ 25
3.4.1. If............................................................................................................................................................. 25
3.4.2. Else.........................................................................................................................................................26
3.4.3. Elif.......................................................................................................................................................... 26
3.5. Exercícios......................................................................................................................................................... 27
4. Trabalhando com Strings......................................................................................................................................... 27
4.1. Strings.............................................................................................................................................................. 27
4.2. Acesso a elementos........................................................................................................................................28
4.2.1. Índices................................................................................................................................................... 28
4.2.2. Slices...................................................................................................................................................... 28
4.3. Operadores em strings.................................................................................................................................. 29
4.4. Métodos e manipulação de strings............................................................................................................. 30
4.4.1. Count..................................................................................................................................................... 30
4.4.2. Find e Replace...................................................................................................................................... 31
4.4.3. Upper, Lower e Capitalize...................................................................................................................31
4.4.4. Split e Join............................................................................................................................................ 31
4.4.5. Strip....................................................................................................................................................... 32
4.5. Inserção e formatação de substrings........................................................................................................... 32
4.6. Exercícios......................................................................................................................................................... 33
5. Estrutura de dados.................................................................................................................................................... 33
5.1. Listas................................................................................................................................................................. 33
5.2.1. Manipulação de listas......................................................................................................................... 34
5.2. Tuplas............................................................................................................................................................... 36
5.2.1. Manipulação de tuplas....................................................................................................................... 37
5.3. Dicionários....................................................................................................................................................... 39
5.3.1. Manipulação de dicionários............................................................................................................... 39
5.4. Conjuntos........................................................................................................................................................ 41
5.4.1. Manipulação de conjuntos................................................................................................................. 41
5.5. Exercícios......................................................................................................................................................... 43
6. Estrutura de repetição...............................................................................................................................................43
6.1. Instrução for.................................................................................................................................................... 43
6.2. Iteradores range e enumerate...................................................................................................................... 44
6.2.1. Range.................................................................................................................................................... 44
6.2.2. For + Range..........................................................................................................................................45
6.2.3. Enumerate............................................................................................................................................ 46
6.2.4. For + Enumerate.................................................................................................................................. 46
6.3. While................................................................................................................................................................ 46
6.4. Interrupção de loops...................................................................................................................................... 47
6.4.1. Break......................................................................................................................................................47
6.4.2. Continue............................................................................................................................................... 48
6.4.3. Pass........................................................................................................................................................ 49
6.5. List comprehension........................................................................................................................................ 49
6.6. Exercícios......................................................................................................................................................... 50
7. Funções....................................................................................................................................................................... 51
7.1. Função.............................................................................................................................................................. 51
7.1.1. Parâmetros........................................................................................................................................... 51
7.2. Tipos de retorno............................................................................................................................................. 52
7.2.1. Único..................................................................................................................................................... 53
7.2.2. Múltiplos............................................................................................................................................... 53
7.3. Funções anônimas.......................................................................................................................................... 53
7.4. Exercícios......................................................................................................................................................... 56
8. Introdução à Orientação a Objetos.........................................................................................................................56
8.1. Introdução....................................................................................................................................................... 56
8.1.1. Motivações........................................................................................................................................... 56
8.1.2. Vantagens............................................................................................................................................. 57
8.2. O que são classes?......................................................................................................................................... 57
8.3. Métodos e atributos.......................................................................................................................................58
8.3.1. Atributos............................................................................................................................................... 58
8.3.2. Métodos................................................................................................................................................60
8.4. O que são objetos?........................................................................................................................................ 61
8.4.1. Instanciando objetos........................................................................................................................... 62
8.5. Encapsulamento............................................................................................................................................. 64
8.5.1. Atributos privados............................................................................................................................... 64
8.5.2. Métodos get e set............................................................................................................................... 65
8.5.3. Métodos privados............................................................................................................................... 65
8.6. Exercícios......................................................................................................................................................... 66
9. Bibliotecas...................................................................................................................................................................67
9.1. Introdução....................................................................................................................................................... 67
9.2. Importando bibliotecas................................................................................................................................. 67
9.3. Usando bibliotecas......................................................................................................................................... 69
Referências..................................................................................................................................................................... 70
0. Introdução ao curso
Nesta seção vamos apresentar a vocês aspectos gerais sobre a linguagem de programação Python. Serão
abordados assuntos como a história da linguagem, quais aplicações ela possui, quais empresas do mercado
brasileiro e mundial usam o Python no dia a dia delas e o quais serão os conhecimentos a serem
desenvolvidos ao longo do curso.
Essa apostila tem como objetivo principal aprofundar os assuntos abordados durante as vídeo aulas sobre a
linguagem Python, com diversos exemplos e linguagem de fácil entendimento.
0.1. Sobre o Python
0.1.1. História
A linguagem foi concebida no final da década de 80. Porém, em 1982, Guido Van Rossum teve a primeira
ideia de implementar o Python enquanto trabalhava no CWI (Centrum Wiskunde & Informatica, Centro de
Matemática e Ciência da Computação) em Amsterdã, Holanda, no time de desenvolvimento da linguagem
ABC.
Com o fim da linguagem ABC, Guido foi transferido para um projeto do sistema operacional chamado
Amoeba. Nesse grupo de trabalho, ele percebeu a necessidade de criar uma linguagem para escrever
programas intermediário, algo entre as linguagens C e Shell Script. Assim, em 1991, foi lançada a primeira
versão da linguagem: o Python 1.0 .
O nome Python foi escolhido pois Van Rossum decidiu seguir uma ideia parecida com a de James Gosling,
criador da linguagem Java. James escolheu o nome “Java” pois era o nome da terra de origem do café que
seus colegas de trabalho apreciavam. De acordo com “Trytoprogram” [1], em 1970 existia um programa de
comédia da BBC chamado “Monty Python’s Flying Circus” que Guido gostava muito. Então, quando o
projeto da linguagem foi concluído, ele percebeu que o nome Python possuía as características que queria
para o nome de uma linguagem: marcante e forte.
Outra informação interessante sobre essa linguagem, de acordo com o site “Mindbending” [2], é que, por
muito tempo, o autor evitou vincular o nome da linguagem à cobra píton, porém desistiu quando a editora
O’Reilly sugeriu colocar a cobra na capa do primeiro livro “Programming Python”.
0.1.2. O que é o Python?

O Python é uma linguagem de programação interpretada, modular, orientada a objetos e funcional, além
de possuir tipagem dinâmica e forte. Mas o que significa tudo isso?
Uma linguagem é dita interpretada se ela não precisa ser traduzida para a linguagem de máquina
(compilada), mas sim interpretada por um outro programa do computador, chamado interpretador, e esse
traduzirá o código para a compilação. Quando uma linguagem é modular ela possui o desenvolvimento das
rotinas feito através de módulos que são interligados por uma interface comum [3]. A característica de
orientada a objetos é muito forte no Python, isso quer dizer que toda a estrutura da linguagem é feita em
cima dos conceitos classes e objetos da POO (Programação Orientada a Objetos). Além disso, essa
linguagem é funcional por estar fortemente fundamentada em conceitos de funções matemáticas.
Quando falamos de tipagem dinâmica e forte, uma das principais características do Python, significa que a
linguagem reconhece o tipo da variável declarada e, uma vez reconhecido, ele se manterá o mesmo até
que ela seja descartada.
Diferentemente de outras ferramentas, o Python é distribuído gratuitamente. Assim como outros softwares
de código aberto, como o Linux, é possível vermos o código fonte inteiro da linguagem de graça na
internet e sem nenhuma restrição. Podemos, inclusive, mudar ou adaptar qualquer parte do código, se
estivermos aptos a isso. Porém, não devemos pensar que, por ser de graça, o Python não oferece apoio
para seus usuários. A comunidade online do Python costuma responder às dúvidas de seus usuários de
forma rápida e eficiente.
0.2. Onde é usado

De acordo com [4] a linguagem possui diversas aplicações no mundo atual. A figura abaixo explica quais as
aplicações do Python hoje em dia.
Fonte: DataFlair -
Disponível em: https://data-flair.training/blogs/python-applications/
Essas diversas aplicações fazem com que o Python amplie as possibilidades tanto de quem vai entrar no
mercado de trabalho quanto das empresas que poderão usá-lo em seu dia a dia.
No âmbito mundial empresas como Instagram estão mudando suas plataformas para para o Python
combinado com o Django (Framework do Python). A linguagem foi escolhida por três principais motivos: (i)
popularidade da linguagem, (ii) velocidade de desenvolvimento e (iii) preferência dos desenvolvedores pela
linguagem. O Spotify é uma das maiores plataformas em streaming que usa o Python. Aproximadamente
80% dos serviços de back-end da empresa usam a linguagem para estabelecer as conexões necessárias.
Outra empresa gigante que precisa ser mencionada é a Google. A maior empresa de tecnologia do mundo
usa o Python tanto em projeto internos quanto externos, para ser mais abrangente, sendo o Youtube um
dos exemplos. Além dessas, podemos citar, também, Yahoo, IBM, Nokia e até a Nasa.
Já no cenário nacional a grande empresa de destaque é a Globo.com. A empresa usa o Python em grande
escala para gerenciar os conteúdos dos seus portais, uma vez que a natureza desses conteúdos precisa de
praticidade. Vale ressaltar que o Django é muito utilizado, também, pela empresa. Além da Globo.com
temos também outras como Mercado Livre e MagazineLuiza.
0.2.1. Python + Linux

Além das diversas empresas que usam o Python dentro de seus projetos, a linguagem possui forte relação
com o sistema operacional Linux. Ao contrário do Windows e Mac OS, o Linux não foi desenvolvido com
fins comerciais, além de possuir código aberto, o que significa que qualquer pessoa pode criar e distribuir
aplicativos para ele. Este sistema já possui o Python instalado, sendo possível utilizá-lo pelo terminal e
dispensar instalações prévias da linguagem.
0.3. Apresentação do curso

A principal razão para aprender a programar é fazer diferença no mercado de trabalho. Após a grande
revolução digital do século diversas empresas adotaram softwares modernos e precisam de pessoas que
saibam utilizar essas ferramentas. Além dos softwares, a programação é utilizada para a interpretação da
enorme quantidade de dados que a revolução digital proporcionou.
Neste curso você aprenderá os principais fundamentos da programação na linguagem Python. Serão
abordados assuntos como variáveis, expressões condicionais, estruturas lógicas e de repetição, estruturas
de dados, como listas e tuplas, e funções na programação. Todos esses assuntos contribuirão para o início
do seu conhecimento sobre programação e, principalmente, sobre o Python.
1. Configuração do ambiente de desenvolvimento
Antes de começarmos a programar, precisamos configurar o computador. Para isso, precisamos de uma IDE
(Integrated development environment) capaz de interpretar e rodar nossos códigos. Quando executamos o
código criado estamos passando a seguinte mensagem para o computador “faça o que meu código te diz
para fazer”. De acordo com [5] existem vários ambientes de desenvolvimento para programarmos em
Python, podendo ser gratuitos ou não. Neste curso, usaremos a IDE Jupyter que será instalada através da
distribuição Anaconda.
1.1. Conhecendo o Anaconda

O Anaconda é uma plataforma de distribuição gratuita e código aberto para diversas linguagens, podendo
destacar o Python e o R. Quando se trata do Python, ela já possui um interpretador integrado, facilitando o
processo de programação.
Juntamente com o Conda, sistema de gerenciamento de pacotes de código o aberto que instala
rapidamente, executa e atualiza pacotes e suas dependências [6], essa plataforma se torna uma forte aliada
para os programadores, principalmente na área de ciência de dados, já que o Anaconda foi feito por
cientistas de dados para cientistas de dados [7].
O interesse principal do Anaconda é simplificar as instalações dos pacotes. Ao invés de precisarmos instalar
cada módulo um por um, poderemos baixar tudo de uma vez e atualizar, de forma prática e fácil, na
medida em que um pacote seja necessário.
1.2. Configurando o ambiente

Para instalar o Anaconda em seu computador é preciso seguir os seguintes passos:
1. Acessar o site oficial do Anaconda e ir para a parte de downloads;

2. Escolher o sistema operacional (Linux, Windows ou Mac OS) e realizar o download da versão 3.X do
Python. (neste curso está sendo usada a versão 3.7, mas como o Python sofre constantes
atualizações depende de qual é a versão mais atual disponível)
3. Depois que o download for concluído a seguinte tela aparecerá:
E você deverá clicar em “Next” e, em seguida, aceitar o termos de condição:
4. A próxima tela será para definir se o ambiente poderá ser acessado somente pelo usuário que está
fazendo a instalação (Just me ) ou por todos os outros usuários presentes no computador (All users).
Feita a escolha, prossiga em “Next”.
5. Em seguida, deverá escolher o diretório em que o Anaconda será instalado e depois prosseguir em
Next
6. Na próxima tela, a sugestão é manter a opção que já aparece (Register Anaconda as the system
Python 3.6) e esperar a instalação
7. Na próxima tela uma escolha que deve ser feita pelo usuário caso deseje realizar o MS Visual Studio.
Esta instalação só é recomendada se o usuário estiver familiarizado com o ambiente e preferir este
editor, caso não basta selecionar a opção Skip
8. Por fim, a instalação estará concluída e a seguinte mensagem aparecerá na tela. Então basta
escolher a opção Finish.
9. Depois de instalado o ambiente, o usuário pode localizar em seu sistema a ferramenta Anaconda e
selecionar o ambiente de desenvolvimento desejado (neste caso, o Jupyter) na seguinte tela:
10. Ao clicar, o usuário você será direcionado para a pasta padrão do Jupyter, em que poderá criar um
notebook (ferramenta do Jupyter para criar projetos). Para isso basta ir na opção New > Notebook:
Python 3 e estará pronto para começar seus projetos.
1.3. Conhecendo o Jupyter

O Jupyter Notebook é uma excelente ferramenta popular para escrever códigos em Python. O nome
Jupyter é uma junção das linguagens que ele suporta: Julia, Python e R. Julia e R são mais populares na
área de ciência de dados, enquanto o Python é usado tanto nessa área quanto em várias outras já citadas
anteriormente.
A interface dessa IDE é baseada em navegadores da internet, tanto que, ao abrí-lo, uma nova guia
aparecerá no navegador padrão. Nessa página estão várias pastas (diretórios) que estão disponíveis para
guardar os projetos desenvolvidos no Jupyter. Para começar a programar basta escolher o diretório de
preferência, clicar em “New” e em seguida “Python 3”. Ao fazer isso um novo notebook será aberto como
uma guia do browser de nome Untitled, que é possível alterar apenas realizando um duplo click nele.
Dentro dessa página existe um retângulo com um In[ ]do lado esquerdo, chamado cédula (cell). As
células conterão toda a programação em Python, porém elas também podem conter textos, basta mudar
do tipo de Code para Markdown.
Para rodar um código neste ambiente de desenvolvimento é preciso (i) digitar algum código, como
print(“Hello World!”) e, em seguida, clicar no botão Run ou, no atalho do teclado Windows, crtl +
Enter ou shift + Enter.
1.4. Conhecendo o Spyder

Apesar do Jupyter ser a IDE em que desenvolveremos este curso, ela não é a única que vem com o
Anaconda. Outro também ambiente muito utilizado é o Spyder. O Spyder é um poderoso ambiente
desenvolvido em Python para se programar em Python criado por e para engenheiros, cientistas e analistas
de dados[8].
2. Variáveis e comunicação com o usuário
2.1. O que são variáveis?

Antes de sabermos o que é uma variável precisamos saber o que é um algoritmo. Um algoritmo pode ser
definido como uma sequência finita de instruções que levam a execução de uma tarefa [9]. O algoritmos
estão presentes em várias das nossas atividades diárias, como usar o aplicativo de GPS para traçar a menor
rota até o trabalho. Esse aplicativo faz o uso de um algoritmo que chamamos de caminho mínimo. Porém,
outras tarefas não relacionadas aos computadores podem ser consideradas algoritmos. Um exemplo
clássico é a tarefa de fazer um bolo. Para produzirmos um bolo precisamos seguir o passo a passo como:
1. Juntar os ingredientes;
2. Misturar em uma vasilha;
3. Untar a forma;
4. Colocar a mistura na forma;
5. Colocar a forma no forno pré-aquecido;
6. Retirar a forma após 20 minutos.
Observe que para termos o bolo precisamos seguir esses passos mostrados acima. Mas qual a diferença
entre o algoritmo do computador e os algoritmos do nosso dia a dia? Nós, como seres humanos, podemos
tolerar e interpretar um algoritmo que não foi descrito com precisão, ma o computador não. Portanto, ao
escrevermos nossos algoritmos ao longo deste curso e da vida de programador é necessário descrevermos
cada tarefa com precisão para evitarmos tanto problemas de lógica (entendimento do computador sobre o
que foi escrito) quanto de sintaxe (regras para a linguagem utilizada).
E onde entram as variáveis nesse processo? Se observarmos a receita de bolo novamente teremos algumas
variávei como ingredientes, forma e forno. Em computação, variáveis são formas de armazenar dados que
serão usados ao longo do nosso código. No Python existem 4 principais tipos de variáveis:
● int - qualquer número inteiro positivo ou negativo;

● float - qualquer número que contém um ponto decimal, também chamado de números reais;
● string - são variáveis do tipo texto;
● bool - uma variável categórica, que recebe apenas valores de True (verdadeiro) ou False (falso).
2.2. Criando variáveis

Antes de começarmos a criar variáveis para nosso programa existem algumas regras que devem ser
seguidas.
2.2.1. Regras para declaração de variáveis

Para definirmos nossas variáveis algumas regras devem ser observadas:
1. O nome da variável em Python não pode começar com um valor numérico. Por exemplo, se
definirmos uma variável de nome 1valor haverá um erro de sintaxe;
2. Não podem existir espaços dentro do nome da variável. Se definirmos com o nome valor teste o
Python retornará um erro;
3. Não é possível utilizar caracteres especiais no Python, como %, $, &, <, >, |, \, /, etc.
4. Existem alguma palavras reservadas da linguagem e essas não podem ser utilizadas para nomes de
variáveis. Dentre elas, temos:
Uma dica de ouro para programar em python e todas as outras linguagens é que o nome da variável esteja
relacionado com o que ela irá armazenar. Ou seja, criar um nome significativo para facilitar a compreensão
sobre o que a variável representa. Por exemplo, se criarmos uma variável para armazenar o ano de um carro,
podemos definir o nome da variável como anoCarro (lembrando sempre das regras de definição de nome).
Também poderíamos colocar o nome da variável como ano pois atende às regras de definição. Porém, com
esse nome, não traria o real significado da variável e se tornaria ambíguo pois podemos declarar o ano de
muitas outras coisas. Essa dica não é somente para o nome de variáveis, deve ser aplicada também aos
nomes de funções, métodos, classes que veremos mais à frente.
2.2.2. Criando variáveis

Para criar uma variável você utiliza a seguinte sintaxe:
nomevariavel = valor
Observe que a esquerda temos o nome que definimos para a variável e a direita temos o valor que ela
receberá. O sinal de igual (=) é chamado de operador de atribuição. Diferentemente do sinal de igualdade
(==) que faz a comparação de dois valores, o sinal de igual faz a atribuição de um valor a uma variável. O
comando de atribuição atribui o valor que está à direita à variável que está do lado esquerdo. Agora veja
um exemplo de comandos de atribuição:
nota = 10
media = 6.6
No comando acima estamos guardando o valor 10 na variável nota e o valor 6.6 na variável média.
Podemos também fazer o seguinte:
nome = “Joao”
Guardamos o valor Joao na variável nome.

Ao contrário de muitas linguagens, o Python, por ter uma linguagem de tipagem forte, não precisa que
identifiquemos o tipo da variável antes de declará-la.
2.2.3. Declaração de múltiplas variáveis

Em python, podemos fazer a declaração múltipla de variáveis que é muito útil no código por utilizar uma
única instrução de código. Veja como fazer a declaração múltipla dessas variáveis:
idade, nome, email = 20, “Joao”, “joao@gmail.com”
Nesse exemplo temos três variáveis declaradas em uma única linha idade, nome e email que recebem,
respectivamente, os valores 20, Joao e joao@gmail.com.
2.3. Funções de impressão e captura de dados

Além das variáveis, o Python possui duas funções principais de interação com o usuário: print e input. O
input é uma função pronta da linguagem que é utilizada para obter entrada de dados. Se em um
determinado momento da aplicação for necessário pedirmos um dado ao usuário essa é a função que
utilizaremos. Ela faz uma pausa no programa e espera que o usuário entre com algum dado. Após o usuário
digitar, o input lê o dado e atribui à variável associada. Ou seja, o valor retornado pelo que o usuário
digitou pode ser armazenado em uma variável e utilizado futuramente. Observe o exemplo:
nome = input(“Por favor digite seu nome: ”)

idade = input(“Por favor digite sua idade: ”)
Nesse caso os valores de nome e idade que forem digitados pelo usuário ficarão armazenados nas variáveis
nome e idade. Porém, é importante ressaltar que mesmo que o usuário tenha digitado um número a
variável armezenará o dado como uma string.
A segunda função é a print. Ela também é uma função pronta da linguagem e é utilizada para saída de
dados. Se durante a aplicação for necessário mostrar ao usuário algum dado, utilizaremos a função print.
Ela pode exibir no terminal mais de uma informação separado por vírgulas. Se a saída a ser exibida for uma
variável, a declaração é definida por print(variavel). Se a saída for uma string, a declaração é definida
por a string que deseja mostrar entre “ ”, da seguinte forma: print(“o seu texto”), igual fizemo no
primeiro “Hello World!”. Cada parâmetro que será mostrado no terminal deve ser separado por vírgula
como o seguinte exemplo: print(par1, par2,..., parN).
nome = “Joao”
idade = 20
print(nome)
print(idade)
Além de podermos imprimir apenas variáveis ou apenas textos, podemos, também, criar frases com a
função print:
nome = “Joao”
nota = 10
print(“Parabéns”, nome, “você tirou”, nota, “no teste”)
Observe que juntamos a parte textual e as variáveis dentro dos parênteses do print .
2.4. Funções nativas para variáveis

O Python possui diversas funções úteis para manipulação de tipos de variáveis. Vamos aprender mais a
frente sobre o que são funções, mas as que serão apresentadas a seguir são bem simples de entender e
muito úteis quando precisamos identificar o tipo da variável que temos (inteiro, texto, etc) ou modificá-lo.
A primeira função que veremos é a type(). Ela, quando chamada, retorna o tipo do objeto que foi
passado como parâmetro. Ou seja, chamamos essa função e passamos algum objeto, como variáveis, ela
nos mostra qual é o tipo daquela variável. Observe o exemplo:
nome = “Joao”
nota = 10
type(nome)
----------------
<class 'str'>
Veja que quando colocamos a variável nome dentro dos parênteses a função mostra que o seu tipo é str,
abreviação de string (texto). Quando colocamos um objeto numérico, como nota, ela nos retorna a seguinte
classe:
type(nota)
-------------------
<class 'int'>
Essa função identifica todos os tipos de objetos presentes na linguagem. Alguns já vimos como inteiros (int),
strings (str) e float (float), outros vamos ver nas lições futuras como listas (list), tuplas (tuple) e dicionários
(dict).
Além da função type(), o Python apresenta funções nativas dos tipos das variáveis que podem ser usadas
para modificar o tipo de uma variável que temos. Veja o exemplo:
r1 = 3.89
r2 = -4.35
type(r1)
type(r2)
--------------------------------
<class 'float'>
<class 'float'>
i_r1 = int(r1)
i_r2 = int(r2)
print(i_r1)
print(i_r2)
---------------------------------
3
-4
Nele, transformamos as variáveis r1 e r2 em variáveis inteiras i_r1 e i_r2. É importante ressaltar que a
função nativa int() não arredonda os valores das variáveis, mas sim retira a parte depois da vírgula do
número real e deixa apenas a parte inteira. Assim como a função int(), temos funções dos outros tipos de
dados, como float() e str().
n1 = 10
r1 = 3.89
print(str(n1))
print(str(r1))
---------------------------------
10
3.89
Esse tipo de conversão é comumente chamado de cast. No exemplo acima fizemos um cast de inteiro para
string e outro cast de float para string.
print("r1 tem o valor", r1, "e o tipo", type(r1))

print("i_r1 tem o valor", i_r1, "e o tipo", type(i_r1))
------------------------------------------------------
r1 tem o valor 3.89 e o tipo <class 'float'>
i_r1 tem o valor 3 e o tipo <class 'int'>
É possível também mudarmos, momentâneamente, o tipo da variável, o que é muito útil quando
precisamos fazer certas operações ou quando queremos mostrar alguma frase na tela:
print("n1 em cast para float vale", float(n1), "mas n1 continua valendo", n1,
"e com o tipo", type(n1))
-------------------------------------------------------------------------------
n1 em cast para float vale 10.0 mas n1 continua valendo 10 e com o tipo <class
'int'>
Quando usamos a função input() para recolher dados, o Python identifica todos os dados como strings.
Porém, em alguma situações, precisamos que o dado lido seja de um outro tipo de dado. Para
convertermos um número inserido pelo usuário em um número do Python, basta usarmos uma dessas
funções citadas acima, como int() ou float ().
nota = input("Qual a sua nota?")
print(type(nota))
nota = int(input("Qual a sua nota?"))
print(type(nota))
-------------------------------------------
Qual a sua nota?10
<class 'str'>
Qual a sua nota?10
<class 'int'>
Além das funções apresentadas anteriormente, vamos comentar de outras três funções nativas como
len(), round() e abs(). O método len() é muito usado para verificar o tamanho de uma variável. Se
tivermos uma variável do tipo string, ele contará quantos caracteres temos na string.
mensagem = “Olá mundo”

print(type(mensagem))
print("O tamanho da variavel mensagem é: ", len(mensagem))
---------------------------------------------------------------
<class 'str'>
O tamanho da variavel mensagem é: 9
O round() é usado em situações que queremos arredondar o valor de uma variável e o abs() é para quando
queremos apenas o valor absoluto de uma variável:
n2 = - 20
n2_abs = abs(n2)
print("n2 =", n2, "e n2_abs =", n2_abs)
------------------------------------------------
n2 = -20 e n2_abs = 20
Para usarmos o round precisamos passar duas informações para esse método: o objeto que queremos
arredondar e a quantidade de casas depois da vírgula que desejamos:
r2 = -5.39674
r2 = round(r2, 1)
print(r2)
----------------------------------------
-5.4
Veja que o número que antes tinha 5 casas decimais agora tem apenas uma.
2.5. Operações aritméticas
O Python, assim como as demais linguagens de programação, apresenta as operações aritméticas básicas,
como adição, subtração, multiplicação e divisão sendo representados, respectivamente por +, -, * e / . Além
dessas operações básicas há também a operação de módulo, representada pelo símbolo %, de potência,
representada por **, e de divisão inteira, representada por //. A tabela a seguir mostra como funcionam
esses operadores:
Operação Descrição Exemplo
+ Adição 2+2=4
- Subtração 10 - 1 = 9
* Multiplicação 3 * 5 = 15
/ Divisão 10 / 2 = 5
% Módulo (resto da divisão) 7/2=1
** Potenciação 2 ** 3 = 8
// Divisão inteira 11 // 5 = 2
É importante ressaltar que as operações aritméticas devem ser feitas apenas entre variáveis de tipos
numéricos:
numero = 1
falso_numero = '1'
print(numero, falso_numero)
print(type(numero), type(falso_numero))
----------------------------------------------------
1 1
<class 'int'> <class 'str'>
print('Soma = ', numero + falso_numero)

----------------------------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Observe que quando tentamos soma o numero, do tipo int, com o falso_numero, do tipo str, o Python
retorna um erro, dizendo que não é possível realizar operações entre inteiros e textos
2.5.1. Ordem de precedência
Assim como aprendemos na escola que temos uma ordem para realizar operações em expressões
aritméticas, em programação também seguimos uma ordem. Devemos seguir a seguinte ordem:
1. Os parênteses têm a mais alta precedência e podem ser usados para forçar que uma operação ou
expressão seja calculada primeiro. Além disso, os parênteses são muito usados, também, para deixar
as expressões mais legíveis;
2. Exponenciação tem a segunda precedência mais alta;
3. Multiplicação, divisão e divisão inteira possuem o mesmo nível de precedência. Se tivermos várias
delas em uma expressão elas serão executadas da esquerda para a direita na ordem em que
aparecem;
4. Por fim, as últimas operações que serão realizadas são adição e subtração, que, também, possuem o
mesmo nível de precedência, e devem ser executadas da esquerda para a direita na ordem em que
aparecem.
Veja como o mesmo conjunto de operações pode obter diferentes resultados de acordo com a ordem de
precedência:
print(5 + 3 * 2)
print(3 * 5 + 4 **2)
print(3*(5+4)**2)
--------------------------------
11
31
243
2.6. Exercícios
1. Escreva um programa para calcular a soma de dois inteiros lidos do teclado;
2. Escreva um programa que receba três valores do teclado e escreva na tela a soma e a média desses
valores;
3. Faça um programa que leia um número inteiro e escreva na tela o antecessor e o sucessor deste.;
4. Escreva um programa que receba os dados de um triângulo (base e altura) e calcule sua área;
5. Escreva um programa que leia um número do teclado e informe seu dobro, seu triplo e sua raiz
quadrada;
6. Escreva um programa que leia um valor em metros e converta para centímetros e milímetros;
7. Faça um programa que leia altura e largura de uma parede, calcule sua área e a quantidade de tinta
necessária para pintá-la sabendo que cada litro de tinta pinta 2m^2.
3. Operadores lógicos, relacionais e estruturas
condicionais
3.1. Operadores lógicos

O operador lógico, assim como um operador aritmético, pertence a uma classe de operações sobre
variáveis e elementos. Com eles trabalhamos com valores do tipo bool. Geralmente, variáveis desse tipo são
utilizadas para realizar comparações e podem assumir somente dois valores: True ou False [10]. Em Python
temos 3 operadores lógicos: and, or e not.
Operador Exemplo no código O que determina
and a and b se ambos x e y são verdadeiros
or a or b se apenas x ou apenas y é verdadeiro
not not a nega o valor original de x
3.1.1. And
Sejam dois valores booleanos A e B. O operador and resulta em um valor True (verdadeiro) se os dois
valores forem verdadeiros. Se um deles ou ambos tiverem valor falsos, resulta em um valor False (falso).
a = True
b = False
print ('A and B =', a and b)
-----------------------------
A and B = False
3.1.2. Or
Sejam dois valores booleanos A e B. O operador OR resulta em valor False (falso) apenas quando os dois
valores forem falsos, se apenas um for verdadeiro.
a = False
b = True
print ('A or B =', a or b)
-----------------------------
A or B = True
3.1.3. Not
Seja um valor booleano A, o operador not tem como função inverter o valor original. Se o valor passado for
True ele inverte para False e se o valor passado for False, ele inverte para True.
a = False
print ('Invertendo o valor de a:', not a)
-----------------------------------------
Invertendo o valor de a: True
3.1.4. Tabela da verdade

A tabela da verdade é um recurso muito utilizado no estudo da matemática lógica. Com ela podemos
determinar qual será o valor de uma operação lógica, isto é, saber se a operação retornará valor verdadeiro
(True) ou falso (False).
A B A and B A or B
True False False True
True True True True
False False False False
False True False True
Observe que, com ela, podemos ver todos os resultados das operações and e or e provar que o operador
and apenas retorna verdadeiro quando suas duas entradas são verdadeiras e o operador or só retorna falso
quando suas duas entradas são falsas.
3.1.5. Ordem de precedência

Assim como os operadores aritméticos, os operadores lógicos também apresentam ordem de precedência
ao serem executados. Primeiro realizamos a operação not, depois a and e, por último, a operação or.
3.2. Expressões relacionais

O trabalho dos computadores é, frequentemente, associado a tomadas de decisões. Porém, essas decisões
são diferentes das decisões feitas por humanos. Os computadores decidem a partir de comparações que
retornam verdadeiro ou falso. Os operadores usados para realizar esse tipo de comparação são:
Operador Significado
== Igual a
!= Diferente que
>= Maior que ou igual a
> Maior que
<= Menor que ou igual a
< Menor que
As expressões que fazemos com a ajuda desses operadores são chamadas de expressões relacionais. Elas
são peças fundamentais para programação, já que os código são baseados, principalmente, em tomada de
decisões.
3.3. Resumo de precedência e exemplos

Ao longos das lições anteriores deixamos muito evidente a importância da ordem de precedência entre as
operações lógicas e aritméticas. Dentro disso, devemos ressaltar que existem expressões, em Python, que
misturam esses dois tipos de expressões e, além da precedência que cada um desses operadores possui,
também há uma ordem de execução de todos eles. Veja na tabela a seguir:
Operador Significado
() Parênteses
** Potenciação
*, /, %, // Multiplicação, divisão, módulo, divisão inteira
+, - Soma, subtração
>, >=, <, <=, ==, != Comparações
not não lógico
and e lógico
or ou lógico
Quando todas essas operações estão em uma única expressão o Python as executa de acordo com a ordem
da tabela acima, primeiro os parênteses, depois as operações aritméticas de acordo com sua precedência,
seguidas das comparações e, por último, as operações lógicas também de acordo com a precedência.
Veja no exemplo a seguir como as operações aritméticas são sempre executadas antes das lógicas:
2 + 3 == 3 + 2 * 1
2 + 3 == 3 + 2
5 == 3 + 2
5 == 5
True
É possível perceber que primeiro executamos a multiplicação, depois a adição e, por último, a comparação.
1) (2 < 3) and (5 > 1)

True and True
True
2) (2 > 3) and (3 < 2) or (2 <3)
False and False or True
False or True
True
3) (2 > 3) and ((3 < 2) or (2 <3))
False and (False or True)
False and (True)
False
Podemos ver que os exemplos 2 e 3 possuem o mesmo conjunto de operações, mas resultados finais
diferentes. Isso acontece pois em 3 priorizamos a execução do or antes do and com a ajuda dos parênteses.
3.4. Estruturas condicionais if, else e elif

Até agora vimos instruções que eram realizadas de forma linear, ou seja, as instruções eram executadas
uma por uma, de cima para baixo, sem nenhuma condição que mudasse isso. Porém, sabemos que, em
certas situações o precisamos estabelecer condições para que certas instruções sejam executadas. Para isso
existem as estruturas condicionais if, else e elif.
3.4.1. If
Em geral, a estrutura if seleciona ações que devem ser executadas[11] .Utilizamos a estrutura condicional if
como uma condição que determinará se um bloco de instruções será executado ou não. Por exemplo, se
estiver ensolarado você poderá ir ao mercado para sua mãe. Nesse exemplo temos a condição “estar
ensolarado” e a ação “ir ao mercado”. No Python, a sintaxe do if é dada por:
if (condição):
instrução 1
instrução 2
instrução N
Se a condição estabelecida for verdadeira o programa executará o bloco de instruções dentro do if.
Devemos ficar atentos a indentação do código, pois é ela que delimita o que será executado em cada parte
do código.
idade = 25
if (idade > 18 and idade < 70):
print('Seu voto é obrigatório')
No exemplo acima criamos uma variável idade e, com a ajuda do if, vamos determinar se a pessoa com essa
idade pode ou não votar. Para idade = 25 a pessoa deve votar, ou seja, voto obrigatório.
3.4.2. Else
A estrutura else é usada como um par da estrutura if e podemos entendê-los como “se - se não”. No
exemplo anterior é possível relacionar o else da seguinte forma: se estiver ensolarado, vá ao mercado para
sua mãe. Se não, não saia de casa e avise sua mãe. O else é executado apenas quando a condição
estabelecida no if é falsa.
idade = 10
else:
print('Você não vota')
Quando declaramos a variável idade recebendo o valor 10 a condição estabelecida no if não é cumprida
pois 10 não está no intervalo [18,70[. Então, o código pula o bloco de instruções estabelecidas dentro do if
e vai direto para o else.
3.4.3. Elif
A estrutura elif (else + if) é usada quando precisamos adicionar mais condições para seguir a linha de
raciocínio do programa e pode ser entendido como um “se não, se”. Seguindo o exemplo do supermercado,
se estiver chovendo, você deverá ir ao mercado. Se não, se você tiver um carro e souber dirigir, você deverá
ir ao mercado. Se não, você não irá ao mercado e avisará sua mãe. Veja que mesmo que não esteja
ensolarado, há uma outra condição, ter carro e saber dirigir, que possibilita a ida ao mercado.
idade = 16
elif((idade >=16 and idade < 18) or idade >70):
print('Seu voto é opcional')
else:
print('Você não vota')
Nesse exemplo, a variável idade recebeu o valor 16. No Brasil, uma pessoa com idade entre 16 e 17 anos ou
maior ou igual a 70 anos pode votar, mas não é obrigada. Para que nosso programa identifique essa
situação usamos a estrutura elif. Assim, se a condição do if não for atendida, o código verifica a condição
no elif e só se essa não for atendida que ele executa as instruções no else. É importante ressaltar que
podemos criar quantos elif quisermos.
3.5. Exercícios
1. Faça um programa que peça dois números e imprima o maior deles;
2. Faça um script que peça um valor e mostre na tela se o valor é positivo ou negativo;
3. Crie um programa que verifique se uma letra digitada é "F" ou "M". Conforme a letra escrever: F -
Feminino, M - Masculino, Sexo Inválido;
4. Faça um programa que leia um número inteiro e diga se ele é ou não um número primo;
5. Escreva um programa para aprovar o empréstimo bancário para a compra de uma casa. O
programador vai perguntar o valor da casa, o salário do comprador e em quantos anos ele vai pagar.
Calcule o valor da prestação mensal sabendo que ela não pode exceder 30% do salário ou então o
empréstimo será negado;
6. Desenvolva um programa que leia o peso de uma pessoa, calcule seu IMC e mostre seu status de
acordo com as informações abaixo:
 Abaixo de 18.5: abaixo do peso
 Entre 18.5 e 25: peso ideal
 25 até 30: sobrepeso
 30 até 40: obesidade
 Acima de 40: obesidade mórbida
4. Trabalhando com Strings
4.1. Strings
Quando desejamos guardar um texto ou uma frase em Python, que nada mais é do que uma sequência
imutável de caracteres, utilizamos uma string. Acabamos de dizer que a string é uma sequência imutável, o
que significa que uma vez que a string foi criada, os seus caracteres não podem ser alterados. Essa
sequência pode ser divida em partes e em python podemos utilizar os índices para chamar as partes das
sequências. Para criar uma string devemos colocar o texto desejado entre aspas, podendo ser aspas simple
ou duplas, já que linguagem não as diferencia.
curso = 'Fundamentos essenciais para Python'

4.2. Acesso a elementos
4.2.1. Índices
Em algumas situações, quando estamos programando, precisamos acessar um determinado elemento na
string. Cada item da string possui um índice para que possamos acessá-lo. A contagem é feita da esquerda
para a direita começando no número 0. Isso quer dizer que o primeiro elemento possui índice 0, o segundo
possui índice 1, seguindo assim até o final da string.
print(curso[0])
print(curso[1])
print(curso[2])
print(curso[3])
---------------------------
F
u
n
d
Como foi dito, o primeiro elemento da variável curso, F, foi acessado através do índice 0. Porém, essa não é
a única indexação que a linguagem oferece. Podemos também, sequenciar da direita para esquerda através
de índices negativos:
print(curso[-6])
print(curso[-5])
print(curso[-4])
print(curso[-3])
print(curso[-2])
print(curso[-1])
---------------------------
P
y
t
h
o
n
Veja que a última letra da string curso é a letra n e podemos acessá-la através do índice -1. A penúltima
letra é a letra o, que pode ser acessada pelo índice -2. Assim, podemos acessar elementos de trás para
frente.
4.2.2. Slices
Em algumas situações não queremos apenas um único elemento da string, mas sim um pedaço maior dela.
A linguagem permite o acesso em slice, ou seja, acessar uma parte maior da string. Existem várias formas
de acessar um pedaço de uma string como reverso, da parte até o final, misto, exclusivamente negativo e
com saltos negativos e múltiplos. Veja os exemplos a seguir:
curso[:6]
---------------
'Fundam'
Perceba que no código acima pegamos todos os itens até o elemento de índice 5. Apesar de termos
colocado até 6, o Python considera o slice como um intervalo aberto à direita, ou seja, o elemento de índice
6 não está incluso. Podemos, também, acessar slices através dos índices negativos:
curso[-6:]
---------------
'Python'
Veja que com o slice reverso foram selecionadas os 6 últimos caracteres ao invés dos 6 primeiros.
Outra variação importante desse tipo de acesso é o com saltos. Podemos, na string, pegar do elemento 1
até o elemento 10 saltando de 2 em 2:
curso[1:10:2]
---------------
'yhnpr'
4.3. Operadores em strings

As strings, por serem sequências, suportam alguns tipos de operações como concatenação, que é a junção
de duas strings, e repetição, que cria uma nova string repetindo a primeira.
resp = 'Maria é responsavel pelo setor '

setor = 'comercial'
print(resp + setor)
--------------------------------
Maria é responsavel pelo setor comercial
nome = "Joao"
print (nome * 3)
print(nome + " é"* 3)
print((nome + " é ") * 3)
---------------
JoaoJoaoJoao
Joao é é é
Joao é Joao é Joao é
Observe, nos exemplos, que a concatenação é feita através do sinal +, porém o significado desse sinal é
diferente do sinal de soma. Nas strings o + passa a ideia de junção de elementos. O mesmo acontece com
o sinal *, nas strings esse sinal possui significado de repetição e não de vezes. Isso acontece pois o Python
possui uma propriedade chamada polimorfismo, ou seja, o significado de uma operação depende do
objeto em que a operação acontecerá.
Existem, também, algumas operações nativas do Python que podem ser aplicadas nas Strings e são de
grande utilidade, como o type() e o len(). Como já explicamos em lições anteriores, o type retorna qual o
tipo do dado e o len retorna o tamanho daquele dado.
print('Tipo da string: ', type(curso))

print('Tamanho da string:', len(curso))
--------------------------------
Tipo da string: <class 'str'>
Tamanho da string: 28
Quando trabalhamos com Strings podemos, também, verificar se um elemento específico se encontra ou
não na nossa variável do tipo string através da palavra-chave in.
'Python' in curso
-------------------
True
'a' in curso
-------------------
True
'bala' in curso
-------------------
False
4.4. Métodos e manipulação de strings

Todas as operações em strings que vimos até aqui, são, na verdade, operações que podem ser realizadas
em objetos sequenciáveis, ou seja, elas também funcionarão em estruturas como listas e tupla, que
veremos no módulo seguinte. Além dessas operações genéricas, as strings possuem operações próprias,
chamadas de métodos.
4.4.1. Count
O método count() retorna a quantidade de ocorrência da substring que foi passada como parâmetro na
string original
curso.count('a')
-------------------
4
4.4.2. Find e Replace
O método find() retorna o menor índice em que a substring passada como parâmetro foi encontrada. Se
não for encontrada ela retorna -1.
curso.find('an')
-------------------
-1
Já o método replace() retorna uma cópia da sequência com todas as ocorrências da substrings pela nova
string passada como parâmetro.
curso.replace('Python','Java')
--------------------------------
'Fundamentos essenciais para Java'
4.4.3. Upper, Lower e Capitalize

Os métodos upper() e lower() vão modificar retornar uma cópia da string em que todos os caracteres são
em letras maiúsculas e minúsculas, respectivamente.
curso.upper()
--------------------------------
'FUNDAMENTOS ESSENCIAIS PARA PYTHON'
curso.lower()
--------------------------------
'fundamentos essenciais para python'
Já o método capitalize() retorna uma cópia da string em que apenas o primeiro caractere está em
maiúsculo.
curso.capitalize()
----------------------------------
'Fundamentos essenciais para python'
4.4.4. Split e Join

O método split tem como objetivo dividir uma string. No parâmetro da função deve ser passado o
caractere separador, ou seja, quando o caracter informado for encontrado a string será separada. Por
padrão, esse caractere é o espaço, porém podemos definir um caractere qualquer. Ao contrário do método
split, temos também o método join, que retorna uma string na qual os elementos da sequência foram
unidos pelo separador str (-).
curso.split()
-----------------------------------------
['Python', 'para', 'análise', 'de', 'dados']
'-'.join(curso)
-----------------------------------------
'P-y-t-h-o-n- -p-a-r-a- -a-n-á-l-i-s-e- -d-e- -d-a-d-o-s'
4.4.5. Strip
Em python, existe muitos métodos que auxiliam no tratamento das strings, muitas operações podem ser
feitas para facilitar o trabalho com as strings. Dentre elas podemos citar strip(), rtrip() e lstrip(). Quando
queremos transformar ou mudar algo dentro da string podemos usá-las. A primeira remove todos os
espaços inúteis no início e no final da string. Já a segunda, rstrip (que significa Right Strip), e a terceira,
lstrip (que significa Left Strip), removem os espaços inúteis existentes na direita e na esquerda
respectivamente.
nova_frase = " Fundamentos Python "

-----------------------------------------
'Fundamentos Python'
nova_frase.rstrip()
-----------------------------------------
' Fundamentos Python'
nova_frase.lstrip()
-----------------------------------------
'Fundamentos Python '
4.5. Inserção e formatação de substrings

A formatação de strings no Python é, atualmente, feita através do método format() . É um método de
formatação de strings que permite concatenar elementos dentro de uma string através de formatação
posicional.
nome = 'Luiz'
setor = 'RH'
texto = "{} é responsavel pelo setor {}".format(nome, setor)
print(texto)
-----------------------------------------------------------
Luiz é responsavel pelo setor RH
val = 10.123243
text2 = "valor {:.2f} com 2 casa decimais".format(val)
print(text2)
-----------------------------------------------------------
valor 10.12 com 2 casa decimais
4.6. Exercícios
1. Crie um programa que leia o nome completo de uma pessoa e mostre:
 O nome com todas as letras maiúsculas e minúsculas.
 Quantas letras ao todo (sem considerar espaços).
 Quantas letras tem o primeiro nome.
2. Crie um programa que leia o nome de uma cidade diga se ela começa ou não com o nome
"SANTO".
3. Faça um programa que leia uma frase pelo teclado e mostre quantas vezes aparece a letra "A", em
que posição ela aparece a primeira vez e em que posição ela aparece a última vez.
5. Estrutura de dados
Alguma vezes, quando estamos programando, trabalhamos com apenas um dado, seja ele um número ou
um texto. Porém, em diversas situações, precisamos usar um conjunto de dados, como uma lista de nomes
ou uma lista de produtos e seus preços. Para isso, usaremos as estruturas de dados listas, tuplas, dicionário
e conjuntos.
5.1. Listas
As listas são as estruturas de dados ordenadas mais flexíveis dentro do Python. Ao contrário das strings, as
listas podem conter qualquer tipo de dado, como números, strings e até outras listas. Além disso, as listas
são mutáveis, ou seja, você pode modificar, adicionar ou deletar qualquer elemento dentro dela. Elas são
construídas por elementos dentro de um colchete [ ] , separados por vírgula.
Esse tipo de estrutura possui certas propriedades como:

1. Ser uma coleção ordenada de objetos: podemos ver as listas como lugares para armazenar outros
objetos para que possamos tratá-los como grupos.
2. Acesso por índices: assim como vimos nas strings, os elementos das listas também podem ser
acessados através de um índice. Isso implica, também, no acesso de elementos através de slices.
3. Tamanho variável e heterogeneidade: além da possibilidade de conter qualquer tipo de objeto
(inteiros, floats, strings, etc.) as listas podem variar de tamanho, já que podemos adicionar ou retirar
um elemento da lista
listaSetores = ['Comercial', 'RH', 'Financeiro', 'Adm', 'Operacional']

listaSetores
-----------------------------------------------------------
['Comercial', 'RH', 'Financeiro', 'Adm', 'Operacional']
listaNum = [10, 4, 5, 10.3, 2]
listaNum
---------------------------------
[10, 4, 5, 10.3, 2]
listaHomogenea = [10, 'Comercial', 'RH', 5, 10.3, 'Operacional']

listaHomogenea
---------------------------------
[10, 'Comercial', 'RH', 5, 10.3, 'Operacional']
Operadores nativos do Python que já vimos anteriormente também podem ser usados nas listas, como o
type() e o len():
len(listaSetores)
---------------------------------
5
type(listaNum)
---------------------------------
list
5.2.1. Manipulação de listas

Agora, vamos aprender algumas formas de manipulação de listas como acesso, operadores e os métodos
mais usados para trabalharmos com as listas
Acesso
Para acessarmos os elementos dentro da nossa lista usamos uma sintaxe igual a que mostramos no acesso
de elementos das strings. Podemos acessar por índices, índices negativos e slices.
listaNum[3]
-------------------
10.3
listaNum[-3]
-------------------
5
listaNum[0:2]
-------------------
[10, 4]
listaSetores[::2]
-------------------
['Comercial', 'Financeiro', 'Operacional']
Operadores
Os operadores + e * podem, também, ser usados nas listas com o mesmo objetivo de que foram utilizados
nas strings, de concatenação e repetição, respectivamente.
l1 = [1,2,3,4]
l2 = [5,3,6,2]
l1 + l2
-------------------
[1, 2, 3, 4, 5, 3, 6, 2]
print("L1: ", l1)

print("L1 * 3:", l1*3)
-------------------
L1: [1, 2, 3, 4]
L1 * 3: [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
Métodos de manipulação de listas

Como já dissemos várias vezes, as listas são estruturas de dados que podem ser alteradas. A seguir,
mostraremos como manipulá-las e modificá-las.
print('ListaNum original: ', listaNum)

listaNum[0] = 78
print('ListaNum após mudança: ',listaNum)
---------------------------------------
ListaNum original: [10, 4, 5, 10.3, 2]
ListaNum após mudança: [78, 4, 5, 10.3, 2]
Nesse exemplo, fizemos uma atribuição simples. O elemento de índice 0, que antes era o número 10, foi
substituído pelo número 78. Além disso, as listas possuem muitos métodos para manipulá-las.
Remove
O método remove() apaga o primeiro elemento encontrado com valor igual ao que foi passado como
parâmetro. Se o elemento não existir, ele retorna erro do tipo ValueError
listaSetores.remove('Financeiro')
listaSetores
---------------------------------------
['Comercial', 'RH', 'Adm', 'Operacional']
Append
Esse método adiciona o item especificado dentro do parênteses ao final da lista
listaSetores.append("Marketing")
listaSetores
---------------------------------------
['Comercial', 'RH', 'Adm', 'Operacional', 'Marketing']
Pop
Utilizamos o método pop() quando queremos retirar um elemento da lista a partir do índice informado. Se
nenhum índice for informado, a função apaga e nos devolve o último elemento da lista.
listaSetores.pop()
listaSetores
---------------------------------------
['Comercial', 'RH', 'Adm', 'Operacional']
listaSetores.pop(1)
listaSetores
---------------------------------------
['Comercial', 'Adm']
Sort
Esse método é usado quando queremos uma lista ordenada. Por padrão, ela ordena de forma crescente, ou
seja, do menor para o maior. Porém, podemos mudar isso, basta escrever dentro dos parênteses reverse =
True.
listaSetores.sort()
listaSetores
---------------------------------------
['Adm', 'Comercial', 'Financeiro', 'Operacional', 'RH']
listaNum.sort()
listaNum
---------------------------------------
[2, 4, 5, 10.3, 78]
Esses são os métodos mais utilizados em Python sobre listas, porém existem vários outros. Caso queira
conhecê-los acesse a documentação oficial.
5.2. Tuplas
As tuplas são estruturas semelhantes às listas, porém elas tuplas são imutáveis. Geralmente usamos tuplas
para guardar dados que não podem ser alterados ou que já conhecemos o tamanho. As tuplas são
construídas por itens dentro de parênteses ( ), separados por vírgula. Apesar da tuplas não suportarem
nenhuma chamada de método, elas apresentam grande parte das propriedades que citamos das listas.
1. Ser uma coleção ordenada de objetos: assim como as listas, podemos ver as tuplas como lugares
para armazenar outros objetos em sequência para que possamos tratá-los como grupos.
2. Acesso por índices: assim como vimos nas strings e nas listas , os elementos das tuplas podem ser
acessados através de um índice. Isso implica, também, no acesso de elementos através de slices.
3. Sequência imutável: assim como já mencionamos anteriormente, as tuplas são estrutura imutáveis,
ou seja, não podemos adicionar nem remover um de seus elementos.
4. Tamanho fixo e heterogeneidade: assim como as listas, as tuplas podem conter qualquer tipo de
objeto, como int, float, strings e até listas.
5.2.1. Manipulação de tuplas

Apesar de serem imutáveis, as tuplas possuem funções que serão muito úteis na hora de programarmos.
Criação
Uma tupla consiste em uma sequência de dados separados por vírgula sempre envolvidos por "( )".
tuplaNum = (12, 19,21, 34, 90, 3)

tuplaNum
---------------------------------------
(12, 19, 21, 34, 90, 3)
tuplaHetero = (12, 19, 21, 'Minha', 3.8, 'Tupla')

tuplaHetero
---------------------------------------
(12, 19, 21, 'Minha', 3.8, 'Tupla')
Observe, no código abaixo, que se tentarmos mudar algum elemento da tupla o Python retornará um erro
do tipo TypeError:
tuplaHetero[0] = 18
---------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-23-f4be0c3b81a9> in <module>()
----> 1 tuplaHetero[0] = 18
TypeError: 'tuple' object does not support item assignment
Acesso
O acesso nas tuplas é dado de forma similar às listas e strings. Assim como elas, temos diversas formas de
acessar os elementos de uma tupla.
tuplaHetero[0]
---------------------------------------
12
tuplaNum[:3]
---------------------------------------
(12, 19, 21)
Desempacotamento
O Python tem um mecanismo de atribuição múltipla de variáveis retirando elementos de tuplas. Esse
mecanismo é chamado de desempacotamento. Essa técnica é muito útil quando queremos atribuir a
diferentes variáveis cada um dos elementos da tupla.
curso = ('Python', 'Voitto', 2020, 12345, 10)

nomeDocurso, empresa, anoDeCriacao, codigo, nota) = curso
nomeDocurso
-------------------------------------------------------
'Python'
Operações
As tuplas também suportam operações de concatenação e de repetição assim como as listas e strings.
Lembrando que essas operações são feitas através dos sinais + e *, respectivamente.
tuplaNum + tuplaHetero
-------------------------------------------------------
(12, 19, 21, 34, 90, 3, 12, 19, 21, 'Minha', 3.8, 'Tupla')
tuplaNum * 3
-------------------------------------------------------
(12, 19, 21, 34, 90, 3, 12, 19, 21, 34, 90, 3, 12, 19, 21, 34, 90, 3)
Extensão sobre tuplas

Apesar de não podermos mudar, diretamente, um elemento de uma tupla com as operações acima
podemos realizar certas alterações. Se quisermos adicionar algum elemento à nossa variável tupla basta
concatenarmos com uma outra tupla com os elementos que queremos e atribuir o resultado dessa
concatenação a tupla original.
tuplaNum = tuplaNum +(10,12)

tuplaNum
-------------------------------------
(12, 19, 21, 34, 90, 3, 10, 12, 10, 12)
Podemos, também, criar uma tupla em que os elementos dentro dela são listas. Como as listas são objetos
mutáveis. é possível alterar o elemento que está dentro da tupla
minha_tupla = ([1,2,3], ['a','b','c'])

print('Tupla de listas:',minha_tupla)
-------------------------------------
Tupla de listas: ([1, 2, 3], ['a', 'b', 'c'])
minha_tupla[0].append(4)
print('Adicionando 4 no objeto 0:',minha_tupla)
------------------------------------------------------
Adicionando 4 no objeto 0: ([1, 2, 3, 4], ['a', 'b', 'c'])
Se essas duas táticas de operações ainda não forem suficientes ou a mudança na tupla for muito extensa,
podemos transformar a tupla em lista e, então, fazermos as mudanças que quisermos
l_tuplaNum = list(tuplaNum)
l_tuplaNum
-----------------------------
[12, 19, 21, 34, 90, 3]
l_tuplaNum.append(30)
l_tuplaNum
------------------------------
[12, 19, 21, 34, 90, 3, 30]
5.3. Dicionários
Os dicionários em Python são estruturas completamente diferentes das listas e das tuplas e a principal
diferença é que eles não são sequenciados, mas são mapeados. O mapeamento dos dicionários acontece
pois há um elemento chave que pode guardar diversos valores. Dessa forma, o acesso aos elementos do
dicionário não é feito através do índice em que o elemento se encontra, mas sim pela chave relacionada a
ele. Outra característica importante dos dicionários é que eles são mutáveis, ou seja, podemos adicionar ou
retirar elementos, assim como as listas.
Os dicionários são úteis sempre que precisamos associar um conjunto de valores com chaves - para
descrever as propriedades de algo, por exemplo
5.3.1. Manipulação de dicionários
Criação
Os dicionários são delimitados por '{ }' e contém uma lista de pares chave: valor separados por vírgulas.
dicionarioSetores = {'Comercial': 'Maria',

'RH': 'Luiz',
'Financeiro':'Joao',
'Adm': 'Luisa',
'Operacional': 'Ana'}
dicionarioSetores
-----------------------------------------
{'Adm': 'Luisa',
'Comercial': 'Maria',
'Financeiro': 'Joao',
'Operacional': 'Ana',
'RH': 'Luiz'}
dicionario = {'a': 2,
'b': 4,
'c': '45'}
dicionario
-----------------------------------------
{'a': 2, 'b': 4, 'c': '45'}
Acesso
Ao contrário das listas e tuplas, que possuem acesso por índices, os elementos de um dicionário são
acessados através das chaves.
dicionarioSetores['RH']
-----------------------------------------
'Luiz'
dicionario['a']
-----------------------------------------
2
Operações
As principais operações que podem ser feitas em um dicionário envolvem armazenar e recuperar valores a
partir das chaves. Podemos excluir um valor a partir da operação del e verificar a existência de uma chave
com a operação in. Essas operações retornam True ou False ao verificar se uma chave se encontra ou não
no dicionário em questão. É importante ressaltar que essas operações só serão feitas em cima das chaves e
não dos valores do dicionário.
'Operacional' in (dicionarioSetores)
-----------------------------------------
True
'Maria' in (dicionarioSetores)
-----------------------------------------
False
del dicionarioSetores['Adm']
dicionarioSetores
-----------------------------------------
{'Comercial': 'Maria',
'RH': 'Luiz'}
Podemos, também, adicionar elementos ao nosso dicionário, lembrando sempre que eles devem conter
uma chave e valores relacionados a essa chave
dicionarioSetores['Executivo'] = 'Rafael'
dicionarioSetores
-----------------------------------------
{'Adm': 'Luisa',
'Comercial': 'Maria',
'Executivo': 'Rafael',
'RH': 'Luiz'}
5.4. Conjuntos
Além das estruturas citadas, o Python oferece mais uma estrutura chamada set para representar conjuntos.
Os conjuntos são coleções desordenadas de elementos sem repetições. Eles são muito utilizados quando
queremos eliminar itens repetidos em certos objetos e quando precisamos realizar operações matemáticas
de conjuntos, como união, interseção, diferença e diferença simétrica.
5.4.1. Manipulação de conjuntos
Criação
Para criar uma estrutura do tipo de conjunto podemos usar chaves “{ }” ou chamar o construtor set().
frutas = {'banana', 'maca', 'mexerica', 'morango', 'morango', 'uva', 'uva'}

frutas
-----------------------------------------
{'banana', 'maca', 'mexerica', 'morango', 'uva'}
lista = [1,1,2,2,2,3,3,3,3,4,4,4,5,5,6,9,10]
set(lista)
-----------------------------------------
{1, 2, 3, 4, 5, 6, 9, 10}
Acesso
Apesar de muito útil, a estrutura de conjuntos não é indexável e, por isso, não é possível fazer acesso dos
elementos que estão dentro dela através de índices ou chaves.
Operações
Assim como nos dicionários, podemos verificar a existência de um elemento no conjunto. Porém não é
possível deletar nenhum elemento.
'banana' in (frutas)
-----------------------------------------
True
del frutas['banana']
-----------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-46-ab91f89fcc8f> in <module>()
----> 1 del frutas['banana']
TypeError: 'set' object does not support item deletion
Com os conjuntos também podemos realizar operações matemáticas de conjuntos.
União
A união de conjuntos, assim como na matemática, corresponde a junção dos elementos dos conjuntos de
dados.
a = {1,2,3,4,5,6}
b = {1,2,7,8,9,10,11}
print('União: ',a.union(b))
-----------------------------------------
União: {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
Interseção
A interseção de conjuntos corresponde aos elementos que se repetem nos dois conjuntos dados.
print('Interseção: ', a.intersection(b))

-----------------------------------------
Interseção: {1, 2}
Diferença
A diferença de conjuntos é representada pelos elementos de um conjunto que não aparecem no outro
conjunto.
print('Diferença: ', a.difference(b))

-----------------------------------------
Diferença: {3, 4, 5, 6}
Diferença simétrica
Já a diferença simétrica entre conjuntos é dada pela união dos conjuntos menos os elementos que se
encontram na interseção.
print('Diferença simétrica: ', a.symmetric_difference(b))

------------------------------------------------------
Diferença simétrica: {3, 4, 5, 6, 7, 8, 9, 10, 11}
5.5. Exercícios
1. Crie uma tupla preenchida com os 20 primeiros colocados da Tabela do Campeonato Brasileiro de
Futebol na ordem de colocação e mostre:
 Os 5 primeiros;
 Os 4 últimos colocados;
 Times em ordem alfabética;
 Em qual posição está o time que você torce;
2. Criar um programa que vai gerar cinco números aleatórios e colocar em uma tupla. Depois disso,
mostre a listagem de números gerados e também indique o menor e o maior valor que estão na
tupla;
3. Desenvolva um programa que leia quatro valores pelo teclado e guarde-os em uma tupla. No final,
mostre:
 Quantas vezes apareceu o valor 9;
 Em que posição foi digitado o primeiro valor 3;
 Quais foram os números pares;
6. Estrutura de repetição
Outro processo muito importante na programação, além da tomada de decisão, é a repetição de blocos de
instrução. Em diversas situações, quando estamos programando, precisamos que certos comandos sejam
executados mais de uma vez. Para não ficarmos repetindo as mesmas instruções diversas vezes, existem os
loops como for e while que veremos ao longo deste módulo.
6.1. Instrução for

Em python, a sintaxe da estrutura de repetição for não é a tradicional utilizada em outras linguagens, na
qual temos que definir no cabeçalho da estrutura uma variável e iniciá-la, a condição de parada e o
incremento. O uso do for em python permite que possamos interagir com sequência tais como: strings,
listas, tuplas e dicionários. A estrutura for é composta pela definição de uma variável, seguida pela
sequência que será iterada.
A variável a ser declarada no início da estrutura receberá um item contido na sequência a cada iteração do
for. No final, todos os elementos da sequência terão sido percorridos e a cada iteração, o elemento
seguinte que estiver contido na sequência terá sido passado pela variável

for setores in listaSetores:
print(setores)
------------------------------------------------------
Comercial
RH
Financeiro
Adm
Operacional
nome = 'Maria'
for caractere in nome:
print(caractere)
------------------------------------------------------
M
a
r
i
a
6.2. Iteradores range e enumerate
6.2.1. Range
A função range é uma função interna do Python muito utilizada na estrutura de repetição for. Essa função
nos retorna uma sequência de valores iterativos de acordo com um determinado intervalo passado a ela.
Essa função pode receber até 3 informações diferentes para criar a sequência de valores, sendo eles (i) em
qual número essa sequência começa, (ii) até qual número ela vai e (iii) qual será o intervalo entre esse
números (de 1 em 1, de 2 em 2, etc.)
list(range(0,5))
--------------------
[0, 1, 2, 3, 4]
Podemos mudar o início da criação dessa lista. Ao invés dela começar no 0, podemos fazer com que
comece no 1.
list(range(1,6))
--------------------
[1, 2, 3, 4, 5]
Por último, também podemos criar listas com “saltos” entre os números.
list(range(10,20,2))
--------------------
[10, 12, 14, 16, 18]
6.2.2. For + Range

Por criar uma estrutura iterativa, o range é muito utilizado juntamente com o loop for.
for i in range (5):

print(i)
--------------------
0
1
2
3
4
for i in range (10,20):

print(i)
--------------------
10
11
12
13
14
15
16
17
18
19
for i in range(0,100,10):
print(i)
--------------------
0
10
20
30
40
50
60
70
80
90
for i in range (len(listaSetores)):

print(listaSetores[i])
--------------------
Comercial
RH
Financeiro
Adm
Operacional
6.2.3. Enumerate
Muitas vezes, enquanto estamos lidando com iteradores precisamos manter uma contagem de quantas
iterações foram feitas. A função enumerate foi criada exatamente com esse propósito. Esse método
adiciona um contador a um objeto iterável e o retorna em uma forma de objeto enumerado.
list(enumerate(listaSetores))
--------------------
[(0, 'Comercial'),
(1, 'RH'),
(2, 'Financeiro'),
(3, 'Adm'),
(4, 'Operacional')]
6.2.4. For + Enumerate

Assim como o Range, o enumerate também é muito utilizado em conjunto com a estrutura de loop for.
for a,b in enumerate(listaSetores):

if (a == 2):
print(b)
--------------------
Financeiro
6.3. While
Em Python, a estrutura de repetição while é outra forma de executar iterações. Essa estrutura repete seus
comandos enquanto determinado condição for verdadeira. A estrutura de repetição while se assemelha
muito a estrutura condicional if, o que as diferencia é o número de vezes que o bloco de comandos será
executado.
Os loops com a instrução while requerem um pouco mais de atenção. É preciso garantir que em algum
momento a condição que mantém o loop funcionando irá ser falsa, caso contrário a repetição continuará
acontecendo infinitamente.
i = 0
while i < 100:
print(i)
i = i+10
----------------------------------
0
10
20
30
40
50
60
70
80
90
i = 0
while (i < len(listaSetores)):
print(i)
i += 1 # equivalente a i = i+1
----------------------------------
Comercial
RH
Financeiro
Adm
Operacional
Um erro muito comum é esquecermos de atualizar a variável presente na condição dentro do bloco de
instruções do while. Dessa forma, a variável não troca de valor e faz com que a condição seja sempre
verdadeira. No exemplo abaixo, o while mostrará na tela infinitas vezes,ou até que ele interrompido, a
palavra Comercial, que representa o item de posição 0 da nossa listaSetores.
i = 0
while i < len(listaSetores):
print(listaSetores[i])
6.4. Interrupção de loops
6.4.1. Break
A instrução break é utilizada para forçar a interrupção da execução da iteração, ou seja, encerrar
imediatamente o loop que está sendo executado. O uso mais comum da instrução break é quando uma
condição é adicionada e exige uma saída rápida do loop. Essa instrução pode ser utilizada tanto em
repetições while quanto for.

for setor in listaSetores:
print(setor, 'antes do if')
if setor == 'Financeiro':
break
print(setor, 'depois do if')
------------------------------------------------------------
Comercial antes do if
Comercial depois do if
RH antes do if
RH depois do if
Financeiro antes do if
No exemplo acima, veja que o break impediu a execução do segundo print. Isso acontece, justamente,
porque ele interrompe, imediatamente, o loop. Podemos, também, usar essa instrução para encerrar loops
infinitos
i = 0
while True:
print('r')
i += 1
if (i == 5):
break
------------------------------------------------------------
r
r
r
r
r
É possível perceber que a condição estabelecida no while será sempre verdadeira, então, é colocado uma
condição if que diz que quando o contador i for igual 5 o loop deve ser interrompido.
6.4.2. Continue
A instrução continue rejeita todas as instruções restantes na iteração atual do loop e move o controle de
volta para a parte superior do loop. Esse tipo de instrução pode ser utilizada tanto no while quanto no for.
x = 0
while(x <= 4):
x+=1
print(x, 'antes do if')
if(x == 4):
print("\n")
continue
print(x, 'depois do if')
------------------------------------------------------------
1 antes do if
1 depois do if
2 antes do if
2 depois do if
3 antes do if
3 depois do if
4 antes do if
5 antes do if
5 depois do if
Veja que quando o contador x teve seu valor igual a 4 o código printou uma linha vazia (através do ‘\n’),
não executou as próximas linhas de código do while e voltou para o início do while. É possível perceber que
o continue, ao contrário do break, não interrompe todo o loop, ele apenas termina a execução atual.
for nome in 'Maria':

if nome == 'i':
continue
print(nome)
------------------------------------------------------------
M
a
r
a
6.4.3. Pass
O pass é uma operação nula. Quando ela é chamada nada acontece. É útil quando uma instrução é
necessária sintaticamente, mas nenhum código precisa ser executado.
sequencia = {'a', 'a', 'b', 'b'}

for i in sequencia:
pass
Observe que o código acima não executa nada e o pass serve apenas de placeholder.
6.5. List comprehension

A list comprehension (ou compreensão de lista) é uma construção sintática disponível no Python, e em
outras linguagens, para criarmos uma lista baseada em listas existentes. Uma compreensão de lista possui
as seguintes propriedades:
1. Uma sequência de entrada (normalmente uma lista);

2. Uma variável que representa membros da sequência de entrada;
3. Uma expressão opcional do predicado;
4. Uma expressão de saída que produz elementos da lista de saída com membros da sequência de
entrada que satisfazem o predicado.
quadrados = [x**2 for x in range(10)]
quadrados
------------------------------------------------------------
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
É possível perceber cada uma das propriedades citadas no código acima. A sequência de entrada é o objeto
iterável gerado pela função range(), a variável que representa os elementos é a variável x e a expressão que
criará uma lista final é a x**2. Com isso, foi gerada uma nova lista com os quadrados da sequência de
números gerados por range().
Se fossemos criar a mesma lista usando apenas o for, este seria nosso código:
quadrados = []
for x in range(10):
quadrados.append(x**2)
quadrados
------------------------------------------------------------
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
Esse tipo de criação de listas também pode apresentar condições para que um elemento seja inserido na
lista, o que foi dito na propriedade 3.
quadrados = [x**2 for x in range(10) if x%2 == 0]

quadrados
--------------------------------------------------
[0, 4, 16, 36, 64]
Apesar da expressão de saída continuar sendo o quadrado de x, estabelecemos uma condição que diz que
apenas os números pares serão elevados ao quadrado e, consequentemente, guardados na lista final.
6.6. Exercícios
1. Crie um programa que conte todos os números pares que estão dentro do intervalo [1,50];
2. Faça um programa que calcule a soma entre todos os números ímpares que são múltiplos de três e
que se encontram no intervalo de 1 até 500;
3. Desenvolva um programa que leia seis números inteiros e mostre a soma apenas daqueles que
forem pares. Se o número for ímpar desconsidere-o;
4. Faça um programa que leia um número e diga se ele é um número primo ou não;
5. Faça um programa que mostre na tela uma contagem regressiva para o estouro de fogos de artifício,
indo de 10 até 0, com uma pausa de 1 segundo entre eles
7. Funções
7.1. Função
No Python, as função podem ser ditas como um bloco de comandos que executa uma tarefa. A principal
finalidade das funções é nos ajudar a organizarmos nosso código em pedaços que correspondam a meios
para resolver o problema em questão.
Assim como nas variáveis, podemos criar qualquer nome para as funções, menos as palavras reservadas do
Python, e devem seguir as mesmas regras de nomenclatura, como não usar espaços nem caracteres
especiais. A sintaxe de uma definição de transação é:
def nome_funcao (parametro1, parametro2):

comandos
Uma vez que definirmos a função, podemos chamá-la quantas vezes quisermos e os comandos
estabelecidos dentro dela serão executados.
A função pode conter qualquer quantidade de comandos que desejarmos, desde que eles estejam na
mesma indentação dentro do def, assim como os comandos do for e do while.
def minha_funcao():
print('Olá')
minha_funcao()
--------------------------------------------------
Olá
É importante perceber que apenas a definição da função não a executa. Para isso, precisamos chamá-la,
ação conhecida também como invocação de função, como já fizemos com funções como print, input, range
e várias outras.
7.1.1. Parâmetros
Algumas funções precisam de informações prévias para serem executadas. Em programação, essas
informações são chamadas de parâmetros. Os parâmetros podem ser de qualquer tipo de dado que vimos
anteriormente, uma lista, um número, uma string. Quando uma função possui um parâmetro ao ser
definida é necessário passar o parâmetro ao chamarmos a função. A chamada de uma função definida com
parâmetros é feita pelo nome da função e dentro dos parênteses são passadas as informações que a
função precisa para ser executada, os parâmetros.
def calcula_area_circulo(raio):
print("A área do círculo é: ",3.14 * raio**2)
calcula_area_circulo(2)
--------------------------------------------------
A área do círculo é: 12.56
def imprimeSetores(listaSetores):
for setores in listaSetores:
print(setores)
imprimeSetores(listaSetores)
--------------------------------------------------
Comercial
RH
Financeiro
Adm
Operacional
Os dois exemplos mostrados acima são de funções que precisam de informações prévias para serem
executadas. A calcula_circulo precisa de um valor de raio para calcular a área do círculo que possui esse raio.
Já a imprimeSetores precisa de uma lista, no caso a listaSetores, para mostrar ao usuário quais os
elementos presentes na lista.
É fundamental entender que as variáveis que serão declaradas como parâmetros são utilizadas apenas
localmente. Por exemplo, se você tiver uma variável chamada x fora da função e outra variável chamada x
que está dentro da função e as alterações feitas em x dentro da função não afeta a variável chamada x que
está fora da função.
O termo técnico para essa situação é local scope, que significa que o alcance e influência da variável
permanece apenas dentro da função e não fora dela. As variáveis criadas e modificadas dentro de uma
função literalmente deixam de existir no momento em que a função para executar. Isso é bom pois quando
estamos escrevendo nossa função não precisamos nos preocupar em alterar acidentalmente uma variável
fora da função que tem o mesmo nome.
7.2. Tipos de retorno

Uma função pode retornar um valor e esse valor que foi retornado pode ser usado fora da função. Até
agora vimos funções que apenas realizam determinada tarefa, mas não retornavam valores que poderiam
ser utilizados em outras situações. Através da palavra-chave return podemos devolver qualquer tipo de
dado para utilizarmos durante a execução do programa.
def nome_funcao (parametro1, parametro2):

comandos
return
7.2.1. Único
As funções podem nos retornar valores únicos, ou seja, apenas um valor para ser utilizado ao longo do
nosso programa. Podemos mudar a função calcula_area_circulo para retornar o valor que foi calculado
dentro da função.
def calcula_area_circulo(raio):
return 3.14 * raio**2
print("A área do círculo de raio 3 é:",calcula_area_circulo(3))
------------------------------------------------------------
A área do círculo de raio 3 é: 28.26
Observe que, agora, a função retorna o valor que foi calculado dentro da função. Quando chamamos uma
função que retorna algum valor ela deve estar associada a uma variável ou, como no exemplo acima, a
função print.
def calcula_quadrado(x):
quadrado = x**2
return quadrado
quadrado = calcula_quadrado(5)
7.2.2. Múltiplos
Além de retornar apenas um valor, o Python permite que as funções retornem múltiplos valores. Isso pode
acontecer graças a estrutura de dados tupla. Quando criamos uma função que retorna mais de um valor ela,
na verdade, retorna uma tupla em que os elementos são o que desejamos retornar.
def operacoes_aritmeticas (n1,n2):

soma = n1 + n2
subtracao = n1 - n2
return soma, subtracao
print(operacoes_aritmeticas(5,2))
------------------------------------------------------------
(7, 3)
Como a nossa função retorna uma tupla, podemos realizar o desempacotamento para atribuir a uma
variável cada elemento da tupla.
7.3. Funções anônimas

Além de conseguirmos declarar funções com a palavra chave def, o Python permite definirmos funções
através do comando lambda. Esse tipo de função declarada através do lambda é conhecida como função
anônima. A anonimidade das funções lambdas no Python acontece pois elas normalmente não precisam ter
um nome igual as funções declaradas através do def precisam. A principal razão pela qual o nome é usado
em Python é porque o termo lambda é usado para descrever funções anônimas no cálculo.
As funções lambdas possuem uma forma geral dada pela palavra lambda seguida de um ou mais
elementos (assim como os elementos que passamos como parâmetros nas funções def) seguido por uma
expressão após dois pontos.
lambda argumentos: expressão
Os objetos que esse tipo de função retorna funcionam da mesma forma que os retornados pela função
atribuída através do def, porém existem algumas diferenças:
1. Lambda é uma expressão, não uma definição. Isso faz com que as funções anônimas possam ser
utilizadas em situações que funções definidas não podem, como dentro de uma lista ou como
parâmetro de uma outra função.
2. A sintaxe da função lambda é uma expressão única, e não um bloco de comandos. Por conta
dessa limitação as expressões são menos gerais do que funções def, já que os comandos que ela
executará são poucos.
Observe o exemplo abaixo. Apesar de não ser uma atribuição muito utilizada, como já falamos, atribuímos à
variável f uma função lambda que retorna o quadrado do valor x quadrado, como se fosse uma f(x) = x^2
f = lambda x: x**2
x = 9
f(x)
------------------------------------------------------------
81
Podemos, também, aplicar a função f em uma lista:
for i in listaNum:
print(f(i))
------------------------------------------------------------
6084
16
25
106.09000000000002
4
Mas por que usar funções anônimas se já temos as funções através do def? As funções anônimas são úteis
como um tipo de “função curta” que pode servir de parâmetro para uma outra função. Elas tendem a ser
mais simples de construir do que uma função definida.
def funcao (listaNum, f):

for i in listaNum:
print(f(i))
funcao(listaNum,f)
------------------------------------------------------------
6084
16
25
106.09000000000002
4
Podemos, também, passar outros tipos de funções que não foram atribuídas a variáveis:
funcao(listaNum, lambda x: 2*x)

------------------------------------------------------------
156
8
10
20.6
4
funcao(listaNum, lambda x: x-10)

------------------------------------------------------------
68
-6
-5
0.3000000000000007
-8
A função lambda pode ser usada juntamente com o list comprehension
def funcao2 (listaNum,f):

nova_lista = []
for i in listaNum:
nova_lista.append(f(i))
return nova_lista
funcao2(listaNum, f)
------------------------------------------------------------
[6084, 16, 25, 106.09000000000002, 4]
funcao2(listaNum, lambda x: 2*x)

------------------------------------------------------------
[156, 8, 10, 20.6, 4]
def funcao3(x, f):

return [f(i) for i in x]
funcao3([1,2,3], lambda x: x**2)
------------------------------------------------------------
[1, 4, 9]
7.4. Exercícios
1. Faça um programa que uma função area() que receba as dimensões de um terreno retangular
(altura e largura) lidas do teclado e mostre a área do terreno;
2. Crie uma função que retorne o fatorial de um número n passado por parâmetro
3. Faça um programa que tenha uma função contador() que receba três parâmetros: inicio, fim e passo
e realize a contagem das seguintes formas:
 De 1 até 10, de 1 em 1
 De 10 até 0 de 2 em 2
 Uma contagem personalizada
4. Faça um programa que tenha uma lista chamada números e duas funções chamadas sorteia() e
somaPar(). A primeira função vai sortear 5 números e vai colocá-los dentro da lista e a segunda
função vai mostrar a soma entre todos os valores pares sorteados pela função anterior.
5. Faça um programa que tenha uma função notas() que pode receber várias notas de aluno e vai
retornar um dicionário com as seguintes informações:
 Quantidade de notas;
 A maior nota;
 A menor nota;
 A média da turma.
8. Introdução à Orientação a Objetos
8.1. Introdução
No capítulo anterior falamos sobre funções e como elas facilitam a programação, já que, uma vez definidas,
elas podem ser utilizadas em qualquer parte do código. Neste capítulo veremos sobre classes e como ela
pode complementar nossa programação. As classes são uma importante característica de modernas
linguagens de programação orientadas a objetos como Python.
A POO (Programação Orientada a Objetos) é um paradigma de programação usual e frequente em diversas

linguagens de programação atualmente, como o Python. Ela tem sua origem por volta da década de 1960,
quando Alan Kay estava na pós-Graduação. Esse tipo de programação foi criada para tentar aproximar o
mundo virtual do mundo real, procurando simular o mundo em que vivemos dentro de um computador.
Para isso, são usados dois principais conceitos: classes e objetos. Nesse modelo de programação, o
programador é responsável por moldar os objetos e explicar como eles devem interagir entre si.
8.1.1. Motivações
A orientação a objetos é usada para auxiliar o desenvolvimento de softwares, gerando códigos mais
inteligíveis e aplicações mais seguras, e para lidar, da melhor forma, com o aumento complexidade dos
softwares.
Uma das grandes vantagens da POO é a reutilização de código. Durante muito tempo, programadores
construíram aplicações muito parecidas que resolviam o mesmo problema. Para que essas aplicações
pudessem ser utilizadas por outros programadores foi criada a orientação a objetos. Além disso, o
crescimento das demandas por metodologias que pudessem abstrair e modularizar as estruturas básicas
fez com que esse paradigma seja cada vez mais aplicado na linguagens de programação, como Java, Ruby,
Python e muitas outras.
8.1.2. Vantagens
Programar de forma orientada a objetos possui diversas vantagens para programadores. Dentre elas,
podemos citar:
● A codificação fica mais próxima do que vemos no mundo real;
● A manutenção do sistema fica muito mais fácil e rápida;
● Maior reutilização do código;
● Segurança;
● Legibilidade;
● Código flexível.
8.2. O que são classes?

Como falamos anteriormente, as classes são uma das principais características que compõe a linguagem
orientada a objetos e podem ser definidas como uma estrutura que abstrai um conjunto de objetos com
características similares. Ou seja, a classe descreve as ações que seus objetos podem fazer e quais
informações eles podem armazenar.
Para entendermos melhor como uma classe funciona vamos exemplificar através de uma classe Carro. Ao
vermos um carro na rua conseguimos reconhecer e dizer que aquilo é um carro. Apesar de existirem
diversos tipos de carros, todos eles possuem características como ano de fabricação, modelo, cor, empresa
que o fabricou, etc. Além dessas características, todos os carro possuem ações que eles podem fazer, como
acelerar, frear e ligar o farol. Assim, podemos entender que classe carro passa a ideia de um veículo
motorizado de 4 rodas que possui certas características e funcionalidades
Em Python, para criarmos nossa classes usamos a palavra chaves class:
class Carro():
pass
Observe que, acima, criamos uma classe vazia, com a ajuda do pass. Porém, quando queremos criar uma
classe precisamos de uma função especial chamada __ init __, abreviação de initialize. Essa função é sempre
o nosso primeiro contato com a classe e vamos usá-la para definir a inicialização de nossa ideia de
modelagem. O __init__ sempre recebe um parâmetro especial que identifica a própria classe, o parâmetro
self.
class Carro ():
def __init__(self):
print("Eu sou um carro")
Carro()
----------------------------------
Eu sou um carro
<__main__.Carro at 0x7fbc2e4e3860>
Def é abreviação de define, e __init__ é o nome de um método Python interno capaz de criar objetos dentro
de uma classe.
8.3. Métodos e atributos
8.3.1. Atributos
Como já mencionamos anteriormente, a classe Carro possui características que todos os objetos (que
veremos mais à frente) apresentarão. Essas características são chamadas de atributos. A nossa classe carro
pode apresentar características como modelo, ano de fabricação, marca e cor. Podemos associar os
atributos como as variáveis presentes em nossa classe.
O self é usado como uma referência para a própria classe. É por meio dele que poderemos criar e acessar
nossos atributos e métodos da classe.
class Carro ():

def __init__(self, marca, modelo, anoDeFabricacao, cor):
self.marca = marca
self.modelo = modelo
self.anoDeFabricacao = anoDeFabricacao
self.cor = cor
Quando fazemos self.marca = marca estamos criando o atributo marca e atribuindo a ele a marca que foi
passada como parâmetro na função __init__. E assim por diante com as variáveis modelo, anoDeFabricacao
e cor.
Atributos com valor padrão

Podemos, também, criar atributos que não precisam ser passados quando criarmos um objeto da classe
carro. Esses atributos possuem um valor padrão pré definido. Usamos esse valor padrão em situações que
sempre daremos a esses objetos algum valor padrão no momento em que são criados.
class Carro ():

def __init__(self, marca, modelo, anoDeFabricacao, cor, statusFarol =
'desligado'):
self.marca = marca
self.cor = cor
#statusFarol é parâmetro com valor padrão, segundo a definição de nosso

__init__()
self.statusFarol = statusFarol
Veja como definimos atributos com valores padrão para nossa classe. O atributos statusFarol sempre será
desligado, mas pode ser mudado ao instanciar um objeto.
Além do valor padrão podemos criar atributos com valores pré-definidos e que não podem ser mudados
ao inicializar a classe:
class Carro ():

'desligado'):
self.marca = marca
self.cor = cor
self.velocimetro = 0
Observe que o atributo velocimetro será sempre 0 ao instanciarmos nossa classe. Isso faz com que ele não
seja um atributo que precise ser passado como parâmetro para o __init__.
8.3.2. Métodos
Os atributos de uma classe são referentes a uma característica do objeto, ou seja, são sempre fatos sobre o
objeto, como a cor do carro. Porém, é possível definirmos métodos de uma classe, que refletem mais as
ações que o objeto pode fazer do que suas características. Um exemplo de método da nossa classe carro é
acelerar e frear, já que todo carro pode realizar essas duas ações. O método é, na verdade, uma função,
igual a que aprendemos no módulo anterior, porém, os métodos sempre estão associados a uma classe e
só podem ser acessados através de um objeto. Além disso, o primeiro parâmetro de um método sempre
recebe o objeto de instância que é o assunto implícito da chamada do método.
Esse parâmetro é chamado self, usado como referência ao objeto que está sendo definido pela classe.
Podemos passar os outros parâmetros que alguns métodos precisam normalmente, separando-os com as
vírgulas.
class Carro ():
'desligado'):
self.marca = marca
self.cor = cor
#statusFarol e velocimetro são parâmetros com valores padrão, segundo a

definição de nosso __init__()
def ligarFarol(self):
if(self.statusFarol == 'desligado'):
self.statusFarol = 'ligado'
print("Farol ligado!")
def desligarFarol(self):
if(self.statusFarol == 'ligado'):
self.statusFarol = 'desligado'
print("Farol desligado!")
Veja que no exemplo acima criamos dois métodos para nossa classe carro: ligarFarol() e
desligarFarol(). Esses dois métodos mudarão o atributo statusFarol para ligado ou para desligado,
respectivamente. Como falamos, podemos, também, criar métodos que recebem parâmetros:
def acelerar(self, acresVelocidade):

self.velocimetro = self.velocimetro + acresVelocidade
def frear(self, decresVelocidade = 5):

if (self.velocimetro > decresVelocidade):
self.velocimetro = self.velocimetro - descresVelocidade
else:
Nesse caso, criamos dois métodos: acelerar() e frear(). Esses dois métodos modificam o atributo
velocimetro, que não é passado como parâmetro. O acelerar() apresenta o argumento
acresVelocidade, que significa o quanto queremos aumentar a velocidade do nosso carro. Já o método
frear possui um argumento com valor padrão, ou seja, ao chamá-lo podemos, ou não, passar o quanto
queremos frear nosso carro. Se não passarmos, ele decrescerá a variável velocimetro em 5 unidades.
Observe que os métodos funcionam como funções, uma vez que podemos criar diversas instruções dentro
deles.
8.4. O que são objetos?

O que caracteriza a programação orientada a objetos são os objetos. Em geral, podemos considerar os
objetos como representação de entidades do mundo real. Na nossa classe carro, podemos definir os
objetos como carros específicos, por exemplo o fiat uno, o gol, o jeep, etc. Falamos que ao criarmos um
objeto estamos instanciando a classe, ou seja, criando uma ocorrência específica da classe.
Veja que no exemplo nós temos a nossa classe carro e as ocorrências específicas dela, como o gol laranja, o
fusca azul e o uno azul escuro. Todas as instâncias da classe possuem as mesmas características, como
marca, modelo, ano de fabricação e cor, porém em ocorrências diferentes.
Podemos definir um objeto como um ente independente composto por:

● estado interno: uma memória interna em que valores podem ser armazenados e modificados ao
longo da vida do objeto
● comportamento, um conjunto de ações pré-definidas (métodos), através das quais o objeto
responderá a demanda de processamento por parte de outros objetos.
8.4.1. Instanciando objetos

Criamos objetos a partir de uma classe, em que são definidas as características e funcionalidades do objeto.
Instanciar um objeto é a ação de criar uma ocorrência específica da classe para podermos trabalhar com ele.
Conseguimos instanciar objetos, em Python, da seguinte forma:
nome_objeto = Nome_Classe(self, atributo1, atributo2,.., atributoN)
gol = Carro('wolks', 'gol', 2010, 'laranja')

fusca = Carro('wolks', 'fusca', 1990, 'azul claro')
uno = Carro('fiat', 'uno', 2000, 'azul escuro')
No exemplo acima, criamos três ocorrências da nossa classe Carro: o gol, o fusca e o uno. Através deles que
poderemos acessar os atributos e métodos da classe.
Utilizando nossos objetos
Como dissemos, é através dos objetos que poderemos interagir com a classe.
gol.acelerar(10) #chamou o método

print(gol.velocimetro)
---------------------------------------------
10
Veja no exemplo que chamamos o método acelerar, passamos o número 10 e o método foi executado de
acordo com o que criamos dentro dele. O mesmo acontece quando usamos a função ligarFarol().
fusca.ligarFarol()
---------------------------------------------
Farol ligado!
É importante ressaltar que quando mudamos a variável de um objeto específico essa mesma variável do
outro objeto não é mudada. Isso mostra como os objetos são independentes entre si
print(gol.velocimetro)
print(fusca.velocimetro)
---------------------------------------------
10
0
print(gol.statusFarol)
print(fusca.statusFarol)
---------------------------------------------
desligado
ligado
Interação com os objetos

Uma vez que criamos nossa classe, todas as demais estruturas estudadas podem ser utilizadas para
interagir e armazenar as instâncias dessa classe. Podemos, por exemplo, criar uma lista de objetos carro.
i = 0
lista = []
while i < 3:
marca = input("Digite a marca: ")
modelo = input("Digite o modelo: ")
ano = int(input("Digite o ano: "))
cor = input("Digite a cor: ")
carro = Carro(marca, modelo, ano, cor)
lista.append(carro)
i = i+1
---------------------------------------------
Digite a marca: wolks
Digite o modelo: gol
Digite o ano: 2010
Digite a cor: prata
Digite a marca: fiat
Digite o modelo: uno
Digite o ano: 2000
Digite a cor: vermelho
Digite a marca: jeep
Digite o modelo: renegate
Digite o ano: 2015
Digite a cor: branco
lista[0].acelerar(10)
print(lista[0].velocimetro)
---------------------------------------------
10
Veja que criamos uma lista de objetos carros e através do acesso por índices conseguimos usar o método
acelerar(). Isso vale para todos os elementos da lista e seus métodos e atributos.
8.5. Encapsulamento
O encapsulamento é um dos principais pilares da programação orientada a objetos. Esta é uma das partes
que proporcionam maior segurança à programação, pois permite que certos dados estejam escondidos.
Mais formalmente falando, o encapsulamento permite a distinção de elementos públicos, protegidos ou
privados.
8.5.1. Atributos privados

Em Python, o encapsulamento é feito de duas formas (i) um underline para elementos protegido e (ii) com
dois underlines para elementos privados. Nesta parte do curso, vamos lidar apenas com elementos privados.
Na nossa classe carro, criaremos uma variável privada chamada status. Essa variável serve para mostrar se o
carro está ligado ou desligado. Queremos proteger essa variável pois não queremos que usuários externos
tenham acesso a ela, já que não é qualquer um que pode ligar ou desligar o carro.
def __init__(self, marca, modelo, anoDeFabricacao, cor, statusFarol ='desligado'):

self.marca = marca
self.cor = cor
self.__status = 'desligado' # Atributo privado da classe Carro
Agora esse atributo só pode ser acessado por métodos da classe.
8.5.2. Métodos get e set

A maior parte das linguagens de programação que possuem orientação a objetos fazem o encapsulamento
ligado a métodos get e set que irão retornar e mudar o valor da variável, respectivamente. Isso evita o
acesso direto a propriedade do objeto, adicionando uma outra camada de segurança à aplicação.
# Informa o status atual do carro

def get_status(self):
return self.__status
# Permite que o status do carro seja modificado, perante avaliação de segurança

def set_status(self, novo_status, chave):
if chave == 123456:
self.__status = novo_status
else:
print("O status não pode ser alterado")
Veja que, como falamos, apenas métodos internos da classe poderão ter acesso à variável __status.
Dessa forma usuários externo podem acessar e mudar a variável, porém com algumas restrições. No
set_status() há uma verificação se o usuário que está tentando mudar possui a chave correta.
8.5.3. Métodos privados

Os métodos privados possuem a mesma ideia de atributos privados. Eles são métodos que usuários
externos não terão acesso, apenas funções dentro da classe podem utilizá-lo. Por exemplo, podemos criar
uma função __verifica_chave(self,chave) que servirá para fazer a verificação do método set().
# Criando um método privado

def __verifica_chave(self, chave):
if chave == 123456:
return True
else:
return False
# Permite que o status do carro seja modificado, perante avaliação de segurança
def set_status(self, novo_status, chave):
# Utilização de métodos privados
chave_certa = self.__verifica_chave(chave)
if chave_certa:
self.__status = novo_status
else:
print("O status não pode ser alterado")
Esse método privado não fica disponível para utilização quando criamos o objeto igual os métodos acelerar
e frear ficam. Ele pode ser usado apenas por funções dentro da classe.
8.6. Exercícios
1. Classe Triangulo: crie uma classe que modele um triângulo:
 Atributos: LadoA, LadoB, LAdoC;
 Métodos: claculaPerimetro(), maiorLado();
 Crie um programa que utilize esta classe. Ele deve pedir ao usuário que informe as medidas de um
triângulo. Depois, deve criar um objeto com as medidas e imprimir sua área e maior lado.
2. Classe Funcionário: implemente a classe Funcionário. Um funcionário tem nome e um salário. Escreva
um construtor com dois parâmetro, nome e salário , e o método
aumentaSalario(percentualDeAumento) que recebe a porcentagem que se deseja aumentar o salário
do funcionário.
3. Implemente uma classe Aluno, que deve ter os seguintes atributos: nome, curso, tempoSemDormir (em
horas). Esta classe deverá ter os seguintes métodos:
 estudar (que recebe como parâmetro a qtd de horas de estudo e acrescenta tempoSemDormir)
 dormir (que recebe como parâmetro a qtd de horas de sono e reduz tempoSemDormir)
 Crie um código de teste da classe, criando um objeto da classe aluno e usando os métodos estudar
e dormir. Ao final imprima quanto tempo o aluno está sem dormir
4. Crie uma classe Aluno, que possui como atributo um nome e cpf. Crie outra classe chamada Equipe,
que possui como atributo uma lista de participantes do tipo Aluno e outro atributo chamado projeto.
Crie uma terceira classe chamada GerenciadorEquipes. Essa classe possui como atributo uma lista de
todas as equipes formadas. Ela deverá possuir como método criarEquipe, que recebe uma lista de
alunos de uma equipe e diz se a equipe pode ser formada ou não. Caso não haja nenhum aluno da
equipe a ser ser formada em uma outra equipe com o mesmo projeto, então a equipe é criada e
acrescentada à lista. Caso contrário é informada que a equipe não pode ser criada
5. Classe carro: implemente uma classe chamada Carro com as seguintes propriedades:
 Um veículo tem um certo consumo de combustível (medidos em km / litro) e uma certa quantidade
de combustível no tanque;
 O consumo é especificado no construtor e o nível de combustível inicial é 0.;
 Forneça um método andar() que simule o ato de dirigir o veículo por uma certa distância, reduzindo
o nível de combustível no tanque de gasolina. Esse método recebe como parâmetro a distância em
km;
 Forneça um método obterGasolina(), que retorna o nível atual de combustível;
 Forneça um método adicionarGasolina() para abastecer o tanque;
 Faça um programa para testar a classe carro.
9. Bibliotecas
9.1. Introdução
Ao sairmos de um interpretador Python para outro o que foi definido no código anterior (variáveis e
funções) é perdido. Para que isso não aconteça, o Python possui uma maneira de colocar essas definições
em um arquivo para que possamos usar as definições em qualquer interpretador. Tal arquivo é chamado de
módulo e cada módulo é, essencialmente, uma coleção de código pré-escrito que podemos usar no nosso
próprio código sem ter repetir algo que já foi escrito.
Em Python, módulos fornecem uma maneira fácil de organizar componentes em um sistema, servindo
como pacotes independentes de variáveis. Todos os módulos que importamos se tornam atributos do
nosso código, assim podemos utilizar os métodos e objetos disponibilizados pela biblioteca.
Podemos relacionar as bibliotecas em Python como bibliotecas físicas. As bibliotecas do Python possuem
diversos pacotes, que podem ser comparados aos livros, e esses pacotes apresentam diversos módulos, que
são comparados aos capítulos dos livros. Todos esses elementos representam grande parte do que faz a
linguagem Python ser reconhecida como modular, já que o código é agrupado de acordo com sua função.
O Python vem, automaticamente, com uma vasta coleção de módulos chamada de biblioteca padrão. Com
eles podemos realizar tarefas comuns no dia a dia da programação como interfaces para sistemas
operacionais, persistência de objetos, correspondência padrão de texto e muito mais. Nenhuma dessas
ferramentas faz parte da própria linguagem Python, mas podemos usá-las importando os módulos
apropriados em qualquer instalação padrão do Python.
Como exemplos das bibliotecas da linguagem temos:
Bibliotecas Funcionalidade
Math Operações matemáticas, como seno, cosseno, fatorial, etc.
Scipy Usada para matemática, ciência e engenharia.
Numpy Usada para cálculos numéricos e álgebra linear.
Sympy Usada para computação simbólica
Matplotlib Usada para criação de gráficos e visualização de dados.
9.2. Importando bibliotecas

Existem diversas formas de importar as funcionalidades presentes em um módulo. Dentre elas, a mais
simples é simplesmente usar a palavra import seguida no nome do módulo que desejamos usar.
import math
O comando acima importa a biblioteca math inteira, que possui diversas funções e atributos usados para
operações matemáticas. Um detalhe interessante sobre a importação de biblioteca é que podemos dar
“apelidos” a elas através da palavra chave as:
import math as mt
Agora, usaremos as ferramentas da biblioteca math através do apelido mt que demos. Alguma bibliotecas
possuem essa nomenclatura de forma padrão, ou seja, são convenções no mundo da programação:
import numpy as np
import pandas as pd
Em alguns momentos não precisamos importar a biblioteca inteira, mas apenas alguma de suas
ferramentas. Para fazer isso, podemos usar seguinte comando:
from math import sin
Nesse exemplo, estamos importando apenas o método sin, que calcula o seno de um dado ângulo em
radianos, e poderemos usá-lo apenas através de sin(ângulo) ao invés de math.sin(ângulo).
Podemos, também, importar vários itens de uma biblioteca listando seus nomes, separados por vírgulas.
from math import sin, cos
No exemplo acima importamos apenas os métodos seno e cosseno.
É possível, também, importar todos os módulos da biblioteca para que possamos usar suas funcionalidades
sem precisar do prefixo math.
from math import *
Apesar de parecer muito útil, esse tipo de importação não é muito comum. Se importamos muitos módulos
e usamos muitas peças diferentes de cada um deles, evitar nomes de módulos no código pode dificultar
outros programadores para ler e entender esse código.
Por fim, conseguimos importar diversas bibliotecas através de um único import, basta separar as
bibliotecas por vírgulas.
import math, matplotlib

import scipy
9.3. Usando bibliotecas
Quando importamos uma biblioteca todas as funcionalidades dela estarão disponíveis para utilizarmos.
Observe o exemplo:
import math
math.sin(90)
-----------------------
0.8939966636005579
Acessamos os métodos das bibliotecas através da sintaxe nome_biblioteca.nome_metodo, igual

acessamos os métodos das classes. O método sin() calcula o seno de um grau dado em radianos e a
mesma coisa acontece com o método cos().
math.cos(90)
-----------------------
0.4480736161291701
As fazermos a importação do tipo
from math import *
Podemos usar o método sem precisar acessá-lo através do math.
factorial(10)
-----------------------
3628800
Porém, como falamos, não é uma prática muito utilizada.
A mesma ideia é válida para importar apenas certas ferramentas:

from math import sin, cos
sin(0)
-----------------------
0.0
cos(0)
-----------------------
1.0
Referências
[1] Trytoprogram. History of python programming. Online; acessado em 01 jun 2020

[2] Mindbending . A história do Python. Online; acessado 01 jun 2020
[3] Guezzi, Carlo; Jazayeri, Mehdi (1998). Programming Language Concepts (em inglês) 3ª ed. New York:
John Wiley & Sons. p. 7. 427 páginas.
[4] Python. Applications for Python. Online; acessado em 02 jun 2020
[5] Python Brasil. IDEs para Python. Online; acessado em 02 jun 2020
[6] Conda. Conda Docs. Online; acessado em 02 jun 2020
[7] Anaconda. Online; acessado em 02 jun 2020
[8] Spyder. Online; acessado em 03 jun 2020
[9] Cormen, Thomas. Desmistificando algoritmos. Vol. 1. Elsevier Brasil, 2017.
[10] Maruch, Stef, and Aahz Maruch. Python for dummies. John Wiley & Sons, 2006.
[11] Lutz, Mark. Learning python: Powerful object-oriented programming. " O'Reilly Media, Inc.", 2013.

Aula 01 - Apostila Introdutória

Enviado por

Direitos autorais:

Formatos disponíveis

Aula 01 - Apostila Introdutória

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Aula 01 - Apostila Introdutória

Enviado por

Direitos autorais:

Formatos disponíveis

Fundamentos essenciais de Python

Direitos desta edição reservados

Supervisão editorial: Thiago Coutinho de Oliveira

0.1. Sobre o Python

0.1.2. O que é o Python?

0.2. Onde é usado

0.2.1. Python + Linux

0.3. Apresentação do curso

1.1. Conhecendo o Anaconda

1.2. Configurando o ambiente

1. Acessar o site oficial do Anaconda e ir para a parte de downloads;

1.3. Conhecendo o Jupyter

1.4. Conhecendo o Spyder

2.1. O que são variáveis?

● int - qualquer número inteiro positivo ou negativo;

2.2. Criando variáveis

2.2.1. Regras para declaração de variáveis

2.2.2. Criando variáveis

Guardamos o valor Joao na variável nome.

2.2.3. Declaração de múltiplas variáveis

idade, nome, email = 20, “Joao”, “joao@gmail.com”

2.3. Funções de impressão e captura de dados

nome = input(“Por favor digite seu nome: ”)

print(“Parabéns”, nome, “você tirou”, nota, “no teste”)

2.4. Funções nativas para variáveis

print("r1 tem o valor", r1, "e o tipo", type(r1))

mensagem = “Olá mundo”

Operação Descrição Exemplo

% Módulo (resto da divisão) 7/2=1

print('Soma = ', numero + falso_numero)

3.1. Operadores lógicos

Operador Exemplo no código O que determina

and a and b se ambos x e y são verdadeiros

or a or b se apenas x ou apenas y é verdadeiro

not not a nega o valor original de x

3.1.4. Tabela da verdade

True False False True

True True True True

False False False False

False True False True

3.1.5. Ordem de precedência

3.2. Expressões relacionais

>= Maior que ou igual a

> Maior que

<= Menor que ou igual a

< Menor que

3.3. Resumo de precedência e exemplos

*, /, %, // Multiplicação, divisão, módulo, divisão inteira

>, >=, <, <=, ==, != Comparações

not não lógico

1) (2 < 3) and (5 > 1)

3.4. Estruturas condicionais if, else e elif

4. Trabalhando com Strings

curso = 'Fundamentos essenciais para Python'

4.3. Operadores em strings

resp = 'Maria é responsavel pelo setor '

print('Tipo da string: ', type(curso))

4.4. Métodos e manipulação de strings

4.4.3. Upper, Lower e Capitalize

4.4.4. Split e Join