सभी Bazel फ़ाइलें

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है किसी समस्या की शिकायत करें रात · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है सभी Baze फ़ाइलों के लिए उपलब्ध तरीके. इनमें .bzl फ़ाइलें, BUILD, MODULE.baकोई, seller.baज़ेन, और WorkSPACE शामिल हैं.

सदस्य

कुल

unknown abs(x)

किसी संख्या की ऐब्सलूट वैल्यू दिखाता है (एक ही मैग्निट्यूड वाली नॉन-नेगेटिव नंबर).
abs(-2.3) == 2.3

पैरामीटर

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

dir

list dir(x)

स्ट्रिंग की सूची दिखाता है: इसमें पैरामीटर ऑब्जेक्ट के एट्रिब्यूट और तरीकों के नाम होते हैं.

पैरामीटर

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

गिनती करें

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 ज़रूरी है
उन वैल्यू की सूची, जो डीबगप्रिंट (जो डिफ़ॉल्ट रूप से str के बराबर है) के साथ फ़ॉर्मैट की गई है और sep (डिफ़ॉल्ट रूप से " " पर सेट होती है) के साथ जुड़ी हुई है. यह गड़बड़ी के मैसेज में दिखती है.

फ़्लोट

float float(x=unbound)

x को फ़्लोट वैल्यू के रूप में दिखाता है.
  • अगर 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 का एट्रिब्यूट या तरीका है, तो 'सही' दिखाता है. ऐसा नहीं होने पर 'गलत' दिखाता है. उदाहरण:
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 इसे बिना किसी बदलाव के दिखाता है.
  • अगर x बूल है, तो int सही के लिए 1 और गलत के लिए 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 के बीच होनी चाहिए. इसमें 0 भी हो सकती है. ऐसा तब होता है, जब x, लिटरल वैल्यू हो. अगर वैल्यू कोई स्ट्रिंग नहीं है, तो यह पैरामीटर नहीं दिया जाना चाहिए.

लेंस

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 कॉल करने लायक; या 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 कॉल करने लायक; या 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)

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

आरईपीआर

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]
sorted([3, 5, 4], reverse = True) == [5, 4, 3]
sorted(["two", "three", "four"], key = len) == ["two", "four", "three"]  # sort by length

पैरामीटर

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