# Python Programme in einer Zeile code schreiben

Wenn du Scripte bis zur einer Zeile Code verkürzen möchtest; Hab ich hier ein paar Möglichkeite aufgeschrieben.
Eine ist Lambda, weiteres findest du in Inhaltsverzeichniss:

## Inhaltsverzeichnis:
1. [Lambda](##-lambda-funktionen-grundlage)
2. [Semikolons](##-semikolon)
3. [Listen definieren](#-list-comprehension)
4. [Mehrfachzuwesungen](##-variablen-mehrfachzuwesungen)

## Lambda Funktionen Grundlage
Lambda wird benutzt um eine **Anonyme Funktion** zu definieren
> Beispiel:  
> ```
> funcbla = <lambda-ausdruck>
> funcbla()
> ```

Oder du kannst eine lambda Funktion direkt ausführen:  
> `(<lambda-ausdruck>)(<zu-übergebene-variablen>)`oder `<lambda-ausdruck(ohne "lambda : <vars>")` <-- **locale variablen werden genutzt**
### Lambda Ausdrücke:
man definiert eine Ausdruck so:
> ```
> lambda <vars> : <func1()> if <statement> else <func2>
> ```

> Beispiel:
>  ```
> print((lambda x : "ungerade" if x%2 else "gerade")(123))
> ```
> Output: `ungerade`
> 
> **Wenn du eine Funktion in einen Lambda Ausdruck verwendest, muss sie eine Variable zurückgeben.  
> Lambda gibt entweder `ungerade` oder `gerade` im Beispiel and print() zurück.**


## Semikolon
Nutze ein `;` um mehrere Funktionen in einer Zeile zu verketten
> Beispiel:
> ```
> func1()
> func2()
> ```
> wird zu:  
> ```
> func1();func2()
> ```


# List Comprehension
Mit List Comprehensions kann man Listen in einer zeiler definieren und darüber iterieren:
> Beispiel:
> ```
> list1 = []
> for x in range(10):
>   list1.append(x)
> ```
> wird zu:  
> ```
> list1 = [<vart-to-add(or you can use Variables like "x")> for x in range(10)]
> ```

Mann kan auch if statements in Comprehentions nutzen:
```
newlist = [expression for item in iterable if condition == True]
```
> Beispiel:
> ```
> list1 = ["a", "b", "c", "d", "e"]
> list2 = [x for x in fruits if "a" in x]
> ```
> ^ Addiert Das Objekt x zu list2 wenn `if "a" in x` also eine "a" in den String Objekt ist.


## Variablen Mehrfachzuwesungen
variablen sind was sehr nützliches was nicht fehlen darf!
Man kann sie auf verschiedene arten zuwei?en, eine davon ist mit Mehrfachzuweisungen:
> ```
> var1 = 1
> var2 = 2
> var3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
> ```
> wir zu:
> ```
> var1, var2, var3 = 1, 2, [x for x in range(10]```

### Stapel = Stapel
In Grunde kann man mit Mehrfachzuweisungen Stapel(Tuple) entpacken oder packen:
> Packen eines Tupels in eine Variable
> ```
> var1 = a,b,c
> ```
> soviel wie:
> "var = tulple"
> ^ "Anfenger Hinweiss: Wenn man das untenstehenliegene Prinzip verstanden hat ist man flexibler"

> Packen eines Tupels in einen Tuple:
> ```
>  var1, var2, var3 = 1, 2, 3
> ```
> soviel wie:
> "tuple = tulple"