IPython Notebook

MAC2166 - Introdução à Computação

08/04/2014 - Aula 5

Expressões lógicas: o tipo bool e os operadores lógicos and, or e not

Uma expressão lógica é uma expressão que tem somente dois valores possíveis como resultado: verdadeiro ou falso.

Expressões desse tipo são construídas, por exemplo, por meio de operadores de comparação, como ==, !=, >, >=, < e <=, e operadores lógicos (que veremos mais adiante nesta aula).

In [1]:
 
12 == 12
Out[1]:
True
In [2]:
 
12 == 13
Out[2]:
False

Em aulas anteriores, usamos algumas expressões lógicas simples para indicar a condições de execução dos laços while e das execuções condicionais if-elif-else.

O resultado de uma expressão lógica é sempre do tipo bool:

In [3]:
 
resultado = 12 == 12
print(resultado, type(resultado))
True <class 'bool'>

True e False são valores especiais, os únicos possíveis no tipo bool:

In [4]:
 
print(type(True))
print(type(False))
<class 'bool'>
<class 'bool'>

Portanto, True e False não são strings (True não é a mesma coisa que "True").

Para construir expressões lógicas, podemos usar também operadores lógicos. Existem três operadores lógicos: and, or e not. O significado desses operadores é bastante intuitivo, uma vez que ele equivale à interpretação que fazemos deles na língua inglesa (e também das suas traduções para a língua portuguesa).

Exemplos:

x > 0 and x < 10

A expressão acima só é verdadeira (ou seja, o resultado é True) somente quando duas condições são satisfeitas ao mesmo tempo: x é maior que 0 e x e menor que 10.

n%2 == 0 or n%3 == 0

A expressão acima é verdadeira quando pelo menos uma das condições é verdadeira, ou seja, quando n é divisível por 2 ou quando n é divisível por 3. Note que se n for divisível por 2 e por 3 ao mesmo tempo, a expressão continua sendo verdadeira.

not (x > y)

Na expressão acima, o operador not nega o resultado da expressão lógica entre parênteses. Portanto, o resultado só será verdadeiro se x não for maior que y, ou seja, se x for menor ou igual a y.

As interpretações providas acima são apropriadas quando os operandos usados para o operador lógico são valores do tipo bool ou uma expressão cujo o resultado é um bool. Mas Python não restringe o uso dos operadores lógicos apenas para operandos do tipo bool. Portanto, existe uma outra que é mais conveniente para os casos em que pelo menos um dos operandos não é um bool:

  • Na expressão x and y, primeiro o x é avaliado. Se o x é falso, então o seu valor é devolvido como resultado da operação de and. No caso contrário, y é avaliado e o valor resultante será o resultado da operação and.

  • Na expressão x or y, primeiro o x é avaliado. Se o x é verdadeiro, então o seu valor é devolvido como resultado da operação de and. No caso contrário, y é avaliado e o valor resultante será o resultado da operação and.

Além disso, em uma expressão lógica, os valores 0 (int), 0.0 (float) e "" (str) são considerados equivalentes ao valor booleano False. Qualquer coisa diferente deles é considerado equivalente a True.

Veja os exemplos a seguir:

In [5]:
 
x = 5
x > 0 and x < 10
Out[5]:
True
In [6]:
 
0.0 and x == 5
Out[6]:
0.0
In [7]:
 
17 and x == 5
Out[7]:
True
In [8]:
 
x == 5 and 17
Out[8]:
17
In [9]:
 
17 or x == 6
Out[9]:
17
In [10]:
 
not(17) or x == 6
Out[10]:
False
In [11]:
 
not(17) or 18
Out[11]:
18

Os operadores lógicos tem menor precedência que os operadores matemáticos. Assim, em uma expressão, primeiro são avaliados os operadores matemáticos (de acordo com as regras de precedência que vimos na aula passada), e só depois são avaliados os operadores lógicos. O ordem de precedência (da maior para a menor) para os operações lógicas é a seguinte:

  1. not
  2. and
  3. or

Problema 8

Dados um número inteiro n > 0 e as médias de n alunos, determinar quantos ficaram de recuperação. Um aluno está de recuperação se sua média estiver entre 3,0 e 5,0 (nota máxima é 10,0).

In [ ]:
 
n = int(input("Digite n: "))
rec = 0
cont = 0
while cont < n:
    media = float(input("Digite uma nota: "))
    if media >= 3.0 and media < 5.0: #  essa condição equivale a: 3.0 <= media < 5.0:
        rec = rec + 1
    cont = cont + 1
print(rec, "alunos ficaram de recuperação")

Problema 9

Dados um número inteiro n, n > 0, e uma sequência com n números inteiros, verificar se a sequência está em ordem crescente.

In [ ]:
 
n = int(input("Digite o tam da seq: "))
cresce = True
ant = int(input("Digite um num da seq: "))
n = n - 1
while n > 0 and cresce:
   atual = int(input("Digite um num da seq: "))
   n = n - 1
   if ant >= atual:
      cresce = False
   ant = atual
if cresce:
   print("Sequência crescente")
else:
   print("Sequência não é crescente")

Na solução acima, é importante destacarmos a variável cresce, que atua no programa como um indicador de passagem.

Um indicador de passagem é uma variável que inicia com um determinado valor e, caso o evento que ele marca ocorra, seu valor é alterado e não muda mais. Esse é o caso da variável cresce, que é iniciada com o valor True e só é modificada para False quando o programa identifica que um número que "quebra a sequência de números crescentes" foi fornecido como entrada. Ao final da execução do laço while, se cresce estiver com o valor False então ela indicará que foi encontrado na sequência de entrada um número que quebrou a ordem crescente.

O indicador de passagem é um padrão frequentemente usado em programação; ele identifica a occorência de um evento que impacta o fluxo de execução do programa. Por isso, é importante compreender muito bem como ele funciona.

Problema Extra

Dado um número inteiro n>0, verificar se este número contém dois dígitos adjacentes iguais.

In [ ]:
 
n = int(input("Digite um número: "))
iguais = False
d_ant = n % 10
n = n // 10
d = 0
while n > 0 and not iguais:
    d_atual = n % 10
    n = n // 10    
    if d_atual == d_ant:
        iguais = True
    d_ant = d_atual
if iguais:
    print("Contém números adjacentes iguais")
else:
    print("Não contém números adjacentes iguais")

Tópicos vistos na Aula 5

  • tipo bool, valores booleanos True e False
  • operadores lógicos and, or e not
  • expressões lógicas
  • indicador de passagem

Referências e outros materiais para estudo