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

Question

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

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

Comments

संबंधित: पायथन में मैं दशमलव बिंदु से एक संख्या को कैसे विभाजित करूं?

— ire_and_curses 22

Answer 1

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

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

Comments

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

— intuited

number_dec = str(number-int(number)).split('.')[1]

— रयान एलन

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

— स्टू

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

— टी।

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

— क्रिस्टियन सियुपिटु

Answer 2

5.55 % 1

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

0.550000000001

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

Comments

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

— बेरील

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

— हॉक्कुक

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

— कोडरफ़ॉरेफ़ाइनल

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

— एनरिको बोरबा

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

— mckenzm

Answer 3

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

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

Comments

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

— लॉर्ड लोह।

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

— रैन

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

— SirJ

Answer 4

व्हाट अबाउट:

a = 1.3927278749291
b = a - int(a)

b
>> 0.39272787492910011

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

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

Answer 5

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

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

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

Comments

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

— टाइप करें

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

— aherok

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

— मैथ्यू पर्डन

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

— D1X

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

— जॉन वाई

Answer 6

मोडुलो आज़माएँ:

5.55%1 = 0.54999999999999982

Answer 7

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

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

Comments

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-, वैसे ही निपटना चाहेंगे ।

— मार्क डिकिंसन

Answer 8

import math
orig = 5.55
whole = math.floor(orig)    # whole = 5.0
frac = orig - whole         # frac = 0.55

Comments

>>> फ्राक 0.5499999999999998

— macm

Answer 9

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

Comments

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

— किंडल

Answer 10

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

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

Answer 11

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

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)

Comments

0.000005 के लिए यह क्या करता है?

— आदित्य पटनायक

Answer 12

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

>> 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

Comments

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

— ire_and_curses

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

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

— क्वांटम कार्ल

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

— लैम्ब्डा फेयरी

Answer 13

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

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

from decimal import *

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

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

Answer 14

उदाहरण:

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

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

Comments

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

— मेव

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

— लोर्न के

Answer 15

import math

x = 1245342664.6
print( (math.floor(x*1000)%1000) //100 )

यह निश्चित रूप से काम किया

Comments

ऑपरेटर // का क्या अर्थ है?

— l -''''''--------- '' '' '' '' '' ''

Answer 16

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

number = 5.55

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

print(result)

Answer 17

व्हाट अबाउट:

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 माइनस कर सकते हैं, और दशमलव अंकों की वांछित संख्या का पता लगा सकते हैं। यह ज्यादातर समय काम करना चाहिए, जब तक कि आपके पास दशमलव के बहुत सारे स्थान न हों और बी की गणना करते समय राउंडिंग की गलती दूसरे दौर के पैरामीटर के साथ हो।

Comments

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

Answer 18

आप इसे आज़माना चाहते हैं:

your_num = 5.55
n = len(str(int(your_num)))
float('0' + str(your_num)[n:])

यह वापस आ जाएगी 0.55।

Answer 19

number=5.55
decimal=(number-int(number))
decimal_1=round(decimal,2)
print(decimal)
print(decimal_1)

आउटपुट: 0.55

Answer 20

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

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

Answer 21

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

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

Answer 22

एक अन्य विकल्प के 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 के शीर्ष दाएं पैनल पर समझाया गया है । यदि आप चाहें, तो आप इस लिंक में भी देख सकते हैं कि यह कुछ नमूना आदानों के साथ कैसे मेल खाता है।

---

स्रोत

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

Answer 23

मैंने पाया है कि वास्तव में बड़े अंश भागों के साथ बड़ी संख्या में अंश प्राप्त करने के लिए मोडुलो 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')

Answer 24

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

Answer 25

एक समाधान 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 होगा

Answer 26

आप इसका उपयोग कर सकते हैं:

number = 5.55
int(str(number).split('.')[1])

Answer 27

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

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