Unterscheidung einer Variable , 'Dict' oder 'Object'

[YAPD]

Hallo Zusammen,

ich habe eine Frage zu der Behandlung von Variablen in Funktionen.
Und zwar habe ich folgende Problematik. Ich habe eine einfache
Funktion :

Code: Alles auswählen

import inspect

def registerlanguage(name, *obj , **parameters ):

    if type(obj) is dict:
        print("Dictionary Detected !")

    if inspect.isclass(type(obj)) is True:
        print("OBJ Detected !")

Ich möchte nun die o.g. Funktion mit folgenden 2 Befehlen aufrufen :

Code: Alles auswählen

test = LanguageOBJ()

Beispiel 1 : registerlanguage("Excel", test)
Beispiel 2 : registerlanguage("Excel", delimiter="", quoting="Yes")

Die Variable 'test' ist ein Klassenobjekt, der zu Testzwecken so erzeugt wurde :

Code: Alles auswählen

class Language_OBJ:
    
    def __init__(self):
        
        print("Initialisierung des Language - Objekts !")

        self.delimiter = None
        self.quoting = None
        self.quote_Character = None
        self.double_Quotes = None
        self.escape_Character = None

Mein Problem ist nun folgedes :

Die Funktion soll erkennen, ob es sich beim 2. Parameter des Aufrufs entweder um ein Objekt
handeln, wie bei Beispiel 1 oder um weitere Parameter der Form Dict, also key = value.

VG
YAPD

[rogerb]

@YAPD,

das würde man über isinstance() machen:

Code: Alles auswählen

if isinstance(obj, dict):
    print("Dictionary Detected !")
elif isinstance(obj, Language_OBJ):
    print("OBJ Detected !")

Man prüft, ob ein Objekt eine Instanz eines Typen ist, nicht den Typ selbst.

[YAPD]

@YAPD,

das würde man über isinstance() machen:

Code: Alles auswählen

if isinstance(obj, dict):
    print("Dictionary Detected !")
elif isinstance(obj, Language_OBJ):
    print("OBJ Detected !")

Man prüft, ob ein Objekt eine Instanz eines Typen ist, nicht den Typ selbst.

Hi Roger. Danke für deine Antwort. Ohje, da sieht meine "Lösung', an der ich gerade
die ganze Zeit gearbeitet habe aber anders aus :

Code: Alles auswählen

def Register_Language(name, *obj, **language_parameters):

    rl_language_objects = {}

    # print( "OBJ        :" , obj )
    # print( "Parameters :" , language_parameters )

    if (obj == ()) and (language_parameters == {}):
        print("No Parameters Found !")
        exit(0)

    if obj != ():
        print("Processing OBJ {} !".format(obj[0]))

        rl_language_objects["delimiter"] = obj[0].delimiter
        rl_language_objects["quoting"] = obj[0].quoting

        if language_parameters != {}:
            print("Processing More Parameters !")

            for lp in language_parameters:

                if lp in [ p for p in [ 'delimiter' , 'quoting' ] ] :
                    rl_language_objects[lp] = language_parameters[lp]

                else:
                    print("The Specified Parameter Is Not Registered !")
                    exit( 0 )

        else:
            print("No More Paramters To Process !")

    if (obj == ()) and (language_parameters != {}):
        print("Processing Dictionary !")

        for dictionary_parameter in language_parameters:

            if dictionary_parameter in [ p for p in [ 'delimiter' , 'quoting' ] ] :
                rl_language_objects[dictionary_parameter] = language_parameters[dictionary_parameter]
            else:
                print("The Specified Parameter Is Not Registered !")
                exit( 0 )

    print(rl_language_objects)
    
    print( "-------------------------------------" )  

Aufrufe :

Code: Alles auswählen

Register_Language( 'Excel' , test )
Register_Language( "Excel" , test , Delimiter = "Test" )
Register_Language( "Excel" , Delimiter = "" , Quoting = "Yes" )

VG
YAPD

[Sirius3]

Funktionen schreibt man wie Variablennamen ausschließlich mit Kleinbuchstaben.
exit hat außerhalb der main-Funktion nichts verloren. Statt dessen benutzt man Exceptions.
Was hast Du Dir bei `[ p for p in [ 'delimiter' , 'quoting' ] ]` gedacht?

Code: Alles auswählen

class Language:
    def __init__(delimiter=",", quote='"'):
        self.delimiter = delimiter 
        self.quote =quote

