guide.txt

🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍PYTHON BASIC GUIDE 2023-2024 Unbeatabledev 🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍

1.intendations
same number of intendations in one block of code
z.B.
if
  print
  print

2.Variablen

Variable = Wert
Typen:
int = ganze Zahlen
float= Zahl mit Komma
string= Text z.B. x = "John"

Variablen können den Typ verändern


Regeln:


    A variable name must start with a LETTER or the underscore character
    A variable name CANNOT start with a NUMBER
    A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )
    Variable names are CASE-SENSITIVE (age, Age and AGE are three different variables)
    A variable name cannot be any of the Python keywords.

make variables readable snake case: variable_mein_name
Informationen Variable:
1 variable: mehrere Werte z.B. x = y = z = "Orange"

collections entpacken
 fruits = ["apple", "banana", "cherry"]
x, y, z = fruits

variables with functions
function(x,y)

Local:
Unabhängig zu globalen variablen, nur für eine funktion
GLOBAL:

global um etw. global zu definieren
auch global wenn man etw. globales in einer funktion ändert

Daten Sammlungsarten:


   LIST is a collection which is ordered and changeable. Allows duplicate members.
   TUPLE is a collection which is ordered and unchangeable. Allows duplicate members.
   SET is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.
   DICTIONARY is a collection which is ordered** and changeable. No duplicate members.

3. Comments
#Dies ist unnütz für  den Code

4. Quotes
"='

5. Tuple 
 fruits = ["apple", "banana", "cherry"]

6. Datentypen

Example 	Data Type 	
x = "Hello World" 	                str 	
x = 20 	                                int 	
x = 20.5 	                        float 	
x = 1j 	                                complex 	
x = ["apple", "banana", "cherry"] 	list 	
x = ("apple", "banana", "cherry") 	tuple 	
x = range(6) 	                        range 	
x = {"name" : "John", "age" : 36} 	dict 	
x = {"apple", "banana", "cherry"} 	set 	
x = frozenset({"apple", "banana", "cherry"}) 	frozenset 	
x = True 	                                bool 	
x = b"Hello" 	                                bytes 	
x = bytearray(5) 	                        bytearray 	
x = memoryview(bytes(5)) 	                memoryview 	
x = None 	                                NoneType 	

Int (Integer) : Int, or integer, is a WHOLE NUMBER, positive or negative, without decimals, of unlimited length.

Float, or "floating point number" is a NUMBER, positive or negative, containing one or more DECIMALS.

Complex numbers (COMPLEX NUMBER) are written with a "j" as the imaginary part

random numbers: print(random.randrange(1, 10)) 

Man kann auch converten (eher unnütz)

#convert from int to float:
a = float(x)

#convert from float to int:
b = int(y)

#convert from int to complex:
c = complex(x)

7. Casting

Type ---> Variable

int() - constructs an integer number from an integer literal, a float literal (by removing all decimals), or a string literal (providing the string represents a whole number)float() -         constructs a float number from an integer literal, a float literal or a string literal (providing the string represents a float or an integer)
str() -          constructs a string from a wide variety of data types, including strings, integer literals and float literals

8. strings

" + '

z.B. a = "Hello"

Informationen:
string = Anordnung
Jeder Text der Variable hat eine Position

Man kann string mit vielen Funktionen z.B. if, if present, if not present verwenden.

Strings slicen: Die Anordnung teilen: unnütz

Python hat viele Funktionen um die strings zu modifizieren

+ to combine strings

Man kann strings nicht mit Zahlen kombinieren
ABER format()  mit {} um andere Variablen einzufügen

Escape character: \
z.B. für double quotes

\' 	Single Quote 	
\\ 	Backslash 	
\n 	New Line 	
\r 	Carriage Return 	
\t 	Tab 	
\b 	Backspace 	
\f 	Form Feed 	
\ooo 	Octal value 	
\xhh 	Hex value

Es gibt viele Methoden, um Strings auszuwerten.

9. Booleans = return value true or false

Man kann Funktionen mit Booleans verknüpfen, z.B. um zu gucken, ob eine Funktion funktioniert

Es gibt mehrere Funktionen, mit denen man Booleans verwenden kann

isinstance() data type

ein boolean value ausgeben

def myFunction() :
  return True
print(myFunction())
 
bool()
x = "Hello"
y = 15

print(bool(x))
print(bool(y))
Fast alle Variablen mit Inhalt sind true

10. Operators = Operatoren für Variablen

Mathe (UNWICHTIG)
+ 	Addition 	x + y 	
- 	Subtraction 	x - y 	
* 	Multiplication 	x * y 	
/ 	Division 	x / y 	
% 	Modulus 	x % y 	
** 	Exponentiation 	x ** y 	
// 	Floor division 	x // y


