Wie kann ich sich wiederholende if-elif-Anweisungen in meiner Bewertungssystemfunktion vereinfachen?

Das Ziel ist es, ein Programm zu erstellen, um Punktzahlen von einem '0 zu 1'-System in ein' F zu A'-System umzuwandeln:

• Wenn score >= 0.9 würde 'A' drucken
• Wenn score >= 0.8 würde 'B' drucken
• 0,7, C.
• 0,6, D.
• Und jeder Wert unter diesem Punkt druckt F.

Dies ist der Weg, um es zu erstellen und es funktioniert auf dem Programm, aber es ist etwas repetitiv:

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')

Ich würde gerne wissen, ob es eine Möglichkeit gibt, eine Funktion so zu erstellen, dass sich die zusammengesetzten Anweisungen nicht so oft wiederholen.

Ich bin ein absoluter Anfänger, würde aber etwas in der Art von:

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

möglich sein?

Die Absicht hier ist, dass wir es später aufrufen können, indem wir nur scr, numbergrade und letter grade als Argumente übergeben:

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')

Wenn es möglich wäre, weniger Argumente zu übergeben, wäre es sogar noch besser.

Mit dem Halbierungsmodul können Sie eine numerische Tabellensuche durchführen:

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']

Sie können etwas in diese Richtung tun:

# 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'

Dies wird nextmit einem Standardargument für einen Generator über die von erstellten Score-Grade-Paare verwendet zip. Es ist praktisch das genaue Äquivalent Ihres Loop-Ansatzes.

Sie können jeder Note einen Schwellenwert zuweisen:

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"

In diesem speziellen Fall benötigen Sie keine externen Module oder Generatoren. Einige grundlegende Mathematik ist genug (und schneller)!

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"

Sie können np.selectaus der Numpy-Bibliothek für mehrere Bedingungen verwenden:

>> 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')

Ich habe eine einfache Idee, um dies zu lösen:

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

Jetzt,

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

Sie können Folgendes verwenden numpy.searchsorted, wodurch Sie zusätzlich die Möglichkeit haben, mehrere Ergebnisse in einem einzigen Anruf zu verarbeiten:

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']

Sie haben einen einfachen Fall angegeben. Wenn Ihre Logik jedoch komplizierter wird, benötigen Sie möglicherweise eine Regelengine , um das Chaos zu bewältigen.

Sie können die Sauron Rule Engine ausprobieren oder einige Python Rules Engines von PYPI finden.

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

Sie können auch einen rekursiven Ansatz verwenden:

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']

Hier sind einige prägnantere und weniger verständliche Ansätze:

Die erste Lösung erfordert die Verwendung der Bodenfunktion aus der mathBibliothek.

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

Und wenn Sie aus irgendeinem Grund beim Importieren der mathBibliothek gestört werden. Sie könnten eine Problemumgehung für die Bodenfunktion verwenden:

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

Diese sind etwas kompliziert und ich würde davon abraten, sie zu verwenden, es sei denn, Sie verstehen, was los ist. Dies sind spezifische Lösungen, die die Tatsache ausnutzen, dass die Inkremente in Noten 0,1 betragen, was bedeutet, dass die Verwendung eines anderen Inkrements als 0,1 mit dieser Technik wahrscheinlich nicht funktionieren würde. Es gibt auch keine einfache Oberfläche zum Zuordnen von Noten zu Noten. Eine allgemeinere Lösung wie die von dawg mit Bisect ist wahrscheinlich besser geeignet oder die sehr saubere Lösung von schwobaseggl. Ich bin mir nicht sicher, warum ich diese Antwort veröffentliche, aber es ist nur ein Versuch, das Problem ohne Bibliotheken zu lösen (ich versuche nicht zu sagen, dass die Verwendung von Bibliotheken schlecht ist) in einer Zeile, die die Vielseitigkeit von Python demonstriert.

Sie können ein Diktat verwenden.

Code

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")

Demo

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

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

Wenn die Punktzahl tatsächlich zwischen 0 und 1 liegt, multiplizieren Sie zuerst 100 und suchen Sie dann die Punktzahl.

Hoffe, dass Folgendes helfen könnte: Wenn 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') else: print ('F')

Sie könnten eine Liste mit Zahlen und dann eine Liste mit Noten haben:

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

Wenn Sie dann eine bestimmte Punktzahl in eine Buchstabennote umwandeln möchten, können Sie Folgendes tun:

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

Dann wäre Ihr Endergebnis "B".