MAC2166 - Introdução à Computação

28/03/2017 - 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 é 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 interpretação 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 5.1

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 [12]:
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")

Digite n: 5
Digite uma nota: 4.6
Digite uma nota: 8.9
Digite uma nota: 5.0
Digite uma nota: 3.0
Digite uma nota: 3.4
3 alunos ficaram de recuperação

Problema 5.2

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 [13]:
n = int(input("Digite o tamanho da sequência: "))
crescente = True
ant = int(input("Digite um número da sequência: "))
n = n - 1
while n > 0 and crescente:
   atual = int(input("Digite um número da sequência: "))
   n = n - 1
   if ant >= atual:
      crescente = False
   ant = atual
if crescente:
   print("Sequência crescente")
else:
   print("Sequência não é crescente")

Digite o tamanho da sequência: 5
Digite um número da sequência: 3
Digite um número da sequência: 5
Digite um número da sequência: 12
Digite um número da sequência: 9
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 5.3

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

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

Digite um número: 546228
O número digitado contém dígitos adjacentes iguais

Problema Extra

Nota: Questão 1 da Prova 1 de 2014.

Na figura, no plano cartesiano, a região sombreada não inclui as linhas de bordo. Note que o eixo y cai bem no meio da figura, e usamos o lado do quadrado para indicar as ordenadas correspondentes.

alt text

Escreva na página do desenho um programa que lê as coordenadas cartesianas (x, y) de um ponto, ambas do tipo float e imprime dentro se esse ponto está na região, e fora caso contrário.

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