วิธีที่ปลอดภัยที่สุดในการแปลง float เป็นจำนวนเต็มในไพ ธ อน?

โมดูลคณิตศาสตร์ ธ ประกอบด้วยฟังก์ชั่นที่มีประโยชน์เช่น&floor ceilฟังก์ชั่นเหล่านี้ใช้จำนวนจุดลอยตัวและส่งกลับจำนวนเต็มที่ใกล้เคียงที่สุดหรือต่ำกว่านั้น อย่างไรก็ตามฟังก์ชั่นเหล่านี้คืนคำตอบเป็นจำนวนจุดลอยตัว ตัวอย่างเช่น:

import math
f=math.floor(2.3)

ตอนนี้fผลตอบแทน:

2.0

วิธีที่ปลอดภัยที่สุดในการดึงจำนวนเต็มออกจาก float นี้โดยไม่เสี่ยงต่อการปัดเศษข้อผิดพลาด (ตัวอย่างเช่นถ้า float เท่ากับ 1.99999) หรือบางทีฉันควรใช้ฟังก์ชันอื่นโดยสิ้นเชิง?

จำนวนเต็มทั้งหมดที่สามารถแทนด้วยจำนวนจุดลอยตัวมีการแสดงที่แน่นอน ดังนั้นคุณสามารถใช้อย่างปลอดภัยintกับผลลัพธ์การเป็นตัวแทนที่ไม่แน่นอนจะเกิดขึ้นเฉพาะในกรณีที่คุณพยายามแสดงจำนวนตรรกยะด้วยตัวส่วนที่ไม่ได้เป็นกำลังสอง

ว่างานนี้ไม่สำคัญเลย! มันเป็นคุณสมบัติของการเป็นตัวแทนจุดลอยตัวของ IEEE ที่ int =floor = ⌊⋅⌋หากขนาดของตัวเลขที่เป็นปัญหานั้นมีขนาดเล็กพอ แต่การแสดงที่ต่างกันนั้นเป็นไปได้โดยที่ int (floor (2.3)) อาจเป็น 1

การอ้างอิงจากวิกิพีเดีย ,

จำนวนเต็มใด ๆ ที่มีค่าสัมบูรณ์น้อยกว่าหรือเท่ากับ 2 ²⁴สามารถแสดงได้อย่างแม่นยำในรูปแบบความแม่นยำเดียวและจำนวนเต็มใด ๆ ที่มีค่าสัมบูรณ์น้อยกว่าหรือเท่ากับ 2 ⁵³สามารถแสดงได้อย่างแม่นยำในรูปแบบความแม่นยำสองเท่า

int(your non integer number)จะใช้เล็บมัน

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

