Dari seorang penerjemah: ini adalah terjemahan dari bahan Rakshit Vasudev, yang telah mempelajari DataScience sejak lama dan menggunakan Python di dalamnya. Penulis berbicara tentang perpustakaan Numpy yang kuat, yang memungkinkan Anda untuk mengimplementasikan banyak fitur pembelajaran mesin dan bekerja dengan data besar.
Numpy adalah perpustakaan matematika untuk Python. Ini memungkinkan Anda untuk melakukan segala macam perhitungan secara efisien dan cepat. Ini sangat memperluas fungsionalitas Python berkat solusi khusus yang digunakan di dalamnya. Artikel ini berbicara tentang fitur dasar Numpy, dan ini hanya bagian pertama; yang lain akan diterbitkan sedikit kemudian. Artikel ini diperuntukkan bagi mereka yang baru mulai belajar Numpy, memasuki dunia matematika yang berani dengan Python.
Skillbox merekomendasikan: Pengembang Python dari awal tentu saja.
Kami mengingatkan Anda: untuk semua pembaca "Habr" - diskon 10.000 rubel saat mendaftar untuk kursus Skillbox apa pun menggunakan kode promosi "Habr".
Impor perpustakaan
import numpy as np
Pada titik ini, kami memberi tahu Python bahwa np adalah referensi untuk Numpy, yang akan terus digunakan.
Sekarang buat array python dan array np.
Tidak ada banyak perbedaan dalam penarikan.
print(a) print(A) ==================================================================== [1, 2, 3, 4, 5, 6, 7, 8, 9] [1 2 3 4 5 6 7 8 9]
Nah, mengapa lebih baik menggunakan array numpy daripada yang biasa? Jawabannya adalah karena np akan memungkinkan kita untuk membuat perhitungan lebih cepat dan memodifikasi keseluruhan arsitektur aplikasi.
np.arange ()
np.arange(0,10,2) ==================================================================== array([0, 2, 4, 6, 8])
([mulai], berhenti, [langkah]) memesan angka-angka. Inilah artinya bagi mobil.
Kami membuat daftar-np, mulai dari 0 hingga 10, tetapi tidak termasuk 10, ditambah menambah angka sebanyak 2 setiap kali.
Jadi, kami mendapatkan ini:
array ([0, 2, 4, 6, 8])
Penting untuk diingat bahwa digit terakhir tidak termasuk dalam daftar.
Contoh lain:
np.arange(2,29,5) ==================================================================== array([2, 7, 12, 17, 22, 27])
Array ini juga bisa disebut matriks atau vektor. Karena itu, jangan khawatir ketika saya mengatakan, misalnya: "Bentuk matriksnya adalah 2 * 3." Semua ini berarti bahwa array kita pada akhirnya akan terlihat seperti ini:
array([2, 7, 12], [17, 22, 27])
Sekarang mari kita bicara tentang parameter seperti bentuk untuk array np default. Bentuk di sini adalah atribut. Contoh penggunaannya di bawah ini.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.shape ==================================================================== (9,)
Ini adalah matriks angka, di mana dalam satu baris hanya ada 9 elemen. Pada prinsipnya, matriks 1 * 9 ideal, bukan?
Pada dasarnya, ya, dan untuk ini, membentuk kembali () ikut bermain. Ini adalah metode yang mengubah ukuran matriks asli seperti yang kita inginkan.
Berikut adalah contoh penggunaan membentuk kembali () dalam praktek.
A = [1, 2, 3, 4, 5, 6, 7, 8, 9] A.reshape(1,9) ==================================================================== array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])
Perhatikan bahwa membentuk kembali mengembalikan matriks multidimensi. Ini ditunjukkan oleh dua tanda kurung di awal. [[1, 2, 3, 4, 5, 6, 7, 8, 9]] adalah matriks yang berpotensi multidimensi, tidak seperti [1, 2, 3, 4, 5, 6, 7, 8, 9].
Contoh lain:
B = [1, 2, 3, 4, 5, 6, 7, 8, 9] B.reshape(3,3) ==================================================================== array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
Jika kita mengambil parameter bentuk untuk B, maka itu akan menjadi (3.3):
B.shape ==================================================================== (3,3)
Mari beralih ke np.zeros ()
Apa yang dijabarkan dalam kode ini?
np.zeros((4,3)) ==================================================================== ???????????
Yaitu: di sini matriks format 3 * 4 diisi dengan nol diberikan. Ini kesimpulannya:
np.zeros((4,3)) ==================================================================== array([[0., 0., 0.], [0., 0., 0.], [0., 0., 0.], [0., 0., 0.]])
np.zeros ((n, m)) mengembalikan matriks format n * m yang diisi dengan nol. Semuanya sederhana.
Apa yang dilakukan np.eye ()?
Kembali kepada kami unit matriks dengan karakteristik tertentu.
np.eye(5) ==================================================================== array([[1., 0., 0., 0., 0.], [0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.], [0., 0., 0., 0., 1.]])
Bagaimana cara melipatgandakan dua matriks?
Tidak masalah: np.dot () digunakan untuk ini. Fungsi ini adalah produk skalar jika vektor dan produk matriks (yang paling biasa) diteruskan ke sana.
Contoh: A = (2,3) & B = (3,2). Di sini jumlah kolom dalam A adalah 3. Jumlah baris dalam B adalah 3. Karena karakteristiknya bertepatan, perkalian dimungkinkan.
Kami telah menyiapkan matriks untuk perkalian. Selanjutnya - kita bertindak.
Sekarang mari kita tambahkan elemen individu ke dalam matriks.
np.sum () menambahkan elemen ke matriks.
Namun, kami memiliki dua opsi.
1. Lipat dalam baris
6 - jumlah baris pertama (1, 2, 3).
15 - detik (4, 5, 6).
24 - ketiga (7, 8, 9).
2. Lipat kolom
12 - jumlah kolom pertama (1, 4, 7).
15 - menurut yang kedua (2, 5, 7).
18 - menurut yang ketiga (3, 6, 9).
Di bawah ini adalah video yang dibuat oleh penulis, di mana semua yang dijelaskan di atas dijelaskan lagi, lebih jelas.
Skillbox merekomendasikan: