Python 3.7 - Functions

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




python

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

पायथन दुभाषिया में कई प्रकार के कार्य और प्रकार निर्मित होते हैं जो हमेशा उपलब्ध रहते हैं। वे यहाँ वर्णमाला क्रम में सूचीबद्ध हैं।

अंतर्निहित कार्य
abs() delattr() hash() memoryview() set()
all() dict() help() min() setattr()
any() dir() hex() next() slice()
ascii() divmod() id() object() sorted()
bin() enumerate() input() oct() staticmethod()
bool() eval() int() open() str()
breakpoint() exec() isinstance() ord() sum()
bytearray() filter() issubclass() pow() super()
bytes() float() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
abs(x)

किसी संख्या का पूर्ण मान लौटाएं। तर्क पूर्णांक या फ्लोटिंग पॉइंट नंबर हो सकता है। यदि तर्क एक जटिल संख्या है, तो इसकी परिमाण वापस आ जाती है।

all(iterable)

True लौटें यदि चलने योग्य के सभी तत्व सही हैं (या यदि चलने योग्य खाली है)। के बराबर:

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
any(iterable)

रिटर्न इट्रेबल का कोई भी एलिमेंट अगर सही है। यदि चलने योग्य खाली है, तो False लौटें। के बराबर:

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
ascii(object)

repr() , किसी ऑब्जेक्ट के प्रिंट करने योग्य प्रतिनिधित्व वाले स्ट्रिंग को वापस लौटाएं, लेकिन repr() द्वारा लौटे स्ट्रिंग में गैर-ASCII वर्णों repr() का उपयोग करके \x , \u या \U एस्केप से बच जाएं। यह पायथन 2 में repr() द्वारा लौटाए गए समान स्ट्रिंग उत्पन्न करता है।

bin(x)

एक पूर्णांक संख्या को "0b" के साथ पहले से बाइनरी स्ट्रिंग में परिवर्तित करें। परिणाम एक मान्य पायथन अभिव्यक्ति है। यदि x एक पायथन int() ऑब्जेक्ट नहीं है, तो उसे एक __index__() विधि को परिभाषित करना __index__() जो पूर्णांक लौटाता है। कुछ उदाहरण:

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

यदि उपसर्ग "0 बी" वांछित है या नहीं, तो आप निम्नलिखित में से किसी भी तरीके का उपयोग कर सकते हैं।

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

अधिक जानकारी के लिए format() भी देखें।

class bool([x])

एक बूलियन मान लौटाएं, जो कि True या False x को मानक सत्य परीक्षण प्रक्रिया का उपयोग करके परिवर्तित किया जाता है। यदि x गलत है या छोड़ा गया है, तो यह False ; अन्यथा यह Truebool() क्लास int() का एक उपवर्ग है ( न्यूमेरिक प्रकार देखें - इंट, फ्लोट, कॉम्प्लेक्स )। इसे आगे नहीं किया जा सकता है। इसके एकमात्र उदाहरण False और True ( बूलियन मान देखें)।

संस्करण 3.7 में परिवर्तित: x अब एक केवल स्थितीय पैरामीटर है।

breakpoint(*args, **kws)

यह फ़ंक्शन आपको कॉल साइट पर डीबगर में ले जाता है। विशेष रूप से, यह sys.breakpointhook() कॉल sys.breakpointhook() , जो सीधे गुजरता है और सीधे गुजरता है। डिफ़ॉल्ट रूप से, sys.breakpointhook() कॉल pdb.set_trace() कोई तर्क की अपेक्षा करता है। इस स्थिति में, यह विशुद्ध रूप से एक सुविधा कार्य है, इसलिए आपको डिबगर में प्रवेश करने के लिए स्पष्ट रूप से pdb या अधिक कोड टाइप करने की आवश्यकता नहीं है। हालाँकि, sys.breakpointhook() को किसी अन्य फ़ंक्शन पर सेट किया जा सकता है और breakpoint() स्वचालित रूप से कॉल करेगा, जिससे आप पसंद के डिबगर में ड्रॉप कर सकते हैं।

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

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

बाइट्स की एक नई सरणी लौटें। bytearray class 0 <= x <256 श्रेणी में पूर्णांकों का एक उत्परिवर्तनीय अनुक्रम है। इसमें उत्परिवर्तनीय अनुक्रमों के अधिकांश सामान्य तरीके हैं, जिन्हें Mutable Sequence Types में वर्णित किया गया है, साथ ही अधिकांश विधियाँ जो bytes प्रकार की हैं, देखें बाइट्स और बायट्रे ऑपरेशन

वैकल्पिक स्रोत पैरामीटर का उपयोग कुछ भिन्न तरीकों से सरणी को इनिशियलाइज़ करने के लिए किया जा सकता है:

  • यदि यह एक स्ट्रिंग है , तो आपको एन्कोडिंग (और वैकल्पिक रूप से, त्रुटियां ) पैरामीटर भी देना होगा; bytearray तब string को बाइट्स में कनवर्ट करके str.encode() का उपयोग str.encode()
  • यदि यह एक पूर्णांक है , तो सरणी में वह आकार होगा और नल बाइट्स के साथ आरंभीकृत किया जाएगा।
  • यदि यह बफ़र इंटरफ़ेस के अनुरूप एक ऑब्जेक्ट है, तो बाइट्स सरणी को आरंभीकृत करने के लिए ऑब्जेक्ट का केवल-पढ़ने वाला बफ़र उपयोग किया जाएगा।
  • यदि यह एक चलने योग्य है , तो यह 0 <= x < 256 की श्रेणी में पूर्णांकों का पुनरावृत्त होना चाहिए, जिसका उपयोग सरणी की प्रारंभिक सामग्री के रूप में किया जाता है।

एक तर्क के बिना, आकार 0 का एक सरणी बनाया जाता है।

बाइनरी अनुक्रम प्रकारों को भी देखें - बाइट्स, बायटियर, मेमोरीव्यू और बायटायर्रे ऑब्जेक्ट्स

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

एक नया "बाइट्स" ऑब्जेक्ट लौटाएं, जो 0 <= x < 256 सीमा में पूर्णांकों का एक अपरिवर्तनीय अनुक्रम है। bytes का एक अपरिवर्तनीय संस्करण है - इसमें समान गैर-उत्परिवर्तन विधियां और समान अनुक्रमण और स्लाइसिंग व्यवहार हैं।

तदनुसार, कंस्ट्रक्टर तर्कों की व्याख्या bytearray

बाइट ऑब्जेक्ट्स को शाब्दिक के साथ भी बनाया जा सकता है, स्ट्रिंग और बाइट्स शाब्दिक देखें

बाइनरी अनुक्रम प्रकार भी देखें - बाइट्स, बायटियर , मेमोरीव्यू , बाइट्स ऑब्जेक्ट्स , और बाइट्स और बायट्रे ऑपरेशन

callable(object)

यदि ऑब्जेक्ट तर्क कॉल करने योग्य दिखाई देता है तो True लौटें, यदि नहीं तो False । यदि यह सही है, तो यह अभी भी संभव है कि कॉल विफल हो, लेकिन यदि यह गलत है, तो कॉलिंग ऑब्जेक्ट कभी भी सफल नहीं होगा। ध्यान दें कि कक्षाएं कॉल करने योग्य हैं (कॉलिंग एक नया उदाहरण देता है); उदाहरण कॉल करने योग्य हैं यदि उनकी कक्षा में __call__() विधि है।

संस्करण 3.2 में नया: इस फ़ंक्शन को पहले पायथन 3.0 में हटा दिया गया था और फिर पायथन 3.2 में वापस लाया गया था।

chr(i)

एक चरित्र का प्रतिनिधित्व करने वाले स्ट्रिंग को लौटाएं जिसका यूनिकोड कोड बिंदु पूर्णांक i है । उदाहरण के लिए, chr(97) स्ट्रिंग 'a' लौटाता है, जबकि chr(8364) स्ट्रिंग '€' लौटाता है। यह ord() का विलोम है।

तर्क के लिए मान्य सीमा 1,114,111 के माध्यम से 0 (आधार 16 में 0x10FFFF) से है। यदि मैं उस सीमा से बाहर हूं तो ValueError को उठाया जाएगा।

@classmethod

किसी विधि को वर्ग विधि में बदलना।

एक वर्ग विधि कक्षा को पहले तर्क के रूप में प्राप्त करती है, ठीक उसी तरह जैसे कि एक इंस्टेंस विधि उदाहरण प्राप्त करती है। एक वर्ग विधि घोषित करने के लिए, इस मुहावरे का उपयोग करें:

class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...

@classmethod फ़ॉर्म एक फ़ंक्शन decorator - विवरण के लिए फ़ंक्शन परिभाषाओं में फ़ंक्शन परिभाषा का विवरण देखें।

इसे या तो कक्षा पर (जैसे कि Cf() ) या उदाहरण पर (जैसे C().f() ) कहा जा सकता है। इसके वर्ग को छोड़कर उदाहरण को नजरअंदाज किया जाता है। यदि किसी वर्ग विधि को एक व्युत्पन्न वर्ग के लिए कहा जाता है, तो व्युत्पन्न वर्ग वस्तु को पहले तर्क के रूप में पारित किया जाता है।

वर्ग विधियाँ C ++ या Java स्थैतिक विधियों से भिन्न हैं। यदि आप चाहते हैं, तो इस अनुभाग में staticmethod() देखें।

कक्षा के तरीकों के बारे में अधिक जानकारी के लिए, मानक प्रकार पदानुक्रम में मानक प्रकार पदानुक्रम पर प्रलेखन से परामर्श करें।

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

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

फ़ाइल नाम तर्क को वह फ़ाइल देना चाहिए जिसमें से कोड पढ़ा गया था; कुछ पहचानने योग्य मान को पास करें यदि यह फ़ाइल से नहीं पढ़ा गया ( '<string>' आमतौर पर उपयोग किया जाता है)।

मोड तर्क निर्दिष्ट करता है कि किस प्रकार का कोड संकलित किया जाना चाहिए; यदि स्रोत में कथनों का एक क्रम होता है, तो 'eval' किया जा सकता है, यदि यह एक एकल अभिव्यक्ति के होते हैं, या 'single' यदि इसमें एक एकल संवादात्मक कथन (बाद वाले मामले में, अभिव्यक्ति कथन जो किसी चीज़ का मूल्यांकन करते हैं अन्य के अलावा None भी मुद्रित None जाएगा)।

वैकल्पिक तर्क झंडे और NOT_inherit नियंत्रण जो भविष्य के बयान स्रोत के संकलन को प्रभावित करते हैं। यदि न तो मौजूद है (या दोनों शून्य हैं) कोड भविष्य के उन बयानों के साथ संकलित किया जाता है जो उस कोड में प्रभावी होते हैं जो compile() कह रहे हैं compile() । यदि झंडे का तर्क दिया जाता है और NOT_inherit नहीं है (या शून्य है) तो झंडे के तर्क द्वारा निर्दिष्ट भविष्य के बयानों का उपयोग उन लोगों के अलावा किया जाता है जो वैसे भी उपयोग किए जाएंगे। यदि NOT_inherit एक गैर-शून्य पूर्णांक है तो झंडे का तर्क यह है - संकलन करने के लिए कॉल के आसपास के भविष्य के बयानों को अनदेखा किया जाता है।

भविष्य के बयान बिट्स द्वारा निर्दिष्ट किए जाते हैं जो कई बयानों को निर्दिष्ट करने के लिए एक साथ बिटवाइड किया जा सकता है। किसी दिए गए फ़ीचर को निर्दिष्ट करने के लिए आवश्यक _Feature को __future__ मॉड्यूल में _Feature उदाहरण पर compiler_flag विशेषता के रूप में पाया जा सकता है।

तर्क अनुकूलन कंपाइलर के अनुकूलन स्तर को निर्दिष्ट करता है; -1 का डिफ़ॉल्ट मान इंटरप्रेटर के ऑप्टिमाइज़ेशन स्तर का चयन करता है जैसा कि -O विकल्प द्वारा दिया गया है। स्पष्ट स्तर 0 (कोई अनुकूलन नहीं; __debug__ सत्य है), 1 ( __debug__ हटाए जाते हैं, __debug__ झूठा है) या 2 (docstrings भी हटा दिए गए हैं)।

यदि संकलित स्रोत अमान्य है, और ValueError यदि स्रोत नल बाइट्स है, तो यह फ़ंक्शन SyntaxError उठाता है।

यदि आप Python कोड को अपने AST प्रतिनिधित्व में पार्स करना चाहते हैं, तो ast.parse()

ध्यान दें

'single' या 'eval' मोड में मल्टी-लाइन कोड के साथ एक स्ट्रिंग को संकलित करते समय, इनपुट को कम से कम एक पंक्ति वर्ण द्वारा समाप्त किया जाना चाहिए। यह code मॉड्यूल में अपूर्ण और पूर्ण विवरणों का पता लगाने की सुविधा है।

चेतावनी

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

वर्जन 3.2 में बदला: विंडोज और मैक के नए उपयोग की अनुमति। इसके अलावा 'exec' मोड में इनपुट को अब एक नई लाइन में समाप्त नहीं होना है। ऑप्टिमाइज़ पैरामीटर जोड़ा गया।

संस्करण 3.5 में बदला: पहले, TypeError को तब उठाया गया था जब स्रोत में अशक्त बाइट्स का सामना किया गया था।

class complex([real[, imag]])

मूल्य वास्तविक + कल्पना * 1j के साथ एक जटिल संख्या लौटाएं या एक स्ट्रिंग या संख्या को एक जटिल संख्या में परिवर्तित करें। यदि पहला पैरामीटर एक स्ट्रिंग है, तो इसे एक जटिल संख्या के रूप में व्याख्या किया जाएगा और फ़ंक्शन को दूसरे पैरामीटर के बिना बुलाया जाना चाहिए। दूसरा पैरामीटर कभी भी एक स्ट्रिंग नहीं हो सकता है। प्रत्येक तर्क किसी भी संख्यात्मक प्रकार (जटिल सहित) हो सकता है। यदि कल्पना को छोड़ दिया जाता है, तो यह शून्य में चूक जाता है और निर्माणकर्ता int() और float() जैसे संख्यात्मक रूपांतरण के रूप में कार्य करता है। यदि दोनों तर्क छोड़ दिए जाते हैं, तो 0j लौटाता है।

ध्यान दें

स्ट्रिंग से परिवर्तित करते समय, स्ट्रिंग में केंद्रीय + या - ऑपरेटर के आसपास व्हाट्सएप नहीं होना चाहिए। उदाहरण के लिए, complex('1+2j') ठीक है, लेकिन complex('1 + 2j') ValueError बढ़ाता है।

जटिल प्रकार को न्यूमेरिक प्रकारों में वर्णित किया गया है - इंट, फ्लोट, जटिल

संस्करण 3.6 में बदल गया: कोड शाब्दिक में अंडरस्कोर के साथ अंकों को समूहीकृत करना अनुमत है।

delattr(object, name)

यह setattr() का एक रिश्तेदार है। तर्क एक वस्तु और एक स्ट्रिंग हैं। स्ट्रिंग को ऑब्जेक्ट की विशेषताओं में से एक का नाम होना चाहिए। फ़ंक्शन नामित विशेषता को हटाता है, बशर्ते ऑब्जेक्ट इसे अनुमति देता है। उदाहरण के लिए, delattr(x, 'foobar') del x.foobar बराबर है।

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

एक नया शब्दकोश बनाएँ। डिक्शनरी ऑब्जेक्ट डिक्शनरी क्लास है। dict और मानचित्रण प्रकार देखें - इस वर्ग के बारे में प्रलेखन के लिए तानाशाह

अन्य कंटेनरों के लिए अंतर्निहित list , set और tuple कक्षाएं, साथ ही collections मॉड्यूल देखें।

dir([object])

तर्कों के बिना, वर्तमान स्थानीय दायरे में नामों की सूची लौटाएं। एक तर्क के साथ, उस वस्तु के लिए मान्य विशेषताओं की एक सूची वापस करने का प्रयास करें।

यदि ऑब्जेक्ट में __dir__() नाम की एक विधि है, तो इस विधि को कॉल किया जाएगा और उसे विशेषताओं की सूची को वापस करना होगा। यह उन वस्तुओं को अनुमति देता है जो एक कस्टम __getattr__() या __getattribute__() फ़ंक्शन को लागू करने की अनुमति देते हैं जिस तरह से dir() उनकी विशेषताओं को रिपोर्ट करता है।

यदि ऑब्जेक्ट __dir__() प्रदान नहीं करता है, तो फ़ंक्शन ऑब्जेक्ट के __dict__ विशेषता से, यदि परिभाषित किया गया है, और इसके प्रकार ऑब्जेक्ट से जानकारी इकट्ठा करने की पूरी कोशिश करता है। परिणामी सूची आवश्यक रूप से पूरी नहीं होती है, और जब वस्तु में कस्टम __getattr__() होता है, तो यह गलत हो सकता है।

डिफ़ॉल्ट dir() तंत्र विभिन्न प्रकार की वस्तुओं के साथ अलग-अलग व्यवहार करता है, क्योंकि यह पूरी जानकारी के बजाय सबसे अधिक प्रासंगिक उत्पादन का प्रयास करता है:

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

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

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

ध्यान दें

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

divmod(a, b)

दो (गैर जटिल) संख्याओं को तर्क के रूप में लें और पूर्णांक विभाजन का उपयोग करते समय उनकी भागफल और शेष संख्याओं की एक जोड़ी लौटाएं। मिश्रित ऑपरेंड प्रकारों के साथ, बाइनरी अंकगणितीय ऑपरेटरों के लिए नियम लागू होते हैं। पूर्णांकों के लिए, परिणाम (a // b, a % b) । फ्लोटिंग पॉइंट नंबरों के लिए परिणाम (q, a % b) , जहाँ q आमतौर पर math.floor(a / b) लेकिन उससे 1 कम हो सकता है। किसी भी मामले में q * b + a % b बहुत करीब है , यदि a % b गैर-शून्य है तो b के समान चिन्ह है, और 0 <= abs(a % b) < abs(b)

enumerate(iterable, start=0)

एक enumerate ऑब्जेक्ट लौटें। iterable एक अनुक्रम, एक पुनरावृत्त, या कुछ अन्य ऑब्जेक्ट होना चाहिए जो पुनरावृत्ति का समर्थन करता है। __next__() द्वारा लौटाई गई विधि enumerate() एक टपल लौटाती है जिसमें एक गणना होती है ( प्रारंभ से जिसमें चूक होती है) और पुनरावृति से प्राप्त मानों से प्राप्त मान।

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

के बराबर:

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1
eval(expression, globals=None, locals=None)

तर्क एक स्ट्रिंग और वैकल्पिक ग्लोबल्स और स्थानीय हैं। यदि प्रदान किया गया है, तो ग्लोबल्स एक शब्दकोश होना चाहिए। यदि प्रदान किया जाता है, तो स्थानीय लोग किसी भी मैपिंग ऑब्जेक्ट हो सकते हैं।

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

>>> x = 1
>>> eval('x+1')
2

इस फ़ंक्शन का उपयोग मनमाने कोड ऑब्जेक्ट्स (जैसे कि compile() द्वारा बनाए गए compile() को निष्पादित करने के लिए भी किया जा सकता है। इस स्थिति में एक स्ट्रिंग के बजाय एक कोड ऑब्जेक्ट पास करें। यदि कोड ऑब्जेक्ट को मोड तर्क के रूप में 'exec' साथ संकलित किया गया है, तो eval() का रिटर्न वैल्यू None होगा।

संकेत: बयानों के गतिशील निष्पादन को निष्पादन exec() फ़ंक्शन द्वारा समर्थित किया जाता है। globals() और locals() फ़ंक्शन क्रमशः वर्तमान वैश्विक और स्थानीय शब्दकोश लौटाते हैं, जो कि eval() या exec() द्वारा उपयोग के लिए पास होने के लिए उपयोगी हो सकता है।

ast.literal_eval() एक फ़ंक्शन के लिए देखें जो केवल शाब्दिक रूप से अभिव्यक्तियों के साथ तार का मूल्यांकन कर सकता है।

exec(object[, globals[, locals]])

यह फ़ंक्शन पायथन कोड के गतिशील निष्पादन का समर्थन करता है। ऑब्जेक्ट या तो एक स्ट्रिंग या कोड ऑब्जेक्ट होना चाहिए। यदि यह एक स्ट्रिंग है, तो स्ट्रिंग को पायथन के बयानों के एक सूट के रूप में पार्स किया जाता है जिसे तब निष्पादित किया जाता है (जब तक कि एक सिंटैक्स त्रुटि नहीं होती है)। [1] यदि यह एक कोड ऑब्जेक्ट है, तो इसे बस निष्पादित किया जाता है। सभी मामलों में, निष्पादित कोड को फ़ाइल इनपुट के रूप में मान्य होने की उम्मीद है (संदर्भ मैनुअल में "फ़ाइल इनपुट" अनुभाग देखें)। विदित हो कि return और yield स्टेटमेंट फंक्शन डेफिनिशन के बाहर भी इस्तेमाल नहीं किए जा सकते हैं, भले ही कोड के exec() लिए पास किया गया हो। वापसी मूल्य None

सभी मामलों में, यदि वैकल्पिक भागों को छोड़ दिया जाता है, तो कोड को वर्तमान दायरे में निष्पादित किया जाता है। यदि केवल ग्लोबल्स प्रदान किए जाते हैं, तो यह एक शब्दकोष होना चाहिए, जिसका उपयोग वैश्विक और स्थानीय चर दोनों के लिए किया जाएगा। यदि ग्लोबल्स और लोकल दिए जाते हैं, तो वे क्रमशः वैश्विक और स्थानीय चर के लिए उपयोग किए जाते हैं। यदि प्रदान किया जाता है, तो स्थानीय लोग किसी भी मैपिंग ऑब्जेक्ट हो सकते हैं। याद रखें कि मॉड्यूल स्तर पर, ग्लोबल्स और लोकल एक ही शब्दकोश हैं। यदि निष्पादन को ग्लोबल्स और स्थानीय के रूप में दो अलग-अलग ऑब्जेक्ट मिलते हैं, तो कोड को निष्पादित किया जाएगा जैसे कि इसे एक वर्ग परिभाषा में एम्बेड किया गया था।

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

ध्यान दें

बिल्ट-इन फ़ंक्शन globals() और locals() वर्तमान वैश्विक और स्थानीय शब्दकोश को क्रमशः वापस करते हैं, जो exec() लिए दूसरे और तीसरे तर्क के रूप में उपयोग करने के लिए चारों ओर से गुजरना उपयोगी हो सकता है।

ध्यान दें

डिफ़ॉल्ट स्थानीय लोगों को नीचे दिए गए फ़ंक्शन locals() लिए वर्णित किया गया है: डिफ़ॉल्ट स्थानीय शब्दकोश में संशोधन का प्रयास नहीं किया जाना चाहिए। फ़ंक्शन exec() रिटर्न के बाद स्थानीय लोगों पर कोड के प्रभाव को देखने की आवश्यकता होने पर एक स्पष्ट स्थानीय शब्दकोश पास करें।

filter(function, iterable)

पुनरावृत्ति के उन तत्वों से एक पुनरावृत्ति का निर्माण जिसके लिए फ़ंक्शन सही है। iterable या तो एक अनुक्रम हो सकता है, एक कंटेनर जो पुनरावृत्ति का समर्थन करता है, या एक पुनरावृत्त। यदि फ़ंक्शन None , तो पहचान फ़ंक्शन को मान लिया जाता है, अर्थात, चलने योग्य सभी तत्व जो झूठे हैं हटा दिए जाते हैं।

ध्यान दें कि filter(function, iterable) जनरेटर अभिव्यक्ति के बराबर है (item for item in iterable if function(item)) यदि फ़ंक्शन कोई None और (item for item in iterable if item) यदि फ़ंक्शन None

पूरक समारोह के लिए itertools.filterfalse() देखें जो कि पुनरावृत्त के तत्वों को लौटाता है जिसके लिए फ़ंक्शन गलत है।

class float([x])

किसी संख्या या स्ट्रिंग x से निर्मित फ्लोटिंग पॉइंट संख्या लौटाएँ।

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

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

यहाँ floatnumber एक फ्लोटिंग पॉइंट शाब्दिक में वर्णित पायथन फ्लोटिंग-पॉइंट शाब्दिक का रूप है । मामला महत्वपूर्ण नहीं है, इसलिए, उदाहरण के लिए, "inf", "Inf", "INFINITY" और "iNfINity" सकारात्मक अनंत के लिए सभी स्वीकार्य वर्तनी हैं।

अन्यथा, यदि तर्क एक पूर्णांक या एक फ्लोटिंग पॉइंट नंबर है, तो एक ही मान के साथ एक फ्लोटिंग पॉइंट नंबर (पायथन के फ़्लोटिंग पॉइंट सटीक के भीतर) वापस आ जाता है। यदि तर्क पायथन फ्लोट की सीमा के बाहर है, तो एक OverflowError उठाया जाएगा।

एक सामान्य पायथन ऑब्जेक्ट x , float(x) प्रतिनिधि को x.__float__()

यदि कोई तर्क नहीं दिया जाता है, तो 0.0 लौटा दिया जाता है।

उदाहरण:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

फ्लोट प्रकार को न्यूमेरिक प्रकारों में वर्णित किया जाता है - इंट, फ्लोट, कॉम्प्लेक्स

संस्करण 3.6 में बदल गया: कोड शाब्दिक में अंडरस्कोर के साथ अंकों को समूहीकृत करना अनुमत है।

संस्करण 3.7 में परिवर्तित: x अब एक केवल स्थितीय पैरामीटर है।

format(value[, format_spec])

एक मान को "स्वरूपित" प्रतिनिधित्व में रूपांतरित करें, जैसा कि format_spec द्वारा नियंत्रित है। Format_spec की व्याख्या मूल्य तर्क के प्रकार पर निर्भर करेगी, हालांकि एक मानक स्वरूपण सिंटैक्स है जो अधिकांश अंतर्निहित प्रकारों द्वारा उपयोग किया जाता है: प्रारूप विशिष्टता मिनी-भाषा

डिफ़ॉल्ट format_spec एक खाली स्ट्रिंग है जो आमतौर पर str(value) रूप में एक ही प्रभाव देता है।

format(value, format_spec) लिए एक कॉल का type(value).__format__(value, format_spec) लिए अनुवाद किया जाता है type(value).__format__(value, format_spec) जो मान के __format__() विधि की खोज करते समय उदाहरण शब्दकोश को बायपास करता है। यदि TypeError सर्च object() तक पहुँच जाता object() और एक प्रकार का अपवाद अपवाद उठाया जाता है, तो format_spec गैर-रिक्त है, या यदि format_spec या रिटर्न मान स्ट्रिंग नहीं है।

संस्करण 3.4 में परिवर्तित: object().__format__(format_spec) यदि कोई object().__format__(format_spec) नहीं है तो TypeError उठाता है।

class frozenset([iterable])

वैकल्पिक रूप से frozenset से लिए गए तत्वों के साथ, एक नई frozenset वस्तु frozenset frozenset एक निर्मित वर्ग है। frozenset और सेट प्रकार देखें - इस वर्ग के बारे में प्रलेखन के लिए सेट, फ्रोज़ेनसेट

अन्य कंटेनरों के लिए अंतर्निहित set , list , tuple और dict कक्षाएं, साथ ही साथ collections मॉड्यूल देखें।

getattr(object, name[, default])

ऑब्जेक्ट की नामित विशेषता का मान लौटाएं। नाम एक तार होना चाहिए। यदि स्ट्रिंग ऑब्जेक्ट की विशेषताओं में से एक का नाम है, तो परिणाम उस विशेषता का मूल्य है। उदाहरण के लिए, getattr(x, 'foobar') x.foobar बराबर है। यदि नामित विशेषता मौजूद नहीं है, तो यदि प्रदान किया गया है, तो डिफ़ॉल्ट लौटा दिया जाता है, अन्यथा AttributeError को उठाया जाता है।

globals()

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

hasattr(object, name)

तर्क एक वस्तु और एक स्ट्रिंग हैं। परिणाम True यदि स्ट्रिंग ऑब्जेक्ट की विशेषताओं में से एक का नाम है, तो False यदि नहीं। (यह getattr(object, name) को कॉल getattr(object, name) और यह देखते हुए लागू किया जाता है कि क्या यह एक AttributeError या कोई उठाता है या नहीं।)

hash(object)

ऑब्जेक्ट का हैश मान लौटें (यदि यह एक है)। हैश मान पूर्णांक हैं। शब्दकोश लुकअप के दौरान शब्दकोश कुंजियों की तुलना जल्दी करने के लिए इनका उपयोग किया जाता है। संख्यात्मक मान जो समान की तुलना करते हैं, उनका समान हैश मान होता है (भले ही वे विभिन्न प्रकार के हों, जैसा कि 1 और 1.0 के लिए मामला है)।

ध्यान दें

कस्टम __hash__() विधियों वाले ऑब्जेक्ट के लिए, ध्यान दें कि hash() होस्ट मशीन की बिट चौड़ाई के आधार पर रिटर्न वैल्यू को छोटा करता है। विवरण के लिए __hash__() देखें।

help([object])

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

यह फ़ंक्शन site मॉड्यूल द्वारा अंतर्निहित नामस्थान में जोड़ा गया है।

संस्करण pydoc में परिवर्तित: pydoc परिवर्तन और inspect मतलब है कि pydoc लिए सूचित हस्ताक्षर अब अधिक व्यापक और सुसंगत हैं।

hex(x)

एक पूर्णांक संख्या को "0x" के साथ उपसर्ग के निचले हेक्साडेसिमल स्ट्रिंग में बदलें। यदि x एक पायथन int() ऑब्जेक्ट नहीं है, तो उसे एक __index__() विधि को परिभाषित करना __index__() जो पूर्णांक लौटाता है। कुछ उदाहरण:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'

यदि आप एक पूर्णांक संख्या को अपरकेस या निचले हेक्साडेसिमल स्ट्रिंग के साथ उपसर्ग के साथ परिवर्तित करना चाहते हैं या नहीं, तो आप निम्न में से किसी भी तरीके का उपयोग कर सकते हैं:

>>> '%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
>>> format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
>>> f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')

अधिक जानकारी के लिए format() भी देखें।

16 के आधार का उपयोग करके एक हेक्साडेसिमल स्ट्रिंग को पूर्णांक में बदलने के लिए int() भी देखें।

ध्यान दें

एक फ्लोट के लिए हेक्साडेसिमल स्ट्रिंग प्रतिनिधित्व प्राप्त करने के लिए, float.hex() विधि का उपयोग करें।

id(object)

किसी वस्तु की "पहचान" लौटाएं। यह एक पूर्णांक है जो अपने जीवनकाल के दौरान इस वस्तु के लिए अद्वितीय और निरंतर होने की गारंटी है। गैर-अतिव्यापी जीवनकाल वाली दो वस्तुओं में एक ही id() मूल्य हो सकता है।

CPython कार्यान्वयन विवरण: यह मेमोरी में ऑब्जेक्ट का पता है।

input([prompt])

यदि त्वरित तर्क मौजूद है, तो यह एक नई सीमा के बिना मानक आउटपुट के लिए लिखा जाता है। फ़ंक्शन तब इनपुट से एक पंक्ति पढ़ता है, इसे एक स्ट्रिंग में परिवर्तित करता है (एक अनुगामी न्यूलाइन को छीनते हुए), और वह लौटाता है। जब EOF को पढ़ा जाता है, तो EOFError को उठाया जाता है। उदाहरण:

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

यदि readline मॉड्यूल लोड किया गया था, तो input() इसका उपयोग विस्तृत रेखा संपादन और इतिहास की सुविधा प्रदान करने के लिए करेगा।

class int([x])
class int(x, base=10)

किसी संख्या या स्ट्रिंग x से निर्मित पूर्णांक ऑब्जेक्ट लौटाएं या यदि कोई तर्क नहीं दिया जाता है, तो 0 लौटाएं। यदि x __int__() को परिभाषित करता है __int__() , int(x) रिटर्न x.__int__() । यदि x __trunc__() को परिभाषित करता है, तो यह x.__trunc__() लौटाता है। फ्लोटिंग पॉइंट नंबरों के लिए, यह शून्य की ओर बढ़ता है।

यदि x कोई संख्या नहीं है या यदि आधार दिया गया है, तो x को एक स्ट्रिंग, bytes या bytearray उदाहरण होना चाहिए जो कि मूलांक आधार में पूर्णांक शाब्दिक का प्रतिनिधित्व करता है । वैकल्पिक रूप से, शाब्दिक + से पहले या - (बीच में कोई जगह नहीं) और व्हाट्सएप से घिरा हो सकता है। एक बेस-एन शाब्दिक में 10 से 35 मान वाले z (या A से Z ) अंकों के साथ 0 से n-1 तक के अंक होते हैं। डिफ़ॉल्ट आधार 10. है। अनुमत मान 0 और 2–36 हैं। बेस -2, -8, और -16 शाब्दिक रूप से कोड में पूर्णांक शाब्दिक के साथ 0b / 0b , 0b / 0O , या 0x / 0b साथ वैकल्पिक रूप से उपसर्ग किया जा सकता है। बेस 0 का मतलब कोड शाब्दिक के रूप में व्याख्या करना है, ताकि वास्तविक आधार 2, 8, 10, या 16 हो, और इसलिए कि int('010', 0) कानूनी नहीं है, जबकि int('010') है, साथ ही int('010', 8)

पूर्णांक प्रकार को संख्यात्मक प्रकारों में वर्णित किया गया है - इंट, फ्लोट, जटिल

संस्करण 3.4 में बदला गया: यदि आधार int() उदाहरण नहीं है और आधार वस्तु का __index__() विधि है, तो उस पद्धति को आधार के लिए पूर्णांक प्राप्त करने के लिए कहा जाता है। पिछले संस्करणों ने __int__() बजाय __index__()

संस्करण 3.6 में बदल गया: कोड शाब्दिक में अंडरस्कोर के साथ अंकों को समूहीकृत करना अनुमत है।

संस्करण 3.7 में परिवर्तित: x अब एक केवल स्थितीय पैरामीटर है।

isinstance(object, classinfo)

यदि ऑब्जेक्ट तर्क classinfo तर्क का एक उदाहरण है, या उसके (प्रत्यक्ष, अप्रत्यक्ष या virtual ) उप-वर्ग का उदाहरण है तो सही लौटें। यदि ऑब्जेक्ट दिए गए प्रकार का ऑब्जेक्ट नहीं है, तो फ़ंक्शन हमेशा गलत होता है। यदि classinfo टाइप ऑब्जेक्ट्स (या पुनरावर्ती, अन्य ऐसे tuples) का एक टपल है, तो ऑब्जेक्ट के किसी भी प्रकार का एक उदाहरण होने पर वापस लौटें। यदि classinfo एक प्रकार या इस तरह के tuple के tuple नहीं है, तो TypeError अपवाद उठाया जाता है।

issubclass(class, classinfo)

अगर क्लासीनोफ़ का एक उपवर्ग (प्रत्यक्ष, अप्रत्यक्ष या virtual ) है तो सही लौटें। एक वर्ग को स्वयं का उपवर्ग माना जाता है। classinfo वर्ग वस्तुओं का एक प्रकार हो सकता है, जिस स्थिति में classinfo में हर प्रविष्टि की जाँच की जाएगी। किसी अन्य मामले में, TypeError अपवाद उठाया जाता है।

iter(object[, sentinel])

एक iterator वस्तु लौटें। पहले तर्क की व्याख्या दूसरे तर्क की उपस्थिति के आधार पर बहुत अलग तरीके से की जाती है। दूसरे तर्क के बिना, ऑब्जेक्ट एक संग्रह ऑब्जेक्ट होना चाहिए जो पुनरावृत्ति प्रोटोकॉल ( __iter__() विधि) का समर्थन करता है, या इसे अनुक्रम प्रोटोकॉल ( __getitem__() 0 पर शुरू होने वाले पूर्णांक तर्क के साथ विधि __getitem__() समर्थन करना चाहिए। यदि यह उन प्रोटोकॉल का समर्थन नहीं करता है, तो TypeError को उठाया जाता है। यदि दूसरा तर्क, प्रहरी , दिया जाता है, तो ऑब्जेक्ट को कॉल करने योग्य ऑब्जेक्ट होना चाहिए। इस मामले में बनाया गया __next__() प्रत्येक कॉल के लिए उसके __next__() विधि के लिए कोई तर्क के साथ ऑब्जेक्ट को कॉल करेगा; यदि लौटाया गया मूल्य प्रहरी के बराबर है, तो StopIteration उठाया जाएगा, अन्यथा मान वापस कर दिया जाएगा।

Iterator प्रकार भी देखें।

iter() के दूसरे रूप का एक उपयोगी अनुप्रयोग iter() एक निश्चित रेखा तक पहुंचने तक फ़ाइल की पंक्तियों को पढ़ना है। निम्नलिखित उदाहरण फ़ाइल को तब तक पढ़ता है जब तक कि readline() विधि एक रिक्त स्ट्रिंग नहीं लौटाती:

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)
len(s)

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

class list([iterable])

एक फ़ंक्शन होने के बजाय, list वास्तव में एक उत्परिवर्तनीय अनुक्रम प्रकार है, जैसा कि Lists और अनुक्रम प्रकारों में Lists - सूची, टपल, रेंज

locals()

वर्तमान स्थानीय प्रतीक तालिका का प्रतिनिधित्व करने वाले शब्दकोश को अपडेट और वापस करें। नि: शुल्क चर locals() द्वारा लौटाए जाते locals() जब इसे फ़ंक्शन ब्लॉकों में कहा जाता है, लेकिन क्लास ब्लॉकों में नहीं।

ध्यान दें

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

map(function, iterable, ...)

पुनरावृत्ति लौटाएँ जो परिणाम के हर आइटम पर फ़ंक्शन को लागू करता है, परिणाम देता है। यदि अतिरिक्त पुनरावृत्त तर्क पारित किए जाते हैं, तो फ़ंक्शन को कई तर्कों को लेना चाहिए और समानांतर में सभी पुनरावृत्तियों से आइटम पर लागू किया जाना चाहिए। कई पुनरावृत्तियों के साथ, इट्रेटर बंद हो जाता है जब सबसे छोटा चलने योग्य समाप्त हो जाता है। ऐसे मामलों के लिए जहां फ़ंक्शन इनपुट पहले से ही तर्क ट्यूपल्स में व्यवस्थित होते हैं, itertools.starmap()

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

एक पुनरावृत्त या दो या अधिक तर्कों में से सबसे बड़ी वस्तु लौटाएं।

यदि एक स्थितीय तर्क प्रदान किया जाता है, तो यह एक iterable होना चाहिए। पुनरावृत्ति में सबसे बड़ी वस्तु वापस आ गई है। यदि दो या अधिक स्थितिगत तर्क प्रदान किए जाते हैं, तो सबसे बड़ी स्थितिगत तर्क वापस आ जाते हैं।

दो वैकल्पिक खोजशब्द-केवल तर्क हैं। मुख्य तर्क सूची के लिए उपयोग किए जाने वाले एक-तर्क आदेश फ़ंक्शन को निर्दिष्ट करता है। डिफ़ॉल्ट तर्क एक ऑब्जेक्ट को निर्दिष्ट करने के लिए लौटाता है यदि प्रदान किए गए चलने योग्य खाली है। यदि चलने योग्य खाली है और डिफ़ॉल्ट प्रदान नहीं किया गया है, तो एक ValueError उठाया जाता है।

यदि कई आइटम अधिकतम हैं, तो फ़ंक्शन पहले वाले का सामना करता है। यह अन्य सॉर्ट-स्टेबिलिटी sorted(iterable, key=keyfunc, reverse=True)[0] टूल्स जैसे sorted(iterable, key=keyfunc, reverse=True)[0] और heapq.nlargest(1, iterable, key=keyfunc)

संस्करण 3.4 में नया: डिफ़ॉल्ट कीवर्ड-केवल तर्क।

memoryview(obj)

दिए गए तर्क से बनाई गई "स्मृति दृश्य" ऑब्जेक्ट लौटें। अधिक जानकारी के लिए मेमोरी व्यू देखें।

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

एक पुनरावृत्त या दो या अधिक तर्कों में सबसे छोटी वस्तु लौटाएं।

यदि एक स्थितीय तर्क प्रदान किया जाता है, तो यह एक iterable होना चाहिए। पुनरावृत्त में सबसे छोटी वस्तु वापस आ गई है। यदि दो या अधिक स्थितिगत तर्क प्रदान किए जाते हैं, तो सबसे छोटी स्थिति के तर्क वापस आ जाते हैं।

दो वैकल्पिक खोजशब्द-केवल तर्क हैं। मुख्य तर्क सूची के लिए उपयोग किए जाने वाले एक-तर्क आदेश फ़ंक्शन को निर्दिष्ट करता है। डिफ़ॉल्ट तर्क एक ऑब्जेक्ट को निर्दिष्ट करने के लिए लौटाता है यदि प्रदान किए गए चलने योग्य खाली है। यदि चलने योग्य खाली है और डिफ़ॉल्ट प्रदान नहीं किया गया है, तो एक ValueError उठाया जाता है।

यदि एकाधिक आइटम न्यूनतम हैं, तो फ़ंक्शन पहले वाले का सामना करता है। यह अन्य सॉर्ट-स्टेबिलिटी sorted(iterable, key=keyfunc)[0] टूल्स जैसे sorted(iterable, key=keyfunc)[0] और heapq.nsmallest(1, iterable, key=keyfunc)

संस्करण 3.4 में नया: डिफ़ॉल्ट कीवर्ड-केवल तर्क।

next(iterator[, default])

अपने __next__() पद्धति को कॉल करके अगले आइटम को __next__() । यदि डिफ़ॉल्ट दिया जाता है, तो StopIteration समाप्त हो जाने पर उसे लौटा दिया जाता है, अन्यथा StopIteration उठाया जाता है।

class object

एक नई सुविधाहीन वस्तु लौटाएं। object() सभी वर्गों के लिए एक आधार है। इसमें वे विधियाँ हैं जो पायथन कक्षाओं के सभी उदाहरणों के लिए सामान्य हैं। यह फ़ंक्शन किसी भी तर्क को स्वीकार नहीं करता है।

ध्यान दें

object() __dict__ नहीं है, इसलिए आप object() क्लास के एक उदाहरण के लिए मनमाने ढंग से विशेषताओं को निर्दिष्ट नहीं कर सकते।

oct(x)

एक पूर्णांक संख्या को "0" के साथ उपसर्गित एक अष्टक स्ट्रिंग में बदलें। परिणाम एक मान्य पायथन अभिव्यक्ति है। यदि x एक पायथन int() ऑब्जेक्ट नहीं है, तो उसे एक __index__() विधि को परिभाषित करना __index__() जो पूर्णांक लौटाता है। उदाहरण के लिए:

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

यदि आप पूर्णांक संख्या को "उप" या नहीं उपसर्ग के साथ ऑक्टेल स्ट्रिंग में परिवर्तित करना चाहते हैं, तो आप निम्न में से किसी भी तरीके का उपयोग कर सकते हैं।

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

format() अधिक जानकारी के लिए भी देखें ।

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

फ़ाइल खोलें और संबंधित फ़ाइल ऑब्जेक्ट वापस करें । यदि फ़ाइल को खोला नहीं जा सकता है, तो एक OSError उठाया जाता है।

फ़ाइल एक पथ जैसी वस्तु है जो फ़ाइल के पाथनाम (वर्तमान या कार्यशील निर्देशिका के पूर्ण या सापेक्ष) को खोला जा सकता है या लिपटे जाने के लिए फ़ाइल का पूर्णांक फ़ाइल विवरणक है। (यदि कोई फ़ाइल डिस्क्रिप्टर दिया जाता है, तो यह बंद हो जाता है जब लौटे I / O ऑब्जेक्ट को बंद कर दिया जाता है, जब तक कि क्लोज़फ़ड सेट नहीं हो जाता False )।

मोड एक वैकल्पिक स्ट्रिंग है जो उस मोड को निर्दिष्ट करता है जिसमें फ़ाइल खोली जाती है। यह 'r' पाठ मोड में पढ़ने के लिए खुला जिसका अर्थ है चूक । अन्य सामान्य मान 'w' लेखन के लिए हैं (यदि यह पहले से मौजूद है तो फ़ाइल को रौंदते हुए), 'x' अनन्य निर्माण के लिए और संलग्न करने के 'a' लिए (जो कुछ यूनिक्स प्रणालियों पर है, इसका मतलब है कि सभी वर्तमान स्थिति की परवाह किए बिना फ़ाइल के अंत में अपील लिखते हैं) पाठ मोड में, यदि एन्कोडिंग निर्दिष्ट नहीं है , तो उपयोग किया गया एन्कोडिंग प्लेटफ़ॉर्म निर्भर है: locale.getpreferredencoding(False) वर्तमान स्थानीय एन्कोडिंग प्राप्त करने के लिए कहा जाता है। (कच्चे बाइट को पढ़ने और लिखने के लिए बाइनरी मोड का उपयोग करें और एन्कोडिंग को अनिर्दिष्ट छोड़ दें ।) उपलब्ध मोड हैं:

चरित्र अर्थ
'r' पढ़ने के लिए खुला (डिफ़ॉल्ट)
'w' लिखने के लिए खुला, पहले फ़ाइल को काट-छाँट कर
'x' अनन्य निर्माण के लिए खुला है, यदि फ़ाइल पहले से मौजूद है, तो विफल
'a' लेखन के लिए खुला है, अगर यह मौजूद है तो फ़ाइल के अंत में संलग्न है
'b' बाइनरी मोड
't' पाठ मोड (डिफ़ॉल्ट)
'+' अद्यतन (पढ़ने और लिखने) के लिए एक डिस्क फ़ाइल खोलें
'U' सार्वभौमिक न्यूलाइन्स मोड (पदावनत)

डिफ़ॉल्ट मोड 'r' (पाठ पढ़ने के लिए खुला है, का पर्यायवाची 'rt' )। बाइनरी रीड-राइट एक्सेस के लिए, मोड 'w+b' फ़ाइल को 0 बाइट्स में खोलता और काटता है। 'r+b' ट्रंकेशन के बिना फ़ाइल खोलता है।

Overview में वर्णित है , पायथन बाइनरी और टेक्स्ट I / O के बीच अंतर करता है। बाइनरी मोड ( मोड तर्क सहित) 'b' में खोली गई फाइलें बिना किसी डिकोडिंग के ऑब्जेक्ट के रूप में सामग्री लौटाती हैं। पाठ मोड में (डिफ़ॉल्ट, या जब मोड तर्क में शामिल किया जाता है ), फ़ाइल की सामग्री को वापस कर दिया जाता है , बाइट्स को पहले प्लेटफ़ॉर्म-निर्भर एन्कोडिंग का उपयोग करके या निर्दिष्ट एन्कोडिंग का उपयोग करके डीकोड किया जाता है। bytes 't' str(value)

ध्यान दें

पायथन अंतर्निहित ऑपरेटिंग सिस्टम की टेक्स्ट फ़ाइलों की धारणा पर निर्भर नहीं करता है; सभी प्रसंस्करण पायथन द्वारा ही किया जाता है, और इसलिए प्लेटफ़ॉर्म-स्वतंत्र है।

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

  • बाइनरी फ़ाइलों को निश्चित-आकार वाले विखंडू में बफर किया जाता है; बफर के आकार को अंतर्निहित डिवाइस के "ब्लॉक आकार" और वापस गिरने पर निर्धारित करने के लिए एक अनुमानी का उपयोग करके चुना जाता है io.DEFAULT_BUFFER_SIZE । कई प्रणालियों पर, बफर आमतौर पर 4096 या 8192 बाइट्स लंबा होगा।
  • "इंटरएक्टिव" टेक्स्ट फाइल (फाइल जिसके लिए isatty() रिटर्न True ) लाइन बफरिंग का उपयोग करते हैं। अन्य पाठ फाइलें बाइनरी फ़ाइलों के लिए ऊपर वर्णित नीति का उपयोग करती हैं।

एन्कोडिंग फ़ाइल को डीकोड या एनकोड करने के लिए उपयोग किए जाने वाले एन्कोडिंग का नाम है। यह केवल पाठ मोड में उपयोग किया जाना चाहिए। डिफ़ॉल्ट एन्कोडिंग प्लेटफ़ॉर्म डिपेंडेंट (जो भी locale.getpreferredencoding() रिटर्न) है, लेकिन पायथन द्वारा समर्थित किसी भी टेक्स्ट एन्कोडिंग का उपयोग किया जा सकता है। codecs समर्थित एन्कोडिंग की सूची के लिए मॉड्यूल देखें ।

त्रुटियाँ एक वैकल्पिक स्ट्रिंग है जो निर्दिष्ट करती है कि एन्कोडिंग और डिकोडिंग त्रुटियों को कैसे संभाला जाना चाहिए - इसका उपयोग बाइनरी मोड में नहीं किया जा सकता है। कई मानक त्रुटि हैंडलर उपलब्ध हैं ( त्रुटि हैंडलर के तहत सूचीबद्ध ), हालांकि किसी भी त्रुटि से निपटने वाला नाम जो पंजीकृत है, codecs.register_error() वह भी मान्य है। मानक नामों में शामिल हैं:

  • 'strict' ValueError यदि कोई एन्कोडिंग त्रुटि है, तो एक अपवाद बढ़ाने के लिए । डिफ़ॉल्ट मान का None समान प्रभाव होता है।
  • 'ignore' त्रुटियों को अनदेखा करता है। ध्यान दें कि एन्कोडिंग त्रुटियों की अनदेखी करने से डेटा हानि हो सकती है।
  • 'replace' '?' जहां कोई विकृत डेटा है, वहां एक प्रतिस्थापन मार्कर (जैसे ) डाला जाता है।
  • 'surrogateescape' यूनिकोड प्राइवेट यूज़ एरिया के कोड पॉइंट के रूप में U + DC80 से U + DCFF तक किसी भी गलत बाइट का प्रतिनिधित्व करेगा। surrogateescape डेटा लिखने के दौरान त्रुटि हैंडलर का उपयोग किए जाने पर ये निजी कोड बिंदु फिर से उसी बाइट में बदल जाएंगे । यह अज्ञात एन्कोडिंग में फ़ाइलों को संसाधित करने के लिए उपयोगी है।
  • 'xmlcharrefreplace' फ़ाइल में लिखते समय केवल समर्थित होता है। एन्कोडिंग द्वारा समर्थित वर्णों को उपयुक्त XML वर्ण संदर्भ के साथ प्रतिस्थापित नहीं किया जाता है &#nnn;
  • 'backslashreplace' पायथन के बैकस्लेस्ड एस्केप सीक्वेंस द्वारा विकृत डेटा की जगह।
  • 'namereplace' (यह भी केवल जब लेखन का समर्थन किया जाता है) असमर्थित वर्णों को \N{...} एस्केप अनुक्रमों से बदल देता है ।

newline यह नियंत्रित करता है कि सार्वभौमिक newlines मोड कैसे काम करता है (यह केवल पाठ मोड पर लागू होता है)। यह हो सकता है None , '' , '\n' , '\r' , और '\r\n' । यह निम्नानुसार काम करता है:

  • स्ट्रीम से इनपुट पढ़ते समय, यदि न्यूलाइन है None , तो यूनिवर्सल न्यूलाइन्स मोड सक्षम है। इनपुट में लाइनों में समाप्त कर सकते हैं '\n' , '\r' या '\r\n' , और इन में अनुवाद कर रहे हैं '\n' फोन करने वाले को लौट किए जाने से पहले। यदि यह है '' , तो यूनिवर्सल न्यूलाइन्स मोड सक्षम किया गया है, लेकिन लाइन एंडरिंग अनलॉकरेटेड कॉलर को वापस कर दिया जाता है। यदि इसके पास कोई अन्य कानूनी मान है, तो इनपुट लाइनें केवल दिए गए स्ट्रिंग द्वारा समाप्त की जाती हैं, और समाप्त होने वाली रेखा कॉलर को वापस नहीं लौटाया जाता है।
  • जब स्ट्रीम करने के लिए उत्पादन लेखन, अगर न्यू लाइन है None , किसी भी '\n' लिखे गए वर्णों को सिस्टम डिफ़ॉल्ट लाइन विभाजक के लिए, अनुवाद किया जाता है os.linesep । यदि न्यूलाइन है '' या '\n' , कोई अनुवाद नहीं होता है। यदि newline अन्य कानूनी मूल्यों में से कोई है, तो '\n' लिखे गए किसी भी अक्षर को दिए गए स्ट्रिंग में अनुवादित किया जाता है।

यदि क्लोज़फ़ड है False और फ़ाइल नाम के बजाय फ़ाइल डिस्क्रिप्टर दिया गया है, तो फ़ाइल बंद होने पर अंतर्निहित फ़ाइल डिस्क्रिप्टर को खुला रखा जाएगा। यदि फ़ाइल नाम दिया जाता है तो क्लोज़फ़ड True (डिफ़ॉल्ट) होना चाहिए अन्यथा एक त्रुटि खड़ी हो जाएगी।

एक सलामी बल्लेबाज को सलामी बल्लेबाज के रूप में पास करके उपयोग किया जा सकता है । फ़ाइल ऑब्जेक्ट के लिए अंतर्निहित फ़ाइल डिस्क्रिप्टर को तब ( फ़ाइल , झंडे ) के साथ ओपनर कॉल करके प्राप्त किया जाता है । ओपनर को एक ओपन फाइल डिस्क्रिप्टर (पासिंग के समान कार्यक्षमता में ओपनर परिणाम के रूप में पारित ) वापस करना होगा। os.open None

नई बनाई गई फ़ाइल non-inheritable अंतर्निहित है ।

निम्न उदाहरण दिए गए निर्देशिका के सापेक्ष फ़ाइल खोलने के लिए फ़ंक्शन के dir_fd पैरामीटर का उपयोग करता है os.open :

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

फ़ंक्शन द्वारा लौटाए गए फ़ाइल ऑब्जेक्ट का प्रकार open() मोड पर निर्भर करता है। जब open() एक पाठ मोड (में एक फ़ाइल को खोलने के लिए प्रयोग किया जाता है 'w' , 'r' , 'wt' , 'rt' , आदि), इसके बारे में एक उपवर्ग रिटर्न io.TextIOBase (विशेष रूप से io.TextIOWrapper )। जब बफरिंग के साथ एक बाइनरी मोड में एक फ़ाइल खोलने के लिए उपयोग किया जाता है, तो लौटा वर्ग एक उपवर्ग है io.BufferedIOBase । सटीक वर्ग भिन्न होता है: बाइनरी मोड को पढ़ने में, यह एक रिटर्न देता है io.BufferedReader ; द्विआधारी और द्विआधारी मोड लिखने में, यह एक रिटर्न देता है io.BufferedWriter , और रीड / राइट मोड में, यह एक रिटर्न देता है io.BufferedRandom । जब बफरिंग अक्षम किया गया है, कच्चे धारा, का एक उपवर्ग io.RawIOBase , io.FileIO , दिया जाता है।

यह भी देखें फ़ाइल जैसे, मॉड्यूल, हैंडलिंग fileinput , io (जहां open() घोषित किया जाता है), os , os.path , tempfile , और shutil

संस्करण 3.3 में परिवर्तित:
  • सलामी बल्लेबाज पैरामीटर जोड़ दिया गया।
  • 'x' मोड जोड़ दिया गया।
  • IOError उठाया जाता था, यह अब एक उपनाम है OSError
  • FileExistsError अब बनाया गया है यदि फ़ाइल अनन्य निर्माण मोड ( 'x' ) में पहले से मौजूद है।
संस्करण 3.4 में परिवर्तित:
  • फ़ाइल अब गैर-अंतर्निहित है।

संस्करण 3.4 के बाद से खारिज किया गया, संस्करण 4.0 में निकाल दिया जाएगा: 'U' मोड।

संस्करण 3.5 में परिवर्तित:
  • सिस्टम कॉल बाधित है और संकेत हैंडलर एक अपवाद बढ़ा नहीं करता है, समारोह अब बजाय एक जुटाने की सिस्टम कॉल पुनः प्रयास करता InterruptedError अपवाद (देखें पीईपी 475 औचित्य के लिए)।
  • 'namereplace' त्रुटि हैंडलर जोड़ दिया गया।
संस्करण 3.6 में परिवर्तित:
  • समर्थन वस्तुओं को लागू करने के लिए जोड़ा गया os.PathLike
  • Windows पर, कंसोल बफ़र को खोलने से io.RawIOBase अन्य उप-वर्ग को लौटाया जा सकता है io.FileIO
ord(c)

एक यूनिकोड वर्ण का प्रतिनिधित्व करने वाले एक स्ट्रिंग को देखते हुए, उस चरित्र के यूनिकोड कोड बिंदु का प्रतिनिधित्व करने वाला पूर्णांक लौटाएं। उदाहरण के लिए, ord('a') पूर्णांक 97 और ord('€') (यूरो चिह्न) रिटर्न देता है 8364 । यह उलटा है chr()

pow(x, y[, z])

पावर y पर वापसी x ; यदि z मौजूद है, तो x को पावर y , modulo z (तुलना में अधिक कुशलता से गणना की गई ) पर लौटें । दो-तर्क फॉर्म पॉवर ऑपरेटर का उपयोग करने के बराबर है :। pow(x, y) % z pow(x, y) x**y

तर्कों में संख्यात्मक प्रकार होने चाहिए। मिश्रित ऑपरेंड प्रकार के साथ, द्विआधारी अंकगणितीय ऑपरेटरों के लिए ज़बरदस्ती नियम लागू होते हैं। के लिए int() ऑपरेंड, परिणाम ऑपरेंड (बलात्कार के बाद) जब तक दूसरा तर्क नकारात्मक है के रूप में एक ही प्रकार है; उस स्थिति में, सभी तर्कों को फ्लोट में बदल दिया जाता है और एक फ्लोट परिणाम दिया जाता है। उदाहरण के लिए, 10**2 रिटर्न 100 , लेकिन 10**-2 रिटर्न 0.01 । यदि दूसरा तर्क नकारात्मक है, तो तीसरे तर्क को छोड़ दिया जाना चाहिए। यदि z मौजूद है, तो x और y पूर्णांक प्रकार के होने चाहिए , और y गैर-ऋणात्मक होना चाहिए।

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

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

सभी गैर-कीवर्ड तर्क स्ट्रिंग्स में परिवर्तित हो जाते हैं जैसे str(value) कि स्ट्रीम में लिखे जाते हैं, sep द्वारा अलग किए जाते हैं और इसके बाद अंत में सीप और एंड दोनों को तार होना चाहिए; वे भी हो सकते हैं None , जिसका अर्थ है डिफ़ॉल्ट मानों का उपयोग करना। यदि कोई वस्तु नहीं दी गई है, print() तो बस अंत लिखेंगे ।

फ़ाइल तर्क एक के साथ एक वस्तु होना चाहिए write(string) विधि; यदि यह मौजूद नहीं है या None , sys.stdout इसका उपयोग किया जाएगा। चूंकि मुद्रित तर्क टेक्स्ट स्ट्रिंग्स में परिवर्तित होते हैं, इसलिए print() बाइनरी मोड फ़ाइल ऑब्जेक्ट के साथ उपयोग नहीं किया जा सकता है। इन के लिए, file.write(...) बजाय का उपयोग करें ।

क्या आउटपुट बफ़र किया जाता है, आमतौर पर फ़ाइल द्वारा निर्धारित किया जाता है , लेकिन यदि फ्लश कीवर्ड तर्क सही है, तो स्ट्रीम जबरन फ़्लश की जाती है।

संस्करण 3.3 में बदला गया : फ्लश कीवर्ड तर्क जोड़ा गया ।

class property(fget=None, fset=None, fdel=None, doc=None)

एक संपत्ति विशेषता लौटें।

फ़ीचर एक विशेषता मान प्राप्त करने का एक कार्य है। फ़ीचर मान सेट करने के लिए fset एक फ़ंक्शन है। fdel एक विशेषता मान को हटाने के लिए एक फ़ंक्शन है। और doc विशेषता के लिए एक docstring बनाता है।

एक विशिष्ट उपयोग एक प्रबंधित विशेषता को परिभाषित करने के लिए है x :

class C:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, value):
        self._x = value

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

यदि का एक उदाहरण है सी , cx गेटर लागू करेगा, cx = value सेटर और लागू करेगा del cx Deleter।

यदि दिया जाता है, तो डॉक संपत्ति विशेषता का डॉकस्ट्रिंग होगा। अन्यथा, संपत्ति fget की डॉकस्ट्रिंग (यदि यह मौजूद है) की प्रतिलिपि बनाएगी । इससे property() एक decorator रूप में आसानी से पढ़े जाने वाले गुणों को आसानी से बनाया जा सकता है :

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

@property डेकोरेटर बदल जाता है voltage() एक एक केवल पढ़ने के लिए ही नाम के साथ विशेषता के लिए "गेटर" में विधि, और इसके लिए docstring सेट वोल्टेज के लिए "वर्तमान वोल्टेज प्राप्त करें।"

एक संपत्ति वस्तु है getter , setter और deleter सज्जाकार कि इसी एक्सेसर समारोह सजाया समारोह के लिए सेट के साथ संपत्ति की एक प्रतिलिपि बनाने के रूप में प्रयोग करने योग्य तरीके। यह एक उदाहरण के साथ सबसे अच्छा समझाया गया है:

class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

यह कोड पहले उदाहरण के बराबर है। अतिरिक्त कार्यों को मूल संपत्ति ( x इस मामले में) के समान नाम देना सुनिश्चित करें ।

लौटे संपत्ति वस्तु भी गुण होते हैं fget , fset और fdel निर्माता तर्क करने के लिए इसी।

संस्करण 3.5 में बदला गया: संपत्ति वस्तुओं की डॉकस्ट्रिंग अब लेखन योग्य हैं।

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

एक फ़ंक्शन होने के बजाय, range वास्तव में एक अपरिवर्तनीय अनुक्रम प्रकार है, जैसा कि Ranges और अनुक्रम प्रकारों में सूचीबद्ध है - सूची, टपल, रेंज

repr(object)

किसी ऑब्जेक्ट के मुद्रण योग्य प्रतिनिधित्व वाले स्ट्रिंग को लौटाएं। कई प्रकारों के लिए, यह फ़ंक्शन एक स्ट्रिंग को वापस करने का प्रयास करता है, जो पास होने पर उसी मूल्य के साथ एक वस्तु प्राप्त करेगा eval() , अन्यथा प्रतिनिधित्व कोण कोष्ठक में संलग्न एक स्ट्रिंग है जिसमें अतिरिक्त जानकारी के साथ ऑब्जेक्ट के प्रकार का नाम शामिल है अक्सर वस्तु का नाम और पता सहित। एक वर्ग इस बात को नियंत्रित कर सकता है कि यह फ़ंक्शन किस __repr__() विधि को परिभाषित करके अपने उदाहरणों के लिए वापस लौटता है ।

reversed(seq)

एक रिवर्स iterator लौटें । seq एक ऑब्जेक्ट होना चाहिए जिसमें एक __reversed__() विधि है या अनुक्रम प्रोटोकॉल का समर्थन करता है ( __len__() विधि और __getitem__() पूर्णांक तर्कों के साथ विधि शुरू होती है 0 )।

round(number[, ndigits])

लौटें संख्या को गोल ndigits दशमलव बिंदु के बाद परिशुद्धता। यदि ndigits छोड़ा गया है या है None , तो यह उसके इनपुट के लिए निकटतम पूर्णांक लौटाता है।

अंतर्निहित प्रकारों के समर्थन के लिए round() , मानों को शक्ति माइनस ndigits के 10 के निकटतम कई पर गोल किया जाता है ; यदि दो गुणक समान रूप से पास हैं, तो गोलाई भी पसंद की ओर की जाती है (इसलिए, उदाहरण के लिए, दोनों round(0.5) और round(-0.5) हैं 0 , और round(1.5) है 2 )। कोई भी पूर्णांक मान ndigits (सकारात्मक, शून्य या नकारात्मक) के लिए मान्य है । रिटर्न मान एक पूर्णांक है यदि ndigits छोड़ा गया है या None । अन्यथा वापसी मूल्य में संख्या के समान प्रकार है ।

एक सामान्य अजगर वस्तु के लिए number , round प्रतिनिधि को number.__round__

ध्यान दें

round() तैरने के लिए व्यवहार आश्चर्यजनक हो सकता है: उदाहरण के लिए, अपेक्षित के बजाय round(2.675, 2) देता 2.67 है 2.68 । यह एक बग नहीं है: यह इस तथ्य का परिणाम है कि अधिकांश दशमलव अंशों को एक फ्लोट के रूप में बिल्कुल प्रतिनिधित्व नहीं किया जा सकता है। फ़्लोटिंग पॉइंट अंकगणित देखें : अधिक जानकारी के लिए मुद्दे और सीमाएँ

class set([iterable])

set वैकल्पिक रूप से पुनरावृति से लिए गए तत्वों के साथ एक नई वस्तु लौटाएं । set एक अंतर्निहित वर्ग है। इस वर्ग के बारे में दस्तावेज़ीकरण के लिए सेट - फ्रोज़ेंसेट देखें set और सेट करें

अन्य कंटेनरों के लिए निर्मित देखना frozenset , list , tuple , और dict कक्षाएं, साथ ही collections मॉड्यूल।

setattr(object, name, value)

यह प्रतिपक्ष है getattr() । तर्क एक वस्तु, एक स्ट्रिंग और एक मनमाना मूल्य हैं। स्ट्रिंग एक मौजूदा विशेषता या एक नई विशेषता का नाम दे सकती है। फ़ंक्शन विशेषता को मूल्य प्रदान करता है, बशर्ते ऑब्जेक्ट इसे अनुमति देता है। उदाहरण के लिए, setattr(x, 'foobar', 123) के बराबर है x.foobar = 123

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

द्वारा निर्दिष्ट सूचकांकों के सेट का प्रतिनिधित्व करने वाली एक slice ऑब्जेक्ट पर लौटें range(start, stop, step) शुरुआत और कदम के लिए तर्क डिफ़ॉल्ट None । स्लाइस ऑब्जेक्ट्स में केवल-पढ़ने के लिए डेटा विशेषताएँ होती हैं start , stop और step जो केवल तर्क मूल्यों (या उनके डिफ़ॉल्ट) को वापस करती हैं। उनकी कोई अन्य स्पष्ट कार्यक्षमता नहीं है; हालाँकि, उनका उपयोग न्यूमेरिकल पायथन और अन्य थर्ड पार्टी एक्सटेंशन द्वारा किया जाता है। विस्तारित इंडेक्सिंग सिंटैक्स का उपयोग करने पर स्लाइस ऑब्जेक्ट भी उत्पन्न होते हैं। उदाहरण के लिए: a[start:stop:step] या a[start:stop, i] itertools.islice() एक वैकल्पिक संस्करण के लिए देखें जो पुनरावृत्ति देता है।

sorted(iterable, *, key=None, reverse=False)

पुनरावृत्त वस्तुओं में से एक नई क्रमबद्ध सूची लौटाएँ ।

दो वैकल्पिक तर्क हैं जिन्हें कीवर्ड तर्क के रूप में निर्दिष्ट किया जाना चाहिए।

कुंजी एक तर्क के एक फ़ंक्शन को निर्दिष्ट करती है जिसका उपयोग प्रत्येक सूची तत्व से तुलना कुंजी निकालने के लिए किया जाता है key=str.lower :। डिफ़ॉल्ट मान है None (सीधे तत्वों की तुलना करें)।

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

functools.cmp_to_key() एक पुराने-शैली cmp फ़ंक्शन को कुंजी फ़ंक्शन में बदलने के लिए उपयोग करें ।

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

सॉर्टिंग उदाहरण और एक संक्षिप्त सॉर्टिंग ट्यूटोरियल के लिए, सॉर्टिंग को कैसे देखें ।

@staticmethod

किसी विधि को स्थैतिक विधि में बदलना।

एक स्थैतिक विधि एक अंतर्निहित पहला तर्क प्राप्त नहीं करता है। एक स्थिर विधि घोषित करने के लिए, इस मुहावरे का उपयोग करें:

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@staticmethod प्रपत्र एक समारोह है decorator - में समारोह परिभाषाओं का विवरण देखने के समारोह परिभाषाएँ जानकारी के लिए।

इसे या तो कक्षा (जैसे Cf() ) या उदाहरण पर (जैसे C().f() ) कहा जा सकता है । इसके वर्ग को छोड़कर उदाहरण को नजरअंदाज किया जाता है।

पायथन में स्थैतिक विधियाँ जावा या C ++ में पाए जाने वाले समान हैं। classmethod() एक वैरिएंट के लिए भी देखें जो वैकल्पिक क्लास कंस्ट्रक्टर बनाने के लिए उपयोगी है।

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

class C:
    builtin_open = staticmethod(open)

स्थिर तरीकों के बारे में अधिक जानकारी के लिए, में मानक प्रकार पदानुक्रम के लिए दस्तावेज़ देखें मानक प्रकार पदानुक्रम

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

वस्तु str(value) का एक संस्करण लौटाएँ । विवरण के लिए देखें। str(value)

str बिल्ट-इन स्ट्रिंग class । स्ट्रिंग के बारे में सामान्य जानकारी के लिए, पाठ अनुक्रम प्रकार - str देखें

sum(iterable[, start])

रकम शुरू होती है और बाएं से दाएं चलने वाली चलने वाली वस्तुओं को वापस लौटाती है। के लिए चूक शुरू करो 0 Iterable के आइटम सामान्य रूप से नंबर दिए गए हैं, और शुरू मान एक स्ट्रिंग होना करने के लिए अनुमति नहीं है।

कुछ उपयोग मामलों के लिए, अच्छे विकल्प हैं sum() । तार के एक क्रम को समाप्‍त करने का पसंदीदा, तेज तरीका है कॉलिंग ''.join(sequence) । विस्तारित सटीकता के साथ फ्लोटिंग पॉइंट वैल्यू जोड़ने के लिए, देखें math.fsum() । पुनरावृत्तियों की एक श्रृंखला को संक्षिप्त करने के लिए, उपयोग करने पर विचार करें itertools.chain()

super([type[, object-or-type]])

किसी प्रॉक्सी ऑब्जेक्ट को लौटाएं जो विधि को अभिभावक या सिबलिंग क्लास के प्रकार को कॉल करता है । यह उन विरासत वाले तरीकों तक पहुंचने के लिए उपयोगी है जिन्हें एक वर्ग में ओवरराइड किया गया है। खोज क्रम वही है जिसका उपयोग getattr() इसके अलावा किया जाता है कि प्रकार स्वयं ही छोड़ दिया गया है।

प्रकार की __mro__ विशेषता विधि रिज़ॉल्यूशन खोज क्रम को सूचीबद्ध करती है जिसका उपयोग दोनों द्वारा किया जाता है और । विशेषता डायनेमिक है और जब भी वंशानुक्रम पदानुक्रम अद्यतन किया जाता है तब इसे बदल सकते हैं। getattr() super()

यदि दूसरा तर्क छोड़ दिया जाता है, तो लौटाया गया सुपर ऑब्जेक्ट अनबाउंड है। यदि दूसरा तर्क एक वस्तु है, isinstance(obj, type) तो सत्य होना चाहिए। यदि दूसरा तर्क एक प्रकार है, issubclass(type2, type) तो सही होना चाहिए (यह क्लासमेथोड के लिए उपयोगी है)।

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

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

दोनों उपयोग के मामलों के लिए, एक विशिष्ट सुपरक्लास कॉल इस तरह दिखता है:

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

ध्यान दें कि super() स्पष्ट डॉटेड विशेषता लुकअप जैसे बाध्यकारी प्रक्रिया के हिस्से के रूप में लागू किया गया है super().__getitem__(name) । ऐसा __getattribute__() अनुमान लगाने योग्य क्रम में कक्षाओं को खोजने के लिए अपनी स्वयं की विधि को लागू करने से होता है जो सहकारी कई विरासतों का समर्थन करता है। तदनुसार, super() इस तरह के बयान या ऑपरेटरों का उपयोग कर अंतर्निहित लुकअप के लिए अपरिभाषित है super()[name]

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

सहकारी कक्षाओं का उपयोग करने के तरीके के बारे में व्यावहारिक सुझावों के लिए super() , सुपर () का उपयोग करने के लिए मार्गदर्शिका देखें ।

tuple([iterable])

एक फ़ंक्शन होने के बजाय, tuple वास्तव में एक अपरिवर्तनीय अनुक्रम प्रकार है, जैसा कि Tuples और अनुक्रम प्रकारों में सूचीबद्ध है - सूची, ट्यूपल, रेंज

class type(object)
class type(name, bases, dict)

एक तर्क के साथ, किसी वस्तु का प्रकार वापस करें । वापसी मूल्य एक प्रकार की वस्तु है और आमतौर पर उसी वस्तु के रूप में जो लौटाता है object.__class__

isinstance() में निर्मित समारोह, एक वस्तु के प्रकार के परीक्षण के लिए सिफारिश की है क्योंकि यह खाते में उपवर्गों लेता है।

तीन तर्कों के साथ, एक नई प्रकार की वस्तु लौटाएं। यह अनिवार्य रूप से class बयान का एक गतिशील रूप है । नाम स्ट्रिंग वर्ग के नाम है और हो जाता है __name__ विशेषता; ठिकानों टपल आधार वर्ग दर्ज करती है और हो जाता __bases__ विशेषता; और डिक्शनरी डिक्शनरी एक ऐसा नेमस्पेस है जिसमें क्लास बॉडी के लिए परिभाषाएँ लिखी जाती हैं और इसे एक स्टैंडर्ड डिक्शनरी में कॉपी किया जाता है __dict__ । उदाहरण के लिए, निम्नलिखित दो कथन समान type() वस्तुएं बनाते हैं :

>>> class X:
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

टाइप ऑब्जेक्ट्स भी देखें ।

संस्करण 3.6 में परिवर्तित: उप-वर्ग type() जिनमें से ओवरराइड type.__new__ नहीं करते हैं, वे ऑब्जेक्ट के प्रकार को प्राप्त करने के लिए एक-तर्क फॉर्म का उपयोग नहीं कर सकते।

vars([object])

किसी __dict__ विशेषता के साथ मॉड्यूल, वर्ग, उदाहरण, या किसी अन्य ऑब्जेक्ट के लिए विशेषता लौटाएं __dict__

मॉड्यूल और उदाहरण जैसे ऑब्जेक्ट में एक अद्यतन करने योग्य __dict__ विशेषता है; हालाँकि, अन्य वस्तुओं में उनकी __dict__ विशेषताओं पर प्रतिबंध हो सकता है (उदाहरण के लिए, कक्षाएं types.MappingProxyType प्रत्यक्ष शब्दकोश अपडेट को रोकने के लिए एक का उपयोग करती हैं )।

एक तर्क के बिना, vars() जैसे कार्य करता है locals() । ध्यान दें, स्थानीय शब्दकोश केवल पढ़ने के लिए उपयोगी है क्योंकि स्थानीय शब्दकोश में अपडेट की अनदेखी की जाती है।

zip(*iterables)

एक पुनरावृत्ति करें जो प्रत्येक पुनरावृत्तियों से तत्वों को एकत्र करता है।

टुपल्स का एक पुनरावर्तक लौटाता है, जहाँ i -th tuple में प्रत्येक तर्क क्रम या पुनरावृत्तियों में से i -थ तत्व होता है। जब छोटा इनपुट चलने योग्य समाप्त हो जाता है, तो इट्रेटर बंद हो जाता है। एक एकल चलने योग्य तर्क के साथ, यह 1-ट्यूपल्स के एक पुनरावृत्त लौटाता है। बिना किसी तर्क के, यह एक खाली पुनरावृत्ति देता है। के बराबर:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

पुनरावृत्तियों के बाएं से दाएं मूल्यांकन क्रम की गारंटी है। यह संभव है कि डेटा श्रृंखला का उपयोग करते हुए n-लंबाई समूहों में क्लस्टरिंग के लिए एक मुहावरा संभव हो zip(*[iter(s)]*n) । यह दोहराता ही इटरेटर n बार ताकि प्रत्येक उत्पादन टपल का परिणाम है n इटरेटर के लिए कॉल। यह इनपुट को एन-लेंथ चंक्स में विभाजित करने का प्रभाव है।

zip() केवल असमान लंबाई इनपुट के साथ उपयोग किया जाना चाहिए जब आप अनुगामी के बारे में परवाह नहीं करते हैं, अब पुनरावृत्तियों से बेजोड़ मान। यदि वे मान महत्वपूर्ण हैं, तो itertools.zip_longest() इसके बजाय उपयोग करें ।

zip() * ऑपरेटर के साथ मिलकर किसी सूची को अनज़िप करने के लिए इस्तेमाल किया जा सकता है:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True
__import__(name, globals=None, locals=None, fromlist=(), level=0)

ध्यान दें

यह एक उन्नत फ़ंक्शन है जो इसके विपरीत, रोज़ पायथन प्रोग्रामिंग में आवश्यक नहीं है importlib.import_module()

इस फ़ंक्शन को import कथन द्वारा लागू किया जाता है । बयान के शब्दार्थ को बदलने के लिए इसे प्रतिस्थापित किया जा सकता है ( builtins मॉड्यूल को आयात करने और असाइन करने के लिए builtins.__import__ ) import , लेकिन ऐसा करना दृढ़ता से हतोत्साहित किया जाता है क्योंकि आमतौर पर समान लक्ष्यों को प्राप्त करने के लिए आयात हुक का उपयोग करना आसान होता है ( पीईपी 302 देखें )। कोड के कारण समस्याएँ जो मानती हैं कि डिफ़ॉल्ट आयात कार्यान्वयन उपयोग में है। का प्रत्यक्ष उपयोग __import__() भी इसके पक्ष में हतोत्साहित किया जाता है importlib.import_module()

फ़ंक्शन मॉड्यूल नाम का आयात करता है , संभवतः दिए गए ग्लोबल्स और स्थानीय लोगों का उपयोग करके यह निर्धारित करने के लिए कि पैकेज संदर्भ में नाम की व्याख्या कैसे करें। Fromlist वस्तुओं या submodules कि द्वारा दिए गए मॉड्यूल से आयात किया जाना चाहिए के नाम देता है नाम । मानक कार्यान्वयन अपने स्थानीय लोगों के तर्क का उपयोग नहीं करता है, और केवल बयान के पैकेज संदर्भ को निर्धारित करने के लिए अपने ग्लोबल्स का उपयोग करता है import

स्तर निर्दिष्ट करता है कि पूर्ण या सापेक्ष आयात का उपयोग करना है या नहीं। 0 (डिफ़ॉल्ट) का अर्थ केवल पूर्ण आयात करना है। स्तर के लिए सकारात्मक मान मॉड्यूल कॉलिंग की निर्देशिका के सापेक्ष खोज करने के लिए मूल निर्देशिकाओं की संख्या को इंगित करते __import__() हैं ( विवरण के लिए पीईपी 328 देखें)।

जब नाम चर फार्म की है package.module , आम तौर पर, शीर्ष स्तर के पैकेज (नाम पहली डॉट तक) दिया जाता है, नहीं मॉड्यूल द्वारा नामित नाम । हालांकि, जब एक गैर खाली fromlist तर्क दिया जाता है, मॉड्यूल द्वारा नामित नाम दिया जाता है।

उदाहरण के लिए, स्टेटमेंट import spam में निम्नलिखित कोड से मिलता-जुलता बायटेकोड होता है:

spam = __import__('spam', globals(), locals(), [], 0)

import spam.ham इस कॉल में कथन परिणाम है:

spam = __import__('spam.ham', globals(), locals(), [], 0)

ध्यान दें कि कैसे __import__() टॉपप्ले मॉड्यूल को यहां लौटाया जाता है क्योंकि यह वह वस्तु है जो import कथन द्वारा एक नाम के लिए बाध्य है ।

दूसरी ओर, बयान में from spam.ham import eggs, sausage as saus परिणाम है

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage

यहां, spam.ham मॉड्यूल से लौटा दिया गया है __import__() । इस ऑब्जेक्ट से, आयात करने वाले नामों को उनके संबंधित नामों को पुनर्प्राप्त और सौंपा गया है।

यदि आप बस नाम से एक मॉड्यूल (संभवतः एक पैकेज के भीतर) आयात करना चाहते हैं, तो उपयोग करें importlib.import_module()

संस्करण 3.3 में परिवर्तित: स्तर के लिए नकारात्मक मान अब समर्थित नहीं हैं (जो कि डिफ़ॉल्ट मान को 0 में बदलता है)।

फुटनोट

[1] ध्यान दें कि पार्सर केवल लाइन कन्वेंशन के यूनिक्स-शैली के अंत को स्वीकार करता है। यदि आप किसी फ़ाइल से कोड पढ़ रहे हैं, तो विंडोज या मैक-शैली के न्यूलाइन को बदलने के लिए न्यूलाइन रूपांतरण मोड का उपयोग करना सुनिश्चित करें।

Original text