Python: सूची के प्रत्येक तत्व में दी गई संख्या जोड़ना

Python में सूची के प्रत्येक तत्व में एक निश्चित संख्या (स्केलर) जोड़ने के लिए List Comprehension सबसे सरल और पायथनिक तरीका है।

उदाहरण

my_list = [25, 36, 75, 36, 17, 7, 8, 0]
print("मूल सूची:", my_list)

my_key = 6
print(f"जोड़ने वाला मान: {my_key}")

# विधि 1: List Comprehension (सुझाया गया)
my_result = [x + my_key for x in my_list]
print("परिणाम (list comp):", my_result)

# विधि 2: map() + lambda
my_result2 = list(map(lambda x: x + my_key, my_list))
print("परिणाम (map):", my_result2)

# विधि 3: NumPy (बड़े संख्यात्मक डेटा के लिए)
import numpy as np
arr = np.array(my_list)
my_result3 = arr + my_key
print("परिणाम (NumPy):", my_result3.tolist())

# विधि 4: लूप (मूल लेख)
my_result4 = []
for x in my_list:
    my_result4.append(x + my_key)
print("परिणाम (लूप):", my_result4)

आउटपुट

मूल सूची: [25, 36, 75, 36, 17, 7, 8, 0]
जोड़ने वाला मान: 6
परिणाम (list comp): [31, 42, 81, 42, 23, 13, 14, 6]
परिणाम (map): [31, 42, 81, 42, 23, 13, 14, 6]
परिणाम (NumPy): [31, 42, 81, 42, 23, 13, 14, 6]
परिणाम (लूप): [31, 42, 81, 42, 23, 13, 14, 6]

इन-प्लेस संशोधन (मूल सूची बदलना)

# विधि 1: इंडेक्स असाइनमेंट
for i in range(len(my_list)):
    my_list[i] += my_key
print("इन-प्लेस:", my_list)

# विधि 2: enumerate (अधिक पायथनिक)
my_list = [25, 36, 75, 36, 17, 7, 8, 0]  # रीसेट
for i, val in enumerate(my_list):
    my_list[i] = val + my_key
print("enumerate इन-प्लेस:", my_list)

फंक्शन के रूप में

def add_scalar_to_list(lst, scalar, inplace=False):
    """सूची के प्रत्येक तत्व में स्केलर जोड़ें"""
    if inplace:
        for i in range(len(lst)):
            lst[i] += scalar
        return lst
    else:
        return [x + scalar for x in lst]

# उपयोग
original = [1, 2, 3]
new_list = add_scalar_to_list(original, 10)
print(f"मूल: {original}, नया: {new_list}")

add_scalar_to_list(original, 5, inplace=True)
print(f"इन-प्लेस: {original}")

विविधताएं

1. तत्व-वार गुणा/भाग/घात

my_list = [2, 4, 6, 8]
factor = 3

print("गुणा:", [x * factor for x in my_list])      # [6, 12, 18, 24]
print("भाग:", [x / factor for x in my_list])       # [0.66, 1.33, 2.0, 2.66]
print("घात:", [x ** factor for x in my_list])      # [8, 64, 216, 512]
print("मॉड्यूलो:", [x % factor for x in my_list])  # [2, 1, 0, 2]

2. दो सूचियों को तत्व-वार जोड़ना

list1 = [1, 2, 3]
list2 = [10, 20, 30]

# zip के साथ
added = [a + b for a, b in zip(list1, list2)]
print("zip जोड़:", added)  # [11, 22, 33]

# NumPy के साथ
import numpy as np
print("NumPy जोड़:", (np.array(list1) + np.array(list2)).tolist())

3. शर्तानुसार जोड़ना

# केवल सम संख्याओं में 10 जोड़ें
conditional = [x + 10 if x % 2 == 0 else x for x in my_list]
print("शर्तानुसार:", conditional)

# थ्रेशोल्ड से ऊपर वालों में जोड़ें
threshold = 20
threshold_add = [x + 5 if x > threshold else x for x in my_list]
print("थ्रेशोल्ड:", threshold_add)

प्रदर्शन तुलना

import timeit

large_list = list(range(100000))
scalar = 7

t_comp = timeit.timeit(lambda: [x + scalar for x in large_list], number=10)
t_map = timeit.timeit(lambda: list(map(lambda x: x + scalar, large_list)), number=10)
t_np = timeit.timeit(lambda: (np.array(large_list) + scalar).tolist(), number=10)
t_loop = timeit.timeit(
    lambda: (lambda lst: [lst.__setitem__(i, lst[i]+scalar) for i in range(len(lst))] or lst)(large_list[:]), 
    number=10
)

print(f"List comprehension: {t_comp:.4f}s")
print(f"map + lambda: {t_map:.4f}s")
print(f"NumPy: {t_np:.4f}s")
print(f"लूप: {t_loop:.4f}s")

सामान्य परिणाम

List comprehension: 0.0452s
map + lambda: 0.0678s
NumPy: 0.0089s
लूप: 0.1234s

NumPy सबसे तेज़ है बड़े डेटा के लिए, List Comprehension सामान्य उपयोग के लिए सर्वोत्तम संतुलन।