NumPy सरणी आरंभीकरण (समान मूल्यों के साथ भरें)

Question

मुझे लंबाई का एक नुमाइंदा सरणी बनाने की आवश्यकता है n, जिसमें से प्रत्येक तत्व है v।

क्या इससे बेहतर कुछ है:

a = empty(n)
for i in range(n):
    a[i] = v

मैं जानता हूँ कि zerosऔर onesv = 0, 1. मैं इस्तेमाल कर सकते हैं के लिए काम करेगा v * ones(n), लेकिन यह काम नहीं होगा जब vहै None, और भी बहुत धीमी होगी।

Comments

मेरे कंप्यूटर पर, 0 केस के लिए, a = np.zeros(n)लूप में उपयोग करना इससे तेज है a.fill(0)। यह वह चीज है जो मैंने अपेक्षित की थी क्योंकि मुझे लगा कि a=np.zeros(n)नई मेमोरी को आवंटित करने और आरंभ करने की आवश्यकता होगी। अगर कोई इसे समझा सकता है, तो मैं इसकी सराहना करूंगा।

— user3731622

आप किसी को भी एक ख़ास सरणी नहीं डाल सकते, क्योंकि कोशिकाएँ एक विशिष्ट डेटा प्रकार के साथ बनाई जाती हैं, जबकि किसी के पास स्वयं का प्रकार नहीं है और वास्तव में एक सूचक है।

— कैमियन

@Camion हाँ, मुझे पता है :) अब v * ones(n)भी भयानक है, क्योंकि यह महंगी गुणा का उपयोग करता है। हालांकि के *साथ बदलें +, और v + zeros(n)कुछ मामलों में आश्चर्यजनक रूप से अच्छा लगता है ( stackoverflow.com/questions/5891410/… )।

— अधिकतम

अधिकतम, v को जोड़ने से पहले शून्य के साथ एक सरणी बनाने के बजाय, इसे खाली करना var = np.empty(n)और फिर इसे 'var [:] = v' से भरना और भी तेज़ है । (btw, np.full()इस के रूप में उपवास के रूप में) है

— कैमियन

Answer 1

NumPy 1.8 पेश किया गया np.full(), जो एक निश्चित मूल्य से भरा एक सरणी बनाने के लिए empty()पीछा करने की तुलना में अधिक प्रत्यक्ष विधि है fill():

>>> np.full((3, 5), 7)
array([[ 7.,  7.,  7.,  7.,  7.],
       [ 7.,  7.,  7.,  7.,  7.],
       [ 7.,  7.,  7.,  7.,  7.]])

>>> np.full((3, 5), 7, dtype=int)
array([[7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7]])

यह निश्चित रूप से एक निश्चित मूल्यों से भरा एक सरणी बनाने का तरीका है, क्योंकि यह स्पष्ट रूप से वर्णन करता है कि क्या हासिल किया जा रहा है (और यह सिद्धांत में बहुत कुशल हो सकता है क्योंकि यह बहुत विशिष्ट कार्य करता है)।

Comments

यह पूर्ण () विधि मेरे लिए अच्छी तरह से काम कर रही है, लेकिन मैं इसके लिए कुछ प्रलेखन नहीं पा सकता हूं। क्या कोई मुझे सही जगह पर ले जा सकता है?

— जेम्स एडम्स

आप कम से कम help(numpy.full)एक पायथन शेल में कर सकते हैं । मुझे यह भी आश्चर्य है कि यह वेब प्रलेखन में नहीं है।

— एरिक ओ लेबिगॉट

मेरे सिस्टम पर (पायथन 2.7, Numpy 1.8), np.full () वास्तव में np.empty () और उसके बाद np.fill () की तुलना में थोड़ा धीमा है।

— जॉन ज़्विनक

१०,००० तत्वों के लिए, मैं लगभग १०% के अंतर के साथ एक ही चीज़ (सिवाय इसके np.fill()मौजूद नहीं है और होनी चाहिए arr.fill()) का निरीक्षण करता हूं । यदि अंतर बड़ा होता, तो मैं NumPy बग ट्रैकर में एक मुद्दा उठाता। :) मैं निष्पादन समय में इतने छोटे अंतर के लिए अधिक स्पष्ट और स्पष्ट कोड पसंद करता हूं, इसलिए मैं np.full()हर समय साथ रहता हूं ।

— एरिक ओ लेबिगॉट

मेरी मशीन np.full पर () np.array.fill रूप में एक ही गति () है

— Fnord

Answer 2

Numpy 1.7.0 के लिए अपडेट किया गया: (हैट-टिप @ रॉल्फ बारस्ट्रा के लिए।)

a=np.empty(n); a.fill(5) सबसे तेज है।

अवरोही गति क्रम में:

%timeit a=np.empty(1e4); a.fill(5)
100000 loops, best of 3: 5.85 us per loop

%timeit a=np.empty(1e4); a[:]=5 
100000 loops, best of 3: 7.15 us per loop

%timeit a=np.ones(1e4)*5
10000 loops, best of 3: 22.9 us per loop

%timeit a=np.repeat(5,(1e4))
10000 loops, best of 3: 81.7 us per loop

%timeit a=np.tile(5,[1e4])
10000 loops, best of 3: 82.9 us per loop

Comments

अधिक हाल और प्रत्यक्ष के लिए एक समय जोड़ना np.full()उपयोगी होगा। मेरी मशीन पर, NumPy 1.8.1 के साथ, यह कम प्रत्यक्ष fill()संस्करण की तुलना में लगभग 15% धीमा है (जो कि अप्रत्याशित है, जैसा full()कि थोड़ा तेज होने की क्षमता है)।

— एरिक ओ लेबिगॉट

@ डेविडस्वांडर्स: मुझे यकीन नहीं है कि मैं आपका अनुसरण कर रहा हूं: fill()सबसे तेज समाधान है। गुणन समाधान बहुत धीमा है।

— एरिक ओ लेबिगॉट

नोट: यदि गति वास्तव में एक चिंता का विषय है, के आकार का उपयोग 10000करने के बजाय 1e4बनाता है एक उल्लेखनीय अंतर किसी कारण से, ( full(), लगभग 50% धीमी है के साथ 1e4)।

— एरिक ओ लेबिगॉट

मेरे परिणामों को जोड़ने के साथ full(), यह काफी धीमी गति से चलता है जब डेटाटाइप स्पष्ट रूप से फ्लोट नहीं होता है। अन्यथा, यह सबसे अच्छी विधियों के साथ तुलनीय (लेकिन थोड़ा धीमा) है।

— user2699

@ user2699 मैं इस को देख रहा हूँ नहीं, 100,000 तत्वों के साथ: full(100000, 5), full(100000, 5, dtype=float), full(100000, 5, dtype=int)और a =np.empty(100000); a.fill(5)मेरी मशीन पर एक ही समय के बारे में सभी ले (कोई कैशिंग के साथ: %timeit -r1 -n1 …) (NumPy 1.11.2)।

— एरिक ओ लेबिगॉट

Answer 3

मेरा मानना fillहै कि ऐसा करने का सबसे तेज़ तरीका है।

a = np.empty(10)
a.fill(7)

आपको हमेशा ऐसे पुनरावृत्तियों से बचना चाहिए जैसे आप अपने उदाहरण में कर रहे हैं। एक साधारण a[:] = vयह पूरा करेगा कि आपका प्रसारण सुन्न प्रसारण का उपयोग क्या करता है ।

Comments

धन्यवाद। देखने में fill, मैंने देखा कि repeatमेरी ज़रूरतें और भी बेहतर हैं।

— अधिकतम

क्या आप यह कहने के लिए अपने जवाब को अपडेट करने का मन बनाते हैं कि आपकी सिफारिश a[:]=vवास्तव में की तुलना में अधिक तेज है fill?

— अधिकतम

@ मोम यह तेज है? प्रसारण एक सरणी को भरने के लिए एक अधिक सामान्य तरीका है और मुझे लगता है कि धीमी या बहुत संकीर्ण उपयोग के मामले के बराबर है fill।

— पॉल

Answer 4

जाहिर है, न केवल निरपेक्ष गति, बल्कि गति क्रम (जैसा कि user1579844 द्वारा रिपोर्ट किया गया है) मशीन पर निर्भर हैं; यहाँ मुझे क्या मिला:

a=np.empty(1e4); a.fill(5) सबसे तेज़ है;

अवरोही गति क्रम में:

timeit a=np.empty(1e4); a.fill(5) 
# 100000 loops, best of 3: 10.2 us per loop
timeit a=np.empty(1e4); a[:]=5
# 100000 loops, best of 3: 16.9 us per loop
timeit a=np.ones(1e4)*5
# 100000 loops, best of 3: 32.2 us per loop
timeit a=np.tile(5,[1e4])
# 10000 loops, best of 3: 90.9 us per loop
timeit a=np.repeat(5,(1e4))
# 10000 loops, best of 3: 98.3 us per loop
timeit a=np.array([5]*int(1e4))
# 1000 loops, best of 3: 1.69 ms per loop (slowest BY FAR!)

तो, कोशिश करें और पता करें, और अपने प्लेटफ़ॉर्म पर सबसे तेज़ उपयोग करें।

Answer 5

मैं था

numpy.array(n * [value])

ध्यान में रखते हुए, लेकिन जाहिर है कि बड़े पर्याप्त के लिए अन्य सभी सुझावों की तुलना में धीमी है n।

यहां परफ्लोटॉट (मेरा एक पालतू प्रोजेक्ट) के साथ पूरी तुलना की गई है ।

दो emptyविकल्प अभी भी सबसे तेज़ हैं (NumPy 1.12.1 के साथ)। fullबड़े सरणियों के लिए पकड़ लेता है।

---

प्लॉट जनरेट करने के लिए कोड:

import numpy as np
import perfplot


def empty_fill(n):
    a = np.empty(n)
    a.fill(3.14)
    return a


def empty_colon(n):
    a = np.empty(n)
    a[:] = 3.14
    return a


def ones_times(n):
    return 3.14 * np.ones(n)


def repeat(n):
    return np.repeat(3.14, (n))


def tile(n):
    return np.repeat(3.14, [n])


def full(n):
    return np.full((n), 3.14)


def list_to_array(n):
    return np.array(n * [3.14])


perfplot.show(
    setup=lambda n: n,
    kernels=[empty_fill, empty_colon, ones_times, repeat, tile, full, list_to_array],
    n_range=[2 ** k for k in range(27)],
    xlabel="len(a)",
    logx=True,
    logy=True,
)

Answer 6

आप उपयोग कर सकते हैं numpy.tile, जैसे:

v = 7
rows = 3
cols = 5
a = numpy.tile(v, (rows,cols))
a
Out[1]: 
array([[7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7],
       [7, 7, 7, 7, 7]])

हालांकि tileइसका मतलब एक टाइल (एक स्केलर के बजाय, इस मामले में) को 'टाइल' करना है, यह किसी भी आकार और आयाम के पूर्व-भरे सरणियों का निर्माण करते हुए काम करेगा।

Answer 7

बिना नुक्सान के

>>>[2]*3
[2, 2, 2]

Comments

सुझाव [v] * nओपी प्रश्न के लिए अधिक सीधे प्रासंगिक होगा।

— जलाया

इस उत्तर ने पहले से ही इस दृष्टिकोण का उल्लेख किया है।

— कॉमनसिडेंस