Python Basics for AI

1. 파이썬 AI 개발 환경 준비하기

• Basic computer class for newbies
• 파이썬 개요
• 파이썬 코딩 환경

2. 파이썬 기초 문법 1

• Variables
• Function and Console I/O
• Conditionals and Loops
• String and advanced function concept

3. 파이썬 기초 문법 2

• Python Data Structure
• Pythonic code

4. 파이썬 객체 지향 프로그래밍

• Python Object Oriented Programming
• Module and Project

5. 파이썬으로 데이터 다루기

• File / Exception / Log Handling
• Python data handling

6. Numpy 기초

• 선형대수의 계산식을 다루는 라이브러리를 다뤄봅니다

7. Pandas 기초

• Pandas 1,2 : 기본,심화 (데이터 처리에 유용한 pandas 라이브러리를 다뤄봅니다)

  AI Math

1. 벡터가 뭐에요?

• 벡터의 기초에 대해 학습합니다.

2. 행렬이 뭐에요?

• 행렬의 기초에 대해 학습합니다.

3. 경사하강법 (순한맛)

• 경사하강법과 미분의 개념, 그레디언트 벡터에 대해 학습합니다.

4. 경사하강법 (매운맛)

• 경사하강법 기반 선형회귀 알고리즘과 확률적 경사하강법을 알아봅니다.

5. 딥러닝 학습방법 이해하기

• 비선형 모델인 신경망과 역전파 알고리즘 및 활성함수에 대해 학습합니다.

6. 확률론 맛보기

• 확률론의 기초인 확률분포, 조건부확률, 기대값과 몬테카를로 샘플링 방법을 알아봅니다.

7. 통계학 맛보기

• 통계학의 기초인 모수의 개념과 모수를 추정하는 방법 중 하나인 최대가능도 추정법을 학습합니다.

8. 베이즈 통계학 맛보기

• 베이즈 정리와 인과관계 추론에 대해 학습합니다.

9. CNN 첫걸음

• Convolution 연산과 다양한 차원에서의 연산 방법, 연산의 역전파에 대해 소개합니다.

10. RNN 첫걸음

• 시퀀스 데이터의 개념과 특징, 그리고 이를 처리하기 위한 RNN에 대해 알아봅니다.

  Overview Map

  

  과제 및 퀴즈 소개

  기본 과제

  Python Basics for AI 강의

1. Basic Math

• 간단한 수학을 계산해주는 함수를 python 코드로 구현 : 주어진 리스트에서 가장 큰 숫자, 작은 숫자, 평균, 중간값 반환
• 관련 강의: Python_1-1강 Basic Math

2. Text Processing 1

• string을 다루는 방법을 학습(1): 정규화된 스트링 반환
• 관련 강의: Python_2-1, 2-2, 2-3, 2-4 강 파이썬 기초 문법 I

3. Text Processing 2

• string을 다루는 방법을 학습(2): 인풋으로 받는 스트링에서 숫자만 추출하여 영어 단어로 변환
• 관련 강의: Python_2-1, 2-2, 2-3, 2-4 강 파이썬 기초 문법 I

  AI Math 강의

• AI Math는 각 강의마다 5 문항의 퀴즈가 포함되어 있습니다. (OX, 객관식, 단답형 주관식 등)

  심화 과제

1. Gradient Descent

• 경사하강법을 직접 구현
• 관련 강의: AI Math_3강 경사하강법(순한 맛), 4강 경사하강법(매운 맛)

2. Backpropagation

• RNN의 Backpropagation을 직접 구현
• 관련 강의: AI Math_10강 RNN 첫걸음

3. Maximum Likelihood Estimation

• 정규분포의 모수에 대한 최대가능도 추정 문제 풀이 및 실습
• 관련 강의: AI Math_7강 통계학 맛보기

https://wikidocs.net/book/1

✓ Tab = 4 Spacebar ✓ .py 파일을 cmd창(명령 프롬프트 창)에서 실행하기 위해서는 directory를 파일이 있는 위치로 변경한 후에 python ☐☐☐.py 이 형식으로 명령어 입력하면 됨 ✓ Visual Studio / PyCharm 같은 에디터 사용하면 좋음 ✓ index는 0부터 시작 (-:뒤에서부터 카운트, -1:뒤에서 첫번째 것)

❖ 자료형

숫자

(정수:integer, 실수:floating-point,8진수,16진수)

문자

(String) (\n:줄바꿈, \t:탭 간격, \:\출력, ':'출력) ▷ formatting하는 것 ex> "I ate %d apples" % 3 ▷ %s : 문자열, %c : 문자1개, %d : 정수, %f : 실수, %% : %출력 ▷ %10s : 10개의 문자열 공간에 대입, %0.4f : 소수점 표현 개수 ★ format 함수 사용 "I ate {} apples".format(10) # {}안에 index나 name이 들어갈 수 있음 "{}".format("hi") {}안에 (0:>10 = 오른쪽 정렬, 0<:10 = 왼쪽 정렬, :^10 = 가운데 정렬, :!^10 = !채우기) ★ f 문자열 포매팅 1.선언된 변수를 받아올 수 있고 2.딕셔너리 value를 받아올 수 있다

>>> name = 'jupakk'
>>> age = 28
>>> d = {'favorate sport' : 'soccer', 'favorate food' : 'sushi'}
>>> f'나의 이름은 {name}이고 나이는 {age}이다'
~~~~~ 결과 나옴
>>> f'나는 {d["favorate sport"]} 하는거 좋아하고 {d["favorate food"]} 먹는거 좋아한다'
~~~~~ 결과 나옴

