Capítulo 9.1

Índice

from datascience import *
path_data = '../../../assets/data/'
import matplotlib
matplotlib.use('Agg')
%matplotlib inline
import matplotlib.pyplot as plots
plots.style.use('fivethirtyeight')
import numpy as np

Declarações Condicionais

Em muitas situações, ações e resultados dependem de um conjunto específico de condições sendo satisfeitas. Por exemplo, indivíduos em ensaios clínicos randomizados recebem o tratamento se foram designados para o grupo de tratamento. Um jogador ganha dinheiro se vencer sua aposta.

Nesta seção, aprenderemos como descrever tais situações usando código. Uma declaração condicional é uma declaração de várias linhas que permite ao Python escolher entre diferentes alternativas com base no valor verdade de uma expressão. Embora as declarações condicionais possam aparecer em qualquer lugar, elas aparecem mais frequentemente dentro do corpo de uma função para expressar comportamentos alternativos dependendo dos valores dos
argumentos.

Uma declaração condicional sempre começa com um cabeçalho if, que é uma única linha seguida por um corpo recuado. O corpo só é executado se a expressão imediatamente após o if (chamada de expressão if) avaliar para um valor verdadeiro. Se a expressão if avaliar para um valor falso, então o corpo do if é pulado.

Vamos começar definindo uma função que retorna o sinal de um número.

def sign(x):
    
    if x > 0:
        return 'Positive'

sign(3)

Out[1]:

‘Positive’

Esta função retorna o sinal correto se a entrada for um número positivo. Mas se a entrada não for um número positivo, então a expressão if será avaliada como um valor falso e, portanto, a instrução return será ignorada e a chamada de função não tem valor.

sign(-3)

Então, vamos refinar nossa função para retornar Negative se a entrada for um número negativo. Podemos fazer isso adicionando uma cláusula elif, onde elif if é a abreviação do Python para a frase “else, if”.

def sign(x):
    
    if x > 0:
        return 'Positive'
    
    elif x < 0:
        return 'Negative'

Agora sign retorna a resposta correta quando a entrada é -3:

sign(-3)

Out[2]:

‘Negative’

E se a entrada for 0? Para lidar com este caso, podemos adicionar outra cláusula elif:

def sign(x):
    
    if x > 0:
        return 'Positive'
    
    elif x < 0:
        return 'Negative'
    
    elif x == 0:
        return 'Neither positive nor negative'

sign(0)

Out[3]:

‘Neither positive nor negative’

Equivalentemente, podemos substituir a cláusula final elif por uma cláusula else, cujo corpo será executado apenas se todas as comparações anteriores forem falsas; isto é, se o valor de entrada for igual a 0.

def sign(x):
    
    if x > 0:
        return 'Positive'
    
    elif x < 0:
        return 'Negative'
    
    else:
        return 'Neither positive nor negative'

sign(0)

Out[3]:

‘Neither positive nor negative’

O Formulário Geral

Uma instrução condicional também pode ter múltiplas cláusulas com múltiplos corpos, e apenas um desses corpos pode ser executado. O formato geral de uma instrução condicional com múltiplas cláusulas aparece abaixo.

if <if expression>:
    <if body>
elif <elif expression 0>:
    <elif body 0>
elif <elif expression 1>:
    <elif body 1>
...
else:
    <else body>

Sempre há exatamente uma cláusula if, mas pode haver qualquer número de cláusulas elif. Python avaliará as expressões if e elif nos cabeçalhos em ordem até que seja encontrada uma que seja um valor verdadeiro, então execute o corpo correspondente. A cláusula else é opcional. Quando um cabeçalho else é fornecido, seu corpo else é executado apenas se nenhuma das expressões de cabeçalho das cláusulas anteriores for verdadeira. A cláusula else sempre vem no final (ou não é acrescentada).

Exemplo: Aposta em um Dado

Suponha que eu aposto em um lançamento de um dado justo. As regras do jogo:

Se o dado mostrar 1 ponto ou 2 pontos, eu perco um dólar.
Se o dado mostrar 3 pontos ou 4 pontos, nem perco nem ganho dinheiro.
Se o dado mostrar 5 pontos ou 6 pontos, eu ganho um dólar.

Agora usaremos declarações condicionais para definir uma função uma_aposta que recebe o número de pontos no lançamento e retorna o meu ganho líquido.

def one_bet(x):
    """Retorna meu ganho líquido se o dado mostrar x pontos"""
    if x <= 2:
        return -1
    elif x <= 4:
        return 0
    elif x <= 6:
        return 1

Vamos verificar se a função faz a coisa certa para cada número diferente de pontos.

one_bet(1), one_bet(2), one_bet(3), one_bet (4), one_bet(5), one_bet(6)

Out[4]:

(-1, -1, 0, 0, 1, 1)

Como uma revisão de como funcionam as declarações condicionais, vamos ver o que uma_aposta faz quando a entrada é 3.

Primeiro, ele avalia a expressão if, que é 3 <= 2, que é False. Então uma_aposta não executa o corpo do if.
Em seguida, ele avalia a primeira expressão elif, que é 3 <= 4, que é True. Portanto, uma_aposta executa o corpo do primeiro elif e retorna 0.
Uma vez que o corpo foi executado, o processo está completo. A próxima expressão elif não é avaliada.

Se, por algum motivo, usarmos uma entrada maior que 6, a expressão if será avaliada como False, assim como as duas expressões elif. Portanto, uma_aposta não executa o corpo do if nem os dois corpos do elif, e não haverá valor quando você fizer a chamada abaixo.

one_bet(17)

Para jogar o jogo baseado em um lançamento de dado, você pode usar np.random.choice para gerar o número de pontos e então usar isso como argumento para one_bet. Execute a célula algumas vezes para ver como a saída muda.

one_bet(np.random.choice(np.arange(1, 7)))

Out[5]:

-1

Neste ponto é natural querermos coletar os resultados de todas as apostas para que possamos analisá-los. Na próxima seção desenvolvemos uma maneira de fazer isso sem executar a célula repetidas vezes.

← Capítulo 9 – Aleatoriedade

Capítulo 9.2 – Iteração →