Positional Arguments vs Keyword Arguments in Python Notes in Hindi & English : पोजिशनल आर्गुमेंट्स बनाम कीवर्ड आर्गुमेंट्स में अंतर और 20 महत्वपूर्ण MCQ प्रश्न (Rajasthan IT Exam)

Post a Comment

PGDCA, BCA, B-Tech, MCA, M-Tech, B.Sc computer science राजस्थान सूचना सहायक व कंप्यूटर शिक्षक विशेष नोट्स: इस अध्याय में हम Positional Arguments vs Keyword Arguments in Python (पोजिशनल आर्गुमेंट्स बनाम कीवर्ड आर्गुमेंट्स में अंतर) की संपूर्ण थ्योरी, मुख्य तकनीकी बिंदु, तुलनात्मक तालिका और विगत परीक्षाओं के पैटर्न पर आधारित 20 अति-महत्वपूर्ण बहुविकल्पीय प्रश्न (MCQs) विस्तृत हिंदी व अंग्रेजी व्याख्या सहित पढ़ेंगे।

Overview: Python binds arguments to function parameters either positionally by left-to-right order or by explicit parameter name as keyword arguments. At the call site, positional arguments must always precede keyword arguments, while definitions can enforce positional-only (/) and keyword-only (*) boundaries.

अध्याय सार: पायथन में फंक्शन आर्गुमेंट्स या तो बाएँ-से-दाएँ क्रम (पोजिशनल) से या स्पष्ट पैरामीटर नाम (कीवर्ड) द्वारा पैरामीटर्स से जुड़ते हैं। कॉल करते समय पोजिशनल आर्गुमेंट्स हमेशा कीवर्ड आर्गुमेंट्स से पहले आने चाहिए, जबकि परिभाषा में / (पोजिशनल-ओनली) और * (कीवर्ड-ओनली) सीमाएँ तय की जा सकती हैं।

Positional Arguments vs Keyword Arguments in Python: Detailed Notes & Architecture (पोजिशनल आर्गुमेंट्स बनाम कीवर्ड आर्गुमेंट्स में अंतर)

1. Positional Binding vs Keyword Binding (पोजिशनल बाइंडिंग बनाम कीवर्ड बाइंडिंग)

[EN] Positional arguments match parameters strictly according to their sequence position in the function header, making concise calls like pow(2, 5) natural when parameter order is obvious. Keyword arguments specify param_name=value explicitly at the call site, letting callers pass arguments in any order and clarifying boolean or configuration flags such as sorted(nums, reverse=True). When mixing both styles in one call, all positional arguments must come before any keyword argument; placing a positional argument after a keyword argument triggers SyntaxError. Supplying a value for the same parameter both positionally and by keyword raises TypeError: got multiple values for argument.

[HI] पोजिशनल आर्गुमेंट्स फंक्शन हेडर में लिखे क्रम के अनुसार जुड़ते हैं, जो pow(2, 5) जैसे सरल कॉल में उपयोगी होता है जहाँ क्रम स्पष्ट हो। कीवर्ड आर्गुमेंट्स कॉल के समय param_name=value के रूप में दिए जाते हैं, जिससे किसी भी क्रम में मान भेजना संभव होता है और sorted(nums, reverse=True) जैसे फ्लैग अधिक पठनीय बनते हैं। दोनों को एक साथ उपयोग करते समय सभी पोजिशनल आर्गुमेंट्स कीवर्ड आर्गुमेंट्स से पहले होने चाहिए; कीवर्ड के बाद पोजिशनल लिखने पर SyntaxError आता है। एक ही पैरामीटर के लिए पोजिशनल और कीवर्ड दोनों से मान भेजने पर TypeError आता है।

2. Positional-Only Parameters (/) Since Python 3.8 (पोजिशनल-ओनली पैरामीटर्स (/) — पायथन 3.8 से)

[EN] Introduced in PEP 570 (Python 3.8), a forward slash / in a function definition marks every parameter appearing before it as positional-only. Callers cannot pass positional-only parameters by name—attempting to do so raises TypeError: got some positional-only arguments passed as keyword arguments. This feature lets library authors rename internal parameters without breaking caller code and mirrors C-implemented built-ins like len(obj, /) and divmod(x, y, /). It also frees parameter names so **kwargs can safely accept arbitrary user keys that happen to match an internal positional-only parameter name.

