Python Syntax, Variables & Data Types

The Story That Explains Python Syntax 🗾Python Syntax समझाने वाली कहानी 🗾一个解释 Python 语法的故事 🗾

Syntax is the set of rules for how Python code must be written so that Python can read it. It covers how you name things, how statements end, how you group code into blocks, and how you write expressions. Python checks the syntax of the whole file before it runs the first line.

Syntax वे नियम हैं जिनके हिसाब से Python code लिखा जाना चाहिए ताकि Python उसे पढ़ सके। इसमें आता है कि चीज़ों के नाम कैसे रखें, statements कैसे ख़त्म हों, code को blocks में कैसे बाँटें, और expressions कैसे लिखें। Python पहली line चलाने से पहले पूरी file का syntax जाँचता है।

语法是 Python 代码必须遵守的书写规则，这样 Python 才能读懂它。它包括怎么命名、语句怎么结束、怎样把代码分成块，以及怎么写表达式。Python 在运行第一行之前，会先检查整个文件的语法。

Python Syntax — Five Basic Rules 📐Python Syntax — पाँच बुनियादी नियम 📐Python 语法 —— 五条基本规则 📐

Learn these five rules and you can read most beginner Python code. Everything else builds on them.

ये पाँच नियम सीख लें तो आप beginner स्तर का ज़्यादातर Python code पढ़ सकते हैं। बाक़ी सब इन्हीं पर बनता है।

掌握这五条规则，你就能读懂大多数入门级 Python 代码。其他内容都建立在它们之上。

Indentation — Python's Defining Feature 📏Indentation — Python की पहचान 📏缩进 —— Python 的标志性特征 📏

In most languages indentation only makes code look tidy. In Python, indentation is the structure: it decides which lines belong to an if, a loop or a function.

ज़्यादातर भाषाओं में indentation सिर्फ़ code को साफ़ दिखाता है। Python में indentation ही structure है: यह तय करता है कि कौन सी lines किसी if, loop या function का हिस्सा हैं।

在大多数语言里，缩进只是让代码好看。在 Python 里，缩进就是结构：它决定哪些行属于某个 if、循环或函数。

temperature = 34

# CORRECT — every line in a block has the same indentation (4 spaces is the standard)
if temperature > 30:
    print("It's hot outside")
    print("Stay hydrated")
else:
    print("Weather is fine")

Remove the indent and Python refuses to start. The message names the line and the reason:

Indent हटाएँ तो Python शुरू ही नहीं होता। Message line और कारण बताता है:

去掉缩进，Python 就拒绝运行。报错信息会指出行号和原因：

temperature = 34
if temperature > 30:
print("It's hot outside")

Out of the 64 combinations in the lab, only 9 run at all. The rest fail before a single line executes. Some of the ones that run do something different from what you meant — for example, indenting print("Done") moves it inside the if, so with age 15 it never prints.

Lab के 64 combinations में से सिर्फ़ 9 चलते हैं। बाक़ी एक भी line चलने से पहले असफल हो जाते हैं। जो चलते हैं उनमें से कुछ वह नहीं करते जो आप चाहते थे — जैसे print("Done") को indent करने से वह if के अंदर चला जाता है, तो age 15 पर वह कभी नहीं छपता।

实验室里的 64 种组合中，只有 9 种能运行，其余的在执行任何一行之前就失败了。能运行的组合里，有些做的事情和你想的不一样 —— 例如把 print("Done") 缩进，它就进入了 if 块，age 为 15 时根本不会打印。

Tabs and spaces look the same on screen, but Python counts them differently. Mix them in one block and you get a TabError (the file below has 8 spaces on line 2 and one tab on line 3):

Tabs और spaces screen पर एक जैसे दिखते हैं, पर Python उन्हें अलग गिनता है। एक block में दोनों मिलाएँ तो TabError मिलता है (नीचे की file में line 2 पर 8 spaces और line 3 पर एक tab है):

Tab 和空格在屏幕上看起来一样，但 Python 对它们的计数不同。同一块中混用就会得到 TabError（下面的文件第 2 行是 8 个空格，第 3 行是一个 tab）：

if True:
        print("8 spaces")
	print("1 tab")

Comments and Docstrings 💬Comments और Docstrings 💬注释与文档字符串 💬

Comments are notes for people. Python skips them completely. A docstring is different: it is a string written as the first statement of a function, class or module, and Python keeps it, so tools and help() can show it.

