सभी Bazel फ़ाइलें

किसी समस्या की शिकायत करें Nightly · 7.4 . 7.3 · 7.2 · 7.1 · 7.0 · 6.5

ये तरीके, .bzl फ़ाइलों, BUILD, MODULE.bazel, और WORKSPACE के साथ-साथ सभी Bazel फ़ाइलों में उपलब्ध हैं.

सदस्य

abs

unknown abs(x)

किसी संख्या की ऐब्सोलूट वैल्यू दिखाता है. यह वैल्यू, उस संख्या के बराबर होती है और शून्य से कम नहीं होती.
abs(-2.3) == 2.3

पैरामीटर

पैरामीटर ब्यौरा
x int; या float; ज़रूरी है
संख्या (इंटी या फ़्लोट)

सभी

bool all(elements)

अगर सभी एलिमेंट 'सही' के तौर पर रेट करते हैं या कलेक्शन खाली है, तो 'सही' दिखाता है. bool फ़ंक्शन का इस्तेमाल करके एलिमेंट को बूलियन में बदला जाता है.
all(["hello", 3, True]) == True
all([-1, 0, 1]) == False

पैरामीटर

पैरामीटर ब्यौरा
elements ज़रूरी है
स्ट्रिंग या एलिमेंट का कलेक्शन.

कोई

bool any(elements)

अगर कम से कम एक एलिमेंट का आकलन 'सही' के तौर पर होता है, तो 'सही' दिखाता है. 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 डिफ़ॉल्ट रूप से 0
है शुरुआती इंडेक्स

असफल

None fail(msg=None, attr=None, *args)

इसकी वजह से, गड़बड़ी के साथ फ़ंक्शन लागू नहीं हो पाता.

पैरामीटर

पैरामीटर ब्यौरा
msg डिफ़ॉल्ट रूप से None
है अब काम नहीं करता: इसके बजाय, पोज़िशनल आर्ग्युमेंट का इस्तेमाल करें. यह आर्ग्युमेंट, इंप्लिसिट लीडर पोज़िशनल आर्ग्युमेंट की तरह काम करता है.
attr string; या None; डिफ़ॉल्ट रूप से None
है अब काम नहीं करता. इससे गड़बड़ी के मैसेज में इस स्ट्रिंग वाला एक वैकल्पिक प्रीफ़िक्स जुड़ जाता है.
args ज़रूरी है
वैल्यू की सूची, जिसे debugPrint (यह डिफ़ॉल्ट रूप से str के बराबर होती है) के साथ फ़ॉर्मैट किया गया है और स्पेस के साथ जोड़ा गया है. यह सूची, गड़बड़ी के मैसेज में दिखती है.

फ़्लोट

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 ज़रूरी है
स्ट्रक्चर एट्रिब्यूट का नाम.
default डिफ़ॉल्ट तौर पर unbound
का इस्तेमाल किया जाता है अगर स्ट्रक्चर में दिए गए नाम का कोई एट्रिब्यूट नहीं है, तो डिफ़ॉल्ट वैल्यू दिखाने के लिए इसका इस्तेमाल किया जाता है.

hasattr

bool hasattr(x, name)

अगर ऑब्जेक्ट x में दिए गए name का एट्रिब्यूट या तरीका है, तो True दिखाता है. ऐसा न होने पर False दिखाता है. उदाहरण:
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 को पूर्णांक वैल्यू के तौर पर दिखाता है.
  • अगर x पहले से ही int है, तो int उसे बिना किसी बदलाव के दिखाता है.
  • अगर x बूल है, तो int सही के लिए 1 और गलत के लिए 0 लौटाता है.
  • अगर x एक स्ट्रिंग है, तो उसका फ़ॉर्मैट <sign><prefix><digits> होना चाहिए. <sign> या तो "+" है, "-" है या खाली है (जिसे पॉज़िटिव बताया गया है). <digits>, 0 से लेकर base - 1 तक के अंकों का क्रम होता है. इसमें 10 से 35 तक के अंकों के तौर पर, a से z (या A से Z) अक्षरों का इस्तेमाल किया जाता है. अगर 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 के बीच होनी चाहिए. इसमें 0 भी हो सकती है. ऐसा तब होता है, जब x, लिटरल वैल्यू हो. अगर वैल्यू स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.

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(*args)

दिए गए सभी आर्ग्युमेंट में से सबसे बड़ी वैल्यू दिखाता है. अगर सिर्फ़ एक तर्क दिया गया है, तो वह ऐसा होना चाहिए जिसे बार-बार दोहराया जा सके.यह एक गड़बड़ी होती है, जब एलिमेंट की तुलना नहीं की जा सकती (उदाहरण के लिए, स्ट्रिंग के साथ पूर्णांक) या अगर कोई तर्क नहीं दिया जाता है. 
max(2, 5, 4) == 5
max([5, 6, 3]) == 6

पैरामीटर

पैरामीटर ब्यौरा
args ज़रूरी है
वे एलिमेंट जिनकी जांच करनी है.

कम से कम

unknown min(*args)

दिए गए सभी आर्ग्युमेंट में से सबसे छोटी वैल्यू दिखाता है. अगर सिर्फ़ एक आर्ग्युमेंट दिया जाता है, तो यह एक ऐसा आर्ग्युमेंट होना चाहिए जिसे बार-बार इस्तेमाल किया जा सके. अगर एलिमेंट की तुलना नहीं की जा सकती (उदाहरण के लिए, स्ट्रिंग के साथ int) या कोई आर्ग्युमेंट नहीं दिया गया है, तो यह गड़बड़ी है. 
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)

यह एक ऐसी सूची बनाता है जिसमें आइटम 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
है बढ़ोतरी (डिफ़ॉल्ट रूप से यह संख्या एक होती है). यह नेगेटिव हो सकता है.

आरईपीआर

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]

पैरामीटर

पैरामीटर ब्यौरा
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"
आने वाले समय में, इस फ़ंक्शन में बदलाव हो सकता है. Python के साथ काम करने वाला कोड लिखने और आने वाले समय में भी उसे इस्तेमाल करने के लिए, इसका इस्तेमाल सिर्फ़ रिटर्न वैल्यू की तुलना करने के लिए करें: 
if type(x) == type([]):  # if x is a list

पैरामीटर

पैरामीटर ब्यौरा
x ज़रूरी
वह ऑब्जेक्ट जिसका टाइप जांचना है.

zip

list zip(*args)

tuple का list दिखाता है, जहां i-th ट्यूपल में हर तर्क क्रम या बार-बार लागू होने वाले क्रम से i-th एलिमेंट शामिल होता है. सूची का साइज़, सबसे छोटे इनपुट के साइज़ के बराबर होता है. एक बार में कई बार इस्तेमाल किए जा सकने वाले एक आर्ग्युमेंट के साथ, यह एक-ट्यूपल की सूची दिखाता है. बिना किसी आर्ग्युमेंट के, यह फ़ंक्शन एक खाली सूची दिखाता है. उदाहरण:
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 ज़रूरी
सूचियों को ज़िप करना.