[Python] 2-1) Jupyter 기초

 

 

 

 

 7일차 (23.03.21)

 

 

/Jupyter

 

실행 차이점)

ctrl + enter : 출력은 나오는데 새로운 셀이 추가가 안됨

alt + enter : 실행결과 나오면서 무조건 새로운 in[]셀이 추가됨

shift + enter : 밑에 새롭게 셀이 추가 ,밑에 셀이 있을 경우 안 생김 이동만 됨

셀 위치 변경 화살표로 이동

 

주석 처리 방법)

cell - markdown : 주석 입력

# ,## - # 사용할수록 글씨 작아짐

> - 들여쓰기(?)

tap -

 

NUmPy(Numerical Python)

1 제공

빠르고 효율적인 다차원 배열 객체 ndarray

배열 원소를 다루거나 배열 간의 수학 계산을 수행하는 함수

디스크로부터 배열 기반의 데이터를 읽거나 쓸수 있는 도구

파이썬 확장과 c, c++ 코드에서 Numpy의 자료구조에 접근하고 계산기능을 사용할 수 있도록 해주는 a api

 

2 대용량 데이터 배열으 효율적으로 다룰수 있음

내부적으로 데이터를 다른 내장 파이썬 객체와 분리된 연속된 메모리 블록에 저장

내장 파이썬 연속된 자료형들보다 더 적은 메모리 사용

파이썬 반복문을 사용하지 않고 전체 배열의 복잡한 게산 수행

 

//시간 구하기
import numpy as np
my_arr = np.arange(1000000)
my_list = list(range(1000000))

%time for _ in range(10) : my_arr2 = my_arr *2
%time for _ in range(10) : my_list1 = [x*2 for x in my_list]

 

 

data1 결과 출력

data1 = np.random.randn(6)
data1

 

array([ 1.57022334, -0.8714609 ,  0.0933879 ,  0.44843192,  0.8857358 ,
        0.51839122])

 

2,3 2차원으로 배열 출력

data = np.random.randn(2,3)
data

 

array([[ 0.02403071,  0.13125449,  0.11574168],
       [ 0.42478843,  1.24618936, -0.89918944]])
​

 

곱해도 data 자체값은 변하지 않음

배열이여서 사칙연산 가능 리스트는 불가능 반복문 사용해줘야 함

 

data * 10

 

array([[ 1.52392701, -7.18952901,  7.2889993 ],
       [ 7.40316166, 10.66900725,  5.17644738]])

 

data + data

 

array([[ 0.3047854 , -1.4379058 ,  1.45779986],
       [ 1.48063233,  2.13380145,  1.03528948]])

 

data.shape

 

(2, 3)

 

data.dtype

 

dtype('float64')

 

---

ndarray : N차원 배열 객체

1. list 의 차이점

list는 여러 타입을 지원하지만 ndarry는 하나의 데이터 타입만 가능

ndarray는 알아서 하나의 타입으로 형변환

C의 arra와 동일

 

2. 생성하기

np.arrary함수를 이용하여 ndarray 형태로 변환

a = [1,2,3,4,5]

a_ndarray = np.array(a,int)

 

3. 파이썬은 배열 자료형을 제공하지 않으므로

배열의 표준 패키지는 numpy이며 배열 자료구조 ndarray를 제공

 

4. 벡터화 연산을 통해 간단한 코드로 복잡한 선형대수 연산

 

5. a_ndarray.shape #크기반환

a_ndarray.dtype #타입반환

a_ndarray.ndim #몇차원인지 반환

 

6. 소수점까지 있어야 정확한 Y값을 예측가능하므로 float사용

a_ndarray = np.array(a, dtype = np.float32)

 

data1 = [2, 3.3, 9, 3, 0]
arr1 = np.array(data1)
arr1

 

array([2. , 3.3, 9. , 3. , 0. ])

 

+배열은 자료형이 다 같아야하므로 - float타입으로 변경 됨

 

---

 

arr 구분)

• 0열 선택0열 다음에 열 추가
• 1열 선택1열 다음에 열 추가
• 2열 선택2열 다음에 열 추가

• 0행 선택0행 다음에 행 추가

1차원 arr - len(arr1) = 값(길이)

2차원 arr2 - len(arr2) = 행 값 - len(arr[0]) = '0인덱스 행의' 열

3차원 arr3 len(arr3) = 차원 값 len(arr3[0]) = 차원의 행값 len(arr3[0],[0]) = 행의 열값

1차원 arr

