Tutorial dasar-dasar NumPy untuk pemula

December 23, 2022

Untuk mengerjakan contoh, Anda harus menginstal addon matplotlib selain NumPy.

Profil pelajar

Ini adalah ikhtisar singkat tentang array di NumPy. Ini menunjukkan bagaimana n-dimensi ( $n >= 2$ ) array direpresentasikan dan dapat dimanipulasi. Secara khusus, jika Anda tidak tahu cara menerapkan fungsi umum ke array n-dimensi (tanpa menggunakan for-loop), atau jika Anda ingin memahami properti sumbu dan bentuk untuk array n-dimensi, artikel ini mungkin bisa membantu.

Tujuan pembelajaran

Setelah membaca, Anda harus dapat:

Pahami perbedaan antara array satu, dua, dan n-dimensi di NumPy;
Pahami cara menerapkan beberapa operasi aljabar linier ke larik n-dimensi tanpa menggunakan for-loop;
Memahami sumbu dan properti bentuk untuk array n-dimensi.

Dasar-dasar NumPy

Objek utama NumPy adalah array multidimensi yang homogen. Ini adalah tabel elemen (biasanya angka), semua dari tipe yang sama, diindeks oleh tupel bilangan bulat non-negatif. Dalam dimensi NumPy disebut axes .

Misalnya, larik untuk koordinat titik dalam ruang 3D, , memiliki satu sumbu. Sumbu itu memiliki 3 elemen di dalamnya, jadi kita katakan panjangnya 3. Pada contoh di bawah ini, array memiliki 2 sumbu. Sumbu pertama memiliki panjang 2, sumbu kedua memiliki panjang 3.[1, 2, 1]

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

Kelas array NumPy disebut ndarray. Itu juga dikenal dengan alias array. Perhatikan bahwa numpy.arrayini tidak sama dengan kelas Standard Python Library array.array, yang hanya menangani larik satu dimensi dan menawarkan fungsionalitas yang lebih sedikit. Atribut yang lebih penting dari suatu ndarrayobjek adalah:

ndarray.ndim: jumlah sumbu (dimensi) dari array.
ndarray.shape: dimensi larik. Ini adalah kumpulan bilangan bulat yang menunjukkan ukuran array di setiap dimensi. Untuk matriks dengan n baris dan m kolom, shapeakan menjadi (n,m). Oleh karena itu, panjang shapetuple adalah jumlah sumbu, ndim.
ndarray.size: jumlah total elemen array. Ini sama dengan produk dari unsur-unsur shape.
ndarray.dtype: objek yang menjelaskan jenis elemen dalam array. Seseorang dapat membuat atau menentukan dtype menggunakan tipe Python standar. Selain itu NumPy menyediakan jenisnya sendiri. numpy.int32, numpy.int16, dan numpy.float64 adalah beberapa contohnya.
ndarray.itemsize: ukuran dalam byte dari setiap elemen array. Misalnya, array elemen bertipe float64memiliki itemsize8 (=64/8), sedangkan salah satu elemen bertipe complex32memiliki itemsize4 (=32/8). Ini setara dengan ndarray.dtype.itemsize.
ndarray.data: buffer yang berisi elemen sebenarnya dari array. Biasanya, kita tidak perlu menggunakan atribut ini karena kita akan mengakses elemen dalam array menggunakan fasilitas pengindeksan.

Contoh

>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<class 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<class 'numpy.ndarray'>

Pembuatan Array

Ada beberapa cara untuk membuat array.

Misalnya, Anda dapat membuat larik dari daftar atau tuple Python biasa menggunakan arrayfungsi. Jenis array yang dihasilkan disimpulkan dari jenis elemen dalam urutan.

