Seite 1 von 1

Wie macht man das, dass...

Verfasst: Dienstag 28. November 2006, 03:04
von sape
...nicht 'instance' angezeigt wird, sondern der Name der Klase.

Code: Alles auswählen

class foo:
    pass

print type(foo())
output:

Code: Alles auswählen

<type 'instance'>
So wie z.B. hier:

Code: Alles auswählen

from decimal import Decimal
print type(Decimal("1.1"))
output:

Code: Alles auswählen

<class 'decimal.Decimal'>
Da muss man bestimmt ne Methode hinzufügen, bloß welche?

lg

Verfasst: Dienstag 28. November 2006, 05:59
von mawe
Hi!

Wie das mit type geht, keine Ahnung, aber so gehts auch:

Code: Alles auswählen

foo().__class__.__name__
Gruß, mawe

Verfasst: Dienstag 28. November 2006, 07:46
von birkenfeld
Indem man
* eine Metaklasse mit einem anderen repr() verwendet (schwierig)
* eine New-Style-Klasse verwendet (einfach).

Code: Alles auswählen

class A(object):
    pass
Also: von "object" erben.

Verfasst: Dienstag 28. November 2006, 09:05
von sape
Danke das hilft mir schon weiter.

Wie kriege ich nun heraus von welcher Basisklasse es abgeleitet ist bzw. die Oberste klasse aller klassen. SO was wie "isinstance" aber das mir stattdessen der Type der obersten Klasse Angezeigt wird.
Beispiel:

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
...
Ja nun könnten wider einige meinen, wozu braucht er so was den schon wider.

Gehen wir mal von folgendem aus:

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. :)
Das schöne daran ist das dass Duck-Tyiping weitestgehend eingehalten wird :) Ales was von int abgeleitet ist wird ja von 'isinstance' auch abgefangen und das gleihce für die anderen DAtentypen (bei mir habe ich für alles relevante solche if abfragen so das die Funktion auf fast alles, wo es sinnvoll erscheint, angewendet werden kann.

Naja, dies "elif" Kaskaden könnte man bis ins unendliche treiben, was ich ab einen gewissen punkt (bei sind ca. 10 Stück hintereinander) absolut nicht leiden kann, shcon gar nicht wenn innerhalb des blocks zu 99,% das gleiche getan wird :roll:

Daher dieser anssatz der mir sehr gut gefällt:

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
Wie ich finde eine sehr gute und übersichtliche Lösung :) 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 (z.B. Performance?)

Ja was ist nun das Problem daran. Diese 'type()' zerstört mir alles! Sobald ich da eine 'instance()' reinjage die von 'int' abgeleitet wurde, wird das natürlich wegen dem blöde type() nicht erkannt :roll:

Daher an dieser stelle: Wie genau überprüft 'isinstance()' was die Oberklasse ist (was ist der code)? Es muss irgendwo in der Klasse ein Atribut existieren das angibt welche die Oberklasse ist.

lg

Verfasst: Dienstag 28. November 2006, 09:50
von gerold
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
Hi XtraNine!

Du verrennst dich total!

1.) Bei DuckTyping fragst du nicht, welcher Typ übergeben wurde, sondern ob sich das übergebene Objekt wie das gewünschte Objekt verhält. Aber das hat so gar nichts mit dem zu tun, was du im letzten Beispiel gemacht hast.

2.) ``exec()`` bringt in deinem Code keinen Vorteil:

Code: Alles auswählen

    hash_table = {
        str: str,
        unicode: unicode,
        int: int,
    }
   
    retval = hash_table[type(value)](strval)
3.) Oben aufgezeigte Lösung ist aber auch keine Lösung, da sie schlicht und einfach unnötig ist. Du musst dich noch daran gewöhnen, dass du nicht nur Werte, sondern auch Funktionen, Klassen, Typen, usw. einen zusätzlichen Namen (also eine Variable) zuweisen kannst. --> Verbinde einfach den Typ des übergebenen Objekts mit einem Variablenamen und wandle dann das Ergebnis damit wieder in diesem Typ um.

Code: Alles auswählen

>>> i = 123
>>> old_type = type(i)
>>> s = str(i)
>>> s = s[::-1]
>>> s
'321'
>>> i = old_type(s)
>>> i
321
Oder auch so:

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'>
>>> 
...mit Float wirst du Schwierigkeiten bekommen. (Z.B. bei -1234.12)

mfg
Gerold
:-)

Verfasst: Dienstag 28. November 2006, 09:58
von sape
I am very :shock: :shock: :shock:
Magic!!! Wie geht den sowas? Das verstehe ich nicht :shock:
Da ist ja echt sehr, sehr geil! Aber ich verstehe trotzdem nicht wie so was gehen kann 0o

