PYTHON IMAGEING LIBRARY

Untuk membaca suatu citra digunakan sintaks :

𝑓𝑟𝑜𝑚 𝑃𝐼𝐿 𝑖𝑚𝑝𝑜𝑟𝑡 𝐼𝑚𝑎𝑔𝑒

𝑝𝑖𝑙_𝑖𝑚 = 𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(‘𝐶:\𝑃𝑦𝑡ℎ𝑜𝑛27\𝑦𝑎𝑙𝑒𝑓𝑎𝑐𝑒𝑠\𝑠𝑢𝑏𝑗𝑒𝑐𝑡01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠’)

Untuk mengkonversi citra RGB ke grayscale digunakan sintaks :

𝑝𝑖𝑙_𝑖𝑚 = 𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(‘𝐶:\𝑃𝑦𝑡ℎ𝑜𝑛27\𝑦𝑎𝑙𝑒𝑓𝑎𝑐𝑒𝑠\𝑠𝑢𝑏𝑗𝑒𝑐01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠’). 𝑐𝑜𝑛𝑣𝑒𝑟𝑡(‘𝐿’)

Membuat THUMBNAILS :

𝑝𝑖𝑙_𝑖𝑚. 𝑡ℎ𝑢𝑚𝑏𝑛𝑎𝑖𝑙((128,128))

COPY AND PASTE REGIONS

Melakukan crop pada bagian tertentu pada citra menggunakan metode crop( )

𝑏𝑜𝑥 = (100, 100, 400, 400)

𝑟𝑒𝑔𝑖𝑜𝑛 = 𝑝𝑖𝑙_𝑖𝑚𝑎𝑔𝑒. 𝑐𝑟𝑜𝑝(𝑏𝑜𝑥)

setiap daerah didefinisikan oleh 4 titik, dimana masing-masing koordinat menunjukkan batas kiri, atas,
kanan, dan bawah. PIL digunakan sebagai koordinat sistem dengan (0,0) sebagai titik kiri-atas. Ekstraksi
wilayah sebagai contoh dapat dilakukan rotasi dan mengembalikannya menggunakan metode paste ( ),
sebagai berikut :

𝑟𝑒𝑔𝑖𝑜𝑛 = 𝑟𝑒𝑔𝑖𝑜𝑛. 𝑡𝑟𝑎𝑛𝑠𝑝𝑜𝑠𝑒(𝐼𝑚𝑎𝑔𝑒. 𝑅𝑂𝑇𝐴𝑇𝐸_180)

𝑝𝑖𝑙_𝑖𝑚𝑎𝑔𝑒. 𝑝𝑎𝑠𝑡𝑒(𝑟𝑒𝑔𝑖𝑜𝑛, 𝑏𝑜𝑥)

RESIZE AND ROTATE

Untuk meresize ukuran citra dapat menggunakan metode resize ( ) dengan menginputkan ukuran
terbaru citra yang diinginkan.

𝑜𝑢𝑡 = 𝑝𝑖𝑙_𝑖𝑚𝑎𝑔𝑒. 𝑟𝑒𝑠𝑖𝑧𝑒((128,128))

Untuk melakukan rotasi pada citra, dimana rotasi dilakukan searah dengan jarum jam menggunakan
metode rotate( )

𝑜𝑢𝑡 = 𝑝𝑖𝑙_𝑖𝑚𝑎𝑔𝑒. 𝑟𝑜𝑡𝑎𝑡𝑒(45)

MATPLOTLIB
PLOTTING IMAGES, POINT AND LINES

Example image plotting dengan beberapa titik dan garis

>>> 𝑝𝑖𝑙_𝑖𝑚𝑎𝑔𝑒. 𝑡ℎ𝑢𝑚𝑏𝑛𝑎𝑖𝑙((128,128))

