Zeilenumbruch nur für Code

return = str( var_1) + “ banana“ + str( var_2 )    \
.                 “ apricots“

return =  var_1  * 2  +  0.1 * var_2    \
+ result_a – result_b

\ auf nächsten Zeile weiterzucoden,
.  wie wenn alles in einer Zeile stünde

for

list

list = ["a", "b" ]
for i in list:              # i sind Elemente
    print i                 # output: a
                            #         b
range(2) = [ 0, 1 ]         # ist nummerierte Liste
for i in range(2):
    print i                # output        0
                                   #               1
for i in range( len(list) ):
    print list[i]          # output: a 
                                   #         b

………………………………………………………………………….
dictionary
dict = {„a“=5,
.            „b“ = 8  }
for i in dict:                     // i sind keywords
.            print i                  // output   a
.                                          //                 b
print dict(„i“)                 // output  5
.                                         //                  8

 

Datentyp

list_1 = [ 2, 7,  9]
type( list_1 )             ->    < type ‚list‘>
type(  list_1[0])       ->     < type ‚int‘ >

list_2 = [„hoi“, „ciao“ ]
type(  list_2[0])       ->     < type ’str‘ >

dict = {  „wurst“ : 5,
“ brot“    :  2   }
type( dict)                ->       <type ‚dict‘ >
type( dict[„wurst“])  ->  < type ‚int‘ >

 

Bytes einlesen

Byte-Struktur
– Formatvariablen definieren definieren Datenstruktur
– Formatvariablen stehen in einem String
– für jede Formatvariable muss eine Variable mitgegeben werden
– folgen grosse Datenpakete als, muss deren Länge
.  bekannt sein und wird vor der Stringvariable eingefügt
– “ > “ bedeutet big endian,  “ < “ littel endian

command = pack(‚ >BH‘ + str(length) + ’s ‚, typ, command, length, data)

Python_Struct_BefehlsTabelle

Vor Daten Schlüsselwörter einfügen
data = pack(‚ >BBH’+str(length)+’s ‚, testnumber, time, command, length, data)

Schlüsselwörter vor Data extrahieren
testnumber = unpack(‚>B‘, data[0:1])
time = unpack(‚>B‘, data[1:2])

Daten ohne Schlüsselwörter
data[:4]                             die ersten 4 Bytes werden weggelassen

Big Endian / Littel Endian
big endian = normal      a = (‚>B‘, 3)            output           a = 00 03
little endian                      a = (‚<B‘, 3)            output           a = 03 00

Info
In Python werden Daten als String übergeben. Sollen diese eine bestimmte Byte-Struktur haben, helfen die Funktionen pack() and unpack().
import struct *

binär, hex, ascii

Info
In Python wird vieles per string weitergegeben. Um die Stringwerte zu verstehen,  hier ein kleiner Überblick:
–  „0x3“ entsprechen 3 Bytes (Ascii)
–  „\x3“ enrspricht einem Byte (Binärdatei)
– „\A3“ entspricht einem Byte (Binärdatei)

Binär einlesen
f = open( „../../edid.bin“ , „rb“ )
edid = f.read()                              ‚\xA1 \x10 \xFF 0\x32‘ == 4 Bytes

Wichtige Funktionen
Achtung !!                                
Wandeln Binärzahlen in ASCII !!
bin_zahl = bin(4)                       ‚0b100‘ == 5 Bytes
hex_zahl = hex(12)                  ‚0xc“ == 3 Bytes (Ascii)
edid = hex(3) + edid                „0x3 \xA1 \x10 “ == 3 + 2 = 5 Bytes

 

Listen

Syntax
list = [ „das“, 1, „wer“ ]

Indices
list[0]              =  „das“            positive Index: von links nach rechts
list[1]              =  1
list[-1]             =  „wer“          negative Index: von rechts nach links

Wert zur Liste
list.insert( index,  value)   an exater Stelle einfügen
list.append( value )             am Ende einfügen

Wert entfernen
list.remove(value)                 dieser Wert löschen
list.pop(index)                         Element bei diesem Index löschen
.                                                     Rückgabewert: Wert des gelöschten Elements
del( list[index] )                       Element bei diesem Index löschen

Wert hinzufügen
b = list[0]                                  Wert aus Liste zuweisen
list[2]  = „dieser“                    Neuer Wert einem Element zuweisen

Numerierte Liste  als Rückgabewert             
range(stop)                            range(4)        => [0, 1, 2, 3]
range(start, stop)                 range(2, 4)  =>  [2, 3 ]
range(start, stop, step)       range(1, 6, 2)   => [1, 3 ,5]

Pfadvariable

Info
Neue Module müssen der Pfadvarible zugefügt werden.

Suchbegriffe
set python path

Pfad hinzufügen
>> sys.path                    Gesetzte Pfade werden ausgegeben
sys.path.append(‚../../ pfad von Ort aus, in der Konsole gestartet wurde‘)

Hintergrund
Wenn man ein Modul z.B. abc importiert, sucht der Interpreter nach abc.py in der folgenden Reihenfolge
1. Im aktuellen Verzeichnis
2. PYTHONPATH                                                              >> sys.pat
3. Falls PYTHONPATH nicht gesetzt ist,
wird gesucht in                                                         /usr/lib/python2.7

dictionary

Syntax
dict = { „Schlüsselwort“ : Wert oder „string“ oder Liste}
!!  Die Reihenfolge der Elemente ist zufällig und ändert  !!

Wichtigste Funktionen
dict[„key“]            Gibt den Wert heraus
dict[„key“] = 5     Weist neuen Wert zu
dict[„neu“] = 6    Fügt neues Element ein
del dict[„key“]     Löscht das Element

dict.keys()            Gibt alle Schlüsselwörter heraus

liste = [ dict1, dict2]           // <typ ‚dict‘> wie Varibalen behandeln

For bei dictionary
prices = {   „banana“ : 4,
.                    „apple“     : 2    }
Auswerten des Wertes (integer)
for i in prices:
.                    print   prices[i]             // out:      4
.                                                              //               2
Auswerten des Keyworts (string)
for i in prices:
.                    print  i                             // out:     banana
.                                                              //               apple

Info
Ein assoziative Liste, die eine Kombination aus Namen und Werten ist. Sie ist immer ungeordnet, das heisst ihre Einträge haben keinen fixen Ort in der Liste. Die Werte werden nur über das Schlüsselwort (key) gefunden.

Suchbegriffe
dictionary,   key