Chapter 5: NumPy Fundamentals
MODULE 2 | WEEK 5
Chapter 5: NumPy Fundamentals
Ab tak hum ne data ko Python ki lists me rakha. Lekin jab data hazaron ya lakhon numbers ka ho, lists slow aur mushkil ho jati hain. NumPy (Numerical Python) isi masle ka hal hai. Ye Data Science, ML aur Deep Learning ki bunyad hai: Pandas, Scikit-learn aur TensorFlow sab andar se NumPy hi istemal karte hain.
5.1 NumPy kya hai aur list se behtar kyun?
NumPy ek library hai jo array naam ka special data structure deti hai. Array ek aisi table hai jis ke saare elements ek hi type ke hote hain (jaise sab numbers). Isi wajah se NumPy bohat tez chalta hai.
NumPy ke 4 bare faide
-
Speed: list ke muqable me 10 se 100 guna tez (kyunke andar C language me chalta hai).
-
Kam memory: ek jaise types hone ki wajah se jagah kam gherta hai.
-
Vectorization: loop likhe baghair poore array par ek sath hisaab (neeche dekho).
-
Bunyad: Pandas, Scikit-learn, TensorFlow sab NumPy par bane hain.
NumPy ko istemal karne ke liye import karte hain. Dunya bhar me iska chhota naam np rakha jata hai. Google Colab me NumPy pehle se installed hota hai.
import numpy as np
# List me har number ko 2 se guna karna (loop chahiye)
nums = [1, 2, 3, 4, 5]
doubled = []
for n in nums:
doubled.append(n * 2)
print(doubled) # [2, 4, 6, 8, 10]
# NumPy me loop ki zaroorat nahi (vectorization)
arr = np.array([1, 2, 3, 4, 5])
print(arr * 2) # [ 2 4 6 8 10]
import numpy as np
import time
big_list = list(range(1_000_000))
big_arr = np.arange(1_000_000)
t = time.time()
result = [x * 2 for x in big_list]
print("List:", round(time.time() - t, 4), "second")
t = time.time()
result = big_arr * 2
print("NumPy:", round(time.time() - t, 4), "second")
# NumPy aam tor par bohat zyada tez nikalta hai
5.2 Arrays banana
List se array
import numpy as np
a = np.array([10, 20, 30]) # 1D array (vector)
b = np.array([[1, 2, 3], [4, 5, 6]]) # 2D array (matrix): 2 rows, 3 columns
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) # 3D array
print(a)
print(b)
print(c.shape) # (2, 2, 2)
Khud ba khud arrays banane ke functions
| Function | Kaam | Misaal |
|---|---|---|
| np.zeros(shape) | Sab 0 | np.zeros((2, 3)) |
| np.ones(shape) | Sab 1 | np.ones((2, 2)) |
| np.full(shape, v) | Sab ek value v | np.full((2, 2), 7) |
| np.eye(n) | Identity matrix (diagonal par 1) | np.eye(3) |
| np.arange(start, stop, step) | range jaisa, magar array banata hai | np.arange(0, 10, 2) |
| np.linspace(start, stop, n) | start se stop tak barabar fasle ke n numbers | np.linspace(0, 1, 5) |
| np.random.rand(r, c) | 0 se 1 ke beech random numbers | np.random.rand(2, 3) |
| np.random.randint(a, b, size) | a se b ke beech random poore numbers | np.random.randint(1, 10, 5) |
| np.random.randn(r, c) | Normal distribution wale random numbers | np.random.randn(3) |
import numpy as np
print(np.zeros((2, 3)))
print(np.ones((2, 2)))
print(np.full((2, 2), 7))
print(np.eye(3))
print(np.arange(0, 10, 2)) # [0 2 4 6 8]
print(np.linspace(0, 1, 5)) # [0. 0.25 0.5 0.75 1. ]
Random numbers aur seed
Random numbers har bar alag aate hain. seed lagane se har bar wohi numbers aate hain, jis se tumhara nateeja dobara dohraya (reproduce) ja sakta hai. ML me ye bohat zaroori hai.
import numpy as np
np.random.seed(42) # seed lagao
r = np.random.randint(1, 100, size=5)
print(r.shape) # (5,)
np.random.seed(42)
r2 = np.random.randint(1, 100, size=5)
print((r == r2).all()) # True: dono bar same numbers
5.3 Array ki khasusiyat (Attributes) aur shape badalna
import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr.shape) # (2, 3) -> 2 rows, 3 columns
print(arr.ndim) # 2 -> kitne dimensions
print(arr.size) # 6 -> kul elements
print(arr.dtype) # int64 -> data type (system par int32 bhi ho sakta hai)
f = np.array([1, 2, 3], dtype=float) # type khud chuno
print(f) # [1. 2. 3.]
print(arr.astype(float)) # type badlo
reshape, flatten, transpose
import numpy as np
a = np.arange(12) # [0 1 2 ... 11]
m = a.reshape(3, 4) # 3 rows, 4 columns
print(m)
print(a.reshape(2, -1).shape) # (2, 6) -1 ka matlab: khud nikal lo
print(m.flatten()) # 2D se wapas 1D
print(m.T) # transpose: rows aur columns ulte
print(m.T.shape) # (4, 3)
5.4 Indexing aur Slicing
1D array
Bilkul list ki tarah: index 0 se shuru, negative index aakhir se, slicing [start:stop:step] .
import numpy as np
a = np.array([10, 20, 30, 40, 50])
print(a[0], a[-1]) # 10 50
print(a[1:4]) # [20 30 40]
print(a[::2]) # [10 30 50]
a[0] = 99
print(a) # [99 20 30 40 50]
2D array: [row, column]
import numpy as np
m = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print(m[0, 0]) # 1 pehli row, pehla column
print(m[1, 2]) # 6
print(m[0]) # [1 2 3] poori pehli row
print(m[:, 1]) # [2 5 8] poora doosra column
print(m[0:2, 1:3]) # [[2 3]
# [5 6]] pehli 2 rows, column 1 aur 2
AAM GALTIYAN
- Array ka slice copy nahi hota, balke wohi data ka view hota hai. Slice badalne se asli array bhi badal jata hai. Alag copy ke liye .copy() likho.
import numpy as np
a = np.array([1, 2, 3, 4, 5])
s = a[1:4]
s[0] = 100
print(a) # [ 1 100 3 4 5] asli array badal gaya!
b = np.array([1, 2, 3, 4, 5])
c = b[1:4].copy() # asli copy
c[0] = 100
print(b) # [1 2 3 4 5] safe
Boolean indexing (masking): shart se data chunna
Ye NumPy ki sab se taqatwar khoobiyon me se hai. Pehle ek True/False ka array (mask) banta hai, phir sirf True wali jagah ke elements milte hain.
import numpy as np
marks = np.array([45, 82, 67, 91, 33, 78])
mask = marks > 60
print(mask) # [False True True True False True]
print(marks[mask]) # [82 67 91 78]
print(marks[marks > 60]) # seedha bhi likh sakte hain
print(marks[(marks > 60) & (marks < 90)]) # [82 67 78] dono shartein
print(marks[(marks < 40) | (marks > 90)]) # [91 33] koi ek shart
marks[marks < 40] = 40 # 40 se kam wale ko 40 kar do
print(marks) # [45 82 67 91 40 78]
Fancy indexing (index ki list se chunna)
import numpy as np
a = np.array([10, 20, 30, 40, 50])
print(a[[0, 2, 4]]) # [10 30 50]
print(a[[4, 0]]) # [50 10]
5.5 Array Operations
Element-wise operations (har element par alag alag)
import numpy as np
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print(a + b) # [11 22 33]
print(b - a) # [ 9 18 27]
print(a * b) # [10 40 90] har jori ka guna
print(b / a) # [10. 10. 10.]
print(a ** 2) # [1 4 9]
print(a * 10) # [10 20 30] scalar har element par
print(a > 1) # [False True True]
Aggregation functions: sum, mean, max aur baqi
| Function | Kaam |
|---|---|
| arr.sum() | Sab ka jama |
| arr.mean() | Average |
| arr.median / np.median(arr) | Darmiyani value |
| arr.std() / arr.var() | Standard deviation / variance |
| arr.min() / arr.max() | Sab se chhota / bara |
| arr.argmin() / arr.argmax() | Sab se chhote / bare kiposition (index) |
| arr.cumsum() | Jama hota hua (cumulative sum) |
| np.percentile(arr, q) | q percent par value |
import numpy as np
marks = np.array([45, 82, 67, 91, 33, 78])
print(marks.sum()) # 396
print(marks.mean()) # 66.0
print(np.median(marks)) # 72.5
print(marks.max(), marks.min()) # 91 33
print(marks.argmax()) # 3 (91 index 3 par hai)
print(marks.cumsum()) # [ 45 127 194 285 318 396]
print(round(marks.std(), 2)) # 20.64
axis: row-wise aur column-wise hisaab (bohat zaroori)
-
2D array me hum bata sakte hain ke hisaab kis direction me ho:
-
axis=0: neeche ki taraf (har column ka hisaab). Rows collapse ho jati hain.
-
axis=1: side ki taraf (har row ka hisaab). Columns collapse ho jate hain.
-
Mathematical functions
import numpy as np
a = np.array([1, 4, 9, 16])
print(np.sqrt(a)) # [1. 2. 3. 4.]
print(np.exp(np.array([0, 1]))) # [1. 2.71828183]
print(np.log(np.array([1, np.e]))) # [0. 1.]
print(np.round(np.array([1.234, 5.678]), 1)) # [1.2 5.7]
print(np.abs(np.array([-3, 2, -1]))) # [3 2 1]
sort, unique, where
import numpy as np
a = np.array([5, 2, 9, 2, 5, 1])
print(np.sort(a)) # [1 2 2 5 5 9]
print(np.unique(a)) # [1 2 5 9]
vals, counts = np.unique(a, return_counts=True)
print(vals, counts) # [1 2 5 9] [1 2 2 1]
# np.where: if-else poore array par
marks = np.array([45, 82, 67, 33])
result = np.where(marks >= 50, "Pass", "Fail")
print(result) # ['Fail' 'Pass' 'Pass' 'Fail']
print(np.where(marks >= 50)[0]) # [1 2] jin jagahon par shart sahi hai
Arrays jorna aur todna
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.concatenate([a, b])) # [1 2 3 4 5 6]
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6], [7, 8]])
print(np.vstack([x, y])) # neeche jora (rows barhi)
print(np.hstack([x, y])) # side me jora (columns barhe)
parts = np.split(np.arange(6), 3) # 3 barabar hisson me
print(parts) # [array([0, 1]), array([2, 3]), array([4, 5])]
AAM GALTIYAN
-
Python list aur NumPy array par + ka matlab alag hai. [1,2] + [3] list jorti hai, np.array([1,2]) + 3 har element me 3 jorta hai.
-
Boolean indexing me and / or likhna. NumPy me & aur | chalte hain, aur har shart bracket me honi chahiye.
-
axis ko ulta samajhna. axis=0 column-wise, axis=1 row-wise nateeja deta hai.
-
Array ke slice ko copy samajh kar badalna. Slice asli array ka view hota hai.
-
Alag alag types ko ek array me daalna. NumPy sab ko ek type (jaise float ya text) me badal deta hai.
5.6 Broadcasting (alag shape ke arrays par amal)
Normally element-wise amal ke liye dono arrays ki shape barabar honi chahiye. Lekin NumPy ek smart tareeqa deta hai jise broadcasting kehte hain: chhota array khud ba khud phail kar bare array ki shape jaisa ban jata hai (asal me copy nahi hota, sirf hisaab me aisa mana jata hai).
Broadcasting ke 2 rules
NumPy dono arrays ki shapes ko aakhri dimension se pehli ki taraf milata hai. Har dimension par:
-
Ya to dono ki size barabar ho,
-
Ya un me se kisi ek ki size 1 ho (wo phail jayega).
Agar in dono me se koi baat na ho to error aata hai.
import numpy as np
a = np.ones((3, 4)) # shape (3, 4)
b = np.ones(4) # shape (4,) -> (3,4) se mel khata hai
print((a + b).shape) # (3, 4)
c = np.ones(3) # shape (3,) -> aakhri dimension 3 vs 4: mel nahi
try:
a + c
except ValueError as e:
print("Error:", e)
Broadcasting ka asli istemal: Standardization (z-score)
ML me aksar har column ko is tarah badalte hain ke uska mean 0 aur standard deviation 1 ho. Formula: (x - mean) / std . Broadcasting ki wajah se ye ek line me ho jata hai.
import numpy as np
data = np.array([[170, 65],
[160, 55],
[180, 80],
[175, 70]], dtype=float) # height, weight
mean = data.mean(axis=0) # har column ka mean
std = data.std(axis=0) # har column ka std
z = (data - mean) / std # broadcasting
print(np.round(z, 2))
print(np.round(z.mean(axis=0), 2)) # [0. 0.]
print(np.round(z.std(axis=0), 2)) # [1. 1.]
5.7 Hands-on with NumPy
Pehle khud koshish karo, phir solution dekho.
Exercise 1: 1 se 20 tak ke even numbers
import numpy as np
a = np.arange(1, 21)
print(a[a % 2 == 0]) # [ 2 4 6 8 10 12 14 16 18 20]
Exercise 2: Marks table ka tajziya
4 students, 3 subjects. Har student ka average, har subject ka sab se zyada number, aur topper ka index nikalo.
import numpy as np
marks = np.array([[78, 85, 90],
[60, 55, 70],
[92, 88, 95],
[45, 65, 50]])
student_avg = marks.mean(axis=1)
print(np.round(student_avg, 2)) # [84.33 61.67 91.67 53.33]
print(marks.max(axis=0)) # [92 88 95]
print("Topper index:", student_avg.argmax()) # 2
Exercise 3: Negative numbers ko 0 karo
import numpy as np
a = np.array([4, -2, 7, -9, 0, 3])
a[a < 0] = 0
print(a) # [4 0 7 0 0 3]
Exercise 4: Min-Max Scaling (0 se 1 ke beech laana)
Formula: (x - min) / (max - min)
import numpy as np
x = np.array([10, 20, 30, 40, 50], dtype=float)
scaled = (x - x.min()) / (x.max() - x.min())
print(scaled) # [0. 0.25 0.5 0.75 1. ]
Exercise 5: Chessboard pattern (8x8)
import numpy as np
board = np.zeros((8, 8), dtype=int)
board[1::2, ::2] = 1 # odd rows, even columns
board[::2, 1::2] = 1 # even rows, odd columns
print(board)
Exercise 6: Do points ke darmiyan fasla
Distance = sqrt((x2-x1)<sup>2</sup> + (y2-y1)<sup>2</sup> )
import numpy as np
p1 = np.array([1, 2])
p2 = np.array([4, 6])
distance = np.sqrt(((p2 - p1) ** 2).sum())
print(distance) # 5.0
Exercise 7: Dot product aur Matrix multiplication
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.dot(a, b)) # 32 = 1*4 + 2*5 + 3*6
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B)
# [[19 22]
# [43 50]]
Exercise 8: Random data banao aur samjho
100 students ke random marks (30 se 100) banao. Kitne pass (>= 50) hain, average kya hai, aur kitne students ke marks average se zyada hain?
import numpy as np
np.random.seed(0)
marks = np.random.randint(30, 101, size=100)
print("Pass:", (marks >= 50).sum())
print("Average:", round(marks.mean(), 2))
print("Average se upar:", (marks > marks.mean()).sum())
Challenge: Exercise 2 ki table me har subject ko 0 se 1 ke beech scale karo (Exercise 4 ka formula axis=0 ke saath), bina kisi for loop ke.
KEY TAKEAWAYS
-
NumPy array tez hai, kam memory leta hai, aur vectorization (bina loop ke hisaab) deta hai.
-
Arrays banane ke tareeqay: array, zeros, ones, eye, arange, linspace, random. seed se nateeja dohraya ja sakta hai.
-
shape (2,3) matlab 2 rows, 3 columns. reshape, flatten aur T se shape badalti hai.
-
2D indexing m[row, col]. Slice asli array ka view hota hai, copy ke liye .copy().
-
Boolean masking: arr[arr > 60]. Do shartein: & aur |, har ek bracket me.
-
axis=0 column-wise, axis=1 row-wise hisaab deta hai.
-
Broadcasting: chhota array khud phail kar bare ki shape jaisa ban jata hai (shapes aakhir se milti hain, size barabar ya 1).