Python - Filtrage des entrées, calcul avec un nombre variable d'entrées

Question

J'ai travaillé sur une calculatrice aérodynamique en utilisant python (dans lequel je suis relativement nouveau), dans ce programme, une valeur peut être calculée en fonction de plusieurs entrées différentes, c'est-à-dire. a calcule b, b calcule c, ou c peut trouver b et b peut trouver a .

Pour élaborer sur la fonction de ce programme, il parcourra sa logique jusqu'à ce qu'il ait trouvé tout ce qu'il pouvait avec la ou les entrées données. Le code est assez long pour sa fonction et c'est pourquoi j'aimerais voir s'il pourrait être optimisé ou si je pourrais faire quelque chose de mieux. Pour la méthode d'entrée, l'entrée est une chaîne. Le code est comme suit:

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

J'apprécie toute aide / rétroaction, merci d'avance!

Answer 1

Bienvenue dans Code Review! J'ajouterai ce que @Linny a déjà dit sur les indices de type et la dénomination des variables. La dénomination des variables fait partie des directives PEP-8 de python (voir en bas).

Numéros magiques

Vous avez beaucoup de nombres magiques dans votre code, qui sont vraiment des constantes de conversion, mais qui apparaissent sans une telle explication.

Noms de variables

Puisque vous écrivez une calculatrice aérodynamique, il serait utile d'utiliser des noms complets pour diverses variables de votre code. Pour par exemple. altitudeau lieu de alt, temperatureau lieu de juste temp( tempest généralement utilisé comme variable temporaire dans le code).

Température du sol

Sur la base du déroulement du programme, je suppose que ground_temperaturec'est essentiel pour tout calcul. Peut-être vérifiez-le au tout début et arrêtez-vous tôt en cas de chèques invalides.

Arguments optionnels

De ce qui précède, il suffit ground_temperatured'appeler la calculatrice. Tout le reste est facultatif et peut être calculé. Peut-être qu'une fonction qui par défaut d'autres valeurs Nonevous conviendra mieux:

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

Booléens pour chaque paramètre

Avec l'approche ci-dessus, vous pouvez simplement valider la valeur elle-même, sans avoir à garder une trace d'un booléen pour ces valeurs.

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

PEP-8

En python, il est courant (et recommandé) de suivre le guide de style PEP-8 pour écrire du code propre, maintenable et cohérent.

Les fonctions et les variables doivent être nommées dans a lower_snake_case, classes as UpperCamelCaseet constantes as UPPER_SNAKE_CASE.

Answer 2

Juste quelques notes sur le style

• Les noms de variable et de fonction doivent être snake_case
• Vous devez ajouter des conseils de type pour afficher les types de paramètres que vous acceptez et la ou les valeurs renvoyées par vos fonctions.

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

Vous n'avez pas besoin de créer une variable pour un calcul afin de renvoyer ce calcul. Renvoyez simplement l'expression elle-même.