Neuling in Python

[BlackJack]

@doclektor: Keine Sorge, hier ist niemand böse auf Dich.

Klar kann man eine relationale Datenbank für die Datenhaltung für Dein Projekt verwenden. Das ist neben den Python-Grundlagen, Objektorientierung, und ereignisbasierter Programmierung für die GUI allerdings ein weiteres, relativ komplexes Feld mit einer eigenen Abfragesprache die man lernen muss. Wenn man die Daten im Programm als Objekte modelliert, bietet sich hier eine entsprechende Bibliothek an die das relationale Modell auf Objekte abbildet → „Object Relational Mapper“ (ORM). Recht weit verbreitet ist da bei Python die SQLAlchemy-Bibliothek, die ich persönlich fast immer als Abstraktionsschicht für den Datenbankzugriff verwende, auch wenn ich kein ORM brauche.

[NoPy]

@doclektor: Auf Dich ist hier niemand böse, höchstens auf mich. Und selbst da kommen weniger Steine, als erwartet
@BlackJack:
Sicher muss ich noch einiges lernen, beispielsweise ist mir der Zweck und die Anwendung von doc- Strings noch nicht klar.
Das man bei Tests etwas einfacher hantieren kann, als mit anderen Umgebungen, ist mir bewusst. Das wiegt für mich persönlich aber NOCH nicht die Vorteile auf, die ICH PERSÖNLICH bei einer echten IDE hatte (Syntax- Kontrolle, Typsicherheit), denn in python habe ich halt mehr Testszenarien. Wenn ich eine allgemeine Funktion

Code: Alles auswählen

def a(b):
    pass

schreibe, weiß ich in der Funktion erst einmal nicht, was als b alles ankommt. Ergo muss ich dazu auch noch Tests fahren.
Dazu kommt, dass triviale Tests (zählt er wirklich hoch, wenn ich das sage?) erst für automatisierte Tests eine Rolle spielen, denn was ich gerade gemacht habe, weiß ich in der Regel. Die eigentlichen Testszenarien sind nun mal komplexer: (Wenn nach dem Buchen des Sitzpplatzes und des Gepäckes und dem Zahlvorgang der Flieger storniert wurde, geht dann auch das Geld zurück? - Mag sein, dass sich das in python auch einfacher formulieren lässt, als in anderen Umgebungen, aber wie gesagt, ein Gefühl für das richtige Strukturieren von python- Code habe ich noch nicht entwickelt. Gemessen an den Projekten, die ich bislang außerhalb von python gefertigt habe, stümpere ich noch herum. Ich benötige für die Erstfertigung eines Moduls ca. 3 mal so lange, wie sonst. Und um dieses Modul ein halbes Jahr später um Kleinigkeiten zu erweitern und das fehlerfrei zu lauffähig zu bekommen, benötige ich gefühlt noch länger)

Aber ich bin ja hier, um zu lernen, nicht wahr?
Meine aktuellen Stichworte sind Docstrings, ORM, SQLAlchemie

[Hyperion]

@NoPy: Bei Unit Tests (und automatisierten Tests i.A.) ist es nicht wesentlich, ob Du "gerade noch weißt", was der Code macht und auch nicht, ob das etwas kompliziertes ist! Es geht insbesondere um die Absicherung, dass Dinge auch nach (späteren) Änderungen oder Erweiterungen des Programms noch funktionieren.

Auch vermeintlich kleine und einfache Dinge können das Ergebnis stark beeinflussen - das wissen wir alle spätestens seit Jurassic Park

[NoPy]

@NoPy: Bei Unit Tests (und automatisierten Tests i.A.) ist es nicht wesentlich, ob Du "gerade noch weißt", was der Code macht und auch nicht, ob das etwas kompliziertes ist! Es geht insbesondere um die Absicherung, dass Dinge auch nach (späteren) Änderungen oder Erweiterungen des Programms noch funktionieren.

Auch vermeintlich kleine und einfache Dinge können das Ergebnis stark beeinflussen - das wissen wir alle spätestens seit Jurassic Park

Genau das habe ich gemeint

[doclektor]

Hallo,

kann mir jemand sagen wo der fehler liegt

Code: Alles auswählen

if s > t:
    (x) =+3
elif t > s:
    (y) =+3
elif s == t:
    (x)+1,(y)+1
print (x)
print (y)

Die + 3 rechnet er jeweils richtig auf.
s == t gibt er mir jeweils nur 0 0 aus anstatt 1 1
Bin am üben habe schon mehrere Variationen probiert.

