Code: Alles auswählen
class foo:
pass
print type(foo())
Code: Alles auswählen
<type 'instance'>
Code: Alles auswählen
from decimal import Decimal
print type(Decimal("1.1"))
Code: Alles auswählen
<class 'decimal.Decimal'>
lg
Code: Alles auswählen
class foo:
pass
print type(foo())
Code: Alles auswählen
<type 'instance'>
Code: Alles auswählen
from decimal import Decimal
print type(Decimal("1.1"))
Code: Alles auswählen
<class 'decimal.Decimal'>
Code: Alles auswählen
foo().__class__.__name__
Code: Alles auswählen
class A(object):
pass
Code: Alles auswählen
class foo(int):
pass
class bar(foo)
pass
x = foo()
y = bar()
# hier nun irgendwas das mit als Rückgabe wert zurückgibt, das bar also
# also als oberste lasse 'int' hat (obwohl von foo geerbt) und das foo mir
# ebenfalls 'int' zurückgibt
...
Code: Alles auswählen
def reverse_value(value):
strval = str(value)[::-1]
if isinstance(value, (str, unicode)):
return strval
elif isinstance(value, (int, long)):
return int(strval)
# stellt euch hier an dieser stelle einfach mal Provokant 50 weitere
# elif Abfragen!
#...
else:
raise TypeError("Der Datentype wird nicht unterstuetzt.")
# In meiner Version werden fast alle relevanten Datentypen
# unterstützt auch abgeleitete. :)
Code: Alles auswählen
def revval(value):
import decimal
hash_table = {
str: 'retval = strval',
unicode: 'retval = strval',
int: 'retval = int(strval)',
long: 'retval = long(strval)',
float: 'retval = float(strval)',
decimal.Decimal: 'retval = Decimal(strval)',+
# usw. usf...z.B. complex...
}
strval = str(value)[::-1]
try:
exec(hash_table[type(value)])
except KeyError:
raise TypeError("Der Datentype wird nicht unterstuetzt.")
return retval
Hi XtraNine!XtraNine hat geschrieben:Ich persönlich finde das dass hier einer der wenigen fälle ist, wo es sinn macht exec() zu benutzen. Wenn was dagegen spricht bitte sagen
Code: Alles auswählen
hash_table = {
str: str,
unicode: unicode,
int: int,
}
retval = hash_table[type(value)](strval)
Code: Alles auswählen
>>> i = 123
>>> old_type = type(i)
>>> s = str(i)
>>> s = s[::-1]
>>> s
'321'
>>> i = old_type(s)
>>> i
321
Code: Alles auswählen
>>> class A(int):
... pass
...
>>> i = A(123)
>>> i
123
>>> old_type = type(i)
>>> old_type
<class '__main__.A'>
>>> s = str(i)[::-1]
>>> i = old_type(s)
>>> i
321
>>> type(i)
<class '__main__.A'>
>>>
Code: Alles auswählen
def reverse_value(value):
type_of_value = type(value)
strval = str(value)[::-1]
if (type_of_value != type(float()) and
type_of_value != type(Decimal())):
return type_of_value(strval)
else:
strval = "-" + strval[:-1]
return type_of_value(strval)
Code: Alles auswählen
x = Decimal("-1234.5")
print type(reverse_value(x))
print reverse_value(x)
Code: Alles auswählen
<class 'decimal.Decimal'>
-5.4321
Hi XtraNine!XtraNine hat geschrieben:Code: Alles auswählen
def reverse_value(value): type_of_value = type(value) strval = str(value)[::-1] if (type_of_value != type(float()) and type_of_value != type(Decimal())): return type_of_value(strval) else: strval = "-" + strval[:-1] return type_of_value(strval)
Code: Alles auswählen
if not isinstance(type_of_value, (float, Decimal)):
Code: Alles auswählen
>>> class A(float):
... pass
...
>>> f = A(123.123)
>>> isinstance(f, float)
True
>>>
Code: Alles auswählen
def reverse_value(value):
type_of_value = type(value)
# Wichtig für unicode strings -> str(u"üäöß") wirft eine exception!!
# Ich erwähne das nur falls die frage kommt...
if isinstance(value, (unicode, str)):
return value[::-1]
else:
strval = str(value)[::-1]
if strval[-1] == '-':
return type_of_value("-" + strval[:-1])
return type_of_value(strval)
import sys , codecs
from decimal import Decimal
stdout_enc = sys.stdout.encoding or sys.getfilesystemencoding()
# if not isinstance(type_of_value, (float, Decimal)):
class foo(Decimal):
pass
# <class '__main__.foo'> 11.4321
x = foo("1234.11")
print type(reverse_value(x)), reverse_value(x)
# <class '__main__.foo'> -11.4321
x = foo("-1234.11")
print type(reverse_value(x)), reverse_value(x)
# <class 'decimal.Decimal'> -11.4321
x = Decimal("-1234.11")
print type(reverse_value(x)), reverse_value(x)
# <type 'int'> 54321
x = 12345
print type(reverse_value(x)), reverse_value(x)
# <type 'str'> bulbalb rabof
x = "fobar blablub"
print type(reverse_value(x)), reverse_value(x)
# <type 'unicode'> ß dnu bülbalb räböf
x = u"föbär blablüb und ß"
print type(reverse_value(x)), reverse_value(x).encode(stdout_enc)
# <type 'int'> -54321
x = -12345
print type(reverse_value(x)), reverse_value(x)
# <type 'long'> -41312111019854321
x = -12345891011121314
print type(reverse_value(x)), reverse_value(x)
# usw.
In dem Fall ist es kein Übung. Das ist eine Funktion die ich benötige. Ich bin gerade dabei eine lib mit kleineren Funktionen zu schreiben, die ich vermisse. Darunter gehört auch ein revers_value für alle relevanten Typen (string, gibts ja schon. aber für integer und Dezimalzahlen, komplexe Zahlen, etc gibt es kein reverse Funktion. Wie benötige aber so eine Funktion.)BlackJack hat geschrieben:Ich verstehe ehrlich gesagt denn Sinn dieser ganzen Übung nicht.
Code: Alles auswählen
print reduce(lambda x, y: x+y, expand_value(12345))
Warum magic? Finde ich nicht. Die Funktion liefert nur einen reversed wert zurücke mehr nicht.BlackJack hat geschrieben: So eine Funktion ist einfach ein bisschen zu "Magic" für meinen Geschmack.
Funktioniert nunBlackJack hat geschrieben: Ach und probier's mal mit einer positiven Fliesskommazahl und einem negativen `int` oder `long`.
Na ja wie gesagt die FUnktion ist noch nicht fertig. Ich will auch komplexe Zahlen und so weiter mit reinnehmen.BlackJack hat geschrieben: Als Krönung dann eine Fliesskommazahl die so klein/gross ist, das die wissenschaftliche Notation mit Exponent zum tragen kommt. Unendlich und "Not A Number" lassen wir mal weg.
reverse_value('- abc')XtraNine hat geschrieben:Mir fällt auf das ich diese isinstance garnicht brauche gerold. Ich hatte ein Denkfehler. Ich überpuffe jetzt direkt ob ein minus vorhanden ist
So etwas gibt es nicht für Zeichenketten sondern für Sequenzen im allgemeinen. Und da ist auch ziemlich klar definiert was für eine Bedeutung es hat. Eine Zahl hat keine Elemente auf die man zugreifen kann, also ist auch erstmal nicht klar was man da überhaupt umdrehen soll/kann. Bei Fliesskommazahlen wird es noch verwirrender. Und warum muss das unbedingt *eine* Funktion sein, die alles kann?In dem Fall ist es kein Übung. Das ist eine Funktion die ich benötige. Ich bin gerade dabei eine lib mit kleineren Funktionen zu schreiben, die ich vermisse. Darunter gehört auch ein revers_value für alle relevanten Typen (string, gibts ja schon. aber für integer und Dezimalzahlen, komplexe Zahlen, etc gibt es kein reverse Funktion. Wie benötige aber so eine Funktion.)BlackJack hat geschrieben:Ich verstehe ehrlich gesagt denn Sinn dieser ganzen Übung nicht.
Was spricht dagegen sum(map(int, str(number))) als Funktion `quersumme` zu definieren?Genauso habe ich einen wert expandierer geschrieben als rekurisven Generator den ich auch benötige. Der funktioniert auhc mit allen relevanten Typen -> 123456 wird zu zB. [1, 2, 3, 4, 5, 6] oder (1, 2, 3, 4, 5, 6) usw. is ja als Generator geschrieben und yielded alles Wozu so eine Funktion? Z.B: dafürDa würde die Quersummen berechnen Es gibt aber ncoh viele weitere Einsatzgebiete wo so ein expander nötig wird.Code: Alles auswählen
print reduce(lambda x, y: x+y, expand_value(12345))
`count()` macht *eine* Sache, die sich ausserdem einfach beschreiben lässt. Und die Funktion wurde nicht einfach so aufgenommen, weil sie vielleicht nützlich sein könnte, sondern weil sie sich sonst sehr viele Leute selbst schreiben würden bzw. vorher schon haben.Naja, was ich damit sagen will ist: Auf den ersten blick erscheint die Funktion reverse_value() und expand_value() keinen wirklichen Sinn zu ergeben, was aber nicht stimmen muss Z.B: ergab sehr lange zeit die unendliche generator count() aus itertolls NULL Sinn für mich, bis du mir ein beispiel gezeigt hast und dann ein licht aufgegangen ist bei mir :bigok:
Und was ist der reversed Wert von -12.34? Und versuch das mal ohne die Zeichenkettenrepräsentation zu beschreiben. Oder reversed von ``Viking()``?Warum magic? Finde ich nicht. Die Funktion liefert nur einen reversed wert zurücke mehr nicht.BlackJack hat geschrieben: So eine Funktion ist einfach ein bisschen zu "Magic" für meinen Geschmack.
Was ist der reversed Wert von `(12+34j)`? Und was für eine Bedeutung hat das? Was ist "und so weiter"? Du schreibst hier eine generische Funktion die haufenweise Typtests benötigt, bei verschiedenen Typen völlig unterschiedliche Bedeutungen hat und einen Anwendungsfall hätte ich auch gerne mal gesehen. Es ist letztendlich doch eine Spielerei.Na ja wie gesagt die FUnktion ist noch nicht fertig. Ich will auch komplexe Zahlen und so weiter mit reinnehmen.BlackJack hat geschrieben: Als Krönung dann eine Fliesskommazahl die so klein/gross ist, das die wissenschaftliche Notation mit Exponent zum tragen kommt. Unendlich und "Not A Number" lassen wir mal weg.
Doch natürlich. `float()` ist ein C `double` und die kennen auch +/- unendlich und "Not A Number".Was meinst du mit "Unendlich und "Not A Number" lassen wir mal weg"? SO was hat doch Python nicht oder doch?
Und bevor Du jetzt denkst, hey 'nan' kann man gefahrlos umdrehen: Die Zeichenketten sind plattformspezifisch. Unter Windows kommt da '#NaN' oder so ähnlich als Zeichenkette heraus.In [51]: infinity = float('%s.0' % ('9' * 500))
In [52]: infinity
Out[52]: inf
In [53]: -infinity
Out[53]: -inf
In [54]: infinity - infinity
Out[54]: nan
Was ist daran überraschend? aus "- abc" wird "cba -" 0o. Falls das eine Anspielung auf strings sein soll, die werden ja vorher abgefangen in Zeile 6, und in 7 returned.reverse_value('- abc')
Das Ergebnis finde ich etwas überraschend.
Ja bei den floats sehe ich gerade das es ein wenig strange ist. Werde ich ändern(?). was meinst du mit ->> *eine* <<- warum diese Hervorhebung? Ich verstehe deine frage nicht? Ihr wart doch die jenigen die sagen "Duck-Typing" ist tool ich versuche gerade dem gerecht zu werden in dem ich eine einfache Funktion schreibe die einfach etwas umdreht. Dabei spielt es keine roll ob es eine Zahl ist, oder eine Zeichenkette, oder eine Decimal Zahl (complex lasse ich weg. mach mMn keine Sinn.). Ich würde gerne eine Begründung wissen weshalb du gerade diese Funktion überflüssig findest?Bei Fliesskommazahlen wird es noch verwirrender. Und warum muss das unbedingt *eine* Funktion sein, die alles kann?
Was sprich außer, dieses Beispiel, gegen die Funktion expand_value()? Braucht man das nicht das man 12985764 als [1,2,9,8,5,7,6,4] hat oder 1.234 als [1,'.',2,3,4].Was spricht dagegen sum(map(int, str(number))) als Funktion `quersumme` zu definieren?
-> -43.21. Es wird einfach die Zahl umgedreht. Ich weiß nicht worauf du hinaus willst...Und was ist der reversed Wert von -12.34? Und versuch das mal ohne die Zeichenkettenrepräsentation zu beschreiben.
was ist wiking?Oder reversed von ``Viking()``?
Nö nicht wirklich. complexe lasse ich weg weil sinnfrei. Unterstützt werden Ganze zahlen, Decimal, float, str, unicode und alles was sich wie eine Zahl, Zeichenkette, oder eine Decimalzahl verhält. Bei allen dem wird das gleiche gemacht und zwar der Wert umgedreht. Mehr nicht...bei verschiedenen Typen völlig unterschiedliche Bedeutungen hat und einen Anwendungsfall hätte ich auch gerne mal gesehen
Nein, deine Funktion macht nun eigentlich abhängig vom *Typ* etwas anderes. "When it quacks like a duck, then it has to be a duck" - Du testest aber ob es eine Gans ist, eine Ente, ein Schwan und machst je nach dem etwas anderes.XtraNine hat geschrieben:was meinst du mit ->> *eine* <<- warum diese Hervorhebung? Ich verstehe deine frage nicht? Ihr wart doch die jenigen die sagen "Duck-Typing" ist tool
Du machst mehr oder weniger Overloading: Wenn der Funktion ein Int gegeben wird, machst sie etwas, wenn ein Decimal, dann etwas anderes. Das ist nicht Duck typing, das ist Overloading. Es gibt von PJE sogar einen Code der Overloading in Python ermöglicht.XtraNine hat geschrieben:ich versuche gerade dem gerecht zu werden in dem ich eine einfache Funktion schreibe die einfach etwas umdreht. Dabei spielt es keine roll ob es eine Zahl ist, oder eine Zeichenkette, oder eine Decimal Zahl (complex lasse ich weg. mach mMn keine Sinn.).
[5, 4, 3, 2, 1] Aber Decimal("-1234.11") wäre reversed 11.4321- (du machst eine Sonderbehandlung für das Minus-Zeichen, was ich nicht ganz verstehen. Ich sehe den sinn von so einer Funktion auch nicht, die ganz und gar seltsame und unvorherrsehbare Dinge macht.XtraNine hat geschrieben:reverse_value = Drehe die zahl, zeichenkette von rechts nach links um.
Gegen frage: Was ist [1, 2, 3, 4, 5] reversed(?)
Viking() ist eine Instanz der Viking-Klasse.XtraNine hat geschrieben:was ist wiking?Oder reversed von ``Viking()``?
Nein, bei einem String kannst du den Wert nicht umdrehen, weil ein String per-se keinen Wert hat? Was ist der Wert von "Heiligenschein"? 36? Und umgedreht dann -36?XtraNine hat geschrieben:Unterstützt werden Ganze zahlen, Decimal, float, str, unicode und alles was sich wie eine Zahl, Zeichenkette, oder eine Decimalzahl verhält. Bei allen dem wird das gleiche gemacht und zwar der Wert umgedreht. Mehr nicht...
Code: Alles auswählen
def expand(zahl):
return (int((zahl/10**x)%10) for x in xrange(int(math.floor(math.log10(zahl))),-1,-1))
Das 'e' muss nicht an vierter Stelle stehen, der Exponent kann auch dreistellig sein.XtraNine hat geschrieben:Funktioniert jetzt auch mit floats die nen exp haben. Naja ist zwar ungenau, aber dagegen kann ich ja nichts machen. Wüste auch nicht wie.
Grmpf, hätte ich wohl einfach mal ausprobieren sollen.[Edit: Code ins LodgeIt ausgelagert]
Was ist daran überraschend? aus "- abc" wird "cba -" 0o. Falls das eine Anspielung auf strings sein soll, die werden ja vorher abgefangen in Zeile 6, und in 7 returned.reverse_value('- abc')
Das Ergebnis finde ich etwas überraschend.
Es geht gar nicht darum das ich diese spezielle Funktion nicht sinnvoll finde, sondern die Art wie sie sehr viele verschiedene Dinge tut. "Einfach etwas umdrehen" sagt sich so leicht. Das würde als Docstring sicher nicht ausreichen um die Funktion zu beschreiben. Wenn Du anfängst die Vorbedingungen an die Objekte und die Ergebnisse (wohlgemerkt Mehrzahl!) zu beschreiben, fällt Dir vielleicht auf warum ich finde das das nicht eine Funktion ist, sondern im Grunde mehrere.Ja bei den floats sehe ich gerade das es ein wenig strange ist. Werde ich ändern(?). was meinst du mit ->> *eine* <<- warum diese Hervorhebung? Ich verstehe deine frage nicht? Ihr wart doch die jenigen die sagen "Duck-Typing" ist tool ich versuche gerade dem gerecht zu werden in dem ich eine einfache Funktion schreibe die einfach etwas umdreht. Dabei spielt es keine roll ob es eine Zahl ist, oder eine Zeichenkette, oder eine Decimal Zahl (complex lasse ich weg. mach mMn keine Sinn.). Ich würde gerne eine Begründung wissen weshalb du gerade diese Funktion überflüssig findest?Bei Fliesskommazahlen wird es noch verwirrender. Und warum muss das unbedingt *eine* Funktion sein, die alles kann?
Ich habe es noch nicht gebraucht. Während ich mir beim ersten noch Anwendungsfälle vorstellen könnte, fällt mir so gar keiner ein, warum ich *eine* Funktion bräuchte die *beides* macht.Was sprich außer, dieses Beispiel, gegen die Funktion expand_value()? Braucht man das nicht das man 12985764 als [1,2,9,8,5,7,6,4] hat oder 1.234 als [1,'.',2,3,4].Was spricht dagegen sum(map(int, str(number))) als Funktion `quersumme` zu definieren?
Worauf ich hinaus will, ist dass Du mal beschreibst was bei dem Fliesskommabeispiel mit dem *Wert* gemacht wird, nicht mit einer Repräsentation des Wertes zu einer Basis als Zeichenkette. Was ist bei einer *Zahl* rechts oder links? Oder meinetwegen eine Beschreibung was mit dem Wert bei einer ganzen Zahl passiert, das ist vielleicht einfacher.-> -43.21. Es wird einfach die Zahl umgedreht. Ich weiß nicht worauf du hinaus willst...Und was ist der reversed Wert von -12.34? Und versuch das mal ohne die Zeichenkettenrepräsentation zu beschreiben.
reverse_value = Drehe die zahl, zeichenkette von rechts nach links um.
Eine Liste hat Elemente auf die man zugreifen und die man in umgekehrter Reihenfolge anordnen kann. Das hat eine Zahl nicht. Ausserdem ist die Definition schon durch die Klasse `list()` vorgegeben:Gegen frage: Was ist [1, 2, 3, 4, 5] reversed(?)
Code: Alles auswählen
In [86]: a = [1, 2, 3, 4, 5]
In [87]: a.reverse()
In [88]: a
Out[88]: [5, 4, 3, 2, 1]
Etwas das umgedreht werden kann. Oder auch nicht. Sag Du's mir. Welche Eigenschaften, und darum geht's bei duck typing, müsste ein Wikinger haben um umgedreht werden zu können.was ist wiking?Oder reversed von ``Viking()``?
Und das sieht bei Zahlen anders aus?Nö nicht wirklich. complexe lasse ich weg weil sinnfrei.bei verschiedenen Typen völlig unterschiedliche Bedeutungen hat und einen Anwendungsfall hätte ich auch gerne mal gesehen
Der Wert einer Zahl ist etwas ziemlich abstraktes und etwas "ganzes" im Gegensatz zu einer Zeichenkette die aus kleineren Einheiten zusammengesetzt ist.Unterstützt werden Ganze zahlen, Decimal, float, str, unicode und alles was sich wie eine Zahl, Zeichenkette, oder eine Decimalzahl verhält. Bei allen dem wird das gleiche gemacht und zwar der Wert umgedreht. Mehr nicht...