Python Built-in Functions

The Story That Explains Functional Tools 🏭Functional Tools समझाने वाली कहानी 🏭一个讲清函数式工具的故事 🏭

Python's functional tools — lambda, map, filter, reduce, zip, enumerate, sorted and friends — are the vocabulary for "do this to every item", "keep only these" and "combine into one" without writing the loop yourself.

Python के functional tools — lambda, map, filter, reduce, zip, enumerate, sorted और साथी — "हर item के साथ यह करो", "सिर्फ़ ये रखो" और "सबको एक में मिलाओ" कहने की भाषा हैं, बिना ख़ुद loop लिखे।

Python 的函数式工具 — lambda、map、filter、reduce、zip、enumerate、sorted 等 — 是表达"对每个元素做这件事"、"只保留这些"和"合并成一个"的词汇，无需自己写循环。

Lambda — The Anonymous Function λLambda — बेनाम Function λLambda — 匿名函数 λ

Before map and filter can shine, you need lambda — Python's way of writing a one-expression function without giving it a name. Think of it as a disposable function you write right where you need it.

map और filter के चमकने से पहले आपको lambda चाहिए — Python का तरीका एक-expression वाला function बिना नाम दिए लिखने का। इसे ऐसा function समझें जिसे आप वहीं लिखते हैं जहाँ ज़रूरत है, और फेंक देते हैं।

在 map 和 filter 大显身手之前，你需要 lambda — Python 不起名字就写出单表达式函数的方式。把它看作在需要的地方当场写、用完就扔的函数。

# The traditional way - a named function
def square(x):
    return x * x

# The lambda way - anonymous, one line
square_lambda = lambda x: x * x      # (named here only to compare - see Rule 1)

print(square(5))
print(square_lambda(5))
print(square.__name__, "vs", square_lambda.__name__)

Lambda with Several Argumentsकई Arguments वाला Lambda多参数的 lambda

add      = lambda x, y: x + y
distance = lambda x1, y1, x2, y2: ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
greet    = lambda name, greeting="Namaste": f"{greeting}, {name}!"

print(add(3, 4))
print(distance(0, 0, 3, 4))
print(greet("Aarav"))
print(greet("Meera", "Hey"))

Lambda with a Conditional ExpressionConditional Expression वाला Lambda带条件表达式的 lambda

# You CAN'T write if/else statements - but a conditional expression is fine
grade = lambda score: "pass" if score >= 40 else "fail"

print(grade(75))
print(grade(32))

A Classic Trap — Lambdas in a Loopएक मशहूर जाल — Loop में Lambdas经典陷阱 — 循环里的 lambda

# The late-binding trap: every lambda sees the LAST value of i
funcs = [lambda: i for i in range(3)]
print([f() for f in funcs])

# Fix: freeze the current value with a default argument
funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs])

A lambda does not copy the value of i when it is created. It looks i up when it is called — and by then the loop has finished and i is 2. A default argument (i=i) is evaluated at creation time, so it freezes the value.

Lambda बनते समय i की value copy नहीं करता। वह i को तब देखता है जब उसे बुलाया जाता है — और तब तक loop ख़त्म हो चुका होता है और i 2 है। Default argument (i=i) बनते समय ही evaluate होता है, इसलिए value जम जाती है।

lambda 被创建时不会复制 i 的值。它在 被调用 时才查找 i — 那时循环已结束，i 是 2。默认参数（i=i）在创建时求值，所以能把值固定下来。

Map vs Filter vs Reduce — Three Shapes 🔷Map बनाम Filter बनाम Reduce — तीन आकार 🔷Map、Filter、Reduce — 三种形状 🔷

These three look alike in code but do very different things to your data. Picture the shape of each and you will never mix them up.

Code में ये तीनों एक जैसे दिखते हैं पर आपके data के साथ बिल्कुल अलग काम करते हैं। हर एक का आकार कल्पना करें और आप इन्हें कभी नहीं मिलाएँगे।

这三者在代码里看起来很像，对数据做的事却截然不同。在脑中描绘出各自的 形状，就再也不会混淆。

map() — Transform Every Item 🎨map() — हर Item बदलें 🎨map() — 转换每个元素 🎨

