Python

Estruturas de controle e repetição

20/01/202523/12/2024 Por antonino

Hoje veremos estruturas de controle e repetição

O que é uma estrutura de controle

As estruturas de controle alteram o fluxo de execução do programa com base em condições ou repetições. Elas permitem que o código tome decisões, repita ações ou defina condições que determinam o comportamento do programa. Além disso, essas estruturas são essenciais para tornar o código mais dinâmico e adaptável a diferentes cenários. Existem três tipos principais de estruturas de controle: condicionais, de repetição e de controle de fluxo. Cada uma delas desempenha um papel específico, dependendo do tipo de situação que o programador deseja controlar. Portanto, ao entender essas estruturas, podemos criar programas mais flexíveis e eficientes.

Estruturas Condicionais

As estruturas condicionais são usadas para tomar decisões com base em condições verdadeiras ou falsas.

If, Elif e Else

sinal_atual = "amarelo"
if sinal_atual == "verde":
    print("Siga !")
elif sinal_atual == "amarelo":
    print("Atenção !")
else:
    print("Pare !")

"""
Resultado:
Atenção !
"""

sinal_atual = "amarelo"

if sinal_atual == "verde":

print("Siga !")

elif sinal_atual == "amarelo":

print("Atenção !")

else:

print("Pare !")

"""

Resultado:

Atenção !

"""

If, Else

limite_radar = 40
velocidade_veiculo = 60  
if velocidade_veiculo &gt; limite_radar:
  print(f"veiculo multado andando a {velocidade_veiculo} km/h quando o limite máximo é {limite_radar} km/h")
  print("foto realizada pelo pardal número 545")
  print("enviado para o servidor")
  print("fim")
else:
  print(f"Veículo está no dentro do limite de {limite_radar} km/h")
"""
Resultado:

veiculo multado andando a 60 km/h quando o limite máximo é 40 km/h
foto realizada pelo pardal número 545
enviado para o servidor
fim
"""

limite_radar = 40

velocidade_veiculo = 60

if velocidade_veiculo > limite_radar:

print(f"veiculo multado andando a {velocidade_veiculo} km/h quando o limite máximo é {limite_radar} km/h")

print("foto realizada pelo pardal número 545")

print("enviado para o servidor")

print("fim")

else:

print(f"Veículo está no dentro do limite de {limite_radar} km/h")

"""

Resultado:

veiculo multado andando a 60 km/h quando o limite máximo é 40 km/h

foto realizada pelo pardal número 545

enviado para o servidor

fim

"""

Atenção para a estrutura definida no alinhamento

O alinhamento no Python, também conhecido como indentação, desempenha um papel fundamental na sintaxe da linguagem, pois organiza e estrutura o código de forma clara. Em Python, a indentação é obrigatória e substitui as chaves ({}), utilizadas em outras linguagens como C, C++ ou Java, para definir blocos de código. Assim, ao invés de usar chaves, a indentação indica visualmente quais linhas de código pertencem a determinado bloco. Consequentemente, isso torna o código mais legível e intuitivo, além de evitar confusão na definição de blocos de controle.

opcao_1 = True
opcao_2 = False
opcao_3 = True
print("=============================")
print("Exemplo 1")
print("=============================")
if opcao_1:
    print("Opção 1 é Verdadeira !")
if opcao_2:
    print("Opção 2 é Verdadeira !")
if opcao_3:
    print("Opção 3 é Verdadeira !")
print("nn")
print("=============================")
print("Exemplo 2")
print("=============================")
if opcao_1:
    print("Opção 1 é Verdadeira !")
if opcao_2:
    print("Opção 2 é Verdadeira !")
    # Só vai ser perguntado se opcao_2 for verdadeira
    if opcao_3:
        print("Opção 3 é Verdadeira !")
"""
Resultado:

=============================
Exemplo 1
=============================
Opção 1 é Verdadeira !
Opção 3 é Verdadeira !
=============================
Exemplo 2
=============================
Opção 1 é Verdadeira !
"""

opcao_1 = True

opcao_2 = False

opcao_3 = True

print("=============================")

print("Exemplo 1")

print("=============================")

if opcao_1:

print("Opção 1 é Verdadeira !")

if opcao_2:

print("Opção 2 é Verdadeira !")

if opcao_3:

print("Opção 3 é Verdadeira !")

print("nn")

print("=============================")

print("Exemplo 2")

print("=============================")

if opcao_1:

print("Opção 1 é Verdadeira !")

if opcao_2:

