শূন্য দ্বারা বিভাজন দিয়ে 0 কীভাবে ফিরে আসবেন

Question 1

আমি অজগরটিতে একটি উপাদান অনুসারে বিভাজন সম্পাদনের চেষ্টা করছি, তবে যদি শূন্যের মুখোমুখি হয় তবে আমার শূন্যের জন্য ভাগফল প্রয়োজন need

উদাহরণ স্বরূপ:

array1 = np.array([0, 1, 2])
array2 = np.array([0, 1, 1])

array1 / array2 # should be np.array([0, 1, 2])

আমি সবসময় আমার ডেটা দিয়ে কেবলমাত্র একটি লুপ ব্যবহার করতে পারতাম, তবে সত্যই নিম্পের অপ্টিমাইজেশানকে কাজে লাগাতে ত্রুটিটিকে উপেক্ষা করার পরিবর্তে শূন্য ত্রুটি দ্বারা বিভাজনে 0 ফিরিয়ে আনতে আমার বিভাজন ফাংশনটি প্রয়োজন।

যদি না আমি কিছু অনুপস্থিত করছি, এটা মনে হয় না numpy.seterr () ত্রুটি উপর মান ফিরে আসতে পারেন। শূন্য ত্রুটি পরিচালনার দ্বারা নিজের বিভাজনটি নির্ধারণ করার সময় আমি কীভাবে নম্পতির মধ্যে থেকে সেরাটি পেতে পারি তার সম্পর্কে অন্য কোনও পরামর্শ আছে?

Question 2

Numpy v1.7 + +, আপনি এর জন্য "যেখানে" বিকল্পটি সুবিধা গ্রহণ করতে পারেন ufuncs । আপনি এক লাইনে জিনিসগুলি করতে পারেন এবং আপনাকে এরস্টেট কনটেক্সট ম্যানেজারের সাথে ডিল করতে হবে না।

>>> a = np.array([-1, 0, 1, 2, 3], dtype=float)
>>> b = np.array([ 0, 0, 0, 2, 2], dtype=float)

# If you don't pass `out` the indices where (b == 0) will be uninitialized!
>>> c = np.divide(a, b, out=np.zeros_like(a), where=b!=0)
>>> print(c)
[ 0.   0.   0.   1.   1.5]

এই ক্ষেত্রে এটি বিভাজনের গণনা যে কোনও জায়গায় 'বি' শূন্যের সমান হয় না does যখন খ সমান শূন্য করে, তারপরে আপনি আউট আর্গুমেন্টে মূলত যা মান দিয়েছেন তা থেকে এটি অপরিবর্তিত থাকবে।

Question 3

@ ফ্র্যাঙ্ক ডারননকোর্টের উত্তরে বিল্ডিং, ফিক্সিং -1 / 0:

def div0( a, b ):
    """ ignore / 0, div0( [-1, 0, 1], 0 ) -> [0, 0, 0] """
    with np.errstate(divide='ignore', invalid='ignore'):
        c = np.true_divide( a, b )
        c[ ~ np.isfinite( c )] = 0  # -inf inf NaN
    return c

div0( [-1, 0, 1], 0 )
array([0, 0, 0])

Question 4

অন্যান্য উত্তরের উপর বিল্ডিং, এবং উন্নতি:

0/0যোগ invalid='ignore'করে হ্যান্ডলিংnumpy.errstate()
উপস্থাপক numpy.nan_to_num()রূপান্তর করতে np.nanকরতে 0।

কোড:

import numpy as np

a = np.array([0,0,1,1,2], dtype='float')
b = np.array([0,1,0,1,3], dtype='float')

with np.errstate(divide='ignore', invalid='ignore'):
    c = np.true_divide(a,b)
    c[c == np.inf] = 0
    c = np.nan_to_num(c)

print('c: {0}'.format(c))

আউটপুট:

c: [ 0.          0.          0.          1.          0.66666667]

Question 5

ওয়ান-লাইনার (সতর্কতা ছুড়ে দেয়)

np.nan_to_num(array1 / array2)

Question 6

এটি দুটি ধাপে করার চেষ্টা করুন। বিভাগ আগে, তারপর প্রতিস্থাপন।

with numpy.errstate(divide='ignore'):
    result = numerator / denominator
    result[denominator == 0] = 0

numpy.errstateলাইন ঐচ্ছিক, এবং শুধুমাত্র বাধা দেয়, শূন্য দ্বারা ভাগ এর "ত্রুটি" সম্পর্কে আপনি কহন থেকে numpy যেহেতু আপনি ইতিমধ্যে তা করার ইচ্ছুক করছি, এবং যে ক্ষেত্রে হ্যান্ডলিং।

Question 7

আপনি এই উত্তরinf অনুসারে কেবল অ্যারে টাইপগুলি ভাসমান থাকলেও এর উপর ভিত্তি করে প্রতিস্থাপন করতে পারেন :

>>> a = np.array([1,2,3], dtype='float')
>>> b = np.array([0,1,3], dtype='float')
>>> c = a / b
>>> c
array([ inf,   2.,   1.])
>>> c[c == np.inf] = 0
>>> c
array([ 0.,  2.,  1.])

Question 8

একটি উত্তর যা সম্পর্কিত সম্পর্কিত অনুসন্ধান করেছিলাম তা হ'ল শূন্য ছিল কি না তার ভিত্তিতে আউটপুট ম্যানিপুলেট করা।

মনে করুন arrayAএবং arrayBসূচনা করা হয়েছে, তবে arrayBকিছু শূন্য রয়েছে। আমরা arrayC = arrayA / arrayBনিরাপদে গণনা করতে চাইলে আমরা নিম্নলিখিতগুলি করতে পারি ।

এই ক্ষেত্রে, যখনই আমার কোনও একটি ঘরে শূন্যের বিভাজন রয়েছে, আমি ঘরটিকে সমান হিসাবে সেট করেছিলাম myOwnValue, যা এই ক্ষেত্রে শূন্য হবে

myOwnValue = 0
arrayC = np.zeros(arrayA.shape())
indNonZeros = np.where(arrayB != 0)
indZeros = np.where(arrayB = 0)

# division in two steps: first with nonzero cells, and then zero cells
arrayC[indNonZeros] = arrayA[indNonZeros] / arrayB[indNonZeros]
arrayC[indZeros] = myOwnValue # Look at footnote

পাদটীকা: পূর্বানুমতিতে, এই লাইনটি যাইহোক, অপ্রয়োজনীয়, যেহেতু arrayC[i]তাত্ক্ষণিকভাবে শূন্য করা হয়েছে। তবে যদি myOwnValue != 0এমনটি হয় তবে এই অপারেশনটি কিছু করবে।

Question 9

উল্লেখযোগ্য একটি অন্য সমাধান:

>>> a = np.array([1,2,3], dtype='float')
>>> b = np.array([0,1,3], dtype='float')
>>> b_inv = np.array([1/i if i!=0 else 0 for i in b])
>>> a*b_inv
array([0., 2., 1.])