Na lição anterior, você aprendeu como usar operadores de comparação e declarações condicionais para controlar o fluxo dos seus programas. Embora eles sejam muito poderosos, você frequentemente encontrará situações em que precisa comparar múltiplos valores ao mesmo tempo. Isso pode levar a declarações condicionais aninhadas, por exemplo:

is_citizen = True
age = 25

if is_citizen:
    if age >= 18:
        print('You are eligible to vote') # You are eligible to vote
else:
    print('You are not eligible to vote')

O exemplo acima primeiro verificará se is_citizen é True. Se for o caso, ele então irá para a declaração if aninhada e verificará se age é maior ou igual a 18. Como age é maior ou igual a 18, a mensagem exibida no terminal será You are eligible to vote. Se is_citizen fosse False, então a mensagem impressa no terminal teria sido You are not eligible to vote. Se você está trabalhando com declarações condicionais mais complexas, então você pode usar os operadores and, or e not do Python. Mas antes de mergulharmos nesses operadores, vamos dar uma olhada no que são valores truthy e falsy. Em Python, todo valor tem um valor booleano inerente, ou um sentido embutido de se ele deve ser tratado como True ou False em um contexto lógico. Muitos valores são considerados truthy, ou seja, eles avaliam para True em um contexto lógico. Outros são falsy, significando que eles avaliam para False. Aqui estão alguns valores falsy:

• None
• False
• Inteiro 0
• Número de ponto flutuante 0.0
• Strings vazias ""

Outros valores como números diferentes de zero e strings não vazias são truthy. Se você quer verificar se um valor é truthy ou falsy, você pode usar a função embutida bool(). Ele converte explicitamente um valor para seu equivalente booleano e retorna True para valores truthy e False para valores falsy. Aqui estão alguns exemplos:

print(bool(False)) # False
print(bool(0))  # False
print(bool('')) # False

print(bool(True)) # True
print(bool(1)) # True
print(bool('Hello')) # True

Agora que você entende os valores truthy e falsy, podemos dar uma olhada nos operadores booleanos, que também são conhecidos como operadores lógicos. Estes são operadores especiais que permitem combinar múltiplas expressões para criar uma lógica de tomada de decisão mais complexa no seu código. Existem três operadores booleanos em Python: and, or e not. Vamos primeiro dar uma olhada no operador and. O operador and recebe dois operandos e retorna o primeiro operando se ele for falso, caso contrário, retorna o segundo operando. Ambos os operandos devem ser truthy para que uma expressão resulte em um valor truthy. Aqui está um exemplo:

is_citizen = True
age = 25

print(is_citizen and age) # 25

No exemplo acima, o número 25 é impresso no terminal porque o operador and avaliará o segundo operando se o primeiro operando for True. O operador and é conhecido como um operador de curto-circuito. Short-circuiting significa que o Python verifica os valores da esquerda para a direita e para assim que determina o resultado final. Você frequentemente usará and dentro de declarações if para verificar se múltiplas condições são atendidas. Aqui está como você pode refatorar o exemplo anterior para usar o operador and em vez de declarações if aninhadas:

is_citizen = True
age = 25

if is_citizen and age >= 18:
    print('You are eligible to vote') # You are eligible to vote
else:
    print('You are not eligible to vote')

No exemplo acima, is_citizen é True e age >= 18 avalia para True. Como ambos os operandos do operador and são truthy, a condição is_citizen and age >= 18 é avaliada como True e a chamada print no bloco if é executada. Agora vamos dar uma olhada no operador or. Este operador retorna o primeiro operando se ele for truthy, caso contrário, retorna o segundo operando. Uma expressão or resulta em um valor verdadeiro se pelo menos um operando for verdadeiro. O operador or também é conhecido como um operador de curto-circuito. Aqui está um exemplo:

age = 19
is_employed = False

print(age or is_employed) # 19

O código a seguir imprimirá o número 19 porque o primeiro operando age é truthy. Se você precisa verificar se uma ou mais expressões são True, então você pode usar o operador or em uma condicional assim:

age = 19
is_student = True

if age < 18 or is_student:
    print('You are eligible for a student discount') # You are eligible for a student discount
else:
    print('You are not eligible for a student discount')

Neste caso, age < 18 é False, mas is_student é True. Como pelo menos uma condição é verdadeira, toda a expressão or é avaliada como True e a mensagem de desconto no bloco if é exibida. O último operador que vamos analisar é o operador not que recebe um único operando e inverte seu valor booleano. Ele converte valores truthy em False e valores falsy em True. Ao contrário dos operadores anteriores que analisamos, not sempre retorna True ou False. Aqui estão alguns exemplos:

print(not '') # True, because empty string is falsy
print(not 'Hello') # False, because non-empty string is truthy
print(not 0) # True, because 0 is falsy
print(not 1) # False, because 1 is truthy
print(not False) # True, because False is falsy
print(not True) # False, because True is truthy

É comum usar o operador not em condicionais para verificar se algo não é True ou False, assim:

is_admin = False

if not is_admin:
    print('Access denied for non-administrators.') # Access denied for non-administrators.
else:
    print('Welcome, Administrator!')

Como is_admin é False, então not is_admin está dizendo não False que é True. Então a mensagem Access denied for non-administrators. será exibida. Agora que você entende como funcionam os valores truthy e falsy, os operadores and, or e not e como o short-circuiting funciona, você pode escrever lógica condicional mais flexível e legível.