É aí que entram as estruturas de controle.

Uma estrutura de controle direciona a ordem de execução das instruções

em um programa (conhecido como fluxo de controle do programa).

Aqui está o que você aprenderá neste tutorial: Você encontrará sua primeira estrutura de controle Python, a
instrução.if

No mundo real, geralmente devemos avaliar as informações ao nosso redor e, em seguida, escolher um curso de ação
ou outro com base no que observamos:

Se o tempo estiver bom, então eu vou cortar a grama. (Está implícito que, se o tempo não estiver bom, então eu
não vou cortar a grama.)

Em um programa Python, a declaração é como você executa esse tipo de tomada de decisão. Ele permite a execução
condicional de uma instrução ou grupo de instruções com base no valor de uma expressão.if

O esboço deste tutorial é o seguinte:

Primeiro, você terá uma rápida visão geral da declaração em sua forma mais simples.if
Em seguida, usando a instrução como um modelo, você verá por que as estruturas de controle exigem algum
mecanismo para agrupar instruções em instruções ou blocos compostos. Você aprenderá como isso é feito em
Python.if
Por fim, você vai amarrar tudo junto e aprender a escrever um código complexo de tomada de decisão.

Pronto? Vamos lá!

 Faça o teste: Teste seus conhecimentos com nosso questionário interativo "Python Conditional
Statements". Após a conclusão, você receberá uma pontuação para que você possa acompanhar seu progresso
de aprendizado ao longo do tempo:

Faça o Quiz »

Introdução à Declaraçãoif
Começaremos examinando o tipo mais básico de declaração. Em sua forma mais simples, ele se parece com isso:if

Python

if <expr>:
<statement>

No formulário mostrado acima:

<expr> é uma expressão avaliada em um contexto booleano, conforme discutido na seção sobre Operadores
Lógicos no tutorial Operadores e Expressões em Python.
<statement> é uma instrução Python válida, que deve ser recuada. (Você verá o porquê muito em breve.)

Se é verdadeiro (avalia como um valor que é "verdadeiro"), então é executado. Se for falso, então é ignorado e não
executado.<expr><statement><expr><statement>

Observe que os dois pontos () a seguir são necessários. Algumas linguagens de programação precisam ser colocadas
entre parênteses, mas o Python não.:<expr><expr>

Aqui estão vários exemplos desse tipo de declaração:if

 Python >>>

>>> x = 0
>>> y = 5

>>> if x < y: # Truthy

... print('yes')
...
yes
>>> if y < x: # Falsy
... print('yes')
...

>>> if x: # Falsy
... print('yes')
...
>>> if y: # Truthy
... print('yes')
...
yes

>>> if x or y: # Truthy
... print('yes')
...
yes
>>> if x and y: # Falsy
... print('yes')
...

>>> if 'aul' in 'grault': # Truthy

... print('yes')
...
yes
>>> if 'quux' in ['foo', 'bar', 'baz']: # Falsy
... print('yes')
...

Nota: Se você estiver tentando esses exemplos interativamente em uma sessão REPL, descobrirá que, quando
pressionar Enter ↩ depois de digitar a instrução, nada acontece.print('yes')

Como essa é uma instrução de várias linhas, você precisa pressionar Enter ↩ uma segunda vez para dizer ao
intérprete que terminou de usá-la. Essa nova linha extra não é necessária no código executado a partir de um
arquivo de script.

 Remover anúncios

Instruções de agrupamento: recuo e blocos

Até aqui, tudo bem.

Mas digamos que você queira avaliar uma condição e, em seguida, fazer mais de uma coisa se for verdade:

Se o tempo estiver bom, então eu vou:

Corte a grama
Erva daninha do jardim
Leve o cão para passear

(Se o tempo não estiver bom, então eu não farei nenhuma dessas coisas.)

Em todos os exemplos mostrados acima, cada um foi seguido por apenas um único . Precisa haver alguma maneira
de dizer: "Se for verdade, faça todas as seguintes coisas".if <expr>:<statement><expr>
A abordagem usual adotada pela maioria das linguagens de programação é definir um dispositivo sintático que
agrupa várias instruções em uma instrução ou bloco composto. Um bloco é considerado sintaticamente como uma
única entidade. Quando ele é o destino de uma instrução e é verdadeiro, todas as instruções no bloco são
executadas. Se é falso, então nenhum deles é.if<expr><expr>

