Lặp trong python

Kiểm soát thứ tự lặp lại

Đôi khi, điều quan trọng là phải truy cập các phần tử của một mảng theo một thứ tự cụ thể, bất kể bố cục của các phần tử trong bộ nhớ. Đối tượng cung cấp một tham số thứ tự để kiểm soát khía cạnh lặp lại này. Mặc định, có hành vi được mô tả ở trên, là order=’K’ để giữ thứ tự hiện có. Điều này có thể được ghi đè bằng order=’C’ cho đơn hàng C và order=’F’ cho đơn hàng Fortran

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Sửa đổi giá trị mảng

Theo mặc định, toán hạng đầu vào được coi là đối tượng chỉ đọc. Để có thể sửa đổi các phần tử mảng, bạn phải chỉ định chế độ đọc-ghi hoặc chỉ ghi bằng cờ 'readwrite' hoặc 'writeonly' trên mỗi toán hạng

Sau đó, nditer sẽ tạo ra các mảng bộ đệm có thể ghi mà bạn có thể sửa đổi. Tuy nhiên, vì nditer phải sao chép dữ liệu bộ đệm này trở lại mảng ban đầu sau khi quá trình lặp kết thúc, bạn phải báo hiệu khi quá trình lặp kết thúc bằng một trong hai phương pháp. bạn có thể

• đã sử dụng nditer làm trình quản lý ngữ cảnh bằng cách sử dụng câu lệnh with và dữ liệu tạm thời sẽ được ghi lại khi thoát khỏi ngữ cảnh

• gọi phương thức đóng của iterator sau khi lặp xong, thao tác này sẽ kích hoạt quá trình ghi lại

Trình chỉ định không còn có thể được lặp lại sau khi lệnh đóng được gọi hoặc ngữ cảnh của nó bị thoát

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> with np.nditer(a, op_flags=['readwrite']) as it:
..    for x in it:
..        x[...] = 2 * x
...
>>> a
array([[ 0,  2,  4],
       [ 6,  8, 10]])

Nếu bạn đang viết mã cần hỗ trợ các phiên bản cũ hơn của numpy, hãy lưu ý rằng trước 1. 15, không phải là trình quản lý bối cảnh và không có phương thức đóng. Thay vào đó, nó dựa vào hàm hủy để bắt đầu ghi lại bộ đệm

Sử dụng vòng lặp bên ngoài

Trong tất cả các ví dụ cho đến nay, các phần tử của a được cung cấp lần lượt bởi trình vòng lặp, bởi vì tất cả logic vòng lặp là bên trong của trình vòng lặp. Mặc dù điều này đơn giản và thuận tiện, nhưng nó không hiệu quả lắm. Cách tiếp cận tốt hơn là di chuyển vòng lặp trong cùng một chiều vào mã của bạn, bên ngoài trình vòng lặp. Bằng cách này, các hoạt động vector hóa của NumPy có thể được sử dụng trên các phần tử lớn hơn đang được truy cập

Sẽ cố gắng cung cấp các khối càng lớn càng tốt cho vòng lặp bên trong. Bằng cách buộc thứ tự 'C' và 'F', chúng tôi nhận được các kích thước vòng lặp bên ngoài khác nhau. Chế độ này được bật bằng cách chỉ định cờ lặp

Quan sát rằng với mặc định giữ trật tự bộ nhớ riêng, trình vòng lặp có thể cung cấp một đoạn một chiều duy nhất, trong khi khi buộc thứ tự Fortran, nó phải cung cấp ba đoạn gồm hai phần tử mỗi đoạn

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, flags=['external_loop']):
..     print(x, end=' ')
...
[0 1 2 3 4 5]

>>> for x in np.nditer(a, flags=['external_loop'], order='F'):
..     print(x, end=' ')
...
[0 3] [1 4] [2 5]

Theo dõi một chỉ mục hoặc nhiều chỉ mục

Trong quá trình lặp lại, bạn có thể muốn sử dụng chỉ mục của phần tử hiện tại trong tính toán. Ví dụ: bạn có thể muốn truy cập các phần tử của một mảng theo thứ tự bộ nhớ, nhưng sử dụng thứ tự C, thứ tự Fortran hoặc chỉ mục đa chiều để tra cứu các giá trị trong một mảng khác

Chỉ mục được theo dõi bởi chính đối tượng iterator và có thể truy cập thông qua thuộc tính chỉ mục hoặc thuộc tính multi_index, tùy thuộc vào nội dung được yêu cầu. Các ví dụ dưới đây hiển thị các bản in thể hiện sự tiến triển của chỉ mục

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> it = np.nditer(a, flags=['f_index'])
>>> for x in it:
..     print("%d <%d>" % (x, it.index), end=' ')
...
0 <0> 1 <2> 2 <4> 3 <1> 4 <3> 5 <5>

