Temukan indeks elemen dalam array python 2d

Pengindeksan elemen tunggal

Pengindeksan elemen tunggal berfungsi persis seperti itu untuk urutan Python standar lainnya. Ini berbasis 0, dan menerima indeks negatif untuk pengindeksan dari akhir array

>>> x = np.arange(10)
>>> x[2]
2
>>> x[-2]
8

Tidak perlu memisahkan setiap indeks dimensi ke dalam kumpulan tanda kurung sikunya sendiri

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Perhatikan bahwa jika seseorang mengindeks array multidimensi dengan indeks lebih sedikit daripada dimensi, maka akan diperoleh array subdimensi. Misalnya

>>> x[0]
array([0, 1, 2, 3, 4])

Artinya, setiap indeks yang ditentukan memilih larik yang sesuai dengan sisa dimensi yang dipilih. Dalam contoh di atas, memilih 0 berarti bahwa sisa dimensi dengan panjang 5 dibiarkan tidak ditentukan, dan yang dikembalikan adalah larik dengan dimensi dan ukuran tersebut. Harus dicatat bahwa array yang dikembalikan adalah a , i. e. , ini bukan salinan dari yang asli, tetapi menunjuk ke nilai yang sama di memori seperti halnya larik asli. Dalam hal ini, larik 1-D pada posisi pertama (0) dikembalikan. Jadi menggunakan satu indeks pada array yang dikembalikan, menghasilkan satu elemen yang dikembalikan. Itu adalah

>>> x[0][2]
2

Jadi perhatikan bahwa

>>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> x[1:7:2]
array([1, 3, 5])

Catatan

NumPy menggunakan pengindeksan C-order. Itu berarti indeks terakhir biasanya mewakili lokasi memori yang paling cepat berubah, tidak seperti Fortran atau IDL, di mana indeks pertama mewakili lokasi yang paling cepat berubah dalam memori. Perbedaan ini merupakan potensi besar untuk kebingungan

Mengiris dan melangkah

Pemotongan dasar memperluas konsep dasar pemotongan Python ke dimensi N. Pemotongan dasar terjadi ketika obj adalah objek (dibangun oleh

>>> x[-2:10]
array([8, 9])
>>> x[-3:3:-1]
array([7, 6, 5, 4])

Kasus pengindeksan paling sederhana dengan bilangan bulat N mengembalikan an yang mewakili item terkait. Seperti di Python, semua indeks berbasis nol. untuk indeks ke-i \(n_i\) , rentang yang valid adalah \(0 \le n_i < . Indeks negatif ditafsirkan sebagai menghitung dari akhir array (mis. e. , jika where \(d_i\) is the i-th element of the shape of the array. Negative indices are interpreted as counting from the end of the array (i.e., if \(n_i < 0\) , artinya \(n_i + d_i\)).

Semua larik yang dihasilkan oleh pemotongan dasar selalu dari larik asli

Catatan

Pemotongan NumPy membuat alih-alih salinan seperti dalam kasus urutan Python bawaan seperti string, tuple, dan daftar. Kehati-hatian harus diambil ketika mengekstraksi sebagian kecil dari array besar yang menjadi tidak berguna setelah ekstraksi, karena sebagian kecil yang diekstraksi berisi referensi ke array asli yang besar yang memorinya tidak akan dirilis sampai semua array yang berasal darinya dikumpulkan dari sampah. Dalam kasus seperti itu,

>>> x[-2:10]
array([8, 9])
>>> x[-3:3:-1]
array([7, 6, 5, 4])

Aturan standar pemotongan urutan berlaku untuk pemotongan dasar berdasarkan per dimensi (termasuk menggunakan indeks langkah). Beberapa konsep yang berguna untuk diingat termasuk

• Sintaks slice dasar adalah

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  5 di mana i adalah indeks awal, j adalah indeks penghentian, dan k adalah langkah ( \(k\neq0\)). This selects the m elements (in the corresponding dimension) with index values i, i + k, …, i + (m - 1) k where \(m = q + (r\neq0 . j - i = q k + r, sehingga i + (m - 1) k < j. Misalnya. and q and r are the quotient and remainder obtained by dividing j - i by k: j - i = q k + r, so that i + (m - 1) k < j. For example:

  >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  >>> x[1:7:2]
  array([1, 3, 5])
  

• Negatif i dan j ditafsirkan sebagai n + i dan n + j di mana n adalah jumlah elemen dalam dimensi yang sesuai. K negatif membuat langkah menuju indeks yang lebih kecil. Dari contoh di atas

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  _

• Asumsikan n adalah jumlah elemen dalam dimensi yang diiris. Kemudian, jika i tidak diberikan defaultnya adalah 0 untuk k > 0 dan n - 1 untuk k < 0. Jika j tidak diberikan defaultnya adalah n untuk k > 0 dan -n-1 untuk k < 0. Jika k tidak diberikan, defaultnya adalah 1. Perhatikan bahwa

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  _6 sama dengan

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7 dan artinya pilih semua indeks di sepanjang sumbu ini. Dari contoh di atas

  >>> x[5:]
  array([5, 6, 7, 8, 9])
  

• Jika jumlah objek dalam pemilihan tupel kurang dari N, maka

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7 diasumsikan untuk setiap dimensi berikutnya. Sebagai contoh

  >>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
  >>> x.shape
  (2, 3, 1)
  >>> x[1:2]
  array([[[4],
          [5],
          [6]]])
  

• Bilangan bulat, i, mengembalikan nilai yang sama dengan

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  9 kecuali dimensi objek yang dikembalikan dikurangi 1. Secara khusus, tupel pilihan dengan elemen p-th sebuah bilangan bulat (dan semua entri lainnya

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7) mengembalikan sub-array yang sesuai dengan dimensi N - 1. Jika N = 1 maka objek yang dikembalikan adalah skalar array. Obyek-obyek tersebut dijelaskan dalam

• Jika tupel pilihan memiliki semua entri

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7 kecuali entri p-th yang merupakan objek irisan

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  5, maka array yang dikembalikan memiliki dimensi N yang dibentuk dengan menggabungkan sub-array yang dikembalikan oleh pengindeksan bilangan bulat elemen i, i+k, …, i

• Pemotongan dasar dengan lebih dari satu entri non-

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7 di tupel pengiris, bertindak seperti penerapan pemotongan berulang menggunakan satu entri non-

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7, di mana entri non-

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7 diambil secara berurutan (dengan semua entri non-

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7 lainnya digantikan oleh

  >>> x[-2:10]
  array([8, 9])
  >>> x[-3:3:-1]
  array([7, 6, 5, 4])
  

  7). Jadi,

  >>> x[5:]
  array([5, 6, 7, 8, 9])
  

  _8 bertindak seperti

  >>> x[5:]
  array([5, 6, 7, 8, 9])
  

  9 di bawah pemotongan dasar

  Peringatan

  Hal di atas tidak berlaku untuk pengindeksan lanjutan

• Anda dapat menggunakan pemotongan untuk menetapkan nilai dalam larik, tetapi (tidak seperti daftar) Anda tidak akan pernah dapat menumbuhkan larik. Ukuran nilai yang akan ditetapkan di

  >>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
  >>> x.shape
  (2, 3, 1)
  >>> x[1:2]
  array([[[4],
          [5],
          [6]]])
  

  0 harus (dapat disiarkan ke) bentuk yang sama seperti

  >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  >>> x[1:7:2]
  array([1, 3, 5])
  

  6

• Tuple pengiris selalu dapat dibuat sebagai objek dan digunakan dalam notasi

  >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
  >>> x[1:7:2]
  array([1, 3, 5])
  

  6. Objek irisan dapat digunakan dalam konstruksi sebagai pengganti notasi

  >>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
  >>> x.shape
  (2, 3, 1)
  >>> x[1:2]
  array([[[4],
          [5],
          [6]]])
  

  3. Misalnya,

  >>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
  >>> x.shape
  (2, 3, 1)
  >>> x[1:2]
  array([[[4],
          [5],
          [6]]])
  

  _4 juga dapat diimplementasikan sebagai

  >>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
  >>> x.shape
  (2, 3, 1)
  >>> x[1:2]
  array([[[4],
          [5],
          [6]]])
  

  5. Ini dapat berguna untuk membangun kode generik yang bekerja pada array dimensi arbitrer. Lihat untuk informasi lebih lanjut

Alat pengindeksan dimensi

Ada beberapa alat untuk memudahkan pencocokan bentuk array dengan ekspresi dan tugas

memperluas ke jumlah

>>> x[-2:10]
array([8, 9])
>>> x[-3:3:-1]
array([7, 6, 5, 4])

>>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])
>>> x.shape
(2, 3, 1)
>>> x[1:2]
array([[[4],
        [5],
        [6]]])

>>> x[..., 0]
array([[1, 2, 3],
      [4, 5, 6]])

Ini setara dengan

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

Setiap objek dalam tupel seleksi berfungsi untuk memperluas dimensi dari seleksi yang dihasilkan oleh satu dimensi panjang-satuan. Dimensi yang ditambahkan adalah posisi objek dalam tupel pemilihan. adalah alias untuk

>>> x[..., 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[..., 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Ini berguna untuk menggabungkan dua larik dengan cara yang sebaliknya akan memerlukan operasi pembentukan ulang secara eksplisit. Misalnya

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Pengindeksan array bilangan bulat

Pengindeksan array bilangan bulat memungkinkan pemilihan item arbitrer dalam array berdasarkan indeks N-dimensi mereka. Setiap array bilangan bulat mewakili sejumlah indeks ke dalam dimensi itu

Nilai negatif diizinkan dalam larik indeks dan berfungsi seperti halnya dengan indeks atau irisan tunggal

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Jika nilai indeks di luar batas maka

>>> x[..., 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Ketika indeks terdiri dari larik bilangan bulat sebanyak dimensi larik yang diindeks, pengindeksannya langsung, tetapi berbeda dari pemotongan

Indeks lanjutan selalu dan diulang sebagai satu

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Perhatikan bahwa bentuk yang dihasilkan identik dengan bentuk array pengindeksan (siaran)

>>> x[..., 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

Pengindeksan dengan array indeks multidimensi cenderung menjadi penggunaan yang lebih tidak biasa, tetapi diizinkan, dan berguna untuk beberapa masalah. Kita akan mulai dengan kasus multidimensi yang paling sederhana

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Dalam hal ini, jika larik indeks memiliki bentuk yang cocok, dan ada larik indeks untuk setiap dimensi larik yang diindeks, larik yang dihasilkan memiliki bentuk yang sama dengan larik indeks, dan nilainya sesuai dengan set indeks untuk setiap . Dalam contoh ini, nilai indeks pertama adalah 0 untuk kedua array indeks, sehingga nilai pertama dari array yang dihasilkan adalah

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

Jika array indeks tidak memiliki bentuk yang sama, ada upaya untuk menyiarkannya ke bentuk yang sama. Jika mereka tidak dapat disiarkan ke bentuk yang sama, pengecualian akan dimunculkan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Mekanisme penyiaran memungkinkan array indeks digabungkan dengan skalar untuk indeks lainnya. Efeknya adalah nilai skalar digunakan untuk semua nilai yang sesuai dari array indeks

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Melompat ke tingkat kerumitan berikutnya, dimungkinkan untuk hanya mengindeks sebagian array dengan array indeks. Dibutuhkan sedikit pemikiran untuk memahami apa yang terjadi dalam kasus seperti itu. Misalnya jika kita hanya menggunakan satu array indeks dengan y

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Ini menghasilkan konstruksi array baru di mana setiap nilai array indeks memilih satu baris dari array yang diindeks dan array yang dihasilkan memiliki bentuk yang dihasilkan (jumlah elemen indeks, ukuran baris)

Secara umum, bentuk array yang dihasilkan akan menjadi gabungan dari bentuk array indeks (atau bentuk yang disiarkan oleh semua array indeks) dengan bentuk dimensi yang tidak digunakan (yang tidak diindeks) dalam array yang diindeks

Contoh

Dari setiap baris, elemen tertentu harus dipilih. Indeks baris hanya

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Untuk mencapai perilaku yang mirip dengan pengirisan dasar di atas, penyiaran dapat digunakan. Fungsi ini dapat membantu penyiaran ini. Ini paling baik dipahami dengan sebuah contoh

Contoh

Dari larik 4x3, elemen sudut harus dipilih menggunakan pengindeksan lanjutan. Jadi semua elemen yang kolomnya adalah salah satu dari

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[0]
array([0, 1, 2, 3, 4])

Namun, karena array pengindeksan di atas hanya berulang, penyiaran dapat digunakan (bandingkan operasi seperti

>>> x[:, :, 0]
array([[1, 2, 3],
      [4, 5, 6]])

>>> x[0]
array([0, 1, 2, 3, 4])

Penyiaran ini juga dapat dicapai dengan menggunakan fungsi tersebut

>>> x[0]
array([0, 1, 2, 3, 4])

Perhatikan bahwa tanpa panggilan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x[0]
array([0, 1, 2, 3, 4])

Perbedaan ini adalah hal yang paling penting untuk diingat tentang pengindeksan dengan beberapa indeks tingkat lanjut

Contoh

Contoh kehidupan nyata di mana pengindeksan lanjutan mungkin berguna adalah untuk tabel pencarian warna di mana kami ingin memetakan nilai gambar menjadi tiga kali lipat RGB untuk ditampilkan. Tabel pemeta dapat berbentuk (nlookup, 3). Pengindeksan array seperti itu dengan gambar dengan bentuk (ny, nx) dengan dtype=np. uint8 (atau tipe bilangan bulat apa pun asalkan nilainya dengan batas tabel pencarian) akan menghasilkan array bentuk (ny, nx, 3) di mana tiga kali lipat nilai RGB dikaitkan dengan setiap lokasi piksel

Pengindeksan array Boolean

Pengindeksan lanjutan ini terjadi ketika obj adalah objek array bertipe Boolean, seperti yang mungkin dikembalikan dari operator pembanding. Array indeks boolean tunggal praktis identik dengan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Jika

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> x[1:7:2]
array([1, 3, 5])

Kasus penggunaan umum untuk ini adalah memfilter nilai elemen yang diinginkan. Sebagai contoh, seseorang mungkin ingin memilih semua entri dari sebuah array yang bukan

>>> x[0]
array([0, 1, 2, 3, 4])

Atau ingin menambahkan konstanta ke semua elemen negatif

>>> x[0]
array([0, 1, 2, 3, 4])

Secara umum jika indeks menyertakan array Boolean, hasilnya akan sama dengan memasukkan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Jika hanya ada satu larik Boolean dan tidak ada larik pengindeks bilangan bulat, ini mudah. Kehati-hatian hanya harus dilakukan untuk memastikan bahwa indeks boolean memiliki dimensi yang tepat sebanyak yang seharusnya digunakan

Secara umum, ketika array boolean memiliki dimensi lebih sedikit daripada array yang diindeks, ini setara dengan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x[-2:10]
array([8, 9])
>>> x[-3:3:-1]
array([7, 6, 5, 4])

>>> x[0]
array([0, 1, 2, 3, 4])

Di sini baris ke-4 dan ke-5 dipilih dari larik yang diindeks dan digabungkan untuk membuat larik 2-D

Contoh

Dari sebuah array, pilih semua baris yang berjumlah kurang dari atau sama dengan dua

>>> x[0]
array([0, 1, 2, 3, 4])

Menggabungkan beberapa array pengindeksan Boolean atau Boolean dengan array pengindeksan integer dapat dipahami dengan analogi. Fungsi ini juga mendukung array boolean dan akan bekerja tanpa kejutan

Contoh

Gunakan pengindeksan boolean untuk memilih semua baris yang berjumlah genap. Pada saat yang sama kolom 0 dan 2 harus dipilih dengan indeks bilangan bulat lanjutan. Menggunakan fungsi ini dapat dilakukan dengan

>>> x[0]
array([0, 1, 2, 3, 4])

Tanpa panggilan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Atau tanpa

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x[0]
array([0, 1, 2, 3, 4])

Contoh

Gunakan larik bentuk boolean 2-D (2, 3) dengan empat elemen True untuk memilih baris dari larik bentuk 3-D (2, 3, 5) menghasilkan hasil bentuk 2-D (4, 5)

>>> x[0][2]
2

Menggabungkan pengindeksan lanjutan dan dasar

Ketika setidaknya ada satu irisan (

>>> x[-2:10]
array([8, 9])
>>> x[-3:3:-1]
array([7, 6, 5, 4])

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Dalam kasus paling sederhana, hanya ada satu indeks lanjutan yang digabungkan dengan sebuah slice. Misalnya

>>> x[0][2]
2

Akibatnya, operasi slice dan array indeks bersifat independen. Operasi irisan mengekstrak kolom dengan indeks 1 dan 2, (mis. e. kolom ke-2 dan ke-3), diikuti oleh operasi array indeks yang mengekstrak baris dengan indeks 0, 2 dan 4 (i. e baris pertama, ketiga dan kelima). Ini setara dengan

>>> x[0][2]
2

Sebuah indeks lanjutan tunggal dapat, misalnya, mengganti sebuah slice dan larik hasilnya akan sama. Namun, itu adalah salinan dan mungkin memiliki tata letak memori yang berbeda. Sepotong lebih disukai jika memungkinkan. Misalnya

>>> x[0][2]
2

Cara termudah untuk memahami kombinasi beberapa indeks tingkat lanjut adalah dengan memikirkan bentuk yang dihasilkan. Ada dua bagian untuk operasi pengindeksan, subruang yang ditentukan oleh pengindeksan dasar (tidak termasuk bilangan bulat) dan subruang dari bagian pengindeksan lanjutan. Dua kasus kombinasi indeks perlu dibedakan

• Indeks lanjutan dipisahkan oleh irisan, atau. Misalnya

  >>> x.shape = (2, 5)  # now x is 2-dimensional
  >>> x[1, 3]
  8
  >>> x[1, -1]
  9
  

  _28

• Indeks lanjutan semuanya bersebelahan. Misalnya

  >>> x.shape = (2, 5)  # now x is 2-dimensional
  >>> x[1, 3]
  8
  >>> x[1, -1]
  9
  

  _29 tetapi bukan

  >>> x.shape = (2, 5)  # now x is 2-dimensional
  >>> x[1, 3]
  8
  >>> x[1, -1]
  9
  

  30 karena

  >>> x.shape = (2, 5)  # now x is 2-dimensional
  >>> x[1, 3]
  8
  >>> x[1, -1]
  9
  

  31 adalah indeks lanjutan dalam hal ini

Dalam kasus pertama, dimensi yang dihasilkan dari operasi pengindeksan lanjutan didahulukan dalam larik hasil, dan dimensi subruang setelahnya. Dalam kasus kedua, dimensi dari operasi pengindeksan lanjutan dimasukkan ke dalam larik hasil di tempat yang sama seperti di larik awal (logika terakhir inilah yang membuat pengindeksan lanjutan sederhana berperilaku seperti mengiris)

Contoh

Misalkan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Contoh

Biarkan

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

>>> x.shape = (2, 5)  # now x is 2-dimensional
>>> x[1, 3]
8
>>> x[1, -1]
9

Contoh

Mengiris dapat dikombinasikan dengan indeks boolean yang disiarkan

>>> x[0][2]
2