NumPy Basics – NIELIT O Level (M3-R5)

📘 Introduction

NumPy का पूरा नाम है Numerical Python — यह Python की एक powerful library है जो scientific computing और numerical analysis के लिए बनाई गई है। इसे large multidimensional arrays और matrices पर तेज़ calculations के लिए use किया जाता है।

NumPy Python के scientific stack का foundation है, जिस पर Pandas, Matplotlib, TensorFlow जैसी libraries depend करती हैं।

⚙️ 1️⃣ Why NumPy?

Python की normal lists भी data store कर सकती हैं, लेकिन large-scale numerical data के लिए lists slow और inefficient होती हैं। NumPy arrays:

• ✅ Fast और memory efficient होते हैं।
• ✅ Vectorized operations allow करते हैं (loop की ज़रूरत नहीं)।
• ✅ Broadcasting feature से अलग shapes वाले arrays पर भी operations कर सकते हैं।

📦 2️⃣ Installing NumPy

NumPy install करने के लिए terminal या command prompt में command चलाएँ:

pip install numpy
  

और import करने के लिए:

import numpy as np
  

💡 “np” एक common alias है जिसे हर programmer follow करता है।

🧩 3️⃣ NumPy Array vs Python List

चलिए difference को एक example से समझते हैं 👇

import numpy as np
import time

# Python list
list_data = list(range(1_000_000))
start = time.time()
list_result = [x * 2 for x in list_data]
print("List time:", time.time() - start)

# NumPy array
array_data = np.arange(1_000_000)
start = time.time()
array_result = array_data * 2
print("NumPy time:", time.time() - start)
  

💡 Output बताएगा कि NumPy arrays Python lists से कई गुना तेज़ हैं क्योंकि वे internally C-language में optimized operations use करते हैं।

🔢 4️⃣ Creating NumPy Arrays

NumPy में array बनाने के कई तरीके हैं:

import numpy as np

# From a Python list
a = np.array([1, 2, 3, 4])
print(a)

# Multi-dimensional array
b = np.array([[1, 2], [3, 4]])
print(b)
  

Output:
[1 2 3 4]
[[1 2]
[3 4]]

💡 NumPy arrays का type होता है numpy.ndarray

📊 5️⃣ Basic Array Properties

arr = np.array([[10, 20, 30], [40, 50, 60]])

print("Array:\n", arr)
print("Shape:", arr.shape)
print("Dimensions:", arr.ndim)
print("Data Type:", arr.dtype)
print("Size:", arr.size)
print("Type:", type(arr))
  

Output:
Array:
[[10 20 30]
[40 50 60]]
Shape: (2, 3)
Dimensions: 2
Data Type: int64
Size: 6
Type: <class 'numpy.ndarray'>

🧮 6️⃣ Vectorized Operations

NumPy arrays element-wise operations support करते हैं:

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print("Addition:", a + b)
print("Subtraction:", a - b)
print("Multiplication:", a * b)
print("Division:", a / b)
  

Output:
Addition: [5 7 9]
Subtraction: [-3 -3 -3]
Multiplication: [4 10 18]
Division: [0.25 0.4 0.5]

💡 यह feature lists में नहीं मिलता — वहाँ loops manually लिखने पड़ते हैं।

📘 7️⃣ Mathematical Functions

NumPy में कई mathematical functions available हैं:

arr = np.array([1, 2, 3, 4, 5])
print("Sum:", np.sum(arr))
print("Mean:", np.mean(arr))
print("Standard Deviation:", np.std(arr))
print("Square Root:", np.sqrt(arr))
  

Output:
Sum: 15
Mean: 3.0
Standard Deviation: 1.4142
Square Root: [1. 1.41 1.73 2. 2.23]

📂 8️⃣ Advantages of NumPy

• 🔹 High performance for numerical data.
• 🔹 Efficient memory usage.
• 🔹 Supports broadcasting and vectorization.
• 🔹 Integrates easily with Pandas, Matplotlib, etc.
• 🔹 Provides tools for linear algebra, random numbers, and Fourier transforms.

💬 9️⃣ Interview FAQs

• Q: What is NumPy?
  A: NumPy is a Python library for numerical and scientific computation.
• Q: How is NumPy faster than lists?
  A: NumPy uses C-based vectorized operations and stores data in contiguous memory blocks.
• Q: What is ndarray?
  A: The core data structure in NumPy representing N-dimensional arrays.