>>> it = np.nditer(a, flags=['multi_index'])
>>> for x in it:
..     print("%d <%s>" % (x, it.multi_index), end=' ')
...
0 <(0, 0)> 1 <(0, 1)> 2 <(0, 2)> 3 <(1, 0)> 4 <(1, 1)> 5 <(1, 2)>

>>> with np.nditer(a, flags=['multi_index'], op_flags=['writeonly']) as it:
..     for x in it:
..         x[...] = it.multi_index[1] - it.multi_index[0]
...
>>> a
array([[ 0,  1,  2],
       [-1,  0,  1]])

Việc theo dõi một chỉ mục hoặc nhiều chỉ mục không tương thích với việc sử dụng vòng lặp bên ngoài vì nó yêu cầu một giá trị chỉ mục khác cho mỗi phần tử. Nếu bạn cố gắng kết hợp các cờ này, đối tượng sẽ đưa ra một ngoại lệ

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Vòng lặp thay thế và truy cập phần tử

Để làm cho các thuộc tính của nó dễ dàng truy cập hơn trong quá trình lặp, có một cú pháp thay thế để lặp, hoạt động rõ ràng với chính đối tượng trình lặp. Với cấu trúc vòng lặp này, giá trị hiện tại có thể truy cập được bằng cách lập chỉ mục vào trình vòng lặp. Các thuộc tính khác, chẳng hạn như các chỉ số được theo dõi vẫn như trước. Các ví dụ bên dưới tạo ra kết quả giống hệt với các ví dụ trong phần trước

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Bộ đệm các phần tử mảng

Khi buộc một thứ tự lặp lại, chúng tôi quan sát thấy rằng tùy chọn vòng lặp bên ngoài có thể cung cấp các phần tử theo các phần nhỏ hơn vì các phần tử không thể được truy cập theo thứ tự thích hợp với một bước tiến liên tục. Khi viết mã C, điều này nói chung là tốt, tuy nhiên trong mã Python thuần túy, điều này có thể làm giảm đáng kể hiệu suất

Bằng cách bật chế độ đệm, các khối do trình vòng lặp cung cấp cho vòng lặp bên trong có thể được làm lớn hơn, giảm đáng kể chi phí hoạt động của trình thông dịch Python. Trong ví dụ buộc thứ tự lặp lại Fortran, vòng lặp bên trong sẽ thấy tất cả các phần tử trong một lần khi kích hoạt bộ đệm

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Lặp lại dưới dạng một kiểu dữ liệu cụ thể

Đôi khi cần coi một mảng là một kiểu dữ liệu khác với kiểu dữ liệu được lưu trữ dưới dạng. Chẳng hạn, một người có thể muốn thực hiện tất cả các tính toán trên số float 64 bit, ngay cả khi các mảng đang được thao tác là số float 32 bit. Ngoại trừ khi viết mã C cấp thấp, tốt hơn hết là để trình vòng lặp xử lý việc sao chép hoặc lưu vào bộ đệm thay vì tự truyền kiểu dữ liệu trong vòng lặp bên trong

Có hai cơ chế cho phép thực hiện điều này, bản sao tạm thời và chế độ đệm. Với các bản sao tạm thời, một bản sao của toàn bộ mảng được tạo với kiểu dữ liệu mới, sau đó việc lặp lại được thực hiện trong bản sao. Quyền ghi được cho phép thông qua chế độ cập nhật mảng ban đầu sau khi hoàn tất quá trình lặp. Hạn chế chính của các bản sao tạm thời là bản sao tạm thời có thể tiêu tốn một lượng lớn bộ nhớ, đặc biệt nếu kiểu dữ liệu lặp lại có kích thước mục lớn hơn so với bản gốc

Chế độ đệm giảm thiểu vấn đề sử dụng bộ nhớ và thân thiện với bộ đệm hơn so với tạo bản sao tạm thời. Ngoại trừ các trường hợp đặc biệt, khi cần toàn bộ mảng cùng một lúc bên ngoài trình vòng lặp, nên sử dụng bộ đệm để sao chép tạm thời. Trong NumPy, bộ nhớ đệm được sử dụng bởi các ufunc và các chức năng khác để hỗ trợ các đầu vào linh hoạt với chi phí bộ nhớ tối thiểu

