Bagaimana Anda mengumpulkan angka dengan Python?

Masalah ini membunuhku. Bagaimana cara mengumpulkan angka UP di Python?

Saya mencoba putaran (angka) tetapi membulatkan angka ke bawah. Contoh:

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

Saya mencoba int (angka + .5) tetapi membulatkan angka ke bawah lagi! Contoh:

int(2.3 + .5) = 2

Kemudian saya mencoba putaran (angka + .5) tetapi tidak akan bekerja dalam kasus tepi. Contoh:

WAIT! THIS WORKED!

Mohon saran.

The ceil (langit-langit) fungsi:

import math
print(math.ceil(4.2))

Saya tahu jawaban ini untuk pertanyaan sejak beberapa waktu lalu, tetapi jika Anda tidak ingin mengimpor matematika dan Anda hanya ingin mengumpulkan, ini bekerja untuk saya.

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

Bagian pertama menjadi 4 dan bagian kedua mengevaluasi ke "Benar" jika ada sisanya, yang di samping Benar = 1; Salah = 0. Jadi jika tidak ada sisa, maka itu tetap bilangan bulat yang sama, tetapi jika ada sisanya menambahkan 1.

Masalah Python 2.x yang menarik untuk diingat:

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

Masalahnya adalah bahwa membagi dua int di python menghasilkan int lain dan itu terpotong sebelum panggilan langit-langit. Anda harus membuat satu nilai float (atau cast) untuk mendapatkan hasil yang benar.

Dalam javascript, kode yang sama persis menghasilkan hasil yang berbeda:

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

Jika bekerja dengan bilangan bulat, salah satu cara mengumpulkan adalah dengan mengambil keuntungan dari fakta yang //dibulatkan: Lakukan saja pembagian pada angka negatif, kemudian negasikan jawabannya. Tidak perlu impor, titik apung, atau bersyarat.

rounded_up = -(-numerator // denominator)

Sebagai contoh:

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

Anda mungkin juga suka numpy:

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

Saya tidak mengatakan ini lebih baik daripada matematika, tetapi jika Anda sudah menggunakan numpy untuk tujuan lain, Anda dapat menjaga kode Anda konsisten.

Bagaimanapun, hanya detail yang saya temui. Saya menggunakan banyak numpy dan terkejut itu tidak disebutkan, tetapi tentu saja jawaban yang diterima berfungsi dengan baik.

Gunakanmath.ceil untuk mengumpulkan:

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

CATATAN : Input harus mengambang.

Jika Anda membutuhkan integer, panggil intuntuk mengubahnya:

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

BTW, gunakan math.flooruntuk membulatkan ke bawah dan rounduntuk membulatkan ke bilangan bulat terdekat.

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

Sintaksnya mungkin tidak se pythonic seperti yang mungkin disukai, tetapi ini adalah pustaka yang kuat.

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

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

Saya terkejut tidak ada yang menyarankan

(numerator + denominator - 1) // denominator

untuk divisi integer dengan pembulatan ke atas. Digunakan untuk menjadi cara umum untuk C / C ++ / CUDA (lih. divup)

Jadilah shure rounded value haruslah float

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

tapi

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

Coba ini:

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

Fungsi ini tidak memerlukan modul.

Jawaban di atas benar, namun, mengimpor mathmodul hanya untuk fungsi yang satu ini biasanya terasa sedikit berlebihan bagi saya. Untungnya, ada cara lain untuk melakukannya:

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

Truedan Falseditafsirkan sebagai 1dan 0dalam pernyataan yang melibatkan angka dengan python. g.is_interger()pada dasarnya diterjemahkan ke g.has_no_decimal()atau g == int(g). Jadi pernyataan terakhir dalam bahasa Inggris berbunyiround g down and add one if g has decimal .

Tanpa mengimpor matematika // menggunakan lingkungan dasar:

a) metode / metode kelas

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)

Bagi mereka yang ingin mengumpulkan a / bdan mendapatkan bilangan bulat:

Varian lain yang menggunakan pembagian integer adalah

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

Jika ada orang yang mencari untuk dibulatkan ke tempat desimal tertentu:

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

Saya terkejut saya belum melihat jawaban ini round(x + 0.4999), jadi saya akan meletakkannya. Perhatikan bahwa ini berfungsi dengan versi Python apa pun. Perubahan yang dibuat pada skema pembulatan Python telah membuat hal-hal sulit. Lihat posting ini .

Tanpa mengimpor, saya menggunakan:

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

Kenapa ini bekerja?

Dari dokumen

Untuk jenis bawaan yang mendukung putaran (), nilai dibulatkan ke kelipatan terdekat dari 10 dengan daya minus n; jika dua kelipatan sama-sama dekat, pembulatan dilakukan menuju pilihan genap

Oleh karena itu 2,5 dibulatkan menjadi 2 dan 3,5 dibulatkan menjadi 4. Jika ini tidak terjadi maka pembulatan dapat dilakukan dengan menambahkan 0,5, tetapi kami ingin menghindari sampai ke titik setengah. Jadi, jika Anda menambahkan 0,4999 Anda akan mendekati, tetapi dengan margin yang cukup untuk dibulatkan ke apa yang biasanya Anda harapkan. Tentu saja, ini akan gagal jika x + 0.4999sama dengan [n].5000, tetapi itu tidak mungkin.

Untuk melakukannya tanpa impor:

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

Saya tahu ini dari beberapa waktu yang lalu, tetapi saya menemukan jawaban yang cukup menarik, jadi begini:

-round(-x-0.5)

Ini memperbaiki kasus tepi dan bekerja untuk angka positif dan negatif, dan tidak memerlukan impor fungsi

Bersulang

ketika Anda mengoperasikan 4500/1000 dalam python, hasilnya akan menjadi 4, karena untuk ason python default sebagai bilangan bulat hasilnya, secara logis: 4500/1000 = 4,5 -> int (4.5) = 4 dan ceil of 4 jelaslly adalah 4

menggunakan 4500 / 1000.0 hasilnya akan 4,5 dan langit-langit 4,5 -> 5

Dengan menggunakan javascript, Anda akan menerima 4,5 sebagai hasil dari 4500/1000, karena javascript menganggap hanya hasilnya sebagai "tipe numerik" dan mengembalikan hasilnya secara langsung sebagai float

Semoga berhasil!!

Jika Anda tidak ingin mengimpor apa pun, Anda selalu dapat menulis fungsi sederhana Anda sendiri sebagai:

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

Anda dapat menggunakan lantai devisi dan menambahkan 1 untuknya. 2.3 // 2 + 1

Saya pikir Anda membingungkan mekanisme kerja antara int()dan round().

int()selalu memotong angka desimal jika angka mengambang diberikan; sedangkan round(), dalam hal di 2.5mana 2dan 3keduanya berada dalam jarak yang sama dari 2.5, Python mengembalikan mana yang lebih jauh dari titik 0.

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

Bagian saya

Saya sudah menguji print(-(-101 // 5)) = 21contoh yang diberikan di atas.

Sekarang untuk mengumpulkan:

101 * 19% = 19.19

Saya tidak bisa menggunakan **jadi saya menyebarkan multiply ke divisi:

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

Saya pada dasarnya seorang pemula di Python, tetapi jika Anda hanya mencoba untuk mengumpulkan alih-alih mengapa tidak melakukannya:

round(integer) + 1