Verfasst: Dienstag 28. November 2006, 10:18
von sape
sehr geil! Danke dir gerold :)

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
Nun kanns auch mit den Negativen float/Decimal umgehen :) Ziel ereicht. Hätte nciht gedacht das dass so einfach geht.

lg xtra

EDIT: Man hätte ich das bloß vorher gewusst. Jetzt darf ich erstmal meine Funktionen umschrieben die so änlich aufgebaut sind ^^

P.S.: Python ist einfach Super :bigok:
EDIT2: So, nun noch für complex, etc Zahlen und dann sitzt die Funktion. Wenn ich fertig bin poste ich das Ergebnis in Snippet Sub-Forum.

Verfasst: Dienstag 28. November 2006, 10:40
von gerold
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)
Hi XtraNine!

Die Zeilen 5 und 6 würde ich durch diese hier ersetzen:

Code: Alles auswählen

if not isinstance(type_of_value, (float, Decimal)):
Denn so prüfst du nicht nur auf den EXAKTEN Typ, sondern du fängst auch von diesen Typen abgeleitete Klassen ab.

Code: Alles auswählen

>>> class A(float):
...     pass
...     
>>> f = A(123.123)
>>> isinstance(f, float)
True
>>>
lg
Gerold
:-)

Verfasst: Dienstag 28. November 2006, 10:54
von BlackJack
Ich verstehe ehrlich gesagt denn Sinn dieser ganzen Übung nicht.

Schreib doch mal bitte einen Docstring der beschreibt was diese Funktion macht, was sie an Eigenschaften vom übergebenen Objekt erwartet und was sie als Ergebnis garantiert.

So eine Funktion ist einfach ein bisschen zu "Magic" für meinen Geschmack.

Ach und probier's mal mit einer positiven Fliesskommazahl und einem negativen `int` oder `long`. 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. :-)

Verfasst: Dienstag 28. November 2006, 13:06
von sape
Mir fällt auf das ich diese isinstance garnicht brauche gerold. Ich hatte ein Denkfehler. Ich überpuffe jetzt direkt ob ein minus vorhanden ist :)

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.
BlackJack hat geschrieben:Ich verstehe ehrlich gesagt denn Sinn dieser ganzen Übung nicht.
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.)

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ür

Code: Alles auswählen

 print reduce(lambda x, y: x+y, expand_value(12345))
Da würde die Quersummen berechnen :) Es gibt aber ncoh viele weitere Einsatzgebiete wo so ein expander nötig wird.

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:



BlackJack hat geschrieben: So eine Funktion ist einfach ein bisschen zu "Magic" für meinen Geschmack.
Warum magic? Finde ich nicht. Die Funktion liefert nur einen reversed wert zurücke mehr nicht.
BlackJack hat geschrieben: Ach und probier's mal mit einer positiven Fliesskommazahl und einem negativen `int` oder `long`.
Funktioniert nun :)
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. :-)
Na ja wie gesagt die FUnktion ist noch nicht fertig. Ich will auch komplexe Zahlen und so weiter mit reinnehmen.

Was meinst du mit "Unendlich und "Not A Number" lassen wir mal weg"? SO was hat doch Python nicht oder doch?

EDIT: Fehler korrigiert.

Verfasst: Dienstag 28. November 2006, 14:39
von BlackJack
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 :)
reverse_value('- abc')

Das Ergebnis finde ich etwas überraschend. :-)
BlackJack hat geschrieben:Ich verstehe ehrlich gesagt denn Sinn dieser ganzen Übung nicht.
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.)
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?

Ich würde Dir immer noch empfehlen mal eine Beschreibung der Funktion zu verfassen. Da wird sich herausstellen das Du bei etwas landest wie:

Wenn das Argument vom Typ soundso ist dann sieht das Ergebnis so aus, wenn es vom Typ soundso ist dann so und wenn...

Diese eine Funktion tut im Grunde ganz verschiedene Sachen die teilweise sehr spezialisiert sind.
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ür

Code: Alles auswählen

 print reduce(lambda x, y: x+y, expand_value(12345))