map(function, iterable) calls function on every item and gives back a lazy iterator. Wrap it in list() to get the results.

map(function, iterable) हर item पर function बुलाता है और एक lazy iterator लौटाता है। नतीजे पाने के लिए इसे list() में लपेटें।

map(function, iterable) 对每个元素调用 function，返回一个 惰性迭代器。用 list() 包起来才能得到结果。

nums = [1, 2, 3, 4, 5]

# Traditional way: for loop with append
squared = []
for n in nums:
    squared.append(n ** 2)
print(squared)

# map + lambda way - one line
squared = list(map(lambda n: n ** 2, nums))
print(squared)

Map with a Named Functionनाम वाले Function के साथ Map配合具名函数的 map

# Any function works - not just lambdas
words = ["apple", "BANANA", "Cherry"]
print(list(map(str.lower, words)))
print(list(map(len, words)))

# Read numbers typed on one line
line = "12 7 30 5"
print(list(map(int, line.split())))

map(int, line.split()) is the classic way to read several numbers typed on one line — you will see it in many competitive-programming solutions.

map(int, line.split()) एक line पर लिखी कई संख्याएँ पढ़ने का मशहूर तरीका है — competitive programming के कई solutions में यह दिखता है।

map(int, line.split()) 是读取一行中多个数字的经典写法 — 在很多算法竞赛的解答里都能看到。

Map with Several Iterables — and Lazinessकई Iterables के साथ Map — और आलस多个可迭代对象的 map — 以及惰性

# The function takes as many arguments as you pass iterables
prices     = [10, 20, 30]
quantities = [2, 3, 1]
print(list(map(lambda p, q: p * q, prices, quantities)))

# map is lazy: it computes nothing until you ask
squares = map(lambda n: n * n, [1, 2, 3])
print(squares)                 # a map object, not values
print(list(squares))           # now the values are computed
print(list(squares))           # used up! a map works only once

filter() — Keep Only What Passes 🔍filter() — सिर्फ़ पास होने वाले रखें 🔍filter() — 只保留通过的元素 🔍

filter(function, iterable) keeps only the items for which function returns a truthy value. It is lazy, just like map.

filter(function, iterable) सिर्फ़ वे items रखता है जिनके लिए function truthy value लौटाए। यह भी map की तरह lazy है।

filter(function, iterable) 只保留 function 返回真值的元素。它和 map 一样是惰性的。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Keep only even numbers
print(list(filter(lambda n: n % 2 == 0, nums)))

# None as the function = "keep truthy items"
raw = ["Aarav", "", "Meera", None, "Kabir", "", 0, []]
print(list(filter(None, raw)))

reduce() — Collapse to a Single Value ⚖️reduce() — एक Value में समेटें ⚖️reduce() — 归约为单个值 ⚖️

reduce() lives in the functools module (Python 3 moved it out of the built-ins). It takes a function of two arguments — the running result and the next item — and applies it from left to right until one value is left.

reduce() functools module में रहता है (Python 3 ने इसे built-ins से बाहर निकाला)। यह दो arguments वाला function लेता है — चलता नतीजा और अगला item — और उसे बाएँ से दाएँ लगाता है जब तक एक value न बचे।

reduce() 位于 functools 模块（Python 3 把它移出了内置函数）。它接收一个 两个参数 的函数 — 当前累计结果和下一个元素 — 从左到右依次应用，直到只剩一个值。

from functools import reduce

# Sum: (((1+2)+3)+4)+5 = 15
total = reduce(lambda acc, x: acc + x, [1, 2, 3, 4, 5])

# Product: 1*2*3*4*5 = 120
product = reduce(lambda acc, x: acc * x, [1, 2, 3, 4, 5])

# Max by hand: keep the bigger of each pair
biggest = reduce(lambda a, b: a if a > b else b, [3, 7, 1, 9, 4])

print(total, product, biggest)

Reduce with a Start ValueStart Value के साथ Reduce带初始值的 reduce

from functools import reduce

# The 3rd argument is the STARTING value of the accumulator
print(reduce(lambda acc, x: acc + x, [], 0))            # empty list: returns 0
print(reduce(lambda acc, x: acc + x, [1, 2, 3], 100))   # 100 + 1 + 2 + 3

# Without a start value, an empty list is an error
try:
    reduce(lambda acc, x: acc + x, [])
except TypeError as e:
    print("TypeError:", e)

Try It — Pipeline Factoryकरके देखें — Pipeline Factory动手试试 — 流水线工厂

Build a pipeline from filter, map and reduce, then press Play. Every step is a real call recorded from Python, in the real order. Watch how one item travels the whole line before the next one starts — that is laziness. Try the order buttons: filter → map and map → filter can give different answers. And try x > 100 with nums and the max reducer to see an empty pipeline crash.

filter, map और reduce से pipeline बनाएँ, फिर चलाएँ दबाएँ। हर कदम Python से दर्ज की गई असली call है, असली क्रम में। देखें कि अगला item शुरू होने से पहले एक item पूरी line कैसे पार करता है — यही laziness है। क्रम वाले buttons आज़माएँ: filter → map और map → filter अलग जवाब दे सकते हैं। और ख़ाली pipeline का crash देखने के लिए nums के साथ x > 100 और max reducer आज़माएँ।

用 filter、map 和 reduce 搭一条流水线，然后点 播放。每一步都是从 Python 记录下的真实调用，顺序也是真实的。看一个元素如何先走完整条线，下一个才开始 — 这就是惰性。试试顺序按钮：filter → map 和 map → filter 可能给出不同答案。再试试 nums 配 x > 100 和 max 归约器，看看空流水线如何崩溃。

zip() — Pair Up Iterables 🤝zip() — Iterables की जोड़ी बनाएँ 🤝zip() — 把可迭代对象配对 🤝

zip() takes any number of iterables and gives back tuples of items that sit at the same position. Think of a zipper: the left and right teeth lock together one pair at a time.

zip() कितने भी iterables लेता है और एक ही position पर बैठे items के tuples लौटाता है। Zipper सोचें: बाएँ और दाएँ दाँत एक-एक जोड़ी करके जुड़ते हैं।

zip() 接收任意多个可迭代对象，返回由相同位置的元素组成的元组。想象一条拉链：左右两排齿一对一对地扣在一起。

names  = ["Aarav", "Meera", "Kabir"]
scores = [85, 92, 78]
ages   = [20, 22, 21]

for name, score in zip(names, scores):
    print(f"{name}: {score}")

for name, score, age in zip(names, scores, ages):
    print(f"{name} ({age}): scored {score}")

print(dict(zip(names, scores)))

# Unzip with zip(*...) - like a transpose
pairs = [("Aarav", 85), ("Meera", 92), ("Kabir", 78)]
who, marks = zip(*pairs)
print(who)
print(marks)

When the Lists Have Different Lengthsजब Lists की लंबाई अलग हो当列表长度不同时

from itertools import zip_longest

names  = ["Aarav", "Meera", "Kabir", "Isha"]
scores = [85, 92, 78]                       # one score is missing!

print(list(zip(names, scores)))             # Isha silently disappears

print(list(zip_longest(names, scores, fillvalue="-")))

try:
    list(zip(names, scores, strict=True))   # Python 3.10+
except ValueError as e:
    print("ValueError:", e)

enumerate() — Index and Value Together 🔢enumerate() — Index और Value साथ-साथ 🔢enumerate() — 索引与值一起 🔢

enumerate() replaces the clumsy for i in range(len(...)). It pairs each item with a counter that starts at 0 — or wherever you say.

enumerate() भद्दे for i in range(len(...)) की जगह लेता है। यह हर item को एक counter के साथ जोड़ता है जो 0 से शुरू होता है — या जहाँ से आप कहें।

enumerate() 取代笨拙的 for i in range(len(...))。它给每个元素配一个计数器，从 0 开始 — 或从你指定的数开始。

fruits = ["apple", "banana", "cherry"]

# The old way - works, but noisy
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

# The Pythonic way
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# Start counting from 1 (for people, not programs)
for rank, medal in enumerate(["Gold", "Silver", "Bronze"], start=1):
    print(f"#{rank} - {medal}")

