def aniversarios():
"""Manipula um arquivo Json (escrita/leitura)
"""
# lê o arquivo Json e armazena em um dicionário
with open('json/cientistas.json', 'r') as f:
cientista = json.load(f)
cabecalho(
'Bem-vindo ao dicionário de aniversários. Nós sabemos a data de nascimento de:',
60, ' ')
lista_dados(cientista)
while True:
opcoes()
pergunta = str(input('\tQual é a sua opção? ')).lower().strip()[0]
if pergunta == 'l':
lista_dados(cientista)
elif pergunta == 'n':
print(aniversario(cientista))
elif pergunta == 'a':
print(adiciona(cientista))
lista_dados(cientista)
else:
cabecalho('Fim', 30, '-')
break
def campeoes():
"""Exibe o resultado final
"""
cabecalho('Resultado final', 30, '-')
for k, v in campeao.items():
print(f'{k} -> {v}.'.title())
def main():
cabecalho('Desenhar tabuleiro de jogo')
tabuleiro(int(input('Digite o tamanho do tabuleiro: ')))
tabuleiro()
# tabuleiro(1)
# tabuleiro(8)
# tabuleiro(19)
print(__doc__)
print(tabuleiro.__name__)
print(tabuleiro.__defaults__)
print(tabuleiro.__doc__)
def par_impar(numero: int, divisor: int) -> object:
"""Verifica se o número é par ou ímpar; se par verifica se é múltiplo de 4.
Verifica se o numero é divisível pelo divisor sem resto
:param numero: estrada do usuário
:type numero: int
:param divisor: entrada do usuário
:type divisor: int
:return: par ou impar; se é múltiplo de 4 e se o número é divisível pelo divisor sem resto
:rtype: object
"""
if numero % 2 == 0:
if numero % 4 == 0:
msg = f'O número {numero} é par e multiplo de 4.'
else:
msg = f'O número {numero} é par.'
else:
msg = f'O número {numero} é impar.'
if numero % divisor == 0:
return print(f'{msg}\nOs números {num} e {check} são múltiplos entre si.')
else:
return print(f'{msg}\nOs números {num} e {check} NÃO são múltiplos entre si.')
if __name__ == '__main__':
cabecalho('Par ou ímpar')
num = int(input('Digite um número: '))
check = int(input('Digite um número para ser divisor: '))
par_impar(num, check)
cont += 1
monta_hangman(boneco, letras, erros)
print(f'\t{cores("vermelho")}Incorreto!{cores("limpa")}')
if erros == 6:
print()
pergunta = str(
input('Quer jogar de novo? [S/ outra tecla para sair] ')
).strip().lower()[0]
if pergunta == 's':
# limpa dados para recomeçar
palavra = str(sorteio('txt/sowpods.txt'))
total_letras = len(palavra)
letras = ['_' for y in range(total_letras)]
boneco = [[' ', 'O', ' '], ['/', '|', '\\'],
['/', ' ', '\\']]
acertos = erros = 0
monta_hangman(boneco, letras, erros)
continue
else:
cabecalho('Fim', 30, '-')
break
if acertos == total_letras:
print(f'{cores("verde")}Parabéns!{cores("limpa")}')
cabecalho('Fim', 30, '-')
break
if __name__ == '__main__':
cabecalho('Hangman')
hangman()
:type lista2: list
:return: imprime lista com sobreposição
:rtype: object
"""
lista = []
for item in lista1: # carrega lista1 em item
if item in lista2: # compara item com lista2
if item not in lista: # verifica se o item não esta na lista para não repetir
lista.append(item)
return print(
f'Lista a = {lista1}\nLista b = {lista2}\nLista sobreposta = {lista}')
if __name__ == '__main__':
cabecalho('Solução para sobreposição de lista')
a = sample(range(30), 10)
b = sample(range(30), 12)
sobrepor(a, b)
#
#
cabecalho('Alternativa')
print(
f'>>> print(list(set(sample(range(30), 10)) & set(sample(range(30), 12))))'
)
#
# a1 = set(sample(range(30), 10))
# a2 = set(sample(range(30), 12))
# lista = list(a1 & a2)
# print(a1)
def intersecao(a: list, b: list) -> object:
"""Faz a interseção entre dois conjuntos
:param a: lista
:type a: list
:param b: lista
:type b: list
:return: lista com a interseção
:rtype: object
"""
return print(f'Conjunto a = {a}\nConjunto b = {b}\nInterseção = {list(set(a) & set(b))}')
if __name__ == '__main__':
cabecalho('List Overlap Comprehensions')
lista1 = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
lista2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
lista3 = sample(range(30), 10)
lista4 = sample(range(30), 12)
intersecao(lista1, lista2)
#
# https://docs.python.org/3/tutorial/datastructures.html#sets
#
# 5.4. Sets
#
# O Python também inclui um tipo de dados para conjuntos.
# Um conjunto é uma coleção não ordenada sem elementos duplicados.
# Usos básicos incluem testes de associação e eliminação de entradas duplicadas.
# Os objetos do conjunto também suportam operações matemáticas como:
Aniversário de quem você quer procurar?
Benjamin Franklin
O aniversário de Benjamin Franklin é 17/01/1706.
"""
from cicero import cabecalho
def aniversario():
"""Busca o aniversário em um dicionário
"""
aniversarios = {
'Albert Einstein': '14 de março de 1879',
'Benjamin Franklin': '17 de janeiro de 1706',
'Ada Lovelace': '10 de dezembro de 1815'
}
print(
'Bem-vindo ao dicionário de aniversários. Nós sabemos os aniversários de:'
)
for k, v in aniversarios.items():
print(f'\t\t\t{k}')
nome = str(input('Aniversário de quem você quer saber? ')).strip()
print()
print(f'{nome} nasceu em {aniversarios.get(nome, f"(sem informações)")}.')
if __name__ == '__main__':
cabecalho('Dicionários de aniversários')
aniversario()
def jogar():
"""Preenchimento do tabuleiro do jogo-da-velha e verificação do vencedor
"""
def vencedor(v: str) -> bool:
"""Verifica o ganhador do jogo-da-velha
:param v: string do vencedor
:type v: str
:return: booleano
:rtype: bool
"""
if jogo[0] == [v, v, v] or jogo[1] == [v, v, v] or jogo[2] == [
v, v, v
]: # linhas
return True
elif jogo[0][0] == v and jogo[1][0] == v and jogo[2][0] == v: # coluna
return True
elif jogo[0][1] == v and jogo[1][1] == v and jogo[2][1] == v: # coluna
return True
elif jogo[0][2] == v and jogo[1][2] == v and jogo[2][2] == v: # coluna
return True
elif jogo[0][0] == v and jogo[1][1] == v and jogo[2][
2] == v: # diagonal
return True
elif jogo[0][2] == v and jogo[1][1] == v and jogo[2][
0] == v: # diagonal
return True
else:
return False
def inverte(i: str) -> str:
"""Inverte o jogador
:param i: jogador atual
:type i: str
:return: jogador invertido
:rtype: str
"""
if i == "X":
n_jogador = 'O'
return n_jogador
else:
n_jogador = 'X'
return n_jogador
def tabuleiro():
"""Imprime o tabuleiro do jogo-da-velha
"""
for linhas in range(len(jogo)):
for colunas in range(len(jogo)):
print(jogo[linhas][colunas], end=' ')
print()
print()
def campeoes():
"""Exibe o resultado final
"""
cabecalho('Resultado final', 30, '-')
for k, v in campeao.items():
print(f'{k} -> {v}.'.title())
def limpa(j: list, c: int, jg: str) -> object:
"""Limpa as variáveis para um novo jogo
:param j: tabuleiro limpo
:type j: list
:param c: limpa contador
:type c: int
:param jg: jogador padrão para início de jogo
:type jg: str
:return: variáveis limpas
:rtype: object
"""
j = [['-' for x in range(3)] for y in range(3)] # monta a lista
c = 0
jg = 'X'
return j, c, jg
jogo = [['-' for x in range(3)] for y in range(3)] # monta a lista
conta = 0
jogador = 'X'
campeao = {'X': 0, 'O': 0, 'empate': 0}
while True:
try:
coordenadas = str(
input(f'"{jogador}" joga (linha, coluna): ')).strip()
linha = int(coordenadas.split(',')[0]) - 1
coluna = int(coordenadas.split(',')[1]) - 1
if jogo[linha][coluna] not in 'XO':
if conta % 2 == 0:
jogo[linha][coluna] = 'X'
else:
jogo[linha][coluna] = 'O'
tabuleiro()
if vencedor(jogador):
cabecalho(f'O vencedor foi "{jogador}"', 30, '-')
campeao[jogador] += 1
pergunta = str(
input('Continuar? [Sim / qualquer tecla sair] ')
).strip().lower()[0]
if pergunta == 's':
jogo, conta, jogador = limpa(jogo, conta, jogador)
continue
else:
campeoes()
break
jogador = inverte(jogador)
conta += 1
if conta == 9:
cabecalho('Ocorreu um empate', 30, '-')
campeao['empate'] += 1
pergunta = str(
input('Continuar? [Sim / qualquer tecla sair] ')
).strip().lower()[0]
if pergunta == 's':
jogo, conta, jogador = limpa(jogo, conta, jogador)
continue
else:
campeoes()
break
else:
print(
f'\n{cores("vermelho")}Esta coordenada já foi preenchida.{cores("limpa")} tente novamente!\n'
)
except (ValueError, IndexError):
print(f'{cores("vermelho")}')
print('Erro! Digite uma coordenada válida como "3,1".')
print(f'{cores("limpa")}')
1. Em vez de imprimir os elementos um por um, crie uma nova lista que tenha todos os elementos menores que 5
dessa lista e imprima essa nova lista.
2. Escreva isso em uma linha do Python.
3. Peça ao usuário um número e retorne uma lista que contenha apenas elementos da lista original que sejam menores que
aquele dado pelo usuário.
"""
from cicero import cabecalho
def menor_que(numero: int) -> object:
"""Verifica se o número é maior que o conteúdo da lista
:param numero: entrada do usuário
:type numero: int
:return: imprime uma lista com os números menores que o número
:rtype: object
"""
lista = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
n_lista = []
for i in lista:
if numero > i:
n_lista.append(i)
return print(n_lista)
if __name__ == '__main__':
cabecalho('Listar menor que')
menor_que(int(input('Digite um número inteiro: ')))
"""exercicio011.py em 2018-09-30. Projeto Practice Python.
Peça ao usuário um número e determine se o número é primo ou não.
"""
from cicero import cabecalho
def eh_primo(numero: int) -> object:
"""Verifica se um número é primo
:param numero: entrada usuário
:type numero: int
:return: imprime mensagem para o usuário
:rtype: object
"""
conta = 0
for x in range(1, numero + 1):
if numero % x == 0:
conta += 1
if conta == 2:
return print(f'O número {numero} é primo.')
else:
return print(f'O número {numero} NÃO é primo.')
if __name__ == '__main__':
cabecalho('Números Primos')
eh_primo(int(input('Digite um número: ')))
:type resposta: str
:rtype: object
"""
while True:
if resposta in 'n':
return print('\nFoi bom jogar com você!')
elif resposta in 's':
# mostra as opções para o usuário
for k, v in dicionario.items():
print(f'{k}. {v}')
computador = randint(1, 3)
usuario = int(input('Escolha um número: '))
if (dicionario[usuario] == 'Pedra' and dicionario[computador] == 'Tesoura') \
or (dicionario[usuario] == 'Tesoura' and dicionario[computador] == 'Papel') \
or (dicionario[usuario] == 'Papel' and dicionario[computador] == 'Pedra'):
print('Parabéns! Você venceu.')
elif dicionario[usuario] == dicionario[computador]:
print('Houve um empate.')
else:
print('Você perdeu!')
print(f'Você = {dicionario[usuario]}\nComputador = {dicionario[computador]}\n')
else:
print('Digite S ou N. Tente novamente!')
resposta = str(input('Quer jogar novamente? [S/N] ')).strip().lower()[0]
if __name__ == '__main__':
cabecalho('Pedra-Papel-Tesoura')
opcoes = {1: 'Pedra', 2: 'Papel', 3: 'Tesoura'}
jogar(opcoes)
"""
from cicero import cabecalho
def maior(a: int, b: int, c: int) -> str:
"""Verifica o maior de três termos
:param a: entrada usuário
:type a: int
:param b: entrada usuário
:type b: int
:param c: entrada usuário
:type c: int
:return: resultado da verificação
:rtype: str
"""
if b <= a >= c:
return f'Entre {a},{b} e {c}; {a} é o maior.'
elif a <= b >= c:
return f'Entre {a},{b} e {c}; {b} é o maior.'
else:
return f'Entre {a},{b} e {c}; {c} é o maior.'
if __name__ == '__main__':
cabecalho('Maior de três')
print(maior(3, 2, 4))
print(maior(3, 2, 3))
print(maior(3, 3, 2))
print(maior(3, 3, 3))
representa a categoria da cena. Para fazer isso, você precisará lembrar um pouco sobre a análise
de strings no Python 3.
"""
from cicero import cabecalho
def ler_arquivo():
counter_dict = {}
with open('txt/Training_01.txt') as f:
line = f.readline()
while line:
line = line[3:-26]
if line in counter_dict:
counter_dict[line] += 1
else:
counter_dict[line] = 1
line = f.readline()
print(counter_dict)
# with open('txt/nomes.txt', 'r', encoding="utf8") as f:
# contador = 0
# for linha in f:
# contador += 1
# return print(contador)
if __name__ == '__main__':
cabecalho('Ler do arquivo')
ler_arquivo()
simbolos = '!"#$%&()*+,-./:;<=>?@[\]^_`{|}~'
letras = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
digitos = '0123456789'
return ''.join(sample(simbolos + letras + digitos, tamanho))
def senha2(tamanho: int = 8,
caracteres: str = ascii_letters + digits + punctuation) -> str:
"""Gera senhas aleatórias
:param tamanho: quantidades de caracteres para a senha
:type tamanho: int
:param caracteres: caracteres para gerar a senha
:type caracteres: str
:return: senha
:rtype: str
"""
return ''.join(sample(caracteres, tamanho))
if __name__ == '__main__':
cabecalho('Gerador de senhas')
print(senha1())
print(senha1(14))
print(senha1(int(input('Quantos caracteres terá a sua senha? '))))
print('-' * 40)
print(senha2())
print(senha2(14, '<- Cícero_Henrique_Rodrigues 1234567890 ->'))
print(senha2(int(input('Quantos caracteres terá a sua senha? '))))
cabecalho('Teste')
"""exercicio019.py em 2018-10-02. Projeto Practice Python.
Usando as solicitações e as bibliotecas do BeautifulSoup Python, imprima na tela o texto completo do artigo
neste site: http://www.vanityfair.com/society/2014/06/monica-lewinsky-humiliation-culture.
O artigo é longo, então é dividido entre 4 páginas.
Sua tarefa é imprimir o texto na tela para que você possa ler o artigo completo sem ter que clicar em nenhum botão.
Isso apenas imprimirá o texto completo do artigo na tela.
Não facilitará a leitura, portanto, no próximo exercício, aprenderemos a escrever esse texto em um arquivo .txt.
url = 'https://www.vanityfair.com/style/society/2014/06/monica-lewinsky-humiliation-culture'
titulos = []
soup = BeautifulSoup(requests.get(url).text, features='html.parser')
titulo = soup.findAll('section', {'class': 'content-section'})
for linha in titulo:
titulos.append(linha.text)
"""
#
#
import requests
from bs4 import BeautifulSoup
from cicero import cabecalho
if __name__ == '__main__':
cabecalho('Decodificar uma página da Web 2')
def hangman():
cabecalho('Bem-vindo ao Hangman!', 30, '-')
palavra = str(sorteio('txt/sowpods.txt'))
total_letras = len(palavra)
letras = ['_' for y in range(total_letras)]
boneco = [[' ', 'O', ' '], ['/', '|', '\\'], ['/', ' ', '\\']]
acertos = erros = 0
monta_hangman(boneco, letras, erros)
while True:
print()
print(palavra)
letra = str(input('\nAdivinhe uma letra: ')).strip().upper()
if letra in palavra:
if letra not in letras:
# coloca as letras corretas na lista letras
for k, v in enumerate(palavra):
if v == letra:
letras[k] = v
acertos += 1
monta_hangman(boneco, letras, erros)
else:
monta_hangman(boneco, letras, erros)
print(
f'{cores("azul")}Você já usou esta letra. Tente outra!{cores("limpa")}'
)
else:
erros += 1
# indice da lista dentro da lista
cont = 0
# retira partes do boneco
while True:
if boneco[0][cont] != ' ':
# apaga parte do boneco
boneco[0][cont] = ' '
if len(set(boneco[0])) == 1:
# apaga a lista de índice '0' dentro da lista
del boneco[0]
break
cont += 1
monta_hangman(boneco, letras, erros)
print(f'\t{cores("vermelho")}Incorreto!{cores("limpa")}')
if erros == 6:
print()
pergunta = str(
input('Quer jogar de novo? [S/ outra tecla para sair] ')
).strip().lower()[0]
if pergunta == 's':
# limpa dados para recomeçar
palavra = str(sorteio('txt/sowpods.txt'))
total_letras = len(palavra)
letras = ['_' for y in range(total_letras)]
boneco = [[' ', 'O', ' '], ['/', '|', '\\'],
['/', ' ', '\\']]
acertos = erros = 0
monta_hangman(boneco, letras, erros)
continue
else:
cabecalho('Fim', 30, '-')
break
if acertos == total_letras:
print(f'{cores("verde")}Parabéns!{cores("limpa")}')
cabecalho('Fim', 30, '-')
break
:param lista: entrada
:type lista: list
:return: lista sem duplicatas
:rtype: list
"""
return list(set(lista))
def sem_duplicatas2(lista: list) -> list:
"""Executa um loop para retirar as duplicatas
:param lista: entrada
:type lista: list
:return: lista sem duplicatas
:rtype: list
"""
lista_sem_duplicatas = []
for x in lista:
if x not in lista_sem_duplicatas:
lista_sem_duplicatas.append(x)
return lista_sem_duplicatas
if __name__ == '__main__':
cabecalho('Remover Duplicados da Lista')
a = [1, 1, 2, 2, 3, 3]
b = [1, 2, 3, 4, 3, 2, 1]
print(sem_duplicatas(a))
print(sem_duplicatas2(b))
"""exercicio012.py em 2018-09-30. Projeto Practice Python.
Escreva um programa que tenha uma lista de números (por exemplo, a = [5, 10, 15, 20, 25]) e
faça uma nova lista apenas com o primeiro e o último elemento da lista dada.
Para praticar, escreva este código dentro de uma função.
"""
from cicero import cabecalho
def extremos_lista(lista: list) -> list:
"""retorna uma lista com o primeiro e o último elemento
:param lista: uma lista
:type lista: list
:return: lista com com os dois itens
:rtype: list
"""
return [lista[0], lista[-1]]
if __name__ == '__main__':
cabecalho('Fim da lista')
a = [5, 10, 15, 20, 25]
print(extremos_lista(a))
Use o BeautifulSoup e solicite pacotes Python para imprimir uma lista de todos os títulos de artigos na
página inicial do New York Times.
"""
import requests
from bs4 import BeautifulSoup
from cicero import cabecalho
def decodificador(url: str):
"""Imprime os títulos do NY Times
:param url: endereço de pesquisa no NY Times
:type url: str
"""
titulos = []
soup = BeautifulSoup(requests.get(url).text, features='html.parser')
titulo = soup.findAll('h2', {'class': 'css-78b01r esl82me2'})
for linha in titulo:
titulos.append(linha.text)
for i in range(len(titulos)):
print(titulos[i])
if __name__ == '__main__':
cabecalho('Decodificar uma página da web')
decodificador('http://www.nytimes.com/')
with open(arquivo, 'r', encoding="utf8") as f:
line = f.readline()
z = True
while line:
# obs.: os arquivos foram gravados em encoding utf-8; se for gravado em ansi não é necessário a linha abaixo
# retira caracteres de encoding no início da primeira linha
if z:
line = line[1:]
z = False
# converte string para inteiro e adiciona na lista
lista.append(int(line))
line = f.readline()
print(lista)
return lista
def overlap(a: str, b: str) -> list:
"""Faz a verificação da intersecção entre dois conjuntos
:return: lista ordenada
:rtype: list
"""
return sorted(list(set(cria_lista(a)) & set(cria_lista(b))))
if __name__ == '__main__':
cabecalho('Sobreposição em arquivos')
primos = 'txt/numerosPrimos.txt'
felizes = 'txt/numerosFelizes.txt'
print(overlap(primos, felizes))
tipos de strings de entrada int
Crie um programa que peça ao usuário para inserir seu nome e sua idade. Imprima uma mensagem endereçada a eles,
informando o ano em que completará 100 anos.
"""
from datetime import datetime
from cicero import cabecalho
def idade_100(nome: str, idade: int) -> object:
"""Obtem nome e idade e retorna o ano em que fará 100 anos
:param nome: nome do usuário
:type nome: str
:param idade: idade do usuário
:type idade: int
:return: ano em que completará 100 anos
:rtype: object
"""
return print(
f'Olá {nome}! Você completará 100 anos em {(datetime.now().year - idade) + 100}.'
)
if __name__ == '__main__':
cabecalho('Entrada de dados')
n = str(input('Digite seu nome: '))
i = int(input('Digite sua idade: '))
idade_100(n, i)
break
jogador = inverte(jogador)
conta += 1
if conta == 9:
cabecalho('Ocorreu um empate', 30, '-')
campeao['empate'] += 1
pergunta = str(
input('Continuar? [Sim / qualquer tecla sair] ')
).strip().lower()[0]
if pergunta == 's':
jogo, conta, jogador = limpa(jogo, conta, jogador)
continue
else:
campeoes()
break
else:
print(
f'\n{cores("vermelho")}Esta coordenada já foi preenchida.{cores("limpa")} tente novamente!\n'
)
except (ValueError, IndexError):
print(f'{cores("vermelho")}')
print('Erro! Digite uma coordenada válida como "3,1".')
print(f'{cores("limpa")}')
if __name__ == '__main__':
cabecalho('Jogo-da-Velha')
jogar()
if conta % 2 == 0:
jogo[linha][coluna] = 'X'
else:
jogo[linha][coluna] = 'O'
tabuleiro()
if vencedor(jogador):
cabecalho(f'O vencedor foi "{jogador}"', 30, '-')
break
jogador = inverte(jogador)
conta += 1
if conta == 9:
cabecalho('Ocorreu um empate', 30, '-')
break
else:
print(f'\n{cores("vermelho")}Esta coordenada já foi preenchida.{cores("limpa")} tente novamente!\n')
except ValueError:
print(f'{cores("vermelho")}')
print('Erro! Digite uma coordenada válida como "3,1".')
print(f'{cores("limpa")}')
if __name__ == '__main__':
cabecalho('jogo-da-velha')
jogar()
"""
from cicero import cabecalho
def buscador(numero: int, lista: list) -> object:
"""Verificador se um número existe em uma lista
:param numero: número a ser verificado
:type numero: int
:param lista: lista com os números
:type lista: list
:return: objeto com a verificação booleana
:rtype: object
"""
lista_bin = []
# converte a lista para binario
for y in range(len(lista)):
lista_bin.append(bin(y))
return f'O número {numero} esta na lista? {True if bin(numero) in lista_bin else False}'
if __name__ == '__main__':
cabecalho('Pesquisa de elemento')
numeros = list(range(10))
print(numeros)
print(buscador(0, numeros))
print(buscador(1, numeros))
print(buscador(9, numeros))
print(buscador(10, numeros))
"""exercicio006.py em 2018-09-29. Projeto Practice Python.
Peça ao usuário uma string e imprima se essa string é um palíndromo ou não.
(Um palíndromo é uma string que se lê de trás para frente e de frente para trás.)
"""
from cicero import cabecalho
def palindromo() -> object:
"""Verifica se o inverso da palavra/frase é igual
:return: impressão do resultado
:rtype: object
"""
palavra = str(input('Digite uma palavras: ')).strip().lower().replace(
' ', '')
if palavra == palavra[::-1]:
return print(f'A palavra {palavra} é um palíndromo.')
else:
return print(f'A palavra {palavra} NÃO é um palíndromo.')
if __name__ == '__main__':
cabecalho('Palíndromo')
palindromo()
def plot():
"""Faz plotagem dos dados do arquivo Json
"""
# lê o arquivo Json e armazena em um dicionário
with open('json/cientistas.json', 'r') as f:
cientistas = json.load(f)
lista = []
x = []
y = []
# carrega somente os meses para uma lista
for v in cientistas.values():
lista.append(str(v).split(' ')[2])
# cria listas para plotagem dos meses e ocorrências
for k, v in Counter(lista).items():
x.append(k)
y.append(v)
y = sorted(y, reverse=True)
# cria a plotagem
output_file('html/aniversarios.html')
x_categories = list(Counter(lista))
p = figure(x_range=x_categories)
p.vbar(x=x, top=y, width=0.5)
show(p)
if __name__ == '__main__':
cabecalho('Aniversários')
plot()
:type lista1: list
:param lista2: numeros gerados
:type lista2: list
:return: quantos números encontrados
:rtype: str
"""
vaca = touro = 0
for x in range(len(gerador)):
if lista1[x] == lista2[x]:
vaca += 1
elif lista1[x] in lista2[:]:
touro += 1
return f'{vaca} vaca(s); {touro} touro(s)'
if __name__ == '__main__':
cabecalho('Bem-vindo ao jogo das vacas e dos touros!')
gerador = list(str(randint(1000, 9999)))
conta = 0
print(gerador)
while True:
numero = list(str((input('Digite um número de 4 digitos: '))))
conta += 1
if numero == gerador:
print(
f'Parabéns! Você acertou o número {gerador} em {conta} tentativa(s).'
)
break
else:
print(comparador(numero, gerador))
def jogar():
"""Preenchimento do tabuleiro do jogo-da-velha e verificação do vencedor
"""
def vencedor(v: str) -> bool:
"""Verifica o ganhador do jogo-da-velha
:param v: string do vencedor
:type v: str
:return: booleano
:rtype: bool
"""
if jogo[0] == [v, v, v] or jogo[1] == [v, v, v] or jogo[2] == [v, v, v]: # linhas
return True
elif jogo[0][0] == v and jogo[1][0] == v and jogo[2][0] == v: # coluna
return True
elif jogo[0][1] == v and jogo[1][1] == v and jogo[2][1] == v: # coluna
return True
elif jogo[0][2] == v and jogo[1][2] == v and jogo[2][2] == v: # coluna
return True
elif jogo[0][0] == v and jogo[1][1] == v and jogo[2][2] == v: # diagonal
return True
elif jogo[0][2] == v and jogo[1][1] == v and jogo[2][0] == v: # diagonal
return True
else:
return False
def inverte(i: str) -> str:
"""Inverte o jogador
:param i: jogador atual
:type i: str
:return: jogador invertido
:rtype: str
"""
if i == "X":
n_jogador = 'O'
return n_jogador
else:
n_jogador = 'X'
return n_jogador
def tabuleiro():
"""Imprime o tabuleiro do jogo-da-velha
"""
for linhas in range(len(jogo)):
for colunas in range(len(jogo)):
print(jogo[linhas][colunas], end=' ')
print()
print()
jogo = [['-' for x in range(3)] for y in range(3)] # monta a lista
conta = 0
jogador = 'X'
while True:
try:
coordenadas = str(input(f'"{jogador}" joga (linha, coluna): ')).strip()
linha = int(coordenadas.split(',')[0]) - 1
coluna = int(coordenadas.split(',')[1]) - 1
if jogo[linha][coluna] not in 'XO':
if conta % 2 == 0:
jogo[linha][coluna] = 'X'
else:
jogo[linha][coluna] = 'O'
tabuleiro()
if vencedor(jogador):
cabecalho(f'O vencedor foi "{jogador}"', 30, '-')
break
jogador = inverte(jogador)
conta += 1
if conta == 9:
cabecalho('Ocorreu um empate', 30, '-')
break
else:
print(f'\n{cores("vermelho")}Esta coordenada já foi preenchida.{cores("limpa")} tente novamente!\n')
except ValueError:
print(f'{cores("vermelho")}')
print('Erro! Digite uma coordenada válida como "3,1".')
print(f'{cores("limpa")}')
"""
import json
from collections import Counter
from cicero import cabecalho
def meses():
"""Conta a ocorrência de meses dentro do arquivo Json
"""
# lê o arquivo Json e armazena em um dicionário
with open('json/cientistas.json', 'r') as f:
cientistas = json.load(f)
lista = []
# carrega somente os meses para uma lista
for v in cientistas.values():
lista.append(str(v).split(' ')[2])
# faz a contagem de ocorrência dos meses
print(Counter(lista))
# faz a contagem de ocorrência dos meses (mais elegante)
for x, y in Counter(lista).items():
print(f'{x.rjust(9)}: {y}')
if __name__ == '__main__':
cabecalho('Meses de aniversário')
meses()
