Pandas¶

data = pd.Series([0.25, 0.5, 0.75, 1.0])
data

# Series의 values에 접근하기
data.values

# Series의 index에 접근하기
data.index

# index를 이용하여 Series의 value에 접근하기
data[1]

data = pd.Series([0.25, 0.5, 0.75, 1.0], index=['a', 'b', 'c', 'd'])
data

population_dict = {'california': 38332521,
                  'Texas': 26448193,
                  'New York': 19651127,
                  'Florida': 19552860,
                  'Illinois': 12882135}

# Series의 생성자로 딕셔너리를 넣는다.
population = pd.Series(population_dict)

population

# data가 리스트나 NumPy 배열일 수 있고, 그런 경우 index는 정수가 기본
pd.Series([2, 4, 6])

# data는 지정된 인덱스를 채우기 위새 반복되는 스칼라값일 수 있다.
pd.Series(5, index=[100, 200, 300])

# data가 딕셔너리일때, 이 경우 index는 기본적으로 딕셔너리 키를 정렬해서 취한다.
pd.Series({2:'a', 1:'b', 3:'c'})

# data가 딕셔너리일때, index를 명시적으로 설정할 수 있다.
pd.Series({2:'a', 1:'b', 3:'c'}, index=[3, 2])

area_dict = {'california': 423967,
            'Texas': 695662,
            'New York': 141297,
            'Florida': 170312,
            'Illinois': 149995}

# 딕셔너리의 키를 기준으로 정렬해서 보여준다.
area = pd.Series(area_dict)
area

population_dict = {'california': 38332521,
                  'Texas': 26448193,
                  'New York': 19651127,
                  'Florida': 19552860,
                  'Illinois': 12882135}

population = pd.Series(population_dict)
population

# Series 객체 2개를 이용하여 DataFrame을 생성한다. key는 'population', 'area'가 되며 열 인덱스가 된다.
# 두 개의 Series가 공통으로 가지고 있던 key 이름이 행 인덱스가 된다.
states = pd.DataFrame({'population': population,
                      'area':area})

states

# 인덱스 레이블에 접근
states.index

# 열 레이블에 접근
states.columns

states['area']

"""단일 Series 객체에서 구성하기"""

pd.DataFrame(population, columns=['population'])

"""딕셔너리의 리스트에서 구성하기"""

data = [{'a': i, 'b': 2*i} for i in range(3)]
display(data)

pd.DataFrame(data)

"""딕셔너리로 구성하기"""

data = {'a': [1, 2, 3], 'b': [4, 5, 6]}
display(data)

pd.DataFrame(data)

"""Series 객체의 딕셔너리에 구성하기"""

print(type(population))
print(type(area))

pd.DataFrame({'population': population, 'area': area})

"""NumPy의 구조화된 배열에서 구성하기"""

a = np.zeros(3, dtype = [('A', 'i8'), ('B','f8')])
display(a)

pd.DataFrame(a)

# 딕셔너리의 일부 키가 누락되더라도 Padnas는 NaN 값으로 채운다. (Not A Number)
pd.DataFrame([{'a': 1, 'b': 2}, {'b': 2, 'c': 3}])

idx = pd.Index([2, 3, 5, 7, 11])
idx

display(idx[1])
display(idx[::2])  # Slicing

# NumPy 배열에서 익숙한 속성들
display(idx.size)
display(idx.shape)
display(idx.ndim)
display(idx.dtype)

# 일반적인 방법으로는 변경될 수 없다. 즉 Immutable 하다.
idx[1] = 0

idx_A = pd.Index([1, 3, 5, 7, 9])
idx_B = pd.Index([2, 3, 5, 7, 11])

# 교집합
display(idx_A & idx_B)

# 합집합
display(idx_A | idx_B)

# 여집합
display(idx_A ^ idx_B)

data = pd.Series([0.25, 0.5, 0.75, 1.0], index = ['a', 'b', 'c', 'd'])

print(data)
print(data['b'])

# 키의 포함 유무를 체크해보자
'a' in data

# 키집합
data.keys()

# 새로운 값 추가
data['e'] = 1.25
data

data

"""명시적인 인덱스로 슬라이싱하기"""

# Python 컬렉션, NumPy 배열에서와는 달리 마지막 인덱스가 포함된다.
data['a':'c']

"""암묵적 정수 인덱스로 슬라이싱하기"""

# 마지막 인덱스는 포함되지 않는다.
data[0:2]

data > 0.3

data < 0.8

(data > 0.3) & (data < 0.8)

data[(data > 0.3) & (data < 0.8)]

"""Fancy 인덱싱"""

data[['a', 'e']]

# 미국의 population
display(population)
display(type(population))

# 미국의 area
display(area)
display(type(area))

data = pd.DataFrame({'population': population, 'area': area})
data

# 열 이름으로 된 딕셔너리 스타일의 인덱싱을 통해 접근
data['area']

# 열 이름을 이용해 속성 스타일로 접근
data.area

# 새로운 열을 추가 (NumPy의 ufunc의 벡터화 연산)
data['density'] = data['population'] / data['area']
data

# 데이터 배열
data.values

# 행과 열을 바꾸기 (Transpose)
data.T

# 첫번째 행에 접근. values를 이용하였음을 기억하라. 즉 data[0]이 아니다. Florida 데이터에 접근.
data.values[0]

# 열에 접근
data['area']

# 인덱싱은 열을 참조
display(data['area'])

# 행을 참조해보자. 행에 접근하기 위해서는 암묵적 정수 index를 사용한다.
display(data['Florida'])

# 슬라이싱은 행을 참조 (헷갈리지 말자.)
data['Florida': 'Illinois']

# 슬라이싱이 열을 참조하도록 해보자.
# 기대했던 것과는 다르게 마지막 행이 출력된다.
data['area':'population'] 

# 슬라이싱은 숫자로 변경 가능
data[1:3]

# 마스킹 연산은 행 단위로 해석
data.density > 100

data[data.density > 100]

import numpy as np
import pandas as pd

rng = np.random.RandomState(42)

# 0~10까지 랜덤하게 4개의 수를 뽑아서 value로 만든다.
ser = pd.Series(rng.randint(0, 10, 4))

ser

# index는 보존되고, value에만 지수 값이 적용 된다.
np.exp(ser)

# 0~10까지 랜덤하게 수를 뽑아서 3 by 4 행렬을 만든다.
df = pd.DataFrame(rng.randint(0, 10, (3 ,4)),
                 columns=['A', 'B', 'C', 'D'])

df

# 마찬가지로 data frame 내의 value만 적용된다.
np.sin(df * np.pi / 4)

# 두 개의 다른 데이터 소스를 결합해 미국 주에서 면적 기준 상위 세 개의 주와 인구 기준 상위 세 개의 주를 찾는다고 가정한다.
area = pd.Series({'Alaska': 1723337, 'Texas': 695662,
                 'California': 423967}, name='area')

population = pd.Series({'California': 38332521, 'Texas': 26448193,
                       'New York': 19651127}, name='population')

# 결과 배열은 두 입력 배열의 인덱스의 합집합을 담고 있다.
population / area

A = pd.Series([2, 4, 6], index=[0, 1, 2])
B = pd.Series([1, 3, 5], index=[1, 2, 3])

A + B

# 객체 메서드 add 사용, 비어있는 데이터에 0을 채워라.
A.add(B, fill_value=0)

A = pd.DataFrame(rng.randint(0, 20, (2, 2)), columns = list('ab'))
A

B = pd.DataFrame(rng.randint(0, 10, (3, 3)), columns = list('bac'))
B

# 없는 수의 경우 NaN이 채워진다.
A + B

# add method를 사용하여 NaN을 채워 넣을 수 있다.
A.add(B)

print(A.stack())
print(A.stack().mean())

fill = A.stack().mean()
A.add(B, fill_value = fill)

A = rng.randint(10, size = (3, 4))
A

print(type(A))
print(type(A[0]))

A - A[0]

df = pd.DataFrame(A, columns = list('QRST'))

display(df)

# df[0] : 에러 발생. 직접 해보시오. df.keys()를 쳐보자.
display(df.iloc[0])

# data frame에서 행으로 접근하기 위해서는 iloc을 사용한다.
df - df.iloc[0]

# 0번 row를 가지고 오되, 스텝 사이즈가 2이다.
halfrow = df.iloc[0, ::2]
display(halfrow)

display(df - halfrow)

value1 = np.array([1, None, 3, 4])

# value1의 dtype은 object이다.
value1

# 배열에서 파이썬 객체를 사용한다는 것은 None 값을 가진 배열에서 `sum()` 이나 `min()` 같은 집계 연산을 하면 일반적으로 오류가 발생할 것이다.
value1.sum()

value2 = np.array([1, np.nan, 3, 4])
value2.dtype

# NaN 덧셈
print(1 + np.NaN)

# NaN 곱셈
print(0 * np.NaN)

# NaN이 존재 할 때, 연산에서 에러를 내지는 않지만 정확한 값을 출력하지 않는다.
print(value2.sum())
print(value2.min())

# 누락된 값을 무시하는 특별한 집계 연산
print(np.nansum(value2))
print(np.nanmin(value2))

# Pandas는 nan과 none을 호환성 있게 처리하고, 적절한 경우 서로 변환할 수 있게 했다.
pd.Series([1, np.nan, 2, None])

# 부울 마스크를 반환
data = pd.Series([1, np.nan, 'hello', None])
data.isnull()

display(data.notnull())

# 부울 마스크는 Series나 DataFrame 인덱스로 직접 사용가능
display(data[data.notnull()])

# Series 의 경우
data.dropna()

# DataFrame 의 경우
df = pd.DataFrame([[1, np.nan, 2], 
                  [2, 3, 5],
                  [np.nan, 4, 6]])
df

df.dropna()

# 널 값을 포함하는 모든 열을 삭제하기 - data frame에서는 numpy와 달리 열을 삭제하기 위해서 axis = 1를 사용하였음에 주의하라.
df.dropna(axis = 1)

# NaN으로만 이루어진 컬럼을 추가한다.
df[3] = np.nan
df

# column의 모든 원소가 널 값일 때만 삭제
df.dropna(axis = 1, how = 'all')

# row의 원소 중에서 널이 아닌 값이 최소 3개가 있어야 열을 삭제 하지 않음
df.dropna(axis = 0, thresh = 3)

# series 일 때는 key를 설정하기 위해서 index, data frame 일 때는 key를 설정하기 위해서 columns
data = pd.Series([1, np.nan, 2, None, 3], index = list('abcde'))
data

# 단일 값 0으로 채우기
data.fillna(0)

# 이전의 값(index - 1)으로 채우기
data.fillna(method = 'ffill')

# 뒤의 값(index + 1)으로 채우기
data.fillna(method = 'bfill')

# DafaFrame의 경우 축을 지정하여 채울 수 있다.
display(df)

df.fillna(method = 'ffill', axis = 1)

import pandas as pd

# 사용할 메소드를 미리 만들자.
def make_df(cols, rows):
    """빠르게 DataFrame을 생성"""
    data = {c : [str(c) + str(i) for i in rows] for c in cols}
    return pd.DataFrame(data, rows)
    
# 예제
make_df('ABC', range(3))

ser1 = pd.Series(['A', 'B', 'C'], index = [1, 2, 3])
ser1

ser2 = pd.Series(['D', 'E', 'F'], index = [4, 5, 6])
ser2

# Concat의 기본값은 axis=0이다. 즉 row에 concat 된다.
print(pd.concat([ser1, ser2]))

df1 = make_df('AB', [1, 2])
df2 = make_df('AB', [3, 4])

display(df1)
display(df2)

# 기본적으로 row 아래로 연결된다.
display(pd.concat([df1, df2]))

df3 = make_df('AB', [0, 1])
df4 = make_df('CD', [0, 1])

display(df3)
display(df4)

# row 아래로 붙일 때
display(pd.concat([df3, df4], axis = 0))

# column 뒤에 붙일 때
display(pd.concat([df3, df4], axis = 1))

x = make_df('AB', [0, 1])
y = make_df('AB', [2, 3])

# 복제 인덱스 생성
y.index = x.index

display(x)
display(y)

display(x.index)
display(y.index)

# 인덱스가 복제되어서 겹쳐진다.
concated_df = pd.concat([x, y])
display(concated_df)

# 기존의 인덱스가 유지된다.
# Index를 겹쳐지지 않게 처리할 수 있는 방법은?
display(concated_df.iloc[0])
display(concated_df.iloc[2])

"""처리 방법 1 : 반복을 에러로 잡아낸다."""

try:
    pd.concat([x, y], verify_integrity = True)
except ValueError as e:
     print("ValueError:", e)

"""처리 방법 2 : 인덱스를 무시한다."""
display(x)
display(y)

display(pd.concat([x, y], ignore_index = True))

"""처리 방법 3 : 다중 인덱스 키를 추가한다."""
display(x)
display(y)

display(pd.concat([x, y], keys = ['a', 'b']))

"""새로운 키가 row에 형성된다."""
new_row_key = pd.concat([x, y], axis=0, keys = ['a', 'b'])
display(new_row_key)

# 다중 인덱스를 이용하여 하나의 원소에 접근하려면 tuple 형태로 접근해야 한다.
display(new_row_key.loc[("a", 0), "A"])

# 다중 인덱스를 이용하여 row에 접근하려면 아래와 같이 접근해야 한다.
display(new_row_key.loc[("a", 0)])

# 다중 인덱스와 iloc을 함께 사용하여 원소 및 row에 접근할 수는 없다. 
new_row_key.iloc[3, 1]

"""새로운 키가 column에 형성된다."""
new_col_key = pd.concat([x, y], axis=1, keys = ['a', 'b'])
display(new_col_key)

# 다중 인덱스를 이용하여 하나의 원소에 접근하는 법은 위와 비슷하다.
display(new_col_key.loc[0, ('a', 'A')])

# 다중 인덱스를 이용하여 column에 접근
display(new_col_key['a']['A'])

"""컬럼의 이름이 같은 것끼리 조인된다. defualt는 outer 조인이다."""

df5 = make_df('ABC', [1, 2])
df6 = make_df('BCD', [1, 2])

display(df5)
display(df6)

# outer 조인이기 때문에 없는 값은 NaN으로 채워진다.
display(pd.concat([df5, df6]))

"""inner 조인 사용하면 교집합으로 변경된다."""

pd.concat([df5, df6], join='inner')

"""남기고 싶은 열을 지정할 수 있다."""

# A, B, C 열만 남기고 싶은 경우.
pd.concat([df5, df6], join_axes=[df5.columns])

display(df1)
display(df2)

display(df1.append(df2))

# 회사의 직원 몇 명에 대한 정보를 포함하는 두 개의 DataFrame을 생각해보자.
import pandas as pd

df1 = pd.DataFrame({'employee': ['Bob', 'Jake', 'Lisa', 'Sue'],
                   'group': ['Accounting', 'Engineering', 'Engineering', 'HR']})
df1

df2 = pd.DataFrame({'employee': ['Lisa', 'Bob', 'Jake', 'Sue'],
                   'hire_date': [2004, 2008, 2012, 2014]})
df2

# 이 정보를 하나의 DataFrame으로 결합하고 싶다.
df3 = pd.merge(df1, df2)
df3

df4 = pd.DataFrame({'group': ['Accounting', 'Engineering', 'HR'],
                   'supervisor': ['Carly', 'Guido', 'Steve']})

display(df3)
display(df4)

display(pd.merge(df3, df4))

df5 = pd.DataFrame({'group': ['Accounting', 'Accounting',
                              'Engineering', 'Engineering',
                              'HR', 'HR'],
                   'hire_date': ['math', 'spreadsheets', 
                                 'coding', 'linux', 
                                 'spreadsheets', 'organization']})
display(df1)
display(df5)

display(pd.merge(df1, df5))

display(df1)
display(df2)

pd.merge(df1, df2, on='employee')

df3 = pd.DataFrame({'name': ['Bob', 'Jake', 'Lisa', 'Sue'],
                   'salary': [70000, 80000, 120000, 90000]})

display(df1)
display(df3)

pd.merge(df1, df3, left_on="employee", right_on="name")

# 중복된 열은 삭제하도록 한다.
pd.merge(df1, df3, left_on="employee", right_on="name").drop("name", axis = 1)

# 먼저 df1, df2를 보자.
display(df1)
display(df2)

# 컬럼 이름이었던 것을 인덱스를 설정
df1a = df1.set_index('employee')
df2a = df2.set_index('employee')

display(df1a)
display(df2a)

# 이 때는 left_index나 right_index를 지정하여 조인
pd.merge(df1a, df2a, left_index=True, right_index=True)

df1a.join(df2a)

display(df1a)
display(df3)

pd.merge(df1a, df3, left_index=True, right_on="name")

df6 = pd.DataFrame({'name': ['Peter', 'Paul', 'Mary'],
                   'food': ['fish', 'beans', 'bread']},
                  columns=['name', 'food'])

df7 = pd.DataFrame({'name': ['Mary', 'Joseph'],
                   'drink': ['wine', 'beer']},
                  columns=['name', 'drink'])

display(df6)
display(df7)

# 기본적으로 결과에는 입력값의 두 집합에 대한 교집합이 들어간다.
pd.merge(df6, df7)

# 명시적으로는 다음과 같이 한다.
pd.merge(df6, df7, how='inner')

pd.merge(df6, df7, how='outer')

pd.merge(df6, df7, how='left')