Gunther Oracle APEX und Datenbank Wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
===== 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" :

<code python>
python -m py_compile swith_ampel.py
</code>

alternativ mit "pylint" testen => http://www.pylint.org/


----
=== Welche Version ist im Einsatz ===
**Python 2 / 3**

<code python>

.\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)

</code>


----

==== 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:
<code powershell>

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

</code>

=== 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
<code python>
.\python -m pip install  wheel --upgrade
.\python -m pip install  setuptools --upgrade
</code>


==numpy ==


<code cmd>

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

.\python -m pip install  numpy --upgrade
</code>



==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

<code cmd>
cd D:\Python27\Scripts

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

</code>

funktioniert leider noch nicht .......


== matplotlib ==

see => http://matplotlib.org

Nachdem numpy und scipy  installiert sind kann matplotlib folgen
<code cmd>

.\python -m pip install matplotlib --upgrade

</code>

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

<code python>
.\python -m pip install  wheel --upgrade
.\python -m pip install  setuptools --upgrade
</code>



==numpy - Numerical Python ==


<code cmd>

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

 .\python -m pip install  numpy --upgrade

</code>


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
<code cmd>

.\python -m pip install matplotlib --upgrade

</code>

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

<code python>
 .\python -m pip install exifread  --upgrade
</code>


----


==== Kontrollstrukturen ====

===IF Verzweigung===

<code python>
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

</code>

===Python Ternary Operator **#value_true if <test> else value_false**===

Beispiel:
<code python>
#value_true if <test> else value_false
c=0

zaehler= 10 if c=0 else 1000

</code>

===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

<code python>

# 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

</code>

===WHILE===

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

</code>


==== Iterierbare Objekte und Sortierung von Listen ====

==Listen mit „zip“ zusammenfassen:==

<code python>
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')

</code>

==Eigene Sortierungen ==

Listen normal sortieren

<code python>
#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)
</code>

Sort Methode mitgeben über den key parameter angeben

<code python>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)
</code>

Eine Liste aus Listen sortieren nach dem zweiten Element mit unbenannter Methode (Lambda Konstrukt):
<code python>
#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)

</code>

Eine Liste sortiert zurückgeben und das Original nicht verändern mit <fc #800000>sorted</fc>
Liste enthält wiederum Listenelement mit zwei Einträgen
<code python>
# sort the list with sorted after the second element
sorted_result = sorted(l, key=lambda x: float(x[1]))
</code>

----


====Rechnen====

Beispiele:

<code python>
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ß!
#<grad Angabe>/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)

</code>


----


====String Handling ====

<code python>
#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")

</code>


----

====Listen, Mengen, Tupel, Dictionaries ====

=== Liste ===


Eine Liste wird mit **[ ]** Klammern angelegt. Kann alle Objekttypen aufnehmen

<code bash>

#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
   
   
</code>

==Listen-Abstraktion (List Comprehension)==

Liste aus anderen Listen heraus erzeugen

Genereller Aufbau:

**[ (Output Expression) (for <Variable> in <Sequence>) (Optional Predicate) ]**

Beispiel:

<code python>

#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]


</code>


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

<code python>
#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))

</code>

==Filter==

<code python>
# 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))

</code>

==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.
<code python>

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

</code>


===Tupel===

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

<code python>
# 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)


</code>


=== Dictionary - Wörterbuch ===

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

<code python>
## 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)


</code>

=== 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.

<code python>
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)


</code>

==Frozen Set - Eingefrorene Menge ==

Nicht veränderbar aber schneller in der Verarbeitung

<code python>
fs=frozenset([2,3,3,5])
print (fs)
</code>

===Mehr===

  * http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html

----
==== Boolean - mit Wahrheitswerten umgehen ====

<code python>
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))


</code>


----
==== 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:
<code python>
def doSomeWork():
    pass
</code>

Weitere Beispiele:
<code python>
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)

</code>

==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:
<code python>
def quadrate(x):
    result=x*x
    return result
</code>

Im Programm referenzieren:
<code python>
#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)

</code>


----

==== Exception Handling ===

Beispiel 1 - Abfangen:
<code python>
#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")    

</code>

Beispiel 2 - Solange wiederholen bis eine richtiger Wert eingegeben wurde!:
<code python>
eingabe=0
while eingabe < 0 or eingabe > 10:
        try:
           print("Anzahl (1 bis 10):",end="")
           eingabe=int(input())
           print()
        except:
           continue
</code>




Beispiel 3 - Exception auswerten
<code python>
#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

</code>
see https://docs.python.org/2/tutorial/errors.html

Beispiel 4 Eine  Exception rufen
<code python>
...
try:
   if ergebnis == int(input()):
        print("Richtig")
        return 1
   else:            
        raise                
   except:
         print("Falsch")
         return 0

...
</code>

Beispiel 5 Eine Exception im Code werfen:
<code python>
if (datagram[20]==1):
    raise ValueError('-- Error :: Bit 20 as HIGH detectd - Start telegramm alwas LOW')
</code>

----

==== Zeit und Datum ====
Modul "time" importieren

Datum und Uhrzeit ausgeben:
<code python>
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))



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


Mit Zeiten rechen:

<code python>
# 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)