Comments लोगों के लिए notes हैं। Python उन्हें पूरी तरह छोड़ देता है। Docstring अलग है: यह function, class या module का पहला statement होता है, और Python इसे रखता है, ताकि tools और help() इसे दिखा सकें।

注释是写给人看的，Python 会完全跳过。文档字符串（docstring）不同：它是函数、类或模块的第一条语句，Python 会保留它，供工具和 help() 显示。

# A single-line comment: Python skips this line
x = 42  # an inline comment, after the code


def greet(name):
    """Return a personalised greeting message.

    Args:
        name (str): The person's name.

    Returns:
        str: A greeting like 'Hello, Asha!'
    """
    return f"Hello, {name}!"


print(greet("Asha"))
print(greet.__doc__)

Notice the docstring prints without its left margin. Since Python 3.13, the compiler removes the common leading spaces from docstrings. On Python 3.12 and older, the indented lines would print with their original 4 extra spaces. Python has no special multi-line comment syntax — put # at the start of each line.

ध्यान दें docstring बाएँ margin के बिना छपा। Python 3.13 से compiler docstrings से साझा leading spaces हटा देता है। Python 3.12 और पुराने में indented lines अपने 4 अतिरिक्त spaces के साथ छपतीं। Python में multi-line comment का कोई अलग syntax नहीं — हर line की शुरुआत में # लगाएँ।

注意文档字符串打印时没有左边的缩进。从 Python 3.13 起，编译器会去掉文档字符串中共同的前导空格；在 3.12 及更早版本中，缩进的行会带着原来多出的 4 个空格打印。Python 没有专门的多行注释语法 —— 在每行开头加 # 即可。

Variables — Name Tags for Your Data 🏷️Variables — आपके Data के Name Tags 🏷️变量 —— 数据的名字标签 🏷️

Creating Variables — No Declaration NeededVariables बनाना — Declaration की ज़रूरत नहीं创建变量 —— 无需声明

In C or Java you declare a type first: int age = 25;. In Python you just assign with = and the name exists. The value has a type; the name does not, so the same name can later point to a value of another type.

C या Java में पहले type declare करते हैं: int age = 25;। Python में बस = से assign करें और नाम बन जाता है। Type मान का होता है, नाम का नहीं, इसलिए वही नाम बाद में दूसरे type के मान की ओर इशारा कर सकता है।

在 C 或 Java 中要先声明类型：int age = 25;。在 Python 中，用 = 赋值，名字就存在了。类型属于值，不属于名字，所以同一个名字之后可以指向另一种类型的值。

# Create a variable by assigning a value — no type declaration
name = "Asha"
age = 30
height = 5.7
is_student = False

print(type(name))
print(type(age))
print(type(height))
print(type(is_student))

# The same name can later point to a value of a different type
x = 10
x = "ten"
x = [1, 2, 3]
print(x, type(x))

Naming Rules and Conventions ✍️नाम रखने के नियम और परंपराएँ ✍️命名规则与约定 ✍️

Python has rules (break them and the code will not run) and conventions (break them and the code runs, but other developers find it harder to read). Both matter.

Python में नियम हैं (तोड़ें तो code नहीं चलेगा) और परंपराएँ (तोड़ें तो code चलेगा, पर दूसरे developers को पढ़ना मुश्किल लगेगा)। दोनों ज़रूरी हैं।

Python 有规则（违反则代码无法运行）和约定（违反后代码能跑，但别人更难读懂）。两者都重要。

# Names may use letters from any language, digits and underscores
नाम = "Mohit"
名字 = "李华"
total_price_2026 = 499
print(नाम, 名字, total_price_2026)

import keyword
print(len(keyword.kwlist), "keywords, for example:", keyword.kwlist[:6])
print("soft keywords:", keyword.softkwlist)

# Shadowing a built-in breaks it
list = [1, 2, 3]
try:
    print(list("abc"))
except TypeError as err:
    print("TypeError:", err)
del list                     # remove our variable; the built-in list() works again
print(list("abc"))

The last part shows a real trap. After list = [1, 2, 3], the name list points to your list, so calling list("abc") fails. Deleting your variable with del list brings the built-in back. The four soft keywords (match, case, type, _) act as keywords only in special places, so they are still allowed as names.

