Hướng dẫn how do you find a whole number in python? - làm thế nào để bạn tìm thấy một số nguyên trong python?

Để kiểm tra xem giá trị nổi có phải là số toàn bộ không, hãy sử dụng phương thức

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

1:

>>> (1.0).is_integer()
True
>>> (1.555).is_integer()
False

Phương pháp đã được thêm vào loại

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

2 trong Python 2.6.

Có tính đến rằng trong Python 2,

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

3 là

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

4 (phân chia sàn cho các toán hạng số nguyên!), Và số học điểm nổi đó có thể không chính xác (A

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

2 là một xấp xỉ sử dụng phân số nhị phân, không phải là số thực chính xác). Nhưng điều chỉnh vòng lặp của bạn một chút mà điều này mang lại:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

Điều đó có nghĩa là bất cứ điều gì trên 3 khối, (bao gồm 10648) đã bị bỏ lỡ do sự thiếu chính xác đã nói ở trên:

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

Thay vào đó, bạn phải kiểm tra các số gần với toàn bộ số hoặc không sử dụng

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

6 để tìm số của bạn. Giống như làm tròn gốc khối lập phương của

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

7:close to the whole number instead, or not use

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

6 to find your number. Like rounding down the cube root of

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

7:

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

Nếu bạn đang sử dụng Python 3.5 hoặc mới hơn, bạn có thể sử dụng hàm

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

8 để xem giá trị điểm nổi có nằm trong biên độ có thể định cấu hình không:

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

Đối với các phiên bản cũ hơn, việc triển khai ngây thơ của chức năng đó (bỏ qua việc kiểm tra lỗi và bỏ qua Infinity và Nan) như đã đề cập trong PEP485:

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

Khi chương trình Python của chúng tôi hoạt động với các giá trị số, thường thì chúng tôi có các giá trị lượt với thành phần phân số thành các số toàn bộ (số nguyên). Nhưng làm thế nào để làm như vậy? Và Python có tùy chọn nào? Hãy cùng nhau tìm hiểu.

Trong bài viết này:

• Vòng giá trị số lên xuống trong Python
• Giá trị tròn lên xuống: Chức năng Python từ

  >>> (4**3) ** (1.0/3)
  3.9999999999999996
  >>> 10648 ** (1.0/3)
  21.999999999999996
  

  9
  • Ví dụ: Số python tròn đến số nguyên đầy đủ gần nhất
• Làm tròn xuống số nguyên tiếp theo: Chức năng Python từ

  >>> int(12000 ** (1.0/3))
  22
  >>> 22 ** 3
  10648
  

  0
  • Ví dụ: Các giá trị tròn xuống số nguyên đầy đủ tiếp theo
• Làm tròn đến số nguyên tiếp theo: Hàm Python từ

  >>> int(12000 ** (1.0/3))
  22
  >>> 22 ** 3
  10648
  

  1
  • Ví dụ: Giá trị Python tròn lên đến toàn bộ số
• Làm tròn tất cả các giá trị trong danh sách hoặc mảng python
  • Giá trị python tròn với danh sách hiểu
  • Làm tròn tất cả các giá trị với vòng lặp Python từ

    >>> int(12000 ** (1.0/3))
    22
    >>> 22 ** 3
    10648
    

    2
• Bản tóm tắt

# Vòng giá trị số lên xuống trong Python

Khi chúng ta làm tròn các giá trị, chúng ta đi từ một giá trị số với các vị trí thập phân đến một số toàn bộ. Với quá trình này, chúng tôi mất một số độ chính xác, nhưng giá trị tròn thường dễ đọc và giải thích hơn nhiều.

Python có ba cách để biến giá trị dấu phẩy động thành số toàn bộ (số nguyên):

• Hàm

  >>> (4**3) ** (1.0/3)
  3.9999999999999996
  >>> 10648 ** (1.0/3)
  21.999999999999996
  

  9 tích hợp làm tròn các giá trị lên xuống.
