Hướng dẫn how do you control decimal places in python? - làm thế nào để bạn kiểm soát vị trí thập phân trong python?

Tldr;)

Vấn đề làm tròn của đầu vào và đầu ra đã được giải quyết dứt khoát bằng Python 3.1 và bản sửa lỗi cũng được đưa vào Python 2.7.0.solved definitively by Python 3.1 and the fix is backported also to Python 2.7.0.

Các số tròn có thể được chuyển đổi đảo ngược giữa phao và chuỗi qua lại:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

>>> 0.3
0.3
>>> float(repr(0.3)) == 0.3
True

Một loại

round(12.54673, 2)
# Returns: 12.55

Kết quả của các hoạt động số học phải được làm tròn một lần nữa vì các lỗi làm tròn có thể tích lũy không chính xác hơn so với điều đó có thể xảy ra sau khi phân tích một số. Không được cố định bởi thuật toán

round(12.54673, 2)
# Returns: 12.55

round(12.54673, 2)
# Returns: 12.55

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

The output string function

round(12.54673, 2)
# Returns: 12.55

Bài kiểm tra

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Tài liệu

Xem Ghi chú phát hành Python 2.7 - Ngôn ngữ khác thay đổi đoạn thứ tư:

Chuyển đổi giữa các số dấu phẩy động và chuỗi hiện được làm tròn chính xác trên hầu hết các nền tảng. Những chuyển đổi này xảy ra ở nhiều nơi khác nhau: str () trên phao và số phức; các nhà xây dựng nổi và phức tạp; định dạng số; tuần tự hóa và khử tự động các phao và số phức bằng các mô-đun

round(12.54673, 2)
# Returns: 12.55

3,

round(12.54673, 2)
# Returns: 12.55

4 và

round(12.54673, 2)
# Returns: 12.55

5; phân tích cú pháp phao và văn học tưởng tượng trong mã Python; và chuyển đổi thập phân sang phao. between floating-point numbers and strings are now correctly rounded on most platforms. These conversions occur in many different places: str() on floats and complex numbers; the float and complex constructors; numeric formatting; serializing and de-serializing floats and complex numbers using the

round(12.54673, 2)
# Returns: 12.55

3,

round(12.54673, 2)
# Returns: 12.55

4 and

round(12.54673, 2)
# Returns: 12.55

5 modules; parsing of float and imaginary literals in Python code; and Decimal-to-float conversion.

Liên quan đến điều này, phần repr () của số điểm nổi x hiện đang trả về kết quả dựa trên chuỗi thập phân ngắn nhất mà Lọ đảm bảo quay trở lại X dưới cách làm tròn chính xác (với chế độ làm tròn nửa vòng tròn). Trước đây, nó đã đưa ra một chuỗi dựa trên làm tròn x đến 17 chữ số thập phân.repr() of a floating-point number x now returns a result based on the shortest decimal string that’s guaranteed to round back to x under correct rounding (with round-half-to-even rounding mode). Previously it gave a string based on rounding x to 17 decimal digits.

Vấn đề liên quan

Thông tin thêm: Định dạng

round(12.54673, 2)
# Returns: 12.55

round(12.54673, 2)
# Returns: 12.55

round(12.54673, 2)
# Returns: 12.55

round(12.54673, 2)
# Returns: 12.55

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

round(12.54673, 2)
# Returns: 12.55

round(12.54673, 2)
# Returns: 12.55

round(12.54673, 2)
# Returns: 12.55

round(12.54673, 2)
# Returns: 12.55

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Python có một số tùy chọn để làm tròn đến một số toàn bộ. Nhưng điều gì sẽ xảy ra nếu chúng ta muốn làm tròn đến một số chữ số thập phân, như 2 chữ số thập phân? Hãy để xem cách chúng ta làm điều đó.

Trong bài viết này:

• Giá trị python tròn cho hai vị trí số thập phân (và hơn thế nữa)
• Vòng thập phân tròn lên xuống:

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  1
  • Ví dụ: Các chữ số thập phân tròn lên xuống
• Vòng thập phân ở Python
  • Ví dụ: Làm tròn đến 2 chữ số thập phân
• Vòng thập phân tròn xuống ở Python
  • Ví dụ: Làm tròn xuống 2 chữ số thập phân
• Vòng thập phân của danh sách và mảng
  • Danh sách các vòng đến các vị trí thập phân với danh sách hiểu biết
  • Danh sách tròn đến các vị trí thập phân với vòng lặp Python
  • Mảng Python tròn đến 2 chữ số thập phân
  • Vòng numpy mảng đến hai chữ số thập phân
• Bản tóm tắt

# Vòng Python giá trị đến hai vị trí số thập phân (và hơn thế nữa)

Mặc dù làm tròn vào một số toàn bộ là hữu ích, nhưng vẫn có rất nhiều tình huống mà chúng ta cần phải làm tròn đến một số vị trí thập phân nhất định. Ví dụ, tiền tệ được báo cáo tốt nhất với 2 chữ số thập phân. Và mức độ lỗi và ý nghĩa thường sử dụng nhiều chữ số hơn, như 5.

Python có một số cách để các chữ số thập phân tròn:

• Hàm

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  1 làm tròn số thập phân lên xuống. Điều này làm cho

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  4 thành

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  5 và

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  6 thành

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  7.
• Để làm tròn các vị trí thập phân, chúng ta phải sử dụng một chức năng tùy chỉnh. Theo cách đó

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  8 trở thành

  # Some numerical values
  valueA = 3.14159265359
  valueB = 1845.7409947
  valueC = -100.95
  valueD = 9.5432
  valueE = 34.49953
  
  # Round to different decimal places
  roundA = round(valueA, 5)
  roundB = round(valueB, 4)
  roundC = round(valueC, 3)
  roundD = round(valueD, 2)
  roundE = round(valueE, 1)
  
  # Output rounded values
  print("Value:".ljust(15), "Rounded:")
  
  print(str(valueA).ljust(15), roundA)
  print(str(valueB).ljust(15), roundB)
  print(str(valueC).ljust(15), roundC)
  print(str(valueD).ljust(15), roundD)
  print(str(valueE).ljust(15), roundE)
  

  9.
• Để làm tròn các vị trí thập phân xuống, chúng tôi sử dụng một chức năng tùy chỉnh. Điều đó biến

  Value:          Rounded:
  3.14159265359   3.14159
  1845.7409947    1845.741
  -100.95         -100.95
  9.5432          9.54
  34.49953        34.5
  

  0 thành

  Value:          Rounded:
  3.14159265359   3.14159
  1845.7409947    1845.741
  -100.95         -100.95
  9.5432          9.54
  34.49953        34.5
  

  1.

Hãy cùng xem xét từng cách tiếp cận và mã Python mà họ yêu cầu.

# Vòng thập phân vị trí lên xuống: # Some numerical values valueA = 3.14159265359 valueB = 1845.7409947 valueC = -100.95 valueD = 9.5432 valueE = 34.49953 # Round to different decimal places roundA = round(valueA, 5) roundB = round(valueB, 4) roundC = round(valueC, 3) roundD = round(valueD, 2) roundE = round(valueE, 1) # Output rounded values print("Value:".ljust(15), "Rounded:") print(str(valueA).ljust(15), roundA) print(str(valueB).ljust(15), roundB) print(str(valueC).ljust(15), roundC) print(str(valueD).ljust(15), roundD) print(str(valueE).ljust(15), roundE) 1

Với chức năng Python từ

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Vì vậy, để làm tròn đến 2 số thập phân chúng tôi làm:

round(12.54673, 2)
# Returns: 12.55

# Ví dụ: Các chữ số thập phân tròn lên xuống

Để xem cách thức hoạt động

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Mã này đầu tiên làm cho năm biến dấu phẩy động. Mỗi số có một số số sau điểm thập phân (

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Sau đó, chúng tôi làm tròn mỗi nơi đến một số vị trí thập phân. Chúng tôi gọi hàm

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

Sau đó, hàm Python từ

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

# Vòng thập phân ở Python

Một lựa chọn khác là luôn luôn làm tròn một số chữ số thập phân. Đó là ví dụ như những gì các công ty làm: thay vì giá tròn lên hoặc giảm, các giá trị như

round_decimals_up(8.343)
# Returns: 8.35

Python, tuy nhiên, không có chức năng tích hợp cho điều đó. Nhưng chúng ta có thể làm cho riêng mình và tận dụng chức năng

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

Ở đây, cách chúng tôi mã hóa chức năng

round_decimals_up(8.343)
# Returns: 8.35

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

Hàm này có hai tham số: giá trị thành vòng (

round_decimals_up(8.343)
# Returns: 8.35

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

Mã chức năng có hai phần. Đầu tiên xác nhận và xử lý tham số

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

Đối với xác nhận đó, chúng tôi sử dụng câu lệnh của Python đã được đưa ra. Điều kiện đầu tiên có

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

Tiếp theo, chúng tôi kiểm tra xem

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

Thử nghiệm

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

round_decimals_up(8.343)
# Returns: 8.35

Sau đó, chúng ta đến phần thứ hai của hàm. Đây là nơi chúng tôi làm tròn thực tế đến các vị trí thập phân. Nhưng trước tiên chúng tôi xác định hệ số hiệu chỉnh. Để có được giá trị đó, chúng tôi nâng

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Tiếp theo chúng tôi gọi hàm

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Giả sử chức năng nên tròn

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

round_decimals_up(8.343)
# Returns: 8.35

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

# Ví dụ: Làm tròn đến 2 chữ số thập phân

Để xem cách tương tác với hàm

round_decimals_up(8.343)
# Returns: 8.35

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Chương trình này lần đầu tiên nhập mô -đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

round_decimals_up(8.343)
# Returns: 8.35

Sau đó, chúng tôi thực hiện năm biến (

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Vì vậy, chúng tôi gọi hàm

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

Hàm

round_decimals_up(8.343)
# Returns: 8.35

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

# Vòng thập phân ở Python

Cách thứ ba để xử lý các chữ số thập phân là luôn luôn làm tròn. Đây là những gì một giáo viên nghiêm ngặt có thể sử dụng: thay vì vòng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Không có chức năng tích hợp trong Python cho loại làm tròn đó. Nhưng chúng ta có thể xây dựng của riêng mình và tận dụng chức năng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Điều đó hoạt động độc đáo. Bây giờ, hãy để mã mà chức năng tùy chỉnh đó:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Phần lớn chức năng này giống như hàm tùy chỉnh khác (

round_decimals_up(8.343)
# Returns: 8.35

Sự khác biệt chính là bây giờ chúng tôi sử dụng chức năng

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

round_decimals_up(8.343)
# Returns: 8.35

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

import math


def round_decimals_up(number:float, decimals:int=2):
    """
    Returns a value rounded up to a specific number of decimal places.
    """
    if not isinstance(decimals, int):
        raise TypeError("decimal places must be an integer")
    elif decimals < 0:
        raise ValueError("decimal places has to be 0 or more")
    elif decimals == 0:
        return math.ceil(number)

    factor = 10 ** decimals
    return math.ceil(number * factor) / factor


# Some numbers to round
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to values to a different number of decimal places
roundA = round_decimals_up(valueA)
roundB = round_decimals_up(valueB)
roundC = round_decimals_up(valueC)
roundD = round_decimals_up(valueD)
roundE = round_decimals_up(valueE)

# Output the results
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Giả sử chúng tôi yêu cầu chức năng tròn

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Value:          Rounded:
3.14159265359   3.15
1845.7409947    1845.75
-100.95         -100.95
9.5432          9.55
34.49953        34.5

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

# Ví dụ: Làm tròn xuống 2 chữ số thập phân

Hãy để xem làm thế nào mà chức năng trên hoạt động trong thực tế. Chương trình nhỏ này có chức năng làm tròn 5 giá trị khác nhau:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Đầu tiên chúng tôi nhập mô -đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Sau đó, chúng tôi thực hiện năm biến (

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Value:          Rounded:
3.14159265359   3.14159
1845.7409947    1845.741
-100.95         -100.95
9.5432          9.54
34.49953        34.5

Vì vậy, chúng tôi liên tục thực hiện

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

Bit cuối cùng của mã đầu ra kết quả với hàm

round_decimals_up(8.343)
# Returns: 8.35

round_decimals_up(8.343)
# Returns: 8.35

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

# Vòng thập phân của danh sách và mảng Python

Các ví dụ trên luôn làm tròn một giá trị tại một thời điểm. Tuy nhiên, đôi khi, chúng tôi có một chuỗi với các giá trị mà chúng tôi muốn làm tròn đến một số chữ số thập phân. Hãy cùng xem cách làm như vậy trong Python.

# Danh sách các vòng đến các vị trí thập phân với danh sách hiểu biết

Một tùy chọn là làm tròn mọi giá trị với sự hiểu biết danh sách. Điều này chỉ cần một chút mã và chạy hiệu quả. Một danh sách hiểu hoạt động tốt nhất khi mã của bạn không phức tạp. Đơn giản chỉ cần làm tròn các giá trị đáp ứng dấu hiệu đó.

Ở đây, một ví dụ nhanh chóng:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Ở đây, một chương trình nhỏ làm tròn mọi giá trị trong danh sách:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Trước tiên chúng tôi nhập mô -đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

round_decimals_up(8.343)
# Returns: 8.35

Tiếp theo chúng tôi lập một danh sách với các con số. Danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Các vòng đầu tiên mọi giá trị danh sách đến hai vị trí thập phân (lên và xuống) với hàm

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Độ hiểu hiểu danh sách thứ hai có hàm

round_decimals_up(8.343)
# Returns: 8.35

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Chương trình Bit Bit của mã đầu ra cuối cùng tất cả bốn danh sách với chức năng

round_decimals_up(8.343)
# Returns: 8.35

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Trong ví dụ trên, chúng tôi đã thực hiện các danh sách mới với danh sách hiểu. Nếu bạn không cần phải giữ các giá trị danh sách ban đầu, thì việc hiểu danh sách cũng có thể ghi đè lên danh sách hiện có. Để làm như vậy, chúng tôi đặt giá trị danh sách thành kết của kết quả của danh sách hiểu:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

# Danh sách tròn đến các vị trí thập phân với vòng lặp Python # Some numerical values valueA = 3.14159265359 valueB = 1845.7409947 valueC = -100.95 valueD = 9.5432 valueE = 34.49953 # Round to different decimal places roundA = round(valueA, 5) roundB = round(valueB, 4) roundC = round(valueC, 3) roundD = round(valueD, 2) roundE = round(valueE, 1) # Output rounded values print("Value:".ljust(15), "Rounded:") print(str(valueA).ljust(15), roundA) print(str(valueB).ljust(15), roundB) print(str(valueC).ljust(15), roundC) print(str(valueD).ljust(15), roundD) print(str(valueE).ljust(15), roundE) 2

Cách thứ hai để các giá trị danh sách tròn là với vòng lặp

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Như một ví dụ nhanh:

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Danh sách

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Chương trình nhỏ này làm tròn danh sách các giá trị với

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Trước tiên chúng tôi nhập mô -đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

round_decimals_up(8.343)
# Returns: 8.35

Sau đó, chúng tôi lập một danh sách với một số giá trị dấu phẩy động, cả tích cực và tiêu cực. Sau đó, chúng tôi mã hóa ba danh sách trống (

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Để thực hiện điều đó, chúng tôi tạo ra một vòng lặp

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Chương trình Bit Bit của mã cuối cùng sau đó xuất ra danh sách ban đầu và các dẫn xuất tròn của nó. Ở đây, những gì hiển thị:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Không cần các giá trị danh sách ban đầu? Trong trường hợp đó, bạn không phải lập một danh sách mới, riêng biệt. Thay vào đó, bạn có thể ghi đè lên một nơi hiện có. Một chức năng hữu ích cho điều đó là Python từ

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

# Mảng Python tròn đến 2 chữ số thập phân

Tất nhiên chúng ta cũng có thể làm tròn các bộ sưu tập khác hơn danh sách. Ở đây, cách chúng ta làm tròn mọi giá trị trong một mảng Python đến 2 số thập phân:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Đầu tiên chúng tôi nhập hàm tạo

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Sau đó, chúng tôi xây dựng một mảng thứ hai. Cái này có các giá trị từ mảng ban đầu được làm tròn đến 2 thập phân. Để thực hiện điều đó, chúng tôi sử dụng một danh sách hiểu. Đó là làm tròn từng giá trị thành hai chữ số thập phân (

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Hàm

round_decimals_up(8.343)
# Returns: 8.35

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Bạn có cần phải giữ các giá trị mảng ban đầu không? Trong trường hợp đó, bạn có thể ghi đè lên mảng hiện có với các giá trị tròn của nó. Đây là cách: làm thế nào:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

# Vòng numpy mảng đến hai chữ số thập phân

Tất nhiên chúng ta cũng có thể làm tròn các giá trị của các mảng khác. Một ví dụ là những người từ gói lập trình số numpy cho Python. Để làm tròn một mảng numpy đến hai vị trí thập phân chúng tôi làm:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Trước tiên chúng tôi nhập mô -đun

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Sau đó, chúng tôi làm tròn mảng ban đầu đến hai chữ số thập phân. Vì vậy, chúng tôi gọi hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Bit cuối cùng của mã đầu ra cả mảng gốc và tròn. Điều đó cho thấy cách các giá trị được làm tròn độc đáo đến 2 thập phân:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

Hàm

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

round_decimals_up(8.343)
# Returns: 8.35

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Khi chúng tôi sử dụng các hàm đó trong một danh sách hiểu, chúng có thể làm tròn từng giá trị từ một mảng numpy. Ví dụ:

import random
from decimal import Decimal
for _ in range(1000000):
    x = random.random()
    assert x == float(repr(x)) == float(Decimal(repr(x)))  # Reversible repr()
    assert str(x) == repr(x)
    assert len(repr(round(x, 12))) <= 14         # no excessive decimal places.

ĐỌC THÊM

• Vòng python giá trị cho một số toàn bộ.
• Cắt ngắn giá trị python thành một số
• Cắt ngắn đến một số vị trí thập phân nhất định trong Python

# Bản tóm tắt

Có ba cách để số tròn đến một số vị trí thập phân nhất định. Để làm tròn và xuống, chúng tôi sử dụng chức năng Python từ ____41. Đối số đầu tiên chúng tôi đưa ra chức năng đó là số đến tròn. Đối số thứ hai số lượng vị trí thập phân để làm tròn đến.

Python không có chức năng luôn làm tròn các chữ số thập phân (

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

round_decimals_up(8.343)
# Returns: 8.35

Không có chức năng nào luôn làm tròn các chữ số thập phân (

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

>>> 0.1 + 0.2
0.30000000000000004
>>> 0.1, 0.2, 0.3
(0.1, 0.2, 0.3)

Để làm tròn mọi giá trị trong danh sách hoặc mảng, chúng ta có thể sử dụng vòng lặp hiểu biết hoặc vòng lặp

# Some numerical values
valueA = 3.14159265359
valueB = 1845.7409947
valueC = -100.95
valueD = 9.5432
valueE = 34.49953

# Round to different decimal places
roundA = round(valueA, 5)
roundB = round(valueB, 4)
roundC = round(valueC, 3)
roundD = round(valueD, 2)
roundE = round(valueE, 1)

# Output rounded values
print("Value:".ljust(15), "Rounded:")

print(str(valueA).ljust(15), roundA)
print(str(valueB).ljust(15), roundB)
print(str(valueC).ljust(15), roundC)
print(str(valueD).ljust(15), roundD)
print(str(valueE).ljust(15), roundE)

Người giới thiệu

Lutz, M. (2013). Học Python (Phiên bản thứ 5). Sebastopol, CA: O hèReilly Media.

Sweigart, A. (2015). Tự động hóa những thứ nhàm chán với Python: Lập trình thực tế cho toàn bộ người mới bắt đầu. San Francisco, CA: Không có báo chí tinh bột.

Python.org (N.D.). Chức năng tích hợp sẵn. Truy cập vào ngày 8 tháng 11 năm 2019, từ https://docs.python.org/3/l Library/fives.html

Cập nhật lần cuối vào ngày 9 tháng 9 năm 2020 (xuất bản ngày 20 tháng 12 năm 2019).

«Tất cả các bài báo Python