Bagaimana saya bisa menyederhanakan pernyataan if-elif berulang dalam fungsi sistem penilaian saya?

Tujuannya adalah untuk membangun program untuk mengonversi skor dari sistem '0 ke 1' ke sistem 'F ke A':

• Jika score >= 0.9mau mencetak 'A'
• Jika score >= 0.8mau mencetak 'B'
• 0,7, C
• 0,6, D
• Dan nilai apa pun di bawah titik itu, cetak F

Ini adalah cara untuk membuatnya dan bekerja pada program, tetapi ini agak berulang:

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

Saya ingin tahu apakah ada cara untuk membangun fungsi sehingga pernyataan majemuk tidak akan berulang.

Saya seorang pemula total, tetapi akankah ada sesuatu di baris:

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

menjadi mungkin?

Maksudnya di sini adalah bahwa nanti kita bisa menyebutnya dengan hanya meneruskan scr, numbergrade, dan grade surat sebagai argumen:

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

Jika dimungkinkan untuk mengeluarkan lebih sedikit argumen, itu akan lebih baik.

Anda dapat menggunakan modul bisect untuk melakukan pencarian tabel numerik:

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

Anda dapat melakukan sesuatu seperti ini:

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

Ini digunakan nextdengan argumen default pada generator di atas pasangan skor-skor yang dibuat oleh zip. Ini sebenarnya setara dengan pendekatan loop Anda.

Anda dapat menetapkan nilai ambang untuk setiap nilai:

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"

Dalam kasus khusus ini Anda tidak perlu modul atau generator eksternal. Beberapa matematika dasar sudah cukup (dan lebih cepat)!

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"

Anda dapat menggunakan np.selectdari numpy library untuk berbagai kondisi:

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

Saya punya ide sederhana untuk menyelesaikan ini:

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

Sekarang,

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

Anda dapat menggunakan numpy.searchsorted, yang juga memberi Anda opsi bagus untuk memproses beberapa skor dalam satu panggilan:

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

Anda memberikan kasus sederhana. Namun jika logika Anda semakin rumit, Anda mungkin memerlukan mesin aturan untuk menangani kekacauan.

Anda dapat mencoba mesin Sauron Rule atau menemukan beberapa mesin aturan Python dari PYPI.

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

Anda juga bisa menggunakan pendekatan rekursif:

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

Berikut adalah beberapa pendekatan yang lebih ringkas dan kurang dimengerti:

Solusi pertama membutuhkan penggunaan fungsi lantai dari mathperpustakaan.

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

Dan jika karena alasan tertentu mengimpor mathperpustakaan mengganggu Anda. Anda bisa menggunakan pekerjaan di sekitar untuk fungsi lantai:

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

Ini agak rumit dan saya akan menyarankan untuk tidak menggunakannya kecuali Anda mengerti apa yang sedang terjadi. Mereka adalah solusi spesifik yang mengambil keuntungan dari fakta bahwa kenaikan nilai adalah 0,1 yang berarti bahwa menggunakan kenaikan selain 0,1 mungkin tidak akan berhasil menggunakan teknik ini. Itu juga tidak memiliki antarmuka yang mudah untuk memetakan tanda ke nilai. Solusi yang lebih umum seperti solusi dawg menggunakan bisect mungkin lebih tepat atau solusi schwobaseggl yang sangat bersih. Saya tidak benar-benar yakin mengapa saya memposting jawaban ini tetapi itu hanya upaya memecahkan masalah tanpa perpustakaan (saya tidak mencoba mengatakan bahwa menggunakan perpustakaan itu buruk) dalam satu baris menunjukkan sifat serbaguna python.

Anda dapat menggunakan dict.

Kode

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

Jika skor sebenarnya antara 0 dan 1, kalikan pertama 100, lalu cari skor.

Semoga yang berikut dapat membantu: jika scr> = 0,9: print ('A') elif 0,9> scr> = 0,8: print ('B') elif 0,8> scr> = 0,7: Cetak ('C') elif 0,7 scr> = 0.6: cetak ('D') lain: cetak ('F')

Anda bisa memiliki daftar angka, lalu daftar nilai yang menyertainya:

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

Kemudian, jika Anda ingin mengonversi skor yang ditentukan ke nilai huruf, Anda bisa melakukan ini:

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

Maka skor akhir Anda akan menjadi "B".