Ich versuche gerade ein paar Perl-Scripte nach Python umzusetzen und wundere mich, dass Python bei bestimmten Konstrukten ziemlich umstaendlich ist (oder ich die Syntax nicht verstehe). Beispiel: Perl: if (@ARGV and $ARGV[0] =~ /(\w+)/) { print "$1\n" } Python: if len(sys.argv)>1: m = re.match(r".*?(\w+)",sys.argv[1]) if m: print m.group(1) Mein erster Ansatz if len(sys.argv)>1 and m = re.match(r".*?(\w+)",sys.argv[1]): print m.group(1) erbrachte einen syntax error: Zuweisungen sind bei if nicht zulaessig?! -- + Ulli Horlacher + framstag@tandem-fahren.de + http://tandem-fahren.de/ +
On Apr 10, 2012, at 8:17 AM, Ulli Horlacher wrote:
Ich versuche gerade ein paar Perl-Scripte nach Python umzusetzen und wundere mich, dass Python bei bestimmten Konstrukten ziemlich umstaendlich ist (oder ich die Syntax nicht verstehe). Beispiel:
Perl:
if (@ARGV and $ARGV[0] =~ /(\w+)/) { print "$1\n" }
Python:
if len(sys.argv)>1: m = re.match(r".*?(\w+)",sys.argv[1]) if m: print m.group(1)
Mein erster Ansatz
if len(sys.argv)>1 and m = re.match(r".*?(\w+)",sys.argv[1]): print m.group(1)
erbrachte einen syntax error: Zuweisungen sind bei if nicht zulaessig?!
Nein, ist es nicht. Um genau sowas und die subtilen Fehler, die daraus entstehen koennen (= statt == geschrieben) zu vermeiden. Und alles in eine Zeile zu quetschen ist ebenfalls nicht gerne gesehen. Wenn du unleserlichen Code haben magst - warum dann weg von Perl gehen? Diez
Am 10.04.2012 08:17 schrieb Ulli Horlacher:
Ich versuche gerade ein paar Perl-Scripte nach Python umzusetzen und wundere mich, dass Python bei bestimmten Konstrukten ziemlich umstaendlich ist (oder ich die Syntax nicht verstehe). Beispiel:
Perl:
if (@ARGV and $ARGV[0] =~ /(\w+)/) { print "$1\n" }
Python:
if len(sys.argv)>1: m = re.match(r".*?(\w+)",sys.argv[1]) if m: print m.group(1)
BTW: (s.u.)
Mein erster Ansatz
if len(sys.argv)>1 and m = re.match(r".*?(\w+)",sys.argv[1]): print m.group(1)
erbrachte einen syntax error: Zuweisungen sind bei if nicht zulaessig?!
Nein, diese beiden sind strikt getrennt. AFAICT kannst Du nur mit zwei Ebene arbeiten, wie Du schriebst. Aber Deine RE ist zu kompliziert. Wenn Du re.search() statt re.match() verwendest, kannst Du das .*? weglassen: m = re.search(r"(\w+)", sys.argv[1]) Thomas
Thomas Rachel <nutznetz-0c1b6768-bfa9-48d5-a470-7603bd3aa915@spamschutz.glglgl.de> wrote:
Perl:
if (@ARGV and $ARGV[0] =~ /(\w+)/) { print "$1\n" }
Python:
if len(sys.argv)>1: m = re.match(r".*?(\w+)",sys.argv[1]) if m: print m.group(1)
if len(sys.argv)>1 and m = re.match(r".*?(\w+)",sys.argv[1]): print m.group(1)
erbrachte einen syntax error: Zuweisungen sind bei if nicht zulaessig?!
Nein, diese beiden sind strikt getrennt. AFAICT kannst Du nur mit zwei Ebene arbeiten, wie Du schriebst.
Aber Deine RE ist zu kompliziert. Wenn Du re.search() statt re.match() verwendest, kannst Du das .*? weglassen:
m = re.search(r"(\w+)", sys.argv[1])
Das ist schon mal was :-) Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben: def match(x,s,f=None): global _ _ = [ '' ] if f: m = re.search(x,s,flags=f) else: m = re.search(x,s) if m and m.groups: _.extend(m.groups()) return m Damit kann ich jetzt wie gewohnt in einer Zeile eine Abfrage machen: if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print _[1] -- + Ulli Horlacher + framstag@tandem-fahren.de + http://tandem-fahren.de/ +
Ulli Horlacher, 10.04.2012 11:59:
def match(x,s,f=None): global _ _ = [ '' ]
Örks - globale Variablen für Ergebnisse? Und dann auch noch ohne vernünftigen Namen? Das ist aber ganz schön böse.
if f: m = re.search(x,s,flags=f) else: m = re.search(x,s)
Schau mal in die Doku von re.search() rein, da steht "flags=0". Wenn du also oben in der Signatur statt "f=None" schreibst "flags=0", kannst du die vier Zeilen verkürzen zu m = re.search(x, s, flags=flags)
if m and m.groups: _.extend(m.groups()) return m
Warum nicht einfach "return m.groups()"? Oder auch return m.groups() if m else None Brauchst du noch mehr als Ergebnis? Ansonsten gilt das, was Christopher Arndt geschrieben hat: warum regexen benutzen, wenn es auch sauber geht? Stefan
Am 10.04.2012 11:59, schrieb Ulli Horlacher:
Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben:
def match(x,s,f=None): global _ _ = [ '' ]
Funktionen mit Seiten-Effekten sind ganz, ganz schlechter Stil. ja, das macht man in Perl, aber um jemand anderes kann das kaum noch lesen und verstehen. -- Schönen Gruß - Regards Hartmut Goebel Dipl.-Informatiker (univ.), CISSP, CSSLP Goebel Consult Spezialist für IT-Sicherheit in komplexen Umgebungen http://www.goebel-consult.de Monatliche Kolumne: http://www.cissp-gefluester.de/ Goebel Consult ist Mitglied bei http://www.7-it.de
Autsch. Nicht gerade was man pythonisch nennt. Aber sei's drum. Nur solltest du mit dem _ aufpassen - afaik wird das als temporärer Name in List comprehensions verwandt - und damit könntest du in Probleme kommen, weil da was anderes drin ist als du erwartest. Da wäre ein anderer Name vielleicht besser. Diez Am 10.04.2012 um 11:59 schrieb Ulli Horlacher <framstag@tandem-fahren.de>:
Thomas Rachel <nutznetz-0c1b6768-bfa9-48d5-a470-7603bd3aa915@spamschutz.glglgl.de> wrote:
Perl:
if (@ARGV and $ARGV[0] =~ /(\w+)/) { print "$1\n" }
Python:
if len(sys.argv)>1: m = re.match(r".*?(\w+)",sys.argv[1]) if m: print m.group(1)
if len(sys.argv)>1 and m = re.match(r".*?(\w+)",sys.argv[1]): print m.group(1)
erbrachte einen syntax error: Zuweisungen sind bei if nicht zulaessig?!
Nein, diese beiden sind strikt getrennt. AFAICT kannst Du nur mit zwei Ebene arbeiten, wie Du schriebst.
Aber Deine RE ist zu kompliziert. Wenn Du re.search() statt re.match() verwendest, kannst Du das .*? weglassen:
m = re.search(r"(\w+)", sys.argv[1])
Das ist schon mal was :-)
Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben:
def match(x,s,f=None): global _ _ = [ '' ] if f: m = re.search(x,s,flags=f) else: m = re.search(x,s)
if m and m.groups: _.extend(m.groups()) return m
Damit kann ich jetzt wie gewohnt in einer Zeile eine Abfrage machen:
if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print _[1]
-- + Ulli Horlacher + framstag@tandem-fahren.de + http://tandem-fahren.de/ + _______________________________________________ python-de maillist - python-de@python.org http://mail.python.org/mailman/listinfo/python-de
Am 10.04.2012 12:30, schrieb Diez B. Roggisch:
Aber sei's drum. Nur solltest du mit dem _ aufpassen - afaik wird das als temporärer Name in List comprehensions verwandt - und damit könntest du in Probleme kommen, weil da was anderes drin ist als du erwartest.
*Dieses* Problem besteht allerdings nicht, da die temporärer Namen in List Comprehensions `_[0]`, `_[1]`, usw. lauten. Diese Namen sind in Python gar nicht zulässig. Ein Namenskonflikt ist daher ausgeschlossen. (Alles andere wäre auch ein Armutszeugnis für die Entwickler von Python.) Dennoch:
Da wäre ein anderer Name vielleicht besser.
Aber bei einem ehem. Perl-Jünger stoßen diese Tipps wohl nicht auf allzu großes Gehör. -- Schönen Gruß - Regards Hartmut Goebel Dipl.-Informatiker (univ.), CISSP, CSSLP Goebel Consult Spezialist für IT-Sicherheit in komplexen Umgebungen http://www.goebel-consult.de Monatliche Kolumne: http://www.cissp-gefluester.de/ Goebel Consult ist Mitglied bei http://www.7-it.de
Ah, gut zu wissen. Hab das dann wohl mit dem _ im repl verwechselt. Diez Am 10.04.2012 um 13:28 schrieb Hartmut Goebel <h.goebel@goebel-consult.de>:
Am 10.04.2012 12:30, schrieb Diez B. Roggisch:
Aber sei's drum. Nur solltest du mit dem _ aufpassen - afaik wird das als temporärer Name in List comprehensions verwandt - und damit könntest du in Probleme kommen, weil da was anderes drin ist als du erwartest.
*Dieses* Problem besteht allerdings nicht, da die temporärer Namen in List Comprehensions `_[0]`, `_[1]`, usw. lauten. Diese Namen sind in Python gar nicht zulässig. Ein Namenskonflikt ist daher ausgeschlossen. (Alles andere wäre auch ein Armutszeugnis für die Entwickler von Python.)
Dennoch:
Da wäre ein anderer Name vielleicht besser.
Aber bei einem ehem. Perl-Jünger stoßen diese Tipps wohl nicht auf allzu großes Gehör.
-- Schönen Gruß - Regards Hartmut Goebel Dipl.-Informatiker (univ.), CISSP, CSSLP
Goebel Consult Spezialist für IT-Sicherheit in komplexen Umgebungen http://www.goebel-consult.de
Monatliche Kolumne: http://www.cissp-gefluester.de/ Goebel Consult ist Mitglied bei http://www.7-it.de
_______________________________________________ python-de maillist - python-de@python.org http://mail.python.org/mailman/listinfo/python-de
Am 10.04.2012 13:28 schrieb Hartmut Goebel:
Am 10.04.2012 12:30, schrieb Diez B. Roggisch:
Aber sei's drum. Nur solltest du mit dem _ aufpassen - afaik wird das als temporärer Name in List comprehensions verwandt - und damit könntest du in Probleme kommen, weil da was anderes drin ist als du erwartest.
*Dieses* Problem besteht allerdings nicht, da die temporärer Namen in List Comprehensions `_[0]`, `_[1]`, usw. lauten.
Versteh ich jetzt nicht ganz. Wenn ich folgendes mache: def f(x): global _ _ = [] und dann def g(): l = [a for a, _ in pairs] print _ (ist jetzt frei erfunden, Kontext bitte passend dazudenken) dann habe ich in g() ein potentiell unerwartetes Ergebnis, nämlich den Wert des zweiten Elements des letzten pairs-Elements, nicht etwa die global definierte list. Ganz böse wird es bei def h(): global _ l = [a for a, _ in pairs] weil da das global definierte _ durch etwas ganz anderes ersetzt wird (zumindest in 2.x).
Diese Namen sind in Python gar nicht zulässig. Ein Namenskonflikt ist daher ausgeschlossen.
Hä? Wenn ein Objekt, das unter _ angesprochen wird, __getitem__() implementiert, ist _[1] doch einwandfrei gültig, wenn auch nicht als Bezeichner, sondern als Ausdruck? Oder verstehe ich Dich grade komplett miß? Thomas
Am 10.04.2012 16:24, schrieb Thomas Rachel:
Am 10.04.2012 13:28 schrieb Hartmut Goebel:
Am 10.04.2012 12:30, schrieb Diez B. Roggisch:
Aber sei's drum. Nur solltest du mit dem _ aufpassen - afaik wird das als temporärer Name in List comprehensions verwandt - und damit könntest du in Probleme kommen, weil da was anderes drin ist als du erwartest.
*Dieses* Problem besteht allerdings nicht, da die temporärer Namen in List Comprehensions `_[0]`, `_[1]`, usw. lauten.
Versteh ich jetzt nicht ganz. Wenn ich folgendes mache:
[...]
Diese Namen sind in Python gar nicht zulässig. Ein Namenskonflikt ist daher ausgeschlossen.
Hä? Wenn ein Objekt, das unter _ angesprochen wird, __getitem__() implementiert, ist _[1] doch einwandfrei gültig, wenn auch nicht als Bezeichner, sondern als Ausdruck?
Oder verstehe ich Dich grade komplett miß?
Ja, ziemlich. In List Comprehensions werden Variablen benutzt, die den Namen (=Bezeichner) `_[1]' haben:
def f(): [ xx for aa in AA ] ... dis.dis(f) [....] 6 BUILD_LIST 0 9 DUP_TOP 10 LOAD_ATTR 0 (append) 13 STORE_FAST 0 (_[1])
-- Schönen Gruß - Regards Hartmut Goebel Dipl.-Informatiker (univ.), CISSP, CSSLP Goebel Consult Spezialist für IT-Sicherheit in komplexen Umgebungen http://www.goebel-consult.de Monatliche Kolumne: http://www.cissp-gefluester.de/ Goebel Consult ist Mitglied bei http://www.7-it.de
Am 10. April 2012 16:24 schrieb Thomas Rachel <nutznetz-0c1b6768-bfa9-48d5-a470-7603bd3aa915@spamschutz.glglgl.de>:
Am 10.04.2012 13:28 schrieb Hartmut Goebel:
Am 10.04.2012 12:30, schrieb Diez B. Roggisch:
Aber sei's drum. Nur solltest du mit dem _ aufpassen - afaik wird das als temporärer Name in List comprehensions verwandt - und damit könntest du in Probleme kommen, weil da was anderes drin ist als du erwartest.
*Dieses* Problem besteht allerdings nicht, da die temporärer Namen in List Comprehensions `_[0]`, `_[1]`, usw. lauten.
Versteh ich jetzt nicht ganz. Wenn ich folgendes mache:
def f(x): global _ _ = []
und dann
def g(): l = [a for a, _ in pairs] print _
(ist jetzt frei erfunden, Kontext bitte passend dazudenken)
dann habe ich in g() ein potentiell unerwartetes Ergebnis, nämlich den Wert des zweiten Elements des letzten pairs-Elements, nicht etwa die global definierte list.
Ganz böse wird es bei
def h(): global _ l = [a for a, _ in pairs]
weil da das global definierte _ durch etwas ganz anderes ersetzt wird
(zumindest in 2.x).
Diese Namen sind in Python gar nicht zulässig. Ein Namenskonflikt ist daher ausgeschlossen.
Hä? Wenn ein Objekt, das unter _ angesprochen wird, __getitem__() implementiert, ist _[1] doch einwandfrei gültig, wenn auch nicht als Bezeichner, sondern als Ausdruck?
Oder verstehe ich Dich grade komplett miß?
Ja, denn es geht um etwas ganz anderes. Bis Python 2.6 hat der Interpreter *implizit* die sich noch im Aufbau befindliche Liste während der Ausführung einer List-Comprehension an den Namen "_[1]" gebunden. Derartige Namen sind zwar syntaktisch nicht gültig, doch die Semantik von Python unterstützt sie durchaus [1]. Man konnte diese Namen missbrauchen, um auf diese Liste zuzugreifen, und beispielsweise "[x for x in l if x not in locals()['_[1]']]" verwenden, um eine duplikatfreie Liste zu erzeugen. Allerdings waren diese Namen immer Implementierungsdetail, und wurden in Python 2.7 ohnehin entfernt. [1] Man kann in Python syntaktisch nicht gültige Namen für Attribute verwenden, indem man indirekt, beispielsweise über "globals()" oder über "setattr()" darauf zugreift. "setattr(some_object, 'foo + bar')" erzeugt das Attribut "foo + bar" auf "some_object", an das man – da "foo + bar" syntaktisch nicht gültig ist – allerdings nur über "getattr()" herankommt.
Hallöchen! Ulli Horlacher schreibt:
[...]
Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben:
def match(x,s,f=None): global _ _ = [ '' ] if f: m = re.search(x,s,flags=f) else: m = re.search(x,s)
if m and m.groups: _.extend(m.groups()) return m
Damit kann ich jetzt wie gewohnt in einer Zeile eine Abfrage machen:
if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print _[1]
So etwas ist sehr schlecht wartbar. Ich weiß, daß man sich manchmal selbst damit tröstet wie "ist eh ein Wegwerfprogramm" oder "ich mache das nur sehr lokal an dieser Stelle", aber das bißchen Tipperei, das man spart, lohnt sich nie, als daß man sich damit einen schlechten Stil angewöhnt. Ich pesönlich habe halt immer die Extrazeile in meinen Programmen, selbst wenn ich an einer Stelle viele Regexes habe. So what. Du kannst auch "match" zweimal aufrufen, einmal zum testen und einmal zum Benutzen des Funktionsergebnisses. Je nach Programm ist der Unterschied in der Laufzeit nahezu Null. Es gibt noch weitere Möglichkeiten, aber die hängen von deinen Usecases ab. Tschö, Torsten. -- Torsten Bronger Jabber-ID: torsten.bronger@jabber.rwth-aachen.de oder http://bronger-jmp.appspot.com
Torsten Bronger <bronger@physik.rwth-aachen.de> wrote:
Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben:
if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print _[1]
So etwas ist sehr schlecht wartbar.
Warum?
Tipperei, das man spart, lohnt sich nie, als daß man sich damit einen schlechten Stil angewöhnt.
Warum sind Funktionen schlechter Stil? -- Ullrich Horlacher Informationssysteme und Serverbetrieb Rechenzentrum E-Mail: horlacher@rus.uni-stuttgart.de Universitaet Stuttgart Tel: ++49-711-685-65868 Allmandring 30 Fax: ++49-711-682357 70550 Stuttgart (Germany) WWW: http://www.rus.uni-stuttgart.de/
On Tue, 10 Apr 2012 20:57:42 +0000 (UTC) Ulli Horlacher <framstag@rus.uni-stuttgart.de> wrote:
Torsten Bronger <bronger@physik.rwth-aachen.de> wrote:
Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben:
if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print _[1]
So etwas ist sehr schlecht wartbar.
Warum?
Weil es deutlich komplizierter ausschaut und nicht sofort offensichtlich ist was es macht. Ganz im Gegensatz zur verwendung von Kommandozeilenparsern *hint* *hint*
Tipperei, das man spart, lohnt sich nie, als daß man sich damit einen schlechten Stil angewöhnt.
Warum sind Funktionen schlechter Stil?
Nicht funktionen sind schlechter Stil sondern Funktionen die ihre Rückgabewerte in modulglobalen Variablen zurückgeben. Statt sie, nun ja, also Rückgabewerte zurückzugeben. grüße, Marek
Hallöchen! Ulli Horlacher schreibt:
Torsten Bronger <bronger@physik.rwth-aachen.de> wrote:
Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben:
if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print _[1]
So etwas ist sehr schlecht wartbar.
Warum?
Weil man sich fragt, wo der Wert des "_" herkommt. Schlimmer noch, ein anderer Programmierer wird davon ausgehen, daß "_" denselben Inhalt hat wie vor dieser Zeile -- denn es wurde mit diesem Symbol ja scheinbar nichts gemacht. Tschö, Torsten. -- Torsten Bronger Jabber-ID: torsten.bronger@jabber.rwth-aachen.de oder http://bronger-jmp.appspot.com
Am 10.04.2012 11:59 schrieb Ulli Horlacher:
Weil meine Programme exzessiv regexp und backreferences verwenden, hab ich mir jetzt eine Funktion dafuer geschrieben:
def match(x,s,f=None): global _ _ = [ '' ] if f: m = re.search(x,s,flags=f) else: m = re.search(x,s)
if m and m.groups: _.extend(m.groups()) return m
Damit kann ich jetzt wie gewohnt in einer Zeile eine Abfrage machen:
if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print _[1]
Offen gesagt, schön ist anders. gettext.py macht es allerdings vergleichbar (_ zweckentfremden, um zum Vorbildprodukt kompatibel zu bleiben) Dort ists allerdings noch wüster, weil AFAIR __builtins__ verändert wird, da es andernfalls Probleme gibt, wenn Du match in ein Modul auslagen willst. Ein klein wenig schöner wäre es, die benutzte Liste als Attribut von match zu speichern: def match(x,s,f=None): match.groups = [ '' ] if f: m = re.search(x,s,flags=f) else: m = re.search(x,s) if m and m.groups: match.groups.extend(m.groups()) return m if len(sys.argv)>1 and match(r"(x+)",sys.argv[1],re.I): print match.groups[1] Ansonsten fällt mir allerdings gerade keine andere Möglichkeit ein, abgesehen von einer klassenbasierten Herangehensweise, so in etwa: class Matcher(object): def __init__(self, source): self.source = source def match(self, rx, flags=0): self.groups = [''] if self.source is not None: m = re.search(rx, self.source, flags=flags) self.groups.extend(m.groups()) else: m = None return m class ArgvMatcher(Matcher): def __init__(self, index): if len(sys.argv) > index: self.source = sys.argv[index] else: self.source = None m = ArgvMatcher(1) if m.match(r"(x+)", re.I): print m.groups[1] (ungetestet) Ok, 2 Zeilen - aber IMHO ein *klein* wenig besser... Thomas
Hallöchen! Thomas Rachel schreibt:
[...]
Offen gesagt, schön ist anders. gettext.py macht es allerdings vergleichbar (_ zweckentfremden, um zum Vorbildprodukt kompatibel zu bleiben)
Aber gettext benutzt dieses Symbol nicht als temporären Datenspeicher. Das ist das eigentlich häßliche an Ullis Lösung. Tschö, Torsten. -- Torsten Bronger Jabber-ID: torsten.bronger@jabber.rwth-aachen.de oder http://bronger-jmp.appspot.com
Am 10.04.12 15:14, schrieb Torsten Bronger:
Aber gettext benutzt dieses Symbol nicht als temporären Datenspeicher. Das ist das eigentlich häßliche an Ullis Lösung.
Das hässliche an Ullis Lösung ist, dass er Regular Expressions einsetzt, wo sie in Python nicht notwendig und angebracht sind. Regexe für alles mögliche zu benutzen ist typisch für Perl, und dort zugegebenermaßen auch praktisch, weil die Syntax dafür schön knapp ist. Bei Python sollte die eingebauten Libraries für Standardaufgaben verwenden. Meiner Meinung nach kann jemand erst von sich behaupten, dass er Python programmieren kann, wenn er die Standardlib (und wichtige Third-Party Libraries) gut kennt und einsetzt. Chris
On 10.04.2012 08:17, Ulli Horlacher wrote:
Perl:
if (@ARGV and $ARGV[0] =~ /(\w+)/) { print "$1\n" }
Python:
import optparse optparser = optparse.OptionParser() optparse.add_option('-f', '--foo', dest='foo', action="store_true", help='Make it foo-ish') optparse.add_option(...) options, args = optparser.parse_args() if options.foo: ... if not args: optparser.print_help() http://docs.python.org/library/optparse.html Oder, ab Python 2.7, alternativ: http://docs.python.org/library/argparse.html Chris
On 2012-04-10, Ulli Horlacher wrote:
Ich versuche gerade ein paar Perl-Scripte nach Python umzusetzen und wundere mich, dass Python bei bestimmten Konstrukten ziemlich umstaendlich ist (oder ich die Syntax nicht verstehe). Beispiel:
Perl:
if (@ARGV and $ARGV[0] =~ /(\w+)/) { print "$1\n" }
Python:
if len(sys.argv)>1: m = re.match(r".*?(\w+)",sys.argv[1]) if m: print m.group(1)
Mein erster Ansatz
if len(sys.argv)>1 and m = re.match(r".*?(\w+)",sys.argv[1]): print m.group(1)
erbrachte einen syntax error: Zuweisungen sind bei if nicht zulaessig?!
In C (aus der Welt stammt diese Angewohnheit) ist die Zuweisung zunächst mal ein Ausdruck (und kein Statement) mit dem Wert der rechten Seite und darf deswegen überall dort auftauchen, wo ein Ausdruck zulässig ist. Erst durch das folgende Semikolon wird die Zuweisung zu einem Anweisung. Das ist aber weder intuitiv noch weit verbreitet unter den Programmiersprachen, u.a. weil es fehlerträchtig ist. So kann ein unbeabsichtigtes if (a=b) statt if (a==b) vom Compiler nicht als Syntaxfehler erkannt werden. Und der Nutzen dieses Abkürzungsfimmels ist gering bis nicht vorhanden. Der Weg, den Python da beschreitet, ist normaler, besser lesbar und sicherer. Bernd -- "Die Antisemiten vergeben es den Juden nicht, dass die Juden Geist haben - und Geld." [Friedrich Nietzsche]
participants (12)
-
Andreas Jung -
Bernd Nawothnig -
Christopher Arndt -
Diez B. Roggisch -
Hartmut Goebel -
Marek Kubica -
Sebastian Wiesner -
Stefan Behnel -
Thomas Rachel -
Torsten Bronger -
Ulli Horlacher -
Ulli Horlacher