Da würde die Quersummen berechnen :) Es gibt aber ncoh viele weitere Einsatzgebiete wo so ein expander nötig wird.
Was spricht dagegen sum(map(int, str(number))) als Funktion `quersumme` zu definieren?
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:
`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.
BlackJack hat geschrieben: So eine Funktion ist einfach ein bisschen zu "Magic" für meinen Geschmack.
Warum magic? Finde ich nicht. Die Funktion liefert nur einen reversed wert zurücke mehr nicht.
Und was ist der reversed Wert von -12.34? Und versuch das mal ohne die Zeichenkettenrepräsentation zu beschreiben. Oder reversed von ``Viking()``?
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. :-)
Na ja wie gesagt die FUnktion ist noch nicht fertig. Ich will auch komplexe Zahlen und so weiter mit reinnehmen.
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.
Was meinst du mit "Unendlich und "Not A Number" lassen wir mal weg"? SO was hat doch Python nicht oder doch?
Doch natürlich. `float()` ist ein C `double` und die kennen auch +/- unendlich und "Not A Number".
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
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.

Verfasst: Dienstag 28. November 2006, 15:32
von sape
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.

[Edit: Code ins LodgeIt ausgelagert]
reverse_value('- abc')

Das Ergebnis finde ich etwas überraschend.
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.

Ich werde das trotzdem noch nachher ändern und ne Prüfung auf "Decimal" machen, nicht das andere Objekte davon negativ beeinflusst werden.
Bei Fliesskommazahlen wird es noch verwirrender. Und warum muss das unbedingt *eine* Funktion sein, die alles kann?
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?
Was spricht dagegen sum(map(int, str(number))) als Funktion `quersumme` zu definieren?
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].
Und was ist der reversed Wert von -12.34? Und versuch das mal ohne die Zeichenkettenrepräsentation zu beschreiben.
-> -43.21. Es wird einfach die Zahl umgedreht. Ich weiß nicht worauf du hinaus willst...
reverse_value = Drehe die zahl, zeichenkette von rechts nach links um.
Gegen frage: Was ist [1, 2, 3, 4, 5] reversed(?)
Oder reversed von ``Viking()``?
was ist wiking?
bei verschiedenen Typen völlig unterschiedliche Bedeutungen hat und einen Anwendungsfall hätte ich auch gerne mal gesehen
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...

BTW: Ok, das du reverse_value überflüssig findest ist ok. Hab mit keiner anderen Reaktion gerechnet (ich Denke viel werde es wohl auch nicht anders sehen wie du). Aber was zum henker spricht den bitte gegen expand_value?

Edit (Leonidas): Code ins LodgeIt ausgelagert?

Verfasst: Dienstag 28. November 2006, 18:00
von Leonidas
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 :)
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: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.).
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:reverse_value = Drehe die zahl, zeichenkette von rechts nach links um.
Gegen frage: Was ist [1, 2, 3, 4, 5] reversed(?)
[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:
Oder reversed von ``Viking()``?
was ist wiking?
Viking() ist eine Instanz der Viking-Klasse.
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...
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?

Verfasst: Dienstag 28. November 2006, 19:13
von rayo
Hi

Hab ich das jetzt überlesen?

Für was konkret brauchst du so eine Funktion?

Gruss

PS: hatte gerade Lust (sieht irgendwie Lustig aus :) ):

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))

Verfasst: Dienstag 28. November 2006, 20:08
von akis.kapo
"Wie macht man, dass nicht der Name der ..."

...hätts auch getan. :wink:

Verfasst: Mittwoch 29. November 2006, 01:41
von BlackJack
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.
Das 'e' muss nicht an vierter Stelle stehen, der Exponent kann auch dreistellig sein.
[Edit: Code ins LodgeIt ausgelagert]
reverse_value('- abc')

Das Ergebnis finde ich etwas überraschend.
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.
Grmpf, hätte ich wohl einfach mal ausprobieren sollen. :oops:
Bei Fliesskommazahlen wird es noch verwirrender. Und warum muss das unbedingt *eine* Funktion sein, die alles kann?
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?
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.
Was spricht dagegen sum(map(int, str(number))) als Funktion `quersumme` zu definieren?
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].
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.
Und was ist der reversed Wert von -12.34? Und versuch das mal ohne die Zeichenkettenrepräsentation zu beschreiben.
-> -43.21. Es wird einfach die Zahl umgedreht. Ich weiß nicht worauf du hinaus willst...
reverse_value = Drehe die zahl, zeichenkette von rechts nach links um.
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.
Gegen frage: Was ist [1, 2, 3, 4, 5] reversed(?)
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:

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]
Das lässt nicht allzuviel Interpretationsspielraum.

Darauf basiert auch so ein bisschen die Erwartungshaltung an eine `reversed()`-Funktion (die es ja bereits gibt). Auch was das Ergebnis angeht. Die meisten Leute würden bei zweimaligem umdrehen von "etwas" zum Beispiel erwarten, das wieder der gleiche Anfangswert herauskommt.
Oder reversed von ``Viking()``?
was ist wiking?
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.
bei verschiedenen Typen völlig unterschiedliche Bedeutungen hat und einen Anwendungsfall hätte ich auch gerne mal gesehen
Nö nicht wirklich. complexe lasse ich weg weil sinnfrei.
Und das sieht bei Zahlen anders aus?
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...
Der Wert einer Zahl ist etwas ziemlich abstraktes und etwas "ganzes" im Gegensatz zu einer Zeichenkette die aus kleineren Einheiten zusammengesetzt ist.

Verfasst: Mittwoch 29. November 2006, 07:50
von sape
EDIT: Hat sich erledigt...Hab das alles gelöscht und arbeite an meinen Colorizer für mein prog weiter.

lg