Mảng con liền kề python

xây dựng mảng

Các mảng mới có thể được tạo bằng cách sử dụng các quy trình được nêu chi tiết trong và cũng bằng cách sử dụng hàm tạo cấp thấp

[hình dạng [, dtype, buffer, offset,. ]]

Một đối tượng mảng đại diện cho một mảng đa chiều, đồng nhất của các mục có kích thước cố định

Mảng lập chỉ mục

Mảng có thể được lập chỉ mục bằng cách sử dụng cú pháp cắt Python mở rộng,

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

Xem thêm

.

Bố cục bộ nhớ trong của một ndarray

Một thể hiện của lớp bao gồm một phân đoạn bộ nhớ máy tính một chiều liền kề [thuộc sở hữu của mảng hoặc bởi một số đối tượng khác], được kết hợp với sơ đồ lập chỉ mục ánh xạ N số nguyên vào vị trí của một mục trong khối. Phạm vi mà các chỉ số có thể thay đổi được chỉ định bởi mảng. Mỗi mục chiếm bao nhiêu byte và cách diễn giải các byte được xác định bởi liên kết với mảng

Một đoạn bộ nhớ vốn dĩ là 1 chiều và có nhiều lược đồ khác nhau để sắp xếp các phần tử của mảng N chiều trong khối 1 chiều. NumPy rất linh hoạt và các đối tượng có thể chứa bất kỳ sơ đồ lập chỉ mục theo cấp độ nào. Trong lược đồ phân tầng, chỉ số N chiều \[[n_0, n_1,. , n_{N-1}]\] tương ứng với phần bù [tính bằng byte].

\[n_{\mathrm{offset}} = \sum_{k=0}^{N-1} s_k n_k\]

từ đầu khối nhớ liên kết với mảng. Ở đây, \[s_k\] là các số nguyên xác định giá trị của mảng. Các sơ đồ thứ tự [được sử dụng, ví dụ, trong ngôn ngữ Fortran và Matlab] và thứ tự [được sử dụng trong C] chỉ là các loại lược đồ theo từng bước cụ thể và tương ứng với bộ nhớ có thể được xử lý theo các bước.

\[s_k^{\mathrm{column}} = \mathrm{itemsize} \prod_{j=0}^{k-1} d_j , \quad s_k^{\mathrm{row}} = \mathrm{itemsize} \ . \]

where \[d_j\] = self. hình dạng[j].

Cả hai lệnh C và Fortran đều là , i. e. , bố trí bộ nhớ đơn đoạn, trong đó mọi phần của khối bộ nhớ có thể được truy cập bằng một số kết hợp của các chỉ số

Ghi chú

Mảng liền kề và mảng đơn đoạn đồng nghĩa và được sử dụng thay thế cho nhau trong toàn bộ tài liệu

Mặc dù mảng liền kề kiểu C và kiểu Fortran, có các cờ tương ứng được đặt, có thể được giải quyết bằng các bước trên, các bước thực tế có thể khác. Điều này có thể xảy ra trong hai trường hợp

