In Python ist das korrekte Einrücken von Zeilen sehr wichtig!

<code python>
# Ganzzahlen (integers)
zahl = 42
print(zahl)  # Ausgabe: 42

# Gleitkommazahlen (float)
pi = 3.14
print(pi)  # Ausgabe: 3.14

# Zeichenketten (strings)
name = "Alice"
print("Hallo, " + name)  # Ausgabe: Hallo, Alice

# Boolesche Werte (boolean)
wahr = True
falsch = False
print(wahr)  # Ausgabe: True
</code>

<code ruby>
# Arithmetische Operatoren
a = 5
b = 2

summe = a + b
differenz = a - b
produkt = a * b
quotient = a / b
rest = a % b
potenz = a ** b

print(summe, differenz, produkt, quotient, rest, potenz)
# Ausgabe: 7 3 10 2.5 1 25
</code>

<code ruby>
# Bedingte Anweisung (if-else)
alter = 18

if alter >= 18:
    print("Du bist volljährig.")
else:
    print("Du bist minderjährig.")

# Schleife (for-Schleife)
fruits = ["Apfel", "Banane", "Orange"]

for fruit in fruits:
    print(fruit)

# Schleife (while-Schleife)
counter = 0

while counter < 5:
    print(counter)
    counter += 1
</code>

<code ruby>
def greet(name):
    print("Hallo, " + name + "!")

greet("Bob")
# Ausgabe: Hallo, Bob!
</code>

=====Strings=====

https://docs.python.org/2/library/stdtypes.html#string-methods

<code python>
s = "Hallo welt, ciao"
print len(s)
print s[0:11] # from:to
</code>

ACHTUNG: Strings sind immutable!!! (unveränderbar) Man muss Kopien erzeugen

<code python>
a = "Hello"
b = "world"
print(a + b)

s = "Hello world"
s1 = s[5] + "moon"
</code>

<code python>
s1 = 'abc'
s2 = '123'
print('s1.join(s2):', s1.join(s2))
print('s2.join(s1):', s2.join(s1))

// assoziativ
test =  {'mat': "1", 'that': "2"}
s = '->'
print(s.join(test))
test =  {"1":'mat', "2":'that'}
s = ', '
print(s.join(test))
</code>

=====Arrays=====

In Python nennt man Arrays auch Listen.

<code python>
cars = []
vw = []
vw.append("golf3")
cars.append(vw)
audi = []
audi.append("a1")
cars.append(audi)
print(cars[0])
</code>

=====Funktionen=====

Build In Funktionen: https://www.programiz.com/python-programming/methods/built-in

<code python>
def find(str, ch):
  index = 0
  while index < len(str):
    if str[index] == ch:
      return index
    index = index + 1
  return -1
</code>

Lambda

<code python>
numbers = (1, 2, 3, 4)
result = map(lambda x: x*x, numbers)
print(result)

# converting map object to set
numbersSquare = set(result)
print(numbersSquare)
</code>

=====Parameter=====
<code python>
import sys, getopt

def main(argv):
   inputfile = ''
   outputfile = ''
   try:
      opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="])
   except getopt.GetoptError:
      print 'test.py -i <inputfile> -o <outputfile>'
      sys.exit(2)
   for opt, arg in opts:
      if opt == '-h':
         print 'test.py -i <inputfile> -o <outputfile>'
         sys.exit()
      elif opt in ("-i", "--ifile"):
         inputfile = arg
      elif opt in ("-o", "--ofile"):
         outputfile = arg
   print 'Input file is "', inputfile
   print 'Output file is "', outputfile

if __name__ == "__main__":
   main(sys.argv[1:])
</code>

=====Dateien=====

<code python>
f = open("file","mode") # r, w, w+, a
content = f.read()
for line in f.readlines():
    print(line)
f.write("Hello world")
f.close()
</code>

=====Datenstrukturen=====

====Set====

