데이터 핸들링-판다스

import pandas as pd titanic_df = pd.read_csv(r'C:\Users\User\Desktop\Jupyter\titanic_train.csv') titanic_df.head(3) # .head() 의 default는 5 행이다. # 데이터 프레임의 행과 열 확인하기 print('DataFrame 크기: ', titanic_df.shape) # 결과는 튜플 형태 # 대표적인 데이터 프레임 메소드 : info() , describe() # .info() : 칼럼 별 데이터 타입, 칼럼 별 결측치 수를 확인할 수 있다. titanic_df.info() # .describe() : 칼럼 별 통계적 값을 확인할 수 있다. 물론, 타입이 int, float인 칼럼만 # 조사한다. titanic_df.describe() # 데이터의 대략적인 분포를 확인할 수 있다. 데이터의 이상치, 편향등을 예상할 수있다.

# Pclass 칼럼의 분포를 확인해본다. # DataFrame['칼럼명'] 을 하면 Series형태로 지정한 칼럼 데이터 세트가 반환된다. # value_counts() 메서드를 사용하면 해당 칼럼의 유형과 건수를 확인할 수 있다. # 이 메서드는 Series객체에서만 정의되어있다. 데이터프레임은 메서드를 가지고 있지 않다. value_counts = titanic_df['Pclass'].value_counts() print(value_counts) ''' 3 491 1 216 2 184 Name: Pclass, dtype: int64 '''

titanic_pclass = titanic_df['Pclass'] print(type(titanic_pclass)) titanic_pclass.head() ''' 0 3 1 1 2 3 3 1 4 3 Name: Pclass, dtype: int64 ''' # 맨왼쪽은 index, 오른쪽은 Series의 해당 칼럼의 데이터값이다. # value_counts()메서드의 결과값의 타입을 확인해보자. value_counts = titanic_df['Pclass'].value_counts() print(type(value_counts)) print(value_counts) ''' value_counts = titanic_df['Pclass'].value_counts() print(type(value_counts)) print(value_counts) '''

col_name1 = ['col1'] list1 = [1,2,3] array1 = np.array(list1) print('array1 shape :', array1.shape) # 리스트를 이용해 DataFrame 생성 df_list1 = pd.DataFrame(list1,columns=col_name1) print('1차원 리스트로 만든 DataFrame:\n', df_list1) # 넘파이 ndarray를 이용해 DataFrame 생성 df_array1 = pd.DataFrame(array1, columns = col_name1) print('1차원 ndarray로 만든 DataFrame:\n', df_array1)

# 3개의 칼럼명이 필요함 col_name2 = ['col1','col2','col3'] #2행 3열 형태의 리스트와 배열을 생성한 뒤 DataFrame으로 변환 list2 = [[1,2,3],[11,12,13]] array2 = np.array(list2) print('array2 shape :', array2.shape) # array2 shape : (2, 3) df_list2 = pd.DataFrame(list2, columns = col_name2) print('2차원 리스트로 만든 데이터프레임:\n', df_list2) ''' 2차원 리스트로 만든 데이터프레임: col1 col2 col3 0 1 2 3 1 11 12 13 ''' df_array2 = pd.DataFrame(array2, columns = col_name2) print('2차원 배열로 만든 데이터프레임:\n', df_array2) ''' 2차원 배열로 만든 데이터프레임: col1 col2 col3 0 1 2 3 1 11 12 13 '''

# key는 문자열 칼럼명으로 매핑, value는 리스트 형 칼럼 데이터로 매핑 dict = {'col1':[1,11], 'col2':[2,22], 'col3':[3,33]} df_dict = pd.DataFrame(dict) print('딕셔너리로 만든 dataframe:\n', df_dict) ''' 딕셔너리로 만든 dataframe: col1 col2 col3 0 1 2 3 1 11 22 33 '''

# df_dict를 ndarray로 변환 array3 = df_dict.values print('df_dict.values 타입: ', type(array3), 'df_dict.values shape: ', array3.shape) ''' df_dict.values 타입: <class 'numpy.ndarray'> df_dict.values shape: (2, 3) ''' print(array3) ''' [[ 1 2 3] [11 22 33]] '''

# DataFrame을 리스트로 변환 list3 = df_dict.values.tolist() print('df_dict.values.tolist() 타입:', type(list3)) print(list3) # DataFrame을 딕셔너리로 변환 dict3 = df_dict.to_dict('list') print('\n df_dict.to_dict() 타입:', type(dict3)) ''' df_dict.to_dict() 타입: <class 'dict'> ''' print(dict3) ''' {'col1': [1, 11], 'col2': [2, 22], 'col3': [3, 33]} '''

