Exercício Python

Estude pelo nosso site e tire certificado de 40 horas. Curso completo em:
www.cursoemvideo.com/curso/python-3-mundo-3/

[@Pedro-uz5vn]

parabens ae pros quase 30k de pessoas q chegaram ate aq vcs sao foda!

[@herissonricardo-slackwareo450]

Cada dia que passa essas aulas do Professor Guanabara fica melhor, Parabéns Professor!!!

[@vittaday]

Tava empacando nesse exercício porque estava fazendo com 2 return, e dava None, a correção abriu a mente rs

[@icarodm]

Aconteceu comigo. Não dava pra usar 2 return e nem print dentro e fora da função. Aí vi na aula que vc pode usar print dentro da função que tem return e printar fora sem problemas. xD

[@delcidesneto7840]

Gente to muito feliz por eu consegui fazer esse sozinho tinha tempo que eu não dava conta, é mó satisfatório ver algo que você fez funcionar
f fatorial(num, show=False):
"""
-> Calcula o fatorial do número digitado.
:param n: O número a ser calculado.
:param show: (opcional) mostrar ou não a conta.
:return: Retorna o valor de n.
"""
if show == True:
multiplicador = 1
print('-'*20)
for numero in range(num, 0, -1):
multiplicador = multiplicador*numero
print(numero, end='')
print(' x ' if numero > 1 else ' = ', end='')
return multiplicador
if show == False:
multiplicador = 1
print('-'*20)
for numero in range(num, 0, -1):
multiplicador = multiplicador*numero
return multiplicador
print(fatorial(1, True))

[@cigarroapagado1423]

Exercício era tão simples que eu buguei na parte de entender pra que servia o show kkkkk

[@ailtonmendes8306]

Obrigado Gustavo Guanabara, graças a você e suas video aulas hoje sei Python, me despertou para a área e consegui ingressar na faculdade de análise e desenvolvimento de sistemas !!! #let’sgofebruary2019

[@EquipeZueiros]

Mais uma aula de total qualidade

[@lMatheusx]

#Não fiz a parte do help que o Guanabara fez, mas acho que ficou bem simples e curto!
def fat(n, b):
if(n > 0):
if(b == True):
print(end ='' f'{n} x ' if n > 1 else f'{n} = ');
return n * fat(n - 1, True);
else:
return n * fat(n - 1, False);
else:
return 1;
print(fat(5, True));

[@gabrielgarbi8845]

boa noite Prof Guanabara, por acaso vc ensinará sobre alguma biblioteca? Se sim, PANDAS seria muito bom! Vc explica mto bem, nao consigo achar nada parecido em outros cursos. Parabens!

[@nathaliaaguiar7082]

A felicidade de ver o código funcionando não tem preço...
def fatorial(num, show=False):
'''
-> Calcula o fatorial de um número.
:param num: o número a ser calculado
:return: o valor do fatorial de um número num
'''
print('-' * 35)
mult = 1
while num > 0:
if show :
print(f'{num}', end='')
if num == 1:
print(' =', end='')
else:
print(' X ', end='')
mult *= num
num -= 1
print(f' {mult}')
fatorial(7, show=True)

[@tiktudocine]

fiz o codigo, usando como base tudo que aprendi ate agora com voce professor!
def fatorial(num=1, show=False):
f = 1
if show == False:
for c in range(num, 0, -1):
f *= c
resp = f'{f}'
return resp
elif show:
f = 1
dados = []
for a in range(num, 0, -1):
f *= a
dados.append(f'{a} x ')
dados[-1] = '1'
resp = ''.join(dados) + f' = {f}'
return resp
print(fatorial(5, show=False))

[@Shlnigamii]

que negocio porco.

[@WooFeeBr]

Achei interessante usar isso:
num = 123456789
print(f'{num:,}')
A virgula no final separa os números a cada 3 casas. Muito útil pra lidar com números grandes :)

[@svetlana_kapranova]

Upgrade dessa solução fazendo com que o usuário insira por "int(input)" se ele quer que o cálculo seja exibido:
def fatorial(numero,show=0):
from math import factorial
fatorial_numero = factorial(numero)
print(f'O fatorial de {numero} é {fatorial_numero}.')
if show==1:
print('O cálculo desse fatorial é:')
for c in range(numero,0,-1):
print(f'{c}',end='')
if c > 1:
print('.',end='')
else:
print('=',end='')
print(fatorial_numero)
else:
print('Cálculo não exibido.')
#Programa Principal
numero = int(input('Informe um número inteiro para o cálculo de seu fatorial:'))
show = int(input('Deseja ver o cálculo desse fatorial [0/1]?'))
if show != 1 and show !=0:
show = int(input('Opção inválida.Deseja ver o cálculo desse fatorial [0/1]?'))
fatorial(numero,show)
----------------------------------
Ps: na exibição do cálculo, troquei o "x" por "." , porque acho que a exibição fica mais limpa.

[@denysantos9012]

Tbm fiz assim!
def fact(n,show=False):
f = 1
for c in range(n, 0,-1):
f *=c
if show:
if c !=1:
print(f"{c}",end='×')
else:
print(f"{c}",end='=')
return f

fat = int(input("fatorial de: "))
while True:
cc= input("mostrar calculo[S/N]: ").strip().upper()[0]
if cc not in "SN":
print("opção invalida")
elif cc in "S":
print(fact(fat,show=True))
break
else:
print(fact(fat))
break

[@KayanCriptografia]

@@denysantos9012 Tentem criar um programa que retorne o fatorial de qualquer número real positivo, como por exemplo fatorial de 1/2

[@awaririawa4238]

Obrigado, tio Gu!

[@marcelalima8312]

Aula bem proveitosa! Grata professor.

[@ping8156]

Terminei o curso de python básico da solyd recomendo também é muito bom.

[@diegomarques281]

Continuando firme e forte nos estudos :D

[@fcdennis1983]

Fiz de um modo mais interativo com o usuário:
#função
def fatorial(num, show=False):
f = 1
if show == True:
for c in range(num, 1, -1):
f *= c
print(f'{c} X ', end='')
print(f'1 = ', end='')
return f
if show == False:
for c in range(num, 1, -1):
f *= c
return f'O fatorial de {num} é igual a {f}'
#programa principal
número = int(input('Digite o número que quer o calculo fatorial? '))
detalhe = input('Deseja resultado detalhado (Sim / Não)? ').upper()[0]
while detalhe not in 'SN':
detalhe = input('Deseja detalhado (Sim / Não)? ').upper()[0]
if detalhe in 'Ss':
detalhe = True
else:
detalhe = False
print(fatorial(número, detalhe))

[@jonathammayer4296]

usa o detalhe direto em bool(), ai caso queira que seja false, basta teclar enter sem digitar nada

[@anacarolinaoliveirademiran6429]