Sets, auch als Mengen bezeichnet, sind eine ungeordnete Sammlung einzigartiger Elemente in Python. Sie eignen sich gut, um Duplikate zu entfernen und mathematische Operationen wie Vereinigung, Schnittmenge und Differenz durchzuführen. Die Reihenfolge der Elemente in einem Set (Menge) wird in Python nicht garantiert.

<code python>
fruits = {'apple', 'banana', 'orange'}
fruits.add('grape')
print(fruits)
</code>

====Dictionary====

Dictionaries sind eine assoziative Datenstruktur, die Schlüssel-Wert-Paare enthält. Sie ermöglichen einen schnellen Zugriff auf Werte anhand der Schlüssel und eignen sich gut für die Speicherung und Abfrage von Daten. 

<code python>
student = {'name': 'John', 'age': 20, 'major': 'Computer Science'}
student['age'] = 21
print(student['name'])
</code>

====Listen====

Listen sind eine grundlegende Datenstruktur in Python, die verwendet wird, um eine geordnete Sammlung von Elementen zu speichern. Eine Liste kann Elemente verschiedener Datentypen enthalten und ermöglicht den Zugriff auf die Elemente über deren Position (Index) in der Liste.

<code python>
# Listen erstellen
my_list = [1, 2, 3, 4, 5]
empty_list = []

my_list.append(6)  # Hinzufügen am Ende der Liste
my_list.insert(0, 0)  # Hinzufügen an einer bestimmten Position (Index)

my_list.remove(3)  # Entfernen eines bestimmten Elements
popped_element = my_list.pop()  # Entfernen des letzten Elements und Rückgabe

print(my_list[0])  # Zugriff auf ein bestimmtes Element über den Index
print(my_list[-1])  # Zugriff auf das letzte Element

length = len(my_list)  # Anzahl der Elemente in der Liste

sublist = my_list[1:4]  # Elemente mit Index 1 bis 3 (exklusiv)
sublist2 = my_list[:3]  # Elemente von Beginn bis Index 2 (exklusiv)
sublist3 = my_list[2:]  # Elemente von Index 2 bis Ende

reversed_list = my_list[::-1]  # Liste in umgekehrter Reihenfolge

combined_list = my_list + other_list  # Listen kombinieren

my_list.sort()  # Liste in aufsteigender Reihenfolge sortieren
my_list.sort(reverse=True)  # Liste in absteigender Reihenfolge sortieren
</code>

Listenkomprehension ist eine elegante Möglichkeit, Listen auf der Grundlage von vorhandenen Listen zu erstellen. Sie ermöglicht es uns, komplexe Operationen auf eine kompakte Weise auszudrücken. 

<code python>
numbers = [1, 2, 3, 4, 5]
squared_numbers = [x ** 2 for x in numbers]
print(squared_numbers)
</code>

=====Regular Expessions=====

Die grundlegende Funktion, um nach Mustern in einem String zu suchen, ist re.search():

<code python>
import re

text = "Hello, my name is John."
pattern = r"name is (\w+)"

match = re.search(pattern, text)
if match:
    print("Gefunden:", match.group(0))  # Gesamter Treffer
    print("Name:", match.group(1))      # Erste Gruppe im Muster
</code>

Du kannst re.sub() verwenden, um Muster in einem String zu ersetzen:

<code python>
import re

text = "Hello, my name is John."
pattern = r"John"
replacement = "Alice"

new_text = re.sub(pattern, replacement, text)
print(new_text)
</code>


Mit re.findall() kannst du alle Übereinstimmungen eines Musters in einem String extrahieren:

<code python>
import re

text = "Phone numbers: 123-456-7890, 987-654-3210"
pattern = r"\d{3}-\d{3}-\d{4}"

phone_numbers = re.findall(pattern, text)
print(phone_numbers)
</code>


Du kannst Flags verwenden, um das Verhalten deiner regulären Ausdrücke zu ändern, z.B. für Groß-/Kleinschreibung:

<code python>
import re

text = "Hello, hello, HELLO!"
pattern = r"hello"
matches = re.findall(pattern, text, re.IGNORECASE)  # Case-insensitive Suche
print(matches)
</code>
=====Sockets=====

Siehe [[:scapy|Scapy]].