Variablen (WICHTIG)
= 	x = 5 	x = 5 	
+= 	x += 3 	x = x + 3 	
-= 	x -= 3 	x = x - 3 	
*= 	x *= 3 	x = x * 3 	
/= 	x /= 3 	x = x / 3 	
%= 	x %= 3 	x = x % 3 	
//= 	x //= 3 	x = x // 3 	
**= 	x **= 3 	x = x ** 3 	
&= 	x &= 3 	x = x & 3 	
|= 	x |= 3 	x = x | 3 	
^= 	x ^= 3 	x = x ^ 3 	
>>= 	x >>= 3 	x = x >> 3 	
<<= 	x <<= 3 	x = x << 3

Vergleichen (WICHTIG)
== 	Equal 	x == y 	
!= 	Not equal 	x != y 	
> 	Greater than 	x > y 	
< 	Less than 	x < y 	
>= 	Greater than or equal to 	x >= y 	
<= 	Less than or equal to 	x <= y

Logik (WICHTIG)
and  	Returns True if both statements are true 	x < 5 and  x < 10 	
or 	Returns True if one of the statements is true 	x < 5 or x < 4 	
not 	Reverse the result, returns False if the result is true 	not(x < 5 and x < 10)

Identität + Mitgliedschaft (WICHTIG)

is  	Returns True if both variables are the same object 	x is y 	
is not 	Returns True if both variables are not the same object 	x is not y

in  	Returns True if a sequence with the specified value is present in the object 	x in y 	
not in 	Returns True if a sequence with the specified value is not present in the object 	x not in y

Es gibt eine Relevanz, welche Operatoren den größten Effekt haben
(groß)
() 	Parentheses 	
** 	Exponentiation 	
+x  -x  ~x 	Unary plus, unary minus, and bitwise NOT 	
*  /  //  % 	Multiplication, division, floor division, and modulus 	
+  - 	Addition and subtraction 	
<<  >> 	Bitwise left and right shifts 	
& 	Bitwise AND 	
^ 	Bitwise XOR 	
| 	Bitwise OR 	
==  !=  >  >=  <  <=  is  is not  in  not in  	Comparisons, identity, and membership operators 	
not 	Logical NOT 	
and 	AND 	
or 	OR
(klein)


11. Lists = Datentyp, um Infos in Variablen zu speichern

1. ordered, changeable, and allow duplicate values.
2. Listen haben immer eine spezifische Ordnung
3. Eine Liste kann viele Datentypen beinhalten

Man kann den Index einer Liste filtern, um die Ordnung einer Liste anders aufzurufen
Man kann die Funktion in verwenden, um zu prüfen, ob ein Gegenstand vorhanden ist

Es ist außerdem möglich, Gegenstände einer Liste im NACHHINEIN zu verändern (z.B. mit insert)

append() etwas zu einer Liste im Nachhinein hinzufügen
extend() zwischen mehreren Listen Gegenstände tauschen/hinzufügen
del() um eine Liste zu löschen
clear() leert eine Liste
remove() Gegenstände einer Liste löschen
for loop: durch eine Liste loopen (range um dies genauer zu definieren) / geht auch kurz, indem man List Comprehension anwendet
while loop: mit length (len()) kann man bei gleichbleibender Länge durchloopen

List Comprehension:
 newlist = [expression for item in iterable if condition == True] 

Man kann auch eine Condition hinzufügen, z.B. mit  if x = apple
iterable: Listen filtern mit Zahlen
Expression: Ergebnis der Iteration, welches sich manipulieren lässt.

Mit sort() und reverse() kann man eine Liste verändern

copy() um eine Liste zu kopieren
list() um den Vergleich möglich zu machen z.B. Liste2 = list(Liste1)

+ um Listen zu kombinieren
append() um Gegenstände Listen hinzuzufügen
extend() um Elemente einer Liste in die nächste zu kopieren

Methodenübersicht

append()	Adds an element at the end of the list
clear()	         Removes all the elements from the list
copy()	         Returns a copy of the list
count()	        Returns the number of elements with the specified value
extend()	Add the elements of a list (or any iterable), to the end of the current list
index()	         Returns the index of the first element with the specified value
insert()	Adds an element at the specified position
pop()	        Removes the element at the specified position
remove()	Removes the item with the specified value
reverse()	Reverses the order of the list
sort()	        Sorts the list

12. Tuplets = Mehrere Daten in einver Variable
ordered, unchangeable, and allow duplicate values.

man kann len() verwenden, um die Anzahl der Gegenstände einer Tuplet herauszufinden

Eine Tuple kann jeden Datentyp beinhalten
Mit tuple(()) kann man tuples erstellen

Um nach den Gegenständen einer Tuple zu filtern, kann man indexen. Merke 0=1 und dann geht es pro Item weiter

Um die Existenz eines Gegenstands zu erkennen, kann man in verwenden

Man kann eine Tuple nicht verändern, deshalb muss man sie zu einer Liste und zurück konvertieren.
Allerdings kann man sie mit + mit anderen Tuples addieren

packing = tuple = ("1", "2")
unpacking = 
fruits = ("1", "2")
(blau, rot) = fruits

Bei dem unpacken mit * kann man mehrer Dinge entpacken

Mit einer for Loop und len() und range() kann man durch eine Tuple loopen
Mit einer while Loop und len() geht das selbe

Mit + oder * kann man mit mehreren Tuples arbeiten, z.B. um sie mit + zu kombinieren

Eingebaute Methoden

count()	Returns the number of times a specified value occurs in a tuple
index()	Searches the tuple for a specified value and returns the position of where it was found

13. Set (Datenspeicher) {}

Bedingungen:

unordered, unchangeable*, unindexed, duplicates not allowed

True = 1
False = 0


Methoden

add()	               Adds an element to the set
clear()  	       Removes all the elements from the set
copy()	                Returns a copy of the set
difference()	        Returns a set containing the difference between two or more sets
difference_update()	Removes the items in this set that are also included in another, specified set
discard()	        Remove the specified item
intersection()	        Returns a set, that is the intersection of two other sets
intersection_update()	Removes the items in this set that are not present in other, specified set(s)
isdisjoint()      	Returns whether two sets have a intersection or not
issubset()	        Returns whether another set contains this set or not
issuperset()	        Returns whether this set contains another set or not
pop()           	Removes an element from the set
remove()	        Removes the specified element
symmetric_difference()    	Returns a set with the symmetric differences of two sets
symmetric_difference_update()	inserts the symmetric differences from this set and another
union()          	Return a set containing the union of sets
update()	        Update the set with the union of this set and others


len() = length
set() = ein Set machen
add() = Etwas einem Set hinzufügen
update() = z.B.  set2.update(Set1) Zum updaten eines Sets kann man aber auch andere Datensammlungen verwenden
for loop um durch ein Set durchzuloopen
Oder in benutzen, um das Set zu prüfen

Löschen:
 thisset.remove("banana")
 thisset.discard("banana")

clear() leert ein Set
del löscht sie ganz

union() = eine Union aus zwei Sets machen
intersection() = Aus zwei Listen die gleichen Daten zu einer neuen Liste hinzufügen

14. Dictionaries = ordered*, changeable and do not allow duplicates.

dict =	{
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

Achte auf die goofy Klammern!

Methoden:

clear() 	Removes all the elements from the dictionary
copy()  	Returns a copy of the dictionary
fromkeys()	Returns a dictionary with the specified keys and value
get()	        Returns the value of the specified key
items() 	Returns a list containing a tuple for each key value pair
keys()	        Returns a list containing the dictionary's keys
pop()	        Removes the element with the specified key
popitem()	Removes the last inserted key-value pair
setdefault()	Returns the value of the specified key. If the key does not exist: insert the key, with the specified value
update()	Updates the dictionary with the specified key-value pairs
values()	Returns a list of all the values in the dictionary

Information:
Dictionaries sind veränderbar
Doppelte Daten sind verboten
Alle Datentypen können in einem Dictionary gespeichert werden

dict() um ein dictionary zu erstellen
x = thisdict["model"] um Daten eines Dictionaries zu verwenden
thisdict.get tut das selbe
keys() zeigt die Änderungen an einem Dictionary
values(), um die Values der Werte zu erfahren
items(), um alle Daten anzuzeigen
in(), um zu gucken, ob Daten im Dictionary vorhanden sind
thisdict.update({"year": 2020}) ,  um eines der Daten upzudaten
Z.B. thisdict["color"] = "red" , um einen Wert hinzuzufügen
thisdict.pop() , um einen Gegenstand des Dictionaries zu löschen
del thisdict["model"] , um ein spezifisches Item zu löschen
clear() leert das Dictionary
for loop, um durch alle Gegenstände einzeln zu loopen
values() um alle Werte der Gegenstände herauszufinden
keys() Um die ersten Teile eines Gegenstandes aufzurufen
items() In Kombination mit for loop wird es benutzt, um alle Werte und 1. Teile aufzurufen
copy() z.B. mydict = thisdict.copy() um ein Dictionary zu kopieren
Oder dict() z.B. mydict = dict(thisdict) um ein Dictionary mit den gleichen Werten zu erschaffen

Nested Dictionary:
Dictionary mit mehreren Dictionaries
z.B.
myfamily = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
} 
 print(myfamily["child2"]["name"]) 

15. If...else

Conditions: 

    Equals: a == b
    Not Equals: a != b
    Less than: a < b
    Less than or equal to: a <= b
    Greater than: a > b
    Greater than or equal to: a >= b

Diese Condition mit if verwenden, um etwas zu überprüfen
Denk an die Indentation!

elif = "if the previous conditions were not true, then try this condition"
else = Alles was nicht bei den vorhergehenden conditions beachtet wird

if und if...else können für ein kurzes Statement auch in einer Linie verwendet werden

and kann man mit if verbinden, um mehrere Dinge abzufragen
or um mehrere Conditions zu verbinden
not um ein umgekehrtes Ergbenis der Condition zu erlangen
Info: Man kann mehrere if statements ineinander haben

16. while loop
Loopt während eine condition true ist, z.B.:

i = 1
while i < 6:
  print(i)
  i += 1

Eine Variabe wird benötigt!

break stoppt die loop auch wenn die Condition true ist
continue kann die loop einen Teil der Werte überspringen lassen
else kann code ausführen, wenn die Condition nicht mehr true ist

Sehr nützlich um unendlich code laufen zu lassen, z.B. Generatoren

17. for loop
loopt nur durch eine Sequenz (List, tuple, dictionay, set and string)

break Loop stoppen, bevor sie durch alle Werte geloopt hat
continue einen Gegenstand in der loop überspringen
range() um mehrere Male durch code zu loopen
else code wird ausgeführt, wenn die loop zuende ist
Es können auch nested loops mit einer loop in einer loop erstellt werden

Z.B.:
adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]

for x in adj:
  for y in fruits:
    print(x, y) 

18. Functions block of code that runs when it is called

Eine Function definen:
def my_function():
	Inhalt
Um sie zu callen:
 my_function() 

Man kann eine Funktion mit mehreren Argumenten (auch args) informieren

Um Functions richtig zu callen, muss man, die genaue Anzahl an Argumenten verwenden

Wenn man nicht weiß, wie viele Argumente die Funktion braucht, kann man einen Stern verwenden*

Man kann auch direkt Argumente an die Funktion senden. Das geht z.B. so:
 my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus") 

Auch hier kann man mit zwei Sternen ( def my_function(**kid): ) die Anzahl der Argumente offen lassen

Wenn man die Argumente beim callen einer Funktion offen lässt, erhält man nur das default argument, z.B.:

def my_function(country = "Norway"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()         ----> Norway
my_function("Brazil")

Man kann alle Datenspeicher an eine Funktion senden, sie werden nicht verändert

Mit return kann die Funktion ein value ausgeben

kwargs= Argumente, die im Nachhinein eingefügt werden z.B. parameter = x, kind = Lasse , besser da die Ordnung fer Funktion egal ist
positional args = man ruft nur ein bestimmtes Argument der Funktion auf, z.B. Value1, kind1
Die beiden Typen kann man auch kombinieren

Mit recursion kann eine Funktion sich selbst callen, dies kann aber zu einer Computerzerstörung führen

19. Lambda eine kleine anonyme Funktion

Syntax:  lambda arguments : expression 

Expression: Das was gemacht werden soll: z.B. a + 10
argument: Wäre dann a

Man arbeitet mit den Operatoren und kann jede Nummer an Argumenten verwenden
Lambda Funktionen haben den Vorteil, auch in einer "großen" Funktion laufen zu können

Z.B.:
def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))

Kurzfristig kann Lambda also eine sehr gute Hilfe sein

20. Arrays Mehrere Werte in einer Variable

Arrays gibt es ursprünglich nicht in Python deshalb muss man z.B. NumPy importieren

Wdhl.: Methoden

append()	Adds an element at the end of the list
clear()		Removes all the elements from the list
copy()		Returns a copy of the list
count()		Returns the number of elements with the specified value
extend()	Add the elements of a list (or any iterable), to the end of the current list
index()		Returns the index of the first element with the specified value
insert()	Adds an element at the specified position
pop()		Removes the element at the specified position
remove()	Removes the first item with the specified value
reverse()	Reverses the order of the list
sort()		Sorts the list

Um auf eine Element eines Arrays zu referieren, braucht man den Index, z.B.:

 x = cars[0] 

Um die Nummer der Elemente in einem Array herauszufinden, sollte man len() verwenden, z.B.:

 x = len(cars) 

Mit for in kann man durch die Elemente eines Arrays loopen

Um später einem Array etw. hinzuzufügen kann man append() benutzen (z.B. cars.append(auto1))

Mit pop() kann man ein Element löschen, z.B.:  cars.pop(1) 

Mit remove() geht das selbe ( cars.remove("Volvo") ) 
Einziger Unterschied ist der Index bei pop und der direkte Ruf bei remove

Da Arrays nicht per "Default" vorhanden sind, kann man auch einfach eine Liste aus Python benutzen.

21. Classes/Objects Fast alles in Python ist ein object

Eine Class kann man erstellen, z.B.:

class MyClass:
  x = 5
Um ein object zu erstellen:

p1 = MyClass()
print(p1.x) 

__init__() wird automatisch von Python verwendet, wenn man ein object erstellt

Man kann es aber auch verwenden, um selber ein Value zu einem Object zu geben. Z.B.:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

p1 = Person("John", 36)

