Python: Conceitos e Palavras Reservadas
Tags: python, tutorial, programming
Published: 2023-05-12 20:50:23

[Post anterior](https://dev.to/iugstav/python-tipos-29a2)

As linguagens de programação precisam de instruções sintaticamente corretas para serem executadas e assim criar um programa funcional. Em Python não seria diferente, até porque ainda não existe programação com a mente, né, então precisamos escrever o código. Mas que tipos de instruções são essas?

Python é uma linguagem extremamente simples, com poucas palavras reservadas e mesmo assim tem um impacto absurdo em todas as áreas que ela atinge. O alto nível de abstração propõe um modelo de fácil escrita e compreensão até para leigos (cof, cof) e é por isso que é tão bem-quista pelos programadores. Passeando pelas instruções da linguagem, temos:

## Fluxos de Controle

Nós vimos um exemplo de fluxo de controle no último material, na parte de tipos de dados predefinidos, mas aqui veremos como essa instrução se comporta.

Quando estamos planejando uma ação, pensamos num caminho linear a ser seguido. No entanto, um só caminho não é o suficiente, pois talvez se torne necessário mudar a forma como as coisas funcionam. Por exemplo, você deve mandar “Bom dia”, “Boa tarde” ou “Boa noite” no grupo da família? Não sei, depende do horário. Aí que entram as estruturas de controle.

### A Instrução `if`

Esse pedaço de comando serve para avaliar se uma condição é verdadeira. Se for, ele executará um fluxo alternativo de código. Se não, ele processará outro bloco de controle `else` ou seguirá com a linearidade do código. A instrução `else` é opcional.

Por exemplo, observe o código abaixo:

```python
# número a ser adivinhado
numero_secreto = 13

# número digitado pelo usuáriopython
input_usuario = int(input("Digite o seu número: "))

# instrução if
if input_usuario == numero_secreto:
    # começo do fluxo alternativo
    print("Que isso, hein! Acertou!")

else:
    # bloco else de condição não atendida
    print("Eita! Tá errado.")
```

E o output é:

```shell
$> python3 <nome_do_arquivo>.py
Digite o seu número: 20
Eita! Tá errado.

$> python3 <nome_do_arquivo>.py
Digite o seu número: 13
Que isso, hein! Acertou!
```

O programa acima consiste num código de adivinhação. Nele, criamos a variável `numero_secreto` para armazenar o nosso número a ser achado 13 e, logo em seguida, perguntamos o usuário qual número ele deseja tentar a sorte. Então, criamos uma estrutura de controle cuja condição verifica se o número digitado pelo usuário corresponde com o número armazenado em `numero_secreto`. Se sim, então ele escreve uma mensagem e se não, escreve outra. Mas ainda está muito simples… Que tal encadearmos mais condições para verificar se o número é maior ou menor?

Tal requerimento pode ser feito com a instrução `elif`, que encadeia blocos condicionais de código após um `if`.

```python
# número a ser adivinhado
numero_secreto = 29

# número digitado pelo usuário
input_usuario = int(input("Digite o seu número: "))

# instrução if
if input_usuario == numero_secreto:
    # começo do fluxo alternativo
    print("Que isso, hein! Acertou!")

elif input_usuario < numero_secreto:
    print("Chutou baixo! Aumenta esse valor aí.")

elif input_usuario > numero_secreto:
    print("Muito alto, colega. De novo!!")
```

E agora no output temos:

```shell
$> python3 <nome_do_arquivo>.py
Digite o seu número: 20
Chutou baixo! Aumenta esse valor aí.

$> python3 <nome_do_arquivo>.py
Digite o seu número: 54
Muito alto, colega. De novo!!
```

Assim, criamos uma estrutura de controle completamente funcional. Ainda podemos combinar Álgebra Booleana com os blocos `if` para criar instruções encadeadas com as palavras reservadas `or` e `and`.

## Estruturas de repetição

### A Instrução `while`

Essa instrução nos permite executar repeticamente um bloco de código enquanto a condição inicial dele for verdadeira. Podemos chamar a instrução while *loop*. A sintaxe deste loop pode ser resumida como:

```python
while <condicao>:
		#bloco de código a ser repetido
```

Olhando o exemplo da instrução `if`, eu gostaria que esse programa rodasse até que o usuário adivinhasse o número. Para isso, podemos implementar a estrutura de repetição `while` e, quando o usuário acertar o número secreto, negar a condição inicial, como no código abaixo:

```python
# número a ser adivinhado
numero_secreto = 13
esta_rodando = True

while esta_rodando == True:
    # número digitado pelo usuário
    input_usuario = int(input("Digite o seu número: "))

    # instrução if
    if input_usuario == numero_secreto:
        # começo do fluxo alternativo
        print("Que isso, hein! Acertou!")
        esta_rodando = False

    elif input_usuario < numero_secreto:
        print("Chutou baixo! Aumenta esse valor aí.")

    elif input_usuario > numero_secreto:
        print("Muito alto, colega. De novo!!")

print("Acabou o jogo")
```

E o novo output:

```shell
Digite o seu número: 10
Chutou baixo! Aumenta esse valor aí.
Digite o seu número: 15
Muito alto, colega. De novo!!
Digite o seu número: 13
Que isso, hein! Acertou!
Acabou o jogo
```

Até acertarmos o número, o código estava rodando *loop*, executando o mesmo bloco de processamento. Quando acertamos, o bloco de código referente ao `if` de acerto executado, o resto do código foi lido e, logo no próximo loop, a condição foi negada.

### A Instrução `for..in`

A estrutura de repetição `for..in` é outra instrução de *loop*, mas em vez de rodar até uma condição ser negada, ela roda dentro de um intervalo de números inteiros. Com o intervalo estabelecido, o bloco de processamento declarado dentro do `for` se repete até que o fim do intervalo seja alcançado.

 Para criar um intervalo sem valores predefinidos, temos a função `range()` que recebe dois parâmetros: o começo do intervalo e o seu fim, ambos inteiros. A função pode, ainda, receber somente um parâmetro, que é o fim do intervalo. Nesse caso, a função começaria a contar do primeiro valor possível até o fim passado. O intervalo gerado pela função range é *exclusivo*, ou seja, ele conta o fim do intervalo - 1. 

Chamamos essa ato de percorrer um intervalo finito de *iteração*. Portanto, *loop* `for..in` itera sobre um intervalo. Segue um exemplo dessa repetição abaixo:

```python
resultado = 0

# declaração do loop
for numero in range(1, 10):
    resultado += numero

print(resultado)
```

E o output:

```shell
$> python3 <nome_do_arquivo>.py
45
```

Além de intervalos gerados, podemos utilizar listas de inteiros ou até strings. Mas como vamos iterar sobre strings se uma string não é um intervalo de números? É aí que tá a brincadeira.

As strings em python são listas de caracteres, logo ela tem uma posição inicial e uma final, isto é, um intervalo. A partir daí o que Python implicitamente faz é acessar a posição da string referente ao número do intervalo. Vejamos um exemplo disso abaixo:

```python
mensagem = "Olá Mundo!"

for letra in mensagem:
    print(letra)
```

No caso acima, `mengasem` é interpretada como um range da posição 0 até o tamanho da string e `letra` se torna o elemento da lista na posição correspondente ao número do range. Por exemplo, se `mensagem` criasse o intervalo [0, 5]  e eu estivesse no momento 3 do intervalo, `letra` seria `mensagem[3]`.

### A Instrução `break`

A instrução `break` é usada para sair de uma estrutura de repetição no meio de sua execução, mesmo se o intervalo não foi finalizado ou a condição não foi negada.

### A Instrução `continue`

A instrução `continue` é usada para pular o resto das instruções restantes de um *loop* e pular para a próxima iteração do mesmo.

Aqui, terminamos o básico sobre instruções em Python e começamos a utilizar os conceitos apresentados para formar scripts de grande impacto. Condições e iterações são só o dedo mindinho do que a linguagem oferece. Um passo de cada vez até a elegância.

[Próximo post](https://dev.to/iugstav/python-funcoes-4dni)