Python lernen — jede Frage, jede Antwort

x = 7
y = 2
print(x // y)

print(type(3 / 2))

s = "  Hello  "
print(s.strip().upper())

s = "python"
print(s[1:4])

name = "Ada"
print(f"Hi, {name}!")

xs = [1, 2]
xs.append([3, 4])
print(len(xs))

xs = [1, 2, 3]
xs.extend([4, 5])
print(xs)

t = (1, 2, 3)
t[0] = 9
print(t)

d = {"a": 1, "b": 2}
print(d.get("c", 0))

d = {"x": 1}
print("x" in d)

s = {1, 2, 2, 3, 3, 3}
print(len(s))

vals = [0, "", None, [], "x"]
truthy = [v for v in vals if v]
print(len(truthy))

x = 10
if x > 20:
    print("A")
elif x > 5:
    print("B")
else:
    print("C")

total = 0
for i in range(1, 5):
    total += i
print(total)

names = ["a", "b", "c"]
for i, n in enumerate(names):
    print(i, n)

a = [1, 2, 3]
b = ["x", "y"]
print(list(zip(a, b)))

squares = [x*x for x in range(4)]
print(squares)

def greet(name, greeting="Hi"):
    return f"{greeting}, {name}"
print(greet("Sam"))

def total(*args, **kwargs):
    return sum(args) + sum(kwargs.values())
print(total(1, 2, x=3, y=4))

def f():
    pass
print(type(f()).__name__)

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b, a is b)

print(isinstance(True, int))

try:
    x = int("abc")
except ValueError:
    x = -1
print(x)

import math
print(math.sqrt(16))

class Dog:
    species = 'canine'
    def __init__(self, name):
        self.name = name

a = Dog('Rex')
Dog.species = 'wolf'
print(a.species)

class A:
    def hi(self): return 'A'
class B(A):
    def hi(self): return 'B' + super().hi()

print(B().hi())

class Temp:
    def __init__(self, c):
        self._c = c
    @property
    def f(self):
        return self._c * 9/5 + 32

t = Temp(100)
print(t.f)

class Math:
    @staticmethod
    def add(a, b): return a + b
    @classmethod
    def name(cls): return cls.__name__

print(Math.add(2, 3), Math.name())

def shout(fn):
    def wrap(*a, **k):
        return fn(*a, **k).upper()
    return wrap

@shout
def greet(n): return f'hi {n}'

print(greet('ann'))

class Open:
    def __enter__(self):
        print('in'); return self
    def __exit__(self, *a):
        print('out')

with Open():
    print('mid')

def gen():
    yield 1
    yield 2
    yield 3

g = gen()
print(next(g), next(g))

try:
    raise ValueError('a')
except ValueError:
    print('v')
else:
    print('e')
finally:
    print('f')

class C:
    def __init__(self): self.i = 0
    def __iter__(self): return self
    def __next__(self):
        if self.i >= 2: raise StopIteration
        self.i += 1
        return self.i

print(list(C()))

nums = [1, 2, 3, 4, 5]
print([x*x for x in nums if x % 2])

nums = [1, 2, 3, 4]
print(list(filter(lambda x: x > 2, nums)))

from functools import partial
def power(base, exp): return base ** exp
square = partial(power, exp=2)
print(square(5))

from pathlib import Path
p = Path('/tmp/data.txt')
print(p.suffix, p.stem)

from collections import Counter
print(Counter('mississippi').most_common(2))

for i, v in enumerate(['a', 'b', 'c'], start=10):
    print(i, v)

def classify(x):
    match x:
        case 0: return 'zero'
        case int(): return 'int'
        case _: return 'other'

print(classify(5))

pi = 3.14159
print(f'{pi:.2f}')

import copy
a = [[1, 2], [3, 4]]
b = copy.copy(a)
b[0].append(9)
print(a)

print('a,b,c,d'.split(',', maxsplit=2))

a = {'x': 1, 'y': 2}
b = {'y': 9, 'z': 3}
print(a | b)

pairs = [(1, 'b'), (3, 'a'), (2, 'c')]
print(sorted(pairs, key=lambda p: p[1]))

def add(x, items=[]):
    items.append(x)
    return items

print(add(1))
print(add(2))

from collections import defaultdict
d = defaultdict(int)
for c in 'abca':
    d[c] += 1
