पैसे चुकाकर बने सदस्यों के लिए
- abs
- सभी
- कोई भी
- bool
- dict
- दिर
- सूची में शामिल करें
- फ़ेल
- float
- getattr
- hasattr
- हैश
- int
- len
- list
- ज़्यादा से ज़्यादा
- मिनट
- प्रिंट
- रेंज
- आरईपीआर
- रिवर्स
- क्रम से लगाया गया
- str
- tuple
- टाइप
- zip
abs
unknown abs(x)किसी संख्या की ऐब्सलूट वैल्यू दिखाता है (एक ही मैग्निट्यूड वाली नॉन-नेगेटिव नंबर).
abs(-2.3) == 2.3
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
int; या float;
ज़रूरी है कोई संख्या (int या float) |
सभी
bool all(elements)अगर सभी एलिमेंट 'सही' के तौर पर रेट करते हैं या कलेक्शन खाली होता है, तो 'सही' दिखाता है. bool फ़ंक्शन का इस्तेमाल करके एलिमेंट को बूलियन में बदला जाता है.
all(["hello", 3, True]) == True all([-1, 0, 1]) == False
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
elements
|
ज़रूरी है कोई स्ट्रिंग या एलिमेंट का कलेक्शन. |
कोई भी
bool any(elements)अगर कम से कम एक एलिमेंट का आकलन 'सही' के तौर पर होता है, तो 'सही' दिखाता है. bool फ़ंक्शन का इस्तेमाल करके एलिमेंट को बूलियन में बदला जाता है.
any([-1, 0, 1]) == True any([False, 0, ""]) == False
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
elements
|
ज़रूरी है कोई स्ट्रिंग या एलिमेंट का कलेक्शन. |
bool
bool bool(x=False)बूल टाइप का कंस्ट्रक्टर. अगर ऑब्जेक्ट
None
, False
, खाली स्ट्रिंग (""
), संख्या 0
या खाली कलेक्शन (जैसे कि ()
, []
) है, तो यह False
दिखाता है. ऐसा न होने पर, यह True
दिखाता है.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
डिफ़ॉल्ट तौर पर, False हैवह वैरिएबल जिसे बदला जाना है. |
dict
dict dict(pairs=[], **kwargs)किसी वैकल्पिक पोज़िशनल आर्ग्युमेंट और कीवर्ड आर्ग्युमेंट के सेट से, एक शब्दकोश बनाता है. ऐसे मामले में जहां एक ही कुंजी को कई बार दिया गया है, वहां आखिरी वैल्यू का इस्तेमाल किया जाएगा. कीवर्ड आर्ग्युमेंट के ज़रिए दी गई एंट्री, पोज़िशनल आर्ग्युमेंट के ज़रिए दी गई एंट्री के बाद मानी जाती हैं.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
pairs
|
डिफ़ॉल्ट है [] यह एक डिक्शनरी या बार-बार इस्तेमाल किया जा सकने वाला एलिमेंट है, जिसके हर एलिमेंट की लंबाई 2 (कुंजी, वैल्यू) होती है. |
kwargs
|
ज़रूरी है अतिरिक्त एंट्री का शब्दकोश. |
दिशा
list dir(x)स्ट्रिंग की सूची दिखाता है: इसमें पैरामीटर ऑब्जेक्ट के एट्रिब्यूट और तरीकों के नाम होते हैं.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसकी जांच करनी है. |
गिनती करें
list enumerate(list, start=0)इंडेक्स (int) और इनपुट अनुक्रम से आइटम के साथ, युग्मों (दो-एलिमेंट ट्यूपल) की सूची देता है.
enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
list
|
ज़रूरी इनपुट का क्रम. |
start
|
0 स्टार्ट इंडेक्स डिफ़ॉल्ट है. |
असफल
None
fail(msg=None, attr=None, sep=" ", *args)
गड़बड़ी की वजह से एक्ज़ीक्यूशन नहीं हो पाता.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
msg
|
डिफ़ॉल्ट वैल्यू None हैयह अब काम नहीं करता: इसके बजाय, पोज़िशनल आर्ग्युमेंट का इस्तेमाल करें. यह आर्ग्युमेंट, इंप्लिसिट लीडर पोज़िशनल आर्ग्युमेंट की तरह काम करता है. |
attr
|
string; या None ;
डिफ़ॉल्ट तौर पर, None अब काम नहीं करता है. इससे गड़बड़ी के मैसेज में इस स्ट्रिंग वाला एक वैकल्पिक प्रीफ़िक्स जुड़ जाता है. |
sep
|
डिफ़ॉल्ट है " " ऑब्जेक्ट के बीच सेपरेटर स्ट्रिंग होती है, डिफ़ॉल्ट स्पेस (" ") होती है. |
args
|
ज़रूरी है उन वैल्यू की सूची जिन्हें डीबगप्रिंट (जो डिफ़ॉल्ट रूप से str के बराबर है) के साथ फ़ॉर्मैट किया गया हो और जिसे sep (डिफ़ॉल्ट रूप से " " पर सेट होता है) के साथ जोड़ा गया हो. यह गड़बड़ी के मैसेज में दिखती है. |
float
float float(x=unbound)x को फ़्लोट वैल्यू के रूप में लौटाता है.
- अगर
x
पहले से ही फ़्लोट है, तोfloat
इसे बिना किसी बदलाव के दिखाता है. - अगर
x
बूल है, तोfloat
सही के लिए 1.0 और गलत के लिए 0.0 लौटाता है. - अगर
x
कोई पूर्णांक है, तोfloat
x पर सबसे पास की सीमित फ़्लोटिंग-पॉइंट वैल्यू दिखाता है या साइज़ बहुत बड़ा होने पर गड़बड़ी की जानकारी देता है. - अगर
x
कोई स्ट्रिंग है, तो यह एक मान्य फ़्लोटिंग-पॉइंट लिटरल होना चाहिए याNaN
,Inf
याInfinity
के बराबर (छोटे-बड़े अक्षर को अनदेखा करते हुए) होना चाहिए. इसके पहले+
या-
का निशान होना ज़रूरी नहीं है.
float()
0.0 दिखाता है.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
डिफ़ॉल्ट वैल्यू unbound हैबदली जाने वाली वैल्यू. |
getattr
unknown getattr(x, name, default=unbound)अगर दिए गए नाम का स्ट्रक्चर मौजूद है, तो यह फ़ील्ड दिखाता है. अगर ऐसा नहीं है, तो यह
default
(अगर बताई गई है) दिखाता है या गड़बड़ी की सूचना देता है. getattr(x, "foobar")
, x.foobar
के बराबर है.getattr(ctx.attr, "myattr") getattr(ctx.attr, "myattr", "mydefault")
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है वह स्ट्रक्चर जिसके एट्रिब्यूट को ऐक्सेस किया गया है. |
name
|
ज़रूरी है स्ट्रक्चर एट्रिब्यूट का नाम. |
default
|
डिफ़ॉल्ट है unbound अगर किसी स्ट्रक्चर में दिए गए नाम का एट्रिब्यूट नहीं है, तो यह डिफ़ॉल्ट वैल्यू होती है. |
हैएट्रिब्यूट
bool hasattr(x, name)अगर ऑब्जेक्ट
x
में, दिए गए name
का एट्रिब्यूट या तरीका है, तो 'सही' दिखाता है. ऐसा नहीं होने पर 'गलत' दिखाता है. उदाहरण:hasattr(ctx.attr, "myattr")
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसकी जांच करनी है. |
name
|
ज़रूरी है एट्रिब्यूट का नाम. |
हैश
int hash(value)किसी स्ट्रिंग के लिए हैश वैल्यू दिखाता है. इसकी गणना करने के लिए उसी एल्गोरिदम का इस्तेमाल किया जाता है, जिसका नाम Java के
String.hashCode()
वाले एल्गोरिदम का है. s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]फ़िलहाल, स्ट्रिंग के अलावा वैल्यू हैश करने की सुविधा काम नहीं करती.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
value
|
ज़रूरी है हैश करने के लिए स्ट्रिंग वैल्यू. |
int
int int(x, base=unbound)x को int वैल्यू के रूप में दिखाता है.
- अगर
x
पहले से ही एक पूर्णांक है, तोint
इसे बिना किसी बदलाव के दिखाता है. - अगर
x
बूल है, तोint
सही के लिए 1 और गलत के लिए 0 लौटाता है. - अगर
x
एक स्ट्रिंग है, तो उसका फ़ॉर्मैट<sign><prefix><digits>
होना चाहिए.<sign>
या तो"+"
है,"-"
है या खाली है (जिसे पॉज़िटिव बताया गया है).<digits>
0 से लेकरbase
- 1 तक के अंकों का क्रम होता है, जहां a-z तक अक्षरों (या A-Z के बराबर) का इस्तेमाल 10 से 35 तक के अंकों के रूप में किया जाता है. ऐसे मामले में जहांbase
की वैल्यू 2/8/16 है,<prefix>
ज़रूरी नहीं है और यह 0b/0o/0x (या इसके बराबर 0B/0O/0X) हो सकता है. अगरbase
, इन बेस या खास वैल्यू 0 के अलावा कोई अन्य वैल्यू है, तो प्रीफ़िक्स खाली होना चाहिए. जहांbase
0 है, वहां स्ट्रिंग को एक इंटीजर लिटरल के तौर पर दिखाया जाता है. यहां यह माना जाता है कि किसी एक बेस 2/8/10/16 को इस आधार पर चुना जाता है कि अगर किसी प्रीफ़िक्स का इस्तेमाल किया गया है, तो किस आधार को चुना जाएगा. अगरbase
0 है, तो किसी भी प्रीफ़िक्स का इस्तेमाल नहीं किया जाता और एक से ज़्यादा अंक होते हैं. ऐसी स्थिति में, सबसे पहले आने वाला अंक 0 नहीं हो सकता. यह ऑक्टल और दशमलव के बीच भ्रम की स्थिति से बचने के लिए है. स्ट्रिंग के ज़रिए दिखाई गई संख्या का मान, int टाइप के लिए तय की गई सीमा के अंदर होना चाहिए. - अगर
x
एक फ़्लोट है, तोint
फ़्लोट की पूर्णांक वैल्यू को शून्य की ओर पूर्णांक बनाता है. अगर x नॉन-फ़ाइनाइट (NaN या इनफ़िनिटी) है, तो यह एक गड़बड़ी होती है.
x
किसी दूसरी तरह का है या मान कोई ऐसी स्ट्रिंग है जो ऊपर दिए गए फ़ॉर्मैट के मुताबिक नहीं है, तो यह फ़ंक्शन काम नहीं करता. Python के int
फ़ंक्शन से अलग, यह फ़ंक्शन शून्य आर्ग्युमेंट की अनुमति नहीं देता. साथ ही, यह स्ट्रिंग आर्ग्युमेंट के लिए बाहरी खाली सफ़ेद जगह की अनुमति भी नहीं देता.उदाहरण:
int("123") == 123 int("-123") == -123 int("+123") == 123 int("FF", 16) == 255 int("0xFF", 16) == 255 int("10", 0) == 10 int("-0x10", 0) == -16 int("-0x10", 0) == -16 int("123.456") == 123
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है बदली जाने वाली स्ट्रिंग. |
base
|
डिफ़ॉल्ट वैल्यू unbound हैस्ट्रिंग की वैल्यू को समझने के लिए इस्तेमाल किया गया बेस, डिफ़ॉल्ट रूप से 10 होता है. बेस का पता लगाने के लिए, वैल्यू 2 से 36 के बीच होनी चाहिए. इसमें 0 भी हो सकती है. ऐसा तब होता है, जब x , लिटरल वैल्यू हो. अगर वैल्यू कोई स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.
|
len
int len(x)यह फ़ंक्शन किसी स्ट्रिंग, क्रम (जैसे कि लिस्ट या टपल), डिक्शनरी या अन्य एलिमेंट की लंबाई दिखाता है.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है वह वैल्यू जिसकी रिपोर्ट करनी है. |
सूची
list list(x=[])नई सूची दिखाता है, जिसमें वही एलिमेंट मौजूद होते हैं जो बार-बार दी जाने वाली वैल्यू में होते हैं.
list([1, 2]) == [1, 2] list((2, 3, 2)) == [2, 3, 2] list({5: "a", 2: "b", 4: "c"}) == [5, 2, 4]
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
डिफ़ॉल्ट तौर पर, [] वह ऑब्जेक्ट होता है जिसे बदलना है. |
ज़्यादा से ज़्यादा
unknown max(key=None, *args)सभी दिए गए तर्कों में से सबसे बड़ा देता है. अगर सिर्फ़ एक पोज़िशनल आर्ग्युमेंट दिया गया है, तो वह बार-बार इस्तेमाल किया जा सकने वाला होना चाहिए.अगर एलिमेंट की तुलना नहीं की जा सकती (उदाहरण के लिए, स्ट्रिंग के साथ इनपुट) या कोई आर्ग्युमेंट नहीं दिया गया है, तो यह गड़बड़ी होती है.
max(2, 5, 4) == 5 max([5, 6, 3]) == 6 max("two", "three", "four", key = len) =="three" # the longest max([1, -1, -2, 2], key = abs) == -2 # the first encountered with maximal key value
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
key
|
कॉल करने लायक; या None ;
डिफ़ॉल्ट None हैतुलना करने से पहले, हर एलिमेंट पर एक वैकल्पिक फ़ंक्शन लागू किया जाता है. |
args
|
ज़रूरी है वे एलिमेंट जिनकी जांच करनी है. |
कम से कम
unknown min(key=None, *args)दिए गए सभी तर्कों में से सबसे छोटा दिखाता है. अगर सिर्फ़ एक पोज़िशनल आर्ग्युमेंट दिया गया है, तो उसे दोहराया नहीं जा सकता. अगर एलिमेंट की तुलना नहीं की जा सकती (उदाहरण के लिए, स्ट्रिंग के साथ पूर्णांक) या कोई आर्ग्युमेंट नहीं दिया गया है, तो यह गड़बड़ी होती है.
min(2, 5, 4) == 2 min([5, 6, 3]) == 3 min("six", "three", "four", key = len) == "six" # the shortest min([2, -2, -1, 1], key = abs) == -1 # the first encountered with minimal key value
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
key
|
कॉल करने लायक; या None ;
डिफ़ॉल्ट None हैतुलना करने से पहले, हर एलिमेंट पर एक वैकल्पिक फ़ंक्शन लागू किया जाता है. |
args
|
ज़रूरी है वे एलिमेंट जिनकी जांच करनी है. |
प्रिंट करें
None
print(sep=" ", *args)
args
को डीबग आउटपुट के तौर पर प्रिंट करता है. इसे "DEBUG"
स्ट्रिंग और इस कॉल की जगह (फ़ाइल और लाइन नंबर) के आगे लगाया जाएगा. आर्ग्युमेंट को स्ट्रिंग में बदलने का सटीक तरीका नहीं बताया गया है और यह किसी भी समय बदल सकता है. खास तौर पर, यह str()
और repr()
के फ़ॉर्मैट से अलग और ज़्यादा जानकारी वाली हो सकती है.लोगों के लिए स्पैम वाला स्पैम होने की वजह से, प्रोडक्शन कोड में print
का इस्तेमाल करने की सलाह नहीं दी जाती. बंद करने के लिए, जब भी हो सके fail()
का इस्तेमाल करके मुश्किल गड़बड़ी को प्राथमिकता दें.
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
sep
|
डिफ़ॉल्ट है " " ऑब्जेक्ट के बीच सेपरेटर स्ट्रिंग होती है, डिफ़ॉल्ट स्पेस (" ") होती है. |
args
|
ज़रूरी है प्रिंट किए जाने वाले ऑब्जेक्ट. |
सीमा
sequence range(start_or_stop, stop_or_none=None, step=1)इस नीति से ऐसी सूची बनती है जिसमें आइटम को
step
की बढ़ोतरी का इस्तेमाल करके, start
से stop
पर ले जाया जाता है. अगर एक एलिमेंट दिया जाता है, तो आइटम 0 से लेकर उस एलिमेंट तक होंगे.range(4) == [0, 1, 2, 3] range(3, 9, 2) == [3, 5, 7] range(3, 0, -1) == [3, 2, 1]
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
start_or_stop
|
ज़रूरी है अगर स्टॉप दिया गया है, तो शुरुआती एलिमेंट की वैल्यू. अगर ऐसा नहीं है, तो स्टॉप और असल शुरुआत की वैल्यू 0 होगी |
stop_or_none
|
int; या None ;
पहले आइटम का डिफ़ॉल्ट इंडेक्स None वैकल्पिक है, जो नतीजे वाली सूची में शामिल नहीं है. सूची बनाने की प्रोसेस, stop तक पहुंचने से पहले रुक जाती है.
|
step
|
डिफ़ॉल्ट वैल्यू 1 हैबढ़ोतरी की वैल्यू डिफ़ॉल्ट तौर पर एक होती है. यह नकारात्मक हो सकता है. |
आरईपीआर
string repr(x)यह किसी भी ऑब्जेक्ट को स्ट्रिंग के तौर पर दिखाता है. यह डीबग करने में मदद करता है.
repr("ab") == '"ab"'
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसका फ़ॉर्मैट बदलना है. |
उल्टा
list reversed(sequence)नई, बिना फ़्रीज़ की गई सूची दिखाता है जिसमें फिर से क्रम में लगाए जा सकने वाले मूल क्रम के एलिमेंट उलटे क्रम में शामिल होते हैं.
reversed([3, 5, 4]) == [4, 5, 3]
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
sequence
|
ज़रूरी है बार-बार दोहराए जा सकने वाले क्रम (जैसे कि सूची) को उलटा जाना है. |
क्रम से लगाया गया
list sorted(iterable, key=None, *, reverse=False)दी गई, क्रम से लगाई गई नई सूची दिखाता है जिसमें दिए गए बार-बार दिए जा सकने वाले क्रम के सभी एलिमेंट शामिल होते हैं. अगर एलिमेंट x और y के किसी भी जोड़े की तुलना x < y का इस्तेमाल करके नहीं की जा सकती, तो गड़बड़ी हो सकती है. एलिमेंट को बढ़ते क्रम में लगाया जाता है, जब तक कि रिवर्स तर्क सही न हो. इस मामले में, क्रम घटते क्रम में होता है. क्रम से लगाने की प्रोसेस एक जैसी होती है: एक जैसी तुलना करने वाले एलिमेंट में, वे अपने मूल रिलेटिव ऑर्डर में ही दिखते हैं.
sorted([3, 5, 4]) == [3, 4, 5] sorted([3, 5, 4], reverse = True) == [5, 4, 3] sorted(["two", "three", "four"], key = len) == ["two", "four", "three"] # sort by length
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
iterable
|
ज़रूरी है क्रम से लगाने के लिए, बार-बार इस्तेमाल होने वाला क्रम. |
key
|
कॉल करने लायक; या None ;
डिफ़ॉल्ट None हैतुलना करने से पहले, हर एलिमेंट पर एक वैकल्पिक फ़ंक्शन लागू किया जाता है. |
reverse
|
डिफ़ॉल्ट तौर पर False हैनतीजों को घटते क्रम में दिखाएं. |
str
string str(x)यह किसी भी ऑब्जेक्ट को स्ट्रिंग में बदलता है. यह डीबग करने में मदद करता है.
str("ab") == "ab" str(8) == "8"
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसका फ़ॉर्मैट बदलना है. |
tuple
tuple tuple(x=())दिए गए दोहराए जा सकने वाले मान के जैसे एलिमेंट वाला टपल दिखाता है.
tuple([1, 2]) == (1, 2) tuple((2, 3, 2)) == (2, 3, 2) tuple({5: "a", 2: "b", 4: "c"}) == (5, 2, 4)
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
डिफ़ॉल्ट तौर पर, () वह ऑब्जेक्ट होता है जिसे बदलना है. |
टाइप
string type(x)इसके आर्ग्युमेंट के टाइप का नाम दिखाता है. यह डीबग करने और टाइप-चेकिंग करने में मदद करता है. उदाहरण:
type(2) == "int" type([1]) == "list" type(struct(a = 2)) == "struct"आने वाले समय में यह फ़ंक्शन बदल सकता है. Python के साथ काम करने वाला कोड लिखने और उसे आने वाले समय में इस्तेमाल न करने लायक बनाने के लिए, इसका इस्तेमाल सिर्फ़ रिटर्न वैल्यू की तुलना करने के लिए करें:
if type(x) == type([]): # if x is a list
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसके टाइप की जांच करनी है. |
zip
list zip(*args)
tuple
का list
दिखाता है, जहां i-th ट्यूपल में हर आर्ग्युमेंट के क्रम या बार-बार लागू किए जा सकने वाले एलिमेंट का i-th एलिमेंट शामिल होता है. इस सूची में सबसे छोटे इनपुट का साइज़ होता है. बार-बार दोहराए जा सकने वाले एक आर्ग्युमेंट की मदद से, यह 1-टूपल की सूची दिखाता है. बिना आर्ग्युमेंट के, यह खाली सूची दिखाता है. उदाहरण:zip() # == [] zip([1, 2]) # == [(1,), (2,)] zip([1, 2], [3, 4]) # == [(1, 3), (2, 4)] zip([1, 2], [3, 4, 5]) # == [(1, 3), (2, 4)]
पैरामीटर
पैरामीटर | कंपनी का ब्यौरा |
---|---|
args
|
ज़िप करने के लिए सूचियां ज़रूरी हैं. |