titanic_df['Age_0']=0 # 임의의 칼럼 생성과 값 생성 titanic_df.head(3)

titanic_df['Age_by_10'] = titanic_df['Age']*10 titanic_df['Family_No'] = titanic_df['SibSp'] + titanic_df['Parch']+1 titanic_df.head(3) # 칼럼 업데이트하기 titanic_df['Age_by_10'] = titanic_df['Age_by_10'] + 100 titanic_df.head(3)

# 'Age_0' 열을 삭제해보자. titanic_drop_df = titanic_df.drop('Age_0', axis=1) titanic_drop_df.head(3)

titanic_df.head(3) # inplace=True로 설정하면 원본의 데이터프레임에서 삭제를 한다. --> 대신 새 변수에 저장해주면 # None이라고 나온다. # 여러개의 열을 삭제하고 싶다면 labels값에 리스트로 입력한다. # Age_0, Age_by_10, Family_No' 삭제하기 drop_result = titanic_df.drop(['Age_0','Age_by_10','Family_No'], axis=1, inplace=True) print(' inplace=True 로 drop 후 반환된 값: ', drop_result) titanic_df.head(3)

pd.set_option('display.width', 1000) pd.set_option('display.max_colwidth',15) print('#### before axis 0 drop ####') print(titanic_df.head(3)) ''' #### before axis 0 drop #### PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked 0 1 0 3 Braund, Mr.... male 22.0 1 0 A/5 21171 7.2500 NaN S 1 2 1 1 Cumings, Mr... female 38.0 1 0 PC 17599 71.2833 C85 C 2 3 1 3 Heikkinen, ... female 26.0 0 0 STON/O2. 31... 7.9250 NaN S ''' titanic_df.drop([0,1,2], axis=0, inplace=True) print('#### after axis 0 drop ####') print(titanic_df.head(3)) ''' #### after axis 0 drop #### PassengerId Survived Pclass Name Sex Age SibSp Parch Ticket Fare Cabin Embarked 3 4 1 1 Futrelle, M... female 35.0 1 0 113803 53.1000 C123 S 4 5 0 3 Allen, Mr. ... male 35.0 0 0 373450 8.0500 NaN S 5 6 0 3 Moran, Mr. ... male NaN 0 0 330877 8.4583 NaN Q '''

# 원본 파일 다시 재로딩 titanic_df = pd.read_csv(r'C:\Users\User\Desktop\Jupyter\titanic_train.csv') # index 객체 추출 indexes = titanic_df.index print(indexes) # index 객체를 실제 값 array로 변환 print('Index 객체 array 값:\n', indexes.values) # 1차원 array로 0부터 890까지 가지고 있다. # 배열과 유사하게 단일 값 반환 및 슬라이싱이 가능하다. print(type(indexes.values)) print(indexes.values.shape) print(indexes[:5].values) # [0 1 2 3 4] print(indexes.values[:5]) # [0 1 2 3 4] print(indexes[6])

series_fare = titanic_df['Fare'] print('Fare Series max 값: ', series_fare.max()) ''' Fare Series max 값: 512.3292 ''' print('Fare Series sum 값: ', series_fare.sum()) ''' Fare Series sum 값: 28693.9493 ''' print('sum() Fare Series: ', sum(series_fare)) # 위와 같은 결과 ''' sum() Fare Series: 28693.949299999967 ''' print('Fare Series + 3:\n', (series_fare + 3).head(3)) ''' Fare Series + 3: 0 10.2500 1 74.2833 2 10.9250 '''

titanic_reset_df = titanic_df.reset_index(inplace=False) titanic_reset_df.head(3)

print('### before reset_index ###') value_counts = titanic_df['Pclass'].value_counts() # 결과는 series print(value_counts) ''' 3 491 1 216 2 184 Name: Pclass, dtype: int64 ''' print('value_counts 객체 변수 타입: ', type(value_counts)) new_value_counts = value_counts.reset_index(inplace=False) # 결과는 dataframe print('### after reset_index ###') print(new_value_counts) ''' index Pclass 0 3 491 1 1 216 2 2 184 ''' print('new_value_counts 객체 변수 타입: ', type(new_value_counts))