Try It — Zip & Enumerate Labकरके देखें — Zip & Enumerate Lab动手试试 — Zip 与 Enumerate 实验室

Four names, but only three scores. Pick a tool and see who gets paired, who gets dropped (struck through) and who gets a filler. Every result is real Python output.

चार नाम, पर सिर्फ़ तीन scores। एक tool चुनें और देखें किसकी जोड़ी बनी, कौन हटा (कटा हुआ) और किसे filler मिला। हर नतीजा असली Python output है।

四个名字，却只有三个分数。选一个工具，看看谁被配对、谁被丢掉（划线）、谁得到了填充值。每个结果都是真实的 Python 输出。

sorted() with a Key Function 🏆Key Function के साथ sorted() 🏆带 key 函数的 sorted() 🏆

sorted() can sort by any value you can compute from an item, using the key argument. Python calls the key function once per item, then sorts by those keys. This is where lambdas really shine.

sorted(), key argument से किसी भी ऐसी value से sort कर सकता है जो item से निकाली जा सके। Python हर item के लिए key function एक बार बुलाता है, फिर उन keys से sort करता है। यहीं lambdas असल में चमकते हैं।

sorted() 借助 key 参数，可以按能从元素算出的 任何 值排序。Python 对每个元素调用一次 key 函数，再按这些键排序。这正是 lambda 大放异彩的地方。

students = [
    {"name": "Aarav", "score": 85, "age": 22},
    {"name": "Meera", "score": 92, "age": 20},
    {"name": "Kabir", "score": 78, "age": 25},
    {"name": "Diya",  "score": 92, "age": 23},
]

# Sort by score, high to low
by_score = sorted(students, key=lambda s: s["score"], reverse=True)

# Score high to low, then age low to high (tie-breaker)
compound = sorted(students, key=lambda s: (-s["score"], s["age"]))

# Sort strings by their length, or ignoring case
words = ["banana", "pi", "Apple", "kiwi", "Cherry"]

print("By score: ", [s["name"] for s in by_score])
print("Compound: ", [s["name"] for s in compound])
print("By length:", sorted(words, key=len))
print("Plain:    ", sorted(words))
print("No case:  ", sorted(words, key=str.lower))

Notice "Plain" vs "No case": a plain string sort puts every capital letter before every small letter, so "Cherry" jumps ahead of "banana". key=str.lower fixes it.

"Plain" और "No case" पर ध्यान दें: सामान्य string sort हर बड़े अक्षर को हर छोटे अक्षर से पहले रखता है, इसलिए "Cherry", "banana" से आगे कूद जाता है। key=str.lower इसे ठीक करता है।

注意 "Plain" 和 "No case" 的区别：普通字符串排序把所有大写字母排在所有小写字母前面，所以 "Cherry" 跳到了 "banana" 前面。key=str.lower 能修正它。

Try It — Sort Key Labकरके देखें — Sort Key Lab动手试试 — 排序键实验室

Pick a key and watch the rows slide into their new places. The orange column shows the key Python actually compares. Look for ties — and see that rows with equal keys keep their original order.

एक key चुनें और rows को अपनी नई जगहों पर खिसकते देखें। नारंगी column वह key दिखाता है जिसकी Python असल में तुलना करता है। बराबरी देखें — और ध्यान दें कि बराबर keys वाली rows अपना मूल क्रम रखती हैं।

选一个键，看各行滑到新位置。橙色列显示 Python 实际比较的键。留意并列的情况 — 键相等的行会保持原来的顺序。

any() and all() — Quick Truth Tests ✅any() और all() — झटपट सच की जाँच ✅any() 和 all() — 快速真值测试 ✅

any() returns True if at least one item is truthy. all() returns True only if every item is. Both stop the moment the answer is decided.

any() True लौटाता है अगर कम से कम एक item truthy हो। all() True तभी लौटाता है जब हर item truthy हो। दोनों जवाब तय होते ही रुक जाते हैं।

只要 至少一个 元素为真，any() 就返回 True。只有 每个 元素都为真，all() 才返回 True。两者在答案确定的那一刻就停止。

nums = [2, 4, 6, 8, 10]

print(any(n > 5 for n in nums))       # at least one?
print(any(n > 100 for n in nums))
print(all(n % 2 == 0 for n in nums))  # every one?
print(all(n > 5 for n in nums))

# Edge cases worth remembering
print(any([]), all([]))               # empty: any -> False, all -> True

form = {"name": "Aarav", "email": "a@x.com", "age": 30}
required = ["name", "email", "age"]
if all(form.get(k) for k in required):
    print("Form is complete")

Proof of Short-CircuitingShort-Circuit का सबूत短路求值的证明

checked = []

def is_big(n):
    checked.append(n)
    return n > 50

data = [3, 8, 75, 12, 99, 4]
print(any(is_big(n) for n in data), "checked:", checked)

checked.clear()
print(any([is_big(n) for n in data]), "checked:", checked)

Try It — any/all Detectiveकरके देखें — any/all Detective动手试试 — any/all 侦探

Choose the data, the test, any or all, and whether to pass a generator or a list. Press Play and count the checks. The checks shown are the real calls Python made.

Data, जाँच, any या all, और generator या list देना है — चुनें। चलाएँ दबाएँ और जाँचें गिनें। दिखाई गई जाँचें वही असली calls हैं जो Python ने कीं।

选择数据、测试条件、any 或 all，以及传生成器还是列表。点 播放，数一数检查了几次。显示的检查就是 Python 真实发出的调用。

min(), max(), sum() — with Keys and Defaults 📏min(), max(), sum() — Keys और Defaults के साथ 📏min()、max()、sum() — 带键与默认值 📏

nums = [3, 7, 1, 9, 4]
print(min(nums), max(nums), sum(nums))

words = ["apple", "kiwi", "blueberry", "fig"]
print(min(words, key=len), max(words, key=len))

students = [{"name": "Aarav", "score": 85},
            {"name": "Meera", "score": 92},
            {"name": "Kabir", "score": 78}]
top = max(students, key=lambda s: s["score"])
print(f"Top student: {top['name']} with {top['score']}")

print(sum([10.5, 20.5, 30], 100))     # start value
print(sum([]))                        # empty sum is simply 0

try:
    max([])                           # but max/min of nothing is an error
except ValueError as e:
    print("ValueError:", e)
print(max([], default=0))             # ...unless you give a default

Practical Real-World Examples 🛠️असली दुनिया के उदाहरण 🛠️实用的真实示例 🛠️

Example 1 — Cleaning and Normalising User Inputउदाहरण 1 — User Input की सफ़ाई示例 1 — 清洗并规范用户输入

raw_emails = ["  Aarav@Example.com ", "", "MEERA@example.com",
              None, "  kabir@example.COM"]

# Chain: drop empty/None -> strip -> lowercase
clean = list(map(str.lower, map(str.strip, filter(None, raw_emails))))
print(clean)

# The same as a comprehension
print([e.strip().lower() for e in raw_emails if e])

Both lines give the same result. Nested map(map(filter(...))) is read from the inside out; the comprehension reads left to right. Most Python developers find the second easier.

दोनों lines एक ही नतीजा देती हैं। Nested map(map(filter(...))) अंदर से बाहर पढ़ा जाता है; comprehension बाएँ से दाएँ। ज़्यादातर Python developers को दूसरा आसान लगता है।

两行结果相同。嵌套的 map(map(filter(...))) 要从内往外读；推导式从左往右读。大多数 Python 开发者觉得后者更容易。

Example 2 — Building a Leaderboardउदाहरण 2 — Leaderboard बनाना示例 2 — 制作排行榜

scores = [("Aarav", 85), ("Meera", 92), ("Kabir", 78), ("Diya", 92), ("Isha", 65)]

# Top 3: score high to low, then name A-Z for ties
leaderboard = sorted(scores, key=lambda s: (-s[1], s[0]))[:3]

for rank, (name, score) in enumerate(leaderboard, start=1):
    print(f"#{rank}  {name:8s} {score}")

Example 3 — Running a Bank Balanceउदाहरण 3 — Bank Balance चलाना示例 3 — 计算银行余额

from functools import reduce

