Python ฟังก์ชัน round() พร้อมตัวอย่าง

⚡ สรุปอย่างชาญฉลาด

Python round() เป็นฟังก์ชันในตัวที่ส่งคืนค่าทศนิยมหรือจำนวนเต็มที่ปัดเศษให้ได้ตามจำนวนทศนิยมที่กำหนด โดยใช้การปัดเศษแบบ Banker's rounding เพื่อตัดสินกรณีที่ค่าทศนิยมเท่ากันโดยเลือกเลขคู่ที่ใกล้ที่สุด

  • 🔘 ไวยากรณ์: ฟังก์ชัน round(number, ndigits) รับค่าที่ต้องการปัดเศษและจำนวนหลักที่ระบุ (ซึ่งค่าเริ่มต้นคือศูนย์)
  • ☑️ ประเภทการส่งคืน: หากไม่ระบุจำนวนหลัก (ndigits) จะส่งคืนค่าจำนวนเต็ม ในขณะที่หากระบุจำนวนหลัก จะส่งคืนค่าทศนิยม
  • การปัดเศษแบบนายธนาคาร: ค่ากึ่งกลางจะปัดเศษเป็นจำนวนคู่ที่ใกล้ที่สุด ดังนั้น round(2.5) จะคืนค่า 2
  • 🧪 ตัวเลขติดลบ: การปัดเศษใช้กับตัวเลขติดลบด้วย โดยปัด -2.8 เป็น -3 และ -1.5 เป็น -2
  • 🛠️ เครื่องมือความแม่นยำ: โมดูล decimal และฟังก์ชัน round() ของ NumPy จัดการการปัดเศษแบบความแม่นยำคงที่และการปัดเศษอาร์เรย์
  • 🤖 เวิร์กโฟลว์ AI: โค้ดการเรียนรู้ของเครื่องจะปัดเศษค่าเมตริก ความน่าจะเป็น และน้ำหนัก เพื่อให้การบันทึกและการรายงานมีความถูกต้องแม่นยำยิ่งขึ้น

Python ฟังก์ชันรอบ ()

ฟังก์ชัน round() คืออะไรใน Python?

Python round() เป็นฟังก์ชันในตัวที่มีให้ใช้งาน Pythonฟังก์ชันนี้จะส่งคืนค่าตัวเลขทศนิยมที่ปัดเศษตามจำนวนตำแหน่งทศนิยมที่ป้อนเข้ามา

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

วากยสัมพันธ์

round(float_num, num_of_decimals)

พารามิเตอร์

  • เลขทศนิยม: ตัวเลขทศนิยมที่จะปัดเศษ
  • จำนวนทศนิยม: (ตัวเลือกเสริม) จำนวนทศนิยมที่จะนำมาพิจารณาในการปัดเศษ ค่านี้เป็นตัวเลือก หากไม่ระบุ จะใช้ค่าเริ่มต้นเป็น 0 และการปัดเศษจะทำไปยังจำนวนเต็มที่ใกล้เคียงที่สุด

Descriptไอออน

เมธอด round() รับอาร์กิวเมนต์สองตัว:

  • ตัวเลขที่จะปัดเศษ และ
  • ตำแหน่งทศนิยมที่ควรพิจารณาขณะปัดเศษ

อาร์กิวเมนต์ตัวที่สองเป็นตัวเลือก และค่าเริ่มต้นจะเป็น 0 หากไม่ได้ระบุ ในกรณีดังกล่าว ระบบจะปัดเศษเป็นจำนวนเต็มที่ใกล้ที่สุด และประเภทค่าที่ส่งคืนจะเป็นจำนวนเต็มเช่นกัน

เมื่อมีตำแหน่งทศนิยม เช่น อาร์กิวเมนต์ที่สอง ก็จะปัดเศษตามจำนวนตำแหน่งที่กำหนด ประเภทการส่งคืนจะเป็นแบบทศนิยม

ถ้าตัวเลขหลังจุดทศนิยมที่ให้มาคือ:

  • ถ้าค่ามากกว่าหรือเท่ากับ 5 ค่าสุดท้ายจะถูกบวกเพิ่มอีก 1
  • ถ้า < 5 ค่าสุดท้ายจะถูกส่งคืนตามเดิม โดยรวมถึงทศนิยมตามที่ระบุไว้ด้วย

ส่งคืนค่า

