Code10x

Python code, LINE-BY-LINE, EXECUTION KE WAQT, INTERPRETER dwara TRANSLATE hota hai — C/Java ki tarah, PEHLE se POORA compile HOKAR machine code NAHI BANTA. Isse DEVELOPMENT FAST hota hai, LEKIN EXECUTION generally SLOWER hota hai.

Variable ka TYPE, DECLARATION ke WAQT specify KARNE ki zaroorat NAHI — RUNTIME par, VALUE ke HISAAB SE, TYPE AUTOMATICALLY DECIDE hota hai. Ek VARIABLE, DIFFERENT TIMES par, DIFFERENT TYPES ki VALUES bhi hold kar sakta hai.

List MUTABLE hai (create hone ke BAAD MODIFY ho sakti hai) — SQUARE BRACKETS [] SE. Tuple IMMUTABLE hai (create hone ke BAAD CHANGE NAHI ho sakti) — ROUND BRACKETS () SE.

Python, CODE BLOCKS (if, for, function BODY) DEFINE karne ke liye, CURLY BRACES {} ke BAJAYE, INDENTATION (SPACES/TABS) USE karta hai — GALAT indentation, SYNTAX ERROR DETA hai.

= ASSIGNMENT operator hai (VALUE ko VARIABLE mein STORE karta hai). == COMPARISON operator hai (DO VALUES EQUAL hain YA NAHI, CHECK karta hai, TRUE/FALSE RETURN karta hai).

== VALUES COMPARE karta hai (CONTENT EQUAL hai YA NAHI). is IDENTITY compare karta hai (DO VARIABLES, SAME OBJECT, SAME MEMORY, ko POINT karte hain YA NAHI).

Python 3.6+ mein, STRING FORMATTING ka MODERN, CONCISE TAREEKA — f"Hello, {name}!" SYNTAX SE, VARIABLES ko DIRECTLY, CURLY BRACES ke ANDAR, STRING mein EMBED kiya ja sakta hai.

Python ka "NULL" EQUIVALENT — EK SPECIAL VALUE JO "KOI VALUE NAHI" YA "ABSENCE OF VALUE" REPRESENT karta hai. AGAR EK FUNCTION KUCH RETURN NAHI karta, DEFAULT mein None RETURN hota hai.

EK KEY-VALUE PAIR based DATA STRUCTURE — {key: value} SYNTAX SE — HAR KEY, EK UNIQUE, INDEXED VALUE KO REFER karti hai, jaise EK REAL DICTIONARY mein WORD → MEANING.

Set, UNIQUE VALUES ka EK UNORDERED COLLECTION hai (DUPLICATES AUTOMATICALLY REMOVE ho jaate hain) — list, ORDERED hai aur DUPLICATES ALLOW karti hai.

EK CONCISE SYNTAX, NAYI LIST BANANE ke liye, EXISTING ITERABLE se — jaise [x*2 for x in range(5)] — TRADITIONAL for LOOP + append() se BAHUT CHHOTA, READABLE code.

EK SUBSET of ELEMENTS EXTRACT karna, [start:end:step] SYNTAX SE — jaise my_list[1:4] INDEX 1 SE 3 tak ELEMENTS DETA hai (4 EXCLUDED).

Shallow copy (copy()), TOP-LEVEL STRUCTURE COPY karta hai, LEKIN NESTED OBJECTS SHARED rehte hain. Deep copy (deepcopy()), NESTED OBJECTS SAHIT, POORI TARAH INDEPENDENT COPY BANATA hai.

Mutable types (list, dict, set) create hone ke BAAD MODIFY ho sakte hain. Immutable types (int, str, tuple) create hone ke BAAD CHANGE NAHI ho sakte — MODIFY karne PAR, NAYI VALUE BANTI hai.

CLASS ka CONSTRUCTOR — JAB BHI EK NAYA OBJECT CREATE hota hai, __init__ AUTOMATICALLY CALL hota hai, INITIAL ATTRIBUTES SET karne ke liye.

