सभी बेज़ल फ़ाइलों के लिए तरीके उपलब्ध हैं. इनमें .bzl फ़ाइलें, BUILD, MODULE.baकोई, seller.batz, और वर्कस्पेस शामिल हैं.
सदस्य
- abs
- all
- any
- bool
- dict
- dir
- सूची में शामिल करें
- 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)
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
|
डिफ़ॉल्ट [] है कोई डिक्शनरी या ऐसा आइटरेबल जिसका हर एलिमेंट दो चीज़ों (की, वैल्यू) से बना हो. |
kwargs
|
ज़रूरी है अतिरिक्त एंट्री की डिक्शनरी. |
dir
list dir(x)
पैरामीटर
पैरामीटर | ब्यौरा |
---|---|
x
|
ज़रूरी है वह ऑब्जेक्ट जिसकी जांच करनी है. |
enumerate
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 है, तोint
उसे बिना किसी बदलाव के दिखाता है. - अगर
x
एक बूल वैल्यू है, तोint
True के लिए 1 और False के लिए 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 के बीच होनी चाहिए. इसके अलावा, x को पूर्णांक के तौर पर इस्तेमाल करने के लिए, यह वैल्यू 0 होनी चाहिए. अगर वैल्यू स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.
|
लेंस
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
|
callable; या 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
|
callable; या 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
|
callable; या 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
|
ज़रूरी वह ऑब्जेक्ट जिसका टाइप जांचना है. |
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
|
ज़रूरी सूचियों को ज़िप करना. |