सभी Bazel फ़ाइलों में उपलब्ध तरीके. इनमें .bzl फ़ाइलें, BUILD, MODULE.bazel, VENDOR.bazel, और WORKSPACE शामिल हैं.
सदस्य
- abs
- all
- any
- bool
- dict
- dir
- enumerate
- fail
- फ़्लोट
- getattr
- hasattr
- हैश
- int
- len
- list
- max
- मिनट
- range
- repr
- रिवर्स
- सेट करें
- क्रम में लगाए गए
- str
- ट्यूपल
- टाइप
- 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)अगर कम से कम एक एलिमेंट की वैल्यू True है, तो True दिखाता है. bool फ़ंक्शन का इस्तेमाल करके, एलिमेंट को बूलियन में बदला जाता है.
any([-1, 0, 1]) == True any([False, 0, ""]) == False
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
elements
|
ज़रूरी है एलिमेंट की स्ट्रिंग या कलेक्शन. |
बूल
bool bool(x=False)bool टाइप के लिए कंस्ट्रक्टर. अगर ऑब्जेक्ट
None, False, खाली स्ट्रिंग (""), संख्या 0 या खाली कलेक्शन (उदाहरण के लिए, (), []) है, तो यह False दिखाता है. अगर ऐसा नहीं है, तो यह True दिखाता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
डिफ़ॉल्ट रूप से Falseहोता है वह वैरिएबल जिसे बदलना है. |
dict
dict dict(pairs=[], **kwargs)वैकल्पिक पोज़िशनल आर्ग्युमेंट और कीवर्ड आर्ग्युमेंट के वैकल्पिक सेट से डिक्शनरी बनाता है. अगर एक ही कुंजी को कई बार दिया जाता है, तो आखिरी वैल्यू का इस्तेमाल किया जाएगा. कीवर्ड आर्ग्युमेंट की मदद से दी गई एंट्री, पोज़िशनल आर्ग्युमेंट की मदद से दी गई एंट्री के बाद आती हैं.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
pairs
|
डिफ़ॉल्ट []है कोई डिक्शनरी या ऐसा आइटरेबल जिसका हर एलिमेंट दो चीज़ों (की, वैल्यू) से बना हो. |
kwargs
|
ज़रूरी है अतिरिक्त एंट्री की डिक्शनरी. |
dir
list dir(x)स्ट्रिंग की सूची दिखाता है: पैरामीटर ऑब्जेक्ट के एट्रिब्यूट और तरीकों के नाम.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसकी जांच करनी है. |
enumerate
list enumerate(list, start=0)यह इनपुट क्रम से इंडेक्स (int) और आइटम के साथ, पेयर (दो एलिमेंट वाले ट्यूपल) की सूची दिखाता है.
enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
list
|
इनपुट क्रम ज़रूरी है. |
start
|
int;
डिफ़ॉल्ट तौर पर, 0का इस्तेमाल किया जाता है स्टार्ट इंडेक्स के तौर पर. |
फ़ेल
None fail(msg=None, attr=None, sep=" ", *args)पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
msg
|
डिफ़ॉल्ट Noneहै 'अब इस्तेमाल नहीं किया जा सकता': इसके बजाय, पोज़िशनल आर्ग्युमेंट का इस्तेमाल करें. यह आर्ग्युमेंट, पहले पोज़िशन के आर्ग्युमेंट की तरह काम करता है. |
attr
|
string या None;
डिफ़ॉल्ट Noneहै अब इस्तेमाल नहीं किया जा सकता. इसकी वजह से, गड़बड़ी के मैसेज में इस स्ट्रिंग वाला वैकल्पिक प्रीफ़िक्स जोड़ा जाता है. |
sep
|
string;
डिफ़ॉल्ट तौर पर " "ऑब्जेक्ट के बीच सेपरेटर स्ट्रिंग, डिफ़ॉल्ट रूप से स्पेस (" ") है. |
args
|
ज़रूरी है वैल्यू की सूची, जिसे debugPrint (यह डिफ़ॉल्ट रूप से str के बराबर होती है) के साथ फ़ॉर्मैट किया गया है और sep (डिफ़ॉल्ट रूप से " ") के साथ जोड़ा गया है. यह सूची, गड़बड़ी के मैसेज में दिखती है. |
फ़्लोट
float float(x=unbound)x को फ़्लोट वैल्यू के तौर पर दिखाता है.
- अगर
xपहले से ही फ़्लोट है, तोfloatउसे बिना किसी बदलाव के दिखाता है. - अगर
xएक बूल वैल्यू है, तोfloatसही के लिए 1.0 और गलत के लिए 0.0 दिखाता है. - अगर
xएक int है, तो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
|
string;
ज़रूरी है स्ट्रक्चर एट्रिब्यूट का नाम. |
default
|
डिफ़ॉल्ट तौर पर unboundका इस्तेमाल किया जाता है अगर स्ट्रक्चर में दिए गए नाम का कोई एट्रिब्यूट नहीं है, तो डिफ़ॉल्ट वैल्यू दिखाने के लिए इसका इस्तेमाल किया जाता है. |
hasattr
bool hasattr(x, name)अगर ऑब्जेक्ट
x में दिए गए name का एट्रिब्यूट या तरीका है, तो True दिखाता है. ऐसा न होने पर False दिखाता है. उदाहरण:hasattr(ctx.attr, "myattr")
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसकी जांच करनी है. |
name
|
string;
ज़रूरी है एट्रिब्यूट का नाम. |
हैश
int hash(value)किसी स्ट्रिंग के लिए हैश वैल्यू दिखाता है. इसका हिसाब, Java के
String.hashCode() के जैसे ही एल्गोरिदम का इस्तेमाल करके लगाया जाता है. जैसे: s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]फ़िलहाल, स्ट्रिंग के अलावा अन्य वैल्यू को हैश नहीं किया जा सकता.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
value
|
string;
ज़रूरी है हैश करने के लिए स्ट्रिंग वैल्यू. |
int
int int(x, base=unbound)x को पूर्णांक वैल्यू के तौर पर दिखाता है.
- अगर
xपहले से ही int है, तोintउसे बिना किसी बदलाव के दिखाता है. - अगर
xबूल है, तोintTrue के लिए 1 और False के लिए 0 दिखाता है. - अगर
xएक स्ट्रिंग है, तो इसका फ़ॉर्मैट<sign><prefix><digits>होना चाहिए.<sign>,"+","-"या खाली हो (जिसे पॉज़िटिव के तौर पर समझा जाता है).<digits>, 0 से लेकरbase- 1 तक के अंकों का क्रम होता है. इसमें 10 से 35 तक के अंकों के तौर पर, a से z (या A से Z) अक्षरों का इस्तेमाल किया जाता है. अगरbase2/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 के बीच होनी चाहिए. इसके अलावा, x को पूर्णांक के तौर पर इस्तेमाल करने के लिए, इसे 0 पर सेट किया जा सकता है. अगर वैल्यू स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.
|
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
|
iterable;
डिफ़ॉल्ट रूप से []होता है वह ऑब्जेक्ट जिसे बदलना है. |
अधिकतम
unknown max(key=None, *args)दिए गए सभी आर्ग्युमेंट में से सबसे बड़ी वैल्यू दिखाता है. अगर सिर्फ़ एक पोज़िशनल आर्ग्युमेंट दिया गया है, तो यह खाली नहीं होना चाहिए.अगर एलिमेंट की तुलना नहीं की जा सकती (उदाहरण के लिए, स्ट्रिंग के साथ int) या कोई आर्ग्युमेंट नहीं दिया गया है, तो यह गड़बड़ी है.
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
|
callable; या None;
डिफ़ॉल्ट Noneतुलना करने से पहले, हर एलिमेंट पर लागू किया जाने वाला वैकल्पिक फ़ंक्शन. |
args
|
ज़रूरी है वे एलिमेंट जिनकी जांच करनी है. |
कम से कम
unknown min(key=None, *args)दिए गए सभी आर्ग्युमेंट में से सबसे छोटी वैल्यू दिखाता है. अगर सिर्फ़ एक पोज़िशनल आर्ग्युमेंट दिया गया है, तो यह एक ऐसा आर्ग्युमेंट होना चाहिए जिसे बार-बार इस्तेमाल किया जा सकता हो. अगर एलिमेंट की तुलना नहीं की जा सकती (उदाहरण के लिए, स्ट्रिंग के साथ int) या कोई आर्ग्युमेंट नहीं दिया गया है, तो यह गड़बड़ी है.
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
|
callable; या None;
डिफ़ॉल्ट Noneतुलना करने से पहले, हर एलिमेंट पर लागू किया जाने वाला वैकल्पिक फ़ंक्शन. |
args
|
ज़रूरी है वे एलिमेंट जिनकी जांच करनी है. |
प्रिंट करें
None print(sep=" ", *args)args को डीबग आउटपुट के तौर पर प्रिंट करता है. इसकी शुरुआत में स्ट्रिंग "DEBUG" और इस कॉल की जगह (फ़ाइल और लाइन नंबर) होगी. आर्ग्युमेंट को स्ट्रिंग में बदलने का सटीक तरीका तय नहीं है और इसे कभी भी बदला जा सकता है. खास तौर पर, यह str() और repr() से किए गए फ़ॉर्मैट से अलग हो सकता है. साथ ही, इसमें ज़्यादा जानकारी हो सकती है.प्रोडक्शन कोड में print का इस्तेमाल करने का सुझाव नहीं दिया जाता, क्योंकि इससे उपयोगकर्ताओं के लिए स्पैम जनरेट होता है. बंद किए गए एलिमेंट के लिए, जब भी हो सके fail() का इस्तेमाल करके, गंभीर गड़बड़ी दिखाएं.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sep
|
string;
डिफ़ॉल्ट तौर पर " "ऑब्जेक्ट के बीच सेपरेटर स्ट्रिंग, डिफ़ॉल्ट रूप से स्पेस (" ") है. |
args
|
ज़रूरी है प्रिंट करने के लिए ऑब्जेक्ट. |
सीमा
sequence range(start_or_stop, stop_or_none=None, step=1)यह एक ऐसी सूची बनाता है जिसमें आइटम
start से stop तक जाते हैं. इसके लिए, step की बढ़ोतरी का इस्तेमाल किया जाता है. अगर एक आर्ग्युमेंट दिया जाता है, तो आइटम की रेंज 0 से उस एलिमेंट तक होगी.range(4) == [0, 1, 2, 3] range(3, 9, 2) == [3, 5, 7] range(3, 0, -1) == [3, 2, 1]
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
start_or_stop
|
int;
ज़रूरी है 'स्टॉप' एट्रिब्यूट की वैल्यू दी गई होने पर, 'शुरू करें' एलिमेंट की वैल्यू. अगर 'स्टॉप' एट्रिब्यूट की वैल्यू नहीं दी गई है, तो 'स्टॉप' एलिमेंट की वैल्यू और असल 'शुरू करें' एलिमेंट की वैल्यू 0 होगी |
stop_or_none
|
int या None;
डिफ़ॉल्ट तौर पर Noneपहले आइटम का वैकल्पिक इंडेक्स, जिसे नतीजों की सूची में शामिल नहीं किया जाना है; stop तक पहुंचने से पहले सूची जनरेट होना बंद हो जाता है.
|
step
|
int;
डिफ़ॉल्ट 1है इंक्रीमेंट (डिफ़ॉल्ट 1 है). यह नेगेटिव हो सकता है. |
repr
string repr(x)किसी भी ऑब्जेक्ट को स्ट्रिंग में बदलता है. यह डीबग करने के लिए काम का है.
repr("ab") == '"ab"'
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसे बदलना है. |
रद्द कर दिया गया
list reversed(sequence)यह फ़ंक्शन एक नई और अनफ़्रीज़ की गई सूची दिखाता है. इसमें, ओरिजनल क्रम में मौजूद एलिमेंट को उलटे क्रम में दिखाया जाता है.
reversed([3, 5, 4]) == [4, 5, 3]
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
sequence
|
iterable;
ज़रूरी है यह एक ऐसा क्रम है जिसे उलटा करना है, जैसे कि सूची. |
सेट करो
set set(elements=[])एक्सपेरिमेंटल. यह एपीआई, एक्सपेरिमेंट के तौर पर उपलब्ध है. इसमें कभी भी बदलाव किया जा सकता है. कृपया इस पर भरोसा न करें.
--experimental_enable_starlark_set सेट करके, इसे एक्सपेरिमेंट के तौर पर चालू किया जा सकता है.
एक नया सेट बनाता है. इसके लिए, किसी दिए गए आइटम से एलिमेंट शामिल करने के लिए, इसे शुरू किया जा सकता है.
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
elements
|
डिफ़ॉल्ट तौर पर, []सेट, क्रम या डिक्शनरी. |
क्रम से लगाए गए
list sorted(iterable, key=None, *, reverse=False)यह फ़ंक्शन, क्रम से लगाई गई एक नई सूची दिखाता है. इसमें, दिए गए क्रम में लगाए जा सकने वाले क्रम के सभी एलिमेंट शामिल होते हैं. अगर x, y एलिमेंट के किसी जोड़े की तुलना x < y का इस्तेमाल करके नहीं की जा सकती, तो गड़बड़ी हो सकती है. एलिमेंट को बढ़ते क्रम में लगाया जाता है. हालांकि, अगर reverse आर्ग्युमेंट True है, तो एलिमेंट को घटते क्रम में लगाया जाता है. क्रम में बदलाव नहीं होता: जिन एलिमेंट की तुलना एक जैसी होती है वे अपने मूल क्रम में बने रहते हैं.
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
|
iterable;
ज़रूरी है जिस क्रम को क्रम से लगाना है. |
key
|
callable; या None;
डिफ़ॉल्ट Noneतुलना करने से पहले, हर एलिमेंट पर लागू किया जाने वाला वैकल्पिक फ़ंक्शन. |
reverse
|
bool;
डिफ़ॉल्ट रूप से 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
|
iterable;
डिफ़ॉल्ट रूप से ()होता है वह ऑब्जेक्ट जिसे बदलना है. |
टाइप
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-वें ट्यूपल में, आर्ग्युमेंट के हर क्रम या आइटरेबल से i-वां एलिमेंट होता है. सूची का साइज़, सबसे छोटे इनपुट के साइज़ के बराबर होता है. एक बार में कई बार इस्तेमाल किए जा सकने वाले एक आर्ग्युमेंट के साथ, यह एक-ट्यूपल की सूची दिखाता है. बिना किसी आर्ग्युमेंट के, यह फ़ंक्शन एक खाली सूची दिखाता है. उदाहरण: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
|
ज़रूरी सूचियों को ज़िप करना. |