Python - Eingabefilterung, Berechnung mit einer variablen Anzahl von Eingaben

Question

Ich habe an einem Aerodynamik-Rechner mit Python gearbeitet (was ich relativ neu bin). In diesem Programm kann ein Wert basierend auf mehreren verschiedenen Eingaben berechnet werden, d. H. a berechnet b, b berechnet c oder c kann b finden und b kann a finden .

Um die Funktion dieses Programms zu erläutern, durchläuft es seine Logik, bis es alle möglichen Elemente mit den angegebenen Eingaben gefunden hat. Der Code ist ziemlich lang für seine Funktion und deshalb würde ich gerne sehen, ob er optimiert werden könnte oder ob ich etwas besser machen könnte. Bei der Eingabemethode ist die Eingabe eine Zeichenfolge. Der Code lautet wie folgt:

def Find_Pressure(temp):
    pressure = (101.29 * (((temp + 273.1) / 288.08) ** 5.256))
    return pressure


def Find_Temp_Alt(alt, ground_temp):
    Temp = ground_temp - (0.00649 * alt)
    return Temp


def Find_Density(pressure, temp):
    density = (pressure / (0.2869 * (temp + 273.1)))
    return density


def Find_Alt_Temp(temp, ground_temp):
    Alt = ((ground_temp - temp) / 0.00649)
    return Alt


def is_Valid(x):
    try:
        float(x)
        return True
    except ValueError:
        return False


def Parser(ground_temp, temp, alt, pressure, density):
    a = t = p = d = False
    run = True
    Alt = Temp = Pressure = Density = "N/A"
    if is_Valid(alt):
        Alt = float(alt)
        a = True
    if is_Valid(temp):
        Temp = float(temp)
        if Temp <= -273.1:
            t = False
        else:
            t = True
    if is_Valid(pressure):
        Pressure = float(pressure)
        p = True
    if is_Valid(density):
        Density = float(density)
        d = True

    if not is_Valid(ground_temp):
        print('Enter Ground Temp')
    else:
        G_T = float(ground_temp)
        while run:
            run = False
            if a and not t:
                Temp = Find_Temp_Alt(Alt, G_T)
                t = True
                run = True

            if t and not a:
                Alt = Find_Alt_Temp(Temp, G_T)
                a = True
                run = True

            if p and not t:
                Temp = ((288.08 * ((Pressure / 101.29) ** (1 / 5.256))) - 273.1)
                t = True
                run = True

            if t and not p:
                Pressure = Find_Pressure(Temp)
                p = True
                run = True

            if (p and t) and not d:
                Density = Find_Density(Pressure, Temp)
                d = True
                run = True
            if (d and t) and not p:
                Pressure = (Density * 0.2869 * (Temp + 273.1))
                p = True
                run = True

            if (d and p) and not t:
                Temp = ((Pressure / Density * 0.2869) - 273.1)
                t = True
                run = True
        return Alt, Temp, Pressure, Density

Ich freue mich über jede Hilfe / Rückmeldung, danke im Voraus!

Answer 1

Willkommen bei Code Review! Ich werde das ergänzen, was @Linny bereits über Typhinweise und die Benennung von Variablen gesagt hat. Die Benennung von Variablen ist Teil der PEP-8-Richtlinien von Python (siehe unten).

Magische Zahlen

Sie haben viele magische Zahlen in Ihrem Code, die wirklich Konvertierungskonstanten sind, aber ohne eine solche Erklärung erscheinen.

Variablennamen

Da Sie einen Aerodynamikrechner schreiben, ist es hilfreich, wenn Sie vollständige Namen für verschiedene Variablen in Ihrem Code verwenden. Zum Beispiel. altitudestatt alt, temperaturestatt nur temp( tempwird im allgemeinen als temporäre Variable in Code verwendet wird ).

Bodentemperatur

Aufgrund des Programmflusses gehe ich davon aus, dass dies ground_temperaturefür alle Berechnungen wesentlich ist. Vielleicht gleich zu Beginn prüfen und bei ungültigen Schecks frühzeitig abbrechen.

Optionale Argumente

Von oben wird nur ground_temperaturebenötigt, um den Rechner aufzurufen. Alles andere ist optional und kann berechnet werden. Vielleicht Nonepasst eine Funktion, die andere Werte standardmäßig verwendet, besser zu Ihnen:

def aerodynamic_calculator(
    ground_temperature: float,
    temperature: float = None,
    altitude: float = None,
    pressure: float = None,
    density: float = None,
):

Boolesche Werte für jeden Parameter

Mit dem obigen Ansatz können Sie nur den Wert selbst validieren, ohne einen Booleschen Wert für diese Werte verfolgen zu müssen.

if temperature and not altitude:
    altitude = compute_altitude_from_temperature(temperature, ground_temperature)

PEP-8

In Python ist es üblich (und empfohlen), den PEP-8-Styleguide zu befolgen, um sauberen, wartbaren und konsistenten Code zu schreiben.

Funktionen und Variablen sollten in a lower_snake_case, Klassen als UpperCamelCaseund Konstanten als benannt werden UPPER_SNAKE_CASE.

Answer 2

Nur ein paar Anmerkungen zum Stil

• Variablen- und Funktionsnamen sollten in sein snake_case
• Sie sollten Typhinweise hinzufügen, um anzuzeigen, welche Arten von Parametern Sie akzeptieren und welche Werte Ihre Funktionen zurückgeben.

def find_pressure(temp: float) -> float:
    return (101.29 * (((temp + 273.1) / 288.08) ** 5.256))


def find_temp_alt(alt: float, ground_temp: float) -> float:
    return ground_temp - (0.00649 * alt)


def find_density(pressure: float, temp: float) -> float:
    return (pressure / (0.2869 * (temp + 273.1)))


def Find_Alt_Temp(temp: float, ground_temp: float) -> float:
    return ((ground_temp - temp) / 0.00649)


def is_valid(x: str) -> bool:
    try:
        float(x)
        return True
    except ValueError:
        return False

Sie müssen keine Variable für eine Berechnung erstellen, um diese Berechnung zurückzugeben. Geben Sie einfach den Ausdruck selbst zurück.