★ 관련 함수 ▷ 공백 지우기, 문자열 나누기 등

>>> a = "   hi   "
>>> a.strip()
'hi'
>>> b = "Life is too short"
>>> b.split() # 공백을 기준으로 나눔 (여기에 : 같은거 넣으면 그걸 기준으로 나눔)
['Life', 'is' 'too', 'short']

리스트

>>> a = [1,2,3,4,5,6,[1,2]]
>>> a[1] # 이렇게 인덱스로 요소 가져오는 것
>>> del a[2] # 인덱스로 요소 삭제 가능
>>> a[-1][0] # 리스트 안의 리스트도 가져올 수 있다 (다중 구조 리스트)

튜플

▷ 리스트와 거의 비슷하지만 값의 생성,삭제,수정이 불가능 하다 ▷ ()로 둘러싸는 형태이다(괄호생략가능) ▷ 인덱싱,슬라이싱,연산 등이 가능함

>>> t1 = (1,2,3,4,'a','b')
>>> t1[0]      ------ 인덱싱
>>> t1[1:]     ------ 슬라이싱
>>> t1 + t1*2  ------ 연산
>>> len(t1)    ------ 함수

딕셔너리

▷ 대응 관계를 나타내는 자료형 - 연관 배열(Associate array), 해시(Hash)라고 한다 ▷ Key 와 Value가 한쌍이 된다

>>> 기본구조 - {Key1:Value1, Key2:Value2, Key3:Value3, ...}
>>> a = {1: 'a', 2: 'b', 'name': 'pey', 3: [1,2,3]}
>>> a[★] - ★은 리스트와 같은 인덱스가 아니라 key를 입력해야 한다

▷ dict_keys, dict_values, dict_items (리스트 형식이 아니라서 list(a.keys()) 이렇게 리스트로 변환하면 되고 변환하지 않더라도 dict_keys, dict_values, dict_items 등은 반복(iterate)구문을 실행할 수 있다 ex.for문 )

>>> a.keys()   - 딕셔너리 a의 key만을 모아서 dict_keys 객체로 돌려줌
>>> a.values()  - 딕셔너리 a의 value만을 모아서 dict_value 객체로 돌려줌
>>> a.items()   - 딕셔너리의 key,value 쌍을 튜플로 묶은 객체를 돌려줌
>>> a.get('foo', 'bar')  - key 'foo'에 해당하는 value를 돌려 받는 함수로 만약 key 값이 없을 경우 디폴트 값을 가져오게 하는 함수이다

집합

▷ 중복을 허용하지 않는다 ▷ 순서가 없다 (따라서 인덱스를 사용할 수 없다) ▷ 교집합, 차집합, 합집합을 구할 때 유용함

>>> s1 = set([1,2,3,4,5,6])
>>> s2 = set([4,5,6,7,8,9])
>>> s1 & s2    ---- 교집합
>>> s1.intersection(s2)
>>> s1 | s2    ---- 합집합
>>> s1.union(s2)
>>> s1 - s2    ---- 차집합
>>> s1.difference(s2)

>>> s1.add(4)
>>> s1.update([5,7,8])
>>> s1.remove(2)

불(bool)

▷ True, False 값으로 된 자료형

★ bool 내장함수 사용
>>> bool('python')
>>> bool('')

변수 (자료형의 값을 저장하는 공간)

▷ 변수 이름(메모리의 주소) = 변수에 저장할 값(객체가 메모리에 생성됨) ▷ 복사할 때 유의 점

>>> a = [1,2,3]
>>> b = a        ----- b와 a가 같은 메모리 주소를 갖게 됨(하나를 바꾸면 나머지에 영향이 간다)
>>> b = a[:]     ----- 다른 주소를 갖는 변수 생성
>>> b = copy(a)  ----- 다른 주소를 갖는 변수 생성

❖ 제어문

if문

▷ 기본 구조

>>> if <조건문>:
    <수행할 문장>
    elif <조건문>:
        pass
    else:
        <수행할 문장>

▷ 조건부 표현식 ==== 조건문이 참인 경우 if 조건문 else 조건문이 거짓인 경우

>>> if score >= 60:
        message = "success"
    else:
        message = "failure"

message = "success" if score >= 60 else "failure"

while문

▷ 기본 구조

>>> while <조건문>:
        <수행할 문장1>
        <수행할 문장2>

▷ continue : while문의 처음 조건으로 돌아감 ▷ break : while문을 빠져나감

for문

▷ 기본 구조

>>> for 변수 in 리스트(또는 튜플, 문자열):
        수행할 문장1
        수행할 문장2

▷ 리스트 내포 (list comprehension) [표현식 for 항목 in 반복가능객체 if 조건문]

>>> a = [1,2,3,4]
>>> result = [num * 3 for num in a if num % 2 == 0]
>>> print(result)
[6, 12]

여러개 for문 쓸 때

[표현식 for 항목1 in 반복가능객체1 if 조건문1
        for 항목2 in 반복가능객체2 if 조건문2
        ...
        for 항목n in 반복가능객체n if 조건문n]

❖ 입출력

함수

▷ 기본 구조

def 함수명(매개변수):
    <수행할 문장1>
    <수행할 문장2>