transactions = [
    {"type": "credit", "amount": 500},
    {"type": "debit",  "amount": 120},
    {"type": "credit", "amount": 250},
    {"type": "debit",  "amount": 75},
    {"type": "credit", "amount": 1000},
]

credits = sum(t["amount"] for t in transactions if t["type"] == "credit")

balance = reduce(
    lambda acc, t: acc + t["amount"] if t["type"] == "credit" else acc - t["amount"],
    transactions, 0,
)

print(f"Total credits: Rs {credits}")
print(f"Net balance:   Rs {balance}")

The total of credits uses sum() with a generator — clearer than sum(map(..., filter(...))). The balance genuinely needs custom logic (add or subtract), so it is a fair job for reduce. A plain for loop would be just as good.

Credits का कुल generator के साथ sum() इस्तेमाल करता है — sum(map(..., filter(...))) से साफ़। Balance को सच में custom logic चाहिए (जोड़ना या घटाना), इसलिए यह reduce का सही काम है। एक सामान्य for loop भी उतना ही अच्छा होता।

贷方总额用 sum() 配生成器 — 比 sum(map(..., filter(...))) 清晰。余额确实需要自定义逻辑（加或减），所以交给 reduce 很合理。普通的 for 循环也同样好。

Example 4 — Merging Parallel Dataउदाहरण 4 — समानांतर Data को जोड़ना示例 4 — 合并并行数据

ids    = [101, 102, 103, 104]
names  = ["Aarav", "Meera", "Kabir", "Diya"]
active = [True, False, True, True]

# Build a list of dicts from three parallel lists
users = [{"id": i, "name": n, "active": a} for i, n, a in zip(ids, names, active)]

# Keep only active users
for u in filter(lambda u: u["active"], users):
    print(u)

Map/Filter vs Comprehensions — Which to Use? ⚖️Map/Filter बनाम Comprehensions — कौन-सा इस्तेमाल करें? ⚖️Map/Filter 还是推导式 — 用哪个？⚖️

Every map or filter call can be rewritten as a comprehension. Most Python code prefers comprehensions for readability, but the functional form wins in a few cases.

हर map या filter call को comprehension में बदला जा सकता है। ज़्यादातर Python code पढ़ने में आसानी के लिए comprehensions पसंद करता है, पर कुछ मामलों में functional रूप जीतता है।

每个 map 或 filter 调用都能改写成推导式。大多数 Python 代码出于可读性偏爱推导式，但在少数情况下函数式写法更好。

Same Task, Two Stylesएक काम, दो शैलियाँ同一任务，两种风格

nums = [1, 2, 3, 4, 5, 6]

# map + filter - the functional style
result_a = list(map(lambda n: n ** 2, filter(lambda n: n % 2 == 0, nums)))

# List comprehension - the Pythonic style
result_b = [n ** 2 for n in nums if n % 2 == 0]

print(result_a)
print(result_b)

Performance — Are They Faster? ⚡Performance — क्या ये तेज़ हैं? ⚡性能 — 它们更快吗？⚡

A real measurement, 100 runs each over 100,000 numbers. The first three square numbers; the last two convert numbers to text.

असली माप, 100,000 संख्याओं पर हर एक 100 बार। पहले तीन संख्याओं का square करते हैं; आख़िरी दो संख्याओं को text में बदलते हैं।

真实测量：对 100,000 个数，每种写法运行 100 次。前三种求平方，后两种把数字转成文本。

import timeit

setup = "nums = list(range(100_000)); words = [str(n) for n in nums]"
tests = {
    "for loop + append":    "r = []\nfor n in nums: r.append(n * n)",
    "comprehension":        "r = [n * n for n in nums]",
    "map + lambda":         "r = list(map(lambda n: n * n, nums))",
    "[str(n) for ...]":     "r = [str(n) for n in nums]",
    "map(str, ...)":        "r = list(map(str, nums))",
}
for name, stmt in tests.items():
    t = timeit.timeit(stmt, setup=setup, number=100)
    print(f"{name:22} {t:.3f}s")

Quick Reference Table 📋झटपट Reference Table 📋速查表 📋

Golden Rules and Quick Quiz 🏆सुनहरे नियम और छोटा Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题