[패스트캠퍼스] BDA 부트캠프 학습일지_3주차

3주차 (0703-0707)
패스트캠퍼스 데이터 분석 부트캠프

 

 데이터 분석을 위한 핵심 Tool  Python ( 온라인 강의  1 - 초격자 데이터 사이언스) 

프로그래밍

컴퓨터에게 일을 시키는 과정

 

구성 요소

1. 코드: 프로그래밍 언어의 문법 / 의미론 (* 잘못 쓰면 실행 X)

2. 컴퓨터: 코드를 수행함.

• CPU (연산 담당) → instruction cycle을 계속 돌며 프로그램 실행
• Memory (데이터, 프로그램)
• I/O Device

Instruction cycle

 

파이썬

특징

• 프로그래밍 언어의 일종
• 인터프리터 기반: 컴파일러 기반과 달리 코드를 짧게 line by line 실행 가능 ∴ 느리지만 유연함 
• 데이터 분석 / 프로토타입 개발에 유리
• PyPI라는 오픈소스 라이브러리 → 확장성 우수함

 

데이터 타입

사람이 사용하는 데이터를 컴퓨터가 이해 가능하게 규격화한 것 ( 데이터를 담을 수 있는 그릇 역할 )

→ 컴퓨터가 이해, 소통 및 계산 가능

종류

int (정수), float (실수), str (문자열), list (변경 가능 데이터 그룹), tuple (변경 불가능 데이터 그룹), set (집합), dict (찾을 수 있는 값 key-그에 해당하는 정의 value의 store 방식)

---

파이썬 주요 함수

공통적인 특징

: 사용에 주의해야 됨 → : 이후의 statement는 그 조건에 걸리는 걸 정의하며 Block을 나눌 수 있음

 

1) IF 함수

조건에 따라 명령을 수행하는 statement (조건문)

∴ 조건문을 이용하는 것 = 의사결정을 하는 것

if condition : 
   <statement>
   <statement>
    ...
elif condition : 
   <statement>
    ...
else : 
   <statement>
    ...

* 주의점: 조건에 빠지는 게 없는지 체크 (ex/ list의 처음과 끝의 원소를 indexing 함) - edge case에서 자주 에러남

---

2) for, while 함수

조건에 따라 반복 작업을 수행하는 statement (반복문)

 

프로그래밍에서 중요한 것: 조건과 반복  ∴ 단순 X / 의도한 *어떤* 작업을 반복하게 할지 고안해야 됨

조건문 + 반복문 설계 → 프로그램의 logic 구성

for: 횟수에 따른 반복 수행 (특정 횟수 지정 or sequence를 반복)

for iterator in iterable_object:      ''' iterator: 변수,  iterable_object: 시퀀스 
   <statement>
   <statement>
    ...

while: 조건에 따른 반복 수행 (조건이 만족하는 동안 수행)

while condition:
   <statement>
   <statement>
    ...

---

3) 함수

input (parameter: a,b, ...)를 받아 output을 돌려주는 하나의 기능을 하는 코드 묶음

def function1 (a, b) :
   something = ...
   <statement>
   <statement>
    ...
   return something      '''끝을 의미
result = function1 (3,5)      '''function call (정의된 함수를 사용해 code block 내의 코드를 실행하는 것)

함수 만드는 법

• 기존 코드를 설계할 때부터 함수로 작성
• 재구조화 (refactoring): 기능을 하는 코드 만들고, 잘 실행되는 것을 확인한 후 보충해감

 

* 중요: 어떤 input으로 어떤 output을 낼지 잘 세팅해야 됨

함수의 구조화 ↑ → 가독성↑, 유지보수하기 쉬워짐 (재사용성 향상) → 코드의 생산성 향상

 

---

파이썬 주요 개념

1) I/O

Input: 데이터 입력 (함수 사용)    '''stdin

→ Output: 출력 결과    '''stdout

a = input ("숫자를 하나 입력하세요 : ")
print (a)
>>> 숫자를 하나 입력하세요 : 5
>>> '5'

 

file 형태의 input: 읽기 위해 file I/O (스토리지-프로그램 사이 I/O) 처리 필요함 

with open( "data/a.txt", 'r' ) as f:
    data = f.readlines ()

• with open() 함수로 코드가 존재하는 같은 경로 안의 폴더에서 텍스트 파일을 쉽게 불러올 수 있음
• mode: 'r', 'w', 'a' → read, write, append (뒤에 데이터 추가)
• 데이터 타입에 따라 필요한 라이브러리 달라짐

* 주의점: file 크면 성능 저하 가능함

---

2) OOP

Object-Oriented Programming (객체 기반으로 프로그래밍을 만드는 방법론)

 

매커니즘

1. 객체 ---추상화---> Class  //  2. Class ---구체화---> 객체

• Object(객체): 실제 사물 하나하나
• Class: 사물들이 공유하는 속성                                                                                                                                                     (variable: class를 기술하는 정보를 나타내는 변수, method: 특징을 설명하는 기능)

1. 개념의 추상화: 구현하고자 하는 대상에 대하여 불분명한 형태 (형태O / 구체적X)로 개념들을 프로그램에 옮기는 것
2. 개념의 구체화: Class를 하나하나 개별인 사물, 객체를 만드는 것

 

다양한 특징

   1. 상속: superclass의 모든 개념을 subclass가 이어받아 class variable / method도 그대로 받아서 구현함

                ∴ 하위에서 필요한 것만 추가, 수정할 것만 수정

 

 

   2. 다형성: 상속받으면 기능을 다르게 구현 가능.

                    즉, Class의 하나의 기능을 나타내는 개념이 상속되어 subclass로 구현시 다양한 결과 나옴

 

   3. 은닉화, 추상화: Class 내부의 variable, method 보지 않아도 기능을 사용하는데 문제 없음 ∴ 재사용성 ↑

 

장점

1. 생산성 ↑ : 데이터와 기능을 모두 갖추는 Class를 잘 설계하면 재사용 가능
2. 자연적인 모델링 : 일상의 개념을 그대로 구현
3. 재사용성 ↑ : 상속으로 재사용성 극대화
4. 유지보수 용이성 ↑ : Class가 다르게 구현돼 다른 기능에 영향 ↓

∴ 파이썬은 open-source library를 손쉽게 이용할 수 있음

---

3) Class

OOP에서 구현하려는 개념을 추상화한 코드 템플릿으로, 구현 대상의 특성과 기능을 명확히 정의해야 됨

 

생성자( constructor )를 이용해서 객체 형태로 찍어낼 수 있음.

class Human (superclass):      '''Human : 상속 받을 class명
   def __init__ (self, name, weight):       '''Constructor 구현, 객체는 self라는 변수를 가짐(자기 자신을 구분 O)
      self.name = name
      self.weight = weight      ''' 불러온 객체의 이름 및 무게
      ...
   def gain_weight (self, a, b):
      tmp_weight = self.weight + a
      <statement>
      ...
      return tmp_weight

