Python/Kenjiro995/Matice

Matice

Je dvojrozměrné pole tvaru obdélníka nebo čtverce, mající m řádků, n sloupců. Pro čtvercovou matici tedy platí m = n.

Druhy matic:

• diagonální - které obsahuje nenulové prvky pouze na diagonále.
• trojúhelníkové - má pod diagonálou všechny prvky rovny nule.
• řádkové - má jeden z rozměrů roven 1, tedy tvar 1 * n
• sloupcové - kdy má matice rozměry m * 1

Jak prezentovat matici v kódu

Matici si můžeme představit jako tabulku prvků, pro její reprezentaci můžeme tedy využít dvourozměrné pole.

a = [[1,1,1], [2,3,1]]
b = [[9,9,9], [0,5,1]]
print(a + b)

Výstup:

[[1, 1, 1], [2, 3, 1], [9, 9, 9], [0, 5, 1]]

Občas je třeba matice sčítat nebo násobit, tak jako v matematice. Bohužel obyčejný součet matice ve formě pole je pouze slepí dohromady. Proto je mnohem výhodnější používat modul NumPy, který pracuje s takovýmito typy pole mnohem efektivněji.

Modul NumPy

NumPy je knihovna Pythonu pro numerické výpočty (název znamená Num erical Py thon). Je optimalizován pro rychlost. Používá se hlavně pro zpracování homogenního vícerozměrného pole. Je to základní knihovna pro vědecké výpočty. Má tedy výkonné objekty vícerozměrného pole a integrační nástroje, které jsou užitečné při práci s těmito poli. Je to důležité v téměř každém vědeckém programování v pythonu, které zahrnuje strojové učení, statistiku, bioinformatiku atd. Poskytuje některé opravdu dobré funkce, které jsou velmi dobře napsané a fungují efektivně. Většinou se zaměřuje na provádění matematických operací na sousedních polích.

Zavedení modulu

Základní způsob s plným názvem:

import numpy

a = numpy.array([[1,1,1], [2,3,1]]) #při použití metody plný název "numpy"

print(a)

Výstup:

[[1 1 1]
 [2 3 1]]

Název lze zkrátit změnou pojmenování:

import numpy as np #pojmenovává "as" (jako) np, zvolit lze jakýkoliv náhradní název

a = np.array([[1,1,1], [2,3,1]]) #při použití metody zkrácený název "np"

print(a)

Výstup:

[[1 1 1]
 [2 3 1]]

Součet matic

import numpy as np

a = np.array([[1,1,1], [2,3,1]])
b = np.array([[9,9,9], [0,5,1]])

print(a + b)

Výstup:

[[10 10 10]
 [ 2  8  2]]

Odčítání matic

import numpy as np

a = np.array([[1,1,1], [2,3,1]])
b = np.array([[9,9,9], [0,5,1]])

print(a - b)

Výstup:

[[-8 -8 -8]
 [ 2 -2  0]]

Násobení matic

Násobení po položkách (není pravé maticové násobení):

import numpy as np

a = np.array([[1,1,1], [2,3,1]])
b = np.array([[9,9,9], [0,5,1]])

print(a * b)

Výstup:

[[ 9  9  9]
 [ 0 15  1]]

Pravé maticové násobení (vektorové násobení):

import numpy as np

a = np.array([[1,1,1], [2,3,1], [5,3,6]])
b = np.array([[9,9,9], [0,5,1], [1,2,1]])

print(a @ b)

Výstup:

[[10 16 11]
 [19 35 22]
 [51 72 54]]

import numpy as np

a = np.array([[1,1], [2,3]])
b = np.array([[9,9], [0,5]])

print(a @ b)

Výstup:

[[ 9 14]
 [18 33]]

Pozor! Pravým násobením matic lze násobit jen ty matice, které mají čtvercový tvar (n x n), a nelze násobit matice, které mají obdélníkový tvar (m x n).

Dělení matic

import numpy as np

a = np.array([[8,8,8], [8,8,8]])
b = np.array([[2,2,2], [4,4,4]])

print(a / b)

Výstup:

[[4. 4. 4.]
 [2. 2. 2.]]

Umocňování matic

import numpy as np

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

print(a ** b)

Výstup:

[[ 4  8 16]
 [ 3  9 27]]

Generátory matic

Posloupnost čísel

import numpy as np

a = np.arange(15).reshape(3, 5) #Matice 3x5 s čísly od 0 do 14

print(a)

Výstup:

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

Nulová matice

import numpy as np

a = np.zeros((3, 4)) #Matice 3x4

print(a)

Výstup:

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

Jedničková matice

import numpy as np

a = np.ones((3, 4)) #Matice 3x4, čísla jsou desetiná typu float

print(a)

Výstup:

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

import numpy as np

a = np.ones((3, 4), dtype=int) #Matice 3x4, čísla jsou celá typu int

print(a)

Výstup:

[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]

Matice náhodných čísel

import numpy as np

a = np.random.rand(3,2) #Matice 3x2

print(a)

Výstup:

[[0.28253174 0.29213217]
 [0.2682984  0.216447  ]
 [0.93052966 0.95471456]]

import numpy as np

a = np.random.rand(3,2) * 10

print(a)

Výstup:

[[1.00035561 2.39587355]
 [4.82608495 6.3154159 ]
 [6.31049244 1.44535497]]

import numpy as np

a = np.random.randint(6, size=(8, 8)) #Matice 8x8, náhodná čísla od 0 do 6

print(a)

Výstup:

[[4 5 1 2 4 5 0 1]
 [2 0 0 1 5 2 4 2]
 [4 0 5 3 3 2 1 0]
 [4 3 2 3 5 3 0 1]
 [2 1 0 0 4 1 2 5]
 [3 0 2 2 1 5 4 2]
 [4 2 5 3 3 1 3 0]
 [1 1 0 4 2 0 1 4]]

import numpy as np

a = np.random.randint(1, 6, size=(8, 8)) #Matice 8x8, náhodná čísla od 1 do 6

print(a)

Výstup:

[[1 2 5 5 1 2 3 4]
 [3 1 1 4 5 2 1 5]
 [5 4 3 3 1 1 1 3]
 [1 2 2 4 1 1 3 4]
 [3 4 4 5 5 3 3 5]
 [2 1 1 5 3 5 4 5]
 [3 5 1 2 3 4 2 4]
 [5 3 1 5 3 4 2 3]]

import numpy as np

a = np.random.choice((1,6), (3,10)) #Matice 3x10, náhodná čísla 1 nebo 6

print(a)

Výstup:

[[1 1 6 6 6 1 1 1 6 6]
 [1 1 6 1 1 6 6 1 6 6]
 [6 1 6 6 1 6 6 1 1 1]]

import numpy as np

a = np.random.choice((1,0), (3,10)) #Matice 3x10, náhodná čísla 1 nebo 6

print(a)

Výstup:

[[1 0 0 1 1 0 0 1 0 0]
 [1 1 0 0 1 0 1 1 1 0]
 [1 0 1 0 1 0 0 1 1 0]]

import numpy as np

a = np.random.choice(("A","G","T","C"), (3,10)) #Matice 3x10, náhodné znaky DNA

print(a)

Výstup:

[['G' 'A' 'U' 'U' 'A' 'T' 'U' 'T' 'A' 'T']
 ['T' 'A' 'A' 'T' 'A' 'A' 'U' 'T' 'A' 'T']
 ['G' 'T' 'G' 'U' 'U' 'G' 'T' 'G' 'A' 'T']]

import numpy as np

a = np.random.choice(("A","G","T","C"), (3,10), p=[0.1, 0, 0.3, 0.6]) #Matice 3x10, náhodné znaky DNA, s nastavenou pravděpodoností výskytu (C má pravděpodonost 0.6, proto se objeví nejčastěji)

print(a)

Výstup:

[['T' 'T' 'C' 'C' 'C' 'C' 'C' 'C' 'T' 'C']
 ['A' 'C' 'C' 'T' 'T' 'T' 'T' 'C' 'C' 'C']
 ['C' 'T' 'T' 'C' 'T' 'C' 'C' 'T' 'C' 'C']]

import numpy as np

a = np.random.permutation(10) # Permutace deseti

print(a)

Výstup:

[6 7 8 2 9 3 4 0 5 1]

import numpy as np

a = np.random.permutation((1, 2, 8)) # Permutace čísel 1 a 2 a 8

print(a)

Výstup:

[1 8 2]

Změna tvaru matice

import numpy as np

a = np.array([[3., 7., 3., 4.],[1., 4., 2., 2.], [7., 2., 4., 9.]]) #Matice 3x4

#změna tvaru 2x6
a.resize((2, 6))
print(a)

Výstup:

[[3. 7. 3. 4. 1. 4.]
 [2. 2. 7. 2. 4. 9.]]

Rozsah hodnot linspace()

Vrátí pole hodnot stejně rozmístěnými intervaly, mezi dvěma čísly. Jedná se o vektorový prostor, nevzýváme ho také lineární prostor.

import numpy as np

a = np.linspace(1, 10)

print(a)

Výstup:

[ 1.          1.18367347  1.36734694  1.55102041  1.73469388  1.91836735
  2.10204082  2.28571429  2.46938776  2.65306122  2.83673469  3.02040816
  3.20408163  3.3877551   3.57142857  3.75510204  3.93877551  4.12244898
  4.30612245  4.48979592  4.67346939  4.85714286  5.04081633  5.2244898
  5.40816327  5.59183673  5.7755102   5.95918367  6.14285714  6.32653061
  6.51020408  6.69387755  6.87755102  7.06122449  7.24489796  7.42857143
  7.6122449   7.79591837  7.97959184  8.16326531  8.34693878  8.53061224
  8.71428571  8.89795918  9.08163265  9.26530612  9.44897959  9.63265306
  9.81632653 10.        ]

import numpy as np

a = np.linspace(3, 5)

print(a)

Výstup:

[3.         3.04081633 3.08163265 3.12244898 3.16326531 3.20408163
 3.24489796 3.28571429 3.32653061 3.36734694 3.40816327 3.44897959
 3.48979592 3.53061224 3.57142857 3.6122449  3.65306122 3.69387755
 3.73469388 3.7755102  3.81632653 3.85714286 3.89795918 3.93877551
 3.97959184 4.02040816 4.06122449 4.10204082 4.14285714 4.18367347
 4.2244898  4.26530612 4.30612245 4.34693878 4.3877551  4.42857143
 4.46938776 4.51020408 4.55102041 4.59183673 4.63265306 4.67346939
 4.71428571 4.75510204 4.79591837 4.83673469 4.87755102 4.91836735
 4.95918367 5.        ]

Zadat můžete také počet hodnot mezi které se hodnoty rozpočítají (rozdělí):

import numpy as np

a = np.linspace(3, 5, 100)

print(a)

Výstup:

[3.         3.02020202 3.04040404 3.06060606 3.08080808 3.1010101
 3.12121212 3.14141414 3.16161616 3.18181818 3.2020202  3.22222222
 3.24242424 3.26262626 3.28282828 3.3030303  3.32323232 3.34343434
 3.36363636 3.38383838 3.4040404  3.42424242 3.44444444 3.46464646
 3.48484848 3.50505051 3.52525253 3.54545455 3.56565657 3.58585859
 3.60606061 3.62626263 3.64646465 3.66666667 3.68686869 3.70707071
 3.72727273 3.74747475 3.76767677 3.78787879 3.80808081 3.82828283
 3.84848485 3.86868687 3.88888889 3.90909091 3.92929293 3.94949495
 3.96969697 3.98989899 4.01010101 4.03030303 4.05050505 4.07070707
 4.09090909 4.11111111 4.13131313 4.15151515 4.17171717 4.19191919
 4.21212121 4.23232323 4.25252525 4.27272727 4.29292929 4.31313131
 4.33333333 4.35353535 4.37373737 4.39393939 4.41414141 4.43434343
 4.45454545 4.47474747 4.49494949 4.51515152 4.53535354 4.55555556
 4.57575758 4.5959596  4.61616162 4.63636364 4.65656566 4.67676768
 4.6969697  4.71717172 4.73737374 4.75757576 4.77777778 4.7979798
 4.81818182 4.83838384 4.85858586 4.87878788 4.8989899  4.91919192
 4.93939394 4.95959596 4.97979798 5.        ]

Přidáním dtype=int si lze vynutit pouze celé číslo:

import numpy as np

a = np.linspace(3, 5, 100, dtype=int)

print(a)

Výstup:

[3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4
 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 5]

Využití matic v praxi

Matice jsou užitečné v algoritmech neuronových sítích nebo ve výpočtech fyziky částic, ale také například při šifrování (Maticové šifrování), třeba šifrovací stroj Enigma. Hlavní výhodou maticového šifrování je vyšší odolnost proti frekvenční analýze četnosti znaků. Před šifrováním se znaky převedou na pole čísel. Kódování textu po dvojících čísel jako vektor za pomocí násobení matice tvaru 2x2. Pokud nelze vytvořit inverzní matici, uživatel je požádán o zadání jiné. Při lichém počtu znaků je řetězec doplněn náhodným znakem kvůli nutnosti dvojic. Zpětné dešifrování se provede násobením kódovaného textu s inverzní maticí.