def register_language(name, *language, **parameters):
    if len(language) == 1 and not parameters:
        language = language[0]
    elif not language and parameters:
        language = Language(**parameters)
    else: 
        raise TypeError()

[YAPD]

exit hat außerhalb der main-Funktion nichts verloren. Statt dessen benutzt man Exceptions.

Testscript sagt dir was ?? Wenn du vollständigen einwandfreien Code, willst empfehle ich dir,
dir die fertigen Scripts in den Libs anzuschauen, anstatt die Beiträge im Forum.

Was hast Du Dir bei `[ p for p in [ 'delimiter' , 'quoting' ] ]` gedacht?

Ich hatte vorher eine statische Liste mit den Variablen 'delimiter' , quoting' etc.
Aber das ganze geht geht auch mit einer ganz normalen Liste, wozu die
Umstände

Code: Alles auswählen

if dictionary_parameter in [ 'delimiter' , 'quoting' ] :
...

[__blackjack__]

@YAPD: Du kannst echt gerne immer wieder so angepisst reagieren wenn Du immer wieder auf die gleichen Sachen hingewiesen wirst. Das wird passieren. Immer wieder. Bis keiner mehr Lust hat auf Deine Beiträge zu antworten.

Testskript sagt gar nichts, jedenfalls nicht das man sich da nicht an die Konventionen und saubere Programmierung hält. Denn man lernt das ja nicht wenn man sich immer wieder *nicht* dran hält, sondern in dem man übt es richtig zu machen. Und wir wissen ja nicht was Fehler sind und was nur „ich weiss es ja besser, aber es ist mir egal“.

[__deets__]

Testscript sagt dir was ?? Wenn du vollständigen einwandfreien Code, willst empfehle ich dir,
dir die fertigen Scripts in den Libs anzuschauen, anstatt die Beiträge im Forum.

Wo ist denn bitte genau definiert, was in einem ”Testscript” erlaubt ist, das in einem nicht-Test-Skript nicht erlaubt ist? Denn wir kleinen Dummerle sehen nur 10 Fehler in einem mit den falschen Begriffen und fehlerhaften Beschreibungen daherkommenden Post. Wo genau da jetzt die Teile sind, die wir gnädigerweise diskutieren dürfen, ist halt etwas schwer zu ermitteln.

Und wenn du in einem Testskript Mist programmiert hast, was genau ist der magische Prozess, mit dem dir ein Licht aufgeht, wenn es dann an das Schreiben von “echtem” code gibt? Denn Feedback von uns ist ja offensichtlich verpönt. Und wenn es diesen magischen Vorgang gibt, warum wendest du den nicht einfach gleich an, um dir deine Fragen und Fehler selbst zu erklären?

[YAPD]

@YAPD: Du kannst echt gerne immer wieder so angepisst reagieren wenn Du immer wieder auf die gleichen Sachen hingewiesen wirst. Das wird passieren. Immer wieder. Bis keiner mehr Lust hat auf Deine Beiträge zu antworten.

Testskript sagt gar nichts, jedenfalls nicht das man sich da nicht an die Konventionen und saubere Programmierung hält. Denn man lernt das ja nicht wenn man sich immer wieder *nicht* dran hält, sondern in dem man übt es richtig zu machen. Und wir wissen ja nicht was Fehler sind und was nur „ich weiss es ja besser, aber es ist mir egal“.

Kein Problem. Ich werde auch nicht müde, euch vorzuhalten, wie scheiße ihr Euch gegenüber
Forum Benutzern verhaltet, die nur zum Lernen hier sind und denen ihr komplett die Freude
nehmt. So eine Arroganz und Überheblichkeit habe ich echt noch in keinem anderen Forum
gesehen. Schämt euch. So wie wir bei Python müsst ihr einiges an Sozialkompetenz lernen,
habe ich das Gefühl. Ich war immer freundlich und habe versucht, es mit Humor zu nehmen.
Aber ihr seid einfach unerträglich.

Oder das :

Ich habe einfach nur gefragt, ob die Variable in Grossbuchstaben zu schreiben, eine
Standard Methode ist. Die Antwort :

@YAPD: Wie gross muss der Text denn werden, dass man das überhaupt merkt.

Was soll das ? Ganz ehrlich. So Kommentare könnt ihr euch echt sparen.

[__deets__]

Ich habe einfach nur gefragt, ob die Variable in Grossbuchstaben zu schreiben, eine
Standard Methode ist. Die Antwort :

@YAPD: Wie gross muss der Text denn werden, dass man das überhaupt merkt.

