¿Cómo puedo simplificar las declaraciones repetitivas if-elif en la función de mi sistema de calificación?

El objetivo es crear un programa para convertir puntajes de un sistema '0 a 1' a un sistema 'F a A':

• Si score >= 0.9imprimiera 'A'
• Si score >= 0.8imprimiría 'B'
• 0.7, C
• 0.6, D
• Y cualquier valor por debajo de ese punto, imprima F

Esta es la forma de construirlo y funciona en el programa, pero es algo repetitivo:

if scr >= 0.9:
    print('A')
elif scr >= 0.8:
    print('B')
elif scr >= 0.7:
    print('C')
elif scr >= 0.6:
    print('D')
else:
    print('F')

Me gustaría saber si hay una manera de construir una función para que las declaraciones compuestas no sean tan repetitivas.

Soy un principiante total, pero haría algo en las líneas de:

def convertgrade(scr, numgrd, ltrgrd):
    if scr >= numgrd:
        return ltrgrd
    if scr < numgrd:
        return ltrgrd

¿ser posible?

La intención aquí es que luego podamos llamarlo pasando solo el scr, el grado de calificación y la calificación de letra como argumentos:

convertgrade(scr, 0.9, 'A')
convertgrade(scr, 0.8, 'B')
convertgrade(scr, 0.7, 'C')
convertgrade(scr, 0.6, 'D')
convertgrade(scr, 0.6, 'F')

Si fuera posible pasar menos argumentos, sería aún mejor.

Puede usar el módulo bisect para hacer una búsqueda de tabla numérica:

from bisect import bisect 

def grade(score, breakpoints=[60, 70, 80, 90], grades='FDCBA'):
     i = bisect(breakpoints, score)
     return grades[i]

>>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]
['F', 'A', 'C', 'C', 'B', 'A', 'A']

Puedes hacer algo en este sentido:

# if used repeatedly, it's better to declare outside of function and reuse
# grades = list(zip('ABCD', (.9, .8, .7, .6)))

def grade(score):
    grades = zip('ABCD', (.9, .8, .7, .6))
    return next((grade for grade, limit in grades if score >= limit), 'F')

>>> grade(1)
'A'
>>> grade(0.85)
'B'
>>> grade(0.55)
'F'

Esto se usa nextcon un argumento predeterminado en un generador sobre los pares de calificación-calificación creados por zip. Es prácticamente el equivalente exacto de su enfoque de bucle.

Puede asignar a cada calificación un valor umbral:

grades = {"A": 0.9, "B": 0.8, "C": 0.7, "D": 0.6, "E": 0.5}

def convert_grade(scr):
    for ltrgrd, numgrd in grades.items():
        if scr >= numgrd:
            return ltrgrd
    return "F"

En este caso específico, no necesita módulos externos o generadores. ¡Algunas matemáticas básicas son suficientes (y más rápidas)!

grades = ["A", "B", "C", "D", "F"]

def convert_score(score):
    return grades[-max(int(score * 10) - 5, 0) - 1]

# Examples:
print(convert_grade(0.61)) # "D"
print(convert_grade(0.37)) # "F"
print(convert_grade(0.94)) # "A"

Puede usar np.selectde la biblioteca numpy para múltiples condiciones:

>> x = np.array([0.9,0.8,0.7,0.6,0.5])

>> conditions  = [ x >= 0.9,  x >= 0.8, x >= 0.7, x >= 0.6]
>> choices     = ['A','B','C','D']

>> np.select(conditions, choices, default='F')
>> array(['A', 'B', 'C', 'D', 'F'], dtype='<U1')

Tengo una idea simple para resolver esto:

def convert_grade(numgrd):
    number = min(9, int(numgrd * 10))
    number = number if number >= 6 else 4
    return chr(74 - number)

Ahora,

print(convert_grade(.95))  # --> A 
print(convert_grade(.9))  # --> A
print(convert_grade(.4))  # --> F
print(convert_grade(.2))  # --> F

