Machine Translated by Google

NumPy: dasar mutlak untuk pemula

Selamat datang di panduan pemula mutlak untuk NumPy! Jika Anda memiliki komentar atau saran, silakan
jangan ragu untuk menjangkau!

Selamat datang di NumPy!

NumPy (Numerical Python) adalah pustaka Python open source yang digunakan di hampir setiap bidang sains dan teknik. Ini

adalah standar universal untuk bekerja dengan data numerik di Python, dan merupakan inti dari ekosistem ilmiah Python dan PyData.

Pengguna NumPy mencakup semua orang mulai dari pembuat kode pemula hingga peneliti berpengalaman yang melakukan penelitian

dan pengembangan ilmiah dan industri canggih. NumPy API digunakan secara luas di Pandas, SciPy, Matplotlib, scikit-learn, scikit image

dan sebagian besar ilmu data lainnya dan paket Python ilmiah.

Pustaka NumPy berisi array multidimensi dan struktur data matriks (Anda akan menemukan informasi selengkapnya tentang ini di

bagian selanjutnya). Ini menyediakan ndarray, objek array n-dimensi homogen, dengan metode untuk mengoperasikannya secara

efisien. NumPy dapat digunakan untuk melakukan berbagai macam operasi matematika pada array. Itu menambahkan struktur data

yang kuat ke Python yang menjamin perhitungan yang efisien dengan array dan matriks dan itu menyediakan perpustakaan besar fungsi

matematika tingkat tinggi yang beroperasi pada array dan matriks ini.

Pelajari lebih lanjut tentang NumPy di sini!

Menginstal NumPy
Untuk menginstal NumPy, kami sangat menyarankan untuk menggunakan distribusi Python ilmiah. Jika Anda sedang mencari petunjuk

lengkap untuk menginstal NumPy di sistem operasi Anda, lihat Menginstal NumPy.

Jika Anda sudah memiliki Python, Anda dapat menginstal NumPy dengan:

conda install numpy

atau

pip instal numpy

Jika Anda belum memiliki Python, Anda mungkin ingin mempertimbangkan untuk menggunakan Anaconda. Ini cara termudah untuk

memulai. Hal yang baik tentang mendapatkan distribusi ini adalah kenyataan bahwa Anda tidak perlu terlalu khawatir tentang menginstal

NumPy secara terpisah atau salah satu paket utama yang akan Anda gunakan untuk analisis data Anda, seperti panda, Scikit-Learn,

dll.

Bagaimana cara mengimpor NumPy

Untuk mengakses NumPy dan fungsinya, impor dalam kode Python Anda seperti ini:

impor numpy sebagai np

Kami mempersingkat nama yang diimpor menjadi np untuk keterbacaan kode yang lebih baik menggunakan NumPy. Ini adalah

konvensi yang diadopsi secara luas yang harus Anda ikuti sehingga siapa pun yang bekerja dengan kode Anda dapat dengan
mudah memahaminya.

Membaca kode contoh

Machine Translated by Google
Jika Anda belum nyaman membaca tutorial yang berisi banyak kode, Anda mungkin tidak tahu cara menginterpretasikan blok

kode yang terlihat seperti ini:

>>> a = [Link](6) >>> a2

= a[[Link], :] >>> [Link] (1,
6)

Jika Anda tidak terbiasa dengan gaya ini, sangat mudah untuk memahaminya. Jika Anda melihat >>>, Anda sedang melihat

masukan, atau kode yang akan Anda masukkan. Segala sesuatu yang tidak memiliki >>> di depannya adalah keluaran, atau

hasil dari menjalankan kode Anda. Ini adalah gaya yang Anda lihat saat menjalankan python di baris perintah, tetapi jika Anda

menggunakan IPython, Anda mungkin melihat gaya yang berbeda. Perhatikan bahwa itu bukan bagian dari kode dan akan
menyebabkan kesalahan jika diketik atau disisipkan ke dalam shell Python. Ini dapat diketik atau ditempel dengan aman ke

dalam shell IPython; >>> diabaikan .

Apa perbedaan antara daftar Python dan

larik NumPy?
NumPy memberi Anda berbagai cara cepat dan efisien untuk membuat array dan memanipulasi data numerik di dalamnya.

Sementara daftar Python dapat berisi tipe data yang berbeda dalam satu daftar, semua elemen dalam larik NumPy harus
homogen. Operasi matematis yang dimaksudkan untuk dilakukan pada array akan sangat tidak efisien jika array tidak homogen.

Mengapa menggunakan NumPy?

Array NumPy lebih cepat dan lebih ringkas daripada daftar Python. Array mengkonsumsi lebih sedikit memori dan nyaman

digunakan. NumPy menggunakan lebih sedikit memori untuk menyimpan data dan menyediakan mekanisme untuk menentukan

tipe data. Ini memungkinkan kode untuk dioptimalkan lebih jauh.

Apa itu larik?

Array adalah struktur data pusat dari perpustakaan NumPy. Array adalah kisi nilai dan berisi informasi tentang data mentah,

cara menemukan elemen, dan cara menginterpretasikan elemen. Ini memiliki kisi elemen yang dapat diindeks dengan berbagai

cara. Semua elemen bertipe sama, disebut sebagai array dtype.

Array dapat diindeks oleh tuple bilangan bulat nonnegatif, oleh boolean, oleh array lain, atau oleh bilangan bulat. Peringkat

array adalah jumlah dimensi. Bentuk array adalah kumpulan bilangan bulat yang memberikan ukuran array di sepanjang

setiap dimensi.

Salah satu cara kita dapat menginisialisasi array NumPy adalah dari daftar Python, menggunakan daftar bersarang untuk data dua
dimensi atau lebih tinggi.

Sebagai contoh:

>>> a = [Link]([1, 2, 3, 4, 5, 6])

atau:

>>> a = [Link]([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Kita dapat mengakses elemen-elemen dalam array menggunakan tanda kurung siku. Saat Anda mengakses elemen,

ingatlah bahwa pengindeksan di NumPy dimulai dari 0. Artinya, jika Anda ingin mengakses elemen pertama dalam larik, Anda

akan mengakses elemen "0".

>>> cetak(a[0]) [1 2
3 4]
Machine Translated by Google
Informasi lebih lanjut tentang array
Bagian ini mencakup larik 1D, larik 2D, ndarray, vektor, matriks

Anda mungkin kadang-kadang mendengar larik yang disebut sebagai "ndarray", yang merupakan kependekan dari "array
N-dimensional". Array N-dimensi hanyalah sebuah array dengan sejumlah dimensi. Anda mungkin juga mendengar larik
1-D, atau larik satu dimensi, larik 2-D, atau dua dimensi, dan seterusnya. Kelas ndarray NumPy digunakan untuk mewakili
matriks dan vektor. Vektor adalah larik dengan satu dimensi (tidak ada perbedaan antara vektor baris dan kolom),
sedangkan matriks mengacu pada larik dengan dua dimensi.
Untuk array berdimensi 3-D atau lebih tinggi, istilah tensor juga biasa digunakan.

Apa atribut dari array?

Array biasanya merupakan wadah berukuran tetap dari item dengan jenis dan ukuran yang sama. Jumlah
dimensi dan item dalam array ditentukan oleh bentuknya. Bentuk array adalah kumpulan bilangan bulat bukan
negatif yang menentukan ukuran setiap dimensi.

Di NumPy, dimensi disebut sumbu. Artinya jika Anda memiliki larik 2D yang terlihat seperti ini:

[[0., 0., 0.], [1., 1.,

1.]]

Array Anda memiliki 2 sumbu. Sumbu pertama memiliki panjang 2 dan sumbu kedua memiliki panjang 3.

Sama seperti objek container Python lainnya, isi array dapat diakses dan dimodifikasi dengan mengindeks atau
mengiris array. Tidak seperti objek wadah pada umumnya, larik yang berbeda dapat berbagi data yang sama, sehingga
perubahan yang dilakukan pada satu larik mungkin terlihat di larik lainnya.

Atribut array mencerminkan informasi intrinsik ke array itu sendiri. Jika Anda perlu mendapatkan, atau bahkan
menyetel, properti array tanpa membuat array baru, Anda sering dapat mengakses array melalui atributnya.

Baca lebih lanjut tentang atribut array di sini dan pelajari tentang objek array di sini.

Cara membuat array dasar

Bagian ini mencakup [Link](), [Link](), [Link](), [Link](), [Link](), [Link](),
dtype

Untuk membuat array NumPy, Anda dapat menggunakan fungsi [Link]().

Yang perlu Anda lakukan untuk membuat larik sederhana adalah memberikan daftar ke larik tersebut. Jika Anda mau, Anda juga dapat

menentukan jenis data dalam daftar Anda. Anda dapat menemukan informasi lebih lanjut tentang tipe data di sini.

>>> impor numpy sebagai np

>>> a = [Link]([1, 2, 3])

Anda dapat memvisualisasikan array Anda dengan cara ini:

Ketahuilah bahwa visualisasi ini dimaksudkan untuk menyederhanakan ide dan memberi Anda pemahaman dasar tentang
konsep dan mekanika NumPy. Array dan operasi array jauh lebih rumit daripada yang ditangkap di sini!

Selain membuat larik dari urutan elemen, Anda dapat dengan mudah membuat larik berisi 0:
Machine Translated by Google
>>> [Link](2)
array([0., 0.])

Atau array yang diisi dengan 1:

>>> [Link](2)
array([1., 1.])

Atau bahkan array kosong! Fungsi kosong membuat larik yang konten awalnya acak dan bergantung pada status
memori. Alasan untuk menggunakan kosong di atas nol (atau yang serupa) adalah kecepatan - pastikan untuk
mengisi setiap elemen sesudahnya!

>>> # Buat array kosong dengan 2 elemen >>>

[Link](2) array([3.14, 42. ]) # dapat bervariasi

Anda dapat membuat array dengan berbagai elemen:

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

Dan bahkan array yang berisi rentang interval yang berjarak sama. Untuk melakukannya, Anda akan menentukan
angka pertama, angka terakhir, dan ukuran langkah.

>>> [Link](2, 9, 2)
array([2, 4, 6, 8])

Anda juga bisa menggunakan [Link]() untuk membuat larik dengan nilai yang ditempatkan secara linear dalam interval yang
ditentukan:

>>> [Link](0, 10, num=5) array([ 0.

, 2.5, 5. , 7.5, 10. ])

Menentukan tipe data Anda

Sementara tipe data default adalah floating point (np.float64), Anda dapat secara eksplisit menentukan tipe data mana yang

Anda inginkan menggunakan kata kunci dtype .

>>> x = [Link](2, dtype=np.int64)

>>> x
larik([1, 1])

Pelajari lebih lanjut tentang membuat array di sini

Menambahkan, menghapus, dan menyortir elemen

Bagian ini mencakup [Link](), [Link]()

Menyortir elemen itu sederhana dengan [Link](). Anda dapat menentukan sumbu, jenis, dan urutan saat Anda
memanggil fungsi.

Jika Anda mulai dengan array ini:

>>> arr = [Link]([2, 1, 5, 3, 7, 4, 6, 8])

Anda dapat dengan cepat mengurutkan angka dalam urutan menaik dengan:

>>> [Link](arr)
array([1, 2, 3, 4, 5, 6, 7, 8])
Machine Translated by Google
Selain pengurutan, yang mengembalikan salinan array yang diurutkan, Anda dapat menggunakan:

argsort, yang merupakan pengurutan tidak langsung sepanjang sumbu

tertentu, lexsort, yang merupakan penyortiran stabil tidak langsung pada

banyak kunci, pencarian disortir, yang akan menemukan elemen dalam array

yang diurutkan, dan partisi, yang merupakan jenis parsial.

Untuk membaca lebih lanjut tentang mengurutkan array, lihat: sort.

Jika Anda memulai dengan array ini:

>>> a = [Link]([1, 2, 3, 4]) >>> b =

[Link]([5, 6, 7, 8])

Anda dapat menggabungkannya dengan [Link]().

>>> [Link]((a, b))

array([1, 2, 3, 4, 5, 6, 7, 8])

Atau, jika Anda memulai dengan array ini:

>>> x = [Link]([[1, 2], [3, 4]]) >>> y =

[Link]([[5, 6]])

Anda dapat menggabungkannya dengan:

>>> [Link]((x, y), sumbu=0)

array([[1, 2], [3, 4], [5, 6]])

Untuk menghapus elemen dari array, mudah saja menggunakan pengindeksan untuk memilih elemen yang ingin
Anda pertahankan.

Untuk membaca lebih lanjut tentang concatenate, lihat: concatenate.

Bagaimana cara mengetahui bentuk dan ukuran array?

Bagian ini mencakup [Link], [Link], [Link]

[Link] akan memberi tahu Anda jumlah sumbu, atau dimensi, dari array.

[Link] akan memberi tahu Anda jumlah total elemen array. Ini adalah produk dari elemen
bentuk array.

[Link] akan menampilkan tuple bilangan bulat yang menunjukkan jumlah elemen yang disimpan di
sepanjang setiap dimensi array. Jika, misalnya, Anda memiliki larik 2-D dengan 2 baris dan 3 kolom, bentuk
larik Anda adalah (2, 3).

Misalnya, jika Anda membuat larik ini:

>>> contoh_array = [Link]([[[0, 1, 2, 3],

... [4, 5, 6, 7]],
...
... [[0, 1, 2, 3],
... [4, 5, 6, 7]],
...
... [[0 ,1 ,2, 3],
... [4, 5, 6, 7]]])

Untuk menemukan jumlah dimensi array, jalankan:

Machine Translated by Google
>>> array_example.my
3

Untuk menemukan jumlah total elemen dalam array, jalankan:

>>> contoh_array.ukuran
24

Dan untuk menemukan bentuk array Anda, jalankan:

>>> contoh_array.bentuk (3, 2, 4)

Bisakah Anda membentuk kembali sebuah array?

Bagian ini mencakup [Link]()

Ya!

Menggunakan [Link]() akan memberikan bentuk baru ke array tanpa mengubah data. Ingatlah bahwa ketika Anda menggunakan

metode reshape, larik yang ingin Anda hasilkan harus memiliki jumlah elemen yang sama dengan larik aslinya. Jika Anda memulai

dengan larik dengan 12 elemen, Anda harus memastikan bahwa larik baru Anda juga memiliki total 12 elemen.

Jika Anda mulai dengan array ini:

>>> a = [Link](6) >>>

cetak(a) [0 1 2 3 4 5]

Anda dapat menggunakan reshape() untuk membentuk kembali array Anda. Misalnya, Anda dapat membentuk ulang larik ini menjadi larik

dengan tiga baris dan dua kolom:

>>> b = [Link] ulang(3, 2) >>>

cetak(b) [[0 1] [2 3] [4 5]]

Dengan [Link], Anda dapat menentukan beberapa parameter opsional:

>>> [Link](a, newshape=(1, 6), order='C') array([[0, 1, 2, 3, 4,

5]])

a adalah larik yang akan dibentuk ulang.

newshape adalah bentuk baru yang Anda inginkan. Anda dapat menentukan bilangan bulat atau tupel bilangan bulat. Jika Anda

menentukan bilangan bulat, hasilnya akan berupa larik dengan panjang tersebut. Bentuknya harus sesuai dengan bentuk aslinya.

ÿ Cari dokumen ...

urutan: C berarti membaca/menulis elemen menggunakan urutan indeks mirip C, F berarti membaca/menulis elemen

menggunakan urutan indeks mirip Fortran, A berarti membaca/menulis elemen dalam urutan indeks mirip Fortran jika a adalah
Apa itu NumPy?
Fortran bersebelahan dalam memori, urutan seperti C sebaliknya. (Ini adalah parameter opsional dan tidak perlu ditentukan.)
Instalasi ÿ

Mulai cepat NumPy

Jika Anda ingin mempelajari lebih lanjut tentang urutan C dan Fortran, Anda dapat membaca lebih lanjut tentang
NumPy: dasar mutlak untuk
organisasi internal array NumPy di sini. Pada dasarnya, perintah C dan Fortran berkaitan dengan bagaimana indeks
pemula
berhubungan dengan urutan array disimpan dalam memori. Di Fortran, saat menelusuri elemen array dua dimensi saat disimpan di
dasar-dasar NumPy
memori, indeks pertama adalah indeks yang paling cepat berubah.
Aneka ragam
Saat indeks pertama berpindah ke baris berikutnya saat indeks berubah, matriks disimpan satu kolom pada satu waktu. Ini

f
Machine Translated by Google
NumPy untuk pengguna MATLAB
itulah sebabnya Fortran dianggap sebagai bahasa utama Kolom. Di C sebaliknya, indeks terakhir berubah paling
Membangun dari sumber cepat. Matriks disimpan oleh baris, menjadikannya bahasa utama Baris. Apa yang Anda lakukan untuk C atau Fortran
Menggunakan NumPy C-API bergantung pada apakah lebih penting mempertahankan konvensi pengindeksan atau tidak menyusun ulang data.

Tutorial NumPy ÿ

Cara NumPy Pelajari lebih lanjut tentang manipulasi bentuk di sini.

Untuk pembuat paket hilir

Panduan pengguna dan manual referensi

F2PY Cara mengonversi larik 1D menjadi larik 2D (cara

Glosarium
menambahkan sumbu baru ke larik)
Dokumentasi Di Bawah Kap

untuk pengembang Bagian ini mencakup [Link], np.expand_dims

Melaporkan bug

Catatan rilis Anda dapat menggunakan [Link] dan np.expand_dims untuk menambah dimensi array yang ada.

Lisensi NumPy
Menggunakan [Link] akan menambah dimensi array Anda satu dimensi saat digunakan sekali. Artinya array 1D
akan menjadi array 2D, array 2D akan menjadi array 3D, dan seterusnya.

Misalnya, jika Anda memulai dengan larik ini:

>>> a = [Link]([1, 2, 3, 4, 5, 6]) >>> [Link]

(6,)

Anda dapat menggunakan [Link] untuk menambahkan sumbu baru:

>>> a2 = a[[Link], :] >>>

[Link] (1, 6)

Anda dapat secara eksplisit mengonversi larik 1D dengan vektor baris atau vektor kolom menggunakan [Link].
Misalnya, Anda dapat mengonversi larik 1D menjadi vektor baris dengan menyisipkan sumbu di sepanjang dimensi pertama:

>>> row_vector = a[[Link], :] >>>

row_vector.shape (1, 6)

Atau, untuk vektor kolom, Anda dapat menyisipkan sumbu di sepanjang dimensi kedua:

>>> col_vector = a[:, [Link]] >>>

col_vector.shape (6, 1)

Anda juga dapat memperluas array dengan menyisipkan sumbu baru pada posisi tertentu dengan np.expand_dims.

Misalnya, jika Anda memulai dengan larik ini:

>>> a = [Link]([1, 2, 3, 4, 5, 6]) >>> [Link]

(6,)

Anda dapat menggunakan np.expand_dims untuk menambahkan sumbu pada posisi indeks 1 dengan:

>>> b = np.expand_dims(a, sumbu=1) >>>

[Link] (6, 1)

Anda dapat menambahkan sumbu pada posisi indeks 0 dengan:

Machine Translated by Google
>>> c = np.expand_dims(a, sumbu=0) >>>
[Link] (1, 6)

Temukan informasi lebih lanjut tentang sumbu baru di sini dan expand_dims di expand_dims.

Mengindeks dan mengiris

Anda dapat mengindeks dan mengiris array NumPy dengan cara yang sama seperti Anda dapat mengiris daftar Python.

>>> data = [Link]([1, 2, 3])

>>> data[1]
2

>>> data[0:2]
larik([1, 2]) >>>
data[1:]
larik([2, 3]) >>>
data[-2:] larik([2,
3])

Anda dapat memvisualisasikannya dengan cara ini:

Anda mungkin ingin mengambil bagian dari larik Anda atau elemen larik tertentu untuk digunakan dalam analisis lebih lanjut atau

operasi tambahan. Untuk melakukan itu, Anda harus membuat subset, mengiris, dan/atau mengindeks array Anda.

Jika Anda ingin memilih nilai dari array Anda yang memenuhi kondisi tertentu, langsung saja dengan NumPy.

Misalnya, jika Anda memulai dengan larik ini:

>>> a = [Link]([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Anda dapat dengan mudah mencetak semua nilai dalam larik yang kurang dari 5.

>>> cetak(a[a < 5]) [1 2 3

4]

Anda juga dapat memilih, misalnya, angka yang sama dengan atau lebih besar dari 5, dan menggunakan kondisi tersebut
untuk mengindeks array.

>>> lima_up = (a >= 5) >>>

print(a[lima_up]) [ 5 6 7 8 9 10
11 12]

Anda dapat memilih elemen yang habis dibagi 2:

>>> dapat dibagi_2 = a[a%2==0] >>>

cetak(divisible_by_2) [ 2 4 6 8 10 12]

Atau Anda dapat memilih elemen yang memenuhi dua syarat menggunakan & dan | operator:
Machine Translated by Google
>>> c = a[(a > 2) & (a < 11)] >>>
cetak(c) [ 3 4 5 6 7 8 9 10]

Anda juga dapat menggunakan operator logis & dan | untuk mengembalikan nilai boolean yang menentukan apakah
nilai dalam array memenuhi kondisi tertentu atau tidak. Ini bisa berguna dengan array yang berisi nama atau nilai
kategorikal lainnya.

>>> five_up = (a > 5) | (a == 5) >>>

cetak(lima_up)
[[salah salah salah salah salah]
[Benar Benar Benar Benar Benar]
[Benar Benar Benar Benar Benar]]

Anda juga bisa menggunakan [Link]() untuk memilih elemen atau indeks dari array.

Dimulai dengan larik ini:

>>> a = [Link]([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Anda dapat menggunakan [Link]() untuk mencetak indeks elemen yang, misalnya, kurang dari 5:

>>> b = [Link](a < 5) >>>

print(b) (array([0, 0, 0, 0]),
array([0, 1, 2, 3]))

Dalam contoh ini, sejumlah array dikembalikan: satu untuk setiap dimensi. Larik pertama mewakili indeks baris tempat
nilai-nilai ini ditemukan, dan larik kedua mewakili indeks kolom tempat
nilai-nilai ditemukan.

Jika Anda ingin membuat daftar koordinat di mana elemen-elemennya ada, Anda dapat meng-zip array, mengulangi
daftar koordinat, dan mencetaknya. Sebagai contoh:

>>> list_of_coordinates= daftar(zip(b[0], b[1]))

>>> untuk koordinat di list_of_coordinates:

... cetak(koordinir)
(0, 0)
(0, 1)
(0, 2)
(0, 3)

Anda juga dapat menggunakan [Link]() untuk mencetak elemen dalam array yang kurang dari 5 dengan:

>>> cetak(a[b]) [1
2 3 4]

Jika elemen yang Anda cari tidak ada dalam larik, maka larik indeks yang dikembalikan akan kosong. Sebagai
contoh:

>>> not_there = [Link](a == 42) >>>

print(not_there) (array([], dtype=int64), array([],
dtype=int64))

Pelajari lebih lanjut tentang pengindeksan dan pemotongan di sini dan di sini.

Baca selengkapnya tentang menggunakan fungsi bukan nol di: bukan nol.

Cara membuat array dari data yang ada

Machine Translated by Google
Bagian ini mencakup pemotongan dan pengindeksan, [Link](), [Link](), [Link](), .view(), copy()

Anda dapat dengan mudah membuat larik baru dari bagian larik yang sudah ada.

Katakanlah Anda memiliki array ini:

>>> a = [Link]([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Anda dapat membuat larik baru dari bagian larik Anda kapan saja dengan menentukan di mana Anda ingin memotong
susunan Anda.

>>> arr1 = a[3:8]

>>> arr1
larik([4, 5, 6, 7, 8])

Di sini, Anda mengambil bagian dari array Anda dari posisi indeks 3 hingga posisi indeks 8.

Anda juga dapat menumpuk dua larik yang ada, baik secara vertikal maupun horizontal. Katakanlah Anda memiliki dua larik,
a1 dan a2:

>>> a1 = [Link]([[1, 1], [2, 2]])

...

>>> a2 = [Link]([[3, 3], [4, 4]])

...

Anda dapat menumpuknya secara vertikal dengan vstack:

>>> [Link]((a1, a2))

array([[1, 1], [2, 2], [3, 3], [4,
4]])

Atau susun secara horizontal dengan hstack:

>>> [Link]((a1, a2))

array([[1, 1, 3, 3],
[2, 2, 4, 4]])

Anda dapat membagi array menjadi beberapa array yang lebih kecil menggunakan hsplit. Anda dapat menentukan
jumlah array yang berbentuk sama untuk dikembalikan atau kolom setelah pembagian harus terjadi.

Katakanlah Anda memiliki array ini:

>>> x = [Link](1, 25).membentuk kembali(2, 12)

>>> x
larik([[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
[13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]])

Jika Anda ingin membagi larik ini menjadi tiga larik yang berbentuk sama, Anda akan menjalankan:

>>> [Link](x, 3)
[larik([[ 1, 2, 3, 4], [13, 14, 15,
16]]), larik([[ 5, 6, 7, 8], [17, 18, 19, 20]]), larik([[ 9, 10,
11, 12], [21, 22, 23, 24]])]

Jika Anda ingin membagi array Anda setelah kolom ketiga dan keempat, Anda akan menjalankan:
Machine Translated by Google
>>> [Link](x, (3, 4))
[array([[ 1, 2, 3],
[13, 14, 15]]), larik([[ 4], [16]]),
larik([[ 5, 6, 7, 8, 9, 10, 11, 12], [17, 18, 19 , 20, 21, 22, 23,
24]])]

Pelajari lebih lanjut tentang menumpuk dan memisahkan array di sini.

Anda bisa menggunakan metode view untuk membuat objek array baru yang melihat data yang sama dengan array
asli (salinan dangkal).

Tampilan adalah konsep NumPy yang penting! Fungsi NumPy, serta operasi seperti pengindeksan dan
pemotongan, akan mengembalikan tampilan jika memungkinkan. Ini menghemat memori dan lebih cepat (tidak ada
salinan data yang harus dibuat). Namun penting untuk menyadari hal ini - memodifikasi data dalam tampilan juga
mengubah larik asli!

Katakanlah Anda membuat array ini:

>>> a = [Link]([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Sekarang kita membuat array b1 dengan memotong a dan memodifikasi elemen pertama dari b1. Ini juga
akan memodifikasi elemen yang sesuai !

>>> b1 = a[0, :]
>>> b1
array([1, 2, 3, 4]) >>>
b1[0] = 99
>>> b1
larik([99, 2, 3, 4])
>>> a
array([[99, 2, 3, 4], [ 5, 6, 7, 8],
[ 9, 10, 11, 12]])

Menggunakan metode salin akan membuat salinan lengkap dari larik dan datanya (salinan dalam). Untuk menggunakan ini di

array Anda, Anda bisa menjalankan:

>>> b2 = [Link]()

Pelajari lebih lanjut tentang salinan dan tampilan di sini.

Operasi array dasar

Bagian ini mencakup penjumlahan, pengurangan, perkalian, pembagian, dan banyak lagi

Setelah Anda membuat array, Anda dapat mulai mengerjakannya. Katakanlah, misalnya, Anda telah membuat
dua larik, satu disebut "data" dan satu lagi disebut "satuan"

Anda dapat menambahkan array bersama dengan tanda tambah.

>>> data = [Link]([1, 2]) >>>

satuan = [Link] (2, dtype=int)
>>> data + satuan
larik([2, 3])
Machine Translated by Google

Anda tentu saja dapat melakukan lebih dari sekadar penambahan!

>>> data - satu

larik([0, 1])
>>> data * data
larik([1, 4])
>>> data / data
larik([1., 1.])

Operasi dasar sederhana dengan NumPy. Jika Anda ingin menemukan jumlah elemen dalam array, Anda akan
menggunakan sum(). Ini berfungsi untuk larik 1D, larik 2D, dan larik dalam dimensi yang lebih tinggi.

>>> a = [Link]([1, 2, 3, 4])

>>> [Link]()
10

Untuk menambahkan baris atau kolom dalam larik 2D, Anda harus menentukan sumbu.

Jika Anda mulai dengan array ini:

>>> b = [Link]([[1, 1], [2, 2]])

Anda dapat menjumlahkan sumbu baris dengan:

>>> [Link](axis=0)
array([3, 3])

Anda dapat menjumlahkan sumbu kolom dengan:

>>> [Link](axis=1)
array([2, 4])

Pelajari lebih lanjut tentang operasi dasar di sini.

Penyiaran
Ada kalanya Anda mungkin ingin melakukan operasi antara larik dan bilangan tunggal (juga disebut operasi antara
vektor dan skalar) atau antara larik dengan dua ukuran berbeda. Misalnya, larik Anda (kami akan menyebutnya
"data") mungkin berisi informasi tentang jarak dalam mil, tetapi Anda ingin mengonversi informasi tersebut menjadi
kilometer. Anda dapat melakukan operasi ini dengan:

>>> data = [Link]([1.0, 2.0])

>>> data * 1.6
larik([1.6, 3.2])
Machine Translated by Google

NumPy memahami bahwa perkalian harus terjadi pada setiap sel. Konsep itu disebut penyiaran. Penyiaran
adalah mekanisme yang memungkinkan NumPy untuk melakukan operasi pada array dengan berbagai bentuk.
Dimensi array Anda harus kompatibel, misalnya ketika dimensi kedua array sama atau ketika salah satunya adalah
1. Jika dimensi tidak kompatibel, Anda akan mendapatkan ValueError.

Pelajari lebih lanjut tentang penyiaran di sini.

Operasi array yang lebih berguna

Bagian ini mencakup maksimum, minimum, jumlah, rata-rata, produk, standar deviasi, dan banyak lagi

NumPy juga melakukan fungsi agregasi. Selain min, maks, dan jumlah, Anda dapat dengan mudah menjalankan rata
-rata untuk mendapatkan rata-rata, prod untuk mendapatkan hasil perkalian elemen, std untuk mendapatkan standar
deviasi, dan banyak lagi.

>>> [Link]()
2.0
>>> [Link]()
1.0
>>> [Link]()
3.0

Mari kita mulai dengan larik ini, yang disebut "a"

>>> a = [Link]([[0,45053314, 0,17296777, 0,34376245, 0,5510652],

... [0,54627315, 0,05093587, 0,40067661, 0,55645993], [0,12697628,
... 0,82485143, 0,26590556, 0,56917101]])

Sangat umum untuk menggabungkan sepanjang baris atau kolom. Secara default, setiap fungsi agregasi NumPy
akan mengembalikan agregat dari seluruh array. Untuk menemukan jumlah atau minimum elemen dalam array Anda,
jalankan:

>>> [Link]()
4.8595784

Atau:

>>> [Link]()
0,05093587

Anda dapat menentukan pada sumbu mana Anda ingin fungsi agregasi dihitung. Misalnya, Anda dapat menemukan
nilai minimum dalam setiap kolom dengan menentukan sumbu=0.

>>> [Link](sumbu=0)
larik([0,12697628, 0,05093587, 0,26590556, 0,5510652 ])
Machine Translated by Google
Keempat nilai yang tercantum di atas sesuai dengan jumlah kolom dalam larik Anda. Dengan larik empat kolom,
Anda akan mendapatkan empat nilai sebagai hasilnya.

Baca lebih lanjut tentang metode array di sini.

Membuat matriks
Anda dapat meneruskan daftar daftar Python untuk membuat larik 2-D (atau "matriks") untuk mewakilinya di NumPy.

>>> data = [Link]([[1, 2], [3, 4], [5, 6]])

>>> data
larik([[1, 2], [3,
4], [5,
6]])

Operasi pengindeksan dan pemotongan berguna saat Anda memanipulasi matriks:

>>> data[0, 1]
2
>>> data[1:3]
larik([[3, 4], [5,
6]])
>>> data[0:2, 0]
larik([1, 3])

Anda dapat mengagregasi matriks dengan cara yang sama seperti mengagregasi vektor:

>>> [Link]()
6
>>> [Link]()
1
>>> [Link]()
21

Anda dapat mengagregasi semua nilai dalam matriks dan Anda dapat menggabungkannya di seluruh kolom atau baris menggunakan

parameter sumbu . Untuk mengilustrasikan poin ini, mari kita lihat kumpulan data yang sedikit dimodifikasi:
Machine Translated by Google
>>> data = [Link]([[1, 2], [5, 3], [4, 6]])
>>> data
array([[1, 2], [5,
3], [4,
6]]) >>>
[Link](axis=0)
array([5, 6]) >>>
[Link](axis= 1)
larik([2, 5, 6])

Setelah Anda membuat matriks, Anda dapat menjumlahkan dan mengalikannya menggunakan operator aritmatika jika
Anda memiliki dua matriks dengan ukuran yang sama.

>>> data = [Link]([[1, 2], [3, 4]]) >>> one =

[Link] ([[1, 1], [1, 1]])
>>> data + satuan
larik([[2, 3],
[4, 5]])

Anda dapat melakukan operasi aritmatika ini pada matriks dengan ukuran berbeda, tetapi hanya jika satu matriks hanya

memiliki satu kolom atau satu baris. Dalam hal ini, NumPy akan menggunakan aturan siarannya untuk operasi tersebut.

>>> data = [Link]([[1, 2], [3, 4], [5, 6]]) >>> one_row =
[Link]([[1, 1]]) >>> data + one_row

larik([[2, 3], [4,

5], [6,
7]])

Ketahuilah bahwa saat NumPy mencetak larik N-dimensi, sumbu terakhir dilingkarkan pada yang tercepat sedangkan sumbu
pertama adalah yang paling lambat. Contohnya:
Machine Translated by Google
>>> [Link]((4, 3, 2))
array([[[1., 1.], [1., 1.], [1.,
1.]],

[[1., 1.], [1.,

1.], [1.,
1.]],

[[1., 1.], [1.,

1.], [1.,
1.]],

[[1., 1.], [1.,

1.], [1.,
1.]]])

Sering kali kita ingin NumPy menginisialisasi nilai-nilai array. NumPy menawarkan fungsi seperti one ()
dan zeros(), dan kelas [Link] untuk pembuatan angka acak untuk itu. Yang perlu Anda
lakukan adalah meneruskan jumlah elemen yang ingin Anda hasilkan:

>>> [Link](3)
array([1., 1., 1.])
>>> [Link](3)
array([0., 0., 0.]) >>>
rng = [Link].default_rng() # cara termudah untuk menghasilkan angka acak >>>
[Link](3 ) larik([0,63696169, 0,26978671, 0,04097352])

Anda juga dapat menggunakan one(), zeros(), dan random() untuk membuat larik 2D jika Anda
memberi tupel yang menjelaskan dimensi matriks:

>>> [Link]((3, 2))

array([[1., 1.], [1., 1.],
[1., 1.]]) >>>
[Link]((3 ,
2)) larik([[0., 0.], [0., 0.],
[0., 0.]]) >>>
[Link]((3,
2))
larik([[0.01652764 ,
0,81327024], [0,91275558, 0,60663578],
[0,72949656, 0,54362499]]) #
dapat bervariasi
Machine Translated by Google

Baca selengkapnya tentang membuat larik, diisi dengan 0, 1, nilai lain atau tidak diinisialisasi, di pembuatan larik
rutinitas.

Menghasilkan angka acak

Penggunaan pembangkitan angka acak adalah bagian penting dari konfigurasi dan evaluasi banyak algoritma
pembelajaran numerik dan mesin. Apakah Anda perlu menginisialisasi bobot secara acak dalam jaringan syaraf tiruan,
membagi data menjadi kumpulan acak, atau mengacak kumpulan data Anda secara acak, mampu menghasilkan angka acak
(sebenarnya, angka acak semu berulang) sangatlah penting.

Dengan [Link], Anda dapat menghasilkan bilangan bulat acak dari rendah (ingat bahwa ini termasuk
dengan NumPy) hingga tinggi (eksklusif). Anda dapat mengatur endpoint=True untuk membuat angka yang tinggi
menjadi inklusif.

Anda dapat menghasilkan larik bilangan bulat acak 2 x 4 antara 0 dan 4 dengan:

>>> [Link] bulat(5, ukuran=(2, 4))

array([[2, 1, 1, 0],
[0, 0, 0, 4]]) # dapat bervariasi

Baca lebih lanjut tentang pembuatan angka acak di sini.

Cara mendapatkan item unik dan menghitung

Bagian ini mencakup [Link]()

Anda dapat menemukan elemen unik dalam array dengan mudah menggunakan [Link].

Misalnya, jika Anda memulai dengan larik ini:

>>> a = [Link]([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])

Anda dapat menggunakan [Link] untuk mencetak nilai unik dalam array Anda:

>>> unique_values = [Link](a) >>>

print(unique_values) [11 12 13 14 15 16 17
18 19 20]

Untuk mendapatkan indeks nilai unik dalam larik NumPy (array posisi indeks pertama dari nilai unik dalam larik), cukup
berikan argumen return_index di [Link] () serta larik Anda.

>>> unique_values, indexes_list = [Link](a, return_index=True) >>> print(index_list) [ 0 2

3 4 5 6 7 12 13 14]

Anda dapat meneruskan argumen return_counts di [Link] () bersama dengan larik Anda untuk mendapatkan jumlah
frekuensi nilai unik dalam larik NumPy.

>>> nilai_unik, penghitungan_kejadian = [Link] (a, penghitungan_pengembalian=True) >>>

cetak(jumlah_kejadian) [3 2 2 2 1 1 1 1 1 1 1]
Machine Translated by Google
Ini juga berfungsi dengan array 2D! Jika Anda mulai dengan array ini:

>>> a_2d = [Link]([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [1, 2, 3, 4]] )

Anda dapat menemukan nilai unik dengan:

>>> nilai_unik = [Link](a_2d) >>>

cetak(nilai_unik) [ 1 2 3 4 5 6 7 8 9 10 11 12]

Jika argumen sumbu tidak diteruskan, larik 2D Anda akan diratakan.

Jika Anda ingin mendapatkan baris atau kolom unik, pastikan untuk meneruskan argumen sumbu . Untuk
menemukan baris unik, tentukan sumbu=0 dan untuk kolom, tentukan sumbu=1.

>>> unique_rows = [Link](a_2d, axis=0) >>>

print(unique_rows) [[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]]

Untuk mendapatkan baris unik, posisi indeks, dan jumlah kemunculan, Anda dapat menggunakan:

>>> baris_unik, indeks, jumlah_kejadian = [Link](

... a_2d, axis=0, return_counts=True, return_index=True) >>>
print(unik_baris) [[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11 12]] >>> print(indeks) [0 1 2] >>>
cetak(jumlah_kejadian) [2 1 1]

Untuk mempelajari lebih lanjut tentang menemukan elemen unik dalam larik, lihat unik.

Mentranspos dan membentuk ulang matriks

Bagian ini mencakup [Link](), [Link](), arr.T

Adalah umum untuk mengubah urutan matriks Anda. Array NumPy memiliki properti T yang memungkinkan Anda untuk
mengubah susunan matriks.

Anda mungkin juga perlu mengganti dimensi matriks. Ini bisa terjadi ketika, misalnya, Anda memiliki model yang
mengharapkan bentuk masukan tertentu yang berbeda dari kumpulan data Anda. Di sinilah metode reshape dapat
berguna. Anda hanya perlu melewati dimensi baru yang Anda inginkan untuk
matriks.
Machine Translated by Google
>>> [Link] kembali(2,
3) array([[1, 2, 3],
[4, 5, 6]])
>>> [Link] kembali(3,
2) array([[1, 2], [3, 4], [5, 6]])

Anda juga bisa menggunakan .transpose() untuk membalikkan atau mengubah sumbu array sesuai dengan nilai yang Anda
tentukan.

Jika Anda mulai dengan array ini:

>>> arr = [Link](6).membentuk kembali((2, 3))

>>> arr

larik([[0, 1, 2], [3, 4, 5]])

Anda dapat mengubah urutan array Anda dengan [Link]().

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

Anda juga dapat menggunakan arr.T:

>>> arr.T

larik([[0, 3], [1, 4],

[2, 5]])

Untuk mempelajari lebih lanjut tentang mentransposisi dan membentuk ulang array, lihat transpose dan membentuk kembali.

Cara membalikkan array

Bagian ini mencakup [Link]()

Fungsi [Link]() NumPy memungkinkan Anda membalik, atau membalikkan, isi array di sepanjang sumbu.
Saat menggunakan [Link](), tentukan larik yang ingin Anda balikkan dan sumbunya. Jika Anda tidak menentukan sumbunya,
NumPy akan membalik konten di sepanjang semua sumbu larik input Anda.

Membalik array 1D

Jika Anda mulai dengan array 1D seperti ini:

>>> arr = [Link]([1, 2, 3, 4, 5, 6, 7, 8])

Anda dapat membalikkannya dengan:

Machine Translated by Google
>>> reversed_arr = [Link](arr)

Jika Anda ingin mencetak array terbalik, Anda dapat menjalankan:

>>> print('Array Terbalik: ', reversed_arr)

Array Terbalik: [8 7 6 5 4 3 2 1]

Membalik array 2D

Array 2D bekerja dengan cara yang hampir sama.

Jika Anda mulai dengan array ini:

>>> arr_2d = [Link]([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Anda dapat membalik konten di semua baris dan semua kolom dengan:

>>> reverse_arr = [Link] (arr_2d) >>>

print(reversed_arr) [[12 11 10 9] [ 8 7 6 5] [ 4 3 2
1]]

Anda dapat dengan mudah membalikkan hanya baris dengan:

>>> reversed_arr_rows = [Link](arr_2d, axis=0) >>>

print(arr_rows_terbalik) [[ 9 10 11 12] [ 5 6 7 8] [ 1 2 3 4]]

Atau balikkan hanya kolom dengan:

>>> kolom_arr_terbalik = [Link](arr_2d, sumbu=1) >>>

cetak(arr_kolom_terbalik) [[ 4 3 2 1] [ 8 7 6 5] [12 11 10 9]]

Anda juga dapat membalikkan isi hanya satu kolom atau baris. Misalnya, Anda dapat membalik isi baris pada posisi

indeks 1 (baris kedua):

>>> arr_2d[1] = [Link](arr_2d[1]) >>> print(arr_2d)

[[ 1 2 3 4] [ 8 7 6 5] [ 9 10 11 12]]

Anda juga dapat membalikkan kolom pada posisi indeks 1 (kolom kedua):

>>> arr_2d[:,1] = [Link](arr_2d[:,1]) >>> print(arr_2d)

[[ 1 10 3 4] [ 8 7 6 5] [ 9 2 11 12]]

Baca lebih lanjut tentang membalikkan array di flip.

Membentuk kembali dan meratakan array multidimensi

Machine Translated by Google
Bagian ini mencakup .flatten(), ravel()

Ada dua cara populer untuk meratakan array: .flatten() dan .ravel(). Perbedaan utama antara keduanya adalah bahwa
array baru yang dibuat menggunakan ravel() sebenarnya merupakan referensi ke array induk (yaitu, "tampilan"). Ini berarti
bahwa setiap perubahan pada larik baru akan memengaruhi larik induk juga. Karena ravel tidak membuat salinan, ini hemat
memori.

Jika Anda mulai dengan array ini:

>>> x = [Link]([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

Anda dapat menggunakan ratakan untuk meratakan larik Anda menjadi larik 1D.

>>> [Link]()
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

Saat Anda menggunakan perataan, perubahan pada larik baru Anda tidak akan mengubah larik induk.

Sebagai contoh:

>>> a1 = [Link]() >>>

a1[0] = 99 >>> print(x) #
Array asli [[ 1 2 3 4] [ 5 6 7 8] [ 9 10 11
12]]

>>> cetak(a1) # Larik baru [99 2 3

4 5 6 7 8 9 10 11 12]

Namun saat Anda menggunakan ravel, perubahan yang Anda lakukan pada larik baru akan memengaruhi larik induk.

Sebagai contoh:

>>> a2 = [Link]() >>>

a2[0] = 98 >>> print(x) #
Asli array [[98 2 3 4] [ 5 6 7 8] [ 9 10 11
12]]

>>> cetak(a2) # Larik baru [98 2 3

4 5 6 7 8 9 10 11 12]

Baca lebih lanjut tentang perataan di [Link] dan bersenang - senang.

Cara mengakses docstring untuk informasi lebih lanjut

Bagian ini mencakup bantuan(), ?, ??

Ketika datang ke ekosistem ilmu data, Python dan NumPy dibangun dengan mempertimbangkan pengguna. Salah satu
contoh terbaik dari hal ini adalah akses bawaan ke dokumentasi. Setiap objek berisi referensi ke sebuah string, yang dikenal
sebagai docstring. Dalam kebanyakan kasus, docstring ini berisi ringkasan singkat dan singkat dari objek dan cara
menggunakannya. Python memiliki fungsi help() bawaan yang dapat membantu Anda mengakses informasi ini. Ini berarti

bahwa hampir kapan pun Anda membutuhkan lebih banyak informasi, Anda dapat menggunakan help() untuk menemukan
informasi yang Anda perlukan dengan cepat.

Sebagai contoh:
Machine Translated by Google
>>> bantuan (maks)
Bantuan tentang fungsi bawaan maks dalam modul bawaan:

max(...)
max(iterable, *[, default=obj, key=func]) -> nilai max(arg1, arg2,
*args, *[, key=func]) -> nilai

Dengan satu argumen iterable, kembalikan item terbesarnya. Argumen khusus

kata kunci default menentukan objek yang akan dikembalikan jika iterable yang
disediakan kosong.
Dengan dua atau lebih argumen, kembalikan argumen terbesar.

Karena akses ke informasi tambahan sangat berguna, IPython menggunakan ? karakter sebagai singkatan untuk mengakses
dokumentasi ini bersama dengan informasi relevan lainnya. IPython adalah shell perintah untuk komputasi interaktif dalam
berbagai bahasa. Anda dapat menemukan informasi lebih lanjut tentang IPython di sini.

Sebagai contoh:

Dalam [0]: maks?

max(iterable, *[, default=obj, key=func]) -> nilai max(arg1, arg2,
*args, *[, key=func]) -> nilai

Dengan satu argumen iterable, kembalikan item terbesarnya. Argumen khusus

kata kunci default menentukan objek untuk dikembalikan jika
iterable yang disediakan kosong.
Dengan dua atau lebih argumen, kembalikan argumen terbesar.
Jenis: builtin_function_or_method

Anda bahkan dapat menggunakan notasi ini untuk metode objek dan objek itu sendiri.

Katakanlah Anda membuat array ini:

>>> a = [Link]([1, 2, 3, 4, 5, 6])

Kemudian Anda dapat memperoleh banyak informasi berguna (rincian pertama tentang dirinya sendiri, diikuti oleh docstring
ndarray yang merupakan turunannya ):
Machine Translated by Google
Dalam [1]: a?
Jenis: ndarray
Bentuk string: [1 2 3 4 5 6]
Panjangnya: 6
Mengajukan: ~/ anaconda3/ lib/ python3.9/ site-packages/ numpy/ __init__.py <tidak ada
Dokumen: docstring>
Dokumen kelas:
ndarray(bentuk, dtype=float, buffer=Tidak ada, offset=0,
langkah=Tidak ada, urutan=Tidak ada)

Objek array mewakili array multidimensi, homogen dari item berukuran tetap. Objek tipe
data terkait menjelaskan format setiap elemen dalam array (urutan byte-nya, berapa banyak
byte yang ditempati dalam memori, apakah itu bilangan bulat, angka floating point, atau yang
lainnya, dll.)

Array harus dibangun menggunakan `array`, `zero` atau `empty` (lihat bagian Lihat Juga di
bawah). Parameter yang diberikan di sini mengacu pada
metode tingkat rendah (`ndarray(...)`) untuk membuat instance array.

Untuk informasi lebih lanjut, lihat modul `numpy` dan periksa metode dan atribut array.

Parameter
----------

(untuk metode __new__; lihat Catatan di bawah)

bentuk : Tuple dari int

Bentuk array yang dibuat.
...

Ini juga berfungsi untuk fungsi dan objek lain yang Anda buat. Ingatlah untuk menyertakan docstring dengan fungsi Anda
menggunakan string literal (""" """ atau ''' ''' di sekitar dokumentasi Anda).

Misalnya, jika Anda membuat fungsi ini:

>>> def ganda(a):

... '''Kembalikan a * 2'''
... mengembalikan a *2

Anda dapat memperoleh informasi tentang fungsi:

Di [2]: ganda?
Tanda tangan: ganda (a)
Docstring: Mengembalikan a* 2
Mengajukan: ~/ Desktop/ <ipython-input-23-b5adf20be596>
Jenis: fungsi

Anda dapat mencapai tingkat informasi lain dengan membaca kode sumber objek yang Anda minati. Menggunakan tanda tanya

ganda (??) memungkinkan Anda mengakses kode sumber.

Sebagai contoh:

Di [3]: ganda??
Tanda tangan: ganda (a)
Sumber:

def ganda (a):

'''Kembalikan a * 2'''
kembali a *2
Mengajukan: ~/ Desktop/ <ipython-input-23-b5adf20be596> fungsi
Jenis:
Machine Translated by Google
Jika objek yang dimaksud dikompilasi dalam bahasa selain Python, gunakan ?? akan mengembalikan informasi
yang sama dengan ?. Anda akan menemukan ini dengan banyak objek dan tipe bawaan, misalnya:

Di [4]: len?
Tanda tangan: len(obj, /)
Docstring: Mengembalikan jumlah item dalam wadah.
Jenis: builtin_function_or_method

dan :

Di [5]: len??
Tanda tangan: len(obj, /)
Docstring: Mengembalikan jumlah item dalam wadah.
Jenis: builtin_function_or_method

memiliki output yang sama karena dikompilasi dalam bahasa pemrograman selain Python.

Bekerja dengan rumus matematika

Kemudahan penerapan rumus matematika yang bekerja pada array menjadi salah satu hal yang membuat NumPy
begitu banyak digunakan dalam komunitas ilmiah Python.

Misalnya, ini adalah rumus kesalahan kuadrat rata-rata (rumus utama yang digunakan dalam model pembelajaran
mesin terawasi yang berhubungan dengan regresi):

Menerapkan rumus ini sederhana dan mudah di NumPy:

Apa yang membuat ini bekerja dengan sangat baik adalah prediksi dan label dapat berisi satu atau seribu nilai.
Mereka hanya perlu berukuran sama.

Anda dapat memvisualisasikannya dengan cara ini:

Dalam contoh ini, vektor prediksi dan label berisi tiga nilai, artinya n memiliki nilai tiga. Setelah kita melakukan
pengurangan, nilai dalam vektor dikuadratkan. Kemudian NumPy menjumlahkan nilainya, dan hasil Anda adalah nilai
kesalahan untuk prediksi tersebut dan skor untuk kualitas model.
Machine Translated by Google

Bagaimana cara menyimpan dan memuat objek NumPy

Bagian ini mencakup [Link], [Link], [Link], [Link], [Link]

Anda akan, pada titik tertentu, ingin menyimpan array Anda ke disk dan memuatnya kembali tanpa harus menjalankan kembali

kodenya. Untungnya, ada beberapa cara untuk menyimpan dan memuat objek dengan NumPy. Objek ndarray dapat disimpan ke

dan diambil dari file disk dengan fungsi loadtxt dan savetxt yang menangani file teks normal, memuat dan menyimpan fungsi yang

menangani file biner NumPy dengan ekstensi file .npy, dan fungsi savez yang menangani file NumPy dengan ekstensi file .npz.

File .npy dan .npz menyimpan data, bentuk, dtype, dan informasi lain yang diperlukan untuk merekonstruksi ndarray dengan cara

yang memungkinkan array diambil dengan benar, bahkan saat file berada di komputer lain dengan arsitektur berbeda.

Jika Anda ingin menyimpan satu objek ndarray, simpan sebagai file .npy menggunakan [Link]. Jika Anda ingin menyimpan lebih

dari satu objek ndarray dalam satu file, simpan sebagai file .npz menggunakan [Link]. Anda juga dapat menyimpan beberapa

array ke dalam satu file dalam format npz terkompresi dengan savez_compressed.

Sangat mudah untuk menyimpan dan memuat dan menyusun dengan [Link](). Pastikan untuk menentukan array yang ingin

Anda simpan dan nama file. Misalnya, jika Anda membuat larik ini:

>>> a = [Link]([1, 2, 3, 4, 5, 6])

Anda dapat menyimpannya sebagai "[Link]" dengan:

>>> [Link]('namafile', a)

Anda dapat menggunakan [Link]() untuk merekonstruksi array Anda.

>>> b = [Link]('[Link]')

Jika Anda ingin memeriksa array Anda, Anda dapat menjalankan ::

>>> cetak(b) [1 2
3 4 5 6]

Anda dapat menyimpan larik NumPy sebagai file teks biasa seperti file .csv atau .txt dengan [Link].

Misalnya, jika Anda membuat larik ini:

>>> csv_arr = [Link]([1, 2, 3, 4, 5, 6, 7, 8])

Anda dapat dengan mudah menyimpannya sebagai file .csv dengan nama “new_file.csv” seperti ini:

>>> [Link]('file_baru.csv', csv_arr)

Anda dapat memuat file teks tersimpan dengan cepat dan mudah menggunakan loadtxt():
Machine Translated by Google
>>> [Link]('file_baru.csv')
array([1., 2., 3., 4., 5., 6., 7., 8.])

Fungsi savetxt() dan loadtxt() menerima parameter opsional tambahan seperti header, footer, dan delimiter.
Meskipun file teks lebih mudah untuk dibagikan, file .npy dan .npz lebih kecil dan lebih cepat dibaca. Jika Anda
memerlukan penanganan file teks yang lebih canggih (misalnya, jika Anda perlu bekerja dengan baris yang
berisi nilai yang hilang), Anda akan ingin menggunakan genfromtxt fungsi.

Dengan savetxt, Anda dapat menentukan header, footer, komentar, dan lainnya.

Pelajari lebih lanjut tentang rutinitas input dan output di sini.

Mengimpor dan mengekspor CSV

Mudah dibaca dalam CSV yang berisi informasi yang ada. Cara terbaik dan termudah untuk melakukannya adalah dengan
menggunakan Panda.

>>> impor panda sebagai pd

>>> # Jika semua kolom Anda bertipe sama: >>> x =

pd.read_csv('[Link]', header=0).values >>> print(x)

[['Billie Holiday' 'Jazz' 1300000 27000000]

['Jimmie Hendrix' 'Rock' 2700000 70000000]
['Miles Davis' 'Jazz' 1500000 48000000]
['SIA' 'Pop' 2000000 74000000]]

>>> # Anda juga dapat memilih kolom yang Anda butuhkan:

>>> x = pd.read_csv('[Link]', usecols=['Artist', 'Plays']).nilai >>> print(x)

[['Liburan Billie' 27000000]

['Jimmie Hendrix' 70000000]
['Miles Davis' 48.000.000]
['SIA' 74000000]]

Sangat mudah menggunakan Panda untuk mengekspor array Anda juga. Jika Anda baru mengenal NumPy, Anda
mungkin ingin membuat bingkai data Pandas dari nilai dalam larik Anda dan kemudian menulis bingkai data ke file
CSV dengan Pandas.

Jika Anda membuat larik ini "a"

>>> a = [Link]([[-2.58289208, 0.43014843, -1.24082018, 1.59572603], [ 0.99027828,

... 1.17150989, 0.94125714, -0.14692469], [ 0.76989341,
... 0.81299683, -0.95068423, 0.11769564], [ 0.20484034,
... 0.34784527, 1.96979195 , 0,51992837]])

Anda bisa membuat kerangka data Pandas

Machine Translated by Google
>>> df = [Link](a) >>>
cetak(df)
0 1 2 3
0 -2,582892 0,430148 -1,240820 1,595726
1 0,990278 1,171510 0,941257 -0,146925
2 0,769893 0,812997 -0,950684 0,117696

3 0,204840 0,347845 1,969792 0,519928

Anda dapat dengan mudah menyimpan kerangka data Anda dengan:

>>> df.to_csv('[Link]')

Dan baca CSV Anda dengan:

>>> data = pd.read_csv('[Link]')

Anda juga dapat menyimpan array Anda dengan metode savetxt NumPy .

>>> [Link]('[Link]', a, fmt='%.2f', delimiter=',', header='1, 2, 3, 4')

Jika menggunakan baris perintah, Anda dapat membaca CSV yang disimpan kapan saja dengan perintah seperti:

$cat [Link]
# 1, 2, 3, 4

-2,58,0,43,-1,24,1,60
0,99,1,17,0,94,-0,15
0,77,0,81,-0,95,0,12
0,20,0,35,1,97,0,52

Atau Anda dapat membuka file kapan saja dengan editor teks!

Jika Anda tertarik untuk mempelajari lebih lanjut tentang Panda, lihat dokumentasi resmi Panda.
Pelajari cara memasang Panda dengan informasi resmi pemasangan Panda.

Merencanakan array dengan Matplotlib

Jika Anda perlu membuat plot untuk nilai Anda, sangat mudah dengan Matplotlib.

Misalnya, Anda mungkin memiliki larik seperti ini:

>>> a = [Link]([2, 1, 5, 7, 4, 6, 8, 14, 10, 9, 18, 20, 22])

Jika Anda sudah menginstal Matplotlib, Anda dapat mengimpornya dengan:

>>> impor [Link] sebagai plt

# Jika Anda menggunakan Jupyter Notebook, Anda mungkin juga ingin menjalankan # baris kode berikut
untuk menampilkan kode Anda di notebook:

%matplotlib sebaris

Yang perlu Anda lakukan untuk memplot nilai Anda dijalankan:

Machine Translated by Google
>>> [Link](a)

# Jika Anda menjalankan dari baris perintah, Anda mungkin perlu melakukan
ini: # >>> [Link]()

Misalnya, Anda dapat memplot array 1D seperti ini:

>>> x = [Link](0, 5, 20) >>> y

= [Link](0, 10, 20) >>> [Link](x,
y, 'ungu') # baris >>> [Link](x, y, 'o')
# titik

Dengan Matplotlib, Anda memiliki akses ke sejumlah besar opsi visualisasi.

>>> fig = [Link]() >>>

kapak = fig.add_subplot(projection='3d')
>>> X = [Link](-5, 5, 0.15)
>>> Y = [Link](-5, 5, 0,15)
>>> X, Y = [Link](X, Y)
>>> R = [Link](X**2 + Y**2)
>>> Z = [Link](R)

>>> ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis')

Machine Translated by Google

Untuk membaca lebih lanjut tentang Matplotlib dan apa yang dapat dilakukannya, lihat dokumentasi resminya. Untuk petunjuk

tentang penginstalan Matplotlib, lihat bagian penginstalan resmi.

Kredit gambar: Jay Alammar [Link]

Sebelumnya Lanjut
ÿ ÿ
Mulai cepat NumPy dasar-dasar NumPy

© Hak Cipta 2008-2022, Pengembang NumPy.

Dibuat menggunakan Sphinx 4.5.0.