빅데이터 첫걸음 시작하기 : 데이터분석 인강 2주차

 Python 이란 

˙전 세계적으로 가장 많이 사용하는 프로그래밍 언어 중 하나.

˙1991년 Guido van Rossum이 개발하였다.

˙Zen of Python (PEP 20)*

 

     * Zen of Python : Python 프로그래밍 언어의 설계에 영향을 미치는 컴퓨터 프로그램 작성을 위한 19가지 원칙 가이드

       1. Beautiful is better than ugly.
       2. Explicit is better than implicit.
       3. Simple is better than complex.
       4. Complex is better than complicated.
       5. Flat is better than nested.
       6. Sparse is better than dense.
       7. Readability counts.
       8. Special cases aren't special enough to break the rules.
       9. Although practicality beats purity.
       10. Errors should never pass silently.
       11. Unless explicitly silenced.
       12. In the face of ambiguity, refuse the temptation to guess.
       13. There should be one – and preferably only one – obvious way to do it.
       14. Although that way may not be obvious at first unless you're Dutch.
       15. Now is better than never.
       16. Although never is often better than right now.
       17. If the implementation is hard to explain, it's a bad idea.
       18. If the implementation is easy to explain, it may be a good idea.
       19. Namespaces are one honking great idea – let's do more of those!

 

˙Python의 장점 : 코드가 간결하고 개발 속도가 빠르며, 오픈소스 라이브러리가 많음 

[ Python Library ]
numpy pandas opencv scipy tensorflow	gensim matplotlib pytorch networkx

 

˙Python의 특징 : Line by line 실행 가능 / 데이터 타입 자동 지정 /  다양한 데이터 타입 / 메모리 자동 관리

 

 Python Data Type 

 

Python Data Types

* Python Data Type Source : https://www.geeksforgeeks.org/python-data-types/

1. Numeric(숫자형) - Integer : 정수 / Float : 실수
2. Strings : 문자열
3. List : 목록
4. Tuple* : 셀 수 있는 수량의 순서 있는 열거 / Set : 집합
5. Dictionary : 사전
6. Boolean : 참/거짓
7. Sequence Type : 순서를 가진 데이터 모음

 

 

빅데이터 분석 첫걸음 시작하기 수강신청 링크 (이미지 클릭)

 

---

 2주차 : 분석도구 Python 

2주차 강의에서는
Python에서 사용되는 Data type과 변수(Variable)를 이해하고, 각각의 Data Type을 활용한 기초 문법을 익힌다.
또한 프로그램의 흐름을 제어하는 Control Statement를 활용하여 Function을 만들고,
I/O 처리를 통해 데이터를 입출력하는 방법을 학습한다. 

 

1. Data Type : int, float, String, List, tuple, set, dictionary
2. Control Statement : IF Statement (조건문/if,elif,else), Iteration Statement (반복문)
3. Function : 코드를 하나의 기능으로 만든 묶음, 함수 / 재사용성 Reusability [input → Function → output]
4. 데이터 입출력 (I/O) : STDIN(Standard IN) - 사용자 입력 / STDOUT (Standard OUT) - 사용자 출력, file I/O

 

Python에서 사용되는 Data Type과 명령어 기초 문법을 활용하여 함수를 만들고,
데이터를 입출력하는 방법을 알아볼 수 있었다. 아직은 낯설지만, 빨리 익숙해지기 위해
지속적인 연습이 필요할 것이다. 필요한 데이터를 원활하게 추출해낼 수 있을 때,
비로소 그 데이터를 활용할 수 있을 것이다.

 

온전히 내 것이 될 때까지, Practice!

Data Type

1. 숫자 데이터 Numeric Data Types

1) 사칙연산

a=10
b=5
a+b
print(a+b)
print(a-b)
print(a*b)
print(a/b)

=> 15
=> 5
=> 50
=> 2.0

2) 특수연산

c = 5
d = 2
print(c ** d) # c를 d번 곱한 것. c^d
print(c // d) # c를 d로 나눈 몫.
print(c % d)  # c를 d로 나눈 나머지.
print(c*d)

=> 25
=> 2
=> 1
=> 10

* 연도 N이 윤년인지 확인하기

N = 2024
((N % 4 == 0) and (N % 100 != 0)) or (N % 400 == 0)

=> True

 

2. 문자열 String

1) 특수문자 표현 (escape code)