Läuft ohne Fehlermeldung durch, aber halt das Ergebnis o ist falsch.

Danke

[pillmuncher]

Setz bitte Code in Codetags. Sonst kann man es nicht lesen.

Code: Alles auswählen

if s > t:
    (x) =+3
elif t > s:
    (y) =+3
elif s == t:
    (x)+1,(y)+1
print (x)
print (y)

Die + 3 rechnet er jeweils richtig auf.

Nein, tut "er" nicht. Dazu unten mehr.

Warum schreibst du x und y in Klammern? Das meinst du, bewirkt das?

Außerdem ist += nicht dasselbe wie =+:

Code: Alles auswählen

In [1]: x = 5

In [2]: x + 3
Out[2]: 8

In [3]: x
Out[3]: 5

In [4]: x =+ 3

In [5]: x
Out[5]: 3

In [6]: x += 4

In [7]: x
Out[7]: 7

bla =+ blub ist dasselbe wie bla = (+blub). += ist ein Operator, = + sind zwei.

[BlackJack]

@doclektor: Wenn `t` und `s` gleich sind veränderst Du weder `x` noch `y`. Du erstellst ein Tupel mit den Werten von `x` und `y` jeweils plus 1 und das wars. Mit dem Tupel wird dann nichts gemacht, es wird also einfach wieder verworfen und keinen sichtbaren Effekt.

[NoPy]

Code: Alles auswählen

if s > t: #das macht das, was Du erwartest
    x += 3 #(x) =+3 ist gleichbedeutend mit x = 3
elif t > s: #das macht das, was Du erwartest
    y += 3 #siehe oben
elif s == t: #das macht das, was Du erwartest
   x += 1
   y += 1  #(x)+1,(y)+1 erzeugt ein Tupel aus 2 Werten, die um je 1 größer sind, als x und y
print (x) #macht in etwa, was Du erwartest. Mit den Klammern erreichst Du, dass nicht etwa eine Zahl zurückgegeben wird, sondern ein Tupel mit einer Zahl
print (y)

[/me]

print (x) #macht in etwa, was Du erwartest. Mit den Klammern erreichst Du, dass nicht etwa eine Zahl zurückgegeben wird, sondern ein Tupel mit einer Zahl

Das ist falsch. Ein Tupel wird nicht durch die Klammern, sondern durch ein Komma definiert.

Code: Alles auswählen

>>> x = (1)
>>> x
1
>>> type(x)
<class 'int'>
>>> y = 1,
>>> y
(1,)
>>> type(y)
<class 'tuple'>

[bwbg]

Ergänzend hierzu:

Code: Alles auswählen

>>> ()
()
>>> type(())
<class 'tuple'>

Hier bildet () ein leeres Tupel.

[NoPy]

Ergänzend hierzu:

Code: Alles auswählen

>>> ()
()
>>> type(())
<class 'tuple'>

Hier bildet () ein leeres Tupel.

Hab es jetzt ausprobiert, da ist er wieder, mein persönlicher HÄ?- Effekt

Warum bilden
(1,2,3) und (1,2) Tupel
(1) kein Tupel
() wieder Tupel?

Kann man lernen, ohne Zweifel. Aber ist für mich schon überraschend

[cofi]

/me hat es schon gesagt: Tupel werden durch das Komma erzeugt, nicht durch die Klammern.
Damit hat man aber das Problem, dass man so keine Leeren Tupel erzeugen kann. So kommt es zum Sonderfall `()` fuer das leere Tupel (und wahrscheinlich zur irrigen Annahme, dass Tupel durch Klammern erzeugt werden).

[NoPy]

Nun gut, formuliere ich die Frage um:
Es gibt 2- elementige Tupel, 3- elementige Tupel ...

Irgendjemand benötigte auch mal ein 0- elementiges Tupel. Wofür?

Was passiert, wenn jemand ein 1- elementiges Tupel benötigt? Wie wird das definiert?

Beispiel:

Code: Alles auswählen

def SchreibDasAuf(a):
    for zeile in a:
        for element in zeile:
            print element

a = [[],[1],[1,2],[1,2,3],[1,2,3,4]]
b = ((),(1),(1,2),(1,2,3),(1,2,3,4))
SchreibDasAuf(a)
SchreibDasAuf(b)

[cofi]

1-elementige Tupel hat /me doch gezeigt.

Warum 0-elementige? Haeufig wird man sie nicht brauchen, aber auch ueber 0-elementige Tupel kann man iterieren:

Code: Alles auswählen

