दशमलव बिंदु के बाद नंबर कैसे प्राप्त करें?


123

दशमलव बिंदु के बाद मुझे नंबर कैसे मिलते हैं?

उदाहरण के लिए, अगर मेरे पास है 5.55, तो मुझे कैसे मिलेगा .55?


जवाबों:


29

आपके लिए एक आसान तरीका:

number_dec = str(number-int(number))[1:]

30
पाठक के लिए व्यायाम: यह 10 से बड़ा या बराबर संख्या के लिए काम करते हैं
intuited

11
number_dec = str(number-int(number)).split('.')[1]
रयान एलन

28
डाउनवोट क्योंकि यह एक अनावश्यक रूप से जटिल दृष्टिकोण है। मैंने जो उत्तर मांगा था, वह अगला उत्तर था 5.55 % 1, जो कि अधिक सामान्य रूप से उपयोगी उत्तर भी है - एक तो कई भाषाओं में मोड्यूलो डिवीजन दृष्टिकोण का उपयोग किया जा सकता है, जबकि उपरोक्त उत्तर पायथन-विशिष्ट है।
स्टू

3
नोट: यह समाधान डॉट ( .55) सहित एक स्ट्रिंग देता है , जिसे आप प्रश्नों के शीर्षक के कारण उम्मीद नहीं कर सकते हैं!
टी।

8
str(5.55 - int(5.55))[1:]प्रश्न में उल्लिखित के .5499999999999998बजाय रिटर्न .55
क्रिस्टियन सियुपिटु

198
5.55 % 1

ध्यान रखें कि यह आपको फ्लोटिंग पॉइंट राउंडिंग समस्याओं में मदद नहीं करेगा। यानी, आप प्राप्त कर सकते हैं:

0.550000000001

या अन्यथा 0.55 से थोड़ी दूर आप उम्मीद कर रहे हैं।


7
के रूप में modf, यह भी सटीक पेंच कर सकते हैं: math.modf(5.55)वापस आ जाएगी (0.5499999999999998, 5.0)।
बेरील

1
क्या कोई जानता है कि कौन सा तेज ऑपरेशन होगा, ऊपर वर्णित यह विधि, या: फ्लोट बी = ए - इंट (ए)? मुझे बाद में संदेह हुआ, लेकिन यह देखना चाहता था कि क्या पुष्टि है
हॉक्कुक

4
एक रास्पबेरी पाई पर यह विधि x%1लगभग दोगुनी थी (विधियों x-int(x)और modf(x)[0]समय 980 980, 1.39us, और 1.47us 1000000 से अधिक रन थे)। मेरा मूल्य xहमेशा सकारात्मक था इसलिए मुझे इस बारे में चिंता करने की आवश्यकता नहीं थी।
कोडरफ़ॉरेफ़ाइनल

निश्चित रूप से मॉड्यूल ऑपरेशन तेज है। यह किसी भी नाम लुकअप करने के लिए नहीं है। जबकि int फ़ंक्शन को कॉल करने से वैश्विक चर पर एक खोज होती है।
एनरिको बोरबा

फैंसी न सिर्फ एक फ्राक ()
mckenzm

155

Modf का प्रयोग करें :

>>> import math
>>> frac, whole = math.modf(2.5)
>>> frac
0.5
>>> whole
2.0

2
अच्छा समाधान, लेकिन, math.modf(2.53) = (0.5299999999999998, 2.0)अपेक्षित जवाब 0.53 है
लॉर्ड लोह।

4
@LordLoh। यह फ़्लोटिंग पॉइंट राउंडिंग के कारण है, और किसी भी विधि के साथ होगा।
रैन

@LordLoh। 0.53 प्राप्त करने के लिए राउंड (0.5299999999999998, 2) का उपयोग करने का प्रयास करें दूसरा तरीका दशमलव पैकेज से दशमलव का उपयोग करना है। docs.python.org/2/library/decimal.html
SirJ

57

व्हाट अबाउट:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

या, numpy का उपयोग करना:

import numpy
a = 1.3927278749291
b = a - numpy.fix(a)

33

decimalमानक पुस्तकालय से मॉड्यूल का उपयोग करके , आप मूल परिशुद्धता को बनाए रख सकते हैं और फ्लोटिंग पॉइंट राउंडिंग मुद्दों से बच सकते हैं:

>>> from decimal import Decimal
>>> Decimal('4.20') % 1
Decimal('0.20')

टिप्पणियों में किंडल नोट्स के रूप में, आपको floatसबसे पहले देशी एस को स्ट्रिंग्स में बदलना होगा ।


मूल प्रश्न पूछने वाले के लाभ के लिए: इससे पहले कि वे दशमलव में परिवर्तित किए जा सकें, फ़्लोट को एक तार में परिवर्तित किया जाना चाहिए। तो अगर आपके पास है n = 5.55, n एक फ्लोट है, और आपको Decimal(str(n)) % 1आंशिक भाग प्राप्त करने के लिए करना चाहिए । (यदि आपके पास पूर्णांक है, लेकिन यह आवश्यक नहीं है, तो यह आवश्यक नहीं है।)
टाइप करें

