अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है सभी बेज़ेल फ़ाइलों में तरीके उपलब्ध हैं. इनमें .bzl फ़ाइलें, BUILD, MODULE.baकोई, और वर्कस्पेस शामिल हैं.
सदस्य
- कुल
- सभी
- कोई भी
- bool
- शब्दकोश
- dir
- सूची में शामिल करें
- फ़ेल
- फ़्लोट
- getattr
- hasattr
- हैश
- इंट
- लेंस
- list
- ज़्यादा से ज़्यादा
- मिनट
- प्रिंट
- रेंज
- आरईपीआर
- रिवर्स
- क्रम से लगाया गया
- str
- टपल
- टाइप
- ज़िप
कुल
unknown abs(x)किसी संख्या की ऐब्सलूट वैल्यू दिखाता है (एक ही मैग्निट्यूड वाली नॉन-नेगेटिव नंबर).
abs(-2.3) == 2.3
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
int; या float;
ज़रूरी है संख्या (इंटी या फ़्लोट) |
सभी
bool all(elements)अगर सभी एलिमेंट 'सही' के तौर पर रेट करते हैं या कलेक्शन खाली होता है, तो 'सही' दिखाता है. बूल फ़ंक्शन का इस्तेमाल करके एलिमेंट को बूलियन में बदला जाता है.
all(["hello", 3, True]) == True all([-1, 0, 1]) == False
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
elements
|
ज़रूरी है स्ट्रिंग या एलिमेंट का कलेक्शन. |
कोई
bool any(elements)अगर कम से कम एक एलिमेंट का आकलन 'सही' के तौर पर होता है, तो 'सही' दिखाता है. बूल फ़ंक्शन का इस्तेमाल करके एलिमेंट को बूलियन में बदला जाता है.
any([-1, 0, 1]) == True any([False, 0, ""]) == False
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
elements
|
ज़रूरी है स्ट्रिंग या एलिमेंट का कलेक्शन. |
बूल
bool bool(x=False)बूल टाइप का कंस्ट्रक्टर. अगर ऑब्जेक्ट
None, False, कोई खाली स्ट्रिंग (""), संख्या 0 या कोई खाली कलेक्शन (जैसे कि (), []) है, तो यह False दिखाता है. अगर ऐसा नहीं है, तो यह True दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
डिफ़ॉल्ट रूप से Falseहै वह वैरिएबल जिसे बदलना है. |
डिक्शनरी
dict dict(pairs=[], **kwargs)किसी वैकल्पिक पोज़िशनल आर्ग्युमेंट और कीवर्ड आर्ग्युमेंट के सेट से, एक शब्दकोश बनाता है. ऐसे मामले में जहां एक ही कुंजी को कई बार दिया गया है, वहां आखिरी वैल्यू का इस्तेमाल किया जाएगा. कीवर्ड आर्ग्युमेंट के ज़रिए दी गई एंट्री, पोज़िशनल आर्ग्युमेंट के ज़रिए दी गई एंट्री के बाद मानी जाती हैं.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
pairs
|
डिफ़ॉल्ट रूप से []है डिक्शनरी या बार-बार इस्तेमाल होने वाला ऐसा एलिमेंट जिसके एलिमेंट की लंबाई 2 (कुंजी, वैल्यू) से शुरू होती है. |
kwargs
|
ज़रूरी है अतिरिक्त एंट्री का शब्दकोश. |
dir
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(x=unbound)x को फ़्लोट वैल्यू के रूप में दिखाता है.
- अगर
xपहले से ही फ़्लोट है, तोfloatइसे बिना किसी बदलाव के दिखाता है. - अगर
xबूल है, तोfloatसही के लिए 1.0 और गलत के लिए 0.0 लौटाता है. - अगर
xकोई पूर्णांक है, तोfloatx पर सबसे पास की सीमित फ़्लोटिंग-पॉइंट वैल्यू दिखाता है या साइज़ बहुत बड़ा होने पर गड़बड़ी की जानकारी देता है. - अगर
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है दिए गए नाम का एट्रिब्यूट न होने पर, यह डिफ़ॉल्ट वैल्यू होती है. |
hasattr
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 के अलावा कोई अन्य वैल्यू है, तो प्रीफ़िक्स खाली होना चाहिए. जहांbase0 है, वहां स्ट्रिंग को एक इंटीजर लिटरल के तौर पर दिखाया जाता है. यहां यह माना जाता है कि किसी एक बेस 2/8/10/16 को इस आधार पर चुना जाता है कि अगर किसी प्रीफ़िक्स का इस्तेमाल किया गया है, तो किस आधार को चुना जाएगा. अगरbase0 है, तो किसी भी प्रीफ़िक्स का इस्तेमाल नहीं किया जाता और एक से ज़्यादा अंक हैं. ऐसे में, सबसे पहले आने वाला अंक 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, लिटरल वैल्यू हो. अगर वैल्यू कोई स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.
|
लेंस
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 < का इस्तेमाल करके नहीं की जा सकती, तो हो सकता है कि कोई गड़बड़ी हो वाई. एलिमेंट को बढ़ते क्रम में लगाया जाता है, जब तक कि रिवर्स तर्क सही न हो. इस मामले में, क्रम घटते क्रम में होता है. क्रम से लगाने की प्रोसेस एक जैसी होती है: एक जैसी तुलना करने वाले एलिमेंट में, वे अपने मूल रिलेटिव ऑर्डर में ही दिखते हैं.
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(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
|
ज़रूरी है ज़िप करने के लिए सूचियां. |