print('단일 칼럼 데이터 추출:\n', titanic_df['Pclass'].head(3)) ''' 단일 칼럼 데이터 추출: 0 3 1 1 2 3 Name: Pclass, dtype: int64 ''' print('\n 여러 칼럼의 데이터 추출:\n', titanic_df[['Survived', 'Pclass']].head(3)) ''' 여러 칼럼의 데이터 추출: Survived Pclass 0 0 3 1 1 1 2 1 3 ''' print('[ ]안에 숫자 index는 Keyerror 오류 발생:\n', titanic_df[0]) ''' 하지만 슬라이싱을 이용하거나 불린 인덱싱은 표현 가능하다. 대부분 데이터 셀렉션에서 불린 인덱싱을 많이 이용한다.''' titanic_df[0:2] # 슬라이싱은 가능은 하나 되도록 사용하지 않는 것이 좋다. # pclass 칼럼 값이 3인 데이터 3개만 추출 titanic_df[titanic_df['Pclass']==3].head(3)

data = {'Name':['Chulmin','Eunkyung','Jinwoong','Soobeom'], 'Year':[2011, 2016, 2015, 2015], 'Gender':['Male','Female','Male','Male']} data_df = pd.DataFrame(data, index=['one','two','three','four']) # data_df를 reset_index()로 새로운 숫자형 인덱스 생성 data_df_reset = data_df.reset_index() data_df_reset = data_df_reset.rename(columns={'index':'old_index'}) # 인덱스값에 1을 더해서 1부터 시작하는 새로운 인덱스값 생성 data_df_reset.index = data_df_reset.index+1 data_df_reset

data_df.iloc[0,0] # 다음 코드는 오류를 발생한다. data_df.iloc[0,'Name'] data_df.iloc['one',0] # data_df를 reset_index()로 새로운 숫자형 인덱스를 생성 data_df_reset = data_df.reset_index() data_df_reset = data_df_reset.rename(columns={'index':'old_index'}) data_df_reset.iloc[0,1]

data_df.loc['one','Name'] data_df.loc[1,'Name'] # 위와 같은 결과가 나온다. # 다음 코드는 오류를 발생시킨다. data_df_reset.loc[0,'Name']

print('위치 기반 iloc slicing\n', data_df.iloc[0:1,0], '\n') #1행 1열만 추출한다. print('명칭 기반 loc slicing\n', data_df.loc['one':'two', 'Name']) #2행까지 추출한다. # 이런부분들이 명칭 기반 인덱싱에서 헷갈리는 부분이다. # 특히 인덱스가 정수형일 때 더욱 조심해야 한다. print(data_df_reset.loc[1:2, 'Name']) # 명칭기반 loc인덱스이기 때문에 2행까지 추출한다.

# 승객 중 나이가 60세 이상인 데이터를 추출해보자. titanic_df = pd.read_csv('titanic_train.csv') titanic_boolean = titanic_df[titanic_df['Age']>=60] print(type(titanic_boolean)) # <class 'pandas.core.frame.DataFrame'> titanic_boolean

# 60세 이상인 승객의 나이와 이름을 추출해 보자. 위에 3개만 추출 titanic_df[titanic_df['Age']>=60][['Name','Age']].head(3) #물론 loc[]을 사용해서 추출할 수도 있다. titanic_df.loc[titanic_df['Age']>=60, ['Name','Age']].head(3)

# 나이가 60세 이상이고 선실 등급이 1등급이고 성별이 여성인 데이터를 추출해보자. titanic_df[(titanic_df['Age']>=60) & (titanic_df['Pclass']==1) & (titanic_df['Sex'] =='female')] # 위와 같은 결과는 cond1 = titanic_df['Age']>=60 cond2 = titanic_df['Pclass']==1 cond3 = titanic_df['Sex']=='female' titanic_df[cond1 & cond2 & cond3]

# 가상시뮬레이션 : reviews 테이블의 points 변수를 표준화시키고자 한다. review_points_mean = reviews.points.mean() reviews.points.map(lambda p: p - review_points_mean) # 위의 결과는 시리즈 객체 # 결과를 데이터프레임으로 나타내고 싶다면? --> apply 함수 사용 # 표준화시켜주는 함수 만들기 def remean_points(data): data.points = data.points - review_points_mean return data reviews.apply(remean_points, axis = 'columns') # 특정 칼럼의 데이터들에 대해서 변경(axis = 'columns')

