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.
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.
I've got a program that takes in input a .txt file with coordinates (t, X, Y). The movement stored in this files is more or less circular, and this program is counting the number of rotation by searching the local optima of X+Y.
The last part at the end is to plot the results.
You can find here 2 .txt :
https://drive.google.com/file/d/0BxmtjR3C4bYBdnFZUzVwSVlPUlk/view?usp=sharing
Here is the first version :
The Interpolation function is a cubic interpolation that return False if it couldn't Interpolate, or (Frame_final, X_final, Y_final) if it managed to interpolate.
The Filtrage function is a first-order lowpass-filter.
def Filtrage(Frame, X, Y, DT = 3, a = 0.1):
"""Fonction réalisant un filtrage passe-bas d'ordre 1 du signal."""
# Initialisation
X_temp, Y_temp = [], []
X_filter, Y_filter = [], []
i = 1
X_temp.append(X[0])
Y_temp.append(Y[0])
# Filtrage par morceau
while i < len(Frame)-1:
while Frame[i] - Frame[i-1] == DT:
Xnew = a * X[i-1] + (1 - a) * X_temp[len(X_temp)-1]
Ynew = a * Y[i-1] + (1 - a) * Y_temp[len(Y_temp)-1]
X_temp.append(Xnew)
Y_temp.append(Ynew)
if i < len(Frame)-1:
i += 1
else:
break
X_filter += X_temp
Y_filter += Y_temp
X_temp, Y_temp = [], []
X_temp.append(X[i])
Y_temp.append(Y[i])
i += 1
return (X_filter, Y_filter)
def Traitement_resultat(Chemin_dossier_res, Trace_Graph):
"""Fonction réalisant le traitement des résultats pour déterminer le nombre de tour
effectué par la trajectoire circulaire.
- Le paramètre Chemin_dossier_res est une str.
- Le paramètre Trace_graph est un booléen
"""
print ("Début du traitement des résultats")
# Listage des fichiers résultats + ouverture du fichier de résultats finaux
Fichiers_res = os.listdir(Chemin_dossier_res)
res = open("Data_Results.txt", "w")
res.write("{} {} {}\n".format("Souris", "Nombre de tours", "Distance parcourue"))
# On boucle sur les fichiers
for i in range(0, len(Fichiers_res)):
# Affiche l'état du traitement
print ("{} / {} : {}".format(str(i+1), str(len(Fichiers_res)), Fichiers_res[i]))
# On ouvre le fichier résultat
results = open("{}/{}".format(Chemin_dossier_res, Fichiers_res[i]), "r")
# On récupère les datas dans 2 listes
X, Y, Frame = [], [], []
c = 0
try:
for ligne in results:
# Permet d'éliminer la première ligne d'en-tête
if c >= 1:
row = ligne.split()
if row[0] == "None":
continue
else:
Frame.append(int(row[0]))
X.append(int(row[1]))
Y.append(int(row[2]))
c += 1
results.close()
except:
print ("Fichier {} eronné ! Il ne sera pas traité.".format(Fichiers_res[i]))
results.close()
continue
if len(X) != len(Y):
print ("Fichier {} eronné ! Il ne sera pas traité.".format(Fichiers_res[i]))
continue
# Inteprolation
Data = Interpolation(Frame, X, Y)
if not Data:
print ("Fichier {} eronné ! Il ne sera pas traité.".format(Fichiers_res[i]))
continue
Frame = Data[0]
X = Data[1]
Y = Data[2]
# Filtrage
Data = Filtrage(Frame, X, Y)
X = Data[0]
Y = Data[1]
Diff_len = len(Frame) - len(X)
if Diff_len != 0:
Frame = Frame[:len(Frame)-Diff_len]
# Suppression des extremum
if len(Frame) > 1000:
for k in range(30):
maxX_ID = X.index(max(X))
del X[maxX_ID]
del Y[maxX_ID]
del Frame[maxX_ID]
minX_ID = X.index(min(X))
del X[minX_ID]
del Y[minX_ID]
del Frame[minX_ID]
maxY_ID = Y.index(max(Y))
del X[maxY_ID]
del Y[maxY_ID]
del Frame[maxY_ID]
minY_ID = Y.index(min(Y))
del X[minY_ID]
del Y[minY_ID]
del Frame[minY_ID]
elif len(Frame) > 100:
for k in range(3):
maxX_ID = X.index(max(X))
del X[maxX_ID]
del Y[maxX_ID]
del Frame[maxX_ID]
minX_ID = X.index(min(X))
del X[minX_ID]
del Y[minX_ID]
del Frame[minX_ID]
maxY_ID = Y.index(max(Y))
del X[maxY_ID]
del Y[maxY_ID]
del Frame[maxY_ID]
minY_ID = Y.index(min(Y))
del X[minY_ID]
del Y[minY_ID]
del Frame[minY_ID]
else:
print ("{} : Moins de 100 pts !!".format(Fichiers_res[i]))
Sum = []
# Conversion en minute et creation de la somme
for k in range(len(Frame)):
Frame[k] = Frame[k] / (30 * 60)
Sum.append(X[k] + Y[k])
if len(X) > 2:
# Détermination de la distance parcourue
Distance = 0
for k in range(len(X)-1):
Distance += sqrt((X[k+1] - X[k])**2 + (Y[k+1] - Y[k])**2)
Segments = range(200, 1400, 200)
Res = []
for k in range(len(Segments)):
if Segments[k] < len(Sum):
Sum_calc = []
length = len(Sum) // Segments[k]
last = len(Sum) % Segments[k]
for j in range(length):
Sum_calc.append(Sum[j:j + Segments[k]])
if last > Segments[k] //2:
Sum_calc.append(X[len(Sum) - last:])
else:
Sum_calc[len(Sum_calc) - 1] = Sum_calc[len(Sum_calc) - 1] + Sum[len(Sum) - last:]
# Initialisation of the counter
K = 0
for j in range(len(Sum_calc)):
Counter = 0
b = 0
Moyenne = np.mean(Sum_calc[j])
while b < len(Sum_calc[j]):
if Sum_calc[j][b] <= Moyenne + 10:
b += 1
continue
else:
Counter += 1
while Sum_calc[j][b] >= Moyenne + 10:
b += 1
try:
Sum_calc[j][b]
except:
break
K += Counter
Res.append(K)
if len(Res) > 4:
Res_F = int(np.mean(sorted(Res)[1:len(Res)-1]))
else:
Res_F = int(np.mean(Res))
# Ajout au fichier résultat des données
res.write(Fichiers_res[i][0:len(Fichiers_res[i])-4] + " " * (25 - len(Fichiers_res[i])) + str(Res_F)
+ " " * (26 - len(str(Res_F))) + str(int(Distance)) + "\n")
if Trace_Graph:
# Création des graphiques
plt.figure(figsize = (15, 11), dpi = 600)
# Ligne 2 / Colonne 1 / Position 1
plt.subplot(2, 1, 1)
plt.plot(X, Y, color = "green", linewidth = 0.3, linestyle="-")
plt.xlim(min(X) - 0.1 * np.mean(X), max(X) + 0.1 * np.mean(X))
plt.ylim(min(Y) - 0.1 * np.mean(Y), max(Y) + 0.1 * np.mean(Y))
plt.xlabel("pixel")
plt.ylabel("pixel")
plt.title("Trajectoire de la souris")
# Ligne 2 / Colonne 1 / Position 2
plt.subplot(2, 1, 2)
plt.plot(Frame, X, color = "blue", linewidth = 0.5, linestyle="-", label = "X")
plt.plot(Frame, Y, color = "red", linewidth = 0.5, linestyle="-", label = "Y")
plt.xlim(0, Frame[len(Frame)-1])
plt.ylim(min(min(X),min(Y)) - 0.1 * min(min(X),min(Y)) , max(max(X),max(Y)) + 0.1 * max(max(X),max(Y)))
plt.legend(loc = 'upper left')
plt.xlabel("Temps (minutes)")
plt.xticks(np.linspace(0, int(Frame[len(Frame)-1]), int(Frame[len(Frame)-1]) + 1))
plt.ylabel("Position")
plt.title("Position X et Y de la souris en fonction du temps")
plt.savefig("{}/{}.png".format("Graphiques", Fichiers_res[i][0:len(Fichiers_res[i])-4]), dpi = 600)
plt.close()
res.close()
print ("Fin du traitement des résultats !")
print ("---------------------------------------")
The second programm is exactly the same, with only 3 minors change : some of the variable are placed in a different file.
File Parameters.py :
# Parameters to adjust the analysis
# Low-pass filtering between 0 and 1
a = 0.1
# Thershold to count the maximum as a local maximum
Moy_Up = 10
# Segments cutting
Segments = range(200, 1400, 200)
Programm File :
from Parameters import *
def Filtrage(Frame, X, Y, DT = 3, a = 0.1):
"""Fonction réalisant un filtrage passe-bas d'ordre 1 du signal."""
# Initialisation
X_temp, Y_temp = [], []
X_filter, Y_filter = [], []
i = 1
X_temp.append(X[0])
Y_temp.append(Y[0])
# Filtrage par morceau
while i < len(Frame)-1:
while Frame[i] - Frame[i-1] == DT:
Xnew = a * X[i-1] + (1 - a) * X_temp[len(X_temp)-1]
Ynew = a * Y[i-1] + (1 - a) * Y_temp[len(Y_temp)-1]
X_temp.append(Xnew)
Y_temp.append(Ynew)
if i < len(Frame)-1:
i += 1
else:
break
X_filter += X_temp
Y_filter += Y_temp
X_temp, Y_temp = [], []
X_temp.append(X[i])
Y_temp.append(Y[i])
i += 1
return (X_filter, Y_filter)
def Traitement_resultat(Chemin_dossier_res, Trace_Graph):
"""Fonction réalisant le traitement des résultats pour déterminer le nombre de tour
effectué par la trajectoire circulaire.
- Le paramètre Chemin_dossier_res est une str.
- Le paramètre Trace_graph est un booléen
"""
print ("Début du traitement des résultats")
# Listage des fichiers résultats + ouverture du fichier de résultats finaux
Fichiers_res = os.listdir(Chemin_dossier_res)
res = open("Data_Results.txt", "w")
res.write("{} {} {}\n".format("Souris", "Nombre de tours", "Distance parcourue"))
# On boucle sur les fichiers
for i in range(0, len(Fichiers_res)):
# Affiche l'état du traitement
print ("{} / {} : {}".format(str(i+1), str(len(Fichiers_res)), Fichiers_res[i]))
# On ouvre le fichier résultat
results = open("{}/{}".format(Chemin_dossier_res, Fichiers_res[i]), "r")
# On récupère les datas dans 2 listes
X, Y, Frame = [], [], []
c = 0
try:
for ligne in results:
# Permet d'éliminer la première ligne d'en-tête
if c >= 1:
row = ligne.split()
if row[0] == "None":
continue
else:
Frame.append(int(row[0]))
X.append(int(row[1]))
Y.append(int(row[2]))
c += 1
results.close()
except:
print ("Fichier {} eronné ! Il ne sera pas traité.".format(Fichiers_res[i]))
results.close()
continue
if len(X) != len(Y):
print ("Fichier {} eronné ! Il ne sera pas traité.".format(Fichiers_res[i]))
continue
# Inteprolation
Data = Interpolation(Frame, X, Y)
if not Data:
print ("Fichier {} eronné ! Il ne sera pas traité.".format(Fichiers_res[i]))
continue
Frame = Data[0]
X = Data[1]
Y = Data[2]
# Filtrage
Data = Filtrage(Frame, X, Y, a)
X = Data[0]
Y = Data[1]
Diff_len = len(Frame) - len(X)
if Diff_len != 0:
Frame = Frame[:len(Frame)-Diff_len]
# Suppression des extremum
if len(Frame) > 1000:
for k in range(30):
maxX_ID = X.index(max(X))
del X[maxX_ID]
del Y[maxX_ID]
del Frame[maxX_ID]
minX_ID = X.index(min(X))
del X[minX_ID]
del Y[minX_ID]
del Frame[minX_ID]
maxY_ID = Y.index(max(Y))
del X[maxY_ID]
del Y[maxY_ID]
del Frame[maxY_ID]
minY_ID = Y.index(min(Y))
del X[minY_ID]
del Y[minY_ID]
del Frame[minY_ID]
elif len(Frame) > 100:
for k in range(3):
maxX_ID = X.index(max(X))
del X[maxX_ID]
del Y[maxX_ID]
del Frame[maxX_ID]
minX_ID = X.index(min(X))
del X[minX_ID]
del Y[minX_ID]
del Frame[minX_ID]
maxY_ID = Y.index(max(Y))
del X[maxY_ID]
del Y[maxY_ID]
del Frame[maxY_ID]
minY_ID = Y.index(min(Y))
del X[minY_ID]
del Y[minY_ID]
del Frame[minY_ID]
else:
print ("{} : Moins de 100 pts !!".format(Fichiers_res[i]))
Sum = []
# Conversion en minute et creation de la somme
for k in range(len(Frame)):
Frame[k] = Frame[k] / (30 * 60)
Sum.append(X[k] + Y[k])
if len(X) > 2:
# Détermination de la distance parcourue
Distance = 0
for k in range(len(X)-1):
Distance += sqrt((X[k+1] - X[k])**2 + (Y[k+1] - Y[k])**2)
Res = []
for k in range(len(Segments)):
if Segments[k] < len(Sum):
Sum_calc = []
length = len(Sum) // Segments[k]
last = len(Sum) % Segments[k]
for j in range(length):
Sum_calc.append(Sum[j:j + Segments[k]])
if last > Segments[k] //2:
Sum_calc.append(X[len(Sum) - last:])
else:
Sum_calc[len(Sum_calc) - 1] = Sum_calc[len(Sum_calc) - 1] + Sum[len(Sum) - last:]
# Initialisation of the counter
K = 0
for j in range(len(Sum_calc)):
Counter = 0
b = 0
Moyenne = np.mean(Sum_calc[j])
while b < len(Sum_calc[j]):
if Sum_calc[j][b] <= Moyenne + Moy_Up:
b += 1
continue
else:
Counter += 1
while Sum_calc[j][b] >= Moyenne + Moy_Up:
b += 1
try:
Sum_calc[j][b]
except:
break
K += Counter
Res.append(K)
if len(Res) > 4:
Res_F = int(np.mean(sorted(Res)[1:len(Res)-1]))
else:
Res_F = int(np.mean(Res))
# Ajout au fichier résultat des données
res.write(Fichiers_res[i][0:len(Fichiers_res[i])-4] + " " * (25 - len(Fichiers_res[i])) + str(Res_F)
+ " " * (26 - len(str(Res_F))) + str(int(Distance)) + "\n")
if Trace_Graph:
# Création des graphiques
plt.figure(figsize = (15, 11), dpi = 600)
# Ligne 2 / Colonne 1 / Position 1
plt.subplot(2, 1, 1)
plt.plot(X, Y, color = "green", linewidth = 0.3, linestyle="-")
plt.xlim(min(X) - 0.1 * np.mean(X), max(X) + 0.1 * np.mean(X))
plt.ylim(min(Y) - 0.1 * np.mean(Y), max(Y) + 0.1 * np.mean(Y))
plt.xlabel("pixel")
plt.ylabel("pixel")
plt.title("Trajectoire de la souris")
# Ligne 2 / Colonne 1 / Position 2
plt.subplot(2, 1, 2)
plt.plot(Frame, X, color = "blue", linewidth = 0.5, linestyle="-", label = "X")
plt.plot(Frame, Y, color = "red", linewidth = 0.5, linestyle="-", label = "Y")
plt.xlim(0, Frame[len(Frame)-1])
plt.ylim(min(min(X),min(Y)) - 0.1 * min(min(X),min(Y)) , max(max(X),max(Y)) + 0.1 * max(max(X),max(Y)))
plt.legend(loc = 'upper left')
plt.xlabel("Temps (minutes)")
plt.xticks(np.linspace(0, int(Frame[len(Frame)-1]), int(Frame[len(Frame)-1]) + 1))
plt.ylabel("Position")
plt.title("Position X et Y de la souris en fonction du temps")
plt.savefig("{}/{}.png".format("Graphiques", Fichiers_res[i][0:len(Fichiers_res[i])-4]), dpi = 600)
plt.close()
res.close()
print ("Fin du traitement des résultats !")
print ("---------------------------------------")
I don't know why placing this parameters in a different file is changing my result. When I placed print (a), print (Moy_Up) and print (Segments) in the second program just before they are called, they have the right value (respectively, a, 10 and range(200, 1400, 200)).
But with the first program I get :
Souris Nombre de tours Distance parcourue
1 48 13062
2 44 12927
And with the second one :
Souris Nombre de tours Distance parcourue
1 77 40328
2 76 39235
Moreover, if in the second version I change back :
Data = Filtrage(Frame, X, Y, a) by Data = Filtrage(Frame, X, Y)
Moy_Up by 10
and place back the Segments line, my results come back to those of the first version (quite normal).
Thanks for reading this long post, I tried to be explicit with my problem. I just can't understand why placing this variable in a separate file change my result even thou if I print them, they have the right value.
EDIT : I've used the compare module of Notepad, there is nothing else that differs.
You define Filtrage as follows:
def Filtrage(Frame, X, Y, DT = 3, a = 0.1):
Note the fourth parameter is DT, but when you call it:
Data = Filtrage(Frame, X, Y, a)
...you're passing a as the fourth parameter. You probably mean to do:
Data = Filtrage(Frame, X, Y, a=a)
I have to do a simbols fixer in python for LateX
So I made this code and I dont know why it shows
Traceback (most recent call last):
File "C:\Users\Stark's ProBook\Desktop\prueba.py", line 92, in <module>
BracketFind()
File "C:\Users\Stark's ProBook\Desktop\prueba.py", line 30, in BracketFind
for h in archivo:
UnboundLocalError: local variable 'archivo' referenced before assignment
this is my code is for Python 2.7
# -*- coding: cp1252 -*-
archivo = open("test.txt", "r")
texto = archivo.readlines()
archivo = "".join(texto)
Opening = 0
Closes = 0
print archivo
def Count():
return contador('{')-contador('}')
def contador(simbolo):
conta = 0
for h in archivo:
if simbolo == h:
conta= conta+1
return conta
def Insert(string, index):
return string[:index] + '.' + string[index:]
def Remove(string, index):
return string[:index-1] + '.' + string[index+1:]
def BracketFind():
Opening = 0
Closes = 0
for h in archivo:
if '{' == h:
Opening = Opening+1
elif '}' ==h:
Closes = Closes+1
print "Abiertas ({) "+ str(Opening) + " Cerradas (}) "+str(Closes)
Position = -1
StartReplacing = False
OpenPosition = -1
while True:
Position = -1
StartReplacing = False
OpenPosition = -1
if Count() == 0:
print "Revision exitosa!!, No existe ninguna { sin cerrar " +"Si tienes problemas de compilacion no es por esta razón. " + "Revisa tu codigo en busca de otro error"
return True
if contador('{') == 0 and contador('}')>0:
break
if contador('{') > 0 and contador('}') == 0:
break
for Character in archivo:
Position = Position+1
if Character == '{':
OpenPosition = Position
StartReplacing = True
if StartReplacing:
if Character == '}':
try:
archivo = Remove(archivo,OpenPosition)
archivo = Insert(archivo,OpenPosition)
archivo = Remove(archivo,Position)
archivo = Insert(archivo,Position)
except:
break
iPos = -1
iCount = -1
iTarget = 0
iType = 0
if '{' in archivo:
iTarget = archivo.rfind('{')
print iTarget
iType = 1
elif '}' in archivo:
iTarget = archivo.rfind('}')
iType = 2
if iTarget == -1:
return True
if iType == 1:
print "La llave que abre (" , iTarget , ") quizas es inecesaria o parece no estar cerrada"
elif iType == 2:
print "La llave que cierra (" , iTarget , ") quizas es inecesaria o parece no estar cerrada"
for Character in archivo:
iPos = iPos+1
if Character == '{' or Character == '}':
iCount = iCount+1
if(iCount == iTarget):
print "La llave ",iCount , "Parece tener error"
return True
print Count()
BracketFind()
Do You have an idea about what is causing this?
I dont understand why is showing this if at the begin of the execution it prints 'archivo'
This has to do with how python handles scopes. Initially, archivo is a global variable, defined outside any function or class; it can be accessed from any scope. BracketFind() includes several definitions for archivo, ie 'archivo = Remove(archivo,OpenPosition)'. This causes archivo to revert to a local scope for that function; the global variable you are trying to refer to is no longer accessible.
The easiest way to fix this is to add the line 'global archivo' near the beginning of BracketFind(), but a more robust solution will be to rework your code so archivo is no longer a global variable.
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.