Praticamente todas as linguagens de programação fornecem a capacidade de definir blocos, mas nem todas
fornecem da mesma maneira. Vamos ver como o Python faz isso.

Python: É tudo sobre o recuo

Python segue uma convenção conhecida como a regra do impedimento, um termo cunhado pelo cientista da
computação britânico Peter J. Landin. (O termo é retirado da lei de impedimento no futebol de associação.) Os
idiomas que aderem à regra de impedimento definem blocos por recuo. Python é um de um conjunto relativamente
pequeno de linguagens de regras off-side.

Lembre-se do tutorial anterior sobre a estrutura do programa Python que o recuo tem um significado especial em um
programa Python. Agora você sabe o porquê: o recuo é usado para definir instruções ou blocos compostos. Em um
programa Python, instruções contíguas que são recuadas para o mesmo nível são consideradas parte do mesmo
bloco.

Assim, uma instrução composta em Python tem esta aparência:if

Python

1 if <expr>:
2 <statement>
3 <statement>
4 ...
5 <statement>
6 <following_statement>

Aqui, todas as instruções no nível de recuo correspondente (linhas 2 a 5) são consideradas parte do mesmo bloco. O
bloco inteiro é executado se for verdadeiro ou ignorado se for falso. De qualquer forma, a execução prossegue com
(linha 6) depois.<expr><expr><following_statement>

Python Compound if Instrução

Observe que não há nenhum token que denote o final do bloco. Em vez disso, o final do bloco é indicado por uma
linha que é recuada menos do que as linhas do próprio bloco.

Nota: Na documentação do Python, um grupo de instruções definido por recuo é muitas vezes referido como
um conjunto. Esta série de tutoriais usa os termos bloco e suíte de forma intercambiável.

Considere este arquivo de script:foo.py

Python

1 if 'foo' in ['bar', 'baz', 'qux']:

2 print('Expression was true')
3 print('Executing statement in suite')
4 print('...')
5 print('Done.')
6 print('After conditional')

A execução produz esta saída:foo.py

 Windows Command Prompt

C:\Users\john\Documents>python foo.py
After conditional

As quatro instruções print() nas linhas 2 a 5 são recuadas para o mesmo nível que as outras. Eles constituem o
bloco que seria executado se a condição fosse verdadeira. Mas é falso, então todas as declarações no bloco são
ignoradas. Após o término da instrução composta ter sido alcançada (independentemente de as instruções no bloco
nas linhas 2 a 5 serem executadas ou não), a execução prossegue para a primeira instrução com um nível de recuo
menor: a instrução print() na linha 6.if

Os blocos podem ser aninhados a uma profundidade arbitrária. Cada recuo define um novo bloco e cada recuo
termina o bloco anterior. A estrutura resultante é direta, consistente e intuitiva.

Aqui está um arquivo de script mais complicado chamado :blocks.py

Python

# Does line execute? Yes No

# --- --
if 'foo' in ['foo', 'bar', 'baz']: # x
print('Outer condition is true') # x

if 10 > 20: # x
print('Inner condition 1') # x

print('Between inner conditions') # x

if 10 < 20: # x
print('Inner condition 2') # x

print('End of outer condition') # x

print('After outer condition') # x

A saída gerada quando esse script é executado é mostrada abaixo:

Windows Command Prompt

C:\Users\john\Documents>python blocks.py
Outer condition is true
Between inner conditions
Inner condition 2
End of outer condition
After outer condition

Nota: Caso você esteja se perguntando, a regra de impedimento é a razão para a necessidade da nova linha
extra ao inserir instruções de várias linhas em uma sessão REPL. Caso contrário, o intérprete não tem como
saber que a última declaração do bloco foi inserida.

 Remover anúncios

O que os outros idiomas fazem?

Talvez você esteja curioso para saber quais são as alternativas. Como os blocos são definidos em idiomas que não
aderem à regra do impedimento?

