Lógica de programação 1

# 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 ![image alt](https://img.itdg.com.br/tdg/images/recipes/000/060/429/280773/280773_original.jpg?mode=crop&width=710&height=400 "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 ```  - `#` marca um comentário, e o `Python` ignora o que vem depois dele - a função `print()` imprime o que for passado como argumento ---- ### 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. :::  ```python ❯❯❯ 3 = 3 ```  <code class="error">   File "<stdin>", line 1 </code> <code class="error">SyntaxError: can't assign to literal </code>  ---- ## 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 ``` ----  # MAS e se 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") ``` ---  # 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 -  Como resolver isto? ---- ### 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]