सभी Bazel फ़ाइलें

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

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

सदस्य

कुल

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)

बूल टाइप का कंस्ट्रक्टर. अगर ऑब्जेक्ट None, False, खाली स्ट्रिंग (""), संख्या 0 या खाली कलेक्शन (उदाहरण के लिए, (), []) है, तो यह False दिखाता है. अगर ऐसा नहीं है, तो यह True दिखाता है.

पैरामीटर

पैरामीटर ब्यौरा
x डिफ़ॉल्ट रूप से False
होता है वह वैरिएबल जिसे बदलना है.

डिक्शनरी

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 को int वैल्यू के रूप में दिखाता है.
  • अगर 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 के बीच होनी चाहिए. इसमें 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)

इस नीति से ऐसी सूची बनती है जिसमें आइटम को step की बढ़ोतरी का इस्तेमाल करके, start से stop पर ले जाया जाता है. अगर एक आर्ग्युमेंट दिया जाता है, तो आइटम की रेंज 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]

पैरामीटर

पैरामीटर ब्यौरा
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-वें ट्यूपल में, आर्ग्युमेंट के हर क्रम या आइटरेबल से 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 ज़िप करने के लिए
सूचियां ज़रूरी हैं.