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: Một loạ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]]] >> float[repr[0.3]] == 0.3
True
0 không cần thiết để lưu trữ nữa.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
1 được cải thiện [Python> = 3.1,> = 2.7.0]: because rounding errors could
accumulate more inaccuracy than that is possible after parsing one number. That is not fixed by the improved 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]]] > 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.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
# 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]
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]]] >> 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]]] > 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]]] 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]]] >> 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]]] >> 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ừ //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