▷ 매개변수(parameter) 와 인수(arguments)

def add(a, b):  # a, b는 매개변수
    return a+b

print(add(3, 4))  # 3, 4는 인수

▷ 여러개의 입력값을 받는 함수 ☞ * 은 입력값(매개변수)을 모아서 튜플로 만들어준다 args는 arguments의 약자로 관례적으로 많이 사용한다

def add_many(*args):
    <수행할 문장>

☞ ** 은 입력값(매개변수)을 모아서 딕셔너리로 만들어준다 kwargs는 keyword arguments의 약자로 관례적으로 많이 사용한다

def print_kwargs(**kwargs):
    <수행할 문장>

▷ 결과값은 항상 하나다 return 이후에 여러 결과 값을 넣은 것은 하나의 튜플로 구성되어 반환된다 return으로 함수를 빠져나가는 방법을 사용할 수 있다

▷ 매개변수의 초기값을 설정할 수 있다

def say_myself(name, old, man=True):
def say_myself(name, man=True, old): --- 이렇게 하면 사용 불가능

▷ 함수 안에서 변수를 사용하는 것은 global을 쓰면 된다 (비추천)

a = 1 
def vartest(): 
    global a 
    a = a+1

▷ def 대신에 lambda를 사용할 수 있다 (return명령어가 없어도 결과값을 돌려 줌) lambda 매개변수1, 매개변수2, ... : 매개변수를 이용한 표현식

>>> add = lambda a, b: a+b
>>> result = add(3, 4)
>>> print(result)

사용자의 입,출력을 받고 줄 때

▷ input을 사용하여 사용자로부터 입력을 받는다 (입력되는 것은 모두 문자열로 받는다)

>>> a = input()              ---- a는 입력되는 변수이다
>>> b = input("질문 내용")     ---- 질문 내용을 프롬프트로 띄워준다

▷ print 활용

>>> print("life" "is" "too short") # ①
lifeistoo short
>>> print("life"+"is"+"too short") # ②
lifeistoo short
>>> print("life", "is", "too short")
life is too short
>>> for i in range(10):
        print(i, end=' ')    --- 0 1 2 3 4 5 6 7 8 9
        print(i, end='_')    --- 0_1_2_3_4_5_6_7_8_9_
        print(i, end='')     --- 0123456789
        print(i)             --- 한줄씩 띄어서 출력

파일 읽고 쓰기

▷ 파일 생성 파이썬 내장함수 open 파일 객체 = open(파일 이름, 파일열기 모드) 파일 열기 모드 (r:읽기모드, w:쓰기모드, a:추가모드) 이미 존재하는 파일 위에 쓰려면 추가모드를 사용해야 한다

f = open(test.txt,'w')
f.close()   ---- 파일 닫기
f.write()   ---- 파일에 쓰기

▷ 외부 파일 읽기 readline()을 사용해서 파일을 한 줄씩 읽는다 readlines()을 사용해서 파일을 한 줄씩 읽어와 리스트로 반환한다 read()을 사용해서 파일 전체를 문자열로 반환한다

▷ with문 사용 with문을 사용하면 with문을 벗어나는 순간 자동으로 파일 객체가 close된다

with open("foo.txt", "w") as f:
    f.write("Life is too short, you need python")

▷ sys 모듈로 매개변수 주기 ??? 명령 프롬프트에서 sys모듈을 사용해서 매개변수를 직접 준다는 내용인데 왜 쓰는지, 이득이 뭔지 모르겠다

❖ 클래스, 모듈, 패키지, 라이브러리 등

클래스

▷ 클래스(class)와 객체(object)의 관계 --> 클래스는 틀,도면으로 생각할 수 있고 객체는 클래스로 만든 것을 의미한다 (임의의 클래스로 만든 객체를 그 클래스의 인스턴스라고 표현한다) ▷ 클래스의 기본 구조

def 함수명(매개변수):
    수행할 문장
    ...

▷ 클래스 안에 함수들이 구성 되는데 이것들은 메서드(method)라고 한다 ▷ 각 메서드별로 사용할 매개변수를 받게 되는데 첫번째 매개변수로 self를 받는다 (호출한 객체가 자동으로 전달되는 것) ▷ 각 객체별로 매개변수를 받아서 사용하는데 이에 따라서 객체변수들이 독립적으로 유지되는 것을 볼 수 있다 ▷ 생성자 (constructor) __init__ 매서드를 사용하면 생성자가 된다 (초기값을 설정해줌) ▷ 상속 (inheritance) 새로운 클래스를 생성할 때 다른 클래스의 기능을 물려받아서 사용하는 것 class 클래스이름(상속받을 클래스 이름) (기존 클래스가 라이브러리 형태로 제공되거나 수정이 어려울 때 사용하면 좋음) ▷ 매서드 오버라이딩(overriding) 클래스를 상속 받을 때 매서드를 변경하고 싶으면 해당 매서드를 다시 만들면 된다 ▷ 클래스 변수 클래스를 선언할 때 객체 변수가 아닌 클래스 변수로 선언한 것은 다른 객체들에서도 동일하게 사용되는 변수가 된다

모듈

