DEV Community: Joao Carlos Sousa do Vale

Comandos básicos GIT e vídeo de uso no JetBrains

Joao Carlos Sousa do Vale — Thu, 01 Jun 2023 20:59:34 +0000

Conteúdo

Introdução
Instalando o GIT
Cenário de estudo
Comando - git init
Comando - git status
Comando - git add
Comando - git commit
Comando - git log
Comando - git diff
Comando - git branch
Comando - git merge
Comando - git clone
Comando - git pull
Comando - git push
Linkedin

Vídeo - Git e Github sem linhas de comando

Introdução

Independente da linguagem de programação que você domina (ex. Java, C#, .NET, Python, Kotlin, Javascript, etc) ou de seu perfil na área de TI como backend, frontend, fullstack, devops, entre outros perfis; cedo ou tarde o GIT fará parte de sua vida profissional.

De acordo com o site oficial:

Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

Em resumo, um sistema de controle de versões distribuído aplicável a projetos de qualquer tamanho. Mas o que é um sistema de controle de versões? Ora, com o GIT conseguimos gerenciar as alterações feitas em nosso código, controlando o que foi alterado, por quem foi alterado, e acompanhar todo o histórico de seu versionamento.

E o tal do GitHub?

Já o GitHub é uma plataforma de armazenamento de repositórios GIT em nuvem, além de armazenar localmente em seu GIT, você pode usar o GitHub como backup.

Além do GitHub temos outras plataformas concorrentes bastante utilizadas como o GitLab, Bitbucket.

Neste artigo explicarei os comandos mais utilizados do Git e no vídeo publicado em meu canal do Youtube, como estes comandos podem ser utilizados pela interface do IntelliJ ou das ferramentas Jetbrains.

voltar ao conteúdo

Instalando o GIT

Para você aprender a usar o GIT, sugiro a instalação em sua máquina: faça o download do site oficial e siga o passo a passo, é bastante intuitivo.

voltar ao conteúdo

Cenário de Estudo

Aprenderemos a usar o Git para controlar as versões de um projeto fictício de armazenamento de arquivos TXT, que poderiam ser códigos fonte, scripts, ou qualquer outro tipo de arquivo.

Nosso primeiro passo será a criação de uma pasta/diretório HelloGit em nossa máquina:

Próximos passos:

criar um arquivo ola.txt dentro da pasta criada

salvar o arquivo com algum conteúdo, por exemplo, frase Olá

voltar ao conteúdo

Comando 01 - git init

O comando git init aplicado em um diretório torna este diretório gerenciado ou versionado pelo Git. Todos os arquivos e subdiretórios presentes neste diretório poderão ser controlados e versionados pelo Git.
Usando o git bash, presente na instalação do Git, navegue até a pasta HelloGit e digite git init

Após a execução do comando, a pasta .git responsável pelos arquivos de controle usado pelo git, será criada. Além da criação do branch master.

Um branch podemos representar como um "contexto", um "namespace" ou a ramificação que possui um conjunto específico de arquivos versionados. O branch master ou o branch main representam por convenção, a ramificação principal do seu projeto, onde ficam os arquivos com as versões usadas em produção, ou versões oficiais.

voltar ao conteúdo

Comando 02 - git status

O comando git status mostra o estado atual do branch, ilustrando os arquivos versionados e não versionados. Em nosso caso o arquivo ola.txt não se encontra versionado ainda.

Para versionamos um arquivo ou conjunto de arquivos, o Git segue o fluxo, use a figura abaixo como referência para os próximos comandos:

Experimente também o git status -s, a versão curta de visualização do estado dos arquivos.

voltar ao conteúdo

Comando 03 - git add

O comando git add <nome_arquivo>adiciona os arquivos que não estão sendo rastreados a uma área intermediária de controle, denominado cache.

Execute:

git add ola.txt
git status para visualizar o estado dos arquivos

Arquivos na zona de cache podem ser editados livremente porque não estão versionados ainda. Caso queiras reverter o git add, pode ser usado o comando git rm --cached.

Quando existir múltiplos arquivos a serem adicionados, uma opção é usar o git add . com o "." representando todos os arquivos.

voltar ao conteúdo

Comando 04 - git commit

O comando git commit -m "<mensagem>" versiona os arquivos adicionados no "cache". Através do commit nossos arquivos passam a ser versionados pelo Git. Qualquer alteração nos mesmos, após o commit, exigirão um novo commit atualizando a sua versão no repositório Git local.

Próximos passos:

verifique o status dos arquivos, note que temos o arquivo ola.txt somente adicionado mas não "commitado".
Execute `git commit -m "" para commitar seus arquivos, e versionados pelo Git.

voltar ao conteúdo

Comando 05 - git log

Agora que temos nosso primeiro commit, utilizaremos o comando git log para visualizar o histórico de commits de nosso projeto. Ou a forma curta com o comando git log --oneline.

Atente que cada commit possui um identificador.

Alterando e adicionando diversos arquivos

Após um arquivo ser commitado, qualquer alteração neste arquivo, exigirá um novo ciclo de commit.

Vamos criar dois novos arquivos em nosso projeto: hello.txt e hallo.txt.

Agora repetir o ciclo:

git status
git add .
git status
git commit -m "novos arquivos"

Agora temos dois commits em nosso branch master:

voltar ao conteúdo

Comando 07 - git diff

Experimente alterar algum dos arquivos, por exemplo, modifique o ola.txt adicionando Ola Mundo.

Verifique as alterações com o comandogit diff.

Atualize seu código, use novamente git add ., git status, git commit -m <mensagem>, git log --oneline.

voltar ao conteúdo

Comando 08 - git branch

Quando queremos implementar novas features, corrigir bugs, fazer melhorias, é comum a criação de branches para alterações controladas nos arquivos. E ao final, fazemos o merge do branch trabalhado ao branch principal.

Para criar o novo branch, opção 1:

git branch <nome_branch> para criar o branch.

git checkout <nome_branch> para mudar para o branch.

Observe com atenção que o branch corrente é o mudar-ingles. Com o git log é possível ver os branches existentes e o corrente (HEAD).

voltar ao conteúdo

Opção 2:

git checkout -b <nome_branch>, cria e muda para o branch.

Volte para o master com git checkout master e crie um outro branch a partir do master:

Visualize as informações com git log.

Finalmente no branch inglês modifique o arquivo hello.txt e no branch alemão, o aquivo hallo.txt. Aproveite e observe que a alteração em cada branch não afeta os outros branches. É a mágica de permitir o trabalho em branches paralelos!!!

voltar ao conteúdo

Comando 09 - git merge

Com o trabalho concluído em cada branch, próximo passo será o merge no branch master com o comando git merge.
Depois do merge feito, podemos apagar o branch com o comando git branch -d <nome_branch>.

E com o mudar alemão:

voltar ao conteúdo

Comandos com repositórios remotos

Para finalizar, quando usamos algum repositório remoto como o Github, temos que conhecer mais 3 comandos básicos: git clone, git push e o git pull.

Git clone

O git clone é usado para clonar um repositório remoto. Quando queremos baixar um repositório do Github, por exemplo, copiamos sua URL e usamos o git clone <URL>.

voltar ao conteúdo

Git pull

O comando git pull é usado para atualizar localmente um branch de sua localização remota. Por exemplo, uso do git pull no master.

voltar ao conteúdo

Git push

O comando git push faz o caminho inverso do pull. Este comando serve para enviar ao repositório remoto, as alterações de um branch local.

voltar ao conteúdo

Palavras finais

Espero que tenham gostado de conhecer ou revisar os comandos básicos do Git.
No vídeo do Youtube, você conhecerá outros comandos como rebase, squash, merge, stash usando as ferramentas JetBrains.

Compartilhe com seus amigos e me adicione no Linkedin.

voltar ao conteúdo

Technical Interview - Code #007 - LeetCode #606. Construct String from Binary Tree

Joao Carlos Sousa do Vale — Wed, 07 Sep 2022 20:59:33 +0000

Level

Easy

Complexidade

Linear

Topicos

Arvores Binarias, Travessia Pre-Ordem

Problema

Dada a raiz de uma árvore binária, construir uma String composta de parênteses e valores inteiros de uma árvore binária com o caminho de travessia da pré-compra, e devolvê-lo.

Omitir todos os pares de parênteses vazios que não afetam a relação de mapeamento um-para-um entre a cadeia de caracteres e a árvore binária original.

Restrições:

O número de nós na árvore está na faixa [1, 104].
-1000 <= Node.val <= 1000

Exemplo

Example 1:

Input: root = [1,2,3,4]
Output: "1(2(4))(3)"

Example 2:

Input: root = [1,2,3,null,4]
Output: "1(2()(4))(3)"

Implementar

class Solution {
    public String tree2str(TreeNode root) {

    }
}

Fonte

Construct String from Binary Tree https://leetcode.com/problems/construct-string-from-binary-tree/

https://www.linkedin.com/in/joaocarlosvale/

GitHub

source

Technical Interview - Code #006 - LeetCode #814. Binary Tree Pruning

Joao Carlos Sousa do Vale — Wed, 07 Sep 2022 00:23:08 +0000

Level

Medium

Complexidade

Linear

Topicos

Arvores Binarias, Travessia Pre-Ordem

Problema

Dada a raiz de uma árvore binária, devolva a mesma árvore onde cada sub-árvore (da árvore dada) que não contenha um 1 foi removida.

Restrições:

O número de nós na árvore está na faixa [1, 200].
O nó.val ou é 0 ou 1.

Exemplo

Example 1:

Input: root = [1,null,0,0,1]
Output: [1,null,0,null,1]

Example 2:

Input: root = [1,0,1,0,0,0,1]
Output: [1,null,1,null,1]

Example 3:

Input: root = [1,1,0,1,1,0,1,0]
Output: [1,1,0,1,1,null,1]

Implementar

class Solution {
    public TreeNode pruneTree(TreeNode root) {

    }
}

Fonte

LeetCode #814. Binary Tree Pruning
https://leetcode.com/problems/binary-tree-pruning/

https://www.linkedin.com/in/joaocarlosvale/

GitHub

https://github.com/jcarlosvale/playground/blob/master/src/main/java/tests/leetcode/challenge30days/september2022/BinaryTreePruning.java

Projeto Final - Python #18

Joao Carlos Sousa do Vale — Thu, 14 Jul 2022 14:08:31 +0000

Lista de Exercícios 07 - Funções #17

Joao Carlos Sousa do Vale — Tue, 12 Jul 2022 23:19:53 +0000

Q1. Implemente a função collatz( ):

se o número for par, ela retorna a divisão inteira deste número por 2.
se o número for ímpar, ela retorna (3 * número + 1).

Faça um programa que leia do teclado um número e imprima o retorno da função collatz()

Q2. Modifique o programa anterior, e recursivamente execute a função collatz( ) até o valor de retorno da função seja igual a 1.

Por exemplo, se o usuário digita 3, teremos que imprimir na tela os valores: 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1.

Fique livre de imprimir os valores da forma que achar mais fácil.

Q3. Escreva uma função que receba como parâmetro uma lista e retorne uma string com os elementos da lista separados por vírgula, com exceção do último que deve conter a palavra “e”.

Por exemplo, se a lista for [“banana”, “uva”, “abacaxi”], o método deve retornar a string “banana, uva e abacaxi”.

Q4. Implemente uma função que simule o lançamento de uma moeda, usando o módulo random. Este método receberá como parâmetro a quantidade de lançamentos.

A função imprimirá a quantidade de “caras” e “coroas” gerados.

Por exemplo, se o parâmetro for 5, o programa poderá imprimir: “5 coroas 0 caras” ou “3 coroas 2 caras” ou “1 coroas 4 caras”, entre outras possibilidades.

Q5. Escreva uma função chamada cidade_pais() que recebe como parâmetro o nome de uma cidade e de seu país. A função deve retornar uma string formatada como “Santiago, Chile”.

Q6. Implemente uma lista contendo um conjunto de mensagens de texto. Passe esta lista como parâmetro para uma função responsável por imprimir as mensagens em linhas diferentes.

Q7. Um número é capicua quando lido da esquerda para a direita ou da direita para a esquerda. O ano 2002 é um ano capicua. Elabore uma função que verifique essa característica.

Q8. Criar uma função que receba uma mensagem e dois caracteres e substitua todas as ocorrências do 1o. caractere pelo 2o. caractere.

Exemplo:

digite mensagem:
SE NAO APRENDI TODOS OS EXERCICIOS DE UM CAPITULO, NAO DEVO PASSAR PARA O OUTRO
digite 1a. letra E
digite 2a. letra K
SK NAO APRKNDI TODOS OS KXKRCICIOS DK UM CAPITULO, NAO DKVO PASSAR PARA O OUTRO

Q9. Criar uma função que receba um vetor de inteiros e retorne True se o vetor estiver ordenado ou False se não estiver.

Funções em Python - #16

Joao Carlos Sousa do Vale — Tue, 12 Jul 2022 23:19:29 +0000

Introdução

Uma função é um miniprograma dentro de um programa. É uma estrutura da linguagem que possibilita uma melhor organização de seu programa e facilita a resolução de problemas mais complexos, através delas podemos resolver partes específicas do problema.

Outra vantagem do uso de funções é a possiblidade de reutilização do código, podemos por exemplo, criar uma biblioteca de funções e utilizá-las em nossos programas, sem a necessidade de reescrever a mesma funcionalidade.

Neste capítulo iremos aprender a usar outras funções disponíveis na linguagem como também a criar as nossas próprias funções.

Função bool()

A função bool() retorna True ou False ao receber um parâmetro.

Se o valor é numérico, ele retornará False se o parâmetro é igual a zero.

Para strings, listas e dicionários vazios, o retorno também será False. Como também para o valor None.

#função bool() em ação
>>> bool(-2)
True
>>> bool(0)
False
>>> bool(0)
False
>>> bool(-2)
True
>>> bool(0.00)
False
>>> bool(3.14)
True
>>> bool(None)
False
>>> bool('casa')
True
>>> bool('')
False
>>> bool(' ')
True
>>> bool([])
False
>>> bool([1])
True

Função abs()

A função abs( ) retorna o valor absoluto de um número. O valor sem sinal.

#função abs() em ação
>>> abs(-20)
20
>>> abs(20)
20
>>> abs(-5.433)
5.433
>>> abs(0)
0

Usando módulos

As funções em Python são organizadas em módulos. Cada módulo possui um conjunto de funções relacionadas, que podem ser utilizadas em nossos programas.

Antes de utilizarmos funções de um módulo, precisamos importar o módulo através da instrução import.

Instrução import

Por exemplo, se quisermos gerar 3 números inteiros de forma randômica ou aleatória, entre 1 e 11 com a função randint():

#Algoritmo - gerando 3 números inteiros aleatórios
import random
for i in range(3):
    print(random.randint(1, 10))

Na linha 01 temos que importar o módulo random que contém a função randint( ).

Na linha 03 fazemos a chamada do método, utilizando o nome do módulo e o nome da função, concatenados com um ponto (“.”) .

#Execução - gerando 3 números inteiros aleatórios 
10
7
4

Instrução from - import

Uma alternativa na sintaxe import é utilizar a palavra reservada from e o asterisco (“*”):

#Algoritmo - gerando 3 números inteiros aleatórios versão 2
from random import *
for i in range(3):
    print(randint(1, 10))

Com a sintaxe da linha 01, não é necessário utilizar o prefixo random. para executar o método randint( ). Podemos interpretar a instrução from random import * como, “do (módulo) random, importe tudo”. O asterisco em computação, geralmente, representa “tudo”, “todos”.

Ou podemos especificar quais funções importar com a mesma sintaxe.

#Algoritmo - gerando 3 números inteiros aleatórios versão 3
from random import randint
for i in range(3):
    print(randint(1, 10))

Usando alias

Podemos utilizar um “apelido” ou alias no nome das funções importadas.

#Algoritmo - gerando 3 números inteiros aleatórios versão 4
from random import randint as rand
for i in range(3):
    print(rand(1, 10))

Também é permitido o uso de alias em nome de módulo.

#Algoritmo - gerando 3 números inteiros aleatórios versão 5
import random as r
for i in range(3):
    print(r.randint(1, 10))

Mútiplos imports

Finalmente, para importarmos múltiplos módulos em um programa, basta separarmos os nomes por vírgula.

#Múltiplos imports
import random, math, sys

Módulo time

Função asctime( )

A função asctime( ) retorna a data e horário atual como uma string.

#Usando função asctime()
>>> import time
>>> print(time.asctime())
Mon Apr 11 10:49:25 2022

Também podemos usar a asctime( ) para gerar uma data e hora de uma string. Para isso, temos que fornecer uma tupla com 9 valores: o ano, dia, hora, minutos, segundos, dia da semana (0 é Segunda-Feira, 1 é Terça-Feira, …, 6 - Domingo), dia do ano (pode colocar ZERO), horário de verão (1 - SIM, 0 - NÃO).

Veja alguns exemplos.

#Usando função asctime() com tuplas
>>> import time

>>> t = (2021, 12, 25, 10, 00, 30, 2, 0, 0)
>>> print(time.asctime(t))
Wed Dec 25 10:00:30 2021

>>> t = (2007, 7, 31, 15, 10, 45, 2, 0, 0)
>>> print(time.asctime(t))
Wed Jul 31 15:10:45 2007

Função time( )

A função time() retorna a quantidade de segundos desde 01-Janeiro-1970 00:00:00 AM.

#Usando função time()
>>> import time
>>> print(time.time())
1649667539.7314017

É bastante utilizado quando você quer saber o tempo de execução de um programa ou trecho de código.

#Algoritmo - tempoSomar.py
import time

def somar(n):
    soma = 0
    for i in range(n):
        soma += i
    return soma

n = input("Digite quantidade de numeros para somar: ")
inicio = time.time()
print(somar(int(n)))
fim = time.time()
print("Tempo de execução: ", fim - inicio, " segundos")

Capturamos o tempo antes de executar a função somar( ) na linha 10. E após a execução capturamos novamente o tempo.

Na linha 13 imprimimos a diferença no tempo de execução da função.

#Execução - tempoSomar.py
Digite quantidade de numeros para somar: 100000
4999950000
Tempo de execução:  0.003997802734375  segundos

Função localtime( )

A função localtime() retorna um tupla com 9 valores locais: ano, mês, dia, hora, minutos, segundos, dia do ano e se é horário de verão.

#Usando função localtime()
>>> import time

>>> time.localtime()
time.struct_time(tm_year=2022, tm_mon=4, tm_mday=11, tm_hour=11, tm_min=18, tm_sec=48, tm_wday=0, tm_yday=101, tm_isdst=1)

>>> t = time.localtime()
>>> print("Minutos ", t[4])
Minutos  18
>>> print("Dia do ano ", t[7])
Dia do ano  101

Módulo copy

Função copy( )

A função copy() cria uma cópia de uma lista ou dicionário, criando uma cópia distinta, alterando uma lista ou dicionário não afetará a outra.

#Usando função copy()
>>> import copy
>>> lista_original = ["asa", "aviao"]
>>> lista_copia = copy.copy(lista_original)
>>> lista_copia.append("arara")
>>> lista_original
['asa', 'aviao']
>>> lista_copia
['asa', 'aviao', 'arara']

Função deepcopy

A função deepcopy() é semelhante à função copy(), mas aplicado quando os elementos da lista ou do dicionário são outras listas ou dicionários.

#Algoritmo - deepcopyAcao.py
import copy

turma_original = [
    {'nome': 'Ana', 'nota': 7.5},
    {'nome': 'Bia', 'nota': 8.5}
]

turma_copia = copy.deepcopy(turma_original)
turma_copia.pop()

print(turma_original)
print(turma_copia)

#Execução - deepcopyAcao.py
[{'nome': 'Ana', 'nota': 7.5}, {'nome': 'Bia', 'nota': 8.5}]
[{'nome': 'Ana', 'nota': 7.5}]

Módulo random

Função random.choice()

A função choice() retorna um elemento aleatório da lista.

#Usando função choice()
>>> import random
>>> lista_cor = ["preto", "branco", "vermelho"]

>>> random.choice(lista_cor)
'preto'
>>> random.choice(lista_cor)
'preto'
>>> random.choice(lista_cor)
'vermelho'
>>> random.choice(lista_cor)
'branco'
>>> random.choice(lista_cor)
'branco'

Função random.shuffle()

A função shuffe() reordena os itens de uma lista.

#Usando função shuffle()
>>> import random
>>> lista_cor = ["preto", "branco", "vermelho"]

>>> random.shuffle(lista_cor)
>>> print(lista_cor)
['vermelho', 'preto', 'branco']

>>> random.shuffle(lista_cor)
>>> print(lista_cor)
['branco', 'vermelho', 'preto']

Módulo pprint

Função pprint()

A função prprint() imprime um dicionário ordenando suas chaves.

#Algoritmo - countCharPPrint.py
import pprint 

texto = input("Digite um texto: ")
count = {}
for letra in texto:
    count.setdefault(letra, 0)
    count[letra] += 1

pprint.pprint(count)

#Execução - countCharPPrint.py
Digite um texto: abacaxi de morango
{' ': 2,
 'a': 4,
 'b': 1,
 'c': 1,
 'd': 1,
 'e': 1,
 'g': 1,
 'i': 1,
 'm': 1,
 'n': 1,
 'o': 2,
 'r': 1,
 'x': 1}

Função pformat()

A função pformat() é semelhante ao pprint() mas ao invés de imprimir na tela, ele retorna uma string com as chaves do dicionários ordenadas.

#Algoritmo - countCharPformat.py
import pprint 

texto = input("Digite um texto: ")
count = {}
for letra in texto:
    count.setdefault(letra, 0)
    count[letra] += 1

saida = pprint.pformat(count)
print(saida)

#Execução - countCharPformat.py
Digite um texto: bananada
{'a': 4, 'b': 1, 'd': 1, 'n': 2}

Módulo sys

Função sys.exit( )

A função sys.exit( ) é usada para terminar a execução de um programa imediatamente.

É bastante utilizado quando queremos implementar a saída de um programa após o usuário digitar alguma string definida para terminar a execução do sistema. Por exemplo, enquanto o usuário não digitar sair, o código abaixo continuará executando:

#Algoritmo - digite sair para terminar o programa
import sys
while True:
    print("Programa executando.")
    print("Digite 'sair' para terminar:")
    comando = input()
    if comando == 'sair':
        sys.exit()

No algoritmo acima, importamos o módulo sys (linha 01) para podermos utilizar a função exit( ) na linha07.

Criamos um laço while infinito, nas linhas 02 a 07, que em cada iteração vai imprimir “Programa executando” e solicitar para que o usuário digite “sair” para terminar o programa.

O valor digitado pelo usuário na linha 05 será armazenado na variável comando e na linha 06, se o valor for igual à “sair”, a função exit( ) será executada e o programa finalizado. Senão uma nova iteração será executada, repetindo o ciclo.

#Execução - digite sair para terminar o programa 
Programa executando.
Digite 'sair' para terminar:
teste
Programa executando.
Digite 'sair' para terminar:
nao
Programa executando.
Digite 'sair' para terminar:
quit
Programa executando.
Digite 'sair' para terminar:
sair

Criando funções

Uma função é um pequeno algoritmo que resolve um problema específico, dentro do seu programa. Sua sintaxe é bem simples.

#Sintaxe funções
def <nome_função>(<parâmetros>):
    instruções

Implemente a função abaixo que imprime uma mensagem na tela.

#Algoritmo - ola.py
def ola():
    print("Minha funcao em Python")

ola()

A função está definida (def) na linha 01, com o nome ola. É uma função simples que imprime “Minha funcao em Python”.

Executamos uma função usando seu nome e parênteses, como ilustrado na linha 04.

#Execução - ola.py 
Minha funcao em Python

Parâmetros de função (entrada)

Se quisermos fornecer valores de entrada para uma função, definimos entre os parênteses os parâmetros. Implemente o exemplo, que verifica se um número é par.

#Algoritmo - ehPar.py
def isEven(number):
    if (number % 2 == 0):
        print(f"{number} eh par")
    else:
        print(f"{number} nao eh par")

isEven(4)
isEven(9)
isEven(2124)

Na linha 01 definimos a assinatura da função isEven. A assinatura do método é representado pelo nome do método e os parâmetros de entrada.

Nas linhas 07, 08 e 09, chamamos a função isEven() com diferentes argumentos: 4, 9, 2124. Chamamos de argumento o valor do parâmetro de um método.

#Execução - ehPar.py 
4 eh par
9 nao eh par
2124 eh par

Instrução return (saída)

Uma função pode retornar valor através do uso da instrução return. Se uma instrução return é executada, a função é encerrada.

Observe a função abaixo que executa uma operação aritmética e retorna o valor calculado.

#Algoritmo - calcula.py
def calcula(x, y, op):
    if op == '+':
        return x + y    
    elif op == '-':
        return x - y
    elif op == '*':
        return x * y
    elif op == '/':
        return x / y
    else:
        return 'Operacao invalida'

comando = ""
while comando != "sair":
    comando = input("Calcular (S-sim)? (Digite 'sair' para encerrar.): ")
    if comando == "sair":
        print("Saindo...")
    else:
        x = int(input("Digite o primeiro numero: "))
        y = int(input("Digite o segundo numero: "))
        op = input("Digite a operacao (+, -, *, /): ")
        print(calcula(x, y, op))

Nas linhas 01 a 11 temos uma função que calcula uma operação (op) entre dois números x e y. Os três parâmetros da função.

Para cada operação executada, há uma cláusula return, linhas 03, 05, 07, 09, 11. Se o usuário selecionar a multiplicação, pela cláusula condicional, a linha 07 será executada e encerrará a função.

#Execução - calcula.py 
Calcular (S-sim)? (Digite 'sair' para encerrar.): s
Digite o primeiro numero: 12
Digite o segundo numero: 2
Digite a operacao (+, -, *, /): /
6.0
Calcular (S-sim)? (Digite 'sair' para encerrar.): s
Digite o primeiro numero: 33
Digite o segundo numero: 11
Digite a operacao (+, -, *, /): *
363
Calcular (S-sim)? (Digite 'sair' para encerrar.): sair
Saindo...

No jargão da computação, as funções que não retornam valores são denominadas procedimentos.

Em Python uma função que não retorna um valor explicitamente com o return, implicitamente retona None.

#Algoritmo - ehPar.py modificado
def isEven(number):
    if (number % 2 == 0):
        print(f"{number} eh par")
    else:
        print(f"{number} nao eh par")

num = isEven(4)
print(num)

A função isEven() não retorna valor, logo o valor da linha 07 será None.

#Execução - ehPar.py modificado
4 eh par
None

Escopo de variáveis

Escopo de variável é a região do código em que uma variável existe e pode ser utilizada. Em Python temos o escopo local e o global.

Variável local é uma variável criada dentro de uma função, seu escopo é local, ela existirá somente dentro da função.

Variável global são as variáveis definidas fora de funções, possuem escopo global, podem ser utilizadas em qualquer local do código.

Desta forma, tenha em mente:

Dentro de uma função podemos usar variáveis locais e ler variáveis globais.
Variáveis locais não podem ser usadas fora da função.
Podemos ter variáveis locais e globais com o mesmo nome. Dentro de uma função as variáveis locais tem maior prioridade de uso.

Experimente os seguintes programas e entenda o escopo das variáveis.

#Algoritmo - escopoGlobal.py
def imprime():
    print(contador)

contador = 10
imprime()

A variável da linha 04, pode ser acessada dentro do método imprime().

#Execução - escopoGlobal.py
10

Não podemos acessar uma variável local fora do método.

#Algoritmo - escopoLocalErro.py
def imprime():
    contador = 10

imprime()
print(contador)

Neste exemplo a variável contador é local (linha 02) e não pode ser acessada fora do escopo do método, como na linha 05.

#Execução - escopoLocalErro.py
Traceback (most recent call last):
  File "c:\Python\codes\escopoLocalErro.py", line 5, in <module>
    print(contador)
NameError: name 'contador' is not defined

Variáveis de diferentes escopos mas com mesmo nome possuem a prioridade de localização, se chamadas dentro de uma função, a variável local será acessada.

#Algoritmo - localEGlobal.py
def imprime():
    contador = 10
    print("valor em contador na funcao:", contador)

contador = 5
imprime()
print("valor em contador no escopo global:", contador)

Do exemplo anterior temos a variável contador definida na linha 02 e na linha 05.

#Execução - localEGlobal.py
valor em contador na funcao: 10
valor em contador no escopo global: 5

Palavra global

A palavra reservada global é aplicada na definição de variáveis de escopo global e permitem que o seu valor possa ser alterado dentro de funções.

#Sintaxe - global
global <nome_variavel>

Execute o código abaixo em seu ambiente.

#Algoritmo - usoGlobal.py
def incrementa(incremento):
    global contador
    contador = 10
    contador += incremento

incrementa(5)
print("valor em contador depois da função:", contador)

Nas linha 02 definimos a variável contador como global. Isto nos permite utilizá-lo em qualquer parte do código, inclusive fora da função como na linha 07 . A função incrementa( ) recebe como parâmetro um valor incremento que será adicionado ao contador.

#Execução - usoGlobal.py
valor em contador depois da função: 15

Pilha de execução

Funções podem ter como instruções a chamada para outras funções. A linguagem Python consegue memorizar a execução das funções através de uma estrutura denominada pilha de execução.

Veja o exemplo abaixo, para efeitos didáticos.

#Algoritmo - multiplasFuncoes.py
def funcaoA():
    print("Funcao A")

def funcaoB():
    print("Funcao B")
    funcaoA()

def funcaoC():
    print("Funcao C")
    funcaoB()
    print("Pilha de chamadas")

def main():
    funcaoC()

print("Inicio")
main()
print("Fim")

Temos 4 funções no algoritmo: funcaoA() (linha 01), funcaoB() (linha 04), funcaoC() (linha 08), main() (linha 13).

A funcaoA() imprime uma mensagem na tela, a funcaoB() além de imprimir uma mensagem, chama a funcaoA(). A funcaoC() além de imprimir uma mensagem, executa a funcaoB() e então imprime “Pilha de chamadas”.

Na execução do algoritmo, chamamos a main() (linha 17) que simplesmente executa a funcaoC().

#Execução - multiplasFuncoes.py
Inicio
Funcao C
Funcao B
Funcao A
Pilha de chamadas
Fim

A linguagem cria uma pilha de chamadas, ilustrado abaixo, primeiro chamamos a função main() no Passo 1, que executa a funcaoC() (Passo 2) e coloca no topo da pilha.

A funcaoC() invoca a funcaoB() (Passo 3) que por sua vez chama a funcaoA( ) (Passo 4), sendo colocados no topo da pilha em cada passo. Dos passos 5 ao passo 7, a linguagem executa os métodos do topo da pilha, primeiro a funcaoA( ), depois a funcaoB( ) e finalmente a funcaoC( ) e main( ), respectivamente.

`Pilha de execução`
			`funcaoA()`
		`funcaoB()`	`funcaoB()`	`funcaoB()`
	`funcaoC()`	`funcaoC()`	`funcaoC()`	`funcaoC()`	`funcaoC()`
`main()`	`main()`	`main()`	`main()`	`main()`	`main()`	`main()`
`Passo 1`	`Passo 2`	`Passo 3`	`Passo 4`	`Passo 5`	`Passo 6`	`Passo 7`

Função recursiva

Uma função é chamada recursiva quando ela invoca a si própria em seu bloco de instrução.

Para implementarmos uma função recursiva, é importante definirmos:

O ponto de parada, ou caso base: condição que a função não chamará a sua execução recursiva.
Execução recursiva: condição da execução recursiva.

Criar funções recursivas exige um pouco de experiência na programação, não se assuste se você não consegue neste momento implementar funções recursivas ou entender completamente os exemplos abaixo. Mas é importante saber que toda função recursiva pode ser escrita em uma forma não recursiva.

Nosso primeiro exemplo é implementar a operação da multiplicação mult( ), de números positivos, como função recursiva.

Uma multiplicação de x * y pode ser implementada como a soma de x por y vezes ou soma de y por x vezes. Por exemplo: 3 * 2 = 3 + 3 ou 3 * 2 = 2 + 2 + 2.

Como função recursiva, o caso base da multiplicação: qualquer número multiplicado por ZERO é ZERO, mult(x, 0) = 0.

Como execução recursiva: mult(x, y) = x + mult(x, y-1).

#Algoritmo - multRecursivo.py
def mult(x, y):
    if y == 0:
        return 0
    else:
        return x + mult(x, y - 1)

print(mult(5, 3))
print(mult(2, 0))
print(mult(4, 8))

Nas linhas 01-05 temos a função mult(x, y) recebendo 2 parâmetros, e nas linhas 02-03 a condição base ou de parada e na linha 05 a chamada recursiva.

Para a execução mult(5, 3) sua pilha de execução ficará como abaixo.

`Pilha de execução recursiva`
			`mult(5,0)`
		`mult(5,1)`	`mult(5,1)`	`mult(5,1)`
	`mult(5,2)`	`mult(5,2)`	`mult(5,2)`	`mult(5,2)`	`mult(5,2)`
`mult(5,3)`	`mult(5,3)`	`mult(5,3)`	`mult(5,3)`	`mult(5,3)`	`mult(5,3)`	`mult(5,3)`
`Passo 1`	`Passo 2`	`Passo 3`	`Passo 4`	`Passo 5`	`Passo 6`	`Passo 7`

#Execução - multRecursivo.py
15
0
32

Agora é a sua vez!

Implemente o cálculo do fatorial de um número, positivo, de forma recursiva.

O fatorial de um número é definido como:

fatorial(n) = n * (n-1) * (n-2) * 1.

Por exemplo:

fatorial(5) = 5 * 4 * 3 * 2 * 1 = 120

fatorial(3) = 3 * 2 * 1 = 6

fatorial(1) = 1

Identifique o caso base e a chamada recursiva.

Criando seus próprios módulos

Criar seus próprios módulos é bem simples, da mesma forma como outros programas em Python, você precisa salvar as suas funções em um arquivo .py.

Vamos implementar o seguinte exemplo!

implementar um módulo com 3 funções:
- implementar uma função que gera uma lista de números randômicos, em um intervalo.
- implementar uma função que verifica se um número é par.
- implementar uma função que verifica se um número é primo.
criar um programa que solicite ao usuário a quantidade de números que quer gerar e verificar se é um número par e se é primo.

Para fins didáticos, salvei as funções em um módulo chamado meuModulo.

#Arquivo - meuModulo.py
import random

def isEven(n):
    if n % 2 == 0:
        return True
    else:
        return False

def isPrime(n):
    if n == 1:
        return False
    elif n == 2:
        return True
    else:
        for i in range(2, n):
            if n % i == 0:
                return False
        return True

def generateRandomList(n, max = 100):
    lista = []
    for i in range(n):
        lista.append(random.randint(1, max))
    return lista

Em meuModulo.py temos 3 funções:

isEven: verifica se um número é par, definido nas linhas 03 a 07.
isPrime: verifica se um número é primo, ou seja, ele é divisível somente por 1 e por ele mesmo (linhas 09 a 18).
generateRandomList: gera uma lista de tamanho n, entre os valores 1 e max. _O parâmetro _max é opcional, tem como valor padrão 100. É necessário importar o módulo random (linha 01).

Para usarmos o nosso módulo, aplicamos a sintaxe import, como dos exemplos anteriores.

#Arquivo - usoMeuModulo.py
import meuModulo

def processa(lista):
    for i in lista:
        if meuModulo.isPrime(i):
            print(i, "é primo")

        if meuModulo.isEven(i):
            print(i, "é par")
        else:
            print(i, "é impar")

n = input("Digite quantidade de numeros a serem gerados: ")
lista = meuModulo.generateRandomList(int(n))
processa(lista)

Em nosso programa importamos o meuModulo (linha 01) e utilizamos suas funções nas linhas 05, 08, 14.

#Execução - usoMeuModulo.py
Digite quantidade de numeros a serem gerados: 5
46 é par
4 é par
10 é par
15 é impar
37 é primo
37 é impar

Outros recursos das funções

Argumentos nomeados

Vamos criar uma função que recebe o nome e a idade de uma pessoa, e imprime estas informações.

#Algoritmo - nomeIdade.py
def informacoes(nome, idade):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("João", 20)
informacoes("Maria", 25)

#passando parametros pela posicao
informacoes(45, "Zezim")

Nas linhas 05 e 06 chamamos a função informacoes(nome, idade) com os parâmetros na posição esperada.

Como a função não executa nenhuma operação numérica com a idade, podemos cometer um erro e mudar a ordem dos parâmetros, como na linha 09.

O código ainda irá executar.

#Execução - nomeIdade.py
Nome:  João
Idade:  20 
Nome:  Maria
Idade:  25
Nome:  45
Idade:  Zezim

A forma como estamos passando os argumentos é denominada posicional. A posição do parâmetro determina o argumento associado.

Python fornece outra forma de enviar os argumentos para uma função, usando o nome do parâmetro e o valor de argumento na forma chave-valor. É o denominado argumento nomeado.

Modifique o código acima e execute-o novamente.

#Algoritmo - nomeIdade.py modificado
def informacoes(nome, idade):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes(nome = "Maria", idade = 25)
informacoes(idade = 45, nome = "Zezim")

Nas linhas 05 e 06 estamos indicando o nome do parâmetro e o argumento associado. Desta forma os valores serão tratados corretamente na execução da função.

#Execução - nomeIdade.py modificado
Nome:  Maria
Idade:  25
Nome:  Zezim
Idade:  45

Parâmetros opcionais

Podemos definir um valor padrão para os parâmetros de uma função, desta forma não é obrigado fornecer valores na execução da função.

Modifique o código nomeIdade.py novamente e observe a sintaxe de valor padrão.

#Algoritmo - nomeIdade.py com valor padrão
def informacoes(nome, idade = 10):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("Maria")

Na linha 01 a idade possui um valor padão de 10, não é mais obrigatório fornecer a idade na chamada da função, como ilustrado na linha 05.

#Execução - nomeIdade.py com valor padrão
Nome:  Maria
Idade:  10

Podemos inclusive deixar todos os parâmetros com valores padrões.

#Algoritmo - nomeIdade.py todos os parâmetros com valores
def informacoes(nome = "Jose", idade = 10):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("Maria")
informacoes(20)
informacoes()

Observe a flexibilidade de usar parâmetros opcionais, nas linhas 05, 06 , 07.

#Execução - nomeIdade.py todos os parâmetros com valores
Nome:  Maria
Idade:  10
Nome:  20
Idade:  10
Nome:  Jose
Idade:  10

Número de argumentos indefinidos

Podemos criar funções sem definir a quantidade de parâmetros, através da sintaxe abaixo.

#Sintaxe - parâmetros indefinidos
def <funcao>(*<nome_parametro>):

O parâmetro é interpretado como uma tupla. Implemente o exemplo seguinte.

#Algoritmo - parametrosIndefinidos.py
def imprime(* mensagem):
    print("Executando o metodo: imprime")
    print(mensagem)
    for m in mensagem:
        print(m)
    print("Fim do metodo: imprime")

imprime("Ola", "Mundo")
imprime("Python")
imprime("Python", "Java", "C++")
imprime()

Na linha 01 definimos mensagem como um parâmetro que recebe múltiplos valores, e nas linhas 08 a 11 utilizamos a função com uma quantidade variada de parâmetros.

#Execução - parametrosIndefinidos.py
Executando o metodo: imprime
('Ola', 'Mundo')
Ola
Mundo
Fim do metodo: imprime

Executando o metodo: imprime
('Python',)
Python
Fim do metodo: imprime

Executando o metodo: imprime
('Python', 'Java', 'C++')
Python
Java
C++
Fim do metodo: imprime

Executando o metodo: imprime
()
Fim do metodo: imprime

Se utilizarmos “” em vez de somente “*”, o parâmetro **será interpretado como um dicionário e poderá ter seus valores modificados. Você deve chamar a função com o formato chave-valor.

#Sintaxe - parâmetros indefinidos como dicionário
def <funcao>(**<nome_parametro>):

#Algoritmo - parametrosIndefinidosDic.py
def criarpessoa(nome, idade, **informacoes):
    informacoes["nome"] = nome
    informacoes["idade"] = idade
    return informacoes

pessoa = criarpessoa("Maria", 25, cidade = "São Paulo", estado = "SP")
print(pessoa)

A função criarpessoa() utiliza a sintaxe **informacoes como parâmetro, desta forma, dentro da função ele será interpretado como um dicionário.

#Execução - parametrosIndefinidosDic.py
{'cidade': 'São Paulo', 'estado': 'SP', 'nome': 'Maria', 'idade': 25}

Erros comuns

Cuidado ao salvar o nome de seus programas e utilizar o nome de um módulo da linguagem. Como por exemplo random.py.

Se você importar o módulo random, o interpretador utilizará o programa que você criou em vez de usar o módulo random da linguagem.

Tome cuidado com os tipos de dados usados como parâmetros e forneça valores corretos, caso contrário teremos um erro no código.

#Algoritmo - ehPar.py usando valores não numéricos
def isEven(number):
    if (number % 2 == 0):
        print(f"{number} eh par")
    else:
        print(f"{number} nao eh par")

isEven("4")

#Execução - ehPar.py usando valores não numéricos
Traceback (most recent call last):
  File "c:\Dropbox\Youtube\Python\codes\ehPar.py", line 7, in <module>
    isEven("4")
  File "c:\Dropbox\Youtube\Python\codes\ehPar.py", line 2, in isEven
    if (number % 2 == 0):
TypeError: not all arguments converted during string formatting

Como desenvolvedor, ao implementar funções recursivas, seja cauteloso em garantir que a pilha de chamadas chegará no caso base, senão teremos uma pilha infinita de execução. Pense de forma análoga à criação de um loop, implementando a condição de parada.

Teremos uma execução infinita se executarmos o mult( ) com valor negativo.

#Algoritmo - multRecursivo.py
def mult(x, y):
    if y == 0:
        return 0
    else:
        return x + mult(x, y - 1)

print(mult(2, -1))

#Execução - multRecursivo.py em loop infinito
Traceback (most recent call last):
  File "c:\Python\codes\multRecursiva.py", line 7, in <module>
    print(mult(2, -1))
  File "c:\Python\codes\multRecursiva.py", line 5, in mult
    return x + mult(x, y - 1)
  File "c:\Python\codes\multRecursiva.py", line 5, in mult
    return x + mult(x, y - 1)
  File "c:\Python\codes\multRecursiva.py", line 5, in mult
    return x + mult(x, y - 1)
  [Previous line repeated 995 more times]
  File "c:\Python\codes\multRecursiva.py", line 2, in mult
    if y == 0:
RecursionError: maximum recursion depth exceeded in comparison

Lembre-se que variáveis locais não podem ser acessadas fora da função onde foram definidas.

#Algoritmo - escopoLocalErro.py
def imprime():
    contador = 10

imprime()
print(contador)

#Execução - escopoLocalErro.py
Traceback (most recent call last):
  File "c:\Python\codes\escopoLocalErro.py", line 5, in <module>
    print(contador)
NameError: name 'contador' is not defined

E não podemos alterar o valor de variáveis globais que não são explicitamente marcadas com a palavra global.

#Algoritmo - globalErro.py
def imprime():
    contador += 100
    print(contador)

contador = 10
imprime()

#Execução - globalErro.py
Traceback (most recent call last):
  File "c:\Python\codes\escopoGlobal.py", line 6, in <module>
    imprime()
  File "c:\Python\codes\escopoGlobal.py", line 2, in imprime
    contador += 100
UnboundLocalError: local variable 'contador' referenced before assignment

Os parâmetros opcionais devem sempre ser definidos após os parâmetros obrigatórios. O código abaixo não executa.

#Algoritmo - erro no uso de parâmetros opcionais
def informacoes(nome = "Jose", idade):
    print("Nome: ", nome)
    print("Idade: ", idade)

informacoes("Maria", 20)

#Execução - erro no uso de parâmetros opcionais
  File "c:\codes\nomeIdade.py", line 1
    def informacoes(nome = "Jose", idade):
                                   ^^^^^
SyntaxError: non-default argument follows default argument

Lista de Exercícios 06 - Laços de Repetição #15

Joao Carlos Sousa do Vale — Tue, 12 Jul 2022 23:05:01 +0000

Q1. Escreva um programa que:

crie uma lista vazia - cores
solicite ao usuário que digite suas 3 cores preferidas, e armazene na lista - utilize um laço for e o método append()
imprima a mensagem “A pizza <nome_pizza> é uma das minhas pereferidas.” - use o método for de percorrer listas.

Q2. Usando a função range( ), imprima os múltiplos de 3 entre 12 e 82.

Q3. Crie uma lista com 1 milhão de números, do número 1 ao 1.000.000, e imprima o menor número (que deve ser 1) e o maior número (que deve ser 1.000.000). Finalmente, imprima a soma de todos os números. Use o range() para gerar a lista e as funções sum(), max(), min().

Q4. Crie um programa que solicite ao usuário o nome de cada cidade que ele já visitou, armazenando em uma lista, até ele digitar “sair”. Após ele digitar “sair”, imprima na tela a lista de cidades digitadas.

Q5. O preço de ingresso de um cinema depende da idade da pessoa. Se uma pessoa é menor do que 3 anos, o ingresso é grátis; se a idade está entre 3 e 12, o ingresso custa $10; e se a idade é maior que 12 anos, o ingresso será $15. Escreva um laço for que solicita a idade do usuário e então informa o preço do ingresso. Implemente a forma de sair do laço.

Q6. Modifique o programa anterior. Solicite que o usuário informe a quantidade de ingressos que irá comprar, informe para cada ingresso a idade da pessoa e finalmente imprima o valor total da compra dos ingressos.

Q7. Implemente o seguinte programa:

crie uma lista entrada com 5 elementos do tipo string.
imprima na tela a lista entrada
usando um laço while, enquanto a _entrada _ não estiver vazia:
- remova cada elemento com o método pop
- salve o elemento removido em uma lista saida com o método append
imprima a lista saida

Compare a lista entrada e saida, o que você notou?

Q8. Dada a seguinte lista:

linguagens = ['python', 'java', 'python', 'javascript', 'java', 'c++', 'java']

Crie um algoritmo que remova a palavra ‘java’.

Q9. Imprimir os 100 primeiros pares.

Q10. Crie um algoritmo que leia 2 variáveis inteiras: variável n maior do que 1 e o valor de b maior ou igual a 2.

Calcule “b elevado a n”, isto é, b * b * b …* b (n vezes).

Q11. Crie um progama que leia “n” números inteiros e imprima o maior e o menor deles. O valor de “n” pode ser fornecido pelo usuário.

Q12. Crie um algoritmo que imprima os 10 primeiros termos da série de Fibonnaci. Ela é definida como:

o primeiro e o segundo termo é o valor 1
o termo seguinte é sempre a soma dos 2 anteriores.

Série de Fibonnaci: 1 1 2 3 5 8 …

Q13. Entrar com um número e imprimir todos os seus divisores.

Q14. Entrar com oito nomes e imprimir quantas letras tem cada nome.

Q15. Crie um algoritmo que entre com uma palavra e imprima conforme o exemplo a seguir:

    palavra: AMOR


impressão:
                A
                AM
                AMO
                AMOR

Q16. Crie um algoritmo que entre com uma palavra e imprima conforme o exemplo a seguir:

    palavra: AMOR

impressão:
                AMOR
                AMO
                AM
                A

Q17. Crie um algoritmo que entre com uma palavra e imprima conforme o exemplo a seguir:

    palavra: TERRA

impressão:
                A
                RA
                RRA
                ERRA
                TERRA

Q18. Crie um algoritmo que entre com uma palavra e imprima conforme o exemplo a seguir:

    palavra: TERRA

impressão:
                TERRA
                ERRA
                RRA
                RA
                A

Q19. Ler o número de termos da série n e imprimir o valor de H como:
H = 1 + ½ + ⅓ + ¼ + …+1/n

Q20. Ler o número de termos da série n e imprimir o valor de H como:
H = 1 - ½ + ⅓ - ¼ + …+1/n

Q21. Chico tem 1,50m e cresce 2 centímetros por ano, enquanto Juca tem 1, 1m e cresce 3 centímetros por ano. Construir um algoritmo que calcule e imprima quantos anos serão necessários para que Juca seja maior que Chico.

Q22. Entrar com um número e verificar se ele é um número primo.

Q23. Entrar com um número e verificar se ele é um número triangulas. Um número é triangular quando é resultado do produto de três números consecutivos. Exemplo: 24 = 2 * 3 * 4.

Q24. Uma das maneiras de se conseguira raiz quadrada de um número é subtrair do número os ímpares consecutivos a partir de 1, até que o resultado da subtração seja menor ou igual a zero. O número de vezes que se conseguir fazer a subtração é a raiz quadrada exata (resultado O) ou aproximada do número (resultado negativo).

Exemplo: 

    Raiz de 16
    16-1=15-3=12-5=7-7=0

    Resultado 4, porque foram 4 subtrações.

Laços de Repetição - #14

Joao Carlos Sousa do Vale — Tue, 12 Jul 2022 23:04:01 +0000

Estruturas de repetição

Sintaxe while

A cláusula de repetição while permite que um bloco de código seja executado, repetidamente, enquanto a condição for verdadeira (True). Sua sintaxe contem:

palavra reservada while
uma condição ou expressão booleana
dois pontos (:)
bloco de código indentado (4 espaços), a ser executado se a condição while é True.

#Sintaxe while
while condição :
    instruções

Algoritmo para imprimir os números de 1 a 10:

#Algoritmo - imprimir de 1 a 10
num = 1
while num <= 10:
    print(num)
    num = num+1

Na linha 02 temos a instrução while com a condição de que enquanto o valor da variável num for menor ou igual a 10, as instruções das linhas 03 e 04 serão executadas. Note a indentação ou os 4 espaços necessários para identificar as instruções que serão executadas repetidamente.

Quando trabalhamos com o bloco while é importante controlamos a cláusula condicional, para que ela se torne falsa (False) e finalize a execução do seu laço. Caso contrário teremos um loop infinito, seu código nunca terminará de executar.

Chamamos de iteração cada vez que o laço ou o bloco de código é executado. Do exemplo anterior, o laço possui 10 iterações, e antes que cada iteração seja executada, a cláusula condicional é avaliada.

Veja o exemplo de um loop que não se encerra enquanto o usuário não digita a palavra Python:

#Algoritmo - qual linguagem? (qualLinguagem.py)
linguagem = ""
while linguagem != "Python":
    print("Qual linguagem estamos estudando? ")
    linguagem = input()
print("Parabens! Voce acertou!")

Na linha 01 iniciamos uma variável do tipo string com valor em branco. Na linha 02, iniciamos o nosso bloco while, que executará o bloco de código das linhas 03 e 04, enquanto o valor da variável linguagem não é Python.

Somente quando o bloco de repetição for finalizado (quando o usuário digitar Python), a linha 05 será executada.

#Exemplo - execução de qualLinguagem.py 
Qual linguagem estamos estudando?
c
Qual linguagem estamos estudando?
C++
Qual linguagem estamos estudando?
Java
Qual linguagem estamos estudando?
python
Qual linguagem estamos estudando?
Python
Parabens! Voce acertou!

Atribuição composta

A atribuição composta é uma forma simplificada de reutilizar a mesma variável nas operações aritméticas, como por exemplo +=, -=, *=, /=.

A expressão 2, abaixo, é a simplificação da expressão 1.

#Exemplo - sintaxe atribuição composta
#expressão 1
num = num + 5;

#expressão 2
num += 5;

Experimente algumas atribuições compostas no shell.

#Atribuição composta no shell
>>> num = 10
>>> print(num)
10

>>> num += 5
>>> print(num)
15

>>> num *= 2
>>> print(num)
30

>>> num %= 2
>>> print (num)
0

Vamos a outro exemplo, é comum o uso do laço while para deixar um programa executando até que o usuário digite algum valor para sair e finalizar a execução.

No exemplo abaixo, enquanto o usuário não digitar sair, o programa continuará executando, irá imprimir na tela o que o usuário digitou.

#Algoritmo - executeDigiteSair.py
texto = "\n Digite 'sair' para encerrar o programa"
texto += "\n Digite alguma mensagem: "

mensagem = ""

while mensagem != "sair":
    mensagem = input(texto)
    print(mensagem)

Criamos 2 variáveis, a variável texto para imprimir uma mensagem padrão ao usuário e a variável mensagem que receberá o valor digitado pelo usuário.

Observe o uso do “\n” para escrever em uma nova linha, e o uso do “+=” nas linhas 01 e 02.

Na linha 06 temos nosso laço principal, enquanto o valor de mensagem não for “sair”, o texto será mostrado e o usuário deverá digitar algo que será impresso na tela.

#Execução - executeDigiteSair.py 
 Digite 'sair' para encerrar o programa
 Digite alguma mensagem: Alguma coisa
Alguma coisa

 Digite 'sair' para encerrar o programa
 Digite alguma mensagem: teste
teste

 Digite 'sair' para encerrar o programa
 Digite alguma mensagem: sair
sair

Sintaxe for

O laço for é uma estrutura de repetição alternativa ao laço while. Ele geralmente é aplicado quando já sabemos a quantidade de interação que vamos executar.

Sua sintaxe contem:

palavra reservada for
um nome de variável
a palavra reservada in
a chamada da função range que pode receber até três argumentos ou valores
dois pontos (:)
bloco de código indentado (4 espaços), a ser executado enquanto a condição é True.

#Sintaxe for
for <variavel> in range(<valor 1>, <valor 2>, <valor 3>):
    instruções

Algoritmo para imprimir os números de 1 a 10:

#Algoritmo - imprimir de 1 a 10 usando for
for num in range(10):
    print(num+1)

Para imprimirmos de 1 a 10 usando o for (linha 01), basta definirmos uma variável num que irá variar no intervalo de 10 (range(10)). A função range gerará números de ZERO a 9, por isso foi necessário na linha 02 somar o valor de num com 1.

Instruções break e continue

As instruções break e continue são palavras reservadas que só podem ser utilizadas dentro de laços de repetição.

Instrução break

A instrução break quando é executada, encerra a execução de um laço de repetição. Quando o intepretador Python encontra um comando break, automaticamente ele sairá de dentro do loop e continuará a execução normal do programa.

O exemplo abaixo irá imprimir somente até o número 7:

#Algoritmo - imprimir de 1 a 10 modificado com break
num = 1
while num <= 10:
    print(num)
    if num == 7:
        break
    num = num+1

Veja que o condicional do while é verdadeiro enquanto o num é menor ou igual a 10 (linha 02). Na linha 04 se o num é igual a 7, o comando break será executado e encerrará a execução do loop.

Também usando o break, podemos implementar outra solução para o problema qual linguagem:

#Algoritmo - qual linguagem com break
linguagem = ""
while True:
    print("Qual linguagem estamos estudando? ")
    linguagem = input()
    if linguagem == "Python":
        break

É muito comum encontrarmos algoritmos com uma condição infinita (while True), como do exemplo acima, mas no bloco de instruções temos o break para encerrar a execução do laço.

Instrução continue

Da mesma forma que a instrução break, a instrução continue deve estar dentro de um laço de repetição.

Quando uma instrução continue é encontrada, a execução da interação corrente é interrompida e a próxima interação executada.

Podemos imprimir os números múltiplos de 5 entre 1 e 30, usando o continue:

#Algoritmo - múltiplos de 5 entre 1 e 30
num = 0
while num <= 30:
    num = num + 1
    if (num % 5 != 0):
        continue
    print(num)

O algoritmo acima não é a única e nem a melhor forma de se imprimir os múltiplos de 5, mas foi escrito para explorarmos a sintaxe do continue da linha 05.

Na linha 01 inicializamos uma variável numérica num com valor ZERO e enquanto esta variável possuir o valor menor ou igual a 30 (bloco while - linhas 02 a 06), ela será incrementada de 1 unidade e na linha 04 se o resto da divisão for diferente de ZERO, a instrução continue será executada. A instrução continue sendo executada, automaticamente a linha 06 não será chamada (número não será impresso) e o laço executará a próxima iteração.

#Execução - múltiplos de 5 entre 1 e 30 
5
10
15
20
25
30

Função range( )

Chamamos de argumento os valores que passamos para uma função.

Vimos que algumas funções não possuem argumentos, como o caso da função input( ) que espera algo ser digitado no teclado do computador, e outras que recebem um parâmetro como as funções print(‘Texto’) ou as funções str(valor), int(texto).

A função range utilizado nos laços de repetição for, pode receber até 3 argumentos, representando:

ponto de início do laço (inclusivo)
ponto final do laço (exclusivo)
incremento da iteração

#Sintaxe range
range(argumento1, argumento2, argumento3)

Sintaxe range(argumento 1)

A função range( ) quando possui somente 1 argumento, o utilizará como ponto final do laço, não incluindo o valor.

#Algoritmo - usando range com um argumento
for i in range(5):
    print(i)

O laço iniciará do valor ZERO e o incremento será de 1 unidade.

#Execução - usando range com um argumento 
0
1
2
3
4

Note que o argumento é o valor 5 (linha 01) mas ele não será utilizado, o range será de ZERO a 4.

Sintaxe range(argumento 1, argumento 2)

Quando usamos 2 argumentos na função range( ), o primeiro argumento será o valor inicial e o segundo argumento o valor final não incluso da interação.

#Algoritmo - usando range com dois argumentos
for i in range(20, 30):
    print(i)

Novamente o incremento será de 1 unidade.

#Execução - usando range com dois argumentos 
20
21
22
23
24
25
26
27
28
29

Com o range(20, 30) serão impressos os valores de 20 a 29. O número 30 não é incluído.

Se você possuir um range decrescente, com 2 argumentos, não haverá execução do laço.

Agora é a sua vez!

Reescreva o algoritmo “usando range com dois argumentos” utilizando um range(30, 20).

O que acontece na execução? Você receberá algum erro?

Experimente!

Sintaxe range(argumento 1, argumento 2, argumento 3)

Na sintaxe completa da função range( ) recebendo 3 argumentos, teremos o argumento 1 como ponto inicial, o argumento 2 como valor final exclusivo e o argumento 3 será o incremento em cada iteração.

Para entendermos, veja o exemplo abaixo imprimindo os valores de 0 a 30, de 5 em 5:

#Algoritmo - usando range com trê argumentos
for i in range(0, 31, 5):
    print(i)

Com o terceiro argumento igual a 5, o incremento será de 5 unidades.

#Execução - usando range com três argumentos 
0
5
10
15
20
25
30

O argumento de valor de iteração é flexível, aceitando valores negativos:

#Algoritmo - usando range com trê argumentos, negativo
for i in range(30, 9, -5):
    print(i)

Com o terceiro argumento igual a -5, o incremento será subtraindo 5 unidades. Ou seja, com valores negativos, teremos um decremento.

#Execução - usando range com três argumentos, negativo
30
25
20
15
10

Gerando listas numéricas com range()

O método range() pode ser utilizado para gerar listas numéricas.

#Sintaxe range para gerar listas
<lista> = list(range(<arg1>, <arg2>, <arg3>))
arg2 e arg3 são opcionais no range()

Veja alguns exemplos usando o range() na criação de listas, o código abaixo não consegue ser executado no shell, você precisa criar o arquivo .py.

#Algoritmo - gerarListas.py
print("Exemplo 01")
lista = list(range(5))
print(lista)

print("Exemplo 02")
lista = list(range(10, 15))
print(lista)

print("Exemplo 03")
lista = list(range(30, 41, 2))
print(lista)

#Execução - gerarListas.py
Exemplo 01
[0, 1, 2, 3, 4]
Exemplo 02
[10, 11, 12, 13, 14]
Exemplo 03
[30, 32, 34, 36, 38, 40]

Funções max(), min(), sum()

Com listas numéricas, podemos aplicar algumas funções úteis da linguagem, como:

max(), retorna o maior número da lista.
min(), retorna o menor número da lista.
sum(), retorna a soma dos números da lista.

#Execução - max(), min(), sum() no shell
>>> numeros = [4, 2, 8, 1]

>>> max(numeros)
8

>>> min(numeros)
1

>>> sum(numeros)
15

Percorrendo listas com for

Agora que sabemos o laço for, podemos utilizá-lo para acessar cada elemento de uma lista.

#Sintaxe for para percorrer listas
for <variavel_item> in <lista>:
    instruções

#Algoritmo - imprimindo elementos de uma lista
#Imprime cada elemento de uma lista e calcula seu dobro
lista_numeros = [6, -20, 12, 1]
for num in lista_numeros:
    print(f"Elemento: {num}")
    print("O dobro: " + str(2 * num))

Na linha 01 temos um comentário indicando a funcionalidade do algoritmo, que define uma lista de números (linha 02), e no laço for, percorre cada item da lista e usa a variável num para armazená-los.

As instruções das linhas 04 e 05 pertencem ao bloco for, identificados pela identação ou 4 espaços, e imprimem o valor de num (linha 04) e o seu dobro (linha 05).

#Execução - imprimindo elementos de uma lista 
Elemento: 6
O dobro: 12
Elemento: -20
O dobro: -40
Elemento: 12
O dobro: 24
Elemento: 1
O dobro: 2

Também é possível usar o laço for e percorrer sublistas. Por exemplo, dada uma lista de nomes, imprima os 3 primeiros e os 3 últimos elementos.

#Algoritmo - top3.py
ranking = ["Joao", "Jose", "Maria", "Igor", "Paulo", "Laura", "Andre", "Alex"]

print("Top 3: ")
for nome in ranking[:3] :
    print("\t" + nome)

print("Last 3: ")
for nome in ranking[-3:] :
    print("\t" + nome)

Nas linhas 04 e 09 usamos a sintaxe de sublistas para ler os elementos, também observe o “\t” para inserir 4 espaços na impressão da tela.

#Execução - top3.py 
Top 3: 
    Joao
    Jose
    Maria
Last 3: 
    Laura
    Andre
    Alex

Usando função enumerate()

A função enumerate() retorna o índice e o item da lista.

#Algoritmo - exemploEnumerate.py
lista_cor = ["preto", "branco", "vermelho"]
for indice, cor in enumerate(lista_cor):
    print(indice, cor)

#Execução - exemploEnumerate.py 
0 preto
1 branco
2 vermelho

Preenchendo listas com while

Podemos usar uma lista while para preencher uma lista com valores.

#Algoritmo - listaAmigos.py
amigos = []
while True:
    print("Digite o nome do amigo " + str(len(amigos) + 1) +
            " ou enter para sair:")
    name = input()
    if name == "":
        break  
    amigos.append(name)
print("Lista de amigos:")
for amigo in amigos:
    print("\t" + amigo)

No algoritmo anterior, preenchemos a lista amigos enquanto o usuário fornece algum valor. Através do uso do laço while, pedimos ao usuário que forneça o nome de um amigo, e no laço condicional da linha 06, se o valor for vazio, executamos o break e saímos do laço while.

Finalmente na linha 09, fora do bloco de repetição, imprimimos na tela a lista de amigos.

#Execução - listaAmigos.py 
Digite o nome do amigo 1 ou enter para sair:
Amigo 1
Digite o nome do amigo 2 ou enter para sair:
Joao
Digite o nome do amigo 3 ou enter para sair:
Lara
Digite o nome do amigo 4 ou enter para sair:
Paula
Digite o nome do amigo 5 ou enter para sair:

Lista de amigos:
        Amigo 1
        Joao
        Lara
        Paula

Erros comuns

Cuidado com loops infinitos, situação em que seu código nunca terminará de executar.

Veja o exemplo abaixo, usando o laço while, no qual a variável num nunca é atualizado, e nunca será maior que 10:

#Algoritmo - imprimir de 1 a 10 em loop infinito
01
02
03
num = 1
while num <= 10:
    print(num)

Se você executar o código acima, seu programa irá imprimir o número 1 infinitamente. Para forçar o encerramento do programa, você deve digitar CTRL + C ou CTRL + Z.

A indentação continua importante, as instruções são identificadas através dos 4 espaços do bloco. O algoritmo abaixo é executado mas com o comportamento diferente do esperado, a linha 05 não pertence ao bloco for.

#Algoritmo - indentação incorreta
#Imprime cada elemento de uma lista e calcula seu dobro
lista_numeros = [6, -20, 12, 1]
for num in lista_numeros:
    print(f"Elemento: {num}")
print("O dobro: " + str(2 * num))

#Execução - indentação incorreta
Elemento: 6
Elemento: -20
Elemento: 12
Elemento: 1
O dobro: 2

E não esqueça dos “:” da sintaxe.

#Erro de sintaxe - faltando os “:”
>>> for x in lista_nomes
  File "<stdin>", line 1
    for x in lista_nomes
                        ^
SyntaxError: expected ':'

Lista de Exercícios 05 - Dicionários #13

Joao Carlos Sousa do Vale — Tue, 12 Jul 2022 23:03:43 +0000

Q1. Solicite os seguintes campos de um usuário: nome, idade, sexo, altura. Armazene em um mapa e depois imprima as informações fornecidas na tela.

Q2. Crie um dicionário com os 3 maiores rios do mundo e seus países. Por exemplo “nile”: “egito”.

imprima cada chave, valor como: “O Nilo corta o Egito”;
imprima cada rio em um laço for;
imprima cada país do dicionário em um laço for.

Q3. Utilizando dicionários e listas, modele um programa que armazena o nome de uma pessoa e para cada pessoa as 3 comidas preferidas. Armazene pelo menos a informação de 3 pessoas com suas comidas preferidas e ao final imprima uma mensagem com o nome da pessoa e suas comidas preferidas.

Q4. Crie um dicionario de dicionarios representando um conjunto de cidades. A chave do dicionario principal será o nome da cidade, e o valor de cada chave será um dicionário com pelo menos 3 informações sobre a cidade, como país, população, nome. Imprima as informações de cada cidade na tela, pense na forma como você vai apresentar a informação para o usuário.

Q5. Criar um algoritmo que informe a quantidade total de calorias de uma refeição a partir da escolha do usuário 'que deverá informar o prato, a sobremesa e bebida (veja a tabela a seguir).

Prato	Sobremesa	Bebida
Vegetariano 180 cal	Abacaxi 75 cal	Chá 20 cal
Peixe 230 cal	Sorvete diet 110 cal	Suco de laranja 70 cal
Frango 250 cal	Mousse diet 170 cal	Suco de melão 100 cal
Carne 350 cal	Mousse de chocolate 200 cal	Refrigerante diet 65 cal

Dicionários em Python - #12

Joao Carlos Sousa do Vale — Tue, 12 Jul 2022 22:26:26 +0000

Introdução

Dicionários são coleções de objetos semelhantes às listas e tuplas. A principal diferença é que os dicionários armazenam uma “chave” para cada “valor”, desta forma, no jargão computacional os dicionários são mapas em Python.

Parece confuso, mas vamos explorar este conceito nas próximas seções.

Sintaxe

Dicionários ou mapas armazenam dois valores por cada elemento: uma chave e um valor. É uma estrutura de dados cuja principal finalidade é localizar elementos de forma rápida.

Utilizamos um mapa porque dada uma chave, você encontra um valor. Não existem chaves repetidas em um mapa.

Um dicionário é criado com o uso de chaves (“{ }”) e cada par chave, valor é identificado por dois pontos (“:”) e separados por vírgula (“,”).

#Sintaxe - criando dicionários
>>> mapa_cores = {"Joao":"preto", "Lara":"rosa", "Jose":"azul"}
>>> print(mapa_cores)
{'Joao': 'preto', 'Lara': 'rosa', 'Jose': 'azul'}

>>> mapa_cores_2 = {"Joao":"preto", "Lara":"rosa", "Joao":"azul"}
>>> print(mapa_cores_2)
{'Joao': 'azul', 'Lara': 'rosa'}

No mapa_cores_2 do exemplo anterior, usamos a mesma chave ‘Joao’ duas vezes, com os valores “preto” e “azul” respectivamente. Como as chaves não podem se repetir em um dicionário, o último valor prevalece, e o resultado é o par “Joao”:“azul”.

Também podemos usar dicionários para representar informações de algo em particular, por exemplo, um aluno.

#Sintaxe - representando informações específicas
>>> aluno = {"nome":"Lara", "sexo":"feminino", "idade":15, "altura":1.65}

>>> print(aluno)
{'nome': 'Lara', 'sexo': 'feminino', 'idade': 15, 'altura': 1.65}

Manipulando valores

Enquanto as listas utilizam um índice baseado na posição do elemento (índices começando na posição ZERO), os dicionários usam as chaves como índices.

Acessando valores com a chave

Se queremos ler um valor, devemos usar o valor da chave. Também é possível atualizar o valor, utilizando a chave como índice.

#Manipulando valores em um dicionário
>>> mapa_cores = {"Joao":"preto", "Lara":"rosa", "Jose":"azul"}
>>> print(mapa_cores)
{'Joao': 'preto', 'Lara': 'rosa', 'Jose': 'azul'}
>>> print(mapa_cores['Lara'])
rosa

>>> aluno = {"nome":"Lara", "sexo":"feminino", "idade":15, "altura":1.65}
>>> print("Idade da aluna %s = %s" % (aluno["nome"], aluno["idade"]))
Idade da aluna Lara = 15

Acessando valores - get()

Outra forma de acessar os valores de um dicionário é através do método get().

#Sintaxe - get()
<mapa>.get(<nome_chave>, <retorno_padrao>)

Usando o get() se a chave não existir no mapa, será retornado um valor padrão definido pelo programador.

#Usando o get()
>>> mapa_cores = {'Joao': 'preto', 'Lara': 'rosa'}
>>> mapa_cores.get('Joao', 'azul')
'preto'
>>> mapa_cores.get('Jose', 'azul')
'azul'
>>> print(mapa_cores.get('Jose'))
None

A chave ‘Jose’ não existe no mapa, então é retornado o valor ‘azul’. Caso você não forneça um valor padrão, será retornado o valor None.

Inserindo valores com a chave

Inserir valores em dicionários é mais simples do que em listas. Basta utilizar o dicionário e atribuir um novo valor para uma nova chave.

#Inserindo valores em um dicionário
>>> mapa_cores = {"Joao":"preto", "Lara":"rosa", "Jose":"azul"}
>>> print(mapa_cores)
{'Joao': 'preto', 'Lara': 'rosa', 'Jose': 'azul'}

>>> mapa_cores['Raul'] = 'vermelho'
>>> print(mapa_cores)
{'Joao': 'preto', 'Lara': 'rosa', 'Jose': 'azul', 'Raul': 'vermelho'}

>>> aluno = {"nome":"Lara", "idade":15}
>>> print(aluno)
{'nome': 'Lara', 'idade': 15}

>>> aluno["signo"] = "cancer"
>>> print(aluno)
{'nome': 'Lara', 'idade': 15, 'signo': 'cancer'}

Inserindo valores - setdefault()

O método setdefault() permite adicionar um valor padrão quando uma chave não existe no dicionário.

#Inserindo valores em um dicionário com setdefault()
>>> aluno = {"nome":"Lara"}
>>> aluno
{'nome': 'Lara'}

>>> aluno.setdefault("idade", 15)
15
>>> aluno
{'nome': 'Lara', 'idade': 15}

>>> aluno.setdefault("idade", 20)
15
>>> aluno
{'nome': 'Lara', 'idade': 15}

Observe que ao executarmos o setdefault() mais de uma vez, o valor não será mais alterado porque a chave já existe.

Removendo valores - del

O comando del também é utilizado para remover a chave e valor.

#Removendo valores em um dicionário
>>> mapa_cores = {"Joao":"preto", "Lara":"rosa", "Jose":"azul"}
>>> print(mapa_cores)
{'Joao': 'preto', 'Lara': 'rosa', 'Jose': 'azul'}

>>> del mapa_cores['Joao']

>>> print(mapa_cores)
{'Lara': 'rosa', 'Jose': 'azul'}

Percorrendo dicionários

Lendo com items()

Utilizando um laço for podemos ler a chave e o valor de um mapa, invocando o método items().

#Sintaxe - usando for para ler dicionários
for <variavel_key>, <variavel_value> in <mapa>.items():

#Programa - lerMapa.py
usuario = {
    'nome':'Maria',
    'idade':38,
    'sexo':'F'
}

for key, value in usuario.items():
    print(f"\nChave: {key}")
    print(f"Valor: {value}")

Nas linhas 01 a 05 criamos um mapa com 3 chaves: nome, idade, sexo. E usando a sintaxe for da linha 07 imprimimos as chaves e valores.

#Execução - usando for para ler dicionários
Chave: nome
Valor: Maria

Chave: idade
Valor: 38

Chave: sexo
Valor: F

Um algoritmo interessante usando o setdefault() e o for é o de contar os caracteres de uma string.

Implemente no seu ambiente.

#texto = input("Digite um texto: ")
count = {}
for letra in texto:
    count.setdefault(letra, 0)
    count[letra] += 1

print(count)

Você consegue entender o código acima? O método setdefault() é utilizado para criar um valor padrão na contagem de uma letra encontrada, caso não exista no dicionário, igual a ZERO. Desta forma, podemos manipular o campo (linha 05), incrementando o valor daquela chave. Se não tivéssemos usado o método para indicar um valor padrão, o código acima geraria um erro, uma vez que a chave não estaria presente no dicionário.

#Execução - countChar.py
Digite um texto: abacaxi
{'a': 3, 'b': 1, 'c': 1, 'x': 1, 'i': 1}

Lendo com keys()

O método keys() retorna a lista de chaves de um dicionário.

#Programa - usarKeys.py
usuario = {
    'nome':'Maria',
    'idade':38,
    'sexo':'F'
}

print("Usando Keys())")
for key in usuario.keys():
    print(f"Chave: {key}")

print("\nSem usar Keys())")
for key in usuario:
    print(f"Chave: {key}")

Na linha 12 do código anterior, é possível navegar usando somente o nome do dicionário.

#Execução - usarKeys.py
Usando Keys())
Chave: nome
Chave: idade
Chave: sexo

Sem usar Keys())
Chave: nome
Chave: idade
Chave: sexo

Lendo com values()

O método values() retorna a lista de valores de um mapa.

#Programa - usarValues.py
cores = {
    'Jose':'preto',
    'Leo':'branco',
    'Edu': 'amarelo'
}

for cor in cores.values():
    print(f"Cor: {cor}")

#Execução - usarValues.py
Cor: preto
Cor: branco
Cor: amarelo

Utilizando listas e dicionários

Listas, tuplas e dicionários são tipos de dados semelhantes aos numéricos, booleanos e strings. Desta forma podemos criar listas de dicionários, dicionários de listas, e outras variações.

Lista de dicionário

Neste exemplo, vamos criar uma lista de dicionários, representando uma turma escolar, e cada dicionário representando um aluno. Cada aluno possui uma média, e este programa irá indicar se o aluno reprovou (média < 4), ficará de recuperação (média < 7) ou se ele foi aprovado (médica >= 7).

#Programa - alunosAprovados.py
turma = [
    {'nome':'Paulo', 'media':5.5},
    {'nome':'Lara', 'media':8.5},
    {'nome':'Joca', 'media':3.2},
    {'nome':'Ze', 'media':7.0},
    {'nome':'Edu', 'media':2.4}
]

for aluno in turma:
    if aluno['media'] < 4.0:
        print(f"Aluno {aluno['nome']}: REPROVADO")
    elif aluno['media'] < 7.0:
        print(f"Aluno {aluno['nome']}: RECUPERACAO")
    else:
        print(f"Aluno {aluno['nome']}: APROVADO")

#Execução - usarValues.py
Aluno Paulo: RECUPERACAO
Aluno Lara: APROVADO
Aluno Joca: REPROVADO
Aluno Ze: APROVADO
Aluno Edu: REPROVADO

Podemos também implementar um dicionário de lista para salvar as notas de um aluno e calcular sua média.

#Programa - mediaAluno.py
aluno_01 = {
    "nome" : "Joel",
    "notas": [7.7, 10, 8.3]
}
aluno_02 = {
    "nome" : "Coringa",
    "notas": [3.2, 8, 4.0]
}
aluno_03 = {
    "nome" : "Batman",
    "notas": [8, 9, 10]
}

turma = [aluno_01, aluno_02, aluno_03]

#calcular media
for aluno in turma:
    notas = aluno["notas"]
    media = sum(notas) / len(notas)
    aluno["media"] = media

#imprimindo turma com media
print(turma)

Nas linhas 01 a 12 é criado 3 variáveis do tipo dicionário, representando 3 alunos, com nome e uma lista de notas.

Na linha 14 criamos uma turma como uma lista de alunos.

O laço for lê cada aluno na turma, e utilizando a variável aluno, calcula a sua média (somando as notas e dividindo pela quantidade de notas) e salvando no dicionário representado por aluno.

Finalmente, podemos implementar o exemplo dos alunos aprovados com a turma sendo representada como dicionário de dicionários.

#Programa - alunosAprovadosUsandoDicionario.py
turma = {
    'Paulo' : {'nome':'Paulo', 'media':5.5},
    'Lara' : {'nome':'Lara', 'media':8.5},
    'Joca' : {'nome':'Joca', 'media':3.2},
    'Ze' : {'nome':'Ze', 'media':7.0},
    'Edu' : {'nome':'Edu', 'media':2.4}
}

for nome, dados in turma.items():
    if dados['media'] < 4.0:
        print(f"Aluno {nome}: REPROVADO")
    elif dados['media'] < 7.0:
        print(f"Aluno {nome}: RECUPERACAO")
    else:
        print(f"Aluno {nome}: APROVADO")

#Execução - alunosAprovadosUsandoDicionario.py
Aluno Paulo: RECUPERACAO
Aluno Lara: APROVADO
Aluno Joca: REPROVADO
Aluno Ze: APROVADO
Aluno Edu: REPROVADO

Erros comuns

Dicionários são estruturas chave-valor, não podemos usar chaves inexistentes na lógica de nossos programas.

#Usando chaves inexistentes geram erros na execução
>>> mapa_cores = {"Joao":"preto", "Lara":"rosa"}

>>> print(mapa_cores['Zezinho'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Zezinho'

>>> del mapa_cores['Raul']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Raul'

Também não é possível fazer a junção (“+”) com dicionários.

#operação de junção não suportada
>>> mapa_cor_um = {"Joao":"preto"}
>>> mapa_cor_dois = {"Lara":"rosa"}

>>> mapa_cor_um + mapa_cor_dois
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

Tuplas em Python - #11

Joao Carlos Sousa do Vale — Tue, 12 Jul 2022 22:25:51 +0000

Introdução

Tuplas são listas que não podem ser modificadas, ao invés de utilizarem colchetes, elas utilizam parênteses em sua sintaxe. Uma estrutura que não pode ser modificada é denominada como imutável.

Neste capítulo iremos aprender as principais operações que podemos usar com tuplas.

Sintaxe

Uma tupla é criada de forma semelhante a uma lista, mas com o uso de parênteses.

#Sintaxe - criando tuplas
>>> tupla_cores = ("verde", "preto", "branco")
>>> print(tupla_cores)
('verde', 'preto', 'branco')

>>> tupla_frutas = ["coco", "banana", "uva", "morango"]
>>> print(tupla_frutas)
('coco', 'banana', 'uva', 'morango')

Convertendo tuplas e listas

Semelhante às funções int(), float(), str(), se quisermos converter uma tupla em uma lista ou uma lista em uma tupla, usamos as funções list() e tuple().

#Convertendo uma tupla em lista e vice versa
>>> tupla_cores = ("verde", "preto", "branco")

>>> lista_cores = list(tupla_cores)
>>> lista_cores
['verde', 'preto', 'branco']

>>> lista_cores.append("amarelo")

>>> tupla_cores = tuple(lista_cores)
>>> tupla_cores
('verde', 'preto', 'branco', 'amarelo')

Método partition( )

O método partition( ) é aplicado à uma string e retorna uma tupla com três valores: prefixo, separador, sufixo. A tupla de retorno sempre possui o tamanho fixo de três posições, mesmo que existam múltiplas ocorrências do separador.

Se o separador não for encontrado na string, o valor prefixo da tupla será a própria string e os campos separador e sufixo estarão vazios.

Experimente os exemplos no seu shell.

#Experimente os exemplos no seu shell.
Método partition()
>>> "banana, melao, uva".partition(",")
('banana', ',', ' melao, uva')

>>> prefixo, separador, sufixo = "banana, melao, uva".partition(",")
>>> prefixo
'banana'
>>> separador
','
>>> sufixo
' melao, uva'

>>> "Estou aprendendo Python".partition(",")
('Estou aprendendo Python', '', '')

Observe que no exemplo anterior aplicamos a atribuição múltipla na leitura dos elementos da tupla: prefixo, separador, sufixo = "banana, melao, uva".partition(",").

Erros comuns

Tuplas são somente leitura, você não pode alterar seus valores e nem adicionar elementos depois que são criadas.

#Tuplas não podem ser modificadas
>>> tupla_cores = ("verde", "preto", "branco")
>>> tupla_cores[0] = "azul"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Lista de Exercícios 04 - Listas #10

Joao Carlos Sousa do Vale — Thu, 23 Jun 2022 18:13:20 +0000

Q1. Crie uma lista com seus jogos ou hobbies favoritos e armazene em uma variável chamada games. Crie uma lista com suas comidas favoritas e atribua a uma variável chamada foods. Finalmente, faça a junção (“+”) das duas listas e salve na variável favorites. Imprima na tela a variável favorites.

Q2. Crie uma lista cores com os valores verde, amarelo e vermelho em qualquer ordem e quantidade. Usando um laço for verifique cada elemento da lista e imprima:

se a cor é verde, “voce ganhou 5 pontos”
se a cor é amarela, “voce ganhou 3 pontos”
se a cor é vermelha, “voce ganhou 1 ponto”

Q3. Crie um programa para simular a criação de logins de um website.

crie uma lista de usuarios_atuais com 5 ou mais nomes de usuário
crie uma outra lista usuarios_novos com 5 nomes de usuários, sendo 2 deles existentes na lista usuarios_atuais.
percorra a lista usuarios_novos e verifique se já foram utilizados (presentes em usuarios_atuais). Se presente, imprima uma mensagem indicando que o nome de usuário já foi utilizado. Senão imprima que o nome de usuário está disponível.
a comparação deve ignorar maiúsculas e minúsculas. Por exemplo ‘Joao’ e ‘JOAO’ são considerados iguais.

Q4. Crie um algoritmo que imprima os elementos de uma lista, sem repetir a impressão.

Por exemplo: lista = [1, 5, 2, 4, 1, 3, 5]

Impressão: 1, 5, 2, 4, 3 sem repetir o 1 e o 5.

Q5. Entrar com um nome e imprimi-lo se o primeiro caractere for a letra A (considerar letra minúscula ou maiúscula).

Q6. Entrar com o nome de uma pessoa e so imprimí-lo se o prenome for PAULA, não considerar maiúsculas e minúsculas.

Q7. Crie um programa que faça a distribuição de uma lista de alunos em 3 salas. Cada sala é representada por uma lista e que devem ser impressas no final da distribuição.

Regra de distribuição utiliza a primeira letra do nome do aluno:

“A - K”: sala 101
“L - N”: sala 102
“O - Z”: sala 103

Por exemplo: o aluno Lucas deve ser distribuído na sala 102 e o aluno Pedro na sala 103.

Q8. Criar um algoritmo que leia uma data (no formato ddmmaaaa) e imprimir se a data é válida ou não.

Q9. Dada a seguinte lista de listas:

matriz

matriz = [

['00', '01', '02', '03'],

['10', '11', '12', '13'],

['20', '21', '22', '23'],

['30', '31', '32', '33']

]

Observe que cada lista da matriz possui elementos iniciando com sua posição na lista, por exemplo, o elemento “13” está na 2a. lista (índice 1) e é o quarto elemento (índice 3).

Desta forma, o elemento da 3a. lista e 2a. posição é o “21”.

Faça:

imprima a matriz na tela, tente manter cada lista em uma linha

            ```
             00 01 02 03
             10 11 12 13
             20 21 22 23
             30 31 32 33
            ```

imprima os valores acima da diagonal principal

            ```
             00 01 02 03
                11 12 13
                  22 23
                     33
            ```

imprima a diagonal principal

imprima os valores abaixo da diagonal principal

            ```
             00 
             10 11
             20 21 22
             30 31 32 33
            ```

acima da diagonal principal

            ```
             00 01 02 03
             10 11 12 
             20 21 
             30
            ```

diagonal secundária

abaixo da diagonal secundária

            ```
                      03
                   12 13
                21 22 23
             30 31 32 33
            ```

Q10. Crie um algoritmo que leia os elementos de um vetor com 20 posições e escreva-o. Em seguida, troque o primeiro elemento pelo último, o segundo pelo penúltimo, o terceiro pelo antepenúltimo, e assim sucessivamente. Mostre o vetor depois das trocas.

DEV Community: Joao Carlos Sousa do Vale

Comandos básicos GIT e vídeo de uso no JetBrains

Conteúdo

Vídeo - Git e Github sem linhas de comando

Introdução

E o tal do GitHub?

Instalando o GIT

Cenário de Estudo

Comando 01 - git init

Comando 02 - git status

Comando 03 - git add

Comando 04 - git commit

Comando 05 - git log

Alterando e adicionando diversos arquivos

Comando 07 - git diff

Comando 08 - git branch

Opção 2:

Comando 09 - git merge

Comandos com repositórios remotos

Git clone

Git pull

Git push

Palavras finais

Technical Interview - Code #007 - LeetCode #606. Construct String from Binary Tree

Level

Complexidade

Topicos

Problema

Exemplo

Implementar

Fonte

LinkedIn

GitHub

Technical Interview - Code #006 - LeetCode #814. Binary Tree Pruning

Level

Complexidade

Topicos

Problema

Exemplo

Implementar

Fonte

LinkedIn

GitHub

Projeto Final - Python #18

Lista de Exercícios 07 - Funções #17

Funções em Python - #16

Introdução

Função bool()

Função abs()

Usando módulos

Instrução import

Instrução from - import

Usando alias

Mútiplos imports

Módulo time

Função asctime( )

Função time( )

Função localtime( )

Módulo copy

Função copy( )

Função deepcopy

Módulo random

Função random.choice()

Função random.shuffle()

Módulo pprint

Função pprint()

Função pformat()

Módulo sys

Função sys.exit( )

Criando funções

Parâmetros de função (entrada)

Instrução return (saída)

Escopo de variáveis

Palavra global

Pilha de execução

Função recursiva

Criando seus próprios módulos

Outros recursos das funções

Argumentos nomeados

Parâmetros opcionais