Bây giờ bạn đã hiểu cách chuỗi hoạt động, hãy bắt đầu khám phá một loại dữ liệu khác. con số. Các số trong Python tồn tại ở hai dạng chính. số nguyên và số float. Như đã lưu ý trong Bài 02, số nguyên là số không có dấu thập phân, trong khi số thực là số có dấu thập phân. Đây là điểm khác biệt quan trọng mà bạn PHẢI nhớ, đặc biệt khi làm việc với dữ liệu được nhập và xuất sang Excel
Là những người theo chủ nghĩa nhân văn kỹ thuật số, bạn có thể tự nghĩ: “Tôi chỉ làm việc với văn bản, tại sao tôi phải quan tâm nhiều đến những con số?” . Điều gì sẽ xảy ra nếu bạn muốn biết thời gian một tác giả cụ thể viết thư cho đồng nghiệp hoặc nơi nào anh ấy viết thư thường xuyên nhất, như trường hợp của dự án Republic of Letters tại Stanford? . Ngoài ra, cần hiểu các số để thực hiện các chức năng nâng cao hơn trong Python, chẳng hạn như Vòng lặp, được khám phá trong Bài học 09
Cách bạn tạo đối tượng số trong Python là tạo tên đối tượng, sử dụng dấu bằng và nhập số. Nếu số của bạn có số thập phân, Python sẽ tự động coi đó là số float. Nếu không, nó sẽ tự động coi đó là một số nguyên
Ví dụ về integer và float.
an_int = 1
a_float = 1. 1
Nếu muốn thay đổi số float thành số nguyên, chúng tôi có thể thực hiện việc này bằng cách sử dụng hàm int[]. Khi chúng tôi làm điều này, số float sẽ mất số thập phân và các số đằng sau vị trí thập phân. Tương tự, chúng ta có thể đổi một số nguyên thành số float bằng hàm float[]. Trong trường hợp này, số nguyên sẽ nhận được một. 0 ở cuối. Trong một số trường hợp, bạn có thể cần chuyển đổi một số nguyên hoặc số float thành một chuỗi. Điều này đặc biệt hữu ích khi bạn đang cố gắng tạo các tệp dựa trên số lần lặp lại trong một vòng lặp. Tôi sẽ giải thích quy trình này trong các bài học sau, nhưng bây giờ, bạn nên biết cách thực hiện. Để làm điều này, bạn sử dụng hàm str[]. Trong tất cả các trường hợp này, các hàm này nhận một đối số duy nhất, mục mà bạn muốn chuyển đổi
Ví dụ về chức năng chuyển đổi.
int[a_float] #Điều này sẽ dẫn đến. 1
float[an_int] #Điều này sẽ dẫn đến 1. 0
str[a_float] #Điều này sẽ dẫn đến “1. 0”
Trong suốt dự án DH của mình, rất có thể bạn sẽ cần thao tác với các con số thông qua các phép toán. Dưới đây là danh sách các hoạt động phổ biến
- Bổ sung +
- phép trừ –
- Phép nhân *
- Phép nhân lũy thừa **
- Phân công /
- Modulo % #This sẽ trả lại phần còn lại, e. g. 2%7 sẽ mang lại 1
- Floor // #Điều này sẽ trả về số lần tối đa hai số có thể chia cho nhau, e. g. 2//7 sẽ mang lại 3
Ngoài ra, trong các vòng lặp, bạn sẽ thường xuyên cần xác định Toán tử so sánh [bằng, nhỏ hơn, v.v.]. Dưới đây là danh sách những
Khi làm việc với số thập phân trong Python, chúng ta thường chuyển sang số float. Phao nổi phục vụ chúng tôi tốt cho hầu hết các mục đích, chẳng hạn như phân chia đơn giản, nhưng chúng có những hạn chế có thể trở thành vấn đề cực kỳ nghiêm trọng đối với một số trường hợp sử dụng nhất định. Đơn giản là chúng không đủ chính xác. Tuy nhiên, float không phải là lựa chọn duy nhất của chúng ta, và hôm nay chúng ta sẽ xem xét mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 và lý do tại sao bạn có thể sử dụng nóNhìn nhanh vào nhị phân
Trước khi chúng ta có thể hiểu đúng vấn đề với số float, chúng ta cần xem xét nhanh cách các số được biểu thị trong hệ nhị phân
Hệ thống số mà chúng ta sử dụng trong cuộc sống hàng ngày là hệ thống số cơ số 10, còn được gọi là hệ thống số thập phân. Chúng tôi sử dụng mười chữ số duy nhất trong các kết hợp khác nhau để đại diện cho tất cả các số. Mặt khác, nhị phân là một hệ thống số cơ sở 2 và chỉ sử dụng hai chữ số duy nhất. nói chung là 0 và 1. Khi các số được lưu trữ trong máy tính của chúng tôi, chúng được lưu trữ ở định dạng nhị phân này
Một số nhị phân có thể trông giống như thế này. 10101101, tức là 173
Vậy làm thế nào để chúng ta có được 173 trên 10101101?
Nhị phân hoạt động ở lũy thừa 2, vì vậy số 1 ngoài cùng bên phải trong 10101101, đại diện cho 1 x 2⁰. Sau đó, chúng tôi đi một bước sang trái, nơi chúng tôi tìm thấy số 0. Số 0 này đại diện cho 0 x 2¹, là 0 x 2. Bước thêm một bước sang trái và chúng tôi tìm thấy một số 1 khác, lần này đại diện cho 1 x 2², tức là 4. Mỗi bước sang trái, sức mạnh tăng thêm 1
Tổng cộng chúng ta có một cái gì đó trông như thế này
[1 × 2⁷] + [0 × 2⁶] + [1 × 2⁵] + [0 × 2⁴] + [1 × 2³] + [1 × 2²] + [0 × 2¹] + [1 × 2⁰]
Đó là
[1 x 128] + [0 x 64] + [1 x 32] + [0 x 16] + [1 x 8] + [1 x 4] + [0 x 2] + [1 x 1]
Nếu chúng tôi cộng tất cả những thứ này lại, chúng tôi sẽ nhận được 173. Như bạn có thể thấy, biểu diễn nhị phân của các số có xu hướng dài hơn nhiều so với biểu diễn thập phân, nhưng cuối cùng chúng ta có thể biểu diễn bất kỳ số nguyên nào theo cách này
Phân số trong nhị phân
Vì vậy, chúng tôi đã thực hiện ôn tập nhanh về cách các số nguyên có thể được biểu diễn dưới dạng nhị phân, nhưng còn phân số thì sao?
Ví dụ: 2⁻¹ là ½ và 2⁻² là ¼, có nghĩa là bây giờ chúng ta có thể đại diện cho 0. 75, 0. 5 và 0. 25. Sử dụng các lũy thừa âm lớn hơn dần dần, chúng ta có thể biểu diễn tất cả các cách của số thập phân
Tuy nhiên, cũng như có những số chúng ta không thể biểu diễn bằng một số hữu hạn các chữ số thập phân [e. g. ⅓], cũng có những số chúng ta không thể biểu diễn dưới dạng nhị phân. Ví dụ, số 0. 1 không có đại diện nhị phân hữu hạn
Nổi trong Python
Vậy điều gì xảy ra khi chúng ta viết
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
7 bằng Python? print[f"{0.1:.20f}"] # 0.10000000000000000555
Đối với những bạn không quen thuộc với cú pháp ở trên, thì
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
8 là một cách để nói với Python rằng chúng tôi muốn 20 chữ số sau dấu thập phân cho số float này. Chúng tôi có một bài đăng bạn có thể xem bên dướihttps. //Blog. mật mã. com/python-formatting-number-for-printing/
Như chúng ta có thể thấy, chúng ta không thực sự nhận được
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
7. chúng tôi nhận được một xấp xỉ gần đúng của a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
7. Thật không may, đôi khi một phép tính gần đúng không đủ tốtĐiều này đặc biệt phổ biến khi thực hiện so sánh
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
Nếu chúng ta in
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
1 và print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
2, chúng ta có thể thấy điều gì đã xảy raprint[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
Lỗi gần đúng này có thể trở nên phức tạp hơn rất nhiều trong một loạt các hoạt động, có nghĩa là chúng ta thực sự có thể nhận được sự khác biệt khá đáng kể giữa các số giống hệt nhau
Bạn có thể đọc thêm về những vấn đề này trong tài liệu Python. https. // tài liệu. con trăn. org/3/hướng dẫn/dấu phẩy động. html
Nhập a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
Như đã đề cập ở đầu bài viết này, Python có một cách khác để xử lý các số thập phân, đó là mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6. Không giống như số float, các đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 được xác định trong mô-đun a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 không dễ bị mất độ chính xác này, bởi vì chúng không dựa vào phân số nhị phânTạo đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
Trước khi chúng ta đi sâu vào các đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5, hãy xem cách xác định chúng. Thực tế có một số cách để làm điều nàySử dụng một số nguyên
Cách đầu tiên để tạo một đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 chúng ta sử dụng một số nguyên. Trong trường hợp này, chúng ta chỉ cần chuyển số nguyên làm đối số cho hàm tạo print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
8Bây giờ chúng ta có thể sử dụng
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
81 giống như bất kỳ số nào khác và chúng ta sẽ nhận lại một đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 khi thực hiện các phép toánprint[f"{0.1:.20f}"] # 0.10000000000000000555
1Sử dụng một chuỗi
Có lẽ hơi ngạc nhiên một chút, một trong những cách dễ nhất để tạo một đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 với các thành phần phân số là sử dụng một chuỗi. Chúng ta chỉ cần chuyển một chuỗi đại diện của số cho print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 và nó sẽ lo phần còn lạiprint[f"{0.1:.20f}"] # 0.10000000000000000555
4Như chúng ta có thể thấy, in
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
81 đến 20 chữ số thập phân ở đây cho chúng ta 19 chữ số 0. chúng tôi không kết thúc với một số 5 ngẫu nhiên ở cuối như chúng tôi đã làm khi sử dụng floatNếu bạn cần một biểu diễn thập phân chính xác của một số, sử dụng các chuỗi để tạo các đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 của bạn là một cách rất đơn giản để đạt được điều nàySử dụng phao
Cũng có thể tạo một đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 từ một float, nhưng tôi thường khuyên bạn không nên làm điều này. Ví dụ dưới đây sẽ làm rõ lý do tại saoprint[f"{0.1:.20f}"] # 0.10000000000000000555
8Chuyển đổi trực tiếp từ float khiến đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 của chúng ta kế thừa tất cả sự thiếu chính xác mà chúng ta đã cố gắng tránh ngay từ đầu. Có thể có những trường hợp bạn muốn bảo vệ sự không chính xác này vì một lý do nào đó, nhưng hầu hết thời gian thì không phải như vậy.Sử dụng một tuple
Có lẽ phương pháp phức tạp nhất để tạo một đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 là sử dụng một tuple, và phương pháp này cung cấp cho chúng ta một số hiểu biết sâu sắc về cách các đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 hoạt động ngầm.Bộ dữ liệu chúng tôi cung cấp cho
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 có ba phần. Phần tử đầu tiên trong bộ dữ liệu là số print[f"{0.1:.20f}"] # 0.10000000000000000555
12 hoặc print[f"{0.1:.20f}"] # 0.10000000000000000555
13 và phần tử này đại diện cho dấu của số đó [dương hay âm]. Số 0 ở vị trí đầu tiên này biểu thị số dương, trong khi số 1 biểu thị số âmMục thứ hai trong bộ dữ liệu là một bộ dữ liệu khác và bộ này chứa tất cả các chữ số trong số kết quả. Ví dụ: số
print[f"{0.1:.20f}"] # 0.10000000000000000555
14 có các chữ số print[f"{0.1:.20f}"] # 0.10000000000000000555
15Phần tử thứ ba và cũng là phần tử cuối cùng trong bộ dữ liệu là một số mũ. Điều này cho đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 biết chúng ta cần dịch chuyển bao nhiêu vị trí các chữ số xung quanh dấu thập phân. Số mũ của print[f"{0.1:.20f}"] # 0.10000000000000000555
17 sẽ làm cho các chữ số dịch chuyển 3 dấu cách sang phải, cho chúng ta print[f"{0.1:.20f}"] # 0.10000000000000000555
18, trong khi số mũ của print[f"{0.1:.20f}"] # 0.10000000000000000555
19 sẽ cho chúng ta print[f"{0.1:.20f}"] # 0.10000000000000000555
40Một ví dụ hoàn chỉnh cho số
print[f"{0.1:.20f}"] # 0.10000000000000000555
41 trông như thế nàya = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
3Một điều thực sự quan trọng cần lưu ý ở đây là chúng ta cần các dấu ngoặc quanh bộ bên ngoài, vì
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 mong đợi bộ này là một đối số duy nhất. Xóa dấu ngoặc ngoài sẽ gây ra lỗiMặc dù tương đối phức tạp nhưng cú pháp tuple phù hợp nhất để tạo các đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 theo cách lập trìnhĐối tượng print[f"{0.1:.20f}"] # 0.10000000000000000555
44
print[f"{0.1:.20f}"] # 0.10000000000000000555
Một trong những điều thú vị về mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 là nó cho phép chúng ta xác định hành vi của các đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 theo nhiều cách khác nhau. Chúng tôi có thể chỉ định mức độ chính xác, giới hạn cho số mũ và thậm chí cả quy tắc làm trònĐể làm điều này, chúng ta thường sẽ làm việc với hàm
print[f"{0.1:.20f}"] # 0.10000000000000000555
47, hàm này cho phép chúng ta xem và sửa đổi đối tượng print[f"{0.1:.20f}"] # 0.10000000000000000555
44 cho chuỗi hiện tạiChúng ta hãy xem một đối tượng
print[f"{0.1:.20f}"] # 0.10000000000000000555
44 mặc định trông như thế nàoa = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
2Như bạn có thể thấy, chúng tôi có tất cả các loại thuộc tính mà chúng tôi có thể thiết lập để thay đổi cách hoạt động của đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5Ví dụ: chúng tôi có thể quyết định rằng chúng tôi muốn độ chính xác có giá trị bằng 10 con số quan trọng, chúng tôi sẽ đặt như thế này
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
4Lưu ý rằng độ chính xác mới này chỉ phù hợp trong các phép toán. Chúng ta có thể định nghĩa một đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 với độ chính xác tùy ý, ngay cả khi chúng ta đặt mức độ chính xác thấp hơn bằng cách sử dụng print[f"{0.1:.20f}"] # 0.10000000000000000555
47a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
0Như tôi đã đề cập trước đó, chúng ta cũng có thể xác định cách làm tròn hoạt động cho các đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5, điều này có thể rất hữu ích. Theo mặc định, Python sử dụng cách làm tròn của nhân viên ngân hàng, điều này hơi khác so với cách làm tròn mà chúng ta học ở trườngChúng tôi nói về việc làm tròn của nhân viên ngân hàng ở đây nếu bạn chưa quen với nó. https. //Blog. mật mã. com/làm tròn trong trăn/
Sử dụng
print[f"{0.1:.20f}"] # 0.10000000000000000555
47, chúng ta có thể thay đổi hành vi làm tròn của Python thành luôn làm tròn số thập phân kết thúc bằng print[f"{0.1:.20f}"] # 0.10000000000000000555
85 cách xa print[f"{0.1:.20f}"] # 0.10000000000000000555
12, đó là cách chúng ta làm tròn trong cuộc sống hàng ngàya = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
1Một số hành vi làm tròn khác nhau được xác định trong mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 bằng cách sử dụng các hằng số. Bạn có thể đọc thêm về các tùy chọn có sẵn tại đây. https. // tài liệu. con trăn. tổ chức/3. 7/thư viện/thập phân. html#module-thập phânMột số phương pháp a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 hữu ích
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
Mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 đi kèm với một số phương thức tiện dụng để làm việc với các đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5. Dưới đây là một số mà bạn có thể muốn kiểm traa = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
31
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
Phương pháp
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
31 cho phép chúng tôi lấy căn bậc hai của bất kỳ print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 nào với mức độ chính xác được chỉ địnha = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
2a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
34
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
Phương thức
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
34 được sử dụng để thay đổi một đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 thành một số mũ mới. Ví dụ: giả sử chúng tôi có số a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
37 và chúng tôi muốn thay đổi số này để khớp với mẫu a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
38, chúng tôi có thể viết như saua = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
3Một điều cần lưu ý với phương pháp
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
34 là nó sẽ đưa ra một ngoại lệ a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
20 nếu các giá trị cuối cùng vượt quá mức độ chính xác đã xác địnha = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
4a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
21
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
Phương thức
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
21 cung cấp cho chúng ta một biểu diễn bộ dữ liệu của đối tượng print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5, giống như khi chúng ta tạo một bộ dữ liệu bằng cú pháp bộ dữ liệua = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
5Có nhiều phương pháp khác có sẵn cho các đối tượng
print[f"{a:.20f}"] # 10.00000000000000000000
print[f"{c:.20f}"] # 9.99999999999999822364
5 và tôi khuyên bạn nên xem phần tài liệu này để tìm hiểu thêm. https. // tài liệu. con trăn. tổ chức/3. 7/thư viện/thập phân. html#đối tượng thập phânVì vậy, chúng ta chỉ nên sử dụng a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6?
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
Không cần thiết. Mặc dù mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 chắc chắn là rất gọn gàng và nó có lợi ích là độ chính xác tuyệt đối, nhưng độ chính xác này phải trả giá. Trong trường hợp này, chi phí là gấp đôiThứ nhất, sử dụng mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 khó hơn nhiều so với sử dụng float. Điều này là hiển nhiên ngay khi chúng ta nhìn vào đối tượng a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
28 ở trên và chúng ta cũng có những thứ như ngữ cảnh để xem xét trên đầu trang này. Bạn chỉ cần biết nhiều hơn để thậm chí sử dụng mô-đunTuy nhiên, vấn đề thứ hai có lẽ cấp bách hơn, đó là hiệu suất. Các thao tác của
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 có thể chậm hơn khoảng 3 lần so với các thao tác sử dụng float, vì vậy nếu bạn đang xử lý một phần nhạy cảm về hiệu suất trong ứng dụng của mình, trong đó độ chính xác tuyệt đối không quan trọng, thì bạn có thể muốn tránh sử dụng a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6. Điều này đặc biệt đúng nếu bạn vẫn đang làm việc với Python 2, vì các thao tác khi đó có thể chậm hơn vài trăm lầnMô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 là một công cụ tuyệt vời cần có trong bộ công cụ của chúng ta, nhưng chúng ta phải luôn biết liệu chúng ta có thực sự cần nó cho một ứng dụng cụ thể hay khôngkết thúc
Đó là nó cho bài đăng này trên số float và số thập phân. Chắc chắn còn rất nhiều điều để tìm hiểu, vì vậy, một lần nữa, hãy xem tài liệu. Tài liệu về mô-đun
a = 10
b = a / 77
c = b * 77
if a != c:
print["Things got weird..."]
# Things got weird...
6 có thể hơi đáng sợ, nhưng hy vọng rằng những gì chúng tôi đã nói ở đây sẽ giúp bạn chuẩn bị tốt để đi sâu vàoNếu bạn thích các bài đăng của chúng tôi và bạn muốn đưa Python của mình lên một tầm cao mới, hãy nhớ xem Khóa học Python hoàn chỉnh của chúng tôi