पायथन: अंतराल से मूल्यों को मैप करने के लिए

Question

मैं एक फ़ंक्शन को दोबारा क्रियान्वित कर रहा हूं, जो अंतराल को परिभाषित करने वाले एंडपॉइंट्स की श्रृंखला को देखते हुए जांच करता है कि अंतराल में कोई संख्या शामिल है या नहीं, और उसके बाद संबंधित (किसी भी गणना योग्य तरीके से संबंधित नहीं))। कोड है कि अब काम से निपटने है:

if p <= 100: 
    return 0 
elif p > 100 and p <= 300: 
    return 1 
elif p > 300 and p <= 500: 
    return 2 
elif p > 500 and p <= 800: 
    return 3 
elif p > 800 and p <= 1000: 
    return 4 
elif p > 1000: 
    return 5 

IMO काफी भयानक है, और कहा कि दोनों के अंतराल में अभाव है और वापसी मान हार्डकोडेड कर रहे हैं। किसी भी डेटा संरचना का कोई भी उपयोग निश्चित रूप से संभव है।

Answer 1

import bisect 
bisect.bisect_left([100,300,500,800,1000], p) 

Answer 2

की तर्ज पर की कोशिश कुछ:

d = {(None,100): 0, 
    (100,200): 1, 
    ... 
    (1000, None): 5} 
value = 300 # example value 
for k,v in d.items(): 
    if (k[0] is None or value > k[0]) and (k[1] is None or value <= k[1]): 
     return v 

Answer 3

आप इस पर एक ले कोशिश कर सकते:

def check_mapping(p): 
    mapping = [(100, 0), (300, 1), (500, 2)] # Add all your values and returns here 

    for check, value in mapping: 
     if p <= check: 
      return value 

print check_mapping(12) 
print check_mapping(101) 
print check_mapping(303) 

पैदा करता है:

0 
1 
2 

हमेशा की तरह अजगर में, वहाँ हो जाएगा इसे करने के लिए कोई बेहतर तरीका है।

Answer 4

def which_interval(endpoints, number): 
    for n, endpoint in enumerate(endpoints): 
     if number <= endpoint: 
      return n 
     previous = endpoint 
    return n + 1 

endpoints में एक सूची के रूप में अपने अंतिम बिंदु दर्रा, इस तरह:

which_interval([100, 300, 500, 800, 1000], 5) 

संपादित करें:

ऊपर एक रेखीय खोज है। ग्लेन मेनार्ड के जवाब में बेहतर प्रदर्शन होगा, क्योंकि यह एक बिसेक्शन एल्गोरिदम का उपयोग करता है।

Answer 5

एक और तरीका है ...

def which(lst, p): 
    return len([1 for el in lst if p > el]) 

lst = [100, 300, 500, 800, 1000] 
which(lst, 2) 
which(lst, 101) 
which(lst, 1001) 

Answer 6

यह वास्तव में काफी भयानक है। बिना एक आवश्यकता नहीं hardcoding है, इसे इस तरह लिखा जाना चाहिए किया गया है:

if p <= 100: 
    return 0 
elif p <= 300: 
    return 1 
elif p <= 500: 
    return 2 
elif p <= 800: 
    return 3 
elif p <= 1000: 
    return 4 
else: 
    return 5 

यहाँ कोई hardcodings आवश्यकता को पूरा के साथ एक देखने समारोह, दोनों रैखिक बनाने और द्विआधारी खोज का उपयोग कर, के उदाहरण हैं, और एक जोड़ी दो टेबल पर सैनिटी चेक की:

def make_linear_lookup(keys, values): 
    assert sorted(keys) == keys 
    assert len(values) == len(keys) + 1 
    def f(query): 
     return values[sum(1 for key in keys if query > key)] 
    return f 

import bisect 
def make_bisect_lookup(keys, values): 
    assert sorted(keys) == keys 
    assert len(values) == len(keys) + 1 
    def f(query): 
     return values[bisect.bisect_left(keys, query)] 
    return f