Code: Alles auswählen
class Test:
def __init__(self, x, y, z):
self.x=x
self.y=y
self.z=z
@property
def p1(self):
return self.x*self.y*self.z
@property
def pn(self)
....
Code: Alles auswählen
class Ship:
def __init__(self, length, width, depth, masts, name="Nameless Ship"):
self.length=length
self.width=width
self.depth=depth
self.masts=masts
self.name=name
@property
def tonnage(self):
return round((self.length*self.width*self.depth)/3)
@property
def capacity(self):
return round(self.tonnage*2/3)
@property
def crew(self):
return divmod(self.tonnage, 10)[0] + self.masts*10
def print_stats(self):
print('Name: {0}'.format(self.name))
print('Länge: {0}'.format(self.length))
print('Breite: {0}'.format(self.width))
print('Tiefgang: {0}'.format(self.depth))
print('Masten: {0}'.format(self.masts))
print('Schiffsraum: {0}'.format(self.tonnage))
print('Frachtraum: {0}'.format(self.capacity))
print('Mannschaft: {0}'.format(self.crew))
Code: Alles auswählen
#So verwende ich es:
>>> ship = Ship(20,6,2,3)
>>> ship.crew
38
>>> ship.tonnage
80
#Und so würde ich es gerne optinal auch verwenden können:
>>> ship.crew(80,2)
Nö, Du kannst ja die Logik in eine *Funktion* schreiben, die Du in der Property lediglich aufrufstnezzcarth hat geschrieben: Ich würde jetzt gerne ein Property wie z.B. 'crew' zusätzlich optional auch wie eine 'normale' Funktion mit Parametern aufrufen können. Ich könnte natürlich auch eine eigene Funktion dafür schreiben, hätte aber eine Codeverdoppelung.
Code: Alles auswählen
:class Ship:
: def __init__(self, length, width, depth, masts, name="Nameless Ship"):
: self.length=length
: self.width=width
: self.depth=depth
: self.masts=masts
: self.name=name
:
: @property
: def tonnage(self):
: return tonnage(self.length, self.width, self.depth)
:
:def tonnage(length, width, depth):
: return (length * width * depth) / 3
:
:--
In [21]: s = Ship(60, 20, 10, 3)
In [22]: s.tonnage
Out[22]: 4000.0
In [23]: tonnage(60, 20, 10)
Out[23]: 4000.0Was sollen diese Parameter denn machen? Möchtest du unabhängig von einer konkreten Instanz Werte für tonnage und masts übergeben können?nezzcarth hat geschrieben:Ich würde jetzt gerne ein Property wie z.B. 'crew' zusätzlich optional auch wie eine 'normale' Funktion mit Parametern aufrufen können.
Ui... das ist mal ein starkes Kompliment, danke dafür/me hat geschrieben: Edit: Falls das gewünscht ist, dann ist BlackJacks Vorschlag die gewünschte Lösung.
Code: Alles auswählen
@property
def crew(self):
return self.tonnage // 10 + self.masts * 10Ja, das war gemeint. Mir war erst nach dem abschicken klar, dass da ein Beispiel nötig wäre, das ich dann noch reineditiert hatte./me hat geschrieben:Was sollen diese Parameter denn machen? Möchtest du unabhängig von einer konkreten Instanz Werte für tonnage und masts übergeben können?nezzcarth hat geschrieben:Ich würde jetzt gerne ein Property wie z.B. 'crew' zusätzlich optional auch wie eine 'normale' Funktion mit Parametern aufrufen können.
Edit: Falls das gewünscht ist, dann ist BlackJacks Vorschlag die gewünschte Lösung.
Ich hatte ja irgendwie gehofft, dass das vielleicht noch leichter geht, also, dass man das irgendwie über )Code: Alles auswählen
class Ship:
def __init__(self, length, width, depth, masts, name="Nameless Ship"):
self.length=length
self.width=width
self.depth=depth
self.masts=masts
self.name=name
@staticmethod
def _tonnage(length, width, depth):
return (length * width * depth) / 3
@property
def tonnage(self):
return self._tonnage(self.length, self.width, self.depth)
Da spricht prinzipiell nichts dagegen (außer, dass man den Underscore nach *hinten* setzen sollte. Denn vorne haben sie per Konvention die Bedeutung einer *internen* Methode, die nicht öffentlich verwendet werden sollte), aber dann hast Du natürlich einen eher hässlichen Methodenaufrufnezzcarth hat geschrieben: Kann/sollte man das so machen, oder eher nicht?
Code: Alles auswählen
class TestShip:
def __init__(self, length, width, depth, masts, name="Nameless Ship"):
self.length=length
self.width=width
self.depth=depth
self.masts=masts
self.name=name
@staticmethod
def tonnage(length, width, depth):
return round((length*width*depth)/3)
@staticmethod
def capacity(tonnage):
return round(tonnage*2/3)
@staticmethod
def crew(tonnage, masts):
return tonnage//10 + masts*10
def __getattr__(self, name):
if name.startswith('get_'):
_, method_name = name.split('_', maxsplit=1)
method = getattr(self, method_name)
parameters = []
if not method:
raise AttributeError
for var in method.__code__.co_varnames:
try:
parameters.append(self.__dict__[var])
except KeyError:
t = getattr(self, 'get_'+ var)
parameters.append(t)
return method(*parameters)
Code: Alles auswählen
>>> ship = TestShip(20,5,3,2)
>>> ship.print_stats()
Name: Nameless Ship
Länge: 20
Breite: 5
Tiefgang: 3
Masten: 2
Schiffsraum: 100
Frachtraum: 67
Mannschaft: 30
>>> ship.get_tonnage
100
>>> ship.tonnage(20,5,3)
100
Du willst ja offenbar Berechnungen *ohne* Exemplar einer Klasse durchführen, oder nicht?