• Hàm

  >>> int(12000 ** (1.0/3))
  22
  >>> 22 ** 3
  10648
  

  0 làm tròn đến số nguyên đầy đủ tiếp theo.
• Hàm

  >>> int(12000 ** (1.0/3))
  22
  >>> 22 ** 3
  10648
  

  1 làm tròn đến số nguyên đầy đủ tiếp theo.

Nếu bạn chỉ muốn một chuỗi hoặc đầu ra tập lệnh với toàn bộ số, thì chuỗi định dạng Python cũng có thể thực hiện tác vụ đó. Bằng cách đó, bạn cũng không mất độ chính xác trong giá trị ban đầu.

Hãy cùng xem ba cách tiếp cận này hoạt động như thế nào.

# Giá trị tròn lên và xuống: Chức năng Python từ ____29

Để làm tròn các giá trị điểm nổi lên xuống, chúng tôi sử dụng chức năng Python từ ____29 (Lutz, 2013; Python Docs, N.D. A). Có hai cách để sử dụng chức năng này. Tùy chọn đầu tiên là làm tròn các giá trị đến một số thập phân nhất định. Tùy chọn khác biến giá trị dấu phẩy động thành một số toàn bộ.

Để làm điều đó sau, chúng tôi gọi

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9 với một đối số: giá trị để biến thành một số nguyên. Ví dụ:

round(5.4598)
# Returns: 5

Hàm

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9 làm tròn các giá trị của

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

0 đối với số nguyên chẵn (Python Docs, n.d. A). Vì vậy,

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

0 được làm tròn cho các giá trị dương và làm tròn cho các giá trị âm.

Chẳng hạn, cả

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

2 và

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

3 trả lại

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

4, trong khi

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

5 cho

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

6 và

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

7 cho

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

8. Hành vi Python này hơi khác so với cách làm tròn thường đi.

Khi chúng ta cung cấp cho

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9 một số nguyên, hàm chỉ đơn giản là trả về toàn bộ số đó. Không có lỗi nào trong trường hợp đó, và vì vậy chúng tôi không phải kiểm tra xem đối số chức năng có giá trị phân số không. Nó cần phải là một con số mặc dù; Giá trị chuỗi không được phép trong

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9.

# Ví dụ: Số python tròn đến số nguyên đầy đủ gần nhất

Để xem chức năng

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9 hoạt động như thế nào trong thực tế, hãy để xem xét các chương trình nhỏ sau:

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

# Round values to whole numbers
roundA = round(valueA)
roundB = round(valueB)
roundC = round(valueC)
roundD = round(valueD)
roundE = round(valueE)

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

Ở đây trước tiên chúng tôi tạo năm biến với các giá trị dấu phẩy động. Một số có rất nhiều vị trí thập phân và một số khác chỉ một vài.

Sau đó, chúng tôi làm một số làm tròn. Vì vậy, chúng tôi gọi hàm

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9 và cung cấp một đối số: giá trị thành vòng. Chúng tôi lưu trữ các số nguyên tròn trong các biến

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

3 đến

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

4.

Tiếp theo, chúng tôi đưa ra kết quả với chức năng

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

5. Đối với mỗi biến, chúng tôi hiển thị giá trị ban đầu (ví dụ:

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

6) và kết quả làm tròn của nó (

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

3). Với phương thức chuỗi

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

8, chúng tôi biện minh cho giá trị đầu tiên ở bên trái. Điều đó phù hợp với các giá trị cho đầu ra đẹp hơn.

Ở đây, cách các giá trị tròn trông như thế nào:

Value:          Rounded:
3.14159265359   3
1845.7409947    1846
-100.95         -101
9.55432         10
34.49953        34

# Làm tròn xuống số nguyên tiếp theo: Chức năng Python từ >>> int(12000 ** (1.0/3)) 22 >>> 22 ** 3 10648 0

Hàm

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 trả về giá trị sàn của đối số của nó, đó là số nguyên gần nhất ít hơn hoặc bằng với giá trị đối số đó (Python Docs, n.d. b).

