python - पायथन में 'और'(बूलियन) बनाम 'और'(bitwise) के बीच का अंतर। सूचियों बनाम numpy arrays के साथ व्यवहार में अंतर क्यों?




bit-manipulation boolean-expression (5)

list बारे में

सबसे पहले एक बहुत ही महत्वपूर्ण बात, जिसमें से सब कुछ पालन करेंगे (मुझे उम्मीद है)।

सामान्य पायथन में, list किसी भी तरह से विशेष नहीं है (निर्माण के लिए प्यारा वाक्यविन्यास को छोड़कर, जो ज्यादातर ऐतिहासिक दुर्घटना है)। एक बार सूची [3,2,6] बनने के बाद, यह सभी उद्देश्यों और उद्देश्यों के लिए केवल एक सामान्य पायथन वस्तु है, जैसे कि संख्या 3 , सेट {3,7} , या फ़ंक्शन lambda x: x+5

(हां, यह अपने तत्वों को बदलने का समर्थन करता है, और यह पुनरावृत्ति का समर्थन करता है, और कई अन्य चीजें हैं, लेकिन यह वही है जो एक प्रकार है: यह कुछ संचालन का समर्थन करता है, जबकि कुछ दूसरों का समर्थन नहीं करता है। Int शक्ति को बढ़ाने में सहायता करता है, लेकिन यह नहीं करता है इसे बहुत खास बनाएं - यह सिर्फ एक चीज है। लैम्ब्डा कॉलिंग का समर्थन करता है, लेकिन इससे यह बहुत खास नहीं होता है - यह सब के बाद लैम्ब्डा है :)।

के बारे में and

and एक ऑपरेटर नहीं है (आप इसे "ऑपरेटर" कह सकते हैं, लेकिन आप एक ऑपरेटर के लिए भी "कॉल" कर सकते हैं :)। पाइथन में ऑपरेटर (प्रकार के माध्यम से) कुछ प्रकार की वस्तुओं पर बुलाए जाते हैं, आमतौर पर उस प्रकार के हिस्से के रूप में लिखे जाते हैं। अपने कुछ ऑपरेटरों के मूल्यांकन को पकड़ने के लिए कोई तरीका नहीं है, लेकिन ऐसा कर सकता है (और चाहिए)।

इसका नतीजा यह है कि इसे ओवरलोड नहीं किया जा सकता है, जैसे अधिभारित नहीं किया जा सकता है। यह पूरी तरह से सामान्य है, और एक निर्दिष्ट प्रोटोकॉल के माध्यम से संचार करता है। आप प्रोटोकॉल के अपने हिस्से को कस्टमाइज़ कर सकते हैं, लेकिन इसका मतलब यह नहीं है कि आप व्यवहार and पूरी तरह से बदल सकते हैं। प्रोटोकॉल है:

"ए और बी" की व्याख्या करने वाले पायथन की कल्पना करें (यह सचमुच इस तरह से नहीं होता है, लेकिन यह समझने में मदद करता है)। जब "और" की बात आती है, तो यह उस वस्तु को देखती है जिस पर उसने अभी मूल्यांकन किया है (ए), और पूछता है: क्या आप सच हैं? ( नहीं : क्या आप True ?) यदि आप किसी वर्ग के लेखक हैं, तो आप इस उत्तर को कस्टमाइज़ कर सकते हैं। यदि a जवाब "नहीं" है, and (पूरी तरह से स्किप्स करता है, तो इसका मूल्यांकन नहीं किया जाता है) और कहता है: मेरा परिणाम है ( नहीं : गलत मेरा परिणाम है)।

अगर कोई जवाब नहीं देता है, and पूछता है: आपकी लंबाई क्या है? (फिर से, आप इसे a वर्ग के लेखक के रूप में अनुकूलित कर सकते हैं)। यदि उत्तर 0 है, and उपर्युक्त जैसा ही करता है - इसे झूठा मानता है (झूठा नहीं ), बी छोड़ देता है, और परिणाम देता a

