NumPy 1.14 - numpy.pad()

numpy.pad




numpy

numpy.pad

numpy.pad(array, pad_width, mode, **kwargs) [source]

एक सरणी पैड।

पैरामीटर:

सरणी : array_like रैंक एन

इनपुट सरणी

pad_width : {अनुक्रम, array_like, int}

प्रत्येक अक्ष के किनारों पर गद्देदार मूल्यों की संख्या। (प्रत्येक अक्ष के लिए अद्वितीय पैड चौड़ाई) ((पहले, बाद में, 1),… (पहले, बाद में ,_N_N)। (प्रत्येक अक्ष के लिए पैड से पहले और बाद में पैदावार) (पैड,) या int सभी अक्षों के लिए = बाद = पैड की चौड़ाई के लिए एक शॉर्टकट है।

मोड : str या फंक्शन

निम्न स्ट्रिंग मानों में से एक या एक उपयोगकर्ता आपूर्ति फ़ंक्शन।

'स्थिर'

एक निरंतर मूल्य के साथ पैड।

'किनारे'

सरणी के किनारे मूल्यों के साथ पैड।

'Linear_ramp'

एंड_वल्यू और ऐरे एज वैल्यू के बीच रैखिक रैंप के साथ पैड।

'ज्यादा से ज्यादा'

प्रत्येक अक्ष के साथ वेक्टर के सभी या अधिकतम भाग के पैड।

'मतलब'

प्रत्येक अक्ष के साथ वेक्टर के सभी या भाग के औसत मूल्य वाले पैड।

'माध्यिका'

प्रत्येक अक्ष के साथ वेक्टर के सभी या मध्य भाग के मान वाले पैड।

'न्यूनतम'

प्रत्येक अक्ष के साथ वेक्टर के सभी या न्यूनतम मूल्य वाले पैड।

'प्रतिबिंबित'

वेक्टर के प्रतिबिंब के साथ पैड प्रत्येक अक्ष के साथ वेक्टर के पहले और अंतिम मूल्यों पर प्रतिबिंबित करते हैं।

'सममित'

वेक्टर के प्रतिबिंब के साथ पैड सरणी के किनारे पर प्रतिबिंबित होते हैं।

'रैप'

अक्ष के साथ वेक्टर के आवरण के साथ पैड। पहले मानों का उपयोग अंत को पैड करने के लिए किया जाता है और शुरुआत को पैड करने के लिए अंतिम मानों का उपयोग किया जाता है।

<समारोह>

पैडिंग फ़ंक्शन, नोट्स देखें।

stat_length : अनुक्रम या इंट, वैकल्पिक

'अधिकतम', 'माध्य', 'माध्यिका' और 'न्यूनतम' में प्रयुक्त। प्रत्येक अक्ष के किनारे पर मूल्यों की संख्या, सांख्यिकीय मूल्य की गणना करने के लिए उपयोग की जाती है।

(प्रत्येक अक्ष के लिए (पहले, बाद में, 1),… (पहले वाले, बाद वाले)।

प्रत्येक अक्ष के लिए सांख्यिकीय लंबाई से पहले और बाद में (पहले, बाद में) पैदावार समान होती है।

(stat_length), या int सभी अक्षों के लिए = = पहले = बाद की लंबाई के लिए एक शॉर्टकट है।

संपूर्ण अक्ष का उपयोग करने के लिए डिफ़ॉल्ट None है।

Contin_values : अनुक्रम या int, वैकल्पिक

'स्थिरांक ’में प्रयुक्त। प्रत्येक अक्ष के लिए गद्देदार मान सेट करने के लिए मान।

(प्रत्येक अक्ष के लिए (पहले, बाद में, 1),… (पहले वाले, बाद वाले)।

(प्रत्येक अक्ष के लिए स्थिरांक से पहले और बाद में, समान पैदावार)।

(स्थिर,) या इंट = सभी अक्षों के लिए = पहले = के बाद के लिए एक शॉर्टकट है।

डिफ़ॉल्ट 0 है।

end_values : अनुक्रम या int, वैकल्पिक

'Linear_ramp' में प्रयुक्त। रेखीय_प्रैम्प के अंतिम मान के लिए उपयोग किए जाने वाले मान और इससे गद्देदार सरणी का किनारा बनेगा।

(प्रत्येक अक्ष के लिए अद्वितीय अंत मान) ((पहले, बाद में, 1),… (पहले वाले, बाद वाले)।

(प्रत्येक अक्ष के लिए अंत मानों के पहले और बाद में), (पहले, बाद में) पैदावार मिलती है।

(स्थिर,) या int सभी अक्षों के लिए = पहले = अंत मूल्य के लिए एक शॉर्टकट है।

डिफ़ॉल्ट 0 है।

प्रतिबिंबित_टाइप : {'भी', 'विषम'}, वैकल्पिक

'प्रतिबिंबित', और 'सममित' में प्रयुक्त। 'सम' स्टाइल एज वैल्यू के चारों ओर अनलॅंड रिफ्लेक्ट वाला डिफॉल्ट है। 'विषम' शैली के लिए, ऐरे का बढ़ा हुआ भाग किनारे के मूल्य से परावर्तित मानों को घटाकर बनाया जाता है।

यह दिखाता है:

पैड : ndarray

pad_width अनुसार आकार के साथ array बराबर रैंक की गद्देदार सरणी।

टिप्पणियाँ

संस्करण 1.7.0 में नया।

1 से अधिक रैंक वाले सरणी के लिए, बाद के कुल्हाड़ियों के कुछ पैडिंग की गणना पिछली कुल्हाड़ियों की गद्दी से की जाती है। रैंक 2 एरे के बारे में सोचना सबसे आसान है जहां पहले अक्ष से गद्देदार मूल्यों का उपयोग करके गद्देदार सरणी के कोनों की गणना की जाती है।

यदि उपयोग किया जाता है, तो पेडिंग फ़ंक्शन को रैंक किए गए 1 सरणी को वेक्टर तर्क में लंबाई के बराबर होना चाहिए, जिसमें गद्देदार मान प्रतिस्थापित किए गए हैं। इसके निम्नलिखित हस्ताक्षर हैं:

padding_func(vector, iaxis_pad_width, iaxis, kwargs)

कहा पे

vector : ndarray
एक रैंक 1 सरणी पहले से ही शून्य के साथ गद्देदार है। गद्देदार मूल्य वेक्टर हैं: [pad_tuple [0]] और वेक्टर [-pad_tuple [1]:]।
iaxis_pad_width : tuple
एक 2-टुपल इन्ट्स, iaxis_pad_width [0] वेक्टर की शुरुआत में गद्देदार मूल्यों की संख्या को दर्शाता है जहां iaxis_pad_width [1] वेक्टर के अंत में गद्देदार मूल्यों की संख्या को दर्शाता है।
iaxis : int
वर्तमान में गणना की जा रही धुरी।
kwargs : dict
किसी भी कीवर्ड को फ़ंक्शन की आवश्यकता होती है।

उदाहरण

>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2,3), 'constant', constant_values=(4, 6))
array([4, 4, 1, 2, 3, 4, 5, 6, 6, 6])
>>> np.pad(a, (2, 3), 'edge')
array([1, 1, 1, 2, 3, 4, 5, 5, 5, 5])
>>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])
>>> np.pad(a, (2,), 'maximum')
array([5, 5, 1, 2, 3, 4, 5, 5, 5])
>>> np.pad(a, (2,), 'mean')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> np.pad(a, (2,), 'median')
array([3, 3, 1, 2, 3, 4, 5, 3, 3])
>>> a = [[1, 2], [3, 4]]
>>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
array([[1, 1, 1, 2, 1, 1, 1],
       [1, 1, 1, 2, 1, 1, 1],
       [1, 1, 1, 2, 1, 1, 1],
       [1, 1, 1, 2, 1, 1, 1],
       [3, 3, 3, 4, 3, 3, 3],
       [1, 1, 1, 2, 1, 1, 1],
       [1, 1, 1, 2, 1, 1, 1]])
