# "ich bin ein Kommentar"
print "Hallo" # gibt Hallo im Python Shell aus

""" Blockkommentar:
kann mehrere Zeilen lang sein.
bla bla ...
"""

>>> print "Hallo"
Hallo
>>>

# definiere Varaibelen:
test1 = "string1" # Variblenname = Variableninhalt (die Zuweisung erfolgt ueber "=")
test2 = 'string2'
test3 = "Mein Name ist 'Hubert'"

# Gebe Variablen aus:
print test1 + " " + test2
print test3

# Die String Varaible kann auch mehrmals aufgerufen werden:
print test1 * 3

# Zugriff auf Variablen:
# Mit Eckiger Klammer definiert man die Dauer des Ablaufs.
print test1[0:1]    # lese den ersten Buchstabe der Variable test1 aus.
print test1[0]      # Achtung: es wird bei 0 zu zaehlen begonnen!
print test1[:-1]    # Wenn man keine Position festlegt wird vom Anfang an gestartet.
                    # wenn ein "-" vor die Position steht wird vom Ende aus nach gezaehlt.
print test1[:]

ganzzahl = 10
kommazahl = 10.0
plus = ganzzahl + kommazahl - 5.4
print plus

meineliste1 = ["Eintrag","Eintrag2","ball","rever","hans"]
print meineliste1
meineliste2 = [] #leere Liste
meineliste1.sort(key=str.lower, reverse=False)  # sortiere meine liste unabhaengig von gr. und kleinschreibung aufsteigend
                                                # siehe dazu Beispiel 4 - die Hilfefunktion

print meineliste1

print len(meineliste1)  # Laenge der Liste
print len(meineliste2)
print type(meineliste1) # liest den Datentype aus
print max([ganzzahl,kommazahl])

print dir(__builtins__)                # Hilfe Funktionsauflistung
print dir(__builtins__.list)           # alle Funktionen die unter "list" verfügbar sind
print dir(__builtins__.list.sort)      # die Unterfunktion sort in list (sortiere Liste)
print __builtins__.list.sort.__doc__   # __doc__ ist immer die Doku zur Funktion

import shutil           # einzelnen Laden von einem Modul
import os,urllib, csv   # Laden von mehrere Modulen gleichzeitig
                        # Beim Laden mit import wird ein Namensraum fuer alle Funktionen erstellt

from Tkinter import *   # Durch Laden mit from wird kein Namensraum erstellt und es sind alle diese Funktionen "global" in diesem Programm verfuegbar.
import webbrowser       # Lade ein weiteres Modul

testa = 5 == 5    # gibt Antwort True aus
testb = 5 == 6    # gibt Antwort False aus
print testa
print testb

if testa == True:                               # pruefe ob die Variable testa "True" ist
    print "TEST A ist wahr!"    # gibt Antwort aus
    if testb == False:          # hierachisch nachgeordnete pruefung - laeuft erst wenn die erste (testa == True) zugetroffen ist
        print "Test B ist nicht wahr"   # Antwort auf 2te pruefung


x = 2
if x == 1:                   # pruefe Variable x
    print "Zahl ist 1"
elif x == 2 or x == 3:
    print "Zahl ist 2 oder 3"
else:
    print "Zahl > 3"

# Schleife laeuft so lange x kleiner 10 ist
x = 5
while x < 10:
    print x
    x = x + 1
print "while-Schleife ist fertig"

# Schleife laeuft von 25 - 31 in 2er Schritten -range(start, stop, step)
for i in range(25,32, 2):
    print i
print "for Schleife ist fertig"

# Schleife ueber Text
for c in "mein Text":
    print c

# Schleife ueber Liste
liste=[94165,165,546,46,4,4,465]
for i in liste:
    print i
print "for Schleife ueber Liste ist fertig"

      # normal
x = 200
textausgabe = " wurde als Wert definiert."
x_str =  str(x)             # wandle x(Zahl) in einen String um
print x_str + textausgabe   # erzeuge Beispielvariable
x_1 = x + 0.555
print x_1

print "\n" # Zeilenumbruch in der Ausgabe

      # objektorientiert
def meinefunktion(x,textausgabe):
    x_str =  str(x)
    print x_str + textausgabe
    x_1 = x + 0.9999
    print x_1
    global x_1          # wandle Variable in Globale Variable um damit man auch ausserhalb darauf zugreifen kann - siehe dazu 3 Zeilen weiter unten

