Lesson 25 — Intermediate

ARRAYS:
MEMORY EFFICIENT DATA STORAGE.

Lists flexible hain lekin jab same type ke elements ho toh zyada memory waste hoti hai. Python ka array module typed arrays banata hai jo lists se zyada memory efficient hain. NumPy se pehle ye module samajhna zaroori hai taaki aapko pata ho arrays ka concept kya hai.

WHY: Arrays kyun zaroori hain?

Socho aapke paas 10,000 integers hain. List mein har integer ka Python object hota hai jo 28 bytes leta hai — kul 2,80,000 bytes. Array mein sirf 4 bytes per integer hota hai — kul 40,000 bytes. Ye 7 guna kam memory hai! Jab large numerical data handle karo tab arrays bahut useful hain. NumPy arrays aage detail mein aayenge, pehle basic array module samajh lo.

WHEN: kab arrays use hoti hain

Arrays tab use hoti hain jab aapke paas same type ka bahut data ho — numbers ka list hai, scientific calculations kar rahe ho, large datasets handle kar rahe ho, ya memory optimize karni ho. Har data science aur numerical computing project mein arrays ka use hota hai.

HOW: arrays create aur use karo

Array banana

import array

# Create integer array
arr = array.array('i', [10, 20, 30, 40, 50])
print(arr)
print(arr[0]) # 10

# Create float array
floats = array.array('f', [1.5, 2.7, 3.14])
print(floats)

# Create byte array
bytes_arr = array.array('b', [65, 66, 67, 68])
print(bytes_arr)

array.array() mein pehla argument type code hota hai — 'i' integer ke liye, 'f' float ke liye, 'b' byte ke liye. Doosra argument initial values ki list hai. List ki tarah indexing aur slicing kaam karti hai.

Array operations

import array

arr = array.array('i', [10, 20, 30, 40, 50])

# Add elements
arr.append(60)
arr.insert(1, 15)
print(arr) # array('i', [10, 15, 20, 30, 40, 50, 60])

# Remove elements
arr.remove(30)
popped = arr.pop()
print(arr) # array('i', [10, 15, 20, 40, 50])

# Find element
index = arr.index(40)
print(f"40 is at index {index}")

# Count occurrences
arr.append(40)
print(arr.count(40)) # 2

Arrays mein append(), insert(), remove(), pop() — sab lists jaise kaam karte hain. index() aur count() bhi same hai. Difference sirf memory mein hai, functionality mein nahi.

Slicing aur iteration

import array

arr = array.array('i', [10, 20, 30, 40, 50, 60, 70])

# Slicing
print(arr[1:4]) # array('i', [20, 30, 40])
print(arr[::2]) # array('i', [10, 30, 50, 70])
print(arr[::-1]) # array('i', [70, 60, 50, 40, 30, 20, 10])

# Iteration
for num in arr:
 print(num, end=" ")
print()

# With index
for i, num in enumerate(arr):
 print(f"arr[{i}] = {num}")

Lists ki tarah slicing bhi kaam karti hai — same syntax, same result. Iteration bhi identical hai. Arrays basically typed lists hain jo memory mein efficient hain.

Type codes reference

import array

# Common type codes
int_arr = array.array('i', [1, 2, 3]) # signed int (4 bytes)
float_arr = array.array('f', [1.5, 2.5]) # float (4 bytes)
double_arr = array.array('d', [1.5, 2.5]) # double (8 bytes)
byte_arr = array.array('b', [65, 66]) # signed char (1 byte)
char_arr = array.array('u', ['a', 'b']) # unicode char (4 bytes)

print("Integer array:", int_arr)
print("Float array:", float_arr)
print("Double array:", double_arr)
print("Byte array:", byte_arr)
print("Unicode array:", char_arr)

Type codes decide karte hain ki kitna memory lagega. 'i' (int) 4 bytes leta hai, 'f' (float) 4 bytes, 'd' (double) 8 bytes. Apne data ke hisaab se type code choose karo — galat type se error aayega.

Array vs List

import array
import sys

# Lists can hold mixed types
mixed_list = [1, "hello", 3.14, True]
print("List (mixed):", mixed_list)

# Arrays cannot — same type only
int_array = array.array('i', [1, 2, 3])
# int_array.append("hello") # ERROR: invalid type

# Lists have more methods
my_list = [3, 1, 4, 1, 5, 9]
my_list.sort()
my_list.reverse()
print("List sorted:", my_list)

# Arrays have fewer methods but more efficient
my_arr = array.array('i', [3, 1, 4, 1, 5, 9])
my_arr = array.array('i', sorted(my_arr))
print("Array sorted:", my_arr)

Lists mixed types allow karti hain aur zyada methods deti hain. Arrays sirf same type allow karti hain lekin memory efficient hoti hain. Sorting ke liye arrays mein sorted() use karo ya list() mein convert karo.

Practical use cases

import array

# Store sensor readings (float array)
temperatures = array.array('f', [23.5, 24.1, 22.8, 25.0, 23.9])
print("Avg temp:", sum(temperatures) / len(temperatures))

# Binary data (byte array)
data = array.array('B', [72, 101, 108, 108, 111]) # "Hello" in ASCII
text = bytes(data).decode()
print("Decoded:", text)

# Large number storage
fibonacci = array.array('Q', [0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
print("Fibonacci:", fibonacci)
print(f"Total numbers: {len(fibonacci)}")

Arrays real projects mein bahut kaam aati hain — sensor data store karna, binary data handle karna, large numbers rakhna. Type codes se memory control hota hai.

Common mistakes

• Galat type code dena — 'i' array mein string append karne se TypeError aayega.
• Arrays ko lists samajh ke .sort() call karna — arrays mein sorted() use karo ya list() mein convert karo.
• Large data ke liye lists use karna jab arrays ho sakti hain — memory waste hota hai.
• Type codes yaad na rakhna — 'i' int, 'f' float, 'd' double, 'b' byte.
• Arrays mein mixed types dalne ki koshish — arrays sirf ek type allow karte hain.