मैं सूची में प्रत्येक तत्व को एक संख्या से कैसे गुणा करूं?

Question

मेरे पास एक सूची है:

my_list = [1, 2, 3, 4, 5]

मैं प्रत्येक तत्व को my_list5 से कैसे गुणा कर सकता हूं ? आउटपुट होना चाहिए:

[5, 10, 15, 20, 25]

Comments

का उपयोग करने mapसे बेहतर है for-loop।

— टोनी

और सूची समझ (लगभग हमेशा) की तुलना में बेहतर हैmap (और हमेशा बेहतर mapहोगा अगर आवश्यकता होगी lambda)।

— शैडो रेंजर

Answer 1

आप बस एक सूची समझ का उपयोग कर सकते हैं:

my_list = [1, 2, 3, 4, 5]
my_new_list = [i * 5 for i in my_list]

>>> print(my_new_list)
[5, 10, 15, 20, 25]

ध्यान दें कि एक सूची बोध आमतौर पर एक forलूप करने का एक अधिक कुशल तरीका है :

my_new_list = []
for i in my_list:
    my_new_list.append(i * 5)

>>> print(my_new_list)
[5, 10, 15, 20, 25]

एक विकल्प के रूप में, यहां लोकप्रिय पंडों के पैकेज का उपयोग करके एक समाधान दिया गया है:

import pandas as pd

s = pd.Series(my_list)

>>> s * 5
0     5
1    10
2    15
3    20
4    25
dtype: int64

या, यदि आप केवल सूची चाहते हैं:

>>> (s * 5).tolist()
[5, 10, 15, 20, 25]

Comments

चर नाम जो टोपी से शुरू होता है वह पायथोनिक नहीं है। और वे सूचियाँ हैं, संख्याएँ नहीं। इसलिए मैं उपयोग सुझाव देंगे l1और l2चर नाम के रूप में।

— कासिमिर क्रिस्टल

एक चर के रूप में 'l' का उपयोग भी हतोत्साहित किया जाता है क्योंकि अक्षर 'l' और संख्या 1 आसानी से भ्रमित होते हैं। मैंने ओपी के मूल प्रश्न में चर का उपयोग किया, और मुझे विश्वास है कि आपके प्रश्न के संपादन ने अच्छे से अधिक नुकसान किया है।

— अलेक्जेंडर

यदि आपको लगता है कि मेरा संपादन खराब है, तो आप इसे बेहतर बनाने के लिए प्रश्न को संपादित कर सकते हैं। इसके अलावा, हम बजाय अन्य चर चुन सकते हैं l1जैसे l_1, list_1आदि ये हैं सभी की तुलना में बेहतर Num_1।

— कासिमिर क्रिस्टल

Answer 2

एक धमाकेदार तेजी से दृष्टिकोण सूची से अधिक लूपिंग के बजाय गुणा तरीके से करना है। Numpy ने पहले से ही इसके लिए एक बहुत ही सरल और आसान तरीका प्रदान किया है जिसका आप उपयोग कर सकते हैं।

>>> import numpy as np
>>> 
>>> my_list = np.array([1, 2, 3, 4, 5])
>>> 
>>> my_list * 5
array([ 5, 10, 15, 20, 25])

ध्यान दें कि यह पायथन की मूल सूचियों के साथ काम नहीं करता है। यदि आप किसी संख्या को किसी सूची से गुणा करते हैं तो यह उस संख्या के आकार के आइटम को दोहराएगा।

In [15]: my_list *= 1000

In [16]: len(my_list)
Out[16]: 5000

यदि आप सूची बोध का उपयोग करके शुद्ध पायथन-आधारित दृष्टिकोण चाहते हैं, तो मूल रूप से जाने के लिए सबसे अधिक पायथोनिक तरीका है।

In [6]: my_list = [1, 2, 3, 4, 5]

In [7]: [5 * i for i in my_list]
Out[7]: [5, 10, 15, 20, 25]

सूची बोध के अलावा, एक शुद्ध कार्यात्मक दृष्टिकोण के रूप में, आप map()निम्न के रूप में अंतर्निहित फ़ंक्शन का उपयोग कर सकते हैं :

In [10]: list(map((5).__mul__, my_list))
Out[10]: [5, 10, 15, 20, 25]

यह कोड 's' विधि के भीतर सभी वस्तुओं को पास करता my_listहै और पुनरावृत्ति जैसी वस्तु देता है (अजगर -x में)। फिर आप फ़ंक्शन में निर्मित (पाइथन-2. x में आपको उपयोग करके सूची को सूचीबद्ध करने के लिए पुनरावृत्ति परिवर्तित कर सकते हैं क्योंकि आपको डिफ़ॉल्ट रूप से सूची वापस करने की आवश्यकता नहीं है )।5__mul__list()map

मानक:

In [18]: %timeit [5 * i for i in my_list]
463 ns ± 10.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [19]: %timeit list(map((5).__mul__, my_list))
784 ns ± 10.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [20]: %timeit [5 * i for i in my_list * 100000]
20.8 ms ± 115 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [21]: %timeit list(map((5).__mul__, my_list * 100000))
30.6 ms ± 169 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)


In [24]: arr = np.array(my_list * 100000)

In [25]: %timeit arr * 5
899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Comments

मुझे इस बात में दिलचस्पी है कि क्यों खस्ता विधि 'धधकती तेज' है? क्या आप संभवत: कुछ संसाधनों के बारे में मुझे विस्तृत या इंगित कर सकते हैं? मुझे यकीन नहीं है कि वैश्वीकरण क्या है।

— एरिनमुंड फागेल्सन

@AerinmundFagelson यहाँ -> stackoverflow.com/questions/35091979/…

— Kasravnd

@Kasramvd वह लिंक गलत है। लिंक एकल-निर्देश-एकाधिक-डेटा के रूप में वैश्वीकरण के एक अलग अर्थ पर चर्चा करता है (एक ही बार में कई डेटा के लिए एक ऑपरेशन लागू करना, जैसा कि जीपीयू करता है)। NumPy के संदर्भ में, वेक्टर शुद्ध पायथन के बजाय डेटा अनुक्रम पर काम करने के लिए तेज पूर्व संकलित C छोरों का उपयोग करने का संदर्भ देता है ।

— xjcl

यहाँ एक सटीक लिंक है

— xjcl

Answer 3

आप इसे इस तरह से कर सकते हैं:

 l = [1, 2, 3, 4, 5]
 l[:] = [x * 5 for x in l]

इसके लिए अतिरिक्त आयात की आवश्यकता नहीं है और यह बहुत ही पाइथोनिक है।

Comments

इसके अलावा: यदि आप इसके बारे में अधिक जानकारी प्राप्त करना चाहते हैं तो अवधारणा को सूची समझ कहा जाता है।

— माइकल

मैं बल्कि l = [x * 5 for x in l]खत्म हो गया था l[:] = [x * 5 for x in l]। उत्तरार्द्ध एक नई सूची बनाता है, फिर इसका उपयोग lसंदर्भ की सामग्री को अधिलेखित करने के लिए करता है, जो कि संदर्भ को फिर से परिभाषित करने के लिए सस्ता है। यदि आप वास्तव में अंतरिक्ष के बारे में चिंतित हैं, तो बस एक लूप के साथ पुनरावृत्त करें और इन-प्लेस को म्यूट करें।

— CS95

Answer 4

चूँकि मुझे लगता है कि आप पायथन के साथ नए हैं, तो लंबा रास्ता तय करते हैं, अपनी सूची को लूप के लिए उपयोग करते हैं और प्रत्येक तत्व को एक नई सूची में जोड़ते हैं।

लूप के लिए उपयोग कर रहा है

lst = [5, 20 ,15]
product = []
for i in lst:
    product.append(i*5)
print product

सूची की समझ का उपयोग करना, यह भी लूप के लिए उपयोग करने के समान है लेकिन अधिक 'पायथोनिक' है

lst = [5, 20 ,15]

prod = [i * 5 for i in lst]
print prod

Comments

किसी भी तरह से "लंबा रास्ता" बेहतर कैसे है? यह लंबा है - इस प्रकार पढ़ना अधिक कठिन है - और लिखना आसान नहीं है।

— 5

ठीक है, शायद आपको मेरे शीर्षक पर गलत प्रभाव पड़ा और मैंने कभी नहीं कहा कि यह किसी भी बेहतर है, बस उसे दिखाने की कोशिश कर रहा है कि बिना समझे का उपयोग कैसे करें। अपने अनुभव के कारण जब मैं अजगर में नया था तो मैं आसानी से समझ की अवधारणा को समझ नहीं पा रहा था।

— ellaRT 6