print("Opção 2 é Verdadeira !")

# Só vai ser perguntado se opcao_2 for verdadeira

if opcao_3:

print("Opção 3 é Verdadeira !")

"""

Resultado:

=============================

Exemplo 1

=============================

Opção 1 é Verdadeira !

Opção 3 é Verdadeira !

=============================

Exemplo 2

=============================

Opção 1 é Verdadeira !

"""

Estruturas de repetição

While

Quando não sabemos quantas vezes repetiremos um procedimento, utilizamos o while. Nesse caso, o loop while continuará executando até que uma condição específica se torne verdadeira ou até encontrar a palavra reservada break. Assim, o while oferece maior flexibilidade no controle de repetições, pois a condição de parada pode ser definida durante a execução. Além disso, o uso do break é útil quando precisamos interromper o loop antes que a condição de parada natural seja atingida. Portanto, o while permite um controle dinâmico e eficiente sobre o fluxo de execução.

continuar = True
hortifruti = ['banana', 'morango', 'abacate','pera']
while continuar:
  opcao = input("""==================
         menu       
  ==================
  opções:
  print("1 - Verificar se existe fruta")
  print("2 - Sair")""")
  if(opcao == '1'):
    fruta = input("Qual fruta você procura ?")
    if(fruta in hortifruti):
      print(f'tem {fruta} no hortifruti')
    else:
      print(f'não tem {fruta} no hortifruti')
  elif(opcao == '2'):
    continuar = False
  else:
    break #Caso selecione uma oção inválida pare

continuar = True

hortifruti = ['banana', 'morango', 'abacate','pera']

while continuar:

opcao = input("""==================

==================

opções:

print("1 - Verificar se existe fruta")

print("2 - Sair")""")

if(opcao == '1'):

fruta = input("Qual fruta você procura ?")

if(fruta in hortifruti):

print(f'tem {fruta} no hortifruti')

else:

print(f'não tem {fruta} no hortifruti')

elif(opcao == '2'):

continuar = False

else:

break #Caso selecione uma oção inválida pare

For

Quando usamos o for, sabemos exatamente o número de vezes que o loop será repetido. Entretanto, se o loop encontrar o break, ele pode sair antes de completar todas as repetições. Por exemplo, nos exemplos abaixo, percorremos todas as letras da string e as imprimimos. Dessa forma, conseguimos controlar a iteração de maneira mais previsível, mas ainda com a flexibilidade de interromper a execução sempre que necessário. Portanto, o for nos oferece tanto previsibilidade quanto controle dinâmico sobre o fluxo de execução.

frase='Repetição'
for letra in frase:
  print(letra)
"""
Resultado:

R
e
p
e
t
i
ç
ã
o
"""

frase='Repetição'

for letra in frase:

print(letra)

"""

Resultado:

"""

For , Else

frase='Repetição' 
for letra in frase: print(letra)
else:
    print("fim")
"""
Resultado:
R
e
p
e
t
i
ç
ã
o
fim
"""

frase='Repetição'

for letra in frase: print(letra)

else:

print("fim")

"""

Resultado:

fim

"""

Agora de forma resumida em uma linha.

frase='Repetição'
for letra in frase: print(letra)
"""
Resultado:

R
e
p
e
t
i
ç
ã
o
"""

frase='Repetição'

for letra in frase: print(letra)

"""

Resultado:

"""

Percorrendo uma lista e fazendo uma pergunta

frutas = ["abacaxi","abacate","amora","banana","bacuri","buriti","caju","carambola","cacau",
"damasco","durião","embaúba","figo","framboesa","goiaba","graviola","groselha","heisteria"]
#quais frutas possuem mais de 5 caracteres
resultado = [x for x in frutas if len(x)&gt;5]
descartadas = [x for x in frutas if len(x)&lt;=5]
print(resultado)
print(descartadas)
"""
Resultado:

['abacaxi', 'abacate', 'banana', 'bacuri', 'buriti', 'carambola', 'damasco', 
'durião', 'embaúba', 'framboesa', 'goiaba', 'graviola', 'groselha', 'heisteria']
['amora', 'caju', 'cacau', 'figo']
"""

frutas = ["abacaxi","abacate","amora","banana","bacuri","buriti","caju","carambola","cacau",

"damasco","durião","embaúba","figo","framboesa","goiaba","graviola","groselha","heisteria"]

#quais frutas possuem mais de 5 caracteres

resultado = [x for x in frutas if len(x)>5]

descartadas = [x for x in frutas if len(x)<=5]

print(resultado)

print(descartadas)

"""

Resultado:

['abacaxi', 'abacate', 'banana', 'bacuri', 'buriti', 'carambola', 'damasco',

'durião', 'embaúba', 'framboesa', 'goiaba', 'graviola', 'groselha', 'heisteria']

['amora', 'caju', 'cacau', 'figo']

"""

Comando Continue

frutas = ["maçã", "banana", "laranja", "uva"]
for fruta in frutas:
    if fruta == "banana":
        continue  # Pula a impressão da banana
    print(fruta)
"""
Resultado:
maçã
laranja
uva
"""

frutas = ["maçã", "banana", "laranja", "uva"]

for fruta in frutas:

if fruta == "banana":

continue # Pula a impressão da banana

print(fruta)

"""

Resultado:

maçã

laranja

uva

"""

Comando Pass

for i in range(10):
    if i % 2 == 0:
        pass  # Faz nada se o número for par
    else:
        print(i)
"""
Resultado:
1
3
5
7
9
"""

for i in range(10):

if i % 2 == 0:

pass # Faz nada se o número for par

else:

print(i)

"""

Resultado:

"""

Usamos o comando pass quando sabemos que vamos desenvolver uma função, mas ainda não implementamos seu conteúdo. Nesse caso, declaramos a função e, para evitar erros, colocamos pass no corpo dela. Assim, garantimos que o código seja executado sem problemas, mesmo com a função incompleta. Dessa forma, conseguimos continuar o desenvolvimento sem interrupções, permitindo que voltemos à função mais tarde para adicionar sua lógica. Portanto, o pass é uma solução prática enquanto o código ainda está em desenvolvimento.

Referências:

Documentação Python

Livros sobre Introdução a Python da Amazon

Interno:

Área de Convivência

Operadores em Python

18/01/202523/12/2024 Por antonino

Operadores de Atribuições e Relacionais

Operadores de Atribuição

Os operadores de atribuição são usados para atribuir valores a variáveis, permitindo que o programador manipule os dados de maneira eficiente. O operador básico, e o mais simples, é o símbolo de igualdade =, que realiza a atribuição direta de um valor a uma variável. No entanto, além desse operador básico, Python também possui operadores de atribuição compostos, que combinam a atribuição com operações matemáticas ou lógicas, proporcionando uma maneira mais compacta e eficiente de realizar cálculos ou modificações em variáveis de forma direta.

Esses operadores compostos economizam linhas de código e ajudam a melhorar a legibilidade ao realizar operações como adição, subtração, multiplicação e divisão diretamente dentro da atribuição.

Operador

Descrição

Exemplo

atribuição

nome = "Maria"
print(nome)
"""
Resultado:

Maria
"""

nome = "Maria"

print(nome)

"""

Resultado:

Maria

"""

adição

x = 4
# Adição x = x + 2
x+=2
print('resultado:',x)
"""
Resultado:

resultado: 6
"""

x = 4

# Adição x = x + 2

x+=2

print('resultado:',x)

"""

Resultado:

resultado: 6

"""

subtração

x = 4
# Subitração x = x - 2
x-=2
print('resultado:',x)
"""
Resultado:

resultado: 2
"""

x = 4

# Subitração x = x - 2

x-=2

print('resultado:',x)

"""

Resultado:

resultado: 2

"""

x*=2

multiplicação

x = 4
# Multiplicação x = x * 2
x*=2
print('resultado:',x)
"""
Resultado:

resultado: 8
"""

x = 4

# Multiplicação x = x * 2

x*=2

print('resultado:',x)

"""

Resultado:

resultado: 8

"""

divisão

x = 10
# divisão x = x / 3
x/=3
print('resultado:',x)
"""
Resultado:

resultado: 3.3333333333333335
"""

x = 10

# divisão x = x / 3

x/=3

print('resultado:',x)

"""

Resultado:

resultado: 3.3333333333333335

"""

//=

divisão inteira

x = 10
# divisão inteira x = x // 3
x//=3
print('resultado:',x)
"""
Resultado:

resultado: 3
"""

x = 10

# divisão inteira x = x // 3

x//=3

print('resultado:',x)

"""

Resultado:

resultado: 3

"""

**=

exponenciação

x = 9
# exponenciação x = x ** 2
x**=2
print('resultado:',x)
"""
Resultado:

resultado: 81
"""

x = 9

# exponenciação x = x ** 2

x**=2

print('resultado:',x)

