पायथन में क्या करता है? = (Ior)

112

Google मुझे खोज |=करने नहीं देगा इसलिए मुझे प्रासंगिक दस्तावेज़ खोजने में समस्या हो रही है। किसी को पता है?

python

5

मुझे लगता है कि नीचे इंगित करना प्रासंगिक है, जैसा कि नीचे सनी के जवाब में, वह |भी सेट यूनियन ऑपरेटर के रूप में उपयोग किया जाता है

— TallChuck

10

2019 में Google आपको सर्च करने देगा `| =`! :-)

— rbennell

45

|=वस्तुओं के जोड़े के बीच एक जगह ⁺ ऑपरेशन करता है । विशेष रूप से, के बीच:

सेट : एक यूनियन ऑपरेशन
dicts : एक अपडेट ऑपरेशन
काउंटरर्स : एक यूनियन (मल्टीसेट्स) ऑपरेशन
संख्या : एक बिटवाइज़ या , बाइनरी ऑपरेशन

ज्यादातर मामलों में, यह |ऑपरेटर से संबंधित है । नीचे दिए गए उदाहरण देखें।

सेट

उदाहरण के लिए, दो नियत सेटों का मिलन s1और s2निम्नलिखित समान भावों को साझा करना:

>>> s1 = s1 | s12                                          # 1
>>> s1 |= s2                                               # 2
>>> s1.__ior__(s2)                                         # 3

जहां का अंतिम मूल्य s1इसके बराबर है:

एक नियत OR ऑपरेशन
एक जगह या ऑपरेशन में
एक जगह में या विशेष विधि के माध्यम से ऑपरेशन ⁺⁺

उदाहरण

यहाँ हम या ( |) और (या |=) को सेट करने के लिए :

>>> s1 = {"a", "b", "c"}
>>> s2 = {"d", "e", "f"}

>>> # OR, | 
>>> s1 | s2
{'a', 'b', 'c', 'd', 'e', 'f'}
>>> s1                                                     # `s1` is unchanged
{'a', 'b', 'c'}

>>> # Inplace OR, |=
>>> s1 |= s2
>>> s1                                                     # `s1` is reassigned
{'a', 'b', 'c', 'd', 'e', 'f'}

शब्दकोश

में अजगर 3.9+ , नए मर्ज ( |) और अद्यतन ( |=) ऑपरेटरों शब्दकोशों के बीच प्रस्तावित हैं। नोट: ये ऊपर बताए गए सेट ऑपरेटर्स के समान नहीं हैं।

दो नियत dicts d1और के बीच संचालन को देखते हुए d2:

>>> d1 = d1 | d2                                           # 1
>>> d1 |= d2                                               # 2

कहां d1से समतुल्य है:

एक निर्धारित मर्ज-सही संचालन
इन-प्लेस मर्ज-राइट (अपडेट) ऑपरेशन; के बराबरd1.update(d2)

उदाहरण

यहाँ हम मर्ज (लागू |) और अद्यतन ( |=करने के लिए) dicts :

>>> d1 = {"a": 0, "b": 1, "c": 2}
>>> d2 = {"c": 20, "d": 30}

>>> # Merge, | 
>>> d1 | d2
{"a": 0, "b": 1, "c": 20, "d": 30}
>>> d1 
{"a": 0, "b": 1, "c": 2}

>>> # Update, |=
>>> d1 |= d2
>>> d1 
{"a": 0, "b": 1, "c": 20, "d": 30}

काउंटर

यह collections.Counterएक गणितीय डेटास्ट्रक्चर से संबंधित है जिसे मल्टीसेट (mset) कहा जाता है । यह मूल रूप से (वस्तु, बहुलता) कुंजी-मूल्य जोड़े का एक ताना है।

दो नियत काउंटरों c1और के बीच संचालन को देखते हुए c2:

>>> c1 = c1 | c2                                           # 1
>>> c1 |= c2                                               # 2

कहां c1से समतुल्य है:

एक नियत संघ संचालन
इन-प्लेस यूनियन ऑपरेशन

मल्टीसेट के एक संघ में प्रति प्रविष्टि अधिकतम गुणा शामिल है। ध्यान दें, यह दो सेट के बीच या दो नियमित dicts के समान व्यवहार नहीं करता है।

उदाहरण

यहां हम संघ ( |) और इन-प्लेस यूनियन ( |=) से काउंटरों पर लागू होते हैं :

import collections as ct


>>> c1 = ct.Counter({2: 2, 3: 3})
>>> c2 = ct.Counter({1: 1, 3: 5})

>>> # Union, |    
>>> c1 | c2
Counter({2: 2, 3: 5, 1: 1})
>>> c1
Counter({2: 2, 3: 3})

>>> # Inplace Union, |=
>>> c1 |= c2
>>> c1
Counter({2: 2, 3: 5, 1: 1})

नंबर

अन्त में, आप बाइनरी गणित कर सकते हैं।

दो नियत संख्याओं n1और के बीच संचालन को देखते हुए n2:

>>> n1 = n1 | n2                                           # 1
>>> n1 |= n2                                               # 2

कहां n1से समतुल्य है:

एक निर्धारित बिटवाइज़ या ऑपरेशन
इन-प्लेस बिटवाइज़ या ऑपरेशन

उदाहरण

यहां हम बिटवाइज़ या ( |) और इन-प्लेस बिटवाइज़ OR ( |=) नंबर पर लागू करते हैं :

>>> n1 = 0
>>> n2 = 1

>>> # Bitwise OR, |
>>> n1 | n2
1
>>> n1
0

>>> # Inplace Bitwise OR, |=
>>> n1 |= n2
>>> n1
1

समीक्षा

यह खंड संक्षेप में कुछ बिटवाइज़ गणित की समीक्षा करता है। सरलतम मामले में, बिटवाइज़ या ऑपरेशन दो बाइनरी बिट्स की तुलना करता है। 1जब दोनों बिट्स होंगे तो यह हमेशा वापस आ जाएगा 0।

>>> assert 1 == (1 | 1) == (1 | 0) == (0 | 1)
>>> assert 0 == (0 | 0)

अब हम इस विचार को बाइनरी नंबर से आगे बढ़ाते हैं। किसी भी दो अभिन्न संख्या (आंशिक घटकों की कमी) को देखते हुए, हम बिटवाइज़ लागू करते हैं या एक अभिन्न परिणाम प्राप्त करते हैं:

>>> a = 10 
>>> b = 16 
>>> a | b
26

कैसे? सामान्य तौर पर, बिटवाइज़ ऑपरेशन कुछ "नियमों" का पालन करते हैं:

बाइनरी समकक्षों की आंतरिक रूप से तुलना करें
ऑपरेशन लागू करें
दिए गए प्रकार के रूप में परिणाम लौटाएं

आइए इन नियमों को ऊपर हमारे नियमित पूर्णांक पर लागू करें।

(1) बाइनरी समकक्षों की तुलना करें, यहाँ स्ट्रिंग्स के रूप में देखा जाता है ( 0bबाइनरी को दर्शाता है):

>>> bin(a)
'0b1010'
>>> bin(b)
'0b10000'

(2) प्रत्येक कॉलम के लिए एक बिटवाइज़ या ऑपरेशन लागू करें ( 0जब दोनों हों 0, तो 1):

01010
10000
-----
11010

(३) दिए गए प्रकार में परिणाम लौटाएँ, जैसे आधार १०, दशमलव:

>>> int(0b11010)
26

आंतरिक बाइनरी तुलना का मतलब है कि हम किसी भी आधार में उत्तरार्द्ध को पूर्णांक पर लागू कर सकते हैं, जैसे हेक्स और ऑक्टल:

>>> c = 0xa
>>> d = 0o32
>>> c | d
26

यह सभी देखें

एक सार आधार वर्ग में पुनरावृत्तियों को पुनरावृत्त करने की __ior__()विधि को ओवरलोड करने का एक उदाहरणMutableSet
आर। हेटिंगर की ऑर्डर की गई रेसिपी (क्रमशः लाइनें 3 और 10 देखें)
एक सेट को अद्यतन करने के लिए उपयोग करने के लिए पायथन-विचारों पर एक धागा|=
पायथन ऑपरेटरों के विशेष तरीकों पर पायथन 3 में गोता का एक खंड B.8

⁺_{इन-प्लेस बिटवाइज़ या ऑपरेटर को शाब्दिक रूप से लागू नहीं किया जा सकता है; नामों को ऑब्जेक्ट असाइन करें।}

⁺⁺_{विशेष तरीके अपने संबंधित ऑपरेटरों के समान संचालन वापस करते हैं।}

— pylang
स्रोत

2

पूरी तरह से स्पष्ट होने के लिए, मैं इस प्रदर्शन में जोड़ दूंगा कि नियमित कार्य करने के बाद (x = x | y) आईडी (x) बदल गया है क्योंकि यह एक नई वस्तु है, जबकि = = एक ही आईडी रखता है क्योंकि यह मूल x है। संशोधित किया गया है, इसलिए नाम "inplace" है।

— फ्लोरिमंड

1

यह शीर्ष उत्तर होना चाहिए - यह सबसे अधिक संपूर्ण है।

— निक

संख्या अनुभाग में, आप दावा कर रहे हैं कि दूसरा कथन इन-प्लेस ऑपरेशन करता है। मुझे लगता है कि यह सच नहीं है, क्योंकि intपायथन में एस परस्पर नहीं हैं।

— असोसिया

106

अजगर, और कई अन्य प्रोग्रामिंग भाषाओं में |है बिटवाइज़-या आपरेशन । |=के |रूप +=में करने के लिए है +, ऑपरेशन और asignment का एक संयोजन है।

के var |= valueलिए कम है var = var | value।

एक सामान्य उपयोग का मामला दो सेटों को मिलाना है:

>>> a = {1,2}; a |= {3,4}; print(a)
{1, 2, 3, 4}