यदि दूसरे प्रश्न के लिए 0 से कुछ अन्य उत्तर ("आपकी लंबाई क्या है"), या यह बिल्कुल जवाब नहीं देता है, या यह पहले "(" क्या आप सच हैं ") का जवाब देते हैं, and बी का मूल्यांकन करते हैं , और कहता है: b मेरा परिणाम है। ध्यान दें कि यह किसी भी प्रश्न नहीं पूछता है।

यह सब कहने का दूसरा तरीका यह है कि a and b लगभग a and b के समान ही b if a else a , b if a else a को मूल्यांकन किया जाता है, तो केवल एक बार मूल्यांकन किया जाता है।

अब कलम और पेपर के साथ कुछ मिनट बैठें, और खुद को यह समझें कि जब {ए, बी} {ट्रू, गलत} का सबसेट होता है, तो यह ठीक उसी तरह काम करता है जब आप बूलियन ऑपरेटर की अपेक्षा करेंगे। लेकिन मुझे उम्मीद है कि मैंने आपको विश्वास दिलाया है कि यह अधिक सामान्य है, और जैसा कि आप देखेंगे, इस तरह से और अधिक उपयोगी।

उन दोनों को एक साथ रखो

अब मुझे उम्मीद है कि आप अपना उदाहरण समझ लेंगे 1. and मेरी परवाह नहीं है कि मेरी सूची 1 एक संख्या, सूची, लैम्ब्डा या क्लास Argmhbl का ऑब्जेक्ट है। यह सिर्फ प्रोटोकॉल के सवालों के जवाब में mylist1 के जवाब की परवाह करता है। और निश्चित रूप से, mylist1 लंबाई के बारे में प्रश्न के 5 उत्तर देता है, और मेरी सूची 2 देता है। और बस। इसमें mylist1 और mylist2 के तत्वों के साथ कुछ लेना देना नहीं है - वे कहीं भी तस्वीर दर्ज नहीं करते हैं।

दूसरा उदाहरण: & list

दूसरी ओर, & किसी अन्य की तरह एक ऑपरेटर है, उदाहरण के लिए + । इसे उस वर्ग पर एक विशेष विधि को परिभाषित करके एक प्रकार के लिए परिभाषित किया जा सकता है। int इसे बिटवाई के रूप में परिभाषित करता है "और", और बूल इसे तार्किक "और" के रूप में परिभाषित करता है, लेकिन यह केवल एक विकल्प है: उदाहरण के लिए, सेट और कुछ अन्य ऑब्जेक्ट्स जैसे कि रॉब कुंजी दृश्य इसे एक सेट चौराहे के रूप में परिभाषित करते हैं। list सिर्फ इसे परिभाषित नहीं करती है, शायद इसलिए कि गिडो ने इसे परिभाषित करने के किसी भी स्पष्ट तरीके से नहीं सोचा था।

numpy

दूसरे पैर पर:-डी, numpy arrays विशेष हैं, या कम से कम वे होने की कोशिश कर रहे हैं। बेशक, numpy.array सिर्फ एक वर्ग है, यह ओवरराइड नहीं कर सकता है and किसी भी तरह से, तो यह अगली सबसे अच्छी बात करता है: जब पूछा गया कि "क्या आप सच हैं", numpy.array एक ValueError उठाता है, प्रभावी रूप से कह रहा है "कृपया सवाल दोबारा दोहराएं, सच्चाई का मेरा विचार आपके मॉडल में फिट नहीं है "। (ध्यान दें कि ValueError संदेश के बारे में बात नहीं करता है and - क्योंकि numpy.array नहीं जानता कि यह कौन पूछ रहा है; यह सिर्फ सत्य के बारे में बोलता है।)