from math import factorial
def num(n,show=False):
f=factorial(n)
print(f' O fatorial de {n} é {f}')
if show==True:
print(f' {n}',end='')
for d in range (n,1,-1):
print(f' x {d-1}',end='')
print(f' = {f}')
else:
print()
n=int(input(' Digite um número para calcular o seu fatorial: '))
num(n,show=True)

[@eduardosidneymartinez6537]

valeu professor mais um exercício feito.

[@nataliarauj]

orgulhosa da minha solução!

[@franciscotadeupezzi3431]

Obrigado! Não conseguia entender parâmetros simples como if show:( existe). Obrigado!

[@viniciuslima1311]

na verdade, a leitura é if show:(verdadeiro). Isso pq na aula de condicionais vimos que o primeiro bloco if é o verdadeiro

[@linux_jeff]

Bom vídeo! 🙂

[@pedronovaes_]

Fiz gerando o número de maneira aleatória:
from random import randint
def fatorial(n,show=False):
print(f'Valor sorteado: {n}')
print(f'{n} x',end= " ")
for v in range(n-1,0,-1):
n *= v
if show == True:
print(v,"x " if v != 1 else "= ", end ="")
print(n)
n = randint(2,7)
fatorial(n,show=True)

[@abraxyas]

carai fiz igual hahaha feliz demais
def fatorial(n, show=False):
"""
-> Calcula o Fatorial de um numero.
:param n: O numero a ser calculado.
:param show: (opcional) Mostrar ou não a conta.
:return: O valor do fatorial de um numero n.
"""
f = 1
for i in range(n, 0, -1):
f *= i
if show:
print(i, end='')
if i > 1:
print(' x ', end='')
else:
print(' = ', end='')
return f
print(fatorial(5, True))
help(fatorial)

[@saxvilao]

Obrigado.

[@felipephex]

Melhor curso

[@lucasboticelli342]

Tava indo super bem até a aula 21, depois disso percebi que os exercícios passados estão muito distantes do que é passado na aula teórica, tá ficando realmente complicado de acompanhar, acaba dando uma desanimada mas vamo que vamo

[@DarkHacks22]

concordo, acho errado ter coisa no exercicio que a gente nao aprendeu, obriga a procurar em outro lugar se nao meio impossivel fazer

[@davidalmeida6955]

A minha solução eu usei if... também deu certo . a única diferença é que eu fiz o input pro usuário escolher o número e usar a biblioteca math..

[@gustavohenriquezollnermunh969]

consegui fazer :D, mas em vez de fazer todos esses calculos eu importei a biblioteca math :
def fatorial(num, show=False):''
from math import factorial
if show == True:
for v in range(1, num):
print(f'{v} X ', end='')
print(f'{num} = ', end='')
return factorial(num)
else:
return factorial(num)
print(fatorial(10, True))

[@benhurfaria7819]

Guanabaraaa!! Eu sei que nao é muito o topico agora.. Mas poderia falar de alocacao dinamica de memoria e ponteiros num video avulso?

[@iagosilva4942]

Melhor canal

[@genesebarbosa]

Show...segue mais um...fui no tato e deu certo mais uma vez...assistir a resposta dps...
def fatorial(f,show=False):
v=f+1
a=1
print('-'*30)
if show==False:
while v > 1:
v-=1
a*=v
f=a
return (f)
elif show==True:
while v > 1:
v-=1
a*=v
if v > 1:
print(v,end=' x ')
else:
print(v, end=' = ')
f=a
return (f)
print(fatorial(5))

[@johngimbi]

Bom trabalho

[@re913]

topzera da galáxia pythoniana!
(eu deixo na vel 0.75x pq o gafanhoto mestre fala muito rápido rsrsrsrs.....)
dale!!

[@williangomes9050]

O senhor vai fazer curso de C ou C++ algum dia?

[@EquipeZueiros]

Eu acredito que ano que vem ele vai fazer o curso de C, ele já falou varias vezes q futuramente iria fazer, infelizmente com essa qualidade não dá pra fazer nd rápido, mas com paciência ele faz.

[@marcoshenrique-hp4zv]

@Gabriel Klein tentei me inscrever, mas nao tinha opcao de criar conta,(so apareceu a opcao de login, mas sem o link de "Cadastre-se")
sabe dizer como faco para me inscrever??

[@ducksaj]

Vai sim, será todo em tela DOS (pronpt de comando), serão quase cem aulas e ao final delas você não será capaz nem de fazer um simples cadastro de clientes...

[@hannatavares19]

Tem atualmente no estudonauta

[@thiagoriosbarros2287]

Entendi no enunciado que o objetivo era não usar o print dentro da função e sim o return. Por isso, fiz desta forma:
def fatorial(num=1, show=True):
f = 1
txt = ''
if show:
for c in range(num, 0, -1):
f *= c
if c == 1:
txt = f'{txt} {c} = '
else:
txt = f'{txt} {c} x'
return f'{txt}{f}'
else:
for c in range(num, 0, -1):
f *= c
return f

[@biankpontessousa1573]

Tá aqui o meu:
def fatorial(num=1, show=False):
print('-'*25)
c = 1
for n in range(num, 0, -1):
c *= n
if show == True:
print(n, end='')
print(' x ' if n > 1 else ' = ', end='')
return c
# Programa principal
print(fatorial(5, True))

[@Leandro_timbo]

Eu fiz a solução desse desafio no começo com o for mas sempre que eu executava ele funcionava mas aparecia um NONE, então eu fiz ele com o while e funcionou

[@kisezx3662]

Fiz assim
def fatorial(n, show=True):
f = 1
for c in range(n,0,-1):
if show:
print(c, end='')
if c>1:
print(f' x ', end='')
else:
print(' = ', end='')
f *= c
return f
# Programa principal
while True:
n = int(input('Digite um numero para calcular o factorial: '))
while True:
mostrar = str(input('Quer mostrar a conta? ')).strip().upper()[0]
if mostrar == 'S':
x = True
break
if mostrar == 'N':
x = False
break
f = fatorial(n, show=x)
print(f)
while True:
parar = str(input('Deseja parar? ')).strip().upper()[0]
if parar in 'SN':
break
if parar == 'S':
break

[@cristianomenezes3780]

Consegui :) acabei usando 2 for para guardar em uma lista e outro pra avaliar
def fatorial(fat, show=False):
"""
=> Cálcula o fatorial de um número.
:param fat: O número a ser calculado.
:param show: (opcional) Mostra ou não a conta.
:return: O valor do fatorial de um número fat.
"""
f = 1
lst = []
cont = 0
for c in range(fat, 0, -1):
f *= c
lst.append(c)
if show:
for a in lst:
if cont == (fat - 1):
print(f'{a} = ', end='')
else:
print(f'{a} x ', end='')
cont += 1
return f
else:
return f
help(fatorial)
print(fatorial(5, False))

[@historicosbet]

def Fatorial(n=1, show=False):
"""
-> Calcula Fatorial de um número.
:param n: O número a ser calculado.
:param show: (opcional) Mostrar ou não a conta.
:return: O valor do Fatorial de um número n.
"""
print('-'*30)
fator = 1
for c in range(n, 0, -1):
fator *= c
if show:
print(f'{c} {"=" if c == 1 else "x"} ', end='')
return fator
print(Fatorial(5, show=True))

[@viniciusgustavorodriguesde3767]

Caramba cara, este exercício tirou 1hora e 45 minutos do meu dia para a resolução, mas no fim o importante é claro, resolvido com sucesso!
def fatorial(núm=5, show=False):
"""
Caso esteja passando sufoco na aula de matemática aqui está um programa para calcular o fatorial de qualquer número!!!
Só não abuse da sorte, pode acabar bugando seu sistema e acabar por um xingamento ou qualquer coisa do tipo!
Uso:
Parâmetros: núm = Serve para você digitar o número para tirar o fatorial (valores: 5, caso você não dê um valor!, padrão 5!)
show = É para mostrar o cálculo (valores: True or False, padrão false!)
"""
fatorial = 1
for fator in range(núm, 0, -1):
fatorial *= fator
if show == True:
if fator == 1:
print(f"1 = ", end='')
break
print(f"{fator} * ", end='')
return fatorial
def banner():
print("-" * 30)

banner()
print(fatorial(núm=10, show=False))

[@miickeypdrp5819]

o usúario escolhe o número para fatorar e responde com sim ou não, se quer ver a resolução:
def fatorial(n, s=False):
from math import factorial
c = n
if s:
print("-=" *30)
print("o fatorial de",n,"é",factorial(n))
print("solução: ",end="")
for c in range(1, n+1):
print(c,end="")
if c < n:
print("x",end="")
else:
print(" =",factorial(n))
print("-=" *30)
else:
print("-=" *30)
print("o fatorial de",n,"é",factorial(n))
print("você optou por não ver a solução.")
print("-=" *30)
numero = int(input("número para fatoração: "))
while True:
resolução = str(input("Deseja ver a resolução? ")).lower()[0]
if not resolução in "sn":
print("responda apenas com sim ou não.")
if resolução == "n":
fatorial(numero, False)
break
elif resolução == "s":
fatorial(numero, True)
break

[@iuryoliveira8325]

Dei uma ajustada para printar bonitinho! kkkkkk! Mas ficou legal!
def fatorial(num = 1, show = bool):
f=1
for a in range(num, 0, -1):
f *= a
if show == True:
for b in range(num, 1, -1):
print(f'{b} x', end=' ')
return f'1 = {f}'
else:
return f
#Programa Principal
print(fatorial(5, show=True))

[@josehernandes8726]

Eu fiz assim a minha função
def fatorial(n, show=False):
"""
função que caucula o fatorial de um numero
:param n: numero a se caucular o fatorial
:param show: True = mostra o cauculo / False = esconde o cauculo
:return: o resuçtado do fatorial
"""
from math import factorial
if show == False:
return factorial(n)
else:
cont=n
while cont != 0:
if cont == 1:
print(cont, end=' = ')
else:
print(cont, end=' X ')
cont-=1
return factorial(n)

[@vicentefreire1976]

cara tem detalhes que não consigo imaginar, por exemplo essa situação do simbolo de igual no final, em vez do "X", creio que isso só com os anos de experiência mesmo...

[@victornogueira7641]

AHHHHHHHHHHHHHHH to feliz pela primeira vez consegui fazer com menos linhas que o guanabara
def fator(fac=1, show=0):
'''-> calcula o fatorial de um numero
:param fac: numero a ser fatorado
:param show: se True ele mostra o processo de fatoramento se False nao mostra
:return: ele retorna o valor do numero fatorado'''
f = 1
for c in range(fac, 0, -1):
f *= c
if show == True:
print(f'{c}x' if c > 1 else f'{c}=', end='')
return f
f1 = fator(6,True)
print(f1)
help(fator)

[@jonathammayer4296]

Boa tarde!
Eu fiz o exercicio de uma forma diferente, eu permiti o usuário escolher o número a ser calculado o fatorial e escolher se quer mostrar ou não.
def fatorial(num, show=False):
"""
fatorial é uma função cujo objetivo é demonstrar o cálculo da multiplicação fatorial de um número.
--> Arg 1: num é um numero inteiro qualquer a ser inserido pelo usuário.
--> Arg 2 : show é a opção booleana se o usuário deseja ou não ver o cálculo passo a passo.
--> Return: retorna o valor de num! com a opção de mostrar o cálculo passo a passo.
"""
fat = 1
for c in range(num, 0, -1):
if show:
print(c, end=' ')
if c > 1:
print('x', end=' ')
else:
print(f'= ', end=' ')
fat *= c
return fat
num = int(input('Digite um número: '))
show = bool(input('Deseja ver a operação? [Enter for False] '))
print(fatorial(num, show))

[@callebdebmiguel3298]

mano GUSTAVO boa tarde me chamo sidney sou há algum meses um fã seu, bom recentemente meu sócio que investia em mim com aulas de programação e linguagem me abandonou do nada dizendo ter problemas pessoais e levou o notebook que tinha me dado com todo conhecimento. estou usando suas aulas para sair dessa e gostaria de saber se posso agarrar 100% em seus conhecimentos além do básico para poder vencer esse back que levei. DESDE JÁ FORTE ABRAÇO PRA VC E SUA EQUIPE.

[@melvinsantana2022]

Olá Sidney. Assim como você sou um aprendiz que se juntou a essa nuvem liderada pelo grande gafanhoto. O Guanabara é um cara com uma didática excelente e um cara que compreendeu e atendeu o chamado de que o mundo precisa de programadores do mais diferentes backgrounds, porém existem 2 fatos que você precisa levar em consideração:
- Apesar de estarmos avançando bem (na minha humilde opnião) o Guanabara frisou lá no início que o curso era voltado pra iniciantes e pode não adentrar temas mais profudos. É claro que a resposta do público pode mudar o destino do curso, mas pode ser que em algum momento ele dê o curso como encerrado, mas com toda certeza você terá uma base muito grande pra dar sequência com outros materias mundo a fora.
- As postagens de material podem não ocorrer na velocidade que você precisa e se você tem uma necessidade mais imediata, o seu desenvolvimento técnico pode ser prejudicado.
Se você já fez todo o curso e agora está esperando conteúdo novo sugiro você não ficar esperando pra quando vai ser lançado o próximo vídeo. Corra atrás. Tem bastante conteúdo gratuito por aí, mas se você puder investir um pouquinho tem uma plataforma digital muito famosa com muitos cursos pagos e gratuítos de Python (e muitas outras coisas). Em respeito ao Guanabara, não vou citar nome, nem curso, mas sempre aparece nas propagantdas que antecedem ou interrompem as aulas do grande gafanhoto. Tem cursos em inglês e Português além de sempre rolar promoção (Natal é época de promoção kkk).
Agora se você ainda não chegou até aqui, agarre-se no material já disponível e prepare-se pro vício desse mundo da programação. Pode confiar!
Tmj

[@feliperodriguesdonasciment2509]

Duro esse...
def fatorial(num, show = False):
tot = 1
while tot < numero:
for c in range(num, 1, -1):
tot += 1
if show:
print(f'{num} * {c-1} = {num*(c-1)}')
else:
if tot==numero:
return num
num = num * (c - 1)
print('fim!')
numero = int(input('Digite o número: '))
print(fatorial(numero, show=False))

[@Fadulz]

102 vezes ouvindo: "COMO EU FIZ ISSO? COMO FOI POSSÍVEL? SÓ VC ASSISTIR ATÉ O FINAL QUE A RESPOSTA VEM LOGO AI, ENTÃO COLOCA A FICHA APERTA START E VEM COM O TIO" JKKKKKKKKKKKK Ja até gravei na mente, sonhei com ele falando isso, JESUS!! asuhauhsuahsuha

[@huggoparcelly7255]

O legal é que tem vários caminhos para uma mesma solução.
def fatorial(num, show=0):
"""
-> Calcula o Fatorial de um número.
:param num: O número a ser calculado
:param show: Mostrar ou não o calculo.
:return: O valor fatorial do número.
"""
fat = 1
print('O fatorial de {} é: '.format(num), end='')
if show == 'S':
for cont in range(num, 0, -1):
fat *= cont
print('{}'.format(cont), end='')
if cont > 1:
print(' x ', end='')
else:
print(' = ', end='')
return fat
elif show == 'N':
for cont in range(num, 0, -1):
fat *= cont
return fat
#programa principal
numero = int(input('Digite um número para saber seu fatorial: '))
resp = ' '
while resp not in 'SN':
resp = str(input('Deseja mostrar os cálculos? [S/N] ')).strip().upper()[0]
print(fatorial(numero, resp))

[@andrelf2184]

def fatorial(num, show=False):
"""
*** CÁLCULO DE FATORIAL ***
:param num: valor a ser calculado
:param show: indica se o cálculo será exibido
:return: sem retorno
"""
resp = 1
print(f'{num}! =', end=' ')
while num > 0:
resp *= num
if show:
if num > 1:
print(f'{num} *', end=' ')
else:
print(f'{num} =', end=' ')
num -= 1
print(f'{resp}')
fatorial(5)
fatorial(5, True)
fatorial(12, False)
fatorial(12, True)
help(fatorial)

[@ivanilsonmelo286]

E vamos em frente, mais um pra conta:
def fatorial(num, show=False):
"""
Calcula o Fatorial de um número
:param num: -- > Número desejado (int)
:param show: -- > Se deseja que o processo de cálculo seja apresentado (lógico -boolean)
:return:
"""
dec = num
count = 0
result = 0
fat = ''
while count < num:
count += 1
fat += str(dec) + 'x'
if count > 1:
result = (result * dec)
else:
result = num
dec -= 1
if show:
print(fat[:len(fat)-1], '=', '{}'.format(result))
else:
print(result)
fatorial(5, True)
help(fatorial)

[@Lumc2010]

def fatorial(num=1,show=True):
f = 1
for c in range(num,0,-1):
if show == True:
if c != 1:
print(f"{c} x ",end='')
else:
print(f"{c} = ", end='')
f *= c
return f
n = int(input("Digite um número: "))
ver = str(input("Gostaria de ver o processo [S/N]? ")).upper()[0]
if ver == 'S':
processo = True
fat = fatorial(n, processo)
print(fat)
else:
processo = False
fat = fatorial(n, processo)
print(f"O fatorial de {n} é {fat}")

[@amandadias729]

#Crie um programa que tenha uma função fatorial() que receba dois parâmetros:
#o primeiro que indique o número a calcular e outro chamado show, que será um valor lógico (opcional) indicando se será mostrado ou não na tela o processo de cálculo do fatorial.
from math import factorial
def fatorial(n=0, show=False):
f = factorial(n)
if show == True:
print(f'{n}! = {f}')
fatorial(3, show=True)
#or
def fatorial2way(n,show=False):
c = n
f = 1
while c > 0:
print(f'{c}', end='')
print(' x ' if c > 1 else ' = ', end='') #bota x se o numero é maior que 1 e quando acaba bota =
f = f * c # ou f *= c
c-=1 # c recebe ele mesmo - 1
if show==True:
print(f'{f}')
fatorial2way(3,show=True)

[@antonioevangelistajunior7476]

Gostei do macete "if show:", fui por um caminho um pouco diferente, quem pensou igual a mim?
def fatorial(n=1, show=False):
"""
=> Calcula o fatorial de um número.
:param n: O número a ser calculado
:param show: (opcional) Mostrar ou não a conta.
:return: O valor do fatorial de um número n.
"""
m = 1
conta = f''
for c in range(n, 0, -1):
m *= c
if c > 1:
conta += f'{c} X '
elif c == 1:
conta += f'{c}'
if show == True:
return f'{conta} = {m}'
else:
return m
print(fatorial(6, show=True))

[@awayzso2122]

from math import factorial
def fatorial(n):
for c in range(n,0,-1):
print(c,end='')
if c > 1:
print (' × ',end='')
else:
print(' = ',end='')
print(factorial(n))
n = int(input('Digite um numero: '))
fatorial(n)

[@leomoreirayt]

o meu ficou assim. funciona 100%
def factorial(n: int, show=False):
'''Calculo de factorial
n = Valor inteiro e sera mostrado o seu factorial
show = valor boleano ira mostrar como foi feito o cálculo'''
from math import factorial

if show == True:
sinal = None
for i in range(n, 0, -1):
if i != 1:
sinal = ' x '
else:
sinal = ' = '
print(i, end=sinal)
return factorial(n)
print(factorial(5, show=True))

[@wevertonmata3078]

def fatorial(valor, show=False):
soma = 1
for i in range(valor,0,-1):
if show :
print(i, end="")
if i >1:
print(f' x ', end=" ")
else:
print(f" = ",end='')
soma *= i
return soma
num = int(input("Deseja sabe o fatorial de qual valor: "))
inter = input("Deseja mostra o calculo?[S/N]").upper()
if inter == "S":
show = True
else:
show = False
print(fatorial(num, show=show))

[@zafirwhite3976]

exercicio 102:
fiz um upgrade para o numero e para o calculo :D
def factorial(num, show=False):
"""
--> Calcula o fatorial de um numero
:param num: O numero que vai ser calculado
:param show: Mostrar ou nao a conta
:return: O valor do fatorial de um numero
"""
f = 1
for c in range(num, 0, -1):
if show:
print(c, end='')
if c > 1:
print(f' x ', end='')
else:
print(f' = ', end='')
f *= c
return f
# programa principal
n = int(input('Digite um numero para ver sua fatorial: '))
while True:
calc = str(input('Deseja ver o calculo? [S/N] '))
if calc in 'NnSs':
if calc in 'Ss':
print(factorial(n, show=True))
break
else:
print(factorial(n, show=False))
break
else:
print('Opcao invalida tente novamente')
desculpa pela gambiarra pessoal ;-;

[@thiagomoreira5287]

Onde está a gambiarra?

[@rafaelpintob3]

Também consegui fazer de um modo interativo com o usuario, utilizando while.
#SegueoCodigoAbaixo
def fatorial(num, show=False):
"""
=> => Calcular o Fatorial de um número
:param num: Recebe o que será digitado pelo usuario para calcular o fatorial
:param show: Exibe os calculo inteiro por extenso, se o usuario escolher S na variavel resp
:return: resultado do calculo do fatorial
:param 999: Para encerrar a função.
"""
c = num # Contador vai receber o valor
fat = 1 # Para qualquer multiplicação, fator inical tem que ser sempre 1
while c > 0:
if show:
print(f'{c} ', end='')
if c > 1:
print(' X ', end='')
else:
print(' = ', end='')
fat = fat * c
c = c - 1
return fat
#print(f'-> O Fatorial de {num}! é {fat}.')
# inicio do Programa
while True:
print('-='*30)
num = int(input('INFORME O NUMERO PARA CALCULAR O FATORIAL: '))
if num == 999:
break
resp = str(input('DESEJA MOSTRAR COMPLETO? [S/N] ')).strip().upper()
if resp == 'S':
resp = True
elif resp == 'N':
resp = False
print(fatorial(num,resp))
print('-='*30)
print('Programa Finalizado! Volte Sempre.')
help(fatorial)

[@fabioalvescordeiro9136]