ฟังก์ชันนี้จะคืนค่าจำนวนเต็มหากไม่ได้ระบุจำนวนทศนิยม และคืนค่าจำนวนทศนิยมหากระบุจำนวนทศนิยม โปรดทราบว่าค่าจะถูกปัดเศษขึ้น +1 หากค่าหลังจุดทศนิยมมากกว่าหรือเท่ากับ 5 มิฉะนั้นจะส่งคืนค่าตามเดิมจนถึงจำนวนทศนิยมที่ระบุไว้

การปัดเศษสามารถมีผลกระทบได้มากเพียงใด? (การปัดเศษเทียบกับการตัดทอน)

ตัวอย่างที่ดีที่สุดที่จะแสดงให้เห็นถึงผลกระทบของการปัดเศษคือตลาดหลักทรัพย์ ในอดีต กล่าวคือในปี 1982 ตลาดหลักทรัพย์แวนคูเวอร์ (VSE) เคยตัดทอนมูลค่าหุ้นให้เหลือเพียงสามตำแหน่งทศนิยมในทุกการซื้อขาย

กระบวนการนี้เกิดขึ้นเกือบ 3000 ครั้งต่อวัน การตัดทอนที่สะสมมาส่งผลให้สูญเสียคะแนนประมาณ 25 คะแนนต่อเดือน

ตัวอย่างของการตัดทอนค่าเทียบกับการปัดเศษแสดงไว้ด้านล่าง

ลองพิจารณาตัวเลขทศนิยมที่สร้างขึ้นด้านล่างนี้เป็นมูลค่าหุ้น ในขณะนี้ ฉันกำลังสร้างตัวเลขเหล่านี้สำหรับช่วงเวลา 1,000,000 วินาที ระหว่าง 0.01 ถึง 0.05

ตัวอย่าง:

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]

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

ฉันมีค่ารวมเดิม ค่ารวมที่ได้จากค่าที่ถูกตัดทอน และผลต่างระหว่างค่าเดิมกับค่าที่ถูกตัดทอน

ในชุดตัวเลขเดียวกัน ฉันได้ใช้เมธอด round() โดยปัดเศษทศนิยมสูงสุด 3 ตำแหน่ง และคำนวณผลรวมและผลต่างระหว่างค่าเดิมกับค่าที่ปัดเศษแล้ว

นี่คือตัวอย่างและผลลัพธ์

1 ตัวอย่าง

import random

def truncate(num):
    return int(num * 1000) / 1000

arr = [random.uniform(0.01, 0.05) for _ in range(1000000)]
sum_num = 0
sum_truncate = 0
for i in arr:
    sum_num = sum_num + i  
    sum_truncate = truncate(sum_truncate + i)
  
print("Testing by using truncating upto 3 decimal places")
print("The original sum is = ", sum_num)
print("The total using truncate = ", sum_truncate)
print("The difference from original - truncate = ", sum_num - sum_truncate)

print("\n\n")
print("Testing by using round() upto 3 decimal places")
sum_num1 = 0
sum_truncate1 = 0
for i in arr:
    sum_num1 = sum_num1 + i  
    sum_truncate1 = round(sum_truncate1 + i, 3)

print("The original sum is =", sum_num1)
print("The total using round = ", sum_truncate1)
print("The difference from original - round =", sum_num1 - sum_truncate1)

Output:

Testing by using truncating upto 3 decimal places
The original sum is =  29985.958619386867
The total using truncate =  29486.057
The difference from original - truncate =  499.9016193868665

Testing by using round() up to 3 decimal places
The original sum is = 29985.958619386867
The total using round =  29985.912
The difference from original - round = 0.04661938686695066

ความแตกต่างระหว่างค่าเดิมและค่าที่ถูกตัดทอนคือ 499.9016193868665 และจากฟังก์ชัน round() คือ 0.04661938686695066

ความแตกต่างดูเหมือนจะมาก และตัวอย่างแสดงให้เห็นว่าเมธอด round() ช่วยในการคำนวณให้ได้ความแม่นยำใกล้เคียงแค่ไหน

ตัวอย่าง: การปัดเศษทศนิยม Numbers

ในโปรแกรมนี้ เราจะมาดูวิธีการปัดเศษตัวเลขทศนิยมกัน

# testing round()

float_num1 = 10.60 # here the value will be rounded to 11 as after the decimal point the number is 6 that is >5

float_num2 = 10.40 # here the value will be rounded to 10 as after the decimal point the number is 4 that is <=5

float_num3 = 10.3456 # here the value will be 10.35 as after the 2 decimal points the value >=5