• Q: What are some common NumPy functions?
  A: np.sum(), np.mean(), np.std(), np.sqrt(), np.arange(), etc.
• Q: How do you install NumPy?
  A: Using pip install numpy.

📘 Introduction

NumPy का सबसे main object है — ndarray जिसका मतलब है N-dimensional array. यह homogeneous data items (यानि same data type वाले elements) का collection होता है।

👉 Python lists heterogeneous data (mixed types) रख सकती हैं, लेकिन NumPy arrays memory-efficient और numerical operations के लिए optimized होते हैं।

⚙️ 1️⃣ Creating ndarray Objects

NumPy array (ndarray) बनाने के कई तरीके हैं:

import numpy as np

# 1D Array
a = np.array([10, 20, 30, 40])
print("1D Array:\n", a)

# 2D Array
b = np.array([[1, 2, 3], [4, 5, 6]])
print("\n2D Array:\n", b)

# 3D Array
c = np.array([
              [[1, 2], [3, 4]],
              [[5, 6], [7, 8]]
             ])
print("\n3D Array:\n", c)
  

Output:
1D Array: [10 20 30 40]
2D Array:
[[1 2 3]
[4 5 6]]
3D Array:
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]

🔹 2️⃣ ndarray Properties

हर NumPy array के कुछ important attributes होते हैं 👇

arr = np.array([[10, 20, 30], [40, 50, 60]])

print("Array:\n", arr)
print("Type:", type(arr))
print("Shape:", arr.shape)
print("Dimensions:", arr.ndim)
print("Data Type:", arr.dtype)
print("Size:", arr.size)
print("Total Bytes:", arr.nbytes)
  

Output:
Array:
[[10 20 30]
[40 50 60]]
Type: <class 'numpy.ndarray'>
Shape: (2, 3)
Dimensions: 2
Data Type: int64
Size: 6
Total Bytes: 48

💡 Explanation:
- shape: array का row-column structure
- ndim: dimensions की संख्या
- dtype: elements का data type
- size: total elements की संख्या
- nbytes: total memory (in bytes)

🧮 3️⃣ Homogeneous Data

सभी elements का data type same होना जरूरी है। अगर आप mixed types देंगे, तो NumPy उन्हें automatically upcast कर देता है।

arr = np.array([1, 2.5, 3])
print(arr)
print("Data Type:", arr.dtype)
  

Output:
[1. 2.5 3. ]
Data Type: float64

💡 NumPy automatically int को float में convert कर देता है ताकि array uniform रहे।

🧩 4️⃣ Creating Arrays with Specific Data Type

आप dtype manually define भी कर सकते हैं:

arr1 = np.array([1, 2, 3], dtype='float32')
arr2 = np.array([4, 5, 6], dtype='complex')

print("Float Array:", arr1)
print("Complex Array:", arr2)
  

Output:
Float Array: [1. 2. 3.]
Complex Array: [4.+0.j 5.+0.j 6.+0.j]

📊 5️⃣ Multi-dimensional Arrays

आप N-d arrays (N dimensions) create कर सकते हैं। 1D → Vector, 2D → Matrix, 3D → Tensor.

a = np.array([1, 2, 3])         # 1D
b = np.array([[1, 2], [3, 4]])  # 2D
c = np.array([[[1, 2], [3, 4]]]) # 3D

print(a.ndim, b.ndim, c.ndim)
  

Output:
1 2 3

🔧 6️⃣ Changing Shape

Array को reshape करना बहुत easy है 👇

arr = np.arange(1, 13)
print("Original:", arr)

reshaped = arr.reshape(3, 4)
print("\nReshaped:\n", reshaped)
  

Output:
Original: [ 1 2 3 4 5 6 7 8 9 10 11 12]
Reshaped:
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]

💡 Note: reshape() memory-efficient है — data copy नहीं करता।

🧠 7️⃣ Copy vs View Concept

जब आप NumPy array को assign करते हैं, तो actual data copy नहीं होता, बल्कि एक reference बनता है (view)।

arr = np.array([1, 2, 3, 4])
view_arr = arr.view()
copy_arr = arr.copy()

arr[0] = 99

print("Original:", arr)
print("View:", view_arr)
print("Copy:", copy_arr)
  

Output:
Original: [99 2 3 4]
View: [99 2 3 4]
Copy: [1 2 3 4]

