पायथन - एब्स बनाम फैब्स

Question

मैंने देखा कि अजगर में किसी संख्या का निरपेक्ष मान ज्ञात करने की दो समान विधियाँ हैं:

प्रथम

abs(-5)

दूसरा

import math
math.fabs(-5)

ये तरीके कैसे भिन्न हैं?

Answer 1

math.fabs()अपने तर्क को फ्लोट में परिवर्तित करता है यदि यह हो सकता है (यदि ऐसा नहीं हो सकता है, तो यह एक अपवाद फेंकता है)। यह तब पूर्ण मान लेता है, और परिणाम को एक फ्लोट के रूप में लौटाता है।

तैरने के अलावा, abs()पूर्णांक और जटिल संख्याओं के साथ भी काम करता है। इसका रिटर्न प्रकार इसके तर्क के प्रकार पर निर्भर करता है।

In [7]: type(abs(-2))
Out[7]: int

In [8]: type(abs(-2.0))
Out[8]: float

In [9]: type(abs(3+4j))
Out[9]: float

In [10]: type(math.fabs(-2))
Out[10]: float

In [11]: type(math.fabs(-2.0))
Out[11]: float

In [12]: type(math.fabs(3+4j))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/home/npe/<ipython-input-12-8368761369da> in <module>()
----> 1 type(math.fabs(3+4j))

TypeError: can't convert complex to float

Comments

absकेवल पूर्णांकों और फ़्लोट्स से कहीं अधिक के साथ काम करता है, और परिणाम प्रकार हमेशा तर्क के समान नहीं होता है, जैसे abs(3+4j)।

— एएफएफ

fabsहमेशा की-फ्लोट प्रकृति के कारण अधिक समय लेने के बारे में एक टिप्पणी जोड़ें और आपको सही उत्तर मिल गया है!

— पैट्रिक पेरिनी

@agf: मुझे जटिल संख्याओं के बारे में याद दिलाने के लिए धन्यवाद। रुचि से बाहर, किन अन्य वर्गों को __builtin__.abs()सफलतापूर्वक लागू किया जा सकता है?

— एनपीई

@aix कोई भी उपयोगकर्ता परिभाषित वर्ग को परिभाषित __abs__जादू विधि

— एजीएफ़

Answer 2

संपादित करें: जैसा कि @aix ने सुझाव दिया है, गति अंतर की तुलना करने के लिए एक बेहतर (अधिक निष्पक्ष) तरीका:

In [1]: %timeit abs(5)
10000000 loops, best of 3: 86.5 ns per loop

In [2]: from math import fabs

In [3]: %timeit fabs(5)
10000000 loops, best of 3: 115 ns per loop

In [4]: %timeit abs(-5)
10000000 loops, best of 3: 88.3 ns per loop

In [5]: %timeit fabs(-5)
10000000 loops, best of 3: 114 ns per loop

In [6]: %timeit abs(5.0)
10000000 loops, best of 3: 92.5 ns per loop

In [7]: %timeit fabs(5.0)
10000000 loops, best of 3: 93.2 ns per loop

In [8]: %timeit abs(-5.0)
10000000 loops, best of 3: 91.8 ns per loop

In [9]: %timeit fabs(-5.0)
10000000 loops, best of 3: 91 ns per loop

तो ऐसा लगता है कि पूर्णांक के लिए abs()केवल थोड़ा गति लाभ है fabs()। तैरने के लिए, abs()और fabs()समान गति प्रदर्शित करता है।

---

@Aix ने जो कहा है उसके अलावा, एक और बात पर विचार करना गति का अंतर है:

In [1]: %timeit abs(-5)
10000000 loops, best of 3: 102 ns per loop

In [2]: import math

In [3]: %timeit math.fabs(-5)
10000000 loops, best of 3: 194 ns per loop

तो abs()से तेज है math.fabs()।

Comments

आप सेब की तुलना वहाँ सेब से नहीं कर रहे हैं। from math import fabsसुनिश्चित करने के लिए उपयोग करें, और -5.0दोनों के लिए प्रयास करें ।

— एगफ

इसके अलावा अविश्वसनीय समय परिणाम? आपने पहली बार (५२) एब्स पर ५० एएनएस, फिर बाद में इसे ..३ बीएन के रूप में दिखाया। किसी भी बेंचमार्क के एक भी रन से निष्कर्ष कभी न निकालें, भले ही यह आंतरिक रूप से मुद्दों से बचने की कोशिश करता हो जैसा कि समयबद्ध करता है।

— पीटर हेन्सन

दो और बिंदु: यह अभी भी सेब और संतरे की तुलना करता है, क्योंकि एब्स को बिल्डिंस में देखा जाता है, जबकि फैब्स मॉड्यूल के नाम पर है। उस प्रभाव को दूर करने के लिए "xabs = abs" तब xabs (संख्या) करें। इसके अलावा, पायथन 3.2 के साथ चीजें काफी बदल जाती हैं और जाहिरा तौर पर एब्स () काफी तेज होता है (> 2x), कम से कम फ्लोट्स पर।

— पीटर हैन्सन

@PeterHansen आप सही हैं, वे अलग-अलग सिस्टम लोड के तहत दो रन से हैं। हालांकि जब परीक्षणों के एक ही सेट के भीतर तुलना की जाती है, तो सापेक्ष अंतर अभी भी मान्य है। इसके अलावा, नाम स्थान अंतर को इंगित करने के लिए धन्यवाद - मैंने ऐसा नहीं माना। मैंने इसे 3.2 पर आज़माया नहीं है, लेकिन यह जानना अच्छा है! मैं थोड़ी देर बाद आपके सुझावों के साथ अपना जवाब अपडेट कर दूंगा :) फिर से धन्यवाद!

— KZ

Answer 3

math.fabs()हमेशा फ्लोट देता है, जबकि abs()पूर्णांक वापस कर सकता है।

Comments

absकिसी भी प्रकार की वापसी हो सकती है, __abs__यह उस प्रकार की विशेष विधि पर निर्भर करता है, जिस पर इसे कहा जाता है।

— एएफएफ

Answer 4

abs(): पूर्ण मान को तर्क के अनुसार लौटाता है अर्थात यदि तर्क int है तो वह int को लौटाता है, यदि तर्क फ्लोट है तो यह रिटर्न फ्लोट है। इसके अलावा यह कॉम्प्लेक्स वैरिएबल पर abs(a+bj)भी काम करता है यानी पूर्ण मूल्य पर भी काम करता है और देता हैmath.sqrt(((a)**2)+((b)**2)

math.fabs(): यह केवल पूर्णांक या फ्लोट मान पर काम करता है। हमेशा पूर्ण फ़्लोट मान लौटाता है, चाहे कोई भी तर्क प्रकार हो (जटिल संख्याओं को छोड़कर)।