▷ 함수나 변수 또는 클래스를 모아 놓은 파일이다 ▷ module1.py 이렇게 모듈을 만들 수 있다 ▷ 저장한 모듈을 사용하기 위해서는 import 모듈이름 이렇게 불러오면 된다 ▷ 모듈에서 특정 함수만을 사용하기 위해서는 from 모듈이름 import 모듈함수 이렇게 불러오면 된다 (모듈 함수에 * 문자를 넣으면 모든 함수를 불어오는 것) ▷ import 는 현재의 디렉토리에 있는 파일이나 파이썬 라이브러리가 저장된 디렉토리에 있는 모듈만 불러올 수 있다 ◆ if __name__ == "__main__"의 의미 ☞ 명령 프롬프트에서 파일을 실행하면 위의 if문이 참이되어 수행이 되는 것이고 ☞ 대화형 인터프리터나 다른 파일에서 모듈을 불러서 사용할 때는 위의 if문이 거짓이 되어 if문이 수행되지 않는다 ◆ __name__변수는 모듈을 직접 실행할 때는 __main__으로 되고 import해서 사용할 경우 모듈의 이름이 저장된다

◉ 모듈을 불러올 때 방법

1. sys.path.append 사용 import sys sys 모듈을 불러와서 >> sys.path로 파이썬 라이브러리가 설치되어 있는 디렉토리들을 보고 >> sys.path.append("디렉토리") 사용할 모듈이 있는 디렉토리를 추가한 뒤에 모듈을 불러와 사용함
2. PYTHONPATH 사용 명령 프롬프트에서 set PYTHONPATH=디렉토리 이렇게 하면 모듈을 불러와 사용 가능함

패키지

▷ 패키지는(packages) 도트(.)를 사용해서 파이썬 모듈을 계층적으로 관리할 수 있게 해줌 ﹡ 파이썬에서 모듈은 하나의 .py파일이다

▷ 패키지 예 (game)

game/
    __init__.py
    sound/
        __init__.py
        echo.py
        wav.py
    graphic/
        __init__.py
        screen.py
        render.py
    play/
        __init__.py
        run.py
        test.py

﹡ game : 루트 디렉토리 ﹡ sound, graphic, play : 서브 디렉토리

▷ 패키지 안의 함수 실행하는 방법

1. 모듈을 import하여 함수 실행

   >>> import game.sound.echo
   >>> game.sound.echo.echo_test()

2. 모듈의 디렉토리까지를 from...import하여 함수 실행

   >>> from game.sound import echo
   >>> echo.echo_test()

3. 모듈의 함수를 직접 import하여 함수 실행

   >>> from game.sound.echo import echo_test
   >>> echo_test()

   ▷ __init__.py 의 용도 ﹡ __init__.py 은 해당 디렉토리가 패키지의 일부임을 알려줌 (__init__.py 이 없다면 패키지로 인식 안됨) ```

   from game.sound import * echo.echo_test() [결과 에러]

*로 패키지의 특정 디렉토리들을 불러올 때는 init.py에 all = ['echo'] 이런 식으로 정의해줘야 함 하지만 *로 특정 모듈을 불러올 때는 from a.b.c import * 에서 c가 특정 모듈이면 된다

▷ relative 패키지
임의의 서브 패키지에서 다른 서브 패키지의 모듈을 사용하는 것 가능함

graphic 디렉토리의 render.py모듈이 sound 디렉토리의 echo.py 모듈 사용할 때 render.py의 예

example 1)

from game.sound.echo import echo_test def render_test(): print("render") echo_test()

example 2)

..sound.echo import echo_test def render_test(): print("render") echo_test()

﹡..: 부모 디렉토리 ﹡.``` : 현재 디렉토리

예외 처리

▷

내장 함수

▷

라이브러리

▷

❖ 연습 문제 - Link

★ Link - Google Colab

▼ 2. 왕초보를 위한 파이썬 ▼

https://wikidocs.net/book/2

▼ 3. 파이썬 - 데이터 시각화 ▼

https://wikidocs.net/book/2454

▼ 4. 레벨업 파이썬 ▼

https://wikidocs.net/book/4170

✓ 2차원의 labeled data structure with columns of potentially different types이다. ✓ index = row labels / columns = column labels ✓ Kinds of input Data type ◼︎Dict of 1D ndarrays,lists,dicts,Series ◼︎2D numpy.ndarray ◼︎Structured or record ndarray ◼︎A Series ◼︎Another DataFrame)

▼ 구성 방법 예시 ▼ (data type별)

1. From dict of Series or dicts 구성 예시

>>> d = {
    "one" = pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
    "two" = pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
>>> df = pd.DataFrame(d)
>>> df
>>>
    one    two
a    1.0    1.0
b    2.0    2.0
c    3.0    3.0
d    NaN    4.0
>>> df.index
>>> Index(['a','b','c','d'],dtype='object')
>>> df.columns
>>> Index(['one','two'],dtype='object')    
# When a particular set of columns is passed along with a dict of data, 
the passed columns override the keys in the dict

2. From dict of ndarrays / lists

✓ The ndarrrays must all be the same length.

>>> d = {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]}
>>> pd.DataFrame(d)
>>>
    one    two
a    1.0    4.0
b    2.0    3.0
c    3.0    2.0
d    4.0    1.0

3. Frome structured or record array

✓ DataFrame이 2D NumPy ndarrray처럼 정확히 work 안함

>>> data = np.zeros((2,), dtype=[("A", "i4"), ("B", "f4"), ("C", "a10")]) # 이 부분 체크 필요
>>> data[:] = [(1, 2.0, "Hello"), (2, 3.0, "World")]
>>> pd.DataFrame(data)
>>> 
    A    B    C
