Tutorial Array Numpy Python

Pasang Dengan Python Wheels

Pastikan terlebih dahulu bahwa Anda telah memasang Python. Anda dapat melihat panduan kami tentang cara memasang Python jika Anda masih perlu melakukannya :)

Jika Anda bekerja di Windows, pastikan Anda telah menambahkan Python ke variabel lingkungan PATH. Lalu, jangan lupa memasang manajer paket, seperti pip, yang akan memastikan Anda bisa menggunakan pustaka open-source Python.

Perhatikan bahwa versi Python 3 terbaru sudah menyertakan pip, jadi periksa ulang apakah Anda memilikinya, dan jika ya, tingkatkan sebelum Anda memasang NumPy:

pip install pip --upgrade
pip --version

pip install numpy-<version>-<architecture>.whl

import numpy

Pasang Dengan Distribusi Python Anaconda

Untuk mendapatkan NumPy, Anda juga bisa mengunduh distribusi Python Anaconda. Ini mudah dan akan memungkinkan Anda memulai dengan cepat! Jika Anda belum mengunduhnya, buka halaman resmi untuk mendapatkannya. Ikuti instruksi pemasangan, dan Anda siap mulai!

Apakah Anda bertanya-tanya mengapa ini mungkin lebih mudah?

Hal baik dari mendapatkan distribusi Python ini adalah Anda tidak perlu terlalu khawatir memasang NumPy secara terpisah atau paket utama mana pun yang akan Anda gunakan untuk analisis data, seperti pandas, scikit-learn, dll.

Karena, terutama jika Anda sangat baru dengan Python, pemrograman, atau terminal, akan sangat melegakan bahwa Anaconda sudah menyertakan 100 paket Python, R, dan Scala paling populer untuk ilmu data. Namun bagi data scientist yang lebih berpengalaman, Anaconda tetap menjadi pilihan jika Anda ingin segera mulai mengatasi masalah ilmu data.

Selain itu, Anaconda juga menyertakan beberapa lingkungan pengembangan open-source, seperti Jupyter dan Spyder. Jika Anda ingin mulai bekerja dengan Jupyter Notebook setelah tutorial ini, kunjungi tutorial Jupyter notebook kami.

Singkatnya, pertimbangkan untuk mengunduh Anaconda agar dapat mulai bekerja dengan numpy dan paket lain yang relevan untuk ilmu data!

Cara membuat array NumPy “Kosong”

Yang sering dimaksud orang ketika mereka mengatakan bahwa mereka membuat array “kosong” adalah mereka ingin menggunakan placeholder awal, yang bisa Anda isi belakangan. Anda dapat menginisialisasi array dengan angka satu atau nol, tetapi Anda juga dapat membuat array yang diisi dengan nilai berjarak sama, nilai konstan, atau nilai acak.

Namun, Anda juga tetap bisa membuat array yang benar-benar kosong.

Untungnya bagi kita, ada cukup banyak fungsi untuk membuatnya.

Cobalah semuanya di bawah ini!

import numpy as np

# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Create an array of evenly-spaced values
np.linspace(0,2,9)

Tip: coba-coba fungsi di atas agar Anda memahami cara kerjanya!

• Untuk beberapa fungsi, seperti np.ones(), np.random.random(), np.empty(), np.full() atau np.zeros() satu-satunya hal yang perlu Anda lakukan untuk membuat array berisi satu atau nol adalah meneruskan shape dari array yang ingin dibuat. Sebagai opsi untuk np.ones() dan np.zeros(), Anda juga dapat menentukan tipe data. Pada kasus np.full(), Anda juga harus menentukan nilai konstan yang ingin dimasukkan ke array.
• Dengan np.linspace() dan np.arange() Anda dapat membuat array berisi nilai yang berjarak sama. Perbedaan antara kedua fungsi ini adalah nilai terakhir dari tiga nilai yang diteruskan pada potongan kode di atas menunjuk ke nilai langkah untuk np.linspace() atau jumlah sampel untuk np.arange(). Yang terjadi pada yang pertama adalah Anda ingin, misalnya, array berisi 9 nilai yang berada di antara 0 dan 2. Untuk yang kedua, Anda menentukan bahwa Anda ingin array dimulai pada 10 dan per langkah 5, menghasilkan nilai untuk array yang Anda buat.

Ingat bahwa NumPy juga memungkinkan Anda membuat array atau matriks identitas dengan np.eye() dan np.identity(). Matriks identitas adalah matriks persegi di mana semua elemen pada diagonal utama bernilai satu, dan semua elemen lainnya bernilai nol. Saat Anda mengalikan matriks dengan matriks identitas, matriks yang diberikan tetap tidak berubah.

