Računalništvo in informatika - vaje: Rešene naloge iz knjižnice numpy

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import numpy as np

############
# 1D seznami
############

# seznam iz lista
seznam_0 = np.array([1,2,3,4,5])
print("iz lista", seznam_0)

# seznam iz range-a
seznam_1 = np.array(range(6,10))
print("iz range-a", seznam_1)

# seznam ničel
seznam_2 = np.zeros(5)
print("seznam ničel", seznam_2)

# seznam enic
seznam_3 = np.ones(5)
print("seznam enic", seznam_3)

# naključna števila
seznam_4 = np.random.random(5)
print("random", seznam_4)

# naključen seznam z normalno porazdelitvijo
seznam_5 = np.random.randn(5)
print("normalna porazdelitev", seznam_5)

# seznam z enakomernim razmakom med številkami 
seznam_6 = np.linspace(0, 10, 3)
print("enakomeren razmak", seznam_6)

# seznam z arange
seznam_7 = np.arange(0, 11, 2)
print("arange", seznam_7)

# predpisana vrednost
seznam_8 = np.full(5,1.)
print("predpisana vrednost", seznam_8)

###############
# 2D/3D seznami
###############

# 2D iz list-a
seznam_2D_list = [[1, 2, 3],[4, 5, 6]]
seznam_numpy_2D = np.array(seznam_2D_list)
print("seznam_2D_list\n", seznam_numpy_2D)

# 3D iz list-a
seznam_3D_list = [[[1, 2, 3],[4, 5, 6]],
                  [[7, 8, 9],[10, 11, 12]]]
seznam_numpy_3D = np.array(seznam_3D_list)
print("seznam_2D_list\n", seznam_numpy_3D)

# 2D seznam ničel
seznam_zeros_2D = np.zeros((2,3))
print("seznam_zeros_2D\n", seznam_zeros_2D)

# 3D seznam enic
seznam_ones_3D = np.ones((2,3,4))
print("seznam_ones_3D\n", seznam_ones_3D)

# 2D seznam z vrednostmi 3
seznam_full_2D = np.full((2,3),3)
print("seznam_full_2D\n", seznam_full_2D)

# 3D naključen seznam
seznam_random_3D = np.random.random((2,3,4))
print("seznam_random_3D\n", seznam_random_3D)

# 2D seznam z normalno porazdelitvijo
seznam_randn_2D = np.random.randn(2,3)
print("seznam_randn_2D\n", seznam_randn_2D)

# 3D prazen seznam
seznam_empty_3D = np.empty((2,3,4))
print("seznam_empty_3D\n", seznam_empty_3D)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
import numpy as np

#########################
#########################
#        1D SEZNAMI     #
#########################
#########################
print("1D")

# pripravimo seznam
seznam_1D = np.array([1, 2, 3, 4, 5, 6, 7])

#########################
# dostopanje do elementa#
#########################
# izpišemo prvi element
print("1. element", seznam_1D[0])

# izpišemo 4. element 
print("4. element", seznam_1D[3])

# izpišemo 7. element
print("7. element", seznam_1D[6])

# izpišemo zadnji element
print("-1. element", seznam_1D[-1])

# izpišemo tretji element iz zadnje strani
print("-3. element", seznam_1D[-3])

#########################
#    urejanje elementa  #
#########################
# popravimo 1. element 
seznam_1D[0] = 2

# popravimo 4. element
seznam_1D[3] = 3

# popravimo 7. element
seznam_1D[6] = 4

# popravimo zadnji element
seznam_1D[-1] = 5

# tretji element iz zadnje strani
seznam_1D[-3] = 6
print("popravljen seznam_1D\n", seznam_1D)

#########################
#########################
#        2D SEZNAMI     #
#########################
#########################
print("\n2D")

# pripravimo seznam
seznam_2D = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])

#########################
# dostopanje do elementa#
#########################
# izpišemo element 0, 0
print("element 0, 0:", seznam_2D[0, 0])

# izpišemo element -3, -3
print("element -3, -3:",seznam_2D[-3, -3])

# izpišemo element 2, 2
print("element 2, 2:",seznam_2D[2, 2])

# izpišemo element -1, -1
print("element -1, -1:",seznam_2D[-1, -1])

# izpišemo element 1, 1
print("element 1, 1:",seznam_2D[1, 1])

# izpišemo element -2, -2
print("element -2, -2:",seznam_2D[-2, -2])