# \n -> new line
print("Hello\nWorld")

# \t -> tab
print("Hello\tWorld")

2) 문자열 Formatting

바나나는 3개 있다.
banana = "바나나"; count = 3

# 1) print formatting
print("%s는 %d개 있다." % (banana, count))

# 2) str.format
print("{}는 {}개 있다.".format(banana, count))

# 3) f-string
print(f"{banana}는 {count}개 있다.")

3) 문자열 관련 함수

# 1) 대문자로 바꾸기
s = "hi"
s.upper()
=> 'HI'

# 2) 소문자로 바꾸기
s = "Hi"
s.lower()
=> 'hi'

# 3) 문자 공백 지우기
s = "hi        "
s.strip()
=> 'hi'

# 4) 문자열 삽입
",".join("abcd")
'a,b,c,d'

# 5) 문자열 나누기
s = "Life is too short."
s.split('is') #token 기준 / 없는 경우 공백 기준
=> ['Life ', ' too short.']

# 6) 문자열 바꾸기
s = "Life is too short."
# Life를 Time으로 바꿔봅시다.
s.replace("Life", "Time")
#s.replace(" ", "")

=> 'Time is too short.'

 

3. 연속형 데이터 Sequential Data Types

1) 리스트 List

** Indexing : index를 사용해 접근하는 방법 (*index : 맨 앞부터 0으로 시작, 1씩 증가하는 정수)

    ˙ ex) L=[1,2,3] 에서 index0=L[0] = 1, index1=L[1] = 2, index2=L[2] = 3

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

# L의 첫번째 원소
L[0] #index 0

# L의 5번째 원소
L[4]

# L의 마지막 원소
L[-1] #L[4] == L[전체개수(len(L))-1]
L[len(L)-1]

#------------------------
L2 = [1, [2, 3], 5]
L2

# L2에서 2에 접근하기 위해 indexing을 해보자.
L2[1][0]

** Slicing : 리스트의 일부만 사용하고 싶을 때 사용 (* 리스트의 index와 ':'를 사용하여 슬라이싱, 마지막 생략)

    ˙ex) L = [1, 2, 3, 4] 에서 L[0:2] => [1, 2]

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

# L의 첫번째부터 index2 까지 자르기
L[0:2] #[1,2] #L[0], L[1]

# L의 두번째부터 index4 까지 자르기
L[1:4] #L[1], L[2], L[3]

# 시작 index를 생략하면, 자동으로 index는 0이 된다. (맨 처음)
L[:4] #L[:-1] == L[len(L)-1] == L[:5-1] == L[:4]

# 끝 index를 생략하면, 자동으로 index는(리스트의 길이)가 된다. (맨 마지막) Q. 왜 리스트의 길이일까?
L[1:len(L)] #L[-1] == L[len(L)-1]
L[1:]

# 뒤에서 두 개
L[-2:] #L[-2:len(L)]

* 리스트 연산

# 1) 리스트 더하기
L = [1, 2, 3]
L2 = [4, 5]
L + L2

# 2) 리스트 곱하기
L * 3

# 3) 리스트 수정하기
L[2] = 1
L

L2[0] = 7
L2

L + L2 # 수정한 값으로 적용

* 관련 함수

# 1) 리스트에 원소 추가하기
# 빈 리스트 L을 만들어서 3, 2, 1 순서대로 원소를 추가해봅니다.
L = []
L.append(3)
L.append(2)
L.append(1)
L

# 2) 리스트 원소 정렬하기
# sort()를 이용해 L을 정렬합니다.
L = [4, 3, 16]
L.sort() #ascending order 오름차순
#L.sort(reverse=True) #dscending order 내림차순
L

# 3) 리스트 뒤집기(정렬x)
#L.reverse() # reverse()와 같은 결과를 내는 신박한 방법도 있습니다.
L = [1, 2, 3, 4, 5, 6]
L[::-1]

# 4) 처음부터 끝까지 2씩
L[::2]

# 5) 리스트 원소 제거하기
# 끝에서부터 하나씩 삭제
L.pop()
L

 

2) 튜플 Tuple

 * 리스트와의 차이점

   - ( )를 사용한다.

   - 한번 생성되면 수정이 불가능하다. (immutable type)

 * immutable의 장점

   - 성능 이슈 : 변경되지 않는 그 자체로 장점

   - 프로그래밍 이슈 : 데이터를 의도치않게 수정하게 되는 실수 방지

# 1, 2를 원소로 가지는 tuple을 생성해 봅니다.
t = (1, 2)
t

t1 = ()
t1, type(t1) # 사실 이 때까지 이렇게 2항에 대해서 출력한 모든 결과는 tuple이었다.

t2 = ('a', 'b', ('a', 'b'))
t2

t[0]
=> 1

t[-1]
=> 2

t[0] = 3 # 튜플의 원소를 변경해보자.
=> TypeError


# 그럼 tuple의 더하기, 곱하기는 어떻게 될까?
t = (1, 2)
t2 = (3, 4)
t + t2

t2 * 3

len(t * 3)

 

3) 집합 Set

 * 포함 관계만 표현하는 수학에서의  집합과 동일한 개념이다.

# 1, 2, 3을 원소로 가지는 집합 만들기
s = {1, 2, 3}
s, type(s)

s[1] # 2가 나올것 같지만...
TypeError: 'set' object is not subscriptable

* 집합 연산

s1 = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}

# 1) s1과 s2의 교집합
s1 & s2

s1.intersection(s2) # s1과 s2의 자리를 바꿔도 당연히 같다.
#== s2.intersection(s1)

# 2) s1과 s2의 합집합
s1 | s2

s1 + s2 # 많이 혼동한다.
TypeError: unsupported operand type(s) for +: 'set' and 'set'

s1.union(s2) # s1과 s2의 자리를 바꿔도 당연히 같다.
#== s2.union(s1)

# 3) s1과 s2의 차집합
s1 - s2

s2 - s1 # 당연히 다르다.

#집합 원소의 ununiqueness를 활용하는 경우
L = [ 1, 2, 3, 3, 4, 1, 2, 34, 5, 6, 1, 2]
set(L), len(set(L))

* 집합 관련 함수

# 1) 집합에 원소 하나 추가하기
s = set()
s.add(4)
s

# 2) 집합에 여러 원소 추가하기
s = {1, 2, 3}
s.update({4, 5}) #s.union({4, 5})는 새로운 집합 생성* 다름
s

# 3) 집합에서 원소 제거하기
s.remove(3)
s

 

4) 사전 Dictionary **

* key - value 로 저장 / Table 형태로, index가 아닌 key값을 통해 value에 접근

  => 순서가 아닌 의미 있는 값을 통해 데이터 접근이 가능

* 사전을 표현할 때는 {key : value, key2 : value, ...} 형태로 표현

* 사전 생성 하기

D = {} #dict() #공집합이 아니다.
type(D)

# 위에 나온 테이블 예시를 사전으로 만들어봅니다.
D = {'John' : '0011', 'Maria' : '1234'}
D

#dict indexing
D['John']

# 사전 D에 key가 'a'이고 value가 3인 원소를 추가하자.
D['a'] = '3'
D = {'John': '0011', 'Maria': '1234', 'a': '3'}

# 비교 리스트의 경우,
#L = [1, 2, 3]
#L[0] = 4
#L = [4, 2, 3]

# key값이 이미 존재하는 경우에는 key값을 통한 indexing이 되며, 
key값이 존재하지 않을 때는 assignment를 사용하여 원소를 추가한다.
D["a"] 

D2 = {'a' : 1 , 'a' : 2, 'b': 3} # 무엇이 문제일까?
D2 = {'a': 2, 'b': 3}
# 사전을 만들 때 key 값은 중복이 있을 수 없다.
# 사전에서 key가 될 수 있는 data type은 immutable이어야 한다.
# immutable : int, float, string, tuple, frozenset

* 사전 관련 함수

# 1) 사전의 모든 key값 보기
D = {'name': 'kim', 'phone': '01012345679', 'birth': '1234'}
D.keys()
=> dict_keys(['name', 'phone', 'birth'])

# 2) 사전의 모든 value 보기
D.values()
=> dict_values(['kim', '01012345679', '1234'])

# 3) 사전의 모든 key, value 쌍 보기
D.items()
=> dict_items([('name', 'kim'), ('phone', '01012345679'), ('birth', '1234')])

# 4) 사전의 원소 가져오기
D.get('name')
# 해당하는 키값이 없는 경우,
D.get('address', "Seoul")

# 5) 사전에 해당 key값이 존재하는 지 확인하기
"phone" in D #D.keys()
=> True

# value가 있는 지 확인하기
'1234' in D.values()