Develop Reference

why does my BIP39 seed generation doesnt work?

i'm trying to code a BIP39 wallet, i've generated my entropy and followed the steps to generate the seed...
Here's my code:
import os
import string
import binascii
from binascii import hexlify
import hashlib
import unicodedata
import secrets
import random
bits = 128
print("Bytes = " + str(bits//8))
N = 64
def main():
nb_mots = ask_nb_mot()
nb_total_bit = nb_mots * 11
nb_bits_generes = nb_total_bit - checksum
entropie = ask_entropie(nb_bits_generes)
checksum = nb_mots // 3
def ask_nb_mot():
default_nb_mot = 12
input_string = 'Entrer le nb de mots que vous souhaitez générer: (12 ou 24, default: {0}): '.format(default_nb_mot)
while True:
nb_mot_string = input(input_string)
if len(nb_mot_string) == 0:
return default_nb_mot
word_count = int(nb_mot_string)
if word_count == 12 or word_count == 24:
return word_count
r = os.urandom(bits//8)
def ask_entropie(nb_bits_generes):
entropie = secrets.randbits(nb_bits_generes) # generer les bits
entropie_bin = int_to_bin(entropie, nb_bits_generes) # conversion en binaire
nb_char_genere = nb_bits_generes // 4
input_string = 'Entrez une entropie ou taper sur entrer pour générer automatiquement: '.format(nb_char_genere)
while True:
entropie_string = input(input_string)
entropie_len = len(entropie_string)
if entropie_len == 0:
return generate_entropie(nb_bits_generes)
if entropie_len == nb_char_genere + 2:
entropie_bin = int_to_bin(int(entropie_string, 16), nb_bits_generes)
return entropie_bin
print(entropie_bin)
def generate_entropie(nb_bits_generes):
nb_char_generes = nb_bits_generes // 4
entropie = secrets.randbits(nb_bits_generes) # generer les bits
entropie_bin = int_to_bin(entropie, nb_bits_generes) # conversion en binaire
print('Initial entropy:', entropie_bin) # print string de bits
print('Length of initial entropy:', len(entropie_bin)) # print longueur de ce string
entropie_hex = bin_to_hex(entropie_bin, nb_char_generes) #Hexa conversion
print('Initial entropy as hex:', entropie_hex) # print string en heva base 16
print('Length of entropy as hex:', len(entropie_hex)) # print longueur de cette var
return entropie_bin
# secrets.choice() pour generation du string random + entropie + conversion
def hashage(entropie): #SHA 256
nb_bits_generes = len(entropie)
nb_char_genere = nb_bits_generes // 4
print('char:', nb_char_genere)
entropie_hex = bin_to_hex(entropie, nb_char_genere) # string hexa -> entropie_hex var
entropie_hex_no_padd = entropie_hex[2:]
print('Longueur de lentropie sans le 0x pad:', len(entropie_hex)) # printlongueur sans 0x pad
print('Entropie hexa initiale sans pad', entropie_hex_no_padd)
entropie_bytearray = bytearray.fromhex(entropie_hex_no_padd) # hexa string à bytearray conversion
print(entropie_bytearray, '<--- Entropy as bytes') # print cette var
print('Sa longueur est de :', len(entropie_bytearray)) # print length of bytearray
bits = hashlib.sha256(entropie_bytearray).hexdigest()
print(bits, '<--- SHA-256 hash digest of entropy bytes') # print le hash du bytearray
return bits
def slicing(entropie, entropie_hash, checksum_bit_count):
nb_bits_generes = len(entropie)
nb_char_genere = nb_bits_generes // 4
entropie_hex = bin_to_hex(entropie, nb_char_genere) # hexa string -> entropie_hex var
checksum_char = checksum_bit_count // 4
bit = entropie_hash[0:checksum_char] # prend les x premiers bits
print(bit, '<--- Premiers bits utilisés pour le hash') # print première partie du hash
print((bit[0:checksum_char]), '<--- 1ers n bits à convertir en heva')
check_bit = int(bit, 16) # conversion heva binaire
checksum = int_to_bin(check_bit, checksum_bit_count)
print(checksum, '<--- Checksum (hex to bits)')
print('Entropie + checksum = total bits:', str(entropie) + str(checksum)) # to bin string
print('Longueur totale des bits:', len(str(entropie) + str(checksum))) # print longueur des bits
source = str(entropie) + str(checksum) #+ checksum
groups = [source[i:i + 11] for i in range(0, len(source), 11)] # division en lot de 11 bits
print(groups) # group -> index val -> word in list
totalbits = hex(int(str('0b') + entropie + str(checksum), 2))
print('Le hash de lentropie initiale des bytes:', entropie_hash)
# pour indexer
indice = [int(str('0b') + source[i:i + 11], 2) for i in range(0, len(source), 11)] # (str('0b') for i in range(0,len(source),11)))
print(indice)
print(bip39wordlist([indice]))
return indice
bip39wordlist = []
with open("english.txt", "r", encoding="utf-8") as f:
for w in f.readlines():
bip39wordlist.append(w.strip())
def print_mots(indices):
# print(bip39wordlist)
# print(len(bip39wordlist))
# wordindexes=for i in indices
mots = [bip39wordlist[indices[i]] for i in range(0, len(indices))]
mots_string = ' '.join(mots)
print(mots_string)
wordlist = []
num = int(bin, 2)
bin_num = format(num, "b")
print(bin_num)
for i in range(str(bin_num) // 11):
nb_mots = ask_nb_mot()
nb_total_bit = nb_mots * 11
nb_bits_generes = nb_total_bit - checksum
entropie = ask_entropie(nb_bits_generes)
checksum = nb_mots // 3
nb_char_genere = nb_bits_generes // 4
#print(bin_result[i*11 : (i+1)*11])
index = int(bin_num[i*11 : (i+1)*11], 2)
#print(str(index))
wordlist.append(bip39wordlist[index])
def bin_to_hex(bin, padding): #Fonction de conversion de binaire à heva
num = int(bin, 2)
num = str(num)
return '0x{0:0{1}x}'.format(num, padding)
def int_to_bin(num, padding): #Fonction de conversion de int à binaire
bin_num = format(num, "b")
print(bin_num)
return f'{0:08b}'.format(num, padding)
and i've got this error:
Une exception s'est produite : TypeError
'str' object cannot be interpreted as an integer
Nothing happens when i run my script, it used to generate the seed and convert it to binary, but nothing happens after generate entropy function, i think i missed something, thanks in advance for your time.

How to make a score system in python in a multiplication challenge

I am doing a multiplication challenge and I don't have any idea of how making a score system + a percentage of success, here is my code :
from random import *
tableRevision1 = int(input("Quelle première table de multiplication réviser ? :"))
tableRevision2 = int(input("Quelle deuxième table de multiplication réviser ? :"))
nombreQuestions = int(input("Combien de questions ? : "))
print("Révision des tables de", tableRevision1, "à", tableRevision2, "-", "Nombre de questions :", nombreQuestions)
for nombreQuestions in range(nombreQuestions):
multi=randint(tableRevision1,tableRevision2)
multi2=randint(1, 10)
question=str(multi)+" x "+str(multi2)+" = "
reponse = int(input(question))
score = 0
if reponse == multi*multi2:
print("Bien joué !")
score = score + 1
else:
print("Loupé ! La bonne réponse est :", multi*multi2)
score = score + 0
print("Votre score est : ", score)
Thank you very much

Some refactoring and editing, if you need advice on your code then write to me on discord! RobertK#6151
from random import *
tableRevision1 = int(input('Quelle première table de multiplication réviser ? :'))
tableRevision2 = int(input('Quelle deuxième table de multiplication réviser ? :'))
nombreQuestions = int(input('Combien de questions ? : '))
print('Révision des tables de', tableRevision1, 'à', tableRevision2, '-', 'Nombre de questions :', nombreQuestions)
score = 0
for nombreQuestions in range(nombreQuestions):
multi = randint(tableRevision1, tableRevision2)
multi2 = randint(1, 10)
question = str(multi) + ' x ' + str(multi2) + ' = '
reponse = int(input(question))
if reponse == multi * multi2:
print('Bien joué !')
score += 1
else:
print('Loupé ! La bonne réponse est :', multi * multi2)
print(f'Votre score est : {score}, {round((score/(nombreQuestions+1))*100, 1)}%')

TypeError: expected str, bytes or os.PathLike object, not int. In python, when I add some inputs and some function have to use it

Im new at coding and I'm doing a code for algorithms with a request matrix. I'm seeing this error when I add the code with the ***.
Context: I'm doing an input menu with options so the user can with number 1 create a matrix in excel and so python read it. With number 2 now I want to implement Dijkstra Algorithm.
I had search about this type of error and I know that happen because I'm putting a int and not a str, but I can't find the way to change it and so can read my dijkstra algorithm function requesting the initial node and the goal node.
Maybe I have some error in the parameters or variables. I'm not too good with functions calling. (Just starting to code)
import openpyxl as opxl
import sys
cant_nodos = 3
# FUNCIONES
## Crea la cantidad de nodos a utilizar y la restricción de un mínimo de nodos.
def min_nodos():
cant_nodos = int(input("Ingresar cantidad de nodos a utilizar (mínimo 6)"))
while(cant_nodos < 6):
print("ERROR: Elija mínimo 6 nodos y que sea entero positivo. ")
cant_nodos = int(input("Ingresar cantidad de nodos a utilizar (mínimo 6)"))
return cant_nodos
## Crea un menu
def crear_menu():
menu=int(input("Elija una opción \n 1.Crear parámetros \n 2.Aplicar Dijkstra \n 3.Aplicar Kruskal \n 4.Salir"))
if menu == 1:
min_nodos()
elif menu == 2:
*** empezar = str(input("Elija un nodo de inicio: "))
terminar = str(input("Elija un nodo de termino: ")) ***
dijkstra(cant_nodos, empezar, terminar)
elif menu == 3:
kruskal()
elif menu == 4:
sys.exit()
else:
print("\n ERROR: Elija una opción válida.")
crear_menu()
## Crea la matriz en excel
def crear_matriz_adyacente(cant_nodos):
libro = opxl.Workbook()
pagina = libro.active
pagina.title = "matriz_de_adyacencia"
lista_nodos = []
cont = 0
while(cont < cant_nodos):
contador = str(cont+1)
nodo = str(input("Ingrese nodo " +contador+ ":"))
if nodo not in lista_nodos:
lista_nodos.append(nodo)
pagina.cell(row = 1, column = cont+2, value = nodo)
pagina.cell(row = cont+2, column = 1, value = nodo)
cont = cont+1
else:
print("ERROR: Nodo existente, escoja otro: ")
for fila in range(len(lista_nodos)):
for columna in range(len(lista_nodos)):
if fila == columna:
valor = 0
elif columna > fila:
valor = int(input("Ingrese valor de nodo " +lista_nodos[fila]+" con el nodo " +lista_nodos[columna]+ ":"))
while(valor < 0):
print("ERROR: Valor negativo. Ingrese un valor positivo")
valor = int(input("Ingrese valor de nodo " +lista_nodos[fila]+" con el nodo " +lista_nodos[columna]+ ":"))
pagina.cell(row = fila+2, column = columna+2, value = valor)
pagina.cell(row = columna+2, column = fila+2, value = valor)
libro.save("matriz_adyacente.xlsx")
return crear_menu()
## Abre la matriz para utilizarla
def abrir_matriz_adyacente(matriz_adyacente):
excel = opxl.load_workbook(matriz_adyacente)
lista_excel = []
pagina = excel.active
maximo_columna = pagina.max_column
maximo_fila = pagina.max_row
for fila in range(1, maximo_fila+1):
lista_fila = []
for columna in range(1, maximo_columna+1):
espacio = pagina.cell(row = fila, column = columna)
lista_fila.append(espacio.value)
lista_excel.append(lista_fila)
return lista_excel
def dijkstra(cant_nodos, empezar, terminar):
lista_excel = abrir_matriz_adyacente(cant_nodos)
camino_mas_corto = {}
pista_predecedor = {}
nodos_no_explorados = lista_excel
inf = 9999999
pista_camino = []
for nodo in nodos_no_explorados:
camino_mas_corto[nodo] = inf
camino_mas_corto[empezar] = 0
while nodos_no_explorados:
nodo_min_distancia = None
for nodo in nodos_no_explorados:
if nodo_min_distancia is None:
nodo_min_distancia = nodo
elif camino_mas_corto[nodo] < camino_mas_corto[nodo_min_distancia]:
nodo_min_distancia = nodo
opciones_caminos = lista_excel[nodo_min_distancia].items()
for nodo_hijo, peso in opciones_caminos:
if peso + camino_mas_corto[nodo_min_distancia] < camino_mas_corto[nodo_hijo]:
camino_mas_corto[nodo_hijo] = peso + camino_mas_corto[nodo_min_distancia]
pista_predecedor[nodo_hijo] = nodo_min_distancia
nodos_no_explorados.pop(nodo_min_distancia)
nodo_actual = terminar
while nodo_actual != empezar:
try:
pista_camino.insert(0, nodo_actual)
nodo_actual = pista_predecedor[nodo_actual]
except KeyError:
print("El camino no existe")
break
pista_camino(0, empezar)
if camino_mas_corto[terminar] != inf:
print("Distancia más corta es: " + str(camino_mas_corto[terminar]))
print("Camino optimo es: " + str(pista_camino))
crear_menu()
crear_matriz_adyacente(cant_nodos)
lista_excel = abrir_matriz_adyacente("matriz_adyacente.xlsx")
print(lista_excel)
Thank you!

The issue is
lista_excel = abrir_matriz_adyacente(cant_nodos) # cant_nodos = 3
which calls
excel = opxl.load_workbook(matriz_adyacente) # matriz_adyacente = cant_nodos = 3
opxl.load_workbook expects string/bytes as an argument, not an int. Your program isn't that straightforward to understand, so I'm not sure why you're passing an int to the function. Just replace it with the filename of the sheet that you want to open.

Refreshing a variable with some conditions

I don't understand a specific behavior of Python when I'm trying the refresh a list.
I try to figure it out because I'm stuck in a small project.
Here's the code (it's not the project's code but its just a code to show you the problem):
import time
time_1 = [1,2,3,4,5]
time_change = time_1
def test():
global time_change
time_change.remove(1)
print(time_change)
time.sleep(10)
time_change = time_1
print(time_change)
# What I would like to have is time_change = time_1
test()
# -*- coding: utf-8 -*-
# Les imports
import time
import random
# ===========================================================
# Déclarations des variables globales.
event_type_architecture = " Le secteur de l'architecture. "
event_type_graphisme = " Le secteur du graphisme. "
event_type_developper = " Le secteur du développement. "
event_type_garage = " Le secteur de l'automobile. "
event_type_charpentier = " Le secteur de la charpentrie. "
event_type_avocat = " Le secteur des avocats. "
event_type_medecin = " Le secteur des médecins "
# event_nb_secteurs HERE !
event_tt = [random.randint(1,6)]
event_nb_secteurs = list(event_tt)
types_secteurs = [event_type_architecture , event_type_developper , event_type_graphisme
, event_type_garage , event_type_charpentier, event_type_avocat , event_type_medecin ]
types_secteurs_change = list(types_secteurs)
event_types_secteurs = random.choice(types_secteurs_change)
# ===========================================================
# different events
def event_crise_economique():
print(" \n Une crise économique sévira dans " + str(event_nb_secteurs) +
# I want event_nb_secteurs to go to his initial value which is random.randint(1,6) but doesn't work always print same event_nb_secteurs number.
" secteurs qui sont....\n")
print(event_nb_secteurs)
time.sleep(5)
event_types()
def event_coupure_electricite():
print(" \n Une coupure de courant va arriver dans " + str(event_nb_secteurs) +
" secteurs qui sont.... \n")
time.sleep(5)
event_types()
def event_types():
global types_secteurs_change
global event_nb_secteurs
if event_nb_secteurs == 0 :
quit
for ev_types in range(event_nb_secteurs[0]) :
event_types_secteurs = random.choice(types_secteurs)
if event_types_secteurs in types_secteurs_change :
print(event_types_secteurs)
types_secteurs_change.remove(event_types_secteurs)
event_nb_secteurs = list(event_tt)
types_secteurs_change = list(types_secteurs)
# Le vrai event :
def event ():
random_event = False
nb_hasard = random.randint(9,11)
if nb_hasard >= 9 :
print("\n Oh non ! un évènement va arriver !")
event_random = random.randint(1,4)
if event_random == 1 :
event_coupure_electricite()
elif event_random == 2 :
event_crise_economique()
else :
print("C bon y a r")
for i in range(10):
event()
As I said you need to focus only on event_nb_secteurs which is the problem.
I would like it to go its initial value that is : random.randint(1,6)
But it doesn't work

By doing time_change = time_1, the variable time_change points to the same list pointed by time_1, that's just an alias, you mostly want to make a copy of it
time_1 = [1, 2, 3, 4, 5]
time_change = list(time_1)
def test(): # no need to pause the code, it runs the same without
global time_change
time_change.remove(1)
print(time_change)
time_change = list(time_1)
print(time_change)
>> test()
[2, 3, 4, 5]
[1, 2, 3, 4, 5]

Battleship with Python

Here I've some difficulties with my program ... I tried everything but nothing works ...
Here is my code:
import random
XBateau_un_joueur = 0
YBateau_un_joueur = 0
XBateau_deux_joueur = 1
YBateau_deux_joueur = 1
XBateau_un_IA = 0
YBateau_un_IA = 0
XBateau_deux_IA = 1
YBateau_deux_IA = 1
def Grille(): #définition du tableau qui servira de grille
tableau_joueur = [(0,)*taille]*taille
for i in range(taille):
tableau_joueur[i] = list(tableau_joueur[i])
tableau_joueur[XBateau_deux_joueur][YBateau_deux_joueur] = 1
tableau_joueur[XBateau_un_joueur][YBateau_un_joueur] = 1
if XBateau_un_joueur == XBateau_deux_joueur and YBateau_un_joueur == YBateau_deux_joueur :
XBateau_deux_joueur = XBateau_deux_joueur + 1
YBateau_deux_joueur = YBateau_deux_joueur + 1
if XBateau_deux_joueur > taille - 1 :
XBateau_deux_joueur = XBateau_deux_joueur - 2
if YBateau_deux_joueur > taille - 1 :
YBateau_deux_joueur = YBateau_deux_joueur - 2
tableau_IA = [(0,)*taille]*taille
for j in range(taille):
tableau_IA[j] = list(tableau_IA[j])
tableau_IA[XBateau_un_IA][YBateau_deux_IA] = 1
tableau_IA[XBateau_deux_IA][YBateau_deux_IA] = 1
if XBateau_un_IA and YBateau_un_IA == XBateau_deux_IA and YBateau_deux_IA :
XBateau_deux_IA = XBateau_deux_IA + 1
YBateau_deux_IA = YBateau_deux_IA + 1
if XBateau_deux_IA > taille - 1 :
XBateau_deux_IA = XBateau_deux_IA - 2
if YBateau_deux_joueur > taille - 1 :
YBateau_deux_IA = YBateau_deux_IA - 2
print tableau_joueur
print tableau_IA
def tour_IA():
compteur_de_point_IA = 0
for tour_IA in range (0, 3):
print "L'ennemi nous attaque Capitain !"
x = int(random.randint(0, taille - 1))
y = int(random.randint(0, taille - 1))
if ((x == XBateau_un_joueur) and (y == YBateau_un_joueur)) or ((x == XBateau_deux_joueur) and (y == YBateau_deux_joueur)) :
compteur_de_point_IA = compteur_de_point_IA + 8
print "Arg ! Cette raclure de fond de calle nous a coulé en vaisseau... prenez garde !"
else:
if (x == XBateau_un_joueur) or (y == YBateau_un_joueur) or (x == XBateau_deux_joueur) or (y == YBateau_deux_joueur) :
compteur_de_point_IA = compteur_de_point_IA + 1
print "nous sommes en vue de l'ennemi Cap'tain ! Faite attention !"
else:
print "A l'eau ! Il nous a raté !"
print "Voici les points marqué par l'ennemis :", compteur_de_point_IA
# tour du joueur IRL
def tour_joueur():
list_resultat = []
List_tot = []
print " C'est à vous d'attaquer"
for tour_joueur in range (0, 3):
compteur_de_point_joueur = 0
print "En attente des ordres, lattitude du tir mon capitain ?"
print "(colone)"
x = int(input())
print "longitude du tir ?"
print "(ligne)"
y = int(input())
if ((x == XBateau_un_IA) and (y == YBateau_un_IA)) or ((x == XBateau_deux_IA) and (y == YBateau_deux_IA)) :
compteur_de_point_joueur = compteur_de_point_joueur + 8
print "Aarrrr ! Navire ennemi envoyé par le fond Cap'tain!"
print "Vous marqué 8 points supplémentaires !! Bien joué!"
else:
if (x == XBateau_un_IA) or (y == YBateau_un_IA) or (x == XBateau_deux_IA) or (y == YBateau_deux_IA):
compteur_de_point_joueur = compteur_de_point_joueur + 1
print "L'ennemis est en vue ! Pas mal boucanier !"
print "Vous marqué 1 point supplémentaire !!"
else:
print "Mille sabords !!! Raté !!! Recommencez marins d'eau douce !"
print "Voici votre total de point marqué :", compteur_de_point_joueur
print " "
list_resultat.append(compteur_de_point_joueur)
print list_resultat[0]
print
def nombre_de_joueur() :
print "Combien de joueur êtes vous ?"
nombre = int(input())
print "Vent dans les voiles !! Vent dans les voiles !!"
for k in range(0, nombre) :
Grille()
tour_joueur()
print " "
print " "
tour_IA()
taille = int(input("Veuillez saisir la taille du champs de bataille matelot !"))
XBateau_un_joueur = random.randint(0, taille - 1)#bateau n°1 du joueur
YBateau_un_joueur = random.randint(0, taille - 1)
XBateau_deux_joueur = random.randint(0, taille - 1)#bateau n°2 du joueur
YBateau_deux_joueur = random.randint(0, taille - 1)
XBateau_un_IA = random.randint(0, taille - 1)#bateau n°1 de l'IA
YBateau_un_IA = random.randint(0, taille - 1)
XBateau_deux_IA = random.randint(0, taille - 1)#bateau n°2 de l'IA
YBateau_deux_IA = random.randint(0, taille - 1)
nombre_de_joueur()
And this is the shell:
Traceback (most recent call last):
File "C:\Users\Marion\Documents\Marion\Work\ISN\BatailleNavale2.py", line 138, in <module>
nombre_de_joueur()
File "C:\Users\Marion\Documents\Marion\Work\ISN\BatailleNavale2.py", line 116, in nombre_de_joueur
Grille()
File "C:\Users\Marion\Documents\Marion\Work\ISN\BatailleNavale2.py", line 17, in Grille
tableau_joueur[XBateau_deux_joueur][YBateau_deux_joueur] = 1
UnboundLocalError: local variable 'XBateau_deux_joueur' referenced before assignment
So if you have an idea..
PS : Sorry if my english is bad... I'm french!

You are assigning a value to the variable here:
XBateau_deux_joueur = XBateau_deux_joueur + 1
Python sees this assignment within your function and then, as a result, understands this variable within a local, rather than a global, scope. So the variable does not refer to the global variable that you probably think it should refer to. Thus when you reference the local variable here:
tableau_joueur[XBateau_deux_joueur][YBateau_deux_joueur] = 1
Python has never seen this variable before within the local scope of the function. The name is unbound, and Python throws an error. If you want to refer to the global variable instead, try this: before any reference to the variable, declare it as a global variable (within the function):
def Grille(): #définition du tableau qui servira de grille
global XBateau_deux_joueur
. . .
Any time you assign a value to a variable within a function, Python will assume that the variable is local in scope throughout the entire function unless told otherwise.