O que vamos aprender nessa aula:¶
1. Os operadores de comparação¶
No mundo da programação, um conceito muito útil e versátil é o da comparação. Em Python temos alguns operadores que conseguem realizar comparaçoes entre valores. Eles são:
a > b #maior que
a < b #menor que
a >= b #maior ou igual a
a <= b #menor ou igual a
a == b #igual a
a != b #diferente de
Com esses operadores podemos realizar comparações com diversos tipos diferentes, comparando valores numéricos, strings, etc. Essas comparações são chamadas de expressões lógicas ou booleanas e são avaliadas como sendo verdadeiras ou falsas. Em Python, essas expressões lógicas retornam um tipo Booleano com valor True (verdadeiro) ou False (falso).
Vale resaltar que o operador "=" se comporta como um operador de atribuição e não de igualdade como é o caso do "==".
Vamos observar os seguintes exemplos:
#vamos considerar as seguintes variáveis
a = 10
b = 20.5
#agora vamos testar os nossos operadores de comparação. Troque os comparadores e veja qual o resultado!
a > b
Muito bom! Mas como falamos (e talvez você já tenha testado) essas comparações conseguem fazer mais que comparar valores numéricos:
#Vamos agora considerar nossas variáveis 'a' e 'b' com o tipo string
a = 'aaa'
b = 'aab'
#Vamos testar se nossos operadores ainda funcionam
a < b
Perceberam alguma coisa nessas comparações?
Sim! Quando nossas variáveis tomam valores de strings, a comparação passa a acontecer alfabeticamente (mais precisamente o operador usa um valor numérico único associado a cada letra para determinar a ordem alfabética).E não é somente a ordem alfabética que importa! Se compararmos duas letras iguais, porém uma maiúscula e uma minúscula, elas terão o mesmo valor?
#Vamos considerar as variaveis minuscula e maiuscula
minuscula = 'a'
maiuscula = 'A'
#Será que elas são iguais?
minuscula == maiuscula
Quando comparamos a letra minúscula com a letra maiúscula, percebemos que para o computador elas não são iguais!
Isso ocorre por que para o computador eles são símbolos diferentes. Ele precisa saber quando você quer utilizar uma letra minúscula e quando você quer utilizar uma letra maiúscula. Portanto, 'a' e 'A' não podem ter o mesmo valor, mesmo sendo a mesma letra. Esse assunto não é tão simples assim, e caso queira entender um pouco melhor sobre comparação de strings e codificação de caracteres, sugerimos este link.
#Agora vamos tentar atribuir tipos diferentes às nossas variáveis
a = 4
b = 34.5
#Teste você mesmo! O qua acontece se tentamos comparar esses tipos diferentes? Agora troque tanto
#os operadores como os tipos
a > b
Ok! Viu o que acontece se tentamos comparar uma str com um int? Que tal a comparação entre um int e um float? O resultado era esperado?
E se quiséssemos saber se um número possui um único digito? Como vocês resolveriam?
#Exercício 1
x = 15
Provalvelmente vocês devem ter pensado em rodar o código duas vezes comparando o número com 0 e 10, porém uma maneira mais eficiente de resolver o problema seria usando aninhamento dos operadores de comparação que permitem fazer mais de uma comparação por linha. Tente usar 0 < x < 10.
2. Operadores condicionais if, else e elif¶
Já vimos que as comparações lógicas nos retornam valores True e False. Mas o que podemos fazer com essa informação? Vamos responder essa pergunta com uma tarefa:
Tente fazer um programa que imprima o maior valor entre duas opções:
#Exercício 2
#Esses são os valores apresentados para você
valor_a = 450.5
valor_b = 472.5
#Agora escreva esse programa que nos diz qual é o maior
Conseguiu? Provavelmente não, né? Isso é por que ainda falta uma peça nesse quebra-cabeças de comparação: Algo que consiga avaliar o resultado dessa operação!
Precisamos de uma maneira de pedir para o computador fazer alguma tarefa baseado no resultado da comparação entre os valores. Para isso usamos o termo if, que vem do inglês se. Com esse termo, podemos pedir para o computador fazer alguma coisa se uma condição for atendida. Vamos tentar entender melhor:
Precisamos fazer com que o computador
imprima o valor 'a' se o valor 'a' for maior que o valor 'b'
ou
imprima o valor 'b' se o valor 'b' for maior que o valor 'a'
Entendeu? Agora vamos ver como escrever coisas desse tipo em um programa de verdade.
Em Python utilizamos a expressão if da seguinte forma:
if 'Alguma condição':
'Alguma ação'
Perceba o espaçamento que existe da linha em que a ação está descrita em relação ao lado esquerdo. Essa prática, chamada de indentação, é fundamental para que códigos em Python funcionem corretamente (sendo optativa em outras linguages de programação). A tecla ideal para fazer este espaçamento é o TAB (em cima de Caps Lock), porém também pode ser feito com a barra de espaço.
A condição pode ser qualquer valor ou expressão lógica. Quando a condição retornar o valor booleano True ou qualquer valor diferente de zero, a ação será executada. Caso o retorno seja o booleano False, None ou 0 (zero), a ação não é executada e o programa segue normalmente. Vamos testar:
#Vamos considerar a variável
a = True
#Troque o valor de 'a' e veja os casos em que seu valor é considerado verdadeiro
if a:
print('A condição é verdadeira')
Abaixo temos um exemplo utilizando os operadores de comparação já ensinados:
#Troque o valor destas variáveis e verifique as diferentes saídas de acordo
#com as comparações realizadas
meuDinheiro = 2.50
precoCoxinha = 2
if meuDinheiro > precoCoxinha:
print("Vou comer uma coxinha e ainda vai sobrar dinheiro!")
if meuDinheiro == precoCoxinha:
print("Será que eu devo gastar todo meu dinheiro em uma coxinha?")
print("Com fome ou não, vida que segue")
O mais interessante de se observar neste exemplo é que, quando a expressão lógica do if é falsa, o programa continua sendo executado e apenas ignora a ação englobada.
Além do if temos o operador else, que poderia ser traduzido para caso contrário, ou seja:
if 'Alguma condição':
'Alguma ação'
else:
'Alguma outra ação, caso a condição não seja atendida'
Podemos usar alguns diagramas para ajudar na compreenção do que acontece no programa quando usamos operadores condicionais:
Vamos testar essa propriedade:
#Novamente considere a variável
fome = True
#Troque o valor de 'fome' e perceba como conseguimos pedir para o computador fazer algo
#mesmo quando 'fome' é falsa
if fome:
print('Preciso comer!')
else:
print('Estou de barriga cheia :)')
Agora que entendemos como os operadores if e else funcionam, vamos tentar voltar ao nosso problema inicial. Volte para a célula do problema dos valores e tente escrever o programa com seus novos conhecimentos. Lembre também que as comparações nos dão valores de True ou False.
Ir para problema inicial.
Conseguiu? Eu sabia que conseguiria! Vamos então analisar mais uma propriedade de operadores condicionais: o elif
O operador elif é uma contração do termo else if (se você já viu linguagens como C talvez conheça dessa forma) e significa caso contrário, se. Ele é muito útil para checar mais de uma condição e criar mais de duas possibilidades de ação.
Vamos analisar um pouco de sua sintaxe:
if 'Alguma condição':
'Alguma ação'
elif 'Alguma outra condição':
'Alguma outra ação'
else:
'Alguma outra ação, caso nenhuma das condições sejam atendidas'
Podemos escrever quantos elif quisermos, mas apenas um if e um else para analisar um conjunto de condições.
Entendeu? Então vamos explorar essa propriedade:
#considere agora as seguintes variáveis
fome = 10
sono = 15
#dessa vez, tente criar diferentes condições e mudar os valores de 'fome' e 'sono'.
#Tente também adicionar elifs com diferentes condições mais específicas
if fome < sono:
print('Vou voltar a dormir')
elif fome > sono:
print('Vou pegar alguma coisa para comer')
else:
print('Alguém traz comida pra mim?')
Agora é a sua vez! Faça um pequeno programa que nos diga se uma palavra tem mais, menos ou extamente 5 letras. Lembre do conteúdo da aula passada sobre o tipo string!
#Exercício 3
#essa é a sua palavra. Mude seu valor para a palavra de sua escolha!
palavra = 'Escolha'
#escreva aqui o programa que nos diz se ela tem menos, mais ou exatamente 5 letras. Dica: tente usar a função 'len(palavra)'
Conseguiu? Você está fera! Vamos então continuar nossos estudos.
Um último tema a ser abordado é o aninhamento de expressões if, else e elif:
Podemos escrever expressões do tipo if dentro delas mesmas. Com isso, podemos criar condições dentro de condições, filtrando ainda mais nossos valores. Podemos olhar outro diagrama para ajudar na compreensão:
Mas cuidado!!! Para tanto, é importante respeitar a indentação e os dois pontos que seguem essas expressões! Eles ditam quem está dentro de quem, dando sentido ao nosso programa. Vamos avaliar essa propriedade:
#vamos levar em conta três variáveis
a = 1
b = 5
c = 0.5
#mais uma vez, mude as comparações, valores e tente acrescentar casos de 'elif'
if a <= b:
if a > c:
print('Primeiro "if" aninhado é verdadeiro')
else:
print('Primeiro "if" aninhado é falso')
else:
print('Primeiro "if" é falso')
Para finalizar, tente você realizar mais um pequeno projeto. Dessa vez, imagine que você tenha um site e precise avaliar se alguns usuários podem ou não criar uma conta para o seu serviço. Eles te fornecem um nome, uma senha e a idade deles, e você deve dizer se esses dados são válidos ou não, considerando que:
-O nome de usuário deve ter pelo menos 4 letras;
-A senha deve ter ao menos 8 caracteres;
-A idade deve ser, no mínimo, 15 anos.#Exercício 4
#esses são os dados do usuário. Lembre-se de testar dados diferentes!
nome = 'joao'
senha = 'senha123'
idade = 18
#agora escreva a parte que deve avaliar se o usuário é válido ou não
3. Os operadores lógicos not, and e or¶
Uma outra ferramenta poderosa para um programador são os operadores lógicos. Com eles, podemos fazer análises um pouco mais refinadas quando avaliamos condições. Vamos começar com o operador lógico not. Ele pode ser traduzido para não e é utilizado quando queremos negar uma condição. Para visualizar esse funcionamento utilizamos uma tabela que relaciona as entradas com as devidas saídas. As possíveis entradas são mostradas na primeira coluna da tabela e as saídas na segunda coluna. Chamamos essa tabela de "Tabela Verdade" (Talvez você esteja familiarizado com ela).
O not é um operador lógico unário, ou seja, permite apenas uma entrada por vez (True ou False) e sua função é inverter o valor da entrada. Ou seja, quando aplicado ao valor True, o operador not retorna False; Quando aplicado ao valor False, o operador not retorna True.
Vamos dar uma olhada na tabela:
| |
|---|
|
| |
Perceba como o operador inverte a entrada. Acha que entendeu como funciona? Vamos avaliar esse operador:
#considere novamente a seguinte variável
coronaVirus = False
#agora vamos tentar avaliar o oposto da variável. Sinta-se a vontade para mudar seu valor
if not coronaVirus:
print('O Introcomp comeca dia 8 de agosto')
else:
print('Nem queria mesmo')
Agora tente você. Faça um programa pequeno que nos diga se um número inteiro é par ou ímpar. Acha que consegue? Lembre do operador % que retorna o resto da divisão de um número com outro.
#Exercício 5
#aqui está o número a ser avaliado. Tente mudar seu valor para conferir a resposta
a = 11
#escreva aqui o programa que vai avaliar se a variável 'a' é par ou ímpar
Vamos agora analisar outros operadores lógicos muito úteis: os operadores and e or!
Esses operadores também retornam valores booleanos e são muito úteis para avaliar mais de uma condição dentro do mesmo if. Podem ser traduzidos para e e ou, respectivamente, e podem ser utilizados da seguinte forma:
and - Verdadeiro quando os dois elementos envolvidos são verdadeiros. Pode-se fazer uma analogia com o operador de multiplicação!
or - Verdadeiro quando um ou dois elementos envolvidos são verdadeiros. Pode-se fazer uma analogia com o operador de soma!
Vamos dar uma olhada nas tabelas verdade desses operadores:
| | |
|---|---|
| | A | B | Saída | |:-----:|:-----:|:-----:| | True | True | True | | True | False | False | | False | True | False | | False | False | False | | | A | B | Saída | |:-----:|:-----:|:-----:| | True | True | True | | True | False | True | | False | True | True | | False | False | False | |
Que fique claro que não é nada necessário decorar essas tabelas, tudo se torna natural ao longo do tempo. Uma maneira interessante de se pensar é com a analogia matemática, onde 1 corresponde a True e 0 a False, e o and e o or correspondem aos operadores da analogia anterior de multiplicação e soma::
| | |
|---|---|
| | A | B | Saída | |:-----:|:-----:|:-----:| | 1 | 1 | 1 | | 1 | 0 | 0 | | 0 | 1 | 0 | | 0 | 0 | 0 | | | A | B | Saída | |:-----:|:-----:|:-----:| | 1 | 1 | 1 | | 1 | 0 | 1 | | 0 | 1 | 1 | | 0 | 0 | 0 | |
Uma observação, ao utilizar a analogia de soma encontramos que 1 + 1 = 1 e não a 2, lembre-se, isso vem da situação anterior em que consideramos 1 é True e 0 é False e só temos esses dois valores.
Perceba como os operadores se comportam na presença de diferentes entradas. Agora vamos analisar essas propriedades um pouco melhor:
#vamos considerar três variáveis
a = 10
b = 5
c = 17
#troque as comparações, adicione 'ands' e 'ors', tente introduzir o termo 'not' e mude os valores de 'a', 'b' e 'c'
if a > b and a < c:
print('O primeiro "if" é verdadeiro')
if a < b or a < c:
print('O segundo "if" é verdadeiro')
Agora um exemplo um pouco mais aplicado, em um mini teste vocacional:
#de uma nota de interesse para cada área do conhecimento de 0 a 10
exatas = 0
humanas = 0
biologicas = 0
#Mude os valores de 'exatas','humanas' e 'biologicas'. Sinta-se a vontade para sugerir outros cursos!
if exatas > 6 and biologicas > 6:
print('engenharia biomedica')
if exatas > biologicas and exatas > humanas:
print('engenharia de computacao')
print('engenharia civil')
if humanas == 10 or exatas == 0:
print('psicologia')
print('filosofia')
if biologicas > 6 or (biologicas > exatas and biologicas > humanas):
print('enfermagem')
print('medicina')
Podemos também atribuir a variáveis expressões utilizando o and e o or. Vamos ver como que fica utilizando o exemplo anterior:
#faça o exemplo novamente, mudando a nota de interesse de cada área
exatas = 0
humanas = 0
biologicas = 0
bom_para_exatas_e_bio = exatas > 6 and biologicas > 6
bom_para_exatas = exatas > biologicas and exatas > humanas
bom_para_humanas = humanas == 10 or exatas == 0
bom_para_bio = biologicas > 6 or (biologicas > exatas and biologicas > humanas)
if bom_para_exatas_e_bio:
print('engenharia biomedica')
if bom_para_exatas:
print('engenharia de computacao')
print('engenharia civil')
if bom_para_humanas:
print('psicologia')
print('filosofia')
if bom_para_bio:
print('enfermagem')
print('medicina')
Tente aplicar valores iguais as variáveis dos dois exemplos anteriores. Mesmo escrevendo o código de forma diferente, os resultados foram iguais?
Vamos tentar reescrever o nosso problema do site e das informações de usuário, mas dessa vez utilizando os novos conhecimentos adquiridos.
#Exercício 6
#esses são os dados do usuário. Lembre-se de testar dados diferentes!
nome = 'joao'
senha = 'senha123'
idade = 18
#agora escreva a parte que deve avaliar se o usuário é válido ou não
Podemos também aninhar os operadores lógicos para obtermos resultados diferentes nas operações. Abaixo temos a explicação de como funciona o aninhamento de and e not (mas não se prendam às tabelas, com o tempo tudo se torna natural!):
Se temos duas entradas verdadeiras no operador and, normalmente teríamos que:
| A | B | Saída |
|---|---|---|
| True | True | True |
Porém, se aplicarmos o operador not depois de aplicarmos o operador and, temos que a saída ficaria invertida. Tabela da expressão not (A and B) para as duas entradas verdadeiras:
| A | B | Saída de not (A and B) |
|---|---|---|
| True | True | False |
Assim, analisando toda a tabela verdade desses operadores juntos, obtemos:
| |
|---|
| | A | B | Saída de not (A and B) | |:-----:|:-----:|:-----:| | True | True | False | | True | False | True | | False | True | True | | False | False | True | |
A ideia aqui é que os operadores fazem sua parte do trabalho separadamente, mas com os resultados de outros operadores. Combinar operadores pode ficar muito complicado e, sem cuidado, podemos estar aplicando esses operadores com valores que não tinhamos intenção. Por isso, lembre-se de usar os parenteses para explicitar quais operações você está fazendo! Assim como na matemática, as operacões entre parenteses acontecem primeiro, ou seja, têm prioridade!
Vamos então praticar o aninhamento de outros operadores:
#vamos considerar três variáveis
a = 10
b = 5
c = 17
#troque as comparações, adicione 'ands' e 'ors', tente introduzir o termo 'not' e mude os valores de 'a', 'b' e 'c'
#dessa vez, troque tambem os parenteses, tente imaginar o que aconteceria com e resultado e compare com o resultado final
if not (a > b and a < c):
print('O primeiro "if" é verdadeiro')
if (a < b or a < c) and (c > b):
print('O segundo "if" é verdadeiro')
Muito bem! Agora, um desafio: Faça um programa que recebe três números e nos informe o maior entre eles. Utilize todos os conhecimentos da aula de hoje e teste com múltiplos casos:
#Exercício 7
#esses são seus valores
n1 = 0
n2 = 7
n3 = 1.6
#escreva aqui o programa que nos diz qual dos três números é o maior
4. O que pode dar errado?¶
No decorrer da aula você provavelmente já teve alguns problemas enquanto programava, e para tentar solucionar as dúvidas mais frequentes temos essa seção.
Um dos erros mais frequentes no uso das condicionais em Python é a falta da indentação (IndentationError). Observe o código abaixo:
a = True
if a:
print("123")
Deu problema, né? Como dito no durante a aula, a indentação (o espaço do comando em relação ao lado esquerdo) é fundamental para a interpretação correta do algoritmo. Caso tenha se esquecido, para dar este espaçamento basta apertar a tecla TAB.
Os dois pontos após a condição também é fundamental. Se você esquecer de utilizá-los, o computador vai indicar um erro.
a = True
if a
print("123")
a = True
if a:
print("Verdade")
else
print("Mentira")
Outro erro bem comum que observamos em edições anteriores era o uso da comparação de maneira irregular:
x = 5
y = 2
z = 3
if x > y < z:
print("Mas que loucura é essa?")
Apesar do código funcionar, é importante entendermos o que ele significa. Caso a intenção seja de obter o resultado booleano de "x é maior que y e x é menor que z?", o código não está correto. Observe o código abaixo e veja a equivalência utilizando operadores lógicos, além de uma solução para o questionamento.
x = 5
y = 2
z = 3
if x > y and y < z:
print("Essa é a comparação feita pelo exemplo")
if x > y and x < z:
print("Essa é a comparação citada no texto")
if z > x > y:
print("Essa é uma outra alternativa para a comparação citada no texto (pense um pouco)")
Perfeito! E por aqui terminamos a terceira aula do curso! Na próxima aula estudaremos sobre listas, loops e matrizes, o que permitirá um avanço ainda mais significativo no universo da programação. Bons estudos e lembre-se de responder o formulário :)
Resolução dos exercícios¶
#Exercício 1
x = 4
10 > x > 0
#Exercício 2
valor_a = 450.5
valor_b = 472.5
if valor_a > valor_b:
print(valor_a)
if valor_a < valor_b:
print(valor_b)
#Exercício 3
palavra = 'Escolha'
if len(palavra) > 5:
print('Maior')
elif len(palavra) < 5:
print('Menor')
else:
print('Igual')
#Exercício 4
#-O nome de usuário deve ter pelo menos 4 letras;
#-A senha deve ter ao menos 8 caracteres;
#-A idade deve ser, no mínimo, 15 anos.
nome = 'joao'
senha = 'senha123'
idade = 18
if len(nome) >= 4:
if len(senha) >= 8:
if idade >= 15:
print("CADASTRO EFETUADO COM SUCESSO")
#Exercício 5
a = 10
if(a%2 == 0):
print("PAR")
else:
print("IMPAR")
#Exercício 6
#-O nome de usuário deve ter pelo menos 4 letras;
#-A senha deve ter ao menos 8 caracteres;
#-A idade deve ser, no mínimo, 15 anos.
nome = 'joao'
senha = 'senha123'
idade = 18
if len(nome) >= 4 and len(senha) >= 8 and idade >= 15:
print("CADASTRO EFETUADO COM SUCESSO")
#Exercício 7
n1 = 0
n2 = 7
n3 = 1.6
if n1 > n2 and n1 > n3:
print(n1)
elif n2 > n1 and n2 > n3:
print(n2)
elif n3 > n1 and n3 > n2:
print(n3)
else:
print("Existem dois ou mais números iguais")
This work is licensed under a Creative Commons Attribution 4.0 International License