Cách lặp float trong python

Trong Python, hàm range[] tích hợp có thể được sử dụng để tạo một dải giá trị giữa

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

8 và

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

9

numbers = range[1, 6] # 1, 2, 3, 4, 5

Tuy nhiên, phạm vi được cho là chỉ bao gồm các số nguyên

Điều này có nghĩa là bạn không thể có cuộc gọi phạm vi [] như thế này

numbers = range[0.1, 1.0]

Một cuộc gọi như thế này sẽ tạo ra một lỗi cảnh báo bạn về việc lạm dụng hàm range[]

Giải pháp 1. Chia Mỗi Số Trong Phạm Vi

Để khắc phục sự cố hàm range[] không hoạt động với số float, bạn có thể tạo một phạm vi và chia từng số trong phạm vi đó để có một phạm vi float

Ví dụ: hãy tạo một danh sách đại diện cho số float giữa phạm vi 0. 0 và 1. 0

numbers = range[0, 10]

float_nums = []

for number in numbers:
    f = number / 10
    float_nums.append[f]
    
print[float_nums]

đầu ra

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

Vòng lặp for này có thể được diễn đạt một cách mượt mà hơn bằng cách sử dụng cách hiểu danh sách

rng = [x / 10 for x in range[0, 10]]
print[rng]

Tuy nhiên, sẽ hơi phức tạp khi bạn muốn tạo các loại phạm vi khác

Ví dụ: tạo danh sách các số từ 1. 5 đến 4. 25, với 0. 25 khoảng thời gian sử dụng vòng lặp for đã yêu cầu một số suy nghĩ. Khỏi phải nói khi các số không chia hết

Đây là nơi thư viện NumPy có thể giúp bạn

Giải pháp 2. NumPy arange[]

Một tùy chọn khác để tạo ra một loạt số float là sử dụng hàm arange[] của mô-đun NumPy

Hàm này tuân theo cú pháp

numpy.arange[start, stop, step]

Ở đâu

• start là giá trị bắt đầu của phạm vi
• stop chỉ định kết thúc của phạm vi. Điểm dừng không được bao gồm trong phạm vi
• bước xác định các bước lớn cần thực hiện khi tạo phạm vi

Trong trường hợp bạn chưa cài đặt NumPy, bạn có thể cài đặt nó với PIP bằng cách chạy lệnh sau trong dòng lệnh

________số 8

Bây giờ bạn đã có thư viện, bạn có thể sử dụng hàm arange[] để tạo một dải số float

import numpy as np
rng = np.arange[0.0, 1.0, 0.1]

print[rng]

đầu ra

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

0

Lưu ý cách phạm vi này là độc quyền vì nó không bao gồm giá trị cuối 1. 0 trong phạm vi

Để bao gồm phạm vi, hãy thêm một kích thước bước vào tham số dừng

Ví dụ: để tạo một phạm vi số float từ 0. 0 đến 1. 0

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

1

đầu ra

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

2

Sự cố với arange[]

Vấn đề với cách tiếp cận arange[] là lỗi làm tròn dấu phẩy động

Ví dụ, điều này tạo ra một mảng gồm bốn giá trị [1, 1. 1, 1. 2, 1. 3], mặc dù nó chỉ tạo ra ba giá trị [1, 1. 1, 1. 2]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

3

đầu ra

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

4

Giải pháp 3. NumPy linspace[]

Để khắc phục các sự cố làm tròn dấu phẩy động với hàm arange[] của numpy, thay vào đó hãy sử dụng hàm linspace[] của numpy

Tuy nhiên, lưu ý rằng chức năng này hoạt động khác. Nó hỏi bạn muốn có bao nhiêu số cách nhau một cách tuyến tính giữa giá trị bắt đầu và giá trị kết thúc

Nó theo cú pháp này

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

5

Ở đâu

• start là giá trị bắt đầu của phạm vi
• dừng là giá trị kết thúc của phạm vi
• nvalues ​​là số lượng giá trị để tạo ở giữa bắt đầu và dừng

Ví dụ: hãy tạo các giá trị từ 0. 0 đến 1. 0 với 0. 1 khoảng thời gian. Điều này có nghĩa là bắt đầu là 0 và kết thúc là 1. Ngoài ra, lưu ý rằng bạn muốn tổng cộng 11 giá trị

Đây là cách nó trông trong mã

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

6

đầu ra

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

2

Sự kết luận

Để tạo phạm vi float trong Python, bạn không thể sử dụng trực tiếp hàm range[]. Điều này là do hàm range[] chỉ hỗ trợ số nguyên. Để khắc phục vấn đề này, bạn có một vài lựa chọn

Khả năng hiểu danh sách được sử dụng để thực hiện một số thao tác cho mọi phần tử hoặc chọn một tập hợp con các phần tử đáp ứng một điều kiện

Trên mỗi lần lặp, chúng ta chuyển phần tử danh sách hiện tại cho hàm

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

8 để làm tròn nó thành số nguyên gần nhất

Hàm round nhận 2 tham số sau

Tên Mô tả

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

9số cần làm tròn thành

numbers = range[1, 6] # 1, 2, 3, 4, 5

0 độ chính xác sau dấu thập phân

numbers = range[1, 6] # 1, 2, 3, 4, 5

0số chữ số sau dấu thập phân, số cần có sau phép toán [tùy chọn]

Hàm

numbers = range[1, 6] # 1, 2, 3, 4, 5

2 trả về số được làm tròn thành độ chính xác của

numbers = range[1, 6] # 1, 2, 3, 4, 5

0 sau dấu thập phân

Nếu bỏ qua

numbers = range[1, 6] # 1, 2, 3, 4, 5

0, hàm trả về số nguyên gần nhất

Ngoài ra, bạn có thể sử dụng hàm

numbers = range[1, 6] # 1, 2, 3, 4, 5

5

Làm tròn danh sách số float thành số nguyên bằng cách sử dụng map[] #

Để làm tròn danh sách số float thành số nguyên

1. Truyền hàm

   [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

   8 và danh sách cho hàm

   numbers = range[1, 6] # 1, 2, 3, 4, 5

   5
2. Hàm

   numbers = range[1, 6] # 1, 2, 3, 4, 5

   5 sẽ chuyển từng float cho hàm

   [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

   8
3. Sử dụng lớp

   [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

   83 để chuyển đổi đối tượng

   [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

   84 thành danh sách

Hàm map[] lấy một hàm và một iterable làm đối số và gọi hàm với mỗi mục của iterable

Hàm

numbers = range[1, 6] # 1, 2, 3, 4, 5

5 gọi hàm

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

8 sẽ gọi từng số dấu phẩy động trong danh sách và làm tròn từng giá trị

Bước cuối cùng là sử dụng lớp

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

83 để chuyển đổi đối tượng

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

84 thành danh sách

Lớp danh sách nhận một lần lặp và trả về một đối tượng danh sách

Bạn chọn cách tiếp cận nào là vấn đề sở thích cá nhân. Tôi muốn hiểu danh sách vì tôi thấy nó trực tiếp hơn và dễ đọc hơn

Chúng ta có thể sử dụng float trong vòng lặp Python không?

Tôi có thể sử dụng vòng lặp float in for không?

Chúng ta có thể sử dụng float[] với input[] không?

float[] dùng để làm gì?