Trong các ví dụ của chúng tôi, chúng tôi sẽ xử lý mảng đầu vào bằng một kiểu dữ liệu phức tạp, để chúng tôi có thể lấy căn bậc hai của các số âm. Nếu không kích hoạt các bản sao hoặc chế độ đệm, trình vòng lặp sẽ đưa ra một ngoại lệ nếu loại dữ liệu không khớp chính xác

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Trong chế độ sao chép, 'bản sao' được chỉ định làm cờ cho mỗi toán hạng. Điều này được thực hiện để cung cấp quyền kiểm soát theo kiểu từng toán hạng. Chế độ đệm được chỉ định làm cờ lặp

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

Trình lặp sử dụng quy tắc truyền của NumPy để xác định xem một chuyển đổi cụ thể có được phép hay không. Theo mặc định, nó thực thi truyền 'an toàn'. Điều này có nghĩa là, ví dụ, nó sẽ đưa ra một ngoại lệ nếu bạn cố coi mảng float 64 bit là mảng float 32 bit. Trong nhiều trường hợp, quy tắc ‘same_kind’ là quy tắc hợp lý nhất để sử dụng, vì nó sẽ cho phép chuyển đổi từ float 64 sang 32 bit, chứ không phải từ float sang int hoặc từ phức sang float

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a.T):
..     print(x, end=' ')
...
0 1 2 3 4 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Một điều cần chú ý là chuyển đổi trở lại kiểu dữ liệu ban đầu khi sử dụng toán hạng chỉ đọc hoặc ghi. Một trường hợp phổ biến là triển khai vòng lặp bên trong theo số float 64 bit và sử dụng phép truyền 'same_kind' để cho phép các loại dấu phẩy động khác cũng được xử lý. Trong khi ở chế độ chỉ đọc, một mảng số nguyên có thể được cung cấp, chế độ đọc-ghi sẽ đưa ra một ngoại lệ vì chuyển đổi trở lại mảng sẽ vi phạm quy tắc truyền

Ví dụ

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Mảng đầu ra được phân bổ Iterator

Một trường hợp phổ biến trong các hàm NumPy là có các đầu ra được phân bổ dựa trên việc phát đầu vào và ngoài ra còn có một tham số tùy chọn gọi là 'ra' nơi kết quả sẽ được đặt khi nó được cung cấp. Đối tượng cung cấp một thành ngữ thuận tiện giúp hỗ trợ cơ chế này rất dễ dàng

Chúng tôi sẽ chỉ ra cách thức hoạt động của nó bằng cách tạo một hàm bình phương đầu vào của nó. Hãy bắt đầu với một định nghĩa hàm tối thiểu không bao gồm hỗ trợ tham số 'ngoài'

Ví dụ

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Theo mặc định, việc sử dụng các cờ 'phân bổ' và 'chỉ ghi' cho các toán hạng được chuyển vào là Không có. Điều này có nghĩa là chúng tôi chỉ có thể cung cấp hai toán hạng cho trình vòng lặp và nó xử lý phần còn lại

Khi thêm tham số 'ra', chúng ta phải cung cấp các cờ đó một cách rõ ràng, bởi vì nếu ai đó chuyển vào một mảng là 'ra', thì trình vòng lặp sẽ mặc định là 'chỉ đọc' và vòng lặp bên trong của chúng ta sẽ không thành công. Lý do 'chỉ đọc' là mặc định cho các mảng đầu vào là để tránh nhầm lẫn về việc vô tình kích hoạt thao tác rút gọn. Nếu giá trị mặc định là 'readwrite', thì bất kỳ thao tác phát sóng nào cũng sẽ kích hoạt quá trình giảm, một chủ đề sẽ được đề cập sau trong tài liệu này

Trong khi chúng tôi đang ở đó, hãy cũng giới thiệu cờ 'no_broadcast', điều này sẽ ngăn đầu ra không được phát sóng. Điều này rất quan trọng vì chúng tôi chỉ muốn một giá trị đầu vào cho mỗi đầu ra. Tổng hợp nhiều hơn một giá trị đầu vào là một thao tác rút gọn yêu cầu xử lý đặc biệt. Nó đã gây ra lỗi vì việc giảm phải được bật rõ ràng trong cờ lặp, nhưng thông báo lỗi do vô hiệu hóa phát sóng dễ hiểu hơn nhiều đối với người dùng cuối. Để biết cách khái quát hàm bình phương thành một phép rút gọn, hãy xem hàm tổng bình phương trong phần về Cython

Để hoàn thiện, chúng tôi cũng sẽ thêm cờ 'external_loop' và 'buffered', vì đây là những thứ bạn thường muốn vì lý do hiệu suất

