search

Hướng dẫn round() function python - hàm round () python

Ngày đăng: 31/10/2022
Trả lời: 0
Lượt xem: 16

Hàm round() trong Python làm tròn x về n chữ số sau dấu thập phân. Python làm tròn theo cách sau: round(0.5) là 1.0 và round(-0.5) là -1.0round() trong Python làm tròn x về n chữ số sau dấu thập phân. Python làm tròn theo cách sau: round(0.5) là 1.0 và round(-0.5) là -1.0

Show

Nội dung chính ShowShow

  • Cú pháp hàm round() trong Python:
  • Các tham số của hàm round()
  • Giá trị trả về từ round()
  • Ví dụ 1: round() hoạt động như thế nào?
  • Ví dụ 2: Làm tròn số đến vị trí ndigits đã cho
  • Đăng nhập
  • Python’s Built-in round() Function
  • How Much Impact Can Rounding Have?
  • A Menagerie of Methods
  • Rounding Up
  • Rounding Down
  • Interlude: Rounding Bias
  • Rounding Half Up
  • Rounding Half Down
  • Rounding Half Away From Zero
  • Rounding Half To Even
  • The Decimal Class
  • Rounding NumPy Arrays
  • Rounding Pandas Series and DataFrame
  • Applications and Best Practices
  • Store More and Round Late
  • Obey Local Currency Regulations
  • When In Doubt, Round Ties To Even
  • Additional Resources

Cú pháp

Cú pháp của round() trong Python:round() trong Python:

Các tham số:

  • x: Đây là một biểu thức số.: Đây là một biểu thức số.

  • n: Đây cũng là một biểu thức số.: Đây cũng là một biểu thức số.

Ví dụ sau minh họa cách sử dụng của hàm round() trong Python.

print ("round(50.25556, 2) : ", round(50.25556, 2)) print ("round(10.000056, 3) : ", round(10.000056, 3)) print ("round(-10.000056, 3) : ", round(-10.000056, 3))

Chạy chương trình Python trên sẽ cho kết quả:

round(50.25556, 2) : 50.26 round(10.000056, 3) : 10.0 round(-10.000056, 3) : -10.0

Tiếp tục với chủ đề các hàm tích hợp sẵn trong Python, bài viết sẽ giới thiệu cho các bạn về hàm round() với cú pháp, cách sử dụng cũng như các ví dụ cụ thể. Mời bạn đọc theo dõi.

Nội dung chính

  • Cú pháp hàm round() trong Python:
  • Các tham số của hàm round()
  • Giá trị trả về từ round()
  • Ví dụ 1: round() hoạt động như thế nào?
  • Ví dụ 2: Làm tròn số đến vị trí ndigits đã cho
  • Đăng nhập
  • Python’s Built-in round() Function
  • How Much Impact Can Rounding Have?
  • A Menagerie of Methods
  • Rounding Up
  • Rounding Down
  • Interlude: Rounding Bias
  • Rounding Half Up
  • Rounding Half Down
  • Rounding Half Away From Zero
  • Rounding Half To Even
  • The Decimal Class
  • Rounding NumPy Arrays
  • Rounding Pandas Series and DataFrame
  • Applications and Best Practices
  • Store More and Round Late
  • Obey Local Currency Regulations
  • When In Doubt, Round Ties To Even
  • Additional Resources

Cú pháp trong Python làm tròn một số cho trước, trả về số đó dưới dạng số dấu phẩy động, có số chữ số sau dấu phẩy được chỉ định. Số sau dấu phẩy mặc định là 0, nghĩa là hàm sẽ trả về số nguyên gần nhất.

Cú pháp hàm round() trong Python:

round(number[, ndigits])

Các tham số của hàm round()

Cú pháp của round() trong Python:

  • Các tham số:
  • x: Đây là một biểu thức số.

Giá trị trả về từ round()

  • n: Đây cũng là một biểu thức số.
  • Ví dụ sau minh họa cách sử dụng của hàm round() trong Python.

Ví dụ 1: round() hoạt động như thế nào?

print ("round(50.25556, 2) : ", round(50.25556, 2)) print ("round(10.000056, 3) : ", round(10.000056, 3)) print ("round(-10.000056, 3) : ", round(-10.000056, 3)) 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))

Chạy chương trình Python trên sẽ cho kết quả:

10
11
6
5
7
0
1

Ví dụ 2: Làm tròn số đến vị trí ndigits đã cho

round(50.25556, 2) : 50.26 round(10.000056, 3) : 10.0 round(-10.000056, 3) : -10.0 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))

Chạy chương trình Python trên sẽ cho kết quả:

2.67
50.26
100.0
80.23
122.145

Đăng nhập

round(50.25556, 2) : 50.26 round(10.000056, 3) : 10.0 round(-10.000056, 3) : -10.0

Nội dung chính

  • Python’s Built-in round() Function
  • How Much Impact Can Rounding Have?
  • A Menagerie of Methods
  • Rounding Up
  • Rounding Down
  • Interlude: Rounding Bias
  • Rounding Half Up
  • Rounding Half Down
  • Rounding Half Away From Zero
  • Rounding Half To Even
  • The Decimal Class
  • Rounding NumPy Arrays
  • Rounding Pandas Series and DataFrame
  • Applications and Best Practices
  • Store More and Round Late
  • Obey Local Currency Regulations
  • When In Doubt, Round Ties To Even
  • Additional Resources

Cú pháp

Cú pháp của round() trong Python:

Các tham số:

  • x: Đây là một biểu thức số.
  • n: Đây cũng là một biểu thức số.
  • Ví dụ sau minh họa cách sử dụng của hàm round() trong Python.
  • print ("round(50.25556, 2) : ", round(50.25556, 2)) print ("round(10.000056, 3) : ", round(10.000056, 3)) print ("round(-10.000056, 3) : ", round(-10.000056, 3))
  • Chạy chương trình Python trên sẽ cho kết quả:

Bài viết này không phải là một chuyên luận về độ chính xác số trong điện toán, mặc dù chúng tôi sẽ liên lạc ngắn gọn về chủ đề này. Chỉ có sự quen thuộc với các nguyên tắc cơ bản của Python là cần thiết, và toán học liên quan ở đây sẽ cảm thấy thoải mái cho bất kỳ ai quen thuộc với tương đương với đại số trung học.

Hãy bắt đầu bằng cách nhìn vào cơ chế làm tròn tích hợp Python.

Chức năng vòng () Python tích hợp ()

Python có hàm 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp có hai đối số số, 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 và 
>>> actual_value, truncated_value = 100, 100
9 và trả về số 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được làm tròn thành 
>>> actual_value, truncated_value = 100, 100
9. Đối số 
>>> actual_value, truncated_value = 100, 100
9 mặc định là 0, do đó, để lại kết quả trong một số được làm tròn cho một số nguyên. Như bạn thấy, 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 có thể không hoạt động như bạn mong đợi.

Cách mà hầu hết mọi người được dạy để làm tròn một số đi một cái gì đó như thế này:

Làm tròn số 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 đến 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
1 Các vị trí thập phân bằng cách lần đầu tiên chuyển điểm thập phân trong 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 với các vị trí 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
1 bằng cách nhân 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 với 10ᵖ (10 được nâng lên công suất 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
1) để có được số mới 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
6.

Sau đó nhìn vào chữ số 

>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
7 ở vị trí thập phân đầu tiên của 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
6. Nếu 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
7 nhỏ hơn 5, vòng 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
6 xuống số nguyên gần nhất. Nếu không, vòng 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
6 lên.

Cuối cùng, thay đổi điểm thập phân trở lại 

>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
1 vị trí bằng cách chia 
>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258
6 cho 10ᵖ.

Nó là một thuật toán đơn giản! Ví dụ: số 

def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier
4 được làm tròn đến số toàn bộ gần nhất là 
def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier
5. Số 
def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier
6 được làm tròn đến một vị trí thập phân là 
def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier
7.

Bây giờ hãy mở một phiên thông dịch viên và vòng 

def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier
4 cho toàn bộ số gần nhất bằng cách sử dụng chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp của Python,: Chức năng:

Gasp!

Làm thế nào để 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 xử lý số 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
01?

Vì vậy, 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 vòng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
01 lên đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04 và 
def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier
4 xuống 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04!

Trước khi bạn đưa ra một vấn đề trên trình theo dõi lỗi Python, hãy để tôi đảm bảo với bạn rằng 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
07 được cho là sẽ trả lại 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04. Có một lý do chính đáng tại sao 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 hành xử theo cách nó làm.

Trong bài viết này, bạn sẽ học được rằng có nhiều cách để làm tròn một con số hơn bạn có thể mong đợi, mỗi cách có những ưu điểm và nhược điểm độc đáo. 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 hành xử theo một chiến lược làm tròn cụ thể mà có thể hoặc không phải là một trong những tình huống bạn cần cho một tình huống nhất định.

Bạn có thể tự hỏi, có thể cách mà tôi có thể có những con số thực sự có nhiều tác động? Hãy cùng xem xét về việc các tác động của làm tròn có thể đến mức nào.

Bao nhiêu tác động có thể làm tròn có?

Giả sử bạn có một ngày vô cùng may mắn và tìm thấy 100 đô la trên mặt đất. Thay vì chi tiêu tất cả tiền của bạn cùng một lúc, bạn quyết định chơi thông minh và đầu tư tiền của bạn bằng cách mua một số cổ phiếu của các cổ phiếu khác nhau.

Giá trị của một cổ phiếu phụ thuộc vào cung và cầu. Càng nhiều người muốn mua một cổ phiếu, càng có nhiều giá trị mà cổ phiếu có và ngược lại. Trong thị trường chứng khoán khối lượng lớn, giá trị của một cổ phiếu cụ thể có thể dao động trên cơ sở thứ hai.

Hãy để chạy một thí nghiệm nhỏ. Chúng tôi sẽ giả vờ giá trị tổng thể của các cổ phiếu bạn đã mua dao động theo một số ngẫu nhiên nhỏ mỗi giây, giả sử từ 0,05 đến -0,05 đô la. Biến động này có thể không nhất thiết là một giá trị tốt đẹp chỉ với hai vị trí thập phân. Ví dụ: giá trị tổng thể có thể tăng thêm 0,031286 một giây và giảm giây tiếp theo bằng 0,028476.