0    1    2.0    b'Hello'
1    2    3.0    b'World'
>>> pd.DataFrame(data, index=["first", "second"])
    A    B    C
first    1    2.0    b'Hello'
second    2    3.0    b'World'
>>> pd.DataFrame(data, columns=["C", "A", "B"]) # column name 바꾸는거
    C        A    B
0    b'Hello'    1    2.0
1    b'World'    2    3.0

4. From a list of dicts

>>> data2 = [{"a": 1, "b": 2}, {"a": 5, "b": 10, "c": 20}]
>>> pd.DataFrame(data2)
>>> 
    a    b    c
0    1    2    NaN
1    5    10    20.0

5. From a dict of tuples

✓ 이게 잘 활용되는 예를 찾아봐야 할 듯???

>>> pd.DataFrame(
    {
        ("a","b"): {("A","B"):1, ("A","C"):2},
        ("a","a"): {("A","C"):3, ("A","B"):4},
        ("a","c"): {("A","B"):5, ("A","C"):6},
        ("b","a"): {("A","C"):7, ("A","B"):8},
        ("b","b"): {("A","D"):9, ("A","B"):10},
    }
)
>>> 
        a            b
            b    a    c    a    b
A    B    1.0    4.0    5.0    8.0    10.0
    C    2.0    3.0    6.0    7.0    NaN
        D    NaN    NaN    NaN    NaN    9.0

6. From a Series

✓ The result will be a DataFame (same index as the input Series, one column whose name is the original name of the Series)

7. From a list of namedtuples

✓ namedtuple의 field names가 DataFrame의 columns를 결정한다. ✓ namedtuple 특성 파악 필요

>>> from collections import namedtuple
>>> Point = namedtuple("Point", "x y")
>>> pd.DataFrame([Point(0,0), Point(0,3), (2,3)])
>>>
    x    y
0    0    0
1    0    3
2    2    3
>>> Point3D = namedtuple("Point3D", "x y z")
>>> pd.DataFrame([Point3D(0, 0, 0), Point3D(0, 3, 5), Point(2, 3)])
>>>
    x    y    z
0    0    0    0.0
1    0    3    5.0
2    2    3    NaN

8. From a list of dataclasses

✓ Data Classes 의 list를 passing하는 것 (list of dictionaries를 passing하는 것과 같다) ✓ 다만 all values가 dataclasses여야하고 mixing types이면 TypeError뜸.

>>> from dataclasses import make_dataclass
>>> Point = make_dataclass("Point", [("x", int), ("y", int)])
>>> pd.DataFrame([Point(0, 0), Point(0, 3), Point(2, 3)])
>>>
    x    y
0    0    0
1    0    3
2    2    3

000. Missing data

✓ pandas에서 missing values를 어떻게 다루는지...(정리 예정)

https://pandas.pydata.org/docs/user_guide/missing_data.html#missing-data

▼ Alternate constructors ▼

1. DataFrame.from_dict

✓ dict of dicts / array-like sequences를 가지고 DataFrame을 return함

>>> pd.DataFrame.from_dict(dict([("A", [1, 2, 3]), ("B", [4, 5, 6])]))
>>> 
    A    B
0    1    4
1    2    5
2    3    6
# default로 dict의 key가 columns로 받아짐
# orient='index'로 하면 key가 row labels로 받아짐
>>> pd.DataFrame.from_dict(
    dict([("A", [1, 2, 3]), ("B", [4, 5, 6])]),
    orient="index",
    columns=["one","two","three"],
)
>>>
    one    two    three
A    1    2    3
B    4    5    6

2. DataFrame.from_records

✓ list of tuples / ndarray with structured dtype을 가지고 DataFrame 구성 ✓ 일반적으로 DataFrame 구성하지만 specific field를 index로 할 수 있다

>>> data
>>> array([(1, 2., b'Hello'), (2, 3., b'World')], dtype=[('A', '<i4'), ('B', '<f4'), ('C', 'S10')])
>>> pd.DataFrame.from_records(data, index="C")
>>>
        A    B
C
b'Hello'    1    2.0
b'World'    2    3.0

▼ Handlings ▼

Column selection, addition, deletion

# getting, setting, deleting
>>> df["one"]
>>>
a    1.0
b    2.0
c    3.0
d    NaN
>>> df["three"] = df["one"] * df["two"]
>>> df["flag"] = df["one"] > 2
>>> df
>>>
    one    two    three    flag
a    1.0    1.0    1.0    False
b    2.0    2.0    4.0    False
c    3.0    3.0    9.0    True
d    NaN    4.0    NaN    False
# delete / pop
>>> del df["two"]
>>> three = df.pop("three")
>>> df
>>>
    one    flag
a    1.0    False
b    2.0    False
c    3.0    True
d    NaN    False
>>> df["foo"] = "bar" # insert scalar value
>>>    df
>>>
    one    flag    foo
a    1.0    False    bar
b    2.0    False    bar
c    3.0    True    bar
d    NaN    False    bar
>>> df["one_trunc"] = df["one"][:2] # insert a Series
>>> df
>>> 
    one flag    foo    one_trunc
a    1.0    False    bar    1.0
b    2.0    False    bar    2.0
c    3.0    True    bar    NaN
d    NaN    False    bar    NaN
# insert raw ndarray (length는 같아야 함)
>>> df.insert(1, "bar", df["one"])
>>> df
>>>
    one bar    flag    foo    one_trunc
a    1.0    1.0    False    bar    1.0
b    2.0    2.0    False    bar    2.0
c    3.0    3.0    True    bar    NaN
d    NaN    NaN    False    bar    NaN

Assigning new columns in method chains

✓ assign always returns a copy of the data, leaving the original DataFrrame untouched ✓ 보완 필요...

>>> iris = pd.read_csv("data/iris.data")
>>> iris.head()
>>>
    SepalLength    SepalWidth    PetalLength    PetalWidth    Name
0    5.1        3.5        1.4        0.2        Iris-setosa
1    4.9        3.0        1.4        0.2        Iris-setosa
2    4.7        3.2        1.3        0.2        Iris-setosa
3    4.6        3.1        1.5        0.2        Iris-setosa
4    5.0        3.6        1.4        0.2        Iris-setosa
>>> iris.assign(sepal_ratio=iris["SepalWidth"] / iris["SepalLength"]).head()
>>>
    SepalLength    SepalWidth    PetalLength    PetalWidth    Name        sepal_ratio
0    5.1        3.5        1.4        0.2        Iris-setosa    0.686275
1    4.9        3.0        1.4        0.2        Iris-setosa    0.612245
2    4.7        3.2        1.3        0.2        Iris-setosa    0.680851
3    4.6        3.1        1.5        0.2        Iris-setosa    0.673913
4    5.0        3.6        1.4        0.2        Iris-setosa    0.720000
>>> iris.assign(sepal_ratio=lambda x: (x["SepalWidth"] / x["SepalLength"])).head()
>>> # output 위와 같다
>>> (
        iris.query("SepalLength > 5")
        .assign(
            SepalRatio=lambda x: x.SepalWidth / x.SepalLength,
            PetalRatio=lambda x: x.PetalWidth / x.PetalLength,
        )
        .plot(kind="scatter", x="SepalRatio", y="PetalRatio")
)

>>> dfa = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
>>> dfa.assign(C=lambda x: x["A"] + x["B"], D=lambda x: x["A"] + x["C"])
>>> 
    A    B    C    D
0    1    4    5    6
1    2    5    7    9
2    3    6    9    12

Indexing / selection

참고(추가 예정) Indexing : https://pandas.pydata.org/docs/user_guide/indexing.html#indexing Reindexing : https://pandas.pydata.org/docs/user_guide/basics.html#basics-reindexing

Data alignment and arithmetic

✓ DataFrame object들 사이의 alignment에서 보면, union of column and index로 결과가 구해짐 ✓ DataFrame 과 Series 사이의 alignment에서 보면, DataFrame의 columns에 Series의 index가 정렬되고 이것이 row 방향으로 broadcasting 되며 결과 구해짐

>>> df = pd.DataFrame(np.random.randn(10, 4), columns=["A", "B", "C", "D"])
>>> df2 = pd.DataFrame(np.random.randn(7, 3), columns=["A", "B", "C"])
>>> df + df2
>>> # index와 column에 맞춰 연산
    A        B        C        D
0    0.045691    -0.014138    1.380871    NaN
1    -0.955398    -1.501007    0.037181    NaN
2    -0.662690     1.534833    -0.859691    NaN
3    -2.452949     1.237274    -0.133712    NaN
4     1.414490     1.951676    -2.320422    NaN
5    -0.494922    -1.649727    -1.084601    NaN
6    -1.047551    -0.748572    -0.805479    NaN
7    NaN        NaN        NaN        NaN
8    NaN        NaN        NaN        NaN
9    NaN        NaN        NaN        NaN
>>> df - df.iloc[0]
>>> # Series가 broadcasting 되면서 연산
    A        B        C        D
0    0.000000    0.000000    0.000000    0.000000
1    -1.359261    -0.248717    -0.453372    -1.754659
2    0.253128    0.829678    0.010026    -1.991234
3    -1.311128    0.054325    -1.724913    -1.620544
4    0.573025    1.500742    -0.676070    1.367331
5    -1.741248    0.781993    -1.241620    -2.053136
6    -1.240774    -0.869551    -0.153282    0.000430
7    -0.743894    0.411013    -0.929563    -0.282386
8    -1.194921    1.320690    0.238224    -1.482644
9    2.293786    1.856228    0.773289    -1.446531
# scalars로 연산 될 때
>>> df * 5 + 2
>>> 1 / df
>>> df ** 4
# Boolean로 연산 될 때
>>> df1 = pd.DataFrame({"a": [1, 0, 1], "b": [0, 1, 1]}, dtype=bool)
>>> df2 = pd.DataFrame({"a": [0, 1, 1], "b": [1, 1, 0]}, dtype=bool)
>>> df1 & df2
>>>
    a    b
0    False    False
1    False    True
2    True    False
>>> df1 | df2
>>> df1 ^ df2
>>> -df1

참고(추가 예정) Broadcasting : https://numpy.org/doc/stable/user/basics.broadcasting.html Flexible binary operations : https://pandas.pydata.org/docs/user_guide/basics.html#basics-binop

Transposing

✓ transpose하는 것은 'T'를 사용하면 된다(ndarray와 비슷하게)

>>> df[:5].T
>>>
    0        1        2        3        4
A    0.271860    -1.087401    0.524988    -1.039268     0.844885
B    -0.424972    -0.673690     0.404705    -0.370647     1.075770
C    0.567020    0.113648     0.577046    -1.157892    -0.109050
D    0.276232    -1.478427    -1.715002    -1.344312     1.643563

