Kata Pengantar Penerjemah
Halo lagi! Melanjutkan serangkaian artikel kami tentang menerjemahkan mana tentang numpy. Selamat membaca.
Operator Perbandingan dan Pengujian Nilai
Perbandingan Boolean dapat digunakan untuk perbandingan array elemen dengan panjang yang sama. Nilai kembali adalah array dari nilai Boolean Benar / Salah:
>>> a = np.array([1, 3, 0], float) >>> b = np.array([0, 3, 2], float) >>> a > b array([ True, False, False], dtype=bool) >>> a == b array([False, True, False], dtype=bool) >>> a <= b array([False, True, True], dtype=bool)
Hasil perbandingan dapat disimpan dalam array:
>>> c = a > b >>> c array([ True, False, False], dtype=bool)
Array dapat dibandingkan dengan nilai tunggal:
>>> a = np.array([1, 3, 0], float) >>> a > 2 array([False, True, False], dtype=bool)
Operator any dan all dapat digunakan untuk menentukan apakah setidaknya satu atau semua elemen benar, secara berurutan:
>>> c = np.array([ True, False, False], bool) >>> any(c) True >>> all(c) False
Ekspresi Boolean gabungan dapat diterapkan ke array berdasarkan elemen demi elemen menggunakan fungsi khusus logical_and, logical_or dan logical_not:
>>> a = np.array([1, 3, 0], float) >>> np.logical_and(a > 0, a < 3) array([ True, False, False], dtype=bool) >>> b = np.array([True, False, True], bool) >>> np.logical_not(b) array([False, True, False], dtype=bool) >>> c = np.array([False, True, False], bool) >>> np.logical_or(b, c) array([ True, True, False], dtype=bool)
Di mana fungsi membuat array baru dari dua array lain dengan panjang yang sama menggunakan filter Boolean untuk memilih antara dua elemen. Sintaks dasar: di mana (boolarray,
truearray, falsearray):
>>> a = np.array([1, 3, 0], float) >>> np.where(a != 0, 1 / a, a) array([ 1. , 0.33333333, 0. ])
Dengan fungsi di mana, perbandingan massa juga dapat diterapkan:
>>> np.where(a > 0, 3, 2) array([3, 3, 2])
Beberapa fungsi memungkinkan untuk menguji nilai dalam array. Fungsi bukan nol mengembalikan sebuah tupel indeks nilai bukan nol. Jumlah elemen dalam tuple sama dengan jumlah sumbu dalam array:
>>> a = np.array([[0, 1], [3, 0]], float) >>> a.nonzero() (array([0, 1]), array([1, 0]))
Anda juga dapat memeriksa nilai untuk finiteness dan NaN (bukan angka):
>>> a = np.array([1, np.NaN, np.Inf], float) >>> a array([ 1., NaN, Inf]) >>> np.isnan(a) array([False, True, False], dtype=bool) >>> np.isfinite(a) array([ True, False, False], dtype=bool)
Meskipun kami menggunakan konstanta numpy di sini untuk menambahkan NaN dan infinity, mereka dapat menjadi hasil dari penerapan operasi matematika standar.
Memilih dan memanipulasi elemen array
Kita telah melihat, seperti daftar, elemen array dapat diperoleh dengan menggunakan operasi akses berdasarkan indeks. Namun, tidak seperti daftar, array juga memungkinkan Anda memilih item menggunakan array lain. Ini berarti bahwa kita dapat menggunakan array untuk memfilter himpunan bagian tertentu dari elemen array lainnya.
Array Boolean dapat digunakan sebagai array untuk penyaringan:
>>> a = np.array([[6, 4], [5, 9]], float) >>> a >= 6 array([[ True, False], [False, True]], dtype=bool) >>> a[a >= 6] array([ 6., 9.])
Perlu dicatat bahwa ketika kita melewatkan array boolean a> = 6 sebagai indeks untuk operasi akses dengan indeks array a, array yang dikembalikan hanya akan menyimpan nilai True. Kita juga bisa menulis array untuk difilter ke dalam variabel:
>>> a = np.array([[6, 4], [5, 9]], float) >>> sel = (a >= 6) >>> a[sel] array([ 6., 9.])
Penyaringan yang lebih canggih dapat dicapai menggunakan ekspresi Boolean:
>>> a[np.logical_and(a > 5, a < 9)] >>> array([ 6.])
Selain pemilihan Boolean, Anda juga dapat menggunakan array integer. Dalam hal ini, array integer menyimpan indeks elemen yang akan diambil dari array. Pertimbangkan contoh satu dimensi berikut ini:
>>> a = np.array([2, 4, 6, 8], float) >>> b = np.array([0, 0, 1, 3, 2, 1], int) >>> a[b] array([ 2., 2., 4., 8., 6., 4.])
Dengan kata lain, ketika kita menggunakan b untuk mendapatkan elemen dari a, kita mengambil elemen 0, 0, 1, 3, 2 dan 1 dari a dalam urutan ini. Daftar juga dapat digunakan sebagai array untuk pemfilteran:
>>> a = np.array([2, 4, 6, 8], float) >>> a[[0, 0, 1, 3, 2, 1]] array([ 2., 2., 4., 8., 6., 4.])
Untuk array multidimensi, kita perlu mentransfer beberapa array integer satu dimensi ke indeks operator akses (
Catatan penerjemah: dalam kasus kami, indeks adalah array ) untuk setiap sumbu. Kemudian masing-masing array melewati urutan berikut: elemen pertama berhubungan dengan indeks baris, yang merupakan elemen pertama dari array b, elemen kedua berhubungan dengan indeks kolom, yang merupakan elemen pertama dari array c, dan seterusnya. (
Catatan penerjemah: array pertama [2, 2] dan yang kedua [1, 4], kami memiliki elemen dengan indeks [2, 1] dan [2, 4] pada output ) Contoh:
>>> a = np.array([[1, 4], [9, 16]], float) >>> b = np.array([0, 0, 1, 1, 0], int) >>> c = np.array([0, 1, 1, 1, 1], int) >>> a[b,c] array([ 1., 4., 16., 16., 4.])
Fungsi take khusus tersedia untuk mengambil dengan array integer. Ini berfungsi sama seperti menggunakan operator take pada indeks:
>>> a = np.array([2, 4, 6, 8], float) >>> b = np.array([0, 0, 1, 3, 2, 1], int) >>> a.take(b) array([ 2., 2., 4., 8., 6., 4.])
Fungsi take juga menyediakan argumen sumbu untuk mengambil subbagian dari array multidimensi sepanjang sumbu. (
Catatan penerjemah: baris atau kolom (untuk array dua dimensi) ).
>>> a = np.array([[0, 1], [2, 3]], float) >>> b = np.array([0, 0, 1], int) >>> a.take(b, axis=0) array([[ 0., 1.], [ 0., 1.], [ 2., 3.]]) >>> a.take(b, axis=1) array([[ 0., 0., 1.], [ 2., 2., 3.]])
Berbeda dengan fungsi take, ada fungsi put, yang akan mengambil nilai dari array asli dan menuliskannya ke indeks spesifik di array put lain.
>>> a = np.array([0, 1, 2, 3, 4, 5], float) >>> b = np.array([9, 8, 7], float) >>> a.put([0, 3], b) >>> a array([ 9., 1., 2., 8., 4., 5.])
Perhatikan bahwa nilai 7 dari array asli b tidak digunakan, karena hanya 2 indeks [0, 3] yang ditunjukkan. Array asli akan diulang jika perlu jika panjangnya tidak cocok:
>>> a = np.array([0, 1, 2, 3, 4, 5], float) >>> a.put([0, 3], 5) >>> a array([ 5., 1., 2., 5., 4., 5.])
Vektor dan matriks matematika
NumPy menyediakan banyak fungsi untuk bekerja dengan vektor dan matriks. Fungsi titik mengembalikan produk skalar vektor:
>>> a = np.array([1, 2, 3], float) >>> b = np.array([0, 1, 1], float) >>> np.dot(a, b) 5.0
Fungsi titik juga dapat melipatgandakan matriks:
>>> a = np.array([[0, 1], [2, 3]], float) >>> b = np.array([2, 3], float) >>> c = np.array([[1, 1], [4, 0]], float) >>> a array([[ 0., 1.], [ 2., 3.]]) >>> np.dot(b, a) array([ 6., 11.]) >>> np.dot(a, b) array([ 3., 13.]) >>> np.dot(a, c) array([[ 4., 0.], [ 14., 2.]]) >>> np.dot(c, a) array([[ 2., 4.], [ 0., 4.]])
Anda juga bisa mendapatkan skalar, tensor, dan produk luar dari matriks dan vektor. Perhatikan bahwa untuk vektor, produk dalam dan skalar bertepatan.
>>> a = np.array([1, 4, 0], float) >>> b = np.array([2, 2, 1], float) >>> np.outer(a, b) array([[ 2., 2., 1.], [ 8., 8., 4.], [ 0., 0., 0.]]) >>> np.inner(a, b) 10.0 >>> np.cross(a, b) array([ 4., -1., -6.])
NumPy juga menyediakan serangkaian fungsi dan metode bawaan untuk bekerja dengan aljabar linier. Ini semua dapat ditemukan di sub-modul linalg. Modul-modul ini juga dapat dioperasikan dengan matriks degenerate dan non-degenerate. Penentu matriks dicari dengan cara ini:
>>> a = np.array([[4, 2, 0], [9, 3, 7], [1, 2, 1]], float) >>> a array([[ 4., 2., 0.], [ 9., 3., 7.], [ 1., 2., 1.]]) >>> np.linalg.det(a) -48.
Anda juga dapat menemukan vektor eigen dan nilai eigen dari matriks:
>>> vals, vecs = np.linalg.eig(a) >>> vals array([ 9. , 2.44948974, -2.44948974]) >>> vecs array([[-0.3538921 , -0.56786837, 0.27843404], [-0.88473024, 0.44024287, -0.89787873], [-0.30333608, 0.69549388, 0.34101066]])
Matriks non-degenerasi dapat ditemukan sebagai berikut:
>>> b = np.linalg.inv(a) >>> b array([[ 0.14814815, 0.07407407, -0.25925926], [ 0.2037037 , -0.14814815, 0.51851852], [-0.27777778, 0.11111111, 0.11111111]]) >>> np.dot(a, b) array([[ 1.00000000e+00, 5.55111512e-17, 2.22044605e-16], [ 0.00000000e+00, 1.00000000e+00, 5.55111512e-16], [ 1.11022302e-16, 0.00000000e+00, 1.00000000e+00]])
Dekomposisi tunggal (analog diagonalisasi matriks non-kuadrat) dapat dicapai sebagai berikut:
>>> a = np.array([[1, 3,4], [5, 2, 3]], float) >>> U, s, Vh = np.linalg.svd(a) >>> U array([[-0.6113829 , -0.79133492], [-0.79133492, 0.6113829 ]]) >>> s array([ 7.46791327, 2.86884495]) >>> Vh array([[-0.61169129, -0.45753324, -0.64536587], [ 0.78971838, -0.40129005, -0.46401635], [-0.046676 , -0.79349205, 0.60678804]])
Kami menyelesaikan bagian ketiga. Semoga sukses dan sampai jumpa lagi!