Bạn không muốn theo dõi giá trị của mình đến vị trí thập phân thứ năm hoặc thứ sáu, vì vậy bạn quyết định cắt giảm mọi thứ sau vị trí thập phân thứ ba. Trong biệt ngữ làm tròn, điều này được gọi là cắt số đến vị trí thập phân thứ ba. Có một số lỗi được mong đợi ở đây, nhưng bằng cách giữ ba vị trí thập phân, lỗi này không thể là đáng kể. Đúng?truncating the number to the third decimal place. There’s some error to be expected here, but by keeping three decimal places, this error couldn’t be substantial. Right?

Để chạy thử nghiệm của chúng tôi bằng Python, hãy để bắt đầu bằng cách viết hàm 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 cắt ngắn một số xuống ba số thập phân:

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000

Hàm 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 hoạt động bằng cách đầu tiên chuyển điểm thập phân trong số 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 ba vị trí bên phải bằng cách nhân 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
15. Phần số nguyên của số mới này được thực hiện với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
16. Cuối cùng, điểm thập phân được chuyển ba vị trí trở lại bên trái bằng cách chia 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 cho 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
15.

Tiếp theo, hãy để xác định các tham số ban đầu của mô phỏng. Bạn sẽ cần hai biến: một để theo dõi giá trị thực tế của cổ phiếu của bạn sau khi mô phỏng hoàn tất và một biến cho giá trị của cổ phiếu của bạn sau khi bạn đã cắt giảm ba vị trí thập phân ở mỗi bước.

Bắt đầu bằng cách khởi tạo các biến này thành 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
19:

>>>

>>> actual_value, truncated_value = 100, 100

Hàm 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 hoạt động bằng cách đầu tiên chuyển điểm thập phân trong số 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 ba vị trí bên phải bằng cách nhân 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
15. Phần số nguyên của số mới này được thực hiện với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
16. Cuối cùng, điểm thập phân được chuyển ba vị trí trở lại bên trái bằng cách chia 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 cho 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
15.

>>>

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239

Thịt mô phỏng diễn ra trong vòng 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
26, lặp qua 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
27 của các số trong khoảng từ 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28 và 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
29. Giá trị được lấy từ 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
30 ở mỗi bước được lưu trữ trong biến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
31 mà chúng tôi sử dụng ở đây vì chúng tôi thực sự cần giá trị này bên trong vòng lặp.

Ở mỗi bước của vòng lặp, một số ngẫu nhiên mới giữa 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
20 và 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
21 được tạo bằng cách sử dụng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
34 và được gán cho biến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
35. Giá trị mới của khoản đầu tư của bạn được tính bằng cách thêm 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
35 vào 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
37 và tổng số bị cắt được tính bằng cách thêm 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
35 vào 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
39 và sau đó cắt ngắn giá trị này với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11.

Như bạn có thể thấy bằng cách kiểm tra biến 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
37 sau khi chạy vòng lặp, bạn chỉ mất khoảng 3,55 đô la. Tuy nhiên, nếu bạn đã nhìn vào 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
39, bạn đã nghĩ rằng bạn đã mất gần như tất cả số tiền của mình!

Bỏ qua thời điểm mà 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 không hành xử như bạn mong đợi, hãy để Lôi thử chạy lại mô phỏng. Chúng tôi sẽ sử dụng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 lần này để làm tròn đến ba vị trí thập phân ở mỗi bước và 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
45 Mô phỏng một lần nữa để có được kết quả tương tự như trước đây:

>>>

>>> random.seed(100)
>>> actual_value, rounded_value = 100, 100

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     rounded_value = round(rounded_value + randn, 3)
...

>>> actual_value
96.45273913513529

>>> rounded_value
96.258

Thật la khac biệt!

Có vẻ như gây sốc, lỗi chính xác này đã gây ra sự khuấy động vào đầu những năm 1980 khi hệ thống được thiết kế để ghi lại giá trị của Sở giao dịch chứng khoán Vancouver đã cắt giảm giá trị chỉ số tổng thể thành ba vị trí thập phân thay vì làm tròn. Lỗi làm tròn đã gây ảnh hưởng đến các cuộc bầu cử và thậm chí dẫn đến việc mất mạng.

Làm thế nào bạn có số tròn là quan trọng, và là một nhà phát triển và thiết kế phần mềm có trách nhiệm, bạn cần biết những vấn đề phổ biến là gì và làm thế nào để đối phó với chúng. Hãy để lặn và điều tra các phương pháp làm tròn khác nhau là gì và làm thế nào bạn có thể thực hiện từng phương pháp trong Python thuần túy.

Một người đàn ông của các phương pháp

Có rất nhiều chiến lược làm tròn, mỗi chiến lược đều có ưu điểm và nhược điểm. Trong phần này, bạn sẽ tìm hiểu về một số kỹ thuật phổ biến nhất và cách chúng có thể ảnh hưởng đến dữ liệu của bạn.

Cắt ngắn

Phương pháp đơn giản nhất, mặc dù nhất định, để làm tròn một số là cắt số số thành một số chữ số nhất định. Khi bạn cắt một số, bạn thay thế từng chữ số sau một vị trí nhất định bằng 0. Dưới đây là một số ví dụ:

Giá trịCắt ngắn đểKết quả
12.345 Hàng chục nơi10
12.345 Những người12
12.345 Vị trí thứ mười12.3
12.345 Vị trí hàng trăm12.34

Bạn đã thấy một cách để thực hiện điều này trong hàm 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 từ mức độ ảnh hưởng của việc làm tròn? tiết diện. Trong chức năng đó, số đầu vào đã bị cắt giảm thành ba số thập phân bởi:

  • Nhân số lượng với 
    # không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
    15 để thay đổi số thập phân ba vị trí sang bên phải
  • Lấy phần số nguyên của số mới đó với 
    # không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
    16
  • Chuyển vị trí thập phân ba vị trí trở lại bên trái bằng cách chia cho 
    # không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
    15

Bạn có thể khái quát quy trình này bằng cách thay thế 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
15 bằng số 10ᵖ (
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
51 được nâng lên công suất PTH), trong đó p là số lượng vị trí thập phân để cắt ngắn đến:

def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier

Trong phiên bản 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 này, đối số thứ hai mặc định là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28 để nếu không có đối số thứ hai được truyền cho hàm, thì 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 sẽ trả về phần số nguyên của bất kỳ số nào được truyền cho nó.

Hàm 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 hoạt động tốt cho cả số dương và số âm:

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
0

Bạn thậm chí có thể chuyển một số âm cho 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
56 để cắt ngắn thành các chữ số ở bên trái của dấu thập phân:

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
1

Khi bạn cắt ngắn một số dương, bạn đang làm tròn nó xuống. Tương tự như vậy, cắt ngắn một số âm tròn số đó lên. Theo một nghĩa nào đó, cắt ngắn là sự kết hợp của các phương pháp làm tròn tùy thuộc vào dấu hiệu của số bạn đang làm tròn.

Hãy cùng xem từng phương pháp làm tròn này một cách riêng lẻ, bắt đầu bằng cách làm tròn.

Tập trung

Chiến lược làm tròn thứ hai mà chúng tôi sẽ xem xét được gọi là làm tròn. Chiến lược này luôn làm tròn một số lên đến một số chữ số cụ thể. Bảng sau đây tóm tắt chiến lược này:

Giá trịCắt ngắn đểKết quả
12.345 Hàng chục nơi20
12.345 Những người13
12.345 Vị trí thứ mười12.4
12.345 Vị trí hàng trăm12.35

Bạn đã thấy một cách để thực hiện điều này trong hàm 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 từ mức độ ảnh hưởng của việc làm tròn? tiết diện. Trong chức năng đó, số đầu vào đã bị cắt giảm thành ba số thập phân bởi:

Nhân số lượng với 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
15 để thay đổi số thập phân ba vị trí sang bên phải

Lấy phần số nguyên của số mới đó với 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
16

Trong toán học, một chức năng đặc biệt gọi là hàm trần ánh xạ mỗi số lên trần nhà của nó. Để cho phép hàm trần chấp nhận số nguyên, trần của một số nguyên được xác định là chính số nguyên. Vì vậy, trần của số 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04 là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04.ceiling function maps every number to its ceiling. To allow the ceiling function to accept integers, the ceiling of an integer is defined to be the integer itself. So the ceiling of the number 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04 is 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04.

Trong Python, 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
69 thực hiện hàm trần và luôn trả về số nguyên gần nhất lớn hơn hoặc bằng đầu vào của nó:

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
2

Lưu ý rằng trần của 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28, không phải 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72. Điều này có ý nghĩa bởi vì 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28 là số nguyên gần nhất đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 lớn hơn hoặc bằng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70.

Hãy cùng viết một chức năng gọi là 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 thực hiện chiến lược làm tròn lên trên mạng:

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
3

Bạn có thể nhận thấy rằng 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 trông rất giống 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11. Đầu tiên, điểm thập phân trong 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được dịch chuyển đúng số vị trí sang phải bằng cách nhân 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
81. Giá trị mới này được làm tròn lên đến số nguyên gần nhất bằng cách sử dụng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
69, và sau đó điểm thập phân được chuyển trở lại bên trái bằng cách chia cho 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
81.

Mô hình này thay đổi điểm thập phân, áp dụng một số phương pháp làm tròn để làm tròn sang số nguyên, và sau đó chuyển điểm thập phân trở lại sẽ đi lại nhiều lần khi chúng tôi điều tra các phương pháp làm tròn nhiều hơn. Rốt cuộc, đây là thuật toán tinh thần mà con người chúng ta sử dụng cho các số tròn bằng tay.

Hãy cùng xem xét 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 hoạt động tốt như thế nào cho các đầu vào khác nhau:

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
4

Lưu ý rằng trần của 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28, không phải 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72. Điều này có ý nghĩa bởi vì 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28 là số nguyên gần nhất đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 lớn hơn hoặc bằng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70.

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
5

Lưu ý rằng trần của 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28, không phải 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72. Điều này có ý nghĩa bởi vì 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28 là số nguyên gần nhất đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 lớn hơn hoặc bằng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70.

Hãy cùng viết một chức năng gọi là 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 thực hiện chiến lược làm tròn lên trên mạng:

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
6

Lưu ý rằng trần của 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28, không phải 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72. Điều này có ý nghĩa bởi vì 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28 là số nguyên gần nhất đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70 lớn hơn hoặc bằng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
70.

