Benutzer-Werkzeuge

Webseiten-Werkzeuge


python:python_first_steps

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

Alternativ

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

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:

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:

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 <test> else value_false**

Beispiel:

#value_true if <test> 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ß!
#<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)

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 <Variable> in <Sequence>) (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

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:

Beispiele:


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

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)
<type 'dict'>

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'
<code>
 
Bits verschieben mit ">>" recht und "<<" links
<code python>
 
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 ⇒ 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 <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:]);

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

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

Quellen

Video Tutorial für den allerersten Einstieg:

Cookies helfen bei der Bereitstellung von Inhalten. Durch die Nutzung dieser Seiten erklären Sie sich damit einverstanden, dass Cookies auf Ihrem Rechner gespeichert werden. Weitere Information
"Autor: Gunther Pipperr"
python/python_first_steps.txt · Zuletzt geändert: 2016/02/28 16:20 von Gunther Pippèrr