Analisis mendalam tentang operasi penghirisan numpy dan aplikasi dalam pertempuran sebenar

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]

Guna pengindeksan negatif Operasi menghiris

hasil = arr[-5:] # bermaksud mengambil 5 elemen terakhir tatasusunan

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

hasil = arr[:-3] # bermakna mengambil tatasusunan Semua elemen sebelum elemen ketiga hingga terakhir

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

2 Panduan aplikasi praktikal untuk operasi penghirisan numpy

Operasi penghirisan numpy dalam pemprosesan data dan pengkomputeran saintifik Mempunyai. pelbagai aplikasi. Di bawah ini kami menggunakan beberapa contoh khusus untuk menunjukkan aplikasi operasi menghiris.

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

import numpy sebagai np

Buat tatasusunan dua dimensi

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

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

print(arr)

Pilih baris kedua

[ 1, :]

cetak(hasil) # Output: [4 5 6]

Pilih lajur kedua

hasil = arr[:, 1]

cetak(hasil) # Output: [2 5 8]

Pilih sub Tatasusunan

hasil = arr[1:, 1:]

cetak(hasil) # Output: [[5 6]

          #       [8 9]]

Operasi menghiris bersyarat

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

print(bool_arr) # Output: [False False True True]

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

arr[arr > 2] = 0

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

3. Ringkasan

Artikel ini memperkenalkan penggunaan asas dan senario aplikasi biasa bagi operasi penghirisan dalam numpy, dan memberikan contoh kod operasi penghirisan adalah salah satu alat numpy yang fleksibel dan berkuasa dalam pemprosesan data dan pengkomputeran saintifik adalah penting untuk melaksanakan tugas pemprosesan data dan pelaksanaan algoritma adalah sangat penting Dengan mempelajari artikel ini, saya berharap pembaca akan mempunyai pemahaman yang lebih mendalam tentang operasi penghirisan dalam numpy dan dapat menggunakannya secara fleksibel dalam aplikasi praktikal

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!