├── Exercicios ├── 001 - Deixando tudo pronto.py ├── 002 - Respondendo ao Usuário.py ├── 003 - Somando dois números.py ├── 004 - Dissecando uma Variável.py ├── 005 - Antecessor e Sucessor.py ├── 006 - Dobro, Triplo, Raiz Quadrada.py ├── 007 - Média Aritmética.py ├── 008 - Conversor de Medidas.py ├── 009 - Tabuada.py ├── 010 - Conversor de Moedas.py ├── 011 - Pintando Parede.py ├── 012 - Calculando Descontos.py ├── 013 - Reajuste Salarial.py ├── 014 - Conversor de Temperaturas.py ├── 015 - Aluguel de Carros.py ├── 016 - Quebrando um número.py ├── 017 - Catetos e Hipotenusa.py ├── 018 - Seno, Cosseno e Tangente.py ├── 019 - Sorteando um item na lista.py ├── 020 - Sorteando uma ordem na lista.py ├── 021 - Tocando um MP3.py ├── 022 - Analisador de Textos.py ├── 023 - Separando dígitos de um número.py ├── 024 - Verificando as primeiras letras de um texto.py ├── 025 - Procurando uma string dentro de outra.py ├── 026 - Primeira e última ocorrência de uma string.py ├── 027 - Primeiro e último nome de uma pessoa.py ├── 028 - Jogo da Adivinhação v.1.0.py ├── 029 - Radar eletrônico.py ├── 030 - Par ou Ímpar.py ├── 031 - Custo da Viagem.py ├── 032 - Ano Bissexto.py ├── 033 - Maior e menor valores.py ├── 034 - Aumentos múltiplos.py ├── 035 - Analisando Triângulo v1.0.py ├── 036 - Aprovando Empréstimo.py ├── 037 - Conversor de Bases Numéricas.py ├── 038 - Comparando números.py ├── 039 - Alistamento Militar.py ├── 040 - Aquele clássico da Média.py ├── 041 - Classificando Atletas.py ├── 042 - Analisando Triângulos v2.0.py ├── 043 - Índice de Massa Corporal.py ├── 044 - Gerenciador de Pagamentos.py ├── 045 - GAME Pedra Papel e Tesoura.py ├── 046 - Contagem regressiva.py ├── 047 - Contagem de pares.py ├── 048 - Soma ímpares múltiplos de três.py ├── 049 - Tabuada v.2.0.py ├── 050 - Soma dos pares.py ├── 051 - Progressão Aritmética.py ├── 052 - Números primos.py ├── 053 - Detector de Palíndromo.py ├── 054 - Grupo da Maioridade.py ├── 055 - Maior e menor da sequência.py ├── 056 - Analisador completo.py ├── 057 - Validação de Dados.py ├── 058 - Jogo da Adivinhação v2.0.py ├── 059 - Criando um Menu de Opções.py ├── 060 - Cálculo do Fatorial.py ├── 061 - Progressão Aritmética v2.0.py ├── 062 - Super Progressão Aritmética v3.0.py ├── 063 - Sequência de Fibonacci v1.0.py ├── 064 - Tratando vários valores v1.0.py ├── 065 - Maior e Menor valores.py ├── 066 - Vários números com flag.py ├── 067 - Tabuada v3.0.py ├── 068 - Jogo do Par ou Ímpar.py ├── 069 - Análise de dados do grupo.py ├── 070 - Estatísticas em produtos.py ├── 071 - Simulador de Caixa Eletrônico.py ├── 072 - Número por Extenso.py ├── 073 - Tuplas com Times de Futebol.py ├── 074 - Maior e menor valores em Tupla.py ├── 075 - Análise de dados em uma Tupla.py ├── 076 - Lista de Preços com Tupla.py ├── 077 - Contando vogais em Tupla.py ├── 078 - Maior e Menor valores na Lista.py ├── 079 - Valores únicos em uma Lista.py ├── 080 - Lista ordenada sem repetições.py ├── 081 - Extraindo dados de uma Lista.py ├── 082 - Dividindo valores em várias listas.py ├── 083 - Validando expressões matemáticas.py ├── 084 - Lista composta e análise de dados.py ├── 085 - Listas com pares e ímpares.py ├── 086 - Matriz em Python.py ├── 087 - Mais sobre Matriz em Python.py ├── 088 - Palpites para a Mega Sena.py ├── 089 - Boletim com listas compostas.py ├── 090 - Dicionário.py ├── 091 - Jogo de Dados.py ├── 092 - Cadastro de Trabalhador.py ├── 093 - Cadastro de Jogador de Futebol.py ├── 094 - Unindo Dicionários e Listas.py ├── 095 - Aprimorando os Dicionários.py ├── 096 - Função que calcula área.py ├── 097 - Um print especial.py ├── 098 - Função de Contador.py ├── 099 - Função que descobre o maior.py ├── 100 - Funções para sortear e somar.py ├── 101 - Funções para votação.py ├── 102 - Função para Fatorial.py ├── 103 - Ficha do Jogador.py ├── 104 - Validando entrada de dados.py ├── 105 - Analisando e gerando Dicionários.py ├── 106 - Sistema interativo de ajuda.py ├── 107 - Exercitando módulos.py ├── 108 - Formatando Moedas.py ├── 109 - Formatando Moedas.py ├── 110 - Reduzindo ainda mais seu programa.py ├── 111 - Transformando módulos em pacotes.py ├── 112 - Entrada de dados monetários.py ├── 113 - Funções aprofundadas em Python.py ├── 114 - Site está acessível.py ├── 115 - Cadastro de Pessoas (Arquivo).py ├── 115 - Modulo Pessoas.py ├── pacote │ ├── __init__.py │ ├── __pycache__ │ │ └── __init__.cpython-37.pyc │ ├── dados │ │ ├── __init__.py │ │ └── __pycache__ │ │ │ └── __init__.cpython-37.pyc │ └── moeda │ │ ├── __init__.py │ │ └── __pycache__ │ │ └── __init__.cpython-37.pyc └── temp.md └── README.md /Exercicios/001 - Deixando tudo pronto.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 001 - Deixando tudo pronto 2 | # Crie um programa que escreva "Olá, Mundo" na tela. 3 | 4 | print("Olá, Mundo!") 5 | -------------------------------------------------------------------------------- /Exercicios/002 - Respondendo ao Usuário.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 002 - Respondendo ao Usuário 2 | # Faça um programa que leia o nome de uma pessoa e mostre uma mensagem de boas-vindas. 3 | 4 | nome = str(input("Informe seu nome: ")) 5 | print("É um prazer de conhecer, {}!".format(nome)) 6 | -------------------------------------------------------------------------------- /Exercicios/003 - Somando dois números.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 003 - Somando dois números 2 | # Crie um programa que leia dois números e mostre a soma entre eles. 3 | 4 | n1 = int(input("Informe o primeiro número: ")) 5 | n2 = int(input("Informe o sengundo número: ")) 6 | 7 | print("A soma entre {} e {} é igual a {}!".format(n1, n2, n1+n2)) 8 | -------------------------------------------------------------------------------- /Exercicios/004 - Dissecando uma Variável.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 004 - Dissecando uma Variável 2 | # Faça um programa que leia algo pelo teclado 3 | # e mostre na tela o seu tipo primitivo e todas as informações possíveis sobre ele. 4 | 5 | frase = str(input("Digite algo: ")) 6 | 7 | print("O tipo primitivo desse valor é {}".format(type(frase))) 8 | print("Só tem espaços? {}".format(frase.isspace())) 9 | print("É um número? {}".format(frase.isnumeric())) 10 | print("É alfabético? {}".format(frase.isalpha())) 11 | print("É alfanumérico? {}".format(frase.isalnum())) 12 | print("Esta em maiúsculas? {}".format(frase.isupper())) 13 | print("Esta em minúsculas? {}".format(frase.islower())) 14 | print("Esta capilatizado? {}".format(frase.istitle())) 15 | -------------------------------------------------------------------------------- /Exercicios/005 - Antecessor e Sucessor.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 005 - Antecessor e Sucessor 2 | # Faça um programa que leia um número Inteiro 3 | # e mostre na tela o seu sucessor e seu antecessor. 4 | 5 | from time import sleep 6 | 7 | n = int(input("Digite um número: ")) 8 | print("Analisando o número {}...".format(n)) 9 | sleep(1) 10 | print("Antecessor: {}".format(n-1)) 11 | print("Sucessor: {}".format(n+1)) 12 | -------------------------------------------------------------------------------- /Exercicios/006 - Dobro, Triplo, Raiz Quadrada.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 006 - Dobro, Triplo, Raiz Quadrada 2 | # Crie um algoritmo que leia um número e mostre o seu dobro, triplo e raiz quadrada. 3 | 4 | from time import sleep 5 | 6 | n = int(input("Digite um número: ")) 7 | print("Analisando o número {}".format(n)) 8 | sleep(1) 9 | 10 | print("Dobro: {}".format(n*2)) 11 | print("Triplo: {}".format(n*3)) 12 | print("Raiz quadrada: {:.2f}".format(n**(1/2))) 13 | -------------------------------------------------------------------------------- /Exercicios/007 - Média Aritmética.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 007 - Média Aritmética 2 | # Desenvolva um programa que leia as duas notas de um aluno, calcule e mostre a sua média. 3 | 4 | n1 = float(input("Primeira nota: ")) 5 | n2 = float(input("Segunda nota: ")) 6 | media = (n1 + n2) / 2 7 | 8 | print("A média do aluno é {:.1f}".format(media)) 9 | -------------------------------------------------------------------------------- /Exercicios/008 - Conversor de Medidas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 008 - Conversor de Medidas 2 | # Escreva um programa que leia um valor em metros e o exiba convertido em centímetros e milímetros. 3 | 4 | m = float(input("Uma distância em metros: ")) 5 | cm = m * 100 6 | mm = m * 1000 7 | 8 | print("{}m corresponde a {}cm e {}mm".format(m, cm, mm)) 9 | -------------------------------------------------------------------------------- /Exercicios/009 - Tabuada.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 009 - Tabuada 2 | # Faça um programa que leia um número Inteiro qualquer e mostre na tela a sua tabuada. 3 | 4 | # cores 5 | cor = {'azul': '\033[34m', 6 | 'lilas': '\033[35m'} 7 | 8 | n = int(input("Informe um número para ver sua tabuada: ")) 9 | print("{}-=".format(cor['lilas'])*7) 10 | 11 | i = 1 12 | while i <= 10: 13 | print("{}{} x {:2} = {:3}".format(cor['azul'], n, i, n * i)) 14 | i = i + 1 15 | 16 | print("{}-=".format(cor['lilas'])*7) 17 | -------------------------------------------------------------------------------- /Exercicios/010 - Conversor de Moedas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 010 - Conversor de Moedas 2 | # Crie um programa que leia quanto dinheiro uma pessoa tem na carteira e mostre quantos dólares ela pode comprar. 3 | 4 | real = float(input("Quanto dinheiro você tem na carteira? R$")) 5 | dolar = real / 3.85 6 | print(("Com R${:.2f} você pode comprar ${:.2f}".format(real, dolar))) 7 | -------------------------------------------------------------------------------- /Exercicios/011 - Pintando Parede.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 011 - Pintando Parede 2 | # Faça um programa que leia a largura e a altura de uma parede em metros, 3 | # calcule a sua área e a quantidade de tinta necessária para pintá-la, 4 | # sabendo que cada litro de tinta pinta uma área de 2 metros quadrados. 5 | 6 | larg = float(input("Largura da parede: ")) 7 | alt = float(input("Altura da parede: ")) 8 | area = larg * alt 9 | tinta = area / 2 10 | 11 | print("Sua parde tem a dimensão de {}x{} e a sua área é de {}m²".format(larg, alt, area)) 12 | print("Para pintar essa parede, você precisará de {}L de tinta".format(tinta)) 13 | -------------------------------------------------------------------------------- /Exercicios/012 - Calculando Descontos.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 012 - Calculando Descontos 2 | # Faça um algoritmo que leia o preço de um produto e mostre seu novo preço, com 5% de desconto. 3 | 4 | p = float(input("Qual o preço do produto? ")) 5 | print("O produto que custava R${:.2f}, na promoção com desconto de 5% vai custar R${:.2f}".format(p, p-(p * 5 / 100))) 6 | -------------------------------------------------------------------------------- /Exercicios/013 - Reajuste Salarial.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 013 - Reajuste Salarial 2 | # Faça um algoritmo que leia o salário de um funcionário e mostre seu novo salário, com 15% de aumento. 3 | 4 | s = float(input("Qual o salário do funcionário? R$")) 5 | print("Um funcionário que ganhava R${:.2f}, com 15% de aumento, passa a receber R${:.2f}".format(s, s+(s * 15 / 100))) 6 | -------------------------------------------------------------------------------- /Exercicios/014 - Conversor de Temperaturas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 014 - Conversor de Temperaturas 2 | # Escreva um programa que converta uma temperatura digitando em graus Celsius e converta para graus Fahrenheit. 3 | 4 | c = float(input("Informe a temperatura em ºC: ")) 5 | f = (9 * c / 5)+32 6 | 7 | print("A temperatura de {:.1f}ºC corresponte a {:.1f}ºF".format(c, f)) 8 | -------------------------------------------------------------------------------- /Exercicios/015 - Aluguel de Carros.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 015 - Aluguel de Carros 2 | # Escreva um programa que pergunte a quantidade de Km percorridos 3 | # por um carro alugado e a quantidade de dias pelos quais ele foi alugado. 4 | # Calcule o preço a pagar, sabendo que o carro custa R$60 por dia e R$0,15 por Km rodado. 5 | 6 | dias = int(input("Quantos dias alugados? ")) 7 | km = float(input("Quantos Km rodados? ")) 8 | valor = dias * 60 + km * 0.15 9 | print("O total a pagar é R${:.2f}".format(valor)) 10 | -------------------------------------------------------------------------------- /Exercicios/016 - Quebrando um número.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 016 - Quebrando um número 2 | # Crie um programa que leia um número Real qualquer pelo teclado e mostre na tela a sua porção Inteira. 3 | 4 | from math import trunc 5 | n = float(input("Digite um valor: ")) 6 | print("O valor digitado foi {} e sua porção inteira é {}.".format(n, trunc(n))) 7 | -------------------------------------------------------------------------------- /Exercicios/017 - Catetos e Hipotenusa.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 017 - Catetos e Hipotenusa 2 | # Faça um programa que leia o comprimento do cateto oposto 3 | # e do cateto adjacente de um triângulo retângulo. 4 | # Calcule e mostre o comprimento da hipotenusa. 5 | 6 | from math import hypot 7 | co = float(input("Cateto Oposto: ")) 8 | ca = float(input("Cateto Adjacente: ")) 9 | h = hypot(co, ca) 10 | hp = (co ** 2 + ca ** 2) ** (1/2) 11 | 12 | print("A hipotenusa vai medir: {:.2f}".format(h)) 13 | -------------------------------------------------------------------------------- /Exercicios/018 - Seno, Cosseno e Tangente.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 018 - Seno, Cosseno e Tangente 2 | # Faça um programa que leia um ângulo qualquer e mostre na tela 3 | # o valor do seno, cosseno e tangente desse ângulo. 4 | 5 | import math 6 | 7 | a = float(input("Digite o ângulo que você deseja: ")) 8 | print("Seno: {:.2f}".format(math.sin(math.radians(a)))) 9 | print("Cosseno: {:.2f}".format(math.cos(math.radians(a)))) 10 | print("Tangente: {:.2f}".format(math.tan(math.radians(a)))) 11 | -------------------------------------------------------------------------------- /Exercicios/019 - Sorteando um item na lista.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 019 - Sorteando um item na lista 2 | # Um professor quer sortear um dos seus quatro alunos para apagar o quadro. 3 | # Faça um programa que ajude ele, lendo o nome dos alunos e escrevendo na tela o nome do escolhido. 4 | 5 | from random import choice 6 | a1 = str(input("Primeiro aluno: ")) 7 | a2 = str(input("Segundo aluno: ")) 8 | a3 = str(input("Terceiro aluno: ")) 9 | a4 = str(input("Quarto aluno: ")) 10 | lista = [a1, a2, a3, a4] 11 | print("O aluno escolhido foi {}".format(choice(lista))) 12 | -------------------------------------------------------------------------------- /Exercicios/020 - Sorteando uma ordem na lista.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 020 - Sorteando uma ordem na lista 2 | # O mesmo professor do desafio 019 quer sortear a ordem de 3 | # apresentação de trabalhos dos alunos. Faça um programa que 4 | # leia o nome dos quatro alunos e mostre a ordem sorteada. 5 | 6 | from random import shuffle 7 | a1 = str(input("Primeiro aluno: ")) 8 | a2 = str(input("Segundo aluno: ")) 9 | a3 = str(input("Terceiro aluno: ")) 10 | a4 = str(input("Quarto aluno: ")) 11 | lista = [a1, a2, a3, a4] 12 | shuffle(lista) 13 | print("A ordem de apresentação séra") 14 | print(lista) 15 | -------------------------------------------------------------------------------- /Exercicios/021 - Tocando um MP3.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 021 - Tocando um MP3 2 | # Faça um programa em Python que abra e reproduza o áudio de um arquivo MP3. 3 | 4 | import pygame 5 | pygame.init() 6 | pygame.mixer.music.load('endereço') 7 | pygame.mixer.music.play() 8 | pygame.event.wait() 9 | -------------------------------------------------------------------------------- /Exercicios/022 - Analisador de Textos.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 022 - Analisador de Textos 2 | # Crie um programa que leia o nome completo de uma pessoa e mostre: 3 | # - O nome com todas as letras maiúsculas e minúsculas. 4 | # - Quantas letras ao todo (sem considerar espaços). 5 | # - Quantas letras tem o primeiro nome. 6 | 7 | 8 | nome = str(input("Informe seu nome completo: ")).strip() 9 | print("Seu nome em maisculas é {}".format(nome.upper())) 10 | print("Seu nome em minúsculas é {}".format(nome.lower())) 11 | print("Seu nome tem ao todo {} letras".format(len(nome) - nome.count(' '))) 12 | 13 | print("Seu primeiro nome é {} e ele tem {} letras.".format(nome[:nome.find(' ')], nome.find(' '))) 14 | -------------------------------------------------------------------------------- /Exercicios/023 - Separando dígitos de um número.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 023 - Separando dígitos de um número 2 | # Faça um programa que leia um número de 0 a 9999 3 | # e mostre na tela cada um dos dígitos separados. 4 | 5 | 6 | num = int(input("Informe um número entre 0 a 9999: ")) 7 | print("Analisando o número {}".format(num)) 8 | 9 | n = str(num) 10 | 11 | if (num >= 0) and (num <= 9): 12 | print("Unidade {}".format(n[0])) 13 | 14 | elif (num >= 10) and (num <= 99): 15 | print("Unidade {}".format(n[1])) 16 | print("Dezena {}".format(n[0])) 17 | 18 | elif (num >= 100) and (num <= 199): 19 | print("Unidade {}".format(n[2])) 20 | print("Dezena {}".format(n[1])) 21 | print("Centena {}".format(n[0])) 22 | 23 | elif (num >= 1000) and (num <= 1999): 24 | print("Unidade {}".format(n[3])) 25 | print("Dezena {}".format(n[2])) 26 | print("Centena {}".format(n[1])) 27 | print("Milhar {}".format(n[0])) 28 | 29 | else: 30 | print("Número fora do requisito") 31 | -------------------------------------------------------------------------------- /Exercicios/024 - Verificando as primeiras letras de um texto.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 024 - Verificando as primeiras letras de um texto 2 | # Faça um programa que leia o nome de uma cidade 3 | # e diga se ela começa ou não com o nome "Santos". 4 | 5 | cidade = str(input("Informe o nome da cidade onde você nasceu: ")).strip() 6 | print(cidade[:5] == 'Santo') 7 | -------------------------------------------------------------------------------- /Exercicios/025 - Procurando uma string dentro de outra.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 025 - Procurando uma string dentro de outra 2 | # Faça um programa que leia o nome de uma pessoa 3 | # e diga se ela tem "Silva" no nome. 4 | 5 | 6 | nome = str(input("Informe seu nome: ")) 7 | print('Silva' in nome) 8 | -------------------------------------------------------------------------------- /Exercicios/026 - Primeira e última ocorrência de uma string.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 026 - Primeira e última ocorrência de uma string 2 | # Faça um programa que leia uma frase pelo teclado e mostre: 3 | # - Quantas vezes aparece a letra 'A' 4 | # - Em que posição ela aparece a primeira vez 5 | # - Em que posição ela aparece a última vez 6 | 7 | 8 | nome = str(input("Informe seu nome: ")).upper().strip() 9 | print("A letra 'A' aparece {} vezes".format(nome.count('A'))) 10 | print("A primeira vez aparece na {} posição".format(nome.find('A')+1)) 11 | print("A última vez aparece na {} posição".format(nome.rfind('A'))) 12 | -------------------------------------------------------------------------------- /Exercicios/027 - Primeiro e último nome de uma pessoa.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 027 - Primeiro e último nome de uma pessoa 2 | # Faça um programa que leia o nome completo de uma pessoa 3 | # moastrando em seguido o primeiro e ultimo nome separadamente. 4 | 5 | nome = str(input("Informe seu nome completo: ")).strip() 6 | 7 | n = nome.split() 8 | print("Seu primeiro nome é {}.".format(n[0])) 9 | print("Seu sobrenome é: {}.".format(n[len(n)-1])) 10 | -------------------------------------------------------------------------------- /Exercicios/028 - Jogo da Adivinhação v.1.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 028 - Jogo da Adivinhação v.1.0 2 | # Escreva um programa que faça o computador "pensar" em um número inteiro entre 0 e 5 3 | # e peça para o usuário tentar descobrir qual foi o número escolhido pelo computador. 4 | # O programa deverá escrever na tela se o usuário venceu ou perdeu. 5 | 6 | from random import randint 7 | from time import sleep 8 | 9 | # cores 10 | cor = {'limpa': '\033[m', 11 | 'vermelho': '\033[31m', 12 | 'verde': '\033[32m', 13 | 'amarelo': '\033[33m', 14 | 'azul': '\033[34m', 15 | 'lilas': '\033[35m'} 16 | 17 | print("{}-=-{}".format(cor['amarelo'], cor['limpa']) * 19) 18 | print("{}Vou pensar em um número entre 0 e 5. Tente adivinhar...{}".format(cor['azul'], cor['limpa'])) 19 | print("{}-=-{}".format(cor['amarelo'], cor['limpa']) * 19) 20 | 21 | computador = randint(0, 5) 22 | jogador = int(input("Em que número eu pensei? ")) 23 | 24 | print("{}Processando...{}".format(cor['lilas'], cor['limpa'])) 25 | sleep(3) 26 | 27 | if jogador == computador: 28 | print("{}PARABPENS! Você acertou!{}".format(cor['verde'], cor['limpa'])) 29 | else: 30 | print("{}Que pena, você errou. Pensei no número {}{}".format(cor['vermelho'], computador, cor['limpa'])) 31 | -------------------------------------------------------------------------------- /Exercicios/029 - Radar eletrônico.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 029 - Radar eletrônico 2 | # Escreva um programa que leia a velocidade de um carro. Se ele ultrapassar 80Km/h, 3 | # mostre uma mensagem dizendo que ele foi multado. 4 | # A multa vai custar R$7,00 por cada Km acima do limite. 5 | 6 | # cores 7 | cor = {'limpa': '\033[m', 8 | 'vermelho': '\033[31m', 9 | 'amarelo': '\033[33m'} 10 | 11 | velocidade = int(input("Qual a velocidade atual do carro? ")) 12 | 13 | if velocidade < 0: 14 | print("Velocidade Inválida") 15 | 16 | elif (velocidade >= 0) and (velocidade <= 80): 17 | print("{}Tenha um bom dia e dirija com segurança!{}".format(cor['amarelo'], cor['limpa'])) 18 | 19 | else: 20 | print("{}MULTADO! você excedeu o limite permitido que é 80Km/h".format(cor['vermelho'])) 21 | print("Você deve pagar uma multa de {}R${:.2f}!{}".format(cor['amarelo'], (velocidade-80)*7, cor['limpa'])) 22 | -------------------------------------------------------------------------------- /Exercicios/030 - Par ou Ímpar.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 030 - Par ou Ímpar? 2 | # Crie um programa que leia um número inteiro e mostre na tela se ele é PAR ou ÍMPAR. 3 | 4 | # cores 5 | cor = {'limpa': '\033[m', 6 | 'azul': '\033[34m', 7 | 'lilas': '\033[35m'} 8 | 9 | numero = int(input("{}Me diga um número qualquer: ".format(cor['lilas']))) 10 | print("O número {} é {}{}".format(numero, cor['azul'], 'PAR'if numero % 2 == 0 else 'ÍMPAR')) 11 | -------------------------------------------------------------------------------- /Exercicios/031 - Custo da Viagem.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 031 - Custo da Viagem 2 | # Desenvolva um programa que pergunte a distância de uma viagem em Km. 3 | # Calcule o preço da passagem, cobrando R$0,50 por Km para viagens de até 4 | # 200Km e R$0,45 parta viagens mais longas. 5 | 6 | distancia = float(input("Qual a distância da sua viagem? ")) 7 | 8 | print("Você está prestes a começar uma viage de {:.1f}Km.".format(distancia)) 9 | print("E o preço da sua viagem será de R${:.2f}".format(distancia*0.5 if distancia <= 200 else distancia*0.45)) 10 | -------------------------------------------------------------------------------- /Exercicios/032 - Ano Bissexto.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 032 - Ano Bissexto 2 | # Faça um programa que leia um ano qualquer e mostre se ele é bissexto. 3 | 4 | from datetime import date 5 | ano = int(input("Que ano quer analisar? Digite 0 para analisar o ano atual: ")) 6 | 7 | if ano == 0: 8 | ano = date.today().year 9 | 10 | if (ano % 4 == 0) and (ano % 100 != 0) or (ano % 400 == 0): 11 | print("O ano {} é BISSEXTO".format(ano)) 12 | else: 13 | print("O ano {} NÃO é BISSEXTO".format(ano)) 14 | -------------------------------------------------------------------------------- /Exercicios/033 - Maior e menor valores.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 033 - Maior e menor valores 2 | # Faça um programa que leia três números e mostre qual é o maior e qual é o menor. 3 | 4 | a = int(input("Primeiro valor: ")) 5 | b = int(input("Segundo valor: ")) 6 | c = int(input("Terceiro valor: ")) 7 | 8 | # Verificando o maior valor 9 | if a > b and a > c: 10 | maior = a 11 | elif b > a and b > c: 12 | maior = b 13 | else: 14 | maior = c 15 | 16 | # Verificando o menor valor 17 | if a < b and a < c: 18 | menor = a 19 | elif b < a and b < c: 20 | menor = b 21 | else: 22 | menor = c 23 | 24 | print("O maior valor digitado foi: {}".format(maior)) 25 | print("O menor valor digitado foi: {}".format(menor)) 26 | -------------------------------------------------------------------------------- /Exercicios/034 - Aumentos múltiplos.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 034 - Aumentos múltiplos 2 | # Escreva um programa que pergunte o salário de um funcionário e calcule o valor do seu aumento. 3 | # Para salários superiores a R$1250,00, calcule um aumento de 10%. Para os inferiores ou iguais, o aumento é de 15%. 4 | 5 | salario = float(input('Qual é o salário do funcionário? R$')) 6 | 7 | if salario > 1250: 8 | novo_salario = salario + (salario*10 / 100) 9 | else: 10 | novo_salario = salario + (salario*15 / 100) 11 | 12 | print("Quem ganhava R${:.2f} passa a ganhar R${:.2f} agora.".format(salario, novo_salario)) 13 | -------------------------------------------------------------------------------- /Exercicios/035 - Analisando Triângulo v1.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 035 - Analisando Triângulo v1.0 2 | # Desenvolva um programa que leia o comprimento de três retas 3 | # e diga ao usuário se elas podem ou não formar um triângulo. 4 | 5 | print("-=" * 12) 6 | print("Analisador de Triângulos") 7 | print("-=" * 12) 8 | 9 | r1 = float(input("Primeiro segmento: ")) 10 | r2 = float(input("Segundo segmento: ")) 11 | r3 = float(input("Teceiro segmento: ")) 12 | 13 | if r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2: 14 | print("Os segmentos acima podem formar triângulo") 15 | else: 16 | print("Os segmentos acima não podem formar triângulo") 17 | -------------------------------------------------------------------------------- /Exercicios/036 - Aprovando Empréstimo.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 036 - Aprovando Empréstimo 2 | # Escreva um programa para aprovar o empréstimo bancário para a compra de uma casa. 3 | # Pergunte o valor da casa, o salário do comprador e em quantos anos ele vai pagar. 4 | # A prestação mensal não pode exceder 30% do salário ou então o empréstimo será negado. 5 | 6 | casa = float(input("Informe o valor do imóvel: ")) 7 | salario = float(input("Informe sua renda mensal: ")) 8 | anos = int(input("Informe em quantos anos de financiamento: ")) 9 | 10 | prestacao = casa / (anos * 12) 11 | 12 | if prestacao > (salario*30/100): 13 | print("Infelizmente, o empréstimo foi negado pois a porestação é superior a 30% de sua renda mensal.") 14 | else: 15 | print("Empréstimo aceito. A prestação será de R${:.2f}. Para pagemtno em {} meses.".format(prestacao, anos * 12)) 16 | -------------------------------------------------------------------------------- /Exercicios/037 - Conversor de Bases Numéricas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 037 - Conversor de Bases Numéricas 2 | # Escreva um programa em Python que leia um número inteiro qualquer 3 | # e peça para o usuário escolher qual será a base de conversão: 4 | # 1 para binário, 2 para octal e 3 para hexadecimal. 5 | 6 | num = int(input("Informe um número: ")) 7 | op = int(input("""1 - Binário. 8 | 2 - Octal. 9 | 3 - Hexadecimal 10 | 11 | Converter para: """)) 12 | 13 | if op == 1: 14 | print("Binário: {}".format(bin(num)[2:])) 15 | elif op == 2: 16 | print("Octal: {}".format(oct(num)[2:])) 17 | elif op == 3: 18 | print("Hexadecimal: {}".format(hex(num)[2:])) 19 | else: 20 | print("Opção Inválida.") 21 | -------------------------------------------------------------------------------- /Exercicios/038 - Comparando números.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 038 - Comparando números 2 | # Escreva um programa que leia dois números inteiros e compare-os. mostrando na tela uma mensagem: 3 | # - O primeiro valor é maior 4 | # - O segundo valor é maior 5 | # - Não existe valor maior, os dois são iguais 6 | 7 | num1 = int(input("Informe o primeiro numero: ")) 8 | num2 = int(input("Informe o segundo numero: ")) 9 | 10 | if num1 > num2: 11 | print("O primeiro valor é maior.") 12 | elif num1 < num2: 13 | print("O segundo valor é maior. ") 14 | else: 15 | print("Não existe valor maior, os dois são iguais") 16 | -------------------------------------------------------------------------------- /Exercicios/039 - Alistamento Militar.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 039 - Alistamento Militar 2 | # Faça um programa que leia o ano de nascimento de um jovem 3 | # e informe, de acordo com a sua idade, se ele ainda vai se alistar ao serviço militar, 4 | # se é a hora exata de se alistar ou se já passou do tempo do alistamento. 5 | # Seu programa também deverá mostrar o tempo que falta ou que passou do prazo. 6 | 7 | from datetime import date 8 | 9 | ano_atual = date.today().year 10 | ano = int(input("Infome seu ano de nascimento: ")) 11 | 12 | idade = ano_atual - ano 13 | 14 | print("Quem naceu em {} tem {} anos no ano de {}.".format(ano, idade, ano_atual)) 15 | 16 | if idade < 18: 17 | print("VocÊ irá se alistar em {} ano(s)".format(18 - idade)) 18 | print("Você deverá se alistar em {} ".format(ano_atual + (18-idade))) 19 | 20 | elif idade == 18: 21 | print("Você irá se alistar nesse ano de {}".format(ano_atual)) 22 | 23 | elif idade > 18: 24 | print("Você deveria ter se alistado há {} anos".format(idade-18)) 25 | print("Seu alistamento foi em {}".format(ano_atual - (idade - 18))) 26 | -------------------------------------------------------------------------------- /Exercicios/040 - Aquele clássico da Média.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 040 - Aquele clássico da Média 2 | # Crie um programa que leia duas notas de um aluno e calcule sua média, 3 | # mostrando uma mensagem no final, de acordo com a média atingida: 4 | # - Média abaixo de 5.0: REPROVADO 5 | # - Média entre 5.0 e 6.9: RECUPERAÇÃO 6 | # - Média 7.0 ou superior: APROVADO 7 | 8 | n1 = float(input("Informa a primeira nota: ")) 9 | n2 = float(input("Informa a segunda nota: ")) 10 | 11 | media = (n1 + n2) / 2 12 | 13 | print("A média do aluno é {:.1f}".format(media)) 14 | if 7 > media >= 5: 15 | print("Recuperação") 16 | elif media < 5: 17 | print("Reprovado") 18 | elif media >= 7: 19 | print("Aprovado") 20 | -------------------------------------------------------------------------------- /Exercicios/041 - Classificando Atletas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 041 - Classificando Atletas 2 | # A Confederação Nacional de Natação precisa de um programa que leia o ano de nascimento de um atleta 3 | # e mostre sua categoria, de acordo com a idade: 4 | # - Até 9 anos: MIRIM 5 | # - Até 14 anos: INFANTIL 6 | # - Até 19 anos: JÚNIOR 7 | # - Até 25 anos: SÊNIOR 8 | # - Acima de 25 anos: MASTER 9 | 10 | from datetime import date 11 | 12 | ano_atual = date.today().year 13 | ano = int(input("Infome o ano de nascimento do atleta: ")) 14 | idade = ano_atual - ano 15 | 16 | if idade <= 9: 17 | print("Categoria: Mirim") 18 | 19 | elif idade <= 14: 20 | print("Categoria: Infantil") 21 | 22 | elif idade <= 19: 23 | print("Categoria: Junior") 24 | 25 | elif idade <= 25: 26 | print("Categoria: Sênior") 27 | 28 | else: 29 | print("Categoria: Master") 30 | -------------------------------------------------------------------------------- /Exercicios/042 - Analisando Triângulos v2.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 042 - Analisando Triângulos v2.0 2 | # Refaça o DESAFIO 035 dos triângulos, acrescentando o recurso de mostrar que tipo de triângulo será formado: 3 | # - EQUILÁTERO: todos os lados iguais 4 | # - ISÓSCELES: dois lados iguais, um diferente 5 | # - ESCALENO: todos os lados diferentes 6 | 7 | print("-=" * 12) 8 | print("Analisador de Triângulos") 9 | print("-=" * 12) 10 | 11 | r1 = float(input("Primeiro segmento: ")) 12 | r2 = float(input("Segundo segmento: ")) 13 | r3 = float(input("Teceiro segmento: ")) 14 | 15 | if r1 < r2 + r3 and r2 < r1 + r3 and r3 < r1 + r2: 16 | print("Os segmentos acima podem formar Triângulo", end=' ') 17 | if r1 == r2 == r3: 18 | print("Equilátero") 19 | elif r1 != r2 != r3 != r1: 20 | print("Escaleno") 21 | else: 22 | print("Isósceles") 23 | else: 24 | print("Os segmentos acima não podem formar triângulo") 25 | -------------------------------------------------------------------------------- /Exercicios/043 - Índice de Massa Corporal.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 043 - Índice de Massa Corporal 2 | # Desenvolva uma lógica que leia o peso e a altura de uma pessoa, calcule seu Índice de Massa Corporal (IMC) 3 | # e mostre seu status, de acordo com a tabela abaixo: 4 | # - IMC abaixo de 18,5: Abaixo do Peso 5 | # - Entre 18,5 e 25: Peso Ideal 6 | # - 25 até 30: Sobrepeso 7 | # - 30 até 40: Obesidade 8 | # - Acima de 40: Obesidade Mórbida 9 | 10 | peso = float(input("Informe seu peso: (Kg) ")) 11 | altura = float(input("Informe sua altura: (m) ")) 12 | imc = peso / (altura*altura) 13 | 14 | print("Seu IMC é: {:.2f}".format(imc)) 15 | if imc < 18.5: 16 | print("Faixa de peso: Abaixo do peso.") 17 | elif 25 > imc >= 18.5: 18 | print("Faixa de peso: Peso ideal") 19 | elif 30 > imc >= 25: 20 | print("Faixa de peso: Sobrepeso") 21 | elif 40 > imc >= 30: 22 | print("Faixa de peso: Obesidade") 23 | else: 24 | print("Faixa de peso: Obesidade Mórbida") 25 | -------------------------------------------------------------------------------- /Exercicios/044 - Gerenciador de Pagamentos.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 044 - Gerenciador de Pagamentos 2 | # Elabore um programa que calcule o valor a ser pago por um produto, 3 | # considerando o seu preço normal e condição de pagamento: 4 | # - à vista dinheiro/cheque: 10% de desconto 5 | # - à vista no cartão: 5% de desconto 6 | # - em até 2x no cartão: preço formal 7 | # - 3x ou mais no cartão: 20% de juros 8 | preco = float(input("Informe o valor do produto: R$")) 9 | print("""1 - À vista (dinheiro ou cheque) 10 | 2 - À vista (cartão) 11 | 3 - 2x no cartão 12 | 4 - 3x ou mais""") 13 | 14 | op = int(input("Informe a codição de pagamento: ")) 15 | 16 | if op == 1: 17 | print("O valor do produto será R${:.2f} com a aplicação de 10% de desconto".format(preco - (preco*10)/100)) 18 | 19 | elif op == 2: 20 | print("O valor do produto será R${:.2f} com a aplicação de 5% de desconto".format(preco - (preco * 5) / 100)) 21 | 22 | elif op == 3: 23 | print("O valor do produto será R${:.2f}".format(preco)) 24 | print("A parcela será de 2x de R${:.2f}".format(preco / 2)) 25 | 26 | elif op == 4: 27 | quantidade = int(input("Quantas parcelas? ")) 28 | parcela = (preco + (preco * 20) / 100) / quantidade 29 | print("O valor do produto será R${:.2f} com a aplicação de 20% de juros".format(preco + (preco * 20) / 100)) 30 | print("A parcela será de {}x de R${:.2f}".format(quantidade, parcela)) 31 | 32 | else: 33 | print("Opção de Pagamento inválida") 34 | -------------------------------------------------------------------------------- /Exercicios/045 - GAME Pedra Papel e Tesoura.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 045 - GAME: Pedra Papel e Tesoura 2 | # Crie um programa que faça o computador jogar Jokenpô com você. 3 | 4 | from random import randint 5 | from time import sleep 6 | 7 | itens = ('Pedra', 'Papel', 'Tesoura') 8 | computador = randint(0, 2) 9 | jogador = int(input("""[ 0 ] - Pedra 10 | [ 1 ] - Papel 11 | [ 2 ] - Tesoura 12 | 13 | Opção desejada: """)) 14 | 15 | if jogador > 2 or jogador < 0: 16 | print("Opção inválida") 17 | else: 18 | print("JO") 19 | sleep(1) 20 | print("KEN") 21 | sleep(1) 22 | print("PO!!!\n") 23 | sleep(1) 24 | 25 | print("-=" * 12) 26 | print("Jogador jogou {}".format(itens[jogador])) 27 | print("Computador jogou {}".format(itens[computador])) 28 | print("-=" * 12) 29 | 30 | if jogador == computador: 31 | print("EMPATE!") 32 | 33 | elif jogador == 0 and computador == 1: # Jogador Pedra e Computador Papel 34 | print("COMPUTADOR GANHOU!") 35 | 36 | elif jogador == 1 and computador == 2: # Jogador Papel e Computador Tesoura 37 | print("COMPUTADOR GANHOU!") 38 | 39 | elif jogador == 2 and computador == 0: # Jogador Tesoura e Computador Pedra 40 | print("COMPUTADOR GANHOU!") 41 | 42 | else: 43 | print("JOGADOR GANHOU!") 44 | -------------------------------------------------------------------------------- /Exercicios/046 - Contagem regressiva.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 046 - Contagem regressiva 2 | # Faça um programa que mostre na tela uma contagem regressiva para o estouro de fogos de artifício, 3 | # indo de 10 até 0, com uma pausa de 1 segundo entre eles. 4 | 5 | from time import sleep 6 | 7 | print("Contagem Regressiva para o ano novo:") 8 | for c in range(10, -1, -1): 9 | print(c) 10 | sleep(1) 11 | print("Feliz Ano Novo!!") 12 | -------------------------------------------------------------------------------- /Exercicios/047 - Contagem de pares.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 047 - Contagem de pares 2 | # Crie um programa que mostre na tela todos os números pares que estão no intervalo entre 1 e 50. 3 | 4 | for c in range(1, 51): 5 | if c % 2 == 0: 6 | print(c, end=', ') 7 | print("Fim") 8 | -------------------------------------------------------------------------------- /Exercicios/048 - Soma ímpares múltiplos de três.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 048 - Soma ímpares múltiplos de três 2 | # Faça um programa que calcule a soma entre todos os números que são múltiplos de três 3 | # e que se encontram no intervalo de 1 até 500. 4 | 5 | soma = 0 6 | for c in range(1, 501, 2): 7 | if c % 3 == 0: 8 | soma += c 9 | print(soma) 10 | -------------------------------------------------------------------------------- /Exercicios/049 - Tabuada v.2.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 049 - Tabuada v.2.0 2 | # Refaça o DESAFIO 009, mostrando a tabuada de um número que o usuário escolher, só que agora utilizando um laço for. 3 | 4 | # cores 5 | cor = {'azul': '\033[34m', 6 | 'lilas': '\033[35m'} 7 | 8 | n = int(input("Informe um número para ver sua tabuada: ")) 9 | print("{}-=".format(cor['lilas'])*7) 10 | 11 | for i in range(1, 11): 12 | print("{}{} x {:2} = {:3}".format(cor['azul'], n, i, n * i)) 13 | i += 1 14 | 15 | print("{}-=".format(cor['lilas'])*7) 16 | -------------------------------------------------------------------------------- /Exercicios/050 - Soma dos pares.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 050 - Soma dos pares 2 | # Desenvolva um programa que leia seis números inteiros e mostre a soma apenas daqueles que forem pares. 3 | # Se o valor digitado for ímpar, desconsidere-o. 4 | 5 | soma = 0 6 | for i in range(0, 6): 7 | num = int(input("Informe o {}º valor: ".format(i+1))) 8 | if num % 2 == 0: 9 | soma = soma + num 10 | print("A soma dos números é: {}".format(soma)) 11 | -------------------------------------------------------------------------------- /Exercicios/051 - Progressão Aritmética.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 051 - Progressão Aritmética 2 | # Desenvolva um programa que leia o primeiro termo e a razão de uma PA. 3 | # No final, mostre os 10 primeiros termos dessa progressão. 4 | 5 | print("="*20) 6 | print("PROGRESSÃO DE UMA PA") 7 | print("="*20) 8 | 9 | termo = int(input("Primeiro termo: ")) 10 | razao = int(input("Razão: ")) 11 | decimo = termo + 10 * razao 12 | 13 | for i in range(termo, decimo, razao): 14 | print(i, end=' -> ') 15 | print("FIM") 16 | -------------------------------------------------------------------------------- /Exercicios/052 - Números primos.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 052 - Números primos 2 | # Faça um programa que leia um número inteiro e diga se ele é ou não um número primo. 3 | total = 0 4 | num = int(input("Digite um número: ")) 5 | for i in range(1, num + 1): 6 | if num % i == 0: 7 | total += 1 8 | print("O número {} {}".format(num, "é primo" if total > 2 else "não é primo")) 9 | -------------------------------------------------------------------------------- /Exercicios/053 - Detector de Palíndromo.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 053 - Detector de Palíndromo 2 | # Crie um programa que leia uma frase qualquer e diga se ela é um palíndromo, desconsiderando os espaços. 3 | 4 | aux = str(input("Diga uma frase: ")).strip().upper() 5 | palavras = aux.split() 6 | frase = ''.join(palavras) 7 | tamanho = len(frase)-1 8 | inverso = '' 9 | 10 | for i in range(tamanho, -1, -1): 11 | inverso += frase[i] 12 | 13 | print("O inverso de {} é {}".format(frase, inverso)) 14 | 15 | if frase == inverso: 16 | print("Forma um palíndromo") 17 | else: 18 | print("Não forma um palíndromo") 19 | -------------------------------------------------------------------------------- /Exercicios/054 - Grupo da Maioridade.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 054 - Grupo da Maioridade 2 | # Crie um programa que leia o ano de nascimento de sete pessoas. 3 | # No final, mostre quantas pessoas ainda não atingiram a maioridade e quantas já são maiores. 4 | 5 | from datetime import date 6 | ano_atual = date.today().year 7 | maior = menor = 0 8 | for i in range(1, 8): 9 | ano = int(input("Em que ano a {}º pessoa nasceu? ".format(i))) 10 | if ano_atual - ano >= 18: 11 | maior += 1 12 | else: 13 | menor += 1 14 | print(""" 15 | Maiores de idade: {} 16 | Menores de idade: {} 17 | """.format(maior, menor)) 18 | -------------------------------------------------------------------------------- /Exercicios/055 - Maior e menor da sequência.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 055 - Maior e menor da sequência 2 | # Faça um programa que leia o peso de cinco pessoas. No final, mostre qual foi o maior e o menor peso lidos. 3 | 4 | maior = 0 5 | menor = 1000 6 | for i in range(1, 6): 7 | peso = float(input("Informe o peso da {}º pessoa: ".format(i))) 8 | if peso > maior: 9 | maior = peso 10 | if peso < menor: 11 | menor = peso 12 | print(""" 13 | Maior peso: {} 14 | Menor peso {} 15 | """.format(maior, menor)) 16 | -------------------------------------------------------------------------------- /Exercicios/056 - Analisador completo.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 056 - Analisador completo 2 | # Desenvolva um programa que leia o nome, idade e sexo de 4 pessoas. 3 | # No final do programa, mostre: a média de idade do grupo, qual é o nome do homem mais velho 4 | # e quantas mulheres têm menos de 20 anos. 5 | 6 | soma_idade = 0 7 | homem_idade = 0 8 | homem_nome = '' 9 | c_mulheres = 0 10 | 11 | for i in range(1, 5): 12 | print("----- {}º Pessoa -----".format(i)) 13 | nome = str(input("Nome: ")) 14 | idade = int(input("Idade: ")) 15 | sexo = str(input("Sexo [M/F]: ")) 16 | 17 | soma_idade += idade 18 | 19 | if sexo in 'Mm' and idade > homem_idade: 20 | homem_idade = idade 21 | homem_nome = nome 22 | 23 | if sexo in 'Ff' and idade < 20: 24 | c_mulheres += 1 25 | 26 | print("A média de idade do grupo é de {:.1f}".format(soma_idade / 4)) 27 | print("O homem mais velho tem {} anos e se chama {}".format(homem_idade, homem_nome)) 28 | print("Ao todo são {} mulheres com menos de 20 anos".format(c_mulheres)) 29 | -------------------------------------------------------------------------------- /Exercicios/057 - Validação de Dados.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 057 - Validação de Dados 2 | # Faça um programa que leia o sexo de uma pessoa, mas só aceite os valores 'M' ou 'F'. 3 | # Caso esteja errado, peça a digitação novamente até ter um valor correto. 4 | 5 | sexo = '' 6 | while sexo != 'M' and sexo != 'F': 7 | sexo = str(input("Informe seu sexo: [M/F] ")).strip().upper()[0] 8 | if sexo == 'M': 9 | print("Sexo masculino registrado com sucesso") 10 | else: 11 | print("Sexo feminino registrado com sucesso") 12 | -------------------------------------------------------------------------------- /Exercicios/058 - Jogo da Adivinhação v2.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 058 - Jogo da Adivinhação v2.0 2 | # Melhore o jogo do DESAFIO 028 onde o computador vai "pensar" em um número entre 0 e 10. 3 | # Só que agora o jogador vai tentar adivinhar até acertar, # mostrando no final 4 | # quantos palpites foram necessários para vencer. 5 | 6 | from random import randint 7 | from time import sleep 8 | 9 | # cores 10 | cor = {'limpa': '\033[m', 11 | 'vermelho': '\033[31m', 12 | 'verde': '\033[32m', 13 | 'amarelo': '\033[33m', 14 | 'azul': '\033[34m', 15 | 'lilas': '\033[35m'} 16 | 17 | print("{}-=-{}".format(cor['amarelo'], cor['limpa']) * 19) 18 | print("{}Vou pensar em um número entre 1 e 10. Tente adivinhar...{}".format(cor['azul'], cor['limpa'])) 19 | print("{}-=-{}".format(cor['amarelo'], cor['limpa']) * 19) 20 | 21 | computador = randint(1, 10) 22 | 23 | jogador = -1 24 | tentativas = 0 25 | while jogador != computador: 26 | jogador = int(input("Em que número eu pensei? ")) 27 | tentativas += 1 28 | 29 | print("{}Processando...{}".format(cor['lilas'], cor['limpa'])) 30 | sleep(2) 31 | 32 | if jogador > computador: 33 | print("{}Que pena, você errou. Tente um número menor.{}".format(cor['vermelho'], cor['limpa'])) 34 | else: 35 | print("{}Que pena, você errou. Tente um número maior.{}".format(cor['vermelho'], cor['limpa'])) 36 | print("{}PARABPENS! Você acertou com o total de {} tetativa(s){}".format(cor['verde'], tentativas, cor['limpa'])) 37 | -------------------------------------------------------------------------------- /Exercicios/059 - Criando um Menu de Opções.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 058 - Jogo da Adivinhação v2.0 2 | # Crie um programa que leia dois valores e mostre um menu na tela: 3 | # [ 1 ] somar 4 | # [ 2 ] multiplicar 5 | # [ 3 ] maior 6 | # [ 4 ] novos números 7 | # [ 5 ] sair do programa 8 | # Seu programa deverá realizar a operação solicitada em cada caso. 9 | 10 | n1 = int(input("Priveiro Valor: ")) 11 | n2 = int(input("Segundo Valor: ")) 12 | op = 0 13 | while op != 5: 14 | print("=-"*15) 15 | print(""" [ 1 ] somar 16 | [ 2 ] multiplicar 17 | [ 3 ] maior 18 | [ 4 ] novos números 19 | [ 5 ] sair do programa""") 20 | print("=-" * 15) 21 | op = int(input(">>>> Opção desejada: ")) 22 | if op == 1: 23 | print("Resultado: {} + {} = {}".format(n1, n2, n1+n2)) 24 | elif op == 2: 25 | print("Resultado: {} x {} = {}".format(n1, n2, n1*n2)) 26 | elif op == 3: 27 | print("Resultado: Entre {} e {}, o maior número é {}".format(n1, n2, n1 if n1 > n2 else n2)) 28 | elif op == 4: 29 | n1 = int(input("Priveiro Valor: ")) 30 | n2 = int(input("Segundo Valor: ")) 31 | elif op < 1 or op > 5: 32 | print("Opção inválida. Tente Novamente") 33 | -------------------------------------------------------------------------------- /Exercicios/060 - Cálculo do Fatorial.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 060 - Cálculo do Fatorial 2 | # Faça um programa que leia um número qualquer e mostre o seu fatorial. 3 | # Ex: 5! = 5 x 4 x 3 x 2 x 1 = 120 4 | 5 | print("--- CÁLCULO DO FATORIAL ---") 6 | num = int(input("Digite o número: ")) 7 | fat = 1 8 | print("Calculando {}! =".format(num), end=' ') 9 | while num > 0: 10 | if num == 1: 11 | print(num, end=' ') 12 | else: 13 | print(num, end=' x ') 14 | fat *= num 15 | num -= 1 16 | print("= {}".format(fat)) 17 | -------------------------------------------------------------------------------- /Exercicios/061 - Progressão Aritmética v2.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 061 - Progressão Aritmética v2.0 2 | # Refaça o DESAFIO 051, lendo o primeiro termo e a razão de uma PA, 3 | # mostrando os 10 primeiros termos da progressão usando a estrutura while. 4 | 5 | print("="*20) 6 | print("PROGRESSÃO DE UMA PA") 7 | print("="*20) 8 | 9 | termo = int(input("Primeiro termo: ")) 10 | razao = int(input("Razão: ")) 11 | c = 1 12 | while c < 11: 13 | print("{}".format(termo), end=' -> ') 14 | termo += razao 15 | c += 1 16 | print("FIM") 17 | -------------------------------------------------------------------------------- /Exercicios/062 - Super Progressão Aritmética v3.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 062 - Super Progressão Aritmética v3.0 2 | # Melhore o DESAFIO 061, perguntando para o usuário se ele quer mostrar mais alguns termos. 3 | # Oprograma encerrará quando ele disser que quer mostrar 0 termos. 4 | 5 | print("="*20) 6 | print("PROGRESSÃO DE UMA PA") 7 | print("="*20) 8 | 9 | termo = int(input("Primeiro termo: ")) 10 | razao = int(input("Razão: ")) 11 | 12 | contador = 0 13 | total = 10 14 | mais = 0 15 | while contador < total: 16 | while contador < total: 17 | print("{}".format(termo), end=' -> ') 18 | termo += razao 19 | contador += 1 20 | print("Pausa") 21 | mais = int(input("Quantos termos a mais você quer? ")) 22 | if mais == 0: 23 | contador = total 24 | total += mais 25 | print("Progressão finalizada com o total de {} termos".format(total)) 26 | -------------------------------------------------------------------------------- /Exercicios/063 - Sequência de Fibonacci v1.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 061 - Progressão Aritmética v2.0 2 | # Escreva um programa que leia um número N inteiro qualquer e mostre na tela 3 | # os N primeiros elementos de uma Sequência de Fibonacci. 4 | 5 | N = int(input("Quantos termos você quer mostrar? ")) 6 | c = j = 0 7 | i = 1 8 | 9 | while c < N: 10 | k = i + j 11 | print(j, end=' -> ') 12 | j = i 13 | i = k 14 | c += 1 15 | print("FIM") 16 | -------------------------------------------------------------------------------- /Exercicios/064 - Tratando vários valores v1.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 061 - Progressão Aritmética v2.0 2 | # Crie um programa que leia vários números inteiros pelo teclado. 3 | # O programa só vai parar quando o usuário digitar o valor 999, que é a condição de parada. 4 | # No final, mostre quantos números foram digitados e qual foi a soma entre eles (desconsiderando o flag). 5 | 6 | n = soma = 0 7 | c = -1 8 | while n != 999: 9 | soma += n 10 | c += 1 11 | n = int(input("Digite um numero: ")) 12 | print("Foram digitados {} números e a soma entre eles é {}".format(c, soma)) 13 | -------------------------------------------------------------------------------- /Exercicios/065 - Maior e Menor valores.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 065 - Maior e Menor valores 2 | # Crie um programa que leia vários números inteiros pelo teclado. 3 | # No final da execução, mostre a média entre todos os valores e qual foi o maior e o menor valores lidos. 4 | # O programa deve perguntar ao usuário se ele quer ou não continuar a digitar valores. 5 | 6 | op = '' 7 | soma = quant = maior = menor = 0 8 | while op != 'N': 9 | n = int(input('Digite um número: ')) 10 | soma += n 11 | quant += 1 12 | if quant == 1: 13 | menor = maior = n 14 | else: 15 | if n > maior: 16 | maior = n 17 | if n < menor: 18 | menor = n 19 | 20 | while op != 'S' and op != 'N': 21 | op = str(input("Quer continuar? [S/N] ")).strip().upper()[0] 22 | if op != 'S' and op != 'N': 23 | print("Opção inválida. Tente novamente.") 24 | 25 | media = soma/quant 26 | print(""" 27 | Números digitados: {} 28 | Média dos números: {} 29 | Maior número: {} 30 | Menor número: {} 31 | """.format(quant, media, maior, menor)) 32 | -------------------------------------------------------------------------------- /Exercicios/066 - Vários números com flag.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 066 - Vários números com flag 2 | # Crie um programa que leia números inteiros pelo teclado. 3 | # O programa só vai parar quando o usuário digitar o valor 999, que é a condição de parada. 4 | # No final, mostre quantos números foram digitados e qual foi a soma entre elas (desconsiderando o flag). 5 | soma = quant = 0 6 | while True: 7 | num = int(input('Informe um valor: (999 para parar)')) 8 | if num == 999: 9 | break 10 | soma += num 11 | quant += 1 12 | print(f'A soma dos {quant} valores foi {soma}') 13 | -------------------------------------------------------------------------------- /Exercicios/067 - Tabuada v3.0.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 067 - Tabuada v3.0 2 | # Faça um programa que mostre a tabuada de vários números, um de cada vez, para cada valor digitado pelo usuário. 3 | # O programa será interrompido quando o número solicitado for negativo. 4 | 5 | # cores 6 | cor = {'limpa': '\033[m', 7 | 'azul': '\033[34m', 8 | 'lilas': '\033[35m'} 9 | while True: 10 | n = int(input("Informe um número para ver sua tabuada: ")) 11 | if n < 0: 12 | break 13 | print("{}-={}".format(cor['lilas'], cor['limpa'])*7) 14 | 15 | for i in range(1, 11): 16 | print("{}{} x {:2} = {:3}".format(cor['azul'], n, i, n * i)) 17 | i += 1 18 | 19 | print("{}-={}".format(cor['lilas'], cor['limpa'])*7) 20 | print("Programa Encerrado.") 21 | -------------------------------------------------------------------------------- /Exercicios/068 - Jogo do Par ou Ímpar.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 068 - Jogo do Par ou Ímpar 2 | # Faça um programa que jogue par ou ímpar com o computador. 3 | # O jogo só será interrompido quando o jogador perder, 4 | # mostrando o total de vitórias consecutivas que ele conquistou no final do jogo. 5 | 6 | from random import randint 7 | c = 0 8 | while True: 9 | valor = int(input('Diga um valor: ')) 10 | vcomputador = randint(0, 10) 11 | jogador = 'y' 12 | 13 | while jogador not in 'PI': 14 | jogador = str(input('Par ou Ímpar? [P/I] ')).strip().upper()[0] 15 | 16 | soma = valor + vcomputador 17 | print(f'Você jogou {valor} e o computador {vcomputador}. Total de {soma} é ', end='') 18 | 19 | if jogador == 'P': 20 | if soma % 2 == 0: 21 | print('PAR.') 22 | print('Você ganhou!') 23 | c += 1 24 | else: 25 | print('IMPAR.') 26 | print('Você Perdeu!') 27 | break 28 | else: 29 | if soma % 2 == 0: 30 | print('PAR.') 31 | print('Você Perdeu!') 32 | break 33 | else: 34 | print('IMPAR.') 35 | print('Você Ganhou!') 36 | c += 1 37 | print(f'Game Over! Você venceu {c} vezes.') 38 | -------------------------------------------------------------------------------- /Exercicios/069 - Análise de dados do grupo.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 068 - Jogo do Par ou Ímpar 2 | # Crie um programa que leia a idade e o sexo de várias pessoas. 3 | # A cada pessoa cadastrada, o programa deverá perguntar se o usuário quer ou não continuar. No final, mostre: 4 | # A) quantas pessoas tem mais de 18 anos. 5 | # B) quantos homens foram cadastrados. 6 | # C) quantas mulheres tem menos de 20 anos. 7 | quantMaior = quantHomens = quantMulheres = 0 8 | while True: 9 | idade = int(input('Idade: ')) 10 | sexo = ' ' 11 | while sexo not in 'MF': 12 | sexo = str(input('Sexo: [M/F] ')).strip().upper()[0] 13 | 14 | if idade >= 18: 15 | quantMaior += 1 16 | 17 | if sexo == 'M': 18 | quantHomens += 1 19 | elif idade < 20: 20 | quantMulheres += 1 21 | 22 | continuar = ' ' 23 | while continuar not in 'SN': 24 | continuar = str(input('Deseja continuar? [S/N]')).strip().upper()[0] 25 | 26 | if continuar == 'N': 27 | break 28 | 29 | print(f''' 30 | Maiores de idade cadastrados: {quantMaior} 31 | Homens cadastrados: {quantHomens} 32 | Mulheres com idade inferior a 20: {quantMulheres} 33 | ''') 34 | -------------------------------------------------------------------------------- /Exercicios/070 - Estatísticas em produtos.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 070 - Estatísticas em produtos 2 | # # Crie um programa que leia o nome e o preço de vários produtos. 3 | # # O programa deverá perguntar se o usuário vai continuar ou não. No final, mostre: 4 | # # A) qual é o total gasto na compra. 5 | # # B) quantos produtos custam mais de R$1000. 6 | # # C) qual é o nome do produto mais barato. 7 | 8 | maiorMil = totalGasto = c = barato = 0 9 | nbarato = ' ' 10 | while True: 11 | nome = str(input('Nome: ')) 12 | preco = float(input('Preço: R$')) 13 | 14 | totalGasto += preco 15 | c += 1 16 | if c == 1: 17 | barato = preco 18 | 19 | if preco >= 1000: 20 | maiorMil += 1 21 | 22 | if barato > preco: 23 | barato = preco 24 | nbarato = nome 25 | 26 | continuar = ' ' 27 | while continuar not in 'SN': 28 | continuar = str(input('Deseja continuar? [S/N]')).strip().upper()[0] 29 | 30 | if continuar == 'N': 31 | break 32 | print(f''' 33 | Total Gasto na compra: R${totalGasto:.2f} 34 | Qunatidade de produtos superior a R$1.000: {maiorMil} 35 | O produto mais barato é {nbarato} que custa R${barato:.2f} 36 | ''') 37 | -------------------------------------------------------------------------------- /Exercicios/071 - Simulador de Caixa Eletrônico.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 071 - Simulador de Caixa Eletrônico 2 | # Crie um programa que simule o funcionamento de um caixa eletrônico. 3 | # No início, pergunte ao usuário qual será o valor a ser sacado (número inteiro) 4 | # e o programa vai informar quantas cédulas de cada valor serão entregues. 5 | # OBS: considere que o caixa possui cédulas de R$50, R$20, R$10 e R$1. 6 | ced = 50.00 7 | cedTotal = 0 8 | 9 | print("Cédulas disponíveis R$50, R$20, R$10 e R$1") 10 | sacar = int(input('Qual valor você deseja sacar? R$')) 11 | 12 | while True: 13 | if sacar >= ced: 14 | sacar -= ced 15 | cedTotal += 1 16 | else: 17 | if cedTotal != 0: 18 | print(f'Total de {cedTotal} de R${ced:.2f}') 19 | if ced == 50.00: 20 | ced = 20.00 21 | elif ced == 20.00: 22 | ced = 10.00 23 | elif ced == 10.00: 24 | ced = 1 25 | cedTotal = 0 26 | if sacar == 0: 27 | break 28 | -------------------------------------------------------------------------------- /Exercicios/072 - Número por Extenso.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 072 - Número por Extenso 2 | # Crie um programa que tenha uma tupla totalmente preenchida com uma contagem por extenso, de zero até vinte. 3 | # Seu programa deverá ler um número pelo teclado (entre 0 e 20) e mostrá-lo por extenso. 4 | 5 | numeros = ('zero', 'um', 'dois', 'três', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove', 'dez', 6 | 'onze', 'doze', 'treze', 'catorze', 'quinze', 'dezesseis', 'dezessete', 'dezoito', 'dezenove', 'vinte',) 7 | pos = -1 8 | while pos < 0 or pos > 20: 9 | pos = int(input('Digite um número entre 0 e 20: ')) 10 | print(f'Você digitou o número {numeros[pos]}') 11 | -------------------------------------------------------------------------------- /Exercicios/073 - Tuplas com Times de Futebol.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 073 - Tuplas com Times de Futebol 2 | # Crie uma tupla preenchida com os 20 primeiros colocados da Tabela do Campeonato Brasileiro de Futebol, 3 | # na ordem de colocação. Depois mostre: 4 | # a) Os 5 primeiros times. 5 | # b) Os últimos 4 colocados. 6 | # c) Times em ordem alfabética. 7 | # d) Em que posição está o time da Chapecoense. 8 | 9 | times = ('Palmeiras', 'Santos', 'Flamengo', 'Atlético', 'Internacional', 10 | 'Atlético-PR', 'Botafogo', 'Goias', 'Corinthians', 'Grêmio', 11 | 'Bahia', 'São Paulo', 'Ceará SC', 'Fortaleza', 'Vasco da Gama', 12 | 'Cruzeiro', 'Fluminense', 'Chapecoence', 'CSA', 'Avaí') 13 | 14 | op = int(input(''' 15 | [ 1 ] Imprimir os 5 primeiros colocados. 16 | [ 2 ] Imprimir os 4 ultimos colocados. 17 | [ 3 ] Imprimir Classificação dos times. 18 | [ 4 ] Imprimir os times em ordem alfabética. 19 | [ 5 ] Posição do time chapecoence. 20 | Sua Opção: ''')) 21 | 22 | if op == 1: 23 | for time in range(0, 5): 24 | print(f'{time+1}º {times[time]}') 25 | elif op == 2: 26 | for time in range(16, 20): 27 | print(f'{time + 1}º {times[time]}') 28 | elif op == 3: 29 | for time in range(0, 20): 30 | print(f'{time + 1}º {times[time]}') 31 | elif op == 4: 32 | print(f'Times em ordem alfabética: {sorted(times)}') 33 | elif op == 5: 34 | print(f'Chapecoence está na {times.index("Chapecoence")+1} posição.') 35 | else: 36 | print('Opção Inválida.') 37 | -------------------------------------------------------------------------------- /Exercicios/074 - Maior e menor valores em Tupla.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 074 - Maior e menor valores em Tupla 2 | # Crie um programa que vai gerar cinco números aleatórios e colocar em uma tupla. 3 | # Depois disso, mostre a listagem de números gerados e também indique o menor e o maior valor que estão na tupla. 4 | 5 | from random import sample 6 | 7 | num = tuple(sample(range(10), 5)) 8 | for i in num: 9 | print(i, end=' ') 10 | print(f''' 11 | Maior valor sorteado: {max(num)} 12 | Menor valor sorteado: {min(num)}.''') 13 | -------------------------------------------------------------------------------- /Exercicios/075 - Análise de dados em uma Tupla.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 075 - Análise de dados em uma Tupla 2 | # Desenvolva um programa que leia quatro valores pelo teclado e guarde-os em uma tupla. No final, mostre: 3 | # A) Quantas vezes apareceu o valor 9. 4 | # B) Em que posição foi digitado o primeiro valor 3. 5 | # C) Quais foram os números pares. 6 | 7 | num = (int(input('1º valor:')), int(input('2º valor:')), int(input('3º valor:')), int(input('4º valor:'))) 8 | print(num) 9 | print(f'O número 9 aparece {num.count(9)} vezes.') 10 | if 3 in num: 11 | print(f'O número 3 foi digitado pela primeira vez na posição {num.index(3)}') 12 | else: 13 | print('O número 3 não foi digitado') 14 | print('Números pares digitados: ', end='') 15 | for i in num: 16 | if i % 2 == 0: 17 | print(i, end=' ') 18 | -------------------------------------------------------------------------------- /Exercicios/076 - Lista de Preços com Tupla.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 076 - Lista de Preços com Tupla 2 | # Crie um programa que tenha uma tupla única com nomes de produtos e seus respectivos preços, na sequência. 3 | # No final, mostre uma listagem de preços, organizando os dados em forma tabular. 4 | 5 | print('-'*39) 6 | print(f'{"LISTAGEM DE PREÇOS":^39}') 7 | print('-'*39) 8 | 9 | produtos = ('Lápis', 1.75, 10 | 'Borracha', 2.00, 11 | 'Caderno', 15.90, 12 | 'Estojo', 25.00, 13 | 'Transferidor', 4.20, 14 | 'Compasso', 9.99, 15 | 'Mochila', 120.00, 16 | 'Caneta', 22.30, 17 | 'Livros', 34.90) 18 | 19 | for pos in range(0, len(produtos)): 20 | if pos % 2 == 0: 21 | print(f'{produtos[pos]:.<30}', end='') 22 | else: 23 | print(f'R${produtos[pos]:>7.2f}') 24 | print('-'*39) 25 | -------------------------------------------------------------------------------- /Exercicios/077 - Contando vogais em Tupla.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 077 - Contando vogais em Tupla 2 | # Crie um programa que tenha uma tupla com várias palavras (não usar acentos). 3 | # Depois disso, você deve mostrar, para cada palavra, quais são as suas vogais. 4 | 5 | frutas = ('banana', 'abacate', 'pera', 'uva', 'abacaxi') 6 | 7 | for palavra in frutas: 8 | print(f'Palavra {palavra.upper()} \nVogais: ') 9 | for letra in palavra: 10 | if letra.lower() in 'aeiou': 11 | print(letra, end=' ') 12 | print('\n') 13 | -------------------------------------------------------------------------------- /Exercicios/078 - Maior e Menor valores na Lista.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 078 - Maior e Menor valores na Lista 2 | # Faça um programa que leia 5 valores numéricos e guarde-os em uma lista. 3 | # No final, mostre qual foi o maior e o menor valor digitado e as suas respectivas posições na lista. 4 | 5 | valores = list() 6 | for i in range(0, 5): 7 | valores.append(int(input('Digite um valor: '))) 8 | 9 | print(f'''\nMaior valor digitado: {max(valores)} 10 | Posição: ''', end='') 11 | for i in range(0, 5): 12 | if valores[i] == max(valores): 13 | print(i, end=' ') 14 | 15 | print(f'''\n \nMenor Valor digitado: {min(valores)} 16 | Posição: ''', end='') 17 | for i in range(0, 5): 18 | if valores[i] == min(valores): 19 | print(i, end=' ') 20 | -------------------------------------------------------------------------------- /Exercicios/079 - Valores únicos em uma Lista.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 079 - Valores únicos em uma Lista 2 | # Crie um programa onde o usuário possa digitar vários valores numéricos e cadastre-os em uma lista. 3 | # Caso o número já exista lá dentro, ele não será adicionado. 4 | # No final, serão exibidos todos os valores únicos digitados, em ordem crescente. 5 | 6 | numeros = list() 7 | while True: 8 | aux = int(input('Digite um número:(-1 para sair) ')) 9 | if aux == -1: 10 | break 11 | if aux not in numeros: 12 | numeros.append(aux) 13 | else: 14 | print('Número duplicado. Não irei adicionar') 15 | numeros.sort() 16 | print(f'Valores digitados: {numeros}') 17 | -------------------------------------------------------------------------------- /Exercicios/080 - Lista ordenada sem repetições.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 080 - Lista ordenada sem repetições 2 | # Crie um programa onde o usuário possa digitar cinco valores numéricos e cadastre-os em uma lista, 3 | # já na posição correta de inserção (sem usar o sort()). No final, mostre a lista ordenada na tela. 4 | 5 | numeros = list() 6 | for c in range(0, 5): 7 | aux = int(input('Digite um número: ')) 8 | if c == 0 or aux > numeros[-1]: 9 | numeros.append(aux) 10 | print(f'O valor {aux} foi adicionado na última posição') 11 | else: 12 | p = 0 13 | while p < len(numeros): 14 | if aux <= numeros[p]: 15 | numeros.insert(p, aux) 16 | print(f'O valor {aux} foi adicionado na posição {p}') 17 | break 18 | p += 1 19 | 20 | print(f'Valores digitados: {numeros}') 21 | -------------------------------------------------------------------------------- /Exercicios/081 - Extraindo dados de uma Lista.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 081 - Extraindo dados de uma Lista 2 | # Crie um programa que vai ler vários números e colocar em uma lista. Depois disso, mostre: 3 | # A) Quantos números foram digitados. 4 | # B) A lista de valores, ordenada de forma decrescente. 5 | # C) Se o valor 5 foi digitado e está ou não na lista. 6 | 7 | n = list() 8 | c = -1 9 | while True: 10 | c += 1 11 | n.append(int(input('Difite um número: (0 para sair) '))) 12 | if n[c] == 0: 13 | n.pop() 14 | c -= 1 15 | break 16 | n.sort(reverse=True) 17 | print(f'''Números digitados: {c+1} 18 | Valores em ordem decrescente: {n} 19 | Valor 5 foi digitado? {'Sim' if 5 in n else 'Não'}''') 20 | -------------------------------------------------------------------------------- /Exercicios/082 - Dividindo valores em várias listas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 079 - Valores únicos em uma Lista 2 | # Crie um programa que vai ler vários números e colocar em uma lista. 3 | # Depois disso, crie duas listas extras que vão conter apenas os valores pares e 4 | # os valores ímpares digitados, respectivamente. Ao final, mostre o conteúdo das três listas geradas. 5 | 6 | lista = list() 7 | par = list() 8 | impar = list() 9 | while True: 10 | lista.append(int(input('Digite um número: (0 para sair) '))) 11 | if lista[-1] == 0: 12 | lista.pop() 13 | break 14 | 15 | if lista[-1] % 2 == 0: 16 | par.append(lista[-1]) 17 | else: 18 | impar.append(lista[-1]) 19 | 20 | print(f'''Lista: {lista} 21 | Par: {par} 22 | Impar: {impar}''') 23 | -------------------------------------------------------------------------------- /Exercicios/083 - Validando expressões matemáticas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 083 - Validando expressões matemáticas 2 | # Crie um programa onde o usuário digite uma expressão qualquer que use parênteses. 3 | # Seu aplicativo deverá analisar se a expressão passada está com os parênteses abertos e fechados na ordem correta. 4 | 5 | exp = str(input('Dgite a expressão: ')) 6 | if exp.count('(') == exp.count(')'): 7 | print("Sua expressão está válida!") 8 | else: 9 | print("Sua expressão está errada!") 10 | -------------------------------------------------------------------------------- /Exercicios/084 - Lista composta e análise de dados.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 084 - Lista composta e análise de dados 2 | # Faça um programa que leia nome e peso de várias pessoas, guardando tudo em uma lista. No final, mostre: 3 | # A) Quantas pessoas foram cadastradas. 4 | # B) Uma listagem com as pessoas mais pesadas. 5 | # C) Uma listagem com as pessoas mais leves. 6 | 7 | aux = [] 8 | pessoas = [] 9 | maior = menor = 0 10 | 11 | while True: 12 | aux.append(str(input('Nome: '))) 13 | aux.append(float(input('Peso: '))) 14 | if len(pessoas) == 0: 15 | maior = menor = aux[1] 16 | else: 17 | if aux[1] > maior: 18 | maior = aux[1] 19 | 20 | if aux[1] < menor: 21 | menor = aux[1] 22 | 23 | pessoas.append(aux[:]) 24 | aux.clear() 25 | 26 | op = str(input('Continuar? [S/N]')).strip().upper() 27 | if op == 'N': 28 | break 29 | 30 | print(f'''Quantidade: {len(pessoas)} 31 | Maior Peso {maior} 32 | Menor Peso: {menor}''') 33 | -------------------------------------------------------------------------------- /Exercicios/085 - Listas com pares e ímpares.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 085 - Listas com pares e ímpares 2 | # Crie um programa onde o usuário possa digitar sete valores numéricos e 3 | # cadastre-os em uma lista única que mantenha separados os valores pares e ímpares. 4 | # No final, mostre os valores pares e ímpares em ordem crescente. 5 | valor = [[], []] 6 | for i in range(1, 8): 7 | aux = int(input(f'Digite o {i}º Número: ')) 8 | if aux % 2 == 0: 9 | valor[0].append(aux) 10 | else: 11 | valor[1].append(aux) 12 | valor[0].sort() 13 | valor[1].sort() 14 | print(f'''Pares {valor[0]} 15 | Impares {valor[1]}''') 16 | -------------------------------------------------------------------------------- /Exercicios/086 - Matriz em Python.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 086 - Matriz em Python 2 | # Crie um programa que declare uma matriz de dimensão 3x3 e preencha com valores lidos pelo teclado. 3 | # No final, mostre a matriz na tela, com a formatação correta. 4 | 5 | matriz = [[[], [], []], 6 | [[], [], []], 7 | [[], [], []]] 8 | 9 | for i in range(0, 3): 10 | for j in range(0, 3): 11 | matriz[i][j] = int(input(f'[{i}][{j}] = ')) 12 | 13 | print(matriz[0]) 14 | print(matriz[1]) 15 | print(matriz[2]) 16 | -------------------------------------------------------------------------------- /Exercicios/087 - Mais sobre Matriz em Python.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 087 - Mais sobre Matriz em Python 2 | # Aprimore o desafio anterior, mostrando no final: 3 | # A) A soma de todos os valores pares digitados. 4 | # B) A soma dos valores da terceira coluna. 5 | # C) O maior valor da segunda linha. 6 | 7 | par = terc = maior = 0 8 | matriz = [[[], [], []], 9 | [[], [], []], 10 | [[], [], []]] 11 | 12 | for i in range(0, 3): 13 | for j in range(0, 3): 14 | matriz[i][j] = int(input(f'[{i}][{j}] = ')) 15 | 16 | if matriz[i][j] % 2 == 0: 17 | par += matriz[i][j] 18 | if j == 2: 19 | terc += matriz[i][j] 20 | if i == 1: 21 | maior += matriz[i][j] 22 | 23 | print(matriz[0]) 24 | print(matriz[1]) 25 | print(matriz[2]) 26 | 27 | print(f'''Soma dos valores digitados: {par} 28 | Soma dos valores da terceira coluna {terc} 29 | Maior valor da segunda linha {maior}''') 30 | -------------------------------------------------------------------------------- /Exercicios/088 - Palpites para a Mega Sena.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 088 - Palpites para a Mega Sena 2 | # Faça um programa que ajude um jogador da MEGA SENA a criar palpites. 3 | # O programa vai perguntar quantos jogos serão gerados e vai sortear 6 números entre 1 e 60 para cada jogo. 4 | 5 | from random import sample 6 | quant = int(input('Quantos jogos? ')) 7 | for i in range(1, quant+1): 8 | jogo = [sample(range(1, 60), 6)] 9 | print(f'Jogo {i}: {jogo}') 10 | jogo.clear() -------------------------------------------------------------------------------- /Exercicios/089 - Boletim com listas compostas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 089 - Boletim com listas compostas 2 | # Crie um programa que leia nome e duas notas de vários alunos e guarde tudo em uma lista composta. 3 | # No final, mostre um boletim contendo a média de cada um e permita que o usuário possa mostrar 4 | # as notas de cada aluno individualmente. 5 | 6 | boletim = list() 7 | while True: 8 | nome = str(input('Nome: ')) 9 | n1 = float(input('1º Nota: ')) 10 | n2 = float(input('2º Nota: ')) 11 | media = (n1 + n2) / 2 12 | boletim.append([nome, [n1, n2], media]) 13 | 14 | op = str(input('Continuar? [S/N]')).strip().upper() 15 | if op == 'N': 16 | break 17 | 18 | print(f'{"Nº":<5}{"NOME":<10}{"MÉDIA":>5}') 19 | print('-'*25) 20 | for i, v in enumerate(boletim): 21 | print(f'{i:<5}{v[0]:<10}{v[2]:>8}') 22 | print('-'*25) 23 | 24 | while True: 25 | ref = int(input('Mostrar notas de qual aluno? (999 interrompe)')) 26 | if ref == 999: 27 | break 28 | print(f'Notas do(a) {boletim[ref][0]} são: {boletim[ref][1]}') 29 | -------------------------------------------------------------------------------- /Exercicios/090 - Dicionário.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 090 - Dicionário 2 | # Faça um programa que leia nome e média de um aluno, guardando também a situação em um dicionário. 3 | # No final, mostre o conteúdo da estrutura na tela. 4 | 5 | aluno = {'Nome': str(input('Nome: ')).strip(), 6 | 'Média': float(input('Média: '))} 7 | 8 | if aluno['Média'] >= 7: 9 | aluno['Situação'] = 'Aprovado(a)' 10 | else: 11 | aluno['Situação'] = 'Reprovado(a)' 12 | 13 | for i, j in aluno.items(): 14 | print(f'{i}: {j}') 15 | -------------------------------------------------------------------------------- /Exercicios/091 - Jogo de Dados.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 091 - Jogo de Dados em Python 2 | # Crie um programa onde 4 jogadores joguem um dado e tenham resultados aleatórios. 3 | # Guarde esses resultados em um dicionário em Python. 4 | # No final, coloque esse dicionário em ordem, sabendo que o vencedor tirou o maior número no dado. 5 | 6 | from random import randint 7 | from operator import itemgetter 8 | 9 | jogo = {'jogador 1': randint(1, 6), 'jogador 2': randint(1, 6), 10 | 'jogador 3': randint(1, 6), 'jogador 4': randint(1, 6)} 11 | 12 | ranking = sorted(jogo.items(), key=itemgetter(1), reverse=True) 13 | 14 | for i, j in jogo.items(): 15 | print(f'{i} tirou {j}') 16 | 17 | for i, j in enumerate(ranking): 18 | print(f'{i+1} lugar: {j[0]} com {j[1]}') 19 | -------------------------------------------------------------------------------- /Exercicios/092 - Cadastro de Trabalhador.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 089 - Boletim com listas compostas 2 | # Crie um programa que leia nome e duas notas de vários alunos e guarde tudo em uma lista composta. 3 | 4 | from datetime import datetime 5 | 6 | Trabalhador = dict() 7 | while True: 8 | Trabalhador['Nome'] = str(input('Nome: ')).strip() 9 | nascimento = int(input('Ano de Nascimento: ')) 10 | Trabalhador['Idade'] = datetime.now().year - nascimento 11 | Trabalhador['CTPS'] = int(input('Carteira de Trabalho: (0 não tem) ')) 12 | 13 | if Trabalhador['CTPS'] == 0: 14 | Trabalhador['CTPS'] = "Não possui" 15 | break 16 | else: 17 | Trabalhador['Contratação'] = int(input('Ano de Contratação: ')) 18 | Trabalhador['Salário'] = float(input('Salário: R$')) 19 | Trabalhador['Aposentadoria'] = (Trabalhador['Contratação'] - nascimento) + 35 20 | break 21 | 22 | print('-'*20) 23 | for i, j in Trabalhador.items(): 24 | print(f'{i}: {j}') 25 | -------------------------------------------------------------------------------- /Exercicios/093 - Cadastro de Jogador de Futebol.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 093 - Cadastro de Jogador de Futebol 2 | # Crie um programa que gerencie o aproveitamento de um jogador de futebol. 3 | # O programa vai ler o nome do jogador e quantas partidas ele jogou. 4 | # Depois vai ler a quantidade de gols feitos em cada partida. 5 | # No final, tudo isso será guardado em um dicionário, incluindo o total de gols feitos durante o campeonato. 6 | 7 | gols = list() 8 | jogador = dict() 9 | 10 | jogador['Nome'] = str(input('Nome do Jogador: ')).strip() 11 | partidas = int(input(f'Quantas Partidas {jogador["Nome"]} jogou? ')) 12 | 13 | if partidas > 0: 14 | for c in range(0, partidas): 15 | gols.append(int(input(f' Quantos gols na {c+1}º partida? '))) 16 | jogador['Gols'] = gols[:] 17 | jogador['Total'] = sum(gols) 18 | 19 | print('-='*40) 20 | print(jogador) 21 | 22 | print('-='*40) 23 | for i, j in jogador.items(): 24 | print(f'{i}: {j}') 25 | 26 | print('-='*40) 27 | print(f'O(a) jogador(a) {jogador["Nome"]} jogou {partidas} partidas') 28 | for i, j in enumerate(gols): 29 | print(f' Na {i+1}º partida fez {j} gol(s)') 30 | print(f'Foi um total de {jogador["Total"]} gol(s)') 31 | -------------------------------------------------------------------------------- /Exercicios/094 - Unindo Dicionários e Listas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 094 - Unindo dicionários e listas 2 | # Crie um programa que leia nome, sexo e idade de várias pessoas, 3 | # guardando os dados de cada pessoa em um dicionário e todos os dicionários em uma lista. No final, mostre: 4 | # A) Quantas pessoas foram cadastradas 5 | # B) A média de idade 6 | # C) Uma lista com as mulheres 7 | # D) Uma lista de pessoas com idade acima da média 8 | 9 | lista = list() 10 | mulheres = list() 11 | dicionario = dict() 12 | soma = 0 13 | 14 | while True: 15 | dicionario.clear() 16 | dicionario['Nome'] = str(input('Nome: ')).strip() 17 | dicionario['Idade'] = int(input('Idade: ')) 18 | 19 | while True: 20 | dicionario['Sexo:'] = str(input('Sexo: [M/F]')).strip().upper()[0] 21 | if dicionario['Sexo:'] in 'MF': 22 | break 23 | print('Opção Inválida! Tente novamente, desta vez com M ou F.') 24 | 25 | lista.append(dicionario.copy()) 26 | soma += dicionario['Idade'] 27 | 28 | if dicionario['Sexo:'] == 'F': 29 | mulheres.append(dicionario['Nome']) 30 | 31 | while True: 32 | op = str(input('Quer continuar? [S/N] ')).strip().upper()[0] 33 | if op in 'SN': 34 | break 35 | if op == 'N': 36 | break 37 | 38 | 39 | print(f'''A) Total de pessoas cadastradas: {len(lista)} 40 | B) Média de idade: {soma/len(lista):.2f} 41 | C) Mulheres cadastradas {mulheres} 42 | D) Pessoas com idade acima da média: ''') 43 | 44 | for a in lista: 45 | if a['Idade'] >= soma/len(lista): 46 | print(f' {a["Nome"]}: {a["Idade"]}') 47 | -------------------------------------------------------------------------------- /Exercicios/095 - Aprimorando os Dicionários.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 095 - Aprimorando os Dicionários 2 | # Aprimore o desafio 93 para que ele funcione com vários jogadores, incluindo 3 | # um sistema de visualização de detalhes do aproveitamento de cada jogador. 4 | 5 | gols = list() 6 | jogador = dict() 7 | time = list() 8 | 9 | while True: 10 | jogador['Nome'] = str(input('Nome do Jogador: ')).strip() 11 | partidas = int(input(f'Quantas Partidas {jogador["Nome"]} jogou? ')) 12 | 13 | if partidas > 0: 14 | for c in range(0, partidas): 15 | gols.append(int(input(f' Quantos gols na {c+1}º partida? '))) 16 | jogador['Gols'] = gols[:] 17 | jogador['Total'] = sum(gols) 18 | time.append(jogador.copy()) 19 | 20 | while True: 21 | op = str(input('Quer continuar? [S/N]')).upper().strip()[0] 22 | if op in 'SN': 23 | jogador.clear() 24 | gols.clear() 25 | break 26 | print('Opção inválida! Tente novamente.') 27 | if op == 'N': 28 | break 29 | 30 | print('-='*20) 31 | print(f'{"Cod":<5}{"NOME":<10}{"Total":<10}{"Gols":<10}') 32 | for i, j in enumerate(time): 33 | print(f'{i:<5}{j["Nome"]:<10}{j["Total"]:<10}{j["Gols"]}') 34 | 35 | 36 | print('-='*20) 37 | while True: 38 | aux = int(input('Mostrar os dados de qual jogador? (999 sair) ')) 39 | if aux == 999: 40 | break 41 | else: 42 | print(f'--- LEVANTAMENDO DO JOGADOR {time[aux]["Nome"]}') 43 | for i, j in enumerate(time[aux]["Gols"]): 44 | print(f' Na {i+1}º partida fez {j} gol(s)') 45 | -------------------------------------------------------------------------------- /Exercicios/096 - Função que calcula área.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 096 - Função que calcula área 2 | # Faça um programa que tenha uma função chamada área(), que receba as dimensões de um terreno retangular 3 | # (largura e comprimento) e mostre a área do terreno. 4 | 5 | 6 | def terreno(l, c): 7 | area = l * c 8 | print(f'A área de um terreno com {l} x {c} é de {area}m²') 9 | 10 | 11 | print("CALCULO DA AREA DO TERRENO") 12 | print('-'*20) 13 | 14 | largura = float(input('Largura: (m) ')) 15 | comprimento = float(input('Comprimento: (m) ')) 16 | 17 | terreno(largura, comprimento) 18 | -------------------------------------------------------------------------------- /Exercicios/097 - Um print especial.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 097 - Um print especial 2 | # Faça um programa que tenha uma função chamada escreva(), 3 | # que receba um texto qualquer como parâmetro e mostre uma mensagem com tamanho adaptável. 4 | 5 | 6 | def escreva(msg): 7 | len(msg) 8 | print('~'*len(msg)) 9 | print(msg) 10 | print('~' * len(msg)) 11 | 12 | 13 | txt = str(input('Diga uma mensagem: ')) 14 | escreva(txt) 15 | -------------------------------------------------------------------------------- /Exercicios/098 - Função de Contador.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 098 - Função de Contador 2 | # Faça um programa que tenha uma função chamada contador(), que receba três parâmetros: início, fim e passo. 3 | # Seu programa tem que realizar três contagens através da função criada: 4 | # a) de 1 até 10, de 1 em 1 5 | # b) de 10 até 0, de 2 em 2 6 | # c) uma contagem personalizada 7 | 8 | 9 | def contagem(i, f, p): 10 | print('-='*10) 11 | print(f'Contagem de {i} até {f} passo {p}') 12 | for num in range(i, f, p): 13 | print(num, end=' ') 14 | print('FIM') 15 | 16 | 17 | contagem(1, 11, 1) 18 | contagem(10, -1, -2) 19 | 20 | print('Personalize a contagem:') 21 | inicio = int(input('Início: ')) 22 | fim = int(input('Fim: ')) 23 | passo = int(input('Passo: ')) 24 | 25 | contagem(inicio, fim, passo) 26 | -------------------------------------------------------------------------------- /Exercicios/099 - Função que descobre o maior.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 099 - Função que descobre o maior 2 | # Faça um programa que tenha uma função chamada maior(), que receba vários parâmetros com valores inteiros. 3 | # Seu programa tem que analisar todos os valores e dizer qual deles é o maior. 4 | 5 | 6 | def maior(*num): 7 | print(f'Valores recebidos {num}') 8 | print(f'Maior valor: {max(num)}') 9 | 10 | 11 | maior(1, 2, 3, 9, 5) 12 | -------------------------------------------------------------------------------- /Exercicios/100 - Funções para sortear e somar.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 099 - Função que descobre o maior 2 | # Faça um programa que tenha uma lista chamada números e duas funções chamadas sorteia() e somaPar(). 3 | # A primeira função vai sortear 5 números e vai colocá-los dentro da lista e a segunda função vai mostrar 4 | # a soma entre todos os valores pares sorteados pela função anterior. 5 | 6 | from random import randint 7 | 8 | 9 | def sorteia(lista): 10 | for i in range(0, 5): 11 | lista.append(randint(1, 10)) 12 | print(f'Lista: {lista}') 13 | 14 | 15 | def soma(lista): 16 | print(f'A soma entre os itens da lista é: {sum(lista)}') 17 | 18 | 19 | numeros = list() 20 | sorteia(numeros) 21 | soma(numeros) 22 | -------------------------------------------------------------------------------- /Exercicios/101 - Funções para votação.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 101 - Funções para votação 2 | # Crie um programa que tenha uma função chamada voto() que vai receber como parâmetro o ano de nascimento de uma 3 | # pessoa retornando um valor literal indicando se uma pessoa tem voto NEGADO, OPCIONAL e OBRIGATÓRIO nas eleições. 4 | 5 | 6 | def voto(ano): 7 | from datetime import date 8 | atual = date.today().year 9 | idade = atual - ano 10 | if idade < 16: 11 | return 'Voto: Negado' 12 | elif idade >= 18: 13 | return 'Voto: Obrigatório' 14 | else: 15 | return 'Voto: Opcional' 16 | 17 | 18 | nascimento = int(input('Informe a data de nascimento: ')) 19 | print(voto(nascimento)) 20 | -------------------------------------------------------------------------------- /Exercicios/102 - Função para Fatorial.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 102 - Função para Fatorial 2 | # Crie um programa que tenha uma função fatorial() que receba dois parâmetros: 3 | # o primeiro que indique o número a calcular e outro chamado show, que será um valor lógico (opcional) 4 | # indicando se será mostrado ou não na tela o processo de cálculo do fatorial. 5 | 6 | 7 | def fatorial(num, show=False): 8 | fat = 1 9 | for i in range(num, 0, -1): 10 | fat *= i 11 | if show: 12 | for i in range(num, 0, -1): 13 | if i == 1: 14 | print('1', end='') 15 | else: 16 | print(i, end=' x ') 17 | print(f' = {fat}') 18 | else: 19 | print(f'Fatorial de {num}! é {fat}') 20 | 21 | 22 | n = int(input('Informe um número para calcular o fatorial: ')) 23 | mostrar = int(input('Mostrar na tela? [0-Não/1-Sim]')) 24 | fatorial(n, mostrar) 25 | -------------------------------------------------------------------------------- /Exercicios/103 - Ficha do Jogador.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 103 - Ficha do Jogador 2 | # Faça um programa que tenha uma função chamada ficha(), que receba dois parâmetros opcionais: 3 | # o nome de um jogador e quantos gols ele marcou. O programa deverá ser capaz de mostrar a ficha do jogador, 4 | # mesmo que algum dado não tenha sido informado 5 | 6 | def ficha(jogador='Não informado', gols=-1): 7 | print('-'*40) 8 | print(f'{"Jogador":<20}{"Gols":<20}') 9 | if gols == -1: 10 | print(f'{jogador:<20}{"Não informado":<20}') 11 | else: 12 | print(f'{jogador:<20}{gols:<20}') 13 | 14 | ficha() 15 | ficha('ana') 16 | ficha(gols=5) 17 | ficha('marta', 3) -------------------------------------------------------------------------------- /Exercicios/104 - Validando entrada de dados.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 104 - Validando entrada de dados em Python 2 | # Crie um programa que tenha a função leiaInt(), que vai funcionar de forma semelhante 'a função input() do Python, 3 | # só que fazendo a validação para aceitar apenas um valor numérico. 4 | 5 | 6 | def leiaInt(n): 7 | while not n.isnumeric(): 8 | print(f'{n} não é um número') 9 | n = input('Digite um número: ') 10 | return n 11 | 12 | 13 | aux = leiaInt(input('Digite um número: ')) 14 | print(f'Você digitou o número {aux}') 15 | -------------------------------------------------------------------------------- /Exercicios/105 - Analisando e gerando Dicionários.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 104 - Validando entrada de dados em Python 2 | # Faça um programa que tenha uma função notas() que pode receber várias notas de alunos 3 | # e vai retornar um dicionário com as seguintes informações: 4 | # - Quantidade de notas 5 | # - A maior nota 6 | # - A menor nota 7 | # - A média da turma 8 | # - A situação (opcional) 9 | # Adicione também as docstrings dessa função para consulta pelo desenvolvedor. 10 | 11 | 12 | def notas(*nota): 13 | """ 14 | Função para receber notas e retornar um dicionário contendo informações sobre a turma 15 | :param nota: recebe as notas da turma. 16 | :return: retorna um dicionário contendo a quantidade de notas informadas, a maior e menor nota, além da média da turma. 17 | """ 18 | informacoes = dict() 19 | informacoes['Quantidade de notas'] = len(nota) 20 | informacoes['Maior nota'] = max(nota) 21 | informacoes['Menor nota'] = min(nota) 22 | informacoes['Média da turma'] = sum(nota)/len(nota) 23 | 24 | if sum(nota)/len(nota) >= 7: 25 | informacoes['Situação da turma'] = 'Boa' 26 | elif sum(nota)/len(nota) >= 5: 27 | informacoes['Situação da turma'] = 'Razoavel' 28 | else: 29 | informacoes['Situação da turma'] = 'Ruim' 30 | 31 | for i, j in informacoes.items(): 32 | print(f'{i}: {j}') 33 | 34 | 35 | # MAIN 36 | notas(10, 5, 9) 37 | -------------------------------------------------------------------------------- /Exercicios/106 - Sistema interativo de ajuda.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 106 - Sistema interativo de ajuda em Python 2 | # Faça um mini-sistema que utilize o Interactive Help do Python. 3 | # O usuário vai digitar o comando e o manual vai aparecer. 4 | # Quando o usuário digitar a palavra 'FIM', o programa se encerrará. Importante: use cores. 5 | 6 | 7 | def ajuda(funcao): 8 | print('\033[7m~' * 30) 9 | help(funcao) 10 | print('\033[m' * 30) 11 | 12 | 13 | while True: 14 | print('\033[45m~'*30) 15 | print(f'{"Sistema de ajuda PyHELP":^30}') 16 | print('~' * 30) 17 | print('\033[m') 18 | 19 | aux = (str(input('Função ou Biblioteca (FIM para sair)-> '))) 20 | if aux == 'FIM': 21 | 22 | break 23 | 24 | ajuda(aux) 25 | -------------------------------------------------------------------------------- /Exercicios/107 - Exercitando módulos.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 107 - Exercitando módulos em Python 2 | # Crie um módulo chamado moeda.py que tenha as funções incorporadas aumentar(), diminuir(), dobro() e metade(). 3 | # Faça também um programa que importe esse módulo e use algumas dessas funções. 4 | 5 | from pacote import moeda 6 | 7 | num = float(input('Informe um valor: ')) 8 | print(f'''Aumento de 10%: R${moeda.aumentar(num, 10):.2f} 9 | Subtração de 10%: R${moeda.diminuir(num, 10):.2f} 10 | Dobro: R${moeda.dobro(num):.2f} 11 | Metade: R${moeda.metade(num):.2f}''') 12 | -------------------------------------------------------------------------------- /Exercicios/108 - Formatando Moedas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 108 - Formatando Moedas 2 | # Adapte o código do desafio #107, criando uma função adicional chamada moeda() que consiga mostrar os 3 | # números como um valor monetário formatado. 4 | 5 | from pacote import moeda 6 | 7 | num = float(input('Informe um valor: ')) 8 | print(f'''Aumento de 10%: {moeda.moeda(moeda.aumentar(num, 10))} 9 | Subtração de 10%: {moeda.moeda(moeda.diminuir(num, 10))} 10 | Dobro: {moeda.moeda(moeda.dobro(num))} 11 | Metade: {moeda.moeda(moeda.metade(num))}''') 12 | -------------------------------------------------------------------------------- /Exercicios/109 - Formatando Moedas.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 109 - Formatando Moedas 2 | # Modifique as funções que form criadas no desafio 107 para que elas aceitem um parâmetro a mais, 3 | # informando se o valor retornado por elas vai ser ou não formatado pela função moeda(), desenvolvida no desafio 108. 4 | 5 | from pacote import moeda 6 | 7 | num = float(input('Informe um valor: ')) 8 | print(f'''Aumento de 10%: {moeda.aumentar(num, 10, formatacao=True)} 9 | Subtração de 10%: {moeda.diminuir(num, 10, formatacao=True)} 10 | Dobro: {moeda.dobro(num, formatacao=True)} 11 | Metade: {moeda.metade(num, formatacao=True)}''') 12 | -------------------------------------------------------------------------------- /Exercicios/110 - Reduzindo ainda mais seu programa.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 110 - Reduzindo ainda mais seu programa 2 | # Adicione o módulo moeda.py criado nos desafios anteriores, uma função chamada resumo(), que mostre na tela 3 | # algumas informações geradas pelas funções que já temos no módulo criado até aqui. 4 | 5 | from pacote.moeda import resumo 6 | 7 | resumo(10, 10, 10) 8 | -------------------------------------------------------------------------------- /Exercicios/111 - Transformando módulos em pacotes.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 111 - Transformando módulos em pacotes 2 | # Crie um pacote chamado utilidadesCeV que tenha dois módulos internos chamados moeda e dado. 3 | # Transfira todas as funções utilizadas nos desafios 107, 108 e 109 para o primeiro pacote e 4 | # mantenha tudo funcionando. 5 | 6 | 7 | from pacote.moeda import resumo 8 | 9 | resumo(10, 10, 10) 10 | -------------------------------------------------------------------------------- /Exercicios/112 - Entrada de dados monetários.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 111 - Transformando módulos em pacotes 2 | # Dentro do pacote que criamos no desafio 111, temos um módulo chamado dado. 3 | # Crie uma função chamada leiaDinheiro() que seja capaz de funcionar como a função imput(), 4 | # mas com uma validação de dados para aceitar apenas valores que seja monetários. 5 | 6 | from pacote.moeda import resumo 7 | from pacote import dados 8 | 9 | preco = dados.leiaDinheiro() 10 | aumento = int(input('Informe a porcentagem de aumento: ')) 11 | desconto = int(input('Informe a porcentagem de desconto: ')) 12 | resumo(preco, aumento, desconto) 13 | -------------------------------------------------------------------------------- /Exercicios/113 - Funções aprofundadas em Python.py: -------------------------------------------------------------------------------- 1 | #Exercício Python 113: Reescreva a função leiaInt() que fizemos no desafio 104, incluindo agora a possibilidade 2 | # da digitação de um número de tipo inválido. Aproveite e crie também uma função leiaFloat() com a mesma funcionalidade. 3 | 4 | def leiaINT(): 5 | while True: 6 | try: 7 | n = int(input('Digite um número inteiro: ')) 8 | except (ValueError, TypeError): 9 | print('\033[31mErro! Por favor digite um número inteiro válido\033[m') 10 | else: 11 | return n 12 | 13 | 14 | def leiaFLOAT(): 15 | while True: 16 | try: 17 | n = float(input('Digite um número real: ')) 18 | except (ValueError, TypeError): 19 | print('\033[31mErro! Por favor digite um número real válido\033[m') 20 | else: 21 | return n 22 | 23 | 24 | num1 = leiaINT() 25 | num2 = leiaFLOAT() 26 | 27 | print('-'*20) 28 | print(f'''Número Inteiro: {num1} 29 | Número real: {num2}''') 30 | print('-'*20) 31 | -------------------------------------------------------------------------------- /Exercicios/114 - Site está acessível.py: -------------------------------------------------------------------------------- 1 | #Exercício Python 114: Crie um código em Python que teste se o site pudim está acessível pelo computador usado. 2 | 3 | #import urllib 4 | 5 | import urllib.request 6 | 7 | try: 8 | site = urllib.request.urlopen('http://www.pudim.com.br/') 9 | except urllib.error.URLError: 10 | print('Deu erro') 11 | else: 12 | print('Tudo ok') 13 | -------------------------------------------------------------------------------- /Exercicios/115 - Cadastro de Pessoas (Arquivo).py: -------------------------------------------------------------------------------- 1 | import pessoas 2 | import os 3 | 4 | layout = {'limpar': '\033[m', 5 | 'azul': '\033[36m', 6 | 'amarelo': '\033[33m', 7 | 'vermelho': '\033[31m', 8 | 'barra': '----------------------------------------'} 9 | 10 | while True: 11 | print(layout['azul']) 12 | print(layout['barra']) 13 | print('SISTEMA DE CADASTRO DE PESSOAS'.center(40)) 14 | print(layout['barra']) 15 | print(''' 1 - NOVO CADASTRO\n 2 - PESSOAS CADASTRADAS\n 0 - SAIR''') 16 | 17 | op = int(input(f'''{layout['azul']}Opção desejada: ''')) 18 | 19 | print(layout['limpar']) 20 | 21 | if op == 1: 22 | print(layout['amarelo']) 23 | print(layout['barra']) 24 | print('NOVO CADASTRO'.center(40)) 25 | print(layout['barra']) 26 | 27 | nome = input('Informe o Nome: ') 28 | idade = int(input('Informe a idade: ')) 29 | 30 | print(layout['barra']) 31 | print(layout['limpar']) 32 | pessoas.cadastrarPessoa(nome, idade) 33 | 34 | elif op == 2: 35 | print(layout['amarelo']) 36 | print(layout['barra']) 37 | print('PESSOAS CADASTRADAS'.center(40)) 38 | print(layout['barra']) 39 | pessoas.imprimir() 40 | print(layout['barra'], layout['limpar']) 41 | os.system("PAUSE") 42 | 43 | elif op == 0: 44 | print(layout['amarelo']) 45 | print('Volte Sempre!') 46 | print(layout['limpar']) 47 | break 48 | 49 | else: 50 | print(layout['vermelho']) 51 | print('Opção inválida!') 52 | print(layout['limpar']) 53 | os.system("PAUSE") 54 | -------------------------------------------------------------------------------- /Exercicios/115 - Modulo Pessoas.py: -------------------------------------------------------------------------------- 1 | def cadastrarPessoa(n, i): 2 | try: 3 | arq = open('pessoas.txt', 'r') 4 | conteudo = arq.readlines() 5 | conteudo.append(f'{n}'.ljust(30) + f'{i} anos\n'.rjust(10)) 6 | arq.close() 7 | 8 | arq = open('pessoas.txt', 'w') 9 | arq.writelines(conteudo) 10 | arq.close() 11 | except FileNotFoundError: 12 | arq = open('pessoas.txt', 'w') 13 | texto = (f'{n}'.ljust(30) + f'{i} anos\n'.rjust(10)) 14 | arq.writelines(texto) 15 | 16 | 17 | def imprimir(): 18 | try: 19 | arq = open('pessoas.txt', 'r') 20 | texto = arq.read() 21 | print(texto) 22 | arq.close() 23 | except FileNotFoundError: 24 | print('*** '*10) 25 | 26 | -------------------------------------------------------------------------------- /Exercicios/pacote/__init__.py: -------------------------------------------------------------------------------- 1 | from pacote import moeda, dados 2 | -------------------------------------------------------------------------------- /Exercicios/pacote/__pycache__/__init__.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/andreinaoliveira/Exercicios-Python/c478230420312cce83fd9236c273dd05809d4f37/Exercicios/pacote/__pycache__/__init__.cpython-37.pyc -------------------------------------------------------------------------------- /Exercicios/pacote/dados/__init__.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 111 - Transformando módulos em pacotes 2 | # Dentro do pacote que criamos no desafio 111, temos um módulo chamado dado. 3 | # Crie uma função chamada leiaDinheiro() que seja capaz de funcionar como a função imput(), 4 | # mas com uma validação de dados para aceitar apenas valores que seja monetários. 5 | 6 | def leiaDinheiro(valor=''): 7 | while True: 8 | if ',' in valor or valor.isnumeric(): 9 | a = (f'{valor}'.replace(',','.')) 10 | aux = float(a) 11 | return aux 12 | elif '.' in valor: 13 | aux = float(valor) 14 | return aux 15 | else: 16 | print('Valor informado inválido!') 17 | valor = str(input('Informe um valor: ')) 18 | -------------------------------------------------------------------------------- /Exercicios/pacote/dados/__pycache__/__init__.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/andreinaoliveira/Exercicios-Python/c478230420312cce83fd9236c273dd05809d4f37/Exercicios/pacote/dados/__pycache__/__init__.cpython-37.pyc -------------------------------------------------------------------------------- /Exercicios/pacote/moeda/__init__.py: -------------------------------------------------------------------------------- 1 | # Exercício Python 107 - Exercitando módulos em Python 2 | # Crie um módulo chamado moeda.py que tenha as funções incorporadas aumentar(), diminuir(), dobro() e metade(). 3 | # Faça também um programa que importe esse módulo e use algumas dessas funções. 4 | 5 | 6 | def moeda(preco, moeda='R$'): 7 | """ 8 | Retorna o preço formatado para moeda 9 | :param preco: Valor do produto 10 | :param moeda: A moeda desejada para a formatação, por padrão, real 11 | :return: Preco formatado para moeda 12 | """ 13 | return f'{moeda}{preco:.2f}'.replace('.', ',') 14 | 15 | 16 | def aumentar(preco, taxa, formatacao=False): 17 | """ 18 | Função para aumentar uma porcentagem sobre o produto 19 | :param preco: Preço do produto 20 | :param taxa: Porcentagem que será somada no produto 21 | :param formatacao: Se True retorna o preço formatado com a função moeda() 22 | :return: Aumento de taxa 23 | """ 24 | 25 | novoPreco = preco + (preco * taxa / 100) 26 | return novoPreco if formatacao is False else moeda(novoPreco) 27 | 28 | 29 | def diminuir(preco, taxa, formatacao=False): 30 | """ 31 | Função para diminuir uma porcentagem sobre o produto 32 | :param preco: Preço do produto 33 | :param taxa: Porcentagem que será somada no produto 34 | :param formatacao: Se True retorna o preço formatado com a função moeda() 35 | :return: Desconto de taxa 36 | """ 37 | 38 | novoPreco = preco - (preco * taxa / 100) 39 | return novoPreco if formatacao is False else moeda(novoPreco) 40 | 41 | 42 | def dobro(preco, formatacao=False): 43 | """ 44 | Função para calcular o dobro do preço 45 | :param preco: Preço do produto 46 | :param formatacao: Se True retorna o preço formatado com a função moeda() 47 | :return: Dobro do produto 48 | """ 49 | 50 | novoPreco = preco * 2 51 | return novoPreco if formatacao is False else moeda(novoPreco) 52 | 53 | 54 | def metade(preco, formatacao=False): 55 | """ 56 | Função para calcular a metade do preço 57 | :param preco: Preço do produto 58 | :param formatacao: Se True retorna o preço formatado com a função moeda() 59 | :return: Metade do preço 60 | """ 61 | 62 | novoPreco = preco / 2 63 | return novoPreco if formatacao is False else moeda(novoPreco) 64 | 65 | 66 | def resumo(preco, aumento, desconto): 67 | print('-' * 30) 68 | print(f'{"Resumo do valor":^30}') 69 | print('-' * 30) 70 | print(f'''{"Preço Analisado: ":<20}{moeda(preco):>10} 71 | {"Dobro do preço: ":<20}{dobro(preco, formatacao=True):>10} 72 | {"Metade do preço: ":<20}{metade(preco, formatacao=True):>10} 73 | {aumento}{"% de aumento: ":<18}{aumentar(preco, aumento, formatacao=True):>10} 74 | {desconto}{"% de desconto: ":<18}{diminuir(preco, desconto, formatacao=True):>10}''') 75 | print('-' * 30) 76 | -------------------------------------------------------------------------------- /Exercicios/pacote/moeda/__pycache__/__init__.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/andreinaoliveira/Exercicios-Python/c478230420312cce83fd9236c273dd05809d4f37/Exercicios/pacote/moeda/__pycache__/__init__.cpython-37.pyc -------------------------------------------------------------------------------- /Exercicios/temp.md: -------------------------------------------------------------------------------- 1 | arquivo temporário 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |
2 | hits 3 | 4 | 5 | 6 | 7 | 8 |
9 | 10 | # Exercícios Python - Curso em Vídeo 11 | ### Sobre o Curso em Vídeo 12 | 13 | Curso em vídeo possui um vasto catálogo de cursos gratuitos voltados para área de TI com ótima qualidade e fornecendo diversos exercícios. Segue link para acesso à plataforma: 14 | [Canal no Youtube](https://www.youtube.com/user/cursosemvideo) e [Site](https://www.cursoemvideo.com/) 15 | 16 | ### Sobre o Curso de Python 3 17 | 18 | O curso de Python 3 é dividido em três módulos: Fundamentos, Estruturas de Controle e Estruturas Compostas 19 | 20 | 21 | 24 | 27 | 30 | 31 |
22 | 23 | 25 | 26 | 28 | 29 |
32 | 33 | ### Exercícios 34 | 35 | Os três módulos somam 115 exercícios que compõe esse diretório. As respostas contida nesse diretório possuem lógica diferente da playlist de resolução dos exercícios, mas no fim, o resultado é o mesmo. 36 |

37 | 38 | 39 | 42 | 43 |
40 | 41 |
44 | --------------------------------------------------------------------------------