Projekt: eine Bibliothek zum Umrechnen von Einheiten

LENGTH_UNITS = ["mm", "cm", "m", "km"]


def metres_per(unit: str) -> float:
    """Return how many metres one unit is."""
    if unit == "m":
        return 1.0
    # Add mm, cm and km, and raise ValueError for any other unit.
    return 1.0


def convert_length(value: float, from_unit: str, to_unit: str) -> float:
    """Convert a length from one unit to another."""
    # Raise ValueError for a negative value, then convert via metres.
    return value


print(convert_length(2.5, "km", "m"))

from main import convert_length


def test_km_to_m():
    """2.5 km sind 2500 m"""
    got = convert_length(2.5, "km", "m")
    assert round(got, 6) == 2500.0, f"convert_length(2.5, 'km', 'm') lieferte {got!r}, erwartet: 2500.0"


def test_cm_to_m():
    """250 cm sind 2.5 m"""
    got = convert_length(250, "cm", "m")
    assert round(got, 6) == 2.5, f"convert_length(250, 'cm', 'm') lieferte {got!r}, erwartet: 2.5"


def test_mm_to_cm():
    """5 mm sind 0.5 cm"""
    got = convert_length(5, "mm", "cm")
    assert round(got, 6) == 0.5, f"convert_length(5, 'mm', 'cm') lieferte {got!r}, erwartet: 0.5"


def test_same_unit():
    """7 m sind 7 m"""
    got = convert_length(7, "m", "m")
    assert round(got, 6) == 7.0, f"convert_length(7, 'm', 'm') lieferte {got!r}, erwartet: 7.0"


def test_unknown_unit():
    """Eine unbekannte Einheit löst ValueError aus"""
    try:
        got = convert_length(3, "m", "miles")
    except ValueError:
        return
    raise AssertionError(f"convert_length(3, 'm', 'miles') lieferte {got!r} statt einen ValueError auszulösen")


def test_negative_length():
    """Eine negative Länge löst ValueError aus"""
    try:
        got = convert_length(-1, "m", "cm")
    except ValueError:
        return
    raise AssertionError(f"convert_length(-1, 'm', 'cm') lieferte {got!r} statt einen ValueError auszulösen")

LENGTH_UNITS = ["mm", "cm", "m", "km"]


def metres_per(unit: str) -> float:
    """Return how many metres one unit is."""
    if unit == "mm":
        return 0.001
    elif unit == "cm":
        return 0.01
    elif unit == "m":
        return 1.0
    elif unit == "km":
        return 1000.0
    raise ValueError("unknown length unit: " + unit)


def convert_length(value: float, from_unit: str, to_unit: str) -> float:
    """Convert a length from one unit to another."""
    if value < 0:
        raise ValueError("a length cannot be negative")
    return value * metres_per(from_unit) / metres_per(to_unit)


TEMPERATURE_UNITS = ["C", "F", "K"]


def convert_temperature(value: float, from_unit: str, to_unit: str) -> float:
    """Convert a temperature between C, F and K."""
    # Step 2: convert to kelvin first, refuse anything below 0 K,
    # then convert from kelvin to the target unit.
    return value


print(convert_temperature(100, "C", "F"))

from main import convert_temperature


def test_c_to_f():
    """100 C sind 212 F"""
    got = convert_temperature(100, "C", "F")
    assert round(got, 6) == 212.0, f"convert_temperature(100, 'C', 'F') lieferte {got!r}, erwartet: 212.0"


def test_f_to_c():
    """32 F sind 0 C"""
    got = convert_temperature(32, "F", "C")
    assert round(got, 6) == 0.0, f"convert_temperature(32, 'F', 'C') lieferte {got!r}, erwartet: 0.0"


def test_kelvin():
    """0 C sind 273.15 K, und 0 K sind -273.15 C"""
    got = convert_temperature(0, "C", "K"), convert_temperature(0, "K", "C")
    assert (round(got[0], 6), round(got[1], 6)) == (273.15, -273.15), f"convert_temperature(0, 'C', 'K') und convert_temperature(0, 'K', 'C') lieferten {got!r}"


def test_minus_forty():
    """-40 C sind -40 F"""
    got = convert_temperature(-40, "C", "F")
    assert round(got, 6) == -40.0, f"convert_temperature(-40, 'C', 'F') lieferte {got!r}, erwartet: -40.0"


def test_below_absolute_zero():
    """-300 C und -1 K lösen ValueError aus"""
    for value, unit in [(-300, "C"), (-1, "K")]:
        try:
            got = convert_temperature(value, unit, "F")
        except ValueError:
            continue
        raise AssertionError(f"convert_temperature({value}, {unit!r}, 'F') lieferte {got!r} statt einen ValueError auszulösen")


def test_unknown_unit():
    """Eine unbekannte Einheit löst ValueError aus"""
    try:
        got = convert_temperature(20, "C", "X")
    except ValueError:
        return
    raise AssertionError(f"convert_temperature(20, 'C', 'X') lieferte {got!r} statt einen ValueError auszulösen")

LENGTH_UNITS = ["mm", "cm", "m", "km"]


def metres_per(unit: str) -> float:
    """Return how many metres one unit is."""
    if unit == "mm":
        return 0.001
    elif unit == "cm":
        return 0.01
    elif unit == "m":
        return 1.0
    elif unit == "km":
        return 1000.0
    raise ValueError("unknown length unit: " + unit)


def convert_length(value: float, from_unit: str, to_unit: str) -> float:
    """Convert a length from one unit to another."""
    if value < 0:
        raise ValueError("a length cannot be negative")
    return value * metres_per(from_unit) / metres_per(to_unit)


TEMPERATURE_UNITS = ["C", "F", "K"]


def to_kelvin(value: float, unit: str) -> float:
    """Return the temperature in kelvin."""
    if unit == "K":
        return value
    elif unit == "C":
        return value + 273.15
    elif unit == "F":
        return (value - 32) * 5 / 9 + 273.15
    raise ValueError("unknown temperature unit: " + unit)


def from_kelvin(kelvin: float, unit: str) -> float:
    """Return a temperature given in kelvin in another unit."""
    if unit == "K":
        return kelvin
    elif unit == "C":
        return kelvin - 273.15
    elif unit == "F":
        return (kelvin - 273.15) * 9 / 5 + 32
    raise ValueError("unknown temperature unit: " + unit)


def convert_temperature(value: float, from_unit: str, to_unit: str) -> float:
    """Convert a temperature between C, F and K."""
    kelvin = to_kelvin(value, from_unit)
    if kelvin < 0:
        raise ValueError("below absolute zero")
    return from_kelvin(kelvin, to_unit)


def convert(value: float, from_unit: str, to_unit: str) -> float:
    """Convert value between two units of the same kind."""
    # Step 3: pick convert_length or convert_temperature, refuse mixed
    # kinds, and add a keyword-only option digits for rounding.
    return value


print(convert(1, "km", "m"))

from main import convert


def test_length():
    """convert(1, "km", "m") ist 1000"""
    got = convert(1, "km", "m")
    assert round(got, 6) == 1000.0, f"convert(1, 'km', 'm') lieferte {got!r}, erwartet: 1000.0"


def test_temperature():
    """convert(100, "C", "F") ist 212"""
    got = convert(100, "C", "F")
    assert round(got, 6) == 212.0, f"convert(100, 'C', 'F') lieferte {got!r}, erwartet: 212.0"


def test_digits():
    """digits=1 rundet 123.456 cm auf 123.5"""
    got = convert(1.23456, "m", "cm", digits=1)
    assert got == 123.5, f"convert(1.23456, 'm', 'cm', digits=1) lieferte {got!r}, erwartet: 123.5"


def test_mixed_kinds():
    """Eine Länge wird keine Temperatur"""
    try:
        got = convert(1, "m", "C")
    except ValueError:
        return
    raise AssertionError(f"convert(1, 'm', 'C') lieferte {got!r} statt einen ValueError auszulösen")


def test_digits_keyword_only():
    """digits muss per Schlüsselwort kommen"""
    try:
        got = convert(1.23456, "m", "cm", 1)
    except TypeError:
        return
    raise AssertionError(f"convert(1.23456, 'm', 'cm', 1) lieferte {got!r}; digits sollte nur per Schlüsselwort gehen")


def test_docstring():
    """convert hat einen Docstring"""
    assert convert.__doc__, "convert hat keinen Docstring"