Python 3.7 - Types

अंतर्निहित प्रकार




python

अंतर्निहित प्रकार

निम्न अनुभाग मानक प्रकारों का वर्णन करते हैं जो दुभाषिया में निर्मित होते हैं।

निर्मित अंतर्निहित प्रकार संख्यात्मक, अनुक्रम, मैपिंग, कक्षाएं, उदाहरण और अपवाद हैं।

कुछ संग्रह कक्षाएं परस्पर हैं। अपने सदस्यों को जोड़ने, घटाने, या पुनर्व्यवस्थित करने के तरीके, और एक विशिष्ट वस्तु वापस नहीं करते हैं, संग्रह संग्रह को कभी भी वापस नहीं करते हैं, लेकिन None

कुछ ऑपरेशन कई ऑब्जेक्ट प्रकारों द्वारा समर्थित होते हैं; विशेष रूप से, व्यावहारिक रूप से सभी वस्तुओं की तुलना की जा सकती है, सत्य मूल्य के लिए परीक्षण किया जाता है, और एक स्ट्रिंग ( repr() फ़ंक्शन या थोड़ा अलग स्ट्रिंग repr() फ़ंक्शन repr() परिवर्तित होता है। बाद वाले फ़ंक्शन का उपयोग तब किया जाता है जब कोई ऑब्जेक्ट print() फ़ंक्शन द्वारा लिखा जाता है।

सत्य मूल्य परीक्षण

किसी भी वस्तु का सत्य मूल्य के लिए परीक्षण किया जा सकता है, if या while हालत में या नीचे बूलियन संचालन के संचालन के रूप में उपयोग किया जाता है।

डिफ़ॉल्ट रूप से, किसी ऑब्जेक्ट को तब तक सही माना जाता है जब तक कि उसका वर्ग या तो __bool__() विधि को परिभाषित नहीं करता है, जो False या __len__() पद्धति को शून्य करता है, जब ऑब्जेक्ट को कॉल किया जाता है। [1] यहाँ अधिकांश निर्मित वस्तुओं को गलत माना गया है:

  • स्थिरांक गलत होने के लिए परिभाषित: None और False
  • किसी भी संख्यात्मक प्रकार का शून्य: 0 , 0.0 , 0j , Decimal(0) , Fraction(0, 1)
  • खाली क्रम और संग्रह: '' , () , [] , {} , set() , range(0)

ऑपरेशन और बिल्ट-इन फ़ंक्शन जिनके पास बूलियन परिणाम होता है, वे हमेशा 0 या झूठे और 1 या True लिए गलत होते हैं, जब तक कि अन्यथा न कहा जाए। (महत्वपूर्ण अपवाद: बूलियन ऑपरेशन or and हमेशा अपने एक ऑपरेंड को वापस करना।)

बूलियन ऑपरेशन - और, या, नहीं

ये बूलियन ऑपरेशन हैं, आरोही प्राथमिकता के आधार पर:

ऑपरेशन परिणाम टिप्पणियाँ
x or y यदि x गलत है, तो y , x (1)
x and y यदि x गलत है, तो x , और y है (2)
not x यदि x गलत है, तो True , अन्यथा False (3)

टिप्पणियाँ:

  1. यह एक शॉर्ट-सर्किट ऑपरेटर है, इसलिए यह केवल दूसरे तर्क का मूल्यांकन करता है यदि पहला गलत है।
  2. यह एक शॉर्ट-सर्किट ऑपरेटर है, इसलिए यह केवल दूसरे तर्क का मूल्यांकन करता है यदि पहला सच है।
  3. गैर-बूलियन ऑपरेटरों की तुलना में कम प्राथमिकता not है, इसलिए not a == b की व्याख्या not (a == b) , और a == not b एक वाक्यविन्यास त्रुटि है।

तुलना

पायथन में आठ तुलनात्मक संचालन हैं। उन सभी की प्राथमिकता समान है (जो बूलियन ऑपरेशन से अधिक है)। तुलनाओं को मनमाने ढंग से जंजीर किया जा सकता है; उदाहरण के लिए, x < y <= z , x < y and y <= z बराबर है, सिवाय इसके कि y का केवल एक बार मूल्यांकन किया जाता है (लेकिन दोनों मामलों में z का मूल्यांकन तब नहीं किया जाता है जब x < y गलत पाया जाता है)।

यह तालिका तुलनात्मक कार्यों का सारांश प्रस्तुत करती है:

ऑपरेशन अर्थ
< कड़ाई से कम
<= इससे कम या इसके बराबर
> से अधिक सख्ती से
>= से बड़ा या बराबर
== बराबरी का
!= बराबर नहीं
is वस्तु पहचान
is not उपेक्षित वस्तु पहचान

अलग-अलग प्रकार की वस्तुएं, अलग-अलग संख्यात्मक प्रकारों को छोड़कर, कभी भी बराबर की तुलना नहीं करती हैं। इसके अलावा, कुछ प्रकार (उदाहरण के लिए, फ़ंक्शन ऑब्जेक्ट्स) केवल तुलना की एक विकृत धारणा का समर्थन करते हैं जहां उस प्रकार की कोई भी दो ऑब्जेक्ट असमान हैं। < , <= , > और >= ऑपरेटर किसी अन्य अंतर्निहित संख्यात्मक प्रकार के साथ एक जटिल संख्या की तुलना करते समय एक TypeError अपवाद को बढ़ाएंगे, जब ऑब्जेक्ट विभिन्न प्रकार के होते हैं जिनकी तुलना नहीं की जा सकती है, या अन्य मामलों में जहां कोई परिभाषित नहीं है। आदेश।

जब तक वर्ग __eq__() विधि को परिभाषित नहीं करता तब तक एक वर्ग के गैर-समान उदाहरण सामान्य रूप से गैर-बराबर के रूप में तुलना करते हैं।

जब तक वर्ग __lt__() , __le__() , __gt__() , और __ge__() (सामान्य रूप से __ge__() को परिभाषित नहीं करता है, तब तक उसी वर्ग के अन्य उदाहरणों, या अन्य प्रकार की वस्तु के संबंध में एक वर्ग के उदाहरणों का आदेश नहीं दिया जा सकता है। , __lt__() और __eq__() पर्याप्त हैं, यदि आप तुलना ऑपरेटरों के पारंपरिक अर्थ चाहते हैं)।

is और ऑपरेटरों is not is व्यवहार को अनुकूलित नहीं किया जा सकता है; यह भी कि वे किसी भी दो वस्तुओं पर लागू हो सकते हैं और कभी भी अपवाद नहीं उठा सकते।

एक ही वाक्यात्मक प्राथमिकता के साथ दो और संचालन, प्रकार में समर्थित not in हैं जो कि __contains__() या __contains__() पद्धति को लागू करते हैं।

संख्यात्मक प्रकार - इंट, फ्लोट, जटिल

तीन अलग-अलग संख्यात्मक प्रकार हैं: पूर्णांक , फ्लोटिंग पॉइंट नंबर और जटिल संख्या । इसके अलावा, बूलियन पूर्णांक का एक उपप्रकार हैं। पूर्णांक में असीमित सटीकता है। फ्लोटिंग पॉइंट नंबर आमतौर पर सी में double का उपयोग करके लागू किए जाते हैं; जिस मशीन पर आपका प्रोग्राम चल रहा है उसके लिए फ्लोटिंग पॉइंट नंबरों की शुद्धता और आंतरिक प्रतिनिधित्व के बारे में जानकारी sys.float_info में उपलब्ध है। कॉम्प्लेक्स नंबरों में एक वास्तविक और काल्पनिक हिस्सा होता है, जो प्रत्येक फ्लोटिंग पॉइंट नंबर होता है। एक जटिल संख्या z से इन भागों को निकालने के लिए, z.real और z.imag उपयोग करें। (मानक पुस्तकालय में अतिरिक्त सांख्यिक प्रकार, परिमेय धारण करने वाले fractions और उपयोगकर्ता-निश्चित सटीकता के साथ फ़्लोटिंग-पॉइंट संख्या रखने वाले decimal ।)

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

पायथन पूरी तरह से मिश्रित अंकगणित का समर्थन करता है: जब एक बाइनरी अंकगणितीय ऑपरेटर के पास विभिन्न संख्यात्मक प्रकार के ऑपरेंड होते हैं, तो "संकरा" प्रकार के साथ ऑपरेंड को दूसरे से चौड़ा किया जाता है, जहां पूर्णांक फ्लोटिंग बिंदु की तुलना में संकीर्ण होता है, जो जटिल से संकरा होता है। मिश्रित प्रकार की संख्याओं के बीच तुलना एक ही नियम का उपयोग करती है। [2] कंस्ट्रक्टर्स int() , float() , और complex() का उपयोग विशिष्ट प्रकार की संख्या का उत्पादन करने के लिए किया जा सकता है।

सभी संख्यात्मक प्रकार (जटिल को छोड़कर) आरोही प्राथमिकता द्वारा क्रमबद्ध निम्नलिखित कार्यों का समर्थन करते हैं, (सभी संख्यात्मक संचालन तुलनात्मक संचालन की तुलना में उच्च प्राथमिकता है):

ऑपरेशन परिणाम टिप्पणियाँ पूर्ण प्रलेखन
x + y x और y का योग
x - y x और y का अंतर
x * y एक्स और वाई के उत्पाद
x / y x और y का भागफल
x // y x और y के भागफल का भाग (1)
x % y शेष x / y (2)
-x x उपेक्षित
+x एक्स अपरिवर्तित
abs(x) x का पूर्ण मान या परिमाण abs()
int(x) x पूर्णांक में परिवर्तित हो गया (3) (6) int()
float(x) x फ्लोटिंग पॉइंट में परिवर्तित हो गया (4) (6) float()
complex(re, im) वास्तविक भाग पुनः , काल्पनिक भाग im के साथ एक जटिल संख्या। im शून्य में चूक। (6) complex()
c.conjugate() जटिल संख्या c के संयुग्म
divmod(x, y) जोड़ी (x // y, x % y) (2) divmod()
pow(x, y) x से शक्ति y (5) pow()
x ** y x से शक्ति y (5)

टिप्पणियाँ:

  1. इसे पूर्णांक विभाजन भी कहा जाता है। परिणामी मान एक पूर्ण पूर्णांक है, हालांकि परिणाम का प्रकार आवश्यक रूप से इंट नहीं है। परिणाम हमेशा माइनस इनफिनिटी की ओर गोल होता है: 1//2 0 , (-1)//2 है -1 , 1//(-2) -1 , और (-1)//(-2) है 0
  2. जटिल संख्या के लिए नहीं। इसके बजाय यदि उपयुक्त हो तो abs() का उपयोग करके झांकियों में परिवर्तित करें
  3. फ्लोटिंग पॉइंट से पूर्णांक तक रूपांतरण C के रूप में गोल या छोटा हो सकता है; फ़ंक्शंस देखें math.floor() और math.floor() अच्छी तरह से परिभाषित रूपांतरणों के लिए।
  4. फ्लोट एक वैकल्पिक उपसर्ग "+" या "-" के साथ स्ट्रिंग्स "नेन" और "इन" को भी स्वीकार करता है, नॉट (नंबर) और सकारात्मक या नकारात्मक अनंत के लिए।
  5. पायथन pow(0, 0) और 0 ** 0 से 1 को परिभाषित करता है, जैसा कि प्रोग्रामिंग भाषाओं के लिए आम है।
  6. स्वीकार किए गए संख्यात्मक शाब्दिकों में अंक 0 से 9 या यूनिकोड समतुल्य ( Nd संपत्ति के साथ कोड अंक) शामिल हैं।

    Nd संपत्ति के साथ कोड बिंदुओं की पूरी सूची के लिए http://www.unicode.org/Public/10.0.0/ucd/extracted/DerivedNumericType.txt देखें।

सभी numbers.Real प्रकार ( int() और float() ) में निम्नलिखित ऑपरेशन भी शामिल हैं:

ऑपरेशन परिणाम
math.trunc(x) Integral को x छोटा कर दिया
round(x[, n]) x को n अंक तक, आधे को भी गोल किया जाता है। यदि n को छोड़ दिया जाता है, तो यह 0 से चूक जाता है।
math.floor() सबसे बड़ा Integral <= x
math.ceil() सबसे कम Integral > = एक्स

अतिरिक्त संख्यात्मक कार्यों के लिए math और cmath मॉड्यूल देखें।

इंटीजर टाइप्स पर बिटवाइज ऑपरेशंस

बिटवाइज ऑपरेशन केवल पूर्णांक के लिए समझ में आता है। बिटवाइज़ ऑपरेशंस के परिणाम की गणना इस प्रकार की जाती है कि दोनों को अनंत संख्या में साइन बिट्स के पूरक के रूप में किया गया है।

बाइनरी बिटवाइज़ ऑपरेशंस की प्राथमिकताएं न्यूमेरिक ऑपरेशंस की तुलना में कम और तुलनात्मक तुलना में अधिक हैं; एकात्मक संचालन ~ की अन्य प्राथमिक संख्यात्मक क्रियाओं ( + और - ) के समान प्राथमिकता है।

यह तालिका आरोही प्राथमिकता में क्रमबद्ध बिटवाइज़ ऑपरेशंस को सूचीबद्ध करती है:

ऑपरेशन परिणाम टिप्पणियाँ
x | y बिटवाइज़ या x और y की (4)
x ^ y बिटवाइस एक्सक्लूसिव या एक्स और वाई (4)
x & y बिट वाइज और x और y का (4)
x << n x n बिट्स द्वारा छोड़ा गया (1) (2)
x >> n x सही बिट्स द्वारा स्थानांतरित किया गया (1) (3)
~x एक्स के बिट उल्टे

टिप्पणियाँ:

  1. नकारात्मक शिफ्ट मायने रखता है गैरकानूनी है और एक ValueError कारण होता है।
  2. एन बिट्स द्वारा एक बाएं बदलाव ओवरफ्लो चेक के बिना pow(2, n) द्वारा गुणा के बराबर है।
  3. N बिट्स द्वारा एक सही बदलाव ओवरफ्लो चेक के बिना pow(2, n) द्वारा विभाजन के बराबर है।
  4. इन गणनाओं को एक परिमित दो के पूरक प्रतिनिधित्व में कम से कम एक अतिरिक्त साइन एक्सटेंशन बिट के साथ प्रदर्शन करना ( 1 + max(x.bit_length(), y.bit_length() या अधिक की एक कामकाजी बिट-चौड़ाई समान परिणाम प्राप्त करने के लिए पर्याप्त है यदि अनंत संख्या में साइन बिट्स थे।

पूर्णांक प्रकार पर अतिरिक्त तरीके

इंट प्रकार Integral लागू करता है। Integral आधार आधार वर्ग । इसके अलावा, यह कुछ और तरीके प्रदान करता है:

int.bit_length()

द्विआधारी में एक पूर्णांक का प्रतिनिधित्व करने के लिए आवश्यक बिट्स की संख्या लौटाएं, साइन और प्रमुख शून्य को छोड़कर:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

अधिक सटीक रूप से, यदि x x.bit_length() , तो x.bit_length() विशिष्ट धनात्मक पूर्णांक k जैसे कि 2**(k-1) <= abs(x) < 2**k । समान रूप से, जब abs(x) सही ढंग से गोल लॉगरिदम के लिए पर्याप्त छोटा होता है, तो k = 1 + int(log(abs(x), 2)) । यदि x शून्य है, तो x.bit_length() 0 देता है।

के बराबर:

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

संस्करण 3.1 में नया।

int.to_bytes(length, byteorder, *, signed=False)

पूर्णांक का प्रतिनिधित्व करने वाले बाइट्स की एक सरणी लौटें।

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

पूर्णांक लंबाई बाइट्स का उपयोग करके दर्शाया गया है। यदि एक पूर्णांक बाइट्स की संख्या के साथ प्रतिनिधित्व करने योग्य नहीं है, तो एक OverflowError उठाया जाता है।

बाइटऑर्डर तर्क पूर्णांक को दर्शाने के लिए प्रयुक्त बाइट क्रम को निर्धारित करता है। यदि बाइटऑर्डर "big" , तो बाइट सरणी की शुरुआत में सबसे महत्वपूर्ण बाइट है। यदि बाइटऑर्डर "little" , तो सबसे महत्वपूर्ण बाइट बाइट सरणी के अंत में है। होस्ट सिस्टम के मूल बाइट ऑर्डर का अनुरोध करने के लिए, बाइट ऑर्डर वैल्यू के रूप में sys.byteorder उपयोग करें।

हस्ताक्षरित तर्क यह निर्धारित करता है कि पूर्णांक का प्रतिनिधित्व करने के लिए दो के पूरक का उपयोग किया जाता है या नहीं। यदि हस्ताक्षर False और एक नकारात्मक पूर्णांक दिया जाता है, तो एक OverflowError जाता है। हस्ताक्षरित के लिए डिफ़ॉल्ट मान False

संस्करण 3.2 में नया।

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

दिए गए सरणी बाइट्स द्वारा प्रतिनिधित्व पूर्णांक लौटाएं।

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

तर्क बाइट्स या तो एक बाइट्स की तरह वस्तु या एक उत्पादन करने योग्य बाइट्स होना चाहिए।

बाइटऑर्डर तर्क पूर्णांक को दर्शाने के लिए प्रयुक्त बाइट क्रम को निर्धारित करता है। यदि बाइटऑर्डर "big" , तो बाइट सरणी की शुरुआत में सबसे महत्वपूर्ण बाइट है। यदि बाइटऑर्डर "little" , तो सबसे महत्वपूर्ण बाइट बाइट सरणी के अंत में है। होस्ट सिस्टम के मूल बाइट ऑर्डर का अनुरोध करने के लिए, बाइट ऑर्डर वैल्यू के रूप में sys.byteorder उपयोग करें।

हस्ताक्षरित तर्क बताता है कि पूर्णांक का प्रतिनिधित्व करने के लिए दो के पूरक का उपयोग किया जाता है या नहीं।

संस्करण 3.2 में नया।

फ्लोट पर अतिरिक्त तरीके

फ्लोट प्रकार numbers.Real लागू करता है। सार बेस क्लास । फ्लोट में निम्नलिखित अतिरिक्त विधियां भी हैं।

float.as_integer_ratio()

पूर्णांक की एक जोड़ी लौटाएं, जिसका अनुपात मूल फ्लोट के बराबर और एक सकारात्मक भाजक के साथ है। शिशुओं पर OverflowError और एक NaNs पर मान बढ़ाता है।

float.is_integer()

True यदि फ्लोट का उदाहरण अभिन्न मूल्य के साथ परिमित है, और False अन्यथा:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

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

float.hex()

हेक्साडेसिमल स्ट्रिंग के रूप में एक फ्लोटिंग-पॉइंट संख्या का प्रतिनिधित्व लौटाएं। परिमित फ्लोटिंग-पॉइंट नंबरों के लिए, इस प्रतिनिधित्व में हमेशा एक अग्रणी 0x और एक अनुगामी p और प्रतिपादक शामिल होंगे।

classmethod float.fromhex(s)

हेक्साडेसिमल स्ट्रिंग एस द्वारा दर्शाए गए फ्लोट को वापस करने के लिए क्लास विधि। स्ट्रिंग s में व्हॉट्सएप अग्रणी और अनुगामी हो सकता है।

ध्यान दें कि float.hex() एक आवृत्ति विधि है, जबकि float.fromhex() एक वर्ग विधि है।

एक हेक्साडेसिमल स्ट्रिंग फार्म लेता है:

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

जहाँ वैकल्पिक sign + या - या के द्वारा हो सकता है, integer और fraction हेक्साडेसिमल अंकों के तार होते हैं, और exponent एक दशमलव पूर्णांक होता है जिसमें एक वैकल्पिक अग्रणी चिह्न होता है। मामला महत्वपूर्ण नहीं है, और पूर्णांक या अंश में कम से कम एक हेक्साडेसिमल अंक होना चाहिए। यह सिंटैक्स C99 मानक के खंड 6.4.4.2 में निर्दिष्ट सिंटैक्स के समान है, और जावा 1.5 में प्रयुक्त सिंटैक्स के लिए भी है। विशेष रूप से, float.hex() का आउटपुट C या Java कोड में हेक्साडेसिमल फ्लोटिंग-पॉइंट शाब्दिक के रूप में प्रयोग करने योग्य है, और C के %a प्रारूप चरित्र या Java के Double.toHexString द्वारा निर्मित हेक्साडेसिमल स्ट्रिंग्स को float.fromhex() द्वारा स्वीकार किया float.fromhex()

ध्यान दें कि घातांक को हेक्साडेसिमल के बजाय दशमलव में लिखा गया है, और यह 2 की शक्ति देता है जिसके द्वारा गुणांक को गुणा करना है। उदाहरण के लिए, हेक्साडेसिमल स्ट्रिंग 0x3.a7p10 फ्लोटिंग-पॉइंट नंबर (3 + 10./16 + 7./16**2) * 2.0**10 , या 3740.0 :

>>> float.fromhex('0x3.a7p10')
3740.0

3740.0 लिए रिवर्स रूपांतरण लागू करने से एक ही संख्या का प्रतिनिधित्व करने 3740.0 एक अलग हेक्साडेसिमल स्ट्रिंग मिलता है:

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

सांख्यिक प्रकारों की हाशिंग

संख्याओं के लिए x और y , संभवतः विभिन्न प्रकारों के लिए, यह एक आवश्यकता है कि जब भी x == y (अधिक विवरण के लिए __hash__() विधि प्रलेखन देखें) hash(x) == hash(y) ) है। विभिन्न प्रकार के संख्यात्मक प्रकारों (जैसे, decimal.Decimal , float() , decimal.Decimal और fractions.Fraction ) के कार्यान्वयन और दक्षता में आसानी के लिए संख्यात्मक प्रकारों के लिए पायथन का हैश एकल गणितीय फ़ंक्शन पर आधारित है जो किसी भी परिमेय संख्या के लिए परिभाषित किया गया है, और इसलिए सभी पर लागू होता है int() और fractions.Fraction उदाहरण। decimal.Decimal , और float() और decimal.Decimal सभी परिमित उदाहरण। decimal.Decimal । अनिवार्य रूप से, यह फ़ंक्शन एक निश्चित प्राइम P लिए मॉडुलो P को कम करके दिया जाता है। P का मान Python को sys.hash_info की modulus विशेषता के रूप में उपलब्ध कराया जाता है।

CPython कार्यान्वयन विवरण: वर्तमान में, प्राइम का उपयोग P = 2**31 - 1 है, 32-बिट सी लॉन्ग वाली मशीनों पर और P = 2**61 - 1 64-बिट सी लॉन्ग वाली मशीनों पर।

यहाँ विस्तार से नियम हैं:

  • यदि x = m / n एक nonnegative परिमेय संख्या है और n , P विभाज्य नहीं है, तो hash(x) को m * invmod(n, P) % P रूप में परिभाषित करें, जहाँ invmod(n, P) n modulo P का व्युत्क्रम देता है। ।
  • यदि x = m / n एक nonnegative परिमेय संख्या है और n , P से विभाज्य है (लेकिन m नहीं है) तो n में कोई उलटा modulo P और ऊपर दिया गया नियम लागू नहीं होता है; इस मामले में hash(x) को निरंतर मान sys.hash_info.inf
  • यदि x = m / n एक ऋणात्मक परिमेय संख्या hash(x) को -hash(-x) रूप में परिभाषित करता है। यदि परिणामी हैश -1 , तो इसे -2 बदलें।
  • विशेष मान sys.hash_info.inf , -sys.hash_info.inf और sys.hash_info.nan सकारात्मक अनंत, नकारात्मक अनंत या नान (क्रमशः) के लिए हैश मान के रूप में उपयोग किया जाता है। (सभी हैशेबल नैनों का समान हैश मूल्य है।)
  • एक complex() संख्या z , वास्तविक और काल्पनिक भागों के हैश मानों को कंप्यूटिंग hash(z.real) + sys.hash_info.imag * hash(z.imag) द्वारा संयोजित किया जाता है, कम किए गए modulo 2**sys.hash_info.width तो यह range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)) । फिर, यदि परिणाम -1 , तो इसे -2 बदल दिया जाएगा।

उपरोक्त नियमों को स्पष्ट करने के लिए, यहाँ कुछ उदाहरण पायथन कोड है, जो बिल्ट-इन हैश के बराबर है, एक तर्कसंगत संख्या, float() या complex() के हैश की गणना के लिए:

import sys, math

def hash_fraction(m, n):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return sys.hash_info.nan
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) - (hash_value & M)
    if hash_value == -1:
        hash_value = -2
    return hash_value

Iterator प्रकार

अजगर कंटेनर पर चलने की अवधारणा का समर्थन करता है। यह दो अलग-अलग तरीकों का उपयोग करके लागू किया गया है; ये उपयोगकर्ता-परिभाषित वर्गों को पुनरावृत्ति का समर्थन करने की अनुमति देने के लिए उपयोग किया जाता है। अनुक्रम, अधिक विवरण में नीचे वर्णित है, हमेशा पुनरावृत्ति विधियों का समर्थन करते हैं।

कंटेनर ऑब्जेक्ट को पुनरावृत्ति समर्थन प्रदान करने के लिए एक विधि को परिभाषित करने की आवश्यकता है:

container.__iter__()

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

निम्नलिखित दो विधियों का समर्थन करने के लिए इटैटर ऑब्जेक्ट्स की आवश्यकता होती है, जो एक साथ इट्रेटर प्रोटोकॉल बनाते हैं:

iterator.__iter__()

पुनरावृति वस्तु को ही वापस करें। इसके लिए कंटेनरों और पुनरावृत्तियों को अनुमति देने के for और बयानों के साथ उपयोग करने की आवश्यकता होती है। यह विधि Python / C API में पायथन ऑब्जेक्ट्स के लिए टाइप स्ट्रक्चर के tp_iter स्लॉट से मेल खाती है।

iterator.__next__()

कंटेनर से अगला आइटम वापस करें। यदि आगे कोई आइटम नहीं हैं, तो StopIteration अपवाद बढ़ाएं। यह विधि Python / C API में Python वस्तुओं के लिए संरचना के प्रकार के tp_iternext स्लॉट से मेल खाती है।

पायथन सामान्य और विशिष्ट अनुक्रम प्रकारों, शब्दकोशों और अन्य अधिक विशिष्ट रूपों पर पुनरावृत्ति का समर्थन करने के लिए कई पुनरावृत्त वस्तुओं को परिभाषित करता है। पुनरावृत्त प्रकार प्रोटोकॉल के उनके कार्यान्वयन से परे विशिष्ट प्रकार महत्वपूर्ण नहीं हैं।

एक बार एक __next__() का __next__() विधि StopIteration बढ़ाता है, इसे बाद की कॉल पर ऐसा करना जारी रखना चाहिए। कार्यान्वयन जो इस संपत्ति का पालन नहीं करते हैं उन्हें टूटा हुआ माना जाता है।

जनरेटर के प्रकार

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

अनुक्रम प्रकार - सूची, टपल, सीमा

तीन मूल अनुक्रम प्रकार हैं: सूची, टुपल्स, और रेंज ऑब्जेक्ट। बाइनरी डेटा और टेक्स्ट स्ट्रिंग्स के प्रसंस्करण के लिए तैयार अतिरिक्त अनुक्रम प्रकार समर्पित अनुभागों में वर्णित हैं।

सामान्य अनुक्रम संचालन

निम्न सारणी में किए गए कार्यों को अधिकांश अनुक्रम प्रकारों द्वारा समर्थित किया जाता है, दोनों उत्परिवर्तनीय और अपरिवर्तनीय। collections.abc.Sequence .abc.Sequence ABC को कस्टम अनुक्रम प्रकारों पर इन कार्यों को सही ढंग से कार्यान्वित करना आसान बनाने के लिए प्रदान किया जाता है।

यह तालिका आरोही प्राथमिकता में क्रमबद्ध अनुक्रम संचालन को सूचीबद्ध करती है। तालिका में, s और t एक ही प्रकार के अनुक्रम हैं, n , i , j और k पूर्णांक हैं और x एक मनमाना ऑब्जेक्ट है जो किसी भी प्रकार और s द्वारा लगाए गए मूल्य प्रतिबंधों को पूरा करता है।

not in ऑपरेशंस की तुलना में ऑपरेशंस की प्राथमिकताएँ समान हैं। + (संघनन) और * (पुनरावृत्ति) के संचालन के लिए समान रूप से सांख्यिक संचालन की प्राथमिकता होती है। [3]

ऑपरेशन परिणाम टिप्पणियाँ
x in s True अगर s का कोई आइटम x के बराबर है, तो False (1)
x not in s False यदि s का कोई आइटम x के बराबर है, तो True (1)
s + t एस और टी का संयोजन (6) (7)
s * n या n * s n समय में खुद को जोड़ने के बराबर है (2) (7)
s[i] मैं एस आइटम, मूल 0 (3)
s[i:j] i से j तक का टुकड़ा (3) (4)
s[i:j:k] s से i से j तक कदम k के साथ (3) (5)
len(s) की लंबाई
min(s) की सबसे छोटी वस्तु
max(s) का सबसे बड़ा आइटम
s.index(x[, i[, j]]) s में x की पहली घटना का सूचकांक (सूचकांक के बाद या बाद में और सूचकांक j से पहले) (8)
s.count(x) x में होने वाली घटनाओं की कुल संख्या

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

टिप्पणियाँ:

  1. जबकि संचालन not in और केवल सामान्य मामले में साधारण रोकथाम परीक्षण के लिए उपयोग किया जाता है, कुछ विशेष अनुक्रम (जैसे str() , bytes और bytearray ) भी बाद में परीक्षण के लिए उनका उपयोग करते हैं:

    >>> "gg" in "eggs"
    True
    
  2. 0 से कम n के मान को 0 रूप में माना जाता है (जो उसी प्रकार के एक खाली क्रम को पैदावार करता है)। ध्यान दें कि अनुक्रम s में आइटम कॉपी नहीं किए गए हैं; उन्हें कई बार संदर्भित किया जाता है। यह अक्सर नए पायथन प्रोग्रामर का शिकार करता है; विचार करें:

    >>> lists = [[]] * 3
    >>> lists
    [[], [], []]
    >>> lists[0].append(3)
    >>> lists
    [[3], [3], [3]]
    

    क्या हुआ है कि [[]] एक एक तत्व सूची है जिसमें एक खाली सूची है, इसलिए [[]] * 3 सभी तीन तत्व इस एकल रिक्त सूची के संदर्भ हैं। lists किसी भी तत्व को संशोधित करना इस एकल सूची को संशोधित करता है। आप इस तरह अलग-अलग सूचियों की सूची बना सकते हैं:

    >>> lists = [[] for i in range(3)]
    >>> lists[0].append(3)
    >>> lists[1].append(5)
    >>> lists[2].append(7)
    >>> lists
    [[3], [5], [7]]
    

    एफएक्यू प्रविष्टि में और स्पष्टीकरण उपलब्ध है मैं एक बहुआयामी सूची कैसे बना सकता हूं?

  3. यदि I या j ऋणात्मक है, तो अनुक्रम s के अंत के सापेक्ष है s : len(s) + i या len(s) + j प्रतिस्थापित है। लेकिन ध्यान दें कि -0 अभी भी 0
  4. I से j तक के स्लाइस को इंडेक्स k के साथ वस्तुओं के अनुक्रम के रूप में परिभाषित किया गया है जैसे कि i <= k < j । यदि i या j , len(s) से अधिक है, तो len(s) उपयोग करें। यदि मुझे छोड़ दिया गया है या None , तो 0 उपयोग करें। यदि j छोड़ा गया है या None , तो len(s) उपयोग करें। यदि मैं j से अधिक या बराबर है, तो स्लाइस खाली है।
  5. S से i से j तक के स्टेप k के साथ सूचकांक x = i + n*k जैसे कि 0 <= n < (ji)/k साथ वस्तुओं के अनुक्रम के रूप में परिभाषित किया गया है। दूसरे शब्दों में, सूचकांकों में i , i+k , i+2*k , i+3*k और इसी तरह, जब j तक पहुंच तो रुक जाती है (लेकिन j सहित कभी नहीं)। जब k पॉजिटिव होता है, तो i और j कम हो जाते हैं, अगर वे बड़े होते हैं। जब k ऋणात्मक होता है, तो i और j कम हो जाते हैं len(s) - 1 यदि वे अधिक हैं। यदि मैं या जम्मू को छोड़ दिया गया है या None , तो वे "अंत" मान बन जाते हैं (जो अंत k के संकेत पर निर्भर करता है)। ध्यान दें, k शून्य नहीं हो सकता। यदि k None , तो इसे 1 समान माना जाता है।
  6. अपरिवर्तनीय अनुक्रमों को समेटने से हमेशा एक नई वस्तु प्राप्त होती है। इसका मतलब यह है कि बार-बार सुगमता से अनुक्रम बनाने से कुल अनुक्रम लंबाई में एक द्विघात रनटाइम लागत होगी। रैखिक रनटाइम लागत पाने के लिए, आपको नीचे दिए गए विकल्पों में से एक पर स्विच करना होगा:

    • अगर str.join() वस्तुओं को str.join() हैं, तो आप एक सूची बना सकते हैं और str.join() उपयोग कर सकते हैं या किसी io.StringIO उदाहरण पर लिख सकते हैं और पूरा होने पर उसका मान पुनः प्राप्त कर सकते हैं
    • यदि bytes ऑब्जेक्ट्स को bytes.join() हैं, तो आप इसी तरह bytes.join() या io.BytesIO उपयोग कर सकते हैं, या आप एक bytearray ऑब्जेक्ट के साथ इन-प्लेस io.BytesIO कर सकते हैं। bytearray ऑब्जेक्ट्स उत्परिवर्तनीय होते हैं और एक कुशल समग्र तंत्र होते हैं
    • यदि tuple वस्तुओं को tuple , तो इसके बजाय एक list विस्तार करें
    • अन्य प्रकारों के लिए, संबंधित वर्ग प्रलेखन की जांच करें
  7. कुछ अनुक्रम प्रकार (जैसे कि range ) केवल आइटम अनुक्रमों का समर्थन करते हैं जो विशिष्ट पैटर्न का पालन करते हैं, और इसलिए अनुक्रम संयोजन या पुनरावृत्ति का समर्थन नहीं करते हैं।
  8. जब x को s में नहीं पाया जाता है, तो ValueError बढ़ाता है। सभी कार्यान्वयन अतिरिक्त तर्क i और j से गुजरने का समर्थन नहीं करते हैं। ये तर्क अनुक्रम के उप-वर्गों की कुशल खोज की अनुमति देते हैं। अतिरिक्त तर्कों को पास करना लगभग s[i:j].index(x) का उपयोग करने के बराबर है, केवल बिना किसी डेटा की प्रतिलिपि किए और लौटाए गए अनुक्रम के साथ अनुक्रम के प्रारंभ के सापेक्ष होने के बजाय।

अपरिवर्तनीय अनुक्रम प्रकार

एकमात्र संचालन जो अपरिवर्तनीय अनुक्रम प्रकार आमतौर पर लागू होता है जो कि उत्परिवर्तनीय अनुक्रम प्रकारों द्वारा भी लागू नहीं किया जाता है, hash() निर्मित के लिए समर्थन है।

यह समर्थन अपरिवर्तनीय दृश्यों, जैसे कि frozenset इंस्टेंस, को frozenset कुंजी के रूप में इस्तेमाल करने और set और frozenset इंस्टेंस में संग्रहीत करने की अनुमति देता है।

एक अपरिवर्तनीय अनुक्रम हैश करने का प्रयास करना जिसमें अस्वाभाविक मूल्य शामिल हैं, जिसके परिणामस्वरूप टाइपर्रर होगा।

म्यूटेबल सीक्वेंस टाइप

निम्न तालिका में संचालन को उत्परिवर्तनीय अनुक्रम प्रकारों पर परिभाषित किया गया है। collections.abc.MutableSequence .abc.MutableSequence ABC को कस्टम अनुक्रम प्रकारों पर इन कार्यों को सही ढंग से कार्यान्वित करना आसान बनाने के लिए प्रदान किया जाता है।

तालिका s में एक उत्परिवर्तनीय अनुक्रम प्रकार का एक उदाहरण है, टी किसी भी चलने योग्य वस्तु है और x एक मनमानी वस्तु है जो किसी भी प्रकार और मूल्य प्रतिबंधों को एस द्वारा लगाया जाता है (उदाहरण के लिए, bytearray केवल पूर्णांक को स्वीकार करता है जो मूल्य प्रतिबंध 0 <= x <= 255 पूरा करता है। 0 <= x <= 255 )।

ऑपरेशन परिणाम टिप्पणियाँ
s[i] = x s का आइटम i , x द्वारा बदल दिया गया है
s[i:j] = t i से j तक s के स्लाइस को iterable t की सामग्री से बदल दिया जाता है
del s[i:j] समान के रूप में s[i:j] = []
s[i:j:k] = t s[i:j:k] के तत्वों को t के उन लोगों द्वारा प्रतिस्थापित किया जाता है (1)
del s[i:j:k] सूची से s[i:j:k] के तत्वों को निकालता है
s.append(x) अनुक्रम के अंत में x को जोड़ता है (उसी के रूप में s[len(s):len(s)] = [x] )
s.clear() एस से सभी आइटम हटाता है ( del s[:] रूप में del s[:] ) (5)
s.copy() s की उथली प्रति बनाता है ( s[:] ) (5)
s.extend(t) या s += t t की सामग्रियों के साथ s का विस्तार करता है (अधिकांश भाग s के समान है s[len(s):len(s)] = t ))
s *= n अद्यतन अपनी सामग्री के साथ n बार दोहराया (6)
s.insert(i, x) मेरे द्वारा दिए गए अनुक्रमणिका में x सम्मिलित करता है (उसी के रूप में s[i:i] = [x] )
s.pop([i]) आइटम को i पर पुनर्प्राप्त करता है और इसे s से भी निकालता है (2)
s.remove(x) पहला आइटम हटाएं जहां से s[i] x के बराबर है (3)
s.reverse() जगह में एस के आइटम उलट (4)

टिप्पणियाँ:

  1. टी की लंबाई उसी की होनी चाहिए जिस स्लाइस में यह जगह है।
  2. वैकल्पिक तर्क I -1 को डिफॉल्ट करता है, जिससे कि डिफ़ॉल्ट रूप से अंतिम आइटम हटा दिया जाता है और वापस आ जाता है।
  3. जब x को s में नहीं पाया जाता है, तो ValueError remove
  4. reverse() विधि बड़े अनुक्रम को उलटते समय अंतरिक्ष की अर्थव्यवस्था के लिए अनुक्रम को संशोधित करती है। उपयोगकर्ताओं को यह याद दिलाने के लिए कि यह साइड इफेक्ट द्वारा संचालित होता है, यह उलटा क्रम वापस नहीं करता है।
  5. clear() और copy() को म्यूट करने वाले कंटेनरों के इंटरफेस के साथ संगति के लिए शामिल किया गया है जो टुकड़ा करने की क्रिया का समर्थन नहीं करते हैं (जैसे dict रूप में)

    संस्करण 3.3 में नया: clear() और copy() तरीके।

  6. मान n एक पूर्णांक, या __index__() लागू करने __index__() वस्तु है। शून्य और n के नकारात्मक मान अनुक्रम को स्पष्ट करते हैं। अनुक्रम में आइटम कॉपी नहीं किए गए हैं; उन्हें कई बार संदर्भित किया जाता है, जैसा कि सामान्य अनुक्रम संचालन के तहत s * n के लिए समझाया गया है।

सूचियाँ

सूची परस्पर अनुक्रम हैं, आमतौर पर सजातीय वस्तुओं के संग्रह को संग्रहीत करने के लिए उपयोग किया जाता है (जहां समानता की सटीक डिग्री आवेदन द्वारा भिन्न होगी)।

class list([iterable])

सूचियों का निर्माण कई तरीकों से किया जा सकता है:

  • खाली सूची को दर्शाने के लिए वर्ग कोष्ठक की एक जोड़ी का उपयोग करना: []
  • वर्ग कोष्ठक का उपयोग करना, अल्पविराम से वस्तुओं को अलग करना: [a] , [a, b, c]
  • सूची समझ का उपयोग करना: [x for x in iterable]
  • टाइप कंस्ट्रक्टर का उपयोग करना: list() या list(iterable)

निर्माणकर्ता एक सूची बनाता है जिसके आइटम समान हैं और उसी क्रम में चलने योग्य आइटम हैं। iterable या तो एक अनुक्रम हो सकता है, एक कंटेनर जो पुनरावृत्ति का समर्थन करता है, या एक पुनरावृत्त वस्तु। यदि iterable पहले से ही एक सूची है, तो एक प्रतिलिपि बनाई जाती है और वापस की जाती है, iterable[:] समान iterable[:] । उदाहरण के लिए, list('abc') रिटर्न ['a', 'b', 'c'] और list( (1, 2, 3) ) रिटर्न [1, 2, 3] । यदि कोई तर्क नहीं दिया जाता है, तो निर्माता एक नई खाली सूची बनाता है।

कई अन्य ऑपरेशन भी सूची का निर्माण करते हैं, जिसमें sorted() बिल्ट-इन शामिल हैं।

सूचियाँ सभी सामान्य और mutable अनुक्रम कार्यों को कार्यान्वित करती हैं। सूचियाँ निम्नलिखित अतिरिक्त विधि भी प्रदान करती हैं:

sort(*, key=None, reverse=False)

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

sort() दो तर्क स्वीकार करता है जो केवल कीवर्ड द्वारा पारित किए जा सकते हैं ( कीवर्ड-केवल तर्क ):

कुंजी एक तर्क के एक फ़ंक्शन को निर्दिष्ट करती है जिसका उपयोग प्रत्येक सूची तत्व (उदाहरण के लिए, key=str.lower ) से तुलना कुंजी निकालने के लिए किया जाता है। सूची में प्रत्येक आइटम के अनुरूप कुंजी की गणना एक बार की जाती है और फिर संपूर्ण छँटाई प्रक्रिया के लिए उपयोग की जाती है। None का डिफ़ॉल्ट मान का अर्थ है कि सूची आइटम सीधे एक अलग कुंजी मान की गणना के बिना क्रमबद्ध हैं।

एक कार्यात्मक फ़ंक्शन को 2.x शैली cmp फ़ंक्शन को एक महत्वपूर्ण फ़ंक्शन में बदलने के लिए functools.cmp_to_key() उपयोगिता उपलब्ध है।

रिवर्स एक बूलियन मूल्य है। यदि इसे True सेट किया जाता है, तो सूची तत्वों को क्रमबद्ध किया जाता है जैसे कि प्रत्येक तुलना को उलट दिया गया हो।

यह विधि एक बड़े अनुक्रम को छांटते समय अंतरिक्ष की अर्थव्यवस्था के लिए अनुक्रम को संशोधित करती है। उपयोगकर्ताओं को यह याद दिलाने के लिए कि यह साइड इफेक्ट से संचालित होता है, यह क्रमबद्ध अनुक्रम (उपयोग sorted() को स्पष्ट रूप से नए सॉर्ट किए गए सूची उदाहरण के लिए अनुरोध नहीं करता है।

sort() विधि स्थिर होने की गारंटी है। एक प्रकार स्थिर है यदि यह समान की तुलना करने वाले तत्वों के सापेक्ष क्रम को नहीं बदलने की गारंटी देता है - यह कई पास में छांटने के लिए सहायक है (उदाहरण के लिए, विभाग द्वारा क्रमबद्ध, फिर वेतन ग्रेड द्वारा)।

CPython कार्यान्वयन विवरण: जबकि एक सूची को छांटा जा रहा है, उत्परिवर्तन के प्रयास का प्रभाव, या यहां तक ​​कि निरीक्षण, सूची अपरिभाषित है। पायथन का सी कार्यान्वयन सूची को अवधि के लिए खाली दिखाई देता है, और ValueError बढ़ाता है यदि यह पता लगा सकता है कि सूची एक प्रकार के दौरान उत्परिवर्तित हो गई है।

tuples

ट्यूपल्स अपरिवर्तनीय अनुक्रम हैं, आमतौर पर विषम डेटा (जैसे कि 2-ट्यूपल्स द्वारा निर्मित enumerate() बिल्ट-इन) के संग्रह को संग्रहीत करने के लिए उपयोग किया जाता है। ट्यूपल्स का उपयोग उन मामलों के लिए भी किया जाता है जहां सजातीय डेटा के अपरिवर्तनीय अनुक्रम की आवश्यकता होती है (जैसे कि एक set या dict में भंडारण की अनुमति देना)।

class tuple([iterable])

ट्यूपल्स का निर्माण कई तरीकों से किया जा सकता है:

  • खाली टपल को दर्शाने के लिए कोष्ठक की एक जोड़ी का उपयोग करना: ()
  • सिंगलटन टपल के लिए अनुगामी अल्पविराम का उपयोग करना: a, या (a,)
  • अल्पविराम से अलग आइटम: a, b, c या (a, b, c)
  • tuple बिल्ट-इन: tuple() या tuple(iterable)

कंस्ट्रक्टर एक टपल का निर्माण करता है, जिसकी वस्तुएं समान हैं और उसी क्रम में चलने योग्य आइटम हैं। iterable या तो एक अनुक्रम हो सकता है, एक कंटेनर जो पुनरावृत्ति का समर्थन करता है, या एक पुनरावृत्त वस्तु। यदि चलने योग्य पहले से ही एक टपल है, तो इसे अपरिवर्तित लौटा दिया जाता है। उदाहरण के लिए, tuple('abc') रिटर्न ('a', 'b', 'c') और tuple( [1, 2, 3] ) रिटर्न (1, 2, 3) । यदि कोई तर्क नहीं दिया जाता है, तो निर्माता एक नया खाली टपल बनाता है, ()

ध्यान दें कि यह वास्तव में अल्पविराम है जो एक कोष्ठक बनाता है, कोष्ठक नहीं। कोष्ठक वैकल्पिक हैं, खाली टपल मामले को छोड़कर, या जब उन्हें वाक्यात्मक अस्पष्टता से बचने की आवश्यकता होती है। उदाहरण के लिए, f(a, b, c) तीन तर्कों के साथ एक फ़ंक्शन कॉल है, जबकि f((a, b, c)) एकमात्र तर्क के रूप में 3-ट्यूपल के साथ एक फ़ंक्शन कॉल है।

ट्यूपल सभी सामान्य अनुक्रम संचालन को लागू करते हैं ।

डेटा के विषम संग्रहों के लिए जहां सूचकांक द्वारा पहुंच की तुलना में नाम से पहुंच स्पष्ट है, collections.namedtuple() एक साधारण टपल ऑब्जेक्ट की तुलना में अधिक उपयुक्त विकल्प हो सकता है।

सीमाओं

range प्रकार संख्या के अपरिवर्तनीय अनुक्रम का प्रतिनिधित्व करता है और आमतौर पर में समय की एक विशिष्ट संख्या पाशन के लिए प्रयोग किया जाता है for छोरों।

class range(stop)
class range(start, stop[, step])

रेंज कंस्ट्रक्टर के तर्क पूर्णांक (या तो बिल्ट-इन int() या __index__ विशेष विधि लागू करने वाली कोई भी वस्तु ) होने चाहिए। यदि चरण तर्क को छोड़ दिया जाता है, तो यह चूक करता है 1 । यदि प्रारंभ तर्क छोड़ दिया जाता है, तो यह चूक हो जाती है 0 । यदि चरण शून्य है, ValueError उठाया जाता है।

एक सकारात्मक कदम के लिए , एक श्रेणी की सामग्री r सूत्र द्वारा निर्धारित की जाती है r[i] = start + step*i जहां i >= 0 और r[i] < stop

एक नकारात्मक कदम के लिए , सीमा की सामग्री अभी भी सूत्र द्वारा निर्धारित की जाती है r[i] = start + step*i , लेकिन बाधाएं हैं i >= 0 और r[i] > stop

r[0] मान अवरोध से पूरा नहीं होने पर एक श्रेणी ऑब्जेक्ट खाली हो जाएगा । रेंज नकारात्मक सूचकांकों का समर्थन करते हैं, लेकिन इन्हें सकारात्मक सूचकांकों द्वारा निर्धारित अनुक्रम के अंत से अनुक्रमण के रूप में व्याख्या की जाती है।

पूर्ण मूल्यों से बड़े रंग sys.maxsize अनुमत हैं, लेकिन कुछ विशेषताएं (जैसे len() ) बढ़ा सकती हैं OverflowError

रेंज उदाहरण:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

रेंज कॉन्टेक्शन और रिपिटेशन को छोड़कर सभी सामान्य सीक्वेंस ऑपरेशंस को लागू करते हैं (इस तथ्य के कारण कि रेंज ऑब्जेक्ट केवल ऐसे सिक्वेंस का प्रतिनिधित्व कर सकते हैं जो एक सख्त पैटर्न और रिपीटेशन का पालन करते हैं और कॉन्टैक्शन आमतौर पर उस पैटर्न का उल्लंघन करते हैं)।

start

प्रारंभ पैरामीटर का मान (या 0 यदि पैरामीटर आपूर्ति नहीं किया गया था)

stop

स्टॉप पैरामीटर का मान

step

चरण पैरामीटर का मान (या 1 यदि पैरामीटर आपूर्ति नहीं किया गया था)

range एक नियमित रूप से टाइप का लाभ list या tuple यह है कि एक range ऑब्जेक्ट हमेशा एक ही (छोटी) मेमोरी की मात्रा लेगा, कोई फर्क नहीं पड़ता कि यह किस रेंज का प्रतिनिधित्व करता है (क्योंकि यह केवल स्टोर करता है start , stop और step मान, अलग-अलग आइटम और सबरेंज की गणना करता है जरूरत है)।

रेंज ऑब्जेक्ट collections.abc.Sequence एबीसी को लागू करते हैं , और नकारात्मक परीक्षणों के लिए कंटेंट टेस्ट, एलिमेंट इंडेक्स लुकिंग, स्लाइसिंग और समर्थन जैसी सुविधाएँ प्रदान करते हैं ( अनुक्रम प्रकार देखें - सूची, टपल, रेंज ):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

परीक्षण के साथ समानता के लिए वस्तुओं की सीमा होती है == और != उन्हें अनुक्रम के रूप में तुलना करता है। अर्थात्, दो श्रेणी की वस्तुओं को समान माना जाता है यदि वे समान अनुक्रम मानों का प्रतिनिधित्व करते हैं। (ध्यान दें कि दो रेंज ऑब्जेक्ट्स जो समान की तुलना करते हैं start , अलग-अलग हो सकते हैं , stop और step विशेषताएँ, उदाहरण के लिए range(0) == range(2, 1, 3) या range(0, 3, 2) == range(0, 4, 2) ।)

संस्करण 3.2 में परिवर्तित: अनुक्रम एबीसी को लागू करें। समर्थन टुकड़ा करने की क्रिया और नकारात्मक सूचकांकों। int() सभी वस्तुओं के माध्यम से पुनरावृति के बजाय निरंतर समय में सदस्यता के लिए वस्तुओं का परीक्षण करें।

संस्करण 3.3 में बदला गया: परिभाषित की गई अनुक्रम के आधार पर श्रेणी की वस्तुओं की तुलना करने के लिए '==' और '=' को परिभाषित करें (ऑब्जेक्ट पहचान के आधार पर तुलना करने के बजाय)।

संस्करण 3.3 में नया: The start , stop और step विशेषताएँ।

यह भी देखें

  • Linspace नुस्खा कैसे चल बिन्दु अनुप्रयोगों के लिए उपयुक्त रेंज के एक आलसी संस्करण को लागू को दर्शाता है।

पाठ अनुक्रम प्रकार - str

पायथन में टेक्स्ट डेटा को str() ऑब्जेक्ट्स या स्ट्रिंग्स के साथ संभाला जाता है । स्ट्रिंग्स यूनिकोड कोड बिंदुओं के अपरिवर्तनीय अनुक्रम हैं । स्ट्रिंग शाब्दिक तरीके से लिखे गए हैं:

  • एकल कोट: 'allows embedded "double" quotes'
  • डबल उद्धरण: "allows embedded 'single' quotes"
  • ट्रिपल उद्धृत किया: '''Three single quotes''' , """Three double quotes"""

ट्रिपल उद्धृत स्ट्रिंग में कई लाइनें हो सकती हैं - सभी संबंधित व्हाट्सएप को स्ट्रिंग शाब्दिक में शामिल किया जाएगा।

स्ट्रिंग शाब्दिक जो एक एकल अभिव्यक्ति का हिस्सा हैं और उनके बीच केवल व्हाट्सएप है, को एक स्ट्रिंग स्ट्रिंग शाब्दिक रूप से परिवर्तित किया जाएगा। यही कारण है, ("spam " "eggs") == "spam eggs"

देखें स्ट्रिंग और बाइट्स शाब्दिक शाब्दिक स्ट्रिंग के विभिन्न रूपों, समर्थित भागने दृश्यों सहित, और के बारे में अधिक के लिए r ( "कच्चे") उपसर्ग है कि सबसे एस्केप अनुक्रम प्रसंस्करण अक्षम करता है।

str() कंस्ट्रक्टर का उपयोग करके अन्य वस्तुओं से भी तार बनाए जा सकते हैं ।

चूंकि कोई अलग "वर्ण" प्रकार नहीं है, इसलिए स्ट्रिंग को अनुक्रमणित करना लंबाई के तार पैदा करता है। 1. यह है, गैर-रिक्त स्ट्रिंग s के लिए s[0] == s[0:1]

वहाँ भी कोई परिवर्तनशील स्ट्रिंग प्रकार है, लेकिन str.join() या io.StringIO कुशलता से कई टुकड़े से श्रृंखला बनाते हैं के लिए इस्तेमाल किया जा सकता है।

संस्करण 3.3 में बदला: पायथन 2 श्रृंखला के साथ पीछे की संगतता के लिए, u उपसर्ग को एक बार फिर से स्ट्रिंग शाब्दिक पर अनुमति दी गई है। स्ट्रिंग शाब्दिक के अर्थ पर इसका कोई प्रभाव नहीं है और इसे r उपसर्ग के साथ जोड़ा नहीं जा सकता है ।

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

ऑब्जेक्ट का एक स्ट्रिंग संस्करण लौटाएं । यदि ऑब्जेक्ट प्रदान नहीं किया गया है, तो खाली स्ट्रिंग लौटाता है। अन्यथा, इस पर निर्भर करता है कि एन्कोडिंग या त्रुटियां दी गई हैं, इस पर निर्भर करता है। str()

यदि न तो एन्कोडिंग और न ही त्रुटियां दी जाती हैं, तो str(object) रिटर्न object.__str__() , जो कि "अनौपचारिक" या वस्तु का अच्छा मुद्रण योग्य स्ट्रिंग प्रतिनिधित्व है । स्ट्रिंग ऑब्जेक्ट्स के लिए, यह स्ट्रिंग ही है। यदि वस्तु में एक object.__str__() विधि नहीं है , तो str() वापस लौटने के लिए गिर जाता है repr()

यदि एन्कोडिंग या त्रुटियों में से कम से कम एक दिया जाता है, तो वस्तु एक बाइट्स जैसी वस्तु (जैसे bytes या bytearray ) होनी चाहिए । इस स्थिति में, यदि ऑब्जेक्ट एक bytes (या bytearray ) ऑब्जेक्ट है, तो str(bytes, encoding, errors) इसके बराबर है bytes.decode(encoding, errors) । अन्यथा, बाइट ऑब्जेक्ट अंतर्निहित बफ़र ऑब्जेक्ट को कॉल करने से पहले प्राप्त किया जाता है bytes.decode() । देखें बाइट्स, bytearray, memoryview - द्विआधारी अनुक्रम प्रकार और बफर प्रोटोकॉल बफर वस्तुओं के बारे में जानकारी के लिए।

एन्कोडिंग या त्रुटियों के बिना एक bytes ऑब्जेक्ट पास करना तर्क अनौपचारिक स्ट्रिंग प्रतिनिधित्व को वापस करने के पहले मामले के तहत आता है ( पायथन को कमांड-लाइन विकल्प भी देखें )। str() -b उदाहरण के लिए:

>>> str(b'Zoot!')
"b'Zoot!'"

str कक्षा और उसके तरीकों के बारे में अधिक जानकारी के लिए , पाठ अनुक्रम प्रकार - str और नीचे स्ट्रिंग विधियाँ देखें। स्वरूपित स्ट्रिंग्स को आउटपुट करने के लिए, फ़ॉर्मेट किए गए स्ट्रिंग शाब्दिक और स्वरूप स्ट्रिंग सिंटैक्स अनुभाग देखें। इसके अलावा, टेक्स्ट प्रोसेसिंग सर्विसेज सेक्शन देखें।

स्ट्रिंग के तरीके

स्ट्रिंग्स सभी सामान्य अनुक्रम संचालन को लागू करते हैं , साथ ही नीचे वर्णित अतिरिक्त तरीकों के साथ।

स्ट्रिंग स्ट्रिंग प्रारूपण की दो शैलियों का भी समर्थन करते हैं, एक जो लचीलेपन और अनुकूलन की एक बड़ी डिग्री प्रदान करता है (देखें str.format() , प्रारूप स्ट्रिंग सिंटैक्स और कस्टम स्ट्रिंग प्रारूपण ) और दूसरा C printf शैली प्रारूपण के आधार पर जो संकीर्ण प्रकार की रेंज को संभालता है और उपयोग करने के लिए थोड़ा कठिन है सही ढंग से, लेकिन अक्सर उन मामलों के लिए तेज होता है जो इसे प्रिंट कर सकते हैं ( प्रिंटफ-स्टाइल स्ट्रिंग फॉर्मेटिंग )।

मानक लाइब्रेरी का टेक्स्ट प्रोसेसिंग सर्विसेज अनुभाग कई अन्य मॉड्यूल को कवर करता है जो विभिन्न पाठ संबंधी उपयोगिताओं ( re मॉड्यूल में नियमित अभिव्यक्ति समर्थन सहित ) प्रदान करते हैं।

str.capitalize()

स्ट्रिंग की एक प्रति लौटाएँ जिसके पहले वर्ण को बड़ा किया गया है और शेष को नीचे उतारा गया है।

str.casefold()

स्ट्रिंग की एक Casefolded प्रतिलिपि लौटाएँ। केसफॉल्ड स्ट्रिंग्स का उपयोग केसलेस मिलान के लिए किया जा सकता है।

Casefolding लोअरकेसिंग के समान है लेकिन अधिक आक्रामक है क्योंकि यह एक स्ट्रिंग में सभी मामले के अंतर को हटाने का इरादा है। उदाहरण के लिए, जर्मन लोअरकेस अक्षर 'ß' के बराबर है "ss" । चूंकि यह पहले से ही छोटा है, इसलिए lower() इससे कुछ नहीं होगा 'ß' ; casefold() इसे धर्मान्तरित करता है "ss"

केसफॉल्डिंग एल्गोरिथ्म यूनिकोड मानक के खंड 3.13 में वर्णित है।

संस्करण 3.3 में नया।

str.center(width[, fillchar])

लंबाई चौड़ाई की एक स्ट्रिंग में केंद्रित रिटर्न । पैडिंग निर्दिष्ट फ़िलचर का उपयोग करके किया जाता है (डिफ़ॉल्ट एक ASCII स्थान है)। मूल स्ट्रिंग लौटा दी जाती है यदि चौड़ाई कम से कम या इसके बराबर होती है len(s)

str.count(sub[, start[, end]])

सीमा में सबरिंग उप की गैर-अतिव्यापी घटनाओं की संख्या लौटाएं [ प्रारंभ , अंत ]। वैकल्पिक तर्क शुरू और अंत में स्लाइस अंकन के रूप में व्याख्या की जाती है।

str.encode(encoding="utf-8", errors="strict")

बाइट ऑब्जेक्ट के रूप में स्ट्रिंग का एन्कोडेड संस्करण लौटाएं। डिफ़ॉल्ट एन्कोडिंग है 'utf-8' त्रुटियों को एक अलग त्रुटि हैंडलिंग योजना निर्धारित करने के लिए दिया जा सकता है। त्रुटियों के लिए डिफ़ॉल्ट है 'strict' , जिसका अर्थ है कि एन्कोडिंग त्रुटियाँ एक उठाती हैं UnicodeError । अन्य संभावित मान रहे हैं 'ignore' , 'replace' , 'xmlcharrefreplace' , 'backslashreplace' और किसी अन्य नाम के माध्यम से पंजीकृत codecs.register_error() , खंड देखें त्रुटि हैंडलर । संभावित एन्कोडिंग की सूची के लिए, सेक्शन स्टैंडर्ड एनकोडिंग देखें ।

संस्करण 3.1 में बदला गया: कीवर्ड तर्कों के लिए समर्थन जोड़ा गया।

str.endswith(suffix[, start[, end]])

True यदि स्ट्रिंग निर्दिष्ट प्रत्यय के साथ समाप्त होती है, तो वापस लौटें , अन्यथा वापस लौटें False प्रत्यय भी देखने के लिए प्रत्ययों का एक प्रकार हो सकता है। वैकल्पिक शुरुआत के साथ , उस स्थिति में शुरुआत का परीक्षण करें। वैकल्पिक अंत के साथ , उस स्थिति में तुलना करना बंद करें।

str.expandtabs(tabsize=8)

वर्तमान स्तंभ और दिए गए टैब आकार के आधार पर, स्ट्रिंग की एक प्रति लौटाएं जहां सभी टैब वर्ण एक या एक से अधिक रिक्त स्थान द्वारा प्रतिस्थापित किए जाते हैं। टैब पदों हर घटित tabsize वर्ण (डिफ़ॉल्ट 8, कॉलम 0, 8, 16 और इतने पर पर टैब पदों दे रही है)। स्ट्रिंग का विस्तार करने के लिए, वर्तमान कॉलम को शून्य पर सेट किया जाता है और स्ट्रिंग को चरित्र द्वारा जांचा जाता है। यदि वर्ण एक टैब ( \t ) है, तो परिणाम में एक या अधिक स्थान वर्ण तब तक डाले जाते हैं जब तक कि वर्तमान स्तंभ अगले टैब स्थिति के बराबर न हो। (टैब वर्ण स्वयं कॉपी नहीं किया गया है।) यदि चरित्र एक नई रेखा है ( \n या) \r ), इसे कॉपी किया जाता है और वर्तमान कॉलम शून्य पर रीसेट हो जाता है। किसी भी अन्य चरित्र को अपरिवर्तित कॉपी किया जाता है और वर्तमान कॉलम को एक के द्वारा बढ़ाया जाता है, भले ही चरित्र का प्रतिनिधित्व कैसे किया जाए।

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'
str.find(sub[, start[, end]])

स्ट्रिंग में सबसे कम इंडेक्स लौटाएं जहां सबरिंग सब टुकड़ा के भीतर पाया जाता है s[start:end] । वैकल्पिक तर्क शुरू और अंत में स्लाइस अंकन के रूप में व्याख्या की जाती है। -1 यदि उप नहीं मिला है तो वापस लौटें ।

ध्यान दें

find() विधि केवल इस्तेमाल किया जाना चाहिए अगर आप की स्थिति पता करने की जरूरत उप । यह जाँचने के लिए कि उप एक सबरिंग है या नहीं, in ऑपरेटर का उपयोग करें :

>>> 'Py' in 'Python'
True
str.format(*args, **kwargs)

एक स्ट्रिंग स्वरूपण ऑपरेशन करें। जिस स्ट्रिंग पर यह विधि कहा जाता है, उसमें शाब्दिक पाठ या प्रतिस्थापन फ़ील्ड ब्रेसिज़ द्वारा सीमांकित हो सकते हैं {} । प्रत्येक प्रतिस्थापन फ़ील्ड में या तो स्थितीय तर्क का संख्यात्मक सूचकांक होता है, या कीवर्ड तर्क का नाम होता है। स्ट्रिंग की एक प्रति लौटाता है जहां प्रत्येक प्रतिस्थापन फ़ील्ड को इसी तर्क के स्ट्रिंग मान से बदल दिया जाता है।

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

प्रारूप स्ट्रिंग में निर्दिष्ट किए जा सकने वाले विभिन्न स्वरूपण विकल्पों के विवरण के लिए प्रारूप स्ट्रिंग सिंटैक्स देखें ।

ध्यान दें

जब एक नंबर (स्वरूपण int() , float() , complex() , decimal.Decimal और उपवर्ग) के साथ n प्रकार (पूर्व: '{:n}'.format(1234) ), समारोह अस्थायी रूप से सेट LC_CTYPE करने के लिए स्थान LC_NUMERIC स्थान डिकोड करने के लिए decimal_point और thousands_sep के क्षेत्र localeconv() में यदि वे गैर- ASCII या उससे अधिक समय से 1 बाइट, कर रहे हैं और LC_NUMERIC स्थान अलग है LC_CTYPE लोकेल की तुलना में । यह अस्थायी परिवर्तन अन्य थ्रेड्स को प्रभावित करता है।

संस्करण 3.7 में परिवर्तित: n प्रकार के साथ एक संख्या को स्वरूपित करते समय , फ़ंक्शन कुछ मामलों में अस्थायी रूप से LC_CTYPE लोकेल को सेट करता है LC_NUMERIC

str.format_map(mapping)

के समान str.format(**mapping) है, सिवाय इसके कि mapping प्रयोग किया जाता है सीधे और नहीं एक में कॉपी किया dict । यह उपयोगी है अगर उदाहरण के mapping लिए एक तानाशाही उपवर्ग है:

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

संस्करण 3.2 में नया।

str.index(sub[, start[, end]])

जैसे find() , लेकिन बढ़ाएं ValueError जब सबस्ट्रिंग नहीं मिला।

str.isalnum()

यदि स्ट्रिंग में सभी वर्ण अल्फ़ान्यूमेरिक हैं और सही है, तो कम से कम एक वर्ण है, अन्यथा सही लौटें। एक चरित्र c अक्षरांकीय है निम्नलिखित रिटर्न में से एक है, तो True : c.isalpha() , c.isdecimal() , c.isdigit() , या c.isnumeric()

str.isalpha()

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

str.isascii()

यदि स्ट्रिंग खाली है या स्ट्रिंग में सभी वर्ण ASCII हैं, तो सही अन्यथा वापस लौटें। ASCII वर्णों के कोड अंक U + 0000-U + 007F हैं।

संस्करण 3.7 में नया।

str.isdecimal()

यदि स्ट्रिंग में सभी वर्ण दशमलव वर्ण हैं तो सही लौटें और कम से कम एक वर्ण हो, अन्यथा गलत। दशमलव वर्ण वे होते हैं जिनका उपयोग आधार 10 में संख्याएँ बनाने के लिए किया जा सकता है, जैसे U + 0660, ARABIC-INDIC DIGIT DERO। औपचारिक रूप से एक दशमलव चरित्र यूनिकोड जनरल श्रेणी "एनडी" में एक चरित्र है।

str.isdigit()

यदि स्ट्रिंग के सभी वर्ण अंक हैं, तो सही लौटें और कम से कम एक वर्ण हो, अन्यथा गलत। अंकों में दशमलव वर्ण और अंक शामिल होते हैं जिन्हें विशेष हैंडलिंग की आवश्यकता होती है, जैसे संगतता सुपरस्क्रिप्ट अंक। इस अंक को कवर किया जाता है जिसे आधार 10 में संख्याएँ बनाने के लिए इस्तेमाल नहीं किया जा सकता है, जैसे कि खरोष्ठी संख्याएँ। औपचारिक रूप से, एक अंक एक ऐसा चरित्र है जिसका गुण मान Numeric_Type = Digit या Numeric_Type = दशमलव होता है।

str.isidentifier()

यदि भाषा की परिभाषा, अनुभाग पहचानकर्ता और कीवर्ड के अनुसार स्ट्रिंग एक मान्य पहचानकर्ता है तो सही लौटें ।

keyword.iskeyword() आरक्षित पहचानकर्ताओं जैसे def और के लिए परीक्षण करने के लिए उपयोग करें class

str.islower()

यदि स्ट्रिंग में सभी आवरण वाले अक्षर [4] कम हों तो सही लौटें और कम से कम एक आवरण वाला पात्र हो, अन्यथा गलत।

str.isnumeric()

यदि स्ट्रिंग में सभी वर्ण संख्यात्मक वर्ण हैं और सही है, तो सही लौटें, अन्यथा कम से कम एक वर्ण, असत्य है। सांख्यिक वर्णों में अंक वर्ण शामिल होते हैं, और सभी वर्ण जिनमें यूनिकोड संख्यात्मक मान गुण होते हैं, जैसे U + 2155, VULGAR FRACTION ONE FIFTH। औपचारिक रूप से, संख्यात्मक वर्ण वे होते हैं, जिनका गुण मान Numeric_Type = Digit, Numeric_Type = दशमलव या Numeric_Type = Numeric होता है।

str.isprintable()

यदि स्ट्रिंग के सभी वर्ण मुद्रण योग्य हैं या स्ट्रिंग खाली है, तो सही है, अन्यथा वापस लौटें। गैर-वर्णनीय वर्ण यूनिकोड वर्ण डेटाबेस में "अन्य" या "विभाजक" के रूप में परिभाषित किए गए अक्षर हैं, सिवाय ASCII स्थान (0x20) के जो मुद्रण योग्य माना जाता है। (ध्यान दें कि इस संदर्भ में प्रिंट करने योग्य पात्रों में वे जो जब नहीं किया जाना चाहिए रहे हैं repr() एक स्ट्रिंग पर शुरू हो जाती है। यह करने के लिए लिखा तार की हैंडलिंग पर कोई प्रभाव नहीं sys.stdout या sys.stderr ।)

str.isspace()

यदि स्ट्रिंग में केवल व्हाट्सएप वर्ण हैं तो सही लौटें और कम से कम एक वर्ण हो, अन्यथा गलत। व्हॉट्सएप वर्ण यूनिकोड वर्ण डेटाबेस में "अन्य" या "विभाजक" के रूप में परिभाषित किए गए वर्ण हैं और जो द्विदिशीय संपत्ति "डब्ल्यूएस", "बी", या "एस" में से एक हैं।

str.istitle()

यह सच है कि यदि स्ट्रिंग एक शीर्षकित स्ट्रिंग है और कम से कम एक वर्ण है, उदाहरण के लिए अपरकेस वर्ण केवल अनकहे वर्णों का अनुसरण कर सकते हैं और केवल आवरण वाले वर्णों को कम कर सकते हैं। अन्यथा झूठे लौटो।

str.isupper()

यदि स्ट्रिंग में सभी कैसड कैरेक्टर [4] , तो वापस लौटें और कम से कम एक कैस्ड कैरेक्टर है, अन्यथा गलत।

str.join(iterable)

एक स्ट्रिंग लौटाएं जो पुनरावृत्तियों में स्ट्रिंग का संघनन है । एक TypeError अगर वहाँ किसी भी नॉन-स्ट्रिंग मान हैं बढ़ा दी जाएगी iterable , सहित bytes वस्तुओं। तत्वों के बीच विभाजक इस विधि को प्रदान करने वाला स्ट्रिंग है।

str.ljust(width[, fillchar])

लंबाई चौड़ाई की एक स्ट्रिंग में सही छोड़ दिया स्ट्रिंग लौटें । पैडिंग निर्दिष्ट फ़िलचर का उपयोग करके किया जाता है (डिफ़ॉल्ट एक ASCII स्थान है)। मूल स्ट्रिंग लौटा दी जाती है यदि चौड़ाई कम से कम या इसके बराबर होती है len(s)

str.lower()

सभी आवरण पात्रों के साथ स्ट्रिंग की एक प्रति लौटाएं [4] जिसे लोअरकेस में परिवर्तित किया गया है।

उपयोग किए गए लोअरस्किंग एल्गोरिथ्म को यूनिकोड मानक के खंड 3.13 में वर्णित किया गया है।

str.lstrip([chars])

हटाए गए प्रमुख पात्रों के साथ स्ट्रिंग की एक प्रति लौटाएं। वर्ण तर्क एक स्ट्रिंग में सेट निर्दिष्ट करने हटाया जा रहा है। यदि छोड़ दिया या None , वर्ण तर्क व्हाट्सएप को हटाने के लिए चूक करता है। वर्ण तर्क एक उपसर्ग नहीं है; बल्कि, इसके मूल्यों के सभी संयोजन छीन लिए गए हैं:

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'
static str.maketrans(x[, y[, z]])

यह स्थिर विधि अनुवाद तालिका के लिए प्रयोग करने योग्य है str.translate()

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

यदि दो तर्क हैं, तो उन्हें समान लंबाई के तार होने चाहिए, और परिणामस्वरूप शब्दकोश में, x में प्रत्येक वर्ण को उसी स्थिति में y के समान वर्ण में मैप किया जाएगा। यदि तीसरा तर्क है, तो उसे एक स्ट्रिंग होना चाहिए, जिसके पात्रों को None परिणाम में मैप किया जाएगा ।

str.partition(sep)

सेप की पहली घटना पर स्ट्रिंग को विभाजित करें , और विभाजक से पहले भाग वाले विभाजक के बाद एक 3-ट्यूपल लौटें, और विभाजक के बाद का हिस्सा। यदि विभाजक नहीं मिला है, तो स्ट्रिंग से युक्त 3-ट्यूपल को वापस करें, इसके बाद दो खाली तार हैं।

str.replace(old, new[, count])

स्ट्रिंग की एक प्रति लौटाएं जिसमें पुराने द्वारा प्रतिस्थापित किए गए सभी आवृत्तियों को नई से बदल दिया जाए । यदि वैकल्पिक तर्क गणना दी जाती है, तो केवल पहली गणना घटित होती है।

str.rfind(sub[, start[, end]])

स्ट्रिंग में उच्चतम इंडेक्स पर लौटें जहां सबरिंग उप पाया जाता है, जैसे कि उप भीतर निहित है s[start:end] । वैकल्पिक तर्क शुरू और अंत में स्लाइस अंकन के रूप में व्याख्या की जाती है। -1 असफलता पर लौटें ।

str.rindex(sub[, start[, end]])

जैसे कि rfind() लेकिन ValueError तब उठता है जब सबस्ट्रिंग उप नहीं पाया जाता है।

str.rjust(width[, fillchar])

लंबाई चौड़ाई की एक स्ट्रिंग में सही स्ट्रिंग वापस लौटें । पैडिंग निर्दिष्ट फ़िलचर का उपयोग करके किया जाता है (डिफ़ॉल्ट एक ASCII स्थान है)। मूल स्ट्रिंग लौटा दी जाती है यदि चौड़ाई कम से कम या इसके बराबर होती है len(s)

str.rpartition(sep)

सेप की अंतिम घटना पर स्ट्रिंग को विभाजित करें , और विभाजक से पहले वाले हिस्से, और विभाजक के बाद वाले हिस्से से युक्त 3-टपल लौटें। यदि विभाजक नहीं मिला है, तो दो खाली तारों वाले 3-टपल लौटें, इसके बाद स्ट्रिंग भी।

str.rsplit(sep=None, maxsplit=-1)

सीम में सीमांकक स्ट्रिंग के रूप में शब्दों की सूची लौटाएं । अगर मैक्सप्लिट दिया जाता है, तो अधिकतम अधिकतम छींटों पर किया जाता है, सबसे सही । यदि सेप निर्दिष्ट नहीं है या None , कोई व्हाट्सएप स्ट्रिंग एक विभाजक है। दाईं ओर से विभाजन को छोड़कर, rsplit() ऐसा व्यवहार करता है split() जिसका वर्णन नीचे विस्तार से किया गया है।

str.rstrip([chars])

हटाए गए पात्रों के साथ स्ट्रिंग की एक प्रति लौटाएं। वर्ण तर्क एक स्ट्रिंग में सेट निर्दिष्ट करने हटाया जा रहा है। यदि छोड़ दिया या None , वर्ण तर्क व्हाट्सएप को हटाने के लिए चूक करता है। वर्ण तर्क एक प्रत्यय नहीं है; बल्कि, इसके मूल्यों के सभी संयोजन छीन लिए गए हैं:

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
str.split(sep=None, maxsplit=-1)

सीम में सीमांकक स्ट्रिंग के रूप में शब्दों की सूची लौटाएं । यदि मैक्सप्लिट दिया जाता है, तो अधिकतम मैक्सप्लिट विभाजन किया जाता है (इस प्रकार, सूची में अधिकांश maxsplit+1 तत्व होंगे)। यदि मैक्सप्लिट निर्दिष्ट नहीं है या -1 , तो विभाजन की संख्या पर कोई सीमा नहीं है (सभी संभव विभाजन किए गए हैं)।

यदि सेप दिया जाता है, तो लगातार सीमांकक को एक साथ समूहीकृत नहीं किया जाता है और खाली तारों को परिसीमित करने के लिए समझा जाता है (उदाहरण के लिए, '1,,2'.split(',') रिटर्न ['1', '', '2'] ) सितम्बर तर्क कई पात्रों (उदाहरण के लिए, शामिल हो सकते हैं '1<>2<>3'.split('<>') रिटर्न ['1', '2', '3'] )। एक निर्दिष्ट विभाजक रिटर्न के साथ एक खाली स्ट्रिंग को विभाजित करना ['']

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

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']

यदि सेप निर्दिष्ट नहीं है या नहीं है None , तो एक अलग विभाजन एल्गोरिथ्म लागू किया जाता है: लगातार व्हाट्सएप के रन को एक एकल विभाजक के रूप में माना जाता है, और यदि स्ट्रिंग में अग्रणी या अनुगामी श्वेतरेखा है, तो परिणाम प्रारंभ या अंत में कोई खाली स्ट्रिंग नहीं होगा। नतीजतन, एक None विभाजक रिटर्न के साथ खाली व्हाट्सएप युक्त एक स्ट्रिंग या एक स्ट्रिंग को विभाजित करना []

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

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']
str.splitlines([keepends])

स्ट्रिंग की पंक्तियों की सूची लौटाएं, लाइन की सीमाओं को तोड़ते हुए। परिणामी सूची में लाइन ब्रेक को शामिल नहीं किया जाता है जब तक कि रख-रखाव और सत्य नहीं दिया जाता है।

यह विधि निम्नलिखित पंक्ति सीमाओं पर विभाजित होती है। विशेष रूप से, सीमाएं सार्वभौमिक newlines की एक सुपरसेट हैं ।

प्रतिनिधित्व विवरण
\n रेखा भरण
\r कैरिज रिटर्न
\r\n कैरिज रिटर्न + लाइन फीड
\v या \x0b रेखा सारणीकरण
\f या \x0c फ़ीड बनाएं
\x1c फाइल सेपरेटर
\x1d समूह विभाजक
\x1e रिकॉर्ड सेपरेटर
\x85 अगली पंक्ति (C1 नियंत्रण कोड)
\u2028 लाइन सेपरेटर
\u2029 पैराग्राफ सेपरेटर

3.2 संस्करण में बदला: \v और \f लाइन सीमाओं की सूची में जोड़ा गया।

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

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

split() जब एक सीमांकक स्ट्रिंग सेप दिया जाता है, तो इसके विपरीत , यह विधि खाली स्ट्रिंग के लिए एक खाली सूची लौटाती है, और एक टर्मिनल लाइन ब्रेक के परिणामस्वरूप अतिरिक्त लाइन नहीं होती है:

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

तुलना के लिए, split('\n') देता है:

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']
str.startswith(prefix[, start[, end]])

True यदि उपसर्ग के साथ स्ट्रिंग शुरू होती है तो वापस लौटें , अन्यथा वापस लौटें False उपसर्ग भी देखने के लिए उपसर्ग का एक गुच्छे हो सकता है। वैकल्पिक शुरुआत के साथ , उस स्थिति में परीक्षण स्ट्रिंग शुरुआत। वैकल्पिक अंत के साथ , उस स्थिति में स्ट्रिंग की तुलना करना बंद करें।

str.strip([chars])

हटाए गए प्रमुख और अनुगामी पात्रों के साथ स्ट्रिंग की एक प्रति लौटाएं। वर्ण तर्क एक स्ट्रिंग में सेट निर्दिष्ट करने हटाया जा रहा है। यदि छोड़ दिया या None , वर्ण तर्क व्हाट्सएप को हटाने के लिए चूक करता है। वर्ण तर्क एक उपसर्ग या प्रत्यय नहीं है; बल्कि, इसके मूल्यों के सभी संयोजन छीन लिए गए हैं:

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

सबसे बाहरी अग्रणी और अनुगामी चार्ट तर्क मान स्ट्रिंग से छीन लिए गए हैं। वर्ण एक स्ट्रिंग चरित्र है कि में पात्रों के सेट में निहित नहीं है तक पहुँचने जब तक प्रमुख अंत से निकाल दिए जाते वर्ण । अनुगामी अंत पर एक समान कार्रवाई होती है। उदाहरण के लिए:

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'
str.swapcase()

अपरकेस वर्णों के साथ स्ट्रिंग की एक प्रति लौटाएं जो लोअरकेस में परिवर्तित हो और इसके विपरीत। ध्यान दें कि जरूरी नहीं कि यह सच हो s.swapcase().swapcase() == s

str.title()

स्ट्रिंग का एक शीर्षकबद्ध संस्करण लौटाएं जहां शब्द एक बड़े अक्षर से शुरू होते हैं और शेष अक्षर निचले होते हैं।

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

>>> 'Hello world'.title()
'Hello World'

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

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

एपोस्ट्रोफ के लिए एक वर्कअराउंड का निर्माण नियमित अभिव्यक्ति का उपयोग करके किया जा सकता है:

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."
str.translate(table)

स्ट्रिंग की एक प्रति लौटाएं जिसमें प्रत्येक चरित्र को दिए गए अनुवाद तालिका के माध्यम से मैप किया गया है। तालिका एक ऐसी वस्तु होनी चाहिए __getitem__() , जो आमतौर पर mapping या sequence माध्यम से अनुक्रमण को लागू करती है । जब एक यूनिकोड ऑर्डिनल (एक पूर्णांक) द्वारा अनुक्रमित किया जाता है, तो टेबल ऑब्जेक्ट निम्नलिखित में से कोई भी कर सकता है: एक या अधिक अन्य वर्णों के चरित्र को मैप करने के लिए एक यूनिकोड ऑर्डिनल या एक स्ट्रिंग लौटाएं; वापसी None , वापसी स्ट्रिंग से चरित्र को हटाने के लिए; या एक LookupError अपवाद बढ़ाएं , चरित्र को अपने आप में मैप करने के लिए।

आप str.maketrans() विभिन्न स्वरूपों में चरित्र से चरित्र मैपिंग से अनुवाद मानचित्र बनाने के लिए उपयोग कर सकते हैं ।

codecs कस्टम चरित्र मैपिंग के लिए अधिक लचीले दृष्टिकोण के लिए मॉड्यूल भी देखें ।

str.upper()

सभी कैश्ड वर्णों के साथ स्ट्रिंग की एक प्रति लौटाएं [4] जिसे अपरकेस में परिवर्तित किया गया है। ध्यान दें कि s.upper().isupper() हो सकता है False कि s इसमें बिना वर्ण वाले अक्षर हों या यदि परिणामी वर्ण (यू) की यूनिकोड श्रेणी "लू" (पत्र, अपरकेस) नहीं है, लेकिन उदाहरण के लिए "लेफ्टिनेंट" (पत्र, शीर्षक)।

उपयोग किए गए अपरकेस एल्गोरिथ्म को यूनिकोड मानक के खंड 3.13 में वर्णित किया गया है।

str.zfill(width)

'0' लंबाई चौड़ाई की एक स्ट्रिंग बनाने के लिए ASCII अंकों से भरे हुए स्ट्रिंग की एक प्रति लौटाएं । एक प्रमुख हस्ताक्षर उपसर्ग ( '+' / '-' ) पहले के बजाय साइन चरित्र के बाद गद्दी को सम्मिलित करके नियंत्रित किया जाता है । मूल स्ट्रिंग लौटा दी जाती है यदि चौड़ाई कम से कम या इसके बराबर होती है len(s)

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

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

printf -स्टाइल स्ट्रिंग स्वरूपण

ध्यान दें

यहाँ वर्णित स्वरूपण कार्य कई प्रकार की विचित्रताएँ प्रदर्शित करते हैं जो कई सामान्य त्रुटियों को जन्म देती हैं (जैसे कि टुपल्स और शब्दकोशों को सही ढंग से प्रदर्शित करने में विफल होना)। नए स्वरूपित स्ट्रिंग शाब्दिकों का उपयोग करके , str.format() इंटरफ़ेस या टेम्पलेट स्ट्रिंग इन त्रुटियों से बचने में मदद कर सकते हैं। इन विकल्पों में से प्रत्येक अपने स्वयं के व्यापार-लाभ और सादगी, लचीलेपन और / या एक्स्टेंसिबिलिटी के लाभ प्रदान करता है।

स्ट्रिंग ऑब्जेक्ट्स में एक अद्वितीय अंतर्निहित ऑपरेशन होता है: % ऑपरेटर (मोडुलो)। इसे स्ट्रिंग प्रारूपण या प्रक्षेप ऑपरेटर के रूप में भी जाना जाता है । यह देखते हुए format % values (जहां प्रारूप एक स्ट्रिंग है), प्रारूप % में रूपांतरण विनिर्देशों को शून्य या मान के अधिक तत्वों के साथ बदल दिया जाता है । प्रभाव सी भाषा में उपयोग करने के समान है । sprintf()

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

एक रूपांतरण विनिर्देशक में दो या अधिक वर्ण होते हैं और निम्नलिखित घटक होते हैं, जो इस क्रम में होने चाहिए:

  1. '%' चरित्र है, जो विनिर्देशक की शुरुआत के निशान।
  2. मानचित्रण कुंजी (वैकल्पिक), वर्णों के एक छोटे से क्रम से मिलकर (उदाहरण के लिए, (somename) )।
  3. रूपांतरण फ़्लैग (वैकल्पिक), जो कुछ रूपांतरण प्रकारों के परिणाम को प्रभावित करते हैं।
  4. न्यूनतम फ़ील्ड चौड़ाई (वैकल्पिक)। यदि एक '*' (तारांकन) के रूप में निर्दिष्ट किया जाता है , तो वास्तविक चौड़ाई को मानों में टपल के अगले तत्व से पढ़ा जाता है , और कन्वर्ट करने के लिए ऑब्जेक्ट न्यूनतम फ़ील्ड चौड़ाई और वैकल्पिक परिशुद्धता के बाद आता है।
  5. परिशुद्धता (वैकल्पिक), '.' परिशुद्धता के बाद (डॉट) के रूप में दी गई है । यदि '*' (तारांकन चिह्न) के रूप में निर्दिष्ट किया जाता है , तो वास्तविक परिशुद्धता को मूल्यों में टपल के अगले तत्व से पढ़ा जाता है , और कन्वर्ट करने के लिए मूल्य सटीक के बाद आता है।
  6. लंबाई संशोधक (वैकल्पिक)।
  7. रूपांतरण प्रकार।

जब सही तर्क एक शब्दकोश (या अन्य मानचित्रण प्रकार) है, तो स्ट्रिंग में प्रारूप में चरित्र के तुरंत बाद डाले गए शब्दकोश में एक कोष्ठक मानचित्रण कुंजी शामिल होनी चाहिए '%' । मैपिंग कुंजी मैपिंग से स्वरूपित करने के लिए मान का चयन करती है। उदाहरण के लिए:

>>> print('%(language)s has %(number)03d quote types.' %
...       {'language': "Python", "number": 2})
Python has 002 quote types.

इस मामले में कोई भी * प्रारूप प्रारूप में नहीं हो सकता है (क्योंकि उन्हें अनुक्रमिक पैरामीटर सूची की आवश्यकता होती है)।

रूपांतरण ध्वज वर्ण हैं:

झंडा अर्थ
'#' मूल्य रूपांतरण "वैकल्पिक रूप" (जहां नीचे परिभाषित किया गया है) का उपयोग करेगा।
'0' संख्यात्मक मानों के लिए रूपांतरण शून्य गद्देदार होगा।
'-' परिवर्तित मान समायोजित किया जाता है ( '0' यदि दोनों दिए गए हैं तो रूपांतरण को ओवरराइड करता है )।
' ' (एक स्थान) एक हस्ताक्षरित रूपांतरण द्वारा उत्पादित एक सकारात्मक संख्या (या खाली स्ट्रिंग) से पहले एक खाली छोड़ दिया जाना चाहिए।
'+' एक संकेत चरित्र ( '+' या '-' ) रूपांतरण से पहले होगा ("स्पेस" ध्वज को ओवरराइड करता है)।

एक लंबाई संशोधक ( h और l , या L ) मौजूद हो सकता है, लेकिन इसे अनदेखा कर दिया जाता है क्योंकि यह पायथन के लिए आवश्यक नहीं है - इसलिए जैसे %ld इसके समान है %d

रूपांतरण प्रकार हैं:

रूपांतरण अर्थ टिप्पणियाँ
'd' पूर्णांक दशमलव पर हस्ताक्षर किए।
'i' पूर्णांक दशमलव पर हस्ताक्षर किए।
'o' अष्टक मूल्य पर हस्ताक्षर किए। (1)
'u' अप्रचलित प्रकार - यह समान है 'd' (6)
'x' हेक्साडेसिमल (लोअरकेस) पर हस्ताक्षर किए। (2)
'X' हेक्साडेसिमल (अपरकेस) पर हस्ताक्षर किए। (2)
'e' फ्लोटिंग पॉइंट घातीय प्रारूप (लोअरकेस)। (3)
'E' फ्लोटिंग पॉइंट एक्सपोनेंशियल फॉर्मेट (अपरकेस)। (3)
'f' फ़्लोटिंग पॉइंट दशमलव प्रारूप। (3)
'F' फ़्लोटिंग पॉइंट दशमलव प्रारूप। (3)
'g' फ़्लोटिंग पॉइंट प्रारूप। यदि एक्सपोजर -4 से कम है या सटीक, दशमलव प्रारूप से कम नहीं है तो लोअरकेस घातीय प्रारूप का उपयोग करता है। (4)
'G' फ़्लोटिंग पॉइंट प्रारूप। अगर एक्सपोजर -4 से कम है या सटीक, दशमलव प्रारूप से कम नहीं है तो अपरकेस एक्सपोनेंशियल फॉर्मेट का उपयोग करता है। (4)
'c' एकल वर्ण (पूर्णांक या एकल वर्ण स्ट्रिंग को स्वीकार करता है)।
'r' स्ट्रिंग (किसी भी पायथन ऑब्जेक्ट का उपयोग करके कनवर्ट करता है repr() )। (5)
's' स्ट्रिंग (किसी भी पायथन ऑब्जेक्ट का उपयोग करके कनवर्ट करता है str() )। (5)
'a' स्ट्रिंग (किसी भी पायथन ऑब्जेक्ट का उपयोग करके कनवर्ट करता है ascii() )। (5)
'%' कोई तर्क परिवर्तित नहीं होता है, परिणाम में एक '%' चरित्र होता है।

टिप्पणियाँ:

  1. वैकल्पिक रूप '0o' से पहले अंक से पहले एक अग्रणी ऑक्टल स्पेसियर ( ) डाला जाता है।
  2. वैकल्पिक रूप एक प्रमुख कारण बनता है '0x' या '0X' (जो इस पर निर्भर 'x' या 'X' प्रारूप का प्रयोग किया गया था) पहला अंक से पहले सम्मिलित करने के लिए।
  3. वैकल्पिक रूप से परिणाम हमेशा दशमलव बिंदु समाहित करता है, भले ही कोई अंक इसका अनुसरण न करता हो।

    सटीक दशमलव बिंदु के बाद अंकों की संख्या निर्धारित करता है और 6 तक चूक करता है।

  4. वैकल्पिक रूप से परिणाम हमेशा दशमलव बिंदु होता है, और अनुगामी शून्य को हटाया नहीं जाता क्योंकि वे अन्यथा होते।

    सटीक दशमलव बिंदु से पहले और बाद में 6 तक महत्वपूर्ण अंकों की संख्या निर्धारित करता है।

  5. यदि सटीक है N , तो आउटपुट N वर्णों को काट दिया जाता है।
  6. पीईपी 237 देखें ।

चूंकि पायथन के तारों की स्पष्ट लंबाई है, इसलिए %s रूपांतरण यह नहीं मानते कि '\0' यह स्ट्रिंग का अंत है।

संस्करण 3.1 में परिवर्तित: %f उन संख्याओं के लिए रूपांतरण जिनका निरपेक्ष मान 1e50 से अधिक है, अब %g रूपांतरणों से नहीं बदले जाते हैं ।

