Captains Log

Hier wieder ein Beispiel, warum Gesetzesänderungen im Kampf gegen Terror nur der Triebbefriedigung einiger Überwachungsstaatfanatiker dient:

NSA setzt offenbar soziale Netzwerkanalyse ein (heise.de): Kurz gesagt verwendet die NSA nach bisher unbestätigten Zeitungsberichten zufolge eine Software, die "soziale Netzwerke" analysieren soll. Als soziales Netzwerk bezeichnet man dabei nicht nur die Personengruppe, mit der man sich umgibt, sondern auch die Berührungspunkte, die man mit anderen Gruppen hat. Nach dieser Theorie kennt man um sechs Ecken herum alle Menschen in seinem größeren Wirkungskreis.
Wer einen Account auf OpenBC hat, wird diese Theorie auch schnell bestätigt finden: Ich habe noch nie den Fall gehabt, dass jemand, den ich auf meine Kontaktliste gesetzt habe, nicht um maximal sechs Ecken herum erreichbar war.
In der Praxis mögen die von der NSA gesammelten Daten mit einem Volumen von Schätzungen 639.000 CDs pro Tag zwar immens hoch sein, aber durch die Verknüpfungen, die sich dabei ergeben, stehen mal wieder alle Bürger unter Generalverdacht, und es könnte mitunter mal ganz fix passieren, dass man bespitzelt wird, weil man um eine der Ecken herum jemanden kennt, der Dreck am stecken hat.

Und da das, was in Amerika passiert, ja fast immer als Vorlage für das dient, was kurze Zeit darauf auch bei uns zu einem Trend wird, ist die Befürchtung, mit den in der "Vorratsdatenspeicherung" gesammelten Daten würde Schindluder getrieben, wohl nicht allzu weit entfernt.

Wie passend: *g*

You Are The Magician

You are powerful and wise - beyond what anyone can see. Deeply complex, you have the resources to connect to the spiritual and material world. You posses the knowledge to manipulate your life and the lives around you. You also have a great healing power, should you choose to use it. Your fortune: You have unhidden powers that you have yet to tap into. Soon, you will better understand how to use your intellect and intuition. Believe it or now, you will discover how you can manipulate yourself and others for good. You are at the beginning of a path of spiritual enlightenment.

Ich habs vom Don, und der wiederrum hats von der Frau Rockhound: What kind of rocker are you?

You Are a Freedom Rocker!

You're stuck in the 70s - for better or worse Crazy hair, pot soaked clothes, and tons of groupies Your kind showed the world how to rock Is that freedom rock?... Well turn it up man!

Also mal davon abgesehen, dass ich mich gerade verdammt alt fühle, und ich in den 70ern gezeugt wurde...

...ist das schon ein verdammt geniales Ergebnis. Die Musik ist immer noch unerreicht (wie man an all den Cover und Remakes und dergleichen sieht) und wenn ich die Change gehabt hätte, hätte ich die Zeit gerne live miterlebt - auch wenn ich dann auf Computer hätte verzichten müssen.

Bei den globalen und lokalen Namespaces gab es ja schon eine Funktion, hier die Vertiefung dazu:

#!/usr/bin/env python

def getkey(prompt="Yes/no: ",allow=('y','n')):
    while True:
        query=raw_input(prompt)
        if query in allow:
            return query
        else:
            print "Please answer ",allow,", only!"

print "This is a test question."
print getkey()

print "This is an alternative text:"
print getkey("Please answer Yes or No: ")

print "Use the function above to do something entirely different:"
print getkey("0-9? ",str(range(10)))

Das Beispiel zeigt sehr schön, wie Funktionen in Python funktionieren. Es handelt sich um eine einfache Tastaturabfrage-Routine, die die Eingabe überprüft.
Der Prompt, also das, was zur Aufforderung angezeigt wird, sowie die möglichen Antworten, werden bereits in der Funktionsdefinition angelegt, wobei allow nur zum Zuge kommen, wenn keine Parameter übergeben werden, wie das beim ersten Aufruf von range()-Anweisung ins Spiel, deren Ausgabe mittels getkey()-Funktion selbst besteht aus einer raw_input() ist für Tastaturabfragen zuständig, und die in lediglich nachgeschaut, ob die Antwort in return verlassen und die Eingabe an die aufrufende Funktion zurück gegeben, wo sie einfach nur ausgegeben wird.

Mehr dazu gibt es im Python Tutorial

Okay okay, ich gebe zu, in der letzten Zeit habe ich zuerst garnicht gebloggt, nur um im Anschluß daran Sachen von mir zu geben, die kaum ein Mensch versteht.
Und nachdem der Don gerade schon entsprechend kommentiert hat, wollte ich eben vermerken, dass das so nicht bleibt. Ich lerne gerade Python als neue Programmiersprache und tippe deshalb das gelernte in komprimierter Form in mein Blog. Als Einführung in die Programmierung kann ich das übrigens auch niemandem empfehlen. ;-)
Einen Beitrag zum Thema Python habe ich noch, danach wird über was anderes gebloggt. ;-)

Die for-Schleife in Python arbeitet ähnlich wie die in Unix-Shells: Anstelle von einer Startbedingung zu einer Endbedingung hochzuzählen, wobei die Schrittweise festlegbar ist, wie das bei C der Fall ist, geht Pythons for durch eine Menge von Elementen, wobei es egal ist, von welchem Typ diese Elemente sind:

>>> for x in ("Douglas Adams","Per Anhalter durch die Galaxis",42):
...    print x
...
Douglas Adams
Per Anhalter durch die Galaxis
42

Beim Programmieren ist das natürlich angenehm, weil man Tupel und Listen einfach nur angeben muß, um alle darin enthaltenen Elemente verarbeiten zu können.

Möchte man irgendwas hochzählen, braucht man eine Hilfe, und genau dafür ist range() da:

>>> for x in range(10):
...     print x,
...
0 1 2 3 4 5 6 7 8 9

Es fällt auf, das range bei 0 anfängt zu zählen, aber bei 9 aufhört, statt bis 10. Möchte man eine Ausgabe inklusive der 10, und die 0 möchte man auch nicht sehen, muß man entsprechende Änderungen vornehmen:

>>> max=10
>>> for x in range(1,max+1):
...     print x,
...
1 2 3 4 5 6 7 8 9 10

max ist die Obergrenze, bis zu der ich zählen möchte, und da ich diese inklusive haben möchte, inkrementiere ich den Ausdruck von max um 1.
Der Ausdruck range(a,b) bedeutet, zähle von a nach b, ein range(b) ist also gleichbedeutend mit range(0,b).
Es gibt noch eine dritte Möglichkeit, mit range() zu arbeiten:

>>> for x in range(1,32,2):
...     print x,
...
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31

Der dritte Wert gibt also die Schrittweite an, mit der hochgezählt werden soll. Übrigens funktioniert nicht die Kombination range(Obergrenze,Schrittweite), weil Python hier nicht wissen kann, ob nicht range(Startwert,Obergrenze) gemeint ist. Allerdings wird Python hier auch nicht sauer und haut einem Fehlermeldungen um die Ohren, es passiert nur nichts:

>>> for x in range(32,2):
...     print x,
...
>>>

range() funktioniert natürlich auch "subtrahierend:", wobei hier die Schrittweite auf jeden Fall angegeben werden muß, weil Python ansonsten davon ausgeht, dass wir eine Schrittweite von +1 haben wollen. Warum das so ist, werden wir später noch sehen:

>>> for countdown in range(10,-1):
...     print countdown
...
>>> for countdown in range(10,-1,-1):
...     print countdown,
...
10 9 8 7 6 5 4 3 2 1 0

for ist bei weitem nicht das einzige Einsatzgebiet für range(), vielmehr können hier auch Listen mit befüllt werden:

>>> countdown=range(10,-1,-1)
>>> countdown
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Die Übergabe von Argumenten und Parametern in Programmen ist eine nicht unwichtige Angelegenheit. In der Shellprogrammierung liegen die Argumente in $0, $1, $2... $*, die meisten Programmiersprachen bieten ein Array ARGV oder so ähnlich an (Perl, C...).
Python macht das ähnlich:

#!/usr/bin/env python

import sys

print "My Filename: ",sys.argv[0]
print "No. of args: ",len(sys.argv)-1
print "Arguments  : ",sys.argv[1:]

if len(sys.argv)-1 >= 1:
   print "Processing arguments..."
   for x in range(1,len(sys.argv)):
       print "Argument ",x,": ",sys.argv[x]
else:
   print "Nothing to do."

In Python wird das Tupel argv vom Modul sys zur Verfügung gestellt, deshalb sys.argv. Wie unter Unix üblich (sofern man unter Unix programmiert), steht in argv[0] der Filename drin, mit dem das Programm aufgerufen wurde, oder der entsprechende Parameter, wenn man eben kein python-Script vorliegen hatte.
Die Konstruktion weiter unten gibt einfach nochmal alle Argumente der Reihe nach aus, sofern mehr als ein Argument übergeben wurde.
Wird das Script aufgerufen, sieht das z.B. so aus:

$ ./03_argv.py dies ist einer dieser typischen tests.
My Filename:  ./03_argv.py
No. of args:  6
Arguments  :  ['dies', 'ist', 'einer', 'dieser', 'typischen', 'tests.']
Processing arguments...
Argument  1 :  dies
Argument  2 :  ist
Argument  3 :  einer
Argument  4 :  dieser
Argument  5 :  typischen
Argument  6 :  tests.

Hm, if, range() und for folgen im nächsten Beitrag.

#!/usr/bin/env python

# Namespaces
# In Funktionen gibt es lokale Namensraeume,
# soll ein Objekt global uebernommen werden, muss dies
# mittels global geschehen.

#  - Objekte aus dem Hauptprogramm bleiben auch in
#    Unterfunktionen lesend global, beim Schreibzugriff
#    werden sie aber lokal, es sei denn, es wird explizit
#    "global " angegeben.
#  - (Streng genommen wird beim Schreibzugriff auf ein
#    Objekt aus dem globalen Namespace ein zweites Objekt
#    mit gleichem Namen im lokalen Namespace erzeugt,
#    welches das Objekt aus dem globalen Namespace
#    ueberdeckt.


def test():
    print "Funktionseinstieg"
    print locals()
    print globals()
    print "Globalisierung..."
    a = "Ciao"
    global b
    b = "Erde"
    c = "Universum"
    print "Gaendert: a=",a,", b=",b,", c=",c
    print locals()
    print globals()

print "Programmstart"
print locals()
print globals()

a = "Hallo"
b = "Welt"

print "Variablendefinition"
print "Objekte am Programmanfang: a=",a,", b=",b
print locals()
print globals()
test()
print "Objekte am Programmende  : a=",a,", b=",b
print locals()
print globals()

Das Script verwendet das erste Mal eine selbstgeschriebene Funktion, die durch def angelegt wird. Ihr Name ist test, und die leere Klammer bedeutet, dass sie erstmal keine Variablen oder Variablenwerte aus den aufrufenden Funktionen übernimmt.
Interessant sind die Befehle locals() und globals(), die jeweils den Inhalt des lokalen und globalen Namespace ausgeben, wobei natürlich festzustellen ist, dass es einen globalen Namespace nur innerhalb von Funktionen geben kann, weil das Hauptprogramm nur über einen Namensraum verfügt.

Führt man das Programm aus, gibt es folgendes aus:

Programmstart
{'__builtins__': , '__name__': '__main__', '__file__': './02_namespaces.py', 'test': , '__doc__': None}
{'__builtins__': , '__name__': '__main__', '__file__': './02_namespaces.py', 'test': , '__doc__': None}
Variablendefinition
Objekte am Programmanfang: a= Hallo , b= Welt
{'a': 'Hallo', 'b': 'Welt', '__builtins__': , '__file__': './02_namespaces.py', 'test': , '__name__': '__main__', '__doc__': None}
{'a': 'Hallo', 'b': 'Welt', '__builtins__': , '__file__': './02_namespaces.py', 'test': , '__name__': '__main__', '__doc__': None}
Funktionseinstieg
{}
{'a': 'Hallo', 'b': 'Welt', '__builtins__': , '__file__': './02_namespaces.py', 'test': , '__name__': '__main__', '__doc__': None}
Globalisierung...
Gaendert: a= Ciao , b= Erde , c= Universum
{'a': 'Ciao', 'c': 'Universum'}
{'a': 'Hallo', 'b': 'Erde', '__builtins__': , '__file__': './02_namespaces.py', 'test': , '__name__': '__main__', '__doc__': None}
Objekte am Programmende : a= Hallo , b= Erde
{'a': 'Hallo', 'b': 'Erde', '__builtins__': , '__file__': './02_namespaces.py', 'test': , '__name__': '__main__', '__doc__': None}
{'a': 'Hallo', 'b': 'Erde', '__builtins__': , '__file__': './02_namespaces.py', 'test': , '__name__': '__main__', '__doc__': None}


Die ersten beiden Zeilen zeigen, wie der Namespace aussieht, wenn noch nicht viel passiert ist: Es gibt ein paar eingebaute Module, das File, das das Programm enthält, heißt 02_namespace.py, und es gibt eine definierte Funktion test.
Interessant wird es das erste Mal nach der Deklaration der Variablen a und b, die nun in den globalen Namespace einfliessen (der an der Stelle wiederrum identisch ist mit dem lokalen).
Richtig spannend wird es dann nach dem Funktionsaufruf: Hier ist der lokale Namespace plötzlich leer, wie die der erste Satz geschweifter Klammern anzeigt, währen der globale sich nicht verändert hat.
Dann geschieht zweierlei: Durch die Anweisung global b wird die Variable b von der Funktion test() aus beschreibbar, außerdem wird die Variable a neu deklariert, und c kommt hinzu.
Nach der Globalisierung sieht der lokale Namespace schon anders aus, er enthält a und c, aber immer noch nicht b. Dafür ist im globalen Namespace ersichtlich, dass die Änderung b='Erde' ihre Wirkung nicht verfehlt hat. Wenn sich die Funktion beendet, ist b immer noch 'Erde', aber nicht 'Welt', wie es noch am Anfang der Fall war.
Das c als neue Variable im lokalen Namespace ist, ist nicht verwunderlich, man sieht aber auch sehr schön, dass die lokale Variable a, deren Wert nun 'Ciao' ist, das global deklarierte a überlagert. In der Funktion test hat man nun keinen Zugriff mehr auf die globale Variable a.

Python kennt wie viele andere Programmiersprachen auch, Variablen vom Typ Boolean, die die Werte True oder False annehmen können. Dabei ist das noch nicht mal unbedingt nötig, weil in Python jede Variable als Boolean gewertet werden kann: Variablen mit nicht definiert sind, oder den Wert 0 haben, sind False, während alle anderen True sind, wie das folgende Beispiel zeigt:

>>> x = 20
>>> while x:
...     print x,
...     x=x-1
...
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1

Die while-Schleife arbeitet also auf Basis von Boolean und läuft solange, wie die Bedingung wahr ist.

Daneben gibt es noch den Variablentyp None, den ich vorher noch nicht kannte. Damit können Variablen defklariert werden, ohne jedoch Werte zuzuweisen. Sinn macht das z.B. in Situationen, wo man im Programm eine Variable benötigt, jedoch jeder zugewiesene Wert nur stören würde.