Ví dụ

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

>>> for x in np.nditer(a.T.copy(order='C')):
..     print(x, end=' ')
...
0 3 1 4 2 5

Lặp lại sản phẩm bên ngoài

Bất kỳ phép toán nhị phân nào cũng có thể được mở rộng thành phép toán mảng theo kiểu sản phẩm bên ngoài như trong và đối tượng cung cấp cách để thực hiện điều này bằng cách ánh xạ rõ ràng các trục của toán hạng. Cũng có thể thực hiện việc này bằng cách lập chỉ mục, nhưng chúng tôi sẽ chỉ cho bạn cách sử dụng trực tiếp tham số nditer op_axes để thực hiện việc này mà không cần chế độ xem trung gian

Chúng ta sẽ thực hiện một tích ngoài đơn giản, đặt kích thước của toán hạng thứ nhất trước kích thước của toán hạng thứ hai. Tham số op_axes cần một danh sách các trục cho mỗi toán hạng và cung cấp ánh xạ từ các trục của trình vòng lặp tới các trục của toán hạng

Giả sử toán hạng đầu tiên là một chiều và toán hạng thứ hai là hai chiều. Trình vòng lặp sẽ có ba chiều, vì vậy op_axes sẽ có hai danh sách 3 phần tử. Danh sách đầu tiên chọn ra một trục của toán hạng đầu tiên và là -1 cho phần còn lại của các trục lặp, với kết quả cuối cùng là [0, -1, -1]. Danh sách thứ hai chọn ra hai trục của toán hạng thứ hai, nhưng không được trùng với các trục đã chọn trong toán hạng thứ nhất. Danh sách của nó là [-1, 0, 1]. Toán hạng đầu ra ánh xạ lên các trục của bộ lặp theo cách tiêu chuẩn, vì vậy chúng tôi có thể cung cấp Không thay vì xây dựng một danh sách khác

Hoạt động trong vòng lặp bên trong là một phép nhân đơn giản. Mọi thứ liên quan đến sản phẩm bên ngoài được xử lý bởi thiết lập iterator

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Lưu ý rằng khi đóng trình vòng lặp, chúng ta không thể truy cập và phải sử dụng tham chiếu được tạo bên trong trình quản lý ngữ cảnh

Lặp lại giảm

Bất cứ khi nào một toán hạng có thể ghi có ít phần tử hơn không gian lặp đầy đủ, thì toán hạng đó đang được rút gọn. Đối tượng yêu cầu bất kỳ toán hạng rút gọn nào được gắn cờ là đọc-ghi và chỉ cho phép rút gọn khi 'reduce_ok' được cung cấp dưới dạng cờ lặp

Đối với một ví dụ đơn giản, hãy xem xét việc lấy tổng của tất cả các phần tử trong một mảng

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Mọi thứ phức tạp hơn một chút khi kết hợp các toán hạng rút gọn và phân bổ. Trước khi bắt đầu lặp lại, bất kỳ toán hạng rút gọn nào cũng phải được khởi tạo về giá trị ban đầu của nó. Đây là cách chúng ta có thể làm điều này, tính tổng dọc theo trục cuối cùng của một

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5

Để thực hiện giảm vùng đệm, cần có một điều chỉnh khác trong quá trình thiết lập. Thông thường, việc xây dựng trình vòng lặp liên quan đến việc sao chép bộ đệm dữ liệu đầu tiên từ các mảng có thể đọc được vào bộ đệm. Mọi toán hạng rút gọn đều có thể đọc được, vì vậy nó có thể được đọc vào bộ đệm. Thật không may, việc khởi tạo toán hạng sau khi hoạt động tạo bộ đệm này hoàn tất sẽ không được phản ánh trong bộ đệm mà phép lặp bắt đầu và kết quả rác sẽ được tạo ra

Cờ lặp “delay_bufalloc” ở đó để cho phép các toán hạng rút gọn được cấp phát lặp tồn tại cùng với bộ đệm. Khi cờ này được đặt, trình vòng lặp sẽ không khởi tạo bộ đệm của nó cho đến khi nhận được lệnh đặt lại, sau đó nó sẽ sẵn sàng để lặp lại thông thường. Đây là ví dụ trước trông như thế nào nếu chúng ta cũng kích hoạt tính năng đệm

Ví dụ

>>> a = np.arange(6).reshape(2,3)
>>> for x in np.nditer(a, order='F'):
..     print(x, end=' ')
...
0 3 1 4 2 5
>>> for x in np.nditer(a.T, order='C'):
..     print(x, end=' ')
...
0 3 1 4 2 5