print(p1.name)
print(p1.age) 

__str__() kontrolliert die string Representation des Ergebnisses
Wird diese nicht eingefügt, erhärt man also nur ein abstraktes Ergebnis. So sieht es richtig aus:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def __str__(self):
    return f"{self.name}({self.age})"

p1 = Person("John", 36)

print(p1) 

Man kann auch Funktionen direkt zu einem Objekt hinzufügen.
Tut man dies noch mit self zusammen, kann man auf Variablen in einer class zugreifen. Dies sieht so aus:

class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("John", 36)
p1.myfunc() 

self ist dabei nur ein Platzhalter, man kann es durch jeden beliebigen Buchstaben austauschen. Wie z.B. Malte mit e

Mit Eigenschaften von Objekten zu verändern gibt es folgende Möglichkeiten:

p1.age = 40

(Festlegen des Alters einer Person)

 del p1.age 
(Die Alterseigenschaft löschen)

 del p1 
(Oder auch einfach das ganze Objekt löschen)

22. Inheritance = (Erbe)

ALLE METHODEN UND EIGENSCHAFTEN EINER KLASSE WERDEN AN DIE NÄCHSTE WEITERGEGEBEN

Parent class = Vererber
Child class = Erbe

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

#Use the Person class to create an object, and then execute the printname method:

x = Person("John", "Doe")
x.printname() 

Jetzt hat man eine Parent class

x = Student("Mike", "Olsen")
x.printname() 

Mit dem Hinzufügen der Child class, kann man jetzt den namen des Student printen

Nun __init__() (initialise) benutzen, um der Chil class mehr hinzuzufügen

Allerdings muss man noch einmal __init__() benutzen, um die Parent Class nicht durch das neue __init__() zu löschen

class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname) 

Mit super() kann man automatisch die Eigenschaften der Parent Class nehmen

Um eine neue Eigenschaft hinzuzufügen, muss man diese Eigenschaft bei dem initialisen verwenden, z.B.:

def __init__(self, fname, lname, year): (es wird year hinzugefügt)

Auch eine neue Methode kann man der Child Class hinzufügen, z.B.:

  def welcome(self):
    print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)

Wenn man den gleichen Namen benutzt, wird eine Funktion in der Parent class, dann wird die Inheritance überschrieben

23. Iterators Ein Iterator ist ein Objekt, welches eine zählbare Nummer an Variablen beinhaltet

Ursprünglich sind die Methoden __iter__() und __next__() vorhanden, um mit Iterators zu arbeiten

iterable containers sind z.B. Lists oder Tuples, die Iterators beinhalten

Auch Strings sind iterable

Mit einer for loop kann man durch iterators loopen. Es wird automatisch die Methode __next__() ausgeführt und ist somit eleganter

Methoden erklärt:

The __iter__() method acts similar, you can do operations (initializing etc.), but must always return the iterator object itself.

The __next__() method also allows you to do operations, and must return the next item in the sequence.

Mit so einem Iterator kann man z.B. durch unendlich Zahlen loopen, darum wurde hier ein Maximum von 20 eingebaut

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

24. Polymorphism = Übersetzt in viele Formen

methods/functions/operators mit dem selben Namen, die auf Objekte ausgeführt werden können

Z.B. kann len() bei Tuples, Strings und Dictionaries die Nummer der Objekte oder die Länge eines Wortes bei Strings angeben

Man kann außerdem die gleiche Methode für mehrere Classes nehmen. Z.B.:

class Car:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Drive!")

class Boat:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Sail!")

class Plane:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Fly!")

car1 = Car("Ford", "Mustang")       #Create a Car class
boat1 = Boat("Ibiza", "Touring 20") #Create a Boat class
plane1 = Plane("Boeing", "747")     #Create a Plane class

for x in (car1, boat1, plane1):
  x.move()

Auch bei child classes kann man einen Polymorphismus verwenden

class Vehicle:
  def __init__(self, brand, model):
    self.brand = brand
    self.model = model

  def move(self):
    print("Move!")

class Car(Vehicle):
  pass

class Boat(Vehicle):
  def move(self):
    print("Sail!")

class Plane(Vehicle):
  def move(self):
    print("Fly!")

car1 = Car("Ford", "Mustang") #Create a Car object
boat1 = Boat("Ibiza", "Touring 20") #Create a Boat object
plane1 = Plane("Boeing", "747") #Create a Plane object

for x in (car1, boat1, plane1):
  print(x.brand)
  print(x.model)
  x.move()

Hier wird move() öfters benutzt und man kann die Basiseigenschaften des Vehicles mit den neuen überschreiben
Mit Polymorphismus kann man die gleiche Methode für jede class ausführen (Es ist ein Grundkonzept)

25. Scope = lokale Region der Variable (Fachbegriff) (global + local)

Wenn eine Variable in einer Funktion erstellt wird, dann gehört sie zum lokalen Scope(!)

