Python Functions — Complete Guide

Why Functions Exist — The Core Idea ☕Functions क्यों होते हैं — मूल विचार ☕为什么需要函数 — 核心思想 ☕

In Python, a function is a named, reusable block of code. It takes zero or more inputs (called arguments), does some work, and can give back a result with return. Every serious program is built from many small functions that call each other.

Python में function code का एक नाम वाला, दोबारा इस्तेमाल होने वाला हिस्सा है। यह शून्य या ज़्यादा inputs (जिन्हें arguments कहते हैं) लेता है, कुछ काम करता है, और return से result वापस दे सकता है। हर बड़ा program कई छोटे functions से बनता है जो एक-दूसरे को call करते हैं।

在 Python 中，函数 是一段有名字、可复用的代码。它接收零个或多个输入（叫作 实参，arguments），做一些工作，并可以用 return 返回结果。每个正经的程序都由许多互相调用的小函数组成。

The Anatomy of a Function — def, Parameters, return 🔬Function की बनावट — def, Parameters, return 🔬函数的结构 — def、形参、return 🔬

Every Python function has the same skeleton. Learn it once and you can read all of them.

हर Python function का ढाँचा एक जैसा होता है। इसे एक बार सीख लें, तो आप सभी पढ़ सकेंगे।

每个 Python 函数都有相同的骨架。学会一次，就能读懂所有函数。

Minimal Example — Greeting a Userसबसे छोटा उदाहरण — User का स्वागत最小示例 — 问候用户

def greet(name):
    # Body indented with 4 spaces
    message = f"Hello, {name}!"
    return message

# Calling the function
result = greet("Aarav")
print(result)

Functions Without return — What Actually Happensreturn के बिना Functions — असल में क्या होता है没有 return 的函数 — 实际发生了什么

def shout(word):
    print(word.upper() + "!")
    # No return statement

result = shout("hello")
print("result is:", result)
print("type is:", type(result))

Returning Several Valuesकई Values लौटाना返回多个值

A function can return only one object — but that object can be a tuple. Write values with commas after return, and unpack them at the call site.

Function सिर्फ़ एक object लौटा सकता है — पर वह object एक tuple हो सकता है। return के बाद values को commas से लिखें, और call करने की जगह उन्हें अलग-अलग नामों में खोल लें।

函数只能返回一个对象 — 但这个对象可以是 tuple。在 return 后用逗号写多个值，再在调用处解包。

def min_max(numbers):
    return min(numbers), max(numbers)     # really ONE tuple

pair = min_max([4, 9, 1, 7])
print(pair, type(pair).__name__)

low, high = min_max([4, 9, 1, 7])        # unpack it into two names
print("low =", low, "| high =", high)

Try It — Function Call Stepperकरके देखें — Function Call Stepper动手试试 — 函数调用步进器

