एक मान के खिलाफ कई चर का परीक्षण कैसे करें?

Question

मैं एक ऐसा फंक्शन बनाने की कोशिश कर रहा हूं, जिसमें कई वेरिएबल्स की तुलना एक पूर्णांक से हो और तीन अक्षरों का एक स्ट्रिंग आउटपुट हो। मैं सोच रहा था कि क्या पायथन में इसका अनुवाद करने का कोई तरीका है। तो कहो:

x = 0
y = 1
z = 3
mylist = []

if x or y or z == 0 :
    mylist.append("c")
if x or y or z == 1 :
    mylist.append("d")
if x or y or z == 2 :
    mylist.append("e")
if x or y or z == 3 : 
    mylist.append("f")

जो की एक सूची वापस करेगा:

["c", "d", "f"]

क्या ऐसा कुछ संभव है?

Comments

1(tuple) में उपयोग करें

जब आप किसी भी / सभी तरीके से कथनों की सूची का मूल्यांकन करना चाहते हैं, तो आप any/ allकार्यों का उपयोग कर सकते हैं । उदाहरण के लिए: all([1, 2, 3, 4, False])लौट आएंगे झूठी all([True, 1, 2, 3])लौटेगा सच any([False, 0, 0, False])लौटाएगा गलत any([False, 0, True, False])लौटेगा सच

— eddd

यह प्रश्न एक बहुत लोकप्रिय डुप्लिकेट लक्ष्य है, लेकिन मुझे लगता है कि यह उस उद्देश्य के लिए उप-विषय है। ज्यादातर लोग कुछ ऐसा करने की कोशिश करते हैं if x == 0 or 1:, जो निश्चित रूप से समान है if x or y == 0:, लेकिन फिर भी नए लोगों के लिए थोड़ा भ्रमित हो सकता है। "मेरे x == 0 or 1काम क्यों नहीं हो रहा है" की सरासर मात्रा को देखते हुए ? प्रश्न, मैं इस प्रश्न का उपयोग इन प्रश्नों के लिए हमारे विहित डुप्लिकेट लक्ष्य के रूप में करना चाहूंगा ।

— अरन-फे

जब की तरह "falsey" मूल्यों की तुलना अतिरिक्त ध्यान रखना 0, 0.0या False। आप आसानी से गलत कोड लिख सकते हैं जो "सही" उत्तर देता है।

— smci

इसके विपरीत, अजगर में कई वस्तुओं के लिए एक स्ट्रिंग की तुलना

— ट्रिपल

Answer 1

आप गलतफहमी करते हैं कि बूलियन अभिव्यक्ति कैसे काम करती है; वे एक अंग्रेजी वाक्य की तरह काम नहीं करते हैं और अनुमान लगाते हैं कि आप यहां सभी नामों के लिए समान तुलना के बारे में बात कर रहे हैं। आप क्या देख रहे हैं:

if x == 1 or y == 1 or z == 1:

xऔर yअन्यथा उनका स्वयं ( Falseयदि 0, Trueअन्यथा) पर मूल्यांकन किया जाता है।

आप एक ट्यूपल के खिलाफ एक नियंत्रण परीक्षण का उपयोग कर छोटा कर सकते हैं :

if 1 in (x, y, z):

या अभी भी बेहतर:

if 1 in {x, y, z}:

का उपयोग करते हुए एकset निरंतर लागत वाली सदस्यता परीक्षण का लाभ लेने के ( inसमय की एक निश्चित राशि है जो कुछ भी बाएं हाथ लेता है संकार्य है)।

जब आप उपयोग करते हैं or, तो अजगर ऑपरेटर के प्रत्येक पक्ष को अलग-अलग अभिव्यक्तियों के रूप में देखता है । अभिव्यक्ति x or y == 1को पहले बूलियन टेस्ट के रूप में माना जाता है x, फिर यदि वह गलत है, तो अभिव्यक्ति y == 1का परीक्षण किया जाता है।