meinefunktion(200+5," wurde als Wert definiert.") # rufe Funktion mit zwei Uebergabeparametern auf
print "Ende der objektorientierten Funktion"

# die Folgenden Schritte sind Zusatzinformation und werden nicht
print x_1    # verwende Globale Variable ausserhalb der definierten Funktion.
x_1 = 1000  # ueberschreibe (globale) Variable
print x_1
del x_1     # loesche (globale) Variable

###########################################################################
#  Geocodierung und Visualisierung von Adressdaten mittels der GoogleAPI  #
#  Autor: Ronald Weberndorfer                                             #
#  Datum: 10.01.2011                                                      #
#  Infos: http://ourproject.org/moin/projects/openplanning/PythonGeocoder #
###########################################################################

# Lade benoetigte Module
import os, urllib, csv, shutil, webbrowser
from Tkinter import *

# erzeuge globale Variablen
global addr
addr = ""
global lat
lat = ""

# setze Pfad und Dateinamen
global pfad
pfad = "../prog_data/"
global data
data = pfad + "db.csv"
global data2
data2 = pfad + "db_2.csv"


# definiere Insert Funktion - Button Geocodieren
def Insert():
    global addr
    addr = text.get()   #lade Inhalt des Textfeldes
    if addr == "":      #pruefe Eingabe
        list.insert(0.0, "## Bitte geben sie eine Adresse ein! ## \n")
    else:
        ##### Geocoder Start ####
        url = ''
        if addr[0]=='(':
            center = addr.replace('(','').replace(')','')   # loesche Klammern aus addr
            global lat
            global lng
            lat,lng = center.split(',')     # erzeuge 2 Variablen aus center
            url = 'http://maps.google.com/maps?q=%s+%s' % (lat,lng)
        else:
            # Encode query string into URL
            url = 'http://maps.google.com/?q=' + urllib.quote(addr) + '&output=js'
            # 2 Moeglichkeiten zur Printausgebe der Variable url:
            #print '\nQuery: %s' % (url)    # Aufruf der an Google gesendet wird
            #print "\nQuery: " + str(url)   # Aufruf der an Google gesendet wird
            # Get XML location
            xml = urllib.urlopen(url).read()    # lese xml
            if '<error>' in xml:                # Fange Fehlercode von Google ab
               print '\nGoogle cannot interpret the address.'
            else:
                # lese lat/long aus xml mittels Parser aus
                lat,lng = 0.0,0.0
                center = xml[xml.find('{center:{')+13:xml.find('}',xml.find('{center'))]
                center = center.replace('lat:','').replace('lng:','')
                lat,lng = center.split(',')
                url = 'http://maps.google.com/maps?q=%s+%s' % (lat,lng)
                ## lese Adresse mittels Parser aus
                start =  xml.find('laddr:"')
                adr = xml[start:start + 200]
                end = adr.find("geocode")
                fin = adr[7: end-2]

                # definiere globale Variablen
                global lati 
                lati = float(lat)
                global longi
                longi = float(lng)
                global adresse_neu
                adresse_neu = fin
                global liste
                liste = (addr, lati, longi, adresse_neu)         
                #print liste
                
                ## pruefe Geocode und oeffne Adresse im Browser
                #if url<>'':
                #    print 'Map: %s' % (url)
                #    os.startfile(url)      # funktioniert nur unter Windows
                #    webbrowser.open(url)
                
        ##### Ende Geocoder #####
                
        if adresse_neu == "":       #pruefe Geocodierung - ist eine Adresse vorhanden
            list.insert(0.0, "### Es wurde mit dieser Adresse keine Koordinate gefunden, bitte korrigieren sie die Schreibweise\nund versuchen sie es erneut! ###\n")    # Fehlermeldung
        else:                       # wenn eine Adresse gefunden wurde wird dies in der Verlaufsliste ausgegeben
            list.insert(0.0, "\n")
            list.insert(0.0, "Eingabe: " + addr + "\n")
            list.insert(0.0, "Ausgabe: "+ adresse_neu +"\n")
            list.tag_add("here", "1.9", "1.80")
            list.tag_config("here", background="grey")
            text.delete(0,END)    

# Beende die Anwendung
def ende():
    root.destroy()