"""

Resultado:

resultado: 81

"""

resto da divisão

x = 9
# resto da divisão x = x % 2
x%=2
print('resultado:',x)
"""
Resultado:

resultado: 1
"""

x = 9

# resto da divisão x = x % 2

x%=2

print('resultado:',x)

"""

Resultado:

resultado: 1

"""

Operadores Relacionais

Os operadores relacionais são usados para comparar dois valores, ajudando a estabelecer relações entre eles. Eles retornam um valor booleano, ou seja, True ou False, dependendo do resultado da comparação realizada. Dessa forma, esses operadores desempenham um papel crucial na avaliação de condições dentro de um programa. Além disso, eles são essenciais para controlar fluxos de execução em estruturas condicionais, como if, e em loops, como while e for, permitindo que o código tome decisões baseadas nas relações entre os valores envolvidos.

Operador

Descrição

Exemplo

igual a

a = 5
b = 5
print("resposta: ",a == b)
"""
Resultado:

resposta:  True
"""

a = 5

b = 5

print("resposta: ",a == b)

"""

Resultado:

resposta: True

"""

diferente de

a = 5
b = 5
print("resposta: ",a != b)
"""
Resultado:

resposta:  False
"""

a = 5

b = 5

print("resposta: ",a != b)

"""

Resultado:

resposta: False

"""

maior que

a = 10
b = 5
print("resposta: ",a &gt; b)
"""
Resultado:

resposta:  True
"""

a = 10

b = 5

print("resposta: ",a > b)

"""

Resultado:

resposta: True

"""

maior ou igual a

a = 10
b = 10
print("resposta: ",a &gt;= b)
"""
Resultado:

resposta:  True
"""

a = 10

b = 10

print("resposta: ",a >= b)

"""

Resultado:

resposta: True

"""

menor que

a = 3
b = 10
print("resposta: ",a &lt; b)
"""
Resultado:

resposta:  True
"""

a = 3

b = 10

print("resposta: ",a < b)

"""

Resultado:

resposta: True

"""

menor ou igual

a = 10
b = 10
print("resposta: ",a &lt;= b)
"""
Resultado:

resposta:  True
"""

a = 10

b = 10

print("resposta: ",a <= b)

"""

Resultado:

resposta: True

"""

Operadores In e Not

Os operadores in e not in são utilizados para verificar a pertinência ou ausência de um elemento dentro de uma sequência (como uma lista, tupla, string, etc.). Eles retornam um valor booleano (True ou False) com base na avaliação de inclusão ou exclusão de um item dentro da sequência.

In retorna True caso contenha o valor

hortifruti = ['banana', 'morango', 'abacate','pera']
print('banana' in hortifruti)
print('acerola' in hortifruti)
"""
Resultado:

True
False
"""

hortifruti = ['banana', 'morango', 'abacate','pera']

print('banana' in hortifruti)

print('acerola' in hortifruti)

"""

Resultado:

True

False

"""

Not In retorna True caso não contenha o valor

hortifruti = ['banana', 'morango', 'abacate','pera']
print('banana' not in hortifruti)
print('acerola' not in hortifruti)
"""
Resultado:

False
True
"""

hortifruti = ['banana', 'morango', 'abacate','pera']

print('banana' not in hortifruti)

print('acerola' not in hortifruti)

"""

Resultado:

False

True

"""

Operadores Is e Is Not

Os operadores is e is not são usados para comparar identidade de objetos, ou seja, se duas variáveis referenciam o mesmo objeto na memória. Diferentemente dos operadores relacionais, que comparam os valores de dois objetos, o is e is not comparam as localizações de memória dos objetos. Essa comparação é fundamental quando queremos saber se duas variáveis estão apontando para a mesma posição de memória, e não apenas se os valores armazenados nelas são iguais.

Is

dois_igual_a_dois =  2 == 2
dois_maior_quatro = 2 &gt; 4
print("resultado: ",dois_igual_a_dois is dois_maior_quatro)

"""
Resultado:

resultado:  False
"""

dois_igual_a_dois = 2 == 2

dois_maior_quatro = 2 > 4

print("resultado: ",dois_igual_a_dois is dois_maior_quatro)

"""

Resultado:

resultado: False

"""

Is Not

dois_igual_a_dois =  2 == 2
dois_maior_quatro = 2 &gt; 4
print("resultado: ",dois_igual_a_dois is not dois_maior_quatro)
"""
Resultado:

resultado:  True
"""

dois_igual_a_dois = 2 == 2

