728x90
반응형
SMALL
728x90
반응형
SMALL

오늘 포스팅에서는 파이썬을 활용하여 숫자와 문자의 변형과 list를 관리하는 법에 대하여 알아보도록 하겠습니다.

list 관리를 설명하기 전에 간단하게 숫자와 문자의 변형을 어떻게 하는지에 대하여 알아보도록 하겠습니다.

숫자/문자의 변형 chr(숫자)/ord('알파벳')
print(65)
# JAVA -> print((char)65) 강제 변형 = type casting
print(chr(65))                                      # chr 함수 사용
print(ord('B'))

list 관리 

앞서 언급된 단어 'CRUD'의 의미에 대하여 먼저 설명해드리도록 하겠습니다.

모든 프로그램 언어를 사용하기위해서는 딱 4가지만 기억하고 다룰 줄만 아시면! 기본기는 단단하다고 보시면 됩니다

Create Read Upload Delete 데이터를 어떻게 생성하고, 불러오고, 추가하고, 삭제할 수 있는지 입니다!

이제 list로 데이터를 관리해보도록 하겠습니다~!

CRUD - Create
# list 라는 자료형 자체가 존재 -> [] or {} or ()
a = [10, 20, 30, 40]
print(a)                                            # 출력결과 -> [숫자들] <- list type
b = ['강아지', '호랑이', '코끼리']                       # 요소 -> 숫자 문자 다 허용
print(b)
c = [10, '호랑이', 3.14, True]                       # 서로다른 타입의 항목으로 넣어 맴버들의 설정이 가능 (Only Python)
print(c)

CRUD - Read
a = [10, 20, 30, 40]

1. 통짜로 a전체 출력

print(a)

2. 필요한 인덱스 번호만 출력

print(a[0], a[1], a[2], a[3])           # print(a[4]) <- out of bound / list index out of range

3. for i in 문장

for i in a:
    print(i, end=' ')
print()

for i in [1, 2, 3, 4]:                              # i 는 반복 카운팅용(looping)
    print(i, end=' ')
print()

for value in a:                                     # BUT 여기서는 내용을 꺼내기 떄문에 i 보다는 value, i10, data 를 더 선호
    print(value, end=' ')
print()

CRUD - Update
# 내부적으로 숫자를 대입하는 단순 과정이 아닌 삭제후 추가
a = [10, 20, 30, 40]
a[0] = 50
print(a)

print(id(a[0]), id(a[1]))                           # 고유민증번호

a[0] = 60
print(id(a[0]), id(a[1]))                           # 기존의 들어있는 data 를 삭제시키고 생성했다는것을 보여주는것

CRUD - Delete
a = [10, 20, 30, 40]
del(a[0])                                           # del, remove, erase (depends on language)
print(a)
print(len(a))                                       # a 의 길이를 보여준다 length or size (depends on language)

list 활용 - 내부 list( 1차원, 2차원, 3차원)
a = [10, '호랑이', [20, '코끼리', [30, '독수리']]]

print(a)                                            # list 포함 출력
print(a[2])                                         # 내부 list 만 출력
print(a[2][0], a[2][1])                             # 내부 list 의 선택적 출력
print(a[2][2][0], a[2][2][1])                       # 내부 list 속 내부 list 의 선택적 출력

a = 'Apple'
b = ['A', 'p', 'p', 'l', 'e']
print(a)
print(b)                                            # list 속 알파벳 요소
print(a[0], b[0])

a[0] = 'B' # err>> 문자열은 갱신 X

b[0] = 'B'                                          # list 로 관리된 문자는 갱신 가능
print(b)

a = [인덱스0, 인덱스 1, 인덱스 2] ← a = [10, '호랑이', [20, '코끼리', [30, '독수리']]]

index [0] : int

index [1] : str

index [2] : list

list 활용 - Update & Delete 활용
a = ['a', 'b', 'c', 'd', 'e']
print(a[1:3])                                       # 인덱스 번호 1 ~ 3앞 (3-1)개를 가져오기

a[1:3] = ['F', 'G']                                 # index 1, 3 삭제후, 'F''G'가 새로 갱신
print(a)

a[1:3] = ['H', 'I', 'J', 'K', 'L']                  # index 1, 2가 삭제 됬다고 2개만 갱신할수있는것이 아닌 그 자리로 여러개 대입
print(a)

a = ['a', 'b', 'c', 'd', 'e']
a[1:3] = []                                         # 특정부분만 delete 하고 싶을때 사용
print(a)

a = ['a', 'b', 'c', 'd', 'e']                       # 순수하게 삭제만 한다 (추가라는 개념자체가 없다)
del(a[1:3])
print(a)

list 활용 - append (항목 추가), insert (원하는 항목에 추가), pop (제거)
a = ['o', 'r', 'a', 'n', 'g', 'e']

1. append

print(a)

a.append('f')                                       # list 안에 항목을 추가 시키고 싶을때 append -> 맨뒤 추가
print(a)

a.append(10)                                        # type 상관없이 추가 가능
print(a)

2. insert

a.insert(1, 10)                                     # insert 함수는 원하는 인덱스 번호앞에 추가된다
print(a)

3. pop

a.pop()                                             # 무조건 맨 마지막에 있는 data 를 제거한다
print(a)

a.pop(3)                                            # 원하는 특정 위치의 data 를 제거
print(a)                                            # pop 은 인덱스를 지정해서 제거 , del 은 list 구간 지정 제거

Exception 처리 remove, index(찾고자 하는 인덱스 번호 찾기)

1. remove

a.remove('r')                                       # r을 검색을해서 검색된 r을 제거 시키고 한번을 제거 시키면 중단되기 때문에 뒤에는 지워지지 않는다
print(a)

try:                                                # 예외가 발생하면 try 로 exception 을 잡아준다
    a.remove('t')                                   # 검색에 실패하면 error 발생 (검색에서 반드시 있다고 판단될떄 사용)
except:                                             # 프로그램에서 못찾을 경우 exception 처리를 한다
    print('예외가 발생하였습니다')
    pass
print('호랑이')

2. index

a = ['o', 'r', 'a', 'n', 'r', 'e']

b = a.index('r')                                    # 찾은곳의 인덱스 번호를 알려준다
print(b)

try:
    a.index('t')                                    # index 는 return 값이 있다
except:
    print('예외가 발생하였습니다')
    pass
print('호랑이')

sort 함수 - 비용이 많이 든다 (메모리와 시간 둘중 하나를 선택)
a = ['a', 'c', 'e', 'f', 'd', 'b']
a.sort()                                            # 알파벳 순서대로 정렬을 시켜준다 (sort default )
print(a)                                            # sort 함수는 비용이 많이 든다 -> 1. 시간이 오래걸림 2. 메모리를 많이 사용

reverse() - 역순행이 아니라, 앞과 뒤의 data를 교환
a = ['a', 'c', 'e', 'f', 'd', 'b']
# 이미 정렬이 되어있는 배열을 쓰면 빠르다
a.reverse()                                         # 앞과 뒤의 data 를 swap 시켜준다
print(a)

지금까지 list를 활용한 CRUD에 대하여 알아보았습니다.

다음 포스팅으로는 append와 extend 차이, tuple과 list를 다루는 법등 많이 헷갈리는 함수와 dictionary의 CRUD에 대하여 알아보도록 하겠습니다~!

728x90
반응형
LIST
728x90
반응형
SMALL

이번 포스팅에서는 참일 때 실행될 문장의 참/거짓 조건으로 변환하는 연산자인 삼항 연산과 list(range())를 사용하여 숫자를 증가시키는 방법과 마지막으로 for문에 대하여 알아보도록 하겠습니다.

삼항 연산
num = 23
while True:
    print(num)
    num = num // 2 if num % 2 == 0 else (num * 3) + 1     # = 참일떄 실행 될 문장 if 참 조건 else 거짓 조건
    if num == 1:
        print(num)
        print('프로그램을 종료합니다')
        break

list(range(시작 숫자, 마지막 숫자 +1, step증가))
print(range(0, 10), type(range(0, 10)))              # range 는 단독 사용 X
                                                     # 0 < = x < 10 -> 첫번쨰 숫자부터 시작하여 마지막 숫자 앞까지 출력
a = list(range(0, 10))                               # 단독으로 사용 못하고 list 이용 -> 연속된 데이터를 관리하고싶을떄 사용
print(a)
print(list(range(5, 10)))                            # (linked 생략된 단어) list = []
print(list(range(3, 20, 2)))                         # 3 부터 19까지 step 증가를 2씩 출력

for 문

조건문 사용 시에는 tab(들여 쓰기)에 주의해야 합니다~!!

for i in [0, 1, 2, 3, 4]:
    print(i)

for i in [0, 1, 2, 3, 4]:
    print(i, end=' ')
print()                                             # 다음출력을 위해서 줄바꿈해주는 것은 for 문 밖에서 출력

for i in ['월, 화, 수, 목, 금, 토, 일']:
    print(i, end=' ')
print()

for i in ['강아지, 고양이, 햄스터']:
    print(i, end=' ')
print()

for i in range(0, 10):                              # For 문의 정석 코드
    print(i, end=' ')
print()

예제. 1) 구구단 5단 출력
for i in range(1, 10):
    print('5 *', i, '=', i * 5)

예제. 2) 1-10까지의 합
sum = 0
for i in range(1, 11):
    sum += i
    print(sum)

※ range를 사용할때는 마지막 숫자 +1 구별 주의

 

중첩 For 문
for i in range(0, 3):
    for j in range(0, 4):
        print('[', i, j, ']', end=' ')
print()

중첩 for 문 예제) 결과값 두 자리 숫자로 나타내기 (00, 01, 02...)
k = 0
for i in range(3):                                  # 0은 생략 가능
    for j in range(0, 4):
        print('%02d' % k, end=' ')
        k += 1
print()

다음 포스팅에서는 이어서 숫자/문자 변형, list 관리(CRUD)등 리스트 활용에 대하여 알아보도록 하겠습니다

728x90
반응형
LIST
728x90
반응형
SMALL

지난 포스팅에 이어 파이썬 초급 기초에 대하여 알아보도록 하겠습니다.

소수점 나타내기 round
print(round(3.145, 2))                         # 소수점 두자리까지 반올림/버림
print(round(3.14, 2))

배열
str = 'Apple'
print(str[4])

str = "무궁화꽃이피었습니다"
print(str[4])

str = "무궁화꽃이피었습니다"
print(str[-2])                          # 끝에서 2번째 (only in Python)

print(str[2:5])                         # 2는 가져올곳의 시작 : 뒤는 5번 앞까지
										# 인덱스 번호 2번부터 시작해서 5-2개 (3개)를 가져온다

str = "무궁화꽃이피었습니다"
print(str[:5])                          # 처음부터 5개 출력
print(str[5:])                          # 5번부터 끝까지 출력