DataFrame interoperability with NumPy functions

✓ Elementwise로 연산되는 NumPy functions(log, exp, sqrt ...)는 Series와 DataFrame에서 사용 가능하다 ✓ DataFrame은 ndarray와 같이 적용하기 어렵지만, Series 같은 경우에는 NumPy's universal functions를 적용할 수 있다.

>>> np.exp(df)
>>> np.asarray(df)
>>> 
array([[ 0.2719, -0.425 ,  0.567 ,  0.2762],
       [-1.0874, -0.6737,  0.1136, -1.4784],
       [ 0.525 ,  0.4047,  0.577 , -1.715 ],
       [-1.0393, -0.3706, -1.1579, -1.3443],
       [ 0.8449,  1.0758, -0.109 ,  1.6436],
       [-1.4694,  0.357 , -0.6746, -1.7769],
       [-0.9689, -1.2945,  0.4137,  0.2767],
       [-0.472 , -0.014 , -0.3625, -0.0062],
       [-0.9231,  0.8957,  0.8052, -1.2064],
       [ 2.5656,  1.4313,  1.3403, -1.1703]])
>>> ser = pd.Series([1, 2, 3, 4])
>>>
0     2.718282
1     7.389056
2    20.085537
3    54.598150
# index 순서 달라도 가능 (label별로 자동 정렬)
>>> ser1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
>>> ser2 = pd.Series([1, 3, 5], index=["b", "a", "c"])
>>> np.remainder(ser1, ser2)    
>>>
a    1
b    0
c    3
>>> ser3 = pd.Series([2, 4, 6], index=["b", "c", "d"])
# index 다른 것은 missing value
>>> np.remainder(ser1, ser3)    
>>>
a    NaN
b    0.0
c    3.0
d    NaN
# 
>>> 
# Series와 Index에 binary ufunc 적용되면, 우선적으로 Series로 return함
>>> ser = pd.Series([1, 2, 3])
>>> idx = pd.Index([4, 5, 6])
>>> np.maximum(ser, idx)
>>>
0    4
1    5
2    6

Console display

✓ DataFrame이 너무 클 때 console에 잘려서 display될 수 있다.

>>> baseball = pd.read_csv("data/baseball.csv") # dataset from plyr R package
>>> print(baseball)
>>>
       id     player  year  stint team  lg   g   ab   r    h  X2b  X3b  hr   rbi   sb   cs  bb    so  ibb  hbp   sh   sf  gidp
0   88641  womacto01  2006      2  CHN  NL  19   50   6   14    1    0   1   2.0  1.0  1.0   4   4.0  0.0  0.0  3.0  0.0   0.0
1   88643  schilcu01  2006      1  BOS  AL  31    2   0    1    0    0   0   0.0  0.0  0.0   0   1.0  0.0  0.0  0.0  0.0   0.0
..    ...        ...   ...    ...  ...  ..  ..  ...  ..  ...  ...  ...  ..   ...  ...  ...  ..   ...  ...  ...  ...  ...   ...
98  89533   aloumo01  2007      1  NYN  NL  87  328  51  112   19    1  13  49.0  3.0  0.0  27  30.0  5.0  2.0  0.0  3.0  13.0
99  89534  alomasa02  2007      1  NYN  NL   8   22   1    3    1    0   0   0.0  0.0  0.0   0   3.0  0.0  0.0  0.0  0.0   0.0

[100 rows x 23 columns]

# to_string으로 tabular form으로 representation할 수 있음(단,console width랑 안 맞을 수도)
>>> print(baseball.iloc[-20:, :12].to_string())
>>>
       id     player  year  stint team  lg    g   ab   r    h  X2b  X3b
80  89474  finlest01  2007      1  COL  NL   43   94   9   17    3    0
81  89480  embreal01  2007      1  OAK  AL    4    0   0    0    0    0
82  89481  edmonji01  2007      1  SLN  NL  117  365  39   92   15    2
83  89482  easleda01  2007      1  NYN  NL   76  193  24   54    6    0
84  89489  delgaca01  2007      1  NYN  NL  139  538  71  139   30    0
85  89493  cormirh01  2007      1  CIN  NL    6    0   0    0    0    0
86  89494  coninje01  2007      2  NYN  NL   21   41   2    8    2    0
87  89495  coninje01  2007      1  CIN  NL   80  215  23   57   11    1
88  89497  clemero02  2007      1  NYA  AL    2    2   0    1    0    0
89  89498  claytro01  2007      2  BOS  AL    8    6   1    0    0    0
90  89499  claytro01  2007      1  TOR  AL   69  189  23   48   14    0
91  89501  cirilje01  2007      2  ARI  NL   28   40   6    8    4    0
92  89502  cirilje01  2007      1  MIN  AL   50  153  18   40    9    2
93  89521  bondsba01  2007      1  SFN  NL  126  340  75   94   14    0
94  89523  biggicr01  2007      1  HOU  NL  141  517  68  130   31    3
95  89525  benitar01  2007      2  FLO  NL   34    0   0    0    0    0
96  89526  benitar01  2007      1  SFN  NL   19    0   0    0    0    0
97  89530  ausmubr01  2007      1  HOU  NL  117  349  38   82   16    3
98  89533   aloumo01  2007      1  NYN  NL   87  328  51  112   19    1
99  89534  alomasa02  2007      1  NYN  NL    8   22   1    3    1    0

