सभी Bazel फ़ाइलें

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

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

सदस्य

• abs
• all
• any
• bool
• dict
• dir
• enumerate
• fail
• फ़्लोट
• getattr
• hasattr
• हैश
• int
• len
• list
• max
• मिनट
• print
• 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	डिफ़ॉल्ट तौर पर, 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 को फ़्लोट वैल्यू के तौर पर दिखाता है.

• अगर 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 True के लिए 1 और False के लिए 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 के बीच होनी चाहिए. इसके अलावा, 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)

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

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

आने वाले समय में, इस फ़ंक्शन में बदलाव हो सकता है. 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	ज़रूरी सूचियों को ज़िप करना.