einfache Ausdrücke


... [Seminar "Java und Werkzeuge für das Web] ... [Python 2.2] ... [Schlusswort] ...

Übersicht: einfache Ausdrücke

  • Ausdruck
  • Variablen
  • Ausgabe
  • if / Blöcke
  • case
  • while
  • for
  • Funktionen
  • Module
  • Klassen
  • Mehrfachvererbung
  • Ausnahmen

  • Ausdruck

    python
    Funktionsaufruf
    spam(eggs, ham)
    Methodenaufruf
    spam.ham(eggs)
    Verbundausdruck
    spam < ham and ham != eggs
    Bereichsüberprüfung
    spam < ham < eggs
    enden am Zeilenende
    oder wenn alle Klammern geschlossen sind
    mehrere Zeilen durch escapen von \n
    haben keinen Rückgabewert
    perl
    Funktionsaufruf
    spam(eggs, ham);
    Methodenaufruf
    spam->ham(eggs);
    Verbundausdruck
    $spam < $ham && $ham != $eggs;
    enden mit Semikolon
    auch über mehrere Zeilen
    tcl
    Funktionsaufruf
    spam $eggs $ham
    Methodenaufruf
    spam::ham $eggs
    Verbundausdruck
    expr $spam < $ham && $ham != $eggs
    Bereichsüberprüfung
    expr $spam < $ham < $eggs
    enden am Zeilenende wenn alle offenen Quotes geschlossen sind
    mehrere Zeilen durch escapen von \n

    Variablen

    python
    Werden erzeugt durch Zuweisung
    einfache Zuweisung
    variable = 'wert'
    Tupel
    spam, ham = 'yum', 'tasty'
    Listen
    spam, ham = ['yum', 'tasty']
    Mehrfachzuweisung
    spam = ham = 'lunch'
    zur Zuweisung auf globale Variablen: global
    global x
    x = 23
    sind immer Referenzen
    keine Typüberprüfung
    variable = 10
    werden im aktuellen Namensraum angelegt
    bei Verwendung Suche nach LGB-Regel
    perl
    Werden erzeugt durch Zuweisung
    $variable = 'wert';
    Mehrfachzuweisung
    $spam = $ham = 'lunch';
    keine Typüberprüfung
    $variable = 10;
    sind per default global
    lokale Variablen
    my $variable = 42;
    tcl
    Werden erzeugt durch Zuweisung
    set variable "wert"
    vor tcl8.0 immer strings
    Mehrfachzuweisung
    set spam [set ham lunch]
    zur Zuweisung auf globale Variablen: global
    global x
    x = 23
    keine Typüberprüfung
    set variable 10
    werden im aktuellen Namensraum angelegt

    Ausgabe

    python
    mit print
    gibt auf stdout aus
    trennt mehrere Argumente
    print 'a', 'b'
    a b
    jede Zeile gefolgt von \n
    unterbinden durch ,
    print 'a',
    implizite Stringkonvertierung
    'a'.__repr__()
    perl
    mit print
    gibt auf stdout aus
    gibt mehrere Argumente direkt aus
    print "a", "b"
    ab
    Zeilenvorschub explizit durch Concatenation
    print "a", "b" . "\n"
    tcl
    mit puts
    puts {a b}
    a b
    jede Zeile gefolgt von \n
    bei 2 Parametern ist der erste ein Dateihandle

    if / Blöcke

    python
    durch Einrückung
    bewirkt strukturierten Code
    Lesbarkeit & Wartbarkeit
    Einzelausdruck direkt hinter Block öffnendem Ausdruck
    allgemeine Syntax
    if x == 'spam':
      print "true"
    else:
      print "false"
    if x == 'spam': print "true"
    else: print "false"
    bei mehreren Vergleichen
    if x == 'spam':
      print "true"
    elif x == 'ham':
      print "maybe"
    else:
      print "false"
    perl
    durch Klammerung
    Einzelausdruck muss geklammert werden
    allgemeine Syntax
    if ($x eq spam) {
      print "true";
    } else {
      print "false";
    }
    bei mehreren Vergleichen
    if ($x eq spam) {
      print "true";
    } elsif ($x eq ham) {
      print "maybe";
    } else {
      print "false";
    }
    tcl
    durch Klammerung, entspricht Liste
    Grund ist das Prozedurbasierte Konzept
    Schlüsselwörter else/then optional
    allgemeine Syntax
    if {$x == "spam"} then {
      puts true
    } else {
      puts false
    }
    bei mehreren Vergleichen
    if {$x == "spam"} {
      puts true
    } elseif {$x == "ham"} {
      puts maybe
    } {
      puts false
    }

    case

    python
    in Python nicht vorhanden
    empfohlene Handhabung
    choice = 'ham'
    print { 'spam': 1.95,
      'ham': 1.99,
      'eggs': 0.99,
      'bacon': 1.10}[choice]
    perl
    in Perl nicht vorhanden
    empfohlene Handhabung
    $choice = 'ham';
    print $choice eq 'spam' && 1.95
    ||  $choice eq 'ham' && 1.99
    ||  $choice eq 'eggs' && 0.99
    ||  $choice eq 'bacon' && 1.10;
    tcl
    in tcl nativ vorhanden
    set choice ham
    switch $choice {
      spam  {puts 1.95}
      ham   {puts 1.99}
      eggs  {puts 0.99}
      bacon {puts 1.10}
    }

    while

    python
    allgemeine Syntax
    x = 0
    while x < 10:
      x += 1
      if x == 5: continue
      if x == 10: break
      print x,
    else:
      print 'Ende'
    break beendet die Schleife samt else-Zweig
    continue beendet diesen Schleifendurchlauf
    perl
    allgemeine Syntax
    $x = 0;
    while ($x < 10) {
      $x += 1;
      ($x == 5) && next;
      ($x == 10) && last;
      print $x . "\n";
    } continue {
      print "continue\n";
    }
    tcl
    allgemeine Syntax
    set x 0
    while {$x<10} {
      incr x
      if {$x == 5 } {continue}
      if {$x == 10 } {break }
      puts "x is $x"
    }

    for

    python
    allgemeine Syntax
    for x in ['spam', 'ham', 'foo', 'eggs', 'bar', 'brian']:
      if x == 'foo': continue
      if x == 'bar': break
      print x,
    else:
      print 'Ende'
    break beendet die Schleife samt else-Zweig
    continue beendet diesen Schleifendurchlauf
    als Zählschleife
    for x in range(6):
    for x in range(2,6):
    for x in range(2,6,2):
    perl
    allgemeine Syntax
    foreach ('spam', 'ham', 'foo', 'eggs', 'bar', 'brian' ) {
      /foo/ && next;
      /bar/ && last;
      print;
    } continue {
      print "\n";
    }
    tcl
    allgemeine Syntax
    foreach x {spam ham foo eggs bar brian} {
      if {$x == "foo"} { continue }
      if {$x == "bar"} { break }
      puts $x
    }
    break beendet die Schleife
    continue beendet diesen Schleifendurchlauf
    als Zählschleife
    for {set x 0} {$x < 6} {incr x} { puts $x }
    for {set x 2} {$x < 6} {incr x} { puts $x }
    for {set x 2} {$x < 6} {set x [expr $x + 2]} { puts $x }

    Funktionen

    python
    Deklaration
    def function(x, y=1, z=2):
      print x, y, z
      return x * y / z
    definieren eigenen Namensraum
    Aufruf
    function(2)
    function(2, 3, 1)
    function(2, z=1)
    Catch-All-Parameter
    def function(*args):
    def function(**args):
    perl
    Deklaration
    sub function($;$$) {
      my $x = @_[0];
      my $y = @_[1] || 1;
      my $z = @_[2] || 2;

      print join(" ",@_);
      return $x * $y / $z;
    }
    definieren eigenen Namensraum
    Aufruf
    function(2)
    function(2, 3, 1)
    Catch-All-Parameter
    sub function { print @_ }
    tcl
    Deklaration
    proc function {x y z} {
      puts $x,$y,$z
      return [expr $x * $y / $z]
    }
    Aufruf
    function 2 3 1

    Module

    python
    jede Python-Datei ist ein Modul
    ein Modul ist ein Namensraum
    einbinden von Modulen
    import modulname
    einbinden bestimmter Teile
    from modulname import funktion
    aktualisieren eingebundener Module
    reload(modulname)
    perl
    einbinden von Paketen
    use modulname;
    einbinden bestimmter Teile
    use modulname qw(funktion)
    definition eines Pakets
    package modulname;
    tcl
    nur als einbinden externer Dateien
    source datei.tcl
    Namensräume nur mit [incr Tcl]
    neuladen durch erneutes einbinden

    Klassen

    python
    Deklaration
    class Spam: pass
    Vererbung
    class Spam(object):
    Klassenvariablen
      value = 1
    Methoden
      def doit(self): pass
    Konstruktor
      def __init__(self, arg):
    Instanzvariable
        self.value = arg
    Information "hiding"
      __value = 42
    Operatoren überladen
      def __add__(self, other): pass
    ein Objekt erzeugen
    eggs = Spam(ham)
    eggs.doit()
    perl
    Deklaration
    package Spam;
    Klassenvariablen
    $value = 1;
    Methoden
    sub doit {}
    Konstruktor
    sub new {
      my $class = shift;
      my $self = { @_ };
    Instanzvariable
        self{'number'} = 2;
      return bless($self, $class);
    }
    1
    tcl
    Deklaration
    class Spam {}
    Vererbung
    class Spam {
    inherit parentclass
    Klassenvariablen
      variable value
    Methoden
      method doit{} {puts "doit"}
    Konstruktor
      constructor {x} { set value $x }
    Information "hiding"
      private variable pvalue
    }
    ein Objekt erzeugen
    Spam eggs ham

    Mehrfachvererbung

    python
    Mehrfachvererbung
    class HamNEggs(Ham, Eggs):
    Konstruktoren der Elternklassen
      def __init__(self):
        super(HamNEggs, self).__init__()

    Ausnahmen

    python
    Auslösen & Verarbeiten
    try:
      print v
    except NameError:
      print 'NameError'
    else:
      print 'Works'
    sicher beenden
    def workon(file):
      raise 'MyError'

    f = open('file')
    try:
      workon(file)
    finally:
      f.close()
    perl
    kennt eigentlich keine Exceptions
    simulation wie folgt
    Auslösen & Verarbeiten
    eval {
      die "MyError";
    };
    if($@) {
      print "$@\n";
    }
    tcl
    Verarbeiten
    if [catch { puts $v }] {
      puts Error
    } else {
      puts Works
    }
    Fehler erzeugen
    if [catch {error MyError} result] {
      puts $result
    } else {
      puts { success $result }
    }

    ... [Seminar "Java und Werkzeuge für das Web] ... [Python 2.2] ... [Schlusswort] ...