A tática usada pela maioria das linguagens de programação é designar tokens especiais que marcam o início e o fim
de um bloco. Por exemplo, em Perl os blocos são definidos com pares de chaves () como este:{}
 # (This is Perl, not Python)
if (<expr>) {
<statement>;
<statement>;
...
<statement>;
}
<following_statement>;

C/C++, Java e uma série de outras linguagens usam chaves dessa maneira.

Instrução Compound if em C/C++, Perl e Java

Outros idiomas, como Algol e Pascal, usam palavras-chave e para incluir blocos.beginend

Qual é melhor?
Melhor está nos olhos de quem vê. No geral, os programadores tendem a se sentir bastante fortes sobre como eles
fazem as coisas. O debate sobre os méritos da regra do impedimento pode ser bastante acalorado.

No lado positivo:

O uso de recuo do Python é limpo, conciso e consistente.

Em linguagens de programação que não usam a regra off-side, o recuo do código é completamente
independente da definição de bloco e da função de código. É possível escrever código que é recuado de uma
maneira que não corresponde à forma como o código é executado, criando assim uma impressão equivocada
quando uma pessoa apenas olha para ele. Esse tipo de erro é praticamente impossível de cometer em Python.
O uso de recuo para definir blocos força você a manter os padrões de formatação de código que você
provavelmente deveria estar usando de qualquer maneira.

Do lado negativo:

Muitos programadores não gostam de ser forçados a fazer as coisas de uma certa maneira. Eles tendem a ter
opiniões fortes sobre o que parece bom e o que não parece, e eles não gostam de ser colocados em uma escolha
específica.
Alguns editores inserem uma mistura de caracteres de espaço e tabulação à esquerda de linhas recuadas, o que
dificulta a determinação dos níveis de recuo pelo interpretador Python. Por outro lado, muitas vezes é possível
configurar editores para não fazer isso. Geralmente, não é considerado desejável ter uma mistura de guias e
espaços no código-fonte de qualquer maneira, independentemente da linguagem.

Goste ou não, se você está programando em Python, você está preso à regra off-side. Todas as estruturas de controle
em Python o usam, como você verá em vários tutoriais futuros.

Para o que vale a pena, muitos programadores que se acostumaram com linguagens com meios mais tradicionais de
definição de blocos inicialmente recuaram no caminho do Python, mas se sentiram confortáveis com ele e até
cresceram para preferi-lo.

O e Cláusulaselseelif
Agora você sabe como usar uma instrução para executar condicionalmente uma única instrução ou um bloco de
várias instruções. É hora de descobrir o que mais você pode fazer.if
Às vezes, você deseja avaliar uma condição e seguir um caminho, se for verdadeiro, mas especificar um caminho
alternativo, se não for. Isso é feito com uma cláusula:else

Python

if <expr>:
<statement(s)>
else:
<statement(s)>

Se for verdadeiro, o primeiro conjunto é executado e o segundo é ignorado. Se for false, o primeiro conjunto é
ignorado e o segundo é executado. De qualquer forma, a execução é retomada após a segunda suíte. Ambas as suítes
são definidas por recuo, conforme descrito acima.<expr><expr>

Neste exemplo, é menor que , então o primeiro conjunto (linhas 4 a 5) é executado e o segundo conjunto (linhas 7 a 8)
é ignorado:x50

Python >>>

1 >>> x = 20
2
3 >>> if x < 50:
4 ... print('(first suite)')
5 ... print('x is small')
6 ... else:
7 ... print('(second suite)')
8 ... print('x is large')
9 ...
10 (first suite)
11 x is small

Aqui, por outro lado, é maior que , então a primeira suíte é passada e a segunda suíte executada:x50

Python >>>

1 >>> x = 120
2 >>>
3 >>> if x < 50:
4 ... print('(first suite)')
5 ... print('x is small')
6 ... else:
7 ... print('(second suite)')
8 ... print('x is large')
9 ...
10 (second suite)
11 x is large

Há também sintaxe para a execução de ramificação com base em várias alternativas. Para isso, use uma ou mais
(abreviação de else if) cláusulas. Python avalia cada um por sua vez e executa o conjunto correspondente ao primeiro
que é verdadeiro. Se nenhuma das expressões for verdadeira e uma cláusula for especificada, seu conjunto será
executado:elif<expr>else