Z.B.:

def myfunc():
  x = 300
  print(x)

myfunc() 

Auch bei einer Funktion in der Funktion ist es möglich, die Variable aufzurufen

def myfunc():
  x = 300
  def myinnerfunc():
    print(x)
  myinnerfunc()

myfunc() 

Allerdings ist es unmöglich eine Variable außerhalb der Funktion aufzurufen (global)

Es sei denn man erstellt die Variable z.B. mit x = 1 vor der Funktion, dann kann sie global verwendet werden

Wenn man die gleiche Variable in und außerhalb der Funktion braucht, denkt Python es wären zwei separate Variablen


DESHALB benutzt man global vor einer Variable, um diese im lokalen und globalen scope zu benutzen. Z.B.:

def myfunc():
  global x
  x = 300

myfunc()

print(x) 

Wenn man die Variable in der Funktion ändern will, dann kann man dies auch mit global tun, da man dann auf das globale scope zugreift

x = 200

def myfunc():
  global x
  x = 300

myfunc()

print(x) 

x ist jetzt 300

26. Modules = eine code library in dem Programm

Mit import module vor dem Programm welches den code benutzt, können wir das Module ausführen

Man kann sie aber auch selber machen, indem man sie erst abspeichert:

person1 = {
  "name": "John",
  "age": 36,
  "country": "Norway"
} 

Und dann aufruft

import mymodule

a = mymodule.person1["age"]
print(a) 

(Beispiel)

Der Name des Module ist egal, aber es braucht die .py Endung

Es gibt viele eingebaute Module in Python, die man benutzen kann, wann man will

Wenn man das Modul umnennen will, muss man 
import module as module2 
schreiben
Z.B. wenn man verschiedene Funktionen eines Modules benutzt

Mit dir() kann man alle Funktionen und Variablen eines Modules auflisten

Wenn man nur einen bestimmten Teil eines Modules benutzen möchte, kann man 

from module import tollesache

27. Dates = Mit dem module datetime, kann man mit der Zeit arbeiten

Also
import datetime

Es gibt viele Methoden, um sich spezifische Dinge anzeigen zu lassen

%a 	Weekday, short version 			Wed 	
%A 	Weekday, full version 			Wednesday 	
%w 	Weekday as a number 0-6, 0 		is Sunday 	3 	
%d 	Day of month 01-31 			31 	
%b 	Month name, short version 		Dec 	
%B 	Month name, full version 		December 	
%m 	Month as a number 01-12 		12 	
%y 	Year, short version, without century 	18 	
%Y 	Year, full version 			2018 	
%H 	Hour 00-23 				17 	
%I 	Hour 00-12 				05 	
%p 	AM/PM 	PM 	
%M 	Minute 00-59 				41 	
%S 	Second 00-59 				08 	
%f 	Microsecond 000000-999999 		548513 	
%z 	UTC offset 				+0100 	
%Z 	Timezone 				CST 	
%j 	Day number of year 001-366 		365 	
%U 	Week number of year, Sunday as the first day of week, 00-53 	52 	
%W 	Week number of year, Monday as the first day of week, 00-53 	52 	
%c 	Local version of date and time 	Mon Dec 31 17:41:00 2018 	
%C 	Century 				20 	
%x 	Local version of date 			12/31/18 	
%X 	Local version of time 			17:41:00 	
%% 	A % character 				% 	
%G 	ISO 8601 year 				2018 	
%u 	ISO 8601 weekday (1-7) 			1 	
%V 	ISO 8601 weeknumber (01-53) 		01



Z.B. print(x.strftime("%B")) 

Man muss also mit strftime() arbeiten, um diese Methoden zu verwenden

Mit x = datetime.datetime.now() erhält man die jetzige Zeit, diese kann man dann noch mit den obigen Methoden filtern

Um ein Datum zu erstellen könenn wir datetime() benutzen. Z.B.:

x = datetime.datetime(2020, 5, 17)

Es ist optional welche Informationen man alles angibt

28. Math = Das math module ist in Python eingebaut

Mit min() und max() kann man die entsprechenden Werte filtern. Z.B.:

x = min(5, 10, 25)
y = max(5, 10, 25)

print(x)
print(y) 

Mit pow(x, y) kann man Potenzrechnung machen

Für das module, wie immer:


import math


math.ceil() --> aufrunden
math.floor() --> abrunden

math.pi gibt den Wert von pi an

29. Json Daten speichern uns austauschen (gesprochen Johnson)

Mit json.loads kann man zwischen Python und Json übersetzen. Z.B.:

import json

# some JSON:
x =  '{ "name":"John", "age":30, "city":"New York"}'

# parse x:
y = json.loads(x)

# the result is a Python dictionary:
print(y["age"]) 

Umgekehrt kann man mit json.dumps von python nach json wechseln

import json