[HI] पायथन 3.8 (PEP 570) में जोड़ा गया फॉरवर्ड स्लैश (/) अपने से पहले के सभी पैरामीटर्स को पोजिशनल-ओनली घोषित करता है। कॉलर इन पैरामीटर्स को कीवर्ड नाम से नहीं भेज सकता; ऐसा करने पर TypeError उत्पन्न होता है। इससे लाइब्रेरी लेखक पुराने कॉलर कोड को तोड़े बिना पैरामीटर का नाम बदल सकते हैं और len(obj, /) व divmod(x, y, /) जैसे C-बिल्टइन्स जैसा व्यवहार बना सकते हैं। साथ ही, यदि कोई पोजिशनल-ओनली पैरामीटर नाम **kwargs में भी आ जाए तो नाम टकराव (collision) नहीं होता।

3. Keyword-Only Parameters (*) Since Python 3.0 (कीवर्ड-ओनली पैरामीटर्स (*) — पायथन 3.0 से)

[EN] Introduced in PEP 3102 (Python 3.0), placing a bare asterisk * (or *args) in a function signature makes all subsequent parameters keyword-only. Callers must supply keyword-only parameters explicitly by name (unless they have default values and are omitted); passing them positionally raises TypeError. Standard library functions such as sorted(iterable, /, *, key=None, reverse=False) and print(*objects, sep=' ', end='\n') rely on keyword-only options to prevent ambiguous positional calls. When combining both markers, / must always appear before * in the signature order: def f(pos_only, /, standard, *, kw_only):.

[HI] पायथन 3.0 (PEP 3102) में परिभाषा के भीतर अकेला तारांकन * (या *args) रखने से उसके बाद आने वाले सभी पैरामीटर्स कीवर्ड-ओनली बन जाते हैं। इन्हें कॉल करते समय नाम से ही भेजना अनिवार्य होता है (जब तक कि उनका डिफ़ॉल्ट मान न हो); पोजिशनल रूप से भेजने पर TypeError आता है। स्टैंडर्ड लाइब्रेरी के sorted(iterable, /, *, key=None, reverse=False) और print(..., sep=' ', end='...') इसी नियम का उपयोग करके भ्रम रोकते हैं। एक ही फंक्शन में दोनों का उपयोग करते समय / हमेशा * से पहले लिखा जाता है: def f(pos_only, /, standard, *, kw_only):।

4. Call-Site Unpacking and Common Argument Exceptions (कॉल-साइट अनपैकिंग और सामान्य आर्गुमेंट त्रुटियाँ)

[EN] At the call site, prefixing an iterable with * unpacks its elements as positional arguments, while prefixing a dict with ** unpacks key-value pairs as keyword arguments. The order rule still applies: *iterable unpackings cannot follow keyword arguments unless another * unpacking follows valid positional slots, and any positional literal after a keyword argument fails with SyntaxError. Common runtime mismatches raise TypeError: missing required arguments, too many positional arguments, or unexpected keyword argument names. Understanding the distinction between compile-time SyntaxError (wrong call order) and runtime TypeError (wrong parameter count or binding) is vital for Python exams.

[HI] फंक्शन कॉल करते समय *iterable उसके तत्वों को पोजिशनल आर्गुमेंट्स में और **dict अपनी की-वैल्यू जोड़ियों को कीवर्ड आर्गुमेंट्स में अनपैक कर देता है। कॉल-साइट क्रम नियम यहाँ भी लागू होता है: किसी कीवर्ड आर्गुमेंट के बाद सामान्य पोजिशनल लिटरल लिखने पर SyntaxError आता है। आवश्यक आर्गुमेंट छूटने, अतिरिक्त पोजिशनल मान देने या अज्ञात कीवर्ड नाम भेजने पर रनटाइम पर TypeError उत्पन्न होता है। परीक्षा के लिए कंपाइल-टाइम SyntaxError (गलत क्रम) और रनटाइम TypeError (गलत संख्या या बाइंडिंग) के बीच का अंतर जानना अत्यंत महत्वपूर्ण है।

Syntax, Formula & Technical Example (Positional Arguments vs Keyword Arguments in Python)

def connect(host, /, port=5432, *, tls=True):
    return f"{host}:{port} tls={tls}"

print(connect("db.local", 3306, tls=False))
print(connect("db.local", port=8080))
# connect(host="db.local") -> TypeError (positional-only)
# connect("db.local", 5432, False) -> TypeError (keyword-only)
# Output:
# db.local:3306 tls=False
# db.local:8080 tls=True

Positional Arguments vs Keyword Arguments in Python Quick Reference & Comparison Table

Parameter Marker / FormHow Caller Must Pass ItError on Violation
Before / (Positional-Only)Strictly by position; no name allowedTypeError: passed as keyword
Between / and * (Standard)Either positionally or by keywordTypeError if duplicated both ways
After * or *args (Keyword-Only)Strictly by parameter name (key=val)TypeError: takes fewer positional args
Positional after keyword in callInvalid call syntax: f(a=1, 2)SyntaxError at parse/compile time

Positional Arguments vs Keyword Arguments in Python Top 20 Bilingual MCQs with Answers

Q1. What happens when calling `def f(a, b): return a + b` as `f(a=1, 2)`?

(`def f(a, b): return a + b` को `f(a=1, 2)` के रूप में कॉल करने पर क्या होता है?)

(A) SyntaxError: positional argument follows keyword argument

(B) TypeError

(C) Returns 3

(D) ValueError

Correct Answer: (A)

[EN] Python grammar forbids placing a positional argument (2) after a keyword argument (a=1) at the call site.

[HI] पायथन व्याकरण के अनुसार फंक्शन कॉल में कीवर्ड आर्गुमेंट (a=1) के बाद पोजिशनल आर्गुमेंट (2) लिखने पर SyntaxError आता है।

Q2. What error occurs when executing `def f(a, b): return a - b` followed by `f(5, a=10)`?

(`def f(a, b): return a - b` के बाद `f(5, a=10)` चलाने पर कौन-सी त्रुटि आती है?)

(A) Returns -5

(B) TypeError: f() got multiple values for argument 'a'

(C) UnboundLocalError

(D) SyntaxError

Correct Answer: (B)

[EN] 5 binds to parameter a positionally, and a=10 attempts to bind a second value to a, raising TypeError.

[HI] 5 पहले ही पोजिशनल रूप से a से जुड़ चुका है और a=10 दोबारा मान देता है, जिससे TypeError उत्पन्न होता है।

Q3. In `def calc(x, y, /, z):`, which parameter(s) are positional-only?

(`def calc(x, y, /, z):` में कौन-सा/से पैरामीटर पोजिशनल-ओनली हैं?)

(A) z only

(B) x and y

(C) x, y, and z

(D) y only

Correct Answer: (B)

[EN] All parameters appearing to the left of the `/` marker are strictly positional-only.

[HI] `/` चिह्न के बाईं ओर आने वाले सभी पैरामीटर (x और y) पोजिशनल-ओनली होते हैं।

Q4. In `def log(msg, *, level='INFO'):`, how must `level` be passed if specified by the caller?

(`def log(msg, *, level='INFO'):` में यदि कॉलर `level` का मान देना चाहे तो उसे कैसे भेजना होगा?)

(A) Inside a tuple only

(B) As a keyword argument (`level='WARN'`)

(C) As a positional argument (`log('hi', 'WARN')`)

(D) It cannot be overridden

Correct Answer: (B)

[EN] Any parameter after a bare `*` is keyword-only and cannot be passed positionally.

[HI] अकेले `*` के बाद आने वाला कोई भी पैरामीटर कीवर्ड-ओनली होता है और उसे नाम से ही भेजना पड़ता है।

Q5. Which Python version introduced the positional-only parameter syntax `/` (PEP 570)?

(किस पायथन संस्करण में पोजिशनल-ओनली पैरामीटर सिंटैक्स `/` (PEP 570) जोड़ा गया?)

(A) Python 3.5

(B) Python 3.8

(C) Python 3.10

(D) Python 3.0

Correct Answer: (B)

[EN] PEP 570 added `/` for positional-only parameters in Python 3.8, while `*` keyword-only dates back to Python 3.0.

[HI] PEP 570 द्वारा पायथन 3.8 में `/` जोड़ा गया, जबकि `*` कीवर्ड-ओनली सुविधा पायथन 3.0 से मौजूद थी।

Q6. What does this print? def sub(a, b): return a - b print(sub(b=3, a=10))

(निम्न कोड क्या प्रिंट करेगा? def sub(a, b): return a - b print(sub(b=3, a=10)))

(A) -7

(B) 7

(C) TypeError

(D) SyntaxError

Correct Answer: (B)

[EN] Keyword arguments bind by name regardless of call order, so a=10 and b=3 yields 10 - 3 = 7.

[HI] कीवर्ड आर्गुमेंट्स क्रम के बजाय नाम से जुड़ते हैं, इसलिए a=10 और b=3 से 10 - 3 = 7 प्राप्त होता है।

Q7. Which function header is syntactically INVALID?

(इनमें से कौन-सा फंक्शन हेडर सिंटैक्स के अनुसार अवैध (INVALID) है?)

(A) def f(a, /, b, *, c): pass

(B) def f(a, b, /): pass

(C) def f(a, *, b, /, c): pass

(D) def f(*, a, b): pass

Correct Answer: (C)

[EN] Positional-only marker `/` must always appear before keyword-only marker `*`; reversing them raises SyntaxError.

[HI] पोजिशनल-ओनली चिह्न `/` हमेशा कीवर्ड-ओनली चिह्न `*` से पहले होना चाहिए; क्रम उलटने पर SyntaxError आता है।

Q8. Why does `len(obj=[1, 2])` raise TypeError in Python?

(पायथन में `len(obj=[1, 2])` चलाने पर TypeError क्यों आता है?)

(A) len() takes a positional-only parameter and accepts no keyword arguments

(B) obj is a reserved Python keyword

(C) len() expects a tuple, not a list

(D) len() is a keyword-only function

Correct Answer: (A)

[EN] Built-in len(obj, /) defines its argument as positional-only.

[HI] बिल्ट-इन len(obj, /) फंक्शन अपना पैरामीटर पोजिशनल-ओनली रूप से लेता है और कीवर्ड आर्गुमेंट स्वीकार नहीं करता।

Q9. What is the output of: def show(a, /, b, *, c=3): return a + b + c print(show(1, b=2))

(निम्न कोड का आउटपुट क्या होगा? def show(a, /, b, *, c=3): return a + b + c print(show(1, b=2)))

(A) 3

(B) 6

(C) SyntaxError

(D) TypeError

Correct Answer: (B)

[EN] a=1 is passed positionally (before /), b=2 is passed as keyword (standard slot), and c uses default 3, totaling 6.

[HI] a=1 पोजिशनल है, b=2 कीवर्ड है (सामान्य स्लॉट), और c डिफ़ॉल्ट 3 लेता है; कुल योग 6 प्रिंट होता है।

Q10. What happens when calling `def g(a, b=2): return a * b` as `g()`?

(`def g(a, b=2): return a * b` को `g()` के रूप में कॉल करने पर क्या होता है?)

(A) Returns 2

(B) SyntaxError

(C) TypeError: g() missing 1 required positional argument: 'a'

(D) Returns None

Correct Answer: (C)

[EN] Parameter a has no default value and is required; omitting it triggers TypeError.

[HI] पैरामीटर a का कोई डिफ़ॉल्ट मान नहीं है और वह अनिवार्य है, अतः उसे छोड़ने पर TypeError आता है।

Q11. What does `d = {'x': 4, 'y': 5}; def mul(x, y): return x * y; print(mul(**d))` output?

(`d = {'x': 4, 'y': 5}; def mul(x, y): return x * y; print(mul(**d))` का आउटपुट क्या होगा?)

(A) {'x': 4, 'y': 5}

(B) TypeError

(C) 20

(D) SyntaxError

Correct Answer: (C)

[EN] **d unpacks the dictionary entries as keyword arguments x=4 and y=5, returning 20.

[HI] **d डिक्शनरी की जोड़ियों को कीवर्ड आर्गुमेंट्स x=4 और y=5 के रूप में अनपैक करता है, जिससे 20 मिलता है।

Q12. What happens if a dictionary passed via `**d` contains a key `z` that the function does not accept and has no `**kwargs`?

(यदि `**d` द्वारा पास की गई डिक्शनरी में कोई ऐसी कुंजी `z` हो जिसे फंक्शन स्वीकार न करता हो और उसमें `**kwargs` भी न हो, तो क्या होगा?)

(A) z is silently ignored

(B) SyntaxError

(C) KeyError: 'z'

(D) TypeError: got an unexpected keyword argument 'z'

Correct Answer: (D)

[EN] Passing an unknown keyword name to a function without **kwargs raises TypeError.

[HI] बिना **kwargs वाले फंक्शन को अनपेक्षित कीवर्ड नाम भेजने पर TypeError उत्पन्न होता है।

Q13. How do positional-only parameters prevent key collisions with `**kwargs`?

(पोजिशनल-ओनली पैरामीटर्स `**kwargs` के साथ नाम के टकराव को कैसे रोकते हैं?)

(A) They automatically delete duplicate keys from kwargs

(B) They raise Warning instead of TypeError

(C) They convert kwargs into a tuple

(D) In `def f(name, /, **kwargs):`, passing `f('a', name='b')` stores `'name': 'b'` in kwargs cleanly

Correct Answer: (D)

[EN] Because the first parameter `name` is positional-only, `name='b'` in the call is unambiguously routed into `kwargs`.

[HI] पहला `name` पोजिशनल-ओनली होने के कारण कॉल में भेजा गया `name='b'` बिना किसी टकराव के `kwargs` में चला जाता है।

Q14. Which call to `def fn(a, b, c): pass` is valid?

(`def fn(a, b, c): pass` के लिए इनमें से कौन-सा कॉल वैध (valid) है?)

(A) fn(1, b=2, 3)

(B) fn(1, 2, a=3)

(C) fn(1, c=3, b=2)

(D) fn(a=1, 2, 3)

Correct Answer: (C)

[EN] Positional argument 1 binds a first, followed by keyword arguments c=3 and b=2 in any order.

[HI] पोजिशनल 1 पहले a से जुड़ता है, और उसके बाद कीवर्ड आर्गुमेंट्स c=3 तथा b=2 किसी भी क्रम में आ सकते हैं।

Q15. What happens when you call `sorted([3, 1, 2], True)` in Python 3?

(पायथन 3 में `sorted([3, 1, 2], True)` कॉल करने पर क्या होता है?)

(A) Returns [1, 2, 3]

(B) Returns [3, 2, 1]

(C) SyntaxError

(D) TypeError because reverse is a keyword-only parameter

Correct Answer: (D)

[EN] sorted(iterable, /, *, key=None, reverse=False) requires reverse to be passed as keyword `reverse=True`.

[HI] sorted() में reverse एक कीवर्ड-ओनली पैरामीटर है, इसलिए पोजिशनल रूप से True भेजने पर TypeError आता है।

Q16. Which statement about positional vs keyword arguments in Python is NOT true?

(पायथन में पोजिशनल बनाम कीवर्ड आर्गुमेंट्स के बारे में कौन-सा कथन असत्य (NOT true) है?)

(A) Keyword arguments can appear before positional arguments in a function call if names match

(B) Duplicate assignment of the same parameter raises TypeError

(C) Positional-only parameters are marked using `/` before standard parameters

(D) Keyword arguments make calls with boolean flags self-documenting

Correct Answer: (A)

[EN] Positional arguments must ALWAYS precede keyword arguments in a function call regardless of whether names match.

[HI] फंक्शन कॉल में पोजिशनल आर्गुमेंट्स को हमेशा कीवर्ड आर्गुमेंट्स से पहले आना ही होता है, चाहे नाम मेल खाते हों या नहीं।

Q17. Within Positional Arguments vs Keyword Arguments in Python, which parameter marker / form directly maps to: "Strictly by position; no name allowed"?

(Positional Arguments vs Keyword Arguments in Python में कौन सा Parameter Marker / Form सीधे "Strictly by position; no name allowed" से संबंधित है?)

(A) Positional after keyword in call

(B) Between / and * (Standard)

(C) After * or *args (Keyword-Only)

(D) Before / (Positional-Only)

Correct Answer: (D)

[EN] In Positional Arguments vs Keyword Arguments in Python, 'Before / (Positional-Only)' handles 'Strictly by position; no name allowed' (TypeError: passed as keyword).

[HI] Positional Arguments vs Keyword Arguments in Python में 'Before / (Positional-Only)' का कार्य/विवरण 'Strictly by position; no name allowed' (TypeError: passed as keyword) है।

Q18. Which option accurately describes 'Between / and * (Standard)' in Positional Arguments vs Keyword Arguments in Python?

(Positional Arguments vs Keyword Arguments in Python के संदर्भ में 'Between / and * (Standard)' की सही विशेषता कौन सी है?)

