einfache Ausdrücke

Übersicht: einfache Ausdrücke

---

Ausdruck

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

Funktionsaufruf

spam(eggs, ham);

Methodenaufruf

spam->ham(eggs);

Verbundausdruck

$spam < $ham && $ham != $eggs;

enden mit Semikolon

auch über mehrere Zeilen

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

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

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;

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

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__()

mit print

gibt auf stdout aus

gibt mehrere Argumente direkt aus

print "a", "b"

ab

Zeilenvorschub explizit durch Concatenation

print "a", "b" . "\n"

mit puts

puts {a b}

a b

jede Zeile gefolgt von \n

bei 2 Parametern ist der erste ein Dateihandle

---

if / Blöcke

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"

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";
}

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

in Python nicht vorhanden

empfohlene Handhabung

choice = 'ham'
print { 'spam': 1.95,
  'ham': 1.99,
  'eggs': 0.99,
  'bacon': 1.10}[choice]

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;

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

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

allgemeine Syntax

$x = 0;
while ($x < 10) {
  $x += 1;
  ($x == 5) && next;
  ($x == 10) && last;
  print $x . "\n";
} continue {
  print "continue\n";
}

allgemeine Syntax

set x 0
while {$x<10} {
  incr x
  if {$x == 5 } {continue}
  if {$x == 10 } {break }
  puts "x is $x"
}

---

for

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):

allgemeine Syntax

foreach ('spam', 'ham', 'foo', 'eggs', 'bar', 'brian' ) {
  /foo/ && next;
  /bar/ && last;
  print;
} continue {
  print "\n";
}

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

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):

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 @_ }

Deklaration

proc function {x y z} {
  puts $x,$y,$z
  return [expr $x * $y / $z]
}

Aufruf

function 2 3 1

---

Module

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)

einbinden von Paketen

use modulname;

einbinden bestimmter Teile

use modulname qw(funktion)

definition eines Pakets

package modulname;

nur als einbinden externer Dateien

source datei.tcl

Namensräume nur mit [incr Tcl]

neuladen durch erneutes einbinden

---

Klassen

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()

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

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

Mehrfachvererbung

class HamNEggs(Ham, Eggs):

Konstruktoren der Elternklassen

  def __init__(self):

    super(HamNEggs, self).__init__()

---

Ausnahmen

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()

kennt eigentlich keine Exceptions

simulation wie folgt

Auslösen & Verarbeiten

eval {
  die "MyError";
};
if($@) {
  print "$@\n";
}

Verarbeiten

if [catch { puts $v }] {
  puts Error
} else {
  puts Works
}

Fehler erzeugen

if [catch {error MyError} result] {
  puts $result
} else {
  puts { success $result }
}