dois_maior_quatro = 2 > 4

print("resultado: ",dois_igual_a_dois is not dois_maior_quatro)

"""

Resultado:

resultado: True

"""

Operadores And, Or, Not e Xor

Os operadores lógicos no Python são usados para combinar expressões booleanas e tomar decisões lógicas com base em condições. Eles trabalham com valores verdadeiros (True) ou falsos (False) e são fundamentais para o controle de fluxo e para criar condições complexas.

Em outras palavras, ao usar operadores lógicos, o programador pode definir condições mais elaboradas, criando fluxos de execução mais flexíveis e adaptáveis. Eles são, portanto, cruciais para garantir que o código execute de maneira correta, dependendo das situações que surgem durante a execução do programa.

Observação: Xor também é conhecido como “ou exclusivo“.

Operador Lógico AND

A and B

True

a = True
b = True
print("resposta: ",a and b)
"""
Resultado:

resposta:  True
"""

a = True

b = True

print("resposta: ",a and b)

"""

Resultado:

resposta: True

"""

True

False

a = True
b = False
print("resposta: ",a and b)
"""
Resultado:

resposta:  False
"""

a = True

b = False

print("resposta: ",a and b)

"""

Resultado:

resposta: False

"""

False

True

a = False
b = True
print("resposta: ",a and b)
"""
Resultado:

resposta:  False
"""

a = False

b = True

print("resposta: ",a and b)

"""

Resultado:

resposta: False

"""

False

a = False
b = False
print("resposta: ",a and b)
"""
Resultado:

resposta:  False
"""

a = False

b = False

print("resposta: ",a and b)

"""

Resultado:

resposta: False

"""

Perceba que em AND o resultado é True apenas em “True and True”

Operador Lógico OR

A or B

True

a = True
b = True
print("resposta: ",a or b)
"""
Resultado:

resposta:  True
"""

a = True

b = True

print("resposta: ",a or b)

"""

Resultado:

resposta: True

"""

True

False

a = True
b = False
print("resposta: ",a or b)
"""
Resultado:

resposta:  True
"""

a = True

b = False

print("resposta: ",a or b)

"""

Resultado:

resposta: True

"""

False

True

a = False
b = True
print("resposta: ",a or b)
"""
Resultado:

resposta:  True
"""

a = False

b = True

print("resposta: ",a or b)

"""

Resultado:

resposta: True

"""

False

a = False
b = False
print("resposta: ",a or b)
"""
Resultado:

resposta:  False
"""

a = False

b = False

print("resposta: ",a or b)

"""

Resultado:

resposta: False

"""

Perceba que em OR o resultado é False apenas em “False or False”

Operador Lógico XOR

A xor B

True

a = True
b = True
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  False
"""

a = True

b = True

print("resposta: ",a ^ b)

"""

Resultado:

resposta: False

"""

True

False

a = True
b = False
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  True
"""

a = True

b = False

print("resposta: ",a ^ b)

"""

Resultado:

resposta: True

"""

False

True

a = False
b = True
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  True
"""

a = False

b = True

print("resposta: ",a ^ b)

"""

Resultado:

resposta: True

"""

False

a = False
b = False
print("resposta: ",a ^ b)
"""
Resultado:

resposta:  False
"""

a = False

b = False

print("resposta: ",a ^ b)

"""

Resultado:

resposta: False

"""

Perceba que em XOR o resultado é True apenas quando são valores opostos uma ao outro : “True xor False” e “False xor True”

Operador NOT

O operador not em Python é um operador lógico utilizado para inverter o valor de uma expressão booleana. Ele funciona de forma simples: se a expressão for verdadeira, o operador not a transforma em falsa; se for falsa, o operador a transforma em verdadeira. Dessa forma, ele realiza a negação do valor lógico de uma expressão, proporcionando uma maneira simples e eficiente de inverter o estado de uma condição.

Portanto, o operador not é uma ferramenta poderosa para quem deseja trabalhar com expressões booleanas de maneira flexível e direta.

NOT A

True

a = True
print("resposta: ",not a)
"""
Resultado:

resposta:  False
"""

a = True

print("resposta: ",not a)

"""

Resultado:

resposta: False

"""

False

a = False
print("resposta: ",not a)
"""
Resultado:

resposta:  True
"""

a = False

print("resposta: ",not a)

"""

Resultado:

resposta: True

"""

Perceba que em NOT inverte o resultado

Referências:

Documentação Python

Livros sobre Introdução a Python da Amazon

Interno:

Quem somos