यह समस्या मुझे मार रही है। पायथन में एक राउंडअप एक नंबर यूपी कैसे करता है?
मैंने राउंड (संख्या) की कोशिश की, लेकिन यह संख्या नीचे हो गई। उदाहरण:
round(2.3) = 2.0 and not 3, what I would likeमैंने int (संख्या + .5) की कोशिश की लेकिन यह फिर से नीचे संख्या को गोल करता है! उदाहरण:
int(2.3 + .5) = 2फिर मैंने राउंड (संख्या + .5) की कोशिश की, लेकिन यह बढ़त के मामलों में काम नहीं करेगा। उदाहरण:
WAIT! THIS WORKED!कृपया सलाह दें।
जवाबों:
प्लस्तर लगाना (छत) समारोह:
import math
print(math.ceil(4.2))int(math.ceil(363))
math.ceilपूर्णांक मान के साथ फ्लोटिंग ऑब्जेक्ट न केवल एक वास्तविक पूर्णांक ऑब्जेक्ट देता है।
10000000 * 0.00136 = 13600.000000000002math.ceil(10000000 * 0.00136) = 13601.0
मुझे पता है कि यह उत्तर थोड़ी देर से एक प्रश्न के लिए है, लेकिन अगर आप गणित को आयात नहीं करना चाहते हैं और आप केवल गोल करना चाहते हैं, तो यह मेरे लिए काम करता है।
>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5पहला भाग 4 हो जाता है और दूसरा भाग शेष होने पर "सत्य" का मूल्यांकन करता है, जो कि सत्य 1 = 1 के अतिरिक्त है; मिथ्या = 0. इसलिए यदि कोई शेष नहीं है, तो यह एक ही पूर्णांक रहता है, लेकिन यदि शेष है तो यह 1 जोड़ता है।
//पूर्णांक विभाजन के लिए भी उपयोग कर सकते हैं , इसलिए यह बन जाता है 21 // 5 + (21 % 5 > 0)।
floatएस। अच्छा लगा।
दिलचस्प पायथन 2.x मुद्दा ध्यान में रखने के लिए:
>>> import math
>>> math.ceil(4500/1000)
4.0
>>> math.ceil(4500/1000.0)
5.0समस्या यह है कि अजगर में दो चींटियों को विभाजित करने से एक और अंतर पैदा होता है और जिसे छत कॉल से पहले काट दिया जाता है। आपको एक सही परिणाम प्राप्त करने के लिए एक मान एक फ्लोट (या कास्ट) बनाना होगा।
जावास्क्रिप्ट में, एक ही कोड एक अलग परिणाम उत्पन्न करता है:
console.log(Math.ceil(4500/1000));
5यदि पूर्णांकों के साथ काम कर रहे हैं, तो राउंडिंग का एक तरीका इस तथ्य का लाभ उठाना है कि //नीचे गोल है: बस नकारात्मक संख्या पर विभाजन करें, फिर उत्तर को नकार दें। कोई आयात, फ्लोटिंग पॉइंट, या सशर्त ज़रूरत नहीं।
rounded_up = -(-numerator // denominator)उदाहरण के लिए:
>>> print(-(-101 // 5))
21(num + den - 1) // den, जो intसकारात्मक हर के साथ इनपुट के लिए ठीक है, लेकिन विफल रहता है अगर एक भी गैर-अभिन्न floatशामिल है (या तो अंश या भाजक); यह अधिक जादुई लग रही है, लेकिन दोनों intएस और floatएस के लिए काम करता है । छोटे अंशधारियों के लिए, यह तेज़ (CPython 3.7.2 पर) है, हालांकि अजीब तरह से, जब केवल अंश बड़ा होता है, तो सरणी आधारित गणित की आवश्यकता होती है, आपका दृष्टिकोण धीमा होता है; यह स्पष्ट नहीं है कि ऐसा क्यों है, क्योंकि विभाजन का काम समान होना चाहिए और दो एकात्मक नकारात्मक जोड़ + घटाव से सस्ता होना चाहिए।
तुम भी सुन्न पसंद कर सकते हैं:
>>> import numpy as np
>>> np.ceil(2.3)
3.0मैं यह नहीं कह रहा हूं कि यह गणित से बेहतर है, लेकिन यदि आप पहले से ही अन्य उद्देश्यों के लिए सुन्न का उपयोग कर रहे हैं, तो आप अपने कोड को सुसंगत रख सकते हैं।
वैसे भी, बस एक विस्तार मैं भर आया। मैं बहुत उपयोग करता हूं और आश्चर्यचकित था कि इसका उल्लेख नहीं किया गया था, लेकिन निश्चित रूप से स्वीकृत जवाब पूरी तरह से ठीक काम करता है।
math.ceilराउंड अप करने के लिए उपयोग करें :
>>> import math
>>> math.ceil(5.4)
6.0नोट : इनपुट फ्लोट होना चाहिए।
यदि आपको पूर्णांक की आवश्यकता है, तो intइसे बदलने के लिए कॉल करें :
>>> int(math.ceil(5.4))
6BTW, math.floorराउंड डाउन और roundनिकटतम पूर्णांक पर राउंड का उपयोग करें ।
>>> math.floor(4.4), math.floor(4.5), math.floor(5.4), math.floor(5.5)
(4.0, 4.0, 5.0, 5.0)
>>> round(4.4), round(4.5), round(5.4), round(5.5)
(4.0, 5.0, 5.0, 6.0)
>>> math.ceil(4.4), math.ceil(4.5), math.ceil(5.4), math.ceil(5.5)
(5.0, 5.0, 6.0, 6.0)ceil() से इसका ध्यान
वाक्य-विन्यास जितना हो सकता है उतना पाइथोनिक नहीं हो सकता है, लेकिन यह एक शक्तिशाली पुस्तकालय है।
https://docs.python.org/2/library/decimal.html
from decimal import *
print(int(Decimal(2.3).quantize(Decimal('1.'), rounding=ROUND_UP)))मुझे आश्चर्य है कि किसी ने सुझाव नहीं दिया
(numerator + denominator - 1) // denominatorपूर्णांक के साथ पूर्णांक विभाजन के लिए। C / C ++ / CUDA (cf. divup) के लिए सामान्य तरीका हुआ करता था
1इसे घटाने के बजाय जोड़ने की आवश्यकता है , या गणित करने से पहले अंश और भाजक दोनों के संकेतों को फ्लिप करना होगा।
इसे इस्तेमाल करे:
a = 211.0
print(int(a) + ((int(a) - a) != 0))((int(a) - a) != 0)अभिव्यक्ति रिटर्न 1जब भी aजरूरत को गिरफ्तार किया जाना है। आप अपने उत्तर का विस्तार करना चाहते हैं और समझा सकते हैं कि यह कैसे काम करता है।
>>> def roundup(number):
... return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20इस फ़ंक्शन के लिए किसी मॉड्यूल की आवश्यकता नहीं है।
3, तो यह उस समय तक होगा 4जब कोई व्यक्ति चाहे या नहीं हो सकता है
उपरोक्त उत्तर सही हैं, हालांकि, mathइस एक फ़ंक्शन के लिए मॉड्यूल का आयात करना आमतौर पर मेरे लिए एक ओवरकिल की तरह महसूस होता है। सौभाग्य से, इसे करने का एक और तरीका है:
g = 7/5
g = int(g) + (not g.is_integer())Trueऔर अजगर में संख्याओं को शामिल करने वाले एक बयान के Falseरूप में 1और व्याख्या की जाती है 0। g.is_interger()मूल रूप से अनुवाद करता है g.has_no_decimal()या g == int(g)। इसलिए अंग्रेजी में अंतिम विवरण पढ़ता है round g down and add one if g has decimal।
int(g) + (g % 1 > 0)इसके बजाय ;-)
from math import ceilसंपूर्ण गणित मॉड्यूल आयात करना ठीक लगता है :)
import mathपर्दे के पीछे जो कुछ होता है उसके संदर्भ में यह पंक्ति बहुत अलग नहीं है । यह सिर्फ सभी प्रतीकों को छोड़कर ceil।
गणित का आयात किए बिना // मूल पर्यावरण का उपयोग करके:
a) विधि / वर्ग विधि
def ceil(fl):
return int(fl) + (1 if fl-int(fl) else 0)
def ceil(self, fl):
return int(fl) + (1 if fl-int(fl) else 0)बी) लंबा:
ceil = lambda fl:int(fl)+(1 if fl-int(fl) else 0)यदि कोई व्यक्ति किसी विशिष्ट दशमलव स्थान पर चक्कर लगाना चाहता है:
import math
def round_up(n, decimals=0):
multiplier = 10 ** decimals
return math.ceil(n * multiplier) / multiplierमुझे आश्चर्य है कि मैंने यह जवाब अभी तक नहीं देखा है round(x + 0.4999), इसलिए मैं इसे नीचे रखने जा रहा हूं। ध्यान दें कि यह किसी भी पायथन संस्करण के साथ काम करता है। पायथन राउंडिंग स्कीम में किए गए बदलाव से चीजें मुश्किल हो गई हैं। इस पोस्ट को देखें ।
आयात किए बिना, मैं उपयोग करता हूं:
def roundUp(num):
return round(num + 0.49)
testCases = list(x*0.1 for x in range(0, 50))
print(testCases)
for test in testCases:
print("{:5.2f} -> {:5.2f}".format(test, roundUp(test)))यह क्यों काम करता है
डॉक्स से
अंतर्निहित प्रकारों के लिए समर्थन दौर () में, मानों को शक्ति माइनस n के 10 के निकटतम कई पर गोल किया जाता है; यदि दो गुणक समान रूप से पास हैं, तो गोलाई भी पसंद के अनुसार की जाती है
इसलिए 2.5 2 से गोल हो जाता है और 3.5 से 4 हो जाता है। अगर ऐसा नहीं होता तो 0.5 को जोड़कर राउंड अप किया जा सकता था, लेकिन हम आधे रास्ते तक पहुंचने से बचना चाहते हैं। इसलिए, यदि आप 0.4999 जोड़ते हैं, तो आप करीब पहुंच जाएंगे, लेकिन सामान्य रूप से आप जो अपेक्षा करेंगे, उसके लिए पर्याप्त मार्जिन के साथ। बेशक, यह विफल हो जाएगा अगर x + 0.4999बराबर है [n].5000, लेकिन यह संभावना नहीं है।
math.ceil()?
Without importing I use:। मैंने यह भी उल्लेख किया है कि अगर x + 0.4999यह बराबर है तो यह विफल हो जाएगा [n].5000।
mathमॉड्यूल और math.ceil(), इसलिए उपलब्ध हर जगह अतिरिक्त सामान की स्थापना के बिना सभी व्यावहारिक उद्देश्यों के लिए मानक पुस्तकालय में है। और आपके असफल होने के उल्लेख के बारे में, यह आपके उत्तर में अधूरा है, क्योंकि यह केवल एक बिंदु के लिए नहीं, बल्कि पूरे अंतराल के लिए विफल रहता है। तकनीकी तौर पर, आप बहस कर सकते आप सही हैं, जैसा कि आप कहते हैं कि अगर और नहीं iff , लेकिन यह आकस्मिक पाठक पर छाप कर देगा कि यह कम संभावना से भी यह वास्तव में है।
मुझे पता है कि यह काफी पहले से है, लेकिन मुझे काफी दिलचस्प जवाब मिला, इसलिए यहां जाता है:
-round(-x-0.5)यह किनारों के मामलों को ठीक करता है और सकारात्मक और नकारात्मक दोनों संख्याओं के लिए काम करता है, और किसी भी फ़ंक्शन आयात की आवश्यकता नहीं होती है
चियर्स
-round(-x-0.3) = x
जब आप अजगर में 4500/1000 का संचालन करते हैं, तो परिणाम 4 होगा, क्योंकि परिणाम के रूप में पूर्ण रूप से डिफ़ॉल्ट अजगर asume के लिए, तार्किक रूप से: 4500/1000 = 4.5 -> int (4.5) = 4 और 4 के छत स्पष्ट रूप से 4 है
4500 / 1000.0 का उपयोग करने का परिणाम 4.5 होगा और 4.5 -> 5 का छत होगा
जावास्क्रिप्ट का उपयोग करते हुए आप 4500/1000 के परिणाम के रूप में 4.5 प्राप्त करेंगे, क्योंकि जावास्क्रिप्ट केवल "संख्यात्मक प्रकार" के रूप में परिणाम मानते हैं और परिणाम को सीधे फ्लोट के रूप में लौटाते हैं
शुभ लाभ!!
/हमेशा एक फ्लोट में परिणाम करता है, इसलिए 4500/1000हमेशा 4.5 होता है।
यदि आप कुछ भी आयात नहीं करना चाहते हैं, तो आप हमेशा अपना स्वयं का सरल कार्य लिख सकते हैं:
def RoundUP(num):
if num== int(num):
return num
return int(num + 1)
आप फर्श डिविज़न का उपयोग कर सकते हैं और इसमें 1 जोड़ सकते हैं। २.३ // २ + १
ceil()इसके विपरीत अजीब तरह से करने के बजाय उपयोग करें और फिर क्षतिपूर्ति करें
from math import ceil; assert 4 // 2 + 1 == ceil(4 / 2)
मुझे लगता है कि आप काम कर रहे तंत्र के बीच int()और भ्रमित कर रहे हैं round()।
int()यदि हमेशा फ़्लोटिंग नंबर दिया जाता है, तो हमेशा दशमलव संख्याओं को काटता है; जबकि round(), 2.5जहां के मामले में 2और जहां 3से दोनों समान दूरी पर हैं 2.5, पायथन जो भी 0 बिंदु से अधिक दूर है, लौटाता है।
round(2.5) = 3
int(2.5) = 22.3बदल जाता है 3, जो आपके किसी भी उदाहरण में नहीं होता है।
मैं मूल रूप से पायथन में एक शुरुआत कर रहा हूं, लेकिन अगर आप नीचे की बजाय गोल करने की कोशिश कर रहे हैं तो ऐसा क्यों न करें:
round(integer) + 1round(integer + 0.5)है कि मेरा मतलब है कि यह वही है जो मैं अक्सर करता हूं
round(number + .5)यदि संख्या पूर्णांक है तो काम नहीं करता है।round(3+.5) == 4, जब आप वास्तव में चाहते हैं3।