आख़िरी हिस्सा एक असली जाल दिखाता है। list = [1, 2, 3] के बाद नाम list आपकी list की ओर इशारा करता है, इसलिए list("abc") असफल होता है। del list से अपना variable हटाने पर built-in वापस आ जाता है। चार soft keywords (match, case, type, _) सिर्फ़ ख़ास जगहों पर keyword की तरह काम करते हैं, इसलिए नाम के रूप में अब भी चलते हैं।

最后一部分展示了一个真实陷阱。执行 list = [1, 2, 3] 后，名字 list 指向你的列表，于是 list("abc") 出错。用 del list 删除你的变量后，内置函数就回来了。四个软关键字（match、case、type、_）只在特定位置才充当关键字，所以仍可用作名字。

PEP 8 Naming ConventionsPEP 8 नामकरण परंपराएँPEP 8 命名约定

Multiple Assignment and Swapping 🔄Multiple Assignment और Swapping 🔄多重赋值与交换 🔄

Python can assign several names in one line, and swap two values without a temporary variable. The right side is evaluated first, then unpacked into the names on the left.

Python एक line में कई नाम assign कर सकता है, और बिना temporary variable के दो मान swap कर सकता है। पहले दाईं ओर का हिस्सा evaluate होता है, फिर बाईं ओर के नामों में बँटता है।

Python 可以一行给多个名字赋值，也可以不用临时变量交换两个值。右边先被求值，然后拆开分给左边的名字。

x, y, z = 10, 20, 30
print(x, y, z)

a = b = c = 0
print(a, b, c)

a, b = 5, 10
a, b = b, a                  # swap in one line
print(a, b)

coordinates = [28.6139, 77.2090]      # New Delhi
latitude, longitude = coordinates
print(f"Lat: {latitude}, Lon: {longitude}")

# careful: a = b = [] gives ONE list two names
p = q = []
p.append("shared!")
print(q)

Data Types — The Four Basic Types 🧩Data Types — चार बुनियादी Types 🧩数据类型 —— 四种基本类型 🧩

This lesson covers the four basic built-in types you will use every day: int, float, str and bool. They are not the only ones. Python also has None (meaning "no value"), complex numbers, and collection types such as list and dict that hold other values. Collections come in the next lessons.

यह lesson चार बुनियादी built-in types सिखाता है जो आप रोज़ इस्तेमाल करेंगे: int, float, str और bool। ये अकेले types नहीं हैं। Python में None ("कोई मान नहीं"), complex संख्याएँ, और list व dict जैसे collection types भी हैं जो दूसरे मान रखते हैं। Collections अगले lessons में आएँगे।

本课讲解每天都会用到的四种基本内置类型：int、float、str 和 bool。它们并不是全部类型。Python 还有 None（表示“没有值”）、complex 复数，以及 list、dict 等可以容纳其他值的容器类型。容器类型将在后续课程介绍。

int — Whole Numbers 🔢int — पूर्ण संख्याएँ 🔢int —— 整数 🔢

Integers are exact and have no fixed size. In C or Java a 32-bit int overflows after 2³¹ − 1 (about 2.1 billion). Python just uses more memory for bigger numbers.

Integers सटीक होते हैं और उनका कोई तय आकार नहीं। C या Java में 32-bit int 2³¹ − 1 (लगभग 2.1 अरब) के बाद overflow हो जाता है। Python बड़ी संख्याओं के लिए बस ज़्यादा memory लेता है।

整数是精确的，且没有固定大小。在 C 或 Java 中，32 位 int 超过 2³¹ − 1（约 21 亿）就会溢出。Python 只是为更大的数使用更多内存。

age = 25
population = 8_000_000_000      # underscores make big numbers readable
big_number = 10 ** 100
print(type(age), population, len(str(big_number)), "digits")