ओह ठीक है। मैं सीधे संबंधित नहीं हो सकता क्योंकि मैंने कार्यात्मक भाषाओं के साथ शुरुआत की थी।

— lirtosiast

मैं देखता हूं, वहां अच्छा है। मैंने इसका उत्तर संपादित किया जिसमें इसे करने का कुशल तरीका भी शामिल है।

— ellaRT

Answer 5

मानचित्र के साथ (अच्छा नहीं है, लेकिन समस्या के लिए एक और दृष्टिकोण):

list(map(lambda x: x*5,[5, 10, 15, 20, 25]))

इसके अलावा, यदि आप सुन्न या खस्ता सरणियों का उपयोग करते हैं, तो आप इसका उपयोग कर सकते हैं:

import numpy as np
list(np.array(x) * 5)

Comments

टाइमफाइव फ़ंक्शन को परिभाषित करने के बजाय एक लैम्ब्डा का उपयोग क्यों नहीं किया जाता है?

— विमन्यु

Answer 6

from functools import partial as p
from operator import mul
map(p(mul,5),my_list)

एक तरीका है कि आप इसे कर सकते हैं ... आपका शिक्षक शायद बहुत कम जटिल तरीका जानता है जो शायद कक्षा में शामिल था

Comments

लैंबडा एक्सप्रेशन का उपयोग करके आप इसे आयात विवरण के बिना कर सकते हैं। इसके अलावा, आपका स्निपेट एक मैप ऑब्जेक्ट देता है, जो तब तक बेकार है जब तक कि सूची में नहीं डाला जाता। सूची (नक्शा (लैम्ब्डा x: 5 * x, my_list))।

— महल-ब्रावो

@ महल-ब्रावो इसकी उपयोगिता इस बात पर निर्भर करती है कि आपको इसके साथ क्या करने की ज़रूरत है ... इस समाधान को पूरा करने के कई तरीके हैं (जैसा कि मैं उल्लेख करता हूं ...)

— जोरन बेस्ले

उपयोग करने के लिए सिखाने लोग न करें mapसाथ lambda; जिस पल की आपको आवश्यकता है lambda, आप सूची बोध या जनरेटर अभिव्यक्ति के साथ बेहतर होंगे। यदि आप चतुर हैं, तो आप बहुत कुछ किए बिना काम कर सकते हैं , जैसे कि इस मामले में , हालांकि इस विशेष मामले में, सरल गणित के लिए बाइट कोड दुभाषिया में कुछ अनुकूलन के लिए धन्यवाद , तेज है, साथ ही अधिक पायथोनिक और सरल भी है। । maplambdamap((5).__mul__, my_list)int[x * 5 for x in my_list]

— २.१R पर शैडो रेंजर

Answer 7

में प्रत्येक तत्व को गुणा करने my_listसे k:

k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))

जिसके परिणामस्वरूप: [5, 10, 15, 20]

Answer 8

मुझे सूची बोध या मानचित्र का उपयोग केवल एक वस्तु के नाम x के साथ करना दिलचस्प लगा। ध्यान दें कि जब भी x को पुन: असाइन किया जाता है , तो इसकी आईडी (x) बदल जाती है, अर्थात एक अलग वस्तु की ओर इशारा करती है।

x = [1, 2, 3]
id(x)
2707834975552
x = [1.5 * x for x in x]
id(x)
2707834976576
x
[1.5, 3.0, 4.5]
list(map(lambda x : 2 * x / 3, x))
[1.0, 2.0, 3.0]
id(x) # not reassigned
2707834976576
x = list(map(lambda x : 2 * x / 3, x))
x
[1.0, 2.0, 3.0]
id(x)
2707834980928

Answer 9

सूची समझ का उपयोग करने का सबसे अच्छा तरीका है:

def map_to_list(my_list, n):
# multiply every value in my_list by n
# Use list comprehension!
    my_new_list = [i * n for i in my_list]
    return my_new_list
# To test:
print(map_to_list([1,2,3], -1))

रिटर्न: [-1, -2, -3]

Comments

यह सिर्फ स्वीकृत उत्तर लेता है और इसे एक फ़ंक्शन में बदल देता है। आप शायद एसओ पर प्रतिक्रियाओं के आधे से अधिक के साथ ऐसा कर सकते हैं, लेकिन यह कुछ भी नहीं जोड़ता है और ओपी ने जो पूछा है वह नहीं है।

— अलेक्जेंडर