Python'da bir sayıyı nasıl yuvarlarsınız?

Bu problem beni öldürüyor. Python'da bir sayı UP nasıl toplanır?

Ben (sayı) tur denedim ama sayı aşağı yuvarladı. Misal:

round(2.3) = 2.0 and not 3, what I would like

Ben int (sayı + .5) denedim ama yine numarayı aşağı yuvarlak! Misal:

int(2.3 + .5) = 2

Sonra tur (sayı + .5) denedim ama kenar durumlarda işe yaramaz. Misal:

WAIT! THIS WORKED!

Tavsiye lütfen.

Ceil (tavan) fonksiyonu:

import math
print(math.ceil(4.2))

Bu cevabın bir süre önce bir soru için olduğunu biliyorum, ama matematik almak istemiyorsanız ve sadece yuvarlamak istiyorsanız, bu benim için işe yarıyor.

>>> int(21 / 5)
4
>>> int(21 / 5) + (21 % 5 > 0)
5

İlk bölüm 4 olur ve ikinci bölüm bir kalan varsa "True" olarak değerlendirilir, buna ek olarak True = 1; False = 0. Dolayısıyla, kalan yoksa, aynı tamsayı olarak kalır, ancak kalan varsa 1 ekler.

Akılda tutulması gereken ilginç Python 2.x sorunu:

>>> import math
>>> math.ceil(4500/1000)
4.0
>>> math.ceil(4500/1000.0)
5.0

Sorun, python'da iki int bölmenin başka bir int üretmesi ve tavan çağrısından önce kesilmesidir. Doğru sonucu elde etmek için bir değeri bir kayan nokta (veya döküm) yapmanız gerekir.

Javascript'te, tam olarak aynı kod farklı bir sonuç üretir:

console.log(Math.ceil(4500/1000));
5

Tamsayılarla çalışıyorsanız, yuvarlamanın bir yolu, yuvarlanan gerçeğin avantajından yararlanmaktır //: Sadece negatif sayıdaki bölümü yapın, ardından cevabı reddedin. İçe aktarma, kayan nokta veya koşullu gerekmez.

rounded_up = -(-numerator // denominator)

Örneğin:

>>> print(-(-101 // 5))
21

Şunu da beğenebilirsin numpy:

>>> import numpy as np
>>> np.ceil(2.3)
3.0

Matematikten daha iyi olduğunu söylemiyorum, ancak zaten başka amaçlar için numpy kullanıyorsanız, kodunuzu tutarlı tutabilirsiniz.

Her neyse, sadece bir ayrıntıya rastladım. Numpy'yi çok kullanıyorum ve bahsedilmediğine şaşırdım, ancak elbette kabul edilen cevap mükemmel çalışıyor.

kullanım math.ceil için :

>>> import math
>>> math.ceil(5.4)
6.0

NOT : Giriş şamandıra olmalıdır.

Bir tamsayıya ihtiyacınız varsa, int dönüştürmek için :

>>> int(math.ceil(5.4))
6

BTW, kullanmak math.flooryuvarlak için aşağı ve rounden yakın tam sayıya yuvarlak için.

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

Sözdizimi, istendiği kadar pitonik olmayabilir, ancak güçlü bir kütüphanedir.

https://docs.python.org/2/library/decimal.html

from decimal import *
print(int(Decimal(2.3).quantize(Decimal('1.'), rounding=ROUND_UP)))

Kimsenin önermediğine şaşırdım

(numerator + denominator - 1) // denominator

yuvarlama ile tamsayı bölme için. Eskiden C / C ++ / CUDA (krş. divup)

Shure yuvarlak değeri float olmalı

a = 8 
b = 21
print math.ceil(a / b)
>>> 0

fakat

print math.ceil(float(a) / b)
>>> 1.0

Bunu dene:

a = 211.0
print(int(a) + ((int(a) - a) != 0))

>>> def roundup(number):
...     return round(number+.5)
>>> roundup(2.3)
3
>>> roundup(19.00000000001)
20

Bu işlev modül gerektirmez.

Yukarıdaki cevaplar doğrudur, ancak mathmodülü bu işlev için içe aktarmak genellikle benim için biraz fazlalık gibi geliyor. Neyse ki, bunu yapmanın başka bir yolu var:

g = 7/5
g = int(g) + (not g.is_integer())

Trueve Falseolarak yorumlanır 1ve 0python numaranın yer açıklamada. g.is_interger()temelde g.has_no_decimal()veya anlamına gelir g == int(g). Yani İngilizce'deki son ifade okuyor round g down and add one if g has decimal.

Matematiği içe aktarmadan // temel ortamı kullanarak:

a) yöntem / sınıf yöntemi

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)

Yuvarlamak isteyenler için a / b ve tamsayı almak :

Tamsayı bölümü kullanan bir başka varyant

def int_ceil(a, b):
    return (a - 1) // b + 1

>>> int_ceil(19, 5)
4
>>> int_ceil(20, 5)
4
>>> int_ceil(21, 5)
5

Herhangi bir kişinin belirli bir ondalık basamağa yuvarlamak istemesi durumunda:

import math
def round_up(n, decimals=0):
    multiplier = 10 ** decimals
    return math.ceil(n * multiplier) / multiplier

Bu cevabı henüz görmediğime şaşırdım round(x + 0.4999), bu yüzden cevaplayacağım . Bunun herhangi bir Python sürümü ile çalıştığını unutmayın. Python yuvarlama şemasında yapılan değişiklikler işleri zorlaştırdı. Bu gönderiye bakın .

İçe aktarmadan kullanıyorum:

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

Bu neden çalışıyor?

Dokümanlardan

Round () özelliğini destekleyen yerleşik türler için, değerler güç eksi n'nin 10 en yakın katına yuvarlanır; iki kat eşit derecede yakınsa, yuvarlama eşit seçeneğe doğru yapılır

Bu nedenle 2.5 2'ye yuvarlanır ve 3.5 4'e yuvarlanır. Eğer durum böyle değilse, yuvarlama 0.5 ekleyerek yapılabilir, ancak yarım noktaya gelmekten kaçınmak istiyoruz. Yani, 0,4999 eklerseniz yakınlaşacaksınız, ancak normalde beklediğiniz şeye yuvarlanacak yeterli marj ile. Tabii ki, bu x + 0.4999eşitse başarısız olur [n].5000, ancak bu olası değildir.

Herhangi bir içe aktarma olmadan yapmak için:

>>> round_up = lambda num: int(num + 1) if int(num) != num else int(num)
>>> round_up(2.0)
2
>>> round_up(2.1)
3

Bunun bir süre önce olduğunu biliyorum, ama oldukça ilginç bir cevap buldum, işte burada:

-round(-x-0.5)

Bu, kenarları düzeltir ve hem pozitif hem de negatif sayılar için çalışır ve herhangi bir işlev içe aktarması gerektirmez

Şerefe

python'da 4500/1000 çalıştırdığınızda, sonuç 4 olacaktır, çünkü varsayılan python sonucu tamsayı olarak kabul eder, mantıksal olarak: 4500/1000 = 4.5 -> int (4.5) = 4 ve 4 tavanı açıkça 4'tür

4500 / 1000.0 kullanıldığında sonuç 4.5 ve tavan 4.5 olacak -> 5

Javascript kullanarak 4500/1000 sonucu 4,5 alırsınız, çünkü javascript yalnızca sonucu "sayısal tip" olarak alır ve bir sonucu doğrudan float olarak döndürür

İyi şanslar!!

Hiçbir şeyi içe aktarmak istemiyorsanız, kendi basit işlevinizi her zaman şu şekilde yazabilirsiniz:

def RoundUP(num): if num== int(num): return num return int(num + 1)

Zemin sapmasını kullanabilir ve buna 1 ekleyebilirsiniz. 2.3 // 2 + 1

Sanırım int()ve arasındaki çalışma mekanizmalarını karıştırıyorsunuz round().

int()kayan bir sayı verilirse her zaman ondalık sayıları keser; oysa round(), 2.5nereye 2ve 3her ikisine eşit mesafede 2.5olursa Python 0 noktasından daha uzak olanı döndürür.

round(2.5) = 3
int(2.5) = 2

Benim payım

print(-(-101 // 5)) = 21Yukarıda verilen örneği test ettim .

Şimdi yuvarlamak için:

101 * 19% = 19.19

Ben kullanamam **böylece çarpma bölme yayıldı:

(-(-101 //(1/0.19))) = 20

Ben temelde Python bir acemi değilim, ama sadece aşağı yerine yuvarlamaya çalışıyorsanız neden yapmıyorsunuz:

round(integer) + 1