[Python] classes et variables

Programmation
#1

Bonjour je n’arrive pas à accéder à une variable d’une classe.
Voici le code:

[code]#!/usr/bin/python

-- coding: utf-8 --

from Tkinter import *
from time import sleep
import threading

class Coucou(threading.Thread):

def __init__(self):
    threading.Thread.__init__(self)
    self.encore = True

def run(self):
    while self.encore:
        print("interruption")
        Toto.a = 0
        sleep(20)

def stop(self):
    self.encore = False

class Toto(threading.Thread):

def __init__(self):
    threading.Thread.__init__(self)
    self.encore = True

def run(self):
    self.a = 0
    while self.a != 10 and self.encore:
        chaine="a = " + str(round(self.a*10, 5))
        if self.a < 6:
            self.a = round(self.a + 0.01, 5)
            app.label1.config(text=chaine)
            sleep(0.1)
        else:
            self.a = round(self.a + 0.01, 5)
            app.label1.config(text=chaine)
            sleep(1)

def stop(self):
    self.encore = False

class Pwm(Frame):

def __init__(self, master):
    Frame.__init__(self, master)
    self.creer_applets()

def creer_applets(self):
    self.label1 = Label(fen, text="a = 0")
    self.label1.pack(fill=X, side=TOP)
    self.bouton1 = Button(fen, text="Lancer", command=lambda:self.deb_pwm())
    self.bouton1.pack(fill=X, side=TOP)
    self.bouton2 = Button(fen, text="Arrêt", command=lambda:self.fin_pwm())
    self.bouton2.pack(fill=X, side=TOP)
    self.bouton4 = Button(fen, text="Quitter", command=self.aurevoir)
    self.bouton4.pack(fill=X, side=TOP)

def deb_pwm(self):
    self.toto = Toto()
    self.toto.setDaemon(True)
    self.toto.start()
    self.coucou = Coucou()
    self.coucou.setDaemon(True)
    self.coucou.start()

def fin_pwm(self):
    self.toto.stop()
    self.coucou.stop()

def aurevoir(self):
    fen.destroy()

if name == ‘main’:
fen = Tk()
app = Pwm(fen)
fen.mainloop()

[/code]

La variable que je souhaite modifier est “a” qui est dans la classe Coucou. J’ai indiqué l’endroit critique par des dièses; comme tel, ce n’est manifestement pas la bonne façon d’accéder à cette variable (Toto.a).
Est ce quelqu’un aurait une idée, car ça fait un moment que je tourne en rond.
Merci les pythonistas.

#2

Voici un exemple fonctionnel:

[code]#!/usr/bin/python

class Toto:
a = 5

class Coucou(Toto):
def blabla(self):
Toto.a = 50

print Toto.a
Coucou().blabla()
print Toto.a[/code]
print Toto.a <— affiche 5
Coucou().blabla() <— modifie a 5 à a 50
print Toto.a <— affiche 50

Je connais pas le python, et pas les modules installer pour tester, mais je penses que tu dois:
1- ajouter Toto dans le () de Coucou
2- ajouter une variable a dans Toto (ne connaissant pas python, self.a = 0 dans run devrait peut-être faire l’affaire)
Le reste devrait fonctionner je penses.

#3

Bonjour charette,

Dans la doc Python, il est écrit :

La proposition faite par kripteks est pleinement valide.
Pour accéder à la variable a de la classe Coucou, tu dois indiquer, dans la classe Toto où trouver ladite variable a.

... self.a = 0 ...
devient

... self.Coucou.a = 0 ...
etc.

A+

#4

Ce code n’a aucun sens en programmation objet.

“a” est une variable d’instance d’un objet de la classe Toto qui est déclarée lors de l’appel de la méthode run()
L’expression “Toto.a” dans la méthode run() de la classe Coucou cherche à accéder à une variable de classe sur la classe Toto (qui n’existe donc pas vu que c’est une variable d’instance)
Il faut donc instancier un objet de la classe Toto et lui faire exécuter la méthode run() pour que la variable “a” soit accessible.

toto = Toto()
toto.run()
toto.a = 0

Ceci étant je doute que ça fasse le fonctionnement attendu…

#5

Je suis d’accord avec lroy sauf sur :

[quote=“lroy”]Ce code n’a aucun sens en programmation objet.

Qui peut avoir du sens dans les langages qui permettent de déclarer une classe dans une classe.

#6

Je veux bien un exemple de langage ou j’accède à une classe interne d’une classe par son pointeur d’instance.
MaClasse.MaClasseInterne.foo je veux bien (et encore, uniquement à l’intérieur de MaClasse), mais instanceDeMaClasse.MaClasseInterne.foo ça me paraît foireux. :slightly_smiling:

#7

Merci à tous pour vos réponses.

J’ai réussi à résoudre ce “problème” en faisant:

[code]class Coucou(threading.Thread):

def __init__(self, att):
    threading.Thread.__init__(self)
    self.encore = True
    self.toto = att[/code]

Puis dans def deb_pwm(self):, j’ai mis:
self.coucou = Coucou(self.toto)

ensuite, j’ai pu appeller ma variable grâce à self.toto.a

Merci à tous.

#8

[quote=“lroy”]Je veux bien un exemple de langage ou j’accède à une classe interne d’une classe par son pointeur d’instance.
MaClasse.MaClasseInterne.foo je veux bien (et encore, uniquement à l’intérieur de MaClasse), mais instanceDeMaClasse.MaClasseInterne.foo ça me paraît foireux. :slightly_smiling:[/quote]
En Java tu peut très bien déclarer ça :

public class Foo { public class Bar { } }
Comme Bar n’est pas static elle est dépendante des instances de Foo.
Mais je suis d’accord que déclarer une inner class non static n’est jamais utile.

#9

[quote=“MisterFreez”]Comme Bar n’est pas static elle est dépendante des instances de Foo.
Mais je suis d’accord que déclarer une inner class non static n’est jamais utile.[/quote]
Juste pour mon édification personnelle, vu que je ne connais pas Java…
Un objet d’une classe “non static” contient toujours un pointeur implicite vers l’instance de son parent qui l’a instancié, c’est ça ?
Un peu comme si en C++ on passait [mono]this[/mono] (le parent) au constructeur de l’enfant ?

#10

[quote=“MisterFreez”]En Java tu peut très bien déclarer ça :

public class Foo { public class Bar { } }
Comme Bar n’est pas static elle est dépendante des instances de Foo.
Mais je suis d’accord que déclarer une inner class non static n’est jamais utile.[/quote]
Oui, je suis à peu près d’accord (je suis développeur Java :wink: ) sauf que tu ne pourras toujours jamais écrire this.Bar ou myFoo.Bar où que tu sois dans le code :wink:
Donc je persiste (je suis têtu :blush: ) self.Coucou.a ou this.Bar.qux n’a pas de sens.
Sinon le “public” est à priori inutile sur une inner class, c’est static, private ou rien.

#11

J’avoue ne pas l’avoir essayé :blush:
Mais techniquement une classe est une instance de java.lang.Class, donc je ne vois pas ce qui empêche d’avoir une référence vers une classe. Ce sont plus des limitation syntaxiques qu’autre chose.

#12

bonjour

Est ce que vous savez ou je peux trouver un tuto “claire” sur les classes en python?

#13

[quote=“lroy”]Je veux bien un exemple de langage ou j’accède à une classe interne d’une classe par son pointeur d’instance.
MaClasse.MaClasseInterne.foo je veux bien (et encore, uniquement à l’intérieur de MaClasse), mais instanceDeMaClasse.MaClasseInterne.foo ça me paraît foireux. :slightly_smiling:[/quote]

En python c’est possible.
Attention je ne dis pas que ce code peut-être utile (je n’ai jamais eu besoin d’écrire ce genre de code jusqu’à présent), mais impossible, non.

Python 2.6.1 (r261:67515, Jun 24 2010, 21:47:49) 
[GCC 4.2.1 (Apple Inc. build 5646)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> class A(object):
...     def __init__(self):
...         class Coucou(object):
...             pass
...         self.Coucou = Coucou
... 
>>> a = A()
>>> a.Coucou
<class '__main__.Coucou'>
>>>
>>> # une autre manière de l'écrire
>>> class A(object):
...     def __init__(self):
...         self.Coucou = type("Coucou", (object,), dict())
... 
>>> a = A()
>>> a.Coucou
<class '__main__.Coucou'>

En python tout est objet, y compris les classes qui sont des instances de classes “Metaclass” (la métaclasse par défaut est “type”)

edit:

[quote=“limax”]bonjour

Est ce que vous savez ou je peux trouver un tuto “claire” sur les classes en python?[/quote]

Si tu ne cherches pas un tuto sur la POO en général, mais bien sur les classes en python, et que tu n’as pas peur de l’anglais, je trouve la doc officielle sur le sujet très claire.
Python 2 : docs.python.org/2/tutorial/classes.html