Hướng dẫn math floor to 2 decimal places python - tầng toán học đến 2 chữ số thập phân python

Có vẻ như bạn muốn cắt ngắn, không làm tròn.

Một cách đơn giản sẽ là kết hợp phân chia sàn

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

6 và bộ phận thông thường

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

7:

>>> a = 28.266
>>> a // 0.01 / 100
28.26

Thay vì bộ phận thông thường, bạn cũng có thể nhân [như đã lưu ý trong các bình luận của CMC]:

>>> a // 0.01 * 0.01
28.26

Tương tự, bạn có thể tạo một hàm để làm tròn xuống số thập phân khác/ít hơn. Nhưng bởi vì phao là những con số không chính xác, điều này có thể dẫn đến sự không chính xác.

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

Nhưng như đã nói, nó không chính xác chính xác:

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

0 12.0
1 12.3
2 12.33
3 12.333
4 12.333300000000001 # weird, but almost correct
5 12.33332           # wrong
6 12.33333
7 12.33333

Có những cách tiếp cận khác [chính xác hơn] mặc dù:

Một giải pháp sử dụng mô -đun

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

8

A

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

8 có thể đại diện cho một số thập phân chính xác hơn nhiều so với

0 12.0
1 12.3
2 12.33
3 12.333
4 12.333300000000001 # weird, but almost correct
5 12.33332           # wrong
6 12.33333
7 12.33333

0. Sau đó, người ta có thể sử dụng phương pháp "Nhân, sau đó, sau đó chia" được đề cập bởi Psidom nhưng với độ chính xác cao hơn đáng kể:

import fractions
import math

a = 28.266

def round_down[value, decimals]:
    factor = 10 ** decimals
    f = fractions.Fraction[value]
    return fractions.Fraction[math.floor[f * factor],  factor]

print[round_down[28.266, 2]]
# 1413/50  >> a // 0.01 * 0.01
28.26

1

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

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

import fractions
import math

a = 28.266

def round_down[value, decimals]:
    factor = 10 ** decimals
    f = fractions.Fraction[value]
    return fractions.Fraction[math.floor[f * factor],  factor]

print[round_down[28.266, 2]]
# 1413/50  >> a // 0.01 * 0.01
28.26

3

# 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ư

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

3 thay vào đó luôn được làm tròn lên tới 4,55 đô la.

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

4. Khi chúng ta làm, sử dụng chức năng trông như thế này:

>>> a // 0.01 * 0.01
28.26

4

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

5:

>>> a // 0.01 * 0.01
28.26

5

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

6] và có bao nhiêu vị trí thập phân cần có [

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

7]. Khi tham số sau đó được đặt, nó mặc định là

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

8.

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

7. Thứ hai thực hiện làm tròn thực tế.

Đố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ó

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

0 xem tham số

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

7 có phải là một cái gì đó khác hơn số nguyên [

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

2] không. Khi có, chúng tôi tạo ra

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

3 để thông báo cho người dùng rằng chức năng được sử dụng sai cách.

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

7 có nằm dưới [

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

5] không. Vì hàm không biết cách xử lý các vị trí thập phân âm, chúng tôi kích hoạt

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

6 để truyền đạt điều này với người dùng chức năng.

Thử nghiệm

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

7 cuối cùng xem nếu tham số

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

7 bằng [

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

9]

>>> a // 0.01 * 0.01
28.26

00. Khi hàm phải làm tròn một giá trị mà không có vị trí thập phân, chúng ta chỉ có thể thực hiện hàm

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

4 và làm tròn đến một số toàn bộ.

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

>>> a // 0.01 * 0.01
28.26

02 lên sức mạnh của tham số

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

7. Chúng tôi lưu trữ kết quả trong biến

>>> a // 0.01 * 0.01
28.26

04.

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

4. Bên trong dấu ngoặc đơn của nó, chúng tôi chỉ định giá trị để làm tròn [

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

6] nhân với

>>> a // 0.01 * 0.01
28.26

04. Sau đó, chúng tôi chia kết quả tròn với

>>> a // 0.01 * 0.01
28.26

04 để lấy lại số lượng thập phân thích hợp.

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

>>> a // 0.01 * 0.01
28.26

09 đến 2 thập phân. Mã sau đó lần đầu tiên nhân

>>> a // 0.01 * 0.01
28.26

09 với

>>> a // 0.01 * 0.01
28.26

11 [102].

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

4 sau đó làm tròn

>>> a // 0.01 * 0.01
28.26

13 lên đến một số nguyên [

>>> a // 0.01 * 0.01
28.26

14]. Cuối cùng, chúng tôi chia trở lại với

>>> a // 0.01 * 0.01
28.26

11 để có được kết quả thành hai chữ số thập phân:

>>> a // 0.01 * 0.01
28.26

16.

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

Để xem cách tương tác với chức năng

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

5 tùy chỉnh đó, hãy để sử dụng nó trong một chương trình nhỏ:

>>> a // 0.01 * 0.01
28.26

6

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

>>> a // 0.01 * 0.01
28.26

18. Điều đó làm cho chức năng

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

4 có sẵn cho chức năng tùy chỉnh của chúng tôi, chúng tôi sao chép/dán vào chương trình tiếp theo.

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

0 12
1 123/10
2 1233/100
3 12333/1000
4 123333/10000
5 1233333/100000
6 1233333/100000
7 1233333/100000

4 đến

0 12
1 123/10
2 1233/100
3 12333/1000
4 123333/10000
5 1233333/100000
6 1233333/100000
7 1233333/100000

5]. Mỗi người có một giá trị điểm nổi với một vài chữ số thập phân. Hãy để vòng tròn giá trị của họ.

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

5 nhiều lần. Chúng tôi cung cấp cho nó một đối số: giá trị thành vòng. Hàm sau đó tự động sử dụng hai vị trí thập phân để làm tròn. Chúng tôi đặt các giá trị tròn trong các biến

0 12
1 123/10
2 1233/100
3 12333/1000
4 123333/10000
5 1233333/100000
6 1233333/100000
7 1233333/100000

9 đến

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

0.

Hàm

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

1 sau đó xuất ra giá trị ban đầu và tròn. Đây là cách chức năng làm tròn mọi biến lên đến hai chữ số thập phân:

>>> a // 0.01 * 0.01
28.26

7

# 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

>>> a // 0.01 * 0.01
28.26

26 và

>>> a // 0.01 * 0.01
28.26

27, thay vào đó anh ấy hoặc cô ấy làm tròn xuống

>>> a // 0.01 * 0.01
28.26

28 và

>>> a // 0.01 * 0.01
28.26

29.

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

>>> a // 0.01 * 0.01
28.26

30. Sử dụng một chức năng tùy chỉnh như vậy trông giống như:

>>> a // 0.01 * 0.01
28.26

8

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

>>> a // 0.01 * 0.01
28.26

9

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

5] mà chúng ta đã thảo luận trước đó.

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

>>> a // 0.01 * 0.01
28.26

30. Hàm này làm tròn tham số

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

6 nhân với biến

>>> a // 0.01 * 0.01
28.26

04 xuống. Sau đó, chúng tôi chia lại với

>>> a // 0.01 * 0.01
28.26

04 để có được số lượng thập phân phù hợp.

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

>>> a // 0.01 * 0.01
28.26

36 xuống 2 chữ số thập phân. Mã sau đó nhân lên giá trị đó với

>>> a // 0.01 * 0.01
28.26

11.

>>> a // 0.01 * 0.01
28.26

30 sau đó làm tròn

>>> a // 0.01 * 0.01
28.26

39 xuống một số toàn bộ [

>>> a // 0.01 * 0.01
28.26

40]. Khi chúng tôi chia trở lại với

>>> a // 0.01 * 0.01
28.26

11, chúng tôi sẽ nhận được số lượng số thập phân thích hợp:

>>> a // 0.01 * 0.01
28.26

42.

# 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:

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

0

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

>>> a // 0.01 * 0.01
28.26

18. Bằng cách đó, hàm

>>> a // 0.01 * 0.01
28.26

44 tùy chỉnh có thể sử dụng

>>> a // 0.01 * 0.01
28.26

30. Sau đó chúng tôi chèn chức năng tùy chỉnh đó.

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

0 12
1 123/10
2 1233/100
3 12333/1000
4 123333/10000
5 1233333/100000
6 1233333/100000
7 1233333/100000

4 đến

0 12
1 123/10
2 1233/100
3 12333/1000
4 123333/10000
5 1233333/100000
6 1233333/100000
7 1233333/100000

5]. Mỗi người giữ một giá trị với số thập phân để làm tròn xuống. Đó là những gì chúng tôi làm tiếp theo.

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

>>> a // 0.01 * 0.01
28.26

44. Mỗi lần chúng tôi đưa ra hàm hai đối số: giá trị thành vòng và số chữ số thập phân để giữ. Chúng tôi đặt kết quả trong các biến mới [

0 12
1 123/10
2 1233/100
3 12333/1000
4 123333/10000
5 1233333/100000
6 1233333/100000
7 1233333/100000

9 đến

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

0].

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

1. Chúng tôi đã đưa ra giá trị ban đầu bằng phương pháp

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

2 và cũng bao gồm giá trị tròn. Khi đầu ra hiển thị, mỗi giá trị được làm tròn xuống một số vị trí thập phân nhất định:

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

1

# 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:

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

2

Danh sách

>>> a // 0.01 * 0.01
28.26

53 mà chúng tôi thực hiện ở đây có các giá trị của nó từ một danh sách hiểu. Sự hiểu biết đó thực thi biểu thức

>>> a // 0.01 * 0.01
28.26

54 cho mọi giá trị được tạo bởi vòng lặp

import fractions
import math

a = 28.266

def round_down[value, decimals]:
    factor = 10 ** decimals
    f = fractions.Fraction[value]
    return fractions.Fraction[math.floor[f * factor],  factor]

print[round_down[28.266, 2]]
# 1413/50  >> a // 0.01 * 0.01
28.26

63.

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

5 tròn lên đến hai chữ số thập phân. Danh sách mới mà lợi nhuận này là những gì chúng tôi lưu trữ trong

>>> a // 0.01 * 0.01
28.26

65. Các vòng hiểu danh sách thứ ba và cuối cùng xuống đến hai vị trí thập phân [

>>> a // 0.01 * 0.01
28.26

44]. Kết quả của sự hiểu biết đó được lưu trữ trong danh sách

>>> a // 0.01 * 0.01
28.26

67.

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

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

1. Đây là cách các giá trị tròn đó trông như thế nào:

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

4

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:

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

5

# Danh sách tròn đến các vị trí thập phân với vòng lặp Python

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

import fractions
import math

a = 28.266

def round_down[value, decimals]:
    factor = 10 ** decimals
    f = fractions.Fraction[value]
    return fractions.Fraction[math.floor[f * factor],  factor]

print[round_down[28.266, 2]]
# 1413/50  >> a // 0.01 * 0.01
28.26

74 trong danh sách và chuyển trong giá trị tròn từ danh sách ban đầu [

>>> a // 0.01 * 0.01
28.26

54].

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

import fractions
import math

a = 28.266

def round_down[value, decimals]:
    factor = 10 ** decimals
    f = fractions.Fraction[value]
    return fractions.Fraction[math.floor[f * factor],  factor]

print[round_down[28.266, 2]]
# 1413/50  >> a // 0.01 * 0.01
28.26

57. Trong mỗi chu kỳ vòng lặp, giá trị danh sách hiện tại được truy cập với biến vòng lặp

>>> a // 0.01 * 0.01
28.26

86. Bên trong vòng lặp đó, chúng tôi nối một giá trị tròn vào mỗi trong ba danh sách với phương thức Python từ

>>> a // 0.01 * 0.01
28.26

74.

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ị:

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

8

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ừ

>>> a // 0.01 * 0.01
28.26

88. Ví dụ:

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

9

# 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:

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

0

Đầu tiên chúng tôi nhập hàm xây dựng

>>> a // 0.01 * 0.01
28.26

89 từ mô -đun

>>> a // 0.01 * 0.01
28.26

90. Sau đó, chúng tôi tạo một mảng với các giá trị dấu phẩy động. Chúng tôi đặt tên cho mảng đó

>>> a // 0.01 * 0.01
28.26

57.

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 [

>>> a // 0.01 * 0.01
28.26

54]. Chúng tôi đặt tên cho mảng mới, tròn

>>> a // 0.01 * 0.01
28.26

53.

Hàm

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

1 sau đó xuất ra mảng gốc và tròn. Như chúng ta có thể nói, mỗi giá trị được làm tròn đúng đến hai vị trí thập phân:

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

1

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:

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

2

# 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:

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

3

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

>>> a // 0.01 * 0.01
28.26

95. Sau đó, chúng tôi tạo ra một mảng numpy với hàm

>>> a // 0.01 * 0.01
28.26

96. Mảng đó có một số giá trị dấu phẩy động.

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

>>> a // 0.01 * 0.01
28.26

97 với hai đối số. Đầu tiên là mảng có giá trị đến tròn. Thứ hai là số lượng vị trí thập phân để làm tròn đến. Chúng tôi lưu trữ mảng hàm trả về trong biến

>>> a // 0.01 * 0.01
28.26

53.

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:

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

4

Hàm

>>> a // 0.01 * 0.01
28.26

97 làm tròn lên xuống. Để luôn làm tròn hoặc luôn làm tròn xuống, chúng tôi phải sử dụng các hàm

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

5 và

>>> a // 0.01 * 0.01
28.26

44 tùy chỉnh.

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ụ:

for i in range[0, 8]:
    print[i, round_down[12.33333, i]]

5

ĐỌ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ừ ____58. Đố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 [

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

03 vào

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

04]. Nhưng khi chúng ta tận dụng chức năng

import decimal

def round_down[value, decimals]:
    with decimal.localcontext[] as ctx:
        d = decimal.Decimal[value]
        ctx.rounding = decimal.ROUND_DOWN
        return round[d, decimals]

print[round_down[28.266, 2]]  # 28.26

4 trong một chức năng tùy chỉnh, chúng ta có thể dễ dàng thực hiện điều đó.

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

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

06 trở thành

def round_down[value, decimals]:
    factor = 1 / [10 ** decimals]
    return [value // factor] * factor

print[round_down[28.266, 2]]
# 28.26

07]. Nhưng khi chúng ta bọc hàm

>>> a // 0.01 * 0.01
28.26

30 trong một hàm tùy chỉnh, chúng ta có thể tự tạo hành vi đó.

Để 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

import fractions
import math

a = 28.266

def round_down[value, decimals]:
    factor = 10 ** decimals
    f = fractions.Fraction[value]
    return fractions.Fraction[math.floor[f * factor],  factor]

print[round_down[28.266, 2]]
# 1413/50