Discussion :

[shaiHulud]

Bonjour,

Voici une petite classe dont le but est d’être utilisée comme proxy de n'importe quoi. Son but est de "passer partout", i.e ne pas lever d'erreur lorsqu'elle est utilisée à la place de l'objet attendu.

Voyez une fonctionnalité que j'aurais oublié, ou une amélioration quelconque ?
Merci d'avance.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
class PassePartout:
    """Universal Proxy Object"""
    _exemple= None
    def __init__(self): pass
    def __getattr__(self,key):
        if key== "__str__": return "PassePartout"
        if key== "__repr__": return "PassePartout"
        return PassePartout()
    def __setattr__(self,key,value): pass
    def __getitem__(self,key):  return PassePartout()
    def __setitem__(self,key,value):
        pass
    def __str__(self):return "PassePartout"
    def __repr__(self):return "PassePartout"
    def __hash__(self):    
        """same hashcode for every instance"""
        if PassePartout._exemple is None:
            PassePartout._exemple= PassePartout()
        return object.__hash__(PassePartout._exemple)
    def __call__(self,*args,**kwargs): return PassePartout()
    def __nonzero__(self,*args,**kwargs): return True
    def __coerce__(self,other):
        this= None
        if other.__class__== float(1.0).__class__: this= 0.0
        if other.__class__== int(1).__class__: this= 0
        return (this,other)

[PauseKawa]

Bonjour VV33D,

Je ne vois pas trop l'utilité (Un exemple pour me mettre sur la voie ?) mais je me dit que si l'objet est itérable cela risque de durer un moment.

@+

[afranck64]

pourqu'il soit "passe partout" il devra impérativement toujours répondre True à isinstanceof et là...

Si une string me répond True lorsque je demande un Canvas les carottes pourraient bien cuir.

[wiztricks]

Salut

object est déjà là pour çà (ou plutôt qu'ajoute PassePartout à object qui le rende "intéressant")

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
>>> class A: pass
...
>>> a = A()
>>> isinstance(a, object)
True
>>> a
<__main__.A object at 0x025BBE90>
>>> isinstance('bla', object)
True
>>>

Note: je ne dis pas que cela ne sert à rien, juste que je n'ai pas compris à quoi... Je n'ai pas retrouvé un post de Dividee sur un sujet analogue (proxy).

- W

[afranck64]

Mes pensées étaient plutôt:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
partout = PassePartout()
isinstance(partout, str) #True
isinstance(partout, Canvas) #True

ps:
isinstanceof isinstance (Ma lecture de java me monte à la tête )

[dividee]

Je ne comprends pas très bien l'usage moi non plus.
Si c'est un proxy, comment est-il initialisé ? (un proxy renvoie à autre chose).
Si c'est un "trou noir" (un objet qui retourne toujours lui-même, quel que soit l'opération qu'on lui applique), pourquoi ne pas en faire un singleton ?
Pourquoi "return PassPartout()" et pas "return self" ?

[PauseKawa]

Si c'est un proxy, comment est-il initialisé ? (un proxy renvoie à autre chose).

Je pense que pour VV33D c'est _exemple

Pourquoi "return PassPartout()" et pas "return self" ?

C'est cela le trou noir pour moi...

Ce n'est pas un proxy, c'est une 'yes class'

[dividee]

Je pense que pour VV33D c'est _exemple

Si c'était le cas, __getattr__ devrait utiliser _exemple. Le seul endroit où il est utilisé c'est dans __hash__, et là on voit qu'il est initialisé à une instance de PassePartout... Je ne vois pas trop à quoi ça rime...

A quoi cela sert de créer de nouvelles instances alors qu'aucun attribut ne les distinguent ? Est-ce l'histoire du "borg pattern" qui remplace le singleton ? Il me semble que ça n'apporte rien ici.

[PauseKawa]

C'est bien pour cela que je l'appelle une 'yes class': Elle ne fait pas référence au sujet et répond toujours oui.
Je pense qu'il vas falloir attendre des explications de VV33D.

[afranck64]

C'est bien pour cela que je l'appelle une 'yes class': Elle ne fait pas référence au sujet et répond toujours oui.
Je pense qu'il vas falloir attendre des explications de VV33D.

Je suis d'accord pour la "yes/True-class". Mais une chose me trotinne à la tête. Est-il possible de mettre au point une "True-instsnce" class? qui retourne toujours <True> lorsque l'on fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

isinstance(obj, TrueClass)

? Je n'ai pas vu de méthode "magique" genre __isinstance__ permettant de le faire. Est-ce possible?

[PauseKawa]

Bonjour afranck64,

C'est dans la réponse de wiztricks:
(2.x)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class dummy:
    pass
 
myobj = PassePartout()
print(isinstance(dummy, myobj))
print(isinstance(list, myobj))
print(isinstance(dummy, object))
print(isinstance(list, object))

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
True
True
True
True

Il me semble que c'est dans la doc de 'type' ou un Proposal.

Sur ce je retourne à mes occupations (ho, ho, ho) et bonnes fêtes @ll

[PauseKawa]

Bonjour,

@afranck64: J'avais oublier: __instancecheck__ (et __subclasscheck__)

@+

Edit:
Source
(A lire aussi au passage)
Edit pour le lien direct customizing-instance-and-subclass-checks

[afranck64]

: __instancecheck__ (et __subclasscheck__)

Exactement ce à quoi je pensais.

[fred1599]

En fait c'est quoi l'intérêt de cette classe?

Le PO parle de proxy, et si on parle de ce terme, je le vois comme une tour de contrôle (qui sait dire oui mais aussi non) entre deux machines.

Dire oui à tous ne donne plus l'intérêt d'un proxy, je me trompe?

[PauseKawa]

Bonjour fred1599,

Ce n'est pas un proxy car il n'y a pas de référence à l'objet sujet.
Le code semble (je dis semble dans l'absence de réponse du PO, fêtes oblige sans doute) être là pour écraser la référence d'un objet par PassePartout.
C'est effectivement l’intérêt de la chose que nous recherchons.

Si c'est vraiment pour faire de l'universel je trouve cela dangereux.
Comme dit plus haut l’absence de référence fait que cela vas planter à un moment donné (itération, ValueError sur les attributs de la classe remplacée, etc).

Si c'est pour remplacer quelques objets connus alors autant faire un vrais proxy (Explicit is better than implicit)

En Python le programmeur est considéré comme responsable et dans ce sens il lui est donné un grande liberté de tester, même dans des cas bien spéciaux de la machinerie interne: perso j'adore cela.
Je classerais donc cela dans la case expérimental.

@+

Edit: Reste le quizz du return PassePartout()

[fred1599]

Salut PauseKawa

Ce n'est pas un proxy car il n'y a pas de référence à l'objet sujet.

Ah je me disais aussi

J'attend de voir la réponse du PO pour en dire plus...

[PauseKawa]

Bonsoir,

J'attend de voir la réponse du PO pour en dire plus...

Et si on en profitais pour lui répondre au passage ?
15 réponses mais aucune dans le sens de sa question... On n'est pas très bon sur le coup . De plus cela vas nous permettre d'apprendre aussi au passage.

Pour l'itérable que pensez vous de:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
    def __len__(self):
        return 0
 
    len = __len__
 
    def __next__(self):
        raise StopIteration
 
    next = __next__
 
    def __iter__(self):
        return self

?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
myobj = PassePartout()
if len(myobj):
    for e in myobj:
        print(e)
for e in myobj:
    print(e)

Edit:
@VV33D
Ne pense tu pas que c'est plus lisible comme cela ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
class PassePartout:
    """Universal Proxy Object"""
 
    _exemple= None
 
    def __init__(self):
        pass
 
    def __getattr__(self, key):
        if key== "__str__":
            return "PassePartout"
        if key== "__repr__":
            return "PassePartout"
        return PassePartout()
 
    def __setattr__(self, key, value):
        pass
 
    def __getitem__(self, key):
        return PassePartout()
 
    def __setitem__(self, key, value):
        pass
 
    def __str__(self):
        return "PassePartout"
 
    def __repr__(self):
        return "PassePartout"
 
    def __hash__(self):    
        """same hashcode for every instance"""
        if PassePartout._exemple is None:
            PassePartout._exemple= PassePartout()
        return object.__hash__(PassePartout._exemple)
 
    def __call__(self, *args, **kwargs):
        return PassePartout()
 
    def __nonzero__(self, *args, **kwargs):
        return True
 
    def __coerce__(self, other):
        this = None
        if other.__class__== float(1.0).__class__:
            this = 0.0
        if other.__class__== int(1).__class__:
            this = 0
        return (this, other)
 
    def __len__(self):
        return 0
 
    len = __len__
 
    def __next__(self):
        raise StopIteration
 
    next = __next__
 
    def __iter__(self):
        return self
 
 
myobj = PassePartout()
if len(myobj):
    for e in myobj:
        print(e)
for e in myobj:
    print(e)

C'est sans doute une question de goût puisque cela passe avec l'interpréteur mais bon... import this.

@+

[fred1599]

Et si on en profitais pour lui répondre au passage ?

Oui je veux bien, c'est le principe du forum, mais je ne suis pas sûr de comprendre ce qu'il veut dire par proxy.

En fait peux-tu me dire clairement ce qu'il souhaite faire et dans quel cas on doit/peut l'utiliser ? Tu parles de yes-classes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
myobj = PassePartout()
if len(myobj):
    for e in myobj:
        print(e)
for e in myobj:
    print(e)

2 fois les même lignes, on peut pas faire mieux?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
def __len__(self):
        return 0
 
    len = __len__
 
    def __next__(self):
        raise StopIteration
 
    next = __next__
 
    def __iter__(self):
        return self

Euh, j'ai un peu de mal là

len = __len__ est-ce utile?

Si len(objet) donne toujours 0

pourquoi cette condition?

Code PauseKawa :

Sélectionner tout - Visualiser dans une fenêtre à part

if len(myobj):

[PauseKawa]

J'étais à fond sur le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    def __next__(self):
        raise StopIteration
 
    next = __next__

Cela reviens donc à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    def __len__(self):
        return 0
 
    def __next__(self):
        raise StopIteration
 
    next = __next__
 
    def __iter__(self):
        return self

(next = __next__ pour 2.X/3.X)

[fred1599]

D'accord mais PassePartout concrètement représente quoi comme objet?

Car admettons que se soit une yes-classe, ok, il me faut un argument pour dire que je laisse passer tel objet (toujours sur le principe du proxy).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class PassePartout(object):
    def __init__(self, objet):
        self.objet = objet

En plus ce genre de ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

def __getitem__(self,key):  return PassePartout()

Berk!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
def __getitem__(self, key):
    if isinstance(objet, dict):
        if key not in self.objet:
            return 1
        else:
            return self.objet[key]

Enfin bref le PO ne respecte pas la PEP 8 comme tu le soulignes le post précédent, mais en plus les concepts de la POO.

On ne peut pas faire de POO sur des objets inconnus, étant donné qu'une classe est le patron d'un objet.

On pourrait parler de tunnel, mais là encore le contrôle des objets doit être précis, et bien plus complexe que de simples pass.