- len(arr1) = 값

 

2차원 arr2

- len(arr2) = 행 값

- len(arr[0]) = '0인덱스 행의' 열

 

3차원 arr3

len(arr3) = 차원 값

len(arr3[0]) = 차원의 행값

len(arr3[0],[0]) = 헹의 열값

 

 

 

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

 

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

 

len(arr2)

 

결과 값 -> 2 : 2개의 행

len(arr2[0])

 

결과 값 -> 4 : 열의 개수

arr2.ndim

 

결과 값 -> 2 : 차원 구하기 2차원

arr2.shape

 

결과 값 -> (2, 4) : 행열 구하기

 

 

---

 

zeros : 0으로 가득찬 array 생성

np.zeros(10) 

 

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

 

np.zeros((2,5))

 

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

 

a=np.zeros((2,3,4))
a

 

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

       [[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]]])

 

len(a)

 

결과값 -> 2 : 차원 개수

len(a[0])

 

결과값 -> 3 : 행

len(a[0][0])

 

결과값 -> 4 : 열

a.dtype

 

결과값 -> dtype('float64') :타입을 설정하지 않어서 float로 나옴

---

ance : 1로 가득찬 arrary

np.ones(10, dtype=np.int8)

 

array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], dtype=int8)

 

np.ones((2,4))

 

array([[1., 1., 1., 1.],
       [1., 1., 1., 1.]])       int 설정 안 해줌

 

empty : 초기화되지 않은 값으로 생성

np.empty(10, dtype=np.int8)

 

array([  0, -22,  59,  81, 113,   1,   0,   0,   0,   0], dtype=int8)

 

something_like : _like는 지정된 arrary의 shape 크기만큼 지정된 값으로 채원 array 반환

 

 

test_matrix= np.arange(30).reshape(5,6)
test_matrix

 

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, 26, 27, 28, 29]])

 

arange는 0부터 29까지 출력 하소 reshape(5,6) 2차원으로 다시 정렬

np.ones_like(test_matrix)

 

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

 

np.zeros_like(test_matrix)

 

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

 

 

---

 

range(10) : 파이썬 함수로 정수를 리스트로 반환 (0~9까지 출력)

np.arange(1, 10, 0.5) : 정수, 실수를 배열로 반환 ((1~9까지 0.5씩)

 

list

list_a = list(range(10))
list_a

 

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

 

배열

np.arange(1,10,0.5)

 

array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. ,
       7.5, 8. , 8.5, 9. , 9.5])

 

arr1 = np.array([1,2,3], dtype = np.float64)
arr2 = np.array([1,2,3], dtype = np.int32)

arr1.dtype
arr2.dtype

 

dtype('float64')     arr1
dtype('int32')       arr2

 

타입변환

float_arr = arr2.astype(np.float64)
float_arr.dtype

 

dtype('float64') 

 

//list -> array로 바꾸기
arr = np.array([1.2, 7.2, -2.4, 10.5])
arr

 

array([ 1.2,  7.2, -2.4, 10.5])

 

arr.astype(np.int32)    타입변경

 

array([ 1,  7, -2, 10])

 

int_arr = np.arange(10)
float_arr = np.array([.12, .62, .23], dtype = np.float64)

int_arr.astype(float_arr.dtype)
float_arr.dtype

 

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

 

---

백터와 연산 : 배열의 원소에 대한 반복연산을 하나의 명령어로 처리

data = [0,1,2,3,4,5,6,7,8,9]
answer = []
for i in data:
    answer.append(2*i)
answer

 

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

 

x = np.array(data)
x

 

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

 

x*2

 

array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

 

data * 2

 

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

 

리스트 객체에 정수를 곱하면 객체의 크기가 정수배 만큼 증가

- 배열에 넣어서 연산하면 값에 *2씩

- 배열이 아닌 리스트에 *2를 하면 데이터를 2번 출력

 

 

---

 

비교연산, 논리연산, 수학연산

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

 

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

 

len(arr)

 

결과값 ->2

 

len(arr[0])

 

결과 -> 3

arr * arr

 

array([[ 1.,  4.,  9.],
       [16., 25., 36.]])

 

arr-arr

 

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

 

1/arr

 

array([[1.        , 0.5       , 0.33333333],
       [0.25      , 0.2       , 0.16666667]])

 

arr ** 0.5

 

array([[1.        , 1.41421356, 1.73205081],
       [2.        , 2.23606798, 2.44948974]])

 

arr2 = np.array([[0., 4.,1.],[7.,2.,12.]])
arr2

 