>>> import numpy as np
>>> a = np.array([2, 3, 4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int64')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')

Kesalahan yang sering terjadi adalah pemanggilan arraydengan beberapa argumen, daripada memberikan urutan tunggal sebagai argumen.

>>> a = np.array(1, 2, 3, 4)    # WRONG
Traceback (most recent call last):
  ...
TypeError: array() takes from 1 to 2 positional arguments but 4 were given
>>> a = np.array([1, 2, 3, 4])  # RIGHT

arraymengubah urutan urutan menjadi array dua dimensi, urutan urutan urutan menjadi array tiga dimensi, dan seterusnya.

>>> b = np.array([(1.5, 2, 3), (4, 5, 6)])
>>> b
array([[1.5, 2. , 3. ],
       [4. , 5. , 6. ]])

Jenis larik juga dapat ditentukan secara eksplisit pada waktu pembuatan:

>>> c = np.array([[1, 2], [3, 4]], dtype=complex)
>>> c
array([[1.+0.j, 2.+0.j],
       [3.+0.j, 4.+0.j]])

Seringkali, elemen-elemen dari sebuah array awalnya tidak diketahui, tetapi ukurannya diketahui. Karenanya, NumPy menawarkan beberapa fungsi untuk membuat array dengan konten placeholder awal. Ini meminimalkan kebutuhan untuk menumbuhkan array, operasi yang mahal.

Fungsi zerosmembuat larik yang penuh dengan nol, fungsi onesmembuat larik yang penuh dengan nol, dan fungsi empty membuat larik yang konten awalnya acak dan bergantung pada status memori. Secara default, dtype dari array yang dibuat adalah float64, tetapi dapat ditentukan melalui kata kunci argument dtype.

>>> np.zeros((3, 4))
array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
>>> np.ones((2, 3, 4), dtype=np.int16)
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]]], dtype=int16)
>>> np.empty((2, 3)) 
array([[3.73603959e-262, 6.02658058e-154, 6.55490914e-260],  # may vary
       [5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])

Untuk membuat urutan angka, NumPy menyediakan arangefungsi yang mirip dengan bawaan Python range, tetapi mengembalikan array.

>>> np.arange(10, 30, 5)
array([10, 15, 20, 25])
>>> np.arange(0, 2, 0.3)  # it accepts float arguments
array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

Ketika arangedigunakan dengan argumen floating point, umumnya tidak mungkin untuk memprediksi jumlah elemen yang diperoleh, karena ketepatan floating point yang terbatas. Untuk alasan ini, biasanya lebih baik menggunakan fungsi linspaceyang menerima jumlah elemen yang kita inginkan sebagai argumen, daripada langkah:

from numpy import pi
>>> np.linspace(0, 2, 9)                   # 9 numbers from 0 to 2
array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  ])
>>> x = np.linspace(0, 2 * pi, 100)        # useful to evaluate function at lots of points
>>> f = np.sin(x)

Mencetak Array

Saat Anda mencetak larik, NumPy menampilkannya dengan cara yang mirip dengan daftar bersarang, tetapi dengan tata letak berikut:

sumbu terakhir dicetak dari kiri ke kanan,
yang kedua hingga terakhir dicetak dari atas ke bawah,
sisanya juga dicetak dari atas ke bawah, dengan setiap irisan dipisahkan dari yang berikutnya dengan garis kosong.

Array satu dimensi kemudian dicetak sebagai baris, bidimensi sebagai matriks dan tridimensi sebagai daftar matriks.

>>> a = np.arange(6)                    # 1d array
>>> print(a)
[0 1 2 3 4 5]
>>>
>>> b = np.arange(12).reshape(4, 3)     # 2d array
>>> print(b)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
>>>
>>> c = np.arange(24).reshape(2, 3, 4)  # 3d array
>>> print(c)
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

Lihat di bawah untuk mendapatkan rincian lebih lanjut tentang reshape.

Jika array terlalu besar untuk dicetak, NumPy secara otomatis melewati bagian tengah array dan hanya mencetak bagian sudutnya:

>>> print(np.arange(10000))
[   0    1    2 ... 9997 9998 9999]
>>>
>>> print(np.arange(10000).reshape(100, 100))
[[   0    1    2 ...   97   98   99]
 [ 100  101  102 ...  197  198  199]
 [ 200  201  202 ...  297  298  299]
 ...
 [9700 9701 9702 ... 9797 9798 9799]
 [9800 9801 9802 ... 9897 9898 9899]
 [9900 9901 9902 ... 9997 9998 9999]]

Untuk menonaktifkan perilaku ini dan memaksa NumPy mencetak seluruh larik, Anda dapat mengubah opsi pencetakan menggunakan set_printoptions.

>>> np.set_printoptions(threshold=sys.maxsize)  # sys module should be imported

Operasi Dasar

Operator aritmatika pada array menerapkan elementwise . Array baru dibuat dan diisi dengan hasilnya.

>>> a = np.array([20, 30, 40, 50])
>>> b = np.arange(4)
>>> b
array([0, 1, 2, 3])
>>> c = a - b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10 * np.sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a < 35
array([ True,  True, False, False])

Tidak seperti di banyak bahasa matriks, operator produk *beroperasi secara elemen dalam array NumPy. Produk matriks dapat dilakukan dengan menggunakan @operator (dalam python >=3.5) atau dotfungsi atau metode:

>>> A = np.array([[1, 1],
...               [0, 1]])
>>> B = np.array([[2, 0],
...               [3, 4]])
>>> A * B     # elementwise product
array([[2, 0],
       [0, 4]])
>>> A @ B     # matrix product
array([[5, 4],
       [3, 4]])
>>> A.dot(B)  # another matrix product
array([[5, 4],
       [3, 4]])

Beberapa operasi, seperti +=dan *=, bertindak di tempat untuk mengubah larik yang ada daripada membuat larik baru.

>>> rg = np.random.default_rng(1)  # create instance of default random number generator
>>> a = np.ones((2, 3), dtype=int)
>>> b = rg.random((2, 3))
>>> a *= 3
>>> a
array([[3, 3, 3],
       [3, 3, 3]])
>>> b += a
>>> b
array([[3.51182162, 3.9504637 , 3.14415961],
       [3.94864945, 3.31183145, 3.42332645]])
>>> a += b  # b is not automatically converted to integer type
Traceback (most recent call last):
    ...
numpy.core._exceptions._UFuncOutputCastingError: Cannot cast ufunc 'add' output from dtype('float64') to dtype('int64') with casting rule 'same_kind'

Saat beroperasi dengan array dari tipe yang berbeda, tipe array yang dihasilkan sesuai dengan yang lebih umum atau tepat (perilaku yang dikenal sebagai upcasting).

>>> a = np.ones(3, dtype=np.int32)
>>> b = np.linspace(0, pi, 3)
>>> b.dtype.name
'float64'
>>> c = a + b
>>> c
array([1.        , 2.57079633, 4.14159265])
>>> c.dtype.name
'float64'
>>> d = np.exp(c * 1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
       -0.54030231-0.84147098j])
>>> d.dtype.name
'complex128'

Banyak operasi unary, seperti menghitung jumlah semua elemen dalam array, diimplementasikan sebagai metode ndarraykelas.

>>> a = rg.random((2, 3))
>>> a
array([[0.82770259, 0.40919914, 0.54959369],
       [0.02755911, 0.75351311, 0.53814331]])
>>> a.sum()
3.1057109529998157
>>> a.min()
0.027559113243068367
>>> a.max()
0.8277025938204418

Secara default, operasi ini berlaku untuk array seolah-olah itu adalah daftar angka, apa pun bentuknya. Namun, dengan menentukan axis parameter, Anda dapat menerapkan operasi di sepanjang sumbu larik yang ditentukan:

>>> b = np.arange(12).reshape(3, 4)
>>> b
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>>
>>> b.sum(axis=0)     # sum of each column
array([12, 15, 18, 21])
>>>
>>> b.min(axis=1)     # min of each row
array([0, 4, 8])
>>>
>>> b.cumsum(axis=1)  # cumulative sum along each row
array([[ 0,  1,  3,  6],
       [ 4,  9, 15, 22],
       [ 8, 17, 27, 38]])