Python Variables & Memory — How Storage Works

The Story That Explains Python Variables 🏷️Python Variables समझाने वाली कहानी 🏷️一个解释 Python 变量的故事 🏷️

How Python Stores a Variable 🧠Python Variable कैसे Store करता है 🧠Python 如何存储变量 🧠

When you write a = 10, three things happen:

जब आप a = 10 लिखते हैं, तो तीन चीज़ें होती हैं:

当你写下 a = 10 时，会发生三件事：

a = 10
print(a)             # the value the name refers to
print(type(a))       # what kind of object it is
print(id(a))         # the object's identity (in CPython: its memory address)
print(hex(id(a)))    # the same number in hexadecimal

id() returns a number that is unique for each object while it is alive. In CPython (the normal Python from python.org) it is the object's memory address. The exact number changes from run to run, so yours will differ. Small ints such as 10 sit in a fixed area set up when Python starts, which is why their ids look shorter.

id() एक संख्या लौटाता है जो हर जीवित object के लिए अनोखी होती है। CPython (python.org वाला सामान्य Python) में यह object का memory address है। सटीक संख्या हर run में बदलती है, इसलिए आपकी अलग होगी। 10 जैसे छोटे ints Python शुरू होने पर बने एक तय हिस्से में रहते हैं, इसीलिए उनके ids छोटे दिखते हैं।

id() 返回一个数字，在对象存活期间对每个对象唯一。在 CPython（python.org 提供的标准 Python）中，它就是对象的内存地址。具体数字每次运行都不同，你的结果会不一样。10 这样的小整数位于 Python 启动时准备好的固定区域，所以它们的 id 看起来更短。

What Happens When You Write a = 20? 🔄a = 20 लिखने पर क्या होता है? 🔄写下 a = 20 时发生了什么？🔄

The old number is not overwritten. Integers are immutable — they can never change. So Python makes (or finds) a new object and moves the name to it. You can prove it with id(). Lists are different: they are mutable, so append changes the same object and the id stays the same.

पुरानी संख्या overwrite नहीं होती। Integers immutable हैं — वे कभी नहीं बदलते। इसलिए Python एक नया object बनाता (या ढूँढता) है और नाम उस पर ले जाता है। id() से यह साबित कर सकते हैं। Lists अलग हैं: वे mutable हैं, इसलिए append उसी object को बदलता है और id वही रहता है।

旧数字不会被覆盖。整数是不可变的 —— 永远不能修改。所以 Python 创建（或找到）一个新对象，再把名字移过去。用 id() 可以证明。列表不同：它们是可变的，append 修改的是同一个对象，id 保持不变。

a = 1000
first = id(a)
a = 2000                          # reassignment: a NEW object
print(a, id(a) == first)

x = 1000
before = id(x)
x = x + 1                         # builds a new int 1001, then rebinds x
print(x, id(x) == before)

x += 1                            # same thing: ints cannot change in place
print(x, id(x) == before)

nums = [1, 2]
before = id(nums)
nums.append(3)                    # mutation: the SAME list object changes
nums += [4]                       # for lists, += also changes it in place
print(nums, id(nums) == before)

nums = nums + [5]                 # + builds a NEW list, then rebinds
print(nums, id(nums) == before)

When Is the Old Object Freed?पुराना Object कब मुक्त होता है?旧对象什么时候被释放？

CPython counts how many references point to each object. When the count drops to zero, the object is freed immediately — not "eventually". The separate garbage collector is only needed for objects that refer to each other in a cycle. This class prints a message when it is freed, so you can watch it happen:

CPython गिनता है कि हर object की ओर कितने references हैं। जब गिनती शून्य होती है, object तुरंत मुक्त होता है — "कभी बाद में" नहीं। अलग garbage collector की ज़रूरत सिर्फ़ उन objects के लिए है जो एक-दूसरे की ओर cycle में इशारा करते हैं। यह class मुक्त होने पर message छापती है, ताकि आप इसे होते देख सकें:

CPython 统计每个对象被多少个引用指向。计数降到零时，对象会立即被释放 —— 而不是“迟早”。独立的垃圾回收器只用于互相引用形成循环的对象。下面这个类在被释放时会打印消息，你可以亲眼看到这一过程：

class Tracker:
    """A tiny object that announces when Python frees it."""
    def __init__(self, label):
        self.label = label
        print(f"  created {label}")

    def __del__(self):
        print(f"  freed   {self.label}")


print("t = Tracker('first')")
t = Tracker("first")
print("t = Tracker('second')   # rebind t")
t = Tracker("second")            # 'first' has no names left → freed at once
print("u = t                   # a second name")
u = t
print("del t")
del t                            # 'second' still has the name u
print("del u")
del u                            # last name gone → freed now
print("end of program")

Small ints from −5 to 256 are an exception: they are created once at start-up and are never freed.

−5 से 256 तक के छोटे ints अपवाद हैं: वे start पर एक बार बनते हैं और कभी मुक्त नहीं होते।

−5 到 256 的小整数是例外：它们在启动时创建一次，永远不会被释放。

Why a++ and a-- Do Not Exist in Python 🚫Python में a++ और a-- क्यों नहीं हैं 🚫为什么 Python 没有 a++ 和 a-- 🚫

In C, Java and JavaScript, a++ means "add 1 to a". Python does not have it:

C, Java और JavaScript में a++ का मतलब है "a में 1 जोड़ो"। Python में यह नहीं है:

在 C、Java 和 JavaScript 中，a++ 表示“a 加 1”。Python 没有这个运算符：

a = 5
a++

Worse, ++a and --a are valid — they are just two unary pluses or minuses — so they run without error and change nothing:

इससे बुरा, ++a और --a मान्य हैं — ये बस दो unary plus या minus हैं — इसलिए बिना error चलते हैं और कुछ नहीं बदलते:

更糟的是，++a 和 --a 是合法的 —— 只是两个一元正号或负号 —— 所以运行不会报错，却什么也没改变：

a = 5
print(++a, --a, a)      # +(+a) and -(-a): no change at all
a += 1
print(a)

counter = 0
for _ in range(5):
    ++counter            # looks like C, silently does nothing
print("with ++counter:", counter)

counter = 0
for _ in range(5):
    counter += 1
print("with counter += 1:", counter)

Why? Three Reasons From Python’s Designक्यों? Python के Design से तीन कारण为什么？来自 Python 设计的三个原因

The −5 to 256 Rule — Small Integer Caching 🧊−5 से 256 का नियम — Small Integer Caching 🧊−5 到 256 规则 —— 小整数缓存 🧊

Try this in the interactive REPL, one line at a time:

इसे interactive REPL में एक-एक line करके आज़माएँ:

在交互式 REPL 中逐行试试：

Same code, opposite answers for 100 and 1000. The reason: when CPython starts, it creates every int from −5 to 256 once and reuses those objects everywhere. Ask for 100 and you always get the shared object. Ask for 1000 and you usually get a new one. To test the edges fairly, build the numbers at run time with int(str(n)):

वही code, 100 और 1000 के लिए उल्टे जवाब। कारण: CPython शुरू होते समय −5 से 256 तक का हर int एक बार बनाता है और उन्हें हर जगह दोबारा इस्तेमाल करता है। 100 माँगें तो हमेशा साझा object मिलता है। 1000 माँगें तो अक्सर नया मिलता है। किनारों को ठीक से जाँचने के लिए संख्याएँ run time पर int(str(n)) से बनाएँ:

同样的代码，100 和 1000 的结果却相反。原因是：CPython 启动时会把 −5 到 256 的每个整数创建一次，并在各处复用这些对象。请求 100 总会拿到共享对象；请求 1000 通常会得到新对象。为了公平地测试边界，用 int(str(n)) 在运行时生成数字：

# int(str(n)) builds each number at run time, like real data does
for n in [-6, -5, 0, 100, 256, 257, 1000]:
    a = int(str(n))
    b = int(str(n))
    print(f"{n:>5}: a == b → {a == b},  a is b → {a is b}")

But beware of the classic demo print(257 is 257) or x = 1000; y = 1000 in a script. Inside one file the compiler stores each constant once, so both names get the same object and the answer is True:

पर script में print(257 is 257) या x = 1000; y = 1000 वाले पुराने demo से सावधान रहें। एक file के अंदर compiler हर constant एक बार रखता है, इसलिए दोनों नामों को वही object मिलता है और जवाब True आता है:

但要小心经典演示 —— 在脚本里写 print(257 is 257) 或 x = 1000; y = 1000。同一个文件中，编译器对每个常量只存一份，所以两个名字拿到的是同一个对象，结果为 True：

x = 1000
y = 1000
print(x is y)      # True here! Both lines are in ONE file, so the compiler
                   # stores the constant 1000 once and reuses it.
print(x == y)

Why Cache −5 to 256?−5 से 256 तक cache क्यों?为什么缓存 −5 到 256？

Type Conversion — int(), float(), str() 🔁Type Conversion — int(), float(), str() 🔁类型转换 —— int()、float()、str() 🔁

An object's type can never change. To "convert", you call a function that builds a new object of the type you want. The original stays as it was.

किसी object का type कभी नहीं बदलता। "बदलने" के लिए आप एक function बुलाते हैं जो चाहे गए type का नया object बनाता है। मूल वैसा ही रहता है।

对象的类型永远不会改变。所谓“转换”，是调用一个函数，构建所需类型的新对象。原对象保持不变。