Điều đó nghe có vẻ trừu tượng, nhưng chỉ là một cách khác để nói rằng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 làm tròn đến tổng số tiếp theo. Vì vậy,

round(5.4598)
# Returns: 5

2 trở thành

round(5.4598)
# Returns: 5

3 và

round(5.4598)
# Returns: 5

4 được biến thành

round(5.4598)
# Returns: 5

5. Và vì hàm làm tròn xuống một giá trị nhỏ hơn,

round(5.4598)
# Returns: 5

6 trở thành

round(5.4598)
# Returns: 5

7.

Dưới đây, một ví dụ nhanh về chức năng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0:

import math

math.floor(12.75)
# Returns: 12

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 chỉ chấp nhận một đối số: giá trị để làm tròn xuống. Với một chức năng tùy chỉnh nhỏ, chúng tôi cũng có thể làm tròn xuống một số vị trí thập phân. Xem tròn xuống một số thập phân cụ thể để biết thêm.

# Ví dụ: Các giá trị tròn xuống số nguyên đầy đủ tiếp theo

Để khám phá cách thức hoạt động của chức năng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0, hãy để kiểm tra chương trình Python sau:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

0

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

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

# Round values to whole numbers
roundA = round(valueA)
roundB = round(valueB)
roundC = round(valueC)
roundD = round(valueD)
roundE = round(valueE)

# 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. Điều đó làm cho nó có thể sử dụng chức năng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

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

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

6 đến

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

# Round values to whole numbers
roundA = round(valueA)
roundB = round(valueB)
roundC = round(valueC)
roundD = round(valueD)
roundE = round(valueE)

# 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. Mỗi cái giữ một giá trị dấu phẩy động.

Tiếp theo chúng tôi làm tròn những giá trị đó xuống. Vì vậy, chúng tôi gọi hàm

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 trên mỗi biến. Chúng tôi lưu trữ kết quả trong các biến mới (

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

3 đến

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

4).

Phần thứ ba của chương trình xuất hiện các biến với chức năng Python từ

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

5. Ở đây mỗi câu lệnh

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

5 hiển thị giá trị ban đầu và phiên bản làm tròn của nó. Đây là cách trông như thế nào:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

1

# Làm tròn đến số nguyên tiếp theo: Hàm Python từ >>> int(12000 ** (1.0/3)) 22 >>> 22 ** 3 10648 1

Hàm

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 trả về trần của đối số của nó, đó là số nguyên gần nhất lớn hơn hoặc bằng với giá trị đối số đó (Python Docs, n.d. b).

Đó chỉ là một cách để nói rằng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 làm tròn lên một số toàn bộ:

Value:          Rounded:
3.14159265359   3
1845.7409947    1846
-100.95         -101
9.55432         10
34.49953        34

3 trở thành

Value:          Rounded:
3.14159265359   3
1845.7409947    1846
-100.95         -101
9.55432         10
34.49953        34

4 và

Value:          Rounded:
3.14159265359   3
1845.7409947    1846
-100.95         -101
9.55432         10
34.49953        34

5 bị biến thành

Value:          Rounded:
3.14159265359   3
1845.7409947    1846
-100.95         -101
9.55432         10
34.49953        34

6. Và bởi vì hàm làm tròn lên đến một giá trị lớn hơn,

Value:          Rounded:
3.14159265359   3
1845.7409947    1846
-100.95         -101
9.55432         10
34.49953        34

7 trở thành

round(5.4598)
# Returns: 5

7.

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

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

2

Ở đây, một cách để ghi nhớ sự khác biệt giữa

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 và

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1. Như bạn đã biết, mỗi giá trị điểm nổi nằm giữa hai số nguyên liên tiếp.

import math

math.floor(12.75)
# Returns: 12

2, ví dụ, nằm trong khoảng từ

import math

math.floor(12.75)
# Returns: 12

3 và

import math

math.floor(12.75)
# Returns: 12

4.

Bây giờ trần trần của người Viking là điểm cuối cao hơn của khoảng này. Vì vậy,

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 trả về

import math

math.floor(12.75)
# Returns: 12