# display.width로 얼마나 한 row에 display할 지 결정
>>> pd.set_option("display.width", 40)  # default is 80
>>> pd.DataFrame(np.random.randn(3, 12))
>>>
         0         1         2         3         4         5         6         7         8         9         10        11
0 -2.182937  0.380396  0.084844  0.432390  1.519970 -0.493662  0.600178  0.274230  0.132885 -0.023688  2.410179  1.450520
1  0.206053 -0.251905 -2.213588  1.063327  1.266143  0.299368 -0.863838  0.408204 -1.048089 -0.025747 -0.988387  0.094055
2  1.262731  1.289997  0.082423 -0.055758  0.536580 -0.489682  0.369374 -0.034571 -2.484478 -0.281461  0.030711  0.109121

# individual column별로 max width를 조절 가능
>>> datafile = {
    "filename": ["filename_01", "filename_02"],
    "path": [
        "media/user_name/storage/folder_01/filename_01",
        "media/user_name/storage/folder_02/filename_02",
    ],}
>>> pd.set_option("display.max_colwidth",30)
>>> pd.DataFrame(datafile)
>>>
      filename                           path
0  filename_01  media/user_name/storage/fo...
1  filename_02  media/user_name/storage/fo...
>>> pd.set_option("display.max_colwidth",100)
>>> pd.DataFrame(datafile)
>>>
      filename                                           path
0  filename_01  media/user_name/storage/folder_01/filename_01
1  filename_02  media/user_name/storage/folder_02/filename_02

# expand_frame_repr 로 table을 one block으로 print 가능

DataFrame column attribute access and IPython completion

✓ column attribute access (column label이 valid Python variable name일때)

>>> df = pd.DataFrame({"foo1": np.random.randn(5), "foo2": np.random.randn(5)})
>>> df
>>>
       foo1      foo2
0  1.126203  0.781836
1 -0.977349 -1.071357
2  1.474071  0.441153
3 -0.064034  2.353925
4 -1.282782  0.583787
>>> df.foo1
>>>
0    1.126203
1   -0.977349
2    1.474071
3   -0.064034
4   -1.282782
Name: foo1, dtype: float64

✓ column이 IPython completion mechanism과 connect될 때

>>> df.foo<TAB>  # noqa: E225, E999
>>>
df.foo1  df.foo2

• 참고 자료 및 최종 수정 >>> [2021_12_29] https://pandas.pydata.org/docs/user_guide/dsintro.html#dsintro

✓ 1차원의 labeled array이다. ✓ can holding any data type(integers, strings, floating point numbers, python objects, etc.) ✓ axis label은 index 로 나타낸다. ✓ 기본 구조 >>> s = pd.Series(data,index=index) ✓ s = pd.Series(,name = 'something') >> 이걸로 object 생성 가능 (s1 = s.rename('another')으로 해서 다른 object 생성 가능) ✓ data는 1.Python dict 2.ndarray 3.scalar value등으로 이뤄진다.

1. Python dict 예시

✓ index가 pass되면, 그에 맞는 value도 pull된다

In[] : dict = {"b":1,"a":0,"c":2}
In[] : pd.Series(dict)
Out[] : 
b 1
a 0
c 2
dtype: int64
In[] : pd.Series(dict, index=["b","a","d","c"])
Out[] : 
b 1
a 0
d NaN
c 2
dtype: int64
s["a"]
"e" in s
s["f"]
s.get("f")

2. ndarray 예시

✓ data의 길이와 index의 개수가 같아야 한다(ex)s = pd.Series(np.random.randn(5), index={["a","b","c","d","e"]} ✓ ndarray와 비슷하게 작동됨

s[0] 
s[:3]
s[s > s.median()]
s[[4,3,1]] >>> indexing 부분 더 보기
np.exp(s)

✓ Series가 ndarray-like일때, 1.actual array를 얻으려면

# 1.actual array 얻으려면
s.array
# 2.actual ndarray 얻으려면
s.to_numpy()

3. scalar value 예시

pd.Series(5.0, index=["a","b","c","d","e"])

000. Thinking

✓ Series와 ndarray의 key difference (Series는 automatically align the data based on label)

Input[]: s[1:] + s[:-1]
Output[]:
a    NaN
b    -0.565727
c    -3.018117
d    -2.271265
e    NaN

• 참고 자료 및 최종 수정 >>> [2021_12_08] https://pandas.pydata.org/docs/user_guide/dsintro.html#dsintro

Pandas

: 데이터 분석에 필요한 패키지

• install pandas pip install pandas

• import import pandas as pd

• version check pd.__version__

• object에 data type 지정, indexing, axis labeling/alignment 등을 적용할 수 있다.

• 참고 자료 및 최종 수정 >>> [2021_12_29] https://pandas.pydata.org/docs/user_guide/10min.html#

시작 --- [2021_12_02]

그 동안 딥러닝, 신호처리 등을 배워오며 어렴풋이 따라갔던 것 같다. 시간에 쫓겨 정신 없이 따라다니며 여러 일들을 경험한 것 같다. 이제와서 생각해보니 내 손에 쥔 것이 없는 것 같다. 앞으로 정리하며 걸음을 걸어야 겠다.

@ 몇개의 platform 을 봤는데 Medium 은 영어라 어렵다... 나중에 꼭 도전해야겠다.