# a Python object (dict):
x = {
  "name": "John",
  "age": 30,
  "city": "New York"
}

# convert into JSON:
y = json.dumps(x)

# the result is a JSON string:
print(y) 


All diese Datentypen kann man in json umwandeln


    dict
    list
    tuple
    string
    int
    float
    True
    False
    None

Alle Beispiele
import json

print(json.dumps({"name": "John", "age": 30}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas")))
print(json.dumps("hello"))
print(json.dumps(42))
print(json.dumps(31.76))
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(None)) 

Datentypen sind in Json anders; hier ist die Übersetzung

dict 	Object
list 	Array
tuple 	Array
str 	String
int 	Number
float 	Number
True 	true
False 	false
None 	null

Normal sind JSON strings unschön zu lesen, deshalb kann man sie mit json.dumps() verschönern

 json.dumps(x, indent=4)


Auch die Separatoren können verändert werden

 json.dumps(x, indent=4, separators=(". ", " = "))

json.dumps kann auch die keys sortieren

 json.dumps(x, indent=4, sort_keys=True)


30. PIP Package Manager

pip --version  um die pip version herauszufinden und notfalls zu upgraden

Mit pip install [package] kann man verschiedene Module aus dem Internet ziehen
Man muss sie nur noch importieren

import package

Hier gibt es packages: https://pypi.org/.

Mit pip uninstall kann man packages löschen

pip list listet alle packages auf dem system auf

31. RegEx = Regular Expression, die aus einer Sequenz von Characters ein Suchmuster bildet

Man muss re importen

Beispiel:

import re

txt = "The rain in Spain"
x = re.search("^The.*Spain$", txt) 

Es wird nach The am Anfang und Spain am Ende der string gefiltert

Methoden:

findall 	Returns a list containing all matches
search 		Returns a Match object if there is a match anywhere in the string
split 		Returns a list where the string has been split at each match
sub 		Replaces one or many matches with a string

Metacharacters
		
[] 	A set of characters 								"[a-m]" 	
\ 	Signals a special sequence (can also be used to escape special characters) 	"\d" 	
. 	Any character (except newline character) 					"he..o" 	
^ 	Starts with 									"^hello" 	
$ 	Ends with 									"planet$" 	
* 	Zero or more occurrences 							"he.*o" 	
+ 	One or more occurrences 							"he.+o" 	
? 	Zero or one occurrences 							"he.?o" 	
{} 	Exactly the specified number of occurrences 					"he.{2}o" 	
| 	Either or 									"falls|stays" 	
() 	Capture and group 	 

Special Sequence

\A 	Returns a match if the specified characters are at the beginning of the string 			"\AThe" 	
\b 	Returns a match where the specified characters are at the beginning or at the end of a word
(the "r" in the beginning is making sure that the string is being treated as a "raw string") 		r"\bain"

													r"ain\b" 
\B 	Returns a match where the specified characters are present, but NOT at the beginning (or at the end) of a word
(the "r" in the beginning is making sure that the string is being treated as a "raw string") 	r"\Bain" r"ain\B" 	
\d 	Returns a match where the string contains digits (numbers from 0-9) 		"\d" 	
\D 	Returns a match where the string DOES NOT contain digits 			"\D" 	
\s 	Returns a match where the string contains a white space character 		"\s" 	
\S 	Returns a match where the string DOES NOT contain a white space character 	"\S" 	
\w 	Returns a match where the string contains any word characters (characters from a to Z, digits from 0-9, and the underscore _ character) 	"\w" 	
\W 	Returns a match where the string DOES NOT contain any word characters 										"\W" 	
\Z 	Returns a match if the specified characters are at the end of the string 									"Spain\Z"

Sets

[arn] 		Returns a match where one of the specified characters (a, r, or n) is present 	
[a-n] 		Returns a match for any lower case character, alphabetically between a and n 	
[^arn] 		Returns a match for any character EXCEPT a, r, and n 	
[0123] 		Returns a match where any of the specified digits (0, 1, 2, or 3) are present 	
[0-9] 		Returns a match for any digit between 0 and 9 	
[0-5][0-9] 	Returns a match for any two-digit numbers from 00 and 59 	
[a-zA-Z] 	Returns a match for any character alphabetically between a and z, lower case OR upper case 	
[+] 		In sets, +, *, ., |, (), $,{} has no special meaning, so [+] means: return a match for any + character in the string


Diese Methoden werden benutzt um speziell zu filtern.

Mit findall() kann man einen Text filtern

import re

txt = "The rain in Spain"
x = re.findall("ai", txt)
print(x) 

search() durchsucht eine String nach einem Match
Wenn es mehrere Match objects gibt wird nur das erste ausgegeben

split() splittet das string nach jedem Match. Z.B.:

import re

txt = "The rain in Spain"
x = re.split("\s", txt)
print(x) 

maxsplit lässt einen das splitten kontrollieren

import re

txt = "The rain in Spain"
x = re.split("\s", txt, 1)
print(x) 

Mit sub() kann man matches durch neuen text austauschen

import re

txt = "The rain in Spain"
x = re.sub("\s", "9", txt)
print(x) 

Dies kann man auch mit maxsplit verbinden

Das Match object gibt Informationen über Suche und Ergebnis
Hier sind ein paar Methoden

.span() returns a tuple containing the start-, and end positions of the match.
.string returns the string passed into the function
.group() returns the part of the string where there was a match

Somit kann man das Ergebnis filtern. 
Der RegEx ist sehr kompliziert und bietet dafür wenig Nutzen, allerdings ist es nützlich seine Funktion mit den vielen Methoden im Hinterkopf zu behalten.

32. Try... Except (WICHTIG!!!)

The try block lets you TEST a block of code for errors.

The except block lets you handle the ERROR.

The else block lets you execute code when there is NO ERROR.

The finally block lets you execute code, REGARDLESS of the RESULT of the try- and except blocks.

--------------------------------------------------------------------------------------------------------

Man kann also try und except kombinieren, um bei einem error Informationen zu erhalten. Z.B.:

try:
  print(x)
except:
  print("An exception occurred") 

Man kann so oft except verwenden wie man will, um viele erros abzudecken

finally wird benutzt, um etwas unabhängig vom Ergebnis auszuführen

try:
  print(x)
except:
  print("Something went wrong")
finally:
  print("The 'try except' is finished") 

Oder (hier zum Ressourcensparen)

try:
  f = open("demofile.txt")
  try:
    f.write("Lorum Ipsum")
  except:
    print("Something went wrong when writing to the file")
  finally:
    f.close()
except:
  print("Something went wrong when opening the file") 

Mit raise kann man dem Benutzer erros angeben, wenn etwas falsch gelaufen ist (z.B. bei falschem input)
Oder z.B. hier

try:
  f = open("demofile.txt")
  try:
    f.write("Lorum Ipsum")
  except:
    print("Something went wrong when writing to the file")
  finally:
    f.close()
except:
  print("Something went wrong when opening the file") 


Man kann auch den Typ des Errors bestimmen (einfach schreiben)
z.B. (hier ist Typeerror der error)
x = "hello"

if not type(x) is int:
  raise TypeError("Only integers are allowed") 

SEHR WICHTIG um als Developer Informationen über die Fehler der Nutzer zu geben

33. User input

Man muss die input() Methode verwenden
Z.B.:

Get your own Python Server
username = input("Enter username:")
print("Username is: " + username)

34. String formatting = Den String formattieren (hoffen dass er so aussieht, wie man es will)

Mit format() kann man bestimmte Teile eines Strings formatieren.

Wenn man Strings von user input oder Datenbasen auslesen will, muss man {} Klammern verwenden.
Mit format() kann man eine Überprüfung machen.

price = 49
txt = "The price is {} dollars"
print(txt.format(price))

Man kann auch in den curly Brackets neue Parameter hinzufügen

 txt = "The price is {:.2f} dollars"

Man kann auch mit mehreren Werten arbeiten

 print(txt.format(price, itemno, count)) 

Dann braucht man wiederum mehr curly Brackets:

quantity = 3
itemno = 567
price = 49
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))

Wenn man die Variable korrekt in die curly Brackets eingefügt haben will, kann man den Index benutzen.

Z.B. {0} und {1}

Man kann auch {0} und {0} verwenden, wenn man Variablen mehrmals verwenden möchte.

Es ist auch möglicht Namensindexe hinzuzufügen, man muss sie aber bei format() angeben. Z.B.:

myorder = "I have a {carname}, it is a {model}."
print(myorder.format(carname = "Ford", model = "Mustang"))

Hier sind noch ein paar String Formatierungsmethoden: 

:< 	
Left aligns the result (within the available space)
:> 	
Right aligns the result (within the available space)
:^ 	
Center aligns the result (within the available space)
:= 	
Places the sign to the left most position
:+ 	
Use a plus sign to indicate if the result is positive or negative
:- 	
Use a minus sign for negative values only
:  	
Use a space to insert an extra space before positive numbers (and a minus sign before negative numbers)
:, 	
Use a comma as a thousand separator
:_ 	
Use a underscore as a thousand separator
:b 	
Binary format
:c 		Converts the value into the corresponding unicode character
:d 	
Decimal format
:e 	
Scientific format, with a lower case e
:E 	
Scientific format, with an upper case E
:f 	
Fix point number format
:F 	
Fix point number format, in uppercase format (show inf and nan as INF and NAN)
:g 		
General format
:G 		
General format (using a upper case E for scientific notations)
:o 			
octal format
:x 		
ex format, lower case
:X 		
ex format, upper case
:n 		
Number format
:% 		
percentage format

🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍🐍
Ende 18.01.2024