💡 view() same memory share करता है, जबकि copy() अलग memory block बनाता है।

📘 8️⃣ Checking Array Properties

arr = np.array([[5, 10], [15, 20]])
print("Shape:", arr.shape)
print("Size:", arr.size)
print("Itemsize:", arr.itemsize)
print("Data Type:", arr.dtype)
  

Output:
Shape: (2, 2)
Size: 4
Itemsize: 8
Data Type: int64

💡 हर element का size (bytes) itemsize property से मिलता है।

💬 9️⃣ Interview FAQs

• Q: What is ndarray in NumPy?
  A: N-dimensional homogeneous data structure used for fast computations.
• Q: How is ndarray different from Python list?
  A: ndarray stores same data type elements in contiguous memory, while lists can hold mixed data types.
• Q: What are ndim, shape, and dtype?
  A: ndim → number of dimensions, shape → array structure, dtype → data type of elements.
• Q: What’s the difference between view() and copy()?
  A: view() shares data; copy() creates new independent array.
• Q: What is the default data type in NumPy?
  A: int64 (for integers) and float64 (for decimals).

📘 Introduction

NumPy में हर array element का type एक जैसा (homogeneous) होता है। इस type को dtype (data type object) कहा जाता है। यह बताता है कि array में कौन-सा data store है — जैसे integer, float, string, boolean आदि।

NumPy के dtype objects Python के built-in data types से ज्यादा detailed होते हैं क्योंकि ये memory size और precision को define करते हैं (जैसे int8, int16, int32, float32, float64 आदि)।

🧮 1️⃣ Common NumPy Data Types

💡 Example: NumPy automatically selects the smallest type that can hold the given data.

🔹 2️⃣ Checking Data Type (`dtype` Attribute)

import numpy as np

arr1 = np.array([1, 2, 3])
arr2 = np.array([1.1, 2.2, 3.3])
arr3 = np.array(["A", "B", "C"])
arr4 = np.array([True, False, True])

print("arr1 dtype:", arr1.dtype)
print("arr2 dtype:", arr2.dtype)
print("arr3 dtype:", arr3.dtype)
print("arr4 dtype:", arr4.dtype)
  

Output:
arr1 dtype: int64
arr2 dtype: float64
arr3 dtype: <U1
arr4 dtype: bool

💡 <U1 का मतलब Unicode string (length 1) है।

⚙️ 3️⃣ Creating Arrays with a Specific Data Type

आप array बनाते समय data type specify कर सकते हैं:

arr_int = np.array([1, 2, 3], dtype='int16')
arr_float = np.array([1, 2, 3], dtype='float32')
arr_complex = np.array([1, 2, 3], dtype='complex')

print("Integer:", arr_int.dtype)
print("Float:", arr_float.dtype)
print("Complex:", arr_complex.dtype)
  

Output:
Integer: int16
Float: float32
Complex: complex128

🔄 4️⃣ Type Conversion with astype()

किसी array का data type बदलने के लिए astype() function use किया जाता है।

arr = np.array([10.5, 20.6, 30.7])
new_arr = arr.astype(int)

print("Original:", arr)
print("Converted:", new_arr)
print("Original dtype:", arr.dtype)
print("Converted dtype:", new_arr.dtype)
  

Output:
Original: [10.5 20.6 30.7]
Converted: [10 20 30]
Original dtype: float64
Converted dtype: int64

💡 astype() हमेशा नया array return करता है — existing array modify नहीं करता।

🧩 5️⃣ Mixed Data Type Behavior (Upcasting)

जब आप mixed data देते हैं, तो NumPy automatically upcast कर देता है ताकि सभी elements same dtype में convert हो जाएँ।

arr = np.array([1, 2.5, 3])
print("Array:", arr)
print("Data Type:", arr.dtype)
  

Output:
Array: [1. 2.5 3. ]
Data Type: float64

💡 int → float → string hierarchy में conversion होता है।

🧠 6️⃣ Boolean and Complex Data Types

arr_bool = np.array([1, 0, 3], dtype=bool)
arr_complex = np.array([2, 3], dtype=complex)

print("Boolean Array:", arr_bool)
print("Complex Array:", arr_complex)
  

Output:
Boolean Array: [ True False True ]
Complex Array: [2.+0.j 3.+0.j]

💡 Boolean array में 0 → False और non-zero → True बन जाता है।

🔬 7️⃣ Structured Data Types (Advanced)

