Python Numpy Exercise (1)

 

 

 

Numpy

Numpy is one of the important and powerful packages for computing linear algebra.

In [78]:

from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important; }</style>"))

 

 

 

Numpy and Array

In [2]:

import sys
import numpy as np

In [6]:

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

Out[6]:

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

In [8]:

new_array = np.array([1,2,3,4,5])

In [9]:

new_array

Out[9]:

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

In [10]:

new_array[0]

Out[10]:

1

In [11]:

new_array[-1]

Out[11]:

5

In [12]:

new_array[1:-1]

Out[12]:

array([2, 3, 4])

In [13]:

new_array[1:4:2]

Out[13]:

array([2, 4])

In [14]:

new_array[1::5]

Out[14]:

array([2])

 

Array Type

In [15]:

new_array

Out[15]:

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

In [16]:

new_array.dtype

Out[16]:

dtype('int32')

In [17]:

new_array2 = np.array([0.1, 0.2, 0.3])

In [18]:

new_array2

Out[18]:

array([0.1, 0.2, 0.3])

In [19]:

new_array2.dtype

Out[19]:

dtype('float64')

In [22]:

new_array3 = np.array([1,2,3,4], dtype=float)

In [23]:

new_array3

Out[23]:

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

In [24]:

new_array4 = np.array(['1', '2', '3'])

In [25]:

new_array4.dtype

Out[25]:

dtype('<U1')

In [26]:

new_array5 = np.array([{'a' : 1}, sys])

In [27]:

new_array5

Out[27]:

array([{'a': 1}, <module 'sys' (built-in)>], dtype=object)

In [28]:

new_array5.dtype

Out[28]:

dtype('O')

 

Dimension and Shapes

In [3]:

A = np.array([[1,2,3],[4,5,6]])

 

Numpy has multiple functions to work with multiple dimensional arrays

In [4]:

A.shape

Out[4]:

(2, 3)

In [5]:

A.ndim

Out[5]:

2

In [6]:

A.size

Out[6]:

6

In [10]:

B = np.array([
    [
        [12,11,10],[3,2,1],
    ],
    [
    [6,5,4],[3,2,1]
    ]    ])

In [11]:

B

Out[11]:

array([[[12, 11, 10],
        [ 3,  2,  1]],

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

In [12]:

B.shape

Out[12]:

(2, 2, 3)

In [13]:

B.ndim # multi dimentional arrays 

Out[13]:

3

In [14]:

B.size

Out[14]:

12

 

Indexing an slicing of Matrices

In [15]:

A[1]

Out[15]:

array([4, 5, 6])

In [16]:

A[1][1]

Out[16]:

5

In [17]:

A[0][1]

Out[17]:

2

In [18]:

A[1,0]

Out[18]:

4

In [19]:

A[0:2]

Out[19]:

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

In [20]:

A[:2]

Out[20]:

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

In [21]:

A[:1, :1]

Out[21]:

array([[1]])

In [22]:

B[1]

Out[22]:

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

In [24]:

B[0]

Out[24]:

array([[12, 11, 10],
       [ 3,  2,  1]])

In [25]:

B[0,1]

Out[25]:

array([3, 2, 1])

In [26]:

B[0][1]

Out[26]:

array([3, 2, 1])

In [27]:

B[:1][:1]

Out[27]:

array([[[12, 11, 10],
        [ 3,  2,  1]]])

 

Summary Statistics

In [28]:

a = np.array([1,2,3,4,5,6,7,8,9,10])

In [30]:

a.mean()

Out[30]:

5.5

In [32]:

a.sum()

Out[32]:

55

In [33]:

a.std()

Out[33]:

2.8722813232690143

In [34]:

a.var()

Out[34]:

8.25

 

Multi-dimensional Summary Statistics

In [35]:

A = np.array([
    [1,2,3],
    [2,3,4],
    [3,4,5]
])

In [36]:

A.sum()

Out[36]:

27

In [37]:

A.mean()

Out[37]:

3.0

In [38]:

A.std()

Out[38]:

1.1547005383792515

In [39]:

A.var()

Out[39]:

1.3333333333333333

In [40]:

A.sum(axis=0) # each column

Out[40]:

array([ 6,  9, 12])

In [42]:

A.sum(axis=1) # each rows

Out[42]:

array([ 6,  9, 12])

 

Broadcast and Vectorized operations

In [44]:

a = np.arange(4)

In [45]:

a

Out[45]:

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

In [46]:

a + 10

Out[46]:

array([10, 11, 12, 13])

In [47]:

a - 10

Out[47]:

array([-10,  -9,  -8,  -7])

In [48]:

a += 10

In [49]:

a

Out[49]:

array([10, 11, 12, 13])

In [50]:

a -= 10

In [51]:

a

Out[51]:

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

In [52]:

b = np.array([10,10,10,10])

In [53]:

a + b

Out[53]:

array([10, 11, 12, 13])

In [54]:

a - b

Out[54]:

array([-10,  -9,  -8,  -7])

 

Boolean Arrays

In [56]:

a = np.arange(4)

In [57]:

a

Out[57]:

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

In [58]:

a[0],a[-1]

Out[58]:

(0, 3)

In [59]:

a[[0,-1]]

Out[59]:

array([0, 3])

In [61]:

a[[True, False, False, True]]

Out[61]:

array([0, 3])

In [62]:

a >= 2

Out[62]:

array([False, False,  True,  True])

In [63]:

a[a>=2]

Out[63]:

array([2, 3])

In [64]:

a.mean()

Out[64]:

1.5

In [65]:

a[a > a.mean()]

Out[65]:

array([2, 3])

In [66]:

a[~(a > a.mean())]

Out[66]:

array([0, 1])

In [67]:

a[(a==0) | (a==1)]

Out[67]:

array([0, 1])

 

Linear Algebra

In [68]:

A = np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9]
    
])

In [69]:

B = np.array([
    [1,2],
    [3,4],
    [5,6]
])

 

Vector Algebra

In [70]:

A.dot(B)

Out[70]:

array([[ 22,  28],
       [ 49,  64],
       [ 76, 100]])

In [71]:

A@B

Out[71]:

array([[ 22,  28],
       [ 49,  64],
       [ 76, 100]])

In [72]:

B.T

Out[72]:

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

In [73]:

A

Out[73]:

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

In [74]:

B.T @ A

Out[74]:

array([[48, 57, 66],
       [60, 72, 84]])

 

SIZE of Objects in Memory

In [76]:

sys.getsizeof(1)

Out[76]:

28

In [77]:

sys.getsizeof(10**100)

Out[77]:

72

 

파이썬 Numpy 연습입니다. 

 

혹시 코드에 관해서 여쭈어보고 싶으신거나, 조언해주실게 있으시다면 

 

언제든지 댓글 달아주세요.