Domanda
Questo è un codice che ho trovato su internet. Non sono sicuro di come si è pensato per essere utilizzato. Ho semplicemente riempito membri con l'enum chiavi / valori e funziona, ma sono curioso di cosa si metaclasse è tutto. Io parto dal presupposto che abbia qualcosa a che fare con ctypes, ma non riesco a trovare molte informazioni sul ctypes sottoclasse. So EnumerationType non sta facendo nulla il modo in cui sto usando Enumeration.
from ctypes import *
class EnumerationType(type(c_uint)):
def __new__(metacls, name, bases, dict):
if not "_members_" in dict:
_members_ = {}
for key,value in dict.items():
if not key.startswith("_"):
_members_[key] = value
dict["_members_"] = _members_
cls = type(c_uint).__new__(metacls, name, bases, dict)
for key,value in cls._members_.items():
globals()[key] = value
return cls
def __contains__(self, value):
return value in self._members_.values()
def __repr__(self):
return "<Enumeration %s>" % self.__name__
class Enumeration(c_uint):
__metaclass__ = EnumerationType
_members_ = {}
def __init__(self, value):
for k,v in self._members_.items():
if v == value:
self.name = k
break
else:
raise ValueError("No enumeration member with value %r" % value)
c_uint.__init__(self, value)
@classmethod
def from_param(cls, param):
if isinstance(param, Enumeration):
if param.__class__ != cls:
raise ValueError("Cannot mix enumeration members")
else:
return param
else:
return cls(param)
def __repr__(self):
return "<member %s=%d of %r>" % (self.name, self.value, self.__class__)
And an enumeration probably done the wrong way.
class TOKEN(Enumeration):
_members_ = {'T_UNDEF':0, 'T_NAME':1, 'T_NUMBER':2, 'T_STRING':3, 'T_OPERATOR':4, 'T_VARIABLE':5, 'T_FUNCTION':6}
Soluzione
Una metaclasse è una classe utilizzata per creare le classi. Pensare in questo modo:. Tutti gli oggetti hanno una classe, una classe è anche un oggetto, quindi, ha senso che una classe può avere una classe
http://www.ibm.com/developerworks/linux /library/l-pymeta.html
Per capire cosa questo sta facendo, si può guardare ad alcuni punti del codice.
_members_ = {'T_UNDEF':0, 'T_NAME':1, 'T_NUMBER':2, 'T_STRING':3, 'T_OPERATOR':4, 'T_VARIABLE':5, 'T_FUNCTION':6}
globals()[key] = value
Qui ci vuole ogni chiave definita nel dizionario: "T_UNDEF" "T_NUMBER" e li rende disponibili nel vostro dizionario globals
.def __init__(self, value):
for k,v in self._members_.items():
if v == value:
self.name = k
break
Ogni volta che si effettua un'istanza del enum, si verificherà se il "valore" è nella tua lista di nomi enum ammissibili durante l'inizializzazione della classe. Quando viene trovato il valore, imposta il nome della stringa di self.name.
c_uint.__init__(self, value)
Questa è la linea reale che imposta il "valore ctypes" per un numero intero c reale senza segno.
Altri suggerimenti
Questa è davvero una classe di strano.
Il modo in cui lo si utilizza è corretto, anche se in un altro modo potrebbe essere:
class TOKEN(Enumeration):
T_UNDEF = 0
T_NAME = 1
T_NUMBER = 2
T_STRING = 3
T_OPERATOR = 4
T_VARIABLE = 5
T_FUNCTION = 6
(Questo è quello che i primi 6 linee in __new__
sono per)
Quindi è possibile utilizzare in questo modo:
>>> TOKEN
<Enumeration TOKEN>
>>> TOKEN(T_NAME)
<member T_NAME=1 of <Enumeration TOKEN>>
>>> T_NAME in TOKEN
True
>>> TOKEN(1).name
'T_NAME'
Il metodo from_param
sembra essere per convenienza, per i metodi di scrittura che accettano sia un int o un oggetto Enumeration
. Non proprio sicuro se questo è davvero il suo scopo.
Credo che questa classe è destinato a essere utilizzato quando si lavora con le API esterne enumerazioni uso c-style, ma sembra che un sacco di lavoro per molto poco guadagno.