# Lógica de programação com `Python`
----
# Aula 01
## Engatinhando
---
# O que é um algoritmo
- Um algoritmo é como uma receita de bolo.
- Ele tem *entradas*, *instruções* e uma *saída*;
::: warning
É importante que essa saída ocorra em um tempo finito, caso contrário passaremos fome.
:::
---
## Bolo de caneca

----
### Ingredientes
- 1 ovo
- 2 colheres (sopa) de achocolatado em pó
- 3 colheres (sopa) rasas de açúcar
- 4 colheres (sopa) rasas de farinha de trigo
- 1 colher (sopa) de óleo
- 1 colher (café) rasa de fermento em pó
- 4 colheres (sopa) de leite
----
### Modo de preparo
- Coloque todos os ingredientes dentro de uma caneca de aproximadamente 300 ml ou mais;
- Mexa até obter uma massa homogênea;
- Leve ao micro-ondas por 3 minutos.
----
### Rendimento
- 1 porção
---
| Algoritmo | | Receita |
| --------- | -- | :----- |
| Entradas | :arrow_right: | ingredientes |
| Instruções | :arrow_right: | modo de preparo |
| Saída | :arrow_right: | :cake: |
| |
----
## :game_die: Dados
Num algoritmo, as *entradas* são os **dados** sobre os quais trabalhamos. Podem vir de
- um banco de dados
- um arquivo
- uma entrada do usuário
----
## :wrench: Instruções
Na parte das *instruções* onde dizemos para o computador o que fazer com esses dados.
- verificar se os dados são consistentes
- realizar computações com esses dados
----
## :computer: Saída
E a *saída* é o resultado do que fazemos com esses dados. Alguns exemplos:
- Mostrar os valores na tela
- Atualizar um banco de dados
- Escrever o resultado do cálculo num arquivo
---
# Mão na massa
Não precisamos instalar o `Python`, podemos rodá-lo online no site [`repl.it`](https://repl.it/languages/python3 "Python online")
---
# Saída de dados
---
## Olá mundo!
Escreva o seguinte código no arquivo `main.py` e pressione ==run ▶==
```python=
print("Olá Mundo!") # comentário
```
<span>
<!-- .element: class="fragment" data-fragment-index="1" -->
- `#` marca um comentário, e o `Python` ignora o que vem depois dele
- a função `print()` imprime o que for passado como argumento
</span>
----
### Mais sobre `print`
```python
❯❯❯ print("um", "dois", "três") # vários argumentos
um dois três
# alterando como separamos os argumentos
❯❯❯ print("um", "dois", "três", sep=", ")
um, dois, três
# \n significa uma quebra de linha
❯❯❯ print("um", "dois", "três", sep="\n")
um
dois
três
❯❯❯ print("um", "dois", "três", sep="\t", end=".\n")
um, dois, três.
```
---
# Tipos de dados
----
O `python` tem alguns tipos de dados "de fábrica"
- **Numéricos**: inteiros, ponto flutuante, complexos;
- **Texto**;
- ***Booleanos***: verdadeiro ou falso;
- **Estruturados**: listas, tuplas, dicionários, conjuntos.
---
# Operadores
----
- Matemáticos: `+`, `-`, `*`, `/`, `//`, `%`, `**`
- Lógicos: `or`, `and`, `not`
- Comparação: `==`, `<=`, `>=`, `!=`, `is`, `is not`
- Outros: `=`, `.`, `[]`, `()`
---
# Números
Podemos usar o _prompt_ como uma calculadora.
----
## Operando números 1
```python
❯❯❯ 3 + 4 # soma nos inteiros
7
❯❯❯ 3 - 4.0 # operação com ponto flutuante
-1.0
❯❯❯ (4+2j)*(5-2j) # notação para complexos
(24+2j)
❯❯❯ 4e3/2e-2 # notação cientĩfica
200000.0 # divisão sempre retorna ponto flutuante
```
----
## Operando números 2
```python
❯❯❯ 9//2 # divisão nos inteiros
4
❯❯❯ 9 % 2 # resto da divisão
1
❯❯❯ 5**2 # potênciação
20
```
----
## Comparando números
```python
❯❯❯ 4 > 3
True
❯❯❯ -1 < -2
False
❯❯❯ 0 >= 0
True
❯❯❯ 10 < 3*4
True
```
----
## Comparando números
:::danger
O operador `=` sozinho não se comporta da maneira esperada.
:::
<!-- .element: class="fragment" data-fragment-index="1" -->
```python
❯❯❯ 3 = 3
```
<!-- .element: class="fragment" data-fragment-index="2" -->
<code class="error"> File "<stdin>", line 1 </code>
<code class="error">SyntaxError: can't assign to literal </code>
<!-- .element: class="fragment" data-fragment-index="3" -->
----
## Comparando números
O símbolo para $=$ é `==` e para $\neq$ é `!=`
```python
❯❯❯ 3 == 3
True
❯❯❯ 3**2 != 3*2
True
```
---
# _Booleanos_
- A comparação entre números nos retorna os valores _booleanos_ `True` ou `False`
- Podemos combinálos com os operadores lógicos `and`, `or` e `not`
```python
❯❯❯ 3 > 4 or 2 == 1.9999999999999999999
True
❯❯❯ 3 != 4 and 2 >= 3
False
```
---
# Variáveis
- Antes de trabalhar com texto, vamos aprender a guardar as coisas
- Declarar uma variável é muito simples em `Python`
```python
❯❯❯ a = 4
❯❯❯ b = False
❯❯❯ a > 3 or b
True
```
----
:::warning
Qual será o resultado do seguinte código?
```python
❯❯❯ x = 5
❯❯❯ y = x**2
❯❯❯ x = 1
❯❯❯ y
```
>
:::
----
## Dicas
- Não economize tamanho no nome da variável: ela deve descrever bem o dado em questão.
- Nome de variável tem que começar com alguma letra, depois disso pode ter letra número e _.
- Nomes de variáveis são _case sensive_: `variavel` é diferente de `Variavel` que é diferente de `VaRiAvEl` e etc.
---
# Texto
Podemos usar aspas simples `' '` ou duplas `" "` para dizer pro `python` que estamos lidando com texto
----
## Brincando com texto
```python
❯❯❯ txt = "Olá, mundo!"
❯❯❯ nome = "Bossa"
❯❯❯ txt + nome # concatena texto
'Olá, mundo!Bossa'
❯❯❯ nome*2 # repete concatenações
'BossaBossa'
❯❯❯ txt[0:6] # acessando um pedaço do texto
'Olá, '
❯❯❯ txt[-1] # quem sabe começamos do final
'!'
❯❯❯ txt[0:6] + nome + txt[-1]
'Olá, Bossa!'
❯❯❯ len(txt) # tamanho do texto
11
```
----
## Métodos de texto 1
```python
❯❯❯ txt.lower() # tudo em minúscula
'olá, mundo!'
❯❯❯ txt.upper() # tudo em maiúscula
'OLÁ, MUNDO!'
❯❯❯ txt.swapcase() # troca a capitulação
'oLÁ, MUNDO!'
❯❯❯ txt.title() # iniciais em maiúsculas
'Olá, Mundo!'
❯❯❯ txt.replace("mundo", "Brasil") # substitui
'Olá, Brasil!' # pedaços do texto
```
----
## Métodos de texto 2
```python
❯❯❯ "Olá" in txt # será que tem esse trecho no texto?
True
❯❯❯ txt.find("mundo") # retorna a primenta posição
5
❯❯❯ txt.split(",") # quebra o texto em ,
['Olá', ' mundo!']
❯❯❯ txt.split(" ") # quebra o texto nos espaços
['Olá,', 'mundo!']
```
----
## Métodos de texto 3
```python
❯❯❯ texto1 = "O valor de x é {}."
# as chaves indicam que ali precisa ser preenchido
❯❯❯ texto1.format(42) # substitui {} por 42
'O valor de x é 42.'
❯❯❯ texto2 = "Sabemos que x = {x} e y = {y}"
# podemos nomear as variáveis para substituir
❯❯❯ texto2.format(x="valor", y=5)
'Sabemos que x = valor e y = 5'
```
----
### Detalhes 1
```python=
❯❯❯ "aspas 'simples' dentro da dupla é ok"
"aspas 'simples' dentro da dupla é ok"
❯❯❯ 'aspas "duplas" dentro de simples é ok'
'aspas "duplas" dentro de simples é ok'
❯❯❯ "aspas "duplas" dentro de duplas dá pau"
File "<stdin>", line 1
"aspas "duplas" dentro de duplas dá pau"
^
SyntaxError: invalid syntax
```
----
### Detalhes 2
- Se precisarmos escrever aspas, precisamos colocar uma barra invertida `\` antes. Esse processo é conhecido como _escapar_
```python
❯❯❯ "aspas \"duplas\" dentro de duplas precisa escapar"
'aspas "duplas" dentro de duplas precisa escapar'
❯❯❯ 'aspas \'simples\' escapadas'
"aspas 'simples' escapadas"
```
----
### Detalhes 3
```python
❯❯❯ texto = "podemos escrever o texto \
... em várias linhas usando \\, podemos \n quebrar linhas com \
... \\n e podemos dar uma \t tabulação com \\t"
❯❯❯ print(texto)
podemos escrever o texto em várias linhas usando \, podemos
quebrar linhas com \n e podemos dar uma tabulação com \t
```
----
### Detalhes 4
- Para textos longos, usamos 3 pares de aspas duplas
```python
❯❯❯ texto_longo = """Esse texto aqui é grande
e pode preencher várias linhas.
Não precisamos nos preocupar em "escapar"
aspas no meio dele. As quebras de linha são mantidas
"""
❯❯❯ print(texto_longo)
Esse texto aqui é grande
e pode preencher várias linhas.
Não precisamos nos preocupar em "escapar"
aspas no meio dele. As quebras de linha são mantidas
```
---
# Objetos
- As variáveis em `Python` são _objetos_, que podem ter _métodos_ e _propriedades_
- Acessamos um método ou propriedade de um objeto com o operador `.` ou `[]`
---
# Listas
Listas são vetores de dados, criados entre colchetes. Podem conter qualquer tipo de dados em seu interior.
----
## Criando listas
```python
❯❯❯ lista = ['a', 'b', 'c', 1, 2, 3, True]
❯❯❯ len(lista) # tamanho da lista
7
❯❯❯ lista[0] # primeiro item da lista
'a'
❯❯❯ lista[2:6] # fatia da lista
['c', 1, 2, 3]
❯❯❯ lista[0] = 'z' # alterando a primeira entrada
❯❯❯ lista
['z', 'b', 'c', 1, 2, 3, True]
```
----
## Métodos de listas 1
```python
❯❯❯ 1 in lista # verifica se o elemento
True # está na lista
❯❯❯ 'a' in lista
False
❯❯❯ del lista[4] # apaga o elemento indice 4
❯❯❯ lista
['z', 'b', 'c', 1, 3, True]
❯❯❯ lista.remove('b') # remove 'b'
❯❯❯ lista # (o primeiro que aparecer)
['z', 'c', 1, 3, True]
❯❯❯ lista.pop(1) # retorna o elemento indice 1
'c'
❯❯❯ lista # e apaga ele da lista
['z', 1, 3, True]
```
----
## Métodos de listas 2
```python
❯❯❯ lista.append('x') # adiciona o elemento 'x'
❯❯❯ lista # ao final da lista
['z', 1, 3, True, 'x']
❯❯❯ lista.insert(1, "oi") # insere na posição indicada
❯❯❯ lista
['z', 'oi', 1, 3, True, 'x']
❯❯❯ lista.reverse() # reverte a nossa lista
❯❯❯ lista
['x', True, 3, 1, 'oi', 'z']
❯❯❯ lista + ['lista', 'adicional'] # concatena listas
['x', True, 3, 1, 'oi', 'z', 'lista', 'adicional']
```
---
## _Ranges_
- Gera uma "lista" de números
- `range(n)` gera a lista $0, 1, \ldots, n-1$
```python
❯❯❯ numeros = range(10) # numeros não é uma lista
❯❯❯ list(numeros) # mas conseguimos
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # transformar em uma
```
----
## _Ranges_
- `range(i, j)` gera a lista $i, i+1, \ldots, j-1$
```python
❯❯❯ list(range(15,25))
[15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
```
- `range(i, j, k)` gera a lista $i, i+k, i+2k, \ldots$ com limite em $j-1$
```python
❯❯❯ list(range(100, 200, 30))
[100, 130, 160, 190]
```
---
# Entrada de dados
----
- O comando `input` mostra uma mensagem na tela e exige uma entrada.
- Podemos guardar essa entrada numa variável
```python
❯❯❯ entrada = input("Digite qualquer coisa: ")
Digite qualquer coisa: qualquer coisa↩
❯❯❯ entrada
'qualquer coisa'
❯❯❯ input("Digite um número:")
Digite um número:996
'996' # veja que foi retornado texto
```
----
- Podemos tentar converter o que o usuário digita em número
```python
❯❯❯ entrada = input("Digite um número inteiro: ")
Digite um número inteiro: 37↩
❯❯❯ numero = int(entrada)
❯❯❯ numero
37
```
----
<!-- .slide: data-transition="zoom-in fade-out" -->
# MAS
e <span><!-- .element: class="fragment highlight-red" -->se</span> o usuário não digitar um número inteiro?
---
# Condicionais
----
Queremos verificar se o usuário realmente inseriu um número inteiro
- Se for um número, vamos converter em tipo numérico
- Se não for um número, vamos mostrar uma mensagem de erro
----
Queremos um programa mais ou menos assim
```python=
entrada = input("Digite um número inteiro: ")
# se for inteiro
# -> converta em inteiro
# se não
# -> mostra uma mensagem
```
----
## `if .. else`
```python=
if condição:
# execute algo caso a condição seja True
else:
# execute algo caso a condição for False
```
- `condição` é qualquer expressão que tenha um valor _booleano_
:::warning
os espaços no começo da linha são necessários: eles separam os blocos de código em python
:::
----
Queremos um programa mais ou menos assim
```python=
entrada = input("Digite um número inteiro: ")
if entrada.isdigit(): # retorna True se forem digitos
numero = int(entrada) # converte em inteiro
else:
print("Você não digitou um inteiro")
```
---
<!-- .slide: data-transition="zoom-in fade-out" -->
# MAS
e se o usuário inserir um inteiro negativo?
----
## Problema
- Se você digitar `-5`, o nosso programa diz que você não digitou um número
- Isso pois o método ` isdigit ` só retorna `True` se **todos** os valores da string forem numéricos
- <span><!-- .element: class="fragment highlight-red" --> Como resolver isto?</span>
----
### Minha solução
- Verificar se o primeiro dígito é o sinal de menos
- Se for
- da pra converter o resto do texto em número?
- converter o resto
- multiplicar por -1
- se não der de converter o resto do texto
- mensagem de erro
- Se não for
- tentar fazer o que faríamos antes
----
### Minha solução
```python=
entrada = input("Digite um número inteiro: ")
if entrada[0] == "-": # será que começamos com "-"?
# se sim, vamos tentar converter o resto da entrada
resto = entrada[1:]
if resto.isdigit():
numero = -int(resto) # converte em inteiro
# multiplicando por -1
else: # não foi possível converter o resto
print("Começou com - mas o resto não era número")
else: # se o primeiro dígito não for "-"
if entrada.isdigit(): # tenta converter a entrada
numero = int(entrada)
else: # se não der, mostra mensagem de erro
print("Você não digitou um inteiro")
```
---
## `if .. elif .. else`
Note que meu código tem um trecho
```python=
else:
if condição:
# codigo
```
Esse trecho pode ser substituido por `elif`:
```python=
elif condição:
# codigo
```
:::warning
não esqueça de reduzir a _identação_
:::
----
### Código reescrito
```python=
entrada = input("Digite um número inteiro: ")
if entrada[0] == "-": # será que começamos com "-"?
# se sim, vamos tentar converter o resto da entrada
resto = entrada[1:]
if resto.isdigit():
numero = -int(resto) # converte em inteiro
# multiplicando por -1
else: # não foi possível converter o resto
print("Começou com - mas o resto não era número")
elif entrada.isdigit():
# se o primeiro dígito não for "-" mas dá pra converter
numero = int(entrada) # converte
else: # se não der, mostra mensagem de erro
print("Você não digitou um inteiro")
```
---
# Problemas
----
A [sala de aula](https://repl.it/community/classrooms/150657) no repl.it contém os exercícios
- Aula01Problema01
- Aula01Problema02
- Aula01Problema03
que devem ser resolvidos e enviados para correção.
---
# Fim Aula 01
> In reality, programming languages are how programmers express and communicate _ideas_ — and the audience for those ideas is other programmers, not computers.
> [name=Guido van Rossum]
{"breaks":"true","metaMigratedAt":"2023-06-14T23:50:00.601Z","metaMigratedFrom":"YAML","title":"Lógica de programação 1","description":"Minicurso de lógica de programação.","slideOptions":"{\"theme\":\"blood\",\"transition\":\"none\"}"}