In [2]: for x in ():
   ...:     print x
   ...:

So braucht man keinen Spezialfall in dem Man zb eine Leere Liste statt einem Tupel benutzt.
Ehrlich gesagt kann ich mir momentan nur einen Nutzen als Default-Argument fuer Funktionnen vorstellen (und auch dort ist es zwingend noetig).

[NoPy]

ah, überlesen.

also
a3 = (1,2,3)
a2 = (1,2)
a1 = (1,)
a0 = ()

Nun ja ... kann man lernen

[BlackJack]

Leere Tupel kann man auch brauchen wenn man eine leere Sequenz benötigt aber Listen dafür nicht gehen, zum Beispiel weil Listen nicht „hashable“ sind und damit nicht als Schlüssel in Wörterbüchern oder als Elemente in Mengen verwendet werden können. Zum Beispiel wenn man ein Wörterbuch hat das Wege auf Kosten abbildet und ein Weg dabei durch eine Sequenz von Wegpunkten/Knoten beschrieben wird, dann möchte man vielleicht auch so etwas wie ``path2cost[()] = 0`` haben ohne das als Sonderfall behandeln zu müssen.

[kbr]

a3 = (1,2,3)
a2 = (1,2)
a1 = (1,)
a0 = ()

Die Klammern brauchst Du nur für den Sonderfall a0. Das Komma als Tuplekonstruktor ermöglicht auch so schöne Sachen wie

a, b = b, a

[pillmuncher]

Nun gut, formuliere ich die Frage um:
Es gibt 2- elementige Tupel, 3- elementige Tupel ...

Irgendjemand benötigte auch mal ein 0- elementiges Tupel. Wofür?

Abgesehen von der Hashbarkeit: Tupel bilden ein Monoid. Dazu benötigt man neben einer assoziativen Verkettungsoperation ( + bei Tupeln) auch ein Identitätselement und das ist das leere Tupel:

Code: Alles auswählen

In [1]: #Assoziativität:

In [2]: assert ((1,2) + (3,4)) + (5,6) == (1,2) + ((3,4) + (5,6)) == (1,2,3,4,5,6)

In [3]: #Identitätselement:

In [4]: assert () + (1,2,3) == (1,2,3) + () == (1,2,3)

Und hier sieht man, wofür man Klammern bei Tupeln braucht:

Code: Alles auswählen

In [5]: (1,2) + (3,4)
Out[5]: (1, 2, 3, 4)

In [6]: 1,2 + 3,4
Out[6]: (1, 5, 4)

Um es nochmal zu betonen: Bei der literalen Notation im Pythoncode ist das Komma der Tupel-Operator. Die Klammern dienen lediglich zur Disambiguierung. Ausnahme: das leere Tupel wird durch ein leeres Paar Klammern notiert. Man könnte es auch ohne literale Notation so schreiben:

Code: Alles auswählen

In [7]: tuple()
Out[7]: ()

[NoPy]

Euch mögen meine Fragen blöd vorkommen, aber Eure Antworten helfen mir. Daher werde ich auch nicht damit aufhören
Vielen Dank für die umfangreichen Erläuterungen.

Wenn der ","- operator Tupel- bildend ist, wie muss man denn dann das Komma innerhalb einer Liste interpretieren?

Code: Alles auswählen

a = (1,2,3)
b = 1,2,3
a == b #True

c = [(1,2,3)]
d = [1,2,3]
c == d #False

Wenn die Klammerung im ersten Fall (a,b) egal war, so ändert sie im zweiten Fall sehr wohl den Sachverhalt.
c ist eine Liste mit einem Tupel, d ist eine Liste mit 3 Integern.
Der einzige Unterschied ist die Klammer, die bei a und b egal war und hinsichtlich der Tupel- Bildung keine Bedeutung haben soll.

Ich bin sicher, Du hast eine Erklärung, bin schon neugierig, welche

[kbr]

Steigen wir in die banalen Niederungen der Schulmathematik mit der bekannten Regel: Punktrechnung vor Strichrechnung. In Pillmunchers Beispiel galt Strichrechung vor Tupelkonstruktor. D.h. der arithmetische Plus-Operator hatte die stärkere Bindung. Daher waren die Klammern erforderlich, um diese Bindung zu umgehen.
In dem Listenbeispiel ist es ähnlich: in einer Liste werden Elemente durch Kommata getrennt. Diese Regel hat eine stärkere Bindung als der Tupelkonstruktor. Daher benötigte Du Klammern in einer Liste um Tupel anzulegen.