# Lógica de programação com `Python`
----
# Aula 02
## Caminhando
---
# Iterando com `for`
----
- Em `python` podemos iterar sobre os elementos de uma lista usando o laço `for`
```python
❯❯❯ lista = ['oi', 1, 2.0, 3+4j, ['a', 0]]
❯❯❯ for elemento in lista:
... print(type(elemento), elemento, sep=":\t")
...
<class 'str'>: oi
<class 'int'>: 1
<class 'float'>: 2.0
<class 'complex'>: (3+4j)
<class 'list'>: ['a', 0]
```
----
## `for` num `range`
```python
❯❯❯ for n in range(10):
... print(n**n)
...
1
1
4
27
256
3125
46656
823543
16777216
387420489
```
----
## `for` num texto
```python=
for letra in "percorrendo um texto":
print(letra.upper(), end=" ")
```
----
## `for` com `enumerate`
```python
❯❯❯ lista = "algumas palavras separadas por espaços".split()
❯❯❯ for i, word in enumerate(lista):
... print("{}a palavra: {}".format(i,word))
...
0a palavra: algumas
1a palavra: palavras
2a palavra: separadas
3a palavra: por
4a palavra: espaços
```
----
## `for` dentro de `for`
O código
```python=
# produto cartesiano de conjuntos
for i in range(3):
for j in range(3):
print(i,j)
```
Tem como saída
```
0 0
0 1
0 2
1 0
1 1
1 2
2 0
2 1
2 2
```
----
## `for`: cláusula `break`
- O comando `break` quebra a execução de um `for`
```python=
lista = [1, 2, 4, "texto", 6]
for x in lista:
if type(x)==str: # se o tipo da variavel for texto
print("encontrado texto")
break
print(x)
```
----
## `for`: cláusula `else`
- Quando temos um bloco com `for` e `else`, a parte do `else` é executada ao final da lista se nenhum `break` ocorrer
```python=
lista = [1, 2, 4, 5, 6]
for x in lista:
if type(x)==str: # se o tipo da variavel for texto
print("encontrado texto")
break
print(x)
else:
print("terminou o loop sem break")
```
----
## `for`: cláusula `continue`
- O comando `continue` passa para a próxima iteração do loop for
```python=
lista = [1, 2, "oi", 4, 5, "tchau", 6]
for x in lista:
if type(x)==str: # se for tipo texto
print("texto encontrado: "+x) # imprime mensagem
continue # passa pro próximo item
print(x**2)
```
---
# Exercícios `for`
----
## Exercício 00
### Listando os tipos das variáveis
:::info
Escreva um algoritmo percorra uma lista e imprima o tipo das variáveis dela
:::
----
### Solução
```python=
lista = [1, 2.0, 3j, "4", [5,6]]
for elemento in lista:
print("O elemento", elemento, "é do tipo", type(elemento))
```
<!-- .element: class="fragment" data-fragment-index="1" -->
----
## Exercício 01
### Divisores de um número
:::info
Escreva um algoritmo que tem como entrada um inteiro e tem como saída uma lista dos seus divisores
:::
----
### Solução
```python=
numero = input("Digite um inteiro: ")
divisores = []
n = int(numero)
for d in range(1,n+1): # 1, 2, ..., n
if n % d == 0: # se d divide n (resto 0)
divisores.append(d) # adiciona a lista de divisores
mensagem = "Lista dos divisores de {n}: {lista}"
print(mensagem.format(n=numero, lista=divisores))
```
<!-- .element: class="fragment" data-fragment-index="1" -->
----
## Exercício 02
### Separando uma lista
:::info
Escreva um algoritmo que tenha como entrada uma lista qualquer contendo números e texto, e separe em duas listas: uma só com os números e outra só com texto.
:::
----
## Exercício 03
### Contando caracteres
:::info
Escreva um algoritmo que tenha como entrada um texto e como saída o número de caracteres que ele possui, sem incluir espaços.
:::
----
### Solução
```python=
texto = """Vamos digitar um texto bem grande.
Para fins de contar os caracteres, e rever o que já aprendemos.
"""
sem_espaços = texto.replace(" ","")
quantidade_caracteres = len(sem_espaços)
mensagem = "O texto tem {} caracteres"
print(mensagem.format(quantidade_caracteres))
```
<!-- .element: class="fragment" data-fragment-index="1" -->
----
## Exercício 04
### Verificar primalidade
:::info
Escreva um algoritmo que tem como entrada um inteiro $n$ e tem como saída uma mensagem dizendo se o número é primo ou não
:::
----
### Solução
```python=
numero = input("Digite um inteiro: ")
n = int(numero)
primo = True
for d in range(2,n): # d em 2, ..., x
if n % d == 0: # se d divide x
primo = False # x não é primo
break
if primo:
print(n, "é um número primo")
else:
print(n, "não é um número primo")
```
<!-- .element: class="fragment" data-fragment-index="1" -->
----
## Exercício 05
### Listar primos
:::info
Escreva um algoritmo que implemente o _Crivo de Eratóstenes_: a entrada é um inteiro $n$, e a saída é uma lista com os primos até $n$.
:::
----
### Solução
```python=
# vamos gerar a lista de primos até n
numero = input("Digite um inteiro: ")
primos = []
n = int(numero)
for x in range(2,n+1): # x em 2, 3, ..., n
for d in range(2,x): # d em 2, ..., x
if x % d == 0: # se d divide x
break # quebra o loop
else: # executa quando não ocorre o break
primos.append(x) # adiciona x a lista
mensagem = "Lista dos primos até de {n}: {lista}"
print(mensagem.format(n=numero, lista=primos))
```
<!-- .element: class="fragment" data-fragment-index="1" -->
---
# Iterando com `while`
----
* O laço `while` será executado sempre que uma condição for verdadeira
```python=
senha = ""
while senha!="1234":
# esses comandos serão executados
# enquando condição for True
print("Senha incorreta!")
senha = input("Digite a senha: ")
```
----
## `while`: cláusula `else`
* Se o bloco `while` apresentar uma cláusula `else`, ela é executada quando a condição for `False`
```python=
senha = ""
while senha!="1234":
# esses comandos serão executados
# enquando condição for True
print("Senha incorreta!")
senha = input("Digite a senha: ")
else:
print("Senha correta!")
```
----
## Exemplo de loop
Podemos criar um laço com `while` bem similar com o que fazemos com `for` e `range`
```python=
i = 0 # inicia com zero
while i < 10: # enquanto for menor que 10
print(i) # imprime o i
i = i + 1 # adiciona 1
```
---
# Exercício `while`
----
- Imagine um algoritmo que mostra uma mensagem `"Entre com a 1a nota: "` e pede que o usuário entre uma nota
- Enquanto o usuário não entrar com a palavra `"fim"`, ele vai mostrando as mensagens `"Entre com a 2a nota: "` etc
- Quando o usuário entra a palavra `"fim"`, o algoritmo responde com a média das notas
----
(uma) solução
```python=
quantidade = 1
mensagem = "Entre com a {}a nota: "
soma_notas = 0
entrada = input(mensagem.format(quantidade))
while entrada != "fim":
soma_notas = soma_notas + float(entrada)
quantidade = quantidade + 1
entrada = input(mensagem.format(quantidade))
media = soma_notas/quantidade
print("Sua média foi", media)
```
---
# Operadores de atribuição
- Quando escrevemos `x=5`, estamos atribuindo o valor 5 à variável `x`.
- Podemos mudar o valor ao valor atual de `x` usando os _operadores de atribuição_ `+=`, `-=`, `/=`, `*=`, `**=`
----
## Atribuição
```python
❯❯❯ x = 4 # coloca o valor 4
❯❯❯ x
4
❯❯❯ x += 1 # adiciona 1
❯❯❯ x
5
❯❯❯ x -= 2 # subtrai 2
❯❯❯ x
3
❯❯❯ x /= 6 # divide por 6
❯❯❯ x
0.5
❯❯❯ x **= 2 # eleva ao quadrado
❯❯❯ x
0.25
```
----
- Podemos modificar nosso algoritmo anterior para
```python=
quantidade = 1
mensagem = "Entre com a {}a nota: "
soma_notas = 0
entrada = input(mensagem.format(quantidade))
while entrada != "fim":
soma_notas += float(entrada)
quantidade += 1
entrada = input(mensagem.format(quantidade))
media = soma_notas/quantidade
print("Sua média foi", media)
```
----
## Atribuição múltipla
```python
❯❯❯ x, y = 0, 1 # x = 0, y = 1
❯❯❯ while y < 100: # enquanto y < 100
... x, y = y, x + y
... print(x) # sequencia de Fibonacci
...
1
1
2
3
5
8
13
21
34
55
89
```
----
## Atribuição condicional
Podemos decidir o valor de uma variável com base em uma condição
```python
❯❯❯ x = 5
❯❯❯ y = "condição verdadeira" if x > 5 else "condição falsa"
❯❯❯ y
'condição falsa'
❯❯❯ z = 20 if type(y)==str else -20
❯❯❯ z
20
```
---
# Funções
- Podemos agrupar nossos comandos em blocos chamados _funções_
- Assim como em matemática, funções tem _argumentos_ e retornam _valores_
----
## Sintaxe
```python
def nome_da_funcao(argumento1, argumento2):
# aqui vai a sequencia de passos
# que é executada na função
return resultado
```
----
## Exemplo 1
- Podemos transformar o algoritmo que diz se um número é primo em uma função
```python=
def sera_que_eh_primo(n):
primo = True # começamos assumindo que é primo
# e verificamos se é composto
for d in range(2,n): # d em 2, ..., n
if n % d == 0: # se d divide n
primo = False # n não é primo
break
return primo # retorna valor booleano
print( sera_que_eh_primo(54),
sera_que_eh_primo(37) )
```
----
## Exemplo 2
- Podemos transformar o algoritmo que lista os primos até $n$ em uma função, que irá usar a função `sera_que_eh_primo`
```python=+
def listar_primos(n):
primos = []
for x in range(2,n+1): # para x em 2, 3, ..., n
if sera_que_eh_primo(x): # se x for primo
primos.append(x) # adiciona x a lista
return primos
print(listar_primos(50))
```
----
## Exemplo 3: Recursão
- Vamos criar uma função que retorna o fatorial de um número:
```python=+
def fatorial(n):
if n == 0: # por definição
return 1 # 0! = 1
else:
return n*fatorial(n-1)
# lembrando que n! = n*(n-1)!
print(fatorial(5))
```
----
## Argumentos com valores padrão
```python=
def saudacao(nome, sobrenome = "Padrão"):
mensagem = "Olá, {} {}!"
print(mensagem.format(nome, sobrenome))
# Chamando a função sem o argumento opicional
saudacao("Fulano")
# Chamando a função com os dois argumentos
saudacao("Fulano", "da Silva")
# Nomeando os argumentos
saudacao(sobrenome="Souza", nome="Ciclano")
# Esquecendo um argumento obrigatório
saudacao()
```
----
## Múltiplos argumentos
```python=
def listadeitens(nome, *itens):
mensagem = "Olá, {}. Temos"
print(mensagem.format(nome), end=" ")
for x in itens:
print(x, end=", ")
print("\n", "-"*15)
# Chamando a função só com 1 argumento
listadeitens("Fulano")
# Chamando a função com argumentos
listadeitens("Fulano", "a", "b", "c")
lista = [1, 2, 3, 4]
# Passando uma lista como argumento
listadeitens("Ciclano", lista)
# O * na frente da lista expande ela
listadeitens("Beltrano", *lista)
```
----
## Salvando e importando
- Se salvarmos a nossa função no arquivo `main.py` podemos importá-la para o terminal
```python
❯❯❯ from main import primos
❯❯❯ primos(50)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
```
---
# Exercícios função
----
## Exercício 01
- Crie uma função que tem como entrada uma lista de números e retorna o maior deles
```python=
def maximo(lista):
# podemos começar assumindo que o
# máximo é o primeiro elemento
maximus = lista[0]
for x in lista:
# vamos percorrer a lista e
if x > maximus:
# se acharmos alguém maior
maximus = x
# atualizamos o máximo
return maximus
```
<!-- .element: class="fragment" data-fragment-index="1" -->
----
## Exercício 02
- Crie uma função que tem como entrada uma lista de números e retorne a média deles
```python=
def media(lista):
# começa com a soma zerada
soma = 0
for x in lista:
# e vai somando os elementos da lista
soma += x
media = soma/len(lista)
# a média é só a soma dividida pelo número
# de elementos - que é dado por `len`
return media
```
<!-- .element: class="fragment" data-fragment-index="1" -->
----
## Exercício 03
- Crie uma função que tem como entrada uma lista qualquer e retorne a soma de todos os _números_ dessa lista, ignorando os demais valores.
```python=
def soma_numeros(lista):
# começa com a soma zerada
soma = 0
for x in lista:
# vamos percorrer a nossa lista
if type(x) in (int, float, complex):
# se o elemento tiver um tipo numérico
soma += x
# adicionamos ele a soma
return soma
```
<!-- .element: class="fragment" data-fragment-index="1" -->
---
# Módulos
----
## Módulos
- O `python` já vem com uma biblioteca de funções prontas, chamadas _módulos_ ou _packages_
- Podemos consultar a Biblioteca Padrão em [docs.python.org/3/library](https://docs.python.org/3/library/)
---
## Alguns módulos padrão
- `math`: contém funções matemáticas
- `time`, `date` e `datetime`: para lidar com tempo e datas
- `os` e `shutil`: trabalham com criação de arquivos e diretórios
- `urllib`: para trabalhar com URLs
---
## Maneiras de importar
```python
❯❯❯ from math import sin, cos
# importa as funções sin e cos do módulo math
❯❯❯ sin(0)
0.0
❯❯❯ cos(0)
1.0
❯❯❯ import time # importa o módulo time
❯❯❯ time.sleep(10)
❯❯❯ import datetime as dt
# importa o módulo datetime com o nome dt
❯❯❯ hoje = dt.date.today()
❯❯❯ print(hoje)
2019-09-10
```
---
## Exemplos de uso dos módulos
----
#### Download de arquivo
```python=!
# Vamos baixar um arquivo com dados
from urllib.request import urlretrieve
url = "https://sistemas.furg.br/sistemas/dados_abertos/arquivos/sae-r-u.csv"
# link encontrado na pagina do dados.gov.br
arquivo = "./refeicoes-furg.csv"
# vamos salvar na pasta local com o nome
# refeicoes-furg.csv
urlretrieve(url, arquivo)
```
----
#### Enviando email
```python=
import smtplib
from email.mime.text import MIMEText
# conexão com os servidores da UFSC
smtp_ssl_host = 'smtp.ufsc.br'
smtp_ssl_port = 465
# username ou email para logar no servidor
username = 'l.f.bossa@ufsc.br'
password = '<aqui vai a sua senha>'
# de qual endereço vou enviar
from_addr = "Bossa <%s>" % username
# lista de endereços para os quais
# vou enviar
to_addrs = ['LABMAC <labmac.bnu@contato.ufsc.br>']
# a biblioteca email possuí vários templates
# para diferentes formatos de mensagem
# neste caso usaremos MIMEText para enviar
# somente texto
message = MIMEText('Aqui vai o corpo do e-mail')
message['subject'] = 'Aqui vai o assunto'
message['from'] = from_addr
message['to'] = ', '.join(to_addrs)
# conectaremos de forma segura usando SSL
server = smtplib.SMTP_SSL(smtp_ssl_host, smtp_ssl_port)
# para interagir com um servidor externo precisaremos
# fazer login nele
server.login(username, password)
# enviamos o email
server.sendmail(from_addr, to_addrs, message.as_string())
# e fechamos a conexão
server.quit()
```
----
#### Organizando uma pasta
```python=
import glob
import os
CAMINHO = "./tmp"
# mudando para a pasta que queremos limpar
os.chdir(CAMINHO)
# listando todos os arquivos
arquivos = glob.glob("*.*")
# vamos pegar todas as extensões
extensoes = set([ fl.split(".")[-1] # separa o . e pega o ultimo termo
for fl in arquivos ])
# vamos criar as pastas com as extensões
for ext in extensoes:
os.makedirs("./%s" % ext, exist_ok=True)
# se a pasta já existe, a opção exist_ok=True evita erros
# agora vamos mover os arquivos
for arq in arquivos:
ext = arq.split(".")[-1]
os.rename(arq, "./%s/%s" % (ext, arq))
```
----
#### Criando uma planilha
```python=
import openpyxl
# módulo para trabalhar com arquivos do excel
wb = openpyxl.Workbook() # cria um workbook
ws = wb.active # ativa a planilha de trabalho
ws.title = "PlanilhadoBossa"
# renomeamos a planilha
# vamos colocar alguns dados
ws["A1"] = "Data"
ws["A2"] = "Descriçao"
ws["A3"] = "Valor"
ws["B1"] = "2019-11-07"
ws["B2"] = "Festinha"
ws["B3"] = 25
# vamos salvar
wb.save("Exemplo.xlsx")
```
---
## Módulos extra
São módulos que podem ser instalados
- `NumPy`: módulo de computação científica
- `SymPy`: módulo de matemática simbólica
- `pandas`: módulo de análise de dados
- `matplotlib`: módulo de criação de gráficos de alta qualidade
---
# Problemas
----
A [sala de aula](https://repl.it/community/classrooms/150657) no repl.it contém os exercícios
- Aula02Problema01
- Aula02Problema02
- Aula02Problema03
que devem ser resolvidos e enviados para correção.
---
# Fim Aula 02
{"metaMigratedAt":"2023-06-14T23:56:03.521Z","metaMigratedFrom":"YAML","title":"Lógica de programação 2","breaks":"true","description":"Minicurso de lógica de programação.","slideOptions":"{\"theme\":\"blood\",\"transition\":\"none\"}"}