Je cherche depuis des heures ce que j'ai pu casser dans mon code.
J'ai une fonction qui déplace un objet :
#Déplacement d'un objet
def deplacement(objet,dx,dy,nb,image,temps):
zone_princ.itemconfig((objet), image=image)
zone_princ.update()
print (nb)
for i in range(nb):
zone_princ.move(objet, dx, dy)
zone_princ.update()
time.sleep(temps)
et qui me renvoie :
File "/home/arnaud/numeration/numeration.py", line 367, in deplacement
for i in range (nb):
TypeError: 'NoneType' object is not iterable
Pourtant la commande que j'ai placée pour tenter de comptendre :
print (nb)
me renvoie bien une valeur (30 en l'occurence).
D'ailleurs si je remplace par
for i in range(30):
ça renvoie la même erreur.
Savez-vous pourquoi je ne peux pas itérer 30 ?
Merci
Et voici le code complet :
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from tkinter import *
from random import *
import tkinter.font as tkFont
import time
#Création de la fenêtre
fenetre = Tk()
larg=fenetre.winfo_screenwidth()-100
haut=fenetre.winfo_screenheight()-100
fenetre.title("Numération")
fenetre.geometry(f"{larg}x{haut}+0+0")
#Création des cadres
zone_haut=Frame(fenetre, height=100, width=larg)
zone_haut.grid(in_=fenetre, row=0,column=0, columnspan=2, sticky='nesw')
zone_gauche=Frame(fenetre, width=100, height=haut)
zone_gauche.grid(row=1,column=0, sticky='nesw')
zone_princ=Canvas(fenetre, width=larg-100, height=haut-100, bg="#d6e2e4")
zone_princ.grid(row=1,column=1)
#Variables globales de départ
#Dimensions du canvas
larg_canvas=larg-100
haut_canvas=haut-100
#Marge extérieur des colonnes
marge=50
#Nombre représenté
nombre=0
milliers=centaines=dizaines=unites=0
#Nombre d'objets sélectionnés
m=c=d=u=0
#Nombre de colonnes
nbcolonnes=2
ordre=IntVar()
ordre.set(0)
l = 30
print(f"d={d}")
#Polices
gros = tkFont.Font(family='Helvetica', size=20, weight='bold')
#Images
img_corbeille=PhotoImage(file="images/corbeille.png")
img_minicorbeille = PhotoImage(file="images/minicorbeille.png")
img_unite=PhotoImage(file="images/unite.png")
img_unite_select=PhotoImage(file="images/unite_select.png")
img_dizaine=PhotoImage(file="images/dizaine.png")
img_dizaine_select=PhotoImage(file="images/dizaine_select.png")
img_centaine=PhotoImage(file="images/centaine.png")
img_centaine_select=PhotoImage(file="images/centaine_select.png")
img_millier=PhotoImage(file="images/millier.png")
img_millier_select=PhotoImage(file="images/millier_select.png")
#Création des zones milliers, centaines, dizaines, unités
liste_4=("milliers","centaines","dizaines","unites")
liste_3=("centaines","dizaines","unites")
liste_2=("dizaines","unites")
#Compteurs
compteur_milliers = Label(zone_haut, text=milliers, font=gros)
compteur_centaines = Label(zone_haut, text=centaines, font=gros)
compteur_dizaines = Label(zone_haut, text=dizaines, font=gros)
compteur_unites = Label(zone_haut, text=unites, font=gros)
#Création des colonnes
def rectangles(mode):
global larg_colonne, haut_canvas
posx = posy = marge
for i in (mode):
zone_princ.create_rectangle(posx,posy,larg_colonne+posx,haut_canvas-marge, fill="#d9dce6", tags=f"{i}")
posx=posx+marge+larg_colonne
#Initialisation des éléments
def init():
global larg_colonne, liste_millier, liste_centaine, liste_dizaine, liste_unite, haut_colonne
nb=int(nbcolonnes)
compteur.place(x=10, y=30)
haut_colonne = haut-100-2*marge
if nb==4:
larg_colonne = (larg_canvas - (5 * marge)) / 4
rectangles(liste_4)
if nb==3:
larg_colonne = (larg_canvas - (4 * marge)) / 3
rectangles(liste_3)
if nb==2:
larg_colonne = (larg_canvas - (3 * marge)) / 2
rectangles(liste_2)
if nb==4:
liste_millier = zone_princ.coords("milliers")
casse_millier = Button(zone_princ, text=">>>", command=lambda: casse("millier", milliers))
suppr_millier = Button(zone_princ, text="-", command=lambda: suppr("millier"))
add_millier = Button(zone_princ, text="+", command=lambda: cree("millier", img_millier, 1000, "normal"))
reset_millier = Button(zone_haut, image=img_minicorbeille, command=lambda: reset("millier"))
reset_millier.place(x=(liste_millier[0] + liste_millier[2]) / 2 + 100, y=35, anchor=CENTER)
compteur_milliers.place(x = (liste_millier[0]+liste_millier[2])/2+100, y = 80, anchor=CENTER)
casse_millier.place(x=(liste_millier[0]+liste_millier[2])/2,y=haut_canvas-marge/2, anchor=CENTER)
add_millier.place(x=(liste_millier[0]+liste_millier[2])/2,y=marge/2, anchor=W, width=l)
suppr_millier.place(x=(liste_millier[0]+liste_millier[2])/2,y=marge/2, anchor=E, width=l)
if nb>=3:
liste_centaine = zone_princ.coords("centaines")
liste_dizaine = zone_princ.coords("dizaines")
reset_centaine = Button(zone_haut, image=img_minicorbeille, command=lambda: reset("centaine"))
casse_centaine = Button(zone_princ, text=">>>", command=lambda: casse("centaine", centaines))
groupe_centaines = Button(zone_princ, text="<<<", command=lambda: groupe("centaine", centaines))
deselect_centaine = Button(zone_princ, text="✅", command=lambda: deselect("centaine"), background="#fefb00")
select_centaine = Button(zone_princ, text="✅", command=lambda: select("centaine"), background="red")
add_centaine = Button(zone_princ, text="+", command=lambda: cree("centaine", img_centaine, 100, "normal"))
suppr_centaine = Button(zone_princ, text="-", command=lambda: suppr("centaine"))
compteur_centaines.place(x=(liste_centaine[0] + liste_centaine[2]) / 2 + 100, y=80, anchor=CENTER)
suppr_centaine.place(x=((liste_centaine[0] + liste_centaine[2]) / 2) - l, y=marge / 2, anchor=E, width=l)
add_centaine.place(x=(liste_centaine[0] + liste_centaine[2]) / 2, y=marge / 2, anchor=E, width=l)
deselect_centaine.place(x=((liste_centaine[0] + liste_centaine[2]) / 2) + l, y=marge / 2, anchor=W, width=l)
groupe_centaines.place(x=(liste_centaine[0] + liste_centaine[2]) / 2, y=haut_canvas - marge / 2, anchor=E)
casse_centaine.place(x=(liste_centaine[0] + liste_centaine[2]) / 2, y=haut_canvas - marge / 2, anchor=W)
select_centaine.place(x=(liste_centaine[0] + liste_centaine[2]) / 2, y=marge / 2, anchor=W, width=l)
reset_centaine.place(x=(liste_centaine[0] + liste_centaine[2]) / 2 + 100, y=35, anchor=CENTER)
groupe_dizaines = Button(zone_princ, text="<<<", command=lambda: groupe("dizaine", dizaines))
groupe_dizaines.place(x=(liste_dizaine[0] + liste_dizaine[2]) / 2, y=haut_canvas - marge / 2, anchor=E)
#Dans tous les cas création des boutons dieaines et unités
#Les positions
liste_dizaine = zone_princ.coords("dizaines")
liste_unite = zone_princ.coords("unites")
#Les boutons et les compteurs
deselect_dizaine = Button(zone_princ, text="✅", command=lambda: deselect("dizaine"), background="#fefb00")
casse_dizaine = Button(zone_princ, text=">>>", command=lambda: casse("dizaine", dizaines))
reset_unite = Button(zone_haut, image=img_minicorbeille, command=lambda: reset("unite"))
groupe_unites = Button(zone_princ, text="<<<", command=lambda: groupe("unite", unites))
select_unite = Button(zone_princ, text="✅", command=lambda: select("unite"), background="red")
select_dizaine = Button(zone_princ, text="✅", command=lambda: select("dizaine"), background="red")
deselect_unite = Button(zone_princ, text="✅", command=lambda: deselect("unite"), background="#fefb00")
suppr_unite = Button(zone_princ, text="-", command=lambda: suppr("unite"))
suppr_dizaine = Button(zone_princ, text="-", command=lambda: suppr("dizaine"))
reset_dizaine = Button(zone_haut, image=img_minicorbeille, command=lambda: reset("dizaine"))
add_unite = Button(zone_princ, text="+", command=lambda: cree("unite", img_unite, 1, "normal"))
add_dizaine = Button(zone_princ, text="+", command=lambda: cree("dizaine", img_dizaine, 10, "normal"))
select_unite.place(x=(liste_unite[0] + liste_unite[2]) / 2, y=marge / 2, anchor=W, width=l)
select_dizaine.place(x=(liste_dizaine[0] + liste_dizaine[2]) / 2, y=marge / 2, anchor=W, width=l)
deselect_unite.place(x=((liste_unite[0] + liste_unite[2]) / 2) + l, y=marge / 2, anchor=W, width=l)
deselect_dizaine.place(x=((liste_dizaine[0] + liste_dizaine[2]) / 2) + l, y=marge / 2, anchor=W, width=l)
add_unite.place(x=(liste_unite[0] + liste_unite[2]) / 2, y=marge / 2, anchor=E, width=l)
add_dizaine.place(x=(liste_dizaine[0] + liste_dizaine[2]) / 2, y=marge / 2, anchor=E, width=l)
suppr_unite.place(x=((liste_unite[0] + liste_unite[2]) / 2) - l, y=marge / 2, anchor=E, width=l)
suppr_dizaine.place(x=((liste_dizaine[0] + liste_dizaine[2]) / 2) - l, y=marge / 2, anchor=E, width=l)
casse_dizaine.place(x=(liste_dizaine[0] + liste_dizaine[2]) / 2, y=haut_canvas - marge / 2, anchor=W)
groupe_unites.place(x=(liste_unite[0] + liste_unite[2]) / 2, y=haut_canvas - marge / 2, anchor=CENTER)
reset_dizaine.place(x=(liste_dizaine[0] + liste_dizaine[2]) / 2 + 100, y=35, anchor=CENTER)
reset_unite.place(x=(liste_unite[0] + liste_unite[2]) / 2 + 100, y=35, anchor=CENTER)
compteur_dizaines.place(x=(liste_dizaine[0] + liste_dizaine[2]) / 2 + 100, y=80, anchor=CENTER)
compteur_unites.place(x=(liste_unite[0] + liste_unite[2]) / 2 + 100, y=80, anchor=CENTER)
#Action du bouton corbeille
def nouveau(nb):
global nbcolonnes
nbcolonnes=nb
zone_princ.delete('all')
for widget in zone_princ.winfo_children():
widget.place_forget()
for widget in zone_haut.winfo_children():
widget.place_forget()
init()
reset("tout")
#Fenêtre à propos
def apropos():
fen_apropos = Toplevel(fenetre, background='#fff')
fen_apropos.geometry("600x300+300+200")
fen_apropos.title('À propos')
texte_manuel = Label(fen_apropos, width=550, wraplength=550, justify='left', background='#fff', text="Numération est un logiciel qui permet de représenter les milliers, centaines, dizaines et unités sous fomes de blocs de base, et d'effectuer des conversions entre colonnes.\n\nIl est écrit par Arnaud Champollion et partagé sous licence GNU/GPL.")
texte_manuel.pack()
fen_apropos.mainloop()
#Bouton du choix du nombre de colonnes
choixcol=Scale(zone_gauche, orient='horizontal', showvalue=0, from_=4, to=2, resolution=1, tickinterval=1, length=100, label='Colonnes', command=nouveau)
choixcol.grid(row=1,column=0, sticky='nesw', pady=20)
#Bouton à propos
bouton_apropos=Button(zone_gauche, text="À propos", command=apropos)
bouton_apropos.grid(row=2, column=0)
#Compteur général
compteur=Label(zone_haut, text=nombre, font=gros)
compteur.place(x=10, y=30)
#Corbeille
corbeille=Button(zone_gauche, image=img_corbeille, command=lambda : reset("tout"))
corbeille.grid(row=0,column=0)
#Listes des coordonnées des coins des rectangles
objets_milliers=[]
objets_centaines=[]
objets_dizaines=[]
objets_unites=[]
#Lancement du début
init()
#Pour afficher en console le nombre total et le nombre de chaque puissance de 10
def console():
print(nombre)
print(f'{milliers} milliers')
print(f'{centaines} centaines')
print(f'{dizaines} dizaines')
print(f'{unites} unités')
#Boucle de création d'une image
def cree(objet,img,valeur,mode):
global nombre, milliers, centaines, dizaines, unites,u,d,c,m
#On incrémente les compteur
nombre=nombre+valeur
#On récupère les coordonnées de la colonne correspondante et on incrémente le nombre de chaque
if objet=="millier":
liste_coords=liste_millier
milliers=milliers+1
if objet=="centaine":
liste_coords=liste_centaine
centaines=centaines+1
if objet=="dizaine":
liste_coords=liste_dizaine
dizaines=dizaines+1
if objet=="unite":
liste_coords=liste_unite
unites=unites+1
print(f"d={d}")
maj()
#On attribue des positions maxi
x1=int(liste_coords[0]+60)
x2=int(liste_coords[2]-60)
y1=int(liste_coords[1]+60)
y2=int(liste_coords[3]-60)
xobjet=randint(x1,x2)
yobjet=randint(y1,y2)
#On crée l'objet à une position aléatoire à l'intérieur des positions maxi et on le taggue avec le type d'objet
if objet=="millier":
objets_milliers.append(zone_princ.create_image(xobjet,yobjet, image=img, tags=objet))
if objet=="centaine":
if mode=="groupe":
objets_centaines.append(zone_princ.create_image(coords_groupe[0],coords_groupe[1], image=img, tags=objet))
else:
objets_centaines.append(zone_princ.create_image(xobjet,yobjet, image=img, tags=objet))
if objet=="dizaine":
if mode=="groupe":
objets_dizaines.append(zone_princ.create_image(coords_groupe[0],coords_groupe[1], image=img, tags=objet))
else:
objets_dizaines.append(zone_princ.create_image(xobjet,yobjet, image=img, tags=objet))
if objet=="unite":
if ordre.get()==0:
objets_unites.append(zone_princ.create_image(xobjet,yobjet, image=img, tags=objet))
else:
objets_unites.append(zone_princ.create_image((range(objet)[0]), (range(objet)[1]), image=img, tags=objet))
print (range(objet))
def range(objet):
if objet=="unite":
nombrex=int((larg_colonne/50))
marge=25
return [marge+liste_unite[0]+(len(objets_unites)-nombrex*(int(len(objets_unites)/nombrex)))*50,marge+liste_unite[1]+int(len(objets_unites)/nombrex)*50]
def action_range():
if ordre.get()==1:
print (objets_unites)
print (len(objets_unites))
rang=0
marge = 25
nombrex = int((larg_colonne / 50))
for i in (objets_unites):
print (rang)
cible=(marge+liste_unite[0]+(rang-nombrex*(int(rang/nombrex)))*50,marge+liste_unite[1]+int(rang/nombrex)*50)
print (cible)
zone_princ.move(i,cible[0]-(zone_princ.coords(i)[0]),cible[1]-(zone_princ.coords(i)[1]))
rang=rang+1
#Mise à jour des affichages des compteurs
def maj():
nb=int(nbcolonnes)
compteur.configure(text=nombre)
if nb==4:
compteur_milliers.configure(text=milliers)
if nb>=3:
compteur_centaines.configure(text=centaines)
compteur_dizaines.configure(text=dizaines)
compteur_unites.configure(text=unites)
#Suppression d'un objet
def suppr(objet):
global nombre, milliers, centaines, dizaines, unites, u,d,c,m
if objet=="millier" and milliers>0:
milliers = milliers - 1
if m>0:
m = m - 1
nombre = nombre - 1000
zone_princ.delete(objets_milliers[-1])
objets_milliers.pop()
if objet=="centaine" and centaines>0:
centaines = centaines - 1
nombre = nombre - 100
if c>0:
c = c - 1
zone_princ.delete(objets_centaines[-1])
objets_centaines.pop()
if objet=="dizaine" and dizaines>0:
dizaines = dizaines - 1
nombre = nombre - 10
if d>0:
d = d - 1
zone_princ.delete(objets_dizaines[-1])
objets_dizaines.pop()
if objet=="unite" and unites>0:
unites= unites - 1
nombre = nombre - 1
if u>0:
u = u - 1
zone_princ.delete(objets_unites[-1])
objets_unites.pop()
nombre=1000*milliers+100*centaines+10*dizaines+unites
maj()
#Suppression de tous les objets et remise à zéro
def reset(objet):
global nombre, milliers, centaines, dizaines, unites
if objet=="millier":
zone_princ.delete("millier")
milliers=0
if objet=="centaine":
zone_princ.delete("centaine")
centaines=0
if objet=="dizaine":
zone_princ.delete("dizaine")
dizaines=0
if objet=="unite":
zone_princ.delete("unite")
unites=0
if objet=="tout":
zone_princ.delete("millier")
zone_princ.delete("centaine")
zone_princ.delete("dizaine")
zone_princ.delete("unite")
milliers=centaines=dizaines=unites=0
nombre=1000*milliers+100*centaines+10*dizaines+unites
maj()
#Déplacement d'un objet
def deplacement(objet,dx,dy,nb,image,temps):
zone_princ.itemconfig((objet), image=image)
zone_princ.update()
print (nb)
for i in range(nb):
zone_princ.move(objet, dx, dy)
zone_princ.update()
time.sleep(temps)
#Calcul d'un trajet particulier
def rel(type,id,rang):
coords=zone_princ.coords(id)
return [(arrivee(type,rang)[0])-coords[0],(arrivee(type,rang)[1])-coords[1]]
#Calcul de coordonnées cibles
def arrivee(objet,rang):
global unites, dizaine, centaine, millier
if objet=="millier":
liste_coords=liste_millier
if objet=="centaine":
liste_coords=liste_centaine
if objet=="dizaine":
liste_coords=liste_dizaine
return [(liste_coords[0]+(larg_colonne/2)),(liste_coords[1]+(haut_colonne/2))-(16*(rang-4))]
if objet=="unite":
liste_coords=liste_unite
return [(liste_coords[0]+(larg_colonne/2))+(14*(rang-4)),liste_coords[1]+(haut_colonne/2)]
#Cassage (dégroupage d'un objet) et déplacement
def casse(objet,compteur):
global milliers,centaines,dizaines,unites, objets_milliers, nombre, m,c,d,u
if compteur>0:
compteur=compteur-1
if objet=="millier":
deplacement(objets_milliers[-1],larg_colonne/30,0,30,img_millier_select,0.02)
milliers=milliers-1
m=m-1
nombre=nombre-1000
zone_princ.delete(objets_milliers[-1])
objets_milliers.pop()
for i in range(10):
cree("centaine", img_centaine_select,100,"bouge")
zone_princ.update()
time.sleep(0.6)
zone_princ.itemconfig("centaine",image=img_centaine)
zone_princ.update()
time.sleep(0.6)
if objet=="centaine":
deplacement(objets_centaines[-1],larg_colonne/30,30,0,img_centaine_select,0.02)
centaines=centaines-1
nombre=nombre-100
c=c-1
zone_princ.delete(objets_centaines[-1])
objets_centaines.pop()
for i in range(10):
cree("dizaine", img_dizaine_select,10,"bouge")
zone_princ.update()
time.sleep(0.6)
zone_princ.itemconfig("dizaine",image=img_dizaine)
zone_princ.update()
time.sleep(0.6)
if objet=="dizaine":
deplacement(objets_dizaines[-1],larg_colonne/30,0,30,img_dizaine_select,0.02)
dizaines=dizaines-1
nombre=nombre-10
d=d-1
zone_princ.delete(objets_dizaines[-1])
objets_dizaines.pop()
for i in range(10):
cree("unite", img_unite_select,1,"bouge")
zone_princ.update()
time.sleep(0.6)
zone_princ.itemconfig("unite",image=img_unite)
zone_princ.update()
time.sleep(0.6)
#Groupement, déplacement, suppression et création d'un nouvel objet
def groupe(objet,compteur):
global milliers,centaines,dizaines,unites, objets_milliers, nombre,u,d,c,m, dx, dy, coords_groupe
dx=-10
dy=0
if compteur>=10:
compteur=compteur+10
if objet=="unite" and u==10:
unites=unites-10
u=u-10
nombre=nombre-10
trajectoirex=[]
trajectoirey=[]
rang=0
for i in (objets_unites[-10:]):
trajectoirex.append(rel("unite",i,rang)[0])
trajectoirey.append(rel("unite", i,rang)[1])
rang=rang+1
for i in range (30):
rang = 0
for i in (objets_unites[-10:]):
zone_princ.move(i,trajectoirex[rang]/30,trajectoirey[rang]/30)
rang=rang+1
deplacement('pretabouger',-larg_colonne/30,(randint(-300,300))/30,1,img_unite_select,0)
zone_princ.update()
time.sleep(0.02)
zone_princ.update()
time.sleep(0.3)
coords_groupe=[(zone_princ.coords(objets_unites[-5])[0]+zone_princ.coords(objets_unites[-6])[0])/2,zone_princ.coords(objets_unites[-1])[1]]
print (coords_groupe)
#deplacement('pretabouger',-larg_colonne/30,30,img_unite_select,0.02)
cree("dizaine", img_dizaine, 10, "groupe")
for i in range (10):
zone_princ.delete(objets_unites[-1])
objets_unites.pop()
zone_princ.update()
time.sleep(0.6)
zone_princ.itemconfig("dizaine",image=img_dizaine)
zone_princ.update()
time.sleep(0.6)
if objet=="dizaine" and d==10:
dizaines=dizaines-10
d=d-10
nombre=nombre-100
trajectoirex=[]
trajectoirey=[]
rang=0
for i in (objets_dizaines[-10:]):
trajectoirex.append(rel("dizaine",i,rang)[0])
trajectoirey.append(rel("dizaine", i,rang)[1])
rang=rang+1
for i in range (30):
rang = 0
for i in (objets_dizaines[-10:]):
zone_princ.move(i,trajectoirex[rang]/30,trajectoirey[rang]/30)
rang=rang+1
deplacement('pretabouger',-larg_colonne/30,(randint(-300,300))/30,1,img_dizaine_select,0)
zone_princ.update()
time.sleep(0.02)
zone_princ.update()
time.sleep(0.3)
coords_groupe=[(zone_princ.coords(objets_dizaines[-5])[0]+zone_princ.coords(objets_dizaines[-6])[0])/2,zone_princ.coords(objets_dizaines[-1])[1]]
print (coords_groupe)
#deplacement('pretabouger',-larg_colonne/30,30,img_dizaine_select,0.02)
cree("centaine", img_centaine_select,100,"groupe")
for i in range(10):
zone_princ.delete(objets_dizaines[-1])
objets_dizaines.pop()
zone_princ.update()
time.sleep(0.6)
zone_princ.itemconfig("centaine",image=img_centaine)
zone_princ.update()
time.sleep(0.6)
if objet=="centaine" and c==10:
centaines=centaines-10
c=c-10
nombre=nombre-1000
deplacement('pretabouger',-larg_colonne/30,30,img_centaine_select,0.02)
cree("millier", img_millier_select,1000,"groupe")
for i in range(10):
zone_princ.delete(objets_centaines[-1])
objets_centaines.pop()
zone_princ.update()
time.sleep(0.6)
zone_princ.itemconfig("millier",image=img_millier)
zone_princ.update()
time.sleep(0.6)
#Sélection d'un objet
def select(objet):
global m,c,d,u,unites,dizaines,centaines,milliers
#print(f"vérif u={u}")
#print(f"unites={unites}")
#print(f"nb objets unite={len(objets_unites)}")
print(f"d={d}")
if objet=="unite" and unites>0 and u<len(objets_unites):
u=u+1
#print(f"désormais u={u}")
#print(f"liste des objets{objets_unites}")
#print(f"L'objet à sélectionner est le {objets_unites[-u]}")
zone_princ.itemconfig((objets_unites[-u]),image=img_unite_select, tags=("unite","pretabouger"))
if objet=="dizaine" and dizaines>0 and d<len(objets_dizaines):
zone_princ.itemconfig((objets_dizaines[-d]),image=img_dizaine_select, tags=("dizaine","pretabouger"))
d=d+1
print(f"d={d}")
if objet=="centaine" and centaines>0 and c<len(objets_centaines):
zone_princ.itemconfig((objets_centaines[-c]),image=img_centaine_select, tags=("centaine","pretabouger"))
c=c+1
if objet=="millier" and milliers>0 and m<len(objets_centaines):
zone_princ.itemconfig((objets_milliers[-m]),image=img_millier_select)
m=m+1
#Déselection d'un objet
def deselect(objet):
global m,c,d,u,unites,dizaines,centaines,milliers
if objet=="unite" and unites>0 and u>0:
zone_princ.itemconfig((objets_unites[-u]),image=img_unite)
zone_princ.dtag(objets_unites[-u],"pretabouger")
u=u-1
if objet=="dizaine" and dizaines>0 and d>0:
zone_princ.itemconfig((objets_dizaines[-d]),image=img_dizaine, tags="dizaine")
zone_princ.dtag(objets_dizaines[-d],"pretabouger")
d=d-1
print(f"d={d}")
if objet=="centaine" and centaines>0 and c>0:
zone_princ.itemconfig((objets_centaines[-c]),image=img_centaine, tags="dizaine")
zone_princ.dtag(objets_centaines[-c],"pretabouger")
c=c-1
if objet=="millier" and milliers>0 and m>0:
zone_princ.itemconfig((objets_milliers[-m]),image=img_millier)
m=m-1
#Bouton du choix du nombre de colonnes
choixrange=Checkbutton(zone_gauche, variable=ordre, onvalue = 1, offvalue = 0, text='Ranger', command=action_range)
choixrange.grid(row=3,column=0, sticky='nesw', pady=20)
#Appuis sur les touches
#Ajout d'unités, dizaines ...
fenetre.bind_all('<u>', lambda event: cree("unite",img_unite, 1,"normal"))
fenetre.bind_all('<d>', lambda event: cree("dizaine",img_dizaine, 10,"normal"))
fenetre.bind_all('<c>', lambda event: cree("centaine",img_centaine, 100,"normal"))
fenetre.bind_all('<m>', lambda event: cree("millier",img_millier, 1000,"normal"))
#Sélection de milliers, centaines ...
fenetre.bind_all('<g>', lambda event: select("millier"))
fenetre.bind_all('<h>', lambda event: select("centaine"))
fenetre.bind_all('<j>', lambda event: select("dizaine"))
fenetre.bind_all('<k>', lambda event: select("unite"))
#Boucle principale
fenetre.mainloop()
J'ai renommé la fonction range en rangement et c'est bon.
Il y a certains mots à éviter quand on définit des fonctions, je comprends
Erreur liée à un objet "NoneType" non térable
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Python c'est bon, mangez-en.