Quoi de plus rapide qu'un dictionnaire ?
Salut,
Voilà, par simple curiosité, j'ai comparé 3 classes équivalentes (une dérivée de ctypes.Structure avec bit_field, une autre classique dérivée de object et possedant un __slots__ et enfin une faite en pyrex compilé), une liste et un dico.
Code de la classe en pyrex :
Code:
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
| cdef class Case:
cdef int _walkable,_explodable,_stuntable
cdef object parent
def __cinit__(self,int w, int e, int s, parent=None):
self._walkable=w
self._stuntable=s
self._explodable=e
self.parent=parent
property walkable:
def __get__(self):
if self._walkable:
return True
else:
return False
def __set__(self,value):
if value:
self._walkable=1
else:
self._walkable=0
def __del__(self):
pass
property explodable:
def __get__(self):
if self._explodable:
return True
else:
return False
def __set__(self,value):
if value:
self._explodable=1
else:
self._explodable=0
def __del__(self):
pass
property stuntable:
def __get__(self):
if self._stuntable:
return True
else:
return False
def __set__(self,value):
if value:
self._stuntable=1
else:
self._stuntable=0
def __del__(self):
pass |
le code des deux autres classes (ct=ctypes):
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
| class Case(ct.Structure):
_fields_=[("walkable",ct.c_ushort,1),
("explodable",ct.c_ushort,1),
("stuntable",ct.c_ushort,1),
("parent",ct.py_object)]
class Case2(object):
__slots__=tuple('walkable stuntable explodable parent'.split())
def __init__(self,w=0,e=0,s=0,p=None):
self.walkable=w
self.explodable=e
self.stuntable=s
self.parent=p |
La fonction time utilisée dans le code ci-après est une fonction qui execute la liste de blocs textes passée en paramètre et retourne un tuple des temps d'execution de chaque bloc, et pp=pprint.pprint
Code:
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
| a=Case(0,0,0)
b=Case2(0,0,0)
c=C_case.Case(0,0,0)
d=[0,0,0,0]
e={'walkable':0,'explodable':0,'stuntable':0,'parent':None}
codes=[
'''for x in range(1000):
if a.walkable: a.walkable=0
else: a.walkable=1''',
'''for x in range(1000):
if b.walkable: b.walkable=0
else: b.walkable=1''',
'''for x in range(1000):
if c.walkable: c.walkable=0
else: c.walkable=1''',
'''for x in range(1000):
if d[0]: d[0]=0
else: d[0]=1''',
'''for x in range(1000):
if e['walkable']: e['walkable']=0
else: e['walkable']=1''']
tab=[time(codes) for x in range(500)]
res=[]
for x in range(len(tab[0])):
res+=[sum(y[x] for y in tab)/len(tab)]
pp(res) |
et voici les résultats :
Code:
1
2
3
4
5
6
7
| >>>
[0.00037558209962526237, # module ctypes
0.00032265495207911955, # classique
0.00028882434114848367, # pyrex
0.00024732920097676471, # liste
0.00024037783677704282] # dico
>>> |
Et ma question est la suivante : connaissez-vous un moyen d'obtenir une classe (ou autre objet, même si j'ai une préférence pour les classes...) plus rapide qu'un dico ou une liste (je deteste ecrire les "[]" et encore plus les "['']" :roll:) ?