1. Nếu

   >>> y = x[:,1]
   >>> y
   array[[2, 5], dtype=int32]
   >>> y[0] = 9 # this also changes the corresponding element in x
   >>> y
   array[[9, 5], dtype=int32]
   >>> x
   array[[[1, 9, 3],
          [4, 5, 6]], dtype=int32]
   

   1 thì đối với bất kỳ chỉ số pháp lý nào

   >>> y = x[:,1]
   >>> y
   array[[2, 5], dtype=int32]
   >>> y[0] = 9 # this also changes the corresponding element in x
   >>> y
   array[[9, 5], dtype=int32]
   >>> x
   array[[[1, 9, 3],
          [4, 5, 6]], dtype=int32]
   

   2. Điều này có nghĩa là trong công thức cho phần bù \[n_k = 0\] và do đó \[s_k n_k = . sải chân [k] là tùy ý. and the value of \[s_k\] = self.strides[k] is arbitrary.

2. Nếu một mảng không có phần tử [

   >>> y = x[:,1]
   >>> y
   array[[2, 5], dtype=int32]
   >>> y[0] = 9 # this also changes the corresponding element in x
   >>> y
   array[[9, 5], dtype=int32]
   >>> x
   array[[[1, 9, 3],
          [4, 5, 6]], dtype=int32]
   

   3] thì không có chỉ mục hợp lệ và các bước không bao giờ được sử dụng. Bất kỳ mảng nào không có phần tử nào có thể được coi là liền kề kiểu C và kiểu Fortran

Điểm 1. có nghĩa là

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

Một mảng được coi là căn chỉnh nếu độ lệch bộ nhớ cho tất cả các phần tử và chính độ lệch cơ sở là bội số của chính nó. kích thước mục. Hiểu về căn chỉnh bộ nhớ dẫn đến hiệu suất tốt hơn trên hầu hết các phần cứng

Cảnh báo

Nó thường không cho rằng

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

Dữ liệu trong new theo thứ tự [C], trừ khi được chỉ định khác, nhưng, chẳng hạn, thường tạo ra theo một sơ đồ khác

Ghi chú

Một số thuật toán trong NumPy hoạt động trên các mảng được sắp xếp tùy ý. Tuy nhiên, một số thuật toán yêu cầu mảng đơn đoạn. Khi một mảng có cấu trúc không đều được chuyển vào các thuật toán như vậy, một bản sao sẽ tự động được tạo

Thuộc tính mảng

Các thuộc tính của mảng phản ánh thông tin nội tại của chính mảng đó. Nói chung, việc truy cập một mảng thông qua các thuộc tính của nó cho phép bạn lấy và đôi khi đặt các thuộc tính nội tại của mảng mà không cần tạo một mảng mới. Các thuộc tính được hiển thị là các phần cốt lõi của một mảng và chỉ một số trong số chúng có thể được đặt lại một cách có ý nghĩa mà không cần tạo một mảng mới. Thông tin về mỗi thuộc tính được đưa ra dưới đây

Phương pháp mảng

Một đối tượng có nhiều phương thức hoạt động trên hoặc với mảng theo một cách nào đó, thường trả về một kết quả mảng. Những phương pháp này được giải thích ngắn gọn dưới đây. [Mỗi chuỗi tài liệu của phương pháp có một mô tả đầy đủ hơn. ]

Đối với các phương pháp sau đây cũng có các chức năng tương ứng trong. , , , , , , , , , , , , , , , , , , , , , , , , , , ,

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> x = np.arange[27].reshape[[3,3,3]]
>>> x
array[[[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8]],
       [[ 9, 10, 11],
        [12, 13, 14],
        [15, 16, 17]],
       [[18, 19, 20],
        [21, 22, 23],
        [24, 25, 26]]]]
>>> x.sum[axis=0]
array[[[27, 30, 33],
       [36, 39, 42],
       [45, 48, 51]]]
>>> # for sum, axis is the first keyword, so we may omit it,
>>> # specifying only its value
>>> x.sum[0], x.sum[1], x.sum[2]
[array[[[27, 30, 33],
        [36, 39, 42],
        [45, 48, 51]]],
 array[[[ 9, 12, 15],
        [36, 39, 42],
        [63, 66, 69]]],
 array[[[ 3, 12, 21],
        [30, 39, 48],
        [57, 66, 75]]]]

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

Các phép toán số học, nhân ma trận và so sánh

Các phép toán số học và so sánh trên được định nghĩa là các phép toán theo phần tử và thường mang lại các đối tượng dưới dạng kết quả