คุณสามารถใช้ฟังก์ชั่นรอบ หากคุณใช้พารามิเตอร์ที่สอง (# ของตัวเลขที่สำคัญ) ฉันคิดว่าคุณจะได้รับพฤติกรรมที่คุณต้องการ

เอาต์พุต IDLE

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

เมื่อรวมผลลัพธ์สองรายการก่อนหน้าเข้าด้วยกันเรามี:

int(round(some_float))

สิ่งนี้จะแปลงทศนิยมเป็นจำนวนเต็มอย่างน่าเชื่อถือ

ว่างานนี้ไม่สำคัญเลย! มันเป็นคุณสมบัติของการเป็นตัวแทนจุดลอยตัวของ IEEE ที่ int =floor = ⌊⋅⌋หากขนาดของตัวเลขที่เป็นปัญหานั้นมีขนาดเล็กพอ แต่การแสดงที่ต่างกันนั้นเป็นไปได้โดยที่ int (floor (2.3)) อาจเป็น 1

โพสต์นี้จะอธิบายว่าเพราะเหตุใดจึงใช้งานได้ในช่วงนั้น

ใน double คุณสามารถแทนจำนวนเต็ม 32 บิตได้โดยไม่มีปัญหา มีไม่สามารถจะมีปัญหาการปัดเศษใด ๆ แม่นยำยิ่งขึ้นเป็นสองเท่าสามารถเป็นตัวแทนของจำนวนเต็มทั้งหมดระหว่างและรวมถึง2 ⁵³และ-2 ⁵³ 53

คำอธิบายสั้น ๆ : Double สามารถเก็บได้ถึง 53 หลักไบนารี เมื่อคุณต้องการมากกว่าหมายเลขจะถูกเติมด้วยเลขศูนย์ทางด้านขวา

ตามมาว่า 53 รายการเป็นหมายเลขที่ใหญ่ที่สุดที่สามารถจัดเก็บได้โดยไม่ต้องแพ็ดดิง โดยปกติแล้วตัวเลข (จำนวนเต็ม) ทั้งหมดที่ต้องการตัวเลขน้อยกว่าสามารถจัดเก็บได้อย่างถูกต้อง

เพิ่มหนึ่งถึง111 (ละเว้น) 111 (53 รายการ) ให้ผลตอบแทน 100 ... 000, (53 ศูนย์) อย่างที่เราทราบเราสามารถเก็บ 53 หลักซึ่งทำให้การเติมเต็มเป็นศูนย์ที่ถูกต้องที่สุด

นี่คือที่ 2 ⁵³มาจาก

รายละเอียดเพิ่มเติม:เราต้องพิจารณาว่าจุดลอยตัวของ IEEE-754 ทำงานอย่างไร

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

จากนั้นคำนวณจำนวนดังนี้ (ยกเว้นกรณีพิเศษที่ไม่เกี่ยวข้องที่นี่):

-1 ^sign × 1.mantissa × 2 ^{exponent - bias}

โดยที่bias = 2 ^{เลขชี้กำลัง - 1} - 1คือ 1023 และ 127 สำหรับความแม่นยำสองเท่า / เดี่ยว

เมื่อรู้ว่าการคูณด้วย2 ^Xจะเลื่อนบิตXทั้งหมดไปทางซ้ายมันเป็นเรื่องง่ายที่จะเห็นว่าจำนวนเต็มใด ๆ จะต้องมีบิตทั้งหมดในแมนทิสซาที่จบลงทางขวาของจุดทศนิยมเป็นศูนย์

จำนวนเต็มใด ๆ ยกเว้นศูนย์มีรูปแบบต่อไปนี้ในไบนารี:

1x ... xโดยที่x- e แทนบิตทางด้านขวาของ MSB (บิตที่สำคัญที่สุด)

เพราะเราได้รับการยกเว้นศูนย์จะมีเสมอจะ MSB ที่เป็นหนึ่งซึ่งเป็นเหตุผลที่มันไม่ได้เก็บไว้ ในการจัดเก็บจำนวนเต็มที่เราจะต้องนำมาไว้ในรูปแบบดังกล่าวข้างต้น: -1 ^{ลงชื่อ} × 1.mantissa × 2 ^{ยกกำลัง -} อคติ

นั่นคือการพูดเช่นเดียวกับการเลื่อนบิตไปที่จุดทศนิยมจนกว่าจะมีเพียง MSB ทางด้านซ้ายของ MSB บิตทั้งหมดที่ถูกต้องของจุดทศนิยมจะถูกเก็บไว้ในแมนทิสซา

จากนี้เราจะเห็นได้ว่าเราสามารถเก็บได้มากที่สุด 52 หลักไบนารีนอกเหนือจาก MSB

ตามด้วยจำนวนสูงสุดที่มีการจัดเก็บบิตทั้งหมดไว้อย่างชัดเจน

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

สำหรับสิ่งนี้เราต้องตั้งค่าเลขชี้กำลังเพื่อให้จุดทศนิยมเปลี่ยนตำแหน่ง 52 ตำแหน่ง ถ้าเราต้องเพิ่มเลขชี้กำลังหนึ่งเราไม่สามารถรู้หลักขวาไปทางซ้ายหลังจากจุดทศนิยม

111(omitted)111x.

ตามแบบแผนคือ 0 ตั้งค่า mantissa ทั้งหมดเป็นศูนย์เราได้รับหมายเลขต่อไปนี้:

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

นั่นคือ 1 ตามด้วย 53 ศูนย์, 52 ที่เก็บไว้และ 1 เพิ่มเนื่องจากเลขชี้กำลัง

มันหมายถึง2 ⁵³ซึ่งทำเครื่องหมายขอบเขต (ทั้งลบและบวก) ระหว่างที่เราสามารถเป็นตัวแทนของจำนวนเต็มทั้งหมดได้อย่างถูกต้อง หากเราต้องการเพิ่มหนึ่งถึง2 ⁵³เราจะต้องตั้งค่าศูนย์โดยนัย (แสดงโดยx) เป็นหนึ่ง แต่นั่นเป็นไปไม่ได้

math.floorจะส่งกลับตัวเลขจำนวนเต็มเสมอและดังนั้นint(math.floor(some_float))จะไม่แนะนำข้อผิดพลาดในการปัดเศษ

ข้อผิดพลาดในการปัดเศษอาจถูกนำมาใช้ในmath.floor(some_large_float)แม้ว่าหรือแม้กระทั่งเมื่อเก็บจำนวนมากในการลอยในสถานที่แรก (ตัวเลขจำนวนมากอาจสูญเสียความแม่นยำเมื่อเก็บไว้ในโฟลต)

หากคุณต้องการแปลงสตริงลอยให้เป็น int คุณสามารถใช้วิธีนี้

ตัวอย่าง: '38.0'ถึง38

ในการแปลงค่านี้เป็น int คุณสามารถร่ายมันเป็นทุ่นและ int สิ่งนี้จะทำงานสำหรับสตริงลอยหรือสตริงจำนวนเต็ม

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

หมายเหตุ : สิ่งนี้จะตัดจำนวนใด ๆ หลังจุดทศนิยม

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

ตัวอย่างโค้ดอื่นเพื่อแปลงค่าจริง / จำนวนเต็มเป็นจำนวนเต็มโดยใช้ตัวแปร "vel" เป็นจำนวนจริง / จำนวนลอยตัวและแปลงเป็น INTEGER ที่สูงที่สุดถัดไป "newvel"

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

เมื่อคุณขอวิธีที่ 'ปลอดภัยที่สุด' ฉันจะให้คำตอบอื่นที่ไม่ใช่คำตอบยอดนิยม

วิธีง่ายๆในการตรวจสอบให้แน่ใจว่าคุณไม่สูญเสียความแม่นยำใด ๆ คือการตรวจสอบว่าค่าจะเท่ากันหลังจากที่คุณแปลงค่าเหล่านั้น

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

ถ้า float เป็น 1.0 เช่น 1.0 เท่ากับ 1 ดังนั้นการแปลงเป็น int จะทำงาน และถ้าลอยเป็น 1.1, int (1.1) เท่ากับ 1 และ 1.1! = 1 ดังนั้นค่าจะยังคงลอยและคุณจะไม่สูญเสียความแม่นยำใด ๆ

DF [ 'คอลัมน์'] = DF [ 'คอลัมน์']. astype (int)