int() — building a new integerint() — नया integer बनानाint() —— 构建新整数

print(int("42"), int("-17"), int("  100  "), int("1_000"))
print(int(3.9), int(-3.9), round(3.9))          # int() cuts toward zero
print(int(True), int(False))
print(int("101", 2), int("FF", 16), int("777", 8), int("0x1F", 0))
print(int("४२"), int("١٢٣"))                     # Devanagari and Arabic-Indic digits work too
for bad in ["3.14", "hello", ""]:
    try:
        int(bad)
    except ValueError as err:
        print("ValueError:", err)
print(int(float("3.14")))

Notice int("४२") gives 42: int() accepts digits from any script that Unicode marks as decimal digits, including Devanagari and Arabic-Indic.

ध्यान दें int("४२") 42 देता है: int() किसी भी लिपि के वे अंक मानता है जिन्हें Unicode decimal digits मानता है, Devanagari और Arabic-Indic समेत।

注意 int("४२") 得到 42：int() 接受 Unicode 标记为十进制数字的任何文字的数字，包括天城文和阿拉伯-印度数字。

float() — building a new floatfloat() — नया float बनानाfloat() —— 构建新浮点数

print(float("3.14"), float("-0.5"), float("1e-3"), float("6.022e23"))
print(float(7), float(-42), float(True), float(False))
print(float("inf"), float("-inf"), float("nan"), float(" 2.5 "))
try:
    float("3,14")
except ValueError as err:
    print("ValueError:", err)

str() — building a new stringstr() — नई string बनानाstr() —— 构建新字符串

print(str(42), str(3.14), str(True), str(None))
print(str([1, 2, 3]), str({"a": 1}))
print(repr(str(42)))            # quotes show it is now text

age = 25
try:
    msg = "I am " + age
except TypeError as err:
    print("TypeError:", err)
print("I am " + str(age))
print(f"I am {age}")            # f-strings convert for you

Conversion Cheat SheetConversion Cheat Sheet转换速查表

Every cell above was computed by Python while building this page. A conversion always makes a new object — the original is untouched:

ऊपर का हर cell यह page बनाते समय Python ने निकाला। Conversion हमेशा नया object बनाता है — मूल वैसा ही रहता है:

上表的每个单元格都是生成本页时由 Python 计算的。转换总是生成新对象 —— 原对象不受影响：

s = "42"
n = int(s)
print(type(s).__name__, type(n).__name__, s is n, id(s) == id(n))
print(repr(s))                  # the string is untouched

Putting It All Together — Practice Program 🧪सब एक साथ — अभ्यास Program 🧪综合运用 —— 练习程序 🧪

This script shows every idea from the lesson with real ids. Run it yourself: your ids will be different numbers, but every True/False will match.

यह script lesson का हर विचार असली ids के साथ दिखाती है। इसे ख़ुद चलाएँ: आपके ids अलग संख्याएँ होंगे, पर हर True/False मेल खाएगा।

这个脚本用真实的 id 展示了本课的每个概念。自己运行一下：你的 id 数字会不同，但每个 True/False 都会一致。

# variable_lab.py — every idea from this lesson in one script


def show(name, value):
    """Print a name, its value, its type and its object id."""
    print(f"  {name:<7} = {value!r:<7} type={type(value).__name__:<6} id={id(value)}")


def main():
    line = "─" * 48

    print(f"{line}\n  1. Binding — a = 1000\n{line}")
    a = 1000
    show("a", a)
    first = id(a)

    print(f"\n{line}\n  2. Reassignment — a = 2000\n{line}")
    a = 2000
    show("a", a)
    print(f"  same object as before? {id(a) == first}")

    print(f"\n{line}\n  3. a += 1 (Python's answer to a++)\n{line}")
    before = id(a)
    a += 1
    show("a", a)
    print(f"  same object as before? {id(a) == before}")

    print(f"\n{line}\n  4. Mutation keeps the id\n{line}")
    scores = [90, 85]
    before = id(scores)
    scores.append(70)
    print(f"  {scores} — same object? {id(scores) == before}")

    print(f"\n{line}\n  5. Small-int cache (numbers made at run time)\n{line}")
    for n in ("100", "1000"):
        x, y = int(n), int(n)
        print(f"  int({n!r}) is int({n!r}) → {x is y}   == → {x == y}")

    print(f"\n{line}\n  6. Conversions build new objects\n{line}")
    user_input = "42"                  # imagine this came from input()
    show("text", user_input)
    show("as_int", int(user_input))
    show("as_flt", float(user_input))
    show("back", str(int(user_input)))

    print(f"\n{line}\n  7. Counter loop — the Pythonic way\n{line}")
    counter = 0
    for _ in range(5):
        counter += 1                   # NOT counter++
    print(f"  final counter: {counter}")


if __name__ == "__main__":
    main()

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