Python cheat sheet: syntax, commands और built-in functions तालिकाओं में
Python का syntax indentation पर चलता है, न कि curly braces पर: colon के बाद का block 4 spaces से आगे बढ़ता है। मूल बातें हैं बिना type घोषित किए variables, if/elif/else की शर्तें, for और while loops, def से functions, और built-in functions जैसे print, len, range, input, type, साथ में strings, lists और dictionaries के methods।
यह Python cheat sheet पहले कुछ महीनों के लिए ज़रूरी सब कुछ एक पन्ने पर रखती है: Python syntax, loops, built-in functions, string, list और dictionary के methods, और terminal commands। हर तालिका एक छोटा संदर्भ है, जिसके उदाहरण सीधे REPL में डाले जा सकते हैं।
Python syntax की मूल बातें
भाषा की मुख्य विशेषता: blocks braces से नहीं, indentation से बनते हैं। Colon वाली line के बाद (if, for, def, class) की lines 4 spaces से आगे बढ़ती हैं। Tabs और spaces को मिलाना मना है — IndentationError आएगा।
| Construction | उदाहरण | स्पष्टीकरण |
|---|---|---|
| Comment | # text | # से लेकर line के अंत तक सब कुछ अनदेखा |
| Variable | age = 25 | type घोषित नहीं होता, value से तय होता है |
| एक साथ assignment | a, b = 1, 2 | unpacking; values की अदला-बदली: a, b = b, a |
| Output | print("नमस्ते", name) | arguments के बीच एक space |
| Input | s = input("नाम: ") | हमेशा string लौटाता है |
| f-string | f"{name}: {price:.2f}" | expressions का भीतर लगाना और format |
| Type annotation | count: int = 0 | IDE और checkers के लिए संकेत, run के समय जाँच नहीं होती |
| खाली block | pass | placeholder, जहाँ syntax को body चाहिए |
| Import | from math import sqrt | module या उसके किसी नाम को जोड़ना |
डेटा types
| Type | Literal | बदला जा सकता है |
|---|---|---|
int | 42, 1_000_000 | नहीं |
float | 3.14, 1e-3 | नहीं |
bool | True, False | नहीं |
str | "पाठ", 'पाठ', """कई पंक्तियाँ""" | नहीं |
list | [1, 2, 3] | हाँ |
tuple | (1, 2), (1,) | नहीं |
dict | {"a": 1} | हाँ |
set | {1, 2}, खाली — set() | हाँ |
NoneType | None | — |
Operators
| समूह | Operators | उदाहरण → नतीजा |
|---|---|---|
| गणित | + - * / // % ** | 7 // 2 → 3, 7 % 2 → 1, 2 ** 10 → 1024 |
| तुलना | == != < > <= >= | 1 < x < 10 — तुलना की चेन |
| तर्क | and or not | x or "डिफ़ॉल्ट" |
| सदस्यता | in, not in | "a" in "abc" → True |
| पहचान | is, is not | x is None |
| असाइनमेंट | += -= *= /=, := | if (n := len(s)) > 10: ... |
शर्तें और pattern matching
if score >= 90:
grade = "A"
elif score >= 70:
grade = "B"
else:
grade = "C"
status = "वयस्क" if age >= 18 else "बच्चा" # ternary operator
match command:
case "start":
print("शुरू")
case "stop" | "exit":
print("रुका")
case _:
print("अज्ञात कमांड")
ये values झूठी मानी जाती हैं: False, None, 0, खाली string और खाली collections। इसलिए if len(items) > 0 की जगह बस if items लिखा जाता है।
Python loops: for और while का syntax
for loop
Python के for loop का syntax: for variable in sequence: और 4 spaces वाला body। Loop कोई भी iterable घुमा सकता है — string, list, dictionary, file, range।
for i in range(5): # 0 1 2 3 4
print(i)
for i in range(10, 0, -2): # 10 8 6 4 2
print(i)
for i, fruit in enumerate(["सेब", "नाशपाती"], start=1):
print(i, fruit)
for name, score in zip(names, scores):
print(name, score)
for key, value in prices.items():
print(key, value)
while loop
attempts = 3
while attempts > 0:
password = input("पासवर्ड: ")
if password == "secret":
print("लॉग इन हो गया")
break
attempts -= 1
else:
print("प्रयास ख़त्म हो गए") # चलता है, अगर break नहीं हुआ
| Command | क्या करता है |
|---|---|
break | loop से समय से पहले बाहर निकलता है |
continue | अगले iteration पर जाता है |
loop का else | तब चलता है, जब loop बिना break के पूरा हो |
range(stop), range(start, stop, step) | संख्याओं का क्रम, stop शामिल नहीं |
List comprehensions
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100)) # generator expression
Functions
def greet(name: str, greeting: str = "नमस्ते") -> str:
"""स्वागत का संदेश लौटाता है।"""
return f"{greeting}, {name}!"
def total(*args, **kwargs):
return sum(args), kwargs
square = lambda x: x * x
print(greet("प्रिया")) # नमस्ते, प्रिया!
print(greet("प्रिया", greeting="हैलो")) # हैलो, प्रिया!
| तत्व | अर्थ |
|---|---|
def f(a, b=1) | डिफ़ॉल्ट मान वाला parameter |
*args | कितने भी positional arguments (tuple) |
**kwargs | कितने भी named arguments (dictionary) |
return | मान लौटाना; उसके बिना function None लौटाएगा |
lambda x: ... | एक expression वाला छोटा अनाम function |
global, nonlocal | बाहरी scope के variable को बदलना |
डिफ़ॉल्ट के रूप में बदले जा सकने वाला मान न लें, जैसे def f(items=[]): list एक बार बनती है और calls के बीच जमा होती रहती है। सही तरीका है items=None और भीतर if items is None: items = []।
Built-in functions
Python के built-in functions बिना import के उपलब्ध हैं। ये मुख्य functions हैं जो लगभग हर script में दिखते हैं।
| Function | क्या करता है | उदाहरण → नतीजा |
|---|---|---|
print() | values दिखाता है | print(1, 2, sep="-") → 1-2 |
input() | keyboard से string पढ़ता है | int(input()) |
len() | collection या string की लंबाई | len("abc") → 3 |
type() | object का type | type(3.0) → <class 'float'> |
isinstance() | type की जाँच | isinstance(5, int) → True |
int() float() str() bool() | types बदलना | int("42") → 42 |
list() tuple() set() dict() | collections बनाना | list("ab") → ['a', 'b'] |
range() | संख्याओं का क्रम | list(range(3)) → [0, 1, 2] |
enumerate() | (index, element) की जोड़ियाँ | list(enumerate("ab")) → [(0, 'a'), (1, 'b')] |
zip() | sequences को जोड़ी-दर-जोड़ी मिलाना | list(zip([1, 2], "ab")) → [(1, 'a'), (2, 'b')] |
sum() min() max() | योग, न्यूनतम, अधिकतम | max([3, 7, 1]) → 7 |
abs() round() | निरपेक्ष मान और गोलीकरण | round(3.14159, 2) → 3.14 |
sorted() | नई क्रमबद्ध list | sorted(words, key=len, reverse=True) |
reversed() | उल्टे क्रम का iterator | list(reversed([1, 2])) → [2, 1] |
map() filter() | function लगाना / छानना | list(map(str, [1, 2])) → ['1', '2'] |
any() all() | कम से कम एक / सभी सच | all(x > 0 for x in nums) |
open() | file खोलना | open("a.txt", encoding="utf-8") |
help() dir() | सहायता और attributes की सूची | help(str.split), dir(list) |
id() hash() | object की पहचान और hash | hash("a") |
सबसे सुविधाजनक Python reference हमेशा साथ रहता है — REPL में help() function: help(dict) dictionary के सभी methods विवरण के साथ दिखाएगा, और dir(obj) उपलब्ध नामों की सूची।
String methods
Python strings: string बदली नहीं जा सकती, हर method नई string लौटाता है। Slices list की तरह काम करते हैं: s[1:4], और s[::-1] — उल्टा।
| Method | उदाहरण → नतीजा |
|---|---|
upper() lower() | "Py".upper() → 'PY' |
capitalize() title() | "hello world".title() → 'Hello World' |
strip() lstrip() rstrip() | " hi \n".strip() → 'hi' |
split(sep) | "a,b,c".split(",") → ['a', 'b', 'c'] |
join(iterable) | "-".join(["a", "b"]) → 'a-b' |
replace(old, new) | "cat".replace("c", "b") → 'bat' |
find() index() | "hello".find("l") → 2; न मिले तो -1 (index में — त्रुटि) |
count() | "banana".count("a") → 3 |
startswith() endswith() | "file.py".endswith(".py") → True |
isdigit() isalpha() isspace() | "123".isdigit() → True |
removeprefix() removesuffix() | "test_a".removeprefix("test_") → 'a' |
zfill() center() ljust() | "7".zfill(3) → '007' |
format() | "{} + {}".format(1, 2) → '1 + 2' |
List commands
List एक बदली जा सकने वाली क्रमबद्ध collection है। ज़्यादातर methods list को उसी जगह बदलते हैं और None लौटाते हैं, इसलिए a = a.sort() आम गलती है।
| संक्रिया | क्या करता है | उदाहरण |
|---|---|---|
append(x) | अंत में जोड़ता है | a.append(4) |
extend(iter) | सभी elements जोड़ता है | a.extend([5, 6]) |
insert(i, x) | index पर डालता है | a.insert(0, "first") |
remove(x) | मान की पहली मौजूदगी हटाता है | a.remove(3) |
pop(i) | element हटाकर लौटाता है (डिफ़ॉल्ट — आख़िरी) | last = a.pop() |
clear() | list खाली करता है | a.clear() |
index(x) | पहली मौजूदगी का index | a.index("b") |
count(x) | कितनी बार आया | a.count(1) |
sort() | उसी जगह क्रमबद्ध करता है | a.sort(key=str.lower) |
reverse() | उसी जगह उल्टा करता है | a.reverse() |
copy() | उथली प्रति (shallow copy) | b = a.copy() |
del a[i] | index या slice से हटाना | del a[1:3] |
| Slices | a[start:stop:step] | a[-1] — आख़िरी, a[:3] — पहले तीन |
Dictionary commands
| संक्रिया | क्या करता है | उदाहरण |
|---|---|---|
d[key] | key का मान; key न हो तो KeyError | d["name"] |
get(key, default) | मान या विकल्प | d.get("age", 0) |
d[key] = value | जोड़ना या बदलना | d["city"] = "जयपुर" |
keys() values() items() | keys, values, जोड़ियाँ | for k, v in d.items(): |
update() | दूसरे dictionary से मिलाना | d.update({"a": 1}) |
d1 | d2 | नया जुड़ा हुआ dictionary | merged = defaults | user |
pop(key, default) | हटाकर मान लौटाना | d.pop("tmp", None) |
popitem() | आख़िरी जोड़ी हटाना | d.popitem() |
setdefault(key, value) | मान लौटाना, और key न हो तो बनाना | d.setdefault("tags", []).append("py") |
key in d | key मौजूद है या नहीं | if "name" in d: |
dict.fromkeys() | एक मान वाले keys से dictionary | dict.fromkeys("abc", 0) |
len(d), del d[key] | आकार और हटाना | del d["old"] |
Tuples और sets
| संक्रिया | उदाहरण → नतीजा |
|---|---|
| Tuple unpacking | x, y = (3, 4) |
| Set में जोड़ना | s.add(5), हटाना — s.discard(5) |
| Union / intersection | {1, 2} | {2, 3} → {1, 2, 3}; {1, 2} & {2, 3} → {2} |
| Difference | {1, 2} - {2} → {1} |
| List से दोहराव हटाना | list(dict.fromkeys(items)) — क्रम बनाए रखते हुए |
Exceptions और files
try:
number = int(input("संख्या: "))
except ValueError as err:
print("यह संख्या नहीं है:", err)
else:
print("सफल")
finally:
print("हमेशा चलता है")
with open("data.txt", "w", encoding="utf-8") as f:
f.write("पंक्ति\n")
with open("data.txt", encoding="utf-8") as f:
for line in f:
print(line.rstrip())
| Exception | कब आता है |
|---|---|
SyntaxError, IndentationError | syntax या indentation में गलती |
NameError | नाम परिभाषित नहीं (typo) |
TypeError | गलत type पर operation: "1" + 1 |
ValueError | सही type, पर गलत मान: int("abc") |
IndexError, KeyError | ऐसा index या key नहीं है |
FileNotFoundError | file नहीं मिली |
ZeroDivisionError | शून्य से भाग |
Classes
from dataclasses import dataclass
class Dog:
def __init__(self, name: str):
self.name = name
def bark(self) -> str:
return f"{self.name}: भौं-भौं!"
@dataclass
class Point:
x: float
y: float
print(Dog("टॉमी").bark()) # टॉमी: भौं-भौं!
print(Point(1, 2)) # Point(x=1, y=2)
Built-in modules
Standard library interpreter के साथ आती है — बस import करना काफ़ी है।
| Module | किसके लिए | उदाहरण |
|---|---|---|
math | गणित | math.sqrt(16) → 4.0 |
random | यादृच्छिक संख्याएँ | random.randint(1, 6), random.choice(items) |
datetime | तारीख और समय | datetime.date.today() |
pathlib | paths और files | Path("data").glob("*.csv") |
os, sys | system, environment variables, arguments | os.environ.get("HOME"), sys.argv |
json | JSON पढ़ना और लिखना | json.loads(text), json.dumps(obj, ensure_ascii=False) |
csv | CSV tables | csv.DictReader(f) |
collections | Counter, defaultdict, deque | Counter("banana").most_common(1) → [('a', 3)] |
itertools | iterators के combinations और chains | itertools.chain(a, b) |
re | regular expressions | re.findall(r"\d+", s) |
time | रुकना और समय मापना | time.sleep(1), time.perf_counter() |
asyncio | asynchronous code | asyncio.run(main()) |
Python 3.15 में lazy import आया (PEP 810): lazy import pandas as pd module को उसके पहले इस्तेमाल तक लोड होने से रोकता है, और भारी dependencies वाला script काफ़ी तेज़ शुरू होता है।
Python commands terminal में
“Python commands” वाली खोज का अलग हिस्सा वे commands हैं जो interpreter चलाती हैं और libraries install करती हैं। Windows पर python3 की जगह आम तौर पर python या py लिखा जाता है।
| Command | क्या करता है |
|---|---|
python3 --version | version दिखाता है |
python3 | interactive console REPL खोलता है (बाहर — exit()) |
python3 script.py | file चलाता है |
python3 -c "print(2 + 2)" | एक line चलाता है |
python3 -m venv .venv | virtual environment बनाता है |
source .venv/bin/activate / .venv\Scripts\activate | environment चालू करता है (Linux, macOS / Windows) |
python3 -m pip install requests | package install करता है |
pip list, pip freeze > requirements.txt | packages की सूची और उसे सहेजना |
pip install -r requirements.txt | file से dependencies install करता है |
python3 -m http.server 8000 | मौजूदा folder में सरल web server |
uv init, uv add requests, uv run main.py | uv tool से project, dependency और run |
नए लोगों की आम गलतियाँ
- शर्त में
=से तुलना — शर्त में==चाहिए; एक=असाइनमेंट है। - colon भूल जाना
if,for,defके बाद —SyntaxError। - string और number जोड़ना:
"उम्र: " + 25गलत है, लिखेंf"उम्र: {25}"। - loop के दौरान list बदलना — copy पर चलाएँ
for x in a[:]या नई list बनाएँ। input()string लौटाता है — गणित के लिएint()याfloat()में लपेटें।
निष्कर्ष
Python का syntax indentation, colons और छोटे से set की constructions पर टिका है: शर्तें, for और while loops, functions, classes। इनके साथ दो दर्जन built-in functions और string, list और dictionary के methods जोड़ें — तो रोज़मर्रा के ज़्यादातर काम कवर हो जाते हैं। Cheat sheet सहेजकर रखें, और जब तालिकाएँ आदत बन जाएँ, तब modules और asynchronous programming पर जाएँ; यह सब कोर्स “Python 3.15: शुरुआती से प्रो तक” में व्यवहार में चरण-दर-चरण समझाया गया है।
अक्सर पूछे जाने वाले प्रश्न
Python में indentation के लिए कितने spaces लगाएँ?
PEP 8 के मानक के अनुसार हर स्तर पर 4 spaces। सबसे ज़रूरी बात — पूरे block में एक जैसा रहे और tabs के साथ न मिलाएँ।
list और tuple में क्या अंतर है?
List बदली जा सकती है, उसमें जोड़ सकते हैं और उसी जगह क्रमबद्ध कर सकते हैं; tuple नहीं बदलता, इसलिए वह dictionary की key बन सकता है और तय मानों के समूह के लिए ठीक है।
Python में किसी object के सारे methods कैसे देखें?
dir(obj) से नामों की सूची और help(obj) से विवरण लें — उदाहरण के लिए help(str) सभी string methods दिखाएगा।
sort() और sorted() में क्या अंतर है?
list.sort() खुद list को क्रमबद्ध करता है और None लौटाता है, जबकि sorted() नई list लौटाता है और किसी भी iterable collection पर चलता है।
क्या Python में line के अंत में semicolon चाहिए?
नहीं। एक line में कई commands के लिए semicolon चलता है, पर सामान्य code में हर statement नई line पर लिखा जाता है।
यह विषय “Python 3.15: от новичка до профи” कोर्स में अभ्यास के साथ विस्तार से समझाया गया है।
- Python 3.15 с нуля и для опытных: что нового и как учить
- Python 3.15: установка, REPL и первый скрипт за десять минут
- Переменные, числа и строки в Python: f-строки и t-строки
- Условия, циклы и match/case в Python: управляем ходом программы
- Списки, кортежи, словари и множества: frozendict в Python 3.15