#########################
#    urejanje elementa  #
#########################
# popravimo element -3, -3
seznam_2D[-3, -3] = 12

# popravimo element 2, 2
seznam_2D[2, 2] = 13

# popravimo element -1, -1
seznam_2D[-1, -1] = 14

# popravimo element 1, 1
seznam_2D[1, 1] = 15

# popravimo element -2, -2
seznam_2D[-2, -2] = 16
print("popravljen seznam_2D\n", seznam_2D)

#########################
#########################
#        3D SEZNAMI     #
#########################
#########################
print("\n3D")

# pripravimo seznam
seznam_3D = np.array([[[1, 2, 3],[4, 5, 6],[7, 8, 9]],[[11, 12, 13],[14, 15, 16],[17, 18, 19]]])

#########################
# dostopanje do elementa#
#########################
# izpišemo element 0, 0, 0
print("element 0, 0, 0:", seznam_3D[0, 0, 0])

# izpišemo element -2, -3, -3
print("element -2, -3, -3:",seznam_3D[-2, -3, -3])

# izpišemo element 1, 2, 2
print("element 1, 2, 2:",seznam_3D[1, 2, 2])

# izpišemo element -1, -1, -1
print("element -1, -1, -1:",seznam_3D[-1, -1, -1])

# izpišemo element 1, 1, 1
print("element 1, 1, 1:",seznam_3D[1, 1, 1])

# izpišemo element -2, -2, -2
print("element -2, -2, -2:",seznam_3D[-2, -2, -2])

#########################
#    urejanje elementa  #
#########################
# popravimo element -3, -3, 1
seznam_3D[0, -3, 1] = 112

# popravimo element 1, 2, 2
seznam_3D[1, 2, 2] = 113

# popravimo element -1, -1, -1
seznam_3D[-1, -1, -1] = 114

# popravimo element 1, 1, 1
seznam_3D[1, 1, 1] = 115

# popravimo element -2, 2, -2
seznam_3D[-2, 2, -2] = 116
print("popravljen seznam_3D\n", seznam_3D)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
import numpy as np

#########################
#########################
#  REZANJE 1D SEZNAMOV  #
#########################
#########################
print("1D")

# pripravimo seznam
seznam_1D = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
print("seznam_1D", seznam_1D)

# rez od indeksa 1 do 8 s korakom 2
print("seznam_1D[1:8:2]", seznam_1D[1:8:2])

# rez od indeksa 3 do -1 s korakom 3
print("seznam_1D[3:-1:3]", seznam_1D[3:-1:3])

# rez od indeksa 3 do 6
print("seznam_1D[3:6]", seznam_1D[3:6])

# rez od indeksa 3 do konca s korakom 4
print("seznam_1D[3::4]", seznam_1D[3::4])

# rez od začetka do indeksa 8 s korakom 3
print("seznam_1D[:8:3]", seznam_1D[:8:3])

# rez od začetka do konca s korakom 4
print("seznam_1D[::4]", seznam_1D[::4])

# rez od začetka do indeksa 4
print("seznam_1D[:4:]", seznam_1D[:4:])

# rez od indeksa 4 do konca
print("seznam_1D[4::]", seznam_1D[4::])

# rez od indeksa -3 do konca
print("seznam_1D[-3:]", seznam_1D[-3:])

# rez od indeksa -5 do indeksa -2
print("seznam_1D[-5:-2]", seznam_1D[-5:-2])

# rez od indeksa -1 do začetka s korakom -2
print("seznam_1D[-1::-2]", seznam_1D[-1::-2])

# obrnjen seznam
print("seznam_1D[::-1]", seznam_1D[::-1])

#########################
#########################
#  UREJANJE 1D SEZNAMOV  #
#########################
#########################
print("1D urejanje")

seznam_1D = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
seznam_1D[1:8:2] = 0
print("seznam_1D[1:8:2] = 0 - >", seznam_1D)

seznam_1D = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
seznam_1D[3:-1:3] = [10, 20]
print("seznam_1D[3:-1:3] = [10, 20] - >", seznam_1D)

seznam_1D = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
seznam_1D[-5:-2] = [1, 2, 3]
print("seznam_1D[-5:-2] = [1, 2, 3] - >", seznam_1D)

seznam_1D = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
seznam_1D[-1::-2] = 15
print("seznam_1D[-1::-2] = 15 - >", seznam_1D)

#########################
#########################
#  REZANJE 2D SEZNAMOV  #
#########################
#########################
print("2D")

# pripravimo seznam
seznam_2D = np.array([[1, 2, 3, 4],
                      [5, 6, 7, 8],
                      [9, 10, 11, 12]])
print("seznam_2D\n", seznam_2D)

# prvi dve vrstici in stolpca
print("seznam_2D[:2, :2]\n", seznam_2D[:2, :2])

# zadnji dve vrstici in stolpca
print("seznam_2D[-2:, -2:]\n", seznam_2D[-2:, -2:])

# zadnji 1. in 3. vrstica in 2. in 4. stolpec
print("seznam_2D[0::2, 1::2]\n", seznam_2D[0::2, 1::2])

# celotna prva vrstica
print("seznam_2D[0, :]\n", seznam_2D[0, :])

# celoten drugi stolpce
print("seznam_2D[:, 1]\n", seznam_2D[:, 1])

#########################
#########################
# UREJANJE 2D SEZNAMOV  #
#########################
#########################
print("2D urejanje")

seznam_2D = np.array([[1, 2, 3, 4],
                      [5, 6, 7, 8],
                      [9, 10, 11, 12]])
seznam_2D[:2, :2] = 0
print("seznam_2D[:2, :2] = 0\n", seznam_2D)

seznam_2D = np.array([[1, 2, 3, 4],
                      [5, 6, 7, 8],
                      [9, 10, 11, 12]])
seznam_2D[-2:, -2:] = [[ 15,  16], [17, 18]]
print("seznam_2D[-2:, -2:] = [[ 15,  16], [17, 18]]\n", seznam_2D)

seznam_2D = np.array([[1, 2, 3, 4],
                      [5, 6, 7, 8],
                      [9, 10, 11, 12]])
seznam_2D[0::2, 1::2] = np.array([[2, 4], [10, 12]])
print("seznam_2D[0::2, 1::2] = np.array([[2, 4], [10, 12]])\n", seznam_2D)

seznam_2D = np.array([[1, 2, 3, 4],
                      [5, 6, 7, 8],
                      [9, 10, 11, 12]])
seznam_2D[0, :] = 15
print("seznam_2D[0, :] = 15\n", seznam_2D)

seznam_2D = np.array([[1, 2, 3, 4],
                      [5, 6, 7, 8],
                      [9, 10, 11, 12]])
seznam_2D[:, 1] = np.array([15, 16, 17])
print("seznam_2D[:, 1] = np.array([15, 16, 17])\n", seznam_2D)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import numpy as np

#########################
#########################
#    transponiranje     #
#########################
#########################

# pripravimo originalne sezname
seznam_1D = np.array([1, 2, 3, 4])
seznam_2D = np.array([[1, 2],[3, 4]])
seznam_3D = np.array([[[1, 2],[3, 4]],[[5, 6],[7, 8]]])


# transponiramo 1d seznam
transponiran_seznam_1D = np.transpose(seznam_1D)
print("original 1D\n", seznam_1D)
print("transponiran 1D\n", transponiran_seznam_1D)

# transponiramo 2d seznam
transponiran_seznam_2D = np.transpose(seznam_2D)
print("original 2D\n", seznam_2D)
print("transponiran 2D\n", transponiran_seznam_2D)

# transponiramo 3d seznam z dodatnim argumentom (2, 0, 1)
# 2 - stolpci zamenjajo sloje
# 0 - sloji zamenjajo vrstice
# 1 - vrstice zamenjajo stolpce
transponiran_seznam_3D = np.transpose(seznam_3D, (2, 0, 1))
print("original 3D\n", seznam_3D)
print("transponiran 3D\n", transponiran_seznam_3D)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
import numpy as np

############
# 1D seznami
############
print("#"*10)
print("1D seznami")
print("#"*10)

seznam_1 = np.array([1, 2, 3, 4])
seznam_2 = np.array([5, 6, 7, 8])
skalar = 3
print("seznam_1\n", seznam_1)
print("seznam_2\n", seznam_2)
print("skalar\n", skalar)

# seštevanje dveh seznamov
rez_seštevanje_1 = seznam_1 + seznam_2
rez_seštevanje_2 = np.add(seznam_1, seznam_2)
print("seštevanje dveh seznamov s + in z  np.add():\n", rez_seštevanje_1,"\n", rez_seštevanje_2)

# seštevanje seznama s skalarjem
rez_seštevanje_3 = seznam_1 + skalar
rez_seštevanje_4 = np.add(seznam_1, skalar)
print("seštevanje seznama s skalarjem s + in z np.add():\n", rez_seštevanje_3,"\n", rez_seštevanje_4)


# odštevanje dveh seznamov
rez_odštevanje_1 = seznam_1 - seznam_2
rez_odštevanje_2 = np.subtract(seznam_1, seznam_2)
print("odštevanje dveh seznamov z - in z  np.subtract():\n", rez_odštevanje_1,"\n", rez_odštevanje_2)

# odštevanje seznama s skalarjem
rez_odštevanje_3 = seznam_1 - skalar
rez_odštevanje_4 = np.subtract(seznam_1, skalar)
print("odštevanje seznama s skalarjem z - in z np.subtract():\n", rez_odštevanje_3,"\n", rez_odštevanje_4)

# množenje dveh seznamov
rez_množenje_1 = seznam_1 * seznam_2
rez_množenje_2 = np.multiply(seznam_1, seznam_2)
print("množenje dveh seznamov z * in z  np.multiply():\n", rez_množenje_1,"\n", rez_množenje_2)

# množenje seznama s skalarjem
rez_množenje_3 = seznam_1 * skalar
rez_množenje_4 = np.multiply(seznam_1, skalar)
print("množenje seznama s skalarjem z * in z np.multiply():\n", rez_množenje_3,"\n", rez_množenje_4)

# deljenje dveh seznamov
rez_deljenje_1 = seznam_1 / seznam_2
rez_deljenje_2 = np.divide(seznam_1, seznam_2)
print("deljenje dveh seznamov z / in z  np.divide():\n", rez_deljenje_1,"\n", rez_deljenje_2)

# deljenje seznama s skalarjem
rez_deljenje_3 = seznam_1 / skalar
rez_deljenje_4 = np.divide(seznam_1, skalar)
print("deljenje seznama s skalarjem z / in z np.divide():\n", rez_deljenje_3,"\n", rez_deljenje_4)

# deljenje skalarja s seznamom
rez_deljenje_5 = skalar / seznam_1
rez_deljenje_6 = np.divide(skalar, seznam_1)
print("deljenje skalarja s seznamom z / in z np.divide():\n", rez_deljenje_5,"\n", rez_deljenje_6)

# potenciranje dveh seznamov
rez_potenciranje_1 = seznam_1 ** seznam_2
rez_potenciranje_2 = np.power(seznam_1, seznam_2)
print("potenciranje dveh seznamov z ** in z  np.power():\n", rez_potenciranje_1,"\n", rez_potenciranje_2)

# potenciranje seznama s skalarjem
rez_potenciranje_3 = seznam_1 ** skalar
rez_potenciranje_4 = np.power(seznam_1, skalar)
print("potenciranje seznama s skalarjem z ** in z np.power():\n", rez_potenciranje_3,"\n", rez_potenciranje_4)

# potenciranje skalarja s seznamom
rez_potenciranje_5 = skalar ** seznam_1
rez_potenciranje_6 = np.power(skalar, seznam_1)
print("potenciranje skalarja s seznamom z ** in z np.power():\n", rez_potenciranje_5,"\n", rez_potenciranje_6)

# modulus dveh seznamov
rez_modulus_1 = seznam_1 % seznam_2
rez_modulus_2 = np.mod(seznam_1, seznam_2)
print("modulus dveh seznamov z % in z  np.mod():\n", rez_modulus_1,"\n", rez_modulus_2)

# modulus seznama s skalarjem
rez_modulus_3 = seznam_1 % skalar
rez_modulus_4 = np.mod(seznam_1, skalar)
print("modulus seznama s skalarjem z % in z np.mod():\n", rez_modulus_3,"\n", rez_modulus_4)

# modulus skalarja s seznamom
rez_modulus_5 = skalar % seznam_1
rez_modulus_6 = np.mod(skalar, seznam_1)
print("modulus skalarja s seznamom z % in z np.mod():\n", rez_modulus_5,"\n", rez_modulus_6)

############
# 2D seznami
############
print("#"*10)
print("2D seznami")
print("#"*10)

seznam_1 = np.array([[1, 2, 3, 4],[5, 6, 7, 8]])
seznam_2 = np.array([[1, 2, 1, 2],[3, 4, 3, 4]])
skalar = 3
print("seznam_1\n", seznam_1)
print("seznam_2\n", seznam_2)
print("skalar\n", skalar)

# seštevanje dveh seznamov
rez_seštevanje_1 = seznam_1 + seznam_2
rez_seštevanje_2 = np.add(seznam_1, seznam_2)
print("seštevanje dveh seznamov s + in z  np.add():\n", rez_seštevanje_1,"\n", rez_seštevanje_2)

# seštevanje seznama s skalarjem
rez_seštevanje_3 = seznam_1 + skalar
rez_seštevanje_4 = np.add(seznam_1, skalar)
print("seštevanje seznama s skalarjem s + in z np.add():\n", rez_seštevanje_3,"\n", rez_seštevanje_4)

# odštevanje dveh seznamov
rez_odštevanje_1 = seznam_1 - seznam_2
rez_odštevanje_2 = np.subtract(seznam_1, seznam_2)
print("odštevanje dveh seznamov z - in z  np.subtract():\n", rez_odštevanje_1,"\n", rez_odštevanje_2)

# odštevanje seznama s skalarjem
rez_odštevanje_3 = seznam_1 - skalar
rez_odštevanje_4 = np.subtract(seznam_1, skalar)
print("odštevanje seznama s skalarjem z - in z np.subtract():\n", rez_odštevanje_3,"\n", rez_odštevanje_4)

# množenje dveh seznamov
rez_množenje_1 = seznam_1 * seznam_2
rez_množenje_2 = np.multiply(seznam_1, seznam_2)
print("množenje dveh seznamov z * in z  np.multiply():\n", rez_množenje_1,"\n", rez_množenje_2)

# množenje seznama s skalarjem
rez_množenje_3 = seznam_1 * skalar
rez_množenje_4 = np.multiply(seznam_1, skalar)
print("množenje seznama s skalarjem z * in z np.multiply():\n", rez_množenje_3,"\n", rez_množenje_4)

# deljenje dveh seznamov
rez_deljenje_1 = seznam_1 / seznam_2
rez_deljenje_2 = np.divide(seznam_1, seznam_2)
print("deljenje dveh seznamov z / in z  np.divide():\n", rez_deljenje_1,"\n", rez_deljenje_2)

# deljenje seznama s skalarjem
rez_deljenje_3 = seznam_1 / skalar
rez_deljenje_4 = np.divide(seznam_1, skalar)
print("deljenje seznama s skalarjem z / in z np.divide():\n", rez_deljenje_3,"\n", rez_deljenje_4)

# deljenje skalarja s seznamom
rez_deljenje_5 = skalar / seznam_1
rez_deljenje_6 = np.divide(skalar, seznam_1)
print("deljenje skalarja s seznamom z / in z np.divide():\n", rez_deljenje_5,"\n", rez_deljenje_6)

# potenciranje dveh seznamov
rez_potenciranje_1 = seznam_1 ** seznam_2
rez_potenciranje_2 = np.power(seznam_1, seznam_2)
print("potenciranje dveh seznamov z ** in z  np.power():\n", rez_potenciranje_1,"\n", rez_potenciranje_2)

# potenciranje seznama s skalarjem
rez_potenciranje_3 = seznam_1 ** skalar
rez_potenciranje_4 = np.power(seznam_1, skalar)
print("potenciranje seznama s skalarjem z ** in z np.power():\n", rez_potenciranje_3,"\n", rez_potenciranje_4)

# potenciranje skalarja s seznamom
rez_potenciranje_5 = skalar ** seznam_1
rez_potenciranje_6 = np.power(skalar, seznam_1)
print("potenciranje skalarja s seznamom z ** in z np.power():\n", rez_potenciranje_5,"\n", rez_potenciranje_6)

# modulus dveh seznamov
rez_modulus_1 = seznam_1 % seznam_2
rez_modulus_2 = np.mod(seznam_1, seznam_2)
print("modulus dveh seznamov z % in z  np.mod():\n", rez_modulus_1,"\n", rez_modulus_2)

# modulus seznama s skalarjem
rez_modulus_3 = seznam_1 % skalar
rez_modulus_4 = np.mod(seznam_1, skalar)
print("modulus seznama s skalarjem z % in z np.mod():\n", rez_modulus_3,"\n", rez_modulus_4)

# modulus skalarja s seznamom
rez_modulus_5 = skalar % seznam_1
rez_modulus_6 = np.mod(skalar, seznam_1)
print("modulus skalarja s seznamom z % in z np.mod():\n", rez_modulus_5,"\n", rez_modulus_6)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import numpy as np

# seznam kotov v stopinjah
koti_stopinje = np.array([0, 15, 30, 45, 60, 90, 270, 360])
print("koti_stopinje\n", koti_stopinje)

# pretvorba kotov v radiane
koti_radiani = np.radians(koti_stopinje)
print("koti_radiani\n", koti_radiani)

#pretvorba iz radianov v stopinje
koti_stopinje2 = np.degrees(koti_radiani)
print("koti_stopinje2\n", koti_stopinje2)

# izračun sinusov
vrednosti_sin = np.sin(koti_radiani)
print("sinusi\n", vrednosti_sin)

#izračun arcsin
vrednosti_arcsin = np.arcsin(vrednosti_sin)
print("vrednosti_arcsin\n", vrednosti_arcsin)

# izračun kosinusov
vrednosti_cos = np.cos(koti_radiani)
print("sinusi\n", vrednosti_cos)

#izračun arccos
vrednosti_arccos = np.arccos(vrednosti_cos)
print("vrednosti_arccos\n", vrednosti_arccos)

# preverimo če velja sin(alfa) ** 2 + cos(alfa) ** 2 = 1
vsota_kvadratov = vrednosti_cos ** 2 + vrednosti_sin ** 2
print("vsota_kvadratov\n", vsota_kvadratov)

# izračun tangensov
vrednosti_tan = np.tan(koti_radiani)
print("vrednosti_tan\n", vrednosti_tan)

#izračun arctan
vrednosti_arctan = np.arctan(vrednosti_tan)
print("vrednosti_arctan\n", vrednosti_arctan)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import numpy as np

# definicija seznamov
seznam_1D = np.random.rand(5)
print("seznam_1D", seznam_1D)
seznam_2D = np.random.randn(2,3)
print("seznam_2D", seznam_2D)

# produkt vseh elementov
rezultat_prod = np.prod(seznam_1D)
print("rezultat_prod",rezultat_prod)

# vsota vseh elementov
rezultat_sum = np.sum(seznam_2D)
print("rezultat_sum",rezultat_sum)

# naravna eksponentna funkcija po elementih
rezultat_exp = np.exp(seznam_1D)
print("rezultat_exp",rezultat_exp)

# naravna logaritem po elementih
rezultat_log = np.log(seznam_1D)
print("rezultat_log",rezultat_log)

# logaritem z osnovo 10 po elementih
rezultat_log10 = np.log10(seznam_1D)
print("rezultat_log10",rezultat_log10)

# logaritem z osnovo 2 po elementih
rezultat_log2 = np.log2(seznam_1D)
print("rezultat_log2",rezultat_log2)

# kvadratni koren po elementih
rezultat_sqrt = np.sqrt(seznam_1D)
print("rezultat_sqrt",rezultat_sqrt)

# kubični koren po elementih
rezultat_cbrt = np.cbrt(seznam_2D)
print("rezultat_cbrt",rezultat_cbrt)

# absolutna vrednost po elementih
rezultat_absolute = np.absolute(seznam_2D)
print("rezultat_absolute",rezultat_absolute)

# predznak po elementih
rezultat_sign = np.sign(seznam_1D)
print("rezultat_sign",rezultat_sign)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np

# tenzor napetosti
napetost = np.array([[1, 0, 0], [0, 3, -1], [0, -1, 3]])

# norma
norma = np.linalg.norm(napetost)
print("norma:", norma)

# determinanta
determinanta = np.linalg.det(napetost)
print("determinanta:", determinanta)

# rang
rang = np.linalg.matrix_rank(napetost)
print("rang:", rang)

# sled
sled = np.trace(napetost)
print("sled:", sled)

#lastne vrednosti in vektorji
vrednosti, vektorji = np.linalg.eig(napetost)
print("lastne vrednosti:", vrednosti)
print("lastni vektorji:\n", vektorji)

#diagonalna matrika
napetosti_glavne = np.diag(vrednosti)
print("napetosti_glavne:\n", napetosti_glavne)

#diagonalno matrika s transofrmacijo
napetosti_glavne_2 = np.linalg.multi_dot((np.linalg.inv(vektorji), napetost, vektorji))
print("napetosti_glavne_2:\n", napetosti_glavne_2)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np

# matrika koeficientov
A = np.array([[1, 1, 1], [4, 2, 0], [1, 4, 1]])
print("A\n", A)

# desne strani
b = np.array([1, 6, 2])
print("b\n", b)

#inverz A
invA = np.linalg.inv(A)
print("invA\n", invA)

# rešitev z inverzom
X = np.dot(invA,b)
print("rešitev X z inverzom", X)

# rešitev neposredno
X = np.linalg.solve(A,b)
print("rešitev neposredno", X)

# matrika koeficientov
A1 = np.array([[1, 2, 1], [1, 3, 2], [2, 5, 3], [2, 0, 1], [3, 1, 1]])
print("A1\n", A1)

# desne strani
b1 = np.array([-1, 2, 0, 1, -2])
print("b1\n", b1)

# rešitev po metodi najmanjših kvadratov
X1 = np.linalg.lstsq(A1, b1, rcond=None)[0]
print("rešitev X1 po metodi najmanjših kvadratov", X1)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import numpy as np

seznam = np.array([1.111, 2.222, 3.333, 4.444, 5.555, 6.666])


# zaokrožitev na cela števila
seznam_round = np.round(seznam)
print("seznam_round\n", seznam_round)
seznam_round0 = np.round(seznam, 0)
print("seznam_round0\n", seznam_round0)

# zaokrožitev na 2 decimalni mesti
seznam_round2 = np.round(seznam, 2)
print("seznam_round2\n", seznam_round2)

# zaokrožitev na 1 decimalno mesto
seznam_round1 = np.round(seznam, 1)
print("seznam_round1\n", seznam_round1)

# zaokrožitev navzdol
seznam_floor = np.floor(seznam)
print("seznam_floor\n", seznam_floor)

# zaokrožitev navzgor
seznam_ceil = np.ceil(seznam)
print("seznam_ceil\n", seznam_ceil)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
import numpy as np

# zgeneriramo seznam naključnih vrednosti porazdeljenih z normalno porazdelitvijo
srednja_vrednost = 50
standarni_odklon = 10
seznam = standarni_odklon * np.random.randn(50) + srednja_vrednost
print("seznam\n", seznam)

# izračun srednje vrednosti
seznam_mean = np.mean(seznam)
print("seznam_mean\n", seznam_mean)

# izračun standardnega odklona
seznam_std = np.std(seznam)
print("seznam_std\n", seznam_std)

# izračun mediane
seznam_median = np.median(seznam)
print("seznam_median\n", seznam_median)

# izračun mediane s funcijo percentile()
seznam_median2 = np.percentile(seznam, 50)
print("seznam_median2\n", seznam_median2)

# izračun 25. percentila
seznam_percentile25 = np.percentile(seznam,25)
print("seznam_percentile25\n", seznam_percentile25)

# najmanjši element
seznam_min = np.min(seznam)
print("seznam_min\n", seznam_min)

# največji element
seznam_max = np.max(seznam)
print("seznam_max\n", seznam_max)

# 2d seznam
seznam_2D = np.array([[1.1, 1.2, 1.3],
                 [3.1, 3.2, 3.3],
                 [7.1, 7.2, 7.3]])

# izračun srednje vrednosti po stolpcih
seznam_2D_mean0 = np.mean(seznam_2D, axis=0)
print("seznam_2D_mean0\n", seznam_2D_mean0)

# izračun srednje vrednosti po vrsticah
seznam_2D_mean1 = np.mean(seznam_2D, axis=1)
print("seznam_2D_mean1\n", seznam_2D_mean1)

# izračun srednje vrednosti celotnega seznama
seznam_2D_mean = np.mean(seznam_2D)
print("seznam_2D_mean\n", seznam_2D_mean)

# najmanjši element po stolpcih
seznam_2D_min0 = np.min(seznam_2D, axis=0)
print("seznam_2D_min0\n", seznam_2D_min0)

# najmanjši element po vrsticah
seznam_2D_min1 = np.min(seznam_2D, axis=1)
print("seznam_2D_min1\n", seznam_2D_min1)

# najmanjši element celotnega seznama
seznam_2D_min = np.min(seznam_2D)
print("seznam_2D_min\n", seznam_2D_min)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import numpy as np

# definicija seznamov
seznam_1 =  np.arange(1,51)
seznam_2 = np.arange(76,26,-1)

# seznam_1 > seznam_2
rezultat_1 = np.greater(seznam_1, seznam_2)
print("seznam_1 > seznam_2\n", rezultat_1)

# seznam_1 >= seznam_2
rezultat_2 = np.greater_equal(seznam_1, seznam_2)
print("seznam_1 >= seznam_2\n", rezultat_2)

# seznam_1 < seznam_2
print("seznam_1 < seznam_2\n", np.less(seznam_1, seznam_2))

# seznam_1 <= seznam_2
print("seznam_1 <= seznam_2\n", np.less_equal(seznam_1, seznam_2))

# seznam_1 == seznam_2
print("seznam_1 == seznam_2\n", np.equal(seznam_1, seznam_2))

# seznam_1 != seznam_2
print("seznam_1 != seznam_2\n", np.not_equal(seznam_1, seznam_2))

# rezultat_1 AND rezultat_2
print("rezultat_1 AND rezultat_2\n", np.logical_and(rezultat_1, rezultat_2))

# rezultat_1 OR rezultat_2
print("rezultat_1 OR rezultat_2\n", np.logical_or(rezultat_1, rezultat_2))

# NOT rezultat_1
print("rezultat_1 OR rezultat_2\n", np.logical_not(rezultat_1))

# definicija seznamov
seznam_3 = np.array([np.arange(1,11),np.arange(11,21),np.arange(21,31),np.arange(31,41),np.arange(41,51)])
seznam_4 = np.array([np.arange(76,66,-1),np.arange(66,56,-1),np.arange(56,46,-1),np.arange(46,36,-1),np.arange(36,26,-1)])

# seznam_3 > seznam_4
rezultat_3 = seznam_3 > seznam_4
print("seznam_3 > seznam_4\n", seznam_3 > seznam_4)

# seznam_3 >= seznam_4
rezultat_4 = seznam_3 >= seznam_4
print("seznam_3 >= seznam_4\n", seznam_3 >= seznam_4)

# seznam_3 < seznam_4
print("seznam_3 < seznam_4\n", seznam_3 < seznam_4)

# seznam_3 <= seznam_4
print("seznam_3 <= seznam_4\n", seznam_3 <= seznam_4)

# seznam_3 == seznam_4
print("seznam_3 == seznam_4\n", seznam_3 == seznam_4)

# seznam_3 != seznam_4
print("seznam_3 != seznam_4\n", seznam_3 != seznam_4)

# rezultat_3 AND rezultat_4
print("rezultat_3 AND rezultat_4\n", np.logical_and(rezultat_3, rezultat_4))

# rezultat_3 OR rezultat_4
print("rezultat_3 OR rezultat_4\n", np.logical_or(rezultat_3, rezultat_4))

# NOT rezultat_3
print("rezultat_3 OR rezultat_4\n", np.logical_not(rezultat_3))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np

# definicija seznama
seznam = np.arange(-10,10)

# lihi indeksi
lihi_indeksi = np.arange(0,len(seznam)) % 2 == 1
print("lihi_indeksi\n", lihi_indeksi)
print("vrednosti na lihih indeksih\n", seznam[lihi_indeksi])

#sodi indeksi
sodi_indeksi = np.arange(0,len(seznam)) % 2 == 0
print("sodi_indeksi\n", sodi_indeksi)
print("vrednosti na sodih indeksih\n", seznam[sodi_indeksi])

# kvadriranje elementov na lihih indeksih
seznam[lihi_indeksi] = seznam[lihi_indeksi] ** 2

# popravljen seznam
print("popravljen seznam\n", seznam)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np
import matplotlib.pyplot as plt

# seznam x-ov
X = np.linspace(-10,10,30)

# definicija funkcije
def f_x(x):
    if x < 0:
        return -x
    else:
        return x ** 2

# vektorizacija funkcije
f_X = np.vectorize(f_x, otypes=[float])

Y_1 = f_X(X)
print("Y_1\n", Y_1)

# izračun z logičnimi indeksi
Y_2 = X ** 2
Y_2[X<0] = -X[X<0]
print("Y_2\n", Y_2)

# risanje grafov s knjižnico matplotlib
fig, axs = plt.subplots(2, 1, sharex=True)
axs[0].plot(X, Y_1)
axs[0].set_ylabel('Y_1', fontsize=12)
axs[1].plot(X, Y_2)
axs[1].set_ylabel('Y_2', fontsize=12)
axs[1].set_xlabel('Koordinata x', fontsize=12)

plt.show()