print(dict(d))

from functools import reduce
print(reduce(lambda a, b: a + b, [1, 2, 3, 4], 10))

from collections import deque
d = deque([1, 2, 3])
d.appendleft(0)
d.append(4)
print(list(d))

from typing import Protocol

class Greeter(Protocol):
    def hi(self) -> str: ...

class En:
    def hi(self) -> str:
        return 'hello'

def shout(g: Greeter) -> str:
    return g.hi().upper()

print(shout(En()))

from dataclasses import dataclass, field

@dataclass(frozen=True)
class P:
    name: str
    tags: list[str] = field(default_factory=list)

p = P('a')
p.tags.append('x')
print(p.tags)

from functools import singledispatch

@singledispatch
def fmt(x): return f'obj:{x}'

@fmt.register
def _(x: int): return f'int:{x}'

@fmt.register
def _(x: list): return f'list:{x}'

print(fmt(True))

from itertools import accumulate
import operator

nums = [1, 2, 3, 4]
print(list(accumulate(nums, operator.mul)))

class C:
    __slots__ = ('x',)

c = C()
c.x = 1
c.y = 2
print(c.x, c.y)

from typing import TypedDict, NotRequired

class User(TypedDict):
    name: str
    age: NotRequired[int]

u: User = {'name': 'Ada'}
print(u.get('age', 0))

from contextlib import ExitStack

def open_all(paths):
    with ExitStack() as stack:
        files = [stack.enter_context(open(p)) for p in paths]
        return [f.read() for f in files]

print(type(open_all([])).__name__)

class Desc:
    def __set_name__(self, owner, name):
        self.name = '_' + name
    def __get__(self, obj, t=None):
        return getattr(obj, self.name, 0)
    def __set__(self, obj, v):
        setattr(obj, self.name, v * 2)

class A:
    x = Desc()

a = A(); a.x = 5
print(a.x)

from enum import StrEnum, auto

class Color(StrEnum):
    RED = auto()
    BLUE = auto()

print(Color.RED == 'red', Color.RED.value)

from itertools import groupby

data = [1, 1, 2, 2, 1, 1]
print([(k, list(g)) for k, g in groupby(data)])

import weakref

class Node: pass

n = Node()
r = weakref.ref(n)
print(r() is n)
del n
print(r())

from typing import TypeVar, Generic

T = TypeVar('T')

class Box(Generic[T]):
    def __init__(self, x: T) -> None:
        self.x = x
    def get(self) -> T:
        return self.x

b: Box[int] = Box(3)
print(b.get() + 1)

from functools import cached_property

class C:
    @cached_property
    def v(self):
        print('compute')
        return 42

c = C()
print(c.v); print(c.v)

ba = bytearray(b'hello')
mv = memoryview(ba)
mv[0] = ord('H')
print(ba)

import re

text = 'a1 b22 c333'
print(re.findall(r'\d+', text))

from typing import Literal, assert_never

def area(shape: Literal['sq', 'tr'], v: float) -> float:
    match shape:
        case 'sq': return v * v
        case 'tr': return v * v / 2
        case _: assert_never(shape)

print(area('sq', 3))

class Meta(type):
    def __new__(mcs, name, bases, ns):
        ns['greeting'] = 'hi'
        return super().__new__(mcs, name, bases, ns)

class A(metaclass=Meta):
    pass

print(A.greeting)

match point := (1, 0):
    case (0, 0): r = 'origin'
    case (x, 0): r = f'x-axis:{x}'
    case (0, y): r = f'y-axis:{y}'
    case _: r = 'other'
print(r)

from contextvars import ContextVar
import asyncio

user: ContextVar[str] = ContextVar('user')

async def who():
    return user.get()

async def main():
    user.set('ada')
    print(await who())

asyncio.run(main())

from typing import ParamSpec, TypeVar, Callable
from functools import wraps

P = ParamSpec('P')
R = TypeVar('R')

def log(f: Callable[P, R]) -> Callable[P, R]:
    @wraps(f)
    def w(*a: P.args, **k: P.kwargs) -> R:
        return f(*a, **k)
    return w

from itertools import islice, count

print(list(islice(count(10, 2), 2, 5)))

from typing import Self

class Builder:
    def __init__(self) -> None:
        self.parts: list[str] = []
    def add(self, p: str) -> Self:
        self.parts.append(p)
        return self

class SubBuilder(Builder): pass

import asyncio

async def f(n):
    await asyncio.sleep(0.01)
    return n * 2

async def main():
    out = await asyncio.gather(f(3), f(1), f(2))
    print(out)

asyncio.run(main())

async def greet():
    return "hi"

result = greet()
print(type(result).__name__)

import asyncio, time

async def work():
    time.sleep(1)
    return 42

async def main():
    return await asyncio.gather(work(), work(), work())

asyncio.run(main())

async def boom():
    raise ValueError("x")

async def main():
    res = await asyncio.gather(boom(), boom(), return_exceptions=True)
    print([type(r).__name__ for r in res])

asyncio.run(main())

async def slow():
    await asyncio.sleep(5)
    return 1

async def main():
    try:
        return await asyncio.wait_for(slow(), timeout=0.1)
    except asyncio.TimeoutError:
        print("timeout")

asyncio.run(main())

async def f():
    return 7

async def main():
    print(f())

asyncio.run(main())

async def gen():
    for i in range(3):
        yield i

async def main():
    total = 0
    async for x in gen():
        total += x
    print(total)

asyncio.run(main())

async def main():
    sem = asyncio.Semaphore(2)
    async def worker(i):
        async with sem:
            await asyncio.sleep(0.1)
            return i
    return await asyncio.gather(*(worker(i) for i in range(4)))

print(asyncio.run(main()))

async def main():
    q = asyncio.Queue()
    await q.put(1)
    await q.put(2)
    print(await q.get(), await q.get())

asyncio.run(main())

async def hb():
    while True:
        print("tick")
        await asyncio.sleep(1)

async def main():
    t = asyncio.create_task(hb())
    await asyncio.sleep(0.05)
    t.cancel()
    try:
        await t
    except asyncio.CancelledError:
        print("done")

asyncio.run(main())

async def main():
    async with httpx.AsyncClient() as client:
        r = await client.get("https://api.example.com/x")
        return r.status_code

async def main():
    async with asyncio.TaskGroup() as tg:
        tg.create_task(asyncio.sleep(0.01))
        tg.create_task(asyncio.sleep(0.02))
    print("ok")

asyncio.run(main())

import time

def heavy(n):
    time.sleep(n); return n

async def main():
    loop = asyncio.get_running_loop()
    return await loop.run_in_executor(None, heavy, 0.1)

print(asyncio.run(main()))

async def f():
    return 1

async def main():
    t = asyncio.create_task(f())
    print(isinstance(t, asyncio.Task), asyncio.iscoroutine(f()))

asyncio.run(main())

from contextlib import asynccontextmanager

@asynccontextmanager
async def conn():
    print("open")
    yield "c"
    print("close")

async def main():
    async with conn() as c:
        print(c)

asyncio.run(main())

async def f():
    raise RuntimeError("oops")

async def main():
    asyncio.create_task(f())
    await asyncio.sleep(0.05)
    print("ok")

asyncio.run(main())

async def gen():
    yield 1
    yield 2

async def main():
    it = gen()
    print(await anext(it))
    print(await anext(it))

asyncio.run(main())

async def task(n):
    await asyncio.sleep(0.01)
    return n

async def seq():
    a = await task(1)
    b = await task(2)
    return a + b

async def par():
    a, b = await asyncio.gather(task(1), task(2))
    return a + b

async def main():
    ev = asyncio.Event()
    async def waiter():
        await ev.wait()
        return "go"
    t = asyncio.create_task(waiter())
    await asyncio.sleep(0.01)
    ev.set()
    print(await t)

asyncio.run(main())

async def fetch():
    async with httpx.AsyncClient(timeout=2.0) as c:
        r = await c.get("https://slow.example")
        return r.text

from fastapi import FastAPI

app = FastAPI()

@app.get('/items/{item_id}')
def read(item_id: int):
    return {'id': item_id}

from fastapi import FastAPI

app = FastAPI()

@app.get('/search')
def search(q: str = 'all', limit: int = 10):
    return {'q': q, 'limit': limit}

from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.get('/u/{i}')
def get(i: int):
    if i < 0:
        raise HTTPException(status_code=404, detail='nope')
    return {'i': i}

from fastapi import FastAPI
from pydantic import BaseModel, Field

class Item(BaseModel):
    name: str = Field(min_length=2)