के लिए, यह पूरी तरह से अलग कहानी है। numpy.array इसे परिभाषित कर सकता है जैसा कि यह चाहता है, और यह अन्य ऑपरेटरों के साथ लगातार & परिभाषित करता है: बिंदुवार। तो अंततः आप जो चाहते हैं उसे प्राप्त करें।

HTH,

सूचि बनाम numpy.arrays पर बुलियन और bitwise संचालन के व्यवहार में अंतर क्या बताता है?

मैं निम्नलिखित सरल उदाहरणों में चित्रित ' & ' बनाम ' and ' पायथन में उचित उपयोग के बारे में उलझन में हूं।

    mylist1 = [True,  True,  True,  False,  True]
    mylist2 = [False, True, False,  True, False]  

    >>> len(mylist1) == len(mylist2)
    True

    # ---- Example 1 ----
    >>>mylist1 and mylist2 
    [False, True, False, True, False]
    #I am confused: I would have expected [False, True, False, False, False]

    # ---- Example 2 ----
    >>>mylist1 & mylist2 
    *** TypeError: unsupported operand type(s) for &: 'list' and 'list'
    #I am confused: Why not just like example 1? 

    # ---- Example 3 ----
    >>>import numpy as np

    >>> np.array(mylist1) and np.array(mylist2) 
    *** ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
    #I am confused: Why not just like Example 4? 

     # ---- Example 4 ----
    >>> np.array(mylist1) & np.array(mylist2) 
    array([False,  True, False, False, False], dtype=bool)
    #This is the output I was expecting! 

यह answer , और इस answer दोनों ने मुझे यह समझने में मदद की कि 'and' एक बूलियन ऑपरेशन है लेकिन '&' थोड़ा सा ऑपरेशन है।

मैं reading की अवधारणा को बेहतर ढंग से समझने के लिए कुछ जानकारी reading रहा था, लेकिन मैं अपने उपरोक्त 4 उदाहरणों को समझने के लिए उस जानकारी का उपयोग करने के लिए संघर्ष कर रहा हूं।

नोट, मेरी विशेष स्थिति में, मेरा वांछित आउटपुट एक नई सूची है जहां:

    len(newlist) == len(mylist1) 
    newlist[i] == (mylist1[i] and mylist2[i]) #for every element of newlist

उदाहरण 4, ऊपर, मुझे मेरे वांछित आउटपुट के लिए नेतृत्व किया, तो यह ठीक है।

लेकिन मुझे इस बारे में भ्रमित महसूस हो रहा है कि मुझे / कैसे / क्यों 'और' बनाम 'और' का उपयोग करना चाहिए। इन ऑपरेटरों के साथ सूचियों और numpy arrays अलग तरीके से व्यवहार क्यों करते हैं?

क्या कोई मुझे बुलियन और बिटवाई ऑपरेशंस के बीच अंतर को समझने में मदद कर सकता है ताकि वे सूचियों और numpy.arrays अलग-अलग संभाल क्यों न करें?

मैं बस यह सुनिश्चित करना चाहता हूं कि मैं आगे बढ़ने के लिए इन परिचालनों का उपयोग करना जारी रखूंगा। सहायता के लिए बहुत - बहुत धन्यवाद!

Numpy version 1.7.1

python 2.7

References all inline with text.

संपादन

