===== Code Beispiel für den Einstieg in Python 2 und 3 ===== Code Fragmente für den ersten Einstieg für Python 2 und 3, nicht nur für den Oracle DBA. Leider gibt es so einige Unterschiede im Detail zwischen Python 2 und 3, die es etwas komplizierter gestalten alles was unter Python 2 funktioniert auch in Python 3 zu verwenden. === Entwicklungsumgebungen === **Python 2 / 3** PyCharm * http://www.jetbrains.com/pycharm/ pytools mit Visual Studio * http://pytools.codeplex.com/ * http://www.visualstudio.com/de-de/downloads/download-visual-studio-vs.aspx ---- === Python Distributionen für Windows Systeme === Unter Windows lassen sich für 3.5 nicht so einfach die NumPy Erweiterung verwenden, eine Alternative ist ein "fertiges" Package * http://winpython.github.io/ (aktuell 3.4 verfügbar) * http://www.pyzo.org/downloads.html Alternativ * https://code.google.com/p/pythonxy/ (nur 2.7) ==winpython== Software über http://winpython.github.io/ herunterladen (aktuell 08.2015 WinPython-64bit-3.4.3.5 ) und zum Beispiel nach d:\WinPython installieren. ---- === Ein Python Script nur übersetzen === **Python 2 / 3** Um zum Beispiel vor dem eigentlichen Aufruf die Syntax zu prüfen, durch "-m py_compile" :


python -m py_compile swith_ampel.py

alternativ mit "pylint" testen => http://www.pylint.org/ ---- === Welche Version ist im Einsatz === **Python 2 / 3**



.\python -V


PS D:\Python35> .\python.exe
Python 3.5.0b2 (v3.5.0b2:7a088af5615b, May 31 2015, 06:08:44) [MSC v.1900 32 bit (Intel)] on win32


>>> import sys

>>> print (sys.version)
3.5.0b2 (v3.5.0b2:7a088af5615b, May 31 2015, 06:08:44) [MSC v.1900 32 bit (Intel)]


>>> sys.version_info
sys.version_info(major=3, minor=5, micro=0, releaselevel='beta', serial=2)

---- ==== Module nachinstallieren ==== **Python 2 / 3** Am einfachsten lassen sich Module mit dem **"pip"** installieren. ===pip=== * Download des Scripts "get-pip.py" von https://pip.pypa.io/en/latest/installing.html#install-pip * Script "get-pip.py" zum Beispiel nach D:\Python27 und d:\Python35 kopieren Ablauf in der PowerShell Console:



cd D:\Python27

# Zu Beginn neu installieren
.\python.exe get-pip.py


#update von pip
.\python -m pip install -U pip --upgrade


#nach einer Library/Modul suchen
.\python -m pip search six


#installieren
.\python -m pip install six

=== Wichtige Libraries/Module unter Windows nachinstallieren === Für Linux können die Module oft mit "yum" oder "apt-get" je nach Linux mit allen Abhängigkeiten nach installiert werden. Unter Windows gestaltet sich das etwas schwieriger, zumal hier oft noch selber ein Teil der Quellen neu übersetzt werden müssen. Siehe auch folgendes => http://blog.ionelmc.ro/2014/12/21/compiling-python-extensions-on-windows/ ==Python 2.7== Notwendig für zum Beispiel: "matplotlib" Vorbereitung: Microsoft Visual C++ Compiler for Python 2.7 installieren: * http://aka.ms/vcpython27 herunterladen und installieren (Microsoft Visual C++ Compiler for Python 2.7 ) Phyton Packate "setuptools" und "wheel" installieren


.\python -m pip install  wheel --upgrade
.\python -m pip install  setuptools --upgrade

==numpy ==



.\python -m pip install  six --upgrade
.\python -m pip install  python-dateutil --upgrade

.\python -m pip install  numpy --upgrade

==scipy - SciPy: Scientific Library for Python == Da unter Windows doch so einges dafür übersetzt werden müsste, am einfachsten das Binary scipy-0.16.0-win32-superpack-python2.exe über http://sourceforge.net/projects/scipy laden und installieren. Alternativ: Download fertiger Paket von http://www.lfd.uci.edu/~gohlke/pythonlibs/#scipy


cd D:\Python27\Scripts

.\pip install --use-wheel --no-index --find-links=D:\install\phyton\2.7 scipy-0.16.0-cp27-none-win32

funktioniert leider noch nicht ....... == matplotlib == see => http://matplotlib.org Nachdem numpy und scipy installiert sind kann matplotlib folgen



.\python -m pip install matplotlib --upgrade

Für Windows finden sich hier auch schon fertige Pakete => http://matplotlib.org/downloads.html == PyGame == Für pygame und PyOpenGL, PyOpenGL-accelerate zuvor wheel installieren Siehe auch: * https://bitbucket.org/pygame/pygame/downloads * https://skellykiernan.wordpress.com/2015/01/04/python-pygame-install/ ==Python 3.4== Da zur Zeit für =Python 3.5 nur wenige Libraries (Stand August 2015) überhaupt zur Verfügung stehen auf 3.4 zurück gegangen. Vorbereitung


.\python -m pip install  wheel --upgrade
.\python -m pip install  setuptools --upgrade

==numpy - Numerical Python ==



.\python -m pip install  six --upgrade
.\python -m pip install  python-dateutil --upgrade

 .\python -m pip install  numpy --upgrade

