파이썬 라이브러리¶

matplotlib 을 이용하여 그래프 그리기¶

맷플롯립 패키지를 불러오고, 그래프를 노트북 문서 안에 나타낼 수 있도록 설정한다

import matplotlib.pyplot as plt
%matplotlib inline

리스트 데이터를 그래프로 나타내기

x = [0,1,2,3]
y = [0,1,4,10]
plt.plot( x, y )
plt.show()

numpy 라이브러리¶

numpy 를 이용하여 함수를 그래프로 그리기¶

numpy 라이브러리를 불러온다.

import numpy as np

numpy 를 이용하여 $x$ 데이터에 대한 리스트를 만들고, $y= \cos \left( 2x \right)$ 를 그린다.

x = np.linspace( -np.pi, np.pi, 101)    # 100 steps between -pi and pi 
y = np.cos( 2*x )                       # numpy가 제공하는 수학 함수
plt.plot( x, y )
plt.show()

다중 그래프 그리기

x = np.linspace(-np.pi,np.pi,101)    # 100 steps between -pi and pi
y = np.cos( 2*x )
z = np.exp( -x**2 )

fig = plt.figure()
axes = fig.add_subplot(1,2,1)
axes.plot( x, y )

axes2 = fig.add_subplot(1,2,2)
axes2.plot( x, z )
plt.show()

[참고] np. 을 생략하려면 numpy 라이브러리를 통째로 도입한다.

일반적인 math 라이브러리와 혼동될 수 있으므로 주의하여야 한다.

from numpy import *

x = linspace( -pi, pi, 101)          # 100 steps between -pi and pi 
y = cos( 2*x )                       # numpy가 제공하는 수학 함수
plt.plot( x, y )
plt.show()

배열 만들기¶

np.array() 함수

import numpy as np

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

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

파이썬의 리스트 데이터형 보다 더 효율적이다.

배열의 차원과 원소의 갯수

a.ndim

1

len(a)

5

2차원 배열

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

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

배열의 차원과 원소의 갯수

b.ndim

2

len(b)       # 첫번째 차원의 크기 (행의 갯수)를 반환한다.

2

행과 열의 갯수

b.shape

(2, 3)

np.arange() 함수

np.arange(10)

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

복수 인자: 시작, 끝, 간격

np.arange(1, 9, 2)         # 끝은 포함하지 않는다.

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

실수 범위를 일정 간격으로 나누는 경우에 유용하다.

np.arange(1, 2, 0.2)       # 끝은 포함하지 않는다.

array([1. , 1.2, 1.4, 1.6, 1.8])

끝점을 포함하고 싶다면, 다음과 같은 트릭을 쓸 수도 있다.

np.arange(1, 2.0001, 0.2)

array([1. , 1.2, 1.4, 1.6, 1.8, 2. ])

np.linspace() 함수

시작, 끝, 점의 갯수

a = np.linspace(0, 1, 6)
a

array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])

같은 간격으로 끝점을 포함하지 않으려면, 점의 갯수를 하나 줄이고 endpoint=False 로 설정한다.

a = np.linspace(0, 1, 5, endpoint=False)
a

array([0. , 0.2, 0.4, 0.6, 0.8])

a = np.linspace(0, 1, 5, endpoint=True)
a

array([0.  , 0.25, 0.5 , 0.75, 1.  ])

여러가지 행렬¶

단위 행렬

a = np.eye(3)
a

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

영 행렬

b = np.zeros((2, 2))
b

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

원소가 1인 행렬

c = np.ones((2, 3))
c

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

1차원 벡터를 대각 행렬로 만들기

d = np.diag(np.array([1, 2, 3, 4]))
d

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

다른 데이타 형식의 배열¶

복소수 배열

d = np.array([1+2j, 3+4j, 5+6*1j])
d

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

난수 발생¶

a = np.random.rand(4)          # 0 과 1 사이의 균등한 분포
a

array([0.00457864, 0.05477524, 0.5127786 , 0.48834374])

가우스 분포

b = np.random.randn(4)         # Gaussian
b

array([ 0.14260759, -0.87042911, -0.19687729,  1.47004801])

난수 발생기의 초기화

np.random.seed(1234)          # Setting the random seed

초기화에 필요한 정수를 만들려면, time 모듈을 사용하면 편리하다.

import time
time.time()       # 1970년 1월 1일 0시 0분 0초를 기준으로 현재까지 지나간 시간을 초 단위로 리턴

1544335829.5357673

np.random.seed( int(time.time()) )          # Setting the random seed

인덱싱과 슬라이싱¶

파이썬의 리스트와 같은 방식이 적용된다.

a = np.arange(10)
a

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

인덱싱¶

a[0], a[2], a[-1]

(0, 2, 9)

슬라이싱¶

마지막 인덱스는 포함되지 않는다.

a[1:3]

array([1, 2])

시작의 디폴트 값은 0 이다.

a[:4]

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

시작:끝:간격 조건을 명시하는 경우

a[2:9:3]           # [ 시작:끝:간격 ]

array([2, 5, 8])

원소를 역순으로 배치하려면

a[::-1]            # 원소를 역순으로 배치

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

다차원 배열의 인덱싱¶

a = np.diag(np.arange(3))
a

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

a[1, 1]

1

a[2, 1] = 10            # third row, second column
a

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

a[1]                   # second row

array([0, 1, 0])

배열의 수치적 연산¶

원소별 연산¶

스칼라와의 연산

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

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

a + 1

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

2**a

array([ 2,  4,  8, 16], dtype=int32)

배열 사이의 연산은 해당 원소 끼리의 연산이다.

b = np.ones(4) + 1
b

array([2., 2., 2., 2.])

a - b

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

이차원 배열의 곱셈은 행렬 곱셈이 아니다.

a * b                 # 같은 위치의 원소 끼리의 곱셈이다

array([2., 4., 6., 8.])

c = np.ones((3, 3))
c

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

c * c                 # 같은 위치의 원소 끼리의 곱셈이다

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

행렬 곱셈은 dot() 을 사용한다.

c.dot(c)                    # 행렬 곱셈

array([[3., 3., 3.],
       [3., 3., 3.],
       [3., 3., 3.]])

행렬의 곱셈 : np.dot( A, B )

np.dot( c, c )              # 행렬 곱셈

array([[3., 3., 3.],
       [3., 3., 3.],
       [3., 3., 3.]])

배열의 비교¶

같은 위치에 있는 원소들을 서로 비교한다.

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

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

a > b

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

배열을 통째로 비교하려면

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

np.array_equal(a, b)

False

np.array_equal(a, c)

True

모든 원소들이 같은 경우에만 참이다

배열의 논리 연산¶

a = np.array([1, 1, 0, 0], dtype=bool)
a

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

b = np.array([1, 0, 1, 0], dtype=bool)
b

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

np.logical_or(a, b)

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

np.logical_and(a, b)

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

배열의 초월 함수¶

x = np.linspace(-np.pi,np.pi,13)         # 12 steps between -pi and pi
x

array([-3.14159265, -2.61799388, -2.0943951 , -1.57079633, -1.04719755,
       -0.52359878,  0.        ,  0.52359878,  1.04719755,  1.57079633,
        2.0943951 ,  2.61799388,  3.14159265])

np.sin(x)

array([-1.22464680e-16, -5.00000000e-01, -8.66025404e-01, -1.00000000e+00,
       -8.66025404e-01, -5.00000000e-01,  0.00000000e+00,  5.00000000e-01,
        8.66025404e-01,  1.00000000e+00,  8.66025404e-01,  5.00000000e-01,
        1.22464680e-16])

x = np.arange(5)
x

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

np.log(x)

C:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in log
  """Entry point for launching an IPython kernel.

array([      -inf, 0.        , 0.69314718, 1.09861229, 1.38629436])

np.exp(x)

array([ 1.        ,  2.71828183,  7.3890561 , 20.08553692, 54.59815003])

원소들의 합

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

np.sum(x)

10

또는

x.sum()

10

최대값, 최소값

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

x.max()

3

x.min()

1

최대값, 최소값의 인덱스

x.argmax()         #최대값의 인덱스

1

x.argmin()         #최소값의 인덱스

0

논리 연산

np.all([True, True, False])

False

np.any([True, True, False])

True

[예] 같은 위치에 있는 모든 원소에 대하여, a 보다 b 가 같거나 크고, b 보다 c 가 같거나 큰가를 확인한다.

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

((a <= b) & (b <= c)).all()

True

통계¶

x = np.array([1, 1, 2, 3, 5])
x.mean()

2.4

np.median(x)              # 가운데에 위치한 값

2.0

x.std()                  # 표준편차

1.4966629547095764

컴퓨터, 프로그램 & 수학

블로그 보관함

2018년 9월 8일 토요일

파이썬 Numpy 수학 라이브러리