Cast in Python?

[Rebecca]

Klingt voellig logisch. Ich kann mir aber im Moment gar nicht vorstellen, wie eine schwach typisierte Sprache aussehen soll?

[Leonidas]

Ich kann mir aber im Moment gar nicht vorstellen, wie eine schwach typisierte Sprache aussehen soll?

Wie PHP oder Visual Basic. Das sind eben schwach typisierte Sprachen.

[Joghurt]

Ihr habt ja recht. Ich sollte abends nicht mehr posten

[BlackJack]

Klingt voellig logisch. Ich kann mir aber im Moment gar nicht vorstellen, wie eine schwach typisierte Sprache aussehen soll?

Wie wär's mit C.

Wenn Du in Java `Viking` zu `Object` und dann zu `Duck` castest dann wird der zweite Cast in einer Fehlermeldung enden bevor du auf das `quack`-Attribut zugreifen kannst.

In C kannst Du einen Pointer auf eine `viking` Struktur einfach nach `duck*` casten und auf die, wahrscheinlich falschen, Elemente zugreifen.

In stark typisierten Sprachen "wissen" die "Objekte" selbst welchen Typ sie haben, in schwach typisierten Sprachen entscheiden die Funktionen/Prozeduren wie sie ein "Objekt" sehen wollen.

[bigfrau]

weiss jemand, wie man in diesem Fall auf die "fields" zugreifen kann? Wenn man beispielsweise Object dieser TransferableGenericDataObject_Def Klasse bekommt, dann wie kann man auf diese TClist zugreifen und elemente daraus lesen?
Es geht dabei also nur auf die Attributen zu zugreifen die eigentlich da sind, nur wie kann man die Abfragen, aus dieser merkwürdien Liste?

die Klasse von der TransferableGenericDataObject_Def erbt ist DataObject_Def und ist auch unten zu sehen:

Code: Alles auswählen

class TransferableGenericDataObject_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://schema.eim.cas.de"
        type = (schema, "TransferableGenericDataObject")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns0.TransferableGenericDataObject_Def.schema
            TClist = [GTD("http://schema.eim.cas.de","Field",lazy=False)(pname=(ns,"fields"), aname="_fields", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))]
            attributes = self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            if ns0.DataObject_Def not in ns0.TransferableGenericDataObject_Def.__bases__:
                bases = list(ns0.TransferableGenericDataObject_Def.__bases__)
                bases.insert(0, ns0.DataObject_Def)
                ns0.TransferableGenericDataObject_Def.__bases__ = tuple(bases)

            ns0.DataObject_Def.__init__(self, pname, ofwhat=TClist, extend=True, attributes=attributes, **kw)



class DataObject_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://schema.eim.cas.de"
        type = (schema, "DataObject")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns0.DataObject_Def.schema
            TClist = [ZSI.TC.HexBinaryString(pname=(ns,"id"), aname="_id", minOccurs=1, maxOccurs=1, nillable=True, typed=False, encoded=kw.get("encoded")), GTD("http://schema.eim.cas.de","AlphaString",lazy=False)(pname=(ns,"objectType"), aname="_objectType", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._id = None
                    self._objectType = None
                    return
            Holder.__name__ = "DataObject_Holder"
            self.pyclass = Holder

[keppla]

Ist nicht gegen dich persönlich gerichtet, aber der Code, den du da gepostet hast, kommt direkt aus der Hölle. Ich befürchte, bevor du ihn nicht irgendwie verständlicher machst, werde ich nicht der einzige sein, der ihn nicht versteht, und dir deshalb nicht helfen kann.