NumPy में आप structured arrays भी बना सकते हैं — जैसे records (database rows) को store करने के लिए।

student_dtype = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])

students = np.array([
    ('Amit', 20, 85.5),
    ('Riya', 19, 92.0),
    ('Rahul', 21, 78.0)
], dtype=student_dtype)

print(students)
print("Name of first student:", students[0]['name'])
print("Marks of all students:", students['marks'])
  

Output:
[(b'Amit', 20, 85.5) (b'Riya', 19, 92. ) (b'Rahul', 21, 78. )]
Name of first student: b'Amit'
Marks of all students: [85.5 92. 78. ]

💡 Structured arrays में हर field का अपना dtype होता है, जिससे database-style operations आसानी से किए जा सकते हैं।

📘 8️⃣ dtype Information Functions

print(np.sctypeDict.keys())   # Shows all available scalar types
print(np.typecodes)           # Returns shorthand codes
  

Common Type Codes:
i → integer, f → float, b → boolean, c → complex, U → unicode, S → string

💬 9️⃣ Interview FAQs

• Q: What is dtype in NumPy?
  A: It defines the data type of array elements (e.g., int32, float64).
• Q: How do you change dtype of an array?
  A: Using astype() method.
• Q: What is upcasting in NumPy?
  A: Automatic conversion of smaller data type to larger (e.g., int → float).
• Q: What are structured arrays?
  A: Arrays with multiple fields having different data types (like database records).
• Q: Which function is used to check array data type?
  A: array.dtype

📘 Introduction

हर NumPy array (ndarray) के कुछ विशेष attributes होते हैं जो उसकी structure, size, shape और data type को बताने में मदद करते हैं। ये attributes array की जानकारी देते हैं — और debugging या reshaping के समय बहुत काम आते हैं।

🔹 1️⃣ Common Array Attributes

🧩 2️⃣ Example: Basic Array Attributes

import numpy as np

arr = np.array([[10, 20, 30], [40, 50, 60]])
print("Array:\n", arr)
print("\nDimensions (ndim):", arr.ndim)
print("Shape:", arr.shape)
print("Size:", arr.size)
print("Data Type (dtype):", arr.dtype)
print("Item Size (bytes):", arr.itemsize)
print("Total Memory (nbytes):", arr.nbytes)
print("Type:", type(arr))
  

Output:
Array:
[[10 20 30]
[40 50 60]]
Dimensions (ndim): 2
Shape: (2, 3)
Size: 6
Data Type: int64
Item Size: 8
Total Memory: 48
Type: <class 'numpy.ndarray'>

🔢 3️⃣ shape Attribute (Array Structure)

shape attribute tuple return करता है जो बताता है कि array में कितनी rows और columns हैं। आप shape को modify भी कर सकते हैं।

arr = np.arange(12)
print("Original Shape:", arr.shape)

arr.shape = (3, 4)
print("Reshaped Array:\n", arr)
print("New Shape:", arr.shape)
  

Output:
Original Shape: (12,)
Reshaped Array:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
New Shape: (3, 4)

💡 shape को manually set करना reshape() की तरह ही काम करता है।

🔄 4️⃣ ndim Attribute (Dimensions)

ndim बताता है कि array कितने dimensions का है — 1D → Vector, 2D → Matrix, 3D → Tensor।

a = np.array([1, 2, 3])
b = np.array([[1, 2, 3], [4, 5, 6]])
c = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

print("a.ndim:", a.ndim)
print("b.ndim:", b.ndim)
print("c.ndim:", c.ndim)
  

Output:
a.ndim: 1
b.ndim: 2
c.ndim: 3

⚙️ 5️⃣ dtype Attribute (Data Type)

dtype बताता है कि array के अंदर elements का type क्या है।

arr1 = np.array([10, 20, 30])
arr2 = np.array([10.5, 20.7, 30.2])
arr3 = np.array([True, False, True])

print("arr1 dtype:", arr1.dtype)
print("arr2 dtype:", arr2.dtype)
print("arr3 dtype:", arr3.dtype)
  

Output:
arr1 dtype: int64
arr2 dtype: float64
arr3 dtype: bool

💾 6️⃣ itemsize & nbytes Attributes

itemsize हर element का byte size देता है और nbytes पूरे array की total memory बताता है।

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Item Size:", arr.itemsize)
print("Total Bytes:", arr.nbytes)
print("Verification:", arr.size * arr.itemsize)
  

Output:
Item Size: 8
Total Bytes: 48
Verification: 48

💡 nbytes = size × itemsize formula हमेशा सही होता है।

🔁 7️⃣ Transpose using T Attribute

NumPy array का transpose निकालने के लिए `.T` attribute का use किया जाता है। Rows columns बन जाते हैं और vice versa।

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Original:\n", arr)
print("\nTranspose:\n", arr.T)
  

Output:
Original:
[[1 2 3]
[4 5 6]]
Transpose:
[[1 4]
[2 5]
[3 6]]

💡 Transpose property mostly matrix multiplication या linear algebra में useful है।

🧠 8️⃣ Memory Layout Attributes

NumPy arrays का internal memory layout भी check किया जा सकता है।

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Strides:", arr.strides)
print("Flags:\n", arr.flags)
  

Output (example):
Strides: (24, 8)
Flags:
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False

💡 Strides बताते हैं कि memory में elements कितने bytes skip करके stored हैं। Flags array की memory properties बताते हैं।

💬 9️⃣ Interview FAQs

• Q: What is the difference between shape and size?
  A: shape = structure (rows, columns), size = total elements.
• Q: How can you check number of dimensions?
  A: Using ndim.
• Q: How can you find total memory used by an array?
  A: Using nbytes or size × itemsize.
• Q: What does the attribute T represent?
  A: Transpose of the array.
• Q: How can you get stride information?
  A: Using array.strides.

📘 Introduction

NumPy में कई built-in functions हैं जो हमें अलग-अलग तरीकों से arrays बनाने की सुविधा देते हैं। ये functions mathematical, scientific या data initialization में बहुत काम आते हैं।

🔹 1️⃣ Basic Array Creation Functions

🧮 2️⃣ np.zeros()

यह function zero-filled array बनाता है।

import numpy as np

a = np.zeros((3, 4))
print(a)
print("Data Type:", a.dtype)
  

Output:
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
Data Type: float64

💡 Default data type float होता है — आप dtype='int' देकर बदल सकते हैं।

🧩 3️⃣ np.ones()

यह function one-filled array बनाता है।

b = np.ones((2, 3), dtype=int)
print(b)
  

Output:
[[1 1 1]
[1 1 1]]

💡 अक्सर initialization के लिए उपयोग होता है।

🔢 4️⃣ np.full()

आप एक fixed value से पूरी array भर सकते हैं।

c = np.full((3, 3), 7)
print(c)
  

Output:
[[7 7 7]
[7 7 7]
[7 7 7]]

💡 Machine learning में constant matrices बनाने के लिए useful है।

⚙️ 5️⃣ np.eye()

यह identity matrix बनाता है — diagonal में 1 और बाकी जगह 0।

I = np.eye(4)
print(I)
  

Output:
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]

💡 Linear algebra (matrix inverse, dot product) में बहुत उपयोगी।

🔄 6️⃣ np.arange()

यह function Python range() की तरह काम करता है लेकिन array return करता है।

arr = np.arange(1, 11, 2)
print(arr)
  

Output:
[1 3 5 7 9]

💡 step size के साथ numeric sequences generate करने में उपयोगी।

📈 7️⃣ np.linspace()

यह function start और end values के बीच में equal spacing वाले numbers बनाता है।

x = np.linspace(0, 1, 6)
print(x)
  

Output:
[0. 0.2 0.4 0.6 0.8 1. ]

💡 Mostly plotting और graph generation में useful।

🧠 8️⃣ np.empty()

np.empty() memory allocate करता है लेकिन elements initialize नहीं करता (random values दिख सकते हैं)।

e = np.empty((2,3))
print(e)
  

Output (Example):
[[1.004e-315 0.000e+000 4.940e-324]
[0.000e+000 0.000e+000 0.000e+000]]

💡 Speed optimization के लिए np.empty() बहुत तेज़ होता है।

🧩 9️⃣ Random Arrays

NumPy में random number arrays बनाने के लिए np.random module होता है।

rand_arr = np.random.randint(1, 10, size=(3,3))
rand_float = np.random.rand(2, 4)

print("Random Integers:\n", rand_arr)
print("\nRandom Floats:\n", rand_float)
  

Output:
Random Integers:
[[2 9 1]
[7 3 8]
[5 4 6]]
Random Floats:
[[0.32 0.78 0.12 0.95]
[0.67 0.11 0.84 0.42]]

💬 🔟 Interview FAQs

• Q: Difference between arange() and linspace()?
  A: arange uses step size; linspace uses number of points.
• Q: What is identity matrix in NumPy?
  A: Square matrix with diagonal 1s, created using np.eye().
• Q: How do you create a constant array?
  A: Using np.full(shape, value).
• Q: Which function creates uninitialized array?
  A: np.empty().
• Q: How can you create random numbers?
  A: np.random.randint() (integers) or np.random.rand() (floats).

📘 Introduction

NumPy में आप किसी existing data structure — जैसे list, tuple, या even दूसरे NumPy array — से नया array बना सकते हैं। इसे कहा जाता है Array from Existing Data creation method।

यह method तब useful होता है जब data पहले से available हो, और हमें उसे fast numerical processing के लिए NumPy में convert करना हो।

🔹 1️⃣ Using np.array() (From Python List or Tuple)

सबसे basic तरीका है np.array() function का उपयोग — यह list या tuple को NumPy array में बदल देता है।

import numpy as np

# From a Python List
list_data = [10, 20, 30, 40]
arr1 = np.array(list_data)
print("Array from List:", arr1)

# From a Python Tuple
tuple_data = (1, 2, 3, 4, 5)
arr2 = np.array(tuple_data)
print("Array from Tuple:", arr2)
  

Output:
Array from List: [10 20 30 40]
Array from Tuple: [1 2 3 4 5]

💡 यह सबसे common तरीका है existing data को NumPy array में convert करने का।

🧮 2️⃣ Multi-dimensional Array from Nested List

आप nested lists (lists inside lists) देकर multi-dimensional arrays बना सकते हैं।

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
arr3 = np.array(nested_list)
print(arr3)
print("Shape:", arr3.shape)
  

Output:
[[1 2 3]
[4 5 6]
[7 8 9]]
Shape: (3, 3)

💡 nested list के depth से NumPy automatically dimension set कर देता है।

📘 3️⃣ Using np.asarray()

np.asarray() function भी existing data से array बनाता है — लेकिन फर्क ये है कि अगर data पहले से array है तो वो **copy नहीं करता**, बल्कि **reference (view)** देता है।

list_data = [5, 10, 15]
arr4 = np.asarray(list_data)
print(arr4)

# Converting an existing array again
arr_existing = np.array([1, 2, 3])
arr5 = np.asarray(arr_existing)
arr_existing[0] = 99

print("Existing:", arr_existing)
print("asarray:", arr5)
  

Output:
Existing: [99 2 3]
asarray: [99 2 3]

💡 asarray() ज्यादा efficient है जब आपको copy नहीं चाहिए।

🔁 4️⃣ Using np.copy()

अगर आपको data की independent copy बनानी है (जो changes से unaffected रहे), तो np.copy() use करें।

arrA = np.array([1, 2, 3, 4])
arrB = np.copy(arrA)

arrA[0] = 100

print("Original Array:", arrA)
print("Copied Array:", arrB)
  

Output:
Original Array: [100 2 3 4]
Copied Array: [1 2 3 4]

💡 यह deep copy बनाता है — दोनों arrays independent रहते हैं।

🧩 5️⃣ From Another Array (Like Type Conversion)

आप existing array को दूसरे dtype में बदलकर नया array बना सकते हैं।

arr_int = np.array([1, 2, 3])
arr_float = np.array(arr_int, dtype=float)
print(arr_float)
  

Output:
[1. 2. 3.]

💡 नया dtype देने से original data unaffected रहता है।

💾 6️⃣ From Buffer (Advanced)

NumPy arrays को raw memory buffer से भी बनाया जा सकता है। इसका उपयोग low-level programming या binary data handling में किया जाता है।

import array

# Python's array module
py_array = array.array('i', [1, 2, 3, 4, 5])
np_arr = np.frombuffer(py_array, dtype=int)
print(np_arr)
  

Output:
[1 2 3 4 5]

💡 यहाँ frombuffer() method memory-efficient view बनाता है, copy नहीं करता।

📊 7️⃣ From Iterables (like range, generators)

किसी भी iterable object से NumPy array बनाना आसान है:

iterable_data = range(1, 6)
arr_from_iter = np.fromiter(iterable_data, dtype=float)
print(arr_from_iter)
  

Output:
[1. 2. 3. 4. 5.]

💡 Large data streaming या generators के साथ बहुत उपयोगी।

🧠 8️⃣ Summary Comparison Table

💬 9️⃣ Interview FAQs

• Q: Difference between np.array() and np.asarray()?
  A: array() always makes a copy; asarray() may return reference.
• Q: Which function is best for large data conversions?
  A: np.asarray() because it avoids unnecessary copies.
• Q: How can you create array from buffer data?
  A: Using np.frombuffer().
• Q: How to create array from iterable object?
  A: Using np.fromiter(iterable, dtype).
• Q: Which function ensures deep copy of array?
  A: np.copy().

📘 Introduction

NumPy numerical sequences और evenly spaced values बनाने के लिए कई powerful functions देता है — जैसे arange(), linspace(), logspace(), और geomspace()। इनका उपयोग data generation, testing, graph plotting और simulation में किया जाता है।

🔹 1️⃣ np.arange()

np.arange() Python के range() function की तरह होता है, लेकिन यह NumPy array return करता है।

import numpy as np

arr1 = np.arange(0, 10, 2)
print("arange(0,10,2):", arr1)
  

Output:
arange(0,10,2): [0 2 4 6 8]

💡 Syntax: np.arange(start, stop, step, dtype) - start → शुरू कहाँ से करना है - stop → कहाँ तक जाना है (exclusive) - step → gap या difference

📈 2️⃣ np.linspace()

np.linspace() function evenly spaced numbers generate करता है between start और stop values — based on number of samples (not step size)।

arr2 = np.linspace(0, 1, 6)
print("linspace(0,1,6):", arr2)
  

Output:
linspace(0,1,6): [0. 0.2 0.4 0.6 0.8 1. ]

💡 Syntax: np.linspace(start, stop, num, endpoint=True, dtype=float)
- num: number of samples - endpoint=False करने पर last value exclude होगी

arr3 = np.linspace(0, 5, 5, endpoint=False)
print(arr3)
  

Output:
[0. 1. 2. 3. 4.]

💡 यह graphs (like sine/cosine plots) बनाने के लिए बहुत useful है।

🧮 3️⃣ np.logspace()

np.logspace() function logarithmic scale पर spaced values generate करता है। यह values को powers of base (default = 10) के रूप में return करता है।

arr4 = np.logspace(1, 3, 5)
print("logspace(1,3,5):", arr4)
  

Output:
logspace(1,3,5): [ 10. 31.62 100. 316.23 1000. ]

💡 Syntax: np.logspace(start, stop, num, base=10.0)
यहाँ start और stop को log10 के रूप में लिया जाता है।

👉 Useful in logarithmic graphs, scientific and exponential data representation.

🔢 4️⃣ np.geomspace()

np.geomspace() function geometric progression में spaced values generate करता है (यानी हर value previous value के multiply ratio में होती है)।

arr5 = np.geomspace(1, 1000, 4)
print("geomspace(1,1000,4):", arr5)
  

Output:
geomspace(1,1000,4): [ 1. 10. 100. 1000.]

💡 यह logarithmic data या frequency analysis में काम आता है। Difference — logspace powers देता है, geomspace actual ratio sequence देता है।

📘 5️⃣ Comparison Table

🧠 6️⃣ Practical Example: Plotting with linspace()

Matplotlib के साथ यह बहुत use होता है:

import matplotlib.pyplot as plt

x = np.linspace(0, 2*np.pi, 100)
y = np.sin(x)

plt.plot(x, y)
plt.title("Sine Wave using linspace()")
plt.show()
  

💡 यहाँ linspace() ने 0 से 2π के बीच 100 equal points generate किए।

💬 7️⃣ Interview FAQs

• Q: Difference between arange() and linspace()?
  A: arange → step-based, linspace → number-based spacing.
• Q: What does logspace() return?
  A: Values spaced evenly on a log scale (powers of 10 by default).
• Q: How does geomspace() differ from logspace()?
  A: logspace() uses powers, geomspace() uses direct geometric progression.
• Q: Can linspace() exclude endpoint?
  A: Yes, by setting endpoint=False.
• Q: Which function is best for generating frequencies or exponential ranges?
  A: np.logspace() or np.geomspace().

📘 Introduction

NumPy arrays Python lists की तरह index और slice किए जा सकते हैं। लेकिन NumPy में ये operations बहुत तेज़ (optimized) होते हैं। Indexing के ज़रिए हम single element access करते हैं, और Slicing के ज़रिए array का हिस्सा निकालते हैं।

