[python.débutant] __init__ self, besoin d'aide ...!

AnsuzPeorth · Le 26/02/2010, à 23:16

Bjr,
Je précise avant tout que j'ai passé pas mal de temps à chercher/tester, mais sans vraiment percer le secret .

J'ai compris le principe, réussi les exo qu'on trouve sur le net à ce sujet, mais entre réussir des exos,comprendre et mettre en application, y une marge .

Dans le code qui suit, j'aimerais me passer de l'appel à global. La variable flux doit être accessible dans une fonction (et je ne peux pas l'envoyer en argument). En l'état ca fonctionne, mais je trouve pas très propre et j'aimerais comprendre comment se passer de global grace à self.

Ce script sera pour regarder les chaines tvsurpc. Un bouton par chaine qui envois un signal. C'est très simple (mon premier script bash faisait la même chose, donc je débute en python pareil).

class GladeHandlers:
		
	def france2(event):
		widgets['label1'].set_text("Actuellement : France 2")
		global flux		
		flux ='france_2'
		lecture()
		
	def france3(event):
		widgets['label1'].set_text("Actuellement : France 3")
		global flux		
		flux ='france_3'
		lecture()
		
	def gtk_widget_destroy(event):
		gtk.main_quit()

       # ici <flux> doit être accessible, c'est le choix de la chaine précédemment sélectionnée
	def check_rec(event):
		entree =widgets['entry1'].get_text()
		rec(entree, flux)

def lecture():
	print cmd_add+flux+null  

# a cause de cette fonction, <flux> doit être chargée.	
def rec(entree, flux,  check_rec_actif):
	print entree, flux
	   
class WidgetsWrapper:
	def __init__(self):
		path_gui =path_dossier+'/pctv.glade'
		self.widgets = gtk.glade.XML(path_gui, "window1")
		self.widgets.signal_autoconnect(GladeHandlers.__dict__)
		
	def __getitem__(self, key):
        	return self.widgets.get_widget(key)
		
	def boucle(self):
		gtk.main() 
if __name__ == '__main__':
    widgets = WidgetsWrapper()
    widgets.boucle()

Pour chaque chaine (donc bouton), je dois avoir une fonction propre, comment s'en passer ? Je n'arrive pas à passer un argument à la fonction lors du clic (via glade3, data user ne sort rien !)

Si vous voyez d'autres choses qui clochent, n'hésitez pas

Merci d'avance .

Dernière modification par AnsuzPeorth (Le 26/02/2010, à 23:18)

nesthib · Le 27/02/2010, à 00:05

il faut que tu définisses un constructeur de ta classe :

class GladeHandlers:
    def __init__(self):
        self.flux='France42'
    def france2(self,event):
        self.flux='France2'

AnsuzPeorth · Le 27/02/2010, à 00:31

J'ai déjà essayé, mais comme erreur lors de l'appel (clic bouton)

TypeError: france2() takes exactly 2 arguments (1 given)

Si j'enleve le self des arguments de la fonction, il me dit 'self is not definied'

Ca vient peut être de la façon de connecter les événements:

self.widgets.signal_autoconnect(GladeHandlers.__dict__)

C'est un truc sur lequel je coince, quand et comment utiliser __init__ et self ...! (c'est ça la POO ...!)

nesthib · Le 27/02/2010, à 00:46

oui ça doit plutôt venir de ton event car ce que je t'ai posté avant fonctionne parfaitement, après je ne connais pas glade, je ne pourrais pas t'être d'un grand secours.
Avec wxpython de mémoire il y a une fonction Bind qui relie les événements à la fonction à lancer.

bon j'ai recherché dans un vieux code (2 façons différentes)

self.Bind(wx.EVT_MENU, self.OnNew, id=wx.ID_NEW)
wx.EVT_MENU(self, wx.ID_OPEN, self.OnOpen)

après c'est peut être très différent avec pyglade

kouskous · Le 27/02/2010, à 11:33

Le premier argument de chaque fonction de ta classe doit être "self"