Dengan kata lain, jika Anda mengalikan sebuah matriks dengan matriks identitas, hasilnya akan menjadi matriks yang sama lagi berdasarkan konvensi standar perkalian matriks.

Walaupun fokus tutorial ini bukan untuk mendemonstrasikan cara kerja matriks identitas, cukup dikatakan bahwa matriks identitas berguna saat Anda mulai melakukan perhitungan matriks: matriks ini dapat menyederhanakan persamaan matematika, yang membuat komputasi Anda lebih efisien dan andal.

Cara Memuat Array NumPy Dari Teks

Membuat array dengan bantuan placeholder awal atau dengan beberapa data contoh adalah cara yang bagus untuk memulai dengan numpy. Tetapi ketika Anda ingin mulai dengan analisis data, Anda perlu memuat data dari file teks.

Dengan apa yang telah Anda lihat sejauh ini, Anda tidak akan benar-benar bisa melakukan banyak hal. Gunakan beberapa fungsi spesifik untuk memuat data dari file Anda, seperti loadtxt() atau genfromtxt().

Misalkan Anda memiliki file teks berikut dengan data, Anda ingin menyalin-nempel nilai yang dikomentari pada kode di bawah, menempelkannya ke file teks, dan menyimpannya sebagai “data.txt.” Anda kemudian dapat menggunakan kode di bawah ini:

# This is your data in the text file
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Import your data
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

Pada kode di atas, Anda menggunakan loadtxt() untuk memuat data ke lingkungan Anda. Anda melihat bahwa argumen pertama yang diambil kedua fungsi adalah file teks data.txt. Selanjutnya, ada beberapa argumen spesifik untuk masing-masing: pada pernyataan pertama, Anda melewati baris pertama, dan Anda mengembalikan kolom sebagai array terpisah dengan unpack=TRUE. Ini berarti bahwa nilai pada kolom Value1 akan dimasukkan ke x, dan seterusnya.

Perhatikan bahwa, jika Anda memiliki data yang dipisahkan koma atau jika Anda ingin menentukan tipe data, ada juga argumen delimiter dan dtype yang dapat Anda tambahkan ke argumen loadtxt().

Itu mudah dan lugas, bukan?

Mari lihat file kedua Anda dengan data:

# Your data in the text file
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

Anda melihat bahwa di sini, Anda menggunakan genfromtxt() untuk memuat data. Dalam kasus ini, Anda harus menangani beberapa nilai hilang yang ditandai oleh string 'MISSING'.

Karena fungsi genfromtxt() mengonversi string karakter di kolom numerik menjadi nan, Anda dapat mengonversi nilai-nilai ini ke nilai lain dengan menentukan argumen filling_values. Dalam kasus ini, Anda memilih menetapkan nilai -999 untuk nilai yang hilang tersebut.

Jika, kebetulan, Anda memiliki nilai yang tidak dikonversi menjadi nan oleh genfromtxt(), selalu ada argumen missing_values yang memungkinkan Anda menentukan apa sebenarnya nilai hilang dari data Anda.

Tapi itu belum semuanya.

Tip: lihat halaman numpy.genfromtxt ini untuk melihat argumen lain apa yang dapat Anda tambahkan agar berhasil mengimpor data.

Sekarang Anda mungkin bertanya-tanya apa perbedaan nyata antara kedua fungsi ini.

Contoh-contoh tadi mungkin mengindikasikannya secara implisit, tetapi, secara umum, genfromtxt() memberi Anda sedikit lebih banyak fleksibilitas; Ini lebih tangguh daripada loadtxt().

Mari buat perbedaan ini sedikit lebih praktis: yang terakhir, loadtxt(), hanya berfungsi ketika setiap baris dalam file teks memiliki jumlah nilai yang sama, jadi ketika Anda ingin menangani nilai hilang dengan mudah, Anda biasanya akan merasa lebih mudah menggunakan genfromtxt().

Tapi ini jelas bukan satu-satunya alasan.

Sekilas pada jumlah argumen yang ditawarkan genfromtxt() akan mengajarkan Anda bahwa ada jauh lebih banyak hal yang dapat Anda tentukan dalam impor Anda, seperti jumlah maksimum baris yang dibaca atau opsi untuk secara otomatis menghapus spasi putih dari variabel.

Cara Menyimpan Array NumPy

Setelah Anda melakukan semua yang perlu dilakukan dengan array Anda, Anda juga dapat menyimpannya ke file. Jika Anda ingin menyimpan array ke file teks, Anda dapat menggunakan fungsi savetxt() untuk melakukannya:

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

Ingat bahwa np.arange() membuat array NumPy berisi nilai yang berjarak sama. Nilai ketiga yang Anda teruskan ke fungsi ini adalah nilai langkah.

Tentu saja, ada cara lain untuk menyimpan array NumPy Anda ke file teks. Lihat fungsi pada tabel di bawah jika Anda ingin menyimpan data Anda ke file biner atau arsip:

Untuk informasi lebih lanjut atau contoh cara menggunakan fungsi di atas untuk menyimpan data Anda, periksa halaman referensi NumPy atau gunakan salah satu fungsi bantuan yang ditawarkan NumPy agar langsung mengetahui lebih banyak!

Apakah Anda tidak yakin apa fungsi bantuan NumPy itu?

Jangan khawatir! Anda akan mempelajari lebih lanjut tentangnya di salah satu bagian selanjutnya!

Cara Menginspeksi Array NumPy Anda

Selain atribut array yang telah disebutkan di atas, yaitu data, shape, dtype dan strides, ada beberapa lagi yang dapat Anda gunakan untuk dengan mudah mengetahui lebih banyak tentang array Anda. Yang mungkin menarik untuk digunakan saat Anda baru memulai adalah sebagai berikut:

import numpy as np

# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

Ini hampir semua atribut yang dapat dimiliki sebuah array.

Jangan khawatir jika Anda merasa tidak semuanya berguna bagi Anda saat ini. Ini cukup normal karena, seperti yang Anda baca di bagian sebelumnya, Anda baru akan mulai memikirkan memori ketika Anda bekerja dengan set data besar.

Perhatikan juga bahwa, selain atribut, Anda juga memiliki beberapa cara lain untuk mendapatkan lebih banyak informasi bahkan sedikit mengutak-atik array Anda:

import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the length of `my_array`
print(len(my_array))

# Change the data type of `my_array`
my_array.astype(float)

Sekarang setelah Anda membuat array, baik dengan membuatnya sendiri dengan np.array() atau salah satu fungsi placeholder awal, atau dengan memuat data Anda melalui fungsi loadtxt() atau genfromtxt(), saatnya melihat lebih dekat ke elemen kunci kedua yang benar-benar mendefinisikan pustaka NumPy: komputasi ilmiah.

Cara Transpose Array Anda

Yang dilakukan transpose pada array Anda sebenarnya adalah menukar dimensi-dimensinya. Atau, dengan kata lain, Anda menukar bentuk array. Mari ambil contoh kecil untuk menunjukkan efek transposisi:

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array`
print(my_2d_array)

# Transpose `my_2d_array`
print(np.transpose(my_2d_array))

# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)

Tip: jika perbandingan visual antara array dan versi transposenya belum sepenuhnya jelas, inspeksi shape dari kedua array untuk memastikan Anda memahami mengapa dimensinya ditukar.

Perhatikan bahwa ada dua fungsi transpose. Keduanya melakukan hal yang sama; Tidak terlalu banyak perbedaan. Anda hanya perlu mempertimbangkan bahwa T tampak lebih seperti fungsi kemudahan dan Anda memiliki fleksibilitas lebih dengan np.transpose(). Itulah mengapa disarankan menggunakan fungsi ini jika Anda ingin lebih banyak argumen.

Semuanya baik-baik saja saat Anda mentranspose array yang lebih besar dari satu dimensi, tetapi apa yang terjadi saat Anda hanya memiliki array 1-D? Menurut Anda, apakah akan ada efek?

Coba sendiri pada potongan kode di bawah. Array 1-D Anda telah dimuat:

import numpy as np
my_array = np.array([1,2,3,4])

# Print `my_2d_array
print(my_array)

# Transpose `my_2d_array
print(np.transpose(my_array))

# Or use `T` to transpose `my_2d_array
print(my_array.T)

Anda benar sekali! Tidak ada efek saat Anda mentranspose array 1-D!

Mengubah Bentuk vs Mengubah Ukuran Array Anda

Anda mungkin telah membaca pada bagian broadcasting bahwa dimensi array Anda harus kompatibel jika Anda ingin menjadi kandidat yang baik untuk operasi aritmetika. Namun pertanyaan tentang apa yang harus Anda lakukan ketika itu tidak terjadi, belum terjawab.

Nah, di sinilah Anda mendapatkan jawabannya!

Yang bisa Anda lakukan jika array tidak memiliki dimensi yang sama adalah mengubah ukuran array. Anda kemudian akan mengembalikan array baru yang memiliki shape yang Anda berikan ke fungsi np.resize(). Jika Anda meneruskan array asli bersama dimensi baru, dan jika array baru itu lebih besar daripada yang Anda miliki semula, array baru akan diisi dengan salinan array asli yang diulang sebanyak yang diperlukan.

Namun, jika Anda hanya menerapkan np.resize() pada array dan Anda meneruskan shape baru, array baru akan diisi dengan nol.

Mari coba ini dengan contoh:

import numpy as np
x = np.ones((3,4))

# Print the shape of `x`
print(x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x`
print(x)

Selain mengubah ukuran, Anda juga dapat mengubah bentuk array. Ini berarti Anda memberikan bentuk baru ke array tanpa mengubah datanya. Kunci untuk reshaping adalah memastikan ukuran total array baru tidak berubah. Jika Anda mengambil contoh array x yang digunakan di atas, yang berukuran 3 X 4 atau 12, Anda harus memastikan bahwa array baru juga berukuran 12.

Psst… Jika Anda ingin menghitung ukuran array dengan kode, pastikan menggunakan atribut size: x.size atau x.reshape((2,6)).size:

import numpy as np

# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))

# Print the shape of `x`
print("Shape of x:", x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpose `x`
x = x.T

# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

Keluaran: 

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

Jika semua cara gagal, Anda juga dapat menambahkan (append) sebuah array ke array asli Anda atau menyisipkan (insert) atau menghapus (delete) elemen array untuk memastikan dimensi Anda cocok dengan array lain yang ingin Anda gunakan untuk komputasi.

Operasi lain yang mungkin berguna saat Anda mengubah bentuk array adalah ravel(). Fungsi ini memungkinkan Anda meratakan array. Ini berarti bahwa jika Anda memiliki array 2D, 3D, atau n-D, Anda dapat menggunakan fungsi ini untuk meratakannya menjadi array 1-D.

Cukup praktis, bukan?

Cara Menambahkan (Append) Array

Saat Anda menambahkan array ke array asli, array tersebut “direkatkan” ke akhir array asli tersebut. Jika Anda ingin memastikan bahwa yang Anda tambahkan tidak berada di akhir array, Anda dapat mempertimbangkan untuk menyisipkannya. Buka bagian berikut jika Anda ingin tahu lebih banyak.

Menambahkan adalah hal yang cukup mudah dilakukan berkat pustaka NumPy; Anda dapat menggunakan np.append().

Periksa cara melakukannya pada potongan kode di bawah. Jangan lupa bahwa Anda selalu dapat memeriksa array mana yang dimuat dengan mengetik, misalnya, my_array di shell IPython dan menekan ENTER.

import numpy as np

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

# Print `my_array` before appending
print("my_array before appending:", my_array)

# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Print `new_array`
print("new_array:", new_array)

# Print `my_array` after appending
print("my_array after appending:", my_array)

Keluaran:

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

Perhatikan bahwa my_array tetap tidak berubah setelah append karena np.append() mengembalikan array baru alih-alih memodifikasi array asli di tempat.

Menambahkan ke my_2d_array:

import numpy as np

my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)

# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)

Keluaran: 

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

Perhatikan bagaimana, saat Anda menambahkan kolom ekstra ke my_2d_array, axis ditentukan. Ingat bahwa axis 1 menunjukkan kolom, sementara axis 0 menunjukkan baris dalam array 2-D.

Cara Menyisipkan dan Menghapus Elemen Array

Selain menambahkan, Anda juga dapat menyisipkan dan menghapus elemen array. Seperti yang mungkin sudah Anda duga, fungsi yang memungkinkan Anda melakukan operasi ini adalah np.insert() dan np.delete():

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Insert `5` at index 1
np.insert(my_array, 1, 5)

# Delete the value at index 1
np.delete(my_array,[1])

Cara Menggabungkan dan Memisahkan Array

Anda juga dapat ‘menggabungkan’ atau join array Anda. Ada banyak fungsi yang dapat Anda gunakan untuk tujuan tersebut dan sebagian besar tercantum di bawah.

Cobalah, tetapi pastikan juga untuk menguji shape array di shell IPython. Array yang telah dimuat adalah x, my_array, my_resized_array dan my_2d_array.

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))

# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))

# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])

# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])

Anda akan mencatat beberapa hal saat melalui fungsi-fungsi ini:

• Jumlah dimensi harus sama jika Anda ingin menggabungkan dua array dengan np.concatenate(). Dengan demikian, jika Anda ingin menggabungkan sebuah array dengan my_array, yang 1-D, Anda harus memastikan bahwa array kedua yang Anda miliki juga 1-D.
• Dengan np.vstack(), Anda dengan mudah menggabungkan my_array dengan my_2d_array. Anda hanya perlu memastikan bahwa, saat menumpuk array secara baris (row-wise), jumlah kolom di kedua array sama. Dengan demikian, Anda juga bisa menambahkan array dengan shape (2,4) atau (3,4) ke my_2d_array, selama jumlah kolomnya cocok. Dinyatakan berbeda, array harus memiliki shape yang sama di sepanjang semua kecuali sumbu pertama. Hal yang sama juga berlaku saat Anda ingin menggunakan np.r[].
• Untuk np.hstack(), Anda harus memastikan bahwa jumlah dimensi sama dan jumlah baris di kedua array sama. Itu berarti Anda dapat menumpuk array seperti (2,3) atau (2,4) ke my_2d_array, yang sendiri memiliki shape (2,4). Apa pun dimungkinkan selama Anda memastikan jumlah barisnya cocok. Fungsi ini masih didukung oleh NumPy, tetapi Anda sebaiknya lebih memilih np.concatenate() atau np.stack().
• Dengan np.column_stack(), Anda harus memastikan bahwa array yang Anda masukkan memiliki dimensi pertama yang sama. Dalam kasus ini, kedua shape sama, tetapi jika my_resized_array berukuran (2,1) atau (2,), array tetap akan ditumpuk.
• np.c_[] adalah cara lain untuk menggabungkan. Di sini juga, dimensi pertama dari kedua array harus cocok.

Saat Anda telah menggabungkan array, Anda mungkin juga ingin memisahkannya pada titik tertentu. Sama seperti Anda dapat menumpuknya secara horizontal, Anda juga dapat melakukan hal yang sama tetapi secara vertikal. Anda menggunakan np.hsplit() dan np.vsplit(), masing-masing:

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))

# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))

Yang perlu Anda ingat saat menggunakan kedua fungsi split ini mungkin adalah shape array Anda. Ambil kasus di atas sebagai contoh: my_stacked_array memiliki shape (2,8). Jika Anda ingin memilih indeks tempat pemisahan terjadi, Anda harus mengingat shape tersebut.

Dengan np.histogram()

Berlawanan dengan apa yang mungkin disarankan fungsi tersebut, fungsi np.histogram() tidak menggambar histogram tetapi menghitung kejadian dari array yang masuk ke setiap bin; Ini akan menentukan area yang ditempati setiap batang histogram Anda.

Yang Anda teruskan ke fungsi np.histogram() pertama-tama adalah data masukan atau array yang Anda gunakan. Array akan diratakan saat histogram dihitung.

# Import `numpy` as `np`
import numpy as np

# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))

# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))

Anda akan melihat bahwa sebagai hasilnya, histogram akan dihitung: array pertama mencantumkan frekuensi untuk semua elemen array Anda, sedangkan array kedua mencantumkan bin yang akan digunakan jika Anda tidak menentukan bin apa pun.

Jika Anda menentukan jumlah bin, hasil komputasi akan berbeda: angka pecahan (float) akan hilang dan Anda akan melihat semua bilangan bulat untuk bin.

Masih ada beberapa argumen lain yang dapat Anda tentukan yang dapat memengaruhi histogram yang dihitung. Anda dapat menemukan semuanya di sini.

Tetapi apa gunanya menghitung histogram seperti itu jika Anda tidak dapat memvisualisasikannya?

Visualisasi sangat mudah dengan bantuan Matplotlib, tetapi Anda tidak memerlukan np.histogram() untuk menghitung histogram. plt.hist() melakukan ini sendiri saat Anda meneruskan data (yang telah diratakan) dan bin:

# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')

# Show the plot
plt.show()

Kode di atas kemudian akan memberi Anda histogram (dasar) berikut:

Menggunakan np.meshgrid()

Cara lain untuk memvisualisasikan array Anda (secara tidak langsung) adalah dengan menggunakan np.meshgrid(). Masalah yang Anda hadapi dengan array adalah bahwa Anda memerlukan array 2-D dari nilai koordinat x dan y. Dengan fungsi di atas, Anda dapat membuat kisi persegi panjang dari array nilai x dan array nilai y: fungsi np.meshgrid() mengambil dua array 1D dan menghasilkan dua matriks 2D yang sesuai dengan semua pasangan (x, y) dalam kedua array. Kemudian, Anda dapat menggunakan matriks ini untuk membuat berbagai macam plot.

np.meshgrid() sangat berguna jika Anda ingin mengevaluasi fungsi pada sebuah kisi, seperti yang ditunjukkan kode di bawah:

# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Create an array
points = np.arange(-5, 5, 0.01)

# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)

# Draw a color bar
plt.colorbar()

# Show the plot
plt.show()

Kode di atas memberikan hasil berikut: