Python'da float'ı tamsayıya dönüştürmenin en güvenli yolu?

Python'un matematik modülü floor& gibi kullanışlı fonksiyonlar içerir ceil. Bu işlevler bir kayan nokta sayısı alır ve en yakın tamsayıyı altına veya üstüne döndürür. Ancak bu işlevler cevabı kayan nokta sayısı olarak döndürür. Örneğin:

import math
f=math.floor(2.3)

Şimdi fdöner:

2.0

Yuvarlama hataları riski olmadan (örneğin şamandıra 1.99999'a eşdeğerse) bu şamandıranın tamsayısını almanın en güvenli yolu nedir veya belki de başka bir işlevi tamamen kullanmalıyım?

Kayan nokta sayıları ile temsil edilebilecek tüm tamsayıların tam bir temsili vardır. Böylece intsonuç üzerinde güvenle kullanabilirsiniz . Hatalı gösterimler, yalnızca iki payda olmayan bir payda ile rasyonel bir sayıyı temsil etmeye çalışıyorsanız ortaya çıkar.

Bunun işe yaraması hiç de önemsiz değil! Söz konusu sayıların büyüklüğü yeterince küçükse, IEEE kayan nokta gösteriminin bir özelliğidir, ancak int (kat (2.3)) 1 olabileceği yerlerde farklı gösterimler mümkündür.

Wikipedia'dan alıntı yapmak için ,

Mutlak değeri 2 ^24'e eşit veya daha düşük olan herhangi bir tam sayı, tek duyarlık biçiminde tam olarak temsil edilebilir ve mutlak değeri 2 ^53'e eşit veya daha düşük olan herhangi bir tam sayı , çift duyarlık biçiminde tam olarak temsil edilebilir.

Kullanım int(your non integer number)çivi olacak.

print int(2.3) # "2"
print int(math.sqrt(5)) # "2"

Yuvarlak fonksiyonunu kullanabilirsiniz. İkinci parametre (anlamlı basamak sayısı) kullanmazsanız, istediğiniz davranışı elde edeceğinizi düşünüyorum.

IDLE çıkışı.

>>> round(2.99999999999)
3
>>> round(2.6)
3
>>> round(2.5)
3
>>> round(2.4)
2

Önceki sonuçlardan ikisini birleştirdiğimizde:

int(round(some_float))

Bu, bir şamandırayı oldukça güvenilir bir tam sayıya dönüştürür.

Bunun işe yaraması hiç de önemsiz değil! Söz konusu sayıların büyüklüğü yeterince küçükse, IEEE kayan nokta gösteriminin bir özelliğidir, ancak int (kat (2.3)) 1 olabileceği yerlerde farklı gösterimler mümkündür.

Bu yazı neden bu aralıkta çalıştığını açıklıyor .

Bir çiftte, 32bit tam sayıları sorunsuz olarak temsil edebilirsiniz. Orada olamaz herhangi yuvarlama sorunları olabilir. Daha kesin olarak, çiftler, 2 ⁵³ ve -2 ⁵³ arasındaki ve arasındaki tüm tam sayıları temsil edebilir .

Kısa açıklama : Bir çift 53 adede kadar ikili rakam saklayabilir. Daha fazlasına ihtiyacınız olduğunda, sayı sağda sıfırlarla doldurulur.

53 adetin dolgu olmadan saklanabilecek en büyük sayı olduğu anlaşılmaktadır. Doğal olarak, daha az hane gerektiren tüm (tamsayı) sayılar doğru bir şekilde saklanabilir.

111'e (atlanmış) 111 (53 olanlar) eklenmesi 100 ... 000, (53 sıfır) verir. Bildiğimiz gibi, en sağdaki sıfır dolguyu yapan 53 basamak saklayabiliriz.

2 ⁵³ buradan geliyor.

Daha fazla detay: IEEE-754 kayan noktasının nasıl çalıştığını düşünmemiz gerekir.

  1 bit    11 / 8     52 / 23      # bits double/single precision
[ sign |  exponent | mantissa ]

Daha sonra sayı aşağıdaki gibi hesaplanır (burada alakasız olan özel durumlar hariç):

-1 ^işareti × 1.mantissa × 2 ^{üs - önyargı}

burada yanlılık = 2 ^{üs - 1} - 1 , yani çift / tek kesinlik için sırasıyla 1023 ve 127.

2 ^{X ile} çarpmanın tüm X bitlerini sola kaydırdığını bilerek, herhangi bir tamsayının mantis içinde ondalık noktasının sağına kadar biten tüm bitlere sahip olması gerektiğini görmek kolaydır.

Sıfır dışında herhangi bir tam sayı ikili olarak aşağıdaki forma sahiptir:

1x ... x burada x -es, MSB'nin sağındaki bitleri temsil eder (en önemli bit).

Sıfırı hariç tuttuğumuz için, her zaman bir MSB olacaktır - bu yüzden depolanmaz. Tamsayıyı saklamak için, yukarıda belirtilen forma getirmeliyiz: -1 ^işaretiTamsayıyı × 1.mantissa × 2 ^{üs - sapma} .

Bu, MSB'nin soluna doğru yalnızca MSB olana kadar bitleri ondalık noktaya kaydırmakla aynı şeydir. Ondalık noktasının sağındaki tüm bitler mantis içinde saklanır.

Bundan, MSB dışında en fazla 52 ikili basamak depolayabildiğimizi görebiliriz.

Tüm bitlerin açıkça saklandığı en yüksek sayının

111(omitted)111.   that's 53 ones (52 + implicit 1) in the case of doubles.

Bunun için üssü, ondalık nokta 52 basamak kaydırılacak şekilde ayarlamamız gerekir. Üst üssü bir arttırırsak, ondalık noktadan sonraki sağdaki rakamı bilemeyiz.

111(omitted)111x.

Kural olarak, 0'dır. Tüm mantisin sıfıra ayarlanması, aşağıdaki sayıyı alırız:

100(omitted)00x. = 100(omitted)000.

Bu 1'i takiben 53 sıfır, 52'si depolanmış ve 1'i üs nedeniyle eklenmiştir.

Aralarında tüm tamsayıları doğru bir şekilde temsil edebileceğimiz (hem negatif hem de pozitif) sınırı işaret eden 2 ^53'ü temsil eder. Birini 2 ^53'e eklemek isteseydik , örtük sıfırı (ile gösterilir x) birine ayarlamamız gerekirdi , ama bu imkansız.

math.floorher zaman bir tam sayı döndürür ve böylece int(math.floor(some_float))yuvarlama hataları oluşturmaz.

Yuvarlama hatası math.floor(some_large_float), ilk etapta bir şamandırada çok sayıda saklanırken bile olsa ortaya çıkmış olabilir . (Büyük sayılar şamandıralarda saklandığında hassasiyeti kaybedebilir.)

Bir dize kayan noktasını int'e dönüştürmeniz gerekirse bu yöntemi kullanabilirsiniz.

Örnek: '38.0'-38

Bu bir int dönüştürmek için bir float sonra bir int olarak döküm yapabilirsiniz. Bu ayrıca kayan dizgiler veya tamsayı dizgiler için de çalışır.

>>> int(float('38.0'))
38
>>> int(float('38'))
38

Not : Bu, ondalık basamaktan sonraki tüm sayıları çıkarır.

>>> int(float('38.2'))
38

Değişkenleri kullanarak bir real / float değerini tamsayıya dönüştüren başka bir kod örneği. "vel" gerçek / kayan sayıdır ve bir sonraki en yüksek INTEGER "newvel" e dönüştürülür.

import arcpy.math, os, sys, arcpy.da
.
.
with arcpy.da.SearchCursor(densifybkp,[floseg,vel,Length]) as cursor:
 for row in cursor:
    curvel = float(row[1])
    newvel = int(math.ceil(curvel))

'En güvenli' yolu istediğin için, en iyi cevaptan başka bir cevap daha vereceğim.

Herhangi bir hassasiyeti kaybetmediğinizden emin olmanın kolay bir yolu, değerleri dönüştürdükten sonra değerlerin eşit olup olmadığını kontrol etmektir.

if int(some_value) == some_value:
     some_value = int(some_value)

Eğer şamandıra 1.0 ise, 1.0 1'e eşittir. Bu nedenle int'e dönüşüm gerçekleştirilecektir. Ve şamandıra 1.1 ise, int (1.1) 1 ve 1.1! = 1'e eşittir. Böylece değer bir şamandıra olarak kalır ve herhangi bir hassasiyeti kaybetmezsiniz.

df [ 'Column_Name'] = df [ 'Column_Name']. astype (int)