Penjelasan terperinci kaedah operasi penghirisan numpy dan panduan aplikasi praktikal

Pengenalan: Numpy ialah salah satu perpustakaan pengkomputeran saintifik paling popular dalam Python, menyediakan fungsi operasi tatasusunan yang berkuasa. Antaranya, operasi menghiris adalah salah satu fungsi yang biasa digunakan dan berkuasa dalam numpy. Artikel ini akan memperkenalkan kaedah operasi penghirisan secara numpy secara terperinci, dan menunjukkan penggunaan khusus operasi penghirisan melalui panduan aplikasi praktikal.

1. Pengenalan kepada kaedah operasi penghirisan numpy

Operasi penghirisan Numpy merujuk kepada mendapatkan subset tatasusunan dengan menentukan julat indeks. Bentuk asasnya ialah: array[start:end:step]. Antaranya, mula mewakili indeks permulaan (inklusif), akhir mewakili indeks penamat (eksklusif), dan langkah mewakili saiz langkah (lalai ialah 1). Pada masa yang sama, numpy juga menyokong penggunaan parameter yang ditinggalkan dan indeks negatif.

1. Penggunaan asas operasi menghiris
   Mula-mula, mari kita lihat pada penggunaan asas operasi penghirisan numpy.

import numpy sebagai np

Buat tatasusunan satu dimensi

arr = np.arange(10)
print(arr) # Output: [0 1 2 3 4 5 6 7 8 9]

Operasi

hasil = arr[2:6]
cetak(hasil) # Output: [2 3 4 5]

Hiris tatasusunan dan tukar saiz langkah

hasil = arr[1:9:2]
cetak ( hasil) # Output: [1 3 5 7]

2. Penggunaan parameter yang ditinggalkan
   Mengabaikan parameter boleh memudahkan ungkapan penghirisan. Apabila permulaan diabaikan, lalai ialah 0 apabila tamat diabaikan, lalai ialah panjang tatasusunan apabila langkah diabaikan, lalai ialah 1.

import numpy sebagai np

Buat tatasusunan satu dimensi

arr = np.arange(10)
print(arr) # Output: [0 1 2 3 4 5 6 7 8 9]

Gunakan parameter yang ditinggalkan Operasi menghiris

hasil = arr[:5] # Tinggalkan parameter mula, yang bersamaan dengan arr[0:5]
cetak(hasil) # Output: [0 1 2 3 4]

hasil = arr[5: ] # Abaikan parameter tamat, bersamaan dengan arr[5:10]
print(hasil) # Output: [5 6 7 8 9]

result = arr[::2] # Abaikan parameter langkah, bersamaan dengan arr[0 :10:2 ]
cetak(hasil) # Output: [0 2 4 6 8]

3. Penggunaan indeks negatif
   Indeks negatif mewakili kedudukan yang dikira dari belakang ke hadapan, -1 mewakili elemen terakhir. Pengindeksan negatif memudahkan untuk mendapatkan bahagian timbal balik tatasusunan.

import numpy sebagai np

Buat tatasusunan satu dimensi

arr = np.arange(10)
print(arr) # Output: [0 1 2 3 4 5 6 7 8 9]

cetak(hasil) # Output: [5 6 7 8 9]

cetak(hasil) # Output: [0 1 2 3 4 5 6]

Operasi menghiris untuk tatasusunan dua dimensi
1. Untuk tatasusunan dua dimensi, kita boleh menggunakan operasi menghiris untuk memilih baris, lajur atau sub-tatasusunan.
   

            [4, 5, 6],
            [7, 8, 9]])

[ 1, :]

Pilih lajur kedua

hasil = arr[:, 1]

Pilih sub Tatasusunan

hasil = arr[1:, 1:]

          #       [8 9]]

Kendalian menghiris juga boleh digunakan bersama dengan pertimbangan bersyarat untuk menapis tatasusunan Atau tugasan.
2. 
   
import numpy sebagai np

Buat tatasusunan satu dimensi

arr = np.array([1, 2, 3, 4, 5])

Kira elemen yang lebih besar daripada 2 dalam tatasusunan

bool_arr = arr > 2

Gunakan operasi penghirisan bersyarat untuk memilih elemen yang lebih besar daripada 2

hasil = arr[bool_arr](hasil) [3 4 5]

Gunakan operasi penghirisan bersyarat untuk menetapkan nilai 0 kepada elemen yang lebih besar daripada 2

print(arr) # Output: [1 2 0 0 0]

3. Ringkasan

Atas ialah kandungan terperinci Analisis mendalam tentang operasi penghirisan numpy dan aplikasi dalam pertempuran sebenar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!