— डैनियल स्टटज़बैक
स्रोत

21

क्या आप एक उदाहरण प्रदान कर सकते हैं?

— खनिजों

मैंने नीचे दिए गए एक उपयोग मामले को दिया है

— 15

53

जब सेट के साथ प्रयोग किया जाता है तो यह यूनियन ऑपरेशन करता है।

— धूप
स्रोत

1

मैं कुछ कोड पढ़ रहा था और |=सेट संदर्भ में उपयोग किया गया था, और यह तब तक नहीं था जब तक मैं चारों ओर गड़बड़ नहीं करता था और यह पता

— लगाता

41

यह वर्तमान चर और अन्य एक के बीच केवल एक OR ऑपरेशन है। होने के नाते T=Trueऔर F=False, उत्पादन रेखांकन देखें:

r    s    r|=s
--------------
T    T    T
T    F    T
F    T    T
F    F    F

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

>>> r=True
>>> r|=False
>>> r
True
>>> r=False
>>> r|=False
>>> r
False
>>> r|=True
>>> r
True

— फेडोरक्वी 'SO रोक नुकसान पहुंचाना'
स्रोत

7

यह ऑपरेटर की विकृत छाप का एक प्रकार देता है; |पूर्णांक के लिए एक बिटवाइज़ या ऑपरेटर है, विशेष रूप से बूलियन ऑपरेटर नहीं है, और boolएस के अलावा किसी भी चीज़ के लिए , यह वास्तव में उत्पादन Trueया Falseआउटपुट नहीं करेगा । boolका एक उपवर्ग है int, और अच्छा होने के लिए, उन्होंने इसे boolउत्पादन True/ Falseआउटपुट रखने के लिए अतिभारित किया , लेकिन ज्यादातर मामलों में, बूलियन ऑपरेशन के साथ किया जाना चाहिए or, नहीं |। |बिटवाइस-या सेट-यूनियन के लिए सामान्य उपयोग हैं। उपयोग के बेहतर उदाहरण कुछ ऐसा होगा a = 0b1001; a |= 0b0010; print(bin(a))जो पैदा करता है 0b1011।

— शैडो रेंजर

9

यह एक बाइनरी बिटवाइज़ या बाएं-दाएं और असाइनमेंट के दाएं-हाथ के किनारों को निष्पादित करता है, फिर परिणाम को बाएं हाथ के चर में संग्रहीत करता है।

http://docs.python.org/reference/expressions.html#binary-bitwise-operations

— ब्रैंडन रोड्स
स्रोत

3

यह बिटवाइज़ है या मान लीजिए कि हमारे पास 32 |= 10चित्र 32 और 10 बाइनरी है।

32 = 10 0000
10 = 00 1010

अब क्योंकि | या, एक बिटवाइज़ या दो नंबरों पर करें

1 या 0 -> 1, 0 या 0 -> 0. इसे नीचे श्रृंखला जारी रखें

10 0000 | 00 1010 = 10 1010.

अब बाइनरी को एक दशमलव, 10 1010 = 42 में बदलें।

के लिए = =, ज्ञात उदाहरणों के बारे में सोचो x +=5। इसका मतलब है x = x + 5,कि अगर हमारे पास है x |= 5, तो इसका मतलब है x = x bitwiseor with 5।

— memeKing
स्रोत

यह वह स्पष्टीकरण है जिसकी मैं तलाश कर रहा था, सभी ने सेट और बूल के बारे में बात की लेकिन किसी ने संख्याओं के साथ इसके उपयोग का उल्लेख नहीं किया।

— अंकुश वर्मा

आपके द्वारा दिया गया उदाहरण नहीं है 32 |= 10, बल्कि है 32 | 10। भविष्य के पाठकों के लिए इसे स्पष्ट करने के लिए बस :)

— sniper71

@ sniper71 32 का परिणाम क्या है। = 10

— भविष्य-जिम

2

उपयोग-केस देने के लिए (अन्य उत्तरों के साथ समय बिताने के बाद):

def process(item):
   return bool(item) # imagine some sort of complex processing taking place above

def any_success(data): # return True if at least one is successful
    at_least_one = False
    for item in data:
       at_least_one |= process(item)
    return at_least_one

>>> any_success([False, False, False])
False
>>> any_success([True, False, False])
True
>>> any_success([False, True, False])
True

मूल रूप anyसे शॉर्ट-सर्किटिंग के बिना: उपयोगी हो सकता है यदि आपको प्रत्येक आइटम को संसाधित करने और कम से कम एक सफलता आदि रिकॉर्ड करने की आवश्यकता हो।

इस उत्तर में केवेट भी देखें

— scharfmn
स्रोत

1

पायथन में; = = (ior) संघ संचालन की तरह काम करता है। जैसे अगर x = 5 और x | = 5 तो दोनों मान पहले बाइनरी मान में परिवर्तित हो जाएंगे, फिर यूनियन ऑपरेशन प्रदर्शन करेगा और हमें उत्तर 5 मिलेगा।

— aanchal.s
स्रोत