Each of the arithmetic operations [

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

Toán tử so sánh

[giá trị, /]

Tự trả về =giá trị

[giá trị, /]

Tự trả lại == giá trị

[giá trị, /]

trở lại chính mình. = giá trị

Giá trị thực của một mảng []

[/]

Đúng nếu tự khác Sai

Ghi chú

Kiểm tra giá trị thực của một mảng gọi, sẽ phát sinh lỗi nếu số lượng phần tử trong mảng lớn hơn 1, vì giá trị thực của các mảng đó không rõ ràng. Sử dụng và thay vào đó để rõ ràng về ý nghĩa trong những trường hợp như vậy. [Nếu số phần tử là 0, mảng sẽ ước tính là

>>> # The element of x in the *second* row, *third* column, namely, 6.
>>> x[1, 2]
6

phép toán một ngôi

[/]

-bản thân

[/]

+bản thân

[bản thân]

[/]

~ bản thân

Môn số học

[giá trị, /]

Trả về bản thân + giá trị

[giá trị, /]

Trả lại giá trị bản thân

[giá trị, /]

Trả về giá trị tự *

[giá trị, /]

Trả về bản thân/giá trị

[giá trị, /]

Trả về bản thân // giá trị

[giá trị, /]

Tự trả lại %giá trị

[giá trị, /]

Trả về divmod[bản thân, giá trị]

[giá trị[, mod]]

Trả về pow[bản thân, giá trị, mod]

[giá trị, /]

Tự trả lại giá trị giá trị

[giá trị, /]

Trả lại bản thân & giá trị

[giá trị, /]

trở lại chính mình. giá trị

[giá trị, /]

Trả về self^value

Ghi chú

• Bất kỳ đối số thứ ba nào được âm thầm bỏ qua, vì bên dưới chỉ có hai đối số

• Vì là kiểu dựng sẵn [được viết bằng C], các phương thức đặc biệt của

  >>> y = x[:,1]
  >>> y
  array[[2, 5], dtype=int32]
  >>> y[0] = 9 # this also changes the corresponding element in x
  >>> y
  array[[9, 5], dtype=int32]
  >>> x
  array[[[1, 9, 3],
         [4, 5, 6]], dtype=int32]
  

  01 không được định nghĩa trực tiếp

• Các hàm được gọi để thực hiện nhiều phương thức số học đặc biệt cho mảng có thể được sửa đổi bằng cách sử dụng

Số học, tại chỗ

[giá trị, /]

Tự trả về+=giá trị

[giá trị, /]

Trả về self-=giá trị

[giá trị, /]

Tự trả về*=giá trị

[giá trị, /]

Tự trả về/=giá trị

[giá trị, /]

Tự trả về //=giá trị

[giá trị, /]

Tự trả lại %=giá trị

[giá trị, /]

Tự trả về**=giá trị

[giá trị, /]

Tự trả về =giá trị

[giá trị, /]

Tự trả về&=giá trị

[giá trị, /]

trở lại chính mình. = giá trị

[giá trị, /]

Tự trả về^=giá trị

Cảnh báo

Các hoạt động tại chỗ sẽ thực hiện phép tính bằng cách sử dụng độ chính xác được quyết định bởi kiểu dữ liệu của hai toán hạng, nhưng sẽ âm thầm hạ thấp kết quả [nếu cần] để nó có thể khớp trở lại vào mảng. Do đó, đối với các phép tính chính xác hỗn hợp,

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

Phép nhân ma trận

[giá trị, /]

Trở lại

Ghi chú

Toán tử ma trận

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

>>> y = x[:,1]
>>> y
array[[2, 5], dtype=int32]
>>> y[0] = 9 # this also changes the corresponding element in x
>>> y
array[[9, 5], dtype=int32]
>>> x
array[[[1, 9, 3],
       [4, 5, 6]], dtype=int32]

phương pháp đặc biệt

Đối với chức năng thư viện tiêu chuẩn

[]

Được sử dụng nếu được gọi trên một mảng

[bản ghi nhớ, /]

Được sử dụng nếu được gọi trên một mảng

[]

để ngâm chua

[tiểu bang, /]

để giải nén

tùy chỉnh cơ bản

[*args, **kwargs]

[[dtype], /]

Trả về một tham chiếu mới cho self nếu dtype không được cung cấp hoặc một mảng mới có kiểu dữ liệu được cung cấp nếu dtype khác với dtype hiện tại của mảng

[mảng[, bối cảnh], /]

Trả về dạng xem có cùng loại với bản thân

Tùy chỉnh vùng chứa. [thấy ]

[/]

Trả lại len[tự]

[Chìa khóa, /]

Tự trả về[key]

[giá trị cốt lõi, /]

Đặt self[key] thành giá trị

[Chìa khóa, /]

Tự trả lại chìa khóa

Chuyển đổi; . Chúng chỉ hoạt động trên các mảng có một phần tử trong đó và trả về giá trị vô hướng thích hợp