>>> object1= Human("kim", 70)
>>> object1.name
>>> "kim"
>>> object1.gain_weight(5,7)
>>> 75      '''twp = self (70) + a(5) = 75

---

파이썬 라이브러리

Numpy / Pandas → 데이터 전처리,   Seaborn, Matplotlib, Pyplot → 데이터 시각화

# 없는 라이브러리 설치 가능
!pip install '라이브러리명'    

# 자주 사용하는 라이브러리 별칭(alias) 설정
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

1) Numpy

Numpy란?  최적화된 C code 구현하여 파이썬 한계를 개선하는 라이브러리 (np.어쩌구)

Numpy 중요한 이유:

• 수치 연산: 파이썬은 실수값 연산에 오류 많아 머신러닝에서 성능 저하로 이어짐 →  Numpy는 수치적 안정성 보장 
• 벡터 연산: 한 데이터 타입 사용하여 N개의 실수로 이루어진 벡터값 연산 가능 → 빠른 처리 가능

** 데이터 분석은 벡터 연산이므로 Numpy 중요

 

Numpy array : Numpy의 기본적인 자료 구조 ( 여러 숫자를 다루기 위한 구조 )

-  List와 비슷하나 세부적으로 다름

• 차이점:
  • 선언 이후 크기 변경 불가능
  • ** 모든 원소의 데이터 타입(float, int) 동일 ( 연산 고정된다고 보장 O ∴ 고려 사항이 빠짐 ) 

• 공통점: 인덱싱으로 원소 접근, 생성 이후 update 가능

- 특징

원소 크기 조절 → 크기에 따라 수치 범위 정해짐 ( 메모리 크기↓ - 수치 범위↑ 사이 적절한 값 찾아야 함)

(ex/ np.int8 : 수치 표현 8bits → 2^8개 → -128~127 /  np.float32 : 실수 표현 32 bits )

---

2) Pandas

Pandas란?  DataFrame 형태로 되어 정형 데이터 분석에 최적화된 라이브러리 (pd.어쩌구)

 

- 장점

• 정형 데이터의 효율적 표현 O ( 데이터 조작 : indexing, filtering, reshaping, concatenation, read, writing )
• 테이블 형태의 정제된 데이터 존재 ( 분석 O )
• html, csv, sql, xlsx 등의 정형 데이터가 모두 DataFrame 통일 → 다양한 데이터 통합 관리 가능
• 벡터 연산에 최적화 (Numpy와 연관됨) → 대용량에도 성능 우수
• 엑셀의 연산 기능 거의 다 제공 O

 

Pandas DataFrame : Pandas의 기본적인 자료 구조

 

표 (컬럼, 로우) → 2차원 테이블 구조  ( Series: 컬럼 하나, 로우 하나 → 1차원 구조도 가능 )

객체 변수: index (행), columns (열), values (값)

• Relational DB와 호환 가능
• 한 칼럼을 기준으로 모든 원소의 데이터 타입 동일
• Numpy array를 상위 호환하는 개념 ( 내부 구현체로 Numpy 사용 → universal function 사용 가능 )

---

3) 시각화 라이브러리

1. Seaborn   matplotlib을 기반으로 matplotlib의 개념을 확장한 통계적 데이터 시각화 라이브러리

• numpy, pandas 등 파이썬 라이브러리의 시각화를 중점 + DataFrame 직접적 지원 →  matplotlib보다 편하게 데이터 분석 시각화 가능
• 다양한 기본 plot (lineplot, boxplot, jointplot, pairplot) → 빠른 통계 분석 가능 ( 특히, EDA )

 

2. matplotlib   MATLAB의 기능 → 파이썬

• 파이썬의 시각화 라이브러리
• figure에 component (위의 파란 글씨) 추가하여 그래프 완성
• pyplot 이용 (빠르게) 또는 OOP-style (데테일하게) 이용

 

3. Pyplot

장점: 깔끔함, 코드에 있는 값들 바로 사용 가능

단점: 엑셀 그래프 대비 수정하기 어려움

 

# 불러오는 방법

import matplotlib.pyplot as plt
or
import matplotlib as mpl

# 실행 방법

plt.figure()  ''' 도화지 깔고
plt.plot( [0,1,2,3,4], [1,2,4,8,16] )   ''' 리스트를 기준으로 하는 선 그리고
plt.show()   ''' plot 보여주는 코드임.

# 실제 파이썬 구현 예시

#1. sample data 만들고 막대그래프 그리기

x=["americano", 'cafe latte', 'vanilla latte', 'cold brew', 'flat white']
y=[1463, 301, 866, 905, 274]

plt.figure(figsize=(8, 6)) #()사이에서 옵션 조정 가능함

# 모든 component는 plt.figure 이후, plt.show 이전에 추가해야 됨
plt.grid(alpha=0.3, color='black', linewidth=0.5)    # 격자 추가
plt. title('Coffe Sales', fontsize=14, loc='left')    # 차트 제목 추가
plt.xlabel('Menu')    # x축 제목 추가
plt.ylabel('Sales')    # y축 제목 추가
plt.ylim(0,2000)    # 최소, 최대값 범위 추가
plt.yticks([num for num in range(0,1600,200)])    # 눈금 추가

plt.bar(x,y, color='lightcoral', label='Sales') 
plt.plot([100,200,400,800,1600], label='Average')
plt.legend(loc='best')    # label=''와 같이 사용하여 라벨 표시

plt.show()

 

#2. sample data 만들고 Scatterplot 그리기

import numpy as np

x=np.random.random(100)
y=np.random.random(100)

plt.figure(figsize=(6,6))
plt.scatter(x,y, color='orange', marker='<', s=15, alpha=0.3)

plt.show()

 

#3. Subplot으로 여러 plot 그리기

plt.figure()
         