(A) Strictly by parameter name (key=val)

(B) Strictly by position; no name allowed

(C) Either positionally or by keyword

(D) Invalid call syntax: f(a=1, 2)

Correct Answer: (C)

[EN] 'Between / and * (Standard)' provides 'Either positionally or by keyword' — key point: TypeError if duplicated both ways.

[HI] 'Between / and * (Standard)' का मुख्य विवरण 'Either positionally or by keyword' है (TypeError if duplicated both ways)।

Q19. In Positional Arguments vs Keyword Arguments in Python, identify the correct parameter for the specification: "Strictly by parameter name (key=val)".

(Positional Arguments vs Keyword Arguments in Python में "Strictly by parameter name (key=val)" विवरण किस विकल्प के लिए सही है?)

(A) Between / and * (Standard)

(B) Positional after keyword in call

(C) Before / (Positional-Only)

(D) After * or *args (Keyword-Only)

Correct Answer: (D)

[EN] 'After * or *args (Keyword-Only)' corresponds to 'Strictly by parameter name (key=val)' (TypeError: takes fewer positional args).

[HI] 'After * or *args (Keyword-Only)' का संबंध 'Strictly by parameter name (key=val)' (TypeError: takes fewer positional args) से है।

Q20. Considering Positional Arguments vs Keyword Arguments in Python, what key behavior defines 'Positional after keyword in call'?

(Positional Arguments vs Keyword Arguments in Python में 'Positional after keyword in call' की मुख्य भूमिका या मान क्या है?)

(A) Either positionally or by keyword

(B) Strictly by position; no name allowed

(C) Invalid call syntax: f(a=1, 2)

(D) Strictly by parameter name (key=val)

Correct Answer: (C)

[EN] 'Positional after keyword in call' represents 'Invalid call syntax: f(a=1, 2)' (SyntaxError at parse/compile time).

[HI] 'Positional after keyword in call' का अर्थ/मान 'Invalid call syntax: f(a=1, 2)' है (SyntaxError at parse/compile time)।

Positional Arguments vs Keyword Arguments in Python — Exam FAQs

Q1: When should I prefer keyword arguments over positional arguments when calling a function?

फंक्शन कॉल करते समय पोजिशनल के बजाय कीवर्ड आर्गुमेंट्स को कब प्राथमिकता देनी चाहिए?

[EN] Prefer keyword arguments when a function takes more than two parameters, accepts boolean flags, or has optional configuration parameters so the call stays readable and safe from parameter reordering.

[HI] जब फंक्शन में दो से अधिक पैरामीटर हों, बूलियन फ्लैग हों या वैकल्पिक कॉन्फ़िगरेशन पैरामीटर हों, तब कीवर्ड आर्गुमेंट्स कोड को पठनीय और त्रुटि-मुक्त रखते हैं।

Q2: Can a function have ONLY keyword-only parameters and accept zero positional arguments?

क्या किसी फंक्शन में केवल कीवर्ड-ओनली पैरामीटर्स हो सकते हैं ताकि वह कोई पोजिशनल आर्गुमेंट न ले?

[EN] Yes. Placing `*` as the very first entry (`def connect(*, host, port):`) makes every parameter strictly keyword-only.

[HI] हाँ। पैरामीटर सूची की शुरुआत में `*` रखने (`def connect(*, host, port):`) से सभी पैरामीटर्स अनिवार्य रूप से कीवर्ड-ओनली बन जाते हैं।

Q3: What is the difference between `SyntaxError` and `TypeError` with argument ordering?

आर्गुमेंट क्रम से जुड़ी गलतियों में `SyntaxError` और `TypeError` के बीच क्या अंतर है?

[EN] `SyntaxError` occurs at parse time when a positional argument appears after a keyword argument (like `f(a=1, 2)`), whereas `TypeError` occurs at runtime for wrong counts, unknown keywords, or duplicate parameter bindings.

[HI] कॉल में कीवर्ड के बाद पोजिशनल लिखने (`f(a=1, 2)`) पर पार्स समय `SyntaxError` आता है, जबकि कम/अधिक संख्या, अज्ञात कीवर्ड या दोहरे मान पर रनटाइम `TypeError` आता है।

Related Posts

  • Loading related posts...

Post a Comment

Search Topic Notes & 20 MCQs (Hindi / English)