Hi und willkommen im Forum.
Hmm, gute Frage
Es gibt einige die vertreten die Meinung das man nicht _alles_ bis zu einem Meteoriteneinschlag überprüfen sollte, sondern darauf vertrauen dass der Programmierer, der die Klasse verwendet, weiß was er tut (Also, das er die Dokumentation gelesen hat, und weiß was die richtigen Parameter, etc sind!)
Joa, bis zu einem gewissen grad bin ich auch der Meinung! ->
Es gibt aber Situationen das bei falsch übergebene Parametern im Programmverlauf eigenartige Fehler passieren und so eigenartige Exceptions ausgelöst werden die nicht unbedingt das aussagen was man gerne hätte
Oder noch schlimmer das die Klasse da einfach so hinnimmt und akzeptiert! 0__0 -> Das kann ich mir bei einer Bedingung wie "Zahl muss Positiv sein" sehr gut vorstellen das der Klasse das wenig juckt, wenn du das nicht vorher überprüfst und entsprechend darauf reagierst
Tja, ich bin ehrlich gesagt auch noch nicht in der Lage zu beurteilen wann es angebracht ist einen Parameter auf Datentype Gültigkeit hin zu überprüfen und bei ``False`` dann einen `TypeError` auszulösen :-[
Konnte dir zwar nicht wirklich helfen, daher sehe es als Gratispush vom Thread und als Thread-Abo von mir an, das ich mit diesem Post so eben Aboniert habe :p Mich interresiert nämlich auch wie das die anderen sehen.
Denoch meine Meinung dazu:
So vom Gefühl her
(und würde ich bei mir auch machen!) würde ich eine Überprüfung machen und zwar aus folgenden gründen:
Weil die x und y angaben im `Tuple`
Positive sein müssen! Genau das wird wohl ein grund sein wenn du negative Integerwerte angibst es trotzdem akzeptiert wird von deiner Klasse obwohl es nach _deinem_ Bedingungen nicht sein darf! Sehe ich das richtig?
Der nächste grund ist, das du im `Tuple`genau 2 werte von einem "einzigen" Datentype (int, long, oder eine Ableitung von eben genanten) voraussetzt! Da ist es mMn angebracht zu überprüfen...
Aber der wirklich ausschlaggebende Grund ist für mich das die Integerwerte Positiv sein müssen. So, was sollte man schon überprüfen, weil unter Umständen deine Klasse diesen "Fehler" Stil schweigend hinnehmen würde, anstatt mit einer Exception zu reagieren (Sehe ich das richtig, das deine Klasse bei einem Negativen Int ohne eine Exception darauf reagiert?)
Also konkreter: Wenn der Parameter Ein `Tuple` sein muss, dessen Inhalt alles mögliche sein kann oder besser gesagt nicht vom konkreten Datentype abhängig ist, würde ich mir eine Überprüfung sparen!
Wenn der Inhalt aber von einem Datentype sein
muss (in deinem Fall vom Type `int`, `long` und dazu noch positiv!) würde ich immer eine Überprüfung machen und entsprechende mit einer Exception reagieren, unabhängig davon was mir die andere sagen! Das ist für mich der bessere Stil
Mein Vorschlag:
Wenn kein `Tuple` übergeben wurde -> `TypeError` mit einer schönen Fehlermeldung raisen.
Code: Alles auswählen
if not isinstance(tuple_, tuple):
raise TypeError("deine Meldung")
Wenn die x, y werte im Tuple nicht vom Type int, long oder vom besagten abgeleitet sind -> `TypeError`
Code: Alles auswählen
if not isinstance(tuple_(0), int) or not isinstance(tuple_(1), int):
raise TypeError("deine Meldung")
Wenn die Integerwerte im `tuple` negativ sind, dann auch eine Exception auslösen (muss du wahrscheinlich eine eigene Exception Klasse dafür definieren. Ich weiß nicht ob es für negative Werte schon eine vorgefertigete klasse gibt.)
my 2 cents
lg und schönen rutsch ins neue Jahr
sape