Instanzieren einer Klasse soll String zurückgeben

[PeterRRR]

Hallo!

Ich habe folgendes Problem: Ich habe eine Klasse und in dieser Klasse wird eine Zahl berechnet. Die Instanzierung sieht folgendermaßen aus:

Code: Alles auswählen

varName = myClass(50)

In diesem Beispiel wird die übergebene Zahl 50 dann mit 2 multipliziert.

Jetzt soll aber mit:

Code: Alles auswählen

print varName

das Ergebnis der Berechnung ausgegeben werden, also in diesem Fall sollte "100" ausgegeben werden und zwar direkt mit "print varName" und NICHT mit "print varName.berechnung(50)"

Die Funktion für die Berechnung ist vorhanden, das ist nicht das Problem. Es geht rein darum, dass die Instanzierung nicht ein Objekt, sondern eine int-Variable zurückgibt. Wie ist das möglich?

Danke schon im Voraus für jede Hilfe!

Liebe Grüße
Peter

[DasIch]

Die Frage sagt schon aus:"Der Code ist unbrauchbar."

Du solltest höchstwahrscheinlich eine Funktion nehmen. Eine weitere Möglichkeit wäre dass du nur mit der Instanz einer Klasse arbeitest die __call__ implementiert aber besser dürfte sein du zeigst mal den Code. Dann kann man genaueres sagen.

[Y0Gi]

Die Instanziierung einer Klasse sollte immer genau eines zurückgeben: die Instanz.

Die Idee, dass du eine Klasse und ihren Konstruktor zur Multiplikation von Zahlen verwendest, ist schon ziemlich am Zweck von OOP vorbei. Hier ist eine Funktion locker ausreichend.

Aber wie schon erwähnt, zeig' deinen bisherigen Code und beschreibe ausführlicher deine Rahmenbedingungen und dein Vorhaben.

[PeterRRR]

Ich weiß auch, dass das relativ sinnlos ist, aber es ist eben eine Aufgabenstellung, in der das so gefordert ist und ich hab keine Ahnung, wie das funktionieren soll. Auch mit Google finde ich nichts.

Code: Alles auswählen

class malZwei:
	def __init__(self, n):
		self.zahl=n
	
	def berechne(self, number):
		return number*2

ergebnis=malZwei(50)

print ergebnis

Als Ergebnis sollte dann 100 ausgegeben werden, nur was muss ich daran jetzt noch ändern, dass das der Fall ist?

[numerix]

Ich weiß auch, dass das relativ sinnlos ist, aber es ist eben eine Aufgabenstellung, in der das so gefordert ist und ich hab keine Ahnung, wie das funktionieren soll.

Fällt mir schwer das zu glauben.
Kannst du mal den Original-Aufgabentext posten?

Und statt mit google irgendetwas zu suchen: Nimm dir doch mal das Python-Tutorial zur Hand und arbeite das Kapitel über OOP durch (am besten auch die anderen Kapitel). Ziel kann es doch nicht sein, irgendwie einen passenden Code für eine Problemstellung zusammenzubasteln/-suchen, ohne zu verstehen, was hier eigentlich passiert.

[str1442]

Bei dieser Aktion wird implizit die Methode __str__ der Klasse aufgerufen. Wenn du die neu implementierst kannst du dir das Ergebnis anzeigen lassen.

__str__ kennt übringens keine Konvention, also, es kann anzeigen, was du willst.

Es gibt noch eine andere String Methoden __repr__, die dann eine möglichst Python-getreue Darstellung darstellen sollte. Siehe Documention, special Methods oder so.

[PeterRRR]

Dankeschön, str1442!
Genau das war's, jetzt funktioniert es so wie es sollte!

@ numerix:
Der Aufgabentext ist genau so, wie ich es geschrieben habe, da steht nicht anderes drinnen und du kannst es mir ruhig glauben, oder meinst du etwa, ich erfinde irgendwas?

Danke nochmal euch allen für die Hilfe!

Liebe Grüße
Peter

[numerix]

meinst du etwa, ich erfinde irgendwas?

Nein. Aber es kommt ja vor, dass man eine Aufgabe selbst nicht so versteht wie sie gemeint ist, sie unbewusst entsprechend interpretiert und dann die interpretierte Fassung als eigentliche Aufgabe weitergibt. Das wollte ich ausschließen. Aber scheint ja nun geklärt zu sein (was an der sonderbaren Aufgabenstellung nichts ändert).

[numerix]

__str__ kennt übringens keine Konvention, also, es kann anzeigen, was du willst.

Der Versuch, einen int-Wert zurückzuliefern, führt bei mir aber zu einer Fehlermeldung (nämlich der, dass keine Zeichenkette zurückgeliefert wird). Erst wenn ich eine Zeichenkette daraus mache, funktioniert es. Bei __repr__ ebenso. Somit ließe sich das ursprüngliche Problem, wonach laut OP eine "int-Variable" zurückgegeben werden soll, so nicht lösen. Oder übersehe ich was?

[helduel]

Moin,

Klasse von int ableiten, Konstruktor überschreiben, fertig

Code: Alles auswählen

class doubleint(int):
    def __new__(cls, val):
        return int.__new__(cls, val*2)

i = doubleint(2)

Gruß,
Manuel

[Qubit]

Moin,

Klasse von int ableiten, Konstruktor überschreiben, fertig

Code: Alles auswählen

class doubleint(int):
    def __new__(cls, val):
        return int.__new__(cls, val*2)

i = doubleint(2)

Das soll wohl dann auch der Sinn der Aufgabenstellung sein

Geht aber auch so..

Code: Alles auswählen

>>> class MyClass(object):
	def __new__(self,zahl):
		instance = object.__new__(self)
		instance.__init__()
		res = instance.calc(zahl)
		return res
		## return res,instance
	def __init__(self):
		print "init stuff"
	def calc(self,zahl):
		return 2*zahl

	
>>> var=MyClass(50)
init stuff
>>> var
100
>>> 

[str1442]

Der Versuch, einen int-Wert zurückzuliefern, führt bei mir aber zu einer Fehlermeldung (nämlich der, dass keine Zeichenkette zurückgeliefert wird). Erst wenn ich eine Zeichenkette daraus mache, funktioniert es. Bei __repr__ ebenso. Somit ließe sich das ursprüngliche Problem, wonach laut OP eine "int-Variable" zurückgegeben werden soll, so nicht lösen. Oder übersehe ich was?

Ja, es muss bei beidem eine Zeichenkette sein.

Ich meinte, er will / wollte nur Informationen über das Objekt haben, nicht die Daten des Objektes selbst. Für solche Fälle ist __str__ geeignet bzw gedacht.

Wenn er wirklich die Daten selbst haben will, muss er auf Attribute zugreifen. Alles andere macht auch keinen Sinn, denn das Objekt bleibt das Objekt. Die Aufgabe ist also allerhöchstens dann nicht unsinning, wenn es darum geht, zu zeigen, wie man Objekten eine eigene Darstellung geben kann. Alles andere ist imho klarer Missbrauch einer Klassenstruktur.

Alternative wäre, die int Variable, wie von helduel gezeigt, selbst zum Objekt zu machen. Das hat dann aber nichts mehr mit der eigentlichen Aufgabe zu tun und ist auch ansonsten eine eher schlechte Idee. Vorallem "berechnung" passt dann ja überhaupt nicht da mit rein.

[helduel]

...bzw., da soll ja ein String zurückgegeben werden:

Code: Alles auswählen

class doubleint(str):
    def __new__(cls, val):
        return str.__new__(cls, val*2)

i = doubleint(6)

So. Natürlich ist das ganze einfach nur unsinnig .

[derdon]

Ich kanns nicht nur unsinnig machen, ich kann es auch unnötig kompliziert machen

Code: Alles auswählen

In [36]: class Multiplicate(object):
    def __init__(self, num):
        self.num = num
    def __mul__(self, other):
        return self.__class__(self.num * other.num)
    def __str__(self):
        return "%d" % self.num
    __repr__ = __str__
   ....:     
   ....:     

In [44]: a = Multiplicate(5)

In [45]: b = Multiplicate(8)

In [46]: a * b
Out[46]: 40

In [47]: print a * b
40

[Qubit]

...bzw., da soll ja ein String zurückgegeben werden:

Naja, das ist ja nur ein kleiner Schritt

Code: Alles auswählen

>>> class MyClass(object):
    def __new__(self,zahl,typ=int):
        instance = object.__new__(self)
        instance.__init__()
        res = instance.calc(zahl)
        return typ(res)
        ## return res,instance
    def __init__(self):
        print "init stuff"
    def calc(self,zahl):
        return 2*zahl

>>> var=MyClass(50)
init stuff
>>> var
100
>>> var=MyClass(50,str)
init stuff
>>> var
'100'
>>>

[BlackJack]

@derdon: Aber da wird doch gar kein `threading` und keine Bitschiebereien verwendet. Also noch nicht kompliziert genug.

[roschi]

hallo!

wie schon gesagt, diese aufgabenstellung waere totaler schwachsinn...
als funktion ginge das doch viel einfacher:

Code: Alles auswählen

def berechnen(n):
    return n * 2

print berechnen(50)

noch was zu deiner klasse:

Code: Alles auswählen

class malZwei:
    def __init__(self, n):
        self.zahl=n
   
    def berechne(self, number):
        return number*2

warum uebergibst du der methode 'berechne' nochmal eine zahl, wenn du sie doch schon beim instanzieren mit angibst und in den namensraum der klasse packst?
so gehts doch auch:

Code: Alles auswählen

class malZwei:
    def berechne(self, n):
        return n * 2

x = malZwei()
print x.berechne(50)

oder so:

Code: Alles auswählen

class malZwei:
    def __init__(self, n):
        self.zahl = n

    def berechne(self):
        return self.zahl * 2

x = malZwei(50)
print x.berechne()

so musst du die klasse allerdings fuer jede zahl, mit der du arbeiten willst, neu instanzieren.

lg
roschi