Code: Alles auswählen
a = foo()
if a is not False:
print a
Code: Alles auswählen
print a if (a = foo() is not False)
Code: Alles auswählen
a = foo()
if a is not False:
print a
Code: Alles auswählen
print a if (a = foo() is not False)
Dein Punkt ist wahrscheinlich ein anderer, aber was it falsch mit dieser Verkürzung:droptix hat geschrieben:Kennt ihr sowas auch?
Ich wünsche mir da manchmal eine verkürzte Form, wo ich a nicht unbedingt erst zwischenspeichern muss, bevor ich a nicht wirklich brauche. Jetzt kommt Pseudo-Code:Code: Alles auswählen
a = foo() if a is not False: print a
Code: Alles auswählen
print a if (a = foo() is not False)
Code: Alles auswählen
if foo(): print foo()
Na foo() wird zwei Mal ausgeführt. Das muss nicht sein, da bereits der erste Aufruf das gewünschte Ergebnis liefert. Und wenn foo() sehr zeitaufwändig arbeitet und/oder dazu noch in einer Schleife aufgerufen wird, geht das deutlich zu lasten der Performance.alban hat geschrieben:Dein Punkt ist wahrscheinlich ein anderer, aber was it falsch mit dieser Verkürzung:Die erste Vereinfachung ist anstatt not False -> True zu testen. Dann nicht erst einer Variable zuordnen, sonder gleich die Funktion nehmen.Code: Alles auswählen
if foo(): print foo()
Oder stellt euch vor foo() gibt die aktuelle Mikrosekunde aus.droptix hat geschrieben:Na foo() wird zwei Mal ausgeführt. Das muss nicht sein, da bereits der erste Aufruf das gewünschte Ergebnis liefert. Und wenn foo() sehr zeitaufwändig arbeitet und/oder dazu noch in einer Schleife aufgerufen wird, geht das deutlich zu lasten der Performance.
Das würde ich eher so schreiben:droptix hat geschrieben:Kennt ihr sowas auch?
Code: Alles auswählen
a = foo() if a is not False: print a
Code: Alles auswählen
a = foo()
if a:
print a
Das ist jetzt nicht Dein Ernst, oder? Du hast da genau das gleiche geschrieben wie oben, nur in einer anderen Reihenfolge. Was ist daran jetzt vereinfacht? Und das Ergebnis der Funktion wird auch hier "zwischengeschpeichert", nämlich in jedem Fall an `a` gebunden.Ich wünsche mir da manchmal eine verkürzte Form, wo ich a nicht unbedingt erst zwischenspeichern muss, bevor ich a nicht wirklich brauche. Jetzt kommt Pseudo-Code:
Code: Alles auswählen
print a if (a = foo() is not False)
Is ja mein Problem, dass ich es gern ohne Zwischenspeichern machen würde, aber nicht weiß wie man das ausdrücken soll Vielleicht noch so hier:BlackJack hat geschrieben:Das ist jetzt nicht Dein Ernst, oder? Du hast da genau das gleiche geschrieben wie oben, nur in einer anderen Reihenfolge. Was ist daran jetzt vereinfacht? Und das Ergebnis der Funktion wird auch hier "zwischengeschpeichert", nämlich in jedem Fall an `a` gebunden.
Code: Alles auswählen
print foo() if not False
Code: Alles auswählen
a = foo() if not False
if a:
print a
Code: Alles auswählen
def ifthen(condition, expression):
if condition:
return expression(condition)
Code: Alles auswählen
def out(spam):
print spam
ifthen(foo(), out)
Code: Alles auswählen
ifthen(foo(), lambda x : sys.stdout.write(x))
Du möchtest es nicht an einen Namen binden, aber später noch darauf zugreifen!? Das widerspricht sich irgendwie.droptix hat geschrieben:Is ja mein Problem, dass ich es gern ohne Zwischenspeichern machen würde, aber nicht weiß wie man das ausdrücken soll Vielleicht noch so hier:BlackJack hat geschrieben:Das ist jetzt nicht Dein Ernst, oder? Du hast da genau das gleiche geschrieben wie oben, nur in einer anderen Reihenfolge. Was ist daran jetzt vereinfacht? Und das Ergebnis der Funktion wird auch hier "zwischengeschpeichert", nämlich in jedem Fall an `a` gebunden.
Das trifft's vielleicht eher. Dann kann ich aber mit dem Ergebnis nicht weiterarbeiten...Code: Alles auswählen
print foo() if not False
Könntest Du davon bitte mal die Semantik erklären? Die erschliesst sich mir gerade so gar nicht. An was ist `a` nach Ausführung der der ersten Zeile gebunden für die Fälle 1) `foo()` gibt `False` zurück und 2) `foo()` gibt etwas ungleich `False` zurück?Code: Alles auswählen
a = foo() if not False if a: print a
Code: Alles auswählen
def do_if_not_false(var, operation):
if var:
operation(var)
def mein_print(x):
print x
do_if_not_false(foo(), mein_print)
Verstehe ehrlich auch nicht worauf du hinaus willst.droptix hat geschrieben:Code: Alles auswählen
a = foo() if not False if a: print a
Code: Alles auswählen
class foo(object):
pass
x = foo()
if isinstance(x, foo):
print "x ist Instanz von foo"
else:
print "x != Instanz von foo"
x = 1
if isinstance(x, foo):
print "x ist Instanz von foo"
else:
print "x != Instanz von foo"
Code: Alles auswählen
x ist Instanz von foo
x != Instanz von foo
Code: Alles auswählen
class foo(object):
pass
x = 1
if x:
print "x ist True"
x = foo()
if x:
print "x ist True"
Code: Alles auswählen
class foo(object):
pass
if x:
print "x ist True"
if x:
print "x ist True"
Code: Alles auswählen
class foo(object):
pass
x = 1
if x:
print "x ist True"
x = foo()
if x:
print "x ist True"
x = "test"
if x:
print "x ist True"
Hatte ich vergessen zu erwähnen, dachte es kommt schon korrekt rüber: foo() gibt False zurück, wenn die Prozedur innerhalb von foo() nicht erfolgreich war. Andernfalls liefert foo() einen Wert ungleich False.BlackJack hat geschrieben:Könntest Du davon bitte mal die Semantik erklären? Die erschliesst sich mir gerade so gar nicht. An was ist `a` nach Ausführung der der ersten Zeile gebunden für die Fälle 1) `foo()` gibt `False` zurück und 2) `foo()` gibt etwas ungleich `False` zurück?
Code: Alles auswählen
if foo() is not False:
print foo()
Code: Alles auswählen
<?php
if (($a = foo()) !== false) {
echo $a;
}
?>
Mit Prozedur innerhalb von `foo` willst du also sagen das `Foo` eine Klasse ist? Dan meinst du den Konstruktor. Der Konstruktor kann keinen von dir mit `return` bestimmten Wert zurückliefern, sondern erzeugt eine Instanz von `Foo`.foo() gibt False zurück, wenn die Prozedur innerhalb von foo() nicht erfolgreich war
Code: Alles auswählen
class Foo(object):
def __init__(self, filename):
path = os.path.split(filename)[0]
if not os.path.exists(path):
raise IOError(2, "Der angegeben Pfad existiert nicht", path)
try:
x = Foo("test")
print "ok"
print x
except IOError:
print "nicht ok"
Code: Alles auswählen
def foo(val):
def tester(val):
if val != 100:
return False
else:
return True
return tester(val)
if foo(1):
print "True"
else:
print "False"
Warum? `Foo` = Derivat von `bool`? Also es wird eine Instanz von `Foo` in `a` erzeugt das lediglich ein bool Derivat ist? Oder soll der Konstruktor von `Foo` einen Bolschen wert returnen? 0oHatte ich vergessen zu erwähnen, dachte es kommt schon korrekt rüber: foo() gibt False zurück, wenn die Prozedur innerhalb von foo() nicht erfolgreich war. Andernfalls liefert foo() einen Wert ungleich False.
Code: Alles auswählen
class Foo(object):
def __init__(self, val):
# wenn val nit ok...
[...]
return False # Geht nicht!
# wenn ok
[...]
return True # geht auch nicht!
Foo(1)
Code: Alles auswählen
TypeError: __init__() should return None, not 'bool'
Was zum kuckuck spricht den bitte gegen folgendes?droptix hat geschrieben:[...]
Sowas in der Art hatten wir ja oben schon. Nun die Frage: Wie löst man das am besten, wenn man nicht zwei Mal foo() schreiben will, weil foo() dann auch zwei Mal ausgeführt wird?
In PHP gibt's da beispielsweise sowas:
Code: Alles auswählen
<?php if (($a = foo()) !== false) { echo $a; } ?>
Code: Alles auswählen
a=foo()
if a:
print a
print "a ist True ;)"
else:
print a
print "a ist False ;)"
Macht bitte keine Wissenschaft draus... mit foo() meinte ich eine simple Funktion und mit Prozedur die Aufgabe, die die Funktion zu erfüllen hat. Wenn die Aufgabe fehlschlägt (z.B. Division durch Null oder was weiß ich sonst noch), dann liefert die Funktion halt False zurück.sape hat geschrieben:Mit Prozedur innerhalb von `foo` willst du also sagen das `Foo` eine Klasse ist? Dan meinst du den Konstruktor. Der Konstruktor kann keinen von dir mit `return` bestimmten Wert zurückliefern, sondern erzeugt eine Instanz von `Foo`.
Laut Wikipedia wäre eine Prozedur in der Programmierung eine Funktion/Methode, die keinen Rückgabewert erzeugt. Macht auch Sinn... aber der Begriff wäre eng gesehen in meinem Fall falsch gewählt, da ja im Fehlerfall False zurück gegeben wird.sape hat geschrieben:Oder redest du von einer Funktion die innerhalb wider eine Funktion hat?
Is doch völlig Wurscht. Es ging mir nur um syntaktische Möglichkeiten.sape hat geschrieben:Bevor ich ein weiteres mal die Glaskugel raushole, bitte mal konkreter werden! Zeig mal was genau `Foo`ist Danke.
Theoretisch gesehen nichts. Wie gesagt, es ging mir um syntaktische Möglichkeiten.sape hat geschrieben:Was zum kuckuck spricht den bitte gegen folgendes?Code: Alles auswählen
a=foo() if a: print a print "a ist True ;)" else: print a print "a ist False ;)"
Code: Alles auswählen
def ListDir(path):
try:
c = os.listdir(path)
except:
return False
r = {
'dirs': [],
'files': [],
'links': []
}
for i in c:
item = os.path.join(path, i)
if os.is_link(item):
r['links'].append(i)
elif os.is_dir(item):
r['dirs'].append(i)
elif os.is_file(item):
r['files'].append(i)
return r
Code: Alles auswählen
def Walk(path):
r = ListDir(path)
if r is not False:
print path
for d in r['dirs']:
Walk(os.path.join(path, d))
Walk("/")
Code: Alles auswählen
print path if ListDir(path) is not False
Code: Alles auswählen
class MeineException(Exception):
pass
def list_dir(path):
try:
c = os.listdir(path)
except Exception,e:
raise MeineException("Fehler bei listdir")
r = {
'dirs': [],
'files': [],
'links': []
}
for i in c:
item = os.path.join(path, i)
if os.is_link(item):
r['links'].append(i)
elif os.is_dir(item):
r['dirs'].append(i)
elif os.is_file(item):
r['files'].append(i)
return r
try:
a = list_dir(mein_pfad)
print a
except MeineException, e:
print 'listdir fehlgeschlagen'
Ich schliesse mich rayo an: Ausnahmen wurden eingeführt um spezielle Rückgabewerte, die einen Fehler signalisieren, loszuwerden. Sie zu behandeln indem ein "Fehlerwert" zurückgegeben wird, ist ein Rückschritt. Behandele die Ausnahme lieber in Deiner `walk()`-Funktion.droptix hat geschrieben:In einem Fall habe ich ne Funktion ListDir, die mir den Verzeichnisinhalt eines Pfades einliest. Wenn alles klar ging, liefert die Funktion ein Dict zurück. Wenn dabei was schief ging (Pfad falsch, keine Zugriffsrechte etc.), dann eben False:
Code: Alles auswählen
def list_dir(path):
dirs = list()
files = list()
links = list()
for name in os.listdir(path):
full_name = os.path.join(path, name)
if os.path.islink(full_name):
links.append(name)
elif os.path.isdir(full_name):
dirs.append(name)
elif os.path.isfile(full_name):
files.append(name)
return dirs, files, links
def walk(path):
try:
dirs, dummy, dummy = list_dir(path)
print path
for dirname in dirs:
walk(os.path.join(path, dirname))
except IOError:
pass
Code: Alles auswählen
def walk(path, onerror=None):
try:
dirs, dummy, dummy = list_dir(path)
print path
for dirname in dirs:
walk(os.path.join(path, dirname))
except IOError, error:
if onerror is not None:
if onerror == 'raise':
raise
else:
onerror(error)
Du hast von einer Methode innerhalb von `foo`geredet und da bin ich dann davon ausgegangen das `foo` eine Klasse sein muss, weil alle Funktionen innerhalb einer Klasse eben Methode genannt werden. Daher meine frage. Also Sorry, war mein Fehler...droptix hat geschrieben:[...]
Macht bitte keine Wissenschaft draus... mit foo() meinte ich eine simple Funktion und mit Prozedur die Aufgabe, die die Funktion zu erfüllen hat. Wenn die Aufgabe fehlschlägt (z.B. Division durch Null oder was weiß ich sonst noch), dann liefert die Funktion halt False zurück.
Da würde ich eine Exception liefern! Grade bei solchen Sachen wie "Datei nicht vorhanden, Falscher Pfad, ungültige Dateizugriffsrechte" _müssen_ Exceptions (die darauf hinweißen) ausgelöst werden. Schließlich ist das ja eine Ausnahme verhalten. Ein schlichtes `False` ist einfach ungenügend und man weiß dann nicht woran der Fehler lag und kann dann nicht darauf entsprechend richtig reagieren.In einem Fall habe ich ne Funktion ListDir, die mir den Verzeichnisinhalt eines Pfades einliest. Wenn alles klar ging, liefert die Funktion ein Dict zurück. Wenn dabei was schief ging (Pfad falsch, keine Zugriffsrechte etc.), dann eben False:
In meinem Fall ungenügend, weil ich auch Symlinks auswerten möchte und später auch Junctions.rayo hat geschrieben:PS: für den rekursiven durchlauf von Verzeichnissen ist os.walk ganz gut geeignet
Hmmm, manchmal ist das einfach unangenehm, viele try-except-Statements zu verwenden, wenn mir ein einfaches False reichen würde. Denn ich möchte gar nicht weiter auswerten, warum os.listdir() eine Ausnahme erzeugte. Wenn ein Fehler vorkommt, wird das aktuelle Verzeichnis eben übersprungen.BlackJack hat geschrieben:Ich schliesse mich rayo an: Ausnahmen wurden eingeführt um spezielle Rückgabewerte, die einen Fehler signalisieren, loszuwerden. Sie zu behandeln indem ein "Fehlerwert" zurückgegeben wird, ist ein Rückschritt.
Uh, was ist der genaue Unterschied zwischen Gleicheit und Identität? Und was ist ein Singleton?BlackJack hat geschrieben:Aber werde auf jeden Fall den Identitätstest auf `False` los. `True` und `False` sind nur Namen, es handelt sich nicht um Singletons wie bei `None`, also sollte man auch nicht auf Identität sondern auf Gleichheit testen.
Ist netter, geb ich zu. Bei except passiert hier halt nix. Aber es wäre zumindest vorbereitet, wenn das später mal interessant werden sollte... Macht es hier eigentlich einen Unterschied, ob man foo = [] oder foo = list() verwendet?BlackJack hat geschrieben:Ich hätte die Funtkionen so geschrieben:
Code: Alles auswählen
def list_dir(path): dirs = list() files = list() links = list() for name in os.listdir(path): full_name = os.path.join(path, name) if os.path.islink(full_name): links.append(name) elif os.path.isdir(full_name): dirs.append(name) elif os.path.isfile(full_name): files.append(name) return dirs, files, links def walk(path): try: dirs, dummy, dummy = list_dir(path) print path for dirname in dirs: walk(os.path.join(path, dirname)) except IOError: pass
Nee, hab ich nie so erwähnt. Daher verwunderte mich deine Interpretationsfreudesape hat geschrieben:Du hast von einer Methode innerhalb von `foo`geredet und da bin ich dann davon ausgegangen das `foo` eine Klasse sein muss, weil alle Funktionen innerhalb einer Klasse eben Methode genannt werden.
Nein, im Großen und Ganzen eigentlich nicht. Aber guck doch mal in die [wiki]FAQ#GibtEsEinenUnterschiedZwischenlistBzwdict[/wiki], dort wird genau diese Frage diskutiert.droptix hat geschrieben:Macht es hier eigentlich einen Unterschied, ob man foo = [] oder foo = list() verwendet?