# Leistungsdaten

Leistungsprofile von Luftfahrzeugen integrieren — Daten nach ICAO Doc 8643 für die Planung von Reichweite, Geschwindigkeit und Wirbelschleppenkategorie.



Lauffähige Beispiele, um Leistungsdaten von Luftfahrzeugen anhand der ICAO-Musterkennung abzurufen und zu vergleichen. Felddefinitionen und Hinweise zur Abdeckung finden Sie in der vollständigen Referenz [Flugzeugleistungsdaten](/docs/v31/aircraft-performance).

| # | Frage                                                                                      | Verwendete Daten                    |
| - | ------------------------------------------------------------------------------------------ | ----------------------------------- |
| 1 | Welche Leistungsdaten hat eine Boeing 737-800?                                             | `/aircraft/performance/{icao_type}` |
| 2 | Wie schneiden A320, B738 und A35K bei Reichweite und Reisegeschwindigkeit im Vergleich ab? | `/aircraft/performance/{icao_type}` |

<DocRequirements>
  <DocRequirementAuth />
</DocRequirements>

### Installation [#install]

Die folgenden Skripte verwenden `requests` für API-Aufrufe und `rich` für die Terminalausgabe. Einmalig installieren:

```bash
pip install requests rich
```

***

### 1. Leistungsdaten einer Boeing 737-800 (B738) abrufen [#1-look-up-performance-specs-for-a-boeing-737-800-b738]

**Frage:** Welche Reisegeschwindigkeit, Reichweite, Abmessungen und Betriebsgrenzen hat eine B738?

Leistungsdaten sind nach ICAO-Musterkennung indiziert. Ein 404 bedeutet, dass der Typ noch nicht in der Leistungsdatenbank enthalten ist — bei seltenen oder sehr neuen Typen ist das normal.

```python
import os

import requests
from rich.console import Console
from rich.table import Table

console = Console()

HEADERS = {
    "X-RapidAPI-Key": os.getenv("RAPIDAPI_KEY", "YOUR_RAPIDAPI_KEY"),
    "X-RapidAPI-Host": "skylink-api.p.rapidapi.com",
}
BASE = "https://skylink-api.p.rapidapi.com"

ICAO_TYPE = "B738"


def fetch_performance(icao_type: str) -> dict | None:
    r = requests.get(
        f"{BASE}/aircraft/performance/{icao_type}",
        headers=HEADERS,
        timeout=(10, 15),
    )
    if r.status_code == 404:
        return None
    r.raise_for_status()
    return r.json()


def main() -> None:
    data = fetch_performance(ICAO_TYPE)

    if data is None:
        console.print(f"[yellow]Type {ICAO_TYPE} not in performance database.[/yellow]")
        return

    cruise_kt = data["cruise_speed_ktas"]
    cruise_kmh = round(cruise_kt * 1.852)
    range_nm = data["max_range_nm"]
    range_km = round(range_nm * 1.852)
    mtow_t = data["mtow_t"]
    mtow_lb = round(mtow_t * 2204.6)

    table = Table(title=f"Performance — {data['icao_type']} {data['name']}", border_style="cyan")
    table.add_column("Field", style="bold")
    table.add_column("Value")

    table.add_row("ICAO Type", data["icao_type"])
    table.add_row("Name", data["name"])
    table.add_row("Engine Type", data["engine_type"])
    table.add_row("Wake Category", data["wake_category"])
    table.add_row("Cruise Speed", f"{cruise_kt} kt  ({cruise_kmh} km/h)")
    table.add_row("Service Ceiling", f"{data['service_ceiling_ft']:,} ft")
    table.add_row("Max Range", f"{range_nm:,} nm  ({range_km:,} km)")
    table.add_row("Wingspan", f"{data['wing_span_m']} m")
    table.add_row("Length", f"{data['length_m']} m")
    table.add_row("MTOW", f"{mtow_t} t  ({mtow_lb:,} lb)")
    table.add_row("Max Passengers", str(data["max_passengers"]))

    console.print(table)


if __name__ == "__main__":
    main()
```

**Ausgabe:** Eine Tabelle mit allen Leistungsfeldern einschließlich abgeleiteter Einheitenumrechnungen (km/h, km, lb).

***

### 2. Reisegeschwindigkeit und Reichweite von A320, B738 und A35K vergleichen [#2-compare-cruise-speed-and-range-for-a320-vs-b738-vs-a35k]

**Frage:** Welcher von drei gängigen Schmal- und Großraumtypen hat die größte Reichweite, und wie schneiden sie bei der Reisegeschwindigkeit ab?

Rufen Sie jeden Typ parallel ab, sortieren Sie absteigend nach `max_range_nm` und markieren Sie den Typ mit der größten Reichweite mit ★. Typen, die einen 404 liefern, werden mit einer Warnung übersprungen.

```python
import os
from concurrent.futures import ThreadPoolExecutor, as_completed

import requests
from rich.console import Console
from rich.table import Table

console = Console()

HEADERS = {
    "X-RapidAPI-Key": os.getenv("RAPIDAPI_KEY", "YOUR_RAPIDAPI_KEY"),
    "X-RapidAPI-Host": "skylink-api.p.rapidapi.com",
}
BASE = "https://skylink-api.p.rapidapi.com"

TYPES = ["A320", "B738", "A35K"]


def fetch_performance(icao_type: str) -> tuple[str, dict | None]:
    r = requests.get(
        f"{BASE}/aircraft/performance/{icao_type}",
        headers=HEADERS,
        timeout=(10, 15),
    )
    if r.status_code == 404:
        return icao_type, None
    r.raise_for_status()
    return icao_type, r.json()


def main() -> None:
    found: list[dict] = []
    missing: list[str] = []

    with ThreadPoolExecutor(max_workers=5) as pool:
        futures = {pool.submit(fetch_performance, t): t for t in TYPES}
        for future in as_completed(futures):
            icao_type, data = future.result()
            if data is None:
                missing.append(icao_type)
            else:
                found.append(data)

    if missing:
        console.print(f"[yellow]Skipped (not in database): {', '.join(missing)}[/yellow]")

    if not found:
        console.print("[red]No performance data available for any of the requested types.[/red]")
        return

    found.sort(key=lambda d: d["max_range_nm"], reverse=True)
    best_range = found[0]["icao_type"]

    table = Table(title="Aircraft Performance Comparison", border_style="cyan")
    table.add_column("Type", style="bold")
    table.add_column("Name")
    table.add_column("Cruise (kt)", justify="right")
    table.add_column("Range (nm)", justify="right")
    table.add_column("Ceiling (ft)", justify="right")
    table.add_column("Wake", justify="center")

    for d in found:
        star = " ★" if d["icao_type"] == best_range else ""
        table.add_row(
            d["icao_type"] + star,
            d["name"],
            str(d["cruise_speed_ktas"]),
            f"{d['max_range_nm']:,}",
            f"{d['service_ceiling_ft']:,}",
            d["wake_category"],
        )

    console.print(table)


if __name__ == "__main__":
    main()
```

**Ausgabe:** Eine Vergleichstabelle, absteigend nach Reichweite sortiert. Der Typ mit der größten Reichweite ist mit ★ markiert.