सभी Bazel फ़ाइलें

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

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

सदस्य

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 डिफ़ॉल्ट है []
यह एक डिक्शनरी या बार-बार इस्तेमाल किया जा सकने वाला एलिमेंट है, जिसके हर एलिमेंट की लंबाई 2 (कुंजी, वैल्यू) होनी चाहिए.
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 ज़रूरी है
उन वैल्यू की सूची जिन्हें डीबगप्रिंट (जो डिफ़ॉल्ट रूप से 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 को int वैल्यू के रूप में दिखाता है.
  • अगर x पहले से ही एक पूर्णांक है, तो 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 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)

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

क्रम से लगाए गए

list sorted(iterable, key=None, *, reverse=False)

दी गई, क्रम से लगाई गई नई सूची दिखाता है जिसमें दिए गए बार-बार दिए जा सकने वाले क्रम के सभी एलिमेंट शामिल होते हैं. अगर एलिमेंट x और y के किसी भी जोड़े की तुलना x < y का इस्तेमाल करके नहीं की जा सकती, तो गड़बड़ी हो सकती है. एलिमेंट को बढ़ते क्रम में लगाया जाता है, जब तक कि रिवर्स तर्क सही न हो. इस मामले में, क्रम घटते क्रम में होता है. क्रम में बदलाव नहीं होता: जिन एलिमेंट की तुलना एक जैसी होती है वे अपने मूल क्रम में बने रहते हैं. 
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 ज़रूरी
सूचियों को ज़िप करना.