plt.subplot(1,2,1) 
plt.plot([0.1,0.3,0.5])

plt.subplot(3,2,2)
plt.plot([0.6,0.3,0.4])

plt.subplot(3,2,4)
plt.bar([1,2,3],[3,2,1])

plt.subplot(3,2,6)
plt.scatter([1,2,3,4,5],[5,3,4,2,4])

plt.show()

 

#4. DataFrame으로 plotting

df.plot  /  df

import pandas as pd
x=["americano", 'cafe latte', 'vanilla latte', 'cold brew', 'flat white']
y=[1463, 301, 866, 905, 274]
df=pd.DataFrame({"Menu":x,"Count":y})

df.plot(kind='barh', x='Menu', y='Count')
or df

 

---

 

 데이터 분석을 위한 핵심 Tool  Python ( 온라인 강의  2  -  직장인을 위한~) 

파이썬 기초 문법

사칙연산

• 더하기 + , 빼기 - 
• 나눗셈 / , 곱하기 * 
• 몫 // , 나머지 % ( 몫, 나머지 한번에: result = divmod(10, 3) 이라면 result[0] → 3, result[1] → 1 )
• 거듭제곱 ** ( 2**2  → 4 )

 

조건문

a = 10
if a > 1 :
    print('a 는 1보다 큽니다!')
>>> a 는 1보다 큽니다!

 

반복문

# for문
for a in [1,2,3]:
    print(a)
>>> 1 2 3

# while문
a = 0
while a < 3:
    a = a + 1
    print(a)
>>> 1 2 3

 

함수

def와 return을 사용한 함수 선언

def sum(a, b):
    c = a + b
    return c

sum(1, 2)   ''' 위에서 선언한 함수 실행
>>> 3

---

자료형의 종류

숫자형(int, float), 문자열(str), 참/거짓(bool), 리스트(list), 튜플(tuple), 딕셔너리(dict), 집합(set) 

→ 변수 : 자료형의 값을 담는 그릇 ( 변수 이름: 알파벳+숫자/언더바  ex/ var_2 등 )

 

- 종류

1. 숫자형: 숫자(Number) 형태로 이루어진 자료형

항목	항목Python 표현 예시
정수형 (int)	100, -100, 123, -123, 0
실수형 (float)	100.5, -100.5, 10e3, 10e5
복소수	1 + 2j, 10j, -10j
8 진수	0o25, 0o34
16 진수	0xFF, 0x2A

강제 지정 가능 :

a = int(1.0) 
print(a) 
>>> 1  

a = float(-1) 
print(a) 
>>> -1.0

 

2. 문자형: 문자(String) 형태로 이루어진 자료형

큰따옴표 "" 와 작은 따옴표 '' 를 활용해서 문자열을 만들 수 있음

#1. 여러줄 표현
c = """Life is too short,
You need Python
My life would be so long!
"""

#2. 문자열 안에 따옴표
c =  "Life is too short, You need 'Python'"

#3. 문자열 더하기
head = "Python"
tail = " is fun!"
head + tail
>>> Python is fun!

#4. 문자열 슬라이싱
c = "Life is too short, You need Python"
c[0]
>>> L
c[-2]
>>> o
c[0:4]
>>> Life 

#5. 문자열 나누기
split_c = c.split(' ')   ''' 공백 기준으로 나누어짐
split_c
>>> ['Life', 'is', 'too', 'short,', 'You', 'need', 'Python']
split_c[0]
>>> Life

 

3. 논리형: 참/거짓(Boolean) 형태의 자료형

• True, False 조건과, 아무것도 없다는 뜻인 None 타입
• Python 에서는
  • 1 값: True
  • 0과 None 값: False 

a = True
if a:
    print('True!')
>>> True!      ''' a=False라면 출력 시 아무 값도 나오지 않음

 

4. 리스트형: 요소(값)의 모음 형태의 자료형입니다

• 묶고 싶은 요소(값)들을 대괄호 ([ ]) 를 사용하여 감싸주어 만듦
  • 리스트명 = [요소1, 요소2, 요소3, ...]   ex/ a = [1, 2, 3, 4]
• Python 의 모든 자료형을 리스트의 요소로 담을 수 O

a = [1,2,3]

#1. 리스트 더하기
b = [4,5,6]
a + b
>>> [1, 2, 3, 4, 5, 6]

#2. 리스트 값 바꾸기
a[0] = 4
a
>>> [4, 2, 3]

#3. 리스트 요소 추가
a.append(4)
a
>>> [1, 2, 3, 4]

#3. 리스트 요소 제거
a.remove(4)
a
>>> [1, 2, 3]

#4. 리스트 요소 삽입
a.insert(1,4)
a
>>> [1, 4, 2, 3]

#5. 리스트 정렬
a.sort(reverse=True)      ''' reverse: 내림차순
a
>>> [3, 2, 1]
 
#6, 리스트 위치 반환
a.index(2)      ''' 2가 어느 인덱스에 존재?
>>> 1

#7. 리스트 개수 세기
a = [1,1,2,3]   
a.count(1)
>>> 2

#8. 리스트 길이 파악
len(a)
>>> 3

 

4. 튜플형

• 리스트형과 거의 비슷하지만, 변수를 읽기 전용( 삭제, 수정 불가능 ) 으로 만들고 싶을 때 사용합
• 묶고 싶은 요소(값)들을 괄호 (( )) 를 사용하여 감싸주어 만듦
  • 튜플명 = (요소1, 요소2, 요소3, ...)     ex/ a = (1, 2, 3, 4)

 

5. 딕셔너리형: 키(Key) - 값(Value) 쌍 모음 사전 형태의 자료형

• 리스트나 튜플과 다르게 순서가 없음
• 빠르게 값을 찾을 수 있음
• 키와 값 쌍들을 중괄호 ({ }) 를 사용하여 감싸주어 만듦
  • 딕셔너리명 = {'Key1': Value1, 'Key2': Value2, ...}    ex/ a = {'a' : 1, 'b' : 2 }
• 키(Key) 는 문자형/튜플,   값(Value) 은 모든 자료형을 담을 수 있음

a = {'Bulldog': 'dog', 'Munchkin' : 'cat'}

#1. 키 검색
a.keys()
>>> dict_keys(['Bulldog', 'Munchkin'])

#2. 값 검색
a['Bulldog']
>>> dog

#3. 값 추가
a['Poodle'] = 'dog'
a
>>> {'Bulldog': 'dog', 'Munchkin': 'cat', 'Poodle': 'dog'}

#4. 값 변경
a['Bulldog'] = 'cat'
a
>>> {'Bulldog': 'cat', 'Munchkin': 'cat', 'Poodle': 'dog'}

#5. 요소 삭제
del a['Bulldog']
a
>>> {'Munchkin': 'cat', 'Poodle': 'dog'}

#6. 모두 삭제
a.clear()
a
>>> {}

 

6. 집합형: 순서가 없고, 중복이 허용되지 않는 자료형입니다

• 묶고 싶은 요소들을 중괄호 ({ }) 를 사용하여 감싸주어 만듦
  • 집합명 = {요소1, 요소2, 요소3, ...}    ex/ a = {1, 2, 3}

b = {'H', 'E', 'L', 'L', 'O'}
b
>>> 
{'E', 'H', 'L', 'O'}

#1. 집합 표현 가능
a = {1,2,3,4,5}
b = {4,5,6,7,8}

# 교집합
a & b
>>> {4, 5}

# 합집합
a | b
>>> {1, 2, 3, 4, 5, 6, 7, 8}

# 차집합
a - b
>>> {1, 2, 3}

#2. 다른 자료형으로 변환 가능
a = {1,2,3,4,5}
print(type(a))
a = list(a)
print(type(a))

>>> <class 'set'>
<class 'list'>

---

제어문과 함수

1. 조건문

• 조건에 따라 참과 거짓을 판단하는 문장
• 비교 연산자를 기준으로 참/거짓을 판단 → 조건문 안에 있는 동작문을 순차적으로 실행
  • 비교 연산자: >, <, >=, <=, ==, !=
  • 논리 연산자: A and B, A or B, not A    (A, B: 비교 연산자를 사용한 조건문)
  • 그 밖의 연산자: A in / not in  " 리스트 / 튜플 / 문자열 "

 

# if, elif, else 문

#1. 비교 연산자
sleepy = True     # 조건문
if sleepy == True:
    print("커피를 마신다")    # 동작문 A
else:
    print("차를 마신다")      # 동작문 B
>>> 커피를 마신다

#2. in 연산자
status = ['happy', 'angry', 'sleepy']
if 'sleepy' in status:
    print("커피를 마신다")
elif 'sad' in status:
   print("술을 마신다")
else:
    print("차를 마신다")
>>> 커피를 마신다

 

 

2. 반복문

• 조건문이 거짓이될 때 까지 반복을 명령하는 구문
• for 문: 변수를 받아 반복  /   while 문: 일정 조건까지 반복

 

# while문

sleepy = True
awake_point = 3       # 잠이 깨는 시점
num_coffee = 0
while sleepy==True:                    # 조건 1 : 잠이 오면, 아래 실행
    num_coffee = num_coffee + 1
    print('커피를 {} 잔 마셨습니다!'.format(num_coffee))

    if num_coffee >= awake_point:      # 조건 2 : 잠이 깨는 시점이 되면, 아래 실행
        sleepy = False
        print('더이상 잠이 오지 않습니다')
    if num_coffee >= max_coffee:       # 조건 3 : 커피가 떨어지면, 아래 실행
        print('커피가 다 떨어졌습니다')
        break

>>> 커피를 1 잔 마셨습니다!
커피를 2 잔 마셨습니다!
커피를 3 잔 마셨습니다!
더이상 잠이 오지 않습니다

 

# for 문

drink = ['커피', '차', '물']
for item in drink:
    print('{} 을(를) 마셨습니다!'.format(item))
    if item=='차':
        break

>>> 커피 을(를) 마셨습니다!
차 을(를) 마셨습니다!

 

 

3. 함수

• 입력 값을 받아서 일정한 처리를 진행하고 출력값을 반환하는 장치
• 반복되는 작업을 묶어서 재사용 할 수 있도록 해주기 때문에 매우 중요
• 기본 문법
  • def 함수명(입력인수):
    return 출력인수

def drink_beverage(drink):
    for item in drink:
        print('{} 을(를) 마셨습니다!'.format(item))

drink_beverage(['커피', '차', '물'])    ''' 함수 사용 1
drink_beverage(['콜라', '사이다', '우유'])    ''' 함수 사용 2

>>> 커피 을(를) 마셨습니다!
차 을(를) 마셨습니다!
물 을(를) 마셨습니다!
콜라 을(를) 마셨습니다!
사이다 을(를) 마셨습니다!
우유 을(를) 마셨습니다!

# return 추가하여 출력값 활용하기
    return len(drink), drink[-1]
num_drink, last_drink = drink_beverage(['커피', '차', '물'])
print('총 {} 잔 마셨습니다'.format(num_drink))
print('마지막으로 {} 을(를) 마셨습니다'.format(last_drink))

>>> 총 3 잔 마셨습니다
마지막으로 물 을(를) 마셨습니다

---

입력과 출력

1. 입력: input()

favorite = input('당신이 가장 좋아하는 것은 무엇입니까?')

 

2. 출력: print()

print('{ }와 { }는 빠릅니다'.format(favorite, '비행기'))
or    print( f'{favorite}는 빠릅니다')

.format( 변수 ) or f'{ 변수 }를 통해 { }안에 변수의 값을 출력할 수 있음

 

3. 파일 읽고 쓰기

-  파일 생성하기

• open 을 사용해 새 파일을 만들 수 있음 → open 이후 반드시 close
• 파일 열기 모드
  • r : 읽기 모드 (수정 불가)
  • w : 쓰기 모드
  • a : 추가 모드 (파일의 마지막에 내용 추가)

f = open('new_file.txt', 'w')
f.close()

-  파일 쓰기

f = open('new_file.txt', 'w')
for i in range(1, 11):
    f.write('{}번째 줄입니다\n'.format(i))
f.close()

-  파일 읽기

f = open('new_file.txt', 'r')
for line in f.readlines():
    print(line)
f.close()

>>> 1번째 줄입니다
2번째 줄입니다
...
10번째 줄입니다

---

파이썬 고급 기능

1. List Comprehension

• 리스트를 빠르고 쉽게 생성할 수 있음
• 기본 문법
  • 리스트형 = [변수 for 변수 in [변수1, 변수2, 변수3, ...]]
  • 리스트형 = [변수 for 변수 in [변수1, 변수2, 변수3, ...] if 조건문 ]

new_list = [elem for elem in range(10) if (elem % 2) == 1]
new_list
>>> [1, 3, 5, 7, 9]

 

2. 예외 처리

• 오류가 발생할 때 오류를 무시하거나, 오류 유형에 따라 이후 조치를 추가해 주는 기능
• 기본 문법
  • try문: 우선적으로 실행할 구문 ...
  • except문 : 오류 발생 시 실행할 구문 ...

def error_function(input):
    for i in range(10):
        try:
            result = input / i
            print(result)

#1. 오류 무시
        except:
            pass
error_function(10)    >>> 10/0 이라는 오류는 무시하고, 10/1부터 실시됨.

#2. 예상되는 예외만 지정하여 처리
        except ZeroDivisionError:       # 0으로 나누었을 때 발생하는 에러만 무시
            pass
error_function('10')     >>> 1번 방법과 달리 문자열을 넣어 발생하는 오류도 감지할 수 있음.

 

3. 프로그램 모듈화

• 작성한 Python 코드를 실제 동작할 수 있는 프로그램처럼 만드는 방법
• 모듈화된 코드 → 다른 외부 장치에서도 import / 실행 가능
• 기본 모듈화 과정
  1. 프로그램 내용이 담긴 main() 함수를 만들어 줍니다
  2. if __name__=="__main__": 구문을 코드 가장 하단에 추가해 줍니다
  3. main() 함수를 추가된 구문에 들여쓰기를 맞춰서 실행될 수 있도록 합니다
  4. .py 파일을 만들어 주고, 프로그램 내용을 붙여넣습니다
  5. .py 파일을 실행합니다

# 모듈화 샘플 코드 (1~3 과정)
def main():
    item = input('당신이 가장 좋아하는 것은 무엇입니까?')
    print('저도 {} 을(를) 참 좋아합니다!'.format(item))
if __name__=="__main__":
    main()

# module_sample.py 파일 만든 이후 프로그램 실행 (4~5 과정)
!python module_sample.py

---

Numpy

데이터 슬라이싱과 정렬

1. 배열 생성하기

# 리스트 → numpy 변환
mylist = [[1,2,3], [4,5,6]]
np.array(mylist)

# 데이터 타입 지정
np.array([1,2,3], dtype=int / float )

# 자체 생성 함수
np.ones((3,3))    >>> [ 1,1,1 ] * 3
np.zeros((3,3))    >>> [ 1,1,1 ] * 3
np.eye(3,3)    >>> [ 1,0,0 ] , [ 0,1,0 ] , [ 0,0,1 ]
np.full((3,3), 10)    >>> [ 10,10,10 ] * 3
np.random.rand(3,3)    >>> [ 랜덤값,랜덤값, 랜덤값 ] * 3

# 등간격 배열 생성
np.arange(2, 10, 2)    >>> array([2, 4, 6, 8])    ''' 2부터 10 미만까지, 2 간격
np.linspace(1, 10, 5)    >>> array([ 1. , 3.25, 5.5 , 7.75, 10. ])   ''' 1~10 사이의 5개의 값

2. 슬라이싱

• arr[ 행(row) 인덱스, 열(column) 인덱스, ... N축 인덱스]

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

arr[0] or arr[0,:]   >>> array([1, 2, 3, 4])  ''' 1행 슬라이싱
arr[:,0]   >>> array([ 1, 5, 9, 13])  ''' 1열 슬라이싱
arr[0:2, 1:3]    >>> array([[2, 3], [6, 7]])   ''' 1,2행, 2,3열 슬라이싱

3. 인덱싱

# Fancy 인덱싱 ( 지정 Index 위치만, 리스트 [ ] 로 지정 )
arr[[0,2,3],:]      ''' 1, 2, 4행 인덱싱
arr[:,[0,1,2]]      ''' 1, 2, 3열 인덱싱
arr[[0,1],[0,1]]   ''' 1,2행, 1,2열 인덱싱 (겹치는 부분만)

# Boolean 인덱싱 ( 조건을 만족하는 값만 )
bool = np.array([[True, True, True, True],
                 [False, False, False, False],
                 [True, True, True, True],
                 [False, False, False, False]])
arr[bool]      >>> array([ 1, 2, 3, 4, 9, 10, 11, 12])

arr[arr>10]   >>> array([11, 12, 13, 14, 15, 16])

4. 유용한 Numpy 함수

# 최소값, 최대값  print(np.min(arr), np.max(arr))  >>> 1 16
# 최소값, 최대값 인덱스  print(np.argmin(arr), np.argmax(arr))  >>> 0 15
# 전체 합, 평균  print(np.sum(arr), np.mean(arr))  >>> 136 8.5
# 특정 값 인덱스  np.where(arr==5)  >>> (array([1]), array([0]))

5. 배열 차원 변환     * 변환하려는 차원과 크기가 맞지 않지 않으면 에러 발생!

# 1차원 -> 2차원 변환
arr1 = np.arange(10)
arr2 = arr1.reshape(2,5)  or  arr2 = arr1.reshape(2,-1)
>>>  array([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])

# 2차원 -> 1차원 변환
arr1 = arr2.reshape(1,-1)
>>> array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

6. 정렬

# 1차원 정렬
arr = np.array([10,2,3,4,6,5,7,8,1,9])
np.sort(arr)  >>> array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])   ''' 오름차순
np.sort(arr)[::-1]  >>> array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])   ''' 내림차순

# N 차원 정렬
arr = np.array([[11, 9, 11, 12],
                [8, 9, 5, 7],
                [3, 1, 2, 4],
                [14, 16, 13, 15]])
#1. 행 방향 (위에서 아래로)
np.sort(arr, axis=0)   >>> array([[ 3, 1, 2, 4], [ 8, 9, 5, 7], [11, 9, 11, 12], [14, 16, 13, 15]])
np.sort(arr, axis=0)[::-1]  >>> array([[14, 16, 13, 15], [11, 9, 11, 12], [ 8, 9, 5, 7], [ 3, 1, 2, 4]])
#2. 열방향 (왼쪽에서 오른쪽으로)
np.sort(arr, axis=1)   >>> array([[ 9, 11, 11, 12], [ 5, 7, 8, 9], [ 1, 2, 3, 4], [13, 14, 15, 16]])
np.sort(arr, axis=1)[::-1]   >>> array([[13, 14, 15, 16], [ 1, 2, 3, 4], [ 5, 7, 8, 9], [ 9, 11, 11, 12]])

---

Matrix 연산과 성능

 

• 대부분의 정형 데이터 세트는 행렬 형태로 이루어짐
• 행렬 연산: 딥러닝 분석에서 가장 자주 쓰이는 연산 중 하나
• Python 을 이용한 행렬 연산은 Numpy 가 가장 성능이 좋음

 

1. 행렬의 덧셈과 뺄셈: 연산되는 두 행렬의 차원이 같아야 함 

arr1 + arr2
arr1 - arr2

 

2. 행렬의 곱셈과 나눗셈

• Element-wise 연산 : 연산되는 두 행렬의 차원이 같아야 함

arr1 * arr2
arr1 / arr2

• * 내적 연산(Dot Product) : 연산되는 앞행렬(열)과 뒤행렬(행) 차원이 같아야 함.

arr1 = np.array([[1, 2, 3, 4],
                 [5, 6, 7, 8]])            ''' 2*4
arr2 = np.array([[1, 2],
                 [5, 6],
                 [9, 10],
                 [13, 14]])                ''' 4*2
np.dot(arr1, arr2)

>>> array([[ 90, 100],
                [202, 228]]) 

 

3. 행렬 집계 함수

합계(np.sum), 최대(np.max), 최소(np.min), 평균(np.mean), 표준편차(np.std)

• np.sum(arr, axis=0) : 행방향
• np.sum(arr, axis=1) : 열방향

 

4. Broadcasting 연산

저 차원 배열의 연산 → 고차원 배열로 확장

arr3d = 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]]])
arr2d = np.array([[0,1],[2,3],[4,5],[6,7]])

#1. 고차원으로 맞춰서 연산
arr3d + arr2d
>>>
array([[[ 0, 2], [ 4, 6], [ 8, 10], [12, 14]],  [[ 8, 10], [12, 14], [16, 18], [20, 22]],  [[16, 18], [20, 22], [24, 26], [28, 30]]])

#2. 단일 값 브로드캐스팅도 가능
arr2d + 10
arr2d * 10
arr2d / 10
>>> 각 값에 10을 더하고, 곱하고, 나눈 값이 출력