আমার গ্রেডিং সিস্টেমের ফাংশনে আমি-এলিফ স্টেটমেন্টগুলি পুনরাবৃত্তিমূলক কীভাবে সহজ করব?

Question

লক্ষ্যটি একটি '0 থেকে 1' সিস্টেম থেকে 'এফ থেকে এ' সিস্টেমে স্কোর রূপান্তর করার জন্য একটি প্রোগ্রাম তৈরি করা:

• যদি score >= 0.9'এ' মুদ্রণ হত
• যদি score >= 0.8'বি' মুদ্রণ করতেন
• 0.7, সি
• ০..6, ডি
• এবং যে বিন্দু নীচে যে কোনও মান, এফ মুদ্রণ করুন

এটি এটি তৈরির উপায় এবং এটি প্রোগ্রামে কাজ করে তবে কিছুটা পুনরাবৃত্তি:

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

আমি জানতে চাই যে কোনও ফাংশন তৈরির উপায় আছে যাতে যৌগিক বিবৃতিগুলি পুনরাবৃত্তি না হয়।

আমি মোট শিক্ষানবিশ, তবে এর লাইনে কিছু চাই:

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

সম্ভব?

এখানে অভিপ্রায়টি হ'ল পরবর্তীতে আমরা কেবল স্ক্রিন, নম্বরগ্রাড এবং লেটার গ্রেডকে যুক্তি হিসাবে পাস করে এটি বলতে পারি:

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

যদি কম যুক্তি পাস করা সম্ভব হয় তবে এটি আরও ভাল।

Comments

সম্পর্কিত: পাইথনে সুইচ স্টেটমেন্টের প্রতিস্থাপন?

— wjandrea

এটা কি তোমার প্রশ্নের উত্তর? পাইথনে গ্রেডিং সিস্টেম কীভাবে তৈরি করবেন?

— রোডআরনার

Answer 1

একটি সংখ্যার সারণী দেখার জন্য আপনি দ্বিখণ্ডিত মডিউলটি ব্যবহার করতে পারেন :

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

Comments

আমি ব্যবহারের জন্য একটি অতিরিক্ত +1 চাই bisect, যা আমি এটি খুব কম ব্যবহার করেছি বলে মনে করি।

— norok2

@ নরোক 2 আমি মনে করি না 4 টি উপাদানের একটি তালিকা যদিও শুরু করার জায়গা। এই জাতীয় ছোট তালিকার জন্য একটি লিনিয়ার স্ক্যান সম্ভবত দ্রুততর হবে। কোনও শিরোনাম ছাড়াই একটি পরিবর্তনীয় ডিফল্ট যুক্তি ব্যবহার করুন;)

— এসইচওবাসেগগল

অবশ্যই, তবে এটি ক্ষতি করে না এবং প্রশ্নের শেখার দিকটি দেওয়া হয়েছে, আমি এটি বেশ উপযুক্ত বলে মনে করি।

— norok2

এটি বাইসেক্ট মডিউল থেকে উদাহরণ

— ডগ

@ sswwbaseggl এমনকি এই জাতীয় ছোট তালিকার জন্যও দ্বিপাক্ষিক দ্রুততর। আমার ল্যাপটপে দ্বিখণ্ডিত দ্রবণটি 1.2µs এবং লুপটি 1.5µs লাগে

— ইফতা

Answer 2

আপনি এই লাইন বরাবর কিছু করতে পারেন:

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

এটি nextতৈরি করা স্কোর-গ্রেড জোড়াগুলির তুলনায় জেনারেটরে একটি ডিফল্ট যুক্তি সহ ব্যবহার করে zip। এটি কার্যত আপনার লুপ পদ্ধতির সঠিক সমতুল্য।

Answer 3

আপনি প্রতিটি গ্রেডকে একটি প্রান্তিক মান নির্ধারণ করতে পারেন:

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"

Comments

দ্রষ্টব্য, আপনি যদি পাইথন ৩.6 বা তার থেকে নীচে ব্যবহার করেন sorted(grades.items())তবে ডিক্টগুলি বাছাইয়ের গ্যারান্টিযুক্ত না হওয়ার কারণে আপনার উচিত ।

— wjandrea

এটি সমস্ত পাইথন সংস্করণে নির্ভরযোগ্যভাবে কাজ করবে না। মনে রাখবেন যে ডিকের ক্রমটি গ্যারান্টিযুক্ত নয়। এছাড়াও একটি dictএকটি অকারণে হেভিডাটা গঠন, হিসাবে এটি অর্ডার যে বিষয়ে, এবং আপনি আপ ইনডেক্স (অর্ডার) দ্বারা যাহাই হউক না কেন খুঁজছি হয়, কী দ্বারা নয়।

— schwobaseggl

নিশ্চিত যে সবচেয়ে দক্ষ নয়, তবে এটি তর্কসাপেক্ষে সর্বাধিক পঠনযোগ্য কারণ সমস্ত চিহ্ন তাদের প্রান্তিকের নিকটে লেখা হয়। আমি বরং ডোকের পরিবর্তে কয়েক জোড়া জোড় দিয়ে প্রতিস্থাপন করব।

— norok2

@schwobaseggl এই নির্দিষ্ট কাজের জন্য, হ্যাঁ, টিপলগুলির একটি তালিকা একটি ডিকের চেয়ে ভাল হবে, তবে এই সমস্ত কোডটি যদি মডিউলে চলে যায় তবে ডিক আপনাকে লেটার গ্রেড -> প্রান্তিকের সন্ধানের অনুমতি দেবে।

— wjandrea