array([[ 0.,  4.,  1.],
       [ 7.,  2., 12.]])

 

arr2>arr

 

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

 

a = np.array([1,2,3])
b = np.array([10,20,30])

a == 2

 

array([False,  True, False])

 

(a == 2) & (b>10)

 

array([False,  True, False])

 

결과가 배열마다 비교해서 결과 값이 여러개 나옴

배열 인덱스 끼리 연산 해줌

#all :배열의 모든 원소가 같은지 확인
np.all(a == b)

 

False    

 

비교값도 다 맞아야하고 비교값에 대한 결과 값도 다 충족할 때

 

---

연습문제)

 

다음과 같은 행렬을 만드시오 [10,20,30] [40,50,60]

 

#1
a1 = np.array([[10,20,30],[40,50,60]])
a1

 

#2
b1 = np.arange(10,70,10).reshape(2,3)
b1

 

array([[10, 20, 30],
       [40, 50, 60]])

 

---

인덱싱, 슬라이싱

인덱싱 - 특정 위치 인덱스 출력

슬라이싱 - 범위 설정 인덱스 출력

arr= np.arange(10)
arr

 

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

 

arr[5]

 

결과 => 5 : 0부터 5번째 값

arr[-1]

 

결과 => 9: 뒤에사 -1자리 출력

arr[5:8]

 

결과 => 5,6,7 : 5부터 8이전 까지 출력

arr[5:8]=12
arr

 

array([ 0,  1,  2,  3,  4, 12, 12, 12,  8,  9])

 

데이터는 복사되지 않고 뷰에대한 변경은 그대로 원본에 적용 됨

arr_slice = arr[5:8]
arr_slice

 

array([12, 12, 12])

 

arr_slice[1]=12345

 

arr_slice

 

array([   12, 12345,    12])

 

arr

 

array([    0,     1,     2,     3,     4,    12, 12345,    12,     8,
           9])

 

arr_slice[:]=64
arr

 

array([ 0,  1,  2,  3,  4, 64, 64, 64,  8,  9])

 

Numpy는 대용량의 데이터 처리를 염두에 설계되었으므로 복사하면 성능과 메모리에 문제가 생김

복사되는게 아니므로 복사가 하고싶다면 copy()

copy_arr=arr[5:8].copy()
copy_arr

 

array([   12, 12345,    12])

 

copy_arr[:]=10
copy_arr

 

array([10, 10, 10])

 

---

#1차원
arr

 

array([ 0,  1,  2,  3,  4, 64, 64, 64,  8,  9])

 

#2차원
arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2d[2]

 

array([7, 8, 9])

 

arr2d[0,2]

 

3

 

#3차원
arr3d =  np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
arr3d

 

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

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

 

arr3d[0]

 

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

 

arr3d.shape

 

(2, 2, 3)

 

old_value = arr3d[0].copy()
arr3d[0]=41
arr3d

 

array([[[41, 41, 41],
        [41, 41, 41]],

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

 

arr3d[0] = old_value
arr3d

 

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

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

 

arr3d[1,0]

 

array([7, 8, 9])

 

x = arr3d[1]
x

 

array([[ 7,  8,  9],
       [10, 11, 12]])

 

x[0]

 

array([7, 8, 9])

 

arr2d

 

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

 

arr2d[:2]

 

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

 

arr2d[:2, 1:]

 

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

 

arr2d[1, :2]

 

array([4, 5])

 

arr2d[:2,2]

 

array([3, 6])

 

arr2d[:, :1]

 

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

 

arr2d[:2,1:]=0
arr2d

 

array([[1, 0, 0],
       [4, 0, 0],
       [7, 8, 9]])

 

---

연습문제 2

m = np.array([[0,1,2,3,4],
              [5,6,7,8,9],
              [10,11,12,13,14]])

 

1. 이 행렬애서 값 7을 인덱싱한다

m[1][2]

 

2. 이 행렬에서 값 14를 인덱싱한다

m[2][4]

 

3. 이 행렬애서 배열 [6,7]을 슬라이싱한다.

m[1,1:3]

 

4. 이 행렬애서 배열 [7,12]을 슬라이싱한다.

m[1:,2]

 

5. 이 행렬애서 배열 [[3,4],[8,9]]을 슬라이싱한다.

m[:2,3:]

 

---

불리언값으로 선택

- 인덱스 배열의 원소가 true, false로 이루어짐

- 배열의 크기가 원래 ndarray 객체 크기와 같아댜함

a= np.array([0,1,2,3,4,5,6,7,8,9])
idx = np.array([True, False,True, False,True, False,
                True, False,True, False])
a[idx]

 

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

 

a%2

 

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

 

a%2 == 0

 

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

 

a[a%2==0]

 

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

 

names = np.array(['bob','job','will','bob','will','joe','joe'])
data = np.random.randn(7,4)
names

 

array(['bob', 'job', 'will', 'bob', 'will', 'joe', 'joe'], dtype='<U4')
​

 

data

 

array([[ 0.49658682, -0.49307438, -0.01707738,  1.2938424 ],
       [-0.14187906, -1.61501713,  0.71566874,  1.74687225],
       [ 1.64421097, -1.50169749, -1.22634295, -0.19370482],
       [ 0.00932732,  1.05577434,  0.78641164,  0.96078302],
       [-0.51055449, -0.140159  ,  0.74721061,  1.02268137],
       [ 2.18602266, -0.17206536, -0.84613705,  0.44909032],
       [ 2.32278243,  1.028269  , -0.1188879 ,  1.11725799]])

 

names =='bob'

 

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

 

data[names == 'bob']

 

array([[ 0.49658682, -0.49307438, -0.01707738,  1.2938424 ],
       [ 0.00932732,  1.05577434,  0.78641164,  0.96078302]])

 

data[names == 'bob', 2:]

 

array([[-0.01707738,  1.2938424 ],
       [ 0.78641164,  0.96078302]])

 

data[names =='bob', 3]

 

array([1.2938424 , 0.96078302])

 

names !='bob'

 

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

 

data[~(names =='bob')]

 

array([[-0.14187906, -1.61501713,  0.71566874,  1.74687225],
       [ 1.64421097, -1.50169749, -1.22634295, -0.19370482],
       [-0.51055449, -0.140159  ,  0.74721061,  1.02268137],
       [ 2.18602266, -0.17206536, -0.84613705,  0.44909032],
       [ 2.32278243,  1.028269  , -0.1188879 ,  1.11725799]])

 

cond = names =='bob'
data[~cond]

 

array([[-0.14187906, -1.61501713,  0.71566874,  1.74687225],
       [ 1.64421097, -1.50169749, -1.22634295, -0.19370482],
       [-0.51055449, -0.140159  ,  0.74721061,  1.02268137],
       [ 2.18602266, -0.17206536, -0.84613705,  0.44909032],
       [ 2.32278243,  1.028269  , -0.1188879 ,  1.11725799]])

 

mask = (names =='bob')|(names == 'will')
mask

 

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

 

data[mask]

 

array([[ 0.49658682, -0.49307438, -0.01707738,  1.2938424 ],
       [ 1.64421097, -1.50169749, -1.22634295, -0.19370482],
       [ 0.00932732,  1.05577434,  0.78641164,  0.96078302],
       [-0.51055449, -0.140159  ,  0.74721061,  1.02268137]])

 

data[data<0] = 0
data

 

array([[0.49658682, 0.        , 0.        , 1.2938424 ],
       [0.        , 0.        , 0.71566874, 1.74687225],
       [1.64421097, 0.        , 0.        , 0.        ],
       [0.00932732, 1.05577434, 0.78641164, 0.96078302],
       [0.        , 0.        , 0.74721061, 1.02268137],
       [2.18602266, 0.        , 0.        , 0.44909032],
       [2.32278243, 1.028269  , 0.        , 1.11725799]])

 

data[names != 'joe']=7
data

 

array([[7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [7.        , 7.        , 7.        , 7.        ],
       [2.18602266, 0.        , 0.        , 0.44909032],
       [2.32278243, 1.028269  , 0.        , 1.11725799]])

 

x = np.arange(1,21)
x

 

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20])

 

1. 배열에서 3의 배수를 찾아라

x[x % 3 == 0] 

 

array([ 3,  6,  9, 12, 15, 18])

 

2. 배열에서 4로 나누면 1이 남는 수를 찾아라

x[x % 4 == 1] 

 

array([ 1,  5,  9, 13, 17])

 

3. 배열에서 3으로 나누면 나누어지고 4로 나누면 1이 남는 수를 찾아라

x[(x % 3 == 0) & (x % 4 ==1)] 

 

array([9])

 

 

 

와 오늘 내용 왜케 많아!

 

 

 

#ABC부트캠프 #부트캠프 #유클리드소프트 #파이썬 #python #고용노동부 #한국산업인력공단