Podrías usar numpy.searchsorted, lo que además te brinda esta buena opción de procesar múltiples puntajes en una sola llamada:

import numpy as np

grades = np.array(['F', 'D', 'C', 'B', 'A'])
thresholds = np.arange(0.6, 1, 0.1)

scores = np.array([0.75, 0.83, 0.34, 0.9])
grades[np.searchsorted(thresholds, scores)]  # output: ['C', 'B', 'F', 'A']

Usted proporcionó un caso simple. Sin embargo, si su lógica se está volviendo más complicada, es posible que necesite un motor de reglas para manejar el caos.

Puede probar el motor de reglas de Sauron o encontrar algunos motores de reglas de Python en PYPI.

>>> grade = lambda score:'FFFFFFDCBAA'[int(score*100)//10]
>>> grade(0.8)
'B'

También podría usar un enfoque recursivo:

grade_mapping = list(zip((0.9, 0.8, 0.7, 0.6, 0), 'ABCDF'))
def get_grade(score, index = 0):
    if score >= grade_mapping[index][0]:
        return(grade_mapping[index][1])
    else:
        return(get_grade(score, index = index + 1))

>>> print([get_grade(score) for score in [0, 0.59, 0.6, 0.69, 0.79, 0.89, 0.9, 1]])
['F', 'F', 'D', 'D', 'C', 'B', 'A', 'A']

Aquí hay algunos enfoques más concisos y menos comprensibles:

La primera solución requiere el uso de la función de piso de la mathbiblioteca.

from math import floor
def grade(mark):
    return ["D", "C", "B", "A"][min(floor(10 * mark - 6), 3)] if mark >= 0.6 else "F"

Y si por alguna razón importar la mathbiblioteca te está molestando. Podría usar una solución alternativa para la función de piso:

def grade(mark):
    return ["D", "C", "B", "A"][min(int(10 * mark - 6) // 1, 3)] if mark >= 0.6 else "F"

Estos son un poco complicados y recomendaría no usarlos a menos que entiendas lo que está sucediendo. Son soluciones específicas que aprovechan el hecho de que los incrementos en las calificaciones son 0.1, lo que significa que usar un incremento diferente a 0.1 probablemente no funcionaría usando esta técnica. Tampoco tiene una interfaz fácil para asignar marcas a calificaciones. Una solución más general como la de dawg usando bisect es probablemente la solución más limpia o más adecuada de schwobaseggl. No estoy realmente seguro de por qué estoy publicando esta respuesta, pero es solo un intento de resolver el problema sin ninguna biblioteca (no estoy tratando de decir que usar bibliotecas es malo) en una línea que demuestra la naturaleza versátil de Python.

Puedes usar un dict.

Código

def grade(score):
    """Return a letter grade."""
    grades = {100: "A", 90: "A", 80: "B", 70: "C", 60: "D"}
    return grades.get((score // 10) * 10, "F")

Manifestación

[grade(scr) for scr in [100, 33, 95, 61, 77, 90, 89]]

# ['A', 'F', 'A', 'D', 'C', 'A', 'B']

Si los puntajes están realmente entre 0 y 1, primero multiplique 100, luego busque el puntaje.

Espero que lo siguiente pueda ayudar: if scr> = 0.9: print ('A') elif 0.9> scr> = 0.8: print ('B') elif 0.8> scr> = 0.7: Print ('C') elif 0.7 scr> = 0.6: print ('D') más: print ('F')

Podría tener una lista de números, luego una lista de calificaciones para acompañarla:

scores = (0.9, 0.8, 0.7, 0.6, 0.6)
lettergrades = ("A", "B", "C", "D", "F", "F")

Luego, si desea convertir una puntuación especificada en una calificación de letra, puede hacer esto:

item = 1 # Item 1 would be 0.8
scr = lettergrades[item]

Entonces tu puntaje final sería "B".