float_num4 = 10.3445 #here the value will be 10.34 as after the 2 decimal points the value is <5

print("The rounded value without num_of_decimals is :", round(float_num1))
print("The rounded value without num_of_decimals is :", round(float_num2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num3, 2))
print("The rounded value with num_of_decimals as 2 is :", round(float_num4, 2))

Output:

The rounded value without num_of_decimals is : 11
The rounded value without num_of_decimals is : 10
The rounded value with num_of_decimals as 2 is : 10.35
The rounded value with num_of_decimals as 2 is : 10.34

ตัวอย่าง: การปัดเศษค่าจำนวนเต็ม

หากคุณบังเอิญใช้ round() กับค่าจำนวนเต็ม มันจะคืนค่าตัวเลขนั้นกลับมาโดยไม่มีการเปลี่ยนแปลงใดๆ

# testing round() on a integer

num = 15

print("The output is", round(num))

Output:

The output is 15

ตัวอย่าง: การปัดเศษเป็นค่าลบ Numbers

เรามาดูตัวอย่างการปัดเศษกับจำนวนลบกันสักเล็กน้อย

# testing round()

num = -2.8
num1 = -1.5
print("The value after rounding is", round(num))
print("The value after rounding is", round(num1))

Output:

C:\pythontest>python testround.py
The value after rounding is -3
The value after rounding is -2

ตัวอย่าง: ปัดเศษอาร์เรย์ NumPy

คุณปัดเศษ NumPy อย่างไร อาร์เรย์ใน Python?

เพื่อแก้ไขปัญหานี้ เราสามารถใช้โมดูล NumPy และใช้เมธอด numpy.round() หรือ numpy.around() ดังตัวอย่างด้านล่าง

ใช้ numpy.round()

# testing round()
import numpy as np

arr = [-0.341111, 1.455098989, 4.232323, -0.3432326, 7.626632, 5.122323]

arr1 = np.round(arr, 2)

print(arr1)

Output:

C:\pythontest>python testround.py
[-0.34  1.46  4.23 -0.34  7.63  5.12]

เราสามารถใช้ numpy.around() ได้เช่นกัน ซึ่งจะให้ผลลัพธ์เหมือนกับ numpy.round() ที่แสดงไว้ข้างต้น

ตัวอย่าง: โมดูลทศนิยม

นอกเหนือจากฟังก์ชัน round() แล้ว Python มีโมดูลทศนิยมที่ช่วยในการจัดการตัวเลขทศนิยมได้อย่างแม่นยำยิ่งขึ้น

โมดูล Decimal มีประเภทการปัดเศษให้เลือกใช้ ดังแสดงด้านล่าง:

  • เพดานโค้ง: มันจะปัดเข้าหาค่าอนันต์
  • ปัดลง: ระบบจะปัดค่าให้เข้าใกล้ศูนย์
  • พื้นกลม: มันจะปัดเข้าหาค่าลบอนันต์
  • ปัดเศษลงครึ่งหนึ่ง: ระบบจะปัดเศษไปยังค่าที่ใกล้เคียงที่สุดโดยมีค่าเข้าใกล้ศูนย์
  • รอบครึ่งคู่: ระบบจะปัดเศษให้เป็นค่าที่ใกล้เคียงที่สุด โดยปัดขึ้นเป็นจำนวนเต็มคู่ที่ใกล้ที่สุด
  • ปัดเศษขึ้นครึ่งหนึ่ง: ระบบจะปัดเศษไปยังค่าที่ใกล้เคียงที่สุดที่ห่างจากศูนย์
  • รวบรวม: ระบบจะปัดเศษค่าให้ห่างจากศูนย์

ในรูปแบบทศนิยม เมธอด quantize() จะช่วยปัดเศษเป็นจำนวนตำแหน่งทศนิยมคงที่ และคุณสามารถระบุการปัดเศษที่จะใช้ได้ ดังที่แสดงในตัวอย่างด้านล่าง

ตัวอย่าง: การใช้วิธีปัดเศษ () และทศนิยม

import  decimal
round_num = 15.456

final_val = round(round_num, 2)

#Using decimal module
final_val1 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_CEILING)
final_val2 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_DOWN)
final_val3 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_FLOOR)
final_val4 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_DOWN)
final_val5 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_EVEN)
final_val6 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_HALF_UP)
final_val7 = decimal.Decimal(round_num).quantize(decimal.Decimal('0.00'), rounding=decimal.ROUND_UP)

