A estrutura de repetição while (enquanto) realiza um teste lógico no início do loop, e cada vez que o teste retornar verdadeiro, os comandos associados ao laço são executados. Se retornar falso, o laço é encerrado e o processamento volta para o fluxo principal do programa.
Vamos supor novamente o personagem de videogame da aula anterior, mas dessa vez não sabemos quantos passos ele terá que fazer para pegar a maçã. Nesse mesmo "chão" tem alguns buracos aleatórios no lugar de algumas plataformas, aí colocaremos também moedas em algumas plataformas, nesse caso, usamos um condicional if dentro do while (não esqueça da indentação).
O mesmo exemplo usado em for antes, faremos em while, assim:
c = 1
while c < 10:
print(c)
c += 1
Como visto, podemos usar o while quando sabemos o limite também, mas isso não faz ele mais rápido que o for (e o for usaria menos linhas). Mas quando não sabemos o limite, só dá pra usar o while.
O exemplo abaixo, só é possível com while:
n = 1
while n != 0:
n = int(input("Digite um valor: "))
print("Parou!")
Outro exemplo:
r = "S"
while r == "S":
n = int(input("Digite um valor: "))
r = str(input("Quer continuar? [S/N] ")).upper()
print("Parou!")
Dependerá muito da situação se usaremos for ou while.
Outro exemplo:
n = 1
par = impar = 0
while n != 0:
n = int(input("Digite um valor: "))
if n != 0:
if n % 2 == 0:
par += 1
else:
impar += 1
print("Você digitou {} números pares e {} números ímpares.".format(par, impar))
Lembrando do personagem de videogame da aula anterior, que não sabia quantos passos ele teria que dar para pegar a maçã. Nesse mesmo "chão" tinha alguns buracos aleatórios no lugar de algumas plataformas, e também tinha moedas para pegar. Só que nesse exemplo, ao invés de maçãs, teria uma plataforma flutuando com um troféu, que significaria o fim do jogo por ser o prêmio do vencedor, no caso ele pularia, pegaria o troféu e pararia (para não cair do buraco). Para isso, usamos a opção break.
O break é usado para interromper um laço while, que pode durar pra sempre, dependendo da condição do mesmo.
Veja um exemplo de laço while infinito:
cont = 1
while True:
print(cont, "→ ", end="")
print("Acabou")
Outro exemplo, com uma flag de parada:
n = s = 0
while n != 999:
n = int(input("Digite um número: "))
s += n
print("A soma vale {}".format(s))
No exemplo acima, a flag de parada é o número 999. Mas nesse caso, o 999 não deve ser considerado, e subtrair o número a flag (999) é um tremenda gambiarra, nesse caso que utilizamos o break.
Para isso, utilizaremos um while infinito, com a condição true, e dentro, um if com o break, assim:
n = s = 0
while True:
n = int(input("Digite um número: "))
if n == 999:
break
s += n
print("A soma vale {}".format(s))
Existe também em Python, o continue, menos usado, que apenas ignora o código e reinicia a execução:
num = 0
while num < 30:
num += 1
if num % 2 == 0:
continue
print("Nº {}.".format(num))
PS: No Python 3.6 e superiores, usamos as fstrings, assim, apenas colocando um f antes das aspas, ao invés o format:
print(f"A soma vale {s}")
Outro exemplo:
nome = "José"
idade = 33
salario = 987.3
print(f"O {nome} tem {idade} anos e ganha R$ {salario:.2f}.")
As formatações também funcionam normalmente, como visto acima.
Em Python, assim como em qualquer linguagem, a variável é um espaço na memória, por exemplo:
lanche = "hambúrguer"
print(lanche)
Ou seja, no caso acima, a string "hambúrguer" ocupa um determinado espaço da memória, se atribuirmos abaixo novamente a variável lanche com o suco, esta última substituirá o espaço que antes era do hambúrguer, podemos até testar com o print assim:
lanche = "hambúrguer"
lanche = "suco"
print(lanche)
Mas tem os casos que queremos ter mais de um espaço na mesma variável, vamos supor que no exemplo, queremos uma variável com o nome lanche com quatro espaços, para hambúrguer, suco, pizza e pudim, pra um lanche completo. Nesse caso utilizamos as tuplas (de forma semelhante aos vetores em outras linguagens).
Só pra entender, as variáveis comuns, que só cabem um valor, são chamadas de variáveis simples. As tuplas, listas e etc., que podem guardar mais de um valor, são chamadas de variáveis compostas.
Veja um exemplo de uso de tuplas em Python:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
PS: Em muitos exercícios das aulas anteriores, podíamos ter utilizado as tuplas.
Para acessar as tuplas, usamos índices contados a partir do zero, no caso, a tupla lanche tem quatro elementos ordenados de 0 a 3.
PS: As strings no Python também são variáveis compostas, uma palavra como "Café" é uma lista onde cada letra ocupa um índice, onde no 0 está o "C", no 1 está o "a" e assim por diante, por isso é possível manipular strings em operações como fatiamento.
Se colocarmos uma variável composta no print, ele vai mostrar todas os dados dele assim:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
print(lanche)
Mas para exibir um elemento específico, usamos o índice entre colchetes assim:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
print(lanche[2])
E podemos também fazer o fatiamento, onde ele mostra apenas parte dos elementos da tupla, assim:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
print(lanche[0:2])
PS: No caso acima, ele não mostrará o elemento 2, e sim parará nesse elemento, no caso ele exibe os elementos 0 e 1 (hambúrguer e suco).
Temos também outros tipos de fatiamento assim:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
print(lanche[1:]) # Mostra do elemento 1 até o final
print(lanche[-1]) # Mostra o último elemento, se for -2 é o penúltimo e etc.
Temos também o len que lê a quantidade de espaços de uma tupla:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
print(len(lanche))
E para lermos todos os elementos, usamos um laço for dessa forma:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
for i in lanche: # Isso é como um for iterator
print(i)
PS: No caso acima, não usamos o range, apenas o nome da tupla e consequentemente, usamos apenas a variável i dele, isso é o uso do for com iterador, usado apenas em vetores e equivalentes.
Lembrando que as tuplas são imutáveis, ou seja, não podemos substituir ou remover um índice de uma tupla.
Basicamente, para definir uma tupla, usamos os parênteses, para listas os colchetes e para dicionários as chaves.
As tuplas, mesmo não utilizando parênteses, o Python 3.6 reconhece como tuplas, veja o uso sem parênteses, assim:
lanche = "hambúrguer", "suco", "pizza", "pudim"
No caso da exibição, os índices sempre são exibidos com colchetes, por exemplo:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
print(lanche[-2])
print(lanche[1:3])
print(lanche[:2])
Se tentarmos substituir algum índice, dará erro:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
lanche[1] = "refrigerante" # Dará erro
E usando um for iterator assim:
lanche = ("hambúrguer", "suco", "pizza", "pudim")
for i in lanche:
print(f"Eu vou comer {i}")
print("Comi pra caramba!")
Podemos adicionar ou alterar elementos nas tuplas, mas só na inicialização, por exemplo:
lanche = ("hambúrguer", "suco", "pizza", "pudim", "batata-frita")
for i in lanche:
print(f"Eu vou comer {i}")
print("Comi pra caramba!")
Podemos usar também o len num for comum e os índices, assim:
lanche = ("hambúrguer", "suco", "pizza", "pudim", "batata-frita")
for i in range(0, len(lanche)):
print(f"Eu vou comer {lanche[i]}")
print("Comi pra caramba!")
PS: Lembrando que o range ignora o último elemento, mas no caso de usar len não faz diferença, já que ele conta a quantidade de elementos (no caso 5), e não os índices (no caso de 0 a 4), por isso são exibidos até o 4 e não é preciso fazer outras alterações, pode ser exibido assim também:
for i in range(0, 5):
print(f"Eu vou comer {lanche[i]}")
Podemos também usar o enumerate, que exibe o elemento e a posição assim:
for p, c in enumerate(lanche):
print(f"Eu vou comer {c} na posição {p}")
Podemos exibir ele em ordem, usando o método sorted assim:
print(sorted(lanche))
print(lanche)
PS: Como visto acima, o sorted não altera a tupla, por ser imutável, apenas faz uma exibição em ordem numa lista.
Podemos unir uma ou mais tuplas assim:
a = (2, 5, 4)
b = (5, 8, 1, 2)
c = a + b
print(c)
No caso acima, ele criou uma terceira tupla com os elementos das duas primeiras.
E normalmente, podemos utilizar outros elementos assim:
print(len(c))
print(c.count(5))
print(c.index(2))
print(c.index(2, 1)) # Aqui não mostra a 1ª posição que se encontra o 2 e mostra a seguinte
O método count, só lembrando, ele conta quantas vezes determinado elemento aparece numa variável composta. O index mostra a posição da primeira ocorrência do elemento.
Diferente dos vetores em linguagens como Java e C, as tuplas podem ter dados de tipos diferentes dentro delas, por exemplo:
pessoa = ("Sérgio", 45, "M", 78.9)
Não podemos deletar ou alterar um elemento da tupla, mas podemos deletar ela toda usando o método del, assim:
del(pessoa)
PS: O método del pode ser utilizado para deletar qualquer elemento do Python.
Podemos também usar o tuple() para criar tuplas, e usar um range() para preencher ela, assim:
valores = tuple(range(4, 11)) # Preenche a tupla com valores de 4 até 10, não confunda com as posições
print(valores)