>>> a = [1, 2, 3, 4, 5]
>>> np.pad(a, (2, 3), 'reflect')
array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
>>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])
>>> np.pad(a, (2, 3), 'symmetric')
array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
>>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
>>> np.pad(a, (2, 3), 'wrap')
array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
>>> def pad_with(vector, pad_width, iaxis, kwargs):
...     pad_value = kwargs.get('padder', 10)
...     vector[:pad_width[0]] = pad_value
...     vector[-pad_width[1]:] = pad_value
...     return vector
>>> a = np.arange(6)
>>> a = a.reshape((2, 3))
>>> np.pad(a, 2, pad_with)
array([[10, 10, 10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10, 10, 10],
       [10, 10,  0,  1,  2, 10, 10],
       [10, 10,  3,  4,  5, 10, 10],
       [10, 10, 10, 10, 10, 10, 10],
       [10, 10, 10, 10, 10, 10, 10]])
>>> np.pad(a, 2, pad_with, padder=100)
array([[100, 100, 100, 100, 100, 100, 100],
       [100, 100, 100, 100, 100, 100, 100],
       [100, 100,   0,   1,   2, 100, 100],
       [100, 100,   3,   4,   5, 100, 100],
       [100, 100, 100, 100, 100, 100, 100],
       [100, 100, 100, 100, 100, 100, 100]])