07 de outubro de 2020 • 9 min de leitura
Python
Soluções de problemas de Livros e Atividades Python
Exercício retirado do livro :
Solução do problema:
produtos = []
quantidade = []
valor = []
resultado = []
for cont in range(0,3):
produtos.append(str(input('Digite o produto:')))
quantidade.append(int(input('Digite a quantidade:')))
valor.append(float(input('Digite o Valor :').replace(',', '.')))
for x,y in enumerate(valor):
resultado.append(y*quantidade[x])
print(f'O Produto:{produtos[0]} foi Vendido: {quantidade[0]} vezes , pelo valor de R$ {valor[0]} e o valor total foi de : R$ {resultado[0]:.2f} ')
print(f'O Produto:{produtos[1]} foi Vendido: {quantidade[1]} vezes , pelo valor de R$ {valor[1]} e o valor total foi de : R$ {resultado[1]:.2f} ')
print(f'O Produto:{produtos[2]} foi Vendido: {quantidade[2]} vezes , pelo valor de R$ {valor [2]} e o valor total foi de : R$ {resultado[2]:.2f} ')
print(f'O Valor Total de todas as Vendas é de R$ {(sum(resultado)):.2f} ' )
Output :
Comentários :
-
produtos = [] está entre colchetes pois é uma lista mutável assim como quantidade valor e resultado.
-
for cont in range (0,3): função for percorre índices de 0 a 3 pois temos 3 itens na lista porem o terceiro item vai para o índice 2 pois o primeiro item cai no índice 0 função append insere o valor digitado na lista referente , produtos.append recebe um valor str = string = texto . input abre janela para digitar o produto. int = integer ou seja numero inteiro e float = numero real .
-
Função enumerate , Percorre o Array enumerando suas posições x e y é só um parâmetro para valor e quantidade
-
resultado.append(yquantidade[x]) = adiciona o resultado da multiplicação de valor e quantidade na lista resultado e y é valor quantidade e [x] é os valores da multiplicação que vai nos índices da lista resultado
-
.replace(',', '.') substitui virgula por ponto para evitar erros caso o usuário digitar virgulas nos valores
-
função sum soma todos os valores dos índices da lista resultado
-
o resultado onde aparece o valor de 41.300000... foi exibido dessa forma pois o print nao usou o metodo de formatar números float , para corrigir basta escrever o código dessa forma , {resultado[2]:.2f} ') adicionando o parâmetro :.2f , porem já atualizei o código para exibir o output da melhor forma diferente da foto
lista completa para formatar prints :
O código acima foi a forma mais eficiente que consegui para resolver esse problema mas cada programador tem seu jeito de trabalhar e formas de resolver um problema.
Se você não tem Pycharm instalado para executar esse código , voce pode usar esse site
https://colab.research.google.com/#create=true
onde você pode testar códigos em Python sem necessidade de instalar programas
ou simplesmente utilizar o vscode e instalar extensões como o jupyter notebook
O Clássico Calculo de média de notas
materias = int(input('Digite a quantidade de materias '))
notas = []
for c in range (0,materias):
notas.append(float(input('Digite as notas :').replace(',', '.')))
resultado = (sum(notas) / (materias))
print(f'A Média final é {resultado:.2f}')
Sequência de Fibonacci
https://pt.wikipedia.org/wiki/Sequ%C3%AAncia_de_Fibonacci
Código Python Para Calcular a Sequência de Fibonacci
print('-'*33)
print('Sequência de Fibonacci')
print('-'*33)
termos = int(input('Digite Quantas Sequência de termos Fibonacci você quer exibir : '))
termo0 = 0
termo1 = 1
print('-'*33)
print(f'{termo0} → {termo1}', end="")
contador = 3
while contador <= termos:
termox = termo0 + termo1
print('→ {} '.format(termox), end="")
termo0 = termo1
termo1 = termox
contador += 1
print('→ Fim da Sequência')
Output :
Comentários :
Antes de elaborar o código foi preciso entender a logica da sequencia de Fibonacci , Na matemática, a Sequência de Fibonacci é uma sequência de números inteiros , começando normalmente por 0 e 1, na qual, cada termo subsequente corresponde à soma dos dois anteriores.
Quando o código é iniciado o Python executa as primeiras linhas do código onde o print exibe o valor de termo0 e termo1 onde estão com o valor declarado de 0 e 1
porem quando o código chega na estrutura de repetição while o código só vai rodar oque está dentro da estrutura do escopo do while que vai dar um looping de repetição pela quantidade definida pela variável ' termos ' onde o usuário ira digitar quantos termos devem ser exibidos na tela , então o código não vai ser executado desde as primeiras linhas e sim a sequencia vai sendo impressa na tela a cada looping de repetição do while , onde o valor do termo 0 passar a ser o valor do termo1 e o termo1 passa a ter o valor do termox que é a soma de termo0 e termo1 e assim por diante.
Contador = 3 , o contador foi definido a partir do 3 pois a soma já foi iniciada quando foi definido o valor do termo 0 e 1 e o termox .
e a linha de código ' print('→ {} '.format(termox), end="") ' fica no meio da estrutura do while pois é dessa forma que o print ira imprimir um termo a cada sequencia de looping , pois se fosse colocado no final do código ele só iria colocar o valor total de todas as sequencias e o parâmetro ' end="" , faz com que cada termo seja impresso na mesma linha em sequência.
Função Recursiva :
def fibonacci(i, b=0, c=1):
if i != 0:
print(b, end=' -> ')
b = b + c
c = b - c
fibonacci(i-1, b=b, c=c)
return 'FIM'
print(fibonacci(int(input('Quantos termos vc quer mostrar: '))))
Output :
Comentário :
A Função Recursiva recebe esse nome pois ela chama ela mesma durante o ciclo de execução
def fibonacci(i, b=0, c=1): na definição dessa função o parâmetro i é o numero inteiro que vai ser digitado no input do print , b=0 e c=1 é igual no exemplo anterior , são os parâmetros base para o calculo de Fibonacci
if i != 0: é o ponto de parada do ciclo de execução , enquanto o numero i for diferente de 0 execute o código.
print(b, end=' -> ') vai imprimir na tela a sequencia fibonacci do parâmetro b , o parâmetro c não vai ser impresso pois a cada ciclo ele vai ser um numero negativo que não precisa ser exibido
fibonacci(i-1, b=b, c=c) a cada ciclo os valores dentro de Def são atualizados por esse parâmetro onde o i-1 significa que a cada ciclo vai subtrair o numero inteiro solicitado no input até chegar a 0 onde é o ponto de parada e b=b passa a receber o novo valor onde b = b+c e o c pega o novo valor onde c = b-c.
A função recursiva executa o código de uma forma diferente dos exemplos anteriores , usa o método call stack ou pilha de chamadas , onde a cada ciclo o valor fica salvo na memoria
Cálculo Fatorial :
Fatorial é um número natural inteiro positivo, o qual é representado por n! O fatorial de um número é calculado pela multiplicação desse número por todos os seus antecessores até chegar ao número 1.
então 5x4x3x2x1 = 120
Cálculo Fatorial usando o While :
contador = int(input(' Digite um número para calcular o Fatorial:'))
fatorial = 1
print(f'Fatorial de {contador}! ', end="")
while contador > 0:
print(f'{contador}', end="")
print('x' if contador > 1 else '=' , end="")
fatorial *= contador
contador -= 1
print(f'{fatorial}')
Output :
Comentários :
fatorial = 1 Recebe esse valor pois o Calculo Fatorial é uma Multiplicação e Não pode ter o valor de 0 igual no Cálculo de Fibonacci
while contador > 0: enquanto o contador for maior que 0 execute o código abaixo
print('x' if contador > 1 else '=' , end="") esse print tem operadores de comparação apenas para coloca um sinal de = quando o código chegar no contador 0
fatorial *= contador : se o contador for 5 o Python vai interpretar o código dessa forma :
5x1x4x1x3x1x2x1 = 120 , pois o valor fatorial foi definido como 1 , porem no primeiro ciclo de execução o python calculou 5x1 = 5 e salvou o 5 na memoria como uma calculadora faz , então quando chamou o 4x1 calculou 5x4 .
contador -= 1 : simplesmente significa que a cada repetição vai subtrair 1 do contador até chegar em 0 o ponto de parada .
Fatorial usando laço For :
n = int(input('Digite um numero para calcular seu fatorial: '))
f = 1
for c in range (1, n):
f *= n
n -= 1
print('Seu fatorial é {}.'.format(f))
Utilizando a estrutura de repetição For fica mais simples e claro de entender
o Python vai calcular igual ao while : ex 1x5x1x4x1x3x1x2x1x1 = 120
e a lógica de execução vai seguir o mesmo padrão
Fatorial Modo Apelativo :)
from math import factorial
n = int(input('Digite o número para calculo do Fatorial:'))
f = factorial(n)
print(f' O Fatorial de {n} é {f}')
Output :
Comentário :
No exemplo acima vemos que o Python Pode usar a Biblioteca Math com o Calculo Fatorial pronto que adianta a vida do programador sem a necessidade de elaborar nenhuma logica , porem nen sempre existe uma biblioteca disponível para executar esses cálculos .
Fatorial recursivo :
def fatorial(n: int) -> int:
if n == 1 or n == 0:
return 1
return n * fatorial(n - 1)
if __name__ == "__main__":
fat = fatorial(int(input('Digite o número para calculo do Fatorial:')))
print(fat)
Output :
Comentário :
Essa Função Recursiva está um pouco diferente do exemplo anterior , pois é uma recursão de 2 fatores , porem segue a mesma lógica
def fatorial(n: int) -> int: Definição da função Fatorial recebe como parâmetro número inteiro e retorna numero inteiro
if n == 1 or n == 0: return 1 = caso-base para parar a recursão, retornar um valor real e resolver as equações (quando chegarmos em 1) ponto de parada
return n fatorial(n - 1) = **retorna n (ex 5 ) Fatorial é o nome da Def quem tem parâmetro ( n - 1 ) retira -1 a cada ciclo para zerar o contador até concluir o calculo onde n é o numero do fatorial digitado no input**
então na primeira chamada ficou 5x4 pois o parâmetro n -1 fez a subtração
porem nesse caso a call stack vai executar o código dessa maneira depois de todos os ciclos forem salvos na memoria 1x2 ' 2 ' 2x3 ' 6 ' 6x4 ' 24 ' 24x5 ' 120 ' a cada calculo a stack vai sendo apagada da memoria , a função recursiva faz o calculo 1 de cada vez
melhor forma de observar como um código sendo executado é utilizando o debuger do vscode por exemplo
obs existe um limite de valores para serem executados no call stack que é de 1000 e o python protege o código de um possível looping infinito
funções recursivas geralmente consomem muita memoria e devem ser utilizada em programações funcionais , fora isso o tradicional é programar usando um laço ' for ' se for utilizado mais de 1000 interações por exemplo ou usar o looping com while
Como exibir as linhas de um arquivo txt usando Python ?
Desafio veio de um fórum gringo dessa vez :
file1 = open('Mary_Lamb.txt', 'r')
Lines = file1.readlines()
count = 0
for line in Lines:
count += 1
print("Line{}: {}".format(count, line.strip()))
file1.close()
Output :
Acho que não preciso explicar muito , na parte inicial do código foi colocado o nome do arquivo txt que está na mesma pasta do Python e o método readlines faz a leitura de todas as linhas e o .strip fez uma copia de cada linha pra ser possível contar e separar as linhas
f.close() é um boa pratica fechar um arquivo depois de aberto no final do código.