Hãy cùng viết một chức năng gọi là 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 thực hiện chiến lược làm tròn lên trên mạng:

Bạn có thể nhận thấy rằng 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 trông rất giống 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11. Đầu tiên, điểm thập phân trong 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được dịch chuyển đúng số vị trí sang phải bằng cách nhân 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
81. Giá trị mới này được làm tròn lên đến số nguyên gần nhất bằng cách sử dụng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
69, và sau đó điểm thập phân được chuyển trở lại bên trái bằng cách chia cho 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
81.

Mô hình này thay đổi điểm thập phân, áp dụng một số phương pháp làm tròn để làm tròn sang số nguyên, và sau đó chuyển điểm thập phân trở lại sẽ đi lại nhiều lần khi chúng tôi điều tra các phương pháp làm tròn nhiều hơn. Rốt cuộc, đây là thuật toán tinh thần mà con người chúng ta sử dụng cho các số tròn bằng tay.

Hãy cùng xem xét 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 hoạt động tốt như thế nào cho các đầu vào khác nhau:

Giống như # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))11, bạn có thể chuyển giá trị âm cho # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))56:

Khi bạn chuyển một số âm cho 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
56, số trong đối số đầu tiên của 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 được làm tròn đến số chữ số chính xác ở bên trái của dấu thập phân.

Hãy đoán xem những gì 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
89 trả về:		Có phải 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
90 những gì bạn mong đợi?		Nếu bạn kiểm tra logic được sử dụng trong việc xác định ________ 176, cụ thể, cách hàm 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
69 hoạt động thì điều đó có ý nghĩa rằng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
89 trả về 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
90. Tuy nhiên, một số người tự nhiên mong đợi tính đối xứng xung quanh số 0 khi làm tròn các số, do đó nếu 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
01 được làm tròn lên đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04, thì 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
97 sẽ được làm tròn lên đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
98.
12.345 Hãy để thiết lập một số thuật ngữ. Đối với các mục đích của chúng tôi, chúng tôi sẽ sử dụng các thuật ngữ làm tròn lên và các vòng tròn xuống theo sơ đồ sau:10
12.345 Làm tròn lên bên phải và xuống bên trái. (Hình ảnh: David Amos)12
12.345 Làm tròn luôn làm tròn một số vào bên phải trên dòng số và làm tròn xuống luôn làm tròn một số vào bên trái trên dòng số.12.3
12.345 Làm tròn xuống12.34

Đối tác của nhóm làm tròn lên trên mạng là chiến lược làm tròn của người Viking, luôn làm tròn một số xuống một số chữ số được chỉ định. Dưới đây là một số ví dụ minh họa chiến lược này:

Giá trị

Làm tròn xuống

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
7

Kết quả

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
8

Hàng chục nơi

Những người

>>>

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
9

Vị trí thứ mười

Vị trí hàng trăm

Để thực hiện chiến lược làm tròn xuống của người Viking trong Python, chúng ta có thể tuân theo cùng một thuật toán mà chúng tôi đã sử dụng cho cả # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))99 và # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))76. Đầu tiên chuyển điểm thập phân, sau đó làm tròn sang một số nguyên, và cuối cùng thay đổi dấu thập phân trở lại.

Trong 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76, chúng tôi đã sử dụng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
69 để làm tròn lên trần của số sau khi chuyển điểm thập phân. Tuy nhiên, đối với chiến lược làm tròn xuống của người Viking, chúng ta cần làm tròn lên sàn của số sau khi chuyển điểm thập phân.

May mắn cho chúng tôi, mô -đun 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
58 có chức năng 
10
11
6
5
7
0
1
04 trả về sàn của đầu vào của nó:

Ở đây, định nghĩa của 

10
11
6
5
7
0
1
05:

Mặt khác, hàm 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 là đối xứng xung quanh 0. Điều này là bởi vì, sau khi chuyển điểm thập phân sang bên phải, 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 cắt các chữ số còn lại. Khi giá trị ban đầu là dương, số tiền này sẽ làm tròn số xuống. Số âm được làm tròn lên. Vì vậy, 
10
11
6
5
7
0
1
26 trả về 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
61 và 
10
11
6
5
7
0
1
28 trả về 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72.

Khái niệm đối xứng giới thiệu khái niệm về độ lệch làm tròn, mô tả cách làm tròn ảnh hưởng đến dữ liệu số trong bộ dữ liệu.rounding bias, which describes how rounding affects numeric data in a dataset.

Chiến lược làm tròn của người Viking có một vòng hướng tới sự thiên vị vô cực tích cực, bởi vì giá trị luôn được làm tròn theo hướng vô cực tích cực. Tương tự như vậy, chiến lược làm tròn xuống của người Viking có một vòng đối với sự thiên vị vô cực tiêu cực.round towards positive infinity bias, because the value is always rounded up in the direction of positive infinity. Likewise, the “rounding down” strategy has a round towards negative infinity bias.

Chiến lược cắt ngắn của người Viking thể hiện một vòng hướng tới sự thiên vị vô cực tiêu cực đối với các giá trị dương và một vòng hướng tới vô cực dương cho các giá trị âm. Các chức năng làm tròn với hành vi này được cho là có một vòng về phía không thiên vị, nói chung.round towards zero bias, in general.

Hãy để xem cách thức hoạt động của nó trong thực tế. Hãy xem xét danh sách các phao sau:

>>>

10
11
6
5
7
0
1
0

Hãy để tính toán giá trị trung bình của các giá trị trong 

10
11
6
5
7
0
1
30 bằng hàm 
10
11
6
5
7
0
1
31:

>>>

10
11
6
5
7
0
1
1

Hãy để tính toán giá trị trung bình của các giá trị trong 

10
11
6
5
7
0
1
30 bằng hàm 
10
11
6
5
7
0
1
31:

>>>

10
11
6
5
7
0
1
2

Hãy để tính toán giá trị trung bình của các giá trị trong 

10
11
6
5
7
0
1
30 bằng hàm 
10
11
6
5
7
0
1
31:

Bây giờ áp dụng từng 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76, 
10
11
6
5
7
0
1
05 và 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 trong danh sách hiểu biết để làm tròn từng số trong 
10
11
6
5
7
0
1
30 đến một vị trí thập phân và tính giá trị trung bình mới:

Sau khi mỗi số trong 

10
11
6
5
7
0
1
30 được làm tròn, giá trị trung bình mới là khoảng 
10
11
6
5
7
0
1
37, lớn hơn giá trị trung bình thực tế của 
10
11
6
5
7
0
1
38. Làm tròn xuống dịch chuyển trung bình xuống khoảng 
10
11
6
5
7
0
1
39. Giá trị trung bình của các giá trị bị cắt là khoảng 
10
11
6
5
7
0
1
40 và là giá trị gần nhất với giá trị trung bình thực tế.

Ví dụ này không ngụ ý rằng bạn nên luôn luôn cắt ngắn khi bạn cần làm tròn các giá trị riêng lẻ trong khi bảo tồn giá trị trung bình càng gần càng tốt. Danh sách 

10
11
6
5
7
0
1
30 chứa số lượng giá trị dương và âm bằng nhau. Hàm 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11 sẽ hoạt động giống như 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 trên danh sách tất cả các giá trị dương và giống như 
10
11
6
5
7
0
1
05 trên danh sách tất cả các giá trị âm.

Những gì ví dụ này minh họa là độ lệch làm tròn hiệu ứng có trên các giá trị được tính toán từ dữ liệu đã được làm tròn. Bạn sẽ cần phải ghi nhớ những hiệu ứng này khi rút ra kết luận từ dữ liệu đã được làm tròn.

Thông thường, khi làm tròn, bạn quan tâm đến việc làm tròn đến số gần nhất với một số độ chính xác được chỉ định, thay vì chỉ làm tròn mọi thứ lên hoặc xuống.tie with respect to 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
60 and 
10
11
6
5
7
0
1
48. In cases like this, you must assign a tiebreaker.

Ví dụ: nếu ai đó yêu cầu bạn làm tròn các số 

10
11
6
5
7
0
1
45 và 
10
11
6
5
7
0
1
46 đến một vị trí thập phân, có lẽ bạn sẽ phản hồi nhanh chóng với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
60 và 
10
11
6
5
7
0
1
48. Các chức năng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
11, 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
76 và 
10
11
6
5
7
0
1
05 don don làm bất cứ điều gì như thế này.

Còn số 10 11 6 5 7 0 152 thì sao? Bạn có thể nghĩ ngay lập tức để làm tròn điều này đến 10 11 6 5 7 0 148, nhưng trong thực tế, 10 11 6 5 7 0 152 là tương đương từ # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))60 và 10 11 6 5 7 0 148. Theo một nghĩa nào đó, # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))60 và 10 11 6 5 7 0 148 đều là những con số gần nhất đến 10 11 6 5 7 0 152 với độ chính xác của số thập phân. Số 10 11 6 5 7 0 152 được gọi là cà vạt liên quan đến # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))60 và 10 11 6 5 7 0 148. Trong các trường hợp như thế này, bạn phải chỉ định một kẻ phá vỡ.

Cách mà hầu hết mọi người được dạy về mối quan hệ phá vỡ là bằng cách làm tròn đến các số lớn hơn của hai con số có thể.

Làm tròn một nửa lênChiến lược làm tròn một nửa của người Viking lên từng số vào số gần nhất với độ chính xác được chỉ định và phá vỡ các mối quan hệ bằng cách làm tròn. Dưới đây là một số ví dụ:Giá trị
13.825 Vòng một nửa lên đến10
13.825 Kết quả14
13.825 Hàng chục nơi13.8
13.825 Những người13.83

Vị trí thứ mười

Vị trí hàng trăm

  • Để thực hiện chiến lược nửa vòng tròn của người Viking trong Python, bạn bắt đầu như thường lệ bằng cách chuyển điểm thập phân sang bên phải bởi số lượng địa điểm mong muốn. Tuy nhiên, tại thời điểm này, bạn cần một cách để xác định xem chữ số ngay sau điểm thập phân thay đổi nhỏ hơn hoặc lớn hơn hoặc bằng 

    10
11
6
5
7
0
1
    63.

  • Một cách để làm điều này là thêm 

    10
11
6
5
7
0
1
    64 vào giá trị đã thay đổi và sau đó làm tròn với 
    10
11
6
5
7
0
1
    08. Điều này hoạt động bởi vì:

Nếu chữ số ở vị trí thập phân đầu tiên của giá trị thay đổi nhỏ hơn năm, thì việc thêm 

10
11
6
5
7
0
1
64 won Thay đổi phần số nguyên của giá trị dịch chuyển, do đó sàn bằng phần nguyên.

10
11
6
5
7
0
1
3

Nếu chữ số đầu tiên sau vị trí thập phân lớn hơn hoặc bằng 

10
11
6
5
7
0
1
63, thì việc thêm 
10
11
6
5
7
0
1
64 sẽ tăng phần số nguyên của giá trị dịch chuyển bằng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
61, do đó, sàn bằng với số nguyên lớn hơn này.

Hãy để thử nghiệm 

10
11
6
5
7
0
1
70 trên một vài giá trị để thấy rằng nó hoạt động:

>>>

10
11
6
5
7
0
1
4

Vì 

10
11
6
5
7
0
1
70 luôn phá vỡ các mối quan hệ bằng cách làm tròn đến các giá trị lớn hơn của hai giá trị có thể, các giá trị âm như 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
97 tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72, không phải là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
98:

>>> 

10
11
6
5
7
0
1
5

Vì 

10
11
6
5
7
0
1
70 luôn phá vỡ các mối quan hệ bằng cách làm tròn đến các giá trị lớn hơn của hai giá trị có thể, các giá trị âm như 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
97 tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72, không phải là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
98:

>>>

10
11
6
5
7
0
1
6

Vì 

10
11
6
5
7
0
1
70 luôn phá vỡ các mối quan hệ bằng cách làm tròn đến các giá trị lớn hơn của hai giá trị có thể, các giá trị âm như 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
97 tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72, không phải là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
98:

>>>

10
11
6
5
7
0
1
7

Vì 

10
11
6
5
7
0
1
70 luôn phá vỡ các mối quan hệ bằng cách làm tròn đến các giá trị lớn hơn của hai giá trị có thể, các giá trị âm như 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
97 tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72, không phải là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
98:

Tuyệt quá! Bây giờ bạn cuối cùng có thể nhận được kết quả đó rằng chức năng 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp từ chối cho bạn:

Mặc dù trước khi bạn quá phấn khích, hãy để Lừa xem điều gì sẽ xảy ra khi bạn cố gắng và làm tròn 

10
11
6
5
7
0
1
80 đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04 Số thập phân:

>>>

10
11
6
5
7
0
1
8

Vì 

10
11
6
5
7
0
1
70 luôn phá vỡ các mối quan hệ bằng cách làm tròn đến các giá trị lớn hơn của hai giá trị có thể, các giá trị âm như 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
97 tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
72, không phải là 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
98:

>>>

10
11
6
5
7
0
1
9

Tuyệt quá! Bây giờ bạn cuối cùng có thể nhận được kết quả đó rằng chức năng 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp từ chối cho bạn:

Mặc dù trước khi bạn quá phấn khích, hãy để Lừa xem điều gì sẽ xảy ra khi bạn cố gắng và làm tròn 

10
11
6
5
7
0
1
80 đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
04 Số thập phân:

Chờ đợi. Chúng tôi vừa thảo luận về cách các mối quan hệ được làm tròn đến các giá trị lớn hơn của hai giá trị có thể. 

10
11
6
5
7
0
1
80 bị đập vào giữa 
10
11
6
5
7
0
1
83 và 
10
11
6
5
7
0
1
84. Vì 
10
11
6
5
7
0
1
83 là lớn hơn của hai người này, 
10
11
6
5
7
0
1
86 sẽ trả lại 
10
11
6
5
7
0
1
83. Nhưng thay vào đó, chúng tôi có 
10
11
6
5
7
0
1
84.

Có lỗi trong hàm 

10
11
6
5
7
0
1
70 không?should not be used in situations where precision is paramount. For applications where the exact precision is necessary, you can use the 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 class from Python’s 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 module. You’ll learn more about the 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 class below.

Khi 

10
11
6
5
7
0
1
70 vòng 
10
11
6
5
7
0
1
80 đến hai vị trí thập phân, điều đầu tiên nó làm là nhân 
10
11
6
5
7
0
1
80 với 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
19. Hãy để đảm bảo rằng điều này hoạt động như mong đợi:

Vâng, đó là sai! Nhưng nó giải thích tại sao 

10
11
6
5
7
0
1
86 trả về -1,23. Hãy để tiếp tục các bước từng bước ____270, sử dụng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
31 trong bản phát hành để nhớ lại đầu ra giá trị cuối cùng ở mỗi bước:

Mặc dù 10 11 6 5 7 0 197 thực sự gần với 10 11 6 5 7 0 198, số nguyên gần nhất nhỏ hơn hoặc bằng với nó là 10 11 6 5 7 0 199. Khi điểm thập phân được chuyển trở lại bên trái, giá trị cuối cùng là 10 11 6 5 7 0 184.

Chà, bây giờ bạn biết làm thế nào 

10
11
6
5
7
0
1
86 trả về 
10
11
6
5
7
0
1
84 mặc dù không có lỗi logic, nhưng tại sao Python nói rằng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
03 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
04? Có lỗi trong Python không?

Thực tế là Python nói rằng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
03 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
04 là một tạo tác của lỗi biểu diễn dấu phẩy động. Bạn có thể tự hỏi mình, được rồi, nhưng có cách nào để khắc phục điều này không? Một câu hỏi hay hơn để tự hỏi mình là "Tôi có cần sửa cái này không?"		Các số điểm nổi không có độ chính xác chính xác, và do đó không nên được sử dụng trong các tình huống trong đó độ chính xác là tối quan trọng. Đối với các ứng dụng có độ chính xác chính xác là cần thiết, bạn có thể sử dụng lớp 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 từ mô -đun PythonTHER 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bạn sẽ tìm hiểu thêm về lớp 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 dưới đây.		Nếu bạn đã xác định rằng lớp ____310 tiêu chuẩn của Python là đủ cho ứng dụng của bạn, một số lỗi không thường xuyên trong 
10
11
6
5
7
0
1
70 do lỗi biểu diễn điểm nổi nên là một mối quan tâm.
13.825 Bây giờ, bạn đã nhận được một hương vị về cách các số máy tròn trong bộ nhớ, hãy để tiếp tục thảo luận về các chiến lược làm tròn bằng cách nhìn vào một cách khác để phá vỡ một chiếc cà vạt.10
13.825 Làm tròn một nửa xuống14
13.825 Chiến lược làm tròn một nửa xuống, các vòng tròn với số gần nhất với độ chính xác mong muốn, giống như phương pháp làm tròn một nửa lên, ngoại trừ việc nó phá vỡ mối quan hệ bằng cách làm tròn vào số ít hơn trong hai số. Dưới đây là một số ví dụ:13.8
13.825 Giá trị13.82

Vòng một nửa xuống

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
0

Kết quả

>>>

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
1

Hàng chục nơi

>>> 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
2

Những người

>>>

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
3

Vị trí thứ mười

>>>

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
4

Vị trí hàng trăm

Bạn có thể thực hiện chiến lược nửa làm tròn xuống trong Python bằng cách thay thế 

10
11
6
5
7
0
1
08 trong hàm 
10
11
6
5
7
0
1
70 bằng 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
69 và trừ 
10
11
6
5
7
0
1
64 thay vì thêm: thêm:

Hãy để kiểm tra print(round(2.665, 2)) print(round(50.25556, 2)) print(round(100.000056, 3)) print(round(80.23456, 2)) print(round(122.145,5))16 so với một vài trường hợp thử nghiệm:

Cả 

10
11
6
5
7
0
1
70 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
16 không có sai lệch nói chung. Tuy nhiên, việc làm tròn dữ liệu với rất nhiều mối quan hệ sẽ giới thiệu sự thiên vị. Ví dụ cực đoan, hãy xem xét danh sách các số sau:

>>>

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
5

Hãy để tính toán giá trị trung bình của các số sau:

Thực tế là Python nói rằng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
03 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
04 là một tạo tác của lỗi biểu diễn dấu phẩy động. Bạn có thể tự hỏi mình, được rồi, nhưng có cách nào để khắc phục điều này không? Một câu hỏi hay hơn để tự hỏi mình là "Tôi có cần sửa cái này không?"		Các số điểm nổi không có độ chính xác chính xác, và do đó không nên được sử dụng trong các tình huống trong đó độ chính xác là tối quan trọng. Đối với các ứng dụng có độ chính xác chính xác là cần thiết, bạn có thể sử dụng lớp 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 từ mô -đun PythonTHER 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bạn sẽ tìm hiểu thêm về lớp 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 dưới đây.		Nếu bạn đã xác định rằng lớp ____310 tiêu chuẩn của Python là đủ cho ứng dụng của bạn, một số lỗi không thường xuyên trong 
10
11
6
5
7
0
1
70 do lỗi biểu diễn điểm nổi nên là một mối quan tâm.
15.25 Bây giờ, bạn đã nhận được một hương vị về cách các số máy tròn trong bộ nhớ, hãy để tiếp tục thảo luận về các chiến lược làm tròn bằng cách nhìn vào một cách khác để phá vỡ một chiếc cà vạt.20
15.25 Làm tròn một nửa xuống15
15.25 Chiến lược làm tròn một nửa xuống, các vòng tròn với số gần nhất với độ chính xác mong muốn, giống như phương pháp làm tròn một nửa lên, ngoại trừ việc nó phá vỡ mối quan hệ bằng cách làm tròn vào số ít hơn trong hai số. Dưới đây là một số ví dụ:15.3
-15.25 Bây giờ, bạn đã nhận được một hương vị về cách các số máy tròn trong bộ nhớ, hãy để tiếp tục thảo luận về các chiến lược làm tròn bằng cách nhìn vào một cách khác để phá vỡ một chiếc cà vạt.-20
-15.25 Làm tròn một nửa xuống-15
-15.25 Chiến lược làm tròn một nửa xuống, các vòng tròn với số gần nhất với độ chính xác mong muốn, giống như phương pháp làm tròn một nửa lên, ngoại trừ việc nó phá vỡ mối quan hệ bằng cách làm tròn vào số ít hơn trong hai số. Dưới đây là một số ví dụ:-15.3

Giá trị

  1. Nếu 
    >>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
    4 là tích cực và 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    29, hãy làm tròn
  2. Nếu 
    >>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
    4 là dương và 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    31, hãy làm tròn xuống
  3. Nếu 
    >>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
    4 là âm và 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    29, hãy làm tròn xuống
  4. Nếu 
    >>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
    4 là âm và 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    31, hãy làm tròn

Sau khi làm tròn theo một trong bốn quy tắc trên, sau đó bạn chuyển vị trí thập phân trở lại bên trái.

Với một số 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 và giá trị cho 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
56, bạn có thể thực hiện điều này trong Python bằng cách sử dụng 
10
11
6
5
7
0
1
70 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
16:

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
6

Điều đó đủ dễ dàng, nhưng thực sự có một cách đơn giản hơn!

Nếu trước tiên bạn lấy giá trị tuyệt đối của 

>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 bằng cách sử dụng hàm 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
41 tích hợp của Python, bạn chỉ có thể sử dụng 
10
11
6
5
7
0
1
70 để làm tròn số. Sau đó, tất cả những gì bạn cần làm là cho số tròn giống như 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4. Một cách để làm điều này là sử dụng chức năng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44.

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 lấy hai số 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
46 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
47 và trả về 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
46 với dấu hiệu của 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
47:

>>>

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
7

Lưu ý rằng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 trả về 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
10, mặc dù cả hai đối số của nó đều là số nguyên.

Sử dụng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
41, 
10
11
6
5
7
0
1
70 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44, bạn có thể thực hiện một nửa vòng tròn từ chiến lược không có trong hai dòng Python:

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
8

Trong 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55, giá trị tuyệt đối của 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được làm tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
56 vị trí thập phân bằng cách sử dụng 
10
11
6
5
7
0
1
70 và kết quả này được gán cho biến 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
59. Sau đó, dấu hiệu ban đầu của 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được áp dụng cho 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
59 bằng cách sử dụng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 và giá trị cuối cùng này với dấu hiệu chính xác được trả về bởi hàm.

Kiểm tra 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 trên một vài giá trị khác nhau cho thấy hàm hoạt động như mong đợi:

>>>

Lưu ý rằng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 trả về 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
10, mặc dù cả hai đối số của nó đều là số nguyên.

Sử dụng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
41, 
10
11
6
5
7
0
1
70 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44, bạn có thể thực hiện một nửa vòng tròn từ chiến lược không có trong hai dòng Python:

Trong 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55, giá trị tuyệt đối của 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được làm tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
56 vị trí thập phân bằng cách sử dụng 
10
11
6
5
7
0
1
70 và kết quả này được gán cho biến 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
59. Sau đó, dấu hiệu ban đầu của 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được áp dụng cho 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
59 bằng cách sử dụng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 và giá trị cuối cùng này với dấu hiệu chính xác được trả về bởi hàm.

>>>

2.67
50.26
100.0
80.23
122.145
0

Lưu ý rằng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 trả về 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
10, mặc dù cả hai đối số của nó đều là số nguyên.

Sử dụng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
41, 
10
11
6
5
7
0
1
70 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44, bạn có thể thực hiện một nửa vòng tròn từ chiến lược không có trong hai dòng Python:

Trong 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55, giá trị tuyệt đối của 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được làm tròn đến 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
56 vị trí thập phân bằng cách sử dụng 
10
11
6
5
7
0
1
70 và kết quả này được gán cho biến 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
59. Sau đó, dấu hiệu ban đầu của 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
4 được áp dụng cho 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
59 bằng cách sử dụng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 và giá trị cuối cùng này với dấu hiệu chính xác được trả về bởi hàm.

Kiểm tra print(round(2.665, 2)) print(round(50.25556, 2)) print(round(100.000056, 3)) print(round(80.23456, 2)) print(round(122.145,5))55 trên một vài giá trị khác nhau cho thấy hàm hoạt động như mong đợi:

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
9

Chức năng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 Vòng tròn số theo cách mà hầu hết mọi người có xu hướng tròn số trong cuộc sống hàng ngày. Bên cạnh đó là chức năng làm tròn quen thuộc nhất mà bạn đã thấy cho đến nay, 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 cũng loại bỏ các độ lệch tròn trong các bộ dữ liệu có số lượng tương đương các mối quan hệ tích cực và tiêu cực.		Hãy để kiểm tra mức độ 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 giảm thiểu sai lệch làm tròn trong ví dụ từ phần trước:		Giá trị trung bình của các số trong 
10
11
6
5
7
0
1
30 được bảo tồn gần như chính xác khi bạn làm tròn từng số trong 
10
11
6
5
7
0
1
30 đến một vị trí thập phân với 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55!
15.255 Tuy nhiên, 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 sẽ thể hiện sự thiên vị làm tròn khi bạn làm tròn mọi số trong các bộ dữ liệu chỉ có mối quan hệ tích cực, chỉ có mối quan hệ tiêu cực hoặc nhiều mối quan hệ của một dấu hiệu khác. Sự thiên vị chỉ được giảm thiểu tốt nếu có một số lượng tương tự các mối quan hệ tích cực và tiêu cực trong bộ dữ liệu.		20
15.255 Làm thế nào để bạn xử lý các tình huống trong đó số lượng mối quan hệ tích cực và tiêu cực khác nhau đáng kể? Câu trả lời cho câu hỏi này đưa chúng ta đến vòng tròn đầy đủ cho chức năng đã lừa dối chúng ta khi bắt đầu bài viết này: Chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp của Python.		15
15.255 Làm tròn một nửa để thậm chí15.3
15.255 Một cách để giảm thiểu độ lệch làm tròn khi làm tròn các giá trị trong bộ dữ liệu là các mối quan hệ tròn đến số gần nhất ở độ chính xác mong muốn. Dưới đây là một số ví dụ về cách làm điều đó:15.26

Giá trị

Vòng một nửa để thậm chí

Kết quả

>>>

2.67
50.26
100.0
80.23
122.145
1

Lưu ý rằng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 trả về 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
10, mặc dù cả hai đối số của nó đều là số nguyên.

Sử dụng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
41, 
10
11
6
5
7
0
1
70 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44, bạn có thể thực hiện một nửa vòng tròn từ chiến lược không có trong hai dòng Python:

>>>

2.67
50.26
100.0
80.23
122.145
2

Lưu ý rằng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44 trả về 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
10, mặc dù cả hai đối số của nó đều là số nguyên.

Sử dụng 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
41, 
10
11
6
5
7
0
1
70 và 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
44, bạn có thể thực hiện một nửa vòng tròn từ chiến lược không có trong hai dòng Python:

Trong print(round(2.665, 2)) print(round(50.25556, 2)) print(round(100.000056, 3)) print(round(80.23456, 2)) print(round(122.145,5))55, giá trị tuyệt đối của >>> import random >>> random.seed(100) >>> for _ in range(1000000): ... randn = random.uniform(-0.05, 0.05) ... actual_value = actual_value + randn ... truncated_value = truncate(truncated_value + randn) ... >>> actual_value 96.45273913513529 >>> truncated_value 0.239 4 được làm tròn đến # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))56 vị trí thập phân bằng cách sử dụng 10 11 6 5 7 0 170 và kết quả này được gán cho biến print(round(2.665, 2)) print(round(50.25556, 2)) print(round(100.000056, 3)) print(round(80.23456, 2)) print(round(122.145,5))59. Sau đó, dấu hiệu ban đầu của >>> import random >>> random.seed(100) >>> for _ in range(1000000): ... randn = random.uniform(-0.05, 0.05) ... actual_value = actual_value + randn ... truncated_value = truncate(truncated_value + randn) ... >>> actual_value 96.45273913513529 >>> truncated_value 0.239 4 được áp dụng cho print(round(2.665, 2)) print(round(50.25556, 2)) print(round(100.000056, 3)) print(round(80.23456, 2)) print(round(122.145,5))59 bằng cách sử dụng print(round(2.665, 2)) print(round(50.25556, 2)) print(round(100.000056, 3)) print(round(80.23456, 2)) print(round(122.145,5))44 và giá trị cuối cùng này với dấu hiệu chính xác được trả về bởi hàm.

Kiểm tra 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 trên một vài giá trị khác nhau cho thấy hàm hoạt động như mong đợi:

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
9

Những lợi ích của mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 bao gồm:

  • Đại diện thập phân chính xác: 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    82 thực sự là 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    82 và 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    84 trả về 
    # không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
    28, như bạn mong đợi.    : 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    82 is actually 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    82, and 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    84 returns 
    # không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
    28, as you’d expect.
  • Bảo tồn các chữ số quan trọng: Khi bạn thêm 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    86 và 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    87, kết quả là 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    88 với số 0 được duy trì để chỉ ra ý nghĩa.    : When you add 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    86 and 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    87, the result is 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    88 with the trailing zero maintained to indicate significance.
  • Độ chính xác thay đổi của người dùng: Độ chính xác mặc định của mô-đun 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    08 là hai mươi tám chữ số, nhưng giá trị này có thể được người dùng thay đổi để khớp với vấn đề trong tay.    : The default precision of the 
    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    08 module is twenty-eight digits, but this value can be altered by the user to match the problem at hand.

Hãy cùng khám phá cách làm việc làm tròn hoạt động trong mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bắt đầu bằng cách nhập phần sau vào Python Repls:

>>>

2.67
50.26
100.0
80.23
122.145
3

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

Như bạn có thể thấy trong ví dụ trên, chiến lược làm tròn mặc định cho mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
95. Điều này phù hợp với chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp và phải là chiến lược làm tròn ưa thích cho hầu hết các mục đích.

Hãy cùng khai báo một số bằng cách sử dụng lớp 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07. Để làm như vậy, hãy tạo một thể hiện 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 mới bằng cách chuyển 
2.67
50.26
100.0
80.23
122.145
00 chứa giá trị mong muốn:

>>>

2.67
50.26
100.0
80.23
122.145
4

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

>>>

2.67
50.26
100.0
80.23
122.145
5

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

Như bạn có thể thấy trong ví dụ trên, chiến lược làm tròn mặc định cho mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
95. Điều này phù hợp với chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp và phải là chiến lược làm tròn ưa thích cho hầu hết các mục đích.

>>>

2.67
50.26
100.0
80.23
122.145
6

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