Python

if <expr>:
<statement(s)>
elif <expr>:
<statement(s)>
elif <expr>:
<statement(s)>
...
else:
<statement(s)>

Um número arbitrário de cláusulas pode ser especificado. A cláusula é opcional. Se estiver presente, pode haver
apenas um, e deve ser especificado por último:elifelse
 Python >>>

>>> name = 'Joe'

>>> if name == 'Fred':
... print('Hello Fred')
... elif name == 'Xander':
... print('Hello Xander')
... elif name == 'Joe':
... print('Hello Joe')
... elif name == 'Arnold':
... print('Hello Arnold')
... else:
... print("I don't know who you are!")
...
Hello Joe

No máximo, um dos blocos de código especificados será executado. Se uma cláusula não estiver incluída e todas as
condições forem falsas, nenhum dos blocos será executado.else

Nota: Usar uma longa série // pode ser um pouco deselegante, especialmente quando as ações são declarações
simples como . Em muitos casos, pode haver uma maneira mais pythonica de realizar a mesma
coisa.ifelifelseprint()

Aqui está uma alternativa possível ao exemplo acima usando o método:dict.get()

Python >>>

>>> names = {
... 'Fred': 'Hello Fred',
... 'Xander': 'Hello Xander',
... 'Joe': 'Hello Joe',
... 'Arnold': 'Hello Arnold'
... }

>>> print(names.get('Joe', "I don't know who you are!"))

Hello Joe
>>> print(names.get('Rick', "I don't know who you are!"))
I don't know who you are!

Lembre-se do tutorial sobre dicionários Python que o método dict.get() pesquisa um dicionário para a chave
especificada e retorna o valor associado se ele for encontrado, ou o valor padrão fornecido, se não for.

Uma instrução com cláusulas usa avaliação de curto-circuito, análoga ao que você viu com o e operadores. Uma vez
que uma das expressões é considerada verdadeira e seu bloco é executado, nenhuma das expressões restantes é
testada. Isso é demonstrado abaixo:ifelifandor

Python >>>

>>> var # Not defined

Traceback (most recent call last):
File "<pyshell#58>", line 1, in <module>
var
NameError: name 'var' is not defined

>>> if 'a' in 'bar':

... print('foo')
... elif 1/0:
... print("This won't happen")
... elif var:
... print("This won't either")
...
foo

A segunda expressão contém uma divisão por zero, e a terceira faz referência a uma variável indefinida. Qualquer um
deles geraria um erro, mas nenhum deles é avaliado porque a primeira condição especificada é verdadeira.var
 Remover anúncios

Instruções de uma linhaif

É costume escrever em uma linha e recuado na seguinte linha assim:if <expr><statement>

Python

if <expr>:
<statement>

Mas é permitido escrever uma declaração inteira em uma linha. O seguinte é funcionalmente equivalente ao exemplo
acima:if

Python

if <expr>: <statement>

Pode até haver mais de um na mesma linha, separados por ponto-e-vírgula:<statement>

Python

if <expr>: <statement_1>; <statement_2>; ...; <statement_n>

Mas o que isso significa? Há duas interpretações possíveis:

1. Se for verdade, execute . <expr><statement_1>

Então, execute incondicionalmente, independentemente de ser verdade ou não.

<statement_2> ... <statement_n><expr>

2. Se for verdade, execute todo o . Caso contrário, não execute nenhum deles.<expr>
<statement_1> ... <statement_n>

Python toma a última interpretação. O ponto-e-vírgula que separa o tem maior precedência do que os dois pontos
seguintes - na linguagem do computador, diz-se que o ponto-e-vírgula se liga mais firmemente do que o cólon. Assim,
os são tratados como uma suíte, e ou todos eles são executados, ou nenhum deles é:<statements><expr><statements>

Python >>>

>>> if 'f' in 'foo': print('1'); print('2'); print('3')

...
1
2
3
>>> if 'z' in 'foo': print('1'); print('2'); print('3')
...

Várias instruções podem ser especificadas na mesma linha que uma ou cláusula também:elifelse
 Python >>>

>>> x = 2
>>> if x == 1: print('foo'); print('bar'); print('baz')
... elif x == 2: print('qux'); print('quux')
... else: print('corge'); print('grault')
...
qux
quux

>>> x = 3
>>> if x == 1: print('foo'); print('bar'); print('baz')
... elif x == 2: print('qux'); print('quux')
... else: print('corge'); print('grault')
...
corge
grault

Embora tudo isso funcione, e o intérprete o permita, geralmente é desencorajado com base no fato de que leva a uma
baixa legibilidade, particularmente para declarações complexas. A PEP 8 recomenda especificamente contra ela.if

Como de costume, é um pouco uma questão de gosto. A maioria das pessoas acharia o seguinte visualmente mais
atraente e mais fácil de entender à primeira vista do que o exemplo acima:

Python >>>

>>> x = 3
>>> if x == 1:
... print('foo')
... print('bar')
... print('baz')
... elif x == 2:
... print('qux')
... print('quux')
... else:
... print('corge')
... print('grault')
...
corge
grault

Se uma declaração é simples o suficiente, no entanto, colocar tudo em uma linha pode ser razoável. Algo assim
provavelmente não levantaria muito os grilhões de ninguém:if

Python

debugging = True # Set to True to turn debugging on.

.
.
.

if debugging: print('About to call function foo()')

foo()

Expressões condicionais (operador ternário do Python)

Python suporta uma entidade de tomada de decisão adicional chamada uma expressão condicional. (Também é
referido como um operador condicional ou operador ternário em vários lugares na documentação do Python.)
Expressões condicionais foram propostas para adição à linguagem na PEP 308 e receberam luz verde de Guido em
2005.

Em sua forma mais simples, a sintaxe da expressão condicional é a seguinte:

Python

<expr1> if <conditional_expr> else <expr2>

Isso é diferente dos formulários de instrução listados acima porque não é uma estrutura de controle que direciona o
fluxo de execução do programa. Ele age mais como um operador que define uma expressão. No exemplo acima, é
avaliado primeiro. Se for verdade, a expressão será avaliada como . Se for falso, a expressão será avaliada como
.if<conditional_expr><expr1><expr2>

Observe a ordem não óbvia: a expressão do meio é avaliada primeiro e, com base nesse resultado, uma das
expressões nas extremidades é retornada. Aqui estão alguns exemplos que esperamos que ajudem a esclarecer:

Python >>>

>>> raining = False

>>> print("Let's go to the", 'beach' if not raining else 'library')
Let's go to the beach
>>> raining = True
>>> print("Let's go to the", 'beach' if not raining else 'library')
Let's go to the library

>>> age = 12
>>> s = 'minor' if age < 21 else 'adult'
>>> s
'minor'

>>> 'yes' if ('qux' in ['foo', 'bar', 'baz']) else 'no'

'no'

Nota: A expressão condicional do Python é semelhante à sintaxe usada por muitas outras linguagens - C, Perl e
Java, para citar algumas. Na verdade, o operador é comumente chamado de operador ternário nessas
linguagens, o que é provavelmente a razão pela qual a expressão condicional do Python é às vezes referida
como o operador ternário Python.<conditional_expr> ? <expr1> : <expr2>?:

Você pode ver no PEP 308 que a sintaxe foi considerada para Python, mas finalmente rejeitada em favor da
sintaxe mostrada acima.<conditional_expr> ? <expr1> : <expr2>

Um uso comum da expressão condicional é selecionar a atribuição de variáveis. Por exemplo, suponha que você
queira encontrar o maior de dois números. Claro, há uma função embutida, max(), que faz exatamente isso (e muito
mais) que você poderia usar. Mas suponha que você queira escrever seu próprio código do zero.

Você pode usar uma instrução padrão com uma cláusula:ifelse

Python >>>

>>> if a > b:
... m = a
... else:
... m = b
...

Mas uma expressão condicional é mais curta e indiscutivelmente mais legível também:

Python >>>

>>> m = a if a > b else b

Lembre-se de que a expressão condicional se comporta como uma expressão sintaticamente. Ele pode ser usado
como parte de uma expressão mais longa. A expressão condicional tem precedência menor do que praticamente
todos os outros operadores, de modo que parênteses são necessários para agrupá-la por si só.