बाइनरी अनुक्रम प्रकार - बाइट्स, बायटियर, मेमोरीव्यू

बाइनरी डेटा में हेरफेर करने के लिए कोर अंतर्निहित प्रकार हैं bytes और bytearray । वे समर्थित हैं memoryview जिनके द्वारा प्रतिलिपि बनाने की आवश्यकता के बिना अन्य बाइनरी ऑब्जेक्ट की मेमोरी तक पहुंचने के लिए बफर प्रोटोकॉल का उपयोग किया जाता है।

array मॉड्यूल 32-बिट पूर्णांकों और IEEE754 डबल परिशुद्धता चल मूल्यों जैसे बुनियादी डेटा प्रकार के कुशल भंडारण का समर्थन करता है।

बाइट्स ऑब्जेक्ट्स

बाइट्स ऑब्जेक्ट एकल बाइट्स के अपरिवर्तनीय अनुक्रम हैं। चूंकि कई प्रमुख बाइनरी प्रोटोकॉल ASCII टेक्स्ट एन्कोडिंग पर आधारित हैं, बाइट ऑब्जेक्ट्स कई तरीके प्रदान करते हैं जो केवल ASCII संगत डेटा के साथ काम करते समय मान्य होते हैं और विभिन्न प्रकार के स्ट्रिंग ऑब्जेक्ट्स के साथ निकटता से संबंधित होते हैं।

class bytes([source[, encoding[, errors]]])

सबसे पहले, बाइट्स शाब्दिक के लिए वाक्यविन्यास मोटे तौर पर स्ट्रिंग शाब्दिकों के लिए समान है, सिवाय इसके कि एक b उपसर्ग जोड़ा जाता है:

  • एकल कोट: b'still allows embedded "double" quotes'
  • डबल उद्धरण: b"still allows embedded 'single' quotes"
  • ट्रिपल उद्धृत किया: b'''3 single quotes''' , b"""3 double quotes"""

केवल बाइट्स शाब्दिक में ASCII वर्णों की अनुमति है (घोषित स्रोत कोड एन्कोडिंग की परवाह किए बिना)। 127 से अधिक किसी भी बाइनरी वैल्यू को उचित एस्केप सीक्वेंस का उपयोग करके बाइट्स शाब्दिक में दर्ज किया जाना चाहिए।

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

जबकि बाइट्स शाब्दिक और अभ्यावेदन ASCII पाठ पर आधारित होते हैं, बाइट्स ऑब्जेक्ट वास्तव में पूर्णांकों के अपरिवर्तनीय अनुक्रमों की तरह व्यवहार करते हैं, अनुक्रम में प्रत्येक मान इस तरह से प्रतिबंधित है कि 0 <= x < 256 (इस प्रतिबंध का उल्लंघन करने का प्रयास शुरू हो जाएगा ValueError )। यह जानबूझकर जोर देने के लिए किया जाता है, जबकि कई द्विआधारी स्वरूपों में ASCII आधारित तत्व शामिल होते हैं और कुछ पाठ-उन्मुख एल्गोरिदम के साथ उपयोगी रूप से हेरफेर किया जा सकता है, यह आम तौर पर द्विआधारी डेटा के लिए मामला नहीं है (द्विआधारी रूप से पाठ प्रसंस्करण एल्गोरिदम को द्विआधारी रूप से लागू करने के लिए जो नहीं हैं ASCII संगत आमतौर पर डेटा भ्रष्टाचार को जन्म देगा)।

शाब्दिक रूपों के अलावा, बाइट्स ऑब्जेक्ट को कई अन्य तरीकों से बनाया जा सकता है:

  • शून्य-बाइट निर्दिष्ट लंबाई की ऑब्जेक्ट: bytes(10)
  • पूर्णांक के चलने योग्य से: bytes(range(20))
  • बफर प्रोटोकॉल के माध्यम से मौजूदा बाइनरी डेटा की प्रतिलिपि बनाना: bytes(obj)

निर्मित bytes भी देखें ।

चूंकि 2 हेक्साडेसिमल अंक एक बाइट के लिए ठीक-ठीक मेल खाते हैं, बाइनरी डेटा का वर्णन करने के लिए हेक्साडेसिमल संख्या आमतौर पर इस्तेमाल किया जाने वाला प्रारूप है। तदनुसार, बाइट्स प्रकार में उस प्रारूप में डेटा पढ़ने के लिए एक अतिरिक्त वर्ग विधि है:

classmethod fromhex(string)

यह bytes क्लास मेथड बाइट ऑब्जेक्ट देता है, दिए गए स्ट्रिंग ऑब्जेक्ट को डिकोड करता है। स्ट्रिंग में प्रति बाइट दो हेक्साडेसिमल अंक होने चाहिए, जिसमें ASCII व्हाट्सएप को अनदेखा किया जा सकता है।

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

संस्करण 3.7 में बदला गया: bytes.fromhex() अब स्ट्रिंग में सभी ASCII व्हाट्सएप को रिक्त करता है, न कि केवल रिक्त स्थान।

एक रिवर्स रूपांतरण फ़ंक्शन बाइट ऑब्जेक्ट को उसके हेक्साडेसिमल प्रतिनिधित्व में बदलने के लिए मौजूद है।

hex()

उदाहरण में प्रत्येक बाइट के लिए दो हेक्साडेसिमल अंकों वाली एक स्ट्रिंग ऑब्जेक्ट लौटें।

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

संस्करण 3.5 में नया।

के बाद से बाइट्स वस्तुओं पूर्णांक के अनुक्रम (एक टपल के लिए समान), एक बाइट वस्तु के लिए कर रहे हैं , b[0] एक पूर्णांक हो जाएगा, जबकि b[0:1] लंबाई 1. (यह, पाठ स्ट्रिंग्स के विपरीत है, जहां दोनों अनुक्रमण और टुकड़ा करने की क्रिया एक का उत्पादन करेगा की एक बाइट वस्तु हो जाएगा लंबाई 1)

बाइट्स ऑब्जेक्ट्स का प्रतिनिधित्व शाब्दिक प्रारूप ( b'...' ) का उपयोग करता है क्योंकि यह अक्सर उदाहरण की तुलना में अधिक उपयोगी होता है bytes([46, 46, 46]) । आप हमेशा बाइट्स ऑब्जेक्ट को पूर्णांक की सूची में बदलकर उपयोग कर सकते हैं list(b)

ध्यान दें

पायथन 2.x उपयोगकर्ताओं के लिए: पायथन 2.x श्रृंखला में, 8-बिट स्ट्रिंग्स (एक बिल्ट-इन बाइनरी डेटा प्रकार के लिए निकटतम चीज़ 2.x ऑफ़र) और यूनिकोड स्ट्रिंग्स के बीच विभिन्न प्रकार के निहितार्थ रूपांतरणों की अनुमति थी। यह इस तथ्य के लिए एक बैकवर्ड संगतता संगतता थी कि पायथन मूल रूप से केवल 8-बिट पाठ का समर्थन करता था, और यूनिकोड पाठ एक बाद का जोड़ था। पायथन 3.x में, उन निहित रूपांतरणों को हटा दिया गया है - 8-बिट बाइनरी डेटा और यूनिकोड पाठ के बीच रूपांतरण स्पष्ट होना चाहिए, और बाइट्स और स्ट्रिंग ऑब्जेक्ट हमेशा असमान की तुलना करेंगे।

बाइटियर ऑब्जेक्ट्स

bytearray ऑब्जेक्ट्स ऑब्जेक्ट के लिए एक परस्पर समकक्ष है bytes

class bytearray([source[, encoding[, errors]]])

बायट्रियर ऑब्जेक्ट्स के लिए कोई समर्पित शाब्दिक सिंटैक्स नहीं है, इसके बजाय वे हमेशा कंस्ट्रक्टर को कॉल करके बनाए जाते हैं:

  • एक खाली उदाहरण बनाना: bytearray()
  • दी गई लंबाई के साथ शून्य-भरा उदाहरण बनाना: bytearray(10)
  • पूर्णांक के चलने योग्य से: bytearray(range(20))
  • बफर प्रोटोकॉल के माध्यम से मौजूदा बाइनरी डेटा की प्रतिलिपि बनाना: bytearray(b'Hi!')

के रूप में bytearray वस्तुओं परिवर्तनशील हैं, वे समर्थन mutable आम बाइट्स और bytearray संचालन में वर्णित के अलावा क्रम के संचालन बाइट्स और bytearray संचालन

इसके अलावा में निर्मित bytearray देखें ।

चूंकि 2 हेक्साडेसिमल अंक एक बाइट के लिए ठीक-ठीक मेल खाते हैं, बाइनरी डेटा का वर्णन करने के लिए हेक्साडेसिमल संख्या आमतौर पर इस्तेमाल किया जाने वाला प्रारूप है। तदनुसार, बाईटियर्रे प्रकार में उस प्रारूप में डेटा पढ़ने के लिए एक अतिरिक्त वर्ग विधि है:

classmethod fromhex(string)

यह bytearray क्लास विधि दिए गए स्ट्रिंग ऑब्जेक्ट को डिकोड करते हुए, बायटेरियर ऑब्जेक्ट को लौटाती है। स्ट्रिंग में प्रति बाइट दो हेक्साडेसिमल अंक होने चाहिए, जिसमें ASCII व्हाट्सएप को अनदेखा किया जा सकता है।

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

संस्करण 3.7 में बदला गया: bytearray.fromhex() अब स्ट्रिंग में सभी ASCII व्हाट्सएप को रिक्त करता है, न कि केवल रिक्त स्थान।

एक रिवर्स रूपांतरण फ़ंक्शन एक हेक्साडेसिमल प्रतिनिधित्व में एक बायरियर ऑब्जेक्ट को बदलने के लिए मौजूद है।

hex()

उदाहरण में प्रत्येक बाइट के लिए दो हेक्साडेसिमल अंकों वाली एक स्ट्रिंग ऑब्जेक्ट लौटें।

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

संस्करण 3.5 में नया।

चूंकि बायट्रेयर ऑब्जेक्ट एक पूर्णांक ऑब्जेक्ट बी के लिए पूर्णांक (एक सूची के समान) के अनुक्रम होते हैं , इसलिए b[0] एक पूर्णांक b[0:1] होगा , जबकि लंबाई का एक बाइट्रियर ऑब्जेक्ट होगा 1. (यह पाठ स्ट्रिंग्स के साथ विरोधाभास है, जहां दोनों अनुक्रमण और स्लाइसिंग एक उत्पादन करेंगे लंबाई 1)

Bytearray ऑब्जेक्ट्स का प्रतिनिधित्व बाइट्स शाब्दिक प्रारूप ( bytearray(b'...') ) का उपयोग करता है क्योंकि यह अक्सर उदाहरण की तुलना में अधिक उपयोगी होता है bytearray([46, 46, 46]) । आप हमेशा उपयोग की जाने वाली पूर्णांक वस्तु को पूर्णांकों की सूची में बदल सकते हैं list(b)

बाइट्स और बायट्रे ऑपरेशन

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

ध्यान दें

बाइट्स और बाईट्रेयर ऑब्जेक्ट्स के तरीके स्ट्रिंग्स को उनके तर्कों के रूप में स्वीकार नहीं करते हैं, जैसे स्ट्रिंग्स के तरीके बाइट्स को उनके तर्कों के रूप में स्वीकार नहीं करते हैं। उदाहरण के लिए, आपको लिखना होगा:

a = "abc"
b = a.replace("a", "f")

तथा:

a = b"abc"
b = a.replace(b"a", b"f")

कुछ बाइट्स और बायटेरियर ऑपरेशन ASCII संगत बाइनरी फॉर्मेट के उपयोग को मानते हैं, और इसलिए मध्यस्थ बाइनरी डेटा के साथ काम करने से बचा जाना चाहिए। ये प्रतिबंध नीचे दिए गए हैं।

ध्यान दें

एएससीआईआई आधारित प्रारूप में संग्रहीत नहीं किए जाने वाले द्विआधारी डेटा में हेरफेर करने के लिए इन एएससीआईआई आधारित संचालन का उपयोग करने से डेटा भ्रष्टाचार हो सकता है।

बाइट्स और बायटेरियर ऑब्जेक्ट्स पर निम्न विधियों का उपयोग मनमाने ढंग से बाइनरी डेटा के साथ किया जा सकता है।

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

परिणाम को की गैर-अतिव्यापी घटनाओं की संख्या लौटें उप रेंज [में शुरू , अंत ]। वैकल्पिक तर्क शुरू और अंत में स्लाइस अंकन के रूप में व्याख्या की जाती है।

किसी भी बाइट्स जैसी वस्तु या किसी पूर्णांक की सीमा 0 से 255 तक की हो सकती है।

संस्करण ३.३ में बदला: ० से २५५ तक के एक पूर्णांक को परवर्ती के रूप में स्वीकार करें।

bytes.decode(encoding="utf-8", errors="strict")
bytearray.decode(encoding="utf-8", errors="strict")

दिए गए बाइट्स से एक स्ट्रिंग डिकोड करें। डिफ़ॉल्ट एन्कोडिंग है 'utf-8' त्रुटियों को एक अलग त्रुटि हैंडलिंग योजना निर्धारित करने के लिए दिया जा सकता है। त्रुटियों के लिए डिफ़ॉल्ट है 'strict' , जिसका अर्थ है कि एन्कोडिंग त्रुटियाँ एक उठाती हैं UnicodeError । अन्य संभावित मान हैं 'ignore' , 'replace' और किसी अन्य नाम के माध्यम से पंजीकृत है codecs.register_error() , अनुभाग त्रुटि हैंडलर देखें । संभावित एन्कोडिंग की सूची के लिए, सेक्शन स्टैंडर्ड एनकोडिंग देखें ।

ध्यान दें

अस्थायी बाइट्स या बायट्रेयर ऑब्जेक्ट बनाने की आवश्यकता के बिना किसी भी बाइट्स जैसी ऑब्जेक्ट को डिकोड करने की अनुमति देने के लिए एन्कोडिंग तर्क को पास करना। str()

संस्करण 3.1 में परिवर्तित: कीवर्ड तर्कों के लिए जोड़ा गया समर्थन।

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

लौटें True बाइनरी डेटा निर्दिष्ट के साथ समाप्त होता है, तो प्रत्यय , अन्यथा वापसी False प्रत्यय भी देखने के लिए प्रत्ययों का एक प्रकार हो सकता है। वैकल्पिक शुरुआत के साथ , उस स्थिति में शुरुआत का परीक्षण करें। वैकल्पिक अंत के साथ , उस स्थिति में तुलना करना बंद करें।

किसी भी बाइट्स जैसी वस्तु की खोज करने के लिए प्रत्यय (तों) हो सकता है ।

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

डेटा में सबसे कम इंडेक्स को वापस लौटाएं, जहां लेटेरेंस सब पाया जाता है, जैसे कि सब स्लाइस में निहित होता है s[start:end] । वैकल्पिक तर्क शुरू और अंत में स्लाइस अंकन के रूप में व्याख्या की जाती है। -1 यदि उप नहीं मिला है तो वापस लौटें ।

किसी भी बाइट्स जैसी वस्तु या किसी पूर्णांक की सीमा 0 से 255 तक की हो सकती है।

ध्यान दें

find() विधि केवल इस्तेमाल किया जाना चाहिए अगर आप की स्थिति पता करने की जरूरत उप । यह जाँचने के लिए कि उप एक सबरिंग है या नहीं, in ऑपरेटर का उपयोग करें :

>>> b'Py' in b'Python'
True

संस्करण ३.३ में बदला: ० से २५५ तक के एक पूर्णांक को परवर्ती के रूप में स्वीकार करें।

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

जैसे find() , लेकिन ValueError बाद में नहीं मिलने पर उठाएं ।

किसी भी बाइट्स जैसी वस्तु या किसी पूर्णांक की सीमा 0 से 255 तक की हो सकती है।

संस्करण ३.३ में बदला: ० से २५५ तक के एक पूर्णांक को परवर्ती के रूप में स्वीकार करें।

bytes.join(iterable)
bytearray.join(iterable)

एक बाइट्स या बायटेरियर ऑब्जेक्ट लौटाएं जो पुनरावृत्त बाइनरी डेटा अनुक्रमों के चलने योग्य है । ए TypeError को उठाया जाएगा यदि उसमें चलने योग्य कोई भी मान हो जो बाइट्स जैसी वस्तुएं नहीं हैं , जिसमें str() ऑब्जेक्ट भी शामिल हैं। तत्वों के बीच विभाजक इस विधि को प्रदान करने वाले बाइट्स या बाइटियर्रे ऑब्जेक्ट की सामग्री है।

static bytes.maketrans(from, to)
static bytearray.maketrans(from, to)

के लिए यह स्थिर विधि एक अनुवाद तालिका प्रयोग करने योग्य देता bytes.translate() है कि में प्रत्येक वर्ण मैप कर देंगे से में एक ही स्थान पर चरित्र में करने के लिए ; से और करने के लिए दोनों होना चाहिए बाइट्स की तरह वस्तुओं और एक ही लंबाई की है।

संस्करण 3.1 में नया।

bytes.partition(sep)
bytearray.partition(sep)

की पहली आवृत्ति पर अनुक्रम को विभाजित सितम्बर , और एक 3 टपल हिस्सा युक्त विभाजक या उसके bytearray कॉपी करना और विभाजक के बाद वाले हिस्से लौट विभाजक से पहले,। यदि विभाजक नहीं मिला है, तो मूल अनुक्रम की एक प्रतिलिपि युक्त 3-ट्यूपल लौटाएं, इसके बाद दो खाली बाइट्स या बायटेरियर ऑब्जेक्ट्स।

विभाजक को खोजने के लिए किसी भी बाइट्स जैसी वस्तु हो सकती है ।

bytes.replace(old, new[, count])
bytearray.replace(old, new[, count])

अनुक्रम की एक प्रति लौटें पुराने के सभी घटनाओं के साथ नए द्वारा प्रतिस्थापित । यदि वैकल्पिक तर्क गणना दी जाती है, तो केवल पहली गणना घटित होती है।

खोज और उसके प्रतिस्थापन की खोज किसी भी बाइट्स जैसी वस्तु हो सकती है ।

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]])

अनुक्रम में उच्चतम सूचकांक वापस लौटाएं जहां परवर्ती उप पाया जाता है, जैसे कि उप भीतर निहित होता है s[start:end] । वैकल्पिक तर्क शुरू और अंत में स्लाइस अंकन के रूप में व्याख्या की जाती है। -1 असफलता पर लौटें ।

किसी भी बाइट्स जैसी वस्तु या किसी पूर्णांक की सीमा 0 से 255 तक की हो सकती है।

संस्करण ३.३ में बदला: ० से २५५ तक के एक पूर्णांक को परवर्ती के रूप में स्वीकार करें।

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

जैसे कि बाद में rfind() उठता है ValueError जब पार्श्व उप नहीं पाया जाता है।

किसी भी बाइट्स जैसी वस्तु या किसी पूर्णांक की सीमा 0 से 255 तक की हो सकती है।

संस्करण ३.३ में बदला: ० से २५५ तक के एक पूर्णांक को परवर्ती के रूप में स्वीकार करें।

bytes.rpartition(sep)
bytearray.rpartition(sep)

के अंतिम घटना में अनुक्रम को विभाजित सितम्बर , और एक 3 टपल हिस्सा युक्त विभाजक या उसके bytearray कॉपी करना और विभाजक के बाद वाले हिस्से लौट विभाजक से पहले,। यदि विभाजक नहीं मिला है, तो मूल अनुक्रम की एक प्रतिलिपि युक्त 3-ट्यूपल लौटाएं, इसके बाद दो खाली बाइट्स या बायटेरियर ऑब्जेक्ट्स।

विभाजक को खोजने के लिए किसी भी बाइट्स जैसी वस्तु हो सकती है ।

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

लौटें True अगर बाइनरी डेटा निर्दिष्ट के साथ शुरू होता उपसर्ग , अन्यथा वापसी False उपसर्ग भी देखने के लिए उपसर्ग का एक गुच्छे हो सकता है। वैकल्पिक शुरुआत के साथ , उस स्थिति में शुरुआत का परीक्षण करें। वैकल्पिक अंत के साथ , उस स्थिति में तुलना करना बंद करें।

खोज करने के लिए उपसर्ग (तों) किसी भी बाइट्स जैसी वस्तु हो सकती है ।

bytes.translate(table, delete=b'')
bytearray.translate(table, delete=b'')

बाइट्स या बायटेरियर ऑब्जेक्ट की एक प्रति लौटाएं जहां वैकल्पिक तर्क डिलीट में होने वाली सभी बाइट्स हटा दी जाती हैं, और बचे हुए बाइट्स को दिए गए अनुवाद तालिका के माध्यम से मैप किया गया है, जिसकी लंबाई बाइट्स ऑब्जेक्ट 256 होनी चाहिए।

आप bytes.maketrans() अनुवाद तालिका बनाने के लिए विधि का उपयोग कर सकते हैं ।

केवल अनुवादों को हटाने वाले अनुवाद के लिए तालिका तर्क सेट करें None :

>>> b'read this short text'.translate(None, b'aeiou')
b'rd ths shrt txt'

संस्करण 3.6 में परिवर्तित: हटाएं अब एक कीवर्ड तर्क के रूप में समर्थित है।

बाइट्स और बायटेरियर ऑब्जेक्ट्स पर निम्न विधियों में डिफ़ॉल्ट व्यवहार होते हैं जो एएससीआईआई संगत बाइनरी प्रारूपों के उपयोग को मानते हैं, लेकिन फिर भी उपयुक्त तर्कों को पारित करके मनमाना बाइनरी डेटा के साथ उपयोग किया जा सकता है। ध्यान दें कि इस खंड में सभी उप-विधि विधियाँ जगह में संचालित नहीं होती हैं, और इसके बजाय नई वस्तुओं का उत्पादन करती हैं।

bytes.center(width[, fillbyte])
bytearray.center(width[, fillbyte])

लंबाई चौड़ाई के अनुक्रम में केंद्रित ऑब्जेक्ट की एक प्रति लौटाएं । पैडिंग निर्दिष्ट फ़िलबाइट का उपयोग करके किया जाता है (डिफ़ॉल्ट एक ASCII स्थान है)। के लिए bytes वस्तुओं, यदि मूल अनुक्रम दिया जाता है चौड़ाई से कम या उसके बराबर होता है len(s)

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.ljust(width[, fillbyte])
bytearray.ljust(width[, fillbyte])

लंबाई चौड़ाई के अनुक्रम में औचित्य वाली वस्तु की एक प्रति लौटाएं । पैडिंग निर्दिष्ट फ़िलबाइट का उपयोग करके किया जाता है (डिफ़ॉल्ट एक ASCII स्थान है)। के लिए bytes वस्तुओं, यदि मूल अनुक्रम दिया जाता है चौड़ाई से कम या उसके बराबर होता है len(s)

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.lstrip([chars])
bytearray.lstrip([chars])

हटाए गए निर्दिष्ट बाइट्स के साथ अनुक्रम की एक प्रति लौटाएं। वर्ण तर्क एक द्विआधारी बाइट मूल्यों का वह समूह को निर्दिष्ट अनुक्रम हटा दिया जाना चाहिए है - नाम तथ्य इस विधि आमतौर पर ASCII वर्ण के साथ प्रयोग किया जाता है को संदर्भित करता है। यदि छोड़ दिया या None , चर तर्क ASCII व्हाट्सएप को हटाने के लिए चूक। वर्ण तर्क एक उपसर्ग नहीं है; बल्कि, इसके मूल्यों के सभी संयोजन छीन लिए गए हैं:

>>> b'   spacious   '.lstrip()
b'spacious   '
>>> b'www.example.com'.lstrip(b'cmowz.')
b'example.com'

बाइट मानों को हटाने के लिए बाइनरी अनुक्रम किसी भी बाइट्स जैसी वस्तु हो सकती है ।

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.rjust(width[, fillbyte])
bytearray.rjust(width[, fillbyte])

लंबाई चौड़ाई के एक क्रम में सही वस्तु की एक प्रति लौटाएं । पैडिंग निर्दिष्ट फ़िलबाइट का उपयोग करके किया जाता है (डिफ़ॉल्ट एक ASCII स्थान है)। के लिए bytes वस्तुओं, यदि मूल अनुक्रम दिया जाता है चौड़ाई से कम या उसके बराबर होता है len(s)

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.rsplit(sep=None, maxsplit=-1)
bytearray.rsplit(sep=None, maxsplit=-1)

सीम का उपयोग करके सीमांकक स्ट्रिंग के रूप में एक ही प्रकार के बाद के बाइनरी अनुक्रम को विभाजित करें । अगर मैक्सप्लिट दिया जाता है, तो अधिकतम अधिकतम छींटों पर किया जाता है, सबसे सही । अगर sep निर्दिष्ट नहीं है या None , कोई भी ASCII व्हाट्सएप से पूरी तरह से युक्त एक विभाजक है। दाईं ओर से विभाजन को छोड़कर, rsplit() ऐसा व्यवहार करता है split() जिसका वर्णन नीचे विस्तार से किया गया है।

bytes.rstrip([chars])
bytearray.rstrip([chars])

हटाए गए निर्दिष्ट बाइट्स के साथ अनुक्रम की एक प्रति लौटाएं। वर्ण तर्क एक द्विआधारी बाइट मूल्यों का वह समूह को निर्दिष्ट अनुक्रम हटा दिया जाना चाहिए है - नाम तथ्य इस विधि आमतौर पर ASCII वर्ण के साथ प्रयोग किया जाता है को संदर्भित करता है। यदि छोड़ दिया या None , चर तर्क ASCII व्हाट्सएप को हटाने के लिए चूक। वर्ण तर्क एक प्रत्यय नहीं है; बल्कि, इसके मूल्यों के सभी संयोजन छीन लिए गए हैं:

>>> b'   spacious   '.rstrip()
b'   spacious'
>>> b'mississippi'.rstrip(b'ipz')
b'mississ'

बाइट मानों को हटाने के लिए बाइनरी अनुक्रम किसी भी बाइट्स जैसी वस्तु हो सकती है ।

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.split(sep=None, maxsplit=-1)
bytearray.split(sep=None, maxsplit=-1)

सीम का उपयोग करके सीमांकक स्ट्रिंग के रूप में एक ही प्रकार के बाद के बाइनरी अनुक्रम को विभाजित करें । यदि मैक्सप्लिट दिया गया है और गैर-नकारात्मक है, तो अधिकतम मैक्सप्लिट विभाजन किया जाता है (इस प्रकार, सूची में अन्य maxsplit+1 तत्व होंगे)। यदि मैक्सप्लिट निर्दिष्ट नहीं है या है -1 , तो विभाजन की संख्या पर कोई सीमा नहीं है (सभी संभव विभाजन किए गए हैं)।

यदि सीप दिया जाता है, तो लगातार सीमांकक को एक साथ समूहीकृत नहीं किया जाता है और खाली बाद के परिसीमन के लिए समझा जाता है (उदाहरण के लिए, b'1,,2'.split(b',') रिटर्न [b'1', b'', b'2'] ) सितम्बर तर्क एक multibyte अनुक्रम (उदाहरण के लिए, शामिल हो सकते हैं b'1<>2<>3'.split(b'<>') रिटर्न [b'1', b'2', b'3'] )। एक निर्दिष्ट विभाजक के साथ एक खाली अनुक्रम को विभाजित करना [b''] या [bytearray(b'')] वस्तु के प्रकार के विभाजन पर निर्भर करता है। सितम्बर तर्क किसी भी हो सकता है बाइट्स जैसी वस्तु

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

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']

यदि sep निर्दिष्ट या नहीं है None , तो एक अलग विभाजन एल्गोरिथ्म लागू किया जाता है: लगातार ASCII व्हाट्सएप के रन को एक एकल विभाजक के रूप में माना जाता है, और परिणाम में प्रारंभ या अंत में कोई खाली स्ट्रिंग नहीं होगा यदि अनुक्रम में व्हाट्सएप अग्रणी या ट्रैस है। नतीजतन, एक खाली अनुक्रम या एक अनुक्रम को विभाजित करके जिसमें एक निर्दिष्ट विभाजक रिटर्न के बिना केवल ASCII व्हाट्सएप शामिल है []

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

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']
bytes.strip([chars])
bytearray.strip([chars])

हटाए गए निर्दिष्ट अग्रणी और अनुगामी बाइट्स के साथ अनुक्रम की एक प्रति लौटाएं। वर्ण तर्क एक द्विआधारी बाइट मूल्यों का वह समूह को निर्दिष्ट अनुक्रम हटा दिया जाना चाहिए है - नाम तथ्य इस विधि आमतौर पर ASCII वर्ण के साथ प्रयोग किया जाता है को संदर्भित करता है। यदि छोड़ दिया या None , चर तर्क ASCII व्हाट्सएप को हटाने के लिए चूक। वर्ण तर्क एक उपसर्ग या प्रत्यय नहीं है; बल्कि, इसके मूल्यों के सभी संयोजन छीन लिए गए हैं:

>>> b'   spacious   '.strip()
b'spacious'
>>> b'www.example.com'.strip(b'cmowz.')
b'example'

बाइट मानों को हटाने के लिए बाइनरी अनुक्रम किसी भी बाइट्स जैसी वस्तु हो सकती है ।

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

बाइट्स और बायटेरियर ऑब्जेक्ट्स पर निम्न विधियाँ ASCII संगत बाइनरी फॉर्मेट का उपयोग मानती हैं और उन्हें बाइनरी डेटा पर लागू नहीं किया जाना चाहिए। ध्यान दें कि इस खंड में सभी उप-विधि विधियाँ जगह में संचालित नहीं होती हैं, और इसके बजाय नई वस्तुओं का उत्पादन करती हैं।

bytes.capitalize()
bytearray.capitalize()

प्रत्येक बाइट के साथ अनुक्रम की एक प्रति लौटाएं जो ASCII वर्ण के रूप में व्याख्या की गई है, और पहली बाइट को कैपिटल और शेष को घटा दिया गया है। गैर-एएससीआईआई बाइट मूल्यों को अपरिवर्तित के माध्यम से पारित किया जाता है।

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

उस अनुक्रम की एक प्रति लौटाएँ जहाँ सभी ASCII टैब वर्णों को वर्तमान स्तंभ और दिए गए टैब आकार के आधार पर एक या अधिक ASCII रिक्त स्थान द्वारा प्रतिस्थापित किया जाता है। टैब पदों घटित हर tabsize बाइट्स (डिफ़ॉल्ट 8, कॉलम 0, 8, 16 और इतने पर पर टैब पदों दे रही है)। अनुक्रम का विस्तार करने के लिए, वर्तमान कॉलम शून्य पर सेट है और अनुक्रम को बाइट द्वारा जांच की जाती है। यदि बाइट एक ASCII टैब वर्ण ( b'\t' ) है, तो परिणाम में एक या अधिक स्थान वर्ण तब तक डाले जाते हैं जब तक कि वर्तमान स्तंभ अगले टैब स्थिति के बराबर न हो। (टैब वर्ण स्वयं कॉपी नहीं किया गया है।) यदि वर्तमान बाइट एक ASCII न्यूलाइन है ( b'\n' ) या कैरिज रिटर्न ( b'\r' ), इसे कॉपी किया जाता है और वर्तमान कॉलम शून्य पर रीसेट हो जाता है। किसी अन्य बाइट मान को अपरिवर्तित कॉपी किया जाता है और बाइट मान का प्रतिनिधित्व करने पर वर्तमान कॉलम एक से बढ़ जाता है:

>>> b'01\t012\t0123\t01234'.expandtabs()
b'01      012     0123    01234'
>>> b'01\t012\t0123\t01234'.expandtabs(4)
b'01  012 0123    01234'

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.isalnum()
bytearray.isalnum()

यदि अनुक्रम में सभी बाइट्स वर्णानुक्रम ASCII वर्ण या ASCII दशमलव अंक हैं और अनुक्रम खाली नहीं है, तो सही है, अन्यथा वापस लौटें। वर्णनात्मक ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' । ASCII दशमलव अंक अनुक्रम में उन बाइट मान हैं b'0123456789'

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

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False
bytes.isalpha()
bytearray.isalpha()

अगर क्रमानुसार सभी बाइट अनुक्रमिक ASCII अक्षर हैं और अनुक्रम खाली नहीं है, तो सही है, अन्यथा वापस लौटें वर्णनात्मक ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

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

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False
bytes.isascii()
bytearray.isascii()

यदि अनुक्रम खाली है या अनुक्रम में सभी बाइट्स ASCII हैं, तो गलत है, अन्यथा वापस लौटें। ASCII बाइट्स 0-0x7F की सीमा में हैं।

संस्करण 3.7 में नया।

bytes.isdigit()
bytearray.isdigit()

यदि अनुक्रम में सभी बाइट्स ASCII दशमलव अंक हैं और अनुक्रम खाली नहीं है, तो सही है, अन्यथा वापस लौटें। ASCII दशमलव अंक अनुक्रम में उन बाइट मान हैं b'0123456789'

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

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False
bytes.islower()
bytearray.islower()

यदि अनुक्रम में कम से कम एक कम ASCII चरित्र है और कोई अपरकेस ASCII वर्ण नहीं है, तो सही लौटें अन्यथा गलत।

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

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

लोअरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyz' । अपरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

bytes.isspace()
bytearray.isspace()

अनुक्रम में सभी बाइट्स ASCII व्हाट्सएप हैं और अगर अनुक्रम खाली नहीं है, तो सही है, अन्यथा वापस लौटें। ASCII व्हाट्सएप वर्ण अनुक्रम में वे बाइट मान हैं b' \t\n\r\x0b\f' (स्पेस, टैब, न्यूलाइन, कैरिज रिटर्न, वर्टिकल टैब, फॉर्म फीड)।

bytes.istitle()
bytearray.istitle()

यदि ASCII टाइटलकेस है और अनुक्रम खाली नहीं है, तो सही है, अन्यथा वापस लौटें। bytes.title() "शीर्षक" की परिभाषा के बारे में अधिक जानकारी के लिए देखें ।

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

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False
bytes.isupper()
bytearray.isupper()

अगर क्रमानुसार कम से कम एक अपरकेस अल्फाबेटिक ASCII वर्ण है और कोई ASCII वर्ण नहीं है, तो सही लौटें।

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

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

लोअरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyz' । अपरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

bytes.lower()
bytearray.lower()

सभी अपरकेस ASCII वर्णों के साथ अनुक्रम की एक प्रति लौटाएं जो उनके संगत लोअरकेस समकक्ष में परिवर्तित हो।

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

>>> b'Hello World'.lower()
b'hello world'

लोअरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyz' । अपरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)

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

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

>>> b'ab c\n\nde fg\rkl\r\n'.splitlines()
[b'ab c', b'', b'de fg', b'kl']
>>> b'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
[b'ab c\n', b'\n', b'de fg\r', b'kl\r\n']

split() जब एक सीमांकक स्ट्रिंग सेप दिया जाता है, तो इसके विपरीत , यह विधि खाली स्ट्रिंग के लिए एक खाली सूची लौटाती है, और एक टर्मिनल लाइन ब्रेक के परिणामस्वरूप अतिरिक्त लाइन नहीं होती है:

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])
bytes.swapcase()
bytearray.swapcase()

सभी लोअरकेस ASCII वर्णों को उनके संबंधित अपरकेस समकक्ष और इसके विपरीत में परिवर्तित अनुक्रम की एक प्रति लौटाएं।

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

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

लोअरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyz' । अपरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

इसके विपरीत str.swapcase() , यह हमेशा ऐसा होता bin.swapcase().swapcase() == bin है जो बाइनरी संस्करणों के लिए होता है। एएससीआईआई में केस रूपांतरण सममित हैं, हालांकि यह आम तौर पर यूनिकोड कोड बिंदुओं के लिए सही नहीं है।

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.title()
bytearray.title()

द्विआधारी अनुक्रम का एक शीर्षकबद्ध संस्करण लौटाएं जहां शब्द एक अपरकेस ASCII वर्ण से शुरू होते हैं और शेष अक्षर निचले होते हैं। बिना बाइट के मान अनमॉडिफाइड रह जाते हैं।

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

>>> b'Hello world'.title()
b'Hello World'

लोअरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyz' । अपरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' । अन्य सभी बाइट मान अप्रयुक्त हैं।

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

>>> b"they're bill's friends from the UK".title()
b"They'Re Bill'S Friends From The Uk"

एपोस्ट्रोफ के लिए एक वर्कअराउंड का निर्माण नियमित अभिव्यक्ति का उपयोग करके किया जा सकता है:

>>> import re
>>> def titlecase(s):
...     return re.sub(rb"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0:1].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase(b"they're bill's friends.")
b"They're Bill's Friends."

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.upper()
bytearray.upper()

सभी लोअरकेस ASCII वर्णों को उनके संबंधित अपरकेस समकक्ष में परिवर्तित अनुक्रम की एक प्रति लौटाएं।

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

>>> b'Hello World'.upper()
b'HELLO WORLD'

लोअरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'abcdefghijklmnopqrstuvwxyz' । अपरकेस ASCII वर्ण अनुक्रम में उन बाइट मान हैं b'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

bytes.zfill(width)
bytearray.zfill(width)

b'0' लंबाई चौड़ाई का अनुक्रम बनाने के लिए ASCII अंकों से भरे अनुक्रम की एक प्रति लौटाएं । एक प्रमुख हस्ताक्षर उपसर्ग ( b'+' / पहले के बजाय साइन चरित्र के बाद b'-' गद्दी को सम्मिलित करके नियंत्रित किया जाता है । वस्तुओं के लिए, मूल अनुक्रम लौटाया जाता है यदि चौड़ाई कम से कम या इसके बराबर है । bytes len(seq)

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

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

printf -स्टाइल बाइट्स स्वरूपण

ध्यान दें

यहाँ वर्णित स्वरूपण कार्य कई प्रकार की विचित्रताएँ प्रदर्शित करते हैं जो कई सामान्य त्रुटियों को जन्म देती हैं (जैसे कि टुपल्स और शब्दकोशों को सही ढंग से प्रदर्शित करने में विफल होना)। यदि मुद्रित किया जा रहा मान टपल या शब्दकोश हो सकता है, तो इसे टुपल में लपेटें।

बाइट ऑब्जेक्ट्स ( bytes / bytearray ) में एक अद्वितीय अंतर्निहित ऑपरेशन होता है: % ऑपरेटर (मॉडुलो)। इसे बाइट्स फॉर्मेटिंग या इंटरपोलेशन ऑपरेटर के रूप में भी जाना जाता है । यह देखते हुए format % values (जहां प्रारूप एक बाइट ऑब्जेक्ट है), प्रारूप % में रूपांतरण विनिर्देशों को शून्य या मान के अधिक तत्वों के साथ बदल दिया जाता है । प्रभाव सी भाषा में उपयोग करने के समान है । sprintf()

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

एक रूपांतरण विनिर्देशक में दो या अधिक वर्ण होते हैं और निम्नलिखित घटक होते हैं, जो इस क्रम में होने चाहिए:

  1. '%' चरित्र है, जो विनिर्देशक की शुरुआत के निशान।
  2. मानचित्रण कुंजी (वैकल्पिक), वर्णों के एक छोटे से क्रम से मिलकर (उदाहरण के लिए, (somename) )।
  3. रूपांतरण फ़्लैग (वैकल्पिक), जो कुछ रूपांतरण प्रकारों के परिणाम को प्रभावित करते हैं।
  4. न्यूनतम फ़ील्ड चौड़ाई (वैकल्पिक)। यदि एक '*' (तारांकन) के रूप में निर्दिष्ट किया जाता है , तो वास्तविक चौड़ाई को मानों में टपल के अगले तत्व से पढ़ा जाता है , और कन्वर्ट करने के लिए ऑब्जेक्ट न्यूनतम फ़ील्ड चौड़ाई और वैकल्पिक परिशुद्धता के बाद आता है।
  5. परिशुद्धता (वैकल्पिक), '.' परिशुद्धता के बाद (डॉट) के रूप में दी गई है । यदि '*' (तारांकन चिह्न) के रूप में निर्दिष्ट किया जाता है , तो वास्तविक परिशुद्धता को मूल्यों में टपल के अगले तत्व से पढ़ा जाता है , और कन्वर्ट करने के लिए मूल्य सटीक के बाद आता है।
  6. लंबाई संशोधक (वैकल्पिक)।
  7. रूपांतरण प्रकार।

जब सही तर्क एक शब्दकोश (या अन्य मानचित्रण प्रकार) होता है, तो बाइट ऑब्जेक्ट में प्रारूप में चरित्र के तुरंत बाद डाले गए शब्दकोश में एक कोष्ठक मानचित्रण कुंजी को शामिल करना होगा '%' । मैपिंग कुंजी मैपिंग से स्वरूपित करने के लिए मान का चयन करती है। उदाहरण के लिए:

>>> print(b'%(language)s has %(number)03d quote types.' %
...       {b'language': b"Python", b"number": 2})
b'Python has 002 quote types.'

इस मामले में कोई भी * प्रारूप प्रारूप में नहीं हो सकता है (क्योंकि उन्हें अनुक्रमिक पैरामीटर सूची की आवश्यकता होती है)।

रूपांतरण ध्वज वर्ण हैं:

झंडा अर्थ
'#' मूल्य रूपांतरण "वैकल्पिक रूप" (जहां नीचे परिभाषित किया गया है) का उपयोग करेगा।
'0' संख्यात्मक मानों के लिए रूपांतरण शून्य गद्देदार होगा।
'-' परिवर्तित मान समायोजित किया जाता है ( '0' यदि दोनों दिए गए हैं तो रूपांतरण को ओवरराइड करता है )।
' ' (एक स्थान) एक हस्ताक्षरित रूपांतरण द्वारा उत्पादित एक सकारात्मक संख्या (या खाली स्ट्रिंग) से पहले एक खाली छोड़ दिया जाना चाहिए।
'+' एक संकेत चरित्र ( '+' या '-' ) रूपांतरण से पहले होगा ("स्पेस" ध्वज को ओवरराइड करता है)।

एक लंबाई संशोधक ( h और l , या L ) मौजूद हो सकता है, लेकिन इसे अनदेखा कर दिया जाता है क्योंकि यह पायथन के लिए आवश्यक नहीं है - इसलिए जैसे %ld इसके समान है %d

रूपांतरण प्रकार हैं:

रूपांतरण अर्थ टिप्पणियाँ
'd' पूर्णांक दशमलव पर हस्ताक्षर किए।
'i' पूर्णांक दशमलव पर हस्ताक्षर किए।
'o' अष्टक मूल्य पर हस्ताक्षर किए। (1)
'u' अप्रचलित प्रकार - यह समान है 'd' (8)
'x' हेक्साडेसिमल (लोअरकेस) पर हस्ताक्षर किए। (2)
'X' हेक्साडेसिमल (अपरकेस) पर हस्ताक्षर किए। (2)
'e' फ्लोटिंग पॉइंट घातीय प्रारूप (लोअरकेस)। (3)
'E' फ्लोटिंग पॉइंट एक्सपोनेंशियल फॉर्मेट (अपरकेस)। (3)
'f' फ़्लोटिंग पॉइंट दशमलव प्रारूप। (3)
'F' फ़्लोटिंग पॉइंट दशमलव प्रारूप। (3)
'g' फ़्लोटिंग पॉइंट प्रारूप। यदि एक्सपोजर -4 से कम है या सटीक, दशमलव प्रारूप से कम नहीं है तो लोअरकेस घातीय प्रारूप का उपयोग करता है। (4)
'G' फ़्लोटिंग पॉइंट प्रारूप। अगर एक्सपोजर -4 से कम है या सटीक, दशमलव प्रारूप से कम नहीं है तो अपरकेस एक्सपोनेंशियल फॉर्मेट का उपयोग करता है। (4)
'c' सिंगल बाइट (पूर्णांक या एकल बाइट ऑब्जेक्ट स्वीकार करता है)।
'b' बाइट्स (कोई भी वस्तु जो बफर प्रोटोकॉल का अनुसरण करती है या होती है __bytes__() )। (5)
's' 's' के लिए एक उपनाम है 'b' और इसका उपयोग केवल पायथन 2/3 कोड बेस के लिए किया जाना चाहिए। (6)
'a' बाइट्स (किसी भी पायथन ऑब्जेक्ट का उपयोग करके कनवर्ट करता है repr(obj).encode('ascii','backslashreplace) )। (5)
'r' 'r' के लिए एक उपनाम है 'a' और इसका उपयोग केवल पायथन 2/3 कोड बेस के लिए किया जाना चाहिए। (7)
'%' कोई तर्क परिवर्तित नहीं होता है, परिणाम में एक '%' चरित्र होता है।

टिप्पणियाँ:

  1. वैकल्पिक रूप '0o' से पहले अंक से पहले एक अग्रणी ऑक्टल स्पेसियर ( ) डाला जाता है।
  2. वैकल्पिक रूप एक प्रमुख कारण बनता है '0x' या '0X' (जो इस पर निर्भर 'x' या 'X' प्रारूप का प्रयोग किया गया था) पहला अंक से पहले सम्मिलित करने के लिए।
  3. वैकल्पिक रूप से परिणाम हमेशा दशमलव बिंदु समाहित करता है, भले ही कोई अंक इसका अनुसरण न करता हो।

    सटीक दशमलव बिंदु के बाद अंकों की संख्या निर्धारित करता है और 6 तक चूक करता है।

  4. वैकल्पिक रूप से परिणाम हमेशा दशमलव बिंदु होता है, और अनुगामी शून्य को हटाया नहीं जाता क्योंकि वे अन्यथा होते।

    सटीक दशमलव बिंदु से पहले और बाद में 6 तक महत्वपूर्ण अंकों की संख्या निर्धारित करता है।

  5. यदि सटीक है N , तो आउटपुट N वर्णों को काट दिया जाता है।
  6. b'%s' पदावनत किया जाता है, लेकिन 3.x श्रृंखला के दौरान हटाया नहीं जाएगा।
  7. b'%r' पदावनत किया जाता है, लेकिन 3.x श्रृंखला के दौरान हटाया नहीं जाएगा।
  8. पीईपी 237 देखें ।

ध्यान दें

इस पद्धति का बाईट्रेयर संस्करण जगह में संचालित नहीं होता है - यह हमेशा एक नई वस्तु का उत्पादन करता है, भले ही कोई बदलाव नहीं किया गया हो।

यह भी देखें

पीईपी 461 - बाइट्स और बायट्रेयर के लिए% स्वरूपण जोड़ना

संस्करण 3.5 में नया।

मेमोरी दृश्य

memoryview ऑब्जेक्ट पायथन कोड को किसी ऑब्जेक्ट के आंतरिक डेटा तक पहुंचने की अनुमति देते हैं जो कॉपी किए बिना बफर प्रोटोकॉल का समर्थन करता है ।

class memoryview(obj)

memoryview उस संदर्भ को बनाएं obj obj बफर प्रोटोकॉल का समर्थन करना चाहिए। अंतर्निहित वस्तुएं जो बफर प्रोटोकॉल का समर्थन करती हैं उनमें शामिल हैं bytes और bytearray

A memoryview में एक तत्व की धारणा है , जो कि ओब्जेक्टिव ऑबजेक्ट यूनिट है जिसे ओब्जेक्टिव ऑब्जेक्ट ओब्जेक्ट द्वारा नियंत्रित किया जाता है । कई सरल प्रकारों जैसे कि bytes और bytearray , एक तत्व एक एकल बाइट है, लेकिन अन्य प्रकार जैसे कि array.array बड़े तत्व हो सकते हैं।

len(view) की लंबाई के बराबर है tolist । यदि view.ndim = 0 , लंबाई 1. है view.ndim = 1 , तो , लंबाई दृश्य में तत्वों की संख्या के बराबर है। उच्च आयामों के लिए, लंबाई नेस्टेड सूची प्रतिनिधित्व की लंबाई के बराबर है। itemsize विशेषता आप एक ही तत्व में बाइट की संख्या दे देंगे।

A memoryview इसके डेटा को उजागर करने के लिए स्लाइसिंग और इंडेक्सिंग का समर्थन करता है। एक आयामी टुकड़ा करने की क्रिया एक सबव्यू में परिणाम होगा:

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

यदि मॉड्यूल format से मूल प्रारूप निर्दिष्टकर्ताओं में से एक struct है, तो पूर्णांक के साथ अनुक्रमण या पूर्णांक का एक टपल भी समर्थित है और एकल तत्व को सही प्रकार के साथ लौटाता है । एक-आयामी मेमोरीव्यू को एक पूर्णांक या एक-पूर्णांक ट्यूपल के साथ अनुक्रमित किया जा सकता है। बहु-आयामी मेमोरीव्यू को ndim पूर्णांकों के tuples के साथ अनुक्रमित किया जा सकता है जहां ndim आयामों की संख्या है। शून्य-आयामी मेमोरी साक्षात्कार को खाली टपल के साथ अनुक्रमित किया जा सकता है।

यहां एक गैर-बाइट प्रारूप के साथ एक उदाहरण दिया गया है:

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

यदि अंतर्निहित ऑब्जेक्ट लेखन योग्य है, तो मेमोरीव्यू एक आयामी स्लाइस असाइनमेंट का समर्थन करता है। आकार बदलने की अनुमति नहीं है:

>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')

फॉर्मेट 'बी', 'बी' या 'सी' के साथ हैशेबल (रीड ओनली) टाइप के वन-डायमेंशनल मेमोरीव्यू भी वॉशेबल हैं। हैश को इस प्रकार परिभाषित किया गया है hash(m) == hash(m.tobytes()) :

>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True

संस्करण 3.3 में बदला गया: एक-आयामी मेमोरी साक्षात्कार अब कटा हुआ हो सकता है। फॉरमेट 'बी', 'बी' या 'सी' के साथ वन-डायमेंशनल मेमोरीव्यू अब वॉशेबल हैं।

संस्करण 3.4 में परिवर्तित: मेमोरीव्यू अब स्वचालित रूप से पंजीकृत है collections.abc.Sequence

संस्करण 3.5 में बदला गया: मेमोरी साक्षात्कार को अब पूर्णांकों के ट्यूल के साथ अनुक्रमित किया जा सकता है।

memoryview कई तरीके हैं:

__eq__(exporter)

एक मेमोरीव्यू और एक PEP 3118 निर्यातक समान हैं यदि उनकी आकृतियाँ समान हैं और यदि सभी संबंधित मान समान हैं तो ऑपरेंड के संबंधित प्रारूप कोड को struct सिंटैक्स का उपयोग करके व्याख्या की जाती है ।

struct वर्तमान में समर्थित प्रारूप स्ट्रिंग्स के सबसेट के लिए tolist , v और w यदि समान हैं v.tolist() == w.tolist() :

>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True

यदि struct मॉड्यूल द्वारा प्रारूप स्ट्रिंग का समर्थन नहीं किया जाता है , तो ऑब्जेक्ट हमेशा असमान के रूप में तुलना करेंगे (भले ही प्रारूप स्ट्रिंग और बफर सामग्री समान हो)

>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False

ध्यान दें कि, चल बिन्दु संख्या के साथ के रूप में, v is w करता नहीं मतलब v == w memoryview वस्तुओं के लिए।

संस्करण 3.3 में बदला गया: पिछले संस्करणों में आइटम स्वरूप और तार्किक सरणी संरचना की उपेक्षा करने वाली कच्ची मेमोरी की तुलना की गई।

tobytes()

बफर में डेटा को बाइटस्ट्रिंग के रूप में लौटाएं। यह bytes कंस्ट्रक्टर को मेमोरीव्यू पर कॉल करने के बराबर है ।

>>> m = memoryview(b"abc")
>>> m.tobytes()
b'abc'
>>> bytes(m)
b'abc'

गैर-सन्निहित सरणियों के लिए परिणाम बाइट्स में परिवर्तित सभी तत्वों के साथ समतल सूची प्रतिनिधित्व के बराबर है। tobytes() उन सभी प्रारूप स्ट्रिंग्स का समर्थन करता है, जिनमें struct मॉड्यूल सिंटैक्स में नहीं हैं ।

hex()

बफर में प्रत्येक बाइट के लिए दो हेक्साडेसिमल अंकों के साथ एक स्ट्रिंग ऑब्जेक्ट लौटें।

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

संस्करण 3.5 में नया।

tolist()

तत्वों की सूची के रूप में बफर में डेटा लौटाएं।

>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

संस्करण 3.3 में परिवर्तित: tolist अब struct मॉड्यूल सिंटैक्स के साथ-साथ बहु-आयामी अभ्यावेदन में सभी एकल वर्ण मूल स्वरूपों का समर्थन करता है।

release()

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

इस पद्धति को बुलाए जाने के बाद, दृश्य पर कोई भी संचालन एक ValueError ( release() स्वयं को छोड़कर, जिसे कई बार कहा जा सकता है) उठाता है :

>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

संदर्भ प्रबंधन प्रोटोकॉल का उपयोग एक समान प्रभाव के लिए किया जा सकता है, with कथन का उपयोग करते हुए:

>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

संस्करण 3.2 में नया।

cast(format[, shape])

एक नए प्रारूप या आकार के लिए एक स्मृति कास्ट करें। आकार में चूक होती है [byte_length//new_itemsize] , जिसका अर्थ है कि परिणाम दृश्य एक आयामी होगा। रिटर्न वैल्यू एक नया मेमोरीव्यू है, लेकिन बफर खुद कॉपी नहीं होता है। समर्थित जातियां 1D -> C- contiguous और C- सन्निहित -> 1D हैं।

गंतव्य प्रारूप struct सिंटैक्स में एकल तत्व मूल स्वरूप तक सीमित है । स्वरूपों में से एक बाइट प्रारूप ('बी', 'बी' या 'सी') होना चाहिए। परिणाम की बाइट लंबाई मूल लंबाई के समान होनी चाहिए।

1D / लंबे समय तक 1D / अहस्ताक्षरित बाइट कास्ट करें:

>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24

1D / अहस्ताक्षरित बाइट्स को 1D / char में डालें:

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview: invalid value for format "B"
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

1 डी / बाइट्स को 1 डी / हस्ताक्षरित चार पर कास्ट करें:

>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

2 डी / अहस्ताक्षरित चार को कास्ट करें

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

संस्करण 3.3 में नया।

संस्करण 3.5 में परिवर्तित: बाइट दृश्य में कास्टिंग करते समय स्रोत प्रारूप प्रतिबंधित नहीं है।

कई आसानी से उपलब्ध विशेषताएँ भी हैं:

obj

मेमोरीव्यू की अंतर्निहित वस्तु:

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

संस्करण 3.3 में नया।

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes()) । यह बाइट्स में जगह की मात्रा है जो सरणी एक सन्निहित प्रतिनिधित्व में उपयोग करेगी। यह जरूरी नहीं कि लेन (एम) के बराबर हो:

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

बहु-आयामी सरणियाँ:

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

संस्करण 3.3 में नया।

readonly

एक संकेत है कि स्मृति केवल पढ़ने के लिए है।

format

struct दृश्य में प्रत्येक तत्व के लिए प्रारूप ( मॉड्यूल शैली में) युक्त एक स्ट्रिंग । एक्सपोर्टर्स से एक मेमोरीव्यू बनाया जा सकता है जिसमें मनमाने फॉर्मेट स्ट्रिंग्स हैं, लेकिन कुछ तरीके (जैसे tolist ) देशी सिंगल एलिमेंट फॉर्मेट तक ही सीमित हैं।

संस्करण ३.३ में बदला गया: प्रारूप 'B' अब संरचनात्मक मॉड्यूल सिंटैक्स के अनुसार संभाला जाता है। इसका मतलब है कि memoryview(b'abc')[0] == b'abc'[0] == 97

itemsize

मेमोरीव्यू के प्रत्येक तत्व के बाइट्स में आकार:

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True
ndim

मेमोरी का प्रतिनिधित्व करने वाले एक बहु-आयामी सरणी के कितने आयाम दर्शाता है एक पूर्णांक।

shape

ndim एन-डायमेंशनल ऐरे के रूप में मेमोरी की शेप देने की लंबाई से पूर्णांक का एक हिस्सा।

संस्करण 3.3 में बदला: None जब ndim = 0 के बजाय एक खाली टपल ।

strides

ndim सरणी के प्रत्येक आयाम के लिए प्रत्येक तत्व तक पहुंचने के लिए बाइट्स में आकार देने की लंबाई से पूर्णांक का एक हिस्सा।

संस्करण 3.3 में बदला: None जब ndim = 0 के बजाय एक खाली टपल ।

suboffsets

PIL- शैली सरणियों के लिए आंतरिक रूप से उपयोग किया जाता है। मूल्य केवल सूचनात्मक है।

c_contiguous

एक संकेत है कि स्मृति C- contiguous

संस्करण 3.3 में नया।

f_contiguous

एक संकेत है कि स्मृति फोरट्रान contiguous

संस्करण 3.3 में नया।

contiguous

एक संकेत है कि स्मृति contiguous

संस्करण 3.3 में नया।

सेट प्रकार - सेट, फ्रोज़ेनसेट

एक सेट ऑब्जेक्ट अलग-अलग hashable वस्तुओं का एक अनियंत्रित संग्रह है । सामान्य उपयोगों में सदस्यता परीक्षण, एक अनुक्रम से डुप्लिकेट को हटाना, और गणितीय संचालन जैसे कि चौराहे, संघ, अंतर और सममित अंतर को कंप्यूटिंग करना शामिल है। (अन्य कंटेनरों के लिए निर्मित देख dict , list है, और tuple वर्गों, और collections मॉड्यूल।)

अन्य संग्रह की तरह, सेट समर्थन x in set , len(set) और for x in set । एक अनियंत्रित संग्रह होने के नाते, सेट तत्व स्थिति या प्रविष्टि के क्रम को रिकॉर्ड नहीं करता है। तदनुसार, सेट अनुक्रमण, स्लाइसिंग या अन्य अनुक्रम-जैसे व्यवहार का समर्थन नहीं करते हैं।

वर्तमान में दो अंतर्निहित सेट प्रकार हैं, set और frozenset set प्रकार परिवर्तनशील है - सामग्री की तरह तरीकों का उपयोग कर बदला जा सकता है add() और remove() । चूँकि यह परिवर्तनशील है, इसका कोई हैश मान नहीं है और इसका उपयोग या तो एक शब्दकोश कुंजी के रूप में या दूसरे सेट के तत्व के रूप में नहीं किया जा सकता है। frozenset प्रकार अपरिवर्तनीय और है hashable - इसकी सामग्री के बाद यह बनाई गई है परिवर्तित नहीं किया जा सकता है; यह इसलिए एक शब्दकोश कुंजी के रूप में या किसी अन्य सेट के तत्व के रूप में उपयोग किया जा सकता है।

गैर-खाली सेट (फ्रॉज़ेनसेट्स नहीं) ब्रेसिज़ के भीतर तत्वों की अल्पविराम से अलग सूची रखकर बनाया जा सकता है, उदाहरण के लिए: निर्माणकर्ता के {'jack', 'sjoerd'} अलावा set

दोनों वर्गों के लिए निर्माणकर्ता समान हैं:

class set([iterable])
class frozenset([iterable])

एक नया सेट या frozenset वस्तु जिसका तत्वों से लिया जाता है लौटें iterable । एक सेट के तत्वों को hashable होना चाहिए । सेट के सेट का प्रतिनिधित्व करने के लिए, आंतरिक सेट frozenset ऑब्जेक्ट होना चाहिए । यदि पुनरावृत्त निर्दिष्ट नहीं है, तो एक नया खाली सेट लौटाया जाता है।

निम्नलिखित कार्यों के उदाहरण set और frozenset प्रदान करते हैं:

len(s)

सेट में तत्वों की संख्या लौटें रों (की प्रमुखता रों )।

x in s

एस में सदस्यता के लिए टेस्ट एक्स

x not in s

एस में गैर-सदस्यता के लिए टेस्ट एक्स

isdisjoint(other)

True यदि सेट में अन्य के साथ कोई तत्व नहीं है तो वापस लौटें । यदि उनका चौराहा खाली सेट है, तो केवल और केवल समूह ही नाराज हैं।

issubset(other)
set <= other

परीक्षण करें कि क्या सेट में प्रत्येक तत्व दूसरे में है

set < other

परीक्षण करें कि क्या सेट अन्य का उचित उपसमूह है , अर्थात set <= other and set != other

issuperset(other)
set >= other

परीक्षण करें कि क्या प्रत्येक तत्व दूसरे सेट में है।

set > other

परीक्षण करें कि क्या सेट अन्य का एक उचित सुपरसेट है , अर्थात set >= other and set != other

union(*others)
set | other | ...

सेट और अन्य सभी से तत्वों के साथ एक नया सेट लौटाएं।

intersection(*others)
set & other & ...

सेट और अन्य सभी के लिए आम तत्वों के साथ एक नया सेट लौटाएं।

difference(*others)
set - other - ...

सेट में तत्वों के साथ एक नया सेट लौटाएं जो दूसरों में नहीं हैं।

symmetric_difference(other)
set ^ other

तत्वों के साथ सेट या अन्य में एक नया सेट लौटाएं लेकिन दोनों नहीं।

copy()

एस के उथले प्रति के साथ एक नया सेट लौटाएं ।

ध्यान दें, के गैर ऑपरेटर संस्करणों union() , intersection() , difference() , और symmetric_difference() , issubset() और issuperset() तरीकों एक तर्क के रूप में किसी भी iterable को स्वीकार करेंगे। इसके विपरीत, उनके ऑपरेटर आधारित समकक्षों को उनके तर्क सेट करने की आवश्यकता होती है। यह set('abc') & 'cbs' अधिक पढ़ने योग्य के पक्ष में त्रुटि-प्रवण निर्माण को रोकता है set('abc').intersection('cbs')

दोनों set और frozenset समर्थन की तुलना सेट करने के लिए करते हैं। दो सेट बराबर हैं यदि और केवल यदि प्रत्येक सेट का प्रत्येक तत्व दूसरे में निहित है (प्रत्येक दूसरे का सबसेट है)। एक सेट दूसरे सेट से कम है अगर और केवल अगर पहला सेट दूसरे सेट का एक उचित सबसेट है (एक सबसेट है, लेकिन बराबर नहीं है)। एक सेट दूसरे सेट से अधिक है यदि और केवल अगर पहला सेट दूसरे सेट का एक उचित सुपरसेट है (एक सुपरसेट है, लेकिन बराबर नहीं है)।

उदाहरणों की set तुलना frozenset उनके सदस्यों पर आधारित उदाहरणों से की जाती है । उदाहरण के लिए, set('abc') == frozenset('abc') रिटर्न True और ऐसा ही होता है set('abc') in set([frozenset('abc')])

उप-क्रम और समानता की तुलना कुल ऑर्डरिंग फ़ंक्शन के लिए सामान्य नहीं होती है। उदाहरण के लिए, किसी भी दो अरिक्त संबंध तोड़ना सेट तो बराबर नहीं हैं और एक दूसरे के सबसेट नहीं हैं, सभी निम्नलिखित वापसी की False : a<b , a==b , या a>b

चूंकि सेट केवल आंशिक ऑर्डरिंग (सब्सेट रिलेशनशिप) को परिभाषित करते हैं, इसलिए सेट की sort() सूचियों के लिए विधि का आउटपुट अपरिभाषित है।

सेट तत्वों, शब्दकोश कुंजी की तरह होना चाहिए, hashable

द्विआधारी संचालन जो मिश्रण set करते frozenset हैं, पहले ऑपरेंड के प्रकार को वापस करते हैं। उदाहरण के लिए: का frozenset('ab') | set('bc') एक उदाहरण देता है frozenset

निम्न तालिका सूची संचालन के लिए उपलब्ध संचालन set को अपरिवर्तनीय उदाहरणों पर लागू नहीं करती है frozenset :

update(*others)
set |= other | ...

अन्य सभी से तत्वों को जोड़ते हुए, सेट को अपडेट करें।

intersection_update(*others)
set &= other & ...

केवल और उसमें पाए जाने वाले सभी तत्वों को ध्यान में रखते हुए सेट को अपडेट करें।

difference_update(*others)
set -= other | ...

दूसरों में पाए जाने वाले तत्वों को हटाते हुए सेट को अपडेट करें।

symmetric_difference_update(other)
set ^= other

सेट को अपडेट करें, केवल सेट में पाए गए तत्वों को रखते हुए, लेकिन दोनों में नहीं।

add(elem)

सेट में एलिमेंट एलम जोड़ें ।

remove(elem)

तत्व निकालें ELEM सेट से। KeyError अगर हाथी सेट में समाहित नहीं है तो उठाता है ।

discard(elem)

तत्व निकालें ELEM सेट से अगर यह मौजूद है।

pop()

सेट से एक मनमाना तत्व निकालें और वापस करें। KeyError सेट खाली होने पर उठाता है।

clear()

सेट से सभी तत्वों को निकालें।

ध्यान दें, के गैर ऑपरेटर संस्करणों update() , intersection_update() , difference_update() , और symmetric_difference_update() तरीकों एक तर्क के रूप में किसी भी iterable को स्वीकार करेंगे।

ध्यान दें, ELEM को तर्क __contains__() , remove() और discard() तरीकों एक सेट हो सकता है। एक बराबर frozenset के लिए खोज का समर्थन करने के लिए, एक अस्थायी एक से बनाई गई है ELEM

मानचित्रण प्रकार - तानाशाही

एक mapping ऑब्जेक्ट मनमानी वस्तुओं के लिए hashable मूल्यों को mapping । मैपिंग उत्परिवर्तनीय वस्तुएं हैं। वर्तमान में केवल एक मानक मानचित्रण प्रकार है, शब्दकोश । (अन्य कंटेनरों के लिए निर्मित देख list , set है, और tuple वर्गों, और collections मॉड्यूल।)

शब्दकोश की कुंजियाँ लगभग मनमानी मूल्य हैं। वे मान जो कि उपलब्ध नहीं हैं, hashable , सूची, शब्दकोश या अन्य परिवर्तनशील प्रकारों वाले मान (जिनकी तुलना वस्तु की पहचान के बजाय मूल्य से की जाती है) को कुंजी के रूप में उपयोग नहीं किया जा सकता है। संख्यात्मक के लिए उपयोग किए जाने वाले संख्यात्मक प्रकार संख्यात्मक तुलना के लिए सामान्य नियमों का पालन करते हैं: यदि दो संख्याएं समान (जैसे कि 1 और 1.0 ) की तुलना करती हैं, तो उनका उपयोग समान रूप से एक ही शब्दकोश प्रविष्टि को अनुक्रमित करने के लिए किया जा सकता है। (हालांकि, ध्यान दें कि चूंकि कंप्यूटर फ़्लोटिंग-पॉइंट संख्याओं को सन्निकटन के रूप में संग्रहीत करते हैं, इसलिए आमतौर पर उन्हें शब्दकोश कुंजियों के रूप में उपयोग करना नासमझी है।)

key: value शब्दकोशों को ब्रेसिज़ के भीतर जोड़े की अल्पविराम से अलग सूची रखकर बनाया जा सकता है , उदाहरण के लिए: {'jack': 4098, 'sjoerd': 4127} या {4098: 'jack', 4127: 'sjoerd'} , या dict कंस्ट्रक्टर द्वारा ।

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

वैकल्पिक स्थिति तर्क और कीवर्ड तर्कों के संभवतः खाली सेट से आरंभ किया गया एक नया शब्दकोश लौटाएं।

यदि कोई स्थितिगत तर्क नहीं दिया जाता है, तो एक खाली शब्दकोश बनाया जाता है। यदि कोई स्थैतिक तर्क दिया जाता है और यह एक मैपिंग ऑब्जेक्ट है, तो एक शब्दकोश मैपिंग ऑब्जेक्ट के समान कुंजी-मूल्य वाले जोड़े के साथ बनाया जाता है। अन्यथा, स्थितीय तर्क एक iterable वस्तु होनी चाहिए । Iterable में प्रत्येक आइटम वास्तव में दो वस्तुओं के साथ एक चलने योग्य होना चाहिए। प्रत्येक आइटम का पहला ऑब्जेक्ट नए शब्दकोश में एक कुंजी बन जाता है, और दूसरा ऑब्जेक्ट संबंधित मूल्य। यदि एक कुंजी एक से अधिक बार होती है, तो उस कुंजी के लिए अंतिम मान नए शब्दकोश में संबंधित मूल्य बन जाता है।

यदि कीवर्ड तर्क दिए जाते हैं, तो कीवर्ड तर्क और उनके मूल्य स्थितीय तर्क से बनाए गए शब्दकोश में जुड़ जाते हैं। यदि कोई कुंजी जोड़ी जा रही है, पहले से मौजूद है, तो कीवर्ड तर्क से मान स्थिति तर्क से मान बदल देता है।

वर्णन करने के लिए, निम्नलिखित उदाहरण सभी के लिए एक समान शब्द देते हैं {"one": 1, "two": 2, "three": 3} :

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

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

ये ऐसे ऑपरेशन हैं जो समर्थन का समर्थन करते हैं (और इसलिए, कस्टम मैपिंग प्रकारों को भी समर्थन करना चाहिए):

len(d)

शब्दकोश में आइटमों की संख्या वापस करें d

d[key]

कुंजी कुंजी के साथ d का आइटम लौटाएं । यदि कुंजी मैप में नहीं है तो उठाता है । KeyError

यदि कोई उप-वर्ग एक विधि को परिभाषित करता है __missing__() और कुंजी मौजूद नहीं है, तो d[key] ऑपरेशन उस विधि को मुख्य कुंजी के साथ तर्क के रूप में कहता है । d[key] आपरेशन तो रिटर्न या जन्म देती है जो कुछ भी लौट आए या द्वारा उठाए गए है __missing__(key) कॉल। कोई अन्य संचालन या विधियाँ आह्वान नहीं करती हैं __missing__() । यदि __missing__() परिभाषित नहीं है, KeyError तो उठाया जाता है। __missing__() एक विधि होनी चाहिए; यह एक उदाहरण चर नहीं हो सकता है:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

ऊपर दिए गए उदाहरण के कार्यान्वयन का हिस्सा दिखाता है collections.Counter । द्वारा एक अलग __missing__ विधि का उपयोग किया जाता है collections.defaultdict

d[key] = value

सेट d[key] करने के लिए मूल्य

del d[key]

डी d[key] से निकालें । यदि कुंजी मैप में नहीं है तो उठाता है । KeyError

key in d

True यदि d के पास कुंजी है , तो वापस लौटें False

key not in d

के बराबर है not key in d

iter(d)

शब्दकोश की कुंजी पर एक पुनरावृत्त लौटें। यह एक शॉर्टकट है iter(d.keys())

clear()

शब्दकोश से सभी आइटम निकालें।

copy()

शब्दकोश की उथली प्रति लौटाएं।

classmethod fromkeys(seq[, value])

से कुंजी के साथ एक नया शब्दकोश बनाएं seq करने के लिए सेट और मूल्यों मूल्य

fromkeys() एक वर्ग विधि है जो एक नया शब्दकोश लौटाती है। मान चूक None

get(key[, default])

कुंजी के लिए मान लौटाएं यदि कुंजी शब्दकोश में है, तो डिफ़ॉल्ट रूप से । यदि डिफ़ॉल्ट नहीं दिया गया है None , तो यह चूक करता है , ताकि यह विधि कभी भी न उठे KeyError

items()

शब्दकोश के आइटम ( (key, value) जोड़े) का एक नया दृश्य लौटाएं । दृश्य वस्तुओं का प्रलेखन देखें ।

keys()

शब्दकोश की कुंजियों का एक नया दृश्य लौटाएँ। दृश्य वस्तुओं का प्रलेखन देखें ।

pop(key[, default])

यदि कुंजी शब्दकोश में है, इसे हटाने और अपने मूल्य, और वापसी वापसी डिफ़ॉल्ट । यदि डिफ़ॉल्ट नहीं दिया गया है और कुंजी शब्दकोश में नहीं है, तो एक KeyError उठाया जाता है।

popitem()

(key, value) शब्दकोश से एक जोड़ी निकालें और वापस लौटाएँ। जोड़े LIFO के क्रम में वापस आ जाते हैं ।

popitem() एक डिक्शनरी पर विनाशकारी पुनरावृति के लिए उपयोगी है, जैसा कि अक्सर सेट एल्गोरिदम में उपयोग किया जाता है। यदि शब्दकोश खाली है, तो कॉलिंग popitem() उठती है a KeyError

संस्करण 3.7 में परिवर्तित: LIFO आदेश अब गारंटी है। पूर्व संस्करणों में, popitem() एक अनियंत्रित कुंजी / मान युग्म लौटाएगा।

setdefault(key[, default])

यदि शब्दकोष में कुंजी है, तो उसका मान लौटाएं। यदि नहीं, तो डिफ़ॉल्ट के मान के साथ कुंजी डालें और डिफ़ॉल्ट लौटें । डिफ़ॉल्ट चूक । None

update([other])

मौजूदा कुंजियों को अधिलेखित करते हुए अन्य से कुंजी / मान जोड़े के साथ शब्दकोश को अपडेट करें। वापसी None

update() या तो एक अन्य शब्दकोश वस्तु या कुंजी / मूल्य जोड़े के एक पुनरावृत्ति को स्वीकार करता है (जैसे कि ट्यूपल्स या लंबाई के अन्य पुनरावृत्तियों) यदि कीवर्ड तर्क निर्दिष्ट किए जाते हैं, तो शब्दकोश को उन कुंजी / मान युग्मों के साथ अपडेट किया जाता है d.update(red=1, blue=2) :।

values()

शब्दकोश के मूल्यों का एक नया दृश्य लौटाएँ। दृश्य वस्तुओं का प्रलेखन देखें ।

यदि समान (key, value) जोड़े हैं, तो केवल और अगर डिक्शनरी की तुलना होती है । आदेश की तुलना ('<', '<=', '> =', '>') बढ़ाएँ TypeError

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

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

संस्करण 3.7 में परिवर्तित: शब्दकोश आदेश प्रविष्टि आदेश होने की गारंटी है। यह व्यवहार 3.6 से CPython का कार्यान्वयन विवरण था।

यह भी देखें

types.MappingProxyType एक का केवल पढ़ने के लिए एक दृश्य बनाने के लिए इस्तेमाल किया जा सकता है dict

शब्दकोश वस्तुओं को देखने

वस्तुओं द्वारा दिया dict.keys() , dict.values() और dict.items() कर रहे हैं वस्तुओं को देखने । वे शब्दकोश की प्रविष्टियों पर एक गतिशील दृश्य प्रदान करते हैं, जिसका अर्थ है कि जब शब्दकोश बदलता है, तो दृश्य इन परिवर्तनों को दर्शाता है।

शब्दकोश दृश्य उनके संबंधित डेटा, और सदस्यता परीक्षणों का समर्थन करने के लिए अधिक पुनरावृत्त हो सकते हैं:

len(dictview)

शब्दकोश में प्रविष्टियों की संख्या लौटाएं।

iter(dictview)

शब्दकोश में कुंजियों, मूल्यों या वस्तुओं (टुपल्स के रूप में प्रतिनिधित्व (key, value) ) पर एक पुनरावृत्तिकर्ता लौटें ।

प्रविष्टि क्रम में कुंजी और मान पुनरावृत्त होते हैं। इस के निर्माण की अनुमति देता (value, key) का उपयोग कर जोड़े zip() : pairs = zip(d.values(), d.keys()) । उसी सूची को बनाने का दूसरा तरीका है pairs = [(v, k) for (k, v) in d.items()]

डिक्शनरी में प्रविष्टियों को जोड़ने या हटाने के दौरान विचारों को बदलना या RuntimeError सभी प्रविष्टियों पर पुनरावृति करने में विफल हो सकता है ।

संस्करण 3.7 में परिवर्तित: शब्दकोश आदेश प्रविष्टि आदेश होने की गारंटी है।

x in dictview

वापसी True अगर x अंतर्निहित शब्दकोश की कुंजियों, मूल्यों या वस्तुओं में है (बाद वाले मामले में, x एक (key, value) तुच्छ होना चाहिए )।

कुंजी के दृश्य सेट-जैसे हैं क्योंकि उनकी प्रविष्टियाँ अद्वितीय और धोने योग्य हैं। यदि सभी मान उपलब्ध नहीं होते हैं, तो (key, value) जोड़े अद्वितीय और धोने योग्य होते हैं, तो आइटम दृश्य भी सेट-जैसे होते हैं। (के बाद से प्रविष्टियों आम तौर पर अद्वितीय नहीं हैं मान विचारों सेट की तरह के रूप में व्यवहार नहीं कर रहे हैं।) सेट की तरह देखा गया, संचालन सार आधार वर्ग के लिए निर्धारित के सभी collections.abc.Set उपलब्ध हैं (उदाहरण के लिए, == , < , या ^ )।

शब्दकोश देखने के उपयोग का एक उदाहरण:

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.keys()
>>> values = dishes.values()

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'sausage', 'bacon', 'spam'}

प्रसंग प्रबंधक प्रकार

पायथन का with बयान एक संदर्भ प्रबंधक द्वारा परिभाषित रनटाइम संदर्भ की अवधारणा का समर्थन करता है। यह उन विधियों की एक जोड़ी का उपयोग करके कार्यान्वित किया जाता है, जो उपयोगकर्ता द्वारा परिभाषित कक्षाओं को एक रनटाइम संदर्भ को परिभाषित करने की अनुमति देते हैं, जो कि स्टेटमेंट समाप्त होने से पहले दर्ज किया जाता है और जब स्टेटमेंट समाप्त हो जाता है:

contextmanager.__enter__()

रनटाइम संदर्भ दर्ज करें और इस ऑब्जेक्ट या रनटाइम संदर्भ से संबंधित किसी अन्य ऑब्जेक्ट को वापस करें। इस पद्धति द्वारा लौटाया गया मान इस संदर्भ प्रबंधक का उपयोग करके विवरणों के as खंड में पहचानकर्ता के लिए बाध्य है with

एक संदर्भ प्रबंधक का एक उदाहरण जो स्वयं रिटर्न करता है, एक फ़ाइल ऑब्जेक्ट है । फ़ाइल ऑब्जेक्ट open() एक with बयान में संदर्भ अभिव्यक्ति के रूप में उपयोग करने की अनुमति देने के लिए __enter __ () से खुद को वापस करते हैं ।

एक संदर्भ प्रबंधक का एक उदाहरण जो संबंधित वस्तु को लौटाता है वह वह है जो उसके द्वारा लौटाया जाता है decimal.localcontext() । ये प्रबंधक सक्रिय दशमलव संदर्भ को मूल दशमलव संदर्भ की एक प्रति पर सेट करते हैं और फिर प्रतिलिपि लौटाते हैं। यह with बयान के शरीर में वर्तमान दशमलव संदर्भ में बयान के बाहर कोड को प्रभावित किए बिना परिवर्तन करने की अनुमति देता है with

contextmanager.__exit__(exc_type, exc_val, exc_tb)

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

इस पद्धति से एक वास्तविक मूल्य वापस with करने से बयान को अपवाद को दबाने और बयान के तुरंत बाद बयान के साथ निष्पादन जारी रखने का कारण होगा with । अन्यथा इस पद्धति का क्रियान्वयन समाप्त होने के बाद अपवाद का प्रचार जारी है। इस पद्धति के निष्पादन के दौरान होने वाले अपवाद with बयान के शरीर में होने वाले किसी भी अपवाद को बदल देंगे ।

अपवाद को कभी भी स्पष्ट रूप से reraised नहीं किया जाना चाहिए - इसके बजाय, इस विधि को यह इंगित करने के लिए गलत मान लौटना चाहिए कि विधि सफलतापूर्वक पूरी हो गई है और उठाए गए अपवाद को दबाना नहीं चाहता। इससे संदर्भ प्रबंधन कोड आसानी से पता लगा सकता है कि कोई __exit__() विधि वास्तव में विफल हुई है या नहीं ।

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

पायथन के generator एस और contextlib.contextmanager डेकोरेटर इन प्रोटोकॉल को लागू करने का एक सुविधाजनक तरीका प्रदान करते हैं। यदि एक जनरेटर फ़ंक्शन को contextlib.contextmanager डेकोरेटर के साथ सजाया गया है , तो यह एक संदर्भ प्रबंधक को आवश्यक __enter__() और __exit__() विधियों को लागू करने के बजाय, एक अघोषित जनरेटर फ़ंक्शन द्वारा उत्पादित इट्रेटर से लौटाएगा।

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

अन्य अंतर्निहित प्रकार

दुभाषिया कई अन्य प्रकार की वस्तुओं का समर्थन करता है। इनमें से अधिकांश केवल एक या दो ऑपरेशन का समर्थन करते हैं।

मॉड्यूल

एक मॉड्यूल पर एकमात्र विशेष ऑपरेशन विशेषता पहुंच है: m.name जहां एम एक मॉड्यूल है और नाम एम के प्रतीक तालिका में परिभाषित नाम तक पहुंचता है । मॉड्यूल विशेषताओं को सौंपा जा सकता है। (ध्यान दें कि import कथन कड़ाई से नहीं बोल रहा है, एक मॉड्यूल ऑब्जेक्ट पर एक ऑपरेशन; import foo इसके लिए फू नामक एक मॉड्यूल ऑब्जेक्ट की आवश्यकता नहीं है, बल्कि इसके लिए कहीं एक फू नामक मॉड्यूल के लिए (बाहरी) परिभाषा की आवश्यकता होती है।)

प्रत्येक मॉड्यूल की एक विशेष विशेषता है __dict__ । यह डिक्शनरी है जिसमें मॉड्यूल का सिंबल टेबल है। इस शब्दकोश को संशोधित करने से वास्तव में मॉड्यूल की प्रतीक तालिका बदल जाएगी, लेकिन __dict__ विशेषता के लिए प्रत्यक्ष असाइनमेंट संभव नहीं है (आप लिख सकते हैं m.__dict__['a'] = 1 , जो ma होना परिभाषित करता है 1 , लेकिन आप नहीं लिख सकते हैं m.__dict__ = {} )। __dict__ सीधे संशोधित करने की अनुशंसा नहीं की जाती है।

दुभाषिया में निर्मित मॉड्यूल इस तरह लिखे जाते हैं <module 'sys' (built-in)> :। यदि किसी फ़ाइल से लोड किया जाता है, तो वे इस प्रकार लिखे जाते हैं <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>

कक्षाएँ और कक्षाएँ

इनके लिए ऑब्जेक्ट्स, वैल्यूज़ और टाइप्स और class देखें ।

कार्य

फ़ंक्शन ऑब्जेक्ट फ़ंक्शन परिभाषाओं द्वारा बनाए जाते हैं। एक फ़ंक्शन ऑब्जेक्ट पर एकमात्र ऑपरेशन इसे कॉल करना है func(argument-list) :।

फ़ंक्शन ऑब्जेक्ट्स के वास्तव में दो स्वाद हैं: अंतर्निहित फ़ंक्शन और उपयोगकर्ता-परिभाषित फ़ंक्शन। दोनों एक ही ऑपरेशन (फ़ंक्शन को कॉल करने के लिए) का समर्थन करते हैं, लेकिन कार्यान्वयन अलग है, इसलिए विभिन्न ऑब्जेक्ट प्रकार।

अधिक जानकारी के लिए फ़ंक्शन परिभाषाएँ देखें ।

तरीके

विधियाँ फ़ंक्शन हैं जिन्हें विशेषता संकेतन का उपयोग करके कहा जाता है। दो स्वाद हैं: अंतर्निहित विधियाँ (जैसे append() सूचियों पर) और वर्ग उदाहरण विधियाँ। अंतर्निहित विधियों का वर्णन उन प्रकारों के साथ किया जाता है जो उनका समर्थन करते हैं।

यदि आप एक विधि (एक क्लास नेमस्पेस में परिभाषित फ़ंक्शन) का उपयोग एक उदाहरण के माध्यम से करते हैं, तो आपको एक विशेष ऑब्जेक्ट मिलता है: एक बाउंड विधि (जिसे इंस्टेंस विधि भी कहा जाता है ) ऑब्जेक्ट। जब कहा जाता है, यह self तर्क को तर्क सूची में जोड़ देगा । बाउंड विधियों में दो विशेष रीड-ओनली विशेषताएँ हैं: m.__self__ वह ऑब्जेक्ट है जिस पर विधि संचालित होती है, और m.__func__ विधि को लागू करने वाला फ़ंक्शन है। कॉलिंग m(arg-1, arg-2, ..., arg-n) पूरी तरह से कॉलिंग के बराबर है m.__func__(m.__self__, arg-1, arg-2, ..., arg-n)

फ़ंक्शन ऑब्जेक्ट्स की तरह, बाउंड मेथड ऑब्जेक्ट्स मनमानी विशेषताओं को प्राप्त करने का समर्थन करते हैं। हालाँकि, चूंकि विधि विशेषताएँ वास्तव में अंतर्निहित फ़ंक्शन ऑब्जेक्ट ( meth.__func__ ) पर संग्रहीत हैं, इसलिए बाउंड विधियों पर विधि विशेषताएँ सेट करना बंद कर दिया गया है। एक विधि पर एक विशेषता सेट करने का प्रयास एक परिणाम में AttributeError उठाया जा रहा है। विधि विशेषता सेट करने के लिए, आपको इसे अंतर्निहित फ़ंक्शन ऑब्जेक्ट पर स्पष्ट रूप से सेट करने की आवश्यकता है:

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

देखें मानक प्रकार पदानुक्रम में अधिक जानकारी के लिए।

कोड ऑब्जेक्ट

कोड ऑब्जेक्ट्स का उपयोग कार्यान्वयन द्वारा "छद्म-संकलित" निष्पादन योग्य पायथन कोड जैसे कि एक फ़ंक्शन बॉडी का प्रतिनिधित्व करने के लिए किया जाता है। वे फ़ंक्शन ऑब्जेक्ट्स से भिन्न होते हैं क्योंकि उनके वैश्विक निष्पादन वातावरण का संदर्भ नहीं होता है। कोड ऑब्जेक्ट बिल्ट-इन compile() फ़ंक्शन द्वारा लौटाए जाते हैं और फ़ंक्शन ऑब्जेक्ट से उनकी __code__ विशेषता के माध्यम से निकाले जा सकते हैं । code मॉड्यूल भी देखें ।

किसी कोड ऑब्जेक्ट को निष्पादित या मूल्यांकन किया जा सकता है (इसे स्रोत स्ट्रिंग के बजाय) exec() या eval() निर्मित कार्यों में।

देखें मानक प्रकार पदानुक्रम में अधिक जानकारी के लिए।

ऑब्जेक्ट टाइप करें

टाइप ऑब्जेक्ट विभिन्न ऑब्जेक्ट प्रकारों का प्रतिनिधित्व करते हैं। किसी ऑब्जेक्ट का प्रकार अंतर्निहित फ़ंक्शन द्वारा एक्सेस किया जाता है type() । प्रकारों पर कोई विशेष संचालन नहीं है। मानक मॉड्यूल types सभी मानक निर्मित प्रकारों के लिए नामों को परिभाषित करता है।

प्रकार इस तरह लिखा जाता है: <class 'int'>

अशक्त वस्तु

यह ऑब्जेक्ट फ़ंक्शंस द्वारा लौटाया जाता है जो स्पष्ट रूप से एक मान नहीं लौटाता है। यह बिना किसी विशेष ऑपरेशन का समर्थन करता है। बिल्कुल एक अशक्त वस्तु है, जिसका नाम None (एक अंतर्निहित नाम) है। type(None)() एक ही सिंगलटन पैदा करता है।

के रूप में लिखा है None

एलिप्सिस ऑब्जेक्ट

इस वस्तु आमतौर पर टुकड़ा करने की क्रिया (देखें द्वारा किया जाता है Slicings )। यह बिना किसी विशेष ऑपरेशन का समर्थन करता है। बिल्कुल एक दीर्घवृत्ताभ वस्तु है, जिसका नाम Ellipsis (एक अंतर्निहित नाम) है। सिंगलटन type(Ellipsis)() पैदा करता है Ellipsis

यह के रूप में Ellipsis या लिखा है ...

NotImplemented ऑब्जेक्ट

यह ऑब्जेक्ट तुलना और बाइनरी ऑपरेशन से लौटाया जाता है जब उन्हें उन प्रकारों पर काम करने के लिए कहा जाता है जो वे समर्थन नहीं करते। अधिक जानकारी के लिए Comparisons देखें । बिल्कुल एक NotImplemented वस्तु है। type(NotImplemented)() सिंगलटन उदाहरण प्रस्तुत करता है।

के रूप में लिखा है NotImplemented

बूलियन मान

बूलियन मान दो स्थिर ऑब्जेक्ट हैं False और True । उनका उपयोग सत्य मूल्यों का प्रतिनिधित्व करने के लिए किया जाता है (हालांकि अन्य मूल्यों को भी गलत या सत्य माना जा सकता है)। संख्यात्मक संदर्भों में (उदाहरण के लिए जब एक अंकगणितीय ऑपरेटर के तर्क के रूप में उपयोग किया जाता है), वे क्रमशः पूर्णांक 0 और 1 की तरह व्यवहार करते हैं। बिल्ट-इन फ़ंक्शन bool() का उपयोग किसी भी मूल्य को बूलियन में बदलने के लिए किया जा सकता है, यदि मूल्य को एक सत्य मूल्य के रूप में व्याख्या किया जा सकता है ( ऊपर अनुभाग सत्य मूल्य परीक्षण देखें )

वे क्रमशः, False और के रूप में लिखे True गए हैं।

आंतरिक वस्तुएं

देखें मानक प्रकार पदानुक्रम इस जानकारी के लिए। यह स्टैक फ्रेम ऑब्जेक्ट्स, ट्रेसबैक ऑब्जेक्ट्स और स्लाइस ऑब्जेक्ट्स का वर्णन करता है।

विशेष गुण

कार्यान्वयन कई विशेष प्रकारों के लिए कुछ विशेष रीड-ओनली विशेषताओं को जोड़ता है, जहाँ वे प्रासंगिक हैं। इनमें से कुछ dir() बिल्ट-इन फ़ंक्शन द्वारा रिपोर्ट नहीं किए गए हैं ।

object.__dict__

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

instance.__class__

वह वर्ग जिसके लिए एक श्रेणी उदाहरण है।

class.__bases__

एक वर्ग वस्तु के आधार वर्गों का टपल।

definition.__name__

वर्ग, फ़ंक्शन, विधि, विवरणक या जनरेटर उदाहरण का नाम।

definition.__qualname__

वर्ग, कार्य, विधि, विवरणक या जनरेटर उदाहरण का योग्य नाम

संस्करण 3.3 में नया।

class.__mro__

यह विशेषता वर्गों का एक टपल है जो विधि संकल्प के दौरान बेस कक्षाओं की तलाश में माना जाता है।

class.mro()

इस विधि को अपने उदाहरणों के लिए विधि रिज़ॉल्यूशन ऑर्डर को अनुकूलित करने के लिए मेटाक्लस द्वारा ओवरराइड किया जा सकता है। इसे क्लास इंस्टेंटेशन पर बुलाया जाता है, और इसके परिणाम को इसमें संग्रहीत किया जाता है __mro__

class.__subclasses__()

प्रत्येक वर्ग अपने तात्कालिक उपवर्गों के कमजोर संदर्भों की एक सूची रखता है। यह विधि उन सभी संदर्भों की एक सूची देता है जो अभी भी जीवित हैं। उदाहरण:

>>> int.__subclasses__()
[<class 'bool'>]

फुटनोट

[1] इन विशेष तरीकों के बारे में अतिरिक्त जानकारी पायथन रेफरेंस मैनुअल ( मूल अनुकूलन ) में पाई जा सकती है ।
[2] परिणामस्वरूप, सूची [1, 2] को समान माना जाता है [1.0, 2.0] , और इसी तरह टुपल्स के लिए।
[3] उनके पास होना चाहिए क्योंकि पार्सर ऑपरेंड के प्रकार को नहीं बता सकता है।
[4] ( 1 , 2 , 3 , 4 ) कैसड कैरेक्टर वे होते हैं जिनमें सामान्य श्रेणी की संपत्ति "लू" (लेटर, अपरकेस), "एलएल" (लेटर, लोअरकेस), या "लेफ्ट" (लेटर, शीर्षक) में से एक होती है।
[5] ( 1 , 2 ) केवल एक टुपल को प्रारूपित करने के लिए आपको इसलिए एक सिंगलटन टपल प्रदान करना चाहिए जिसका एकमात्र तत्व ट्यूपल को स्वरूपित किया जाना है।

Original text