4. Điểm bắt đầu thấp hơn của khoảng số nguyên đó được gọi là sàn nhà. Vì vậy,

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 trả về 12.

Chức năng Python từ

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 luôn làm tròn đến một số nguyên đầy đủ. Nhưng với một chức năng tùy chỉnh nhỏ, chúng ta cũng có thể làm tròn đến một số vị trí thập phân. Xem các giá trị Python tròn đến các vị trí thập phân cho cách làm thế nào.

# Ví dụ: Giá trị Python tròn lên đến toàn bộ số

Hãy cùng xem cách

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 hoạt động trong thực tế. Chương trình ví dụ này làm tròn một số giá trị dấu phẩy động lên đến một số toàn bộ:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

3

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

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

# Round values to whole numbers
roundA = round(valueA)
roundB = round(valueB)
roundC = round(valueC)
roundD = round(valueD)
roundE = round(valueE)

# 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. Điều đó làm cho chức năng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 có sẵn. Sau đó, chúng tôi thực hiện năm biến khác nhau, được đặt tên là

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

6 đến

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

# Round values to whole numbers
roundA = round(valueA)
roundB = round(valueB)
roundC = round(valueC)
roundD = round(valueD)
roundE = round(valueE)

# 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. Mỗi người có một số với một số vị trí thập phân.

Phần tiếp theo làm tròn các giá trị đó lên đến một số nguyên đầy đủ. Để thực hiện điều đó, chúng tôi gọi hàm

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 trên mỗi biến. Chúng tôi đặt các giá trị trả về chức năng đó trong các biến mới,

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

3 đến

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

4.

Phân đoạn mã thứ ba có hàm

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

5 đầu ra cả giá trị gốc và tròn. Ở đây, những gì hiển thị:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

4

# Làm tròn tất cả các giá trị trong danh sách hoặc mảng python

Tất nhiên cũng có những tình huống chúng tôi có một loạt các giá trị để làm tròn, thay vì một giá trị duy nhất. Có hai cách chính để làm điều đó: với một danh sách hiểu hoặc vòng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

2. Hãy xem nào.

# Vòng python giá trị với danh sách hiểu biết

Khi chúng ta có một chuỗi các giá trị dấu phẩy động, một cách để làm tròn chúng là với sự hiểu biết danh sách. Điều đó chỉ cần một chút mã và chạy hiệu quả.

Ở đây, một chương trình nhỏ làm điều đó:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

5

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

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

# Round values to whole numbers
roundA = round(valueA)
roundB = round(valueB)
roundC = round(valueC)
roundD = round(valueD)
roundE = round(valueE)

# 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. Điều đó làm cho các chức năng làm tròn

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 và

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 có sẵn. Sau đó, chúng tôi lập một danh sách có tên

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

12, chứa một số giá trị dấu phẩy động.

Để làm tròn các giá trị đó vào toàn bộ số, chúng tôi thực hiện ba toàn bộ danh sách. Cái đầu tiên thực hiện

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9 cho mỗi giá trị danh sách. Hai chức năng khác thực thi

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 và

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 trên các giá trị danh sách.

Chúng tôi tạo ra các giá trị mà các hàm đó sử dụng với vòng lặp

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

2 nội tuyến:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

17. Điều này lấy một giá trị từ danh sách

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

12 tại một thời điểm và cung cấp nó thông qua biến

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

19.

Những toàn bộ danh sách đó tạo ra danh sách mới. Chúng tôi chỉ định những biến đó cho các biến

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

20,

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

21 và

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

22.

Phần cuối cùng của chương trình đưa ra danh sách ban đầu và ba phần tròn. Đây là cách trông như thế nào:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

6

Trong ví dụ trên, chúng tôi giữ danh sách ban đầu. Nếu bạn không cần phải giữ lại các giá trị đó, bạn cũng có thể ghi đè danh sách ban đầu với các giá trị tròn. Đây là cách mà một danh sách hiểu được điều đó:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

7

# Làm tròn tất cả các giá trị với vòng lặp Python >>> int(12000 ** (1.0/3)) 22 >>> 22 ** 3 10648 2

Tất nhiên chúng ta cũng có thể làm tròn các giá trị danh sách hoặc mảng với vòng lặp

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

2 thông thường. Điều này đòi hỏi nhiều mã hơn một chút so với khả năng hiểu danh sách, nhưng giúp dễ dàng thực hiện các hoạt động bổ sung trên mỗi yếu tố. Cộng với một vòng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

2 dễ đọc hơn trong các tình huống phức tạp.

Tại đây, cách một chương trình Python làm tròn các giá trị bên trong vòng lặp

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

2:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

8

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

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

# Round values to whole numbers
roundA = round(valueA)
roundB = round(valueB)
roundC = round(valueC)
roundD = round(valueD)
roundE = round(valueE)

# 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 để có thể sử dụng

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 và

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0. Sau đó, chúng tôi lập một danh sách (

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

12) với các giá trị dấu phẩy động.

Sau đó, chúng tôi thực hiện ba danh sách trống ban đầu:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

20,

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

21 và

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

22. Chúng sẽ giữ các giá trị tròn của chúng tôi.

Để lấp đầy các danh sách đó, chúng tôi tạo một vòng lặp Python

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

2. Vòng lặp này đi qua tất cả các yếu tố trong danh sách

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

12. Trong mỗi chu kỳ vòng lặp, biến

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

19 giữ một phần tử duy nhất trong danh sách đó.

Bên trong vòng lặp, chúng tôi gọi phương thức

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

37 trên mỗi ba danh sách mới. Bằng cách đó, chúng tôi thêm một yếu tố mới cho họ. Giá trị chúng tôi thêm mỗi lần vượt qua vòng lặp là biến

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

19 được làm tròn với

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9,

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 và

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0. Sau khi vòng lặp này được thực hiện, mỗi danh sách trong ba danh sách đó có một giá trị tròn từ danh sách ban đầu.

Chương trình kết thúc với một số tuyên bố

def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):
    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

5. Hiển thị danh sách ban đầu và các dẫn xuất tròn của nó. Ở đây, đầu ra đó trông như thế nào:

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

9

Nhân tiện, bạn không phải lập một danh sách mới khi bạn làm tròn các giá trị. Nếu bạn tốt với việc mất dữ liệu gốc, bạn cũng có thể ghi đè danh sách hiện có. Làm như vậy thật dễ dàng khi bạn kết hợp vòng lặp

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

2 với hàm

>>> for n in range(12000, -1, -1):
...     if (n ** (1.0/3)).is_integer():
...         print n
... 
27
8
1
0

44:

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

0

ĐỌC THÊM

• Giá trị trăn tròn đến một số vị trí thập phân nhất định
• Cắt ngắn các giá trị điểm nổi python thành một số
• Cắt ngắn giá trị python thành một số chữ số thập phân nhất định

# Bản tóm tắt

Python có ba cách để làm tròn giá trị dấu phẩy động đến một số toàn bộ. Hàm

>>> (4**3) ** (1.0/3)
3.9999999999999996
>>> 10648 ** (1.0/3)
21.999999999999996

9 làm tròn giá trị lên hoặc xuống. Một chữ số thập phân

>>> from math import isclose
>>> isclose((4**3) ** (1.0/3), 4)
True
>>> isclose(10648 ** (1.0/3), 22)
True

0 có vòng python hướng tới một số nguyên thậm chí. Điều đó làm cho nó làm tròn cho các giá trị tích cực và xuống cho những giá trị tiêu cực.

Mặt khác, hàm

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

0 luôn làm tròn xuống số nguyên đầy đủ gần nhất.

>>> int(12000 ** (1.0/3))
22
>>> 22 ** 3
10648

1 làm ngược lại. Chức năng đó luôn làm tròn lên đến một số toàn bộ.

Tất cả ba chức năng hoạt động theo cùng một cách: cung cấp chức năng với một đối số, đó là giá trị điểm nổi thành vòng.

Xuất bản ngày 20 tháng 12 năm 2019.

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