Code: Alles auswählen
class A:
def __init__(self, wert):
self.a = wert
for i in range(10):
a=A(i)Code: Alles auswählen
class A:
def __init__(self, wert):
self.a = wert
Liste=[]
for i in range(10):
a=A(i)
Liste.append(a)
print Liste
Code: Alles auswählen
liste = [A(i) for i in xrange(10**7)]Ich dachte eher daran, dass sie ja eindeutig definiert sind durch ihren Wert. Ich müsste evtl. noch erwähnen, dass ich mit meiner Klasse einen Baum erstelle, also haben die Objekte (Knoten) Beziehungen untereinander.numerix hat geschrieben:Wenn du auf 10⁷ Elemente zugreifen willst, dann musst du sie zwangsläufig irgendwo vorrätig halten - eine Liste könnte da schon richtig sein.
Du nutzt die Klasse später hoffentlich nicht nur, um einen einzigen Wert abzulegen?
numerix hat geschrieben:
Schneller als mit append geht es mittels list comprehension.
Außerdem kannst du statt range xrange verwenden, das ist für 10⁷ auch schneller:
"Liste" ist übrigens ein schlechter Name ("liste" auch ...).Code: Alles auswählen
liste = [A() for _ in xrange(10**7)]
Zahl der Objekte: ich erstelle einen Baum mit sehr vielen Blättern.jbs hat geschrieben:Was verstehst du unter langsam und warum brauchst du so viele Objekte?
Hast du dir numpy angeschaut?
Wenn man "Namen" etwas allgemeiner fast: Nein.legargeomatrix hat geschrieben:Nochmal meine Frage: kann ich auf erstellte Objekte zugreifen, wenn sie keinen eindeutigen Namen haben (oder alle gleich heißen)?
Könnte man evtl. Namen "künstlich" herstellen, in dem man in die Schleife einen variablen Namen gibt, z.B. in der Form eines Indizes? Also anstatt die Objekte in eine Liste ablagern, sie einfach mit dem entsprechenden indiz aufrufen, z.B. mit a0, a1, a2... anstatt liste[0], liste[1] etc. Wäre das überhaupt schneller?numerix hat geschrieben: Wenn man "Namen" etwas allgemeiner fast: Nein.
Wenn du 10 Instanzen deiner Klasse erzeugst und sie alle an den Namen a bindest, dann kannst du auf die ersten 9 Instanzen über diesen Namen nicht mehr zugreifen.
Wenn du sie in einer Liste ablegst, haben sie zwar keinen Namen im engeren Sinne, aber über die Indizes hast du eben Zugriff.
Ja, könntest du diese Datenstruktur nennt sich Dictionary oder Map. Schneller ist das natürlich nicht. Da ist die Liste schon am schnellsten.legargeomatrix hat geschrieben:Also anstatt die Objekte in eine Liste ablagern, sie einfach mit dem entsprechenden indiz aufrufen, z.B. mit a0, a1, a2... anstatt liste[0], liste[1] etc. Wäre das überhaupt schneller?
Code: Alles auswählen
l = [None]*10000000
for i in len(l):
l[i] = A(i)Code: Alles auswählen
l = [objekt_mit_kompliziertem_verfahren_erzeugen(i) for i in xrange(1000000)]Code: Alles auswählen
from time import clock
class A(object):
__slots__ = ["i"]
def __init__(self, i):
self.i = i
l = []
t = clock()
for x in xrange(1000000):
l.append(A(x))
print clock() - t
Was macht den genau slots, und warum ist das so viel schneller?HerrHagen hat geschrieben:Das wär doch mal ne Verwendung für __slots__. Ich habs mal ausprobiert:
Mit slots braucht das ca. 2,7s, ohne 8s. Außerdem wird nur 1/4 des Speichers gebraucht.
Allerdings glaube ich das eine "normale" Datenstruktur (ohne Verwendung von Klassen) am effizientesten wäre. Hat deine Klasse noch irgendwelche Funktionen an sich gebunden, die die Verwendung unbedingt sinnvoll machen? Wenn nein dann solltest du vielleicht alles in einer Liste/Dict abspeichern. Schachteln kannst du auch diese.
Code: Alles auswählen
class Knoten(object):
"""Knoten-Klasse fuer die Knoten des Spielbaums"""
def __init__(self, stellung, vater, tiefe):
self.stellung = stellung
#die Tiefe entspricht der Runde, in der der Knoten gespielt wurde
self.tiefe = tiefe
self.kinder = []
self.vater = vater
self.bewertung = None
self.blatt = False
#ersetzt del self, denn die pointers muessen entfernt werden
def delete(self, spielbaum):
Knoten.get_vater(self).kinder.remove(self)
self.kinder = []
spielbaum.remove(self)
return spielbaum
def set_bewertung(self, bewertung):
self.bewertung = bewertung
def set_tiefe(self,tiefe):
self.tiefe = tiefe
def set_kind(self, kind):
self.kinder.append(kind)
def set_blatt(self):
self.blatt = not self.blatt
def ist_blatt(self):
return self.blatt
def get_bewertung(self):
return self.bewertung
def get_vater(self):
return self.vater
def get_stellung(self):
return self.stellung
def get_tiefe(self):
return self.tiefe
def get_kinder(self):
return self.kinder
Code: Alles auswählen
class Foo(object):
def __init__(self, name):
self.name = name
f = Foo("Hyperion")
f.name = "Chris"
print f.name
Ja, dass es auch ohne geht ist mir klar, doch das Projekt wird auch dazu dienen, OOP zu unterrichten, darum die strikte OOP-Schreibweise.Hyperion hat geschrieben:Kommst Du aus der Java-Welt oder hast Dich am Open Book von Galileo orintiert? Diese ganzen getter und setter sind absolut unnötig in Python und dazu noch un-pythonisch. Man kann auf die Attribute eines Objektes auch direkt zugreifen.
Also: Weg mit dem ganzen Kram
Was haben denn getter und setter mit OOP zu tun? *wunder*legargeomatrix hat geschrieben: Ja, dass es auch ohne geht ist mir klar, doch das Projekt wird auch dazu dienen, OOP zu unterrichten, darum die strikte OOP-Schreibweise.
legargeomatrix hat geschrieben:Ja, dass es auch ohne geht ist mir klar, doch das Projekt wird auch dazu dienen, OOP zu unterrichten, darum die strikte OOP-Schreibweise.
Meine Güte, dann Pack halt noch nen xrange ums len.numerix hat geschrieben:@Darii: Dein gezeigter Code ist gar nicht lauffähig ...
Interessant woran das vorhin lag, bei mir kamen vorhin 10 Sek raus, jetzt ist es gleich, muss das morgen nochmal prüfen. Ehrlich gesagt erstaunt es mich, dass append so schnell ist.Aber im Ernst: "massiv schneller" wird das dadurch nicht.
Der Flaschenhals ist hier auch nicht das Befüllen oder Anhängen an die Liste, sondern die vielen Instanzbildungen.
Code: Alles auswählen
import numpy
t = clock()
f1 = [None] * 1000000
for i in xrange(1000000):
f1[i] = i
print clock() - t
t = clock()
f2 = []
for i in xrange(1000000):
f2.append(i)
print clock() - t
t = clock()
f3 = numpy.empty(1000000)
for i in xrange(1000000):
f3[i] = i
print clock() - tCode: Alles auswählen
0.389669636783
0.550597073092
0.492012252954