a, b = 17, 5
print(a + b, a - b, a * b)
print(a / b)        # true division: always a float
print(a // b)       # floor division
print(a % b)        # remainder
print(a ** b)       # power
print(-17 // 5, -17 % 5)    # floor division rounds DOWN, toward minus infinity
print(0b1010, 0o17, 0xFF)   # binary, octal, hexadecimal literals
print(10 / 2)

"No size limit" has one practical catch. Converting a huge int to text is limited to 4300 digits by default (since Python 3.11), to protect servers from slow conversions. The number itself is fine. The same script also shows how much memory a few objects really use:

"आकार की कोई सीमा नहीं" में एक व्यावहारिक पेच है। बहुत बड़े int को text में बदलना default रूप से 4300 अंकों तक सीमित है (Python 3.11 से), ताकि servers धीमे conversions से बचें। संख्या ख़ुद ठीक रहती है। यही script यह भी दिखाती है कि कुछ objects असल में कितनी memory लेते हैं:

“没有大小限制”有一个实际的例外：默认情况下（自 Python 3.11 起），把超大整数转成文本最多允许 4300 位，以防服务器被缓慢的转换拖垮。数字本身没问题。同一脚本还显示了几个对象实际占用的内存：

import sys
print(sys.getsizeof(True), sys.getsizeof(0), sys.getsizeof(10**100))   # bytes per object
print(sys.getsizeof(0.1))               # every float object is the same size
print(sys.float_info.dig, sys.float_info.max)

big = 10 ** 5000                        # the int itself is fine
print(big.bit_length(), "bits")
try:
    print(str(big))
except ValueError as err:
    print("ValueError:", err)
sys.set_int_max_str_digits(0)           # 0 = no limit (only if you really need it)
print(len(str(big)), "digits")

Reading the first lines: True and 0 each take 28 bytes as Python objects (not 1 bit), and 10**100 takes 72 bytes because it needs more digits. Every float object takes 24 bytes; 8 of them hold the 64-bit value.

पहली lines पढ़ें: True और 0 Python objects के रूप में 28-28 bytes लेते हैं (1 bit नहीं), और 10**100 72 bytes लेता है क्योंकि उसे ज़्यादा अंक चाहिए। हर float object 24 bytes लेता है; उनमें से 8 में 64-bit मान रहता है।

看前几行：True 和 0 作为 Python 对象各占 28 字节（不是 1 位），10**100 需要更多位数，占 72 字节。每个 float 对象占 24 字节，其中 8 字节存放 64 位数值。

float — Decimal Numbers 📏float — दशमलव संख्याएँ 📏float —— 小数 📏

Floats store real numbers in 64-bit binary (IEEE 754 double precision, the same as double in C and Java). That gives about 15–17 significant digits and a range up to about 1.8 × 10³⁰⁸.

Floats वास्तविक संख्याओं को 64-bit binary में store करते हैं (IEEE 754 double precision, C और Java के double जैसा)। इससे लगभग 15–17 सार्थक अंक और लगभग 1.8 × 10³⁰⁸ तक की range मिलती है।

浮点数用 64 位二进制存储实数（IEEE 754 双精度，与 C、Java 的 double 相同），约有 15–17 位有效数字，范围可达约 1.8 × 10³⁰⁸。

price = 19.99
tiny = 1e-8
huge = 6.022e23
print(type(price), tiny, huge, float(7))

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
import math
print(math.isclose(0.1 + 0.2, 0.3))
print(round(0.1 + 0.2, 1))
print(round(2.5), round(3.5))       # round-half-to-even ("banker's rounding")

from decimal import Decimal
print(Decimal("0.1") + Decimal("0.2"))
print(Decimal(0.1))                 # the value really stored for 0.1

print(float("inf") > 10**308, float("nan") == float("nan"))

Two surprises are worth remembering. First, 0.1 + 0.2 == 0.3 is False; compare floats with math.isclose(). Second, round() sends halves to the nearest even number ("banker's rounding"), so round(2.5) is 2. The Decimal(0.1) line shows the value the computer really stores for 0.1.

दो आश्चर्य याद रखने लायक़ हैं। पहला, 0.1 + 0.2 == 0.3 False है; floats की तुलना math.isclose() से करें। दूसरा, round() आधे को सबसे नज़दीकी even संख्या पर ले जाता है ("banker's rounding"), इसलिए round(2.5) है 2। Decimal(0.1) वाली line दिखाती है कि computer 0.1 के लिए असल में कौन सा मान store करता है।

有两个意外值得记住。第一，0.1 + 0.2 == 0.3 为 False；比较浮点数请用 math.isclose()。第二，round() 把 .5 舍入到最近的偶数（“银行家舍入”），所以 round(2.5) 是 2。Decimal(0.1) 那一行显示了计算机为 0.1 实际存储的值。

int vs float — Quick Comparisonint बनाम float — झटपट तुलनाint 与 float —— 快速对比

str — Text 🔤str — Text 🔤str —— 文本 🔤

A string is a sequence of characters. It is immutable: you cannot change one character inside it. Methods like .upper() or .replace() return a new string and leave the old one as it was.

String characters का एक क्रम है। यह immutable है: इसके अंदर एक character भी नहीं बदल सकते। .upper() या .replace() जैसे methods एक नई string लौटाते हैं और पुरानी को वैसा ही छोड़ देते हैं।

字符串是字符序列，它是不可变的：不能修改其中某个字符。.upper()、.replace() 等方法返回一个新字符串，原字符串保持不变。

Creating Strings — Four WaysStrings बनाना — चार तरीक़े创建字符串 —— 四种方式

msg1 = 'Hello, World!'
msg2 = "Hello, World!"                 # same as single quotes
poem = """Roses are red,
Violets are blue."""
path = r"C:\Users\new_folder\test"     # raw string: backslashes kept as they are
print(msg1 == msg2)
print(poem)
print(path)

path = "C:\Users\new_folder"     # no r prefix: \U starts an escape
print(path)

String Operations — The Essential ToolkitString Operations — ज़रूरी औज़ार字符串操作 —— 必备工具箱

first, last = "Hello", "World"
print(first + " " + last)
print("─" * 20)
word = "Python"
print(len(word), word[0], word[-1], word[2:5], word[::-1])

text = "  Hello, Python World!  "
print(repr(text.strip()))
print(repr(text.lower()))
print(text.replace("Python", "Coding"))
print(text.split(","))
print("Python" in text)
print(text.count("o"))           # Hello, Python, World → 3
print(text.startswith("  H"))

try:
    word[0] = "J"
except TypeError as err:
    print("TypeError:", err)     # strings are immutable
print("J" + word[1:])            # make a new string instead

repr() is used on two lines so you can see the spaces that .strip() removed. Note text.count("o") is 3 (Hello, Python, World). The last two lines show immutability: assigning to word[0] fails, so you build a new string instead.

दो lines पर repr() लगाया है ताकि आप वे spaces देख सकें जो .strip() ने हटाए। ध्यान दें text.count("o") 3 है (Hello, Python, World)। आख़िरी दो lines immutability दिखाती हैं: word[0] में assign करना असफल होता है, इसलिए नई string बनाते हैं।

有两行用了 repr()，方便你看到 .strip() 去掉的空格。注意 text.count("o") 是 3（Hello、Python、World）。最后两行展示了不可变性：给 word[0] 赋值会失败，所以要生成新字符串。

f-Strings — The Modern Way to Format Textf-Strings — Text Format करने का आधुनिक तरीक़ाf-string —— 现代的文本格式化方式

Put f before the quotes and write any expression inside { }. After a colon you can add a format spec that controls commas, decimals, percentages, padding and alignment. f-strings arrived in Python 3.6; the {age = } debugging form arrived in 3.8.

Quotes से पहले f लगाएँ और { } के अंदर कोई भी expression लिखें। Colon के बाद एक format spec जोड़ सकते हैं जो commas, दशमलव, प्रतिशत, padding और alignment तय करता है। f-strings Python 3.6 में आए; {age = } वाला debugging रूप 3.8 में।

在引号前加 f，就能在 { } 中写任意表达式。冒号后面可以加格式说明（format spec），控制千位分隔符、小数位、百分比、填充和对齐。f-string 在 Python 3.6 引入；{age = } 调试写法在 3.8 引入。

name, age, salary = "Asha", 30, 75000.50
print(f"Name: {name}, Age: {age}")
print(f"In 5 years: {age + 5}")
print(f"Uppercase: {name.upper()}")
print(f"Salary: ₹{salary:,.2f}")
print(f"Percentage: {0.856:.1%}")
print(f"Binary of 10: {10:b}")
print(f"Padded: {age:05d}")
print(f"[{'hi':<10}] [{'hi':>10}] [{'hi':^10}]")
print(f"{age = }")               # handy for debugging (Python 3.8+)

Escape CharactersEscape Characters转义字符

print("Line1\nLine2")
print("Col1\tCol2")
print("C:\\Users")
print('It\'s fine')
print("He said \"hi\"")

bool — True or False 💡bool — True या False 💡bool —— 真或假 💡

A boolean has only two values: True and False, with a capital first letter. Comparisons produce booleans, and every if and while uses one to decide what to do.

Boolean के सिर्फ़ दो मान हैं: True और False, पहला अक्षर capital। Comparisons से booleans बनते हैं, और हर if और while फ़ैसला करने के लिए इन्हीं का इस्तेमाल करता है।

布尔值只有两个：True 和 False，首字母大写。比较运算产生布尔值，每个 if 和 while 都靠它来决定怎么做。

is_active = True
print(type(is_active))
print(10 > 5, 10 == 5, 10 != 5, 10 >= 10, "abc" == "ABC")

x = 15
print(x > 10 and x < 20)
print(x > 10 or x > 100)
print(not (x > 10))

print(True + True, True * 10, False + 7)       # bool is a kind of int
scores = [85, 42, 91, 58, 73, 95]
passed = sum(s >= 60 for s in scores)
print(f"Students passed: {passed}/{len(scores)}")

Because bool is a subclass of int, True counts as 1 and False as 0. That is why sum(s >= 60 for s in scores) counts the passing scores.

क्योंकि bool, int का subclass है, True 1 गिना जाता है और False 0। इसीलिए sum(s >= 60 for s in scores) पास होने वाले scores गिनता है।

因为 bool 是 int 的子类，True 算作 1，False 算作 0。所以 sum(s >= 60 for s in scores) 能数出及格的分数个数。

Truthy and Falsy ValuesTruthy और Falsy मान真值与假值

Any value can be used where Python expects a boolean. A short list of values count as falsy; everything else is truthy.

जहाँ Python boolean चाहता है वहाँ कोई भी मान इस्तेमाल हो सकता है। कुछ गिने-चुने मान falsy हैं; बाक़ी सब truthy।

在 Python 需要布尔值的地方可以使用任何值。只有少数几个值算作假值（falsy），其余都是真值（truthy）。

username = ""
if username:
    print(f"Welcome, {username}")
else:
    print("No username provided")

name = ""
display_name = name or "Anonymous"
print(display_name)

items = []
if not items:
    print("Cart is empty")

for value in [0, 0.0, "", [], {}, None, "0", "False", " ", [0]]:
    print(f"{value!r:>8} → {bool(value)}")

Type Conversion (Casting) 🔁Type Conversion (Casting) 🔁类型转换 🔁

Built-in functions turn a value of one type into another. You need this all the time, because input() always returns a string, even when the user types a number.

Built-in functions एक type के मान को दूसरे में बदलते हैं। इसकी ज़रूरत बार-बार पड़ती है, क्योंकि input() हमेशा string लौटाता है, चाहे user संख्या ही लिखे।

内置函数可以把一种类型的值转换成另一种。这非常常用，因为 input() 总是返回字符串，即使用户输入的是数字。

age_str = input("Enter your age: ")      # input() always returns a str
age = int(age_str)
print(f"Next year you'll be {age + 1}")

print(int("100"), int(" 42 "), int(9.99), int(-9.99))   # int() cuts toward zero
print(float("3.14"), str(42) + " cats")
print(bool(0), bool("hello"), bool("False"))           # any non-empty string is True!
for bad in ["hello", "3.14", ""]:
    try:
        int(bad)
    except ValueError as err:
        print("ValueError:", err)
print(int(float("3.14")))
print(round(float("3.99")))                            # round() if you want rounding

The run above typed 25 at the prompt. Note that int("3.14") fails: int() only reads whole-number text. Convert with float() first, then use int() to cut or round() to round.

ऊपर के run में prompt पर 25 लिखा गया। ध्यान दें int("3.14") असफल होता है: int() सिर्फ़ पूर्ण संख्या वाला text पढ़ता है। पहले float() से बदलें, फिर काटने के लिए int() या round करने के लिए round() लगाएँ।

上面的运行在提示符处输入了 25。注意 int("3.14") 会失败：int() 只能读取整数文本。先用 float() 转换，再用 int() 截断或用 round() 舍入。

type() and isinstance() — Checking Types 🔍type() और isinstance() — Types जाँचना 🔍type() 与 isinstance() —— 检查类型 🔍

type(x) returns the exact type of a value. isinstance(x, T) asks "is x a T, or a subtype of T?" and can take several types at once.

type(x) मान का सटीक type लौटाता है। isinstance(x, T) पूछता है "क्या x एक T है, या T का subtype?" और एक साथ कई types ले सकता है।

type(x) 返回值的确切类型。isinstance(x, T) 问的是“x 是 T 或 T 的子类型吗？”，并且可以一次检查多个类型。

print(type(42), type(3.14), type("hello"), type(True))
x = 42
print(type(x) is int, type(x) is str)
print(isinstance(42, int), isinstance(True, int), isinstance(True, bool))
print(isinstance(3.14, (int, float)))


def double(value):
    """Double a number, but reject anything that is not an int or float."""
    if isinstance(value, bool) or not isinstance(value, (int, float)):
        raise TypeError(f"Expected a number, got {type(value).__name__}")
    return value * 2


print(double(21), double(3.5))
for bad in ["21", True]:
    try:
        double(bad)
    except TypeError as err:
        print("TypeError:", err)

One fix compared with a typical textbook version: because isinstance(True, int) is True, a check for (int, float) lets booleans through, and double(True) would quietly return 2. The function above rejects bool first. Also prefer type(x) is int over type(x) == int when you really need an exact type check.

आम textbook version से एक सुधार: क्योंकि isinstance(True, int) True है, (int, float) की जाँच booleans को भी आने देती है, और double(True) चुपचाप 2 लौटा देता। ऊपर का function पहले bool को रोकता है। जब सच में सटीक type जाँच चाहिए तो type(x) == int की जगह type(x) is int लिखें।

与常见教材写法相比的一处修正：由于 isinstance(True, int) 为 True，检查 (int, float) 会放过布尔值，double(True) 会悄悄返回 2。上面的函数先排除了 bool。另外，确实需要精确类型检查时，用 type(x) is int 而不是 type(x) == int。

Cheat Sheet — The Four Types at a Glance 📋Cheat Sheet — चारों Types एक नज़र में 📋速查表 —— 四种类型一览 📋

Complete Practice Program 🎓पूरा अभ्यास Program 🎓完整练习程序 🎓

This script uses everything from the lesson: blocks and indentation, comments, variables, all four types, f-string alignment, and booleans. Save it as student_report.py and run python3 student_report.py.

यह script lesson की हर चीज़ इस्तेमाल करती है: blocks और indentation, comments, variables, चारों types, f-string alignment, और booleans। इसे student_report.py नाम से save करें और python3 student_report.py चलाएँ।

这个脚本用到了本课的所有内容：代码块与缩进、注释、变量、四种类型、f-string 对齐以及布尔值。保存为 student_report.py，然后运行 python3 student_report.py。

# student_report.py — syntax, variables and all four basic types together


def get_grade(score):
    """Turn a numeric score into a letter grade."""
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"


def main():
    name = "Asha Verma"                      # str
    student_id = 2026_001                    # int (underscore only for reading)
    scores = [88, 92, 75, 95, 83]            # ints in a list
    average = sum(scores) / len(scores)      # float
    passed = average >= 60.0                 # bool
    honour_roll = average >= 85.0            # bool

    line = "═" * 34
    print(line)
    print("  STUDENT REPORT CARD")
    print(line)
    print(f"  Name:        {name}")
    print(f"  ID:          {student_id}")
    print(f"  Subjects:    {len(scores)}")
    print(line)
    subjects = ["Maths", "Science", "English", "History", "Art"]
    for subject, score in zip(subjects, scores):
        mark = "✓" if score >= 60 else "✗"
        print(f"  {subject:<10} {score:>3}  ({get_grade(score)}) {mark}")
    print(line)
    print(f"  Average:     {average:.1f}")
    print(f"  Grade:       {get_grade(average)}")
    print(f"  Passed:      {passed}")
    print(f"  Honour roll: {honour_roll}")
    print(line)
    for label, value in [("name", name), ("ID", student_id), ("average", average), ("passed", passed)]:
        print(f"  type of {label:<8} {type(value).__name__}")


if __name__ == "__main__":
    main()

The average is 433 / 5 = 86.6, a float, so get_grade(86.6) returns "B" even though it passes the 85 honour-roll line. Try changing one score and predict the new grade before you run it.

औसत 433 / 5 = 86.6 है, एक float, इसलिए get_grade(86.6) "B" लौटाता है, भले ही यह 85 की honour-roll रेखा पार करता है। एक score बदलें और चलाने से पहले नए grade का अंदाज़ा लगाएँ।

平均分是 433 / 5 = 86.6，一个 float，所以 get_grade(86.6) 返回 "B"，尽管它超过了 85 分的荣誉榜线。试着改一个分数，并在运行前预测新的等级。

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