Như bạn có thể thấy trong ví dụ trên, chiến lược làm tròn mặc định cho mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
95. Điều này phù hợp với chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp và phải là chiến lược làm tròn ưa thích cho hầu hết các mục đích.

>>>

2.67
50.26
100.0
80.23
122.145
7

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

>>>

2.67
50.26
100.0
80.23
122.145
8

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

Như bạn có thể thấy trong ví dụ trên, chiến lược làm tròn mặc định cho mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
95. Điều này phù hợp với chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp và phải là chiến lược làm tròn ưa thích cho hầu hết các mục đích.

Hãy cùng khai báo một số bằng cách sử dụng lớp 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07. Để làm như vậy, hãy tạo một thể hiện 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 mới bằng cách chuyển 
2.67
50.26
100.0
80.23
122.145
00 chứa giá trị mong muốn:

Chỉ để giải trí, hãy để thử nghiệm khẳng định rằng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 duy trì biểu diễn thập phân chính xác:		Ahhh. Điều đó thỏa mãn, phải không?
Làm tròn một 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07 được thực hiện với phương pháp 
2.67
50.26
100.0
80.23
122.145
03:		Được rồi, có lẽ trông hơi vui, vì vậy hãy để điều đó phá vỡ điều đó. Đối số 
2.67
50.26
100.0
80.23
122.145
04 trong 
2.67
50.26
100.0
80.23
122.145
03 xác định số lượng vị trí thập phân để làm tròn số. Vì 
2.67
50.26
100.0
80.23
122.145
06 có một vị trí thập phân, số 
2.67
50.26
100.0
80.23
122.145
07 vòng đến một vị trí thập phân duy nhất. Chiến lược làm tròn mặc định là một nửa làm tròn đến một nửa, vì vậy kết quả là 
def truncate(n, decimals=0):
    multiplier = 10 ** decimals
    return int(n * multiplier) / multiplier
7.
Hãy nhớ lại rằng chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3, cũng sử dụng một nửa làm tròn cho chiến lược, đã không chính xác để làm tròn 
2.67
50.26
100.0
80.23
122.145
10 đến hai thập phân. Thay vì 
2.67
50.26
100.0
80.23
122.145
11, 
2.67
50.26
100.0
80.23
122.145
12 trả về 
2.67
50.26
100.0
80.23
122.145
13. Nhờ các mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 đại diện thập phân chính xác, bạn đã giành được vấn đề này với lớp 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07:		Một lợi ích khác của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 là làm tròn sau khi thực hiện số học được chăm sóc tự động và các chữ số quan trọng được bảo tồn. Để xem điều này trong hành động, hãy để thay đổi độ chính xác mặc định từ hai mươi tám chữ số thành hai, sau đó thêm các số 
10
11
6
5
7
0
1
45 và 
2.67
50.26
100.0
80.23
122.145
18:
Để thay đổi độ chính xác, bạn gọi 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 và đặt thuộc tính 
2.67
50.26
100.0
80.23
122.145
20. Nếu đặt thuộc tính trên một cuộc gọi hàm có vẻ kỳ lạ với bạn, bạn có thể làm điều này bởi vì 
2.67
50.26
100.0
80.23
122.145
21 trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đặc biệt đại diện cho bối cảnh nội bộ hiện tại chứa các tham số mặc định được sử dụng bởi mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08.		Giá trị chính xác của 
10
11
6
5
7
0
1
45 cộng với 
2.67
50.26
100.0
80.23
122.145
18 là 
2.67
50.26
100.0
80.23
122.145
26. Vì độ chính xác hiện là hai chữ số và chiến lược làm tròn được đặt thành mặc định là một nửa làm tròn thành chẵn, nên giá trị 
2.67
50.26
100.0
80.23
122.145
26 được tự động làm tròn thành 
2.67
50.26
100.0
80.23
122.145
28.
Để thay đổi chiến lược làm tròn mặc định, bạn có thể đặt thuộc tính 
2.67
50.26
100.0
80.23
122.145
29 thành bất kỳ một trong nhiều cờ. Bảng sau đây tóm tắt các cờ này và chiến lược làm tròn mà họ thực hiện:		Lá cờ
Chiến lược làm tròn
2.67
50.26
100.0
80.23
122.145
30
Tập trung
2.67
50.26
100.0
80.23
122.145
31
Làm tròn xuống
2.67
50.26
100.0
80.23
122.145
32
Cắt ngắn
2.67
50.26
100.0
80.23
122.145
33

Làm tròn từ số không

2.67
50.26
100.0
80.23
122.145
34

Làm tròn một nửa so với số không

>>>

2.67
50.26
100.0
80.23
122.145
9

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

Như bạn có thể thấy trong ví dụ trên, chiến lược làm tròn mặc định cho mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
95. Điều này phù hợp với chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp và phải là chiến lược làm tròn ưa thích cho hầu hết các mục đích.

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
0

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

Như bạn có thể thấy trong ví dụ trên, chiến lược làm tròn mặc định cho mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 là 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
95. Điều này phù hợp với chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp và phải là chiến lược làm tròn ưa thích cho hầu hết các mục đích.

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
1

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
91 Trả về một đối tượng 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
92 đại diện cho bối cảnh mặc định của mô -đun 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Bối cảnh bao gồm độ chính xác mặc định và chiến lược làm tròn mặc định, trong số những thứ khác.

Có ba chiến lược trong mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 cho phép làm tròn nhiều sắc thái hơn. Phương pháp 
2.67
50.26
100.0
80.23
122.145
34 làm tròn mọi thứ theo số gần nhất và phá vỡ mối quan hệ bằng cách làm tròn từ số không:

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
2

Lưu ý rằng 

2.67
50.26
100.0
80.23
122.145
34 hoạt động giống như 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 của chúng tôi và không thích 
10
11
6
5
7
0
1
70.

Ngoài ra còn có một chiến lược 

2.67
50.26
100.0
80.23
122.145
35 phá vỡ mối quan hệ bằng cách làm tròn về 0:

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
3

Lưu ý rằng 

2.67
50.26
100.0
80.23
122.145
34 hoạt động giống như 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 của chúng tôi và không thích 
10
11
6
5
7
0
1
70.

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
4

Lưu ý rằng 

2.67
50.26
100.0
80.23
122.145
34 hoạt động giống như 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 của chúng tôi và không thích 
10
11
6
5
7
0
1
70.

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
5

Lưu ý rằng 

2.67
50.26
100.0
80.23
122.145
34 hoạt động giống như 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
55 của chúng tôi và không thích 
10
11
6
5
7
0
1
70.

Ngoài ra còn có một chiến lược 

2.67
50.26
100.0
80.23
122.145
35 phá vỡ mối quan hệ bằng cách làm tròn về 0:

Chiến lược làm tròn cuối cùng có sẵn trong mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 rất khác với bất cứ điều gì chúng ta đã thấy cho đến nay:

Trong các ví dụ trên, có vẻ như 

2.67
50.26
100.0
80.23
122.145
37 làm tròn mọi thứ về 0. Trên thực tế, đây chính xác là cách 
2.67
50.26
100.0
80.23
122.145
37 hoạt động, trừ khi kết quả của việc làm tròn kết thúc trong một 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
28 hoặc 
10
11
6
5
7
0
1
63. Trong trường hợp đó, số được làm tròn khỏi số không:

Trong ví dụ đầu tiên, số 2.67 50.26 100.0 80.23 122.14567 lần đầu tiên được làm tròn về 0 ở vị trí thập phân thứ hai, tạo ra 2.67 50.26 100.0 80.23 122.14568. Vì 2.67 50.26 100.0 80.23 122.14568 không kết thúc trong một # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))28 hoặc 10 11 6 5 7 0 163, nên nó được để lại như vậy. Mặt khác, 2.67 50.26 100.0 80.23 122.14572 được làm tròn về 0 ở vị trí thập phân thứ hai, dẫn đến số # không có tham số ndigits print(round(10)) print(round(10.7)) print(round(5.5)) print(round(5.4)) print(round(6.8)) print(round(0.1)) print(round(0.7))01. Điều này kết thúc trong một 10 11 6 5 7 0 163, vì vậy vị trí thập phân đầu tiên sau đó được làm tròn từ số 0 đến def truncate(n, decimals=0): multiplier = 10 ** decimals return int(n * multiplier) / multiplier 7.

Trong phần này, chúng tôi chỉ tập trung vào các khía cạnh làm tròn của mô -đun 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08. Có một số lượng lớn các tính năng khác làm cho 
print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
08 trở thành một lựa chọn tuyệt vời cho các ứng dụng trong đó độ chính xác dấu phẩy động tiêu chuẩn là không đủ, chẳng hạn như ngân hàng và một số vấn đề trong điện toán khoa học.

Để biết thêm thông tin về 

print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
07, hãy xem hướng dẫn bắt đầu nhanh trong các tài liệu Python.

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
6

Tiếp theo, hãy để chúng tôi chú ý sang hai mặt hàng chủ lực của các ngăn xếp khoa học và máy tính khoa học Python,: Numpy và Pandas.

Làm tròn mảng numpy

Trong các lĩnh vực của khoa học dữ liệu và điện toán khoa học, bạn thường lưu trữ dữ liệu của mình dưới dạng 

2.67
50.26
100.0
80.23
122.145
79. Một trong những tính năng mạnh mẽ nhất của Numpy, là việc sử dụng vector hóa và phát sóng để áp dụng các hoạt động cho toàn bộ mảng cùng một lúc thay vì một yếu tố tại một thời điểm.

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
7

Hãy để tạo ra một số dữ liệu bằng cách tạo một mảng số giả ngẫu nhiên 3 × 4:

Đầu tiên, chúng tôi gieo hạt mô -đun 

2.67
50.26
100.0
80.23
122.145
80 để bạn có thể dễ dàng tái tạo đầu ra. Sau đó, một mảng số điểm nổi 3 × 4 được tạo bằng 
2.67
50.26
100.0
80.23
122.145
81.

Để làm tròn tất cả các giá trị trong mảng 

10
11
6
5
7
0
1
30, bạn có thể chuyển 
10
11
6
5
7
0
1
30 làm đối số cho hàm 
2.67
50.26
100.0
80.23
122.145
84. Số lượng vị trí thập phân mong muốn được đặt với đối số từ khóa 
# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
56. Một nửa vòng cho chiến lược thậm chí được sử dụng, giống như chức năng 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 tích hợp của Python.

  • 2.67
50.26
100.0
80.23
122.145
    97
  • 2.67
50.26
100.0
80.23
122.145
    98
  • 2.67
50.26
100.0
80.23
122.145
    99
  • >>> def truncate(n):
...     return int(n * 1000) / 1000
    00

Ví dụ: các vòng sau tất cả các giá trị trong 

10
11
6
5
7
0
1
30 đến ba số thập phân:

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
8

2.67
50.26
100.0
80.23
122.145
84 là sự thương xót của lỗi biểu diễn dấu phẩy động, giống như 
>>> import random
>>> random.seed(100)

>>> for _ in range(1000000):
...     randn = random.uniform(-0.05, 0.05)
...     actual_value = actual_value + randn
...     truncated_value = truncate(truncated_value + randn)
...

>>> actual_value
96.45273913513529

>>> truncated_value
0.239
3 là.

Ví dụ: giá trị trong hàng thứ ba của cột đầu tiên trong mảng 

10
11
6
5
7
0
1
30 là 
2.67
50.26
100.0
80.23
122.145
91. Khi bạn làm tròn số này đến ba vị trí thập phân bằng cách sử dụng một nửa làm tròn cho chiến lược thậm chí là, bạn mong đợi giá trị sẽ là 
2.67
50.26
100.0
80.23
122.145
92. Nhưng bạn có thể thấy trong đầu ra từ 
2.67
50.26
100.0
80.23
122.145
84 rằng giá trị được làm tròn thành 
2.67
50.26
100.0
80.23
122.145
94. Tuy nhiên, giá trị 
2.67
50.26
100.0
80.23
122.145
95 trong hàng đầu tiên của cột thứ hai chính xác là 
2.67
50.26
100.0
80.23
122.145
96.

Nếu bạn cần làm tròn dữ liệu trong mảng của mình vào số nguyên, Numpy cung cấp một số tùy chọn:

Hàm 

>>> def truncate(n):
...     return int(n * 1000) / 1000
01 làm tròn mọi giá trị trong mảng đến số nguyên gần nhất lớn hơn hoặc bằng giá trị ban đầu:

>>>

>>> def truncate(n):
...     return int(n * 1000) / 1000
9

Này, chúng tôi đã phát hiện ra một số mới! Số 0 tiêu cực!

>>>

>>> actual_value, truncated_value = 100, 100
0

Trên thực tế, tiêu chuẩn IEEE-754 yêu cầu thực hiện cả số 0 dương và âm. Những gì có thể sử dụng là có một cái gì đó như thế này? Wikipedia biết câu trả lời:

>>>

>>> actual_value, truncated_value = 100, 100
1

Về mặt không chính thức, người ta có thể sử dụng ký hiệu của 

>>> def truncate(n):
...     return int(n * 1000) / 1000
02, cho một giá trị âm được làm tròn về 0. Ký hiệu này có thể hữu ích khi một dấu hiệu tiêu cực là đáng kể; Ví dụ, khi lập bảng nhiệt độ Celsius, trong đó một dấu hiệu tiêu cực có nghĩa là dưới mức đóng băng. (Nguồn)

>>> actual_value, truncated_value = 100, 100
2

Nhờ các hoạt động vector hóa của Numpy, điều này hoạt động giống như bạn mong đợi:

>>>

>>> actual_value, truncated_value = 100, 100
3

Bây giờ, bạn là một bậc thầy tròn trịa, hãy cùng xem Python, Khoa học dữ liệu nặng nề khác: Thư viện Pandas.

Sê -ri Gấu trúc tròn và DataFrame

Thư viện Pandas đã trở thành một yếu tố chính cho các nhà khoa học dữ liệu và các nhà phân tích dữ liệu làm việc trong Python. Theo lời của Joe Wyndham thực sự của Python:

Pandas là một người thay đổi trò chơi cho khoa học và phân tích dữ liệu, đặc biệt nếu bạn đến Python vì bạn đang tìm kiếm một thứ gì đó mạnh mẽ hơn Excel và VBA. (Nguồn)

Hai cấu trúc dữ liệu gấu trúc chính là 

>>> def truncate(n):
...     return int(n * 1000) / 1000
08, theo thuật ngữ rất lỏng lẻo hoạt động giống như bảng tính Excel và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
09, mà bạn có thể nghĩ như một cột trong bảng tính. Cả hai đối tượng 
>>> def truncate(n):
...     return int(n * 1000) / 1000
09 và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
08 cũng có thể được làm tròn hiệu quả bằng các phương pháp 
>>> def truncate(n):
...     return int(n * 1000) / 1000
12 và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
13:

>>>

>>> actual_value, truncated_value = 100, 100
4

Bây giờ, bạn là một bậc thầy tròn trịa, hãy cùng xem Python, Khoa học dữ liệu nặng nề khác: Thư viện Pandas.

>>>

>>> actual_value, truncated_value = 100, 100
5

Bây giờ, bạn là một bậc thầy tròn trịa, hãy cùng xem Python, Khoa học dữ liệu nặng nề khác: Thư viện Pandas.

>>>

>>> actual_value, truncated_value = 100, 100
6

Bây giờ, bạn là một bậc thầy tròn trịa, hãy cùng xem Python, Khoa học dữ liệu nặng nề khác: Thư viện Pandas.

>>>

>>> actual_value, truncated_value = 100, 100
7

Sê -ri Gấu trúc tròn và DataFrame

Thư viện Pandas đã trở thành một yếu tố chính cho các nhà khoa học dữ liệu và các nhà phân tích dữ liệu làm việc trong Python. Theo lời của Joe Wyndham thực sự của Python:

Pandas là một người thay đổi trò chơi cho khoa học và phân tích dữ liệu, đặc biệt nếu bạn đến Python vì bạn đang tìm kiếm một thứ gì đó mạnh mẽ hơn Excel và VBA. (Nguồn)

Hai cấu trúc dữ liệu gấu trúc chính là 

>>> def truncate(n):
...     return int(n * 1000) / 1000
08, theo thuật ngữ rất lỏng lẻo hoạt động giống như bảng tính Excel và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
09, mà bạn có thể nghĩ như một cột trong bảng tính. Cả hai đối tượng 
>>> def truncate(n):
...     return int(n * 1000) / 1000
09 và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
08 cũng có thể được làm tròn hiệu quả bằng các phương pháp 
>>> def truncate(n):
...     return int(n * 1000) / 1000
12 và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
13:

Phương pháp >>> def truncate(n): ... return int(n * 1000) / 1000 13 cũng có thể chấp nhận từ điển hoặc >>> def truncate(n): ... return int(n * 1000) / 1000 09, để chỉ định độ chính xác khác nhau cho mỗi cột. Chẳng hạn, các ví dụ sau đây cho thấy cách làm tròn cột đầu tiên của >>> def truncate(n): ... return int(n * 1000) / 1000 16 đến một vị trí thập phân, vị trí thứ hai đến hai và vị trí thứ ba đến ba thập phân:

Nếu bạn cần sự linh hoạt làm tròn hơn, bạn có thể áp dụng các hàm Numpy ____ ____204, 

# không có tham số ndigits 
print(round(10))
print(round(10.7))
print(round(5.5))
print(round(5.4))
print(round(6.8))
print(round(0.1))
print(round(0.7))
57 và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
19 cho các đối tượng Pandas 
>>> def truncate(n):
...     return int(n * 1000) / 1000
09 và 
>>> def truncate(n):
...     return int(n * 1000) / 1000
08:

Hàm 

10
11
6
5
7
0
1
70 đã sửa đổi từ phần trước cũng sẽ hoạt động ở đây:

Xin chúc mừng, bạn rất tốt trên đường để làm tròn thành thạo! Bây giờ bạn biết rằng có nhiều cách để làm tròn một số hơn là có sự kết hợp của taco. .

Có một bước nữa: biết khi nào nên áp dụng chiến lược phù hợp.

Các ứng dụng và thực tiễn tốt nhất

Sự kéo dài cuối cùng trên con đường của bạn để làm tròn sự điêu luyện là sự hiểu biết khi nào nên áp dụng kiến ​​thức mới của bạn. Trong phần này, bạn sẽ học một số thực tiễn tốt nhất để đảm bảo bạn làm tròn số của mình đúng cách.

Lưu trữ nhiều hơn và tròn muộn

Khi bạn xử lý các bộ dữ liệu lớn, lưu trữ có thể là một vấn đề. Trong hầu hết các cơ sở dữ liệu quan hệ, mỗi cột trong bảng được thiết kế để lưu trữ một loại dữ liệu cụ thể và các loại dữ liệu số thường được gán chính xác để giúp bảo tồn bộ nhớ.

Ví dụ, một cảm biến nhiệt độ có thể báo cáo nhiệt độ trong lò công nghiệp kéo dài cứ sau mười giây chính xác đến tám chữ số thập phân. Các bài đọc từ điều này được sử dụng để phát hiện sự dao động bất thường về nhiệt độ có thể chỉ ra sự thất bại của một yếu tố sưởi ấm hoặc một số thành phần khác. Vì vậy, có thể có một kịch bản Python chạy so sánh mỗi lần đọc đến cuối cùng để kiểm tra các biến động lớn.

Các bài đọc từ cảm biến này cũng được lưu trữ trong cơ sở dữ liệu SQL để nhiệt độ trung bình hàng ngày bên trong lò có thể được tính toán mỗi ngày vào nửa đêm. Nhà sản xuất phần tử sưởi ấm bên trong lò khuyến nghị thay thế thành phần bất cứ khi nào nhiệt độ trung bình hàng ngày giảm 

>>> def truncate(n):
...     return int(n * 1000) / 1000
25 độ dưới mức bình thường.

Làm thế nào các tình huống như thế này được xử lý thường được xác định bởi một chính phủ quốc gia. Bạn có thể tìm thấy một danh sách các phương pháp làm tròn được sử dụng bởi các quốc gia khác nhau trên Wikipedia.

Nếu bạn đang thiết kế phần mềm để tính toán tiền tệ, bạn phải luôn kiểm tra luật pháp và quy định địa phương tại các địa điểm của người dùng.

Khi nghi ngờ, các mối quan hệ tròn để thậm chí

Khi bạn làm tròn các số trong các bộ dữ liệu lớn được sử dụng trong các tính toán phức tạp, mối quan tâm chính là hạn chế sự tăng trưởng của lỗi do làm tròn.