<code python>
import socket

HOST = "127.0.0.1"  # Standard loopback interface address (localhost)
PORT = 65432  # Port to listen on (non-privileged ports are > 1023)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind((HOST, PORT))
    s.listen()
    conn, addr = s.accept()
    with conn:
        print(f"Connected by {addr}")
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data)
</code>

<code python>
import socket

HOST = "127.0.0.1"  # The server's hostname or IP address
PORT = 65432  # The port used by the server

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect((HOST, PORT))
    s.sendall(b"Hello, world")
    data = s.recv(1024)

print(f"Received {data!r}")
</code>

=====Binary=====

<code python>
# convert a decimal ip address string into a binary ip address string
def test1(ip):
    ipparts = ip.split(".")
    print( bin(int(ipparts[0]))[2:].zfill(8) + "." + bin(int(ipparts[1]))[2:].zfill(8) + "." + bin(int(ipparts[2]))[2:].zfill(8) + "." + bin(int(ipparts[3]))[2:].zfill(8) )

# convert a decimal ip address string to Int32  
# x = 192.168.0.13
# x = {13} + 2**0 * 0  +  2**8 * {0}  +  2**16 * {168}  +  2**24 * {192}
def test2(ip):
    ipparts = ip.split(".")
    x = int(ipparts[3]) + 2**0 * 0 + 2**8 * int(ipparts[2]) + 2**16 * int(ipparts[1]) + 2**24 * int(ipparts[0])
    print( bin(x)[2:].zfill(32) )

    
test1("172.16.32.13")
test2("172.16.32.13")
</code>
=====Security=====

<code python>
python -c "import pty; pty.spawn('/bin/bash');"
</code>

=====JSON=====

<code python>
// [{"a":"aaa"},{"b":"bbb"}]
import json
with open("json.txt") as file:
    data = json.load(file)
print(data[0].get("key"))
</code>

=====PyGame=====

Pong

<code python>
import pygame
from pygame.locals import *

# Initialisierung von Pygame
pygame.init()

# Fenstergröße
WIDTH, HEIGHT = 640, 480
WINDOW_SIZE = (WIDTH, HEIGHT)

# Farben
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

# Erstellung des Spielfensters
window = pygame.display.set_mode(WINDOW_SIZE)
pygame.display.set_caption("Pong")

# Spieler
PLAYER_WIDTH, PLAYER_HEIGHT = 10, 60
player1_pos = pygame.Rect(50, HEIGHT/2 - PLAYER_HEIGHT/2, PLAYER_WIDTH, PLAYER_HEIGHT)
player2_pos = pygame.Rect(WIDTH - 50 - PLAYER_WIDTH, HEIGHT/2 - PLAYER_HEIGHT/2, PLAYER_WIDTH, PLAYER_HEIGHT)
player1_speed = 0
player2_speed = 0

# Ball
BALL_RADIUS = 10
ball_pos = pygame.Rect(WIDTH/2 - BALL_RADIUS/2, HEIGHT/2 - BALL_RADIUS/2, BALL_RADIUS, BALL_RADIUS)
ball_speed_x = 3
ball_speed_y = 3

# Spiel-Loop
running = True
clock = pygame.time.Clock()