AnsuzPeorth · Le 27/02/2010, à 20:28

kouskous a écrit :

Le premier argument de chaque fonction de ta classe doit être "self"

J'ai essayé d'en mettre un peu de partout...!

Le problème venait de la façon de gérer les event (enfin, je pense).

J'ai tjrs pas bien cerné le truc ...!

Le but est d'avoir des variables modifiées dans une fonction de classe, et accessible depuis une autre fonction de cette classe.
Le modèle :

class Enfant:
	def fonction_enfant(self):
		self.new_var ='new'
		self.var ='modifier'
		print 'depuis fonction_enfant', self.new_var, self.var

	def fonction_enfant2(self):
		print 'depuis fonction_enfant2', self.new_var, self.var	

class Parent:
	def __init__(self):
		self.var ='init'
		# 3 lignes qui suivent pas necessaire d'être dans __init__,
		# et self non plus. C'est pour coller à l'utilisation que j'en ai fait.
		# les appels aux fonctions simulent les event
		self.truc =Enfant()
		self.truc.fonction_enfant()
		self.truc.fonction_enfant2()

Parent()

##### Résultat #######
~$ './test.py' 
depuis fonction_enfant new modifier
depuis fonction_enfant2 new modifier

J'ai branché les event sur un dictionnaire (par moyen de faire sortir les arguments des boutons dans glade3), ce qui permet d'avoir des arguments aux event des boutons. (ca évite de créer une fonction par bouton, comme mon premier exemple).

Il doit sûrement avoir une autre façon de procéder ???

Un morceau de code (en construction). Si vous voyez des trucs qui pique les yeux, ou des façons plus mieux, n'hésitez pas !

#! /usr/bin/env python
# -*- coding:Utf8 -*-
import os.path, os
import gtk, subprocess
import gtk.glade

path_fichier =os.environ['_']
path_dossier = os.path.dirname(path_fichier)
#os.chdir(path_dossier)

dic_chaine ={'france_2':'France 2','france_3':'France 3','france_4':'France 4',
		'france_5':'France 5','arte':'Arte','direct_8':'Direct 8','nt1':'NT1',
		'nrj12':'NRJ 12','bfm_tv':'BFM TV','lcp':'LCP' }

class GladeHandlers:
	def choix(self,widget,name,arg):
		nom =dic_chaine[arg]
		self.end_add =arg
		widgets['label1'].set_text(nom)
		print cmd_add+add_stream+self.end_add+null
		print cmd_vide
		#os.system(cmd_vide)
		#os.system(cmd_add+add_stream+self.end_add+null)
		
	def check_rec(self, widget):
		print self.end_add, widget
			
		
class WidgetsWrapper:
	def __init__(self):	
		branche =GladeHandlers()
		dic ={"france2":(branche.choix, self, 'france_2'),
		      "france3":(branche.choix, self, 'france_3'),
		      "france4":(branche.choix, self, 'france_4'),
		      "france5":(branche.choix, self, 'france_5'),
		      "arte":(branche.choix, self, 'arte'),
		      "direct8":(branche.choix, self, 'direct_8'),
		      "nt1":(branche.choix, self, 'nt1'),
		      "nrj12":(branche.choix, self, 'nrj12'),
		      "bfm":(branche.choix, self, 'bfm_tv'),
		      "lcp":(branche.choix, self, 'lcp'),	      
		      "check_rec":branche.check_rec}
		path_gui =path_dossier+'/pctv.glade'
		self.widgets = gtk.glade.XML(path_gui, "window1")
		#self.widgets.signal_autoconnect(GladeHandlers.__dict__)
		self.widgets.signal_autoconnect(dic)
	
	def __getitem__(self, key):
        	return self.widgets.get_widget(key)
   	
	def boucle(self):
		gtk.main() 


if __name__ == '__main__':
    widgets = WidgetsWrapper()
    widgets.boucle()
   # os.kill(pid, 3)

Je suis prêt pour les tomates

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 26/02/2010, à 23:16