यह ऑपरेटर की पूर्वता के कारण है । orऑपरेटर की तुलना में कम पूर्वता है ==तो बाद मूल्यांकन किया जाता है, परीक्षण पहले ।

हालांकि, भले ही यह मामला नहीं था, और अभिव्यक्ति x or y or z == 1को वास्तव में (x or y or z) == 1इसके बजाय व्याख्या किया गया था , यह अभी भी वह नहीं करेगा जो आप इसे करने की अपेक्षा करते हैं।

x or y or zपहले तर्क का मूल्यांकन करेंगे जो 'सत्य' है, उदाहरण के लिए False, संख्यात्मक 0 या रिक्त नहीं ( बूलियन संदर्भ में पायथन को गलत मानते हुए विवरण के लिए बूलियन अभिव्यक्ति देखें)।

इसलिए मूल्यों के लिए x = 2; y = 1; z = 0, x or y or zसमाधान करेंगे 2, क्योंकि यह तर्कों में पहला सच जैसा मूल्य है। तब 2 == 1होगा False, भले ही y == 1होगा True।

वही उलटा पर लागू होगा; एक एकल चर के खिलाफ कई मूल्यों का परीक्षण; x == 1 or 2 or 3उन्हीं कारणों से असफल होगा। का प्रयोग करें x == 1 or x == 2 or x == 3या x in {1, 2, 3}।

Comments

मुझे setसंस्करण के लिए जाने की इतनी जल्दी नहीं होगी । Tuple बनाने और बनाने में बहुत सस्ते हैं। मेरी मशीन पर कम से कम, टुपल्स सेट की तुलना में तेज़ होते हैं जब तक कि टपल का आकार लगभग 4-8 तत्वों के आसपास न हो। यदि आपको इससे अधिक स्कैन करना है, तो एक सेट का उपयोग करें, लेकिन यदि आप 2-4 संभावनाओं में से एक आइटम की तलाश कर रहे हैं, तो एक ट्यूपल अभी भी तेज है! आप सबसे अधिक संभावना मामले के लिए व्यवस्था कर सकते हैं, तो टपल में प्रथम माना जाता है, जीत भी बड़ा है: (अपने परीक्षण timeit.timeit('0 in {seq}'.format(seq=tuple(range(9, -1, -1)))))

— SingleNegationElimination

@dequestarmappartialsetattr: पायथन 3.3 और ऊपर में, सेट को एक स्थिरांक के रूप में संग्रहीत किया जाता है, सृजन समय को पूरी तरह से दरकिनार करते हुए, सृजन समय को समाप्त करता है। ट्यूपल्स मेमोरी मंथन से बचने के लिए पाइथन कैश के रूप में उन्हें बनाने के लिए सस्ते हो सकते हैं, जिससे सेट पर सबसे बड़ा अंतर होता है।

— मार्टिन पीटर्स

@dequestarmappartialsetattr: यदि आप केवल सदस्यता परीक्षा, पूर्णांक सेट के लिए और tuples आदर्श परिदृश्य के लिए समान रूप से तेज़ हैं; पहला तत्व मिलान। उसके बाद ट्यूपल्स सेट से हट जाते हैं।

— मार्टिन पीटर्स

@MartijnPieters: setइस परीक्षण के लिए शाब्दिक संकेतन का उपयोग करना तब तक बचत नहीं है जब तक कि setशाब्दिक की सामग्री भी शाब्दिक न हो, सही? if 1 in {x, y, z}:कैश नहीं कर सकते set, क्योंकि x, yऔर zबदल सकता है, इसलिए या तो समाधान के लिए tupleया setखरोंच से निर्माण करने की आवश्यकता है , और मुझे संदेह है कि सदस्यता के लिए जांच करते समय आपको जो भी बचत बचत मिल सकती है, वह अधिक setसृजन समय से स्वाहा हो जाएगी ।

— शैडो रेंजर

@ShadowRanger: हाँ, peephole ऑप्टिमाइज़ेशन (इसके लिए in [...]या in {...}) केवल तभी काम करता है जब सूची या सेट की सामग्री अपरिवर्तनीय भी हो।

— मार्टिन पीटर्स

Answer 2

आपकी समस्या अधिक आसानी से एक शब्दकोश संरचना के साथ संबोधित की जाती है जैसे:

x = 0
y = 1
z = 3
d = {0: 'c', 1:'d', 2:'e', 3:'f'}
mylist = [d[k] for k in [x, y, z]]

Comments

या यहां तक d = "cdef"कि होता हैMyList = ["cdef"[k] for k in [x, y, z]]

— arager

याmap(lambda i: 'cdef'[i], [x, y, z])

— डान्सल्मो

@MJM आउटपुट ऑर्डर तानाशाह द्वारा निर्धारित नहीं किया जाता है, यह सूची के क्रम से निर्धारित होता है[x, y, z]

— dansalmo

सूची की समझ से अलग जो मैं अभी तक पूरी तरह से आदी नहीं हूँ, हम में से अधिकांश का एक ही पलटा था: उस तानाशाह का निर्माण!

— लोनवंडर

Answer 3

जैसा कि मार्टिज़न पीटर ने कहा, सही और सबसे तेज़, प्रारूप है:

if 1 in {x, y, z}:

उनकी सलाह का उपयोग करते हुए अब आप अलग-अलग बयान देंगे ताकि पायथन प्रत्येक कथन को पढ़ेगा कि क्या पूर्व थे Trueया नहीं False। जैसे कि:

if 0 in {x, y, z}:
    mylist.append("c")
if 1 in {x, y, z}:
    mylist.append("d")
if 2 in {x, y, z}:
    mylist.append("e")
...

यह काम करेगा, लेकिन यदि आप शब्दकोशों का उपयोग करके सहज हैं (देखें कि मैंने वहां क्या किया था), तो आप एक प्रारंभिक शब्दकोश को अपने द्वारा वांछित अक्षरों की संख्याओं की मैपिंग करके साफ कर सकते हैं, फिर बस एक फॉर-लूप का उपयोग करके:

num_to_letters = {0: "c", 1: "d", 2: "e", 3: "f"}
for number in num_to_letters:
    if number in {x, y, z}:
        mylist.append(num_to_letters[number])

Answer 4

लिखने x or y or z == 0का सीधा तरीका है

if any(map((lambda value: value == 0), (x,y,z))):
    pass # write your logic.

लेकिन मुझे नहीं लगता, आपको यह पसंद है। :) और यह तरीका बदसूरत है।

दूसरा तरीका (एक बेहतर) है:

0 in (x, y, z)

BTW बहुत सारे ifइस तरह से लिखे जा सकते हैं

my_cases = {
    0: Mylist.append("c"),
    1: Mylist.append("d")
    # ..
}

for key in my_cases:
    if key in (x,y,z):
        my_cases[key]()
        break

Comments

dictकुंजी के बजाय आपके उदाहरण में , आपको त्रुटियां मिलेंगी क्योंकि रिटर्न का मूल्य .appendहै None, और कॉलिंग ए Noneदेता है AttributeError। सामान्य तौर पर मैं इस पद्धति से सहमत हूं, हालांकि।

— सेठमोर्टन 20

कुंजी के बजाय तानाशाही गलत है, आपको Mylist = ['c', 'd'] मिलेगा, जब शब्दकोश आरंभ हो जाएगा, भले ही आपने "for..loop" भाग के लिए टिप्पणी की हो

— Mahmoud Elshahat

आपके पहले उदाहरण filterसे बेहतर होगा map, क्योंकि यह केवल उन उदाहरणों को लौटाएगा जहां लंबोदर सच का मूल्यांकन करता है

— एलेक्स

लैम्ब्डा के नक्शे की तुलना में एक समझ बहुत सरल है:any(v == 0 for v in (x, y, z))

— vjandrea

Answer 5

यदि आप बहुत आलसी हैं, तो आप मूल्यों को एक सरणी के अंदर रख सकते हैं। जैसे कि

list = []
list.append(x)
list.append(y)
list.append(z)
nums = [add numbers here]
letters = [add corresponding letters here]
for index in range(len(nums)):
    for obj in list:
        if obj == num[index]:
            MyList.append(letters[index])
            break

आप संख्याओं और अक्षरों को एक शब्दकोष में भी रख सकते हैं और कर सकते हैं, लेकिन यह शायद एक बहुत ही सरल है यदि बयानों की तुलना में। कि आप अतिरिक्त आलसी होने की कोशिश के लिए क्या मिलता है :)

एक बात और, आपकी

if x or y or z == 0:

संकलन करेगा, लेकिन उस तरीके से नहीं जैसा आप चाहते हैं। जब आप एक if स्टेटमेंट (उदाहरण) में वेरिएबल डालते हैं

if b

प्रोग्राम जाँच करेगा कि क्या चर शून्य नहीं है। उपरोक्त कथन लिखने का एक और तरीका है (जो अधिक समझ में आता है)

if bool(b)

बूल अजगर में एक इनबिल्ट फंक्शन है जो मूल रूप से बूलियन स्टेटमेंट को सत्यापित करने की आज्ञा देता है (यदि आप नहीं जानते कि वह क्या है, तो यह वही है जिसे आप अपने स्टेटमेंट में अभी बनाने की कोशिश कर रहे हैं :))

एक और आलसी तरीका है जो मैंने पाया है:

if any([x==0, y==0, z==0])

Comments

-1 यहाँ बहुत बुरा अभ्यास है। listपायथन बिलियन है; xyzउदाहरण के लिए , इसके बजाय किसी अन्य नाम का उपयोग करें । जब आप एक कर सकते हैं, तो आप चार चरणों में सूची का निर्माण क्यों करते हैं xyz = [x, y, z]? समानांतर सूचियों का उपयोग न करें, इसके बजाय एक तानाशाही का उपयोग करें। कुल मिलाकर, यह समाधान थैगुयुरसेल की तुलना में बहुत अधिक जटिल है । इसके अलावा पिछले भाग के लिए, एक समझ क्यों नहीं है, यानी any(v == 0 for v in (x, y, z))? पाइथन में भी एरेज़ कुछ और हैं।

— wjandrea

Answer 6

यह जाँचने के लिए कि क्या कोई मान चर के सेट के भीतर निहित है, आप इनबिल्ट मॉड्यूल itertoolsऔर का उपयोग कर सकते हैं operator।

उदाहरण के लिए:

आयात:

from itertools import repeat
from operator import contains

घोषित चर:

x = 0
y = 1
z = 3

मानों की मैपिंग बनाएं (जिस क्रम में आप जांचना चाहते हैं):

check_values = (0, 1, 3)

उपयोग itertoolsचर की पुनरावृत्ति की अनुमति देने के लिए :

check_vars = repeat((x, y, z))

अंत में, mapइट्रेटर बनाने के लिए फ़ंक्शन का उपयोग करें :

checker = map(contains, check_vars, check_values)

फिर, मूल्यों की जाँच करते समय (मूल क्रम में), उपयोग करें next():

if next(checker)  # Checks for 0
    # Do something
    pass
elif next(checker)  # Checks for 1
    # Do something
    pass

आदि...

इसमें इनबिल्ट मॉड्यूल lambda x: x in (variables)होने की वजह से एक फायदा operatorहै और यह उपयोग करने की तुलना में तेज़ और अधिक कुशल हैlambda जिससे एक कस्टम इन-प्लेस फ़ंक्शन बनाना पड़ता है।

सूची में गैर-शून्य (या गलत) मान होने पर जाँचने का दूसरा विकल्प:

not (x and y and z)

समतुल्य:

not all((x, y, z))

Comments

यह ओपी के सवाल का जवाब नहीं देता है। यह केवल दिए गए उदाहरण में पहले मामले को शामिल करता है।

— दीवारर

Answer 7

सेट यहां अच्छा दृष्टिकोण है, क्योंकि यह चर का आदेश देता है, यहां आपका लक्ष्य क्या है। {z,y,x}है {0,1,3}जो कुछ मापदंडों के आदेश।

>>> ["cdef"[i] for i in {z,x,y}]
['c', 'd', 'f']

इस तरह, संपूर्ण समाधान O (n) है।

Comments

आपको एक विवरण जोड़ना चाहिए कि आपका कोड क्या करता है और यह कैसे करता है। केवल कोड का उपयोग करते हुए संक्षिप्त उत्तर हतोत्साहित किया जाता है

— रानिज

Answer 8

यहाँ दिए गए सभी उत्कृष्ट उत्तर मूल पोस्टर की विशिष्ट आवश्यकता पर ध्यान केंद्रित करते if 1 in {x,y,z}हैं और मार्टिज़न पीटर द्वारा आगे रखे गए समाधान पर ध्यान केंद्रित करते हैं।
वे जिस चीज को नजरअंदाज करते हैं, वह प्रश्न का व्यापक निहितार्थ है:
मैं एक मान को कई मानों के खिलाफ कैसे परख सकता हूं?
यदि प्रदान किया गया समाधान आंशिक हिट के लिए काम नहीं करेगा यदि उदाहरण के लिए स्ट्रिंग्स का उपयोग करें:
टेस्ट करें यदि स्ट्रिंग "वाइल्ड" कई मूल्यों में है

>>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in {x, y, z}: print (True)
... 

या

>>> x = "Wild things"
>>> y = "throttle it back"
>>> z = "in the beginning"
>>> if "Wild" in [x, y, z]: print (True)
... 

इस परिदृश्य के लिए एक स्ट्रिंग में परिवर्तित करना सबसे आसान है

>>> [x, y, z]
['Wild things', 'throttle it back', 'in the beginning']
>>> {x, y, z}
{'in the beginning', 'throttle it back', 'Wild things'}
>>> 

>>> if "Wild" in str([x, y, z]): print (True)
... 
True
>>> if "Wild" in str({x, y, z}): print (True)
... 
True

हालांकि, यह ध्यान दिया जाना चाहिए, जैसा @codeforesterकि इस शब्द में बताया गया है , शब्द सीमाएं इस विधि से खो जाती हैं, जैसे कि:

>>> x=['Wild things', 'throttle it back', 'in the beginning']
>>> if "rot" in str(x): print(True)
... 
True

3 अक्षर rotसूची में संयोजन में मौजूद हैं, लेकिन एक व्यक्तिगत शब्द के रूप में नहीं। "सड़ांध" के लिए परीक्षण विफल हो जाएगा, लेकिन अगर सूची में से एक आइटम "नरक में सड़ांध" थे, तो यह भी विफल हो जाएगा।
इस पद्धति का उपयोग करने पर अपने खोज मानदंड से सावधान रहें, और ध्यान रखें कि इसमें यह सीमा है।

Answer 9

मुझे लगता है कि यह इसे बेहतर तरीके से हैंडल करेगा:

my_dict = {0: "c", 1: "d", 2: "e", 3: "f"}

def validate(x, y, z):
    for ele in [x, y, z]:
        if ele in my_dict.keys():
            return my_dict[ele]

आउटपुट:

print validate(0, 8, 9)
c
print validate(9, 8, 9)
None
print validate(9, 8, 2)
e

Answer 10

यदि आप उपयोग करना चाहते हैं तो, निम्नलिखित कथनों का एक और समाधान है:

myList = []
aList = [0, 1, 3]

for l in aList:
    if l==0: myList.append('c')
    elif l==1: myList.append('d')
    elif l==2: myList.append('e')
    elif l==3: myList.append('f')

print(myList)

Answer 11

d = {0:'c', 1:'d', 2:'e', 3: 'f'}
x, y, z = (0, 1, 3)
print [v for (k,v) in d.items() if x==k or y==k or z==k]

Answer 12

यह कोड मददगार हो सकता है

L ={x, y, z}
T= ((0,"c"),(1,"d"),(2,"e"),(3,"f"),)
List2=[]
for t in T :
if t[0] in L :
    List2.append(t[1])
    break;

Answer 13

आप नीचे दिखाए गए तरीके को आजमा सकते हैं। इस पद्धति में, आपको उन चरों की संख्या निर्दिष्ट करने / इनपुट करने की स्वतंत्रता होगी जो आप दर्ज करना चाहते हैं।

mydict = {0:"c", 1:"d", 2:"e", 3:"f"}
mylist= []

num_var = int(raw_input("How many variables? ")) #Enter 3 when asked for input.

for i in range(num_var): 
    ''' Enter 0 as first input, 1 as second input and 3 as third input.'''
    globals()['var'+str('i').zfill(3)] = int(raw_input("Enter an integer between 0 and 3 "))
    mylist += mydict[globals()['var'+str('i').zfill(3)]]

print mylist
>>> ['c', 'd', 'f']

Answer 14

एक पंक्ति समाधान:

mylist = [{0: 'c', 1: 'd', 2: 'e', 3: 'f'}[i] for i in [0, 1, 2, 3] if i in (x, y, z)]

या:

mylist = ['cdef'[i] for i in range(4) if i in (x, y, z)]

Answer 15

हो सकता है कि आपको आउटपुट बिट सेट के लिए प्रत्यक्ष सूत्र की आवश्यकता हो।

x=0 or y=0 or z=0   is equivalent to x*y*z = 0

x=1 or y=1 or z=1   is equivalent to (x-1)*(y-1)*(z-1)=0

x=2 or y=2 or z=2   is equivalent to (x-2)*(y-2)*(z-2)=0

बिट्स के लिए मैप करें: 'c':1 'd':0xb10 'e':0xb100 'f':0xb1000

Isc का संबंध ('c' है):

if xyz=0 then isc=1 else isc=0

अगर सूत्र है तो गणित का उपयोग करें https://youtu.be/KAdKCgBGK0k?list=PLnI9xbPdZUAmUL8htSl6vToPQRRN3hhFp&t3/315

[सी]: (xyz=0 and isc=1) or (((xyz=0 and isc=1) or (isc=0)) and (isc=0))

[घ]: ((x-1)(y-1)(z-1)=0 and isc=2) or (((xyz=0 and isd=2) or (isc=0)) and (isc=0))

...

निम्न सूत्र द्वारा इन सूत्रों को कनेक्ट करें:

• तर्क and समीकरणों के वर्गों का योग है
• तर्क orसमीकरणों की उपज है

और आपके पास कुल समीकरण एक्सप्रेस राशि होगी और आपके पास योग का कुल फॉर्मूला होगा

तब योग और 1 है c, योग और 2 है d, योग और 4 है e, योग और 5 है च

इसके बाद आप पूर्वनिर्धारित सरणी बना सकते हैं जहां स्ट्रिंग तत्वों का सूचकांक तैयार स्ट्रिंग के अनुरूप होगा।

array[sum] आपको तार देता है।

Answer 16

इसे आसानी से किया जा सकता है

for value in [var1,var2,var3]:
     li.append("targetValue")

Answer 17

पायथन में अपने छद्म कोड का प्रतिनिधित्व करने का सबसे मुम्मिक तरीका होगा:

x = 0
y = 1
z = 3
mylist = []

if any(v == 0 for v in (x, y, z)):
    mylist.append("c")
if any(v == 1 for v in (x, y, z)):
    mylist.append("d")
if any(v == 2 for v in (x, y, z)):
    mylist.append("e")
if any(v == 3 for v in (x, y, z)):
    mylist.append("f")

Comments

यह दृष्टिकोण `की तुलना में अधिक सार्वभौमिक है यदि 2 में (एक्स, वाई, जेड): mylist.append ('ई')` क्योंकि मनमाना तुलना (जैसे if any(v >= 42 for v in (x, y, z)):) की अनुमति देता है । और यह सब 3 तरीकों के प्रदर्शन ( 2 in {x,y,z}, 2 in (x,y,z), any(_v == 2 for _v in (x,y,z))) CPython3.6 में लगभग एक ही प्रतीत हो रहा है (देखें सार )

— imposeren

Answer 18

एक एकल मान के साथ कई चर का परीक्षण करने के लिए: if 1 in {a,b,c}:

एक चर के साथ कई मूल्यों का परीक्षण करने के लिए: if a in {1, 2, 3}:

Answer 19

ऐसा लगता है कि आप सीज़र सिफर का निर्माण कर रहे हैं।

एक बहुत अधिक सामान्यीकृत दृष्टिकोण यह है:

input_values = (0, 1, 3)
origo = ord('c')
[chr(val + origo) for val in inputs]

आउटपुट

['c', 'd', 'f']

सुनिश्चित नहीं है कि यह आपके कोड का एक वांछित दुष्प्रभाव है, लेकिन आपके आउटपुट का क्रम हमेशा क्रमबद्ध होगा।

यदि आप यही चाहते हैं, तो अंतिम पंक्ति को बदल दिया जा सकता है:

sorted([chr(val + origo) for val in inputs])

Answer 20

आप शब्दकोश का उपयोग कर सकते हैं:

x = 0
y = 1
z = 3
list=[]
dict = {0: 'c', 1: 'd', 2: 'e', 3: 'f'}
if x in dict:
    list.append(dict[x])
else:
    pass

if y in dict:
    list.append(dict[y])
else:
    pass
if z in dict:
    list.append(dict[z])
else:
    pass

print list

Comments

यह एक बार फिर ऐसा ही हो सकता है। सेट?

— सर्गेई

Answer 21

तानाशाही के बिना, इस समाधान की कोशिश करें:

x, y, z = 0, 1, 3    
offset = ord('c')
[chr(i + offset) for i in (x,y,z)]

और देता है:

['c', 'd', 'f']

Answer 22

इससे आपको मदद मिलेगी।

def test_fun(val):
    x = 0
    y = 1
    z = 2
    myList = []
    if val in (x, y, z) and val == 0:
        myList.append("C")
    if val in (x, y, z) and val == 1:
        myList.append("D")
    if val in (x, y, z) and val == 2:
        myList.append("E")

test_fun(2);

Answer 23

आप इसे एकजुट कर सकते हैं

x = 0
y = 1
z = 3

एक चर में।

In [1]: xyz = (0,1,3,) 
In [2]: mylist = []

हमारी शर्तों को इस प्रकार बदलें:

In [3]: if 0 in xyz: 
    ...:     mylist.append("c") 
    ...: if 1 in xyz: 
    ...:     mylist.append("d") 
    ...: if 2 in xyz: 
    ...:     mylist.append("e") 
    ...: if 3 in xyz:  
    ...:     mylist.append("f") 

आउटपुट:

In [21]: mylist                                                                                
Out[21]: ['c', 'd', 'f']

Answer 24

मुसीबत

जबकि कई मूल्यों के परीक्षण के लिए पैटर्न

>>> 2 in {1, 2, 3}
True
>>> 5 in {1, 2, 3}
False

बहुत पठनीय है और कई परिस्थितियों में काम कर रहा है, एक नुकसान है:

>>> 0 in {True, False}
True

लेकिन हम चाहते हैं

>>> (0 is True) or (0 is False)
False

समाधान

पिछली अभिव्यक्ति का एक सामान्यीकरण ytpillai के उत्तर पर आधारित है :

>>> any([0 is True, 0 is False])
False

जो के रूप में लिखा जा सकता है

>>> any(0 is item for item in (True, False))
False

हालांकि यह अभिव्यक्ति सही परिणाम देती है लेकिन यह पहली अभिव्यक्ति के रूप में पठनीय नहीं है :-(