while running:
    # Hintergrund zeichnen
    window.fill(BLACK)
    
    for event in pygame.event.get():
        if event.type == QUIT:
            running = False
        elif event.type == KEYDOWN:
            if event.key == K_w:
                player1_speed = -3
            elif event.key == K_s:
                player1_speed = 3
            elif event.key == K_UP:
                player2_speed = -3
            elif event.key == K_DOWN:
                player2_speed = 3
        elif event.type == KEYUP:
            if event.key == K_w or event.key == K_s:
                player1_speed = 0
            elif event.key == K_UP or event.key == K_DOWN:
                player2_speed = 0
    
    # Spieler bewegen
    player1_pos.y += player1_speed
    player2_pos.y += player2_speed
    
    # Kollision mit Fenster-Rändern überprüfen
    if player1_pos.top <= 0:
        player1_pos.top = 0
    if player1_pos.bottom >= HEIGHT:
        player1_pos.bottom = HEIGHT
    if player2_pos.top <= 0:
        player2_pos.top = 0
    if player2_pos.bottom >= HEIGHT:
        player2_pos.bottom = HEIGHT
    
    # Ball bewegen
    ball_pos.x += ball_speed_x
    ball_pos.y += ball_speed_y
    
    # Kollision mit Schlägern überprüfen
    if ball_pos.colliderect(player1_pos) or ball_pos.colliderect(player2_pos):
        ball_speed_x *= -1
    if ball_pos.top <= 0 or ball_pos.bottom >= HEIGHT:
        ball_speed_y *= -1
    
    # Ball-Ausrichtung umkehren, wenn das Spielfeld verlassen wird
    if ball_pos.left <= 0 or ball_pos.right >= WIDTH:
        ball_pos.x = WIDTH/2 - BALL_RADIUS/2
        ball_pos.y = HEIGHT/2 - BALL_RADIUS/2
        ball_speed_x *= -1
    
    # Objekte zeichnen
    pygame.draw.rect(window, WHITE, player1_pos)
    pygame.draw.rect(window, WHITE, player2_pos)
    pygame.draw.ellipse(window, WHITE, ball_pos)
    
    # Fenster aktualisieren
    pygame.display.flip()
    clock.tick(60)

# Pygame beenden
pygame.quit()
</code>

=====Tensorflow=====

Siehe [[:tensorflow|Tensorflow]].

<code python>
# -*- coding: utf-8 -*-

import tensorflow as tf
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam

# Beispiel-Datensatz
sentences = [
    "Ich liebe diesen Film!",
    "Das Essen war köstlich.",
    "Der Service war schrecklich.",
    "Der Film war enttäuschend.",
    "Ich kann dieses Restaurant nicht empfehlen.",
    "Ich gehe dort nie wieder hin",
    "Das Konzert war fantastisch.",
    "Der Urlaub war wunderbar.",
    "Der Kundenservice war großartig."
]

labels = np.array([1, 1, 0, 0, 0, 0, 1, 1, 1])  # 1 für positiv, 0 für negativ

# Tokenisierung und Vektorisierung der Sätze
tokenizer = tf.keras.preprocessing.text.Tokenizer()
tokenizer.fit_on_texts(sentences)
sequences = tokenizer.texts_to_sequences(sentences)
word_index = tokenizer.word_index
max_length = max([len(seq) for seq in sequences])
padded_sequences = tf.keras.preprocessing.sequence.pad_sequences(sequences, maxlen=max_length)

# Modell erstellen
model = Sequential()
model.add(Dense(16, activation="relu", input_shape=(max_length,)))
model.add(Dense(1, activation="sigmoid"))

# Modell kompilieren
model.compile(loss="binary_crossentropy", optimizer=Adam(learning_rate=0.001), metrics=["accuracy"])

# Modell trainieren
model.fit(padded_sequences, labels, epochs=10000)

# Neue Sätze vorhersagen
new_sentences = [
    "Der Film hat mir gut gefallen.",
    "Es war ein schrecklicher Abend.",
    "Die sehen mich nie wieder",
    "Das Konzert war erstaunlich gut."
]
new_sequences = tokenizer.texts_to_sequences(new_sentences)
new_padded_sequences = tf.keras.preprocessing.sequence.pad_sequences(new_sequences, maxlen=max_length)
predictions = model.predict(new_padded_sequences)

for sentence, prediction in zip(new_sentences, predictions):
    sentiment = "positiv" if prediction > 0.5 else "negativ"
    print(f"Satz: {sentence}")
    print(f"Sentiment: {sentiment}")
    print()
</code>

=====Torch=====

Siehe [[:torch|Torch]]

=====Transformers=====

Siehe  [[:transformers|Transformers]].
=====Links=====

  * https://www.programiz.com/python-programming/
  * https://docs.python.org/3/tutorial/interpreter.html
  * https://www.youtube.com/watch?v=HGOBQPFzWKo