5.4.2
Numbers ke saath compute karne se pehle, aapko ek container chahiye jo unhe hold kare. NumPy arrays wahi container hain: memory ka ek contiguous block jisme saare elements same dtype ke hote hain, aur ek shape hoti hai. Array-creation functions ek factory floor ki tarah hain — ye aapko bina koi Python loop likhe ek filled grid of numbers stamp out karne dete hain. Paanch main functions ek-ek sawaal ka jawaab dete hain:
"Mujhe ek blank slate chahiye" → ==np.zeros / np.ones==
"Mujhe A aur B ke beech N evenly spaced points chahiye (endpoints included)" → ==np.linspace==
"Mujhe ek fixed step wala range chahiye (jaise Python range)" → ==np.arange==
"Mujhe random numbers chahiye" → ==np.random==
Ek Python list [0]*1000000 slow aur memory-heavy hoti hai: har element ek full Python object hota hai jisme ek pointer hota hai. NumPy iske bajaye ek typed buffer allocate karta hai. Isliye np.zeros(10**6) fast, compact, aur vectorized math ke liye ready hota hai. Creators aapko ek output preallocate karke use fill karne bhi dete hain — scientific code mein ye standard fast pattern hai.
np.zeros(shape, dtype=float) diye gaye shape ka ek array return karta hai jo 0 se bhara hota hai. np.ones(...) 1 se bharta hai. shape ek int (1-D) ya ek tuple (rows, cols, ...) hota hai.
WHAT ye dete hain: ek fully-initialized array.
HOW ye kaam karte hain: buffer allocate karo → har byte set karo (zeros literally memset to 0 karta hai; ones chunke gaye dtype mein value 1 likhta hai).
WHY default dtype float64 hai: scientific math mein floats chahiye hote hain; agar integers chahiye toh dtype=int pass karo.
3 × 4
np.zeros(( 3 , 4 )) # array([[0., 0., 0., 0.], # [0., 0., 0., 0.], # [0., 0., 0., 0.]]) Tuple kyun? Kyunki shape multi-dimensional hoti hai; (3,4) = 3 rows, 4 cols. Sirf 3 dene se ek 1-D length-3 array milti.
Worked example Pehle preallocate karo phir fill karo (pro pattern)out = np.zeros( 5 ) # buffer ready for i in range ( 5 ): # Why? demonstrate filling out[i] = i ** 2 # out -> [ 0., 1., 4., 9., 16.] Preallocate kyun? Ek list badhana aur convert karna slow hai; ek fixed buffer baar-baar reallocation se bachata hai.
Related: np.full(shape, 7) → 7 se bhara hota hai; np.empty(shape) → uninitialized (garbage values, sabse fast, sirf tab safe hai jab aap sab kuch overwrite karo).
Intuition "Mere paas ek interval[ a , b ] step ki parwaah nahi, aapko exactly N points chahiye, dono ends including. [ 0 , 2 π ]
np.linspace(start, stop, num=50, endpoint=True) [ start , stop ] num evenly spaced samples return karta hai, default mein stop ko include karte hue.
Hum chahte hain num points x 0 , … , x n u m − 1 x 0 = a x n u m − 1 = b num points ke beech n u m − 1 gaps hote hain. Toh har gap hai
Δ = n u m − 1 b − a , x k = a + k Δ , k = 0 , 1 , … , n u m − 1.
np.linspace(0, 1, 5)
Δ = 5 − 1 1 − 0 = 0.25 [0. , 0.25, 0.5 , 0.75, 1. ].
Denominator mein 4 kyun? 5 points 4 intervals banate hain, 5 nahi.
np.arange(start, stop, step) start se values return karta hai stop tak lekin stop include nahi , step se aage badhte hue. Ek argument ke saath, np.arange(n) = 0,1,...,n-1.
Values hain a , a + s , a + 2 s , … b
N = ⌈ s b − a ⌉ .
np.arange(0, 1, 0.25)
N = ⌈( 1 − 0 ) /0.25 ⌉ = 4 [0. , 0.25, 0.5 , 0.75]. 1.0 kyun nahi? stop exclusive hai.
Common mistake arange mein float steps drift karte hainGalat soch: np.arange(0, 1, 0.1) exactly 10 acche values deta hai jo 1 ke paas khatam hote hain.
Kyun sahi lagta hai: 1/0.1 = 10 Reality: floating-point 0.1 exact nahi hota, isliye last value thoda andar ghus sakta hai ya thoda off ho sakta hai (jaise 0.999...). Length 10 ya 11 ho sakti hai unpredictably.
Fix: agar kisi interval par points ki jaani-mani sankhya chahiye, toh np.linspace use karo. np.arange sirf integer steps ke liye ya jab fencepost behavior theek ho tab use karo.
WHY seed? Reproducible experiments: same seed → same numbers, taaki ek teammate (ya future mein aap khud) identical output paa sake.
Worked example Reproducible Gaussian samplerng = np.random.default_rng( 0 ) rng.normal( 0 , 1 , 3 ) # same every run with seed=0 Why default_rng purane np.random.rand se better hai? Purane global functions hidden state share karte hain; default_rng recommended, statistically better generator hai.
rng.random() samples ka mean → 0.5 [ 0 , 1 ) 2 1 rng.normal(loc, scale, ...) ka mean → loc, std → scale, large samples ke liye.
Recall Feynman: 12-saal ke bacche ko samjhaoEk khaali egg carton imagine karo. np.zeros ek aisi carton hai jisme har cup mein "0" egg hai; np.ones mein "1" eggs hain. np.linspace matlab "mujhe exactly 5 marks chahiye jo ek ruler par 0 se 1 tak evenly painted hon, bilkul dono siron sameet." np.arange matlab "0 se chalna shuru karo aur 0.25-size ke steps lo, 1 tak pahunchne se pehle ruk jao." np.random matlab cups ko surprise numbers se bharne ke liye dice roll karna — aur ek seed ek magic word hai jo dice ko hamesha ek tarah land karata hai taaki tum game replay kar sako.
Mnemonic Apna creator choose karo"Zero/One = blanks, Lin = kitne MANY, A-range = kitna BADA step, Random = roll."
Yaad karo L inspace = L ast point inLcluded (endpoint rakhta hai); a range = a voids the stop (exclusive, jaise range).
Common mistake 2-D shapes ke liye tuple bhool jaanaGalat: np.zeros(3, 4) → error.
Kyun sahi lagta hai: function calls mein aam taur par comma-separated args hote hain.
Fix: shape EK argument hai: np.zeros((3, 4)). Doosra positional slot dtype ka hai!
Common mistake linspace vs arange endpoint confusionGalat: yeh sochna ki np.linspace(0,10,10) ka step 1 hai.
Kyun: "10 se 10 lagta hai jaise step 1 ho."
Fix: step hai 10/ ( 10 − 1 ) = 1.111 np.linspace(0,10,11) ya np.arange(0,11) use karo.
np.zeros((2,3)) kya return karta hai?Zeros ka ek 2×3 float array (shape tuple ke roop mein pass hoti hai).
np.zeros / np.ones ka default dtype kya hai?float64.
np.linspace(a,b,num) mein endpoint=True ke saath spacing formula kya hai?Δ = ( b − a ) / ( n u m − 1 )
Kya np.linspace default mein stop include karta hai? Haan (endpoint=True).
Kya np.arange stop value include karta hai? Nahi, stop exclusive hai (jaise Python range).
np.arange(a,b,s) mein elements ki sankhya?⌈( b − a ) / s ⌉
np.arange mein float steps se kyun bachna chahiye?Floating-point rounding count/last value ko unreliable bana deta hai; linspace use karo.
np.linspace(0,1,5) kitne points aur kya step deta hai?5 points, step 0.25 → [0,0.25,0.5,0.75,1].
np.empty kya deta hai jo np.zeros nahi deta?Uninitialized (garbage) values — faster, sirf tab safe hai jab sab overwrite karo.
Random generator banane ka modern tarika? rng = np.random.default_rng(seed).
RNG ko seed kyun pass karte hain? Reproducibility — same seed se same sequence milta hai.
rng.random((2,2)) ka range kya hai?[ 0 , 1 )
Bahut saare rng.random() samples ka expected mean? 0.5.
4×4 array jo saara 7 ke barabar ho, kaise banayein? np.full((4,4), 7).
NumPy arrays — shape, dtype, ndim Vectorization vs Python loops Array indexing and slicing Reshaping — reshape, ravel, newaxis Plotting functions with Matplotlib (linspace x-axis ko feed karta hai)Random sampling and distributions Floating-point representation and rounding errors
Need typed number container
Python list is slow and heavy
NumPy array: one typed buffer + shape
np.linspace: N points, ends included
np.arange: fixed step, stop excluded
np.random: random numbers
Preallocate then fill pattern
