Aqui, estudaremos as condicionais em Python, tentaremos cobrir tudo sobre isso.
O operador de módulo % em Python
O operador módulo funciona em inteiros (e expressões inteiras) e produz o resto quando o primeiro operando é dividido pelo segundo. Em Python, o operador de módulo é um sinal de porcentagem (%). A sintaxe é a mesma dos outros operadores:
quoficiente = 7 / 3
print(quoficiente) # 2.3333333333333335
remainder = 7 % 3
print(remainder) # 1
Portanto, 7 dividido por 3 é 2 com 1 restante.
O operador de módulo revelou-se surpreendentemente útil. Por exemplo, você pode verificar se um número é divisível por outro:
if x% y is 0, então x é divisível por y.
Além disso, você pode extrair o dígito ou dígitos mais à direita de um número. Por exemplo, x% 10 produz o dígito mais à direita de x (na base 10). Da mesma forma, x% 100 produz os dois últimos dígitos.
Valores e expressões booleanas em Python
O tipo Python para armazenar valores verdadeiros e falsos é chamado bool, em homenagem ao matemático britânico George Boole. George Boole criou a álgebra booleana, que é a base de toda a aritmética computacional moderna.
Existem apenas dois valores booleanos: True e False. A capitalização é importante, pois verdadeiro e falso não são valores booleanos.
type(True) # correto
type(true) # errado
Uma expressão booleana é uma expressão avaliada como um valor booleano. O operador == compara dois valores e produz um valor booleano:
print(5 == 5) # True
print(5 == 6) # False
Na primeira instrução, os dois operandos são iguais, portanto, a expressão é avaliada como True; na segunda instrução, 5 não é igual a 6, então obtemos False.
O operador == é um dos operadores de comparação; os outros são:
x! = y # x não é igual ay
x> y # x é maior que y
x <y # x é menor que y
x> = y # x é maior ou igual a y
x <= y # x é menor ou igual a y
Embora essas operações provavelmente sejam familiares para você, os símbolos do Python são diferentes dos símbolos matemáticos. Um erro comum é usar um único sinal de igual (=) em vez de um duplo sinal de igual (==).
Lembre-se de que = é um operador de atribuição e == é um operador de comparação. Além disso, não existe = < ou => .
Operadores lógicos em Python
Existem três operadores lógicos: and, or e not. A semântica (significado) desses operadores é semelhante ao seu significado em portugues. Por exemplo, x> 0 e x <10 é verdadeiro apenas se x for maior que 0 e menor que 10.
n% 2 == 0 ou n% 3 == 0 é verdadeiro se qualquer uma das condições for verdadeira, ou seja, se o número for divisível por 2 ou 3.
Finalmente, o operador not nega uma expressão booleana, então not (x> y) é verdadeiro se (x> y) é falso, ou seja, se x é menor ou igual a y.
Execução condicional em Python ( if…)
Para escrever programas úteis, quase sempre precisamos da capacidade de verificar as condições e alterar o comportamento do programa de acordo. As declarações condicionais nos dão essa capacidade. A forma mais simples é a declaração if :
x = 0
if x > 0:
print("x é zero")
A expressão booleana após a instrução if é chamada de condição. Se for verdade, a instrução recuada será executada. Se não, nada acontece.
A sintaxe para uma instrução if é semelhante a esta:
if EXPRESSÃO BOOLEANA:
AFIRMAÇÕES
A instrução if consiste em um cabeçalho e um corpo. O cabeçalho começa com a palavra-chave se seguido por uma expressão booleana e termina com dois pontos (:).
As instruções recuadas que se seguem são chamadas de bloco. A primeira declaração não endentada marca o fim do bloco. Um bloco de instrução dentro de uma instrução composta é chamado de corpo da instrução.
Cada uma das instruções dentro do corpo é executada em ordem se a expressão booleana for avaliada como True. O bloco inteiro é ignorado se a expressão booleana for avaliada como False.
Não há limite para o número de instruções que podem aparecer no corpo de uma instrução if, mas deve haver pelo menos uma. Ocasionalmente, é útil ter um corpo sem instruções (geralmente como um guardião de código que você ainda não escreveu). Nesse caso, você pode usar a instrução pass, que não faz nada.
if True: # Isso é sempre verdade
pass # então isso é sempre executado, mas não faz nada
Execução alternativa em Python ( if … else)
Uma segunda forma da instrução if é a execução alternativa, na qual existem duas possibilidades e a condição determina qual delas será executada. A sintaxe é semelhante a esta:
x= 2
if x % 2 == 0:
print(x, "é um número par")
else:
print(x, "é um número ímpar")
Se o resto quando x é dividido por 2 for 0, então sabemos que x é par e o programa exibe uma mensagem nesse sentido. Se a condição for falsa, o segundo conjunto de instruções é executado. Visto que a condição deve ser verdadeira ou falsa, exatamente uma das alternativas será executada. As alternativas são chamadas de ramos, porque são ramos no fluxo de execução.
Condicionais encadeados em Python
Às vezes, existem mais de duas possibilidades e precisamos de mais de dois ramos. Uma maneira de expressar uma computação como essa é uma condicional encadeada:
x = 2
y = 3
if x < y:
print(x, "é menor que ", y)
elif x > y:
print(x, "é maior que", y)
else:
print(x, "e", y, "são iguais")
elif é uma abreviatura de else if. Novamente, exatamente uma ramificação será executada. Não há limite para o número de instruções elif, mas apenas uma única (e opcional) instrução else é permitida e deve ser a última ramificação na instrução:
escolha = input('faça a sua escolha: > ')
if escolha == 'a':
print("Bom dia")
elif escolha == 'b':
print("Boa tarde")
elif escolha == 'c':
print("Boa noite")
else:
print("Escolha inválida.")
Cada condição é verificada em ordem. Se o primeiro for falso, o próximo será verificado e assim por diante. Se um deles for verdadeiro, a ramificação correspondente é executada e a instrução termina. Mesmo se mais de uma condição for verdadeira, apenas a primeira ramificação verdadeira é executada.
Condicionais aninhados em Python
Uma condicional também pode ser aninhada em outra. Poderíamos ter escrito o exemplo de tricotomia da seguinte forma:
x = 2
y = 3
if x == y:
print(x, "e", y, "são iguais")
else:
if x < y:
print(x, "é menor que", y)
else:
print(x, "é maior que", y)
A condicional externa contém duas ramificações. A primeira ramificação contém uma instrução de saída simples. A segunda ramificação contém outra instrução if, que possui duas ramificações próprias. Essas duas ramificações são instruções de saída, embora também possam ter sido instruções condicionais.
Embora o recuo das instruções torne a estrutura aparente, as condicionais aninhadas tornam-se difíceis de ler muito rapidamente. Em geral, é uma boa ideia evitá-los quando puder.
Os operadores lógicos geralmente fornecem uma maneira de simplificar as instruções condicionais aninhadas. Por exemplo, podemos reescrever o código a seguir usando uma única condicional:
x = 2
if 0 < x:
if x < 10:
print("x é um único dígito positivo.")
A instrução print é executada apenas se passarmos pelas duas condicionais, então podemos usar o operador and :
x = 2
if 0 < x and x < 10:
print("x é um único dígito positivo.")
Esses tipos de condições são comuns, portanto, o Python fornece uma sintaxe alternativa semelhante à notação matemática:
x = 2
if 0 < x < 10:
print("x é um único dígito positivo.")
Essa condição é semanticamente igual à expressão booleana composta e à condicional aninhada.
0 Comentários