Lógica de programação 2

# 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)) ```  ---- ## 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)) ```  ---- ## 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)) ```  ---- ## 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") ```  ---- ## 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)) ```  --- # 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 ```  ---- ## 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 ```  ---- ## 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 ```  --- # 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