1) धन्यवाद @ डेलन ने यह इंगित करने के लिए कि मेरे मूल उदाहरणों में मुझे अस्पष्टता थी जो मेरे गहरे भ्रम को मास्क कर रहा था। मैंने अपने प्रश्नों को स्पष्ट करने के लिए अपने उदाहरण अपडेट किए हैं।


  1. पायथन में X and Y की एक अभिव्यक्ति X and Y देता है, bool(X) == True या X या Y का कोई भी गलत मूल्यांकन करता है, उदाहरण के लिए:

    True and 20 
    >>> 20
    
    False and 20
    >>> False
    
    20 and []
    >>> []
    
  2. बिटवाई ऑपरेटर को सूचियों के लिए परिभाषित नहीं किया गया है। लेकिन यह पूर्णांक के लिए परिभाषित किया गया है - संख्याओं के बाइनरी प्रतिनिधित्व पर परिचालन। 16 (01000) और 31 (11111) पर विचार करें:

    16 & 31
    >>> 16
    
  3. NumPy एक मानसिक नहीं है, यह नहीं जानता, चाहे आप का मतलब है कि उदाहरण के लिए [False, False] एक तार्किक अभिव्यक्ति में True बराबर होना चाहिए। इसमें यह एक मानक पायथन व्यवहार को ओवरराइड करता है, जो है: " len(collection) == 0 साथ कोई खाली संग्रह False "।

  4. शायद NumPy के सरणी और ऑपरेटर का एक अपेक्षित व्यवहार।


शॉर्ट-सर्किटिंग बूलियन ऑपरेटर ( and , or ) को ओवरराइड नहीं किया जा सकता है क्योंकि नई भाषा सुविधाओं को शुरू किए बिना या शॉर्ट सर्किट का त्याग किए बिना ऐसा करने का कोई संतोषजनक तरीका नहीं है। जैसा कि आप जानते हैं या नहीं जानते हैं, वे अपने सच्चे मूल्य के लिए पहले ऑपरेंड का मूल्यांकन करते हैं, और उस मूल्य के आधार पर, या तो दूसरे तर्क का मूल्यांकन और वापसी करते हैं, या दूसरे तर्क का मूल्यांकन नहीं करते हैं और पहले वापस आते हैं:

something_true and x -> x
something_false and x -> something_false
something_true or x -> something_true
something_false or x -> x

ध्यान दें कि (वास्तविक मूल्यांकन का मूल्यांकन करने का परिणाम) वापस आ गया है, सत्य मूल्य नहीं।

उनके व्यवहार को अनुकूलित करने का एकमात्र तरीका __nonzero__ (जिसे पायथन 3 में __bool__ में बदला गया है) को ओवरराइड __nonzero__ , ताकि आप प्रभावित कर सकें कि कौन सा ऑपरेंड वापस आ गया है, लेकिन कुछ अलग नहीं लौटाता है। सूची (और अन्य संग्रह) को "सच्चाई" माना जाता है जब उनमें कुछ भी शामिल होता है, और जब वे खाली होते हैं तो "झूठी" होती है।

NumPy arrays उस धारणा को अस्वीकार करते हैं: उपयोग के मामलों के लिए उनका लक्ष्य है, सत्य के दो अलग-अलग विचार सामान्य हैं: (1) क्या कोई तत्व सत्य है, और (2) क्या सभी तत्व सत्य हैं। चूंकि ये दोनों पूरी तरह से (और चुपचाप) असंगत हैं, और न तो स्पष्ट रूप से अधिक सही या अधिक आम है, NumPy अनुमान लगाने से इंकार कर देता है और आपको स्पष्ट रूप से उपयोग करने की आवश्यकता होती है .any() या .all()

और | (और not , वैसे भी) पूरी तरह से अतिरंजित हो सकता है, क्योंकि वे शॉर्ट सर्किट नहीं करते हैं। जब वे अतिसंवेदनशील होते हैं तो वे कुछ भी वापस कर सकते हैं, और न्यूमपी तत्व-वार ऑपरेशंस करने के लिए इसका अच्छा उपयोग करता है, क्योंकि वे व्यावहारिक रूप से किसी भी अन्य स्केलर ऑपरेशन के साथ करते हैं। दूसरी तरफ, सूचियां अपने तत्वों में संचालन प्रसारित नहीं करती हैं। जैसे ही mylist1 - mylist2 का कोई मतलब नहीं है और mylist1 + mylist2 अर्थ कुछ अलग है, सूचियों के लिए कोई & ऑपरेटर नहीं है।