print("Using round()", final_val)
print("Using Decimal - ROUND_CEILING ",final_val1)
print("Using Decimal - ROUND_DOWN ",final_val2)
print("Using Decimal - ROUND_FLOOR ",final_val3)
print("Using Decimal - ROUND_HALF_DOWN ",final_val4)
print("Using Decimal - ROUND_HALF_EVEN ",final_val5)
print("Using Decimal - ROUND_HALF_UP ",final_val6)
print("Using Decimal - ROUND_UP ",final_val7)

Output:

Using round() 15.46
Using Decimal - ROUND_CEILING  15.46
Using Decimal - ROUND_DOWN  15.45
Using Decimal - ROUND_FLOOR  15.45
Using Decimal - ROUND_HALF_DOWN  15.46
Using Decimal - ROUND_HALF_EVEN  15.46
Using Decimal - ROUND_HALF_UP  15.46
Using Decimal - ROUND_UP  15.46

คำถามที่พบบ่อย

ลำดับ Python 3 ใช้การปัดเศษครึ่งเพื่อให้เท่ากัน (การปัดเศษแบบธนาคาร) สำหรับกรณีที่เสมอกัน ดังนั้น round(0.5) จะเป็น 0, round(2.5) จะเป็น 2 และ round(3.5) จะเป็น 4 วิธีนี้ช่วยลดอคติสะสม

เนื่องจาก 2.675 ไม่สามารถจัดเก็บในรูปแบบเลขฐานสองแบบทศลอยได้อย่างแม่นยำ ค่าที่ได้จริงจะอยู่ที่ประมาณ 2.6749999999999998 ดังนั้นฟังก์ชัน round() จะปัดลง หากต้องการผลลัพธ์ที่แม่นยำ ให้ใช้ decimal.Decimal('2.675')

ใช้โมดูล math: math.ceil(x) จะปัดขึ้นเสมอ math.floor(x) จะปัดลงเสมอ และ int(x) จะตัดทศนิยมที่ศูนย์ออก ฟังก์ชัน round() เองไม่สามารถบังคับทิศทางการปัดได้

ส่งค่าลบเป็นอาร์กิวเมนต์ตัวที่สอง: round(12345, -1) จะได้ 12340, round(12345, -2) จะได้ 12300 และ round(12345, -3) จะได้ 12000 ค่า ndigits ติดลบจะปัดเศษไปทางซ้ายของจุดทศนิยม

ฟังก์ชัน round(x, 2) จะเปลี่ยนค่าที่ใช้ในการคำนวณทางคณิตศาสตร์ในภายหลัง ในขณะที่ f'{x:.2f}' จะจัดรูปแบบการแสดงผลเท่านั้นและคงค่าตัวเลขไว้เหมือนเดิม ควรใช้ round() สำหรับการคำนวณ และใช้ f-strings สำหรับการแสดงผล

ลำดับ Numbers เป็นค่าที่ไม่สามารถเปลี่ยนแปลงได้ ดังนั้นฟังก์ชัน round() จะส่งคืนค่าใหม่โดยไม่เปลี่ยนแปลงค่าที่ป้อนเข้ามา ตัวอย่างเช่น กำหนดค่าให้กับตัวแปร result = round(3.14159, 2); ตัวแปรเดิมจะยังคงความแม่นยำเต็มที่

โค้ดการเรียนรู้ของเครื่องจะปัดเศษค่าความแม่นยำ ค่าความสูญเสีย และความน่าจะเป็น เพื่อให้อ่านง่ายในบันทึก และเพื่อจับคู่การคาดการณ์กับป้ายกำกับคลาส รักษาความแม่นยำเต็มที่สำหรับการคำนวณอนุพันธ์ และปัดเศษเฉพาะค่าเมตริกที่แสดงผลสุดท้ายเท่านั้น

ใช่แล้ว ผู้ช่วย AI เช่น GitHub Copilot จะเติมข้อความอัตโนมัติสำหรับ round(), np.round() และการปัดเศษทศนิยมจากความคิดเห็นหรือชื่อฟังก์ชัน และเครื่องมือของเอเจนต์จะแปลงการจัดรูปแบบด้วยตนเองให้เป็นการเรียกใช้ round() แม้ว่าความแม่นยำที่เลือกยังคงต้องได้รับการตรวจสอบอยู่ก็ตาม

สรุปโพสต์นี้ด้วย: