1.1. Tworzenie wektora

# Wczytanie biblioteki.
import numpy as np

# Utworzenie wektora przedstawiającego wiersz.
vector_row = np.array([1, 2, 3])

# Utworzenie wektora przedstawiającego kolumnę.
vector_column = np.array([[1],
                          [2],
                          [3]])





1.2. Tworzenie macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2],
                   [1, 2],
                   [1, 2]])



matrix_object = np.mat([[1, 2],
                        [1, 2],
                        [1, 2]])
matrix([[1, 2],
        [1, 2],
        [1, 2]])





1.3. Tworzenie macierzy rzadkiej

# Wczytanie bibliotek.
import numpy as np
from scipy import sparse

# Utworzenie macierzy.
matrix = np.array([[0, 0],
                   [0, 1],
                   [3, 0]])

# Utworzenie macierzy w formacie CSR.
matrix_sparse = sparse.csr_matrix(matrix)





# Wyświetlenie macierzy rzadkiej.
print(matrix_sparse)

  (1, 1)    1
  (2, 0)    3





# Utworzenie większej macierzy.
matrix_large = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
                         [3, 0, 0, 0, 0, 0, 0, 0, 0, 0]])

# Utworzenie macierzy w formacie CSR.
matrix_large_sparse = sparse.csr_matrix(matrix_large)

# Wyświetlenie początkowej macierzy rzadkiej.
print(matrix_sparse)

  (1, 1)    1
  (2, 0)    3

# Wyświetlenie macierzy rzadkiej utworzonej na podstawie większej macierzy.
print(matrix_large_sparse)

  (1, 1)    1
  (2, 0)    3





1.4. Wstępna alokacja tablicy NumPy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie wektora o kształcie (1, 5) składającego się wyłącznie z zer.
vector = np.zeros(shape=5)

# Wyświetlenie macierzy.
print(vector)

array([0., 0., 0., 0., 0.])

# Wygenerowanie macierzy o kształcie (3, 3), składającej się wyłącznie z jedynek.
matrix = np.full(shape=(3,3), fill_value=1)

# Wyświetlenie wektora.
print(matrix)

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




1.5. Pobieranie elementów

# Wczytanie biblioteki.
import numpy as np

# Utworzenie wiersza wektora.
vector = np.array([1, 2, 3, 4, 5, 6])

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Pobranie trzeciego elementu wektora.
vector[2]

3

# Pobranie elementu znajdującego się w drugim wierszu i drugiej kolumnie.
matrix[1,1]

5





# Pobranie wszystkich elementów wektora.
vector[:]

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

# Pobranie wszystkich elementów wektora do trzeciego włącznie.
vector[:3]

array([1, 2, 3])

# Pobranie wszystkich elementów wektora od czwartego włącznie.
vector[3:]

array([4, 5, 6])

# Pobranie ostatniego elementu.
vector[-1]

6

# Odwrócenie wektora.
vector[::-1]

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

# Pobranie pierwszych dwóch wierszy i wszystkich kolumn macierzy.
matrix[:2,:]

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

# Pobranie wszystkich wierszy i drugiej kolumny.
matrix[:,1:2]

array([[2],
       [5],
       [8]])





1.6. Opisywanie macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3, 4],
                   [5, 6, 7, 8],
                   [9, 10, 11, 12]])

# Wyświetlenie liczby wierszy i kolumn.
matrix.shape

(3, 4)

# Wyświetlenie liczby elementów (wiersze × kolumny).
matrix.size

12

# Wyświetlenie liczby wymiarów.
matrix.ndim

2





1.7. Przeprowadzanie operacji na wszystkich elementach

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Utworzenie funkcji dodającej 100 do istniejącej wartości.
add_100 = lambda i: i + 100

# Utworzenie funkcji bazującej na metodzie vectorize().
vectorized_add_100 = np.vectorize(add_100)

# Wywołanie funkcji dla wszystkich elementów macierzy.
vectorized_add_100(matrix)

array([[101, 102, 103],
       [104, 105, 106],
       [107, 108, 109]])





# Dodanie wartości 100 do wszystkich elementów.
matrix + 100

array([[101, 102, 103],
       [104, 105, 106],
       [107, 108, 109]])
Wprawdzie broadcasting 





1.8. Znajdowanie wartości maksymalnej i minimalnej

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Zwrot elementu o maksymalnej wartości.
np.max(matrix)

9

# Zwrot elementu o minimalnej wartości.
np.min(matrix)

1





# Wyszukanie w każdej kolumnie elementu o maksymalnej wartości.
np.max(matrix, axis=0)

array([7, 8, 9])

# Wyszukanie w każdym wierszu elementu o maksymalnej wartości.
np.max(matrix, axis=1)

array([3, 6, 9])





1.9. Obliczanie średniej, wariancji i odchylenia standardowego

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Zwrot wartości średniej.
np.mean(matrix)

5.0

# Zwrot wariancji.
np.var(matrix)


6.666666666666667

# Zwrot odchylenia standardowego.
np.std(matrix)

2.5819888974716112





# Wyszukanie wartości średniej w każdej kolumnie.
np.mean(matrix, axis=0)

array([ 4.,  5.,  6.])





1.10. Zmiana kształtu tablicy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy o wielkości 4×3.
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9],
                   [10, 11, 12]])

# Zmiana kształtu macierzy na 2×6.
matrix.reshape(2, 6)

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




matrix.size

12





matrix.reshape(1, -1)

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





matrix.reshape(12)

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





1.11. Transponowanie wektora lub macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Transponowanie macierzy.
matrix.T

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





# Transponowanie wektora.
np.array([1, 2, 3, 4, 5, 6]).T

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





# Transponowanie wiersza wektora.
np.array([[1, 2, 3, 4, 5, 6]]).T

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





1.12. Spłaszczanie macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# Spłaszczenie macierzy.
matrix.flatten()

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





matrix.reshape(1, -1)

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





# Utworzenie pierwszej macierzy.
matrix_a = np.array([[1, 2],
                     [3, 4]])

# Utworzenie drugiej macierzy.
matrix_b = np.array([[5, 6],
                      [7, 8]])

# Utworzenie listy macierzy.
matrix_list = [matrix_a, matrix_b]

# Spłaszczenie całej listy macierzy.
np.ravel(matrix_list)

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





1.13. Znajdowanie rzędu macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 1, 1],
                   [1, 1, 10],
                   [1, 1, 15]])

# Zwrot rzędu macierzy.
np.linalg.matrix_rank(matrix)

2





1.14. Pobieranie przekątnej macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [2, 4, 6],
                   [3, 8, 9]])

# Zwrot elementów znajdujących się na przekątnej macierzy.
matrix.diagonal()
array([1, 4, 9])





# Zwrot elementów znajdujących się na przekątnej o jeden poziom nad przekątną główną.
matrix.diagonal(offset=1)

array([2, 6])

# Zwrot elementów znajdujących się na przekątnej o jeden poziom pod przekątną główną.
matrix.diagonal(offset=-1)

array([2, 8])






1.15. Obliczanie śladu macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 2, 3],
                   [2, 4, 6],
                   [3, 8, 9]])

# Zwrot śladu macierzy.
matrix.trace()

14





# Zwrot sumy elementów leżących na przekątnej macierzy.
sum(matrix.diagonal())

14





1.16. Obliczanie iloczynu skalarnego

# Wczytanie biblioteki.
import numpy as np

# Utworzenie dwóch wektorów.
vector_a = np.array([1,2,3])
vector_b = np.array([4,5,6])

# Obliczenie iloczynu skalarnego.
np.dot(vector_a, vector_b)

32





# Obliczenie iloczynu skalarnego.
vector_a @ vector_b

32





1.17. Dodawanie i odejmowanie macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix_a = np.array([[1, 1, 1],
                     [1, 1, 1],
                     [1, 1, 2]])

# Utworzenie macierzy.
matrix_b = np.array([[1, 3, 1],
                     [1, 3, 1],
                     [1, 3, 8]])

# Dodanie dwóch macierzy.
np.add(matrix_a, matrix_b)

array([[ 2,  4,  2],
       [ 2,  4,  2],
       [ 2,  4, 10]])

# Odjęcie jednej macierzy od drugiej.
np.subtract(matrix_a, matrix_b)

array([[ 0, -2,  0],
       [ 0, -2,  0],
       [ 0, -2, -6]])
Analiza





# Dodanie dwóch macierzy.
matrix_a + matrix_b

array([[ 2,  4,  2],
       [ 2,  4,  2],
       [ 2,  4, 10]])





1.18. Mnożenie macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix_a = np.array([[1, 1],
                     [1, 2]])

# Utworzenie macierzy.
matrix_b = np.array([[1, 3],
                     [1, 2]])

# Mnożenie dwóch macierzy.
np.dot(matrix_a, matrix_b)

array([[2, 5],
       [3, 7]])





# Mnożenie dwóch macierzy.
matrix_a @ matrix_b

array([[2, 5],
       [3, 7]])





# Mnożenie dwóch macierzy z uwzględnieniem ich elementów.
matrix_a * matrix_b

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





1.19. Odwracanie macierzy

# Wczytanie biblioteki.
import numpy as np

# Utworzenie macierzy.
matrix = np.array([[1, 4],
                   [2, 5]])

# Utworzenie macierzy odwrotnej.
np.linalg.inv(matrix)

array([[-1.66666667,  1.33333333],
       [ 0.66666667, -0.33333333]])





# Mnożenie macierzy i jej odwrotność.
matrix @ np.linalg.inv(matrix)

array([[ 1.,  0.],
       [ 0.,  1.]])





1.20. Generowanie liczb losowych

# Wczytanie biblioteki.
import numpy as np

# Zdefiniowanie wartości zalążka.
np.random.seed(0)

# Wygenerowanie trzech losowych liczb zmiennoprzecinkowych z przedziału od 0.0 do 1.0.
np.random.random(3)

array([ 0.5488135 ,  0.71518937,  0.60276338])





# Wygenerowanie trzech losowych liczb całkowitych z przedziału od 1 do 10.
np.random.randint(0, 11, 3)

array([3, 7, 9])





# Pobranie trzech liczb z rozkładu zwykłego o średniej wynoszącej 0.0
# i odchyleniu standardowym równym 1.0.
np.random.normal(0.0, 1.0, 3)

array([-1.42232584, 1.52006949, -0.29139398])

# Pobranie trzech liczb z rozkładu logistycznego o średniej wynoszącej 0.0 i skali równej 1.0.
np.random.logistic(0.0, 1.0, 3)

array([-0.98118713, -0.08939902, 1.46416405])

# Pobranie trzech liczb większych niż lub równych 1.0 i mniejszych niż 2.0.
np.random.uniform(1.0, 2.0, 3)

array([ 1.47997717, 1.3927848, 1.83607876])