# There are only so many words you can use when describing a bottle of wine. # Is a wine more likely to be "tropical" or "fruity"? # Create a Series descriptor_counts counting how many times each of these two words appears in the description column in the dataset. (For simplicity, let's ignore the capitalized versions of these words.) trop_cnt = reviews.description.map(lambda x: 'tropical' in x).sum() fruity_cnt = reviews.description.map(lambda x: 'fruity' in x).sum() descriptor_counts = pd.Series([trop_cnt,fruity_cnt], index = ['tropical','fruity'])

# titanic_df 에 count()를 적용했을 때 titanic_df.count()

# 나이와 요금에 대한 열만 평균 계산 titanic_df[['Age','Fare']].mean()

# Plcass 열을 기준으로 groupby 적용 titanic_groupby = titanic_df.groupby(by='Pclass') print(type(titanic_groupby)) # <class 'pandas.core.groupby.generic.DataFrameGroupBy'>

titanic_groupby = titanic_df.groupby('Pclass').count() titanic_groupby

# Pclass로 groupby를 한뒤, 승객id, 생존여부로 필터링을 해서 해당 열에 대해서만 count()함수를 # 적용해보자. titanic_groupby = titanic_df.groupby('Pclass')[['PassengerId','Survived']].count() titanic_groupby

# Pclass로 구분한 뒤 Age 에 대해서 최대값과 최소값을 계산하고 싶다. titanic_df.groupby('Pclass')['Age'].agg([max,min])

agg_format = {'Age':'max', 'SibSp':'sum', 'Fare':'mean'} titanic_df.groupby('Pclass').agg(agg_format)

import pandas as pd import seaborn as sns df = sns.load_dataset('titanic')[['age','sex','class','fare','survived']] grouped = df.groupby(['class','sex']) # class 와 sex로 다중그룹형성 gdf = grouped.mean() gdf age fare survived class sex First female 34.611765 106.125798 0.968085 male 41.281386 67.226127 0.368852 Second female 28.722973 21.970121 0.921053 male 30.740707 19.741782 0.157407 Third female 21.750000 16.118810 0.500000 male 26.507589 12.661633 0.135447

# class열의 first행만 인덱싱 gdf.loc['First'] age fare survived sex female 34.611765 106.125798 0.968085 male 41.281386 67.226127 0.368852 # class의 first, sex의 female만 인덱싱 gdf.loc[('First','female')] # 튜플 형태로 묶어주면 된다. age 34.611765 fare 106.125798 survived 0.968085 Name: (First, female), dtype: float64

gdf.xs('male', level='sex') # sex그룹(또는 1)의 male값을 갖는 행을 추출, 즉 등급(class)별 male에 대한 자료를 인덱싱

gdf.reset_index() # 라고 한다. # 만약, 컬럼이 멀티 인덱스인 경우, gdf2 = df.groupby('class').agg(['mean','max'])[['age','fare']] # class로 묶고, age,fare에 대해 mean과 max를 수행 [Output] age fare mean max mean max class First 38.233441 80.0 84.154687 512.3292 Second 29.877630 70.0 20.662183 73.5000 Third 25.140620 74.0 13.675550 69.5500 # 위의 멀티열인덱스가 보기 싫다면 다음과 같이 칼럼명을 새로 지정해주면 멀티인덱스가 해제된다. gdf2.columns = ['age_mean','age_max','fare_mean','fare_max'] print(gdf2.head()) [Output] age_mean age_max fare_mean fare_max class First 38.233441 80.0 84.154687 512.3292 Second 29.877630 70.0 20.662183 73.5000 Third 25.140620 74.0 13.675550 69.5500

titanic_df.isna().head(3) # 결측치 개수를 확인 ( 각 열에 대해서 결측치 개수를 알려줌 ) titanic_df.isna().sum() ''' PassengerId 0 Survived 0 Pclass 0 Name 0 Sex 0 Age 177 SibSp 0 Parch 0 Ticket 0 Fare 0 Cabin 687 Embarked 2 dtype: int64 '''

# Cabin 열의 NaN 값을 C000 으로 대체해 본다. titanic_df['Cabin'] = titanic_df['Cabin'].fillna('C000') titanic_df.head(3) # 위와 같은 방식으로는 fillna(inplace=True) 로 지정해주면 다시 값을 받지 않아도 된다. # 'Age'의 결측치를 평균으로, 'Embarked'의 결측치를 S로 대체해 보겠다. titanic_df['Age'].fillna(titanic_df['Age'].mean(), inplace=True) titanic_df['Embarked'].fillna('S', inplace=True) titanic_df.isna().sum() ''' PassengerId 0 Survived 0 Pclass 0 Name 0 Sex 0 Age 0 SibSp 0 Parch 0 Ticket 0 Fare 0 Cabin 0 Embarked 0 dtype: int64 ''' # 보간법으로 결측치 대체하기(연속데이터일때 유용) : interpolate() # 최반값으로 결측치 대체하기 : idxmax() df['embark_town'].value_counts().idxmax() # 해당 칼럼에서 가장 많이 나온값을 반환 most_freq = df['embark_town'].value_counts().idxmax() df['embark_town'] = df['embark_town'].fillna(most_freq) # 이웃한 데이터로 대체하기 : fillna의 method # method='ffill' : 이전값으로 채우기 # method='bfill' : 이후값으로 채우기