No exemplo a seguir, o operador se liga mais firmemente do que a expressão condicional, portanto, e são avaliados
primeiro, seguidos pela expressão condicional. Os parênteses no segundo caso são desnecessários e não alteram o
resultado:+1 + xy + 2
 Python >>>

>>> x = y = 40

>>> z = 1 + x if x > y else y + 2

>>> z
42

>>> z = (1 + x) if x > y else (y + 2)

>>> z
42

Se você quiser que a expressão condicional seja avaliada primeiro, será necessário cercá-la com parênteses de
agrupamento. No próximo exemplo, é avaliado primeiro. O resultado é , que é , assim é atribuído = :
(x if x > y else y)y40z1 + 40 + 243

Python >>>

>>> x = y = 40

>>> z = 1 + (x if x > y else y) + 2

>>> z
43

Se você estiver usando uma expressão condicional como parte de uma expressão maior, provavelmente é uma boa
ideia usar parênteses de agrupamento para esclarecimento, mesmo que eles não sejam necessários.

Expressões condicionais também usam avaliação de curto-circuito, como expressões lógicas compostas. Partes de
uma expressão condicional não são avaliadas se não precisarem ser.

Na expressão:<expr1> if <conditional_expr> else <expr2>

Se for verdadeiro, é retornado e não é avaliado.<conditional_expr><expr1><expr2>

Se for falso, é retornado e não é avaliado.<conditional_expr><expr2><expr1>

Como antes, você pode verificar isso usando termos que gerariam um erro:

Python >>>

>>> 'foo' if True else 1/0

'foo'
>>> 1/0 if False else 'bar'
'bar'

Em ambos os casos, os termos não são avaliados, portanto, nenhuma exceção é levantada.1/0

Expressões condicionais também podem ser encadeadas, como uma espécie de estrutura // alternativa, como
mostrado aqui:ifelifelse

Python >>>

>>> s = ('foo' if (x == 1) else

... 'bar' if (x == 2) else
... 'baz' if (x == 3) else
... 'qux' if (x == 4) else
... 'quux'
... )
>>> s
'baz'

Não está claro se isso tem alguma vantagem significativa sobre a instrução // correspondente, mas é sintaticamente
correto Python.ifelifelse

 Remover anúncios
A declaração Pythonpass
Ocasionalmente, você pode achar que deseja escrever o que é chamado de stub de código: um espaço reservado para
onde você eventualmente colocará um bloco de código que ainda não implementou.

Em linguagens onde os delimitadores de token são usados para definir blocos, como as chaves em Perl e C, os
delimitadores vazios podem ser usados para definir um stub de código. Por exemplo, o seguinte é o código Perl ou C
legítimo:

# This is not Python

if (x)
{
}

Aqui, as chaves vazias definem um bloco vazio. Perl ou C avaliarão a expressão e, mesmo que seja verdadeira,
silenciosamente não farão nada.x

Como o Python usa recuo em vez de delimitadores, não é possível especificar um bloco vazio. Se você introduzir uma
instrução com , algo precisa vir depois dela, na mesma linha ou recuado na linha seguinte.ifif <expr>:

Considere este script:foo.py

Python

if True:

print('foo')

Se você tentar executar o , obterá o seguinte:foo.py

Windows Command Prompt

C:\Users\john\Documents\Python\doc>python foo.py
File "foo.py", line 3
print('foo')
^
IndentationError: expected an indented block

A instrução de passagem do Python resolve esse problema. Ele não muda o comportamento do programa em tudo. Ele
é usado como um espaço reservado para manter o intérprete feliz em qualquer situação em que uma declaração é
sintaticamente necessária, mas você realmente não quer fazer nada:

Python

if True:
pass

print('foo')

Agora é executado sem erro:foo.py

Windows Command Prompt

C:\Users\john\Documents\Python\doc>python foo.py
foo

Conclusão
Com a conclusão deste tutorial, você está começando a escrever código Python que vai além da simples execução
sequencial:

Você foi apresentado ao conceito de estruturas de controle. Essas são instruções compostas que alteram o
fluxo de controle do programa — a ordem de execução das instruções do programa.
Você aprendeu a agrupar instruções individuais em um bloco ou suíte.