Was soll das ? Ganz ehrlich. So Kommentare könnt ihr euch echt sparen.

Es gibt in der Softwareentwicklung einen sehr bekannten Satz: vorzeitige Optimierung ist die Wurzel allen Übels. Und genau das ist hier gemeint. Ein komplizierteres Vorgehen zu nutzen, statt einem einfachen und leicht verständlichen, ist nur gerechtfertigt, wenn es wirkliche Kosten gibt, die zu hoch sind. Wozu man zB profiler benutzt.

Aber wer auf dem Kreuzzug ist, sich von allem angepisst zu fühlen, dem entgehen solche Dinge mal. Und damit die Gelegenheit, etwas zu lernen. Auch wenn man immer wieder behauptet, das tun zu wollen

[YAPD]

Ich habe einfach nur gefragt, ob die Variable in Grossbuchstaben zu schreiben, eine
Standard Methode ist. Die Antwort :

@YAPD: Wie gross muss der Text denn werden, dass man das überhaupt merkt.

Was soll das ? Ganz ehrlich. So Kommentare könnt ihr euch echt sparen.

Es gibt in der Softwareentwicklung einen sehr bekannten Satz: vorzeitige Optimierung ist die Wurzel allen Übels. Und genau das ist hier gemeint. Ein komplizierteres Vorgehen zu nutzen, statt einem einfachen und leicht verständlichen, ist nur gerechtfertigt, wenn es wirkliche Kosten gibt, die zu hoch sind. Wozu man zB profiler benutzt.

Aber wer auf dem Kreuzzug ist, sich von allem angepisst zu fühlen, dem entgehen solche Dinge mal. Und damit die Gelegenheit, etwas zu lernen. Auch wenn man immer wieder behauptet, das tun zu wollen

Also ich will lernen und nehme mir die Ratschläge auch zu Herzen. Und ich bin grundsätzlich nicht auf Kreuzzeug,
sondert finde die Weise, wie manche Kommentare hier geschrieben sind, einfach scheiße. Jetzt an dem Beispiel
meines Scripts wollte ich einfach nur, dass er, wenn er die Bedingung erfüllt, die Ausführung abbricht. Ich habe ja
nur eine Funktion, ohne Klasse. Wie wäre denn der ordentliche Weg, es zu beenden außer mit exit( )

Übrigens ein sehr positives Beispiel, das mir einfällt, ist rogerB. Seine Beiträge sind immer freundlich und auch hilfreich.
Nur dass ihr vielleicht einen Vergleich habt, was ich meine.

[__blackjack__]

@YAPD: Das war eine ernst gemeinte Frage. `str.translate()` ist die für die Aufgabe vorgesehene Methode. Die nimmt man dafür, es sei denn man hat einen Grund das nicht zu tun. Zum Beispiel weil es zu langsam ist. Oder weil man eine fertige Transliteration haben möchte, die mehr umfasst als die deutschsprachigen ”Sonderbuchstaben”, also Buchstaben die von ASCII abweichen. Die kann dann schneller sein. Aber auch langsamer. Auch ist dann wieder die Frage ob die zu langsam ist oder nicht. Wobei man sich diese Frage auch nicht direkt stellt. Sondern wenn ein Programm(teil) zu langsam ist, dann wirft man einen Profiler auf den Code und schaut erst einmal wo tatsächlich die Zeit verbraucht wird und wo man von Optimierungen am meisten profitieren würde.

Man programmiert normalerweise nicht so, dass alles so schnell wie nur irgend möglich läuft. Wenn man darauf aus ist, würde man schon bei der Wahl der Programmiersprache ganz sicher nicht Python nehmen, denn das ist grundsätzlich mindestens in der CPython-Implementierung vergleichsweise grottenlangsam. Der Grund warum Python trotzdem so beliebt ist, ist dass man damit schnell Ergebnisse erzielen kann, die von der Laufzeit her schnell genug sind, und die man lesbar und verständlich schreiben kann.

Funktionen kann man mit ``return`` verlassen wenn es im Grunde eine Prozedur ist, also eine Funktion die keinen Rückgabewert hat, und die einfach beendet werden soll. Falls sie wegen einer Ausnahmesituation verlassen werden soll, dafür gibt es Ausnahmen die man auslösen kann (``raise``).

[YAPD]