</code>

siehe auch http://www.saltycrane.com/blog/2008/11/python-datetime-time-conversions/


----

==== Signal Handling ====

Praktisch um zum Beispiel auf ein ^C zu reagieren

<code python>
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)

...

</code>


----

==== 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:
<code python>
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

</code>


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

<code python>
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
</code>

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:

<code python>
# Commment with umlaut
# Dies ist eine Lösung

# String mit umlaut

print "Lösungsansatz für ein öäü"
</code>


Problem:
<code python>
  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


</code>

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

<code python>
# -*- coding: iso-8859-1 -*-
</code>

Oder auf „echte“ UTF-8 Dateien achten!

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

Lösung String mit encode kodieren, zuvor testen was die Umgebung verwendet:
<code python>
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'))))
...
    
</code>


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:
<code python>
print "Port 17 => %s :: Button pressed:: %d " %  (str(RPIO.input(in_port)), push_count)
</code>

NEW Stype mit "format" Funktion:
<code python>
print "Port 17 => {0:7} :: Button pressed:: {1} ".format(str(RPIO.input(in_port)), push_count)
</code>



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.

<code python>
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

</code>
===c printf ===

<code python>
import sys

def printf(format, *args):
    sys.stdout.write(format % args)	
</code>

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:
<code python>

import json

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

# wandeln
liste=json.loads(hosts)


type(liste)
<type 'dict'>

</code>




----

==== Umgebungsvariablen ====

<code python>
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])
  
</code>


----

==== Rechnen ====

=== Rechenoperationen===
Neben den normalen Rechenoperationen:

  * Ganzzahl-Division mit **<nowiki>//</nowiki>** =>  25 <nowiki>//</nowiki> 3 => 8 (immer die nächste kleinere Zahl!) =>  25 <nowiki>//</nowiki> -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**
<code python>

value=255

bin(value)
'0b11111111'

</code>

Binär angeben:
<code python>
value=0b11111111

value
255

</code>

==Rechnen - Mit einer Maske ein Bit ändern:==

11111111 AND 11111110 => 11111110

"Logische AND = &":
<code bash>

0b11111111 & 0b11111110
254

bin(254)
'0b11111110'
<code>

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

1 << 4

16

bin(16)
0b10000

16 >> 4
1

</code>


Bitweise setzen:
<code bash>
#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)

</code>
siehe auch https://wiki.python.org/moin/BitManipulation


----


==== Parameter Übergabe ====

===Allgemein===

<code python>
import sys

#Alle Übergabe werte stehen in sys.argv

#Programmname an Stelle 0

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


</code>


===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:
<code python>
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 <referenzvoltage> -r <runs> "
        sys.exit(2)
    for opt, arg in opts:
        if opt == '-h':
            print sys.argv[0] + " -v <referenzvoltage> -r <runs> "
            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:]);


</code>
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:
<code python>
#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 <test> 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()<other.flaeche()
    #== gleich
    def __eq__(self,other):
          return self.flaeche()==other.flaeche()

    #Rechenoperatoren 
    #- Operator
    def __sub__(self,other):
        return self.flaeche()-other.flaeche()
    #+
    def __add__(self,other):
        return self.flaeche()+other.flaeche()
    # *  __mul__
    # /  __truediv__
    # // __floordiv__
    # %  __mod__
    # ** __pow__

    #Eigene Methoden hinzufügen
    #Member der Klasse
    def flaeche(self):
        fl=self.laenge*self.breite
        return fl

#
#Eine Klasse vererben
class DachPfanne(Bauteil):
    gewichtsfaktor=0.2
    def __init__(self,artikelnummer,laenge,breite,gewichtsfaktor):
        Bauteil.__init__(self,artikelnummer,laenge,breite)


    def gewicht(self):
        return round(self.gewichtsfaktor * self.flaeche(),2);

    #Defaut Methoden überschreiben
    #String Metode
    def __str__(self):
        return Bauteil.__str__(self) + " Gewicht: "+str(self.gewicht())
    
###################################
#Object verwenden
###################################

t1=Bauteil()
t1.artikelnummer='A1999'
t1.laenge=10.0
t1.breite=5.0

#Alternativ
t2=Bauteil('A2000',20.5,30.2)

#t1 und t2  ausgeben
print(t1,"\n",t2)

#Objekt beschreiben
print(repr(t1))

#Eine Methode aus dem Objeckt aufrufen
print("t1 hat diese Fläche::",str(t1.flaeche()))
print("t2 hat diese Fläche::",str(t2.flaeche()))

#Objekte mit eigener Vergleichopertor vergleichen
if t2 > 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)

</code>


Von zwei Klassen die Eigenschaften vererben:
<code python>
#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

</code>


----

==== Datei Handling ====

===Sequentielles Schreiben===
Eine Datei zum Schreiben und eine andere Datei zum Lesen öffnen
<code python>
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()    

</code>

===Frei in der Datei lesen und schreiben===
<code python>
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()
</code>

=== Alle Dateien in einem Verzeichnis durchsuchen==

Alle Dateien in einem Verzeichnis durchsuchen und das Dateidatum anzeigen:
<code python>
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))
</code>

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

<code python>
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"))    

</code>

----
==== 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