Grundlegendes Python

Reading time: 8 minutes

Python Grundlagen

Nützliche Informationen

list(xrange()) == range() --> In Python 3 ist range das xrange von Python 2 (es ist keine Liste, sondern ein Generator)
Der Unterschied zwischen einem Tuple und einer Liste besteht darin, dass die Position eines Wertes in einem Tuple ihm Bedeutung verleiht, während Listen einfach geordnete Werte sind. Tuples haben Strukturen, aber Listen haben eine Reihenfolge.

Hauptoperationen

Um eine Zahl zu potenzieren, verwendest du: 3**2 (nicht 3^2)
Wenn du 2/3 machst, gibt es 1 zurück, weil du zwei ints (Ganzzahlen) dividierst. Wenn du Dezimalzahlen möchtest, solltest du Floats dividieren (2.0/3.0).
i >= j
i <= j
i == j
i != j
a und b
a oder b
nicht a
float(a)
int(a)
str(d)
ord("A") = 65
chr(65) = 'A'
hex(100) = '0x64'
hex(100)[2:] = '64'
isinstance(1, int) = True
"a b".split(" ") = ['a', 'b']
" ".join(['a', 'b']) = "a b"
"abcdef".startswith("ab") = True
"abcdef".contains("abc") = True
"abc\n".strip() = "abc"
"apbc".replace("p","") = "abc"
dir(str) = Liste aller verfügbaren Methoden
help(str) = Definition der Klasse str
"a".upper() = "A"
"A".lower() = "a"
"abc".capitalize() = "Abc"
sum([1,2,3]) = 6
sorted([1,43,5,3,21,4])

Zeichen verbinden
3 * ’a’ = ‘aaa’
‘a’ + ‘b’ = ‘ab’
‘a’ + str(3) = ‘a3’
[1,2,3]+[4,5]=[1,2,3,4,5]

Teile einer Liste
‘abc’[0] = ‘a’
'abc’[-1] = ‘c’
'abc’[1:3] = ‘bc’ von [1] bis [2]
"qwertyuiop"[:-1] = 'qwertyuio'

Kommentare
# Einzeiliger Kommentar
"""
Mehrzeiliger Kommentar
Ein weiterer
"""

Schleifen

if a:
#somethig
elif b:
#something
else:
#something

while(a):
#comething

for i in range(0,100):
#something from 0 to 99

for letter in "hola":
#something with a letter in "hola"

Tuples

t1 = (1,'2,'three')
t2 = (5,6)
t3 = t1 + t2 = (1, '2', 'three', 5, 6)
(4,) = Singleton
d = () leeres Tuple
d += (4,) --> Hinzufügen zu einem Tuple
KANN NICHT! --> t1[1] == 'Neuer Wert'
list(t2) = [5,6] --> Von Tuple zu Liste

Liste (Array)

d = [] leer
a = [1,2,3]
b = [4,5]
a + b = [1,2,3,4,5]
b.append(6) = [4,5,6]
tuple(a) = (1,2,3) --> Von Liste zu Tuple

Wörterbuch

d = {} leer
monthNumbers={1:’Jan’, 2: ‘feb’,’feb’:2}—> monthNumbers ->{1:’Jan’, 2: ‘feb’,’feb’:2}
monthNumbers[1] = ‘Jan’
monthNumbers[‘feb’] = 2
list(monthNumbers) = [1,2,’feb’]
monthNumbers.values() = [‘Jan’,’feb’,2]
keys = [k for k in monthNumbers]
a={'9':9}
monthNumbers.update(a) = {'9':9, 1:’Jan’, 2: ‘feb’,’feb’:2}
mN = monthNumbers.copy() #Unabhängige Kopie
monthNumbers.get('key',0) #Überprüfen, ob der Schlüssel existiert, Rückgabewert von monthNumbers["key"] oder 0, wenn er nicht existiert

Menge

In Mengen gibt es keine Wiederholungen
myset = set(['a', 'b']) = {'a', 'b'}
myset.add('c') = {'a', 'b', 'c'}
myset.add('a') = {'a', 'b', 'c'} #Keine Wiederholungen
myset.update([1,2,3]) = set(['a', 1, 2, 'b', 'c', 3])
myset.discard(10) #Wenn vorhanden, entfernen, wenn nicht, nichts
myset.remove(10) #Wenn vorhanden, entfernen, wenn nicht, Ausnahme auslösen
myset2 = set([1, 2, 3, 4])
myset.union(myset2) #Werte in myset ODER myset2
myset.intersection(myset2) #Werte in myset UND myset2
myset.difference(myset2) #Werte in myset, aber nicht in myset2
myset.symmetric_difference(myset2) #Werte, die nicht in myset UND myset2 sind (nicht in beiden)
myset.pop() #Erhalte das erste Element der Menge und entferne es
myset.intersection_update(myset2) #myset = Elemente in sowohl myset als auch myset2
myset.difference_update(myset2) #myset = Elemente in myset, aber nicht in myset2
myset.symmetric_difference_update(myset2) #myset = Elemente, die nicht in beiden sind

Klassen

Die Methode in __It__ wird von sort verwendet, um zu vergleichen, ob ein Objekt dieser Klasse größer ist als ein anderes

class Person(name):
def __init__(self,name):
self.name= name
self.lastName = name.split(‘ ‘)[-1]
self.birthday = None
def __It__(self, other):
if self.lastName == other.lastName:
return self.name < other.name
return self.lastName < other.lastName #Return True if the lastname is smaller

def setBirthday(self, month, day. year):
self.birthday = date tame.date(year,month,day)
def getAge(self):
return (date time.date.today() - self.birthday).days


class MITPerson(Person):
nextIdNum = 0	# Attribute of the Class
def __init__(self, name):
Person.__init__(self,name)
self.idNum = MITPerson.nextIdNum  —> Accedemos al atributo de la clase
MITPerson.nextIdNum += 1 #Attribute of the class +1

def __it__(self, other):
return self.idNum < other.idNum

map, zip, filter, lambda, sorted und Einzeiler

Map ist wie: [f(x) für x in iterable] --> map(tutple,[a,b]) = [(1,2,3),(4,5)]
m = map(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) --> [False, False, True, False, False, True, False, False, True]

zip stoppt, wenn das kürzere von foo oder bar stoppt:

for f, b in zip(foo, bar):
print(f, b)

Lambda wird verwendet, um eine Funktion zu definieren
(lambda x,y: x+y)(5,3) = 8 --> Verwende lambda als einfache Funktion
sorted(range(-5,6), key=lambda x: x** 2) = [0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5] --> Verwende lambda, um eine Liste zu sortieren
m = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) = [3, 6, 9] --> Verwende lambda, um zu filtern
reduce (lambda x,y: x*y, [1,2,3,4]) = 24

def make_adder(n):
return lambda x: x+n
plus3 = make_adder(3)
plus3(4) = 7 # 3 + 4 = 7

class Car:
crash = lambda self: print('Boom!')
my_car = Car(); my_car.crash() = 'Boom!'

mult1 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x%3 == 0 ]

Ausnahmen

def divide(x,y):
try:
result = x/y
except ZeroDivisionError, e:
print “division by zero!” + str(e)
except TypeError:
divide(int(x),int(y))
else:
print “result i”, result
finally
print “executing finally clause in any case”

Assert()

Wenn die Bedingung falsch ist, wird der String auf dem Bildschirm ausgegeben.

def avg(grades, weights):
assert not len(grades) == 0, 'no grades data'
assert len(grades) == 'wrong number grades'

Generatoren, yield

Ein Generator gibt anstelle von etwas zurück, dass er etwas "yielded". Wenn Sie darauf zugreifen, gibt er den ersten generierten Wert "zurück", dann können Sie erneut darauf zugreifen und er gibt den nächsten generierten Wert zurück. So werden nicht alle Werte gleichzeitig generiert und es kann viel Speicher gespart werden, wenn man dies anstelle einer Liste mit allen Werten verwendet.

def myGen(n):
yield n
yield n + 1

g = myGen(6) --> 6
next(g) --> 7
next(g) --> Fehler

Reguläre Ausdrücke

import re
re.search("\w","hola").group() = "h"
re.findall("\w","hola") = ['h', 'o', 'l', 'a']
re.findall("\w+(la)","hola caracola") = ['la', 'la']

Spezielle Bedeutungen:
. --> Alles
\w --> [a-zA-Z0-9_]
\d --> Zahl
\s --> Leerzeichen-Zeichen[ \n\r\t\f]
\S --> Nicht-Leerzeichen-Zeichen
^ --> Beginnt mit
$ --> Endet mit
+ --> Eins oder mehr
* --> 0 oder mehr
? --> 0 oder 1 Vorkommen

Optionen:
re.search(pat,str,re.IGNORECASE)
IGNORECASE
DOTALL --> Erlaubt, dass Punkt Zeilenumbrüche übereinstimmt
MULTILINE --> Erlaubt, dass ^ und $ in verschiedenen Zeilen übereinstimmen

re.findall("<.*>", "<b>foo</b>and<i>so on</i>") = ['<b>foo</b>and<i>so on</i>']
re.findall("<.*?>", "<b>foo</b>and<i>so on</i>") = ['<b>', '</b>', '<i>', '</i>']

IterTools
product
from itertools import product --> Generiert Kombinationen zwischen 1 oder mehr Listen, möglicherweise wiederholte Werte, kartesisches Produkt (distributive Eigenschaft)
print list(product([1,2,3],[3,4])) = [(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]
print list(product([1,2,3],repeat = 2)) = [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]

permutations
from itertools import permutations --> Generiert Kombinationen aller Zeichen in jeder Position
print list(permutations(['1','2','3'])) = [('1', '2', '3'), ('1', '3', '2'), ('2', '1', '3'),... Jede mögliche Kombination
print(list(permutations('123',2))) = [('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')] Jede mögliche Kombination der Länge 2

combinations
from itertools import combinations --> Generiert alle möglichen Kombinationen ohne wiederholte Zeichen (wenn "ab" existiert, wird "ba" nicht generiert)
print(list(combinations('123',2))) --> [('1', '2'), ('1', '3'), ('2', '3')]

combinations_with_replacement
from itertools import combinations_with_replacement --> Generiert alle möglichen Kombinationen ab dem Zeichen (zum Beispiel, die 3. wird ab der 3. gemischt, aber nicht mit der 2. oder 1.)
print(list(combinations_with_replacement('1133',2))) = [('1', '1'), ('1', '1'), ('1', '3'), ('1', '3'), ('1', '1'), ('1', '3'), ('1', '3'), ('3', '3'), ('3', '3'), ('3', '3')]

Dekoratoren

Dekorator, der die Zeit misst, die eine Funktion benötigt, um ausgeführt zu werden (von hier):

from functools import wraps
import time
def timeme(func):
@wraps(func)
def wrapper(*args, **kwargs):
print("Let's call our decorated function")
start = time.time()
result = func(*args, **kwargs)
print('Execution time: {} seconds'.format(time.time() - start))
return result
return wrapper

@timeme
def decorated_func():
print("Decorated func!")

Wenn Sie es ausführen, sehen Sie etwas wie das Folgende:

Let's call our decorated function
Decorated func!
Execution time: 4.792213439941406e-05 seconds