Hoe ronde een nummer in Python?
Ik heb het round(number)geprobeerd, maar het rondet het nummer naar beneden. Voorbeeld:
round(2.3) = 2.0
en niet 3, zoals ik zou willen.
De i PROBEERD int(number + .5)MAAR HET ROND HET NUMBER DOWN! Voorbeeld:
int(2.3 + .5) = 2
1, Autoriteit 100%
De CEIL (plafond) functie:
import math
print(int(math.ceil(4.2)))
2, Autoriteit 23%
Ik weet dat dit antwoord is voor een vraag van een tijdje terug, maar als u geen wiskunde wilt importeren en wilt u gewoon afronden, werkt dit voor mij.
>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5
Het eerste deel wordt 4 en het tweede deel evalueert naar “TRUE” als er een rest is, die bovendien true = 1; FALSE = 0. Dus als er geen rest is, blijft het hetzelfde geheel getal, maar als er een rest is, voegt het toe 1.
3, Autoriteit 17%
Interessante Python 2.x-probleem om in gedachten te houden:
>>> import math
>>> math.ceil(4500/1000)
4.0
>>> math.ceil(4500/1000.0)
5.0
Het probleem is dat het verdelen van twee inten in Python een andere int produceert en dat is afgekapt vóór het plafondgesprek. U moet een waarde van een vlotter (of cast) maken om een correct resultaat te krijgen.
JavaScript, exact dezelfde code geeft een ander resultaat:
console.log(Math.ceil(4500/1000));
5
4, Autoriteit 13%
Als het werken met getallen, een manier van afronden is om te profiteren van het feit dat //rondes neer: Doe de divisie op het negatieve getal, dan ontkennen het antwoord. Geen import, floating point, of voorwaardelijk nodig is.
rounded_up = -(-numerator // denominator)
Bijvoorbeeld:
>>> print(-(-101 // 5))
21
5, Autoriteit 6%
Je zou ook graag numpy:
>>> import numpy as np
>>> np.ceil(2.3)
3.0
Ik zeg niet dat het is beter dan wiskunde, maar als je al gebruik numpy voor andere doeleinden, kunt u uw code consistent te houden.
Hoe dan ook, slechts een detail die ik tegenkwam. Ik gebruik numpy veel en was verbaasd dat het werd niet genoemd, maar natuurlijk werkt de geaccepteerde antwoord perfect in orde.
6, Autoriteit 2%
Ik ben verrast dat niemand voorstelde
(numerator + denominator - 1) // denominator
Voor integer-divisie met afronding. Vroeger de gewone manier voor C / C++ / CUDA (zie divup)
7
De syntaxis is mogelijk niet zo pythonic als die misschien leuk vindt, maar het is een krachtige bibliotheek.
https://docs.python.org/2/Library/decimal.html
from decimal import *
print(int(Decimal(2.3).quantize(Decimal('1.'), rounding=ROUND_UP)))
8
Probeer dit:
a = 211.0
print(int(a) + ((int(a) - a) != 0))
9
Wees shure afgeronde waarde moet drijvend zijn
a = 8
b = 21
print math.ceil(a / b)
>>> 0
maar
print math.ceil(float(a) / b)
>>> 1.0
10
De bovenstaande antwoorden zijn echter correct, maar importeren van de mathMODULE ALLEEN VOOR DEZE DEFUNCTIE Veelt meestal als een beetje een overkill voor mij. Gelukkig is er een andere manier om het te doen:
g = 7/5
g = int(g) + (not g.is_integer())
TrueEN Falseworden geïnterpreteerd als 1en 0in een verklaring met nummers in Python. g.is_interger()vertaalt in feite naar g.has_no_decimal()of g == int(g). Dus de laatste verklaring in het Engels leest round g down and add one if g has decimal.
11
zonder wiskunde // te importeren met behulp van basiswaarde:
a) Methode / Klasse-methode
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)
b) lambda:
ceil = lambda fl:int(fl)+(1 if fl-int(fl) else 0)
12
>>> def roundup(number):
... return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20
Deze functie vereist geen modules.
13
Als iemand op zoek is naar een specifieke decimale plaats:
import math
def round_up(n, decimals=0):
multiplier = 10 ** decimals
return math.ceil(n * multiplier) / multiplier
Antwoord 14
Het verbaast me dat ik dit antwoord round(x + 0.4999)nog niet heb gezien, dus ik leg het neer. Merk op dat dit werkt met elke Python-versie. Wijzigingen in het Python-afrondingsschema hebben de zaken bemoeilijkt. Zie dit bericht.
Zonder te importeren, gebruik ik:
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)))
Waarom dit werkt
Uit de documenten
Voor de ingebouwde typen die round() ondersteunen, worden waarden afgerond op het dichtstbijzijnde veelvoud van 10 tot de macht min n; als twee veelvouden even dicht bij elkaar liggen, wordt naar de even keuze afgerond
Daarom wordt 2,5 afgerond naar 2 en 3,5 wordt afgerond naar 4. Als dit niet het geval was, zou naar boven kunnen worden afgerond door 0,5 toe te voegen, maar we willen voorkomen dat we halverwege komen. Dus als u 0,4999 toevoegt, komt u in de buurt, maar met voldoende marge om af te ronden naar wat u normaal zou verwachten. Dit zal natuurlijk mislukken als de x + 0.4999gelijk is aan [n].5000, maar dat is onwaarschijnlijk.
Antwoord 15
Voor degenen die importeren niet willen gebruiken.
Voor een bepaalde lijst of een willekeurig nummer:
x = [2, 2.1, 2.5, 3, 3.1, 3.5, 2.499,2.4999999999, 3.4999999,3.99999999999]
U moet eerst evalueren of het nummer gelijk is aan zijn geheel getal, dat altijd naar beneden rondeert. Als het resultaat waar is, retourneert u het nummer, indien niet, retourneert u het geheel getal (nummer) + 1.
w = lambda x: x if x == int(x) else int(x)+1
[w(i) for i in z]
>>> [2, 3, 3, 3, 4, 4, 3, 3, 4, 4]
Math Logic:
- Als het nummer decimaal onderdeel heeft: Round_Up – Round_Down == 1, altijd.
- Als het cijfer DAENS NIET DECIMAL PART HEEFT: ROND_UP – ROND_DOWN == 0.
Dus:
- round_up == x + round_down
Met:
- x == 1 indien nummer! = Round_down
- x == 0 if nummer == round_down
U snijdt het nummer in 2 delen, het gehele getal en decimaal. Als decimaal niet 0 is, voegt u 1 toe.
PS: Ik heb dit in details uitgelegd sinds sommige opmerkingen hierboven vegen en ik ben nog steeds noob hier, dus ik kan geen commentaar geven.
16
Om het te doen zonder enige import:
>>> round_up = lambda num: int(num + 1) if int(num) != num else int(num)
>>> round_up(2.0)
2
>>> round_up(2.1)
3
17
Ik weet dat dit van vrij een tijdje terug is, maar ik vond een vrij interessant antwoord, dus hier gaat:
-round(-x-0.5)
Hiermee wordt de cases en werkt voor zowel positieve als negatieve getallen op en werkt geen enkele functie-import
Cheers
18
Als u niets wilt importeren, kunt u altijd uw eigen eenvoudige functie schrijven als:
def RoundUP(num):
if num== int(num):
return num
return int(num + 1)
Antwoord 19
Je zou ronde als volgt kunnen gebruiken:
cost_per_person = round(150 / 2, 2)
Antwoord 20
Je kunt verdiepingsdeling gebruiken en er 1 aan toevoegen.
2.3 // 2 + 1
Antwoord 21
wanneer u 4500/1000 in python gebruikt, is het resultaat 4, omdat voor standaard python het resultaat logisch als geheel getal wordt aangenomen:
4500/1000 = 4,5 –> int(4.5) = 4
en het plafond van 4 is duidelijk 4
bij gebruik van 4500/1000,0 is het resultaat 4,5 en een plafond van 4,5 –> 5
Als je javascript gebruikt, ontvang je 4.5 als resultaat van 4500/1000, omdat javascript alleen het resultaat als “numeriek type” aanneemt en een resultaat direct als float retourneert
Veel succes!!
Antwoord 22
Ik ben eigenlijk een beginner bij Python, maar als je alleen naar boven probeert af te ronden in plaats van naar beneden, waarom zou je dat dan niet doen:
round(integer) + 1
Antwoord 23
Ik denk dat je de werkingsmechanismen tussen int()en round()door elkaar haalt.
int()kapt altijd de decimale getallen af als een zwevend getal wordt gegeven; terwijl round(), in het geval van 2.5waarbij 2en 3beide op gelijke afstand van 2.5, geeft Python terug wat het meest verwijderd is van het 0-punt.
round(2.5) = 3
int(2.5) = 2
Antwoord 24
Mijn aandeel
Ik heb print(-(-101 // 5)) = 21getest in het bovenstaande voorbeeld.
Nu afronden:
101 * 19% = 19.19
Ik kan **niet gebruiken, dus spreid ik de vermenigvuldiging naar deling:
(-(-101 //(1/0.19))) = 20