list_data = [1,2,3,4,5]
example_obj = Series(data = list_data)
example_obj
'''
0    1
1    2
2    3
3    4
4    5
dtype: int64
'''

# 인덱스 문자열로 바꾸기
list_data = [1,2,3,4,5]
list_name = ["a","b","c","d","e"]
example_obj = Series(data = list_data, index=list_name)
example_obj
'''
a    1
b    2
c    3
d    4
e    5
dtype: int64
'''
# dict 타입으로 생성하기
dict_data = {"a":1, "b":2, "c":3, "d":4, "e":5}
example_obj = Series(dict_data, dtype=np.float32, name="example_data")
# series 객체 이름 지정
example_obj.name = "number"
# index 이름 지정
example_obj.index.name = "alphabet"
# 데이터 타입(dtype) 변경하기
example_obj = example_obj.astype(int)

raw_data = {'first_name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'],
        'last_name': ['Miller', 'Jacobson', 'Ali', 'Milner', 'Cooze'],
        'age': [42, 52, 36, 24, 73],
        'city': ['San Francisco', 'Baltimore', 'Miami', 'Douglas', 'Boston']}
df = pd.DataFrame(raw_data, columns = ['first_name', 'last_name', 'age', 'city'])
df.first_name # == df["first_name"], series 데이터형
# 인덱싱
s = pd.Series(np.nan, index=[49,48, 1, 2])
s.loc[:1] # 인덱스 이름이 1인 row 까지만
'''
49   NaN
48   NaN
1    NaN
'''
s.iloc(:1] # 인덱스 위치가 1인 row까지만
'''
49   NaN
'''
# column에 새로운 데이터 할당
df.debt = df.age > 40 # column 'debt'에 comparison의 T/F 값 입력하여 붙임

# 컬럼 데이터 타입 확인
df.head(3).T
# 컬럼명 지정
df["a"].head(2)
df[["a", "b", "c"]].head(3)
# 컬럼명 없이 사용하는 인덱스 지정은 row를 표시한다.
df[:3] # == df[[0,1,2]], 0,1,2 row 표시
# 조건식 넣어 selection
df[20 < "age" < 40]

# basic
# 컬럼명과 row index 숫자
df[["name","street"]][:2]
# loc
# row index 명과 컬럼명
df.loc[['c','e'],["name","street"]]
# iloc
# 컬럼 숫자와 row index 숫자
df.iloc[:2,:2]

# 직접 지정해주기
df.index = list(range(0,10))
# 디폴트 인덱스를 추가한 데이터 프레임을 반환
# 기존 인덱스를 대체하고싶다면 drop=True 옵션
df.reset_index(drop=True)
# 단, inplace=True 옵션을 사용하면 원본 데이터 프레임 변환을 '적용'시킨다.

# 1번 row 삭제
df.drop(1)
# 'city' column 삭제
df.drop("city",axis=1)

matrix = df.as_matrix()

s1 = Series(range(1,6), index=list("abcde"))
s2 = Series(range(5,11), index=list("bcdefg"))
# 겹치는 index는 b,c,d,e
s1 + s2 # == s1.add(s2)
'''
a     NaN
b     7.0
c     9.0
d    11.0
e    13.0
f     NaN
g     NaN
dtype: float64
'''

df1 = DataFrame(
    np.arange(9).reshape(3,3), 
    columns=list("abc"))
df2 = DataFrame(
    np.arange(16).reshape(4,4), 
    columns=list("abcd"))
# df2.loc[3]과 df2["d"]가 겹치지 않음
# df1 + df2
df1.add(df2,fill_value=0) # 겹치지 않아 NaN 값이 들어갈 위치를 0으로 채움

df = DataFrame(
    np.arange(16).reshape(4,4), 
    columns=list("abcd"))
s = Series(
    np.arange(10,14), 
    index=list("abcd"))
s2 = Series(np.arange(10,14))
# Series가 Dataframe의 column과 같은 index을 가져 바로 row로 변환되는 경우
df + s
# Series가 Dataframe의 column과 다른 index을 가져 row로 변환되지 않는 경우
df + s2 # 모든 값이 NaN으로 채워짐
# axis를 기준으로 row broadcasting 수행
df.add(s2, axis=0)

# number_df의 값들을 제곱하는 mapping
number_df.map(lambda x: x**2).head(5)
# str 성별값을 0,1 코드값으로 바꾸어 sex_code 컬럼에 추가하는 mapping
df["sex_code"] =  df.sex.map({"male":0, "female":1})
# str 성별값을 0,1 코드값으로 변환하여 출력 - replace
df.sex.replace({"male":0, "female":1}).head()
# to_replace=변환할 키값(from), value=변환하여 저장할 값(to)
# to_replace에 해당하는 값을 value에 있는 값으로 변환시키겠다
df["race"].replace(to_replace=key, value=value, inplace=True)

df_info = df[["earn", "height","age"]]
f = lambda x : x.max() - x.min()
df_info.apply(f)
'''
earn      318047.708444
height        19.870000
age           73.000000
dtype: float64
'''
# Series 값 반환
def f(x):
    return Series([x.min(), x.max(), x.mean()], 
                    index=["min", "max", "mean"])
df_info.apply(f)
'''
earn    height  age
min -98.580489  57.34000    22.000000
max 317949.127955   77.21000    95.000000
mean    32446.292622    66.59264    45.32849
'''

f = lambda x : -x
df_info.applymap(f).head(5)
# 위의 코드는 아래 코드와 동일한 기능을 수행한다.
# f = lambda x : -x
# df_info["earn"].apply(f).head(5)

df.describe()

df.race.unique()
'''
array(['white', 'asian', 'hispanic', 'black', 'other'], dtype=object)
'''

# 컬럼별 합
df.sum(axis=0)
# row별 합
df.sum(axis=1)

# null인 data의 index를 반환
df.isnull()
# Null인 셀 개수 확인
df.isnull().sum()

# ascending=False 시 내림차순
df.sort_values(["age","earn"], ascending=True).head()

# df.[컬럼1].함수(df.[컬럼2])
df.age.corr(df.earn)
df.age.cov(df.earn)
df.corrwith(df.earn)
# 모든 컬럼들간의 상관관계를 다 보여준다
df.corr()

# phone_data.csv 파일 다운로드
!wget https://www.shanelynn.ie/wp-content/uploads/2015/06/phone_data.csv

df_phone = pd.read_csv('./data/phone_data.csv')
df_phone.dtypes
'''
...
date                   object
...
'''
# 문자열 타입의 date 컬럼 값을 각각(apply) 파싱하여 datetime 타입으로 변환
# parse 함수의 argument에서 '일(day)'가 '월(month)'보다 먼저나온다면 dayfirst=True
df_phone['date'] = df_phone['date'].apply(dateutil.parser.parse, dayfirst=True)
df_phone.dtypes
'''
date            datetime64[ns]
'''
# datetime 타입의 월별로 묶어, duration(통화시간)의 합계를 matplotlib로 그래프 표시
df_phone.groupby("month")["duration"].sum().plot()
# month와 item별로 묶어 duration count
# unstack으로 row 인덱스 값들을 column 인덱스로 재구성해 볼 수 있다.
df_phone.groupby(['month','item'])['duration'].count().unstack().plot()
# month로 묶되, 인덱스로 삼지는 말것(as_index=False)
# duration에는 sum을 적용시킬것(agg({"duration":"sum"}))
# agg함수는 그룹에 대하여 사용자가 정의한 집계함수를 적용할 수 있다.
df_phone.groupby("month", as_index=False).agg({"duration":"sum"})
# df_phone.groupby("month").agg({"duration":"sum"}).reset_index # 비슷한 결과
# group 타입 객체를 만들었다면
group.add_prefix('duration_') # 컬럼이름에 접두사 추가하기

# 각 데이터의 value 위치에 들어갈 값은 ["rating"] 컬럼값들 중 하나로 정한다.
# critic의 값들을 row index로 하고, title의 값들을 columns로 구성한다.
# 각 value에 aggfunction "sum"을 적용하고, NaN값은 0으로 채운다.
df_movie.pivot_table(["rating"], index=df_movie.critic, columns=df_movie.title,
                     aggfunc="sum", fill_value=0)

# 세 함수는 같은 역할을 한다.
df_movie.groupby(["critic","title"]).agg({"rating":"first"}).unstack().fillna(0)
df_movie.pivot_table(["rating"], index=df_movie.critic, columns=df_movie.title,
                     aggfunc="sum", fill_value=0)
pd.crosstab(index=df_movie.critic,columns=df_movie.title,values=df_movie.rating,
            aggfunc="first").fillna(0)

# 같은 이름의 컬럼을 기준으로 join
pd.merge(df_a, df_b, on='subject_id')
# 다른 이름의 컬럼을 하나의 컬럼으로 보고, 이를 기준으로 join
pd.merge(df_a, df_b, left_on='subject_id_a', right_on='subject_id_b')
# left join
pd.merge(df_a, df_b, on='subject_id', how='left')
# outer join
pd.merge(df_a, df_b, on='subject_id', how='outer')
# 인덱스를 기준으로 join
pd.merge(df_a, df_b, right_index=True, left_index=True)

# 세로로 붙이기
df_new = pd.concat([df_a, df_b])
df_new.reset_index() # 해주지 않으면, 인덱스가 그대로 붙어 0,1,2,3,0,1,2, ... 형태가 된다.
#df_a.append(df_b) # 거의 같은 기능을 가진다.
# 가로로 붙이기
df_new = pd.concat([df_a, df_b], axis=1)
df_new.reset_index()

import sqlite3 # pymysql을 미리 설치할 것!
conn = sqlite3.connect(".sqlite_example.db")
cur = conn.cursor()
cur.execute("select * from name limit 5;") # SQL문 직접 사용 가능
results = cur.fetchall()
results

writer = pd.ExcelWriter('./data/df_routes.xlsx', engine='xlsxwriter')
# 액셀 형태로 저장
df_routes.to_excel(writer, sheet_name='Sheet1')

df_routes_pickle = pd.read_pickle("./data/df_routes.pickle")
df_routes_pickle.head()