@YAPD: Das war eine ernst gemeinte Frage. `str.translate()` ist die für die Aufgabe vorgesehene Methode. Die nimmt man dafür, es sei denn man hat einen Grund das nicht zu tun. Zum Beispiel weil es zu langsam ist. Oder weil man eine fertige Transliteration haben möchte, die mehr umfasst als die deutschsprachigen ”Sonderbuchstaben”, also Buchstaben die von ASCII abweichen. Die kann dann schneller sein. Aber auch langsamer. Auch ist dann wieder die Frage ob die zu langsam ist oder nicht. Wobei man sich diese Frage auch nicht direkt stellt. Sondern wenn ein Programm(teil) zu langsam ist, dann wirft man einen Profiler auf den Code und schaut erst einmal wo tatsächlich die Zeit verbraucht wird und wo man von Optimierungen am meisten profitieren würde.

Man programmiert normalerweise nicht so, dass alles so schnell wie nur irgend möglich läuft. Wenn man darauf aus ist, würde man schon bei der Wahl der Programmiersprache ganz sicher nicht Python nehmen, denn das ist grundsätzlich mindestens in der CPython-Implementierung vergleichsweise grottenlangsam. Der Grund warum Python trotzdem so beliebt ist, ist dass man damit schnell Ergebnisse erzielen kann, die von der Laufzeit her schnell genug sind, und die man lesbar und verständlich schreiben kann.

Funktionen kann man mit ``return`` verlassen wenn es im Grunde eine Prozedur ist, also eine Funktion die keinen Rückgabewert hat, und die einfach beendet werden soll. Falls sie wegen einer Ausnahmesituation verlassen werden soll, dafür gibt es Ausnahmen die man auslösen kann (``raise``).

Ok. Das ist einleuchtend. Wie gesagt, ich bin ja lernbereit und für Tipps immer offen.

Oh Mann ! Dass mir 'return' nicht eingefallen ist, mein Ernst ????

Code: Alles auswählen

class Language:
    def __init__(delimiter=",", quote='"'):
        self.delimiter = delimiter 
        self.quote =quote

def register_language(name, *language, **parameters):
    if len(language) == 1 and not parameters:
        language = language[0]
    elif not language and parameters:
        language = Language(**parameters)
    else: 
        raise TypeError()

Könnt ihr mir bitte erklären, wozu ich die Länge von language ermittle ?
Da eigentlich keine Klasse involviert war, habe ich das Script leicht verändert.

Code: Alles auswählen

def register_language(name, *language, **parameters):
    if language and not parameters:
        language = language[0]
    elif not language and parameters:
        language = parameters
    elif language and parameters :
        language = language[0]
        parsedparameters = parameters
    else: 
        raise TypeError()

VG
YAPD

[sparrow]

Warum holst du dir so viel Komplexität in deinen Code? Das könntest du dir sparen, wenn laguage immer vom selben Typ wäre. So ist es nur fehleranfällig und für den Anwender undurchsichtig.

Schau dir noch einmal an, was * und ** in Parameterlisten machen. Dann wird klar, warum du die Länge prüfen musst.
Ich würde auf irgendwelche Typprüfungen verzichten - indem language immer von einem sich gleich verhaltenden Typ ist.

[__blackjack__]

Das * beim `language`-Argument macht wenig Sinn wenn das immer entweder 0 oder 1 Elemente enthalten soll. Da würde man eher ein Default-Argument verwenden. Dann hätte man so etwas:

Code: Alles auswählen

def register_language(name, language=None, **parameters):
    language = parameters if language is None else language
    ...

Aber ich würde auch in Frage stellen warum man da überhaupt mit ”Magie” anfangen muss, und würde das mit den `parameters` einfach sein lassen. Das macht die Schnittstelle zu der Funktion nur unnötig kompliziert. Einfach das hier und gut ist's:

Code: Alles auswählen

def register_language(name, language):
    ...

[YAPD]

Dank für Eure ( sehr frühen ) Antworten.

Ich werde nun versuchen, es entsprechend umzuschreiben und das
Ergebnis anschließend posten.

VG
YAPD

[YAPD]

Hallo Zusammen,

nochmal zu der Identifizierung eines Objekts. Leider bin ich hier nicht weitergekommen.

Ich weiß dass wenn ich :

Code: Alles auswählen

class Class_Example_I( Language_OBJ ) :
...

mit 'isinstace()' abfrage ich True oder False erhalte, je nachdem ob das Objekt
ein Child der Klase 'Language_OBJ" ist.

Aber ist ist ja nicht Ziel der Übung, sondern, ich will grundsätzlich wissen, ob
die übergebene Variable ein Objekt ist.