Numpy läßt sich leider auch mit "pip" unter 3.4 nicht installieren, laut Fehlermeldung ( "error: Microsoft Visual C++ 10.0 is required (Unable to find vcvarsall.bat)" ) wird ein Visual C++ 10.0 vorausgesetzt. Es steht aber unter http://sourceforge.net/projects/numpy/files/NumPy/ steht ein Windows Installer Packet für 3.4 zur Verfügung. == matplotlib == see => http://matplotlib.org Nachdem numpy und scipy installiert sind kann matplotlib folgen



.\python -m pip install matplotlib --upgrade

Mit 3.4 kein Problem! ==scipy - SciPy: Scientific Library for Python == Für Phyton 3.4 Installation Package für Windows verwenden ( 08.2015), siehe http://sourceforge.net/projects/scipy . ==ExifRead == Um Bildinformationen auszulesen => https://pypi.python.org/pypi/ExifRead


 .\python -m pip install exifread  --upgrade

---- ==== Kontrollstrukturen ==== ===IF Verzweigung===


x=0
y=2
z=3

#IF Konstrukt
if   x  > 0 :
    print("Größer 0")
elif x == 0 :
    print("gleich 0")
else        :
    print("kleiner 0")

#Mehrfachvergleich
if x < y < z:
    print("y liegt zwischen x und z")


# Vergleichsoperatoren

# > größer
# >= größer gleich
# < kleiner
# <= kleiner oder gleich
# == gleichheit
# != ungleichheit

# Logische Operatoren
# and 
# or
# not

===Python Ternary Operator **#value_true if else value_false**=== Beispiel:


#value_true if  else value_false
c=0

zaehler= 10 if c=0 else 1000

===FOR=== In Python 2x steht keine klassische „For“ Schleife zur Verfügung, soll dann in V3.0 dabei sein. Mit der „range“ Funktion kann aber eine Menge erzeugt werden, über die iteriert werden soll. Eine For Schleife kann auch mit "break" verlassen werden



# Range Funktion für das Erzeugen einer Menge
# Die Schleife läuft von 1 bis 29!
for i in range(1,30):
    # Schleife mit Werten von 0 bis 3
    for y in range(4): 
	printf("i: %d %d \n", i,y)


# String Objekt als Menge

menge="ABCDEFG"

for i in menge:
   print i
A
B
..
G

#Rückwärts über ein Array

for i in reversed(range(10,20,2)):
 print i;

18
16
..
10

===WHILE===


#schleife mit break
x=0
while True :
    print("Durchgang ::",x)
    x+=1
    if x>10:
       break

==== Iterierbare Objekte und Sortierung von Listen ==== ==Listen mit „zip“ zusammenfassen:==


plz  = [2345,2345,4567]
stadt= ["AA","BB","CC"]
land = ["CH","DE","AU"]

elemente=zip(plz,stadt,land)

for elem in elemente:
    print(elem)

### Ausgabe

(2345, 'AA', 'CH')
(2345, 'BB', 'DE')
(4567, 'CC', 'AU')

==Eigene Sortierungen == Listen normal sortieren


#Liste
l=['c','a','e','d','b','x']
print(l)

#gleiche Liste
l.sort()
print(l)

#sortierte Liste zückwärzt neu zurückgeben
ll=sorted(l,reverse=True)
print(l,ll)

Sort Methode mitgeben über den key parameter angeben

x
^#Liste
l=[1,-2,3,-6,4,5,7]
print(l)

#gleiche Liste
l.sort()
print(l)

#sortierte Liste zückwärzt neu zurückgeben
ll=sorted(l,reverse=True,key=abs)
print(ll)

Eine Liste aus Listen sortieren nach dem zweiten Element mit unbenannter Methode (Lambda Konstrukt):


#Test data - List with letter and Numbers pairs
for i in range(65,65+26,1):
   l+=[(chr(i),i)]

# sort the result list after the second parameter 
# mit der unbenannten Funktion (lambda Konstrukt auf dem Listenelement nach dem : ) 
# in dem Fall wird dann der zweite Wert des Elements mit -1 multilizert 
# und damit die Liste rückwärts sortiert

l.sort(key=lambda element: element[1]*-1)

Eine Liste sortiert zurückgeben und das Original nicht verändern mit sorted Liste enthält wiederum Listenelement mit zwei Einträgen


# sort the list with sorted after the second element
sorted_result = sorted(l, key=lambda x: float(x[1]))

---- ====Rechnen==== Beispiele:


import math

#hoch
print(" 4  hoch 2  =>",4**2)
print(" 4  hoch 2  =>",math.pow(4,2))

#Wurzel
print(" 4  Wurzel  =>",math.sqrt(4))

#hoch3
print(" 4  hoch 2  =>",4**3)
print(" 4  hoch 2  =>",math.pow(4,3))

#3' Wurzel
print(" 64  Kubikwurzel  =>",math.pow(64,1/3))

#10 hoch x
print(" 10  hoch 3  =>",math.pow(10,3))

#10' Logarithmus
print(" 10  Logarithmus  =>",math.log(1000,10))

#Eulersche Zahl
print(" Eulersche Zahl  =>",math.e)

#e hoch 5
print(" e  hoch 5  =>",math.exp(5))
print("natürlicher Logarithmus  =>",math.log(148.413159))

#phi
print(" pi =>",math.pi)


#Trigonometrie
#Angabe im Bogenmaß!
#/180*math.pi
#
print(" pi =>",math.sin(30/180*math.pi))
print(" pi =>",math.cos(60/180*math.pi))
print(" pi =>",math.tan(45/180*math.pi))

