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 :

  https://mkaz.blog/code/python-string-format-cookbook/

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.

Todos os códigos disponíveis no meu repositório Github :

https://github.com/FranciscoBSpadaro/codigos-python01