🔹 1️⃣ One-Dimensional Indexing

import numpy as np

arr = np.array([10, 20, 30, 40, 50])
print("First element:", arr[0])
print("Last element:", arr[-1])
print("Third element:", arr[2])
  

Output:
First element: 10
Last element: 50
Third element: 30

💡 Indexing 0 से शुरू होती है। Negative index पीछे से गिनती करता है।

🧩 2️⃣ One-Dimensional Slicing

Slicing का format: array[start:stop:step]

print(arr[1:4])      # index 1 से 3 तक
print(arr[:3])       # शुरुआत से 2 तक
print(arr[2:])       # index 2 से अंत तक
print(arr[::-1])     # उल्टा array
  

Output:
[20 30 40]
[10 20 30]
[30 40 50]
[50 40 30 20 10]

💡 Step parameter optional होता है (default = 1)।

🔢 3️⃣ Two-Dimensional Indexing

2D array में rows और columns दोनों के index specify किए जाते हैं।

arr2 = np.array([[1,2,3],[4,5,6],[7,8,9]])

print("Element at (0,0):", arr2[0,0])
print("Element at (1,2):", arr2[1,2])
print("Element at last row, first col:", arr2[-1,0])
  

Output:
Element at (0,0): 1
Element at (1,2): 6
Element at last row, first col: 7

💡 Format: arr[row, column]

🧮 4️⃣ Two-Dimensional Slicing

हम rows और columns दोनों पर slicing कर सकते हैं।

print(arr2[0:2, 1:3])   # पहले दो rows, last दो columns
print(arr2[:, 0])       # सभी rows, पहला column
print(arr2[1, :])       # दूसरी row पूरी
  

Output:
[[2 3]
[5 6]]

[1 4 7]

[4 5 6]

💡 : का मतलब "सभी elements" होता है।

🔄 5️⃣ Boolean Indexing

Boolean indexing से हम conditional selection कर सकते हैं।

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

print("Values > 25:", arr[arr > 25])
print("Values even:", arr[arr % 2 == 0])
  

Output:
Values > 25: [30 40 50]
Values even: [10 20 30 40 50]

💡 यह technique filtering operations में बहुत useful है।

🎯 6️⃣ Fancy Indexing

Fancy indexing में हम specific index की list देकर multiple elements access कर सकते हैं।

arr = np.array([100, 200, 300, 400, 500])

indices = [0, 2, 4]
print(arr[indices])
  

Output:
[100 300 500]

💡 Fancy indexing result हमेशा copy return करता है।

🧠 7️⃣ 3D Array Indexing

3D arrays में 3 indices होते हैं — (depth, row, column)।

arr3 = np.array([
    [[1,2],[3,4]],
    [[5,6],[7,8]]
])

print(arr3[0,1,0])   # 1st block, 2nd row, 1st col
  

Output:
3

💡 Data science में 3D arrays image या tensor data के लिए use होते हैं।

🧩 8️⃣ Modifying Array Elements

Indexing से आप values को directly update कर सकते हैं।

arr = np.array([1,2,3,4,5])
arr[2] = 99
print(arr)

arr2 = np.array([[1,2,3],[4,5,6]])
arr2[1,1] = 100
print(arr2)
  

Output:
[ 1 2 99 4 5]
[[ 1 2 3]
[ 4 100 6]]

📊 9️⃣ Slice View vs Copy

NumPy में slices views return करते हैं — मतलब ये original array को refer करते हैं, copy नहीं बनाते।

arr = np.array([10,20,30,40])
slice_arr = arr[1:3]
slice_arr[0] = 999

print("Original:", arr)
print("Slice:", slice_arr)
  

Output:
Original: [ 10 999 30 40]
Slice: [999 30]

💡 asarray() और slicing दोनों reference देते हैं, जबकि copy() नई memory बनाता है।

💬 🔟 Interview FAQs

• Q: What is the difference between list slicing and NumPy slicing?
  A: NumPy slicing returns a view (not a copy).
• Q: What does arr[::-1] do?
  A: Reverses the array.
• Q: What is fancy indexing?
  A: Accessing multiple specific indices using a list or array of indices.
• Q: How can you access all rows of 2nd column?
  A: arr[:, 1]
• Q: What is Boolean indexing used for?
  A: Conditional filtering of array elements.