Hướng dẫn dùng arange numpy python

Mục lục bài viết:

• Giá trị trả lại và các tham số của np.arange ()
• Đối số phạm vi của np.arange ()
  • Cung cấp tất cả các đối số phạm vi
  • Cung cấp hai đối số phạm vi
  • Cung cấp đối số một phạm vi
  • Cung cấp đối số phủ định
  • Đếm ngược
  • Nhận Mảng trống
• Các kiểu dữ liệu của np.arange ()
• Vượt ra ngoài phạm vi đơn giản với np.arange ()
• So sánh phạm vi và np.arange ()
  • Tham số và kết quả đầu ra
  • Tạo chuỗi
  • Python cho các vòng lặp
• Các quy trình khác dựa trên phạm vi số
• Tóm tắt nhanh
• Phần kết luận

NumPy là thư viện Python cơ bản cho tính toán số. Kiểu quan trọng nhất của nó là kiểu mảng được gọi ndarray. NumPy cung cấp rất nhiều quy trình tạo mảng cho các trường hợp khác nhau. arange()là một trong những hàm như vậy dựa trên phạm vi số . Nó thường được gọi là np.arange()vì nplà từ viết tắt được sử dụng rộng rãi của NumPy.

Tạo mảng NumPy rất quan trọng khi bạn đang làm việc với các thư viện Python khác dựa vào chúng, như SciPy , Pandas , Matplotlib , scikit-learning, v.v. NumPy thích hợp để tạo và làm việc với mảng vì nó cung cấp các quy trình hữu ích , cho phép tăng hiệu suất và cho phép bạn viết mã ngắn gọn .

Đến cuối bài viết này, bạn sẽ biết:

• có gì np.arange()là
• Cách sử dụng np.arange()
• Làm thế nào np.arange()so sánh với Python built-in Classrange
• Những quy trình tương tự như np.arange()

Hãy xem np.arange()trong hành động!

Giá trị trả lại và các thông số của np.arange()

NumPy arange()là một trong những quy trình tạo mảng dựa trên phạm vi số. Nó tạo ra một thể hiện ndarrayvới các giá trị cách đều nhau và trả về tham chiếu đến nó.

Bạn có thể xác định khoảng thời gian của các giá trị có trong một mảng, khoảng cách giữa chúng và kiểu của chúng với bốn tham số arange():

numpy.arange([start, ]stop, [step, ], dtype=None) -> numpy.ndarray

Ba tham số đầu tiên xác định phạm vi của các giá trị, trong khi tham số thứ tư chỉ định loại của các phần tử:

1. startlà số (số nguyên hoặc số thập phân) xác định giá trị đầu tiên trong mảng.
2. stop là số xác định phần cuối của mảng và không được bao gồm trong mảng.
3. steplà số xác định khoảng cách (hiệu số) giữa hai giá trị liên tiếp trong mảng và mặc định là 1.
4. dtypelà kiểu của các phần tử của mảng đầu ra và mặc định là None.

stepkhông thể bằng không. Nếu không, bạn sẽ nhận được một ZeroDivisionError. Bạn không thể di chuyển đi bất cứ đâu startnếu tăng hoặc giảm 0.

Nếu dtypeđược bỏ qua, arange()sẽ cố gắng để suy ra kiểu của các phần tử mảng từ các loại start, stopvà step.

Bạn có thể tìm thêm thông tin về các tham số và giá trị trả về arange()trong tài liệu chính thức .

Đối số phạm vi của np.arange()

Những lập luận của NumPy arange()xác định các giá trị chứa trong tương ứng với mảng đến các thông số số start, stop, và step. Bạn phải vượt qua ít nhất một trong số chúng.

Các ví dụ sau sẽ cho bạn thấy cách arange()hoạt động tùy thuộc vào số lượng đối số và giá trị của chúng.

Cung cấp tất cả các đối số phạm vi

Khi làm việc với các quy trình NumPy, trước tiên bạn phải nhập NumPy:

>>>

>>> import numpy as np

Bây giờ, bạn đã nhập NumPy và bạn đã sẵn sàng đăng ký arange().

Hãy xem ví dụ đầu tiên về cách sử dụng NumPy arange():

>>>

>>> np.arange(start=1, stop=10, step=3)
array([1, 4, 7])

Trong ví dụ này, startlà 1. Do đó, phần tử đầu tiên của mảng thu được là 1. steplà 3, đó là lý do tại sao giá trị thứ hai của bạn là 1 + 3 4, trong khi giá trị thứ ba trong mảng là 4 + 3, bằng 7.

Theo mẫu này, giá trị tiếp theo sẽ là 10(7 + 3), nhưng việc đếm phải được kết thúc trước khi stop đạt được, vì vậy giá trị này không được bao gồm.

Bạn có thể vượt qua start, stopvà stepnhư các đối số vị trí cũng như:

>>>

>>> np.arange(1, 10, 3)
array([1, 4, 7])

Mẫu mã này tương đương, nhưng ngắn gọn hơn mẫu trước.

Giá trị của stopkhông được bao gồm trong một mảng. Đó là lý do tại sao bạn có thể nhận được các kết quả giống hệt nhau với các stopgiá trị khác nhau :

>>>

>>> np.arange(1, 8, 3)
array([1, 4, 7])

Mẫu mã này trả về mảng có cùng giá trị với hai giá trị trước đó. Bạn có thể nhận được cùng một kết quả với bất kỳ giá trị nào stoplớn hơn 7và nhỏ hơn hoặc bằng 10.

Tuy nhiên, nếu bạn thực hiện stoplớn hơn 10, thì việc đếm sẽ kết thúc sau khi 10đạt được:

>>>

>>> np.arange(1, 10.1, 3)
array([ 1.,  4.,  7., 10.])

Trong trường hợp này, bạn nhận được mảng có bốn phần tử bao gồm 10.

Lưu ý rằng ví dụ này tạo ra một mảng các số dấu phẩy động, không giống như ví dụ trước. Đó là bởi vì bạn chưa xác định dtype, và arange()suy ra nó cho bạn. Bạn sẽ tìm hiểu thêm về điều này sau trong bài viết.

Bạn có thể xem biểu diễn đồ họa của ba ví dụ này trong hình bên dưới:

startđược hiển thị bằng màu xanh lá cây, stopmàu đỏ, trong khi stepvà các giá trị chứa trong các mảng là màu xanh lam.

Như bạn có thể nhìn thấy từ hình trên, hai ví dụ đầu tiên có ba giá trị ( 1, 4và 7) tính. Chúng không cho phép 10được đưa vào. Trong ví dụ thứ ba, stoplớn hơn 10, và nó được chứa trong mảng kết quả.

Cung cấp hai đối số phạm vi

Bạn có thể bỏ qua step. Trong trường hợp này, hãy arange()sử dụng giá trị mặc định của nó là 1. Hai câu lệnh sau là tương đương:

>>>

>>> np.arange(start=1, stop=10, step=1)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(start=1, stop=10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Câu lệnh thứ hai ngắn hơn. step, mặc định 1là những gì thường được mong đợi bằng trực giác.

Sử dụng arange()với gia số 1là một trường hợp rất phổ biến trong thực tế. Một lần nữa, bạn có thể viết ví dụ trước ngắn gọn hơn với các đối số vị trí startvà stop:

>>>

>>> np.arange(1, 10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])

Đây là một cách gọi trực quan và ngắn gọn arange(). Sử dụng các đối số từ khóa trong ví dụ này không thực sự cải thiện khả năng đọc.

Lưu ý: Nếu bạn cung cấp hai đối số vị trí, thì đối số đầu tiên là startvà đối số thứ hai là stop.

Cung cấp đối số một phạm vi

Bạn phải cung cấp ít nhất một đối số tới arange(). Nói chính xác hơn, bạn phải cung cấp start.

Nhưng điều gì sẽ xảy ra nếu bạn bỏ qua stop? Làm thế nào để arange()biết khi nào ngừng đếm? Trong trường hợp này, mảng bắt đầu tại 0và kết thúc trước khi startđạt đến giá trị của ! Một lần nữa, giá trị mặc định của steplà 1.

Nói cách khác, arange()giả sử rằng bạn đã cung cấp stop(thay vì start) và đó startlà 0và stepđang có 1.

Hãy xem một ví dụ mà bạn muốn bắt đầu một mảng 0, tăng các giá trị lên 1và dừng lại trước 10:

>>>

>>> np.arange(start=0, stop=10, step=1)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(0, 10, 1)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(start=0, stop=10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(0, 10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Những mẫu mã này là được. Chúng hoạt động như thể hiện trong các ví dụ trước. Có một cách thậm chí ngắn hơn và gọn gàng hơn, nhưng vẫn trực quan, để làm điều tương tự. Bạn chỉ có thể cung cấp một đối số vị trí duy nhất:

>>>

>>> np.arange(10)  # Stop is 10, start is 0, and step is 1!
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Đây là cách thông thường nhất để tạo một mảng NumPy bắt đầu từ 0 và có số gia là một.

Lưu ý: Đối số đơn xác định vị trí dừng đếm. Mảng đầu ra bắt đầu từ 0và có giá trị gia tăng 1.

Nếu bạn cố gắng cung cấp rõ ràng stopmà không có start, thì bạn sẽ nhận được TypeError:

>>>

>>> np.arange(stop=10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: arange() missing required argument 'start' (pos 1)

Bạn gặp lỗi vì arange()không cho phép bạn tránh rõ ràng đối số đầu tiên tương ứng với start. Nếu bạn cung cấp một đối số duy nhất, thì nó phải như vậy start, nhưng arange()sẽ sử dụng nó để xác định vị trí dừng đếm.

Cung cấp đối số phủ định

Nếu bạn cung cấp các giá trị âm cho starthoặc cả hai startvà stopvà có một giá trị dương step, thì arange()sẽ hoạt động giống như với tất cả các đối số khẳng định:

>>>

>>> np.arange(-5, -1)
array([-5, -4, -3, -2])
>>> np.arange(-8, -2, 2)
array([-8, -6, -4])
>>> np.arange(-5, 6, 4)
array([-5, -1,  3])

Hành vi này hoàn toàn phù hợp với các ví dụ trước. Việc đếm bắt đầu bằng giá trị của start, tăng lên nhiều lần stepvà kết thúc trước khi stopđạt đến giá trị.

Đếm ngược

Đôi khi bạn sẽ muốn một mảng có các giá trị giảm dần từ trái sang phải. Trong những trường hợp như vậy, bạn có thể sử dụng arange()với giá trị âm cho stepvà với giá trị startlớn hơn stop:

>>>

>>> np.arange(5, 1, -1)
array([5, 4, 3, 2])
>>> np.arange(7, 0, -3)
array([7, 4, 1])

Trong ví dụ này, hãy lưu ý mẫu sau: mảng thu được bắt đầu bằng giá trị của đối số đầu tiên và giảm dần đối stepvới giá trị của đối số thứ hai.

Trong câu lệnh cuối cùng, startlà 7, và mảng kết quả bắt đầu bằng giá trị này. steplà -3vì vậy giá trị thứ hai là 7 + (- 3), đó là 4. Giá trị thứ ba là 4 + (- 3) hoặc 1. Việc đếm dừng ở đây vì stop( 0) đạt đến trước giá trị tiếp theo ( -2).

Bạn có thể xem các biểu diễn đồ họa của ví dụ này trong hình bên dưới:

Một lần nữa, startđược hiển thị bằng màu xanh lá cây, stopmàu đỏ, trong khi stepvà các giá trị chứa trong mảng là màu xanh lam.

Lần này, các mũi tên chỉ hướng từ phải sang trái. Đó là bởi vì startlớn hơn stop, steplà âm, và về cơ bản bạn đang đếm ngược.

Ví dụ trước cho kết quả tương tự như sau:

>>>

>>> np.arange(1, 8, 3)[::-1]
array([7, 4, 1])
>>> np.flip(np.arange(1, 8, 3))
array([7, 4, 1])

Tuy nhiên, biến thể với giá trị âm steplà thanh lịch và ngắn gọn hơn.

Nhận Mảng trống

Có một số trường hợp cạnh mà bạn có thể lấy các mảng NumPy trống arange(). Đây là những trường hợp thường xuyên numpy.ndarraykhông có bất kỳ phần tử nào.

Nếu bạn cung cấp các giá trị bằng nhau cho startvà stop, thì bạn sẽ nhận được một mảng trống:

>>>

>>> np.arange(2, 2)
array([], dtype=int64)

Điều này là do việc đếm kết thúc trước khi stopđạt đến giá trị của . Vì giá trị của startbằng stop, nên nó cũng không thể được tiếp cận và đưa vào mảng kết quả.

Một trong những trường hợp bất thường là khi nào startlớn hơn stopvà stepdương, hoặc khi startnhỏ hơn stopvà stepâm:

>>>

>>> np.arange(8, 2, 1)
array([], dtype=int64)
>>> np.arange(2, 8, -1)
array([], dtype=int64)

Như bạn có thể thấy, những ví dụ này dẫn đến các mảng trống, không có lỗi.

Các loại dữ liệu của np.arange()

Kiểu của các phần tử trong mảng NumPy là một khía cạnh quan trọng của việc sử dụng chúng. Khi làm việc với arange(), bạn có thể chỉ định loại phần tử với tham số dtype.

Lưu ý: Dưới đây là một số điểm quan trọng về kiểu của các phần tử có trong mảng NumPy:

• Tất cả các phần tử trong một mảng NumPy có cùng kiểu gọi là dtype (viết tắt của kiểu dữ liệu ).
• Các kiểu NumPy cho phép chi tiết hơn các kiểu số tích hợp sẵn của Python.
• Trong một số trường hợp, kiểu NumPy có bí danh tương ứng với tên của kiểu tích hợp sẵn trong Python.
• Thông thường, các quy trình NumPy có thể chấp nhận các kiểu số Python và ngược lại.
• Một số kiểu NumPy có định nghĩa phụ thuộc vào nền tảng.

Nếu bạn muốn tìm hiểu thêm về các kiểu của mảng NumPy, vui lòng đọc tài liệu chính thức .

Bạn có thể tự do bỏ qua dtype. Trong trường hợp này, arange()sẽ cố gắng suy ra kiểu của mảng kết quả. Nó phụ thuộc vào các loại start, stopvà step, như bạn có thể thấy trong ví dụ sau:

>>>

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> x.dtype
dtype('int64')
>>> x.itemsize  # In bytes
8

Ở đây, có một đối số ( 5) xác định phạm vi giá trị. Loại của nó là int. Đó là lý do tại sao dtype của mảng xsẽ là một trong những kiểu số nguyên được cung cấp bởi NumPy. Trong trường hợp này, NumPy chọn int64kiểu theo mặc định. Đây là kiểu số nguyên 64 bit (8 byte).

Mảng trong ví dụ trước tương đương với mảng này:

>>>

>>> x = np.arange(5, dtype=int)
>>> x
array([0, 1, 2, 3, 4])
>>> x.dtype
dtype('int64')

Đối số dtype=int không tham chiếu đến Python int. Nó dịch sang NumPy int64hoặc đơn giản np.int.

NumPy cung cấp cho bạn một số kiểu số nguyên có kích thước cố định khác nhau về bộ nhớ và giới hạn:

• np.int8: Số nguyên có dấu 8 bit (từ -128đến 127)
• np.uint8: Số nguyên không dấu 8 bit (từ 0đến 255)
• np.int16: Số nguyên có dấu 16 bit (từ -32768đến 32767)
• np.uint16: Số nguyên không dấu 16 bit (từ 0đến 65535)
• np.int32: Số nguyên có dấu 32 bit (từ -2**31đến 2**31-1)
• np.uint32: Số nguyên không dấu 32 bit (từ 0đến 2**32-1)
• np.int64: Số nguyên có dấu 64 bit (từ -2**63đến 2**63-1)
• np.uint64: Số nguyên không dấu 64 bit (từ 0đến 2**64-1)

Nếu bạn muốn các kiểu số nguyên khác cho các phần tử trong mảng của mình, thì chỉ cần chỉ định dtype:

>>>

>>> x = np.arange(5, dtype=np.int32)
>>> x
array([0, 1, 2, 3, 4], dtype=int32)
>>> x.dtype
dtype('int32')
>>> x.itemsize  # In bytes
4

Bây giờ mảng kết quả có các giá trị giống như trong trường hợp trước, nhưng kiểu và kích thước của các phần tử khác nhau. Đối số dtype=np.int32(hoặc dtype='int32') buộc kích thước của mỗi phần tử xlà 32 bit (4 byte).

Khi đối số của bạn là số thập phân thay vì số nguyên, kiểu dtype sẽ là một số kiểu dấu phẩy động NumPy, trong trường hợp này float64:

>>>

>>> y = np.arange(5.0)
>>> y
array([0., 1., 2., 3., 4.])
>>> y.dtype
dtype('float64')

Giá trị của các phần tử giống nhau trong bốn ví dụ cuối cùng, nhưng các kiểu khác nhau.

Nói chung, khi bạn cung cấp ít nhất một đối số dấu phẩy động arange(), mảng kết quả sẽ có các phần tử dấu phẩy động, ngay cả khi các đối số khác là số nguyên:

>>>

>>> np.arange(1, 5.1)
array([1., 2., 3., 4., 5.])
>>> np.arange(1, 5.1).dtype
dtype('float64')
>>> np.arange(0, 9, 1.5)
array([0. , 1.5, 3. , 4.5, 6. , 7.5])
>>> np.arange(0, 9, 1.5).dtype
dtype('float64')

Trong các ví dụ trên, startlà một số nguyên, nhưng kiểu là np.float64vì stophoặc steplà các số dấu phẩy động.

Nếu bạn chỉ định dtype, thì arange()sẽ cố gắng tạo ra một mảng với các phần tử của kiểu dữ liệu được cung cấp:

>>>

>>> y = np.arange(5, dtype=float)
>>> y
array([0., 1., 2., 3., 4.])
>>> y.dtype
dtype('float64')

Đối số dtype=floatở đây được dịch thành NumPy float64, nghĩa là np.float. Nó không đề cập đến Python float. Các bí danh có kích thước cố định cho float64là np.float64và np.float_.

Khi bạn cần một kiểu dấu phẩy động với độ chính xác và kích thước thấp hơn (tính bằng byte), bạn có thể chỉ định rõ ràng rằng:

>>>

>>> z = np.arange(5, dtype=np.float32)
>>> z
array([0., 1., 2., 3., 4.], dtype=float32)
>>> z.dtype
dtype('float32')

Sử dụng dtype=np.float32(hoặc dtype='float32') làm cho mỗi phần tử của mảng z32 bit (4 byte) lớn. Kích thước của mỗi phần tử ylà 64 bit (8 byte):

>>>

>>> y.itemsize  # In bytes
8
>>> z.itemsize  # In bytes
4

Sự khác biệt giữa các phần tử của yvà z, và nói chung là giữa np.float64và np.float32, là bộ nhớ được sử dụng và độ chính xác: phần tử đầu tiên lớn hơn và chính xác hơn phần tử thứ hai.

Trong nhiều trường hợp, bạn sẽ không nhận thấy sự khác biệt này. Tuy nhiên, đôi khi nó quan trọng. Ví dụ, TensorFlow sử dụng float32vàint32 . Tương tự như vậy, khi bạn đang làm việc với hình ảnh, thậm chí các loại nhỏ hơn như uint8được sử dụng .

Khi stepkhông phải là số nguyên, kết quả có thể không nhất quán do các hạn chế của số học dấu phẩy động .

Vượt ra ngoài phạm vi đơn giản với np.arange()

Bạn có thể thoải mái kết hợp arange()với các nhà khai thác (như +, -, *, /, **, và vân vân) và thói quen NumPy khác (chẳng hạn như abs()hay sin()) để tạo ra các dãy các giá trị đầu ra:

>>>

>>> x = np.arange(5)
>>> x
array([0, 1, 2, 3, 4])
>>> 2**x
array([ 1,  2,  4,  8, 16])
>>> y = np.arange(-1, 1.1, 0.5)
>>> y
array([-1. , -0.5,  0. ,  0.5,  1. ])
>>> np.abs(y)
array([1. , 0.5, 0. , 0.5, 1. ])
>>> z = np.arange(10)
>>> np.sin(z)
array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,
       -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849])

Điều này đặc biệt thích hợp khi bạn muốn tạo một cốt truyện trong Matplotlib .

Nếu bạn cần một mảng nhiều chiều, thì bạn có thể kết hợp arange()với .reshape()hoặc các hàm và phương thức tương tự:

>>>

>>> a = np.arange(6).reshape((2, 3))
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> a.shape
(2, 3)
>>> a.ndim
2

Đó là cách bạn có thể lấy ndarraythể hiện với các phần tử [0, 1, 2, 3, 4, 5]và định hình lại nó thành một mảng hai chiều.

So sánh rangevànp.arange()

Python có một lớp tích hợp range, tương tự như NumPy arange()ở một mức độ nào đó. rangevà np.arange()có sự khác biệt quan trọng liên quan đến ứng dụng và hiệu suất. Bạn sẽ thấy sự khác biệt và giống nhau của chúng.

Sự khác biệt chính giữa cả hai là rangemột lớp Python được xây dựng trong, trong khi arange()là một hàm thuộc thư viện của bên thứ ba (NumPy).

Ngoài ra, mục đích của họ là khác nhau! Nói chung, rangephù hợp hơn khi bạn cần lặp lại bằng cách sử dụng vòng lặp Pythonfor . Nếu bạn muốn tạo một mảng NumPy và áp dụng các vòng lặp nhanh bên dưới, thì đó arange()là một giải pháp tốt hơn nhiều.

Tham số và kết quả đầu ra

Cả hai rangevà arange()có cùng các tham số xác định phạm vi của các số thu được:

• start
• stop
• step

Bạn áp dụng các tham số này tương tự, ngay cả trong các trường hợp khi startvà stopbằng nhau.

Tuy nhiên, khi làm việc với range:

• Bạn phải cung cấp các đối số nguyên. Nếu không, bạn sẽ nhận được một TypeError.
• Bạn không thể chỉ định loại của các số được kết quả. Nó luôn luôn int.

rangevà arange()cũng khác nhau về loại trả lại của chúng:

• rangetạo một phiên bản của lớp này có các tính năng giống như các chuỗi khác (như listvàtuple ), chẳng hạn như thành viên, nối, lặp, cắt, so sánh, kiểm tra độ dài và hơn thế nữa.
• arange()trả về một thể hiện của NumPy ndarray.

Tạo chuỗi

Bạn có thể áp dụng rangeđể tạo một phiên bản của listhoặc tuplevới các số cách đều nhau trong một phạm vi được xác định trước. Bạn có thể nhận thấy sự hiểu biết đặc biệt thích hợp cho mục đích này.

Tuy nhiên, việc tạo và thao tác với mảng NumPy thường nhanh hơn và thanh lịch hơn so với làm việc với danh sách hoặc bộ giá trị.

Hãy so sánh hiệu suất của việc tạo listbằng cách sử dụng khả năng hiểu với một NumPy tương đương ndarrayvới arange():

>>>

>>> import timeit
>>> n = 1
>>> timeit.timeit(f'x = [i**2 for i in range({n})]')
>>> timeit.timeit(f'x = np.arange({n})**2', setup='import numpy as np')

Việc lặp lại mã này cho các giá trị khác nhau nđã mang lại các kết quả sau trên máy của tôi:

Các kết quả này có thể khác nhau, nhưng rõ ràng bạn có thể tạo mảng NumPy nhanh hơn nhiều so với một danh sách, ngoại trừ các chuỗi có độ dài rất nhỏ. (Ứng dụng này thường mang lại các lợi ích hiệu suất bổ sung!)

Điều này là do NumPy thực hiện nhiều hoạt động, bao gồm cả lặp, trên C.-level. Ngoài ra, NumPy được tối ưu hóa để làm việc với vectơ và tránh một số chi phí liên quan đến Python.

Python forLoops

Nếu bạn cần các giá trị để lặp lại trong một forvòng lặp Python , thì đó rangethường là giải pháp tốt hơn. Theo tài liệu Python chính thức:

Ưu điểm của các rangeloại trên thường xuyên listhoặc tuplelà một rangeđối tượng sẽ luôn đi cùng (nhỏ) dung lượng bộ nhớ, không có vấn đề kích thước của dãy nó đại diện (vì nó chỉ lưu trữ start, stopvà stepcác giá trị tính toán từng mục và subranges khi cần thiết ). ( Nguồn )

rangethường nhanh hơn so với arange()khi được sử dụng trong forcác vòng lặp Python , đặc biệt là khi có khả năng thoát ra khỏi vòng lặp sớm. Điều này là do rangetạo ra các số theo kiểu lười biếng, khi chúng được yêu cầu, mỗi lần một số.

Ngược lại, arange()tạo ra tất cả các số ở đầu.

Để biết thêm thông tin về range, bạn có thể kiểm tra Hàm Python range () (Hướng dẫn) và tài liệu chính thức .

Các quy trình khác dựa trên phạm vi số

Ngoài ra arange(), bạn có thể áp dụng các quy trình tạo mảng NumPy khác dựa trên phạm vi số:

• linspace()tương tự như arange()ở chỗ nó trả về các số cách đều nhau. Nhưng bạn có thể chỉ định số lượng giá trị sẽ tạo cũng như có bao gồm điểm cuối hay không và có tạo nhiều mảng cùng một lúc hay không.
• logspace()vàgeomspace() tương tự như linspace(), ngoại trừ các số trả về được đặt cách đều nhau trên thang logarit.
• meshgrid(), ogrid()vàmgrid() trả về lưới các điểm được biểu diễn dưới dạng mảng.

Tất cả các chức năng này có các chi tiết cụ thể và các trường hợp sử dụng của chúng. Bạn có thể chọn một trong những thích hợp theo nhu cầu của bạn.

Như bạn đã thấy, NumPy chứa nhiều quy trình hơn để tạo các phiên bảnndarray .

Tóm tắt nhanh

Để sử dụng NumPy arange(), numpytrước tiên bạn cần nhập :

>>>

>>> import numpy as np

Dưới đây là bảng với một vài ví dụ tóm tắt cách sử dụng NumPy arange(). Có thể hữu ích nếu ghi nhớ các cách sử dụng:

Đừng quên rằng bạn cũng có thể ảnh hưởng đến bộ nhớ được sử dụng cho các mảng của mình bằng cách chỉ định kiểu NumPy với tham số dtype.

Phần kết luận

Bây giờ bạn đã biết cách sử dụng NumPy arange(). Hàm np.arange()là một trong những quy trình cơ bản của NumPy thường được sử dụng để tạo các phiên bản của NumPy ndarray. Nó có bốn đối số:

1. start: giá trị đầu tiên của mảng
2. stop: nơi kết thúc mảng
3. step: tăng hoặc giảm
4. dtype: kiểu của các phần tử của mảng

Bạn cũng đã học cách NumPy arange()so sánh với lớp tích hợp sẵn trong Python rangekhi bạn đang tạo chuỗi và tạo giá trị để lặp lại.

Bạn thấy rằng có những thói quen tạo mảng NumPy khác dựa trên dãy số, chẳng hạn như linspace(), logspace(), meshgrid(), và vân vân.

Nếu bạn có thắc mắc hoặc ý kiến, xin vui lòng cho chúng vào phần bình luận bên dưới.