'object' gibt es so anscheinend nicht. Daher kann ich kein :

Code: Alles auswählen

if type(var) is object 

oder bzw. :

Code: Alles auswählen

isinstanace(var , object) 

benutzen..

Ich hoffe, ihr wisst, was ich meine

Danke für Eure Hilfe.

VG
YAPD

[__blackjack__]

@YAPD: Doch `object` gibt es und ``isinstance(var, object)`` geht auch, allerdings kannst Du dann auch gleich ``True`` schreiben weil in Python *alles* ein Objekt ist was man an einen Namen binden kann. Insofern weiss ich jetzt nicht was Du da eigentlich genau machen/wissen willst.

Und vielleicht sollte man noch mal erwähnen, dass man `isinstance()` bzw. Typprüfungen nur ganz selten macht. Also immer wenn man denkt man müsste so etwas machen, sollte man schauen ob man da nicht was falsch macht. Es gibt nur relativ wenig sinnvolle Anwendungsfälle aktiv gegen „duck typing“ zu arbeiten.

[YAPD]

Ich habe gerade ein Beispiel gefunden, an dem ich es erläutere :

Bei dem Modul 'csv' gibt es den Befehl 'csv.register_dialect'. Wenn ich nun folgenden Code ausführe :

Code: Alles auswählen

[IN] csv.register_dialect("Excel", testobjekt ) 
[OUT] Kein Fehler, läuft normal weiter

Das übliche Standardverhalten.

Code: Alles auswählen

[IN] csv.register_dialect("Excel") 
[OUT] Kein Fehler, läuft normal weiter

Wieso funktioniert das überhaupt und was registriert er dann, wenn man keine Parameter angibt ?

Nun zu meinem Punkt. Wenn ich folgendes ausführe :

Code: Alles auswählen

csv.register_dialect( "Excel" , "Objekt" ) 

also, der 2. Parameter kein Objekt ist wirft er den Fehler :

Code: Alles auswählen

_csv.error : Unknown dict

Wenn ich den 1. Code benutze, also das Standardverhalten, kennt das Modul ja auch nicht das
Parentmodul, also kann er hier kein 'isinstace( testobjekt , parentobjekt )' machen.

Ich habe gesehem, dass er bei csv das .h Modul 'PyGetState' benutzt,
dort steht :

Return the “state” of the module, that is, a pointer to the block of
memory allocated at module creation time, or NULL. See PyModuleDef.m_size.

VG
YAPD

[__deets__]

“Objekt” ist ein Objekt. Ein String-Objekt. Und warum es ohne Angabe von Parametern klappt,steht hier: https://github.com/python/cpython/blob/ ... sv.c#L1450

Und was der probiert steht wenige Zeilen später, und läuft auf https://docs.python.org/3/c-api/call.ht ... l-protocol hinaus.

[YAPD]

Warum holst du dir so viel Komplexität in deinen Code? Das könntest du dir sparen, wenn laguage immer vom selben Typ wäre. So ist es nur fehleranfällig und für den Anwender undurchsichtig.

Schau dir noch einmal an, was * und ** in Parameterlisten machen. Dann wird klar, warum du die Länge prüfen musst.
Ich würde auf irgendwelche Typprüfungen verzichten - indem language immer von einem sich gleich verhaltenden Typ ist.

Hey, danke für den Hinweis, das ist ja wirklich wichtig. Ich habe es jetzt
auf folgenden Code "heruntergebrochen" :

Code: Alles auswählen

def Positions_Example(uid, *args, **kwt_args):

    # print('Länge - Parameter     : {}'.format(len(args)))
    # print('Länge - KWT_Parameter : {}'.format(len(kwt_args)))

    if (len(args) == 1) and (not kwt_args):
        print("Exactly One Parameter !")

        if not isinstance(args[0], str) and (not isinstance(args[0], dict)):
            print("Parameter Has To Be A String Or A Dictionary !")

    elif len(args) > 1:
        print("Only One Parameter Allowed !")

    elif (len(args) == 0) and (kwt_args):
        print("Only KWT Parameters !")

    elif len(args) == 0 and (not kwt_args):
        print("Need Parameters To Execute !")

Positions_Example("1234")
Positions_Example("1234", "Testumgebung")
Positions_Example("1234", "Testumgebung", "Neu")
Positions_Example("1234", name="Testumgebung")

Ich weiß jetzt auch, warum man die args immer zählen sollte, sonst
kann man nie genau bestimmen, wie viele Elemente enthalten sind

VG
YAPD