CURRENT OBJECT (INSTANCE) KO REFER karta hai — CLASS ke METHODS ke ANDAR, self.attribute SE, USI SPECIFIC OBJECT ke ATTRIBUTES ACCESS/MODIFY hote hain.

Class attribute, CLASS KA hota hai — SAARE OBJECTS SHARE karte hain. Instance attribute, HAR OBJECT ka APNA, SEPARATE hota hai (typically __init__ mein self.x = x SE SET hota hai).

class Child(Parent): SYNTAX SE, Child class, Parent class ke SAARE ATTRIBUTES/METHODS INHERIT karti hai — CODE REUSABILITY milती hai.

PARENT CLASS ke METHODS/CONSTRUCTOR ko, CHILD CLASS ke ANDAR SE, CALL karne deता hai — jaise super().__init__() SE, PARENT ka __init__ bhi RUN ho jaata hai.

Methods JISKE NAAM, DOUBLE UNDERSCORES SE SHURU/KHATAM hote hain (jaise __init__, __str__, __len__) — PYTHON KE BUILT-IN OPERATIONS (jaise print(), len()) ke SAATH, CUSTOM CLASSES ko INTEGRATE karne DETE hain.

*args, EK FUNCTION ko VARIABLE NUMBER of POSITIONAL ARGUMENTS ACCEPT karne DETA hai (TUPLE ke ROOP mein). **kwargs, VARIABLE NUMBER of KEYWORD ARGUMENTS ACCEPT karta hai (DICTIONARY ke ROOP mein).

EK ANONYMOUS (NAAM-LESS), SINGLE-EXPRESSION FUNCTION — jaise lambda x: x*2 — SHORT, INLINE OPERATIONS ke liye, jaise map()/filter() ke SAATH USE hota hai.

Function parameters ki DEFAULT VALUES, jo TAB USE hoती hain jab CALLER USE VALUE PROVIDE NA KARE — jaise def greet(name="Guest"):.

Positional arguments, ORDER ke HISAAB SE PASS hote hain. Keyword arguments, NAAM SE PASS hote hain (jaise func(name="Aarav")) — ORDER MATTER NAHI karta.

FILE ko AUTOMATICALLY CLOSE kar DETA hai, block KHATAM hote hi (chahe ERROR AAYE YA NA AAYE) — MANUALLY file.close() CALL karne ki zaroorat NAHI.

"r" (READ, DEFAULT), "w" (WRITE, EXISTING content OVERWRITE), "a" (APPEND, END mein ADD) — HAR MODE, FILE ke SAATH DIFFERENT BEHAVIOR DEFINE karta hai.

try mein RISKY code likhte hain. AGAR ERROR (EXCEPTION) aaye, MATCHING except block USE HANDLE karta hai — PROGRAM CRASH hone se BACHATA hai.

HAMESHA EXECUTE hota hai, CHAHE EXCEPTION aaye YA NA AAYE — CLEANUP CODE (jaise FILE CLOSE karna) ke liye USE hota hai.

Exception class ko EXTEND KARKE, APNI KHUD KI class BANATE hain — jaise class InsufficientBalanceError(Exception): pass.

Module, EK SINGLE .py FILE hai. Package, MODULES ka EK COLLECTION hai (EK FOLDER, __init__.py FILE ke SAATH) — RELATED modules ko GROUP karta hai.

Python ka PACKAGE MANAGER — THIRD-PARTY LIBRARIES (jaise requests, numpy) ko INSTALL, UPDATE, aur MANAGE karne ke liye USE hota hai.

import module_name, POORE MODULE ko IMPORT karta hai (module_name.func() SE ACCESS). from module import func, SPECIFIC FUNCTION ko DIRECTLY IMPORT karta hai (func() SE DIRECTLY ACCESS).

EK OBJECT JO __next__() METHOD IMPLEMENT karta hai — EK COLLECTION ke ELEMENTS ko, EK-EK KARKE, TRAVERSE karne DETA hai.

EK SPECIAL FUNCTION JO yield KEYWORD USE karta hai — VALUES ko, EK-EK KARKE, LAZY tareeke SE PRODUCE karta hai (POORI LIST EK SAATH MEMORY mein STORE NAHI karta) — MEMORY-EFFICIENT.

EK INNER FUNCTION JO, OUTER FUNCTION KE VARIABLES ko, OUTER FUNCTION KE RETURN HONE KE BAAD BHI, "REMEMBER" karti hai — STATE PRESERVE karne ka EK WAY.

EK FUNCTION JO, EK DUSRE FUNCTION KO, BINA USKA CODE MODIFY kiye, EXTRA BEHAVIOR ADD karta hai — @decorator_name SYNTAX SE APPLY hota hai.

EK MECHANISM JO, EK WAQT MEIN, SIRF EK THREAD ko, PYTHON BYTECODE EXECUTE karne DETA hai — CPU-BOUND MULTI-THREADING ki PERFORMANCE LIMIT karta hai (MULTIPROCESSING ISKA COMMON WORKAROUND hai).

CHECK karta hai KI SCRIPT, DIRECTLY RUN ho rahi hai, YA KISI DUSRE MODULE dwara IMPORT ki gayi hai — SIRF DIRECT EXECUTION PAR, SPECIFIC CODE CHALANE ke liye USE hota hai.

EK DATA TYPE ko, EK DUSRE TYPE mein, EXPLICITLY CONVERT karta hai — jaise int("5") STRING "5" ko INTEGER 5 mein CONVERT kar deta hai.

Python ki EXTENSIVE STANDARD LIBRARY (os, json, datetime, etc.) — BAHUT SI COMMON FUNCTIONALITY, EXTRA INSTALL kiye BINA, DIRECTLY AVAILABLE hai.

LOCAL variables, FUNCTION ke ANDAR DEFINE hote hain, SIRF USI FUNCTION mein ACCESSIBLE. GLOBAL variables, FUNCTIONS ke BAAHAR DEFINE hote hain, POORE MODULE mein ACCESSIBLE.

FUNCTION ke ANDAR SE, EK GLOBAL VARIABLE ko MODIFY karne ki PERMISSION deता hai — bina isके, FUNCTION ke ANDAR ASSIGNMENT, EK NAYI LOCAL VARIABLE BANA deta.

Python ki OFFICIAL STYLE GUIDE — CODE FORMATTING CONVENTIONS (NAMING, INDENTATION, SPACING) DEFINE karti hai, CONSISTENT, READABLE code ke liye.

{k: v for k, v in items} SYNTAX SE, EK NAYI DICTIONARY, CONCISE tareeke SE BANANA — list comprehension ki tarah, LEKIN dictionaries KE LIYE.

MULTIPLE ITERABLES (lists, tuples) ko, PARALLEL, ELEMENT-BY-ELEMENT, PAIRS mein COMBINE karta hai — jaise zip([1,2], ['a','b']) → [(1,'a'), (2,'b')].

LOOP mein, HAR ELEMENT ke SAATH, USKA INDEX bhi, AUTOMATICALLY, AASAN tareeke SE MILTA hai — for i, item in enumerate(list): — MANUAL COUNTER MAINTAIN karne ki zaroorat NAHI.

EK TUPLE VARIANT JISKE FIELDS, INDEX ke ALAWA, NAAM SE bhi ACCESS ho sakte hain — jaise Point = namedtuple('Point', ['x', 'y']) — READABLE, IMMUTABLE data.

class Child(Parent1, Parent2): SYNTAX SE, EK CLASS, MULTIPLE PARENTS SE INHERIT kar sakti hai — MRO (Method Resolution Order) DECIDE karta hai KAUN SA METHOD PEHLE USE hoga, AMBIGUITY hone PAR.

NAMING CONVENTIONS SE — single UNDERSCORE (_var) "PROTECTED" SIGNAL karta hai (CONVENTION-BASED, ENFORCED NAHI), DOUBLE underscore (__var) NAME MANGLING TRIGGER karta hai (SEMI-PRIVATE).

@classmethod, FIRST ARGUMENT ke ROOP mein CLASS (cls) LETA hai. @staticmethod, NA self, NA cls LETA hai — EK NORMAL FUNCTION jo LOGICALLY CLASS ke ANDAR RAKHA gaya hai.

EK METHOD ko, EK ATTRIBUTE ki TARAH, ACCESS karne DETA hai (BINA PARENTHESES ke) — GETTER/SETTER LOGIC ko, CLEAN, PYTHONIC tareeke SE IMPLEMENT karne KA WAY hai.

AGAR EK MUTABLE OBJECT (jaise list) DEFAULT ARGUMENT ke ROOP mein use kiya jaaye, WOH SAB CALLS ke BEECH SHARE hota hai (SIRF EK BAAR, FUNCTION DEFINITION KE WAQT, CREATE hota hai) — UNEXPECTED BEHAVIOR de sakta hai.

map() HAR ELEMENT PAR EK FUNCTION APPLY karta hai. filter() SIRF UN ELEMENTS ko RAKHTA hai JO EK CONDITION SATISFY karte hain. reduce() (functools se) SAARE ELEMENTS ko, EK SINGLE VALUE mein, COMBINE karta hai.

FUNCTION KHUD KO CALL karta hai, BASE CASE tak. Python ki DEFAULT RECURSION LIMIT ~1000 hai (sys.setrecursionlimit() SE CHANGE ho sakti hai) — DEEP RECURSION, StackOverflow de sakta hai.

csv MODULE (BUILT-IN) SE — csv.reader() YA csv.DictReader() SE, ROW-BY-ROW, DATA PARSE kiya ja sakta hai.

json MODULE SE — json.load()/json.loads() JSON PADHNE ke liye, json.dump()/json.dumps() JSON LIKHNE ke liye — Python DICTIONARIES aur JSON KE BEECH CONVERSION.

DIFFERENT EXCEPTION TYPES ko, DIFFERENT tareeke SE HANDLE karne ke liye — jaise except ValueError: ... except TypeError: ... — SPECIFIC exceptions PEHLE, GENERIC BAAD mein.

try block ke BAAD, EK else BLOCK ADD kiya ja sakta hai — YE SIRF TAB EXECUTE hota hai JAB try block mein KOI EXCEPTION NA AAYE.

EK FOLDER ko, Python "PACKAGE" ke ROOP mein RECOGNIZE karvaна — ISME PACKAGE-LEVEL INITIALIZATION CODE bhi HO sakta hai, YA KHAALI bhi HO SAKTI hai.

HAR PROJECT ke liye, EK ISOLATED SPACE BANATA hai, JISME DEPENDENCIES SEPARATELY INSTALL ho sakti hain — DIFFERENT PROJECTS ke BEECH, VERSION CONFLICTS AVOID hote hain.

Iterable, EK OBJECT hai JO ITERATE ki JA SAKTI hai (jaise list) — __iter__() method rakhta hai. Iterator, ACTUAL "TRAVERSING" OBJECT hai — __next__() method rakhta hai.

return, FUNCTION ko IMMEDIATELY KHATAM karke, EK VALUE DETA hai. yield, FUNCTION ko "PAUSE" karta hai, EK VALUE DETA hai, aur NEXT CALL PAR, WAHI SE RESUME hota hai — GENERATOR banata hai.

(x*2 for x in range(5)) SYNTAX SE, list comprehension jaisa, LEKIN LAZY (ON-DEMAND) evaluation KE SAATH — POORI LIST MEMORY mein STORE NAHI HOTI.

EK OBJECT JO __enter__()/__exit__() methods IMPLEMENT karta hai — RESOURCE SETUP/CLEANUP AUTOMATE karta hai, with statement KE SAATH.

EK LIST/TUPLE ko, INDIVIDUAL POSITIONAL ARGUMENTS mein, "UNPACK" karta hai — jaise func(*my_list) — my_list KE SAARE ELEMENTS, SEPARATE ARGUMENTS ban jaate hain.

RUNTIME PAR, EK EXISTING CLASS/MODULE KE BEHAVIOR ko, DYNAMICALLY MODIFY karna — POWERFUL, LEKIN RISKY TECHNIQUE, DEBUGGING MUSHKIL BANA SAKTI HAI.

Multithreading, EK PROCESS ke ANDAR, MULTIPLE THREADS (GIL ki wajah SE, CPU-bound tasks mein LIMITED benefit). Multiprocessing, SEPARATE PROCESSES BANATA hai (APNA OWN MEMORY, GIL SE UNAFFECTED) — TRUE PARALLELISM CPU-bound tasks ke liye.

"AGAR YE DUCK KI TARAH CHALTA HAI, AUR DUCK KI TARAH QUACK KARTA HAI, TO YE DUCK HAI" — Python OBJECT ka ACTUAL TYPE CHECK NAHI karta, SIRF YE CHECK karta hai KI OBJECT ke PAAS REQUIRED METHODS/ATTRIBUTES HAIN YA NAHI.

__str__, USER-FRIENDLY, READABLE STRING REPRESENTATION DETA hai (print() SE). __repr__, DEVELOPER-FOCUSED, UNAMBIGUOUS REPRESENTATION DETA hai (DEBUGGING ke liye, IDEALLY, EVAL-ABLE).

REFERENCE COUNTING (HAR OBJECT ki REFERENCE COUNT TRACK hoti hai) + GARBAGE COLLECTOR (CIRCULAR REFERENCES DETECT karके CLEAN karta hai) — AUTOMATIC, MANUAL free() ki zaroorat NAHI.

True aur False (CAPITAL LETTER SE SHURU) — 1/0 ke SIMILAR, LEKIN EXPLICIT BOOLEAN TYPE HAIN.

EK STRING, CREATE hone ke BAAD, MODIFY NAHI ki JA SAKTI — KISI BHI "MODIFICATION" (jaise .upper()) SE, EK NAYI STRING BANTI hai, ORIGINAL UNCHANGED rehta hai.

list.sort(), ORIGINAL LIST ko, IN-PLACE, MODIFY karta hai (None RETURN karta hai). sorted(), EK NAYI, SORTED LIST RETURN karta hai, ORIGINAL UNCHANGED rehta hai.

abc module SE, ABC class INHERIT karके, aur @abstractmethod SE METHODS MARK karke — YE CLASS DIRECTLY INSTANTIATE NAHI HO SAKTI, CHILD CLASSES ko ABSTRACT METHODS IMPLEMENT KARNA PADTA hai.

EK EXCEPTION ko MANUALLY "THROW" (RAISE) karta hai — jaise raise ValueError("Invalid input") — CUSTOM ERROR CONDITIONS SIGNAL karne ke liye USE hota hai.

EK PROJECT KE SAARE DEPENDENCIES (aur UNKE VERSIONS) ko LIST karti hai — pip install -r requirements.txt SE, KOI BHI, SAME ENVIRONMENT, EASILY RECREATE kar sakta hai.

EFFICIENT, MEMORY-FRIENDLY, ITERATOR-BASED FUNCTIONS ka EK SET — jaise itertools.chain(), itertools.combinations() — COMPLEX ITERATION PATTERNS ko SIMPLIFY karta hai.

FUNCTION PARAMETERS/RETURN VALUES ke EXPECTED TYPES, OPTIONALLY, SPECIFY karne ka WAY — jaise def add(a: int, b: int) -> int: — RUNTIME PAR ENFORCE NAHI HOTE, LEKIN IDEs/TOOLS ke liye USEFUL.

EK CLASS mein, __slots__ DEFINE karke, INSTANCES ke liye, FIXED SET of ATTRIBUTES SPECIFY ki ja sakti hai — MEMORY USAGE KAM hota hai (__dict__ create NAHI hota HAR INSTANCE ke liye).

Python 3.8+ mein AAYA — EK EXPRESSION KE ANDAR HI, EK VARIABLE ko ASSIGN aur USE karne DETA hai — jaise if (n := len(data)) > 10: — CODE ko MORE CONCISE BANATA hai.

SINGLE-LINE comments # SE SHURU hote hain. MULTI-LINE comments (ya DOCSTRINGS), TRIPLE QUOTES (''' YA """) SE LIKHE JAATE HAIN.