Watch what really happens when you call a function. A new frame (a private workspace for the function's variables) is pushed onto the call stack, the body runs, and return hands a value back before the frame disappears. Try the print vs return tab to see why printing is not returning.

देखें कि function call करने पर असल में क्या होता है। Call stack पर एक नया frame (function के variables का निजी कार्यस्थान) रखा जाता है, body चलती है, और frame के गायब होने से पहले return value वापस देता है। print vs return tab आज़माएँ और देखें कि print करना return करना क्यों नहीं है।

看看调用函数时究竟发生了什么。一个新的 帧（存放函数变量的私有工作区）被压入 调用栈，函数体运行，return 在帧消失之前把值交回。试试 print vs return 标签页，看看为什么打印不等于返回。

Positional Arguments — Order Is Everything 🔢Positional Arguments — क्रम ही सब कुछ है 🔢位置参数 — 顺序就是一切 🔢

When you call a function with values but no names, Python matches them by position — first argument to first parameter, second to second, and so on. Swap the order and you get a bug, not an error.

जब आप बिना नामों के values देकर function call करते हैं, तो Python उन्हें स्थान से मिलाता है — पहला argument पहले parameter को, दूसरा दूसरे को, और आगे भी ऐसे ही। क्रम उलट दें तो error नहीं, bug मिलता है।

当你只传值、不写名字调用函数时，Python 按位置 匹配 — 第一个实参给第一个形参，第二个给第二个，依此类推。顺序一换，得到的是 bug，而不是报错。

def divide(numerator, denominator):
    return numerator / denominator

# Positional — order matters
print(divide(10, 2))   # 10 / 2 = 5.0   correct
print(divide(2, 10))   # 2 / 10 = 0.2   silent bug!

Keyword Arguments — Name Them and Sleep Well 🏷️Keyword Arguments — नाम दें और चैन से सोएँ 🏷️关键字参数 — 写上名字，睡个好觉 🏷️

You can pass arguments by name instead of position with the parameter=value syntax. Keyword arguments explain themselves and are safe from the order-swap bug above.

parameter=value लिखकर आप arguments को स्थान की जगह नाम से दे सकते हैं। Keyword arguments ख़ुद अपना मतलब बताते हैं और ऊपर वाले क्रम-उलटने के bug से सुरक्षित हैं।

用 parameter=value 语法，可以 按名字 而不是按位置传参。关键字参数自带说明，也不会出现上面那种顺序颠倒的 bug。

def divide(numerator, denominator):
    return numerator / denominator

# Keyword calls — order does not matter
print(divide(numerator=10, denominator=2))   # 5.0
print(divide(denominator=2, numerator=10))   # 5.0 — same!

# Mix positional then keyword (positional MUST come first)
print(divide(10, denominator=2))          # 5.0  OK

# Keyword before positional is a SyntaxError — Python refuses to run the file
try:
    compile("divide(numerator=10, 2)", "<test>", "eval")
except SyntaxError as e:
    print("SyntaxError:", e.msg)

Default Arguments — Sensible Fallbacks 🎛️Default Arguments — समझदार विकल्प 🎛️默认参数 — 合理的后备值 🎛️

You can give a parameter a default value in the definition with parameter=default. If the caller does not supply it, Python uses the default. This makes functions flexible without forcing callers to set every option.

Definition में parameter=default लिखकर आप parameter को default value दे सकते हैं। Caller अगर उसे न दे, तो Python default इस्तेमाल करता है। इससे functions लचीले बनते हैं और caller को हर विकल्प भरना नहीं पड़ता।

在定义中用 parameter=default 给形参一个 默认值。调用者不提供时，Python 就用默认值。这让函数更灵活，调用者不必设置每个选项。

def connect(host, port=8080, timeout=30, use_ssl=True):
    print(f"Connecting to {host}:{port}")
    print(f"  timeout={timeout}s, ssl={use_ssl}")

# Only the required argument — rest use defaults
connect("api.example.com")

# Override just the port
connect("api.example.com", 9000)

# Override port and timeout, keep ssl=True
connect("api.example.com", 9000, 60)

Calling Default Arguments by Keyword — The Skip Trick ⏭️Default Arguments को Keyword से Call करना — छोड़ने की तरकीब ⏭️用关键字调用默认参数 — 跳过技巧 ⏭️

Here defaults and keyword calls combine into a superpower. What if you want to keep the defaults for port and timeout, but change only use_ssl? Without keywords you would have to repeat every earlier value. With them, you jump straight to the one you care about.

यहाँ defaults और keyword calls मिलकर ख़ास ताक़त बनते हैं। अगर आप port और timeout के defaults रखना चाहें, पर सिर्फ़ use_ssl बदलना चाहें तो? Keywords के बिना आपको पहले की हर value दोहरानी पड़ती। उनके साथ आप सीधे उसी पर पहुँचते हैं जो आपको चाहिए।

在这里，默认值和关键字调用合在一起成了超能力。如果你想保留 port 和 timeout 的默认值，只改 use_ssl 呢？没有关键字，你得把前面的每个值都重写一遍。有了关键字，你可以直接跳到你关心的那一个。

def connect(host, port=8080, timeout=30, use_ssl=True):
    print(f"{host}:{port} ssl={use_ssl} t={timeout}")

# Keep port & timeout defaults, only change ssl
connect("api.example.com", use_ssl=False)

# Skip port, change timeout only
connect("api.example.com", timeout=60)

# Any combination — order does not matter
connect("api.example.com", use_ssl=False, timeout=60, port=443)

Try It — Argument Matching Machineकरके देखें — Argument Matching Machine动手试试 — 参数匹配机

Edit the def line or the call, then press Call it. Each argument you pass is a card; each parameter is a slot. Watch positional cards fill slots in order, keyword cards jump to the slot with the same name, and defaults fill whatever is left. Try the ✗ chips to see every error Python can raise.

def line या call बदलें, फिर Call करें दबाएँ। हर argument एक card है; हर parameter एक slot। देखें कि positional cards slots को क्रम से भरते हैं, keyword cards उसी नाम वाले slot पर कूदते हैं, और बचा हुआ defaults भरते हैं। Python के हर error को देखने के लिए ✗ वाले chips आज़माएँ।

修改 def 行或调用，然后按 调用。你传的每个实参是一张卡片，每个形参是一个槽。看位置卡片 按顺序 填槽，关键字卡片跳到 同名 的槽，剩下的由默认值填充。试试带 ✗ 的按钮，看看 Python 会抛出的每种错误。

Variable-Length Arguments — *args 🎒बदलती संख्या के Arguments — *args 🎒可变长度参数 — *args 🎒

A single asterisk * before a parameter tells Python: "catch all remaining positional arguments and pack them into a tuple". The name args is only a convention — *numbers works too. The magic is the *.

Parameter से पहले एक asterisk * Python को बताता है: "बचे हुए सारे positional arguments पकड़ो और उन्हें tuple में पैक करो"। नाम args सिर्फ़ परंपरा है — *numbers भी चलता है। असली जादू * में है।

形参前加一个星号 * 是在告诉 Python："接住所有剩下的 位置 参数，打包成 tuple"。名字 args 只是惯例 — *numbers 也可以。真正的魔法在 *。

def sum_all(*args):
    print("args is:", args)
    print("type is:", type(args))
    total = 0
    for n in args:
        total += n
    return total

print(sum_all(1, 2, 3))
print(sum_all(10, 20, 30, 40, 50))
print(sum_all())          # zero args is fine — empty tuple

Mixing Regular Parameters with *argsसामान्य Parameters के साथ *args普通形参与 *args 混用

def log_event(level, *messages):
    for msg in messages:
        print(f"[{level}] {msg}")

log_event("INFO", "server started", "port 8080 open", "ready")

Unpacking — the Other Side of * and **Unpacking — * और ** का दूसरा पहलू解包 — * 和 ** 的另一面

The same stars work at the call site in reverse. * spreads a list or tuple into positional arguments, and ** spreads a dict into keyword arguments. Defining and calling are mirror images.

वही stars call की जगह उल्टा काम करते हैं। * list या tuple को positional arguments में फैला देता है, और ** dict को keyword arguments में। Define करना और call करना एक-दूसरे का प्रतिबिंब हैं।

同样的星号在 调用处 反向工作。* 把 list 或 tuple 展开成位置参数，** 把 dict 展开成关键字参数。定义和调用互为镜像。

def describe(name, age, city):
    print(f"{name}, {age}, from {city}")

values = ["Meera", 31, "Pune"]
describe(*values)                 # * unpacks a list into positions

options = {"city": "Delhi", "age": 25, "name": "Kabir"}
describe(**options)               # ** unpacks a dict into keywords

print(*[1, 2, 3], sep=" | ")      # works with built-ins too

Keyword Arguments Bag — **kwargs 🗃️Keyword Arguments का थैला — **kwargs 🗃️关键字参数袋 — **kwargs 🗃️

A double asterisk ** is the cousin of *args. It catches all remaining keyword arguments and packs them into a dictionary. Your function can then accept an open-ended set of named options without declaring each one.

दोहरा asterisk **, *args का भाई है। यह बचे हुए सारे keyword arguments पकड़कर एक dictionary में पैक करता है। तब आपका function हर एक को घोषित किए बिना नाम वाले विकल्पों का खुला सेट ले सकता है।

双星号 ** 是 *args 的兄弟。它接住所有剩下的 关键字 参数，打包成 字典。这样你的函数不必逐个声明，也能接受任意多个具名选项。

def create_user(username, **kwargs):
    print(f"Creating user: {username}")
    print("kwargs is:", kwargs)
    print("type is: ", type(kwargs))
    for key, value in kwargs.items():
        print(f"  {key} = {value}")

create_user(
    "priya_92",
    email="priya@example.com",
    age=28,
    country="India",
    is_admin=False
)

The Full Parameter Order — Putting It All Together 🧱Parameters का पूरा क्रम — सब एक साथ 🧱完整的形参顺序 — 全部组合起来 🧱

When a function uses every kind of parameter at once, Python enforces a strict order in the definition. Here is the full sequence. Every part is optional, but the parts you use must appear in this order.

जब कोई function हर तरह के parameter एक साथ इस्तेमाल करता है, तो Python definition में सख़्त क्रम लागू करता है। यह रहा पूरा क्रम। हर हिस्सा वैकल्पिक है, पर जो हिस्से आप इस्तेमाल करें, वे इसी क्रम में आने चाहिए।

当一个函数同时使用各种形参时，Python 在定义中强制要求严格的顺序。下面是完整的顺序。每一部分都是可选的，但用到的部分必须按这个顺序出现。

def register(username, email, role="user", *permissions, **profile):
    print(f"username    : {username}")
    print(f"email       : {email}")
    print(f"role        : {role}")
    print(f"permissions : {permissions}")
    print(f"profile     : {profile}")

register(
    "rahul_dev",                     # username (positional)
    "rahul@example.com",              # email    (positional)
    "admin",                         # role     (overrides default)
    "read", "write", "delete",        # *permissions -> tuple
    country="India",                  # **profile -> dict
    joined="2024-01-15"
)

Keyword-Only and Positional-Only Parametersसिर्फ़-Keyword और सिर्फ़-Positional Parameters仅关键字与仅位置形参

Two markers give you extra control. Anything after *args (or a bare *) must be passed by name. Anything before / must be passed by position. The logger in Section 12 uses the first trick for level.

दो निशान आपको अतिरिक्त नियंत्रण देते हैं। *args (या अकेले *) के बाद का सब कुछ नाम से देना होगा। / से पहले का सब कुछ स्थान से देना होगा। Section 12 का logger level के लिए पहला तरीका इस्तेमाल करता है।

两个标记给你更多控制。*args（或单独的 *）之后的形参必须 按名字 传入。/ 之前的形参必须 按位置 传入。第 12 节的日志函数就用第一种技巧来处理 level。

# Parameters AFTER *args (or a bare *) are keyword-only
def order(item, *extras, size="regular"):
    print(f"{size} {item} with {extras}")

order("tea", "sugar", "milk")              # size keeps its default
order("tea", "sugar", size="large")         # size only by name

# Parameters BEFORE / are positional-only (Python 3.8+)
def power(base, exp, /, *, verbose=False):
    result = base ** exp
    if verbose:
        print(f"{base} ** {exp} = {result}")
    return result

print(power(2, 10))
power(2, 10, verbose=True)
try:
    power(base=2, exp=10)
except TypeError as e:
    print("TypeError:", e)

Try It — Packing Machineकरके देखें — Packing Machine动手试试 — 打包机

Same machine, now with bags. Arguments that find no named slot drop into the *args bag (a tuple) or the **kwargs bag (a dict). A * or ** at the call site does the opposite: it unpacks a list or dict into separate arguments. Try the register chips to see all four kinds at once.

वही मशीन, अब थैलों के साथ। जिन arguments को कोई नाम वाला slot नहीं मिलता, वे *args थैले (एक tuple) या **kwargs थैले (एक dict) में गिरते हैं। Call में * या ** उल्टा करता है: list या dict को अलग-अलग arguments में खोल देता है। चारों तरह एक साथ देखने के लिए register वाले chips आज़माएँ।

同一台机器，现在多了袋子。找不到具名槽的实参会掉进 *args 袋（一个 tuple）或 **kwargs 袋（一个 dict）。调用 处的 * 或 ** 正好相反：把 list 或 dict 拆成单独的实参。试试 register 按钮，一次看到全部四种。

How Arguments Are Passed — Object References 🔗Arguments कैसे दिए जाते हैं — Object References 🔗参数如何传递 — 对象引用 🔗

Case 1 — Unchangeable Objects (int, str, tuple, float, bool)मामला 1 — न बदलने वाले Objects (int, str, tuple, float, bool)情况 1 — 不可变对象（int、str、tuple、float、bool）

def try_change(x):
    print(f"  inside before: x = {x}, id = {id(x)}")
    x = x + 100                     # rebinds LOCAL x to a new int
    print(f"  inside after : x = {x}, id = {id(x)}")

number = 5
print(f"before call: number = {number}, id = {id(number)}")
try_change(number)
print(f"after call : number = {number}, id = {id(number)}")

Look at the ids. The parameter x started out pointing at the very same integer as number. But x = x + 100 created a new integer and moved the local name x to it. The caller's number was never touched, because integers cannot change — you cannot modify 5 in place, only create a new object. (Your id numbers will be different; only which ones match matters.)

Ids देखें। Parameter x शुरू में बिल्कुल उसी integer की ओर इशारा करता था जिसकी ओर number। पर x = x + 100 ने एक नया integer बनाया और local नाम x को उस पर ले गया। Caller का number कभी छुआ नहीं गया, क्योंकि integers बदल नहीं सकते — आप 5 को उसी जगह नहीं बदल सकते, सिर्फ़ नया object बना सकते हैं। (आपके id numbers अलग होंगे; मायने सिर्फ़ यह रखता है कि कौन-से मेल खाते हैं।)

看看这些 id。形参 x 一开始指向的就是 number 指向的那个整数。但 x = x + 100 创建了一个 新 整数，并把局部名字 x 移了过去。调用者的 number 从未被碰过，因为整数不可变 — 你不能原地修改 5，只能创建新对象。（你的 id 数值会不同；重要的只是哪些相同。）

Case 2 — Changeable Objects (list, dict, set, your own classes)मामला 2 — बदलने वाले Objects (list, dict, set, आपकी अपनी classes)情况 2 — 可变对象（list、dict、set、自定义类）

def add_item(cart):
    print(f"  inside before: cart = {cart}, id = {id(cart)}")
    cart.append("laptop")          # MUTATES the object in place
    print(f"  inside after : cart = {cart}, id = {id(cart)}")

my_cart = ["book", "pen"]
print(f"before call: cart = {my_cart}, id = {id(my_cart)}")
add_item(my_cart)
print(f"after call : cart = {my_cart}, id = {id(my_cart)}")

Case 3 — Changeable Object, but Rebinding Instead of Mutatingमामला 3 — बदलने वाला Object, पर बदलने की जगह Rebinding情况 3 — 可变对象，但重新绑定而不是修改

def replace_cart(cart):
    cart = ["phone", "charger"]     # REBINDS local name to a NEW list
    print(f"  inside: cart = {cart}")

my_cart = ["book", "pen"]
replace_cart(my_cart)
print(f"after : cart = {my_cart}")     # unchanged!

Same type (a list, which can change), but a completely different result. The assignment cart = [...] did not modify the caller's list — it only made the local name cart point at a brand-new list. The original survived untouched.

वही type (list, जो बदल सकती है), पर बिल्कुल अलग result। Assignment cart = [...] ने caller की list नहीं बदली — इसने सिर्फ़ local नाम cart को एक बिल्कुल नई list की ओर मोड़ दिया। मूल list अछूती रही।

同样的类型（可变的 list），结果却完全不同。赋值 cart = [...] 并没有修改调用者的 list — 它只是让局部名字 cart 指向一个全新的 list。原来的 list 完好无损。

One fine point: a tuple cannot change, but a list inside a tuple still can. t[0].append(1) works when t = ([],).

एक बारीक बात: tuple बदल नहीं सकता, पर tuple के अंदर रखी list अब भी बदल सकती है। t = ([],) हो तो t[0].append(1) चलता है।

一个细节：tuple 不可修改，但 tuple 里面 的 list 仍然可以修改。当 t = ([],) 时，t[0].append(1) 可以正常执行。

Try It — Reference Visualizerकरके देखें — Reference Visualizer动手试试 — 引用可视化

Names are tags; values are objects. Step through each case and watch the arrows. Passing an argument sticks a second tag on the same object. Then it depends: mutating the object is seen by everyone, rebinding the tag is not.

नाम tags हैं; values objects हैं। हर मामले को कदम-दर-कदम चलाएँ और तीर देखें। Argument देने पर उसी object पर दूसरा tag चिपकता है। फिर यह निर्भर करता है: object को बदलना सबको दिखता है, tag को हटाना नहीं।

名字是 标签；值是 对象。逐步执行每种情况，观察箭头。传参就是在 同一个 对象上再贴一个标签。接下来就看情况了：修改 对象大家都看得到，重新绑定 标签则不会。

The Mutable Default Argument Trap 💥बदलने वाले Default Argument का जाल 💥可变默认参数陷阱 💥

This is the most famous Python gotcha. Almost every Python developer meets it at least once — often in production.

यह Python की सबसे मशहूर पकड़ है। लगभग हर Python developer कम से कम एक बार इससे टकराता है — अक्सर production में।

这是 Python 最著名的坑。几乎每个 Python 开发者都至少踩过一次 — 而且往往是在生产环境里。

# The trap:
def append_to(item, target=[]):     # mutable default!
    target.append(item)
    return target

print(append_to(1))
print(append_to(2))
print(append_to(3))
print("stored default:", append_to.__defaults__)

Each call was expected to return a fresh [item]. Instead, the same list is reused and grows across calls. Why? Because default values are evaluated once, when the def line runs. That one list object is stored in append_to.__defaults__ — the last line proves it — and every call that does not pass target changes that same object.

हर call से नई [item] लौटने की उम्मीद थी। इसकी जगह वही list बार-बार इस्तेमाल होती है और हर call के साथ बढ़ती जाती है। क्यों? क्योंकि default values एक बार, def line चलने पर बनती हैं। वह एक list object append_to.__defaults__ में रखा जाता है — आख़िरी line इसका सबूत है — और target न देने वाला हर call उसी object को बदलता है।

本来期望每次调用都返回一个新的 [item]。结果同一个 list 被反复使用，越变越长。为什么？因为默认值 只在 def 这一行运行时计算一次。那个 list 对象存放在 append_to.__defaults__ 里 — 最后一行就是证据 — 每次不传 target 的调用，修改的都是这同一个对象。

# The correct pattern:
def append_to(item, target=None):
    if target is None:
        target = []                    # fresh list every call
    target.append(item)
    return target

print(append_to(1))
print(append_to(2))
print(append_to(3))
print("stored default:", append_to.__defaults__)

Try It — Mutable Default Trap Labकरके देखें — Mutable Default Trap Lab动手试试 — 可变默认值陷阱实验室

Press Call a few times. In the trap version, look inside the function's hidden drawer (__defaults__) and watch the one default list grow — and every earlier result change with it. Then switch to the fixed version and repeat.

Call कुछ बार दबाएँ। Trap वाले रूप में function की छिपी दराज़ (__defaults__) में देखें और एक default list को बढ़ते देखें — और उसके साथ पहले के हर result को बदलते। फिर fixed रूप पर जाएँ और दोहराएँ।

多按几次 调用。在 陷阱 版本中，看看函数的隐藏抽屉（__defaults__），观察 那一个 默认 list 不断变长 — 之前的每个结果也跟着变。然后切换到 修复 版本再试一次。

A Complete Real-World Example — Building a Flexible Logger 📝एक पूरा असली उदाहरण — लचीला Logger बनाना 📝完整的实战示例 — 构建灵活的日志函数 📝

Let's combine everything: a required parameter, *args, keyword-only parameters with defaults, keyword calls and **kwargs.

अब सब कुछ जोड़ते हैं: एक ज़रूरी parameter, *args, defaults वाले keyword-only parameters, keyword calls और **kwargs।

把所有内容组合起来：一个必需形参、*args、带默认值的仅关键字形参、关键字调用以及 **kwargs。

import datetime

def log(message, *tags, level="INFO", timestamp=True, **metadata):
    """
    Log a message with optional tags, level, timestamp, and metadata.

    - message   : required, the log body
    - *tags     : any number of string tags
    - level     : keyword-only, with a default (INFO, WARN, ERROR)
    - timestamp : keyword-only, whether to add the time
    - **metadata: any extra key=value context (user_id, request_id, ...)
    """
    parts = []

    if timestamp:
        now = datetime.datetime.now().strftime("%H:%M:%S")
        parts.append(f"[{now}]")

    parts.append(f"[{level}]")

    if tags:
        parts.append("#" + " #".join(tags))

    parts.append(message)

    if metadata:
        meta_str = " ".join(f"{k}={v}" for k, v in metadata.items())
        parts.append(f"| {meta_str}")

    print(" ".join(parts))


# Simple call — only the required argument
log("Server started")

# With tags (variable positional)
log("Cache miss", "redis", "user-profile")

# Override a default by KEYWORD — timestamp keeps its default
log("Login failed", level="WARN")

# Everything at once
log(
    "Payment declined",
    "stripe", "billing",             # *tags
    level="ERROR",                     # overrides default
    timestamp=True,                     # same as the default
    user_id=4821,                        # **metadata
    request_id="req-9f3a",
    amount=2500
)

The time in brackets is the moment the code ran, so yours will be different.

Brackets में समय वह पल है जब code चला, इसलिए आपका अलग होगा।

方括号里的时间是代码运行的时刻，所以你的会不同。

Try It — Logger Call Builderकरके देखें — Logger Call Builder动手试试 — 日志调用构建器

Fill in the form and the lab writes the call for you, in the clean keyword style. The call is bound to the real log() signature and printed. Try the chips: passing "WARN" by position, or misspelling level, shows two classic *args/**kwargs traps.

Form भरें और lab आपके लिए साफ़ keyword शैली में call लिख देता है। Call असली log() signature से जोड़ा जाता है और print होता है। Chips आज़माएँ: "WARN" को स्थान से देना, या level की ग़लत spelling, *args/**kwargs के दो मशहूर जाल दिखाते हैं।

填写表单，实验室就会用干净的关键字风格帮你写出调用。调用会绑定到真实的 log() 签名并打印出来。试试这些按钮：按位置传入 "WARN"，或把 level 拼错，会展示 *args/**kwargs 的两个经典陷阱。

Golden Rules 🏆सुनहरे नियम 🏆黄金法则 🏆

Quick Checkछोटी जाँच小测验

Seven questions on functions. Pick an answer to see why.

Functions पर सात सवाल। जवाब चुनें और कारण देखें।

关于函数的七道题。选择答案查看解释。