app = FastAPI()

@app.post('/i')
def add(it: Item):
    return it

from fastapi import FastAPI
from pydantic import BaseModel

class Out(BaseModel):
    name: str

app = FastAPI()

@app.get('/me', response_model=Out)
def me():
    return {'name': 'Ada', 'token': 'secret'}

from fastapi import FastAPI, status

app = FastAPI()

@app.post('/items', status_code=status.HTTP_201_CREATED)
def create():
    return {'ok': True}

from fastapi import FastAPI, Depends

app = FastAPI()

def common(q: str = ''):
    return {'q': q}

@app.get('/i')
def list_items(c: dict = Depends(common)):
    return c

from fastapi import FastAPI, Depends

app = FastAPI()

def get_db():
    db = {'x': 1}
    try:
        yield db
    finally:
        db.clear()

@app.get('/')
def r(d=Depends(get_db)):
    return d

from fastapi import FastAPI
import httpx

app = FastAPI()

@app.get('/proxy')
async def proxy():
    async with httpx.AsyncClient() as c:
        r = await c.get('https://api.example.com')
    return r.json()

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def log(msg: str):
    open('log.txt', 'a').write(msg)

@app.post('/notify')
def notify(bt: BackgroundTasks):
    bt.add_task(log, 'sent')
    return {'ok': True}

from fastapi import FastAPI, Request

app = FastAPI()

@app.middleware('http')
async def add_header(request: Request, call_next):
    resp = await call_next(request)
    resp.headers['X-App'] = 'demo'
    return resp

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=['https://x.com'],
    allow_methods=['*'],
)

from fastapi import FastAPI, UploadFile

app = FastAPI()

@app.post('/up')
async def upload(file: UploadFile):
    data = await file.read()
    return {'size': len(data), 'name': file.filename}

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket('/ws')
async def ws(websocket: WebSocket):
    await websocket.accept()
    msg = await websocket.receive_text()
    await websocket.send_text(f'echo:{msg}')

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

def gen():
    for i in range(3):
        yield f'chunk{i}\n'

@app.get('/s')
def stream():
    return StreamingResponse(gen(), media_type='text/plain')

from fastapi import FastAPI, APIRouter

router = APIRouter(prefix='/v1', tags=['users'])

@router.get('/users')
def list_users():
    return []

app = FastAPI()
app.include_router(router)

from fastapi import FastAPI, Depends
from fastapi.security import OAuth2PasswordBearer

oauth2 = OAuth2PasswordBearer(tokenUrl='token')
app = FastAPI()

@app.get('/me')
def me(token: str = Depends(oauth2)):
    return {'token': token}

from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI()

@app.get('/ping')
def ping():
    return {'pong': True}

client = TestClient(app)
r = client.get('/ping')

from contextlib import asynccontextmanager
from fastapi import FastAPI

@asynccontextmanager
async def lifespan(app: FastAPI):
    print('startup')
    yield
    print('shutdown')

app = FastAPI(lifespan=lifespan)

from pydantic import BaseModel, field_validator

class User(BaseModel):
    name: str

    @field_validator('name')
    @classmethod
    def upper(cls, v: str) -> str:
        if not v:
            raise ValueError('empty')
        return v.upper()

from pydantic import BaseModel, ConfigDict

class User(BaseModel):
    model_config = ConfigDict(extra='forbid')
    name: str

import asyncio, httpx
from fastapi import FastAPI

app = FastAPI()

@app.get('/agg')
async def agg():
    async with httpx.AsyncClient() as c:
        a, b = await asyncio.gather(
            c.get('https://x/1'), c.get('https://x/2'))
    return {'a': a.status_code, 'b': b.status_code}

from fastapi import FastAPI, Depends

def auth(token: str = ''):
    return token == 'ok'

def admin(ok: bool = Depends(auth)):
    return ok

app = FastAPI()

@app.get('/a')
def page(is_admin: bool = Depends(admin)):
    return is_admin

from fastapi import FastAPI
import time

app = FastAPI()

@app.get('/work')
def work():
    time.sleep(2)
    return 'done'

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session

def get_session():
    s = Session()
    try:
        yield s
    finally:
        s.close()

app = FastAPI()

@app.get('/u')
def list_u(db: Session = Depends(get_session)):
    return db.execute('SELECT 1').all()