Como redigir ramos condicionais com se declarações em Python

O negócio

Explicar a ramificação condicional com se declarações em Python.

  • Noções básicas de se declarações (se, elif, else)
  • Especificar condições com operadores de comparação, etc.
  • Especificar as condições por número, lista, etc.
  • Especificar múltiplas condições ou negações com operadores lógicos (e, ou não)
  • Expressões condicionais em novas linhas e múltiplas linhas

Há também um operador ternário que descreve um ramo condicional numa só linha. Ver o artigo seguinte.

Noções básicas de se declarações (se, elif, else)

A forma básica da declaração if é a seguinte

if Conditional expression 1:
    `Processing to be performed if Expression 1 is True.`
elif Conditional expression 2:
    `Processing to be performed when expression 1 is false and expression 2 is true.`
elif Expression 3:
    `Process when expression 1 and 2 are false and expression 3 is true.`
...
else:
    `Processing when all conditionals are false.`

O “elif” corresponde ao “outro se” em C e outras línguas, e pode haver qualquer número de “elifs”.

Se houver apenas uma expressão condicional ou processamento quando não for necessário falso, os blocos “elif” e “else” podem ser omitidos.

Especificar condições com operadores de comparação, etc.

Especificar a condição com uma operação que devolve um tipo de bool (verdadeiro, falso), tal como um operador de comparação.

Os operadores de comparação Python são os seguintes

operadorresultado
x < yverdadeiro se x for inferior a y
x <= yverdadeiro se x for menor ou igual a y
x > yverdadeiro se x for maior que y
x >= yverdadeiro se x for maior ou igual a y
x == yverdadeiro se os valores x e y forem iguais
x != yverdadeiro se os valores x e y não forem iguaisx is yverdadeiro se x e y são o mesmo objectox is not yverdadeiro se x e y não são o mesmo objectox in yverdadeiro se x estiver contido em yx not in yverdadeiro se x não estiver contido em y

Exemplo. Por conveniência, é definida como uma função com a declaração def.

def if_test(num):
    if num > 100:
        print('100 < num')
    elif num > 50:
        print('50 < num <= 100')
    elif num > 0:
        print('0 < num <= 50')
    elif num == 0:
        print('num == 0')
    else:
        print('num < 0')

if_test(1000)
# 100 < num

if_test(70)
# 50 < num <= 100

if_test(0)
# num == 0

if_test(-100)
# num < 0

O seguinte pode ser escrito de uma forma que é exclusiva de Python. Ver o artigo seguinte para detalhes.
a < x < b

def if_test2(num):
    if 50 < num < 100:
        print('50 < num < 100')
    else:
        print('num <= 50 or num >= 100')

if_test2(70)
# 50 < num < 100

if_test2(0)
# num <= 50 or num >= 100
  • ==
  • !=

O acima exposto é uma comparação de valores; para comparar as identidades dos objectos, use o seguinte

  • is
  • is not

Por exemplo, ao comparar um número inteiro e um número de ponto flutuante, “==” retorna verdadeiro se os valores forem equivalentes, mas “é” retorna falso porque são objectos diferentes.

i = 10
print(type(i))
# <class 'int'>

f = 10.0
print(type(f))
# <class 'float'>

print(i == f)
# True

print(i is f)
# False

Também é possível fazer a condição se uma lista ou uma corda contém um elemento específico (carácter).

  • in:incluir
  • not in:não incluindo
def if_test_in(s):
    if 'a' in s:
        print('a is in string')
    else:
        print('a is NOT in string')

if_test_in('apple')
# a is in string

if_test_in('melon')
# a is NOT in string

Especificar as condições por número, lista, etc.

A expressão condicional de uma declaração pode ser um número, lista, ou outro objecto que não seja do tipo bool (verdadeiro, falso).

if 10:
    print('True')
# True

if [0, 1, 2]:
    print('True')
# True

Na expressão condicional de um Python se a declaração for falsa, os seguintes objectos são considerados falsos.

Números representando zero, cordas vazias, listas, etc. são considerados falsos; todos os outros são considerados verdadeiros.

A forma como o objecto é julgado pode ser verificada com bool().

print(bool(10))
# True

print(bool(0.0))
# False

print(bool([]))
# False

print(bool('False'))
# True

Isto pode ser utilizado para simplesmente escrever o processo quando a lista está vazia, por exemplo.

def if_test_list(l):
    if l:
        print('list is NOT empty')
    else:
        print('list is empty')

if_test_list([0, 1, 2])
# list is NOT empty

if_test_list([])
# list is empty

Note-se que a corda 'Falsa' também será verdadeira, porque, como se mostra no exemplo acima, qualquer corda que não esteja vazia na corda será verdadeira'. Para converter uma string específica como 'Verdadeiro' ou 'Falso' para 1,0, usar strtobool() no módulo distutils.util.

Especificar múltiplas condições ou negações com operadores lógicos (e, ou não)

Os operadores lógicos (e, ou não) podem ser usados para lidar com a conjunção lógica, disjunção lógica, e negação de múltiplas condições.

operador（Result (na expressão condicional de uma declaração de se)
x and yverdadeiro se ambos x e y forem verdadeiros
x or yverdadeiro se x ou y for verdadeiro
not xfalso se x for verdadeiro, verdadeiro se x for falso
def if_test_and_not(num):
    if num >= 0 and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_not(5)
# num is positive odd

if_test_and_not(10)
# num is NOT positive odd

if_test_and_not(-10)
# num is NOT positive odd

De facto, “x e y” e “x ou y” não retornam Verdadeiro ou Falso, mas sim x ou y. Desde que sejam utilizados em expressões condicionais em se declarações, não há necessidade de se preocupar com eles, uma vez que avaliam para Verdadeiro ou Falso. Ver o artigo seguinte para detalhes.

É possível utilizar e e ou mais do que uma vez.

def if_test_and_not_or(num):
    if num >= 0 and not num % 2 == 0 or num == -10:
        print('num is positive odd or -10')
    else:
        print('num is NOT positive odd or -10')

if_test_and_not_or(5)
# num is positive odd or -10

if_test_and_not_or(10)
# num is NOT positive odd or -10

if_test_and_not_or(-10)
# num is positive odd or -10

Expressões condicionais em novas linhas e múltiplas linhas

Quando múltiplas expressões condicionais são utilizadas ligando-as com “e” ou “ou” e cada linha se torna longa, é por vezes necessário quebrar a expressão condicional e escrevê-la em múltiplas linhas.

Uma quebra de linha pode ser feita usando uma barra invertida ou encerrando a linha inteira entre parênteses.

def if_test_and_backslash(num):
    if num >= 0 \
       and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_backslash(5)
# num is positive odd

def if_test_and_brackets(num):
    if (num >= 0
        and not num % 2 == 0):
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_brackets(5)
# num is positive odd

Pode usar uma barra invertida para quebrar uma linha quantas vezes quiser. Da mesma forma, pode quebrar uma linha qualquer número de vezes dentro de parênteses. Não há limite de indentação.

Note-se que esta é uma técnica que pode ser usada em qualquer lugar em código Python, e não apenas em declarações.

Copied title and URL