2
@intuited: इसे दशमलव होने की आवश्यकता नहीं है, यह फ्लोट के लिए भी काम करता है: 10.0/3 % 1कम से कम मेरे सिस्टम पर
aherok

2
आप स्ट्रिंग का उपयोग करने के बजाय from_float का उपयोग कर सकते हैं। d = Decimal.from_float (1.2)
मैथ्यू पर्डन

@intuited पूर्णांक के रूप में दशमलव भाग कैसे प्राप्त होता है? मैंने to_integer () विधियों की कोशिश की है लेकिन प्रकार अभी भी दशमलव है।
D1X

1
@MatthewPurdon - यदि आप उपयोग करते हैं Decimal.from_float(1.2)(जो अब के रूप में लिखा जा सकता है Decimal(1.2)) आपके पास गोल मुद्दे होंगे, जिससे यह उत्तर बचने की कोशिश कर रहा था।
जॉन वाई


5

स्वीकृत उत्तर के समान, स्ट्रिंग्स के उपयोग से भी आसान तरीका होगा

def number_after_decimal(number1):
    number = str(number1)
    if 'e-' in number: # scientific notation
        number_dec = format(float(number), '.%df'%(len(number.split(".")[1].split("e-")[0])+int(number.split('e-')[1])))
    elif "." in number: # quick check if it is decimal
        number_dec = number.split(".")[1]
    return number_dec

number = 5.55; "." in numberदेता है TypeError: argument of type 'float' is not iterable। और अगर करोगे तो क्या करोगे number = 1e-5?
मार्क डिकिन्सन

@ यह प्रश्न है कि दशमलव बिंदु के बाद मुझे संख्याएँ कैसे मिलेंगी? इसलिए उपयोगकर्ता दशमलव संकेतन (वैज्ञानिक संकेतन नहीं) में तैरने की उम्मीद कर रहा है, मैंने वैज्ञानिक संकेतन के लिए एक खंड भी जोड़ा है
yosemite_k

एक संख्या एक संख्या है; यह केवल एक संख्या का प्रतिनिधित्व है जो वैज्ञानिक संकेतन में हो सकता है। तो "दशमलव संख्‍या में नाव" यहां बहुत मायने नहीं रखता है; जब तक पायथन इसे देखता है, यह सिर्फ एक है float; पायथन को इस बात का कोई ज्ञान नहीं है कि यह किस प्रारूप में मूल रूप से व्यक्त किया गया था। मेरा number = 1e-5उदाहरण समान रूप से लागू होता है number = 0.00001: strसंख्या का प्रतिनिधित्व वैज्ञानिक नामांकन में है। आप e+वैसे भी e-, वैसे ही निपटना चाहेंगे ।
मार्क डिकिंसन


4
>>> n=5.55
>>> if "." in str(n):
...     print "."+str(n).split(".")[-1]
...
.55

2
यह उद्यान-किस्म की संख्याओं के लिए ठीक है, लेकिन वैज्ञानिक संकेतन की आवश्यकता के लिए पर्याप्त संख्या (या छोटे) के लिए इतनी अच्छी तरह से काम नहीं करता है।
किंडल

2

यह एक ऐसा उपाय है जिसे मैंने आजमाया है:

num = 45.7234
(whole, frac) = (int(num), int(str(num)[(len(str(int(num)))+1):]))

2

कभी-कभी ज़ीरो मामला

In [4]: def split_float(x):
   ...:     '''split float into parts before and after the decimal'''
   ...:     before, after = str(x).split('.')
   ...:     return int(before), (int(after)*10 if len(after)==1 else int(after))
   ...: 
   ...: 

In [5]: split_float(105.10)
Out[5]: (105, 10)

In [6]: split_float(105.01)
Out[6]: (105, 1)

In [7]: split_float(105.12)
Out[7]: (105, 12)

0.000005 के लिए यह क्या करता है?
आदित्य पटनायक

1

फर्श का उपयोग करें और मूल संख्या से परिणाम घटाएँ:

>> import math #gives you floor.
>> t = 5.55 #Give a variable 5.55
>> x = math.floor(t) #floor returns t rounded down to 5..
>> z = t - x #z = 5.55 - 5 = 0.55

5
यदि आप जा रहे हैं import math, तो सिर्फ उपयोग क्यों नहीं math.modf()?
ire_and_curses

@ire_and_curses: मैं समस्या का एक वैकल्पिक समाधान प्रदान कर रहा हूं।

1
मंजिल एक इंट को कास्टिंग के रूप में ही करता है ताकि गणित की जगह ले सके। फ्लोअर (टी) इंट (टी) के साथ
क्वांटम कार्ल

@QuantumKarl नहीं, वे अलग हैं। math.floor(-1.1) == -2लेकिन int(-1.1) == -1। हालांकि इस प्रश्न के लिए उपयोग intकरना अधिक सही है।
लैम्ब्डा फेयरी

1

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

अब ऐसे उपकरण हैं जो दशमलव प्रारूप में संख्यात्मक डेटा के भंडारण की अनुमति देते हैं। नीचे Decimalलाइब्रेरी का उपयोग करके एक उदाहरण दिया गया है।