@wjandrea যদি কিছু হয় তবে আপনার কি কি এবং মানগুলির কিছু পরিবর্তন করার দরকার আছে grades[int(score*10)/10.0]তবে তারপরে আপনার Decimalভাসা কুখ্যাতভাবে আচরণ করা ডিক কী হিসাবে ব্যবহার করা উচিত ।

— schwobaseggl

Answer 4

এই নির্দিষ্ট ক্ষেত্রে আপনার বাহ্যিক মডিউল বা জেনারেটরের প্রয়োজন নেই। কিছু প্রাথমিক গণিতই যথেষ্ট (এবং দ্রুত)!

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"

Answer 5

আপনি np.selectএকাধিক শর্তের জন্য নম্পুটি গ্রন্থাগার থেকে ব্যবহার করতে পারেন :

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

Answer 6

আমি এটি সমাধান করার জন্য একটি সহজ ধারণা পেয়েছি:

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

এখন,

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

Answer 7

আপনি ব্যবহার করতে পারেন numpy.searchsorted, যা অতিরিক্তভাবে আপনাকে একক কলে একাধিক স্কোর প্রক্রিয়াজাতকরণের এই দুর্দান্ত বিকল্পটি দেয়:

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

Answer 8

আপনি একটি সহজ কেস সরবরাহ করেছেন। তবে আপনার যুক্তিটি আরও জটিল হয়ে উঠলে বিশৃঙ্খলা সামাল দেওয়ার জন্য আপনার কোনও নিয়ম ইঞ্জিনের প্রয়োজন হতে পারে ।

আপনি সওরন বিধি ইঞ্জিনটি চেষ্টা করতে পারেন বা পিওয়াইপিআই থেকে পাইথন নিয়মের কিছু ইঞ্জিন খুঁজে পেতে পারেন।

Answer 9

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

Comments

এই কোডটি প্রশ্নের উত্তর দিতে পারে, তবে এটি কীভাবে কাজ করে এবং কখন এটি ব্যবহার করবে তা ব্যাখ্যা করে কিছু প্রসঙ্গ অন্তর্ভুক্ত করা ভাল। কোড-কেবল উত্তরগুলি দীর্ঘমেয়াদে কার্যকর নয়।

— মোস্তফা

Answer 10

আপনি পুনরাবৃত্তি পদ্ধতির ব্যবহার করতে পারেন:

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

Answer 11

এখানে আরও কিছু সংক্ষিপ্ত এবং কম বোধগম্য পদ্ধতি রয়েছে:

প্রথম সমাধানটি mathলাইব্রেরি থেকে মেঝে ফাংশন ব্যবহার করা প্রয়োজন ।

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

এবং যদি কোনও কারণে mathগ্রন্থাগারটি আমদানি করা আপনাকে বিরক্ত করে। আপনি মেঝে ফাংশন জন্য চারপাশে একটি কাজ ব্যবহার করতে পারেন:

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

এগুলি কিছুটা জটিল এবং আপনি কী চলছে তা বুঝতে না পারলে আমি এগুলি ব্যবহারের বিরুদ্ধে পরামর্শ দেব। এগুলি সুনির্দিষ্ট সমাধান যা গ্রেডের বর্ধিত হারের 0.1 এর অর্থ গ্রহণ করে যে 0.1 এর বাইরে অন্য একটি বর্ধিত ব্যবহার সম্ভবত এই কৌশলটি ব্যবহার করে কাজ করবে না। গ্রেডগুলিতে চিহ্ন ম্যাপ করার জন্য এটির কোনও সহজ ইন্টারফেসও নেই। বাইসেক্ট ব্যবহার করে ডাউগ-এর মতো আরও একটি সাধারণ সমাধান সম্ভবত আরও উপযুক্ত বা স্কুবাসেসগেলের খুব পরিষ্কার সমাধান। আমি কেন এই উত্তরটি পোস্ট করছি তা সত্যই নিশ্চিত নই তবে এটি কোনও লাইব্রেরি ছাড়াই সমস্যাটি সমাধানের চেষ্টা (আমি বলার চেষ্টা করছি না যে লাইব্রেরিগুলি ব্যবহার করা খারাপ কিনা) অজগরটির বহুমুখী প্রকৃতির চিত্র প্রদর্শন করে।

Answer 12

আপনি একটি ডিক ব্যবহার করতে পারেন।

কোড

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

ডেমো

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

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

স্কোরগুলি যদি 0 ও 1 এর মধ্যে হয় তবে প্রথমে 100 গুণ করুন, তারপরে স্কোরটি অনুসন্ধান করুন।

Answer 13

আশা করি নিম্নলিখিতগুলি সহায়তা করতে পারে: scr> = 0.9: মুদ্রণ ('এ') এলিফ 0.9> এসআর>> 0.8: মুদ্রণ ('বি') এলিফ 0.8> এসআর> = 0.7: মুদ্রণ ('সি') এলিফ 0.7 এসআর> = 0.6: মুদ্রণ ( 'd') আর: মুদ্রণ ( 'এফ')

Answer 14

আপনার সংখ্যার একটি তালিকা থাকতে পারে, তারপরে গ্রেডের একটি তালিকা থাকতে পারে:

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

তারপরে, আপনি যদি একটি নির্দিষ্ট স্কোরকে একটি লেটার গ্রেডে রূপান্তর করতে চান তবে আপনি এটি করতে পারেন:

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

তাহলে আপনার চূড়ান্ত স্কোর হবে "B"।

Comments

আপনি যদি ডিভির বিষয়ে ভাবছেন: এই সমাধানটি 0.83গ্রেডের মতো স্কোর থেকে পাওয়ার কোনও উপায় সরবরাহ করে না "B"। আপনাকে কীভাবে স্কোর থেকে সূচকে উঠতে হবে তা দেখাতে হবে item।

— schwobaseggl