Trong tất cả các phương pháp mà chúng tôi đã thảo luận trong bài viết này, một nửa làm tròn cho chiến lược thậm chí của người dùng giảm thiểu sự thiên vị làm tròn tốt nhất. May mắn thay, Python, Numpy và Pandas đều mặc định cho chiến lược này, vì vậy bằng cách sử dụng các chức năng làm tròn tích hợp mà bạn đã được bảo vệ tốt!

Bản tóm tắt

Whew! Thật là một hành trình này đã được!

Trong bài viết này, bạn đã học được điều đó:

  • Có nhiều chiến lược làm tròn khác nhau, bây giờ bạn biết cách thực hiện trong Python thuần túy.

  • Mỗi chiến lược làm tròn vốn đã đưa ra một thiên vị làm tròn, và một nửa làm tròn cho chiến lược thậm chí là giảm thiểu sự thiên vị này, hầu hết thời gian.

  • Cách mà các máy tính lưu trữ các số điểm nổi trong bộ nhớ tự nhiên đưa ra một lỗi làm tròn tinh tế, nhưng bạn đã học được cách làm việc xung quanh điều này với mô-đun 

    print(round(2.665, 2))
print(round(50.25556, 2))
print(round(100.000056, 3))
print(round(80.23456, 2))
print(round(122.145,5))
    08 trong thư viện tiêu chuẩn Python.

  • Bạn có thể làm tròn các mảng numpy và gấu trúc 

    >>> def truncate(n):
...     return int(n * 1000) / 1000
    09 và 
    >>> def truncate(n):
...     return int(n * 1000) / 1000
    08 đối tượng.

  • Có những thực tiễn tốt nhất để làm tròn với dữ liệu trong thế giới thực.

Nếu bạn quan tâm đến việc tìm hiểu thêm và đào sâu vào các chi tiết lớn của tất cả mọi thứ chúng tôi đã đề cập, các liên kết dưới đây sẽ khiến bạn bận rộn khá lâu.

Ít nhất, nếu bạn đã thích bài viết này và học được điều gì đó mới từ nó, hãy chuyển nó cho một người bạn hoặc thành viên trong nhóm! Hãy chắc chắn để chia sẻ suy nghĩ của bạn với chúng tôi trong các ý kiến. Chúng tôi rất thích nghe một số câu chuyện chiến đấu liên quan đến làm tròn của riêng bạn!

Happy Pythoning!

Tài nguyên bổ sung

Chiến lược làm tròn và thiên vị:

  • Vòng tròn, Wikipedia
  • Các số làm tròn mà không cần thêm sai lệch, từ zipcpu

Thông số kỹ thuật nổi và số thập phân:

  • IEEE-754, Wikipedia
  • Thông số số học thập phân chung của IBM

Những bài đọc thú vị:

  • Những gì mọi nhà khoa học máy tính nên biết về số học nổi, David Goldberg, Khảo sát điện toán ACM, tháng 3 năm 1991
  • Số học dấu nổi: Các vấn đề và hạn chế, từ python.org
  • Tại sao các tầng phân chia số nguyên Python, bởi Guido Van Rossum

programming python ROUND_UP trong Python Làm tròn float Hàm ceil

Bài Viết Liên Quan

C11 viện kiểm sát tối cao là gì năm 2024
C11 viện kiểm sát tối cao là gì năm 2024

là ai Hỏi Đáp Là gì
Giảng giải chú đại bi thầy tuyên hóa năm 2024
Giảng giải chú đại bi thầy tuyên hóa năm 2024

mẹo hay Kinh giảng
Amoxicillin 500 mg là thuốc gì năm 2024
Amoxicillin 500 mg là thuốc gì năm 2024

là ai Khỏe Đẹp Thuốc Thuốc Amoxicillin 500mg
Giải bài tập toán lớp 9 tập 2 trang 56 năm 2024
Giải bài tập toán lớp 9 tập 2 trang 56 năm 2024

mẹo hay Khỏe Đẹp Bài tập
Top 10 loai rồng có that ngoài đời năm 2024
Top 10 loai rồng có that ngoài đời năm 2024

mẹo hay Top List Top Con rồng thật Rồng phương Tây
Lĩnh vực dịch vụ là gì năm 2024
Lĩnh vực dịch vụ là gì năm 2024

là ai Hỏi Đáp Là gì Ngôn ngữ Dịch
Bài tập much many a lot of lots năm 2024
Bài tập much many a lot of lots năm 2024

mẹo hay Khỏe Đẹp Bài tập A lot of
Sql học sinh có điểm trung bình cao năm 2024
Sql học sinh có điểm trung bình cao năm 2024

mẹo hay Học Tốt Học
Huyết áp cao là triệu chứng bệnh gì năm 2024
Huyết áp cao là triệu chứng bệnh gì năm 2024

là ai
Bài tập lý 10 3 định luật newton violet năm 2024
Bài tập lý 10 3 định luật newton violet năm 2024

mẹo hay Khỏe Đẹp Bài tập
Đề tài thực tập kế toán nào dễ nhất năm 2024
Đề tài thực tập kế toán nào dễ nhất năm 2024

mẹo hay
As old as the hills nghĩa là gì năm 2024
As old as the hills nghĩa là gì năm 2024

là ai Hỏi Đáp Là gì Ngôn ngữ Nghĩa là gì
Giải sách bài tập vật lý 8 bài 3 năm 2024
Giải sách bài tập vật lý 8 bài 3 năm 2024

mẹo hay Khỏe Đẹp Bài tập Học Tốt Sách
Chỉ số bpd của thai nhi là gì năm 2024
Chỉ số bpd của thai nhi là gì năm 2024

là ai Hỏi Đáp Là gì
Mua hóa đơn hộ kinh doanh cá thể năm 2024
Mua hóa đơn hộ kinh doanh cá thể năm 2024

mẹo hay
Bài 1 trang 167 sgk toán 4 tính năm 2024
Bài 1 trang 167 sgk toán 4 tính năm 2024

mẹo hay
Báo cáo thực tập kế toán tiền lương file word năm 2024
Báo cáo thực tập kế toán tiền lương file word năm 2024

mẹo hay Công Nghệ File
Trích lục đăng ký kết hôn là gì năm 2024
Trích lục đăng ký kết hôn là gì năm 2024

là ai Hỏi Đáp Là gì
Bài 24 sgk toán 8 tập 2 trang 72 năm 2024
Bài 24 sgk toán 8 tập 2 trang 72 năm 2024

mẹo hay
Bài tập chương tứ giác chương ii lớp 8 năm 2024
Bài tập chương tứ giác chương ii lớp 8 năm 2024

mẹo hay Khỏe Đẹp Bài tập Giải toán Google giải toán

Quảng Cáo

Có thể bạn quan tâm

Ngừoi hay review về đồ ăn gọi là gì năm 2024
1 ngày trước . bởi AcousticSemifinal
Mua sắm hàng hóa dưới 20 triệu nhập vào misa năm 2024
1 ngày trước . bởi SoggyLiquidation
Chỉ số dẻo của đất tiếng anh là gì năm 2024
1 ngày trước . bởi UntenableHardship
1 văn bản của bộ giáo dục hoa kỳ năm 2024
1 ngày trước . bởi SubjectiveCollision
Camera của hãng điện thoại nào tốt nhất năm 2024
1 ngày trước . bởi WiseOpposition
Mục tiêu và phạm vi dự án là gì năm 2024
1 ngày trước . bởi BoundSalvation
Bộ đề 9 điểm luyện thi môn toán thpt năm 2024
1 ngày trước . bởi PaddedBondage
Phạt nộp chậm tờ khai quyết toán thuế tncn năm 2024
1 ngày trước . bởi BlatantIllness
Lễ giáng sinh tiếng anh là gì năm 2024
1 ngày trước . bởi CommandingSuburb
Quy trình lập dự toán chuẩn bị đầu tư năm 2024
1 ngày trước . bởi CommonResignation

Toplist được quan tâm

#1
Top 9 tập bản đồ lớp 8 bài 31 2023
6 tháng trước
#2
Top 6 kết quả thi hsg đà nẵng 2022 2023
6 tháng trước
#3
Top 9 tủ nhựa đài loan 4 cánh 3d 2023
6 tháng trước
#4
Top 9 chất khí có thể làm mất màu dung dịch nước brom là: a. so2. b. co2. c. o2. d. hcl. 2023
6 tháng trước
#5
Top 8 tìm việc làm tiện, phay bảo q7 2023
6 tháng trước
#6
Top 3 tôi xuyên thành tiểu kiều the của lão đại phản 2 2023
6 tháng trước
#7
Top 9 đổi mới phong cách, thái độ phục vụ của cán bộ y tế hướng tới sự hài lòng của người bệnh 2023
6 tháng trước
#8
Top 2 bài the dục phát triển chung lớp 6 2022 2023
6 tháng trước
#9
Top 3 bài giảng vũ điệu sắc màu (lớp 4) 2023
6 tháng trước

Quảng cáo

Xem Nhiều

Nghiệp vụ tín dụng ngân hàng là gì năm 2024
2 ngày trước . bởi NutritionalBuilding
Bài tập cấu hình electron nguyên tử khó năm 2024
3 ngày trước . bởi HumidTiger
Ngày 14 3 là ngày gì năm 2024
3 ngày trước . bởi UnrealConspiracy
Chuỗi phương trình hóa hữu cơ có lời giải năm 2024
1 tuần trước . bởi BenevolentCondominium
Mục đích sử dụng đất 2l 19 năm là gì năm 2024
4 ngày trước . bởi UnreliableBounds
Lỗi giựt màn hình trong fifa online 3 năm 2024
1 tuần trước . bởi IncrementalDoorstep
Ip6 plus và 6s plus khác nhau như thế nào năm 2024
1 tuần trước . bởi Front-pageNoodle
Danh ngôn trong tiếng anh là gì năm 2024
1 tuần trước . bởi MarvelousEmancipation
Top 10 luong cau thu cao nhat the gioi năm 2024
6 ngày trước . bởi OngoingInspiration
Tóm tắt lý thuyết hóa 10 học kì 1 năm 2024
1 tuần trước . bởi LovedMusician

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội

DMCA.com Protection Status
Bản quyền © 2021 Xây Nhà Inc.