from decimal import *

x = Decimal('0.341343214124443151466')
str(x)[-2:] == '66'  # True

y = 0.341343214124443151466
str(y)[-2:] == '66'  # False

1

उदाहरण:

import math
x = 5.55
print((math.floor(x*100)%100))

यह आपको दशमलव बिंदु के बाद दो नंबर देगा, 55 उस उदाहरण से। यदि आपको एक संख्या की आवश्यकता है, तो आप उपरोक्त गणनाओं को १० तक कम कर सकते हैं या इस आधार पर बढ़ा सकते हैं कि आप दशमलव के बाद कितने नंबर चाहते हैं।


यह अच्छा है क्योंकि यह एक गैर-भिन्नात्मक मूल्य लौटाता है, लेकिन नकारात्मक संख्याओं पर टूट जाएगा
मेव

दुर्भाग्य से यह ज्यादातर समय काम नहीं करता है। @ मेव
लोर्न के


1

बस सरल ऑपरेटर डिवीजन '/' और फ्लोर डिवीजन '//' का उपयोग करके आप किसी भी दिए गए फ्लोट का अंश भाग आसानी से प्राप्त कर सकते हैं।

number = 5.55

result = (number/1) - (number//1)

print(result)

0

व्हाट अबाउट:

a = 1.234
b = a - int(a)
length = len(str(a))

round(b, length-2)

आउटपुट:
print(b)
0.23399999999999999
round(b, length-2)
0.234

चूंकि राउंड को दशमलव ('0.234') की लंबाई तक भेजा जाता है, हम 'शून्य' की गणना नहीं करने के लिए केवल 2 माइनस कर सकते हैं, और दशमलव अंकों की वांछित संख्या का पता लगा सकते हैं। यह ज्यादातर समय काम करना चाहिए, जब तक कि आपके पास दशमलव के बहुत सारे स्थान न हों और बी की गणना करते समय राउंडिंग की गलती दूसरे दौर के पैरामीटर के साथ हो।


कोई स्पष्टीकरण?



0

अजगर 3 में दशमलव बिंदु के बाद संख्याओं को प्राप्त करने के लिए मैं अक्सर क्या करता हूं:

a=1.22
dec=str(a).split('.')
dec= int(dec[1])

0

यदि आप पांडा का उपयोग कर रहे हैं:

df['decimals'] = df['original_number'].mod(1)

0

एक अन्य विकल्प के reसाथ re.findallया मॉड्यूल का उपयोग करना होगा re.search:

import re


def get_decimcal(n: float) -> float:
    return float(re.search(r'\.\d+', str(n)).group(0))


def get_decimcal_2(n: float) -> float:
    return float(re.findall(r'\.\d+', str(n))[0])


def get_int(n: float) -> int:
    return int(n)


print(get_decimcal(5.55))
print(get_decimcal_2(5.55))
print(get_int(5.55))

उत्पादन

0.55
0.55
5

यदि आप अभिव्यक्ति को सरल / संशोधित / संशोधित करना चाहते हैं, तो इसे regex101.com के शीर्ष दाएं पैनल पर समझाया गया है । यदि आप चाहें, तो आप इस लिंक में भी देख सकते हैं कि यह कुछ नमूना आदानों के साथ कैसे मेल खाता है।


स्रोत

अजगर घटाव में अतिरिक्त फ्लोटिंग नंबरों से कैसे छुटकारा पाएं?


0

मैंने पाया है कि वास्तव में बड़े अंश भागों के साथ बड़ी संख्या में अंश प्राप्त करने के लिए मोडुलो 1 का उपयोग करते समय समस्याएं हो सकती हैं।

import decimal

>>> d = decimal.Context(decimal.MAX_PREC).create_decimal(
... '143000000000000000000000000000000000000000000000000000000000000000000000000000.1231200000000000000002013210000000'
... )
...
>>> d % 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
decimal.InvalidOperation: [<class 'decimal.DivisionImpossible'>]

मैंने इसके बजाय अभिन्न अंग को पकड़ लिया और बाकी हिस्सों को सरल बनाने में मदद करने के लिए पहले इसे घटाया।

>>> d - d.to_integral()
Decimal('0.1231200000000000000002013210')

0

Modf का उपयोग कर एक और उदाहरण

from math import modf
number = 1.0124584

# [0] decimal, [1] integer
result = modf(number)
print(result[0])
# output = 0124584
print(result[1])
# output = 1

0

एक समाधान modulo और गोलाई का उपयोग कर रहा है।

import math

num = math.fabs(float(5.55))
rem = num % 1

rnd_by =   len(str(num)) - len(str(int(num))) - 1

print(str(round(rem,rnd_by)))

आपका आउटपुट 0.55 होगा



-2

एक और पागल समाधान है (एक स्ट्रिंग में परिवर्तित किए बिना):

number = 123.456
temp = 1

while (number*temp)%10 != 0:
    temp = temp *10
    print temp
    print number

temp = temp /10
number = number*temp
number_final = number%temp
print number_final
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.