# Funktion Button Speichern
def ja_speichern():
    if addr == "":              # Pruefung - wurde bereits geocodiert?
        list.insert(0.0, "Bitte zuerst eine Adresse Geokodieren!\n")   
    else:
        # erzeuge popupinhalt:
        titel = "<h3>" + titelfeld.get() + "</h3>"
        inhalt = inhaltsfeld.get() + "<br><br>"
        popup = titel + inhalt

        # pruefe ob das File neu erstellt wird oder nur einen neue Zeile eingefuegt wird
        vorhanden = os.path.exists(data)
        # schreibe in Database      
        if vorhanden == False:
            # erzeuge neues File und schreibe Dateninhalt
            id = 1                  
            file_wr =open(data,'a+b', buffering=0)
            csv_writer = csv.writer(file_wr, delimiter=";")
            liste = (id, addr, lati, longi, adresse_neu, popup)         
            csv_writer.writerow(liste)
            file_wr.close()
        else:           
            # Schreibfunktion
            file_wr =open(data2,'a+b', buffering=0)
            csv_writer = csv.writer(file_wr, delimiter=";")
                                
            # lese Altdaten ein
            filealt = open(data,'rb')
            csv_reader_alt = csv.reader(filealt, delimiter=';')
            id = 1
            for row in csv_reader_alt:
                #print row
                id = id + 1
                # schreibe bestehende Daten
                csv_writer.writerow(row)
            #print id
            
            # schreibe neue Daten dazu
            liste = (id, addr, lati, longi, adresse_neu, popup)         
            csv_writer.writerow(liste)
            # schliesse Schreib- und Lesefunktion
            file_wr.close()
            filealt.close()
            
            shutil.copyfile(data2, data)    # kopiere data2 wegen append und ueberschreibe data
            os.remove(data2)                # loesche data2
                       
        list.insert(0.0, "## Adresse wurde gespeichert! ## \n") # gib Stausmeldung am GUI aus
        titelfeld.delete(0,END)     # loesche Inhalt des Titelfeld
        inhaltsfeld.delete(0,END)   # loesche Inhalt des Inhaltsfeld


# Erzeuge aus der "csv" Datenbank ein HTML- File fuer die Visualisierung der Daten
def html_erzeugen():
    if lat == "":
        list.insert(0.0, "Bitte zuerst eine Adresse Geokodieren!\n")
    else:
        # erzeuge html File
        start = pfad + "start.dat"      # statische Teil der HTML Datei (beginn)
        end = pfad + "end.dat"          # statische Teil der HTML Datei (ende)

        # Beginn und Ende der Html sind "fix" und werden deshalb aus externen Files eingelesen
        # diese Teile koennen natuerlich je nach Bedarf angepasst werden
        # lade html1
        in_file = open(start,"r")
        start_text = in_file.read()
        in_file.close()
        # lade html2
        in_file = open(end,"r")
        end_text = in_file.read()
        in_file.close()
        
        filealt = open(data,'rb')
        csv_reader_alt = csv.reader(filealt, delimiter=';')
        id = 1
        # lese den Inhalt der csv Datein Spaltenweise ein
        for row in csv_reader_alt:
            id = int(row[0])
            addr = row[1]
            lati = row[2]
            longi = row[3]
            adresse_neu = row[4]
            popup = row[5]
                        
            #erzeuge daraus fuer jedes Element einen Marker (Pin) fuer die Google Karte
            popup_adresse = "Adresse: " + adresse_neu + "<br> Lat: " + str(lati) + "<br>Lon: " + str(longi) + "<br>ID: " +str(id)
            var1 = '\t\tvar point' + str(id) + ' = new GPoint(' + longi + ', ' + lati + ');\n'
            var2 = '\t\tvar html' + str(id) + ' = "' + popup + popup_adresse + '"\n'
            var3 = '\t\tvar beck' + str(id) + ' = new GMarker(point' + str(id) + ');\n'
            var4 = '\t\tGEvent.addListener(beck' + str(id) + ', "click", function(){beck' + str(id) + '.openInfoWindowHtml(html' + str(id) + ')});\n'
            var5 = '\t\tmap.addOverlay(beck' + str(id) + ');'
            center_last_point = '\n\n\t\tmap.setCenter(new GLatLng(' + lat + ', ' + lng + '), 13);\n'  # die Karte wird auf folgenden Punkt zentriert
            marker = var1 + var2 + var3 +  var4 +  var5

            # fuege in der Schleife fuer jede Zeile einen Marker hinzu
            if id == 1:
                marker_alt = marker
            else:
                marker_alt = marker_alt + "\n\n" + marker
                
        marker = marker_alt
               
        # erzeuge HTML-File    
        html = start_text + '\n\n' + marker + center_last_point + end_text
        #print html
        html_out = pfad + "map.html"
        out_file = open(html_out,"w")
        out_file.write(html)
        out_file.close()
        list.insert(0.0, "## HTML Output wurde erzeugt! ## \n") 

# oeffne Html in der Standardanwendung des Betriebssystems
def html_oeffnen():
    list.insert(0.0, "## HTML wird im Browser gestartet ## \n")
    html_offnen = pfad + "map.html"
    #os.startfile(html_offnen)  # funktioniert nur unter Windows
    webbrowser.open(html_offnen)

# oeffne Hilfe im WIKI
def hilfe():
    list.insert(0.0, "## Onlinehilfe wird im Browser geladen ## \n")
    online = "http://ourproject.org/moin/projects/openplanning/PythonGeocoder#Der_Python_Geocoder"
    #os.startfile(online)       # funktioniert nur unter Windows
    webbrowser.open(online)
    
# About Menu
def about():
    top = Tk()
    top.title('About')
    L1 = Label(top, text="Python Geocoder/ HTML Viewer\n Version 1.0 \nDatum: 10.01.2011\nAutor: Ronald Weberndorfer\n\nInhalt:\n Mit diesem Programm kann man Adressen in Google erfassen\nund diese dann mit Titel und Inhalt in einer Html-Karte darstellen.\n Geocodiert und Visualisiert wird mit GoogleMaps.\n\n Weitere Infos + Sourcecode: \nhttp://ourproject.org/moin/projects/openplanning/PythonGeocoder")
    L1.pack()
    top.mainloop()

#### Definition aller GUI FELDER ####
root = Tk()
root.title('Geocoder')

# Menu in der Anwendung
menubar = Menu(root)
filemenu = Menu(menubar, tearoff=0)
filemenu.add_command(label="Geocodieren", command = Insert)
filemenu.add_command(label="Eintrag Speichern", command = ja_speichern)
filemenu.add_command(label="HTML erzeugen", command = html_erzeugen)
filemenu.add_command(label="HTML aufrufen", command = html_oeffnen)
filemenu.add_separator()
filemenu.add_command(label="Beenden", command=ende)
menubar.add_cascade(label="Datei", menu=filemenu)
root.config(menu=menubar)

helpmenu = Menu(menubar, tearoff=0)
helpmenu.add_command(label="Online Hilfe", command=hilfe)
helpmenu.add_command(label="About...", command=about)
menubar.add_cascade(label="Hilfe", menu=helpmenu)
# ende menu

frame = Frame(root)
frame.pack()

# Ueberschrift 1
titel = Label(root, text='Bitte geben Sie eine Adresse oder WGS84-Koordinate (z.B: 47.5, 13.5):',font=('Arial',10), fg='black')
titel.pack()
# Eingabefeld 1
text = Entry(root, bg = 'white', width=80, relief=SUNKEN)
text.pack()
# Button Geocodieren
button = Button(root, text = "Geocodieren", width=20, command = Insert)
button.pack()
# Geocode Verlauf - alle Statusmeldugen werden hier angezeigt
list = Text(root, relief=SUNKEN)
list.pack()

# Ueberschrifen und Eingabefelder fuer Titel und Inhalt des Popups
feld = Label(root, text='Titel:     ',font=('Arial',8), fg='black')
feld.pack()
titelfeld = Entry(root, bg = 'white', width=50, relief=SUNKEN)
titelfeld.pack()
feld2 = Label(root, text='Inhalt:     ',font=('Arial',8), fg='black')
feld2.pack()
inhaltsfeld = Entry(root, bg = 'white', width=50, relief=SUNKEN)
inhaltsfeld.pack()

# Ueberschrift 2
titel = Label(root, text = '     Soll die grau hinterlegte Adresse mit Titel + Inhalt in der Datenbank gespeicher werden?     ',font=('Arial',8), fg='black')
titel.pack()

# Button Speichern
ja = Button(root, width=20, text='JA, Speichern', command = ja_speichern)
ja.pack()

# Ueberschrift 3
titel1 = Label(root, text = '     Soll das Output-HTML erzeugt werden?     ',font=('Arial',8), fg='black')
titel1.pack()
# Button HTML Erzeugen
html_erzeugen = Button(root, width=20, text='JA, HTML Erzeugen', command = html_erzeugen)
html_erzeugen.pack()
# Button HTML im Browser oeffnen
html_aufrufen = Button(root, width=20, text='HTML Aufrufen', command = html_oeffnen)
html_aufrufen.pack()

# Gesamtschleife fuer GUI
root.mainloop()