Dette indlæg giver en introduktionsdokumentation til at komme i gang med NumPy i Python.

# importerer numpy til dette python-script 
importer numpy 
# bygger nogle lister og tilføjer dem med Python- basebiblioteket 
a = [1,2,3] 
b = [1,2,3] 
a+b

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

# erklærer et array med numpy 
a_np = numpy.array([1,2,3]) 
# kontrollerer typen for arrayet for at bekræfte, at det er en numpy array 
type(a_np)

numpy.ndarray

# numpy arrays har en attribut .dtype, så du kan kontrollere numpy datatypen for arrayet 
a_np.dtype

dtype('int32')

# a_np er af typen heltal; lad prøve at tildele en float 
a_np[0] = 
13.33 a_np

array([13, ​​2, 3])

# numpy arrays har en .ndim-attribut, så du kan se antallet af dimensioner af arrayet 
a_np.ndim

1

# numpy arrays har også en .size-attribut; 
# .size giver dig mulighed for at se antallet af elementer indeholdt i arrayet 
a_np.size

3

# matematik bliver muligt elementmæssigt, når du bruger numpy arrays 
# -- oprettelse af et andet numpy array for at teste nogle elementmæssige matematiske operationer 
b_np = numpy.array([2,3,4]) 
# addition 
a_np + b_np

array([11, -1, -1])

# subtraktion 
a_np - b_np

array([11, -1, -1])

# multiplikation 
a_np * b_np

array([26, 6, 12])

# en i kraft af den anden 
a_np ** b_np

array([169, 8, 81], dtype=int32)

# 
division a_np / b_np

array([6,5 , 0,66666667, 0,75 ])

# modulo; test af a_np modulo 2 
a_np % numpy.array([2,2,2])

array([1, 0, 1], dtype=int32)

# modulo; test af b_np modulo 2 
b_np % numpy.array([2,2,2])

array([0, 1, 0], dtype=int32)

# numpy giver mulighed for at bruge "universelle funktioner"; 
# universelle funktioner fungerer elementmæssigt, med numpy arrays 
# et eksempel er .sin 
numpy.sin(a_np)

matrix([0,42016704, 0,90929743, 0,14112001])

# et andet eksempel er .sqrt 
numpy.sqrt(a_np)

matrix([3.60555128, 1.41421356, 1.73205081])

# opbygning af en 2D-datatabel ved hjælp af numpy 
c_np = numpy.array([[1,2,3], 
                   [4,5,6]]) 
c_np

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

# indeksering, dvs. opnåelse af værdien gemt i en defineret celle; 
# her: celle i første række, første 
kolonne c_np[0][0]

1

# her: celle i sidste række, sidste 
kolonne c_np[-1][-1]

6

# her: celle i anden række, første kolonne 
c_np[1][0]

4

# en alternativ måde at gøre ovenstående 
c_np[1,0]

4

# skærer gennem simpel 1d numpy array 
# her: få anden og tredje værdi i d_np 
d_np = numpy.array([7,9,11]) 
d_np[1:3]

array([9, 11])

# få første og tredje element 
d_np[0:3:2] # from:to:step

array([7, 11])

# her: henter hvert andet element i d_np 
d_np[::2]

array([7, 11])

# her: får hvert tredje element 
d_np[::3]

array([7])

# vi kan oprette et 1D-array ved hjælp af .arange, en metode fra numpy-modulet 
e_np = numpy.arange(0,26) #param1: from; param2: til (sidste værdi ekskluderet) 
e_np

matrix([ 0, 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])

# lad os tjekke typen af ​​e_np 
type(e_np)

numpy.ndarray

# numpy arrays kan omformes ved hjælp af numpy .reshape metoden 
f_np = e_np.reshape(2,13) ​​#param1: antal rækker; param2: antal kolonner 
f_np

array([[ 0, 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]])

# Jeg kan bruge .reshape ikke kun til at skabe 2D ud af 1D; 
# se fx denne 
g_np = numpy.array([1,2,3,4,5,6,7,8,9,10,11,12]).reshape(3,2,2) 
g_np

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

       [[ 5, 6], 
        [ 7, 8]], 

       [[ 9, 10], 
        [11, 12]]])

# g_np er heller ikke 3D; lad dele nogle dimensioner ud af denne datakube 
# alle værdier i første retninger af anden dimension 
g_np[:,0,:]

array([[ 1, 2], 
       [ 5, 6], 
       [ 9, 10]])

# én specifik celle; først i alle dimensioner 
g_np[0,0,0]

1

# én specifik celle; sidste i alle dimensioner 
g_np[-1,-1,-1]

12

# én specifik celle; ANDET sidst i alle dimensioner 
g_np[-2,-2,-2]

5

# lad os fuldføre denne første tutorial om numpy med et andet eksempel; 
# Jeg opretter et 2d-array og viser det til dig 
eksempel = numpy.array([[1,2,3,4,5], 
                      [1.1,2.2,3.3,4.4,5.5], 
                      [1.11,2.22,3.33,4.44 ,5.55], 
                      [1.111,2.222,3.333,4.444,5.555], 
                      [1.1111,2.2222,3.3333,4.4444,5.5555]]) 
eksempel

array([[1. , 2. , 3. , 4. , 5. ], 
       [1.1 , 2.2 , 3.3 , 4.4 , 5.5 ], 
       [1.11 , 2.22 , 3.33 , 4.44 , 5.51 ], 
       [ 2, 3, 2 . , 4.444 , 5.555 ], 
       [1.1111, 2.2222, 3.3333, 4.4444, 5.5555]])

# giver nu adgang til værdierne 2.2, 4.4, 2.222 og 4.444 - i blot én kodelinje 
eksempel[1::2,1::2]

array([[2.2 , 4.4 ], 
       [2.222, 4.444]])

# nu nogle eksempler, hvad der sker, når du 
# kopierer med reference 
a_np = numpy.array([1,2,3]) 
b_np = a_np[:1] 
b_np

matrix([1])

# ændring af b_np-element 
b_np[0] = 10000 
b_np

array([10000])

# lad os npw tjekke a_np 
a_np

array([10000, 2, 3])

# ovenfor er effekten af ​​kopiering ved reference; 
# dette sker, når vi skærer gennem numpy arrays; 
# sker det med standard python-liste? 
a = [1,2,3] 
b = a[:1] 
b[0] = 1000 
a

[1, 2, 3]

# kopiering ved reference sker ikke, når du opskærer standardlister i pyhton; 
# hvis vi ikke ønsker at kopiere ved reference, kan vi bruge .copy() metoden, som en del af numpy 
c_np = numpy.array([1,2,3,4,5]) 
d_np = c_np.copy() 
d_np [0] = 10000 
c_np[0] = 99999 
# lad os tjekke c_np nu 
print("dette er c_np:" + str(c_np))

dette er c_np:[99999 2 3 4 5]

# hvad med d_np? 
d_np

array([10000, 2, 3, 4, 5])

# kopiering med .copy() gør det muligt at arbejde med to objekter med uafhængige referencer;

Linnart Felkl

Industriingeniør som gerne beskæftiger sig med optimering, simulation og matematisk modellering i R, SQL, VBA og Python