print(str)                              # 전체 출력
print(str[:])                           # 전체 출력

문자열 대입 (컴파일 에러)
str = 'Apple'
a = str[0]                                      # A 출력
print(a)

b = str[ :2]
print(b)                                        # Ap 출력

Error

str [0]='B'                                                            # B는 글자 (문법 허용 X) => 문자열은 대입되는 순간부터 상수화. 즉, 대입을 못 받는다.

 

c = 'B' + str[1:]                               # 배열을 지정해서 대입
print(c)

값을 대입하는 3가지 방법 (%, {자릿수} , s =")

1. %를 사용

print('호%d 랑%s 이' % (10, '집'))
print('호%d 랑이' % 10)                          # 짝이 1개일때는 ()의 생략이 가능

2. {}를 사용 

{0번째: 10}{1번째: 호랑이}

print('무궁화{0}꽃이{1} 피었습니다'.format(10, '호랑이'))
print('%s 집에 %d가고 싶다' % ('나중에', 82))
print('{0} {1}자고 싶다'.format('지금', 82))

3. 함수="사용

s = '무궁화{0} 꽃이 {1}피었습니다'
print(s)                                       # {} 포함한 결과값
s.format(10, '호랑이')
print(s)                                       # 무궁화{0} 꽃이 {1}피었습니다 와 같은 결과값
t = s.format(10, '호랑이')                      # 함수를 이용한 변경
print(t)
s = s.format(10, '호랑이')                      # s 자체를 변경
print(s)

워드 카운트 (문자열의 길이와 개수, 인덱스 번호)
s = '무궁화꽃이피었습니다'
print(len(s))                                       # 문자열의 갯수

s = '무궁화꽃이무궁회피었무궁화습니다무궁화'
print(s.count('무궁화'))                              # 찾고자는 문자열의 갯수
print('무궁화꽃이무궁회피었무궁화습니다무궁화'.count('무궁화'))  # 직접 대입도 가능

s = '무궁화꽃이꽃이피었습니다'
print(s.find('피았'))                           
# 찾고자하는 문자열의 인덱스(번째수) 번호 / find 검색 실패 경우 항상 -1 return

문자열 출력 결과 대소문자 + 대치
s = 'Apple'                                     # 문자열을 관리하는 객체 생성
t = s + 'Orange'
s = s + 'Banana'
print(t, s)

print(s.lower())                                # 출력 결과를 소문자로
print(s)                                        # s 자체는 변경X

t = s.lower()                                   # 원본데이터는 변경시키지 않는 것이 원친 return 값 으로
print(t)

print(s.upper())                               # 출력 결과를 대문자로
print(s.replace('Banana', 'Orange'))           # 바나나 -> 오렌지
print(s)                                       # s 값이 변경이 안됬다는것은 대치결과를 return 값으로 받아준것

print(s.replace('banana', 'Orange'))           # 대소문자 구분하여 찾아야한다

list 크기, 관리, 분리
s = '무궁화 꽃이 피었습니다'
print(s.split())                              # 스페이스를 기준값으로 글자를 분리
# ['무궁화', '꽃이', '피었습니다'] -> 대괄호 list type(1개 이상의 결과값)
t = s.split()
print(t)                                      # s 자체의 변경 X

print(len(t))                                 # 배열의 크기 리스트의 크기

print(t[0], t[1]*3, t[2])                     # 문자열 자체가 배열로 되어있기떄문에 배열로 관리 + 반복횟수 출력

s = '무궁화:꽃:이:피었:습:니다'
print(s.split(':'))                           # default 는 스페이스며 :를대상으로 구분 (특글자 중심으로 분리)

산술 연산
print(16 + 3)
print(16 - 3)
print(16 * 3)
print(16 / 3)  # 몫
print(16//3)   # 몫 (정수)
print(16 % 3)
print(16 ** 3)

관계 (비교) 연산
print(3 > 2)
print(3 < 2)
print(3 >= 3)
print(3 <= 3)
print(3 == 3)
print(3 != 3)

논리 연산

# AND Java && 거짓이 하나라도 있으면 무조건 거짓

print("-----------")
print(False and False)
print(False and True)
print(True and False)
print(True and True)
# OR Java || 참이 하나라도 있으면 무조건 참
print("-----------")
print(False or False)
print(False or True)
print(True or False)
print(True or True)
# 부정 연산 Java ! 안에있는 결과를 변경시키지 않고 사용하려는때 사용
print("-----------")
print(not(3 > 2))

print(3 + 2 > 4 and 6 < 2 * 4)                  # 해석이 항상 산술 연산 부처
print(5 > 4 and 6 < 8)                          # 산술이 먼저 일어나기에 위의 문제와 동격
print(True and True)

print(((3 + 2) > 4) and (6 < (2 * 4)))          # 위의 모든 출력이 이러한 논리

랜덤 데이터 random과 randint (모사 데이터; 사물 레이션)

from random import* -> random number로부터 제공되는 random 모듈을 사용 

(randint, rnadom, uniform, randrange)

print(random())                                 # 0.0부터 1.0 사이의 값을 랜덤하게 출력
# 3 <= x <= 5 -> 3과 5를 포함
print(randint(3, 5))                            # 3-5 사이의 수를 랜덤 출력
print(randint(10, 100))                         # 10 -100 사이의 수를 랜덤 출력

 - 숫자 2부터 시작해서 20 사이에 있는 숫자를 3씩 증가를 했을 때

print(randrange(2, 20, 3))                      # 2 5 8 11 14 17 20 중 한개를 랜덤하게 뽑아준다

압력 값 (= java print scanner)
a = input('입력하세요:')                          # 숫자를 입력 받기를 원할떄
print(a, type(a))                              
print('----------------')					   # string -> int 로 출력하는 3가지 방법

1. 

print(int(a)*int(a))

2. 

print(int(a)**2)

3. 

a = int (input('입력: '))
print(type(a), a**2)
제어문 (if, while)

1. if 제어문

if (제어문)에 열고 닫아도 되지만 정석은 아니다. () 생략이 정석!

if 3 > 2:                                   # 2. 제어문에 끝에는 :이 붙는다
    print(1)                                    # 3. 조건이 만족할때의 실행 문장은 tab 처리 (하지않을경우 에러 )
    print('----------------')

if 3 > 4:
    print(1)
else:
    print(2)

if 3 > 4:
    print(1)
else:
    print(2)
    print(3)                                    # 위와의 구분이 없으면 enter 를 3번정도 두고 거리를 둔다 if else 상관없이 출력

if 3 > 4:
    print(1)
else:
    print(2)
	print(3) 									# else 문에 들어가 있는 출력값으로 뜬다

2. while 제어문

a = 0
while a < 10:
    a += 1
    print(a)
    print('호랑이')

a = 0
while a < 10:
    a += 1
    if a == 3:
        continue
    if a == 6:
        break
        print(a)
    print('집')

다음 포스팅에서는 이번 포스팅과 연관된 간단한 예제를 풀어보도록 하겠습니다.

728x90
반응형
LIST
728x90
반응형
SMALL

이번 포스팅에서는 파이썬을 배우기에 가장 기초적인 단계를 시작으로 차근차근 설명을 해보도록 하겠습니다.

파이썬 파일 생성하기

이전 포스팅으로 파이썬과 파이참을 설치하셨다면, new project를 생성해주시면 됩니다~! (저는 Day1으로 설정했습니다)

다음 새로운 파이썬 파일을 만들기 위해 Python_Study 디렉토리를 생성하고 Day1의 파이썬 파일을 생성하여 시작합니다

주석 # (코드의 의미 설명 또는 메모에 요긴하게 사용)

shift F10 = 실행의 단축키

코드를 실행할때, 실행할 파일명을 확인해줍니다. (main일 경우, day1은 실행되지 않기 때문에 주의!!!)

숫자 / 문자 출력
print('호랑이')
print(10, '호랑이', 20, '독수리')  # 콤마가 자동으로 출력에 한칸을 띄어준다
print(3.14)                    # 부동 소수 타입
print(True, False)             # 첫 대문자를 사용해야한다
print(10) ; print(20)          # 한줄 처리를 하고 싶을떄 ; 사용
print(10, end='\n')            # 자동으로 줄바꿈 end='\n' (carriage return)이 생략되어있다
print(10, end=' ')             # 출력값이 한줄 default

구분선과 입력
print('--------------------------------')      # Separate = 구분선
print('-'*50)                                   # 50개의 '-'로 구분선 생성가능
print(''*50)                                   # 출력하고자하는 문자열 반복
print('%d %d %s' %(10, 20, '호랑이'))            # 숫자 혹은 문자열 %d %s 입력값은 %()안에 입력
print('코%d 끼%d 리%s' %(10, 20, '호랑이'))       # %앞에 입력가능

Default 값의 활용 sep, end
print(10, 20, 30, 40)
print(10, 20, 30, 40, sep=' ')
print(10, 20, 30, 40, sep=',')                  # default -> sep(띄어쓰기 스페이스 또는 콤마로 나타내기)
print(10, 20, 30, 40, sep=',', end='\n')        # default -> end(default 값으로 줄바꿈도 제어가능)

변수 Type 확인
print(type(10), type('호랑이'), type(3.14), type(True))      # 변수의 type 정보를 알려준다
print( type([ ]), 	  type(( )),       type({ }))
# 숫자 10, 문자 '호랑이', 숫자 3.14, True 값
# [list], (Tuple), {Dictionary}

숫자 문자 연산
print(10 + 20)
print(10 + '호랑이')               # 문법이 성립하지 않음
print('호랑이' + 10)               # 마찬가지
print('호랑이' + '독수리')
print(10 + int('123'))           # 문자열 -> 숫자 int('문자열')
print('호랑이' + str(10))          # 숫자 -> 문자열 str(숫자)

변수 선언 방법의 유형

1. Python은 변수를 선언하는 타입은 없다.

java의 경우, 변수를 선언해 주어야 한다

int a = 10;
int b = 20;

Python의 경우, 변수 선언이 생략된다.

a = 10
b = 20
print(a, b)

2. 중복 변수를 선언할 경우, 과거의 변수는 사라지고 새로만든 변수가 적용된다.

- 가장 마지막 변수만 적용

a = 10
b = 20
a = 30; b = 40;
print(a, b)

3. 변수를 2-3개 동시에 사용할 수 있다.

a, b = 50, 60
print(a, b)
a, b, c = 1, 2, 3
print(a, b, c)

4. 두 변수의 값을 동시에 대입할 수 있다.

 

a = b = 70
print(a, b)

※ Error

a = 10; b = 20 # ;을 사용하여 두 변수를 한줄에 입력할 수 있다
a = 10, b = 20 # Error

Python의 SWAP
a = 10
b = 20
b, a = a, b
print(a, b)



a++

a++ 코드는 유일하게 Python에서만 작용이 되지않기때문에 2가지 방법으로 표기할 수 있다.

a = 100
a = a + 1			# 첫번째 방법
a += 1				# 두번째 방법
print(a)
고유 식별 번호
a = 10
b = 20
c = 10
print(id(a), id(b), id(c))     # a와 b의 고유 번호 BUT c(a의 고유번호와 같음) 경우, 같은 id를 가진다 (only in Python)
a = '호랑이'
b = '코끼리'
c = '호랑이'
print(a, b, c)

16 진수 표현
a = 0x20
print(a)
b = 0o0376                          # 0x or 0o를 사용하여 표현한다
print(b)

복소수의 연산
a = 1 + 2j                       # language j 복소수 i 의미
b = 3 + 4j
print(a + b)

나누기
a = 10
b = 3
print(a/b, a%b, a//b)                           # 몫, 나머지 , 몫의 정수

pow 제곱
print(2**8)

지금까지 파이썬은 기본 입출력에 대하여 알아보았습니다.

다음 포스팅에서는 문자열, list, 산술/비교 연산, 논리연산, 랜덤 데이터, 제어문 등에 대하여 기초 day2로 알아보도록 합시다.

728x90
반응형
LIST
728x90
반응형
SMALL
Python 설치하는 방법

https://www.python.org/

 

Welcome to Python.org

The official home of the Python Programming Language

www.python.org

파이썬 공식 링크를 들어가면

자신의 컴퓨터 환경에 맞는 버전을 선택해 줍니다

저의 경우, Windows 환경에서 설치하기 위해 python releases for window 3.9.0 버전을 선택해 주었습니다.

WindowsX86-64 executable installer 설치

그런 다음, add python 3.9 to path check (경로설정)후, Custonmize installation 하고

next를 누른 뒤, C:\Python\Python39으로 install location을 바꿔줍니다. (나중에 라이브러리들을 설치하기에 편하도록 하기 위한 것이기 때문에 Custimize installation을 굳이 해줄 필요는 없습니다, 단지 "추천"인 거죠~!)

이렇게 하면, python설치는 간단하게 완료되었습니다.

 

python 3.9(64-bit)를 실행할 경우 바로 terminal mode 입장을 합니다.

터미널로 사용하지 않으실 분들은 다음 tool 설치를 위해 ctrl + z로 종료하고 Pycharm을 설치해보도록 합시다!

 

PyCharm 설치

https://www.jetbrains.com/ko-kr/pycharm/download/#section=windows

 

다운로드 PyCharm: JetBrains가 만든 전문 개발자용 Python IDE

최신 버전 다운로드: PyCharm (Windows, macOS, Linux)

www.jetbrains.com

공부를 위한것이라면 순수 Community를 다운받으시면 됩니다

홈페이지를 들어가서 (도구 - IDE - PyCharm - 다운로드 - Community 설치) 순으로 들어가서 위의 화면이 뜨면 다운로드해주세요!

이번에는 따로 커스텀하지 않고 종료 창 전까지 next를 선택한 후, 설치를 완료합니다.

 

오늘 포스팅은 파이썬 기초를 시작하기 전, 설치방법에 대하여 간단하게 설명해 보았습니다. 

다운을 받고 설치를 하셨다면, 다음 포스팅부터는 파이썬 초급이자 가장 기초적인 입력과 출력에 대하여 설명하겠습니다.

728x90
반응형
LIST
728x90
반응형
SMALL

이번 포스팅은 데이터 정규화(Normalisation)에 대해서 알아보도록 하겠습니다.

 

정규화(Normalisation)가 중요한 이유?

머신러닝 알고리즘은 데이터가 가진 feature(특성)들을 비교하여 데이터의 패턴을 찾습니다.

그런데 여기서 주의해야 할 점은 데이터가 가진 feature의 스케일이 심하게 차이가 나는 경우 문제가 되기 때문이다.

데이터의 차이는 모델의 성능을 좌우하기 때문에 신경망 같은 알고리즘들은 데이터의 스케일에 굉장히 민감합니다.

그래서 알고리즘들에 맞게 데이터의 특성 값들을 조절하게 되는데요, 보통 특성마다 스케일을 조정하여 데이터를 변경시킵니다.

예시를 한번 보겠습니다.

우선, 기본적으로 필요한 라이브러리를 임포트 해줍니다.

 

왼편의 그림은 데이터를 전처리 하기 전인 원본 데이터, 오른쪽은 각종 전처리 방법을 사용했을 때의 4가지 모습을 보여주고 있습니다.

본격적으로 전처리 방법에 대해 간단히 이야기해보겠습니다.

 

StandardScaler

scikit-learn의 StandardScaler는 각 특성의 평균을 0, 분산을 1로 변경하여 모든 특성이 같은 크기를 가지게 합니다. 하지만 최솟값과 최댓값 크기를 제한하지는 않습니다. 공식은 다음과 같습니다.

σ는 표준편차를 의미하고, x는 특성 값, 평균을 의미합니다. 이 결과를 표준 점수 또는 z-점수(z-score)라고도 합니다.

RobustScaler

RobustScaler는 일단 특성들이 같은 스케일을 갖게 된다는 것은 StandaradScaler와 비슷하나, 평균과 분산 대신 중간값 mediummedium과 사분위 값 quartilequartile을 사용합니다.

여기서 중간값이란 x보다 작은 수가 절반이고, x보다 큰 수가 절반인 x를 의미합니다. 단순히 평균이라고도 생각할 수 있는데요, 좌표 평면을 활용하기 때문에 각 사분위 별 개수가 중요합니다.

1 사분위 값은 x보다 작은 수가 전체 개수의 1/4인 x이고, 3 사분위는 x보다 큰 수가 전체 개수의 1/4인 x를 의미합니다. 공식은 다음과 같습니다.

q2는 중간값, q1은 1 사분위 값, q3은 3 사분위 값입니다.

이러한 방식 때문에 RobustScaler는 전체 데이터와 아주 동떨어진 데이터 포인트에 영향을 받지 않습니다. 이런 이상한 (멀리 떨어진 데이터)를 이상치(outlier) 라고 합니다. 이는 다른 스케일 조정 기법에서는 문제가 될 수도 있습니다.

MinMaxScaler

MinMaxScaler는 모든 특성이 정확하게 0과 1 사이에 위치하도록 데이터를 변경합니다. 2차원 데이터셋일 경우에는 모든 데이터가 x축의 0 ~ 1, y축은 0 ~ 1 사이의 사각 영역에 담기게 됩니다. 공식은 다음과 같습니다.

Normalizer

Normalizer는 매우 다른 스케일 조정 기법입니다. 이 방식은 특성 벡터의 유클리디안 길이가 1이 되도록 데이터 포인트를 조정합니다. 다른 정규 기법인 StandardScaler, RobustScaler, MinMaxScaler 기법은 특성들의 열 (특성)의 통계치를 사용하지만, Normalizer는 행(데이터 포인트)마다 각기 정규화됩니다.

다른 말로 하면 지름이 1인 원( 3차원 일 땐 구 )에 데이터 포인트를 투영하게 됩니다. 이 말은 각 데이터 포인트가 다른 비율로 (길이에 반비례하여) 스케일이 조정된다는 뜻이 됩니다. 이러한 정규화(normalizationnormalization)는 특성 벡터의 길이는 상관없고 데이터의 방향(또는 각도) 만이 중요할 때 많이 사용합니다.

데이터 변환 적용하기

여러 종류의 변환을 알아보았습니다. cancer 데이터셋에 커널 SVM(SVC)를 적용시키고 MinMaxScaler를 적용시켜 보겠습니다.

sklearn.preprocessing 모듈은 사이킷런에서 각종 전처리 작업을 위한 파이썬 클래스를 내장하고 있습니다.

MinMaxScaler 내부에는 fit 메서드가 존재합니다.

이 메서드는 모델을 훈련시키기 위해 존재하는 메서드가 아닌 각 특성마다의 최소, 최댓값을 계산해 줍니다.

따라서 특성을 의미하는 X_train만 넘겨줍니다.(y_train)은 사용하지 않습니다.

실제 fit 메서드를 통한 변환을 적용시키려면 transform() 메서드를 사용합니다.

transform은 새로운 데이터 표현(representation)을 만들 때 사용하는 메서드입니다.

변환된 배열 크기(shape)는 원본 배열과 동일합니다.

스케일 조정 후를 살펴보면 모든 특성의 최솟값과 최댓값이 각각 0과 1로 바뀐 것이 확인됩니다.

이 데이터에 SVM 모델을 적용하려면 테스트 데이터셋도 스케일 조정이 되어야 합니다. 이번엔 X_test를 조정하겠습니다.

이상하게도 똑같이 스케일을 조정했지만 0 또는 1이 나오지 않습니다. 그리고 0과 1의 범위를 넘어가 버리는 값도 존재하는 것이 확인됩니다.

모든 스케일 모델들은 항상 훈련 세트와 테스트 세트에 같은 변환을 적용시켜야 합니다. transform 메서드는 테스트 세트의 최솟값과 범위를 사용하지 않고, 항상 훈련 세트의 최솟값을 빼고 훈련 세트의 범위로 나눕니다. 간단하게 공식으로 살펴보면 다음과 같습니다.

훈련 데이터와 테스트 데이터의 스케일을 같은 방법으로 조정하기

지도 학습 모델에서 테스트 세트를 사용하려면 훈련 세트와 테스트 세트에 같은 변환을 적용해야 한다는 점이 중요합니다.

일단 이번 예제에서는 위와 반대로, 테스트 세트의 최솟값과 범위를 사용했을 때 어떤 일들이 일어나는지 보겠습니다.

from sklearn.datasets import make_blobs
# 인위적인 데이터 생성하기
X, _ = make_blobs(n_samples=50, centers=5, random_state=4, cluster_std=2)
# 훈련 세트와 테스트 세트로 나누기
X_train, X_test = train_test_split(X, random_state=5, test_size=.1)

# 훈련 세트와 테스트 세트의 산점도 그리기
fig, axes = plt.subplots(1,3,figsize=(13, 4))
axes[0].scatter(X_train[:, 0], X_train[:, 1], c=mglearn.cm2(0), label="훈련 세트", s=60)
axes[0].scatter(X_test[:, 0], X_test[:, 1],c=mglearn.cm2(1), label="테스트 세트", s=60, marker='^')
axes[0].legend(loc='upper left')
axes[0].set_title("원본 데이터")

# MinMaxScaler를 사용해 스케일 조정하기
scaler = MinMaxScaler()
scaler.fit(X_train)
X_train_scaled = scaler.transform(X_train)
X_test_scaled  = scaler.transform(X_test)

# 스케일이 조정된 데이터의 산점도 그리기
axes[1].scatter(X_train_scaled[:, 0], X_train_scaled[:, 1], c=mglearn.cm2(0), label="훈련 세트", s=60)
axes[1].scatter(X_test_scaled[:, 0], X_test_scaled[:, 1], c=mglearn.cm2(1), label="테스트 세트", s=60, marker='^')
axes[1].set_title("스케일 조정된 데이터")


# 테스트 세트의 스케일을 따로 조정하기
# 테스트 세트의 최솟값은 0, 최댓값이 1이 됨
# 절대로 이렇게 사용하지 말것!

test_scaler = MinMaxScaler()
test_scaler.fit(X_test)
X_test_scaled_badly = test_scaler.transform(X_test)

# 잘못 조정된 데이터의 산점도 그리기
axes[2].scatter(X_train_scaled[:, 0], X_train_scaled[:, 1], c=mglearn.cm2(0), label="훈련 세트", s=60)
axes[2].scatter(X_test_scaled_badly[:, 0], X_test_scaled_badly[:, 1], 
                                    marker='^', c=mglearn.cm2(1), label="테스트 세트", s=60)
axes[2].set_title("잘못 조정된 데이터")

for ax in axes:
    ax.set_xlabel("특성 0")
    ax.set_ylabel("특성 1")

첫 번째 그림은 단순히 2차원 원본 데이터셋이며, 훈련 세트는 파란 동그라미, 테스트 세트는 빨간 세모로 표시합니다.

두 번째 그래프는 같은 데이터를 MinMaxScaler를 이용해 스케일을 조절하였는데, 각 그래프의 눈금 빼고는 모양이 변한 것이 없습니다.

하지만, 테스트 데이터(세모)의 최솟값과 최댓값이 0과 1은 아닙니다.

문제는 세 번째 데이터입니다. 훈련 세트와 테스트 세트에 대해 각각 스케일을 조정한 경우, 각 데이터셋이 서로 다르게 스케일 되었기 때문에 삼각형의 배치가 뒤죽박죽 되었습니다.

지도 학습에서 데이터 전처리 효과

다시 cancer 데이터셋으로 돌아와서, SVC를 학습시킬 때 MinMaxScaler의 효과를 확인해 보도록 하겠습니다.

from sklearn.svm import SVC

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=0)

svm = SVC(C=100)
svm.fit(X_train, y_train)
print("테스트 세트 정확도: {:.2f}".format(svm.score(X_test, y_test)))

스케일이 조정되지 않은 원본 데이터의 정확도는 63%의 정확도 밖에 표현하지 못합니다. 다음은 스케일 조정 후의 학습 결과입니다.

# MinMaxScaler 사용
scaler = MinMaxScaler()
scaler.fit(X_train)
X_train_scaled = scaler.transform(X_train)
X_test_scaled  = scaler.transform(X_test)

# 조정된 데이터로 SVM 학습
svm.fit(X_train_scaled, y_train)

# 스케일 조정된 테스트 세트의 정확도
print("스케일 조정된 테스트 세트의 정확도: {:.2f}".format(svm.score(X_test_scaled, y_test)))

단순히 스케일만 조정했을 뿐인데 그 효과는 매우 큰 것이 확인됩니다.

스케일을 조정하는 모든 파이썬 클래스들은 fit과 transform을 제공하므로 손쉽게 전처리 알고리즘을 바꿔낼 수 있습니다.

# 평균 0, 분선 1을 갖도록 스케일 조정하기
from sklearn.preprocessing import StandardScaler

# StandaradScaler 사용
scaler = StandardScaler()
scaler.fit(X_train)
X_train_scaled = scaler.transform(X_train)
X_test_scaled  = scaler.transform(X_test)

# 조정된 데이터로 SVM 학습
svm.fit(X_train_scaled, y_train)

# 스케일 조정된 테스트 세트의 정확도
print("스케일 조정된 테스트 세트의 정확도: {:.2f}".format(svm.score(X_test_scaled, y_test)))

지금까지 데이터 학습 훈련을 위한 스케일링에 대하여 알아보았습니다.

다음 포스팅에서는 One-Hot-Encoding에 대하여 알아보도록 하겠습니다.

728x90
반응형
LIST
728x90
반응형
SMALL

이번 포스팅에서는 범죄 데이터 분석을 Seaborn을 이용하여 시각화로 나타내 보도록 하겠습니다.

 

우선, 한글이 깨지는것을 방지하기 위해 폰트 이슈부터 해결하겠습니다. 

이어서 바로 그래프도 보겠습니다.

상관관계를 아주 손쉽게 시각화해서 보여주고 있습니다.

잠시 분석을 해보면

  • 강도 - 폭력
  • 살인 - 폭력
  • 강도 - 살인

전부다 양의 상관 관계를 갖는다는 것이 확인됩니다.

즉 예를 들어 강도를 기준으로 한다면 폭력과 살인이 많이 일어난다는 이야기가 됩니다.

다음은 CCTV와 살인, 강도에 대한 그래프를 확인해보겠습니다.

 

위의 시각화 데이터를 보면 분명히 인구수가 증가할수록 범죄가 증가하는 것이 확인됩니다.

특히 살인은 매우 많이 일어나는 것이 확인되네요
또한 CCTV와 살인은 상관관계가 낮아 보입니다.( 그래프의 기울기 확인 )

하지만 CCTV가 없을 때 살인사건이 많이 일어나는 것이 확인됩니다.

다음은 인구수와 살인 및 폭력 검거율을 확인해보겠습니다.

이번 분석은 음의 상관관계를 의미합니다. 인구수가 많아질수록 폭력 검거율은 줄어들고, CCTV가 많아질수록 검거율도 낮아지네요??

다음은 heatmap을 이용해서 전체 검거율을 확인해보겠습니다.

이때 검거 항목 최고값을 100으로 한정 해 놓고 계산하겠습니다.

결과를 보니 절도 검거율은 다른 검거율에 비해서 매우 낮다고 볼 수 있겠습니다.

그래프의 하단으로 갈수록 검거율이 낮아지는데, 강남 3구 중 하나인 서초구가 보입니다.
검거율이 우수한 지역은 도봉구, 광진구, 성동구가 있네요.

이어서 정규화된 발생 건수로 확인해 보겠습니다.

발생 건수로는 강남구, 양천구, 영등포구가 범죄 발생 건수가 높게 나타납니다. (그리고 송파구와 서초구도 높네요)

 

이번 포스팅에서는 앞서 정리한 데이터를 Seaborn을 사용하여 시각화로 나타내 보았습니다. 시각화 분석이 조금 더 한눈에 들어오는 것 같죠? Seaborn을 활용하면 더욱 다양하고 예쁘게 시각화를 할 수 있습니다. 

728x90
반응형
LIST
728x90
반응형
SMALL

이번 포스팅에서는 좀 더 편리하게 시각화하기 위해  Seaborn에 대하여 알아보도록 하겠습니다.

우선, Seaborn은 matplotlib을 기반으로 만들어져 통계 데이터 시각화에 최적화된 인기 라이브러리

Seaborn을 활용하면 시각화가 쉬워 집니다

사실 외울게 많습니다...ㅠㅠ

먼저 터미널이나 명령 프롬프트에서pip install seaborn을 입력하여 seaborn 모듈을 설치합니다.

Seaborn 은 좀 더 예쁘게 시각화할 수 있도록 도와줍니다.


간단한 비교를 위해 seaborn을 사용하지 않고 matplot만 사용하여 그래프를 그려 보겠습니다.

기초적인 시각화도 예쁘지만 이번엔 seaborn을 활용해서 여러 가지 스타일을 지정해 보겠습니다.

seaborn을 사용할 때 반드시 matplotlib 모듈도 같이 import 되어 있어야 합니다.

Seaborn에 있는 몇 가지 연습 데이터셋을 사용해 보도록 하겠습니다.

먼저 요일별 점심, 저녁, 흡연 여부와 식사 금액과 팁을 정리한 데이터입니다.

위 데이터는 단순히 요일별 매출을 시각화해본 그래프입니다.

이것만으로도 충분히 시각화가 쉬워지지만, hue라는 옵션을 이용하면 또 다른 데이터를 이용해서 데이터를 구분해 볼 수 있습니다.

위의 그래프를 확인해보면 흡연자가 더 결제범위가 큰 것이 확인됩니다

이번엔 약간 다른 스타일의 그래프를 그려 보겠습니다.

결제 금액과 종업원에게 주는 팁에 대한 회귀 분석 시각화입니다.
lmplot을 활용하면 간단하게 데이터 분석이 가능합니다.

적절한 상관계수를 확인할 때 사용하기 좋은 lmplot

회기 분석은 간단하게 말해서 예전에 그려봤던 상관계수라고 보시면 될 것 같습니다.
일전에 상관계수를 데이터와 데이터 사이에 상관 정도를 구해서 분석의 용도로 활용했는데, 회기 분석은 그 상관관계를 구하는 조금 더 정확한 방법이라고 보시면 될 것 같습니다.
즉, 위의 그래프에서 제시하는 결제금액에 따른 적절한 팁 액수를 확인할 수 있다는 것입니다.

결론적으로 "total_bill과 tip은 양의 상관관계를 갖는다"라고 이야기합니다.( total_bill이 많아질수록 tip이 많아지는 걸 알 수 있습니다)
또한 유효한 범위까지 그림으로 그려주는 것이 확인됩니다.

hue를 이용해서 흡연자로 비교해 보겠습니다.

lmplot 시각화도 hue옵션을 가질 수 있고, palette 옵션을 이용해 색상도 지정해 주었습니다.

다음은 연도 및 월별 항공기 승객수를 기록한 데이터입니다

연도 및 월별 항공기 승객수로 구분하기 위해 pivot_table을 활용하겠습니다.

값 별 수치를 색상으로! heatmap을 사용하여 데이터 확인하기

heatmap을 활용하면 수치 별 시각화를 정말 쉽게 확인할 수 있습니다.

일전 데이터를 보고 pivot을 활용한다면 heatmap으로 데이터를 확인해보세요!

각 항목별 비교로 확인해 보기 pairplot

머신러닝에서 많이 사용되는 아이리스 꽃에 대한 데이터입니다. 각각의 데이터가 의미하는 바는 다음과 같습니다.

  • Species : 붓꽃의 종. setosa, versicolor, virginica 세 가지 값 중 하나
  • Sepal.Width : 꽃받침의 너비
  • Sepal.Length : 꽃받침의 길이
  • Petal.Width : 꽃잎의 너비
  • Petal.Length : 꽃잎의 길이

아주 간단하게 데이터 분석이 가능해집니다.

아이리스 예제는 인공지능 머신러닝에서 매우 중요하게 다뤄지는 예제입니다.

지금까지

다음 포스팅에서는 이전의 범죄 데이터를 활용하여 시각화 분석을 해보도록 하겠습니다.

728x90
반응형
LIST

+ Recent posts