>>> 𝑏𝑜𝑥 = (100,100,400,400)
>>> 𝑏𝑜𝑥
(𝟏𝟎𝟎, 𝟏𝟎𝟎, 𝟒𝟎𝟎, 𝟒𝟎𝟎)
>>> 𝑟𝑒𝑔𝑖𝑜𝑛 = 𝑝𝑖𝑙_𝑖𝑚𝑎𝑔𝑒. 𝑐𝑟𝑜𝑝(𝑏𝑜𝑥)
>>> 𝑓𝑟𝑜𝑚 𝑃𝐼𝐿 𝑖𝑚𝑝𝑜𝑟𝑡 𝐼𝑚𝑎𝑔𝑒
>>> 𝑓𝑟𝑜𝑚 𝑝𝑦𝑙𝑎𝑏 𝑖𝑚𝑝𝑜𝑟𝑡 ∗
>>> 𝑖𝑚 = 𝑎𝑟𝑟𝑎𝑦(𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(′𝐶:\𝑃𝑦𝑡ℎ𝑜𝑛27\𝑦𝑎𝑙𝑒𝑓𝑎𝑐𝑒𝑠\𝑠𝑢𝑏𝑗𝑒𝑐𝑡01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠′))
>>> 𝑖𝑚𝑠ℎ𝑜𝑤(𝑖𝑚)
< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒊𝒎𝒂𝒈𝒆. 𝑨𝒙𝒆𝒔𝑰𝒎𝒂𝒈𝒆 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟓𝑩𝑪𝟐𝟕𝑭𝟎 >
>>> 𝑥 = [100,100,400,400]
>>> 𝑦 = [200,500,200,500]
>>> 𝑝𝑙𝑜𝑡(𝑥, 𝑦, ′𝑟 ∗ ′)
[< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒍𝒊𝒏𝒆𝒔. 𝑳𝒊𝒏𝒆𝟐𝑫 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟓𝑩𝑩𝟒𝟑𝑪𝟖 >]
>>> 𝑝𝑙𝑜𝑡(𝑥[: 2], 𝑦[: 2])
[< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒍𝒊𝒏𝒆𝒔. 𝑳𝒊𝒏𝒆𝟐𝑫 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟐𝟕𝑨𝟖𝟗𝑩𝟎 >]
>>> 𝑡𝑖𝑡𝑙𝑒(′𝑃𝑙𝑜𝑡𝑡𝑖𝑛𝑔: "𝑠𝑢𝑏𝑗𝑒𝑐𝑡01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠′)
< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒕𝒆𝒙𝒕. 𝑻𝒆𝒙𝒕 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟓𝑩𝑩𝟒𝟗𝟎𝟖 >
>>> 𝑠ℎ𝑜𝑤()

Hasil :

Untuk menghapus menggunakan sintaks :

𝑎𝑥𝑖𝑠(‘𝑜𝑓𝑓’)
Penggunaan fungsi plot :

𝑝𝑙𝑜𝑡(𝑥, 𝑦)  𝑑𝑒𝑓𝑎𝑢𝑙𝑡 𝑏𝑙𝑢𝑒 𝑠𝑜𝑙𝑖𝑑 𝑙𝑖𝑛𝑒

𝑝𝑙𝑜𝑡(𝑥, 𝑦, ’𝑟 ∗ ’)𝑟𝑒𝑑 𝑠𝑡𝑎𝑟 − 𝑚𝑎𝑟𝑘𝑒𝑟𝑠
𝑝𝑙𝑜𝑡(𝑥, 𝑦, ’𝑔𝑜 − ‘)𝑔𝑟𝑒𝑒𝑛 𝑙𝑖𝑛𝑒 𝑤𝑖𝑡ℎ 𝑐𝑖𝑟𝑐𝑙𝑒 − 𝑚𝑎𝑟𝑘𝑒𝑟𝑠
𝑝𝑙𝑜𝑡(𝑥, 𝑦, ’𝑘𝑠: ’)𝑏𝑙𝑎𝑐𝑘 𝑑𝑜𝑡𝑡𝑒𝑑 𝑙𝑖𝑛𝑒 𝑤𝑖𝑡ℎ 𝑠𝑞𝑢𝑎𝑟𝑒 − 𝑚𝑎𝑟𝑘𝑒𝑟𝑠

IMAGE CONTOURS AND HISTOGRAM

Format warna dasar untuk plotting

COLOR KET
‘B’ Blue
‘G’ green
‘R’ Red
‘C’ Cyan
‘M’ Magenta
‘Y’ Yellow
‘K’ Black
‘W’ White

Format garis dasar untuk plotting

LINE KET
‘-‘ Solid
‘- -‘ Dashed
‘:’ Dotted

Format dasar marker untuk plotting

MARKER KET
‘.’ Point
‘O’ Circle
‘S’ Square
‘*’ Star
‘+’ Plus
‘X’ X

Example :

𝑓𝑟𝑜𝑚 𝑃𝐼𝐿 𝑖𝑚𝑝𝑜𝑟𝑡 𝐼𝑚𝑎𝑔𝑒

𝑓𝑟𝑜𝑚 𝑝𝑦𝑙𝑎𝑏 𝑖𝑚𝑝𝑜𝑟𝑡 ∗
#𝒓𝒆𝒂𝒅 𝒊𝒎𝒂𝒈𝒆 𝒕𝒐 𝒂𝒓𝒓𝒂𝒚 𝒂𝒏𝒅 𝒄𝒐𝒏𝒗𝒆𝒓𝒕 𝒕𝒐 𝒈𝒓𝒂𝒚𝒔𝒄𝒂𝒍𝒆
𝐼𝑚 = 𝑎𝑟𝑟𝑎𝑦(𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(‘𝑖𝑚𝑎𝑔𝑒𝑠/𝑒𝑚𝑝𝑖𝑟𝑒. 𝑗𝑝𝑔’). 𝑐𝑜𝑛𝑣𝑒𝑟𝑡(‘𝐿’)
#𝒄𝒓𝒆𝒂𝒕𝒆 𝒂 𝒏𝒆𝒘 𝒇𝒊𝒈𝒖𝒓𝒆
𝑓𝑖𝑔𝑢𝑟𝑒()
#𝒅𝒐𝒏’𝒕 𝒖𝒔𝒆 𝒄𝒐𝒍𝒐𝒓𝒔
𝑔𝑟𝑎𝑦()
#𝒔𝒉𝒐𝒘 𝒄𝒐𝒏𝒕𝒐𝒖𝒓𝒔 𝒘𝒊𝒕𝒉 𝒐𝒓𝒊𝒈𝒊𝒏 𝒖𝒑𝒑𝒆𝒓 𝒍𝒆𝒇𝒕 𝒄𝒐𝒓𝒏𝒆𝒓
𝑐𝑜𝑛𝑡𝑜𝑢𝑟(𝑖𝑚, 𝑜𝑟𝑖𝑔𝑖𝑛 = ’𝑖𝑚𝑎𝑔𝑒’)
𝑎𝑥𝑖𝑠(‘𝑒𝑞𝑢𝑎𝑙’)
𝑎𝑥𝑖𝑠(‘𝑜𝑓𝑓’)

Untuk membuat citra histogram, maka sebelumnya citra RGB harus dikonversi ke format grayscale
dengan fungsi convert ( ). Untuk menjadikan ke bentuk histogram dapat diganakan fungsi hist( )

𝑓𝑖𝑔𝑢𝑟𝑒()
ℎ𝑖𝑠𝑡(𝑖𝑚. 𝑓𝑙𝑎𝑡𝑡𝑒𝑛(),128)
(array([ 5.00000000e+00, 2.00000000e+00, 6.00000000e+00,
2.00000000e+00, 9.00000000e+00, 2.20000000e+01,
1.90000000e+01, 7.30000000e+01, 9.60000000e+01,
1.42000000e+02, 6.00000000e+01, 1.50000000e+02,
1.54000000e+02, 9.80000000e+01, 9.30000000e+01,
1.78000000e+02, 2.44000000e+02, 1.12000000e+02,
2.42000000e+02, 2.39000000e+02, 2.85000000e+02,
1.28000000e+02, 2.57000000e+02, 3.26000000e+02,
1.42000000e+02, 3.62000000e+02, 3.28000000e+02,
3.90000000e+02, 0.00000000e+00, 4.56000000e+02,
4.89000000e+02, 8.85000000e+02, 3.15000000e+02,
6.56000000e+02, 4.99000000e+02, 2.22000000e+02,
4.30000000e+02, 4.10000000e+02, 4.40000000e+02,
1.96000000e+02, 3.64000000e+02, 3.72000000e+02,
2.11000000e+02, 1.91000000e+02, 3.81000000e+02,
3.56000000e+02, 3.89000000e+02, 1.82000000e+02,
3.71000000e+02, 3.99000000e+02, 2.05000000e+02,
3.82000000e+02, 4.38000000e+02, 4.27000000e+02,
2.12000000e+02, 4.24000000e+02, 1.87000000e+02,
4.14000000e+02, 2.17000000e+02, 4.67000000e+02,
5.30000000e+02, 2.89000000e+02, 5.50000000e+02,
6.69000000e+02, 5.62000000e+02, 2.70000000e+02,
5.16000000e+02, 5.32000000e+02, 2.55000000e+02,
5.20000000e+02, 5.09000000e+02, 2.89000000e+02,
3.06000000e+02, 6.10000000e+02, 5.65000000e+02,
5.45000000e+02, 2.51000000e+02, 4.92000000e+02,
4.11000000e+02, 2.16000000e+02, 3.87000000e+02,
3.77000000e+02, 3.51000000e+02, 1.66000000e+02,
3.45000000e+02, 1.62000000e+02, 3.23000000e+02,
1.37000000e+02, 2.99000000e+02, 2.69000000e+02,
2.49000000e+02, 1.35000000e+02, 2.79000000e+02,
2.64000000e+02, 1.42000000e+02, 2.53000000e+02,
1.92000000e+02, 1.84000000e+02, 9.90000000e+01,
8.70000000e+01, 1.77000000e+02, 1.68000000e+02,
8.60000000e+01, 1.49000000e+02, 1.34000000e+02,
5.60000000e+01, 1.51000000e+02, 1.23000000e+02,
1.33000000e+02, 5.80000000e+01, 1.20000000e+02,
 1.10000000e+02, 6.40000000e+01, 6.80000000e+01,
1.37000000e+02, 1.17000000e+02, 5.40000000e+01,
1.30000000e+02, 1.57000000e+02, 1.39000000e+02,
8.40000000e+01, 2.01000000e+02, 1.85000000e+02,
1.08000000e+02, 2.09000000e+02, 2.29000000e+02,
2.89000000e+02, 4.47860000e+04]), array([ 8. , 9.9296875, 11.859375 , 13.7890625,
15.71875 , 17.6484375, 19.578125 , 21.5078125,
23.4375 , 25.3671875, 27.296875 , 29.2265625,
31.15625 , 33.0859375, 35.015625 , 36.9453125,
38.875 , 40.8046875, 42.734375 , 44.6640625,
46.59375 , 48.5234375, 50.453125 , 52.3828125,
54.3125 , 56.2421875, 58.171875 , 60.1015625,
62.03125 , 63.9609375, 65.890625 , 67.8203125,
69.75 , 71.6796875, 73.609375 , 75.5390625,
77.46875 , 79.3984375, 81.328125 , 83.2578125,
85.1875 , 87.1171875, 89.046875 , 90.9765625,
92.90625 , 94.8359375, 96.765625 , 98.6953125,
100.625 , 102.5546875, 104.484375 , 106.4140625,
108.34375 , 110.2734375, 112.203125 , 114.1328125,
116.0625 , 117.9921875, 119.921875 , 121.8515625,
123.78125 , 125.7109375, 127.640625 , 129.5703125,
131.5 , 133.4296875, 135.359375 , 137.2890625,
139.21875 , 141.1484375, 143.078125 , 145.0078125,
146.9375 , 148.8671875, 150.796875 , 152.7265625,
154.65625 , 156.5859375, 158.515625 , 160.4453125,
162.375 , 164.3046875, 166.234375 , 168.1640625,
170.09375 , 172.0234375, 173.953125 , 175.8828125,
177.8125 , 179.7421875, 181.671875 , 183.6015625,
185.53125 , 187.4609375, 189.390625 , 191.3203125,
193.25 , 195.1796875, 197.109375 , 199.0390625,
200.96875 , 202.8984375, 204.828125 , 206.7578125,
208.6875 , 210.6171875, 212.546875 , 214.4765625,
216.40625 , 218.3359375, 220.265625 , 222.1953125,
224.125 , 226.0546875, 227.984375 , 229.9140625,
231.84375 , 233.7734375, 235.703125 , 237.6328125,
239.5625 , 241.4921875, 243.421875 , 245.3515625,
247.28125 , 249.2109375, 251.140625 , 253.0703125, 255. ]), <a list of 128 Patch objects>)
>
𝑠ℎ𝑜𝑤()
Dikarenakan fungsi hist( ) berisikan array satu dimensi maka, pada fungsi digunakan flatten( ) untuk
menjadikan array dua dimensi ke bentuk array satu dimensi yang diurutkan berdasarkan nilai baris.

INTERACTIVE ANNOTATION
Terkadang user membutuhkan interaksi dengan aplikasi, sebagai contoh dengan penanda titip pada
suatu citra, atau membutuhkan keterangan untuk beberapa data latih. Pylab dengan fungsi sederhana,
ginput( ), dapat memungkinkan user melakukan hal tersebut.
Example :
𝑓𝑟𝑜𝑚 𝑃𝐼𝐿 𝑖𝑚𝑝𝑜𝑟𝑡 𝐼𝑚𝑎𝑔𝑒
𝑓𝑟𝑜𝑚 𝑝𝑦𝑙𝑎𝑏 𝑖𝑚𝑝𝑜𝑟𝑡 ∗

𝑖𝑚 = 𝑎𝑟𝑟𝑎𝑦(𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(′𝐶:\𝑃𝑦𝑡ℎ𝑜𝑛27\𝑦𝑎𝑙𝑒𝑓𝑎𝑐𝑒𝑠\𝑠𝑢𝑏𝑗𝑒𝑐𝑡01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠′))

𝑖𝑚𝑠ℎ𝑜𝑤(𝑖𝑚)
𝑝𝑟𝑖𝑛𝑡 ′𝑃𝑙𝑒𝑎𝑠𝑒 𝑐𝑙𝑖𝑐𝑘 3 𝑝𝑜𝑖𝑛𝑡𝑠′
𝑥 = 𝑔𝑖𝑛𝑝𝑢𝑡(3)
𝑝𝑟𝑖𝑛𝑡 ′𝑦𝑜𝑢 𝑐𝑙𝑖𝑐𝑘𝑒𝑑 ∶ ′, 𝑥
𝑠ℎ𝑜𝑤()

NUMPY
ARRAY IMAGE REPRESENTATION
Array pada numpy merupakan array dengan multi dimensi yang dapat merepresentasikan vektor,
matriks maupun citra. Array sangat mirip dengan daftar (daftar dari daftar) tetapi terbatas untuk
memiliki semua elemen-elemen dari tipe yang sama. Example :
>>> 𝑖𝑚 = 𝑎𝑟𝑟𝑎𝑦(𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(′𝐶:\𝑃𝑦𝑡ℎ𝑜𝑛27\𝑦𝑎𝑙𝑒𝑓𝑎𝑐𝑒𝑠\𝑠𝑢𝑏𝑗𝑒𝑐𝑡01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠′))
>>> 𝑝𝑟𝑖𝑛𝑡 𝑖𝑚. 𝑠ℎ𝑎𝑝𝑒, 𝑖𝑚. 𝑑𝑡𝑦𝑝𝑒
(𝟐𝟒𝟑𝑳, 𝟑𝟐𝟎𝑳) 𝒖𝒊𝒏𝒕𝟖
>>> 𝑖𝑚 = 𝑎𝑟𝑟𝑎𝑦(𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(′𝐶:\𝑃𝑦𝑡ℎ𝑜𝑛27\𝑦𝑎𝑙𝑒𝑓𝑎𝑐𝑒𝑠\𝑠𝑢𝑏𝑗𝑒𝑐𝑡01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠′), ′𝑓′)
>>> 𝑝𝑟𝑖𝑛𝑡 𝑖𝑚. 𝑠ℎ𝑎𝑝𝑒, 𝑖𝑚. 𝑑𝑡𝑦𝑝𝑒
(𝟐𝟒𝟑𝑳, 𝟑𝟐𝟎𝑳) 𝒇𝒍𝒐𝒂𝒕𝟑𝟐

>>> 𝑖𝑚 #melihat isi dari variabel array image im

𝒂𝒓𝒓𝒂𝒚([[ 𝟏𝟑𝟎., 𝟏𝟑𝟎., 𝟏𝟑𝟎. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
 [ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
...,
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟐., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟔𝟖. , 𝟔𝟖. , 𝟔𝟖. , . . . , 𝟔𝟖. , 𝟔𝟖. , 𝟔𝟖. ]], 𝒅𝒕𝒚𝒑𝒆 = 𝒇𝒍𝒐𝒂𝒕𝟑𝟐)
>>> 𝑖𝑚[50: 100,50: 100] #baris 50 – 100, kolom 50 – 100 (tidak termaksud yang ke – 100)
𝒂𝒓𝒓𝒂𝒚([[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟒𝟏., 𝟏𝟖𝟗. ],
...,
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟏𝟏𝟏. , 𝟓𝟑. , 𝟔𝟖. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . . , 𝟕𝟗. , 𝟔𝟏., 𝟏𝟎𝟖. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . . , 𝟔𝟔. , 𝟕𝟗., 𝟏𝟏𝟗. ]], 𝒅𝒕𝒚𝒑𝒆 = 𝒇𝒍𝒐𝒂𝒕𝟑𝟐)
>>> 𝑖𝑚[𝑖]. 𝑚𝑒𝑎𝑛() #rata – rata nilai dari baris i
𝟏𝟕𝟑. 𝟐𝟑𝟏𝟐𝟓
>>> 𝑖𝑚[: 100, : 50]. 𝑠𝑢𝑚() #jumlah nilai dari 100 baris dan 50 kolom pertama
𝟏𝟐𝟔𝟖𝟕𝟓𝟎. 𝟎
>>> 𝑖𝑚[: , −1] #kolom terakhir
𝒂𝒓𝒓𝒂𝒚([ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟎., 𝟐𝟒𝟔., 𝟐𝟓𝟑., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟐., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟑𝟗. ,
𝟐𝟒𝟖., 𝟐𝟓𝟓., 𝟐𝟓𝟎., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟐. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟐., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓.,
𝟐𝟓𝟓. , 𝟔𝟖. ], 𝒅𝒕𝒚𝒑𝒆 = 𝒇𝒍𝒐𝒂𝒕𝟑𝟐)
>>> 𝑖𝑚[−2, : ] #baris kedua terakhir
𝒂𝒓𝒓𝒂𝒚([ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟑𝟕., 𝟐𝟐𝟎., 𝟐𝟎𝟖., 𝟐𝟎𝟑., 𝟐𝟎𝟕., 𝟐𝟐𝟒., 𝟐𝟑𝟖., 𝟐𝟏𝟓. ,
𝟏𝟗𝟒., 𝟏𝟗𝟐., 𝟏𝟖𝟔., 𝟏𝟕𝟔., 𝟏𝟔𝟏., 𝟏𝟓𝟕., 𝟏𝟔𝟒., 𝟏𝟔𝟕., 𝟏𝟔𝟏. ,
𝟏𝟓𝟒., 𝟏𝟓𝟎., 𝟏𝟒𝟓., 𝟏𝟒𝟓., 𝟏𝟑𝟖., 𝟏𝟒𝟐., 𝟏𝟒𝟒., 𝟏𝟒𝟔., 𝟏𝟑𝟖. ,
𝟏𝟑𝟕., 𝟏𝟑𝟎., 𝟏𝟑𝟎., 𝟏𝟐𝟗., 𝟏𝟐𝟖., 𝟏𝟐𝟔., 𝟏𝟐𝟏., 𝟏𝟐𝟐., 𝟏𝟏𝟗. ,
𝟏𝟏𝟖., 𝟏𝟏𝟏., 𝟏𝟏𝟓., 𝟏𝟎𝟖., 𝟏𝟐𝟑., 𝟏𝟐𝟏., 𝟏𝟑𝟓., 𝟏𝟑𝟓., 𝟏𝟒𝟐. ,
𝟏𝟒𝟓., 𝟏𝟒𝟔., 𝟏𝟓𝟐., 𝟏𝟓𝟖., 𝟏𝟔𝟒., 𝟏𝟔𝟒., 𝟏𝟓𝟖., 𝟏𝟓𝟕., 𝟏𝟔𝟏. ,
𝟏𝟔𝟒., 𝟏𝟔𝟏., 𝟏𝟓𝟖., 𝟏𝟓𝟖., 𝟏𝟓𝟔., 𝟏𝟓𝟖., 𝟏𝟓𝟗., 𝟏𝟓𝟑., 𝟏𝟒𝟐. ,
𝟏𝟒𝟐., 𝟏𝟑𝟔., 𝟏𝟐𝟔., 𝟏𝟏𝟗., 𝟏𝟏𝟐., 𝟏𝟎𝟖., 𝟏𝟎𝟒. , 𝟗𝟖. , 𝟗𝟒. ,
𝟖𝟖. , 𝟖𝟔. , 𝟖𝟔. , 𝟖𝟓. , 𝟖𝟐. , 𝟕𝟗. , 𝟕𝟑. , 𝟕𝟐. , 𝟕𝟒. ,
𝟕𝟒. , 𝟕𝟒. , 𝟕𝟒. , 𝟕𝟑. , 𝟕𝟑. , 𝟕𝟐. , 𝟕𝟐. , 𝟕𝟑. , 𝟕𝟏. ,
𝟔𝟗. , 𝟕𝟏. , 𝟕𝟏. , 𝟔𝟗. , 𝟔𝟗. , 𝟔𝟗. , 𝟔𝟕. , 𝟔𝟔. , 𝟔𝟕. ,
𝟔𝟕. , 𝟔𝟒. , 𝟔𝟒. , 𝟔𝟖. , 𝟕𝟏. , 𝟕𝟐. , 𝟕𝟐. , 𝟕𝟑. , 𝟕𝟒. ,
𝟕𝟖. , 𝟕𝟗. , 𝟕𝟖. , 𝟕𝟗. , 𝟖𝟐. , 𝟖𝟔. , 𝟗𝟎. , 𝟗𝟔., 𝟏𝟎𝟏. ,
𝟏𝟎𝟗., 𝟏𝟏𝟒., 𝟏𝟏𝟖., 𝟏𝟐𝟓., 𝟏𝟑𝟎., 𝟏𝟑𝟎., 𝟏𝟑𝟏., 𝟏𝟑𝟑., 𝟏𝟑𝟎. ,
𝟏𝟐𝟓., 𝟏𝟐𝟗., 𝟏𝟐𝟓., 𝟏𝟏𝟖., 𝟏𝟏𝟗., 𝟏𝟏𝟕., 𝟏𝟏𝟒., 𝟏𝟎𝟒., 𝟏𝟎𝟐. ,
𝟏𝟎𝟏., 𝟏𝟎𝟗., 𝟏𝟏𝟔., 𝟏𝟐𝟒., 𝟏𝟑𝟐., 𝟏𝟑𝟐., 𝟏𝟑𝟓., 𝟏𝟑𝟔., 𝟏𝟒𝟕. ,
𝟏𝟓𝟒., 𝟏𝟓𝟑., 𝟏𝟒𝟐., 𝟏𝟑𝟔., 𝟏𝟒𝟒., 𝟏𝟑𝟕., 𝟏𝟑𝟗., 𝟏𝟖𝟓., 𝟐𝟑𝟏. ,
𝟐𝟒𝟖., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟒𝟗., 𝟐𝟓𝟑. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟑𝟖., 𝟐𝟒𝟓. ,
𝟐𝟓𝟐., 𝟐𝟒𝟖., 𝟐𝟒𝟑., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟑., 𝟐𝟒𝟗., 𝟐𝟓𝟐., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟐𝟏., 𝟏𝟗𝟔. ,
𝟐𝟐𝟎., 𝟐𝟒𝟓., 𝟐𝟓𝟑., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟐., 𝟐𝟓𝟐., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟑𝟔., 𝟐𝟑𝟕., 𝟐𝟒𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ], 𝒅𝒕𝒚𝒑𝒆 = 𝒇𝒍𝒐𝒂𝒕𝟑𝟐)
>>> 𝑖𝑚[−2] #baris ke-2 terakhir
𝒂𝒓𝒓𝒂𝒚([ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟑𝟕., 𝟐𝟐𝟎., 𝟐𝟎𝟖., 𝟐𝟎𝟑., 𝟐𝟎𝟕., 𝟐𝟐𝟒., 𝟐𝟑𝟖., 𝟐𝟏𝟓. ,
𝟏𝟗𝟒., 𝟏𝟗𝟐., 𝟏𝟖𝟔., 𝟏𝟕𝟔., 𝟏𝟔𝟏., 𝟏𝟓𝟕., 𝟏𝟔𝟒., 𝟏𝟔𝟕., 𝟏𝟔𝟏. ,
𝟏𝟓𝟒., 𝟏𝟓𝟎., 𝟏𝟒𝟓., 𝟏𝟒𝟓., 𝟏𝟑𝟖., 𝟏𝟒𝟐., 𝟏𝟒𝟒., 𝟏𝟒𝟔., 𝟏𝟑𝟖. ,
𝟏𝟑𝟕., 𝟏𝟑𝟎., 𝟏𝟑𝟎., 𝟏𝟐𝟗., 𝟏𝟐𝟖., 𝟏𝟐𝟔., 𝟏𝟐𝟏., 𝟏𝟐𝟐., 𝟏𝟏𝟗. ,
𝟏𝟏𝟖., 𝟏𝟏𝟏., 𝟏𝟏𝟓., 𝟏𝟎𝟖., 𝟏𝟐𝟑., 𝟏𝟐𝟏., 𝟏𝟑𝟓., 𝟏𝟑𝟓., 𝟏𝟒𝟐. ,
 𝟏𝟒𝟓., 𝟏𝟒𝟔., 𝟏𝟓𝟐., 𝟏𝟓𝟖., 𝟏𝟔𝟒., 𝟏𝟔𝟒., 𝟏𝟓𝟖., 𝟏𝟓𝟕., 𝟏𝟔𝟏. ,
𝟏𝟔𝟒., 𝟏𝟔𝟏., 𝟏𝟓𝟖., 𝟏𝟓𝟖., 𝟏𝟓𝟔., 𝟏𝟓𝟖., 𝟏𝟓𝟗., 𝟏𝟓𝟑., 𝟏𝟒𝟐. ,
𝟏𝟒𝟐., 𝟏𝟑𝟔., 𝟏𝟐𝟔., 𝟏𝟏𝟗., 𝟏𝟏𝟐., 𝟏𝟎𝟖., 𝟏𝟎𝟒. , 𝟗𝟖. , 𝟗𝟒. ,
𝟖𝟖. , 𝟖𝟔. , 𝟖𝟔. , 𝟖𝟓. , 𝟖𝟐. , 𝟕𝟗. , 𝟕𝟑. , 𝟕𝟐. , 𝟕𝟒. ,
𝟕𝟒. , 𝟕𝟒. , 𝟕𝟒. , 𝟕𝟑. , 𝟕𝟑. , 𝟕𝟐. , 𝟕𝟐. , 𝟕𝟑. , 𝟕𝟏. ,
𝟔𝟗. , 𝟕𝟏. , 𝟕𝟏. , 𝟔𝟗. , 𝟔𝟗. , 𝟔𝟗. , 𝟔𝟕. , 𝟔𝟔. , 𝟔𝟕. ,
𝟔𝟕. , 𝟔𝟒. , 𝟔𝟒. , 𝟔𝟖. , 𝟕𝟏. , 𝟕𝟐. , 𝟕𝟐. , 𝟕𝟑. , 𝟕𝟒. ,
𝟕𝟖. , 𝟕𝟗. , 𝟕𝟖. , 𝟕𝟗. , 𝟖𝟐. , 𝟖𝟔. , 𝟗𝟎. , 𝟗𝟔., 𝟏𝟎𝟏. ,
𝟏𝟎𝟗., 𝟏𝟏𝟒., 𝟏𝟏𝟖., 𝟏𝟐𝟓., 𝟏𝟑𝟎., 𝟏𝟑𝟎., 𝟏𝟑𝟏., 𝟏𝟑𝟑., 𝟏𝟑𝟎. ,
𝟏𝟐𝟓., 𝟏𝟐𝟗., 𝟏𝟐𝟓., 𝟏𝟏𝟖., 𝟏𝟏𝟗., 𝟏𝟏𝟕., 𝟏𝟏𝟒., 𝟏𝟎𝟒., 𝟏𝟎𝟐. ,
𝟏𝟎𝟏., 𝟏𝟎𝟗., 𝟏𝟏𝟔., 𝟏𝟐𝟒., 𝟏𝟑𝟐., 𝟏𝟑𝟐., 𝟏𝟑𝟓., 𝟏𝟑𝟔., 𝟏𝟒𝟕. ,
𝟏𝟓𝟒., 𝟏𝟓𝟑., 𝟏𝟒𝟐., 𝟏𝟑𝟔., 𝟏𝟒𝟒., 𝟏𝟑𝟕., 𝟏𝟑𝟗., 𝟏𝟖𝟓., 𝟐𝟑𝟏. ,
𝟐𝟒𝟖., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟒𝟗., 𝟐𝟓𝟑. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟑𝟖., 𝟐𝟒𝟓. ,
𝟐𝟓𝟐., 𝟐𝟒𝟖., 𝟐𝟒𝟑., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟑., 𝟐𝟒𝟗., 𝟐𝟓𝟐., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟐𝟏., 𝟏𝟗𝟔. ,
𝟐𝟐𝟎., 𝟐𝟒𝟓., 𝟐𝟓𝟑., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟐., 𝟐𝟓𝟐., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟑𝟔., 𝟐𝟑𝟕., 𝟐𝟒𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ,
𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ], 𝒅𝒕𝒚𝒑𝒆 = 𝒇𝒍𝒐𝒂𝒕𝟑𝟐)
>>> 𝑖 = 50
>>> 𝑗 = 100
>>> 𝑖𝑚[𝑖, : ] = 𝑖𝑚[𝑗, : ] #menentukan nilai dari baris I berdasarkan nilai dari baris j
>>> 𝑖𝑚[: , 𝑖] = 100 #menentukan semua nilai pada kolom I ke 100
>>> 𝑖𝑚
𝒂𝒓𝒓𝒂𝒚([[ 𝟏𝟑𝟎., 𝟏𝟑𝟎., 𝟏𝟑𝟎. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
...,
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟐., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. , . . ., 𝟐𝟓𝟓., 𝟐𝟓𝟓., 𝟐𝟓𝟓. ],
[ 𝟔𝟖. , 𝟔𝟖. , 𝟔𝟖. , . . . , 𝟔𝟖. , 𝟔𝟖. , 𝟔𝟖. ]], 𝒅𝒕𝒚𝒑𝒆 = 𝒇𝒍𝒐𝒂𝒕𝟑𝟐)

GRAYLEVEL TRANSFORMS
Setelah membaca citra ke bentuk array numpy, dapat dilakukan beberapa operasi matematika yang
dinginkan. Contoh sederhana dari transformasi graylevel citra. Menggunakan beberapa fungsi f dengan
interval 0 … 255 (atau 0 … 1) . example :
>>> 𝑓𝑟𝑜𝑚 𝑃𝐼𝐿 𝑖𝑚𝑝𝑜𝑟𝑡 𝐼𝑚𝑎𝑔𝑒
>>> 𝑓𝑟𝑜𝑚 𝑛𝑢𝑚𝑝𝑦 𝑖𝑚𝑝𝑜𝑟𝑡 ∗
>>> 𝑖𝑚 = 𝑎𝑟𝑟𝑎𝑦(𝐼𝑚𝑎𝑔𝑒. 𝑜𝑝𝑒𝑛(′𝐶:\𝑃𝑦𝑡ℎ𝑜𝑛27\𝑦𝑎𝑙𝑒𝑓𝑎𝑐𝑒𝑠\𝑠𝑢𝑏𝑗𝑒𝑐𝑡01. 𝑔𝑙𝑎𝑠𝑠𝑒𝑠′))
>>> 𝑖𝑚2 = 255 − 𝑖𝑚 #invert image
>>> 𝑖𝑚3 = (100.0/255) ∗ 𝑖𝑚 + 100 #clamp to interval 100 … 200
>>> 𝑖𝑚4 = 255.0 ∗ (𝑖𝑚/255.0) ∗∗ 2 #squared
>>> 𝑖𝑚𝑠ℎ𝑜𝑤(𝑖𝑚2)
< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒊𝒎𝒂𝒈𝒆. 𝑨𝒙𝒆𝒔𝑰𝒎𝒂𝒈𝒆 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟔𝟏𝟖𝟏𝑬𝟒𝟖 >
>>> 𝑠ℎ𝑜𝑤()
>>> 𝑖𝑚𝑠ℎ𝑜𝑤(𝑖𝑚3)
< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒊𝒎𝒂𝒈𝒆. 𝑨𝒙𝒆𝒔𝑰𝒎𝒂𝒈𝒆 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟔𝟒𝑪𝟕𝟕𝟏𝟎 >
>>> 𝑠ℎ𝑜𝑤()
>>> 𝑖𝑚𝑠ℎ𝑜𝑤(𝑖𝑚4)
< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒊𝒎𝒂𝒈𝒆. 𝑨𝒙𝒆𝒔𝑰𝒎𝒂𝒈𝒆 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟕𝟓𝟎𝟗𝟐𝟒𝟎 >
>>> 𝑠ℎ𝑜𝑤()

Pada contoh pertama invert citra graylevels, contoh ketika mengaplikasikan fungsi quadratic.
Untuk melakukan mengecekkan nilai minimum dan maximum setiap citra dapat menggunakan :
>>> 𝑝𝑟𝑖𝑛𝑡 𝑖𝑛𝑡(𝑖𝑚. 𝑚𝑖𝑛()), 𝑖𝑛𝑡(𝑖𝑚. 𝑚𝑎𝑥())
𝟖 𝟐𝟓𝟓
>>> 𝑝𝑟𝑖𝑛𝑡 𝑖𝑛𝑡(𝑖𝑚2. 𝑚𝑖𝑛()), 𝑖𝑛𝑡(𝑖𝑚2. 𝑚𝑎𝑥())
𝟎 𝟐𝟒𝟕
>>> 𝑝𝑟𝑖𝑛𝑡 𝑖𝑛𝑡(𝑖𝑚3. 𝑚𝑖𝑛()), 𝑖𝑛𝑡(𝑖𝑚3. 𝑚𝑎𝑥())
𝟏𝟎𝟑 𝟐𝟎𝟎
>>> 𝑝𝑟𝑖𝑛𝑡 𝑖𝑛𝑡(𝑖𝑚4. 𝑚𝑖𝑛()), 𝑖𝑛𝑡(𝑖𝑚4. 𝑚𝑎𝑥())
𝟎 𝟐𝟓𝟓

Untuk melakukan transformasi array( ) dapat dilakukan menggunakan fungsi PIL fromarray( ), sebagai
berikut :
>>> 𝑝𝑖𝑙_𝑖𝑚 = 𝐼𝑚𝑎𝑔𝑒. 𝑓𝑟𝑜𝑚𝑎𝑟𝑟𝑎𝑦(𝑖𝑚)
>>> 𝑖𝑚𝑠ℎ𝑜𝑤(𝑝𝑖𝑙_𝑖𝑚)
< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒊𝒎𝒂𝒈𝒆. 𝑨𝒙𝒆𝒔𝑰𝒎𝒂𝒈𝒆 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟕𝟖𝟒𝟔𝑫𝑨𝟎 >
>>> 𝑠ℎ𝑜𝑤()

untuk mengubah tipe data image dari “uint8” ke bentuk type data lainnya, seperti pada im3 atau im4,
membutuhkan konversi balik sebelum membuat PIL image.
>>> 𝑝𝑖𝑙_𝑖𝑚 = 𝐼𝑚𝑎𝑔𝑒. 𝑓𝑟𝑜𝑚𝑎𝑟𝑟𝑎𝑦(𝑢𝑖𝑛𝑡8(𝑖𝑚))
>>> 𝑖𝑚𝑠ℎ𝑜𝑤(𝑝𝑖𝑙_𝑖𝑚)
< 𝒎𝒂𝒕𝒑𝒍𝒐𝒕𝒍𝒊𝒃. 𝒊𝒎𝒂𝒈𝒆. 𝑨𝒙𝒆𝒔𝑰𝒎𝒂𝒈𝒆 𝒐𝒃𝒋𝒆𝒄𝒕 𝒂𝒕 𝟎𝒙𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟎𝟕𝟗𝟕𝟒𝟒𝑨𝟖 >
>>> 𝑠ℎ𝑜𝑤()

IMAGE RESIZING
>>> 𝑑𝑒𝑓 𝑖𝑚𝑟𝑒𝑠𝑖𝑧𝑒(𝑖𝑚, 𝑠𝑧):
#resize an image array using PIL
𝑝𝑖𝑙_𝑖𝑚 = 𝐼𝑚𝑎𝑔𝑒. 𝑓𝑟𝑜𝑚𝑎𝑟𝑟𝑎𝑦(𝑢𝑖𝑛𝑡8(𝑖𝑚))
𝑟𝑒𝑡𝑢𝑟𝑛 𝑎𝑟𝑟𝑎𝑦(𝑝𝑖𝑙_𝑖𝑚. 𝑟𝑒𝑠𝑖𝑧𝑒(𝑠𝑧))

HISTOGRAM EQUALIZATION
>>> 𝑑𝑒𝑓 ℎ𝑖𝑠𝑡𝑒𝑞(𝑖𝑚, 𝑛𝑏𝑟_𝑏𝑖𝑛𝑠 = 256):
"""𝐻𝑖𝑠𝑡𝑜𝑔𝑟𝑎𝑚 𝑒𝑞𝑢𝑎𝑙𝑖𝑧𝑎𝑡𝑖𝑜𝑛 𝑜𝑓 𝑎 𝑔𝑟𝑎𝑦𝑠𝑐𝑎𝑙𝑒 𝑖𝑚𝑎𝑔𝑒. """
#𝑔𝑒𝑡 𝑖𝑚𝑎𝑔𝑒 ℎ𝑖𝑠𝑡𝑜𝑔𝑟𝑎𝑚
𝑖𝑚ℎ𝑖𝑠𝑡, 𝑏𝑖𝑛𝑠 = ℎ𝑖𝑠𝑡𝑜𝑔𝑟𝑎𝑚(𝑖𝑚. 𝑓𝑙𝑎𝑡𝑡𝑒𝑛(), 𝑛𝑏𝑟_𝑏𝑖𝑛𝑠, 𝑛𝑜𝑟𝑚𝑒𝑑 = 𝑇𝑟𝑢𝑒)
𝑐𝑑𝑓 = 𝑖𝑚ℎ𝑖𝑠𝑡. 𝑐𝑢𝑚𝑠𝑢𝑚() #𝑐𝑢𝑚𝑢𝑙𝑎𝑡𝑖𝑣𝑒 𝑑𝑖𝑠𝑡𝑟𝑖𝑏𝑢𝑡𝑖𝑜𝑛 𝑓𝑢𝑛𝑐𝑡𝑖𝑜𝑛
𝑐𝑑𝑓 = 255 ∗ 𝑐𝑑𝑓/𝑐𝑑𝑓[−1] #𝑛𝑜𝑟𝑚𝑎𝑙𝑖𝑧𝑒

#𝑢𝑠𝑒 𝑙𝑖𝑛𝑒𝑎𝑟 𝑖𝑛𝑡𝑒𝑟𝑝𝑜𝑙𝑎𝑡𝑖𝑜𝑛 𝑜𝑓 𝑐𝑑𝑓 𝑡𝑜 𝑓𝑖𝑛𝑑 𝑛𝑒𝑤 𝑝𝑖𝑥𝑒𝑙 𝑣𝑎𝑙𝑢𝑒

 𝑖𝑚2 = 𝑖𝑛𝑡𝑒𝑟𝑝(𝑖𝑚. 𝑓𝑙𝑎𝑡𝑡𝑒𝑛(). 𝑏𝑖𝑛𝑠[: −1], 𝑐𝑑𝑓)
𝑟𝑒𝑡𝑢𝑟𝑛 𝑖𝑚2. 𝑟𝑒𝑠ℎ𝑎𝑝𝑒(𝑖𝑚. 𝑠ℎ𝑎𝑝𝑒), 𝑐𝑑𝑓

EXAMPLE :
from PIL import Image
from numpy import *
from pylab import *

def f():
print(number)

def g():
print(number)
numbers=4

def h():
global number
print(number)
number=3

number=5
f()
g()
h()
f()

OUTPUT :
5
5
5
3

EXAMPLE :
from PIL import Image
from numpy import *
from pylab import *

x=-3
if x<0:
print('Negative change to zero')
x = 0
elif x==0:
print('Zero')
elif x==1:
print('Single')
else:
print('None')

for item in[12,'test',0.1+1.2j]:

print(item)

print('frank kharisma')

for i in range(3,10,2):
 print(i)

print('cathrine nicea')
for number in range (10):
if number in (3,4,7,9):
break
else:
continue
else:
pass

print('achiera brielle')
i=0
rangelist=range(10)
while rangelist[i]<4:
print(rangelist[i])
i+=1

OUTPUT :
Negative change to zero
12
test
(0.1+1.2j)
frank kharisma
3
5
7
9
cathrine nicea
achiera brielle
0
1
2
3

EXAMPLE :
print('bagian 1:')
def passing_example(a_list, an_int=2, a_string="A default string"):
a_list.append("A new item")
an_int=4
return a_list, an_int, a_string

passing_example([1,2,3],10)

print('bagian 2:')
def f(x):
return x%2!=0 and x%3!=0

for element in filter(f, range(2,25)):

print(element)
print()

print('bagian 3:')
def g(x):
return x**3
for element in map(g,[2,4,6,8]):
print(element)
print()

funcvar=lambda x:x+1
print('0')

print('bagian 4:')
def vargtest(a, b, *nkw, **kw):
print('a is: ',a)
print('b is: ',b)
for each_nkw in nkw:
print('additional non-keyword arg:',each_nkw)
for each_kw in kw:
print('additional keyword arg:"%s":%s' %(each_kw, kw[each_kw]))

vargtest(1,2,3,4,x=2,y=3)
vargtest(1,2,*(3,4),**{'x':2,'y':3})

OUTPUT:
5
7
11
13
17
19
23
()
bagian 3:
8
()
64
()
216
()
512
()
0
bagian 4:
('a is: ', 1)
('b is: ', 2)
('additional non-keyword arg:', 3)
('additional non-keyword arg:', 4)
additional keyword arg:"y":3
additional keyword arg:"x":2
('a is: ', 1)
('b is: ', 2)
('additional non-keyword arg:', 3)
('additional non-keyword arg:', 4)
additional keyword arg:"y":3
additional keyword arg:"x":2
EXAMPLE :
class Dog:
counter=0
def __init__(self,name):
self.name=name
Dog.counter+=1
def bark(self):
return self.name+'('+str(Dog.counter)+') wouaf'

dog1=Dog('Lassie')
dog2=Dog('Rex')
print(dog1.bark())
print(dog2.bark())

OUTPUT :
Lassie(2) wouaf
Rex(2) wouaf

NUMPY ARRAY
Help on built-in function array in module numpy.core.multiarray:

array(...)
array(object, dtype=None, copy=True, order='K', subok=False,
ndmin=0)

Create an array.

Parameters
----------
object : array_like
An array, any object exposing the array interface, an object
whose
__array__ method returns an array, or any (nested) sequence.
dtype : data-type, optional
The desired data-type for the array. If not given, then the
type will
be determined as the minimum type required to hold the objects
in the
sequence. This argument can only be used to 'upcast' the
array. For
downcasting, use the .astype(t) method.
copy : bool, optional
If true (default), then the object is copied. Otherwise, a
copy will
only be made if __array__ returns a copy, if obj is a nested
sequence,
or if a copy is needed to satisfy any of the other
requirements
(`dtype`, `order`, etc.).
order : {'K', 'A', 'C', 'F'}, optional
Specify the memory layout of the array. If object is not an
array, the
 newly created array will be in C order (row major) unless 'F'
is
specified, in which case it will be in Fortran order (column
major).
If object is an array the following holds.

===== =========
===================================================
order no copy copy=True
===== =========
===================================================
'K' unchanged F & C order preserved, otherwise most similar
order
'A' unchanged F order if input is F and not C, otherwise C
order
'C' C order C order
'F' F order F order
===== =========
===================================================

When ``copy=False`` and a copy is made for other reasons, the

result is
the same as if ``copy=True``, with some exceptions for `A`,
see the
Notes section. The default order is 'K'.
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned array will be forced to be a base-class array
(default).
ndmin : int, optional
Specifies the minimum number of dimensions that the resulting
array should have. Ones will be pre-pended to the shape as
needed to meet this requirement.

Returns
-------
out : ndarray
An array object satisfying the specified requirements.

See Also
--------
empty, empty_like, zeros, zeros_like, ones, ones_like, full,
full_like

Notes
-----
When order is 'A' and `object` is an array in neither 'C' nor 'F'
order,
and a copy is forced by a change in dtype, then the order of the
result is
not necessarily 'C' as expected. This is likely a bug.
 Examples
--------
>>> np.array([1, 2, 3])
array([1, 2, 3])

Upcasting:

>>> np.array([1, 2, 3.0])

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

More than one dimension:

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

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

Minimum dimensions 2:

>>> np.array([1, 2, 3], ndmin=2)

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

Type provided:

>>> np.array([1, 2, 3], dtype=complex)

array([ 1.+0.j, 2.+0.j, 3.+0.j])

Data-type consisting of more than one element:

>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
>>> x['a']
array([1, 3])

Creating an array from sub-classes:

>>> np.array(np.mat('1 2; 3 4'))

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

>>> np.array(np.mat('1 2; 3 4'), subok=True)

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

EXAMPLE :
>>> import numpy as np
>>> A=np.array([1,2,3])
>>> B=np.array([[4,5,6]])
>>> A.shape
(3L,)
>>> B.shape
(1L, 3L)
>>> A
array([1, 2, 3])
>>> B
array([[4, 5, 6]])
>>> C=A+B
>>> C
array([[5, 7, 9]]) #menjumlahkan array A dan B
>>> type(C)
<type 'numpy.ndarray'> #type variable
>>> np.ndim(C)
2
>>> np.vstack([A,B])
array([[1, 2, 3],
[4, 5, 6]]) #data array ditampilkan secara vertikal
>>> np.hstack([np.matrix(A),B])
matrix([[1, 2, 3, 4, 5, 6]]) #data array ditampilkan secara horizontal
>>> C.tolist()
[[5, 7, 9]] #data pada variable C array
>>> C.tolist()[0]
[5, 7, 9] #data pada variable C array tanpa menggunakan tanda ( )
>>> np.array(C).reshape(-1,)
array([5, 7, 9])
>>> A=np.array([A])
>>> A
array([[1, 2, 3]])
>>> np.hstack([A,B])
array([[1, 2, 3, 4, 5, 6]]) #menggabungkan array A dan B secara
horizontal
>>> D=np.array([[1,2],[3,4]])
>>> D
array([[1, 2],
[3, 4]]) #data array D
>>> A[0,-1]
3
>>> D[1,0]
3
>>> D[:,1]
array([2, 4])
>>> D[1,:]
array([3, 4])
>>> F=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
>>> F
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
>>> F[1::2,1:3]
array([[ 6, 7],
[14, 15]])
>>> np.ix_([1,2,3],[0,2])
(array([[1],
 [2],
[3]]), array([[0, 2]]))
>>> F[np.ix_([1,2,3],[0,2])]
array([[ 5, 7],
[ 9, 11],
[13, 15]])
>>> np.r_[0:4,7:9]
array([0, 1, 2, 3, 7, 8])
>>> np.r_[:4,0]
array([0, 1, 2, 3, 0])
>>> F[::-1,:]
array([[13, 14, 15, 16],
[ 9, 10, 11, 12],
[ 5, 6, 7, 8],
[ 1, 2, 3, 4]])

MATLAB Numpy.array Numpy.matrix Ket

ndims(a) ndim(a) atau a.ndim Dimensi
variable matriks
a
size(a) shape(a) atau a.shape Ukuran dari
matriks a
size(a,n) a.shape[n-1] Jumlah elemen
pada n dimensi
array a
[1 2 3; 4 5 array([[1.,2.,3.],[ mat([[1.,2.,3.], Matriks 2 x 3
6] 4.,5.,6.]]) [4.,5.,6.]])
atau mat(“1 2 3;
4 5 6”)
[a b; c d] vstack([hstack([a,b bmat(‘a b; c d’) Membuat matriks
]),hstack([c,d])]) berisikan huruf
(a, b, c, d)
a(end) a[-1] a[:,-1][0,0] Mengakses elemen
terakhir 1 x n
matriks a
a(2,5) a[1,4] Mengakses elemen
pada baris
kedua, kolom ke-
5
a(2,:) a[1] atau a[1,:] Keseluruhan
elemen pada
baris kedua
matriks a
a(1:5,:) a[0:5] atau a[:5] atau a[0:5,:] Baris kelima
pertama matriks
a
a(end- a[-5:] Baris terakhir
4:end,:) matriks a
a(1:3,5:9) a[0:3][:,4:9] Dari baris
pertama s.d ke-3
dan kolom ke-5
s.d ke-9
a([2,4,5],[1 a[ix_([1,3,4],[0,2])] Baris 2, 4, dan
,3]) 5 dan kolom 1
dan 3
a(3:2:21,:) a[2:21:2,:] Setiap kolom
lain dari a,
dimulai dengan
baris ke – 3 s.d
ke-21
a(1:2:end,:) a[::2,:] Setiap baris
dimulai dengan
baris pertama
pada matriks a
a(end:- a[::-1,:]
1:1,:) atau
flipud(a)
a([1:end a[r_[:len(a),0]] Copy elemen dari
1],:) baris pertama
hingga akhir

EXAMPLE :
>>> F
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]]) #elemen array F
>>> G=np.array([[1,4,7],[3,1,2],[9,5,6],[8,4,1]])
>>> G
array([[1, 4, 7],
[3, 1, 2],
[9, 5, 6],
[8, 4, 1]]) #elemen array G
>>> G.transpose()
array([[1, 3, 9, 8],
[4, 1, 5, 4],
[7, 2, 6, 1]]) #transpose array G
>>> G
array([[1, 4, 7],
[3, 1, 2],
[9, 5, 6],
[8, 4, 1]]) #perintah tersebut tidak mengubah isi elemen secara
permanen
>>> np.dot(F,G)
array([[ 66, 37, 33],
[150, 93, 97],
[234, 149, 161],
 [318, 205, 225]]) #perkalian array F dan G
>>> F*G
Traceback (most recent call last):
File "<pyshell#41>", line 1, in <module>
F*G
ValueError: operands could not be broadcast together with shapes (4,4)
(4,3) #perkalian antara 2 array berbeda tidak bisa dilakukan
>>> F*F
array([[ 1, 4, 9, 16],
[ 25, 36, 49, 64],
[ 81, 100, 121, 144],
[169, 196, 225, 256]]) #array F pangkat 2
>>> F=np.matrix(F)
>>> F
matrix([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]]) #konversi array F ke bentuk matriks F
>>> G=np.matrix(G)
>>> G
matrix([[1, 4, 7],
[3, 1, 2],
[9, 5, 6],
[8, 4, 1]]) #konversi array G ke bentuk matriks G
>>> F*G
matrix([[ 66, 37, 33],
[150, 93, 97],
[234, 149, 161],
[318, 205, 225]]) #perkalian matriks F dan G
>>> F*F
matrix([[ 90, 100, 110, 120],
[202, 228, 254, 280],
[314, 356, 398, 440],
[426, 484, 542, 600]]) #perkalian matriks F dan F
>>> np.multiply(F,F)
matrix([[ 1, 4, 9, 16],
[ 25, 36, 49, 64],
[ 81, 100, 121, 144],
[169, 196, 225, 256]]) #matriks F pangkat 3
>>> G=F[:,::-1]
>>> G
matrix([[ 4, 3, 2, 1],
[ 8, 7, 6, 5],
[12, 11, 10, 9],
[16, 15, 14, 13]]) #mengcopy elemen F ke matriks G dimulai
dari elemen terakhir setiap baris
>>> X=G/F
>>> X
matrix([[4, 1, 0, 0],
[1, 1, 0, 0],
[1, 1, 0, 0],
 [1, 1, 0, 0]]) #matriks X merupakan hasil bagi matriks G
terhadap matriks F
>>> F**2
matrix([[ 90, 100, 110, 120],
[202, 228, 254, 280],
[314, 356, 398, 440],
[426, 484, 542, 600]]) #perkalian matriks F dan F
>>> F**3
matrix([[ 3140, 3560, 3980, 4400],
[ 7268, 8232, 9196, 10160],
[11396, 12904, 14412, 15920],
[15524, 17576, 19628, 21680]]) #Perkalian matriks F, F dan F
>>> np.power(F,3)
matrix([[ 1, 8, 27, 64],
[ 125, 216, 343, 512],
[ 729, 1000, 1331, 1728],
[2197, 2744, 3375, 4096]]) #matriks F pangkat 3
>>> F>4
matrix([[False, False, False, False],
[ True, True, True, True],
[ True, True, True, True],
[ True, True, True, True]], dtype=bool)
#jika elemen matriks bernilai >4 maka bernilai true, else
bernilai false
>>> np.nonzero(F>4)
(array([1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3], dtype=int64),
array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))

>>> F[F>4]
matrix([[ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]])
#menampilkan elemen matriks F lebih besar 4
>>> A[:]=3
>>> E=np.ones
>>> E=np.ones((2,3))
>>> E
array([[ 1., 1., 1.],
[ 1., 1., 1.]]) #elemen matriks E berisikan angka 1
>>> H=F #menyamakan isi elemen matriks H dan F, sehingga apabila
salah satu elemen berubah maka elemen pada matriks lainnya juga akan
berubah
>>> F
matrix([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
>>> H[1,1]=-1
>>> F
matrix([[ 1, 2, 3, 4],
[ 5, -1, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
>>> H=F.copy() #mencopy isi elemen F pada matriks H, jika elemen
matriks H berubah maka tidak akan mempengaruhi isi elemen matriks F
>>> H
matrix([[ 1, 2, 3, 4],
[ 5, -1, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
>>> H[1,1]=-2
>>> F
matrix([[ 1, 2, 3, 4],
[ 5, -1, 7, 8],
[ 9, 10, 11, 12],
[13, 14, 15, 16]])
>>> I=F[1:3,:]
>>> I[:]=3
>>> I=F[1:3,:]
>>> I
matrix([[3, 3, 3, 3],
[3, 3, 3, 3]])
>>> F
matrix([[ 1, 2, 3, 4],
[ 3, 3, 3, 3],
[ 3, 3, 3, 3],
[13, 14, 15, 16]])
>>> I=F[:,1:3].copy()
>>> I
matrix([[ 2, 3],
[ 3, 3],
[ 3, 3],
[14, 15]])
>>> I[:]=2
>>> F
matrix([[ 1, 2, 3, 4],
[ 3, 3, 3, 3],
[ 3, 3, 3, 3],
[13, 14, 15, 16]])
>>> F.flatten()
matrix([[ 1, 2, 3, 4, 3, 3, 3, 3, 3, 3, 3, 3, 13, 14, 15,
16]]) #menampilkan isi matriks F dalam bentuk 1 baris

MATLAB Numpy.array Numpy.matrix Ket

a.’ a.transpose() atau a.T Transpose
matriks a
a’ a.conj().transpose a.H Konjungsi
() atau a.conj().T transpose
matriks a
a*b dot(a,b) a*b Perkalian
matriks a dan b
a.*b a*b Multiply(a,b) Perkalian elemen
matriks a dan b
a./b a/b Pembagian pada
elemen matriks a
dan b
a.^3 a**3 Power(a,3) Matriks a
pangkat 3
(a>0.5) (a>0.5) Elemen matriks
yang bernilai >
0.5
Find(a>0.5) Nonzero(a>0.5) Menemukan elemen
matriks a >0.5
a(:,find(v>0 a[:,nonzero(v>0.5 a[:,nonzero(v.a>0 Ekstraksi kolom
.5) )[0]] .5)[0]] dimana vektor v
>0.5
a(:,find(v>0 a[:,v.T>0.5] a[:,v.T>0.5] Ekstaksi kolom
.5)) dimana vektor
v>0.5
a(a<0.5)=0 a[a<0.5]=0 Elemen bernilai
<0.5 dijadikan 0
a.*(a>0.5) a*(a>0.5) Mat(a.a Elemen bernilai
*(a>0.5).a) <0.5 dijadikan 0
a(:)=3 a[:]=3 Semua elemen
pada matriks a
diubah menjadi
angka 3
y=x y=x.copy() Mengcopy isi
elemen matriks x
ke y
y=x(2,:) y=x[1,:].copy()
y=x(:) y=x.flatten(1)

EXAMPLE :
>>> np.r_[:11]
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) #menampilkan array
dengan range 0 - 10
>>> np.r_['c',:11]
matrix([[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5],
[ 6],
[ 7],
[ 8],
[ 9],
[10]]) #menampilkan array dengan range 0 – 10 dan diurutkan
secara horizontal
>>> np.r_['r',:11]
matrix([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]) #menampilkan
array dengan range 0 – 10 dan diurutkan secara vertical

>>> np.zeros((3,4))
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]]) #menampilkan array elemen nol dengan 3
baris dan 4 kolom

>>> np.ones((3,4))
array([[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.],
[ 1., 1., 1., 1.]]) #menampilkan array elemen 1 dengan 3
baris dan 4 kolom

>>> np.eye(3)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]]) #menampilkan array elemen 1 secara diagonal
(identitas) dengan 3 baris dan 3 kolom

>>> np.diag([3,4,5])
array([[3, 0, 0],
[0, 4, 0],
[0, 0, 5]]) #menampilkan array elemen 3, 4, 5 secara diagonal

>>> np.random.rand(3,2)
array([[ 0.23458584, 0.24901121],
[ 0.43343077, 0.66511224],
[ 0.61652574, 0.06946595]]) #menampilkan nilai random 0 s.d 1
untuk 3 baris dan 2 kolom

>>> np.random.randn(3,2)
array([[-0.24529733, 0.72041882],
[-1.50920684, -0.18274377],
[-1.82148812, 0.95309485]]) #menampilkan nilai random -1 s.d 1
untuk 3 baris dan 2 kolom

>>> np.random.randint(2,9,(3,2))
array([[5, 8],
[6, 8],
[7, 7]]) #menampilkan nilai random 2 s.d 9 untuk 3 baris dan 2
kolom

>>> F=np.random.randint(2,9,(3,2))
>>> F
array([[4, 5],
[5, 3],
[7, 4]]) #menampilkan nilai variable F array secara random 2
s.d 9 untuk 3 baris dan 2 kolom
>>> F.max(0)
array([7, 5])
>>> F.max(1)
array([5, 5, 7])
>>> F.max()
7
>>> G=np.random.randint(2,9,(3,2))
>>> G
array([[2, 8],
[7, 6],
[8, 6]])
>>> np.maximum(F,G)
array([[4, 8],
[7, 6],
[8, 6]])
>>> np.linalg.norm(F)
11.832159566199232
>>> H=np.random.randint(0,2,(2,3))
>>> H
array([[1, 1, 0],
[1, 0, 1]])
>>> I=np.random.randint(0,2,(2,3))
>>> I
array([[0, 1, 0],
[0, 1, 0]])
>>> np.logical_and(H,I)
array([[False, True, False],
[False, False, False]], dtype=bool)
>>> np.logical_or(H,I)
array([[ True, True, False],
[ True, True, True]], dtype=bool)
>>> H&I
array([[0, 1, 0],
[0, 0, 0]])
>>> H|I
array([[1, 1, 0],
[1, 1, 1]])

EXAMPLE :
>>> import numpy.linalg as linalg
>>> import numpy as np
>>> D=np.array([[1,2],[3,4]))
SyntaxError: invalid syntax
>>> D=np.array([[2,3],[3,4]])
>>> linalg.inv(D)
array([[-4., 3.],
[ 3., -2.]])
>>> D=np.array([[1,2],[3,4]])
>>> linalg.inv(D)
array([[-2. , 1. ],
[ 1.5, -0.5]])
>>> np.dot(D,linalg.inv(D))
array([[ 1.00000000e+00, 1.11022302e-16],
[ 0.00000000e+00, 1.00000000e+00]])
>>> D
array([[1, 2],
[3, 4]])
>>> I=np.random.randint(0,2,(2,3))
>>> I
array([[0, 1, 0],
[1, 1, 0]])
>>> linalg.pinv(I)
array([[ -1.00000000e+00, 1.00000000e+00],
[ 1.00000000e+00, -1.66533454e-16],
[ 0.00000000e+00, 0.00000000e+00]])
>>> np.dot(I,linalg.pinv(I))
array([[ 1.00000000e+00, -1.66533454e-16],
[ -6.66133815e-16, 1.00000000e+00]])
>>> linalg.matrix_rank(I)
2
>>> H=np.random.randint(0,2,(2,3))
>>> H
array([[1, 0, 1],
[0, 0, 1]])
>>> linalg.matrix_rank(H)
2
>>> A=np.array([[1,2],[-2,1]])
>>> B=np.array([[3],[-1]])
>>> linalg.solve(A,B)
array([[ 1.],
[ 1.]])
>>> A=np.random.randint(0,10,(3,2))
>>> A
array([[1, 6],
[1, 0],
[3, 3]])
>>> B=np.random.randint(0,10,(3,1))
>>> B
array([[9],
[3],
[2]])
>>> linalg.lstsq(A,B)
(array([[-0.33333333],
[ 1.44444444]]), array([ 13.33333333]), 2, array([ 7.11839646,
2.30833964]))
>>> J=np.random.randint(0,11,(3,4))
>>> J
array([[ 8, 8, 9, 3],
[10, 3, 1, 6],
[ 3, 3, 5, 6]])
>>> (U,S,V)=linalg.svd(J)
>>> U
array([[ 0.72678412, 0.56234038, -0.39440859],
[ 0.54828698, -0.82084153, -0.16000177],
[ 0.4137224 , 0.09996235, 0.9048985 ]])
>>> S
array([ 19.49393292, 6.81999781, 4.05884333])
>>> V
array([[ 0.64319037, 0.44630815, 0.46978494, 0.40794275],
[-0.4999716 , 0.34253465, 0.69501982, -0.38684088],
[-0.50275181, -0.22680809, 0.20075016, 0.80962836],
[-0.28909369, 0.79500764, -0.50591395, 0.16863798]])
>>> np.dot(U.transpose(),U)
array([[ 1.00000000e+00, 4.85722573e-17, 0.00000000e+00],
[ 4.85722573e-17, 1.00000000e+00, -1.11022302e-16],
[ 0.00000000e+00, -1.11022302e-16, 1.00000000e+00]])
>>> np.dot(V.transpose(),V)
array([[ 1.00000000e+00, 3.05311332e-16, 1.38777878e-16,
-1.94289029e-16],
[ 3.05311332e-16, 1.00000000e+00, -2.77555756e-16,
1.38777878e-16],
[ 1.38777878e-16, -2.77555756e-16, 1.00000000e+00,
1.66533454e-16],
[ -1.94289029e-16, 1.38777878e-16, 1.66533454e-16,
1.00000000e+00]])
>>> D=np.hstack([np.diag(S),np.zeros((3,1))])
>>> D
array([[ 19.49393292, 0. , 0. , 0. ],
[ 0. , 6.81999781, 0. , 0. ],
[ 0. , 0. , 4.05884333, 0. ]])
>>> np.dot(np.dot(U,D),V)
array([[ 8., 8., 9., 3.],
[ 10., 3., 1., 6.],
[ 3., 3., 5., 6.]])
>>> L=np.matrix([[6,-3,-10],[0,2,-2],[2,-1,-5]])
>>> L
matrix([[ 6, -3, -10],
[ 0, 2, -2],
[ 2, -1, -5]])
>>> V,P=linalg.eig(L)
>>> V
array([-2.88089912, 4.24581024, 1.63508888])
>>> P
matrix([[ 0.76017728, 0.95227747, -0.73605421],
[ 0.24634855, -0.20299732, -0.66592894],
[ 0.60120121, 0.22794673, -0.12150244]])
>>> P*np.diag(V)*linalg.inv(P)
matrix([[ 6.00000000e+00, -3.00000000e+00, -1.00000000e+01],
[ 2.55351296e-15, 2.00000000e+00, -2.00000000e+00],
[ 2.00000000e+00, -1.00000000e+00, -5.00000000e+00]])
>>> L0=L.copy()
>>> L1=L.copy()
>>> L0.sort(0)
>>> L0
matrix([[ 0, -3, -10],
[ 2, -1, -5],
[ 6, 2, -2]])
>>> L1.sort(1)
>>> L1
matrix([[-10, -3, 6],
[ -2, 0, 2],
[ -5, -1, 2]])
>>> np.linspace(1,3,4)
array([ 1. , 1.66666667, 2.33333333, 3. ])
>>> np.meshgrid([1,2,4],[2,4,5])
[array([[1, 2, 4],
[1, 2, 4],
[1, 2, 4]]), array([[2, 2, 2],
[4, 4, 4],
[5, 5, 5]])]
>>> np.mgrid[0:9,0:6]
array([[[0, 0, 0, 0, 0, 0],
[1, 1, 1, 1, 1, 1],
[2, 2, 2, 2, 2, 2],
[3, 3, 3, 3, 3, 3],
[4, 4, 4, 4, 4, 4],
[5, 5, 5, 5, 5, 5],
[6, 6, 6, 6, 6, 6],
[7, 7, 7, 7, 7, 7],
[8, 8, 8, 8, 8, 8]],

[[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5]]])
>>> np.ogrid[0:3,0:4]
[array([[0],
[1],
[2]]), array([[0, 1, 2, 3]])]
>>> np.concatenate((L0,L1),0)
matrix([[ 0, -3, -10],
[ 2, -1, -5],
[ 6, 2, -2],
[-10, -3, 6],
[ -2, 0, 2],
[ -5, -1, 2]])
>>> np.concatenate((L0,L1),1)
matrix([[ 0, -3, -10, -10, -3, 6],
[ 2, -1, -5, -2, 0, 2],
 [ 6, 2, -2, -5, -1, 2]])
>>> np.tile(L0,(2,3))
matrix([[ 0, -3, -10, 0, -3, -10, 0, -3, -10],
[ 2, -1, -5, 2, -1, -5, 2, -1, -5],
[ 6, 2, -2, 6, 2, -2, 6, 2, -2],
[ 0, -3, -10, 0, -3, -10, 0, -3, -10],
[ 2, -1, -5, 2, -1, -5, 2, -1, -5],
[ 6, 2, -2, 6, 2, -2, 6, 2, -2]])
>>> F=np.array([[1,2,3]])
>>> F
array([[1, 2, 3]])
>>> F.squeeze()
array([1, 2, 3])
>>> F=np.array([[1],[2],[3]])
>>> F
array([[1],
[2],
[3]])
>>> F.squeeze()
array([1, 2, 3])