#Fakultät
print("Fakultät von:")
fa_von=int(input())
result=1
for i in range(1,fa_von+1):
    result= result*i
    
print("Fakultät:",result)

---- ====String Handling ====


#Zeichenkette ist eine unveränderliche Sequenz

#Definition
t1= "1234567"
t2= 'ABCDEFG'
t3= """
Über mehr als eine Zeile Wert 3
"""
t4= " Wert 4 mit ' "
t5= ' Wert 5 mit " '

#Eingabe in der selben Zeile
print("Eingabe::",end='')
t6= input()

#Operatoren

#zusammenfügen
print(t1+t2)

#Mehrfach ausgeben
print(t1*3)

#Länge
print("Länge von t4",len(t4))


#Abschnitte aus einem Text lesen
print("Slice:",t2[0:3])
#Vom Anfang inkl. Zeichen 2
print("Slice:",t2[:3])
#Ab Zeichen 3 bis zum Ende
print("Slice:",t2[3:])
#Ab Zeichen 3 bis zum  2 Vor dem Ende
print("Slice:",t2[3:-2])

#Vergleich

if "W" in t1:
    print("Ein W ist in t1 enthalten")

if "W" not in t6:
    print("Ein W ist in t6 NICHT enthalten")

#Eine Teilstring ausschneiden
#String manipulieren und auf sich selber wieder zuweisen
t1=t1[:2]+ t1[4:]
print(t1)

    
#Als Menge verwenden
for i in t2:
    print(i)

# Wie oft ist ein Buchstabe enthalten
print("Anzahl eines Zeichens:",t6.count("X"))

#Wo kommt das Zeichen zuerst vor? 0 ist die erste Position
print("Position eines Zeichens:",t6.find("X"))
#Suche ab Position
print("Position eines Zeichens:",t6.find("X",3))
# Kein Vorkommen => -1

#Ersetzen
t6=t6.replace("x","X")
print(t6)

#Umwandeln Zahl in Zeichen
t6="Wert ::" + str(18889.990)
print(t6)

#Umwandeln einer Eingabe in eine Zahl
print("Zahl als Eingabe::",end='')
t7= input()
#Fehler abfangen
try:
    zahl=float(t7)
except:
    print("Error - Keine Umwandlung möglich")

---- ====Listen, Mengen, Tupel, Dictionaries ==== === Liste === Eine Liste wird mit **[ ]** Klammern angelegt. Kann alle Objekttypen aufnehmen



#Definieren
z = [ 3, 6, 12.5, -8, 5.5]
#Ausgeben
print(z)
print(z[0])
print(z[::-1])


s=["AB","CD","EF","GH"]
print("Elemente in der Liste::",len(s))

#Listen in Listen
x=[z,s]
print(x)
print(x[0][3])

y=[["ABC",10],["CDE",20]]
#Auf den Wert 10 zugreifen
print(y[0][1])


#Elemente können ersetzt werden
s[3]="XYZ"
print(s)

#Element löschen
del s[0]
print(s)

#Element einfügen
s.insert(0,"abc")
print(s)


# Ein benanntes Element entfernen
s.remove("CD")
print(s)

# ein Element anfügen
s.append("WWW")
print(s)


# Eine Liste rückwärts wandeln:

liste=[0,10,20,30]

liste.reverse()

liste

[30, 20, 10, 0]

# wieder andersherum ausgeben

liste[::-1]
[0, 10, 20, 30]

# eine Liste überbeiten wie
# Liste in int Werte umwandlen
dat=["1","2","3","4","5"]

dati = [int(i) for i in dat]
    

# Überprüfen ob das Element in der Liste enthalten ist
if "3" in dat:    
   #do something

==Listen-Abstraktion (List Comprehension)== Liste aus anderen Listen heraus erzeugen Genereller Aufbau: **[ (Output Expression) (for in ) (Optional Predicate) ]** Beispiel:



#die Demo Liste mit A bis  o erzueugen
l=[]
for i in range(65,80,1):
	l.append(chr(i))

# Listen-Abstraktion (List Comprehension)
# Liste ab G ausgeben

result=[x  for x in l if ord(x) > 70  ]

#Liste verändern
result=[elem+".X"  for elem in l]


#Mehrdimensionale Liste erzeugen ohne Paare mit x=y

[ (x,y)   for x in range(1,10) for y in range(1,10)   if y!=x]

Für List Comprehension siehe auch http://python-3-patterns-idioms-test.readthedocs.org/en/latest/Comprehensions.html ==Map== Eine Funkion auf alle Elemente einer Liste ausführen


#my func
def my_dub(v):
    return v*2

#my basic list
l=range(1,20)

#double all values in the list
result=list(map(my_dub,l))

==Filter==


# Mit filter bestimmmte Element aus der Liste heraussuchen und wieder eine neue Liste erstellen
# Phyton 3 gbit keine Liste sonder ein Filter Objekt zurück das wieder in eine Liste gewandelt werden muss
# Die Suchmethode wird als lambda  ausdruck angegeben

result=filter(lambda element: element[0] == 'M',l)

print(list(result))


#eine Funktion übergeben
# Ist die Zahl gerade oder ungerade 
def my_even(v):
   return v % 2 == 0

#my basic list
l=range(1,20)

result=list(filter(my_even,l))

==reduce== fold in python Ab Python 3.2 importieren! Die Funktion wird auf die Elemente der Liste angewandt, bis alle Element abgearbeitet sind Also Gesamtwert + erstes Element der Liste, dann wieder neuer Gesamtwert + nächstes Element der Liste usw.



from functools import reduce

def my_sum(x,y):
    return x + y


#my basic list
l=range(1,20)

reduce(my_sum,l)

#Result => 190
190


gleiche Ergebnis wie:
r=0
for i in l:
   r+=i

r
190

===Tupel=== Können nicht verändert werden und werden mit **( )** Klammern oder mit "," angelegt!


# mit ()
zt=( 1,3,"AB")
#alternativ
zt= 1,3,"AB"

#Zugreifen
print(zt[3])


#Mehrfachzuweisung

a,b,c = 1,2,"WWW"

print(a,b,c)


#Mehrfachzuweisung mit Werten aus einem Tupel mit gleicher Anzahl
#Anzahl muss zur Position passen
a,b,c = z
print(a,b,c)

#Zuweisung mit * für ungleiche Anzahl von Variablen zu Tupel
# a erhält ersten Wert, b alle Wert bis auf die 8

a,*b,c = 12,2,3,5,6,7,8
print(a,b,c)

=== Dictionary - Wörterbuch === Zusammengefasst aus Schlüssel und Wert und werden mit **{ }** Klammern angelegt und können verändert werden


## dictionary anlegen
pers={  "Gunther":1966 
      , "Martina":1967
      , "Claus"  :1956
      }

#Ein benanntes Element ausgeben
print(pers["Claus"])

#Wert ändern
pers["Martina"] = 1956

#Neuen Wert einfügen
#Wird eingefügt wenn Schlüssel nicht existiert
pers["Martin"] = 1958

#Wert einfügen
pers.update({"Herber":1967,"Bert":1978})

#prüfen
if "Gunther" in pers:
    print(pers["Gunther"])

#ein Element löschen
del pers["Gunther"]


#Views auf die Dictionaries
# Referenzieren die Werte => Inhalte ändern sich mit dem Dictionary!

#Alle Werte
jahrgaenge=pers.values()

#Alle Schlüssel
personen=pers.keys()

#Alle Items
eintraege=pers.items()

print(jahrgaenge)
print(personen)
print(eintraege)

=== Set -Menge === Mengenoperationen können auf den Set's durchgeführt werden, wird mit der Funktion **set()** erzeugt. Ein Set enthält die disjunkte Menge aller unterschiedlichen Objekte der Ausgangsliste.


b=[1,3,3,3,5,6,7,8,8,8,8]

#Liste in ein Set schreiben
s=set(b)
print(s)

#Ein Element löschen
s.discard(3)
print(s)

#Vergleiche auf Mengen
if m1 > m2 :
    print("Menge m1:",m1)
else:
    print("Menge m2:",m2)

m4=set([8,5,"x"])
m5=set([5,"abc","x"])

#Vereinigungsmenge
m_union=m4|m5
print(m_union)

#Schnittmenge
m_schnitt=m4 & m5
print(m_schnitt)

#Differenzmenge j
#je left or right join!

m_dif=m4 - m5
print(m_dif)

m_dif=m5 - m4
print(m_dif)

#Symetrische Differenzmenge
m_sym=m5 ^ m4
print(m_sym)

==Frozen Set - Eingefrorene Menge == Nicht veränderbar aber schneller in der Verarbeitung


fs=frozenset([2,3,3,5])
print (fs)

===Mehr=== * http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html ---- ==== Boolean - mit Wahrheitswerten umgehen ====


a = True
b = False

print(a,b)

#Ergebniss einer Auswertung zuweisen
a = 3 > 1
b = 10 < 3

print(a,b)

#Ist der Wert einer Zahl 0 dann false ansonsten true
c=1
print(c,bool(c))
c=0
print(c,bool(c))

#Ist der Wert eine Strings leer dann false ansonsten true
c="T"
print(c,bool(c))
c=""
print(c,bool(c))

#Ist eine Liste Leer dann false ansonten true
c=[1,2]
print(c,bool(c))
del c[0:2]
print(c,bool(c))

      
#Ist ein tupel oder Set leer dann false ansonten true
c=set((1,2))
print(c,bool(c))
c.clear()
print(c,bool(c))

#Ist ein dictionary Leer dann false ansonten true
c={1:2,3:4}
print(c,bool(c))
del c[1]
del c[3]
print(c,bool(c))

---- ==== Funktionen ==== Eine Leere Funktion anlegen mit "pass" als einzige Code Zeile (d.h. tue nichs!) (z.B. falls eine Function erst später implementiert werden soll:


def doSomeWork():
    pass

Weitere Beispiele:


import math

#Ohne Rückgabewert und Parameter
def printLine():
    print(20*"-")

#Mit Rückgabewert und Parameter
def quadrat(x):
    result=x*x
    return result

def greater(x,y):
    result=y
    if (x>y):
        result=x
    return result

#Wertemenge übergeben als Tupel mit dem * Operator!
#Erste beide Parameter sind Pflicht!
def avg(a,b,*x):
    result=a+b
    c=2+len(x)    
    for w in x:
        result+=w
    result /= c    
    return round(result)

#Return mit mehreren Werten    
def circle(r):
    fl=math.pi*r*r;
    um=2*math.pi*r
    return round(fl,3), round(um,3)

#Gültigkeitsbereich von Variablen
#Lokal vor Global, Listen/Dictionary/sets werden referenziert
def setval(x,y):
    x[0]=99
    y=y+1
    print("Werte von in Function setval: x",x,"und y::",y)



printLine()
print("Quadrat von 3",quadrat(3))
printLine()

#funktionsnamen einer Variable zuweisen
p=printLine

p()

#Benannte Zuweisung bei der Paramter Überabe mit =
print("Größere Wert von :: 10 5 ",greater(y=5,x=10))
p()

#Wertemenge übergeben

print("Wertemenge übergeben - Anzahl 4",avg(2,3))
print("Wertemenge übergeben - Anzahl 6",avg(1,2,4,3,6,5))
p()

#Mehrer Werte zurückgeben
fl,um=circle(5)
print("Ein Kreis mit dem Radius 5m hat die Fläche",fl,"m2 und den Umfang",um ,"m")

xt=circle(6)
print("Ein Kreis mit dem Radius 6m hat die Fläche",xt[0],"m2 und den Umfang",xt[1] ,"m")

p()

#Gültigkeit von Variablen
#Listen/dictonary/sets werden referenziert
#Global vor local
x=[1,2,3]
y=4
print("Werte vor setval  :: x:",x,"und y:",y)
setval(x,y)
print("Werte nach setval :: x:",x,"und y:",y)

==Eine Funktion in ein Modul als Library speichern== Eine neue py Datei für die ausgelagerten Funktionen anlegen, mit "import name_der_library" importieren und dann mit "import name_der_library.function" im eigentlichen Programm referenzieren. Das Modul:


def quadrate(x):
    result=x*x
    return result

Im Programm referenzieren:


#Importiere das Modul und vergebe den Präfix gpi
import modul_gpi as gpi

#Importiere die einzelne Funktion
#Besser da eindeutiger Präfix verwenden! oder mit * alle in dem Modul
#from  modul_gpi import quadrate

z=gpi.quadrate(8)

print(z)

---- ==== Exception Handling === Beispiel 1 - Abfangen:


#Phyton 3! 
try:
    print("Zahl eingeben:: ",end="")
    zahl = float(input())
    print()
    k=1/zahl
except ValueError:
     print("Error: Keine Zahl")
except ZeroDivisionError:
     print("Error: Zahl 0 eingegeben")

Beispiel 2 - Solange wiederholen bis eine richtiger Wert eingegeben wurde!:


eingabe=0
while eingabe < 0 or eingabe > 10:
        try:
           print("Anzahl (1 bis 10):",end="")
           eingabe=int(input())
           print()
        except:
           continue

Beispiel 3 - Exception auswerten


#Python 2

import sys

...

try:
    # insert the whole record
    cursor.executemany("insert into dept (DEPTNO, DNAME4,LOC) values (:1, :2,:3)", dept_rows)
except cx_Oracle.DatabaseError as e:
    connection.rollback()
    print "Oracle Database Error:", e
except:
    print "Unexpected error:", sys.exc_info()[0]
    raise

see https://docs.python.org/2/tutorial/errors.html Beispiel 4 Eine Exception rufen


...
try:
   if ergebnis == int(input()):
        print("Richtig")
        return 1
   else:            
        raise                
   except:
         print("Falsch")
         return 0

...

Beispiel 5 Eine Exception im Code werfen:


if (datagram[20]==1):
    raise ValueError('-- Error :: Bit 20 as HIGH detectd - Start telegramm alwas LOW')

---- ==== Zeit und Datum ==== Modul "time" importieren Datum und Uhrzeit ausgeben:


import time

print("EPOCH Zeit:",time.time())

lt=time.localtime()

print("Local Time:",lt)

print("Datum:   {0:02d}.{1:02d}.{2:4d}".format(lt.tm_mday,lt.tm_mon,lt.tm_year))
print("Uhrzeit: {0:02d}:{1:02d}:{2:02d}".format(lt.tm_hour,lt.tm_min,lt.tm_sec))


#Wochentag ausgeben
wtage=['Montag','Dienstag','Mittwoch','Donnertag','Freitag','Samstag','Sonntag']

print("Der heute Tag ist: {0:8s}".format(wtage[lt.tm_wday]))

#aktuelle Kalenderwoche
print(time.strftime("KW Beginn am Sonntag: %U",lt))
print(time.strftime("KW Beginn am  Montag: %W",lt))

Für das time.struct_time siehe => https://docs.python.org/3/library/time.html#time.struct_time Mit Zeiten rechen:


# Mit Zeiten rechnen
#       YYYY, M, DD, HH, MM, SS, wday, yday, isdst
lTimeT1= 1976, 9, 29, 12, 15,  15,    0,    0,    0
lTimeT2= 1990, 3, 31, 12, 15,  15,    0,    0,    0

# Falls Jahr < 1970 OverflowError: mktime argument out of range!
startzeit =time.mktime(lTimeT1)
endzeit   =time.mktime(lTimeT2)


print("Start Time",startzeit,"End Time:",endzeit)

vergangen=endzeit-startzeit
print("Vergangene Zeit",vergangen)


#Falls vor 1970 nur ein Datum anlegen mit:
#                             YYYY, M, DD, HH, MM, SS,
startzeit2= datetime.datetime(1946, 9, 29, 12, 15,  15)
endzeit2  = datetime.datetime(1971, 3, 31, 23, 35,  55)
print("Start Time:",startzeit2)
print("End Time:"  ,endzeit2)


vergangen2=endzeit2-startzeit2
print("Vergangene Zeit",vergangen2)

siehe auch http://www.saltycrane.com/blog/2008/11/python-datetime-time-conversions/ ---- ==== Signal Handling ==== Praktisch um zum Beispiel auf ein ^C zu reagieren


import signal

...
#define the clean exit
def clean_exit():
        global run
        RPIO.output(out_port,RPIO.LOW)
        run=False
        exit()

#define the trap handler
def handler(signum, frame):
        print "Catch Error {} - frame :: {}".format(signum,frame)
        clean_exit()

# register the signal handler
signal.signal(signal.SIGINT, handler)

...

---- ==== Externe Programme einbinden ==== Gerade im Einsatz von Python als Ersatz für Bash Scripts sind der Aufruf und die Verarbeitung der Rückgaben von externen Programmen sehr wichtig. Beispiel:


import subprocess

#Command + arguments  as sequence
args=["ping", "-a", "www.heise.de"]

#execute the program and pipe the output to subprocess.PIPE
prog=subprocess.Popen(args,stdout=subprocess.PIPE) 

#wait until finished
stat=prog.wait()

# connect pipes together
(output, err) = prog.communicate() 

#print the output
print output

Funktioniert aber nicht mit "shell=True" (cygwin/windows), hier muss das Programm + Argumente dann als ein String übergeben werden.


import subprocess

#Command + arguments  as sequence
args="ping -a www.heise.de"

#execute the program and pipe the output to subprocess.PIPE
prog=subprocess.Popen(args,stdout=subprocess.PIPE,shell=True) 

#wait until finished
stat=prog.wait()

# connect pipes together
(output, err) = prog.communicate() 

#print the output
print output

Python Doku: * https://docs.python.org/2/library/subprocess.html Beispiele: * http://www.cyberciti.biz/faq/python-run-external-command-and-get-output/ * http://www.cyberciti.biz/faq/python-execute-unix-linux-command-examples/ * http://stackoverflow.com/questions/2651874/embed-bash-in-python siehe Anwort 18# ---- ==== Zeichensatz Probleme ===== Die Test Datei:


# Commment with umlaut
# Dies ist eine Lösung

# String mit umlaut

print "Lösungsansatz für ein öäü"

Problem:


  File "check_umlaut.py", line 3
SyntaxError: Non-ASCII character '\xf6' in file check_umlaut.py on line 3, but no encoding declared; see http://www.python.org/pep
s/pep-0263.html for details

# Zeichensatz erkennen mit:

$ file -ib check_umlaut.py

text/plain; charset=ISO-8859

Lösung - den genauen Zeichensatz und Dateityp den Python Interpreter bekannt geben:


# -*- coding: iso-8859-1 -*-

Oder auf „echte“ UTF-8 Dateien achten! Problem:


 return codecs.charmap_encode(input,self.errors,encoding_table)[0]
UnicodeEncodeError: 'charmap' codec can't encode character '\u25b6' in position 25: character maps to

Lösung String mit encode kodieren, zuvor testen was die Umgebung verwendet:


import locale

print("-- Info  :: Environment Settings :: Language :: {0} - Char Set ::{1}".format(locale.getdefaultlocale()[0],locale.getdefaultlocale()[1]))
    
...
print("-- Not index this file::{0}".format(repr(filename.encode('utf-8'))))
...

siehe auch => http://gelb.bcom.at/trac/misc/wiki/TutorialsPython/PythonUmlauteUnicodeEncodings und https://pypi.python.org/pypi/langdetect ---- ==== Formatierte Ausgabe ==== === Python 2 === OLD Style Beispiel mit "%" Operator:


print "Port 17 => %s :: Button pressed:: %d " %  (str(RPIO.input(in_port)), push_count)

NEW Stype mit "format" Funktion:


print "Port 17 => {0:7} :: Button pressed:: {1} ".format(str(RPIO.input(in_port)), push_count)

siehe https://docs.python.org/2/tutorial/inputoutput.html === Python 3 === Formatierte Ausgaben mit Format ähnlich wie in Python 2, aber eben mit den nun notwendigen () für den Methoden Aufruf.


product= {1021:"PC C",45:"Notebook A",578:"Tablet B"}
stock  = {1021:23,45:5,578:10}
price  = {1021:377.9,45:789.6,578:236.78}

for x in 1021,45,578:
    print("{0:04d} {1:12} {2:4d} {3:8.2f} Euro : Gesamt {4:8.2f}".
          format(x ,product[x] ,stock[x] ,price[x], stock[x] * price[x])
          )
          
# => ergibt:          

1021 PC C           23   377.90 Euro : Gesamt  8691.70
0045 Notebook A      5   789.60 Euro : Gesamt  3948.00
0578 Tablet B       10   236.78 Euro : Gesamt  2367.80

===c printf ===


import sys

def printf(format, *args):
    sys.stdout.write(format % args)

siehe https://www.safaribooksonline.com/library/view/python-cookbook-2nd/0596007973/ch04s21.html ---- ==== String to directory mit Json ==== Aufgabe: eine Liste von Wert:Value Paaren wird dynamisch als String erzeugt und soll als "dictionary" Objekt weiter verarbeitet werden. Lösung:



import json

#String
hosts='{"srv01":"db","srv02":"web","srv03":"app"}'

# wandeln
liste=json.loads(hosts)


type(liste)

---- ==== Umgebungsvariablen ====


import os

#print all enviroment variables
print os.environ

#get only enviroment variable HOSTNAME
print  os.environ['HOSTNAME']

#print all keys
for i in os.environ.keys():
  print "{0:25} :: {1}".format(i,os.environ[i])

---- ==== Rechnen ==== === Rechenoperationen=== Neben den normalen Rechenoperationen: * Ganzzahl-Division mit **//** => 25 // 3 => 8 (immer die nächste kleinere Zahl!) => 25 // -3 => -9 * Modulo Operator mit **%** Rest der Ganzzahl-Division => 25 % 3 => 1 - 25 % -3 => -2 ===Mit Binärzahlen rechnen === Integer Wert in Bin ausgeben - Funktion **bin**



value=255

bin(value)
'0b11111111'

Binär angeben:


value=0b11111111

value
255

==Rechnen - Mit einer Maske ein Bit ändern:== 11111111 AND 11111110 => 11111110 "Logische AND = &":



0b11111111 & 0b11111110
254

bin(254)
'0b11111110'


Bits verschieben mit ">>" recht und "<<" links


1 << 4

16

bin(16)
0b10000

16 >> 4
1




Bitweise setzen:

#set bit at postion to 1
def setBit(int_type, offset):
    mask = 1 << offset
    return(int_type | mask)

#set bit at postion to 0
def clearBit(int_type, offset):
    mask = ~(1 << offset)
    return(int_type & mask)


siehe auch https://wiki.python.org/moin/BitManipulation


----


==== Parameter Übergabe ====

===Allgemein===


import sys

#Alle Übergabe werte stehen in sys.argv

#Programmname an Stelle 0

print("Der Programm Name ist:", sys.argv[0])





===Wie in der Bash mit getops ===

Bash Syntax siehe => [[linux:bash_script_snippets#aufruf_parameter_an_ein_script_uebergeben|Parameter an ein Bash Script übergeben]]


Beispiel:

import sys,getopt

def main(argv):
    global ref_voltage
    global v_runs
    try:
        opts, args = getopt.getopt(argv, "hv:r:", ["vref=", "runs="])
    except getopt.GetoptError:
        print sys.argv[0] + " -v  -r  "
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print sys.argv[0] + " -v  -r  "
            sys.exit()
        elif opt in ("-v", "--vref"):
            ref_voltage = float(arg)
        elif opt in ("-r", "--runs"):
            v_runs = int(arg)
    print "Referenz Voltage => {0:10.4f} :: Runs :: {1}".format(ref_voltage, v_runs)


if __name__ == "__main__":
    main(sys.argv[1:]);



siehe http://www.tutorialspoint.com/python/python_command_line_arguments.htm


----


==== Eigene Klassen in Python verwenden ====

Eine einfache erste Klasse mit Methoden und einer Vererbung:

#Um später ein Objeckt zu kopieren!
import copy

#Klasse in Python definieren

#Name der Klasse
class Bauteil:
    #Variablen der Klasse
    artikelnummer = 'A0000'
    laenge,breite = 1.0,1.0
    
    #Konstruktur
    #Kann nicht überladen werden,daher mit optionalen Parametern arbeiten
    def __init__(self,artikelnummer=None,laenge=None,breite=None):
        #value_true if  else value_false
        self.artikelnummer=self.artikelnummer if artikelnummer is None else artikelnummer
        self.laenge= self.laenge if breite is None else breite
        self.laenge= self.laenge if laenge is None else laenge
        
    #Destruktur - Klasse wieder abbauen
    def __del__(self):
        print("Final Block der Klasse");


    #Defaut Methoden überschreiben
    #String Metode
    def __str__(self):
        return "Das Bauteil hat die Artikelnummer::"+ self.artikelnummer +"und die Fläche :: "+str(self.flaeche())

    #Object beschreiben inkl. ausgabe der Basis Klasse
    def __repr__(self):
        return "Objekt der Klasse Bauteil" + " "+repr(super())

    #Operator Methoden
    
    #Vergleich , eigenes object + zu vergleichendes Objekt
    # >= __ge__
    # <= __le__
    # != __ne__
    
    #>  größer
    def __gt__(self,other):
          return self.flaeche()>other.flaeche()
    #<  kleiner
    def __lt__(self,other):
          return self.flaeche() t1:
    print("t2 ist größer")
else:
    print("t1 ist größer")
  
#Object zusammen rechnen - Operator
dif=t1-t2
print("Differenz zwischen t1 und t2 ::",str(dif))
print("Gesamtfläsche      t1 und t2 ::",str(t1+t2))

#Ojekte referenzieren
#Eine zuweisung auf einen neuen Namen zeigt immer noch auf das gleiche Objeckt!
t3=t2
t3.breite=10
print(t3)
print(t2)

#Ein Objekt kopieren (deep copy)
#damit wird ein neues Objekt angelegt auf das t4 zeigt!
t4=copy.deepcopy(t2)
t3.breite=100
print(t3)
print(t4)

#Objekte "abbauen"
del t1,t2

#Vererbtes Objekt anlegen
o1=DachPfanne(  artikelnummer="Dach001"
              , laenge=10
              , breite=10
              , gewichtsfaktor=5)

print(o1)




Von zwei Klassen die Eigenschaften vererben:

#Klasse 1
class Bauteil:
    artikelnummer = 'A0000'
 
    #Konstruktur
    def __init__(self,artikelnummer=None):
        self.artikelnummer=self.artikelnummer if artikelnummer is None else artikelnummer   

    #String Methode
    def __str__(self):
        return "Das Bauteil hat die Artikelnummer:: "+ self.artikelnummer

#Klasse 2
class Material:
    material='Beton'
    def __init__(self,material):
        self.material=material

    #String Methode 
    def __str__(self):
        return "Das Material besteht aus "+self.material

#Zusammen geerbete Klasse
#die gemeinsamen Eigenschaften der ersten genannten Klasse überschreiben die Eigenschaften der zweiten Klasse
class Traeger(Bauteil,Material):
      def __init__(self,material,artikelnummer=None):
        Material.__init__(self,material)
        Bauteil.__init__(self,artikelnummer)
     

################ Verwenden #############
        
t1=Traeger("Stahl")
print(t1)


# ausgabee
# Das Bauteil hat die Artikelnummer:: A0000




----

==== Datei Handling ====

===Sequentielles Schreiben===
Eine Datei zum Schreiben und eine andere Datei zum Lesen öffnen

import sys,time,datetime

n="daten.csv"

#Sequentielles Schreiben
#
try:
    #Dateizeiger auf die Datei öffnen
    # w - schreibend öffnen, neu anlegen
    # a - hinten anfügen
    f = open(n,"w")
except:
    print("Dateizugriff auf"+n+"nicht erfolgreich")
    sys.exit(0)

#Daten
aa=10
bb="Huber"
cc=345.8
t=";"
lt=time.localtime()
ltdat=str(lt.tm_mday)+"."+str(lt.tm_mon)+"."+str(lt.tm_year)

#Zeilen erzeugen
for i in range(20):
    f.write(str(aa+i) + t + bb + t + str(cc+i).replace('.',',') + t + ltdat +"\n")

f.close()


### Wieder einlesen

try:
    f = open(n)
except:
    print("Dateizugriff auf"+n+"nicht erfolgreich")
    sys.exit(0)

l = f.readline()
while l:
    li = l.split(';')
    #Datum wieder als Datum einlesen
    dat=li[3].split('.')
    #Liste in int Werte umwandlen
    dati = [int(i) for i in dat]
    #Datumsobject erzeugen
    datd=datetime.datetime(dati[2], dati[1], dati[0])

    #Alles wieder ausgeben
    print(str(int(li[0])),li[1],str(float(li[2].replace(',','.'))),datd)
    l = f.readline()

f.close()    



===Frei in der Datei lesen und schreiben===

import sys


# Formatierte Datei erzeugen

n="data.dat"

try:
    f = open(n, "w")
except:
    print("Dateizugriff auf "+n+"nicht erfolgreich")
    sys.exit(0)

product= {1021:"PC C",45:"Notebook A",578:"Tablet B"}
stock  = {1021:23,45:5,578:10}
price  = {1021:377.9,45:789.6,578:236.78}

for x in 1021,45,578:
    f.write("{0:04d} {1:12} {2:4d} {3:8.2f} {4:8.2f}\n".
          format(x ,product[x] ,stock[x] ,price[x], stock[x] * price[x])
          )

f.close()

#
### Wieder einlesen und ändern ####
#

# Öffne mit r+ für read and write!
try:
    f = open(n,"r+")
except:
    print("Dateizugriff auf "+n+"nicht erfolgreich")
    sys.exit(0)

#In eine Stelle der Datei positonieren
f.seek(42) # Anfang der zweite Zeile

#Lese 4 Zeichen ein
#Artikel Nummer
artNr=int(f.read(4))

#Lese den Artikelnamen ein
f.seek(42+5)
print("artNr:",artNr,"von",f.read(8),"wird geändert auf",artNr+1)

#Ändere die Artikel Nummer
f.seek(42)
f.write("{0:04d}".format(artNr+1))


f.close()


=== Alle Dateien in einem Verzeichnis durchsuchen==

Alle Dateien in einem Verzeichnis durchsuchen und das Dateidatum anzeigen:

import glob,os,time

#alle Dateiennamen in einem Verzeichnis einlesen mit modul glob
dateiList= glob.glob("*.py")

suchText="for"

for datei in dateiList:
    #Datei öffnen
    try:
        f=open(datei)
    except:
        print("Fehler")
        continue
    #Alles einlesen
    readTextAll= f.read()
    f.close()

    #Suchen im Text
    if readTextAll.find(suchText) != -1:
        print("Suchwort",suchText,"gefunden in",datei)
    else:
        print("Suchwort",suchText,"nicht gefunden in",datei)

    #Datei eigenschaften anzeigen lassen
    print("Größe"      ,os.stat(datei)[6])
    lz=time.localtime(os.stat(datei)[8])
    print("Lesezugriff",time.strftime("%d.%m.%Y %H:%M:%S",lz))


=== Dateien einlesen, umbenennen, löschen===


import sys, shutil, os, glob

#Alle Datein in diesem Verzeichnis mit diesen Filter auflisten
print(glob.glob("*.txt"))

#Prüfe ob die Datei existiert
if os.path.exists("lesen.txt"):
    print("Datei exists!")
else:
    sys.exit()

#Datei mit shutil kopieren
shutil.copyfile("lesen.txt","lesen_neu.txt")
print(glob.glob("*.txt"))

#Datei umbennen
try:
    os.rename("lesen_neu.txt","lesen_alt.txt")
except:
    print("Error rename file")
print(glob.glob("*.txt"))    

#Datei löschen
try:
    os.remove("lesen_alt.txt")
except:
    print("Error drop file")    
print(glob.glob("*.txt"))    



----
==== Konfigurationsdateien ====

siehe https://docs.python.org/3/library/configparser.html


----


==== Quellen ====


Video Tutorial für den allerersten Einstieg:

  * Programmieren lernen mit Python von Thomas Theis  Trailer => https://www.youtube.com/watch?v=SwZKoXTkqUE