Guanabara, obrigado pelos ensinamentos !!!
#Crie um programa que tenha uma função fatorial() que receba dois parâmetros:
# o primeiro que indique o número a calcular e o outro chamado show, que será um valor lógico (opcional)
# indicando se será mostrado ou não na tela o processo de cálculo do fatorial
def fatorial(num=0, show=False):
"""
:num: É o número a ser fatoriado
:return: n! = n . (n - 1). (n - 2). (n - 3) ... 2,1. exemplo: 5! = 5 . 4 . 3 . 2 . 1 = 120 outro 4! = 4. 3 . 2 . 1 = 24
"""
f = 1
for v in range(num, 0, -1):
if show == True:
print(v, end='')
if v > 1:
print(f' x ', end='')
else:
print(f' = ', end='')
f = f * v
print(f'O valor fatorial de {num} é: {f}')
while True:
valor = int(input('Digite um número para o seu fatorial :'))
while True:
ver = int(input('Deseja visualizar o processo de cálculo fatorial ?'
'
1 = [Sim]'
'
2 = [Não]'
'
Opção:'))
if ver == 1:
fatorial(valor, show=True)
break
elif ver == 2:
fatorial(valor)
break
else:
print('Favor digitar somenete uma das opções 1 ou 2 :')
if ver == 1 or ver == 2:
break

[@Alan-ps8kz]

interessante!!!

[@ossussurrosdaescuridao]

def fatorial(num, show=0):
"""
>>>Funcao para calculo de fatorial
num = param obrigatorio, é o numero que deseja ver o fatorial
show = opcional, caso queira ver a conta "True" caso queira apenas a resposta nao precisa ser digitado
return total do fatorial
"""
print('=' * 30)
print('Fatorial

[@Fernandomoraes13]

def fatorial(n=1, show=False):
"""
-> Calcula o fatorial de um número
:param n: O número do qual se quer o fatorial.
:param show: Mostrar ou não a conta feita.
:return: O valor do fatorial do número n.
"""
fac = 1
for i in range(n, 0, -1):
if show:
if i > 1:
print(f'{i}x', end='')
if i == 1:
print(f'{i}=', end='')
fac *= i
return fac
n = int(input('Digite um número interiro: '))
print(fatorial(n))

[@1977ecruz]

# Desafio 102
# Crie um algoritmo q tenha uma função fatorial() q receba dois parâmetros:
# O 1º indica o nº a calcular e o outro chamado show, q será um valor lógico(opcional) indicando se será mostrado ou não o processo de cálculo do fatorial
def fatorial(n, show=False):
"""
-> Calcula o fatorial de um número.
parâmetro n: O nº a ser calculado.
parâmetro show: (opcional) Mostrar ou não a conta.
return: O valor do fatorial de um nº n.
"""
f = 1
for c in range(n, 0, -1):
if show:
print(c, end='')
if c > 1:
print(' x ', end='')
else:
print(' = ', end='')
f *= c
return f
# Programa principal
print(fatorial(5, show=True))
help(fatorial)
# Valeu Guanabara!!!

[@vine460]

Eu fiz dessa forma:
(no lugar de ir printando os números, eu coloco todos eles numa string e retorno no final)
def fatorial(n, show=False):
"""
Função que calcula o fatorial de um número.
:param n: número que terá seu fatorial calculado.
:param show: bool opcional que definirá se o processo
de calculo será ou não mostrado.
:return: o resultado e o processo de calculo caso o valor
de :param show: seja True.
"""
calculo = f'{n} '
for ant in range(n - 1, 0, -1):
n = n * ant
calculo += f'x {ant} '
if show:
return calculo + f'= {n}'
else:
return n
print(f'{fatorial(5, True)}')

[@dualsgo]

# Estou compartilhando minhas anotações sobre os exercícios. Quem quiser, pode copiar e colar em um documento .py pois está tudo formatado e comentado.
# Nesse exercício, temos que criar uma função chamada fatorial() que vai receber dois parâmetros: o primeiro que indique o número a calcular e outro chamado show, que será um valor lógico (opcional) indicando se será mostrado ou não na tela o processo de cálculo do fatorial. Se show for True, o cálculo será exibido. Se show for False, apenas o resultado será exibido.
# Vamos alterar um pouco em relação ao exercício do vídeo do professor. Vamos criar uma função chamada mostrar() que vai perguntar ao usuário se ele quer exibir o cálculo ou não. Se ele digitar S, o cálculo será exibido. Se ele digitar N, apenas o resultado será exibido.
def valor_valido(mensagem):
while True:
# Ainda não vimos o uso de try e except, mas é uma forma de tratar exceções. Se o usuário digitar um valor que não seja numérico, o programa vai exibir uma mensagem de erro e pedir para digitar novamente. Se o bloco try for executado com sucesso, o programa vai retornar o valor digitado pelo usuário.
try:
return int(input(mensagem))
except ValueError:
print('Apenas valores numéricos.')
def mostrar():
while True:
print('Exibir o cálculo?')
continuar = input('[S] SIM [N] NÃO').strip().upper()
if continuar not in ['S', 'N']:
print('Digite S ou N')
else:
if continuar == 'S':
return True
else:
return False
# Já fizemos um exercício para mostrar o fatorial de um número. Aqui nós apenas criamos uma função para isso
def fatorial(valor, mostrar_calculo):
"""
Calcula o fatorial de um número
:param valor: número a ser calculado
:param mostrar_calculo: exibe ou não o cálculo
"""
resultado = 1
if mostrar_calculo:
print(f'{valor}! = ', end='')
for i in range(valor, 0, -1):
print(i, end=' x ' if i > 1 else f' = ')
resultado *= i
print(resultado)
else:
for i in range(valor, 0, -1):
resultado *= i
print(f'{valor}! = {resultado}')
# Por fim, vamos chamar a função fatorial() passando o número a ser calculado e o valor lógico que indica se o cálculo deve ser exibido ou não.
fatorial(valor_valido('Digite o número a calcular... '), mostrar())
# Entenda, usamos duas funções para definir os parâmetros de outra função. Isso é completamente comum

[@jonatascavalcante6404]

Minha resolução foi um pouco diferente mas tb funciona:
def fat(n, s=False):
"""
-> Calcula o fatorial de um númeri.
:param n: O número que será fatorado
:param s: Se deve ou não mostrar o cálculo
:return: O fatorial do número n
"""
f = 1
fc = ''
for i in range(n, 0, -1):
f *= i
fc = fc + str(i)
if i > 1:
fc = fc + ' x '
fc = fc + ' = ' + str(f)
if s:
return fc
else:
return f
help(fat)
print(fat(5))
print(fat(5, True))

[@David73_]

Dps de uma hora eu fiz , mas entendi muito bem dps
def fatorial(a,show=False):
"""show = True , mostra o fatorial do número com o calculo,show = False,mostra o fatorial com o calculo"""
fact = 1
for Cont in range(a,0,-1):
if show == True:
print(f"{Cont} ×",end= ' ')
fact *= Cont
return fact
print(fatorial(6,show = True))

[@hzn3474]

A minha solução ficou muito parecida olha:
def fatorial(número=1, show=False):
resultado = 1
for divisor in range(1, número+1):
if show == True:
if divisor < número:
print(f"{divisor} x ",end="")
else:
print(f"{divisor} = ",end="")
resultado *= divisor
return resultado
print(fatorial(show=True, número=6))

[@jpcardoso387]

def factorial(x, show=False):
"""
-> Calcula o fatorial de um número.
:param x: O número a ser calculado.
:param show: (opcional) Mostrar ou não a conta.
:return: O valor do fatorial do número x.
"""
f = 1
for n in range(x, 0, -1):
f *= n
if show:
if n == 1:
print('1 = ', end='')
else:
print(f'{n}', end=' x ')
return f

[@antoniosavio8338]

def fatorial(numero, show=False):
print(f'Calculando {numero}! = ', end='')
produtoFinal = 1
for c in range(numero, 0, -1):
if show:
print(c, end=' x ' if c > 1 else ' = ')
produtoFinal *= c
return produtoFinal
print(fatorial(4, show=True))
input()

[@fatosem60segundosofc]

eu aprimorei um pouquinho... talvez fique mais legal assim.
~~~~~~~~~~~~~~~~~~~~~~~~~_-_-_-_~~~~~~~~~~~~~~~~~~~~~~~~~
from time import sleep
def fatorial(n, show=False):
"""
-> Calcula o fatorial de um número
:param n: O número a ser calculado.
:param show: (opcional) Mostrar ou não a conta.
:return: O valor do fatorial de um número n.
"""
f = 1
for c in range(n, 0, -1):
if show:
print(c, end='')
if c > 1:
print(f' x ', end='')
else:
print(' = ', end='')
f *= c
return f
resp = str(input('Você quer que eu coloque a conta? [S/N]: ')).upper()[0]
if resp in 'S':
print(fatorial(5, show=True))
else:
print(fatorial(5))
print('Parametros...')
sleep(1)
help(fatorial)

[@hibari759]

def fatorial(n,show = False):
fatorial = 1
for v in range(n,0,-1):
fatorial *= v
if show == True and v != 1:
print(f'{v} x', end=' ')
else:
print(f'{v} = ',end='')
if n != 0:
return fatorial
if n == 0:
return 1

[@kailes8944]

aqui esta minha resolição para esse exercicio, demorei um pouquinho e precisei ver os comentarios, mas deu certo!
import time
def fatorial(num=1, show=False):
f = 1
if show == False:
for c in range(num, 0, -1):
f *= c
return f
if show == True:
for c in range(num, 0, -1):
f *= c
time.sleep(0.3)
print(c, end=' ')
if c > 1:
print('x', end=' ')
if c

[@arthurmaciel3494]

Fiz de uma forma mais interativa, podendo calcular quantas vezes o usuário quiser, segue o código:
from os import system
def fatorial(n, show=False):
"""
-> Calcula o fatorial de um número.
:param n: O número que será calculado o fatorial.
:param show: Mostra o processo do cálculo do fatorial. (Opcional)
:return: O valor do fatorial de n.
"""
fat = 1
for i in range(n, 0, -1):
fat *= i
if show:
print(i, end='')
if i != 1:
print(' x ', end='')
else:
print(' = ', end='')
return fat
# Programa principal:
while True:
num = int(input('Qual número você quer ver o fatorial? '))
mostrar = 'a'
if num > 1:
while mostrar not in 'SN':
mostrar = str(input('Você quer ver o processo do cálculo do fatorial? [S/N]: ')).upper().strip()
print(f'{num}! = ', end='')
if mostrar == 'S':
print(fatorial(num, True))
else:
print(fatorial(num))

continuar = 'a'
while continuar not in 'SN':
continuar = str(input('Quer continuar? [S/N]: ')).upper().strip()
system('cls')
if continuar == 'N':
break
print("\033[33mVOLTE SEMPRE!\033[0m")

[@rafaelduria9848]

fiz um assim
#desafio 102 autoria
def mult(n,show=False):
for c in range(1,10+1,1):
if show == True:
print(f'{n} x {c} = {n*c}')
else:
print(f'{n*c}')
oie = int(input('Digite um numero: '))
mult(oie,show=True)

[@maatheusdev]

O meu ficou um pouco diferente do professor, mas funcionou kk
meu codigo:
def fatorial(c, d=False):
"""
Funcao para calcular o fatorial do primeiro parametro passado.
:param c: Numero que sera fatorado;
:param d: Se True mostra os calculos, se False apenas os resultados
:return: Retorna o resultado e a equaçao
"""
fat = int(1)
tot = int(1)
for x in range(c, 0, -1):
fat = x
tot *= fat
if (d == True):
print(f'{x}', end='')
if (x > 1):
print(' x ', end='')
else:
print(' = ', end='')
return (f'{tot}')
print(fatorial(5, True))
help(fatorial)

[@LuanGermano]

essa fiz assim:
def fatorial(a, show=''):
"""
Programa que serve pra realizar uma contagem fatorial
:param a: o valor calculado
:param show: Se deseja ver os numeros que compoem o fatorial(opcional)
:return: retorno do valor de fatorial a.
"""
from time import sleep
f = 1
print(f'O fatorial de {a}! é: ', end='')
for c in range(a, 0, -1):
f *= c
if show:
print(f'{c}', end='')
if c > 1:
print(end=' x ')
sleep(0.24)
else:
print(end='= ')
sleep(0.24)
return print(f)
fatorial(int(input('Digite um valor que deseja para fatorial: ')),
str(input('Deseja ver a conta sendo realizada:[deixe vazio caso n queira] ')).strip().title())
help(fatorial)

[@alexalmeida6893]

def fatorial(n, show=False):
f = 1
for c in range(n, 0, -1):
if show:
print(f'{c}', end=' ')
print('x' if c > 1 else '=', end=' ')
f *= c
return f
print(fatorial(5, show=True))

[@Bganade]

# Crie um programa que tenha uma função fatorial() que receba dois parâmetros: o primeiro que indique o número a
# calcular e outro chamado show, que será um valor lógico (opcional) indicando se será mostrado ou não na tela o
# processo de cálculo do fatorial.
# @BGanade
def fatorial(num, show=False):
"""
:param num: Numero a ser fatorado
:param show: se True mostra a conta do fatorial, se false não mostra a conta do fatorial
:return: não retorna valor
"""
fat = num
print('#' * 30)
print(f'O fatorial de {num} é: ')
for n in range(num - 1, 1, -1):
fat *= n
if not show:
print(f'{fat}')
print('#' * 30)
if show:
for n in range(num, 0, -1):
if n == 1:
print(f'{n} = {fat}')
else:
print(f'{n} * ', end='')
print('#' * 30)
# Titulo
print(f'
{"-*" * 30}
{"Funções para votação":^60}
{"-*" * 30}
')
# Programa Principal
numero = int(input('Digite um numero para calcular o Fatorial: '))
esc = str(input('Gostaria de mostrar o calculo? [S/N]: ')).upper()[0]
while True:
if esc in 'SN':
break
else:
esc = str(input('Escolha inexistente, escolha S para sim ou N para não: '))[0]
if esc == 'N':
esc = False
else:
esc = True
fatorial(numero, esc)

def fatorial(n, show=False):
"""Faz o calculo do fator de um numero inteiro
Args:
n (int): numero para calcular o fator
show (bool, optional): Mostra detalhamento do calculo. Defaults to False.
"""
from time import sleep
f = 1
for i in range(n, 0, -1):
f *= i
if show == True:
if i == 1:
print(i, end= ' = ',flush=True)
else:
print(i, end=' x ', flush=True)
sleep(0.7)
print(f)
n = int(input('Digite um numero '))
shw = str(input('Mostrar? S/N ')).upper()[0]
if shw == 'S':
show = True
else:
show = False
fatorial(n, show)
github.com/josivantarcio/Desafios-em-Python/blob/main/Desafios/desafio102.py

[@pedrosojunior]

# Exercídio 102 do Curso em Vídeo - Referente a aula 21
# Crie um programa que tenha uma função fatorial() que receba dois parâmetros:
# o primeiro que indique o número a calcular e o outro chamado show, que será um valor lógico
# (opcional) indicando se será mostrado ou não na tela o processo de cálculo do fatorial.
def fatorial(n, show=False):
'''
-> Calcula o fatorial de um número.
:param: n: O número a ser calculado.
:param: show: (opcional) Mostrar ou não a conta.
:return: O valor do fatorial de um número n.
'''
cont = n
fat = 1
while cont > 0:
if show:
if cont == 1:
print(f'{cont} = ', end='')
else:
print(f'{cont} X ', end='')
fat *= cont
cont -= 1
return fat
# Programa principal
print('-' * 50)
print(fatorial(5))
print(fatorial(7, True))
print('-' * 50)
help(fatorial)

[@rafaelrodriguessilva9994]

Mto bom

[@jonathasrobison9167]

def fatorial(num, show=False):
if show:
m = num
while m > 0:
print(f'{m}', end='')
print(' x ' if m > 1 else ' = ', end='')
m -= 1
f = 1
for c in range(num, 0, -1):
f *= c
return f
print(fatorial(6, show=True))

[@joaomatheus7081]

Desafio 102
def fatorial(numero, show = False):
fat = 1
for cont in range(numero, 0, -1):
if show:
print(f'{cont}', end = ' ')
if cont > 1:
print('X', end = ' ')
else:
print('=', end = ' ')
fat *= cont
return fat
# Programa principal...
numero = int(input('Digite um número: '))
mostra = str(input('Digite S para mostrar o fatorial ou N para mostra apenas o resultado: ')).strip().upper()
if mostra == 'S':
show = True
else:
show = False
print(fatorial(numero, show = show))

[@feriamamoto]

def fator(num, show=False):
from math import factorial
for c in range(num, 0, -1):
if show:
print(c, end='')
if c > 1:
print(' x ', end='')
else:
print('--> total =', end='')
return factorial(num)
numero = int(input('Entre com um numero : '))
print(fator(numero, show=False))

[@EduardoRandall]

Na minha solução dei a opção ao usuário de escolher o número a ser fatorado e se quer mostrar ou não o cálculo, e coloquei um sleep pra mostrar a conta sendo feita.
def fatorial(num, show=False):
"""
-> Calcula o Fatorial de um número.
:param num: O número a ser fatorado.
:param show: (OPCIONAL) Mostrar ou não o cálculo.
:return: O valor do Fatorial de um número n.
"""
from time import sleep
f = 1
for c in range(num, 0, -1):
if show:
print(c, end='')
sleep(0.3)
if c > 1:
print(f' x ', end='')
sleep(0.3)
else:
print(f' = ', end='')
sleep(0.3)
f *= c
return f
n = int(input('Qual número você quer fatorar? '))
m = str(input('Quer mostrar o cálculo? [S/N] ')).upper()[0]
print('- ' * 15)
if m in 'S':
print(fatorial(n, True))
elif m in 'N':
print(fatorial(n))

[@LaudaturMonachus]

Dei uma refinada no meu pra ficar um pouco mais interativo.
def fatorial(n, show=False):
f = 1
for c in range(n, 0, -1):
if show:
print(c, end='')
if c > 1:
print(f' x ', end='')
else:
print(' = ', end='')
f *= c
return f
'''Calcula o fatorial de um número
:param n é o número a ser calculado
:param show se vc quiser que seja mostrado o calculo fatorial ou n
:param return mostra o valor do fatorial calculado'''
n = int(input('Informe um número para ver seu fatorial: '))
op = str(input('Quer verl o calculo fatorial? [S/N]: ')).strip().upper()[0]
while op not in 'SN':
print('Opção inválida tente novamente. ', end='')
op = str(input('Quer verl o calculo fatorial? [S/N]: ')).strip().upper()[0]
if op =='S':
print(f'{fatorial(n, show=True)}')
else:
print(f'O fatorial de {n} é {fatorial(n)}')
print('Programa Finalizado.')

[@gustavosantosdecarvalho159]

# Crie um programa que tenha uma função fatorial() que receba dois parâmetros: o primeiro que indique o número a
# calcular e outro chamado show, que será um valor lógico (opcional) indicando se será mostrado ou não na tela o
# processo de cálculo do fatorial.
def fatorial(n=1, show=True):
"""
-> Calcula a operação fatorial de um número.
:param n: para o número desejado
:param show: True para ver o processo. False para não ver o processo.
:return: O valor fatorial no número n.
"""
print('=' * 30)
f = 1
for c in range(n, 0, -1):
f *= c
if show in 'True':
print(f'{c}', end=' ')
if c == 1:
print('=', end=' ')
else:
print('x', end=' ')
return f
resp = input('Deseja aprender como usa a função "Fatorial" [S/N]: ').lower().strip()[0]
print('='*50)
while resp not in 'NnsS':
print('~'*30)
resp = input('Deseja aprender como usa a função "Fatorial" [S/N]: ').lower().strip()[0]
if resp in 'Ss':
help(fatorial)
print('='*50)
num = fatorial((int(input('Número: '))), str(input('Deseja mostrar a conta [True/False]: ').strip().title()))
print(num)

[@tiagosantana3632]

Os meus return não está voltando o valor , preciso fazer assim
Return print(variável)

[@tokageotaku6749]

def fatorial(n, show=False):
"""
-> calcula o fatorial de um número
:param n: número a ser calculado
:param show: se "show" == "True", o cálculo será mostrado, por padrão "show" == False
:return: o resultado do cálculo do fatorial de "n"
"""
from math import factorial
resultado = factorial(n)
if show is True:
for c in range(n, 0, -1):
print(f'\033[97m{c} ', 'x 'if c != 1 else '= \033[92m', end=' ')
return resultado
print(f'\033[35;1;4m{"FUNÇÕES PARA FATORIAL":|^30}\033[0;1m')
print(fatorial(8, True))
help(fatorial)

[@diegoferreira3444]

def fatorial(num, show=False):
"""
Fatorial(num, show=False):
=> Função irá calcular o fatorial de um numero passado e irá retornar um valor para show=False e uma string para show=True
=> num, numero ao qual o fatorial tem de ser calculado
=> show(opcional), caso queira a string mostrando o processo de fatorial mudar o valor para True
"""
tot = 1
revelador = ''
for i in range(1, num + 1):
tot *= i
if i < num:
revelador += str(i) + ' * '
elif i == num:
revelador += str(i) + ' = ' + str(tot)
if show is True:
return revelador
elif show is False:
return tot
print(fatorial(10, True))
help(fatorial)

[@carloshenriquesoares6958]

Fiz usando biblioteca:
def fatorial(n, show=False):
"""
-> Calcula o fatorial de um número
:param n: O número a ser calculado
:param show: (opcional) Mostrar ou não a conta
:return: O valor fatorial de um número n
"""
from math import factorial
if show==False:
return factorial(n)
else:
print(n, end=' ')
for c in range(n, 1, - 1):
print(f'x {c - 1}', end=' ')
return f'= {factorial(n)}'
print(fatorial(5, True))
help(fatorial)

[@rodrigo.telles]

Essa é a minha solução para o Desafio 102 de Python ;-)
from math import factorial
def fatorial(n, show = False):
"""
-->>Calculo do Fatorial de un número já pré-definido.
:param n:Número a ser calculado.
:param show:(Opicional) Mostra ou não o Calculo realizado.
:return:O valor do fatorial de um número
"""
c = 1
fat = factorial(n)
print(f'O Valor de FAT é: {fat}')
if show == True:
print(f'{n}', end='')
for c in range(n-1,0, -1):
print(f' x {c} ',end='')
c +=1
print(f'= {fat}')
print('=='*25)
fatorial(10, True)
print('=='*25)
help(fatorial)
print('=='*25)

[@DgMiguez]

Ficou diferente. Ficou maior, porém funcional.
def fatorial(n, show=False):
'''-> Calcula o Fatorial de um número.
:param n: O número a ser calculado.
:param show: (opcional) Mostrar ou não a conta.
:return: O valor do Farotial escolhido em n.'''
f = 1
c = n
if show == True:
while c > 0:
print(f'{c} ', end='')
print('x ' if c > 1 else '= ', end='')
f *= c
c -= 1
else:
for i in range(n, 0, -1):
f *= c
c -= 1
return f
print(fatorial(int(input('Digite um número para saber seu fatorial: ')), True))
help(fatorial)

[@welenalmeida5588]

fiz o show como uma string pra o usuário digitar:
def fator(num, show):
fatorial = 1
lista = []
for item in range(num, 0, -1):
fatorial *= item
lista.append(item)
if show == 'True':
for i, v in enumerate(lista):
print(f'{v}', end='')
if i < (len(lista) - 1):
print(' x ', end='')
else:
print(' = ', end='')
return f'{fatorial}'
algo = int(input('Digite um número e veja o seu fatorial: '))
bandeira = str(input('Digite True ou False: ')).capitalize().strip()
print(fator(algo, bandeira))

[@Esaito0200]

não consegui fazer sozinho, mas fiz a opção de escolher qual numero vc quer,se quer mostrar os numero fatoriais e se quer continuar:
def fatorial(n,show=False):
"""
a formula do fatorial e n!= n(n-1)
reinicie o programa
"""
re=1
for c in range(n,0,-1):
if show:
if c>1:
print('{} X'.format(c),end=' ')
else:
print('{}= '.format(c),end='')
re*=c
return re
h=str(input('deseja ajuda ?')).upper().strip()[0]
while h not in 'SsNn':
print('opção inválida')
h=str(input('deseja ajuda ?')).upper().strip()[0]
if h in 'Ss':
help(fatorial)
if h in 'Nn':
while True:
n=int(input('digite um numero: '))
t=str(input('quer ver os numeros da fatorial?')).upper().strip()[0]
while t not in 'SsNn':
print('opção inválida')
t=str(input('quer ver os numeros da fatorial?')).upper().strip()[0]
if t in 'sS':
print(fatorial(n,show=True))
if t in 'Nn':
print((fatorial(n,show=False)))
s=str(input('quer contiruar?')).upper().strip()[0]
while s not in 'SsNn':
print('opção inválida')
s=str(input('quer contiruar?')).upper().strip()[0]
if s in 'Nn':
print('finalizado')
break