data = pd.read_csv('http://archive.ics.uci.edu/ml/machine-learning-databases/abalone/abalone.data',header=None, names=['sex','length','diameter','height','whole_weight','shucked_weight','viscera_weight','shell_weight','rings']) # 20개의 테스트 데이터만 저장 df_missing = data.copy()[:20] # 결측값 데이터 생성 df_missing.loc[0:4,'whole_weight'] = np.nan # 학습 데이터 생성 : x , y 에 결측값 삭제 X = df_missing.dropna(axis=0)[['diameter','height','shell_weight']] # 행에 결측치 하나라도 있으면 해당 행 제거 y = df_missing.dropna(axis=0)['whole_weight'] # 마찬가지 X.head() # 선형회귀 모델 생성 lin_reg = linear_model.LinearRegression() # 선형회귀 모형 구성 lin_reg_model = lin_reg.fit(X,y) # 선형회귀 모델로 'whole_weight' 추정값 계산 y_pred = lin_reg_model.predict(df_missing.loc[:,['diameter','height','shell_weight']]) y_pred # 선형회귀 모델의 예측값을 결측값에 대체 --> fillna() 함수 이용, flatten() 함수 이용 # flatten() : numpy에서 제공하는 다차원 배열 공간을 1차원으로 평탄화해주는 함수 df_missing['whole_weight'].fillna(pd.Series(y_pred.flatten()), inplace=True)

# 임의의 제곱 함수 식 def get_square(a): return a**2 print('3의 제곱은:',get_square(3)) # 람다 식으로 변환하기 lambda_square = lambda x : x ** 2 print('3의 제곱은:', lambda_square(3))

a=[1,2,3] squares = map(lambda x : x**2, a) list(squares)

# Name 열의 문자열 개수를 별도의 열인 'Name_len'으로 생성해보자. titanic_df['Name_len'] = titanic_df['Name'].apply(lambda x : len(x)) titanic_df[['Name','Name_len']].head(3) # 좀더 복잡하게 if else 를 사용해 나이가 15세 미만이면 Child, 그렇지 않으면 Adult로 구분하는 # 새로운 열 Child_Adult 열을 apply lambda식을 이용해 만들어보자. titanic_df['Child_Adult'] = titanic_df['Age'].apply(lambda x : 'Child' if x < 15 else 'Adult') titanic_df[['Age','Child_Adult']].head(3) ''' Age Child_Adult 0 22.0 Adult 1 38.0 Adult 2 26.0 Adult '''

# 15세 미만이면 child, 15세와 60세 사이면 adult, 61세 이상이면 elderly인 열을 만들어보자. titanic_df['Age_cat'] = titanic_df['Age'].apply(lambda x : 'Child' if x<15 else('Adult' if 15<=x<=60 else 'Elderly')) titanic_df['Age_cat'].value_counts() ''' Adult 791 Child 78 Elderly 22 Name: Age_cat, dtype: int64 '''

# 5살 이하는 baby, 12살 이하는 child, 18살 이하는 teenage, 25살 이하는 student, 35살 이하는 # young adult, 60세 이하는 adult, 그 이상은 eldery 로 분류해보자. # 함수 생성 def get_category(age): cat = '' if age <= 5 : cat = 'Baby' elif age <= 12 : cat = 'Child' elif age <= 18 : cat = 'Teenager' elif age <= 25 : cat = 'Student' elif age <= 35 : cat = 'Young Adult' elif age <= 60 : cat = 'Adult' else : cat = 'Elderly' return cat # lambda 식에 위에서 생성한 get_category()함수를 반환값으로 지정. # get_category(x)는 입력값으로 'Age' 칼럼 값을 받아서 해당하는 cat 반환 titanic_df['Age_cat'] = titanic_df['Age'].apply(lambda x : get_category(x)) titanic_df[['Age','Age_cat']].head()