ये तरीके, Bazel की सभी फ़ाइलों में उपलब्ध होते हैं. इनमें .bzl फ़ाइलें, BUILD, MODULE.bazel, VENDOR.bazel, और WORKSPACE शामिल हैं.
सदस्य
- abs
- all
- any
- bool
- dict
- dir
- enumerate
- fail
- फ़्लोट
- getattr
- hasattr
- hash
- int
- len
- list
- max
- min
- रेंज
- repr
- रिफ़ंड किया गया
- sorted
- str
- टपल
- type
- zip
एबीएस
unknown abs(x)
abs(-2.3) == 2.3
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
int; या float;
required कोई संख्या (int या फ़्लोट) |
सभी
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 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, sep=" ", *args)पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
msg
|
डिफ़ॉल्ट वैल्यू Noneहै इस्तेमाल बंद कर दिया गया है: इसके बजाय, पोज़ीशनल आर्ग्युमेंट का इस्तेमाल करें. यह आर्ग्युमेंट, लीडिंग पोज़ीशनल आर्ग्युमेंट की तरह काम करता है. |
attr
|
string; या None;
डिफ़ॉल्ट रूप से Noneहोता है अब इस्तेमाल नहीं किया जा सकता. इस स्ट्रिंग को गड़बड़ी के मैसेज में जोड़ने के लिए, एक वैकल्पिक प्रीफ़िक्स बनाता है. |
sep
|
डिफ़ॉल्ट वैल्यू " "है ऑब्जेक्ट के बीच सेपरेटर स्ट्रिंग. डिफ़ॉल्ट वैल्यू स्पेस (" ") है. |
args
|
ज़रूरी है वैल्यू की एक सूची. इसे debugPrint (जो डिफ़ॉल्ट रूप से str के बराबर होता है) का इस्तेमाल करके फ़ॉर्मैट किया जाता है. साथ ही, इसे sep (डिफ़ॉल्ट रूप से " " होता है) का इस्तेमाल करके जोड़ा जाता है. ये वैल्यू, गड़बड़ी के मैसेज में दिखती हैं. |
फ़्लोट
float float(x=unbound)
- अगर
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अगर स्ट्रक्चर में दिए गए नाम का एट्रिब्यूट मौजूद नहीं है, तो डिफ़ॉल्ट वैल्यू दिखाई जाएगी. |
hasattr
bool hasattr(x, name)
x में, दिए गए name का कोई एट्रिब्यूट या तरीका मौजूद है, तो यह फ़ंक्शन True दिखाता है. अगर ऐसा नहीं है, तो False दिखाता है. उदाहरण: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 के अलावा कोई और वैल्यू है, तो प्रीफ़िक्स खाली होना चाहिए. अगर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
|
default 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
|
डिफ़ॉल्ट वैल्यू []है यह वह ऑब्जेक्ट है जिसे बदलना है. |
अधिकतम
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)
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
|
ज़रूरी है अगर स्टॉप की जानकारी दी गई है, तो स्टार्ट एलिमेंट की वैल्यू. अगर स्टॉप की जानकारी नहीं दी गई है, तो स्टॉप की वैल्यू और असल स्टार्ट की वैल्यू 0 होती है |
stop_or_none
|
int; या None;
डिफ़ॉल्ट रूप से Noneहोता है यह पहली ऐसी आइटम का इंडेक्स होता है जिसे नतीजे के तौर पर मिली सूची में शामिल नहीं किया जाना चाहिए. सूची जनरेट करने की प्रोसेस, stop तक पहुंचने से पहले ही रुक जाती है.
|
step
|
डिफ़ॉल्ट वैल्यू 1है इंक्रीमेंट (डिफ़ॉल्ट वैल्यू 1 है). यह नेगेटिव हो सकता है. |
repr
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] 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"
if type(x) == type([]): # if x is a list
पैरामीटर
| पैरामीटर | ब्यौरा |
|---|---|
x
|
required वह ऑब्जेक्ट जिसका टाइप जांचना है. |
zip
list zip(*args)
tuples का 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
|
ज़रूरी है ज़िप करने के लिए सूचियां. |