python apostila_introdutório

Prévia do material em texto

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
http://www.voitto.com.br
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...................................................................................................................................................284.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................................................................................................................................................608.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?
http://en.wikipedia.org/wiki/Monty_Python%27s_Flying_Circus
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
saibamutilizar 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.
https://data-flair.training/blogs/python-applications/
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á:
https://www.anaconda.com/products/individual
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 nomeda 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:
mailto:joao@gmail.com
mailto:joao@gmail.com
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 deuma 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çõese, 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
if (idade > 18 and idade < 70):
print('Seu voto é obrigatório')
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
if (idade > 18 and idade < 70):
print('Seu voto é obrigatório')
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 é responsavelpelo 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.
https://docs.python.org/pt-br/3/tutorial/datastructures.html#more-on-lists
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
https://localhost:8080/#
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',
'Financeiro': 'Joao',
'Operacional': 'Ana',
'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',
'Financeiro': 'Joao',
'Operacional': 'Ana',
'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}
https://localhost:8080/#
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
listaSetores = ['Comercial', 'RH', 'Financeiro', 'Adm', 'Operacional']
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