Theory
Multi-Row Manual Math ની પીડા
તમારા Semester 1 C labs માં, જો તમારી પાસે 100 pocket-money transaction spends ની એક list હોય અને દરેકે દરેક item ને 5% tax થી વધારવું હોય કે માત્ર 50 Rs થી વધુના transactions filter કરવા હોય, તો તમારે અલગ loop counters જાહેર કરવા, પગલું-દર-પગલું iterate કરવું, અને હાથે items ને એક નવી array માં append કરવા પડતા. Standard Python માં પણ, એક primitive list પર math ચલાવવા એક સ્પષ્ટ for loop કે એક list comprehension જોઈએ. NumPy આ loop lines ને સંપૂર્ણપણે કેમ દૂર કરી નાખે છે, તમને numbers ની આખી lists ને mathematical syntax ની એક જ લીટીથી manipulate કરવા દેતાં?
Theory
એક-Passenger Courier સામે એકીકૃત Freight Train
એક courier service કલ્પો જેને 10 parcels જુદાં જુદાં ઘરે પહોંચાડવાનાં છે. એક basic Python list વાપરવી એટલે એક bike courier મોકલવો જે એક parcel લે છે, એક જગ્યાએ જાય છે, પાછો આવે છે, બીજું parcel લે છે, અને 10 વાર આ ફેરો દોહરાવે છે. NumPy arrays એક high-speed freight train ની જેમ કામ કરે છે જે એકસાથે બધાં 10 parcels ભરીને ચાલે છે. જ્યારે એક mathematical સૂચના અપાય છે, એ આખી train ને એકસાથે અડે છે, એક જ processing ફેરામાં દરેકે દરેક parcel ને સમાંતરે બદલી નાખતાં.
Theory
Vectorization અને Boolean Masking ઔપચારિક રીતે
જ્યારે તમે np.array() વાપરીને એક standard Python list ને NumPy array માં ફેરવો છો, ત્યારે એ સંગ્રહને vectorization ની શક્તિ મળે છે. Vectorization સ્પષ્ટ loops ને high-performance, compiled C-code expressions થી બદલી નાખે છે. આ broadcasting શક્ય બનાવે છે, જ્યાં એક operation (જેમ કે arr * 1.05) આપોઆપ દરેકે દરેક element પર લાગુ થાય છે. વધુમાં, arr > 50 જેવી conditions તપાસવાથી filter થયેલી list પાછી નથી મળતી; એને બદલે, એ એક Boolean Mask (true/false flags ની એક array) generate કરે છે જેને elements તરત filter કરવા brackets માં પાછી આપી શકાય.
At a glance
Table 1: Numeric list processing માટે vectorized operations અને boolean filtering syntax.
| Array Vector Operation | એ Dataset ને કેવી રીતે બદલે છે | પરિણામી Output Structure |
|---|---|---|
| spends_arr * 1.10 | Broadcasting: દરેક element ને 1.10 થી ગુણે છે (10% inflation ઉમેરે છે). | એક નવી array જેમાં બધા numbers અંશતઃ મોટા થયેલા હોય. |
| spends_arr > 50 | Logical Evaluation: દરેક cell ને scalar value 50 સામે ચકાસે છે. | માત્ર True અને False flags ધરાવતી એક boolean array. |
| spends_arr[spends_arr > 50] | Boolean Indexing: જ્યાં condition True હોય એ cells filter કરીને રાખે છે. | માત્ર 50 થી વધુ elements ધરાવતી એક ટૂંકી array. |
| spends_arr.round(2) | Element-wise Precision: fractional digits ને બે દશાંશ સ્થાન સુધી round કરે છે. | financial logging માટે સાફ રીતે format થયેલી floats ની એક array. |
Theory
Worked Example: Spends Dataset નું Vectorized Auditing
ચાલો આ concepts એક લાક્ષણિક pocket-money ledger પર લાગુ કરીએ. આપણે રોજિંદા spends ની એક raw numerical Python list ને NumPy array માં load કરીશું, broadcasting દ્વારા એક સરખો cashback discount લગાવીશું, અને boolean arrays વાપરીને high-value transactions તરત અલગ પાડીશું.
Practical
PocketMoney Vectorized Analyzer
import numpy as np
# Step 1: Raw Python list tracking student canteen spends
raw_spends = [40, 120, 35, 75, 200, 50]
# Step 2: Convert the list into a high-speed NumPy array
spends_arr = np.array(raw_spends)
# Step 3: Vectorized Broadcasting - Apply a flat 5 Rs cashback discount
discounted_spends = spends_arr - 5
# Step 4: Boolean Masking - Identify transactions that exceed 60 Rs
high_value_mask = discounted_spends > 60
filtered_spends = discounted_spends[high_value_mask]
print("Original Spends Array:", spends_arr)
print("Discounted Spends Array:", discounted_spends)
print("Logical Boolean Mask:", high_value_mask)
print("Filtered High Spends:", filtered_spends)This example runs in Gri-Learn on the web, where you can edit it and see the output.
Think first
Element-Wise ફેરફારો ટ્રેસ કરો
tracking script નાં પગલાં ધ્યાનથી જુઓ. Logical Boolean Mask અને Filtered High Spends arrays માટે બિલકુલ કયા ઘટકો print થશે?
Show the answer
script output કરશે:
Original Spends Array: [ 40 120 35 75 200 50]
Discounted Spends Array: [ 35 115 30 70 195 45]
Logical Boolean Mask: [False True False True True False]
Filtered High Spends: [115 70 195]
કેમ? 5 બાદ કરવાથી દરેક element સરખી રીતે ઘટે છે. પછી, > 60 નું મૂલ્યાંકન દરેક discounted item તપાસે છે: 35 false છે, 115 true છે, 30 false છે, 70 true છે, 195 true છે, અને 45 false છે. આ boolean mask array ને brackets માં પાછી આપવાથી માત્ર True તરીકે નિશાન કરેલા indices બહાર ખેંચાય છે, અંતિમ high-value subset બનાવતાં.
Quiz
જો તમારી પાસે એક NumPy array `vals = np.array([10, 20, 30])` હોય અને તમે statement `res = vals + 2` ચલાવો, તો `res` ની અંદર શું સંઘરાય છે?
- `[12, 20, 30]` ધરાવતી એક array કારણ કે માત્ર પહેલું item મળે છે.
- `[10, 20, 30, 2]` ધરાવતી એક array કારણ કે એ scalar append કરે છે.
- vectorized broadcasting ને કારણે `[12, 22, 32]` ધરાવતી એક array.
- એક તરત TypeError કારણ કે તમે એક array container માં સીધો એક scalar ઉમેરી શકતા નથી.
Show the answer
vectorized broadcasting ને કારણે `[12, 22, 32]` ધરાવતી એક array.
NumPy એક આખા array sequence પર એકલા numbers ને આપોઆપ scale કે adjust કરવા broadcasting વાપરે છે. scalar 2 અંતર્ગત રીતે broadcast થાય છે અને 10, 20, અને 30 માં અલગ અલગ ઉમેરાય છે, તરત [12, 22, 32] બનાવતાં.
Quiz
Python analytics માં numeric datasets filter કરતી વખતે એક Boolean Mask ની મુખ્ય ભૂમિકા શું છે?
- એ terminal display output screen પરથી સંવેદનશીલ financial values છુપાવે છે.
- એ True/False values ની એક array બનાવે છે જે એક index filter તરીકે લાગુ થતાં target elements અલગ પાડે છે.
- એ strings ની એક array ને floating-point numbers માં ફેરવવા મજબૂર કરે છે.
- એ સંરચનાત્મક matrix reshapes આપોઆપ સંભાળે છે.
Show the answer
એ True/False values ની એક array બનાવે છે જે એક index filter તરીકે લાગુ થતાં target elements અલગ પાડે છે.
એક boolean mask એક ચોક્કસ criteria filter તરીકે કામ કરે છે. જ્યારે arr[mask] જેવા index brackets તરીકે લાગુ થાય, NumPy પસંદગીપૂર્વક માત્ર એ indices રાખે છે જ્યાં mask માં એક True flag હોય, False values ને સંપૂર્ણપણે કાઢી નાખતાં.
Watch out
Classic ફાંદો: ખૂટતા Filtering Brackets
university laboratory examinations માં સૌથી સામાન્ય marks-ગુમાવતી ભૂલ એ છે filtered = spends_arr > 50 લખવું અને એની પાસેથી ખરેખરા numbers મળવાની અપેક્ષા રાખવી. આમ કરવાથી માત્ર raw [True, False, ...] flag mask જ સચવાય છે! ખરેખરી values મેળવવા, તમારે એ mask ને array brackets માં પાછો આપવો પડશે: filtered = spends_arr[spends_arr > 50]. બહારનું array વીંટાળવાનું ભૂલશો નહીં!
Theory
Vectorized Lists ને Semester 3 સાથે જોડવા
Vectorized arithmetic layouts સીધા ઊંડા big-data engines પર map થાય છે. Semester 3 (BCA303/BCA304) માં, જ્યારે unstructured records સાફ કરશો, અમાન્ય sensor anomalies દૂર કરશો, કે SQL databases પર column scaling કરશો, ત્યારે તમે analytical reporting systems માં સાફ tables આપતાં પહેલાં corrupt log entries તરત filter કરવા boolean masks વાપરશો.
Summary
Key takeaways
- Standard lists ને NumPy arrays માં ફેરવવાથી high-speed vectorized operations શક્ય બને છે.
- Broadcasting manual loops વગર એક આખા સંગ્રહ પર એકસાથે mathematical ફેરફારો લાગુ કરે છે.
- Logical expressions સંરચનાત્મક true કે false સૂચક flags થી ભરેલા Boolean Masks generate કરે છે.
- Boolean Indexing આ flag arrays ને brackets માં પાછી મોકલીને subsets તરત filter કરે છે.
- Memory Hook: Scalars દરેક cell પર broadcast થાય છે, conditions true/false masks બનાવે છે, brackets data filter કરે છે!