अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है सभी बेज़ेल फ़ाइलों में तरीके उपलब्ध हैं. इनमें .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)
enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
list
|
ज़रूरी है इनपुट का क्रम. |
start
|
डिफ़ॉल्ट रूप से 0है शुरुआती इंडेक्स |
असफल
None fail(msg=None, attr=None, *args)पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
msg
|
डिफ़ॉल्ट रूप से Noneहै अब काम नहीं करता: इसके बजाय, पोज़िशनल आर्ग्युमेंट का इस्तेमाल करें. यह आर्ग्युमेंट, इंप्लिसिट लीडर पोज़िशनल आर्ग्युमेंट की तरह काम करता है. |
attr
|
string; या None;
डिफ़ॉल्ट रूप से Noneहै अब काम नहीं करता. इससे गड़बड़ी के मैसेज में इस स्ट्रिंग वाला एक वैकल्पिक प्रीफ़िक्स जुड़ जाता है. |
args
|
ज़रूरी है वैल्यू की सूची, जो डीबगप्रिंट (जो डिफ़ॉल्ट रूप से str के बराबर होती है) के साथ फ़ॉर्मैट की गई हो और जिसे गड़बड़ी के मैसेज में स्पेस के साथ जोड़ा गया हो. |
फ़्लोट
float float(x=unbound)
- अगर
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)
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सही के लिए 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(*args)
max(2, 5, 4) == 5 max([5, 6, 3]) == 6
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
args
|
ज़रूरी है वे एलिमेंट जिनकी जांच की जानी है. |
कम से कम
unknown min(*args)
min(2, 5, 4) == 2 min([5, 6, 3]) == 3
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
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)
sorted([3, 5, 4]) == [3, 4, 5]
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
iterable
|
ज़रूरी है क्रम से लगाने के लिए, बार-बार इस्तेमाल होने वाला क्रम. |
key
|
डिफ़ॉल्ट रूप से 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"
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
|
ज़रूरी है ज़िप करने के लिए सूचियां. |