Django के दस्तावेज़ पर पहले उदाहरण और आधार के लिए
यह हमेशा दूसरी सूची लौटाएगा, वास्तव में एक खाली सूची पाइथन के लिए एक सही मान के रूप में दिखाई देगी, इस प्रकार पाइथन 'अंतिम' सही मान वापस कर देता है ताकि दूसरी सूची

In [74]: mylist1 = [False]
In [75]: mylist2 = [False, True, False,  True, False]
In [76]: mylist1 and mylist2
Out[76]: [False, True, False, True, False]
In [77]: mylist2 and mylist1
Out[77]: [False]

उदाहरण 1:

इस प्रकार ऑपरेटर काम करता है।

एक्स और वाई => यदि एक्स झूठा है, तो एक्स , और वाई

तो दूसरे शब्दों में, चूंकि mylist1 False नहीं है, अभिव्यक्ति का परिणाम mylist2 । (केवल खाली सूचियों का मूल्यांकन False ।)

उदाहरण 2:

जैसा कि आप उल्लेख करते हैं, & ऑपरेटर थोड़ा सा है और। बिटवाई ऑपरेशंस केवल संख्याओं पर काम करते हैं। और बी का परिणाम बिट्स में 1s से बना एक संख्या है जो और बी दोनों में से 1 है। उदाहरण के लिए:

>>> 3 & 1
1

यह देखना आसान है कि बाइनरी शाब्दिक (उपरोक्त के समान संख्या) का उपयोग करके क्या हो रहा है:

>>> 0b0011 & 0b0001
0b0001

बिटवाईर ऑपरेशंस बूलियन (सच्चाई) संचालन के अवधारणा में समान हैं, लेकिन वे केवल बिट्स पर काम करते हैं।

तो, मेरी कार के बारे में कुछ बयान दिया

  1. मेरी कार लाल है
  2. मेरी कार में पहियों हैं

इन दो बयानों का तार्किक "और" है:

(क्या मेरी कार लाल है?) और (क्या कार में पहियों हैं?) => गलत मूल्य के तार्किक सत्य

जिनमें से दोनों मेरी कार के लिए कम से कम सच हैं। तो पूरी तरह से बयान का मूल्य तार्किक रूप से सच है।

इन दो बयानों में से थोड़ा सा "और" थोड़ा और अधिक घबराहट है:

(कथन का अंकीय मूल्य 'मेरी कार लाल है') और ('मेरी कार में पहियों' कथन का संख्यात्मक मूल्य) => संख्या

यदि पायथन जानता है कि कथन को संख्यात्मक मानों में कैसे परिवर्तित किया जाए, तो यह ऐसा करेगा और बिटव्यू-और दो मानों की गणना करेगा। यह आपको विश्वास करने के लिए नेतृत्व कर सकता है & इसके साथ विचलित है and , लेकिन उपर्युक्त उदाहरण के साथ वे अलग-अलग चीजें हैं। साथ ही, उन ऑब्जेक्ट्स के लिए जिन्हें कनवर्ट नहीं किया जा सकता है, आपको बस TypeError मिल जाएगा।

उदाहरण 3 और 4:

अजीब एरे के लिए अंकगणितीय परिचालन लागू करता है:

अंकगणित पर अंकगणितीय और तुलना संचालन तत्व-वार संचालन के रूप में परिभाषित किए जाते हैं, और आमतौर पर परिणाम के रूप में ndarray वस्तुओं को उपजते हैं।

लेकिन सरणी के लिए लॉजिकल ऑपरेशंस को लागू नहीं करता है, क्योंकि आप पाइथन में लॉजिकल ऑपरेटरों को अधिभारित नहीं कर सकते हैं । यही कारण है कि उदाहरण तीन काम नहीं करता है, लेकिन उदाहरण चार करता है।

तो अपने and बनाम & प्रश्न का उत्तर देने के लिए: उपयोग करें and

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

लॉजिकल ऑपरेशंस ( and , or not ), हालांकि, हर समय उपयोग किया जाता है।







ampersand