पायथन: मौजूदा सरणी का आकार बदलें और शून्य

Question

से भरें मुझे लगता है कि मेरी समस्या वास्तव में सरल होनी चाहिए, फिर भी मुझे इंटरनेट पर कोई सहायता नहीं मिल रही है। मैं पाइथन के लिए बहुत नया हूं, इसलिए यह संभव है कि मुझे कुछ बहुत याद आ रही है।

मेरे पास एक सरणी है, एस, इस [x x x] (one-dimensional) की तरह। अब मैं विकर्ण मैट्रिक्स, sigma, np.diag(S) के साथ - अब तक बहुत अच्छा बना रहा हूं। अब, मैं इस नए विकर्ण सरणी का आकार बदलना चाहता हूं ताकि मैं इसे किसी अन्य सरणी से गुणा कर सकूं जो मेरे पास है।

import numpy as np 
... 
shape = np.shape((6, 6)) #This will be some pre-determined size 
sigma = np.diag(S) #diagonalise the matrix - this works 
my_sigma = sigma.resize(shape) #Resize the matrix and fill with zeros - returns "None" - why? 

हालांकि, जब मैं my_sigma की सामग्री मुद्रित, मैं "None" मिलता है। क्या कोई मुझे सही दिशा में इंगित कर सकता है, क्योंकि मैं कल्पना नहीं कर सकता कि यह इतना जटिल होना चाहिए।

किसी भी मदद के लिए अग्रिम धन्यवाद!

कैस्पर

ग्राफिकल: क्योंकि यह यथा-स्थान संचालित

[x 0 0] 
[0 x 0] 
[0 0 x] 
[0 0 0] 
[0 0 0] 
[0 0 0] - or some similar size, but the diagonal elements are important. 

Answer 1

sigma.resize() रिटर्न None:

[x x x] 

मैं यह चाहता हूँ:

मैं इस किया है। np.resize(sigma, shape), दूसरी ओर, परिणाम देता है लेकिन शून्य के साथ पैडिंग के बजाय , यह सरणी के दोहराव के साथ पैड करता है।

इसके अलावा, shape() फ़ंक्शन इनपुट के आकार देता है। यदि आप सिर्फ एक आकार को पूर्वनिर्धारित करना चाहते हैं, तो बस एक टुपल का उपयोग करें।

import numpy as np 
... 
shape = (6, 6) #This will be some pre-determined size 
sigma = np.diag(S) #diagonalise the matrix - this works 
sigma.resize(shape) #Resize the matrix and fill with zeros 

बहरहाल, यह पहली बार अपने मूल सरणी बाहर समतल, और फिर दिया आकार में यह फिर से संगठित, मूल आदेश को नष्ट करने। यदि आप resize() का उपयोग करने के बजाय ज़ीरो के साथ "पैड" करना चाहते हैं तो आप सीधे जेनरेट किए गए शून्य-मैट्रिक्स में सीधे इंडेक्स कर सकते हैं।

# This assumes that you have a 2-dimensional array 
zeros = np.zeros(shape, dtype=np.int32) 
zeros[:sigma.shape[0], :sigma.shape[1]] = sigma 

Answer 2

मैं संपादित देखें ... आप पहली बार शून्य बनाने और उसके बाद इसे में कुछ संख्या को स्थानांतरित करने की क्या ज़रूरत है। आप

bigger_sigma = np.zeros(shape, dtype=sigma.dtype) 
diag_ij = np.diag_indices_from(sigma) 
bigger_sigma[diag_ij] = sigma[diag_ij] 

Answer 3

संस्करण 1.7.0 numpy.pad में एक नया numpy समारोह है कि एक-पंक्ति में कर सकते हैं नहीं है के लिए np.diag_indices_from उपयोगी हो सकता है। अन्य उत्तरों की तरह, आप पैडिंग से पहले np.diag के साथ विकर्ण मैट्रिक्स का निर्माण कर सकते हैं। इस उत्तर में उपयोग किए गए tuple ((0,N),(0,0)) पैड के लिए मैट्रिक्स के "पक्ष" को इंगित करता है।

[[1 0 0] 
[0 2 0] 
[0 0 3] 
[0 0 0] 
[0 0 0] 
[0 0 0]] 

Answer 4

एक और शुद्ध अजगर समाधान

a = [1, 2, 3] 
b = [] 
for i in range(6): 
    b.append((([0] * i) + a[i:i+1] + ([0] * (len(a) - 1 - i)))[:len(a)]) 

b अब

[[1, 0, 0], [0, 2, 0], [0, 0, 3], [0, 0, 0], [0, 0, 0], [0, 0, 0]] 

यह एक घृणित समाधान, मैं हूँ है:

import numpy as np 

A = np.array([1, 2, 3]) 

N = A.size 
B = np.pad(np.diag(A), ((0,N),(0,0)), mode='constant') 

B अब के बराबर है प्रवेश टी टोपी। हालांकि, यह list प्रकार के कुछ कार्यों को दिखाता है जिनका उपयोग किया जा सकता है।

Answer 5

यह समाधान resize समारोह के साथ काम करता

, यह सिर्फ एक दोहराई मूल्यों

np.resize(d,(6,3)) 
""" 
adds a repeating value 
array([[ 1., 0., 0.], 
     [ 0., 1., 0.], 
     [ 0., 0., 1.], 
     [ 1., 0., 0.], 
     [ 0., 1., 0.], 
     [ 0., 0., 1.]]) 
""" 

यह काम

करता जोड़ने एक नमूना सरणी

S= np.ones((3)) 
print (S) 
# [ 1. 1. 1.] 
d= np.diag(S) 
print(d) 
""" 
[[ 1. 0. 0.] 
[ 0. 1. 0.] 
[ 0. 0. 1.]] 

""" 

यह dosent काम ले लो

d.resize((6,3),refcheck=False) 
print(d) 
""" 
[[ 1. 0. 0.] 
[ 0. 1. 0.] 
[ 0. 0. 1.] 
[ 0. 0. 0.] 
[ 0. 0. 0.] 
[ 0. 0. 0.]] 
"""