df.dtypes == 'object'
df_object=df[['Suburb','Address','Type','Method','SellerG','Regionname','CouncilArea']]

for i in df_object:
    if len(df[i].unique())> 50:
    # if df[i].nunique() > 50 : 이어도 error
        df= df.drop(i, axis=1, inplace=True)


>>> 'NoneType' object is not subscriptable

원인 : df = df.drop으로 썼음 해결 : df.drop(i, axis=1, inplace=True) 이렇게 작성함

dropna

원하는 행은 꼭 subset=['컬럼명']

df.dropna(subset=['Price'],inplace=True)

중복제거

df.drop_duplicates(inplace=True)

#결측치 확인
df.isna().sum()[df.isna().sum() !=0]/len(df)

• [] len(df)를 나눠주는 이유는 ..?

  # 고유한 값이 너무 많은 컬럼도 예측에 도움이 되지 않으니 확인하고 삭제해주겠습니다. 
  df.nunique()[df.nunique()/len(df)>0.7]
  cols = ['Id', 'LotArea']
  df.drop(cols, axis=1, inplace=True)

  #타겟분포확인
  # 왼쪽으로 치우쳐진 분포입니다. 주택 판매 가격이 400000을 넘지 않는 샘플만 다시 추출하도록 하겠습니다.
  df = df[df['SalePrice']<400000]
  sns.histplot(df['SalePrice'], bins=50)
  # 수치형 컬럼과 타겟간의 상관관계를 확인해보겠습니다. 상관관계가 높은 상위 10개 컬럼만 보도록하겠습니다. 
  # target = SalePrice
  df.corr()['SalePrice'].sort_values(ascending=False).head(11)

  Modeling

  from sklearn.model_selection import train_test_split
  X = df.drop('SalePrice', axis=1)
  y = df['SalePrice']
  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

  모델링에 필요한 두 가지 전처리

1. Scaling scaler = StandardScaler()
2. Encoding

   # 결측치를 먼저 평균으로 모두 채워주겠습니다. 
   X_trian.fillna(X_train.mean(), inplace=True)
   X_test.fillna(X_test.mean(), inplace=True)

   #수치형 변수만 스케일링
   #dtype으로 수치형 변수 판별하기 
   numeric_feats = X_train.dtypes[X_train.dtypes != "object"].index
   scaler = StandardScaler()
   X_train[numeric_feats] = scaler.fit_transform(X_train[numeric_feats])
   X_test[numeric_feats] = scaler.transform(X_test[numeric_feats])

   # .T가 행과 열 위치 바꿈
   X_train[numeric_feats].describe().T[['mean','std']]

   One-Hot encoding

   from category_encoders import OneHotEncoder
   ohe = OneHotEncoder()
   

X_train_ohe = ohe.fit_transform(X_train) X_test_ohe = ohe.fit_transform(X_test)

(X_train_ohe.dtypes == 'object').sum()

mszoning_cols = [x for x in X_train_ohe.columns if 'MSZoning' in x] X_train_ohe[mszoning_cols].head(3)

#범주형 특성이 어떻게 변환이 되었는지 확인 ohe.category_mapping

#### 기준모델 : 평균이용

from sklearn.metrics import r2_score, mean_absolute_error

baseline = [y_train.mean()]*len(y_train) baseline_r2 = r2_score(y_train, baseline) baseline_mae = mean_absolute_error(y_train, baseline)

#### 다중선형회귀 OLS

def print_score(model, X_train, y_train, X_test, y_test) : train_score = np.round(model.score(X_train, y_train) , 3) val_score = np.round(np.mean(cross_val_score(model, X_train, y_train, scoring='r2', cv=3).round(3)),3) test_score = np.round(model.score(X_test, y_test),3)

return train_score, val_score, test_score

from sklearn.model_selection import cross_val_score

선형회귀를 ols라는 객체에 저장합니다.

ols = LinearRegression()

모델 학습

ols.fit(X_train_ohe, y_train)

성능 비교

ols_train, ols_val, ols_test = print_score(ols,X_train_ohe, y_train, X_test_ohe, y_test)

#### ridge regression 모델 만들기

for alpha in [0.01, 0.1, 1.0, 1, 100.0, 1000.0, 10000.0]: print(f"Ridge Regression, alpha={alpha}")

#모델학습
ridge = Ridge(alpha=alpha)
ridge.fit(X_train_ohe, y_train)

#성능확인()#print_score 위에서 만들었던 함수
print_score(ridge,X_train_ohe, y_train, X_test_ohe, y_test)

#coefficients 계수
#절대값 상위 40개의 회귀계수만 불러오기 
coefficients = pd.Series(ridge.coef_, X_train_ohe.columns)
idx = np.abs(coefficients).head(40).index

```

sklearn에서 내장된 교차검증 알고리즘 ridgeCV

def selfintroduction(name, age, address):
    print(f"나는 {name}이고, {age}살이고 {address}에 거주합니다.")

selfintroduction("똑똑2", 24, "경기도")

>>>나는 똑똑2이고, 24살이고 경기도에 거주합니다. 

파라미터가 존재하지 않지만, return 함수

import random

def sundaySchedule():
    li = ["하루종일 공부하기","하루종일 놀기","털기춤","섹시 웨이븡"]
    tjob = random.choice(li)
    return tjob

x = sundaySchedule()
print("일요일인 오늘은 "+x+"를  하는 날로 당첨되었습니다.")
# print("일요일인 오늘은 "+sundaySchedule()+"를 하는 날로 당첨되었습니다. )

>>> 일요일인 오늘은 하루종일 공부하기를  하는 날로 당첨되었습니다.
#예시도 무슨 하루종일 공부야 !!!!!!!!! 어이없어

2개의 리스트를 인자로 받아서 동일한 인덱스에 위치한 원소들을 곱하여 새로운 리스트를 도출하는 프로그램 예제

def listMul(x1, x2): #입력으로 2개의 리스트를 받음
    tlist=[] #동일한 인덱스 두 원소를 곱한 결과를 저장할 리스트
    for i in range(len(x1)):
        tlist.append(x1[i]*x2[i])
    return tlist #리스트로 값을 돌려줌

li1 = [2,4,6,8,10]
li2= [1,2,3,7,9]

newList = listMul(li1,li2) #함수의 리턴 값 list를 newList에 할당함

print(f"li1 = {li1}")
print(f"li2 = {li2}")
print(f"두 리스트의 동일 인데스 원소의 곱셈 결과:{newList}")

>>> 
li1 = [2, 4, 6, 8, 10]
li2 = [1, 2, 3, 7, 9]
두 리스트의 동일 인데스 원소의 곱셈 결과:[2, 8, 18, 56, 90]

def evOdGrouping(): #입력받은 데이터를 짝수와 홀수로 그룹핑하는 함수
    i=1 #함수 내에서 할당한 변수는 함수 내에서만 유효
    while i <= 10:
        in1 = int(input(f"{i}번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :"))
        if in1 % 2 == 0 : #짝수이면
            elist.append(in1) #짝수들
        else : #홀수이면
            olist.append(in1) #홀수들
        i += 1 #i값을 1씩 증가시킴

def mulElements(li):#리스트의 원소들을 모두 곱해 리턴
    mul =1 #곱셈의 결과 저장 변수
    for el in li:
        mul*=el
    return mul #return시 mul값을 돌려줌

elist = [] #짝수의 모음
olist = [] #홀수의 모음

evOdGrouping() #gkatnghcnf

print(f"elist = {elist}, olist ={olist}")
print(f"짝수들의 곱 :{mulElements(elist)}")
print(f"홀수들의 곱 :{mulElements(olist)}")

>>> 1번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. : [입력창]
1번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :1
2번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :2
3번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :3
4번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :4
5번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :5
6번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :6
7번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :7
8번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :-8
9번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :-9
10번째 값으로 -100 ~ 100 사이의 정수를 입력하세요. :-10
elist = [2, 4, 6, -8, -10], olist =[1, 3, 5, 7, -9]
짝수들의 곱 :3840
홀수들의 곱 :-945

함수를 이용해서 평균과 분산 구하기

#variance 구하기_함수 응용
import random
li1 =[] #리스트
li1_avg = None #리스트 1의 평균값

for _ in range(50):#range에서 넘겨주는 값을 사용하지 않을 때 _를 사용함
    li1.append(random.randint(1,50))

print(f"li1 = {li1}")

#함수의 정의를 함수의 호출 이전에 하면 문제없음.
def average(li):
    sum = 0
    for i in li:
        sum += i 
        return (sum/len(li))

def variance(li,avg):
    squaredAdd = 0
    for i in li:
        squaredAdd += (i-avg)**2
    return squaredAdd/len(li)

li1_avg = average(li1)
li1_var = variance(li1, li1_avg)

print(f"li1의 평균 : {li1_avg}, li1의 분산 : {li1_var:.4f}")

람다함수

람다함수는 익명함수 def가 정상함수

lambda 넘겨줄 인자들 (arguments) : 표현식(expression) lambda 함수는 return구문을 사용하지 않는다.

lambda 넘겨줄 인자들 (arguments) : 표현식(expression)
square = lambda a:a**2
x = square(3)
print(x)

#인자의 갯수는 일치해야 함(선언과 동시에 호출)
x = (lambda a,b : a+b)(3,5)
print(f"a+b의 결과는 {x}")

def power(n):
    return lambda x : x**n

 orderPower = power(4)
 print(f"3**4의 값은 : {orderPower(3)}")

 >> 3**4의 값은 : 81

map(function, iterable1, iterable2,...)

def mul(x,y):
    return x,y
x = map(mul,("orange",'banana','strawberry'),('노랗다',"길다","빨갛다"))

x=list(x)
print(f"x={x}")

y=map(lambda a,b : a+b,("orange",'banana','strawberry'),('노랗다',"길다","빨갛다"))
y = list(y)
print(f"y = {y}")
>>>
x=[('orange', '노랗다'), ('banana', '길다'), ('strawberry', '빨갛다')]
y = ['orange노랗다', 'banana길다', 'strawberry빨갛다']

filter(조건함수(function), iterable) 함수

def odd(x):
    return True if x %2 ==1 else False

li = list(range(1,11))
oddlterator = filter(odd, li)

oddList = list(oddlterator)
pritn(f"일반함수를 사용한 홀수 원소들의 필터링 결과 : {oddList}")
>>>일반함수를 사용한 홀수 원소들의 필터링 결과 : [1, 3, 5, 7, 9]

### 람다함수 이용
oddlter = filter(lambda x : x%2 == 1, li)
oddLi = list(oddlter)
print(f"람다함수를 사용한 홀수 원소들의 필터링 결과 : {oddLi}")
>>>람다함수를 사용한 홀수 원소들의 필터링 결과 : [1, 3, 5, 7, 9]

#con에서 지상생활면적이 1700보다 크고 1800보다 작은 값에서 가격을 비교
con = (df['GrLivArea']>=1700) & (df['GrLivArea']< 1800)
df.loc[con, 'SalePrice].min()

.set_option

#판다스 객체들의 결과에서 쉼표를 넣고 소수점 아래는 생략하도록 설정할 수 있습니다.
#float 형식 소숫점 1자리, 쉼표 포함
pd.set_option.display.float_format = '{:,.1f}'.format
pd.set_option('display.float_format', '{:,.1f}'.format)

#기본세팅
pd.set_option('display.float_format',None)

distplot

kind = ' histplot', 'kdeplot', 'ecdfplo' 3가지 plot그릴 수 있음 kde(Kernel Density Estimator) 커널밀도추정 = 곡선화 시켜 줌

산점도에 가장 잘 맞는 직선을 그려주면 그것이 회귀 회귀선 : 실제값- 모델의 예측값[잔차] RSS를 최소로 하는 직선 찾기 RSS : 선형회귀모델의 비용함수. 모델을 학습한다: 비용함수를 최소로 하는 파라미터를 찾는 것. OLS : Ordinary Least Square : 최소제곱법, 잔차의 제곱을 최대한 작게함.

sns.regplot

추세선 95% 신뢰구간을 나타냄

종속변수는 반응(Response)변수, 레이블(Label), 타겟(Target)등으로 불립니다. 독립변수는 예측(Predictor)변수, 설명(Explanatory)변수, 특성(feature) 등으로 불립니다.

scikit-learn 이용해서 선형회귀모델 만들기 특성행렬(독립변수) = X 타겟배열(종속변수) = y .fit() : 모델학습 predict() : 새로운 데이터 예측

다중선형회귀

from sklearn.linear_model import LinearRegression
#feature과 target을 먼저 지정해줌
feature = ['GrLivArea', 'OverallQual']
target = 'SalePrice'

X=df[feature]
y=df[target]

• 3차원 그래프 그리는 것도 해보기 ~ 라고 미뤄두기 😉

  변수 3개 2차원 그래프 그리기
  #독립변수 하나를 hue로 지정해줌
  #size
  sns.scatterplot(x=dff['GrLivArea'], y=df['SalePrice'], hue=df['OverallQual'], size=df['OverallQual'], alpha=0.6)

  #모델학습
  multiple_ols = LinearRegression()
  multiple_ols.fit(X,y)

  다항선형회귀

  from sklearn.pipeline import make_pipeline
  from sklearn.preprocessing import PolynomialFeatures
  

PolynomialFeatures를 사용하면 다항회귀를 만들 수 있습니다.

#degree=2 이차항 def PolynomialRegression(degree=2, kwargs) return make_pipline(PolynomialFeatures(degree)), LinearRegression(kwargs))

features = ['GrLivArea', 'OverallQual'] target = 'SalePrice'

X = df[features] y = df[target]

#2차항의 다항선형회귀 poly_ols = PolynomialRegression(degree=2) poly_ols.fit(X,y)

[링크텍스트](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.Pipeline.html#sklearn.pipeline.Pipeline)
pipeline : 데이터변환(전처리)과 모델을 연결하여 코드를 줄이고 재사용성 높임
scaler를 불러오고 , fit, transform한 후 모델을 학습하는 일련의 작업이 있었지만 pipeline 을 사용하면 **단순히 어떤 스케일러를 쓰고 모델을 쓸것인지만 입력하면 됨**
make_pipeline : 여러 개의 사이킷런 변환기(fit, transform)와 그 뒤에 fit와 predict를 구현한 사이킷런 추정기 연결
따로 튜플로 단계를 작성할 필요가 없다. 모델만 써줘도 자동으로 class 이름을 소문자로 생성
[링크텍스트](https://hhhh88.tistory.com/6)

#### 회귀 평가지표
- MSE RMSE MAE R-sqaured

from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error

실제값

y_real = df['SalePrice'] #기준모델 y_base = [predict]*len(df)

#단순선형회귀 모델 학습 simple_ols = LinearRegression() simple_ols.fit(X,y)

feature = ['GrLivArea'] #독립변수 입력 X_simple = df[feature] #X에 독립변수 넣어주기
y_simple = simple_ols.predict(X_simple) #학습한 x로 y값 예측

#다중선형회귀 모델학습 multiple_ols = LinearRegression() multiple_ols.fit(X,y)

features = ['GrLivArea', 'OverallQual'] X_multiple = df[features] y_multiple = multiple_ols.predict(X_multiple)

#다항선형회귀 y_poly = poly_ols.predict(X_multiple)

* [ ] 헷갈리는 부분 꼭 확인하기 함수 !!! 

#위에서 y_real = df['SalePrice'] #종속변수 #mse, rmse, mae, r2[error]를 출력하는 함수입니다.

여기서 y_pred가 밑에 y_base,y_simple가 들어가는 건가?? 뭐지

def eval_models(y_pred, y_real=y_real): mse = mean_squared_error(y_real, y_pred) rmse = np.sqrt(mse) #제곱근 mae = mean_absolute_error(y_real, y_pred) r2 = r2_score(y_real, y_pred)

return mse, rmse, mae, r2

#평가지표 값 base_mse, base_rmse, base_mae, base_r2 = eval_models(y_base) #기준모델 simple_mse, simple_rmse, simple_mae, simple_r2 = eval_models(y_simple) multiple_mse, multiple_rmse, multiple_mae, multiple_r2 = eval_models(y_multiple) poly_mse, poly_rmse, poly_mae, poly_r2 = eval_models(y_poly)

표만들기

comparison_metrics = pd.DataFrame(index=['mse', 'rmse', 'mae', 'r2'], columns=['Base','Simple', 'Multiple', 'Polynomial']) comparison_metrics['Base'] = [base_mse, base_rmse, base_mae, base_r2 ] comparison_metrics['Simple'] = [simple_mse, simple_rmse, simple_mae, simple_r2] comparison_metrics['Multiple'] = [multiple_mse, multiple_rmse, multiple_mae, multiple_r2] comparison_metrics['Polynomial'] = [poly_mse, poly_rmse, poly_mae, poly_r2] comparison_metrics

#### 선형회귀모델의 계수 Coefficients
- 선형회귀모델의 큰 장점: 직관적 해석이 가능
- `coef_`

#다중선형회귀 #회귀계수 print("coefficient :", multiple_ols.coef_)

절편(intercept)

print('Intercept : ', multiple_ols.intercept_) ```

제주 날씨,인구에 따른 교통량데이터 : 출처 제주 데이터 허브 DataUrl = ‘https://raw.githubusercontent.com/Datamanim/pandas/main/Jeju.csv’

url =‘https://raw.githubusercontent.com/Datamanim/pandas/main/Jeju.csv’
df = pd.read_csv(url, encoding='euc-kr')

수치형 변수를 가진 컬럼을 출력 .select_dtypes

범주형 변수를 가진 컬럼을 출력

#df.columns == 이렇게 시도했다.
ans = df.select_dtypes(exclude=object).columns
ans = df.select_dtypes(include = object).columns

평균 속도 컬럼의 4분위 범위(IQR) 값을 구하여라

ans = df['평균속도'].quantile(0.75) - df['평균속도'].quantile(0.25)

읍면동명 컬럼의 유일값 갯수를 출력하라 .nunique(), .unique()

ans = df.읍면동명.nunique()

url = 'https://raw.githubusercontent.com/Datamanim/pandas/main/chipo.csv'

quantity컬럼 값이 3인 데이터를 추출하여 index를 0부터 정렬하고 첫 5행을 출력하라

ans = df.loc[df['quantity']==3].head().reset_index(drop=True)

item_price 컬럼의 달러표시 문자를 제거하고 float 타입으로 저장하여 new_price 컬럼에 저장하라

df['new_price'] = df['item_price'].str[1:].astype('float')
ans = df['new_price'].head()

new_price 컬럼이 5이하의 값을 가지는 데이터프레임을 추출하고, 전체 갯수를 구하여라

ans = len(df.loc[df.new_price <=5])

item_name명이 Chicken Salad Bowl 인 데이터 프레임을 추출하라고 index 값을 초기화 하여라

ans = df.loc[df.item_name == 'Chicken Salad Bowl'].reset_index(drop=True)

new_price값이 9 이하이고 item_name 값이 Chicken Salad Bowl 인 데이터 프레임을 추출하라

ans = df.loc[(df.new_price <=9) & (df.item_name == 'Chicken Salad Bowl')]

df의 new_price 컬럼 값에 따라 오름차순으로 정리하고 index를 초기화 하여라

ans  = df.sotr_values('new_price).reset_index(drop=True)

df의 item_name 컬럼 값중 Chips 포함하는 경우의 데이터를 출력하라

ans = df.loc[df.item_name.str.contains('Chips')]

df의 item_name 컬럼 값이 Steak Salad 또는 Bowl 인 데이터를 데이터 프레임화 한 후, item_name를 기준으로 중복행이 있으면 제거하되 첫번째 케이스만 남겨라 drop_duplicates()

ans = df.loc[(df.item_name == 'Steak Salad') | (df.item_name == 'Bowl')]
ans = ans.drop_duplicates('item_name')
ans = ans.drop_duplicates('item_name', keep='last')

df의 데이터 중 item_name의 값이 Izze 데이터를 Fizzy Lizzy로 수정하라

df.loc[df.item_name == 'Izze','item_name'
ans =df
ans

df의 데이터 중 choice_description 값이 NaN 인 데이터를 NoData 값으로 대체하라(loc 이용) ~

df.loc[df.choice_description.isnull(),'choice_description'] = 'NoData'
ans = df

df의 데이터 중 choice_description 값에 Vegetables 들어가지 않는 경우의 갯수를 출력하라

ans = len(df.loc[~df.choice_description.str.contains('Vegetables')])
ans

df의 데이터 중 item_name 값이 N으로 시작하는 데이터를 모두 추출하라 .startswith()

ans = df[df.item_name.str.startswtih('N')]
ans

df의 데이터 중 item_name 값의 단어개수가 15개 이상인 데이터를 인덱싱하라

ans = df[df.item_name.str.len() >=15]
ans.head(3)

df의 데이터 중 new_price값이 lst에 해당하는 경우의 데이터 프레임을 구하고 그 갯수를 출력하라 lst =[1.69, 2.39, 3.39, 4.45, 9.25, 10.98, 11.75, 16.98] isin

st1 = [1.69, 2.39, 3.39, 4.45, 9.25, 10.98, 11.75, 16.98]
ans = df.loc[df.new_pric.isin(st1)]

display(ans.head(3))
prin(len(ans))

데이터의 각 host_name의 빈도수를 구하고 host_name으로 정렬하여 상위 5개를 출력하라 .size() .value_counts().sort_index()

ans = df.groupby('host_name').size()
ans = df.host_name.value_counts().sort_inex()

데이터의 각 host_name의 빈도수를 구하고 빈도수 기준 내림차순 정렬한 데이터 프레임을 만들어라. 빈도수 컬럼은 counts로 명명하라

Ans = df.groupby('host_name').size().\
                to_frame().rename(columns={0:'counts'}).\
                sort_values('counts',ascending=False)

neighbourhood_group의 값에 따른 neighbourhood컬럼 값의 갯수를 구하여라 크기 .size(), as_index = False

ans = df.groupby(['neighbourhood_group','neighbourhood'],as_index = False).size()

nighbourhood_group의 값에 따른 neighbourhood컬럼 값 중 neighbourhood_group그룹의 최댓값들을 출력하라 .size() 갯수

ans = df.groupby(['nighbourhood_group','neighbourhood'],as_index=False).size()\
        .groupby(['neighbourhood_group'], as_index=False).max()

neighbourhood 값과 neighbourhood_group 값에 따른 price 의 평균을 계층적 indexing 없이 구하라 .unstack()

ans = df.groupby(['neighbourhood','neighbourhood_group']).price.mean().unstack()

plt.scatter(x,y)
plt.scatter(파일['컬럼명'],파일['컬럼2'])

sns.scatter(파일['컬럼명'],파일['컬럼2'], hue='카테고리지정')

1. index_col=0

   df1 = pd.reda_csv(url, index_col=0)

2. drop 사용

   df2 = df2.drop(df2.columns[0], axis=1)

   #원본 데이터에 지정하지 않아도 원본 데이터프레임에 바로 반영
   df3.drop(['Unnamed: 0'],axis=1, inplace =True)

   링크텍스트

• barplot, 이산형 자료에 대해 범주별로 빈도나 합계 등을 비교하는 데에 유용하다.

• df[['total_bill','tip']].plot(kind='box')

tmp = '12,578'을 정수 12578로 변환하는 코드

#tmp,를 공백으로 바꿔준 뒤에 정수로 변환
int(tmp.replace(tmp[2],""))
#tmp를 , 기준으로 나눈 다음에 다시 합쳐주기 
a,b = tmp.split(",")
int(a+b)

변환코드

df.groupby('sex')['species'].count()

pd.merge(df1, df2, on='No.',how='right')

# df1 에다가 df2그냥 가져다가 사용
df1.append(df2)
pd.concat([df1,df2])

append 세로로만 결합가능 is the specific case (axis=0, join='outer')of concat concat 가로, 세로 모두 결합 가능 gives the flexibility to join based on the axis(all rows or all columns) join is based on the indexes(set by set_index)on how variable = ['left','right','inner','counter'] merge is based on any particular column each of the two dataframes, this columns are variables on like 'left_on','right_on','on'

** p-value**

• p-value가 0에 가까울수록 대립가설이 힘을 얻는다.

• p-value는 0과 1사이의 확률이다.

• p-value를 통합 귀무가설이 맞다는 전제하여 simulation을 진행한다.

• p-value는 sample size와는 무관하다.

• 귀무가설 :null hypothesis

• 단측검정 : One-sided T-test

• 양측검정 : Two-sided T-test

중심극한정리 큰 수의 법칙

• 중심극한 정리 Central Limit Theorem : 어떠한 모양의 임의의 분포에서 추출한 표본집단들의 평균의 분포는 정규분포를 이룬다.
• 큰 수의 법칙 Law of Large Numbers : 어떤 모집단에서 표본집단들을 추출할 때, 각 표본집단의 크기가 커지면 그 표본집단들의 평균은 모집단의 평균과 같아지고, 표본집단들의 분산은 0에 가까워 진다.

암에 걸릴 확률은 1% 이고, 암 검사가 정확히 암을 양성이라고 진단할 확률은 90% 입니다. 또한 암이 아닌데 양성이라고 진단할 확률은 10%입니다. 어떤 사람이 암 검사 결과에서 양성 반응이 나타났을 때, 실제로 이 사람이 암에 걸렸을 확률을 구하는 공식은 아래와 같습니다. 링크텍스트

• A와 B 모두 square matrix이다.

• 2개의 데이터 셋이 동일한 연관성을 가지지만, 공분산 값이 다를 수 있다.

• 어느 벡터이던 단위 벡터의 선형 조합으로 나타낼 수 있다.
• 상관계수의 절대값은 1을 넘을 수 없다.

K-means clustering을 실행하기 전, 데이터에 Data Standardization 필수 진행

#train_test_split(X,Y,test_size =0.25) 평가세트를 새로 만듦 (학습에 사용되지는 않음) 25%정도 학습

경사하강법

Y(정답) =WX(입력) + b(잔차)

model.predict('X')

학습된 규칙과 모델을 활용해 새로운 입력에 대한 예측 값 제공

model.fit(X,Y)

: 학습

martix

• 수 또는 변수를 ()안에 행과 열로 배열
• 2차원 형태의 array 또는 list로 나타냄
• 행과 열의 개수는 매트릭스의 차원을 의미 .shape을 통해 확인
• 두 매트릭스 일치 = 차원과 성분이 동일해야 함.

  .ndim

• 배열의 차원 확인

  .shape

• 벡터의 차원 확인
• 콤마 앞의 수는 벡터의 차원, 즉 성분의 개수

  2d = np.array([[1,2,3],[4,5,6]])
  2d
  >>array([[1, 2, 3],
       [4, 5, 6]])

  #.ndim을 사용하여 배열의 차원확인
  2d.ndim
  >> 2

  #.shape을 사용하여 매트릭스의 차원(행의 수, 열의 수)확인
  2d.shape
  >>(2,3)
  # 1차원일 경우 #1d = np.array([1,2,3,4,5])
  1d.shape
  >>(5, )

행렬의 연산

행렬의 전치 Transpose

• 행과 열을 바꾸어 나타내는 것입니다.
• 일반적으로 $A^T$로 표기합니다.
• .T 또는 np.transpose()를 사용하여 구할 수 있습니다.
• 전치의 전치는 자기 자신입니다.

  $(A^T)^T=A$

a=np.array([[1,2,3],[4,5,6]])
a
>>array([[1, 2, 3],
       [4, 5, 6]])

a.T
>>array([[1, 4],
       [2, 5],
       [3, 6]])

(a.T).T
>>array([[1, 2, 3],
       [4, 5, 6]])

#np.transpose(a)
>>array([[1, 4],
       [2, 5],
       [3, 6]])

행렬곱Matrix Multiplication

• 두 행렬에 대해서 앞 행렬의 열과 뒷 행렬의 행의 수가 같으면 행렬끼리 곱할 수 있습니다.
• np.matmul()을 사용하여 구할 수 있습니다.
• 행렬곱의 결과는 행렬입니다.
• 두 행렬의 차원이 $m\times l$, $l\times n$이면 행렬곱으로 얻은 행렬의 차원은 $m\times n$입니다.

  

정사각형 행렬Square Martix

대각 행렬 Diagonal Martix

: 주 대각선(principal diagonal)을 제외한 모든 성분이 0인 정사각 행렬

$D = \begin{bmatrix} a_{1,1} & 0 & 0 \ 0 & a_{2,2} & 0 \ 0 & 0 & a_{3,3} \end{bmatrix}$

단위 행렬Identity Matrix

• 대각 행렬 중에서 주 대각선 성분이 모두 1인 매트릭스
• np.identity() 또는 np.eye()를 사용하여 나타낼 수 있습니다

  $I_1 = \begin{bmatrix} 1 \end{bmatrix} \qquad I_2 = \begin{bmatrix} 1 & 0 \ 0 & 1 \end{bmatrix} \qquad I_3 = \begin{bmatrix} 1 & 0 & 0 \ 0 & 1 & 0 \ 0 & 0 & 1 \end{bmatrix}$

• 임의의 정사각 행렬에 단위 행렬을 곱한 것은 자기 자신과 같습니다.

  $AI=A$

np.identity()와 np.eye()의 차이

링크텍스트

역행렬

• np.linalg.inv() 사용하여 역행렬 구함.

np.multiply() 행령의 요소 별 곱셈

: 행렬의 특정 행, 열 또는 부분 행렬의 요소 별 곱셈을 수행

np.linalg.matrix_rank()

np.linalg.matrix_rank(A, tol=None) : Return matrix rank of array using SVD method 링크텍스트

#범위 지정해줌
#밑에 식과 같이 작성해야 함. 셀을 분리해서 작성하면 화면 분리됨
plt.xticks(np.arange(x,y))
plt.yticks(np.arange(x,y))

plt.xlim, plt.ylim

#데이터 범위 지정
plt.xlim(-4, 2)          
plt.ylim(0, 4)

plt.axvline()

• 축을 따라 수평선 작성

  plt.axvline(x=0,ylim=0,ymax=1)
  x : 수직선을 배치할 데이터 좌표x 위치
  ylim : y축의 시작 위치, 0과 1사이의 값을 사용, 0을 축의 하단, 1은 축의 상단
  ymax :수직선 y축의 끝 위치, 0과 1 사이의 값을 취합니다. 0은 축의 맨 아래, 1은 축의 맨 위 
  plt.axvline(0, 0, 1, color='lightgray', linestyle='--', linewidth=1)

  

링크텍스트

matplotlib.pyplot.화살표 (x,y,dx,dy)

• x,y 화살표 밑면의 좌표
• dx, dy : x 및 y 방향을 따른 화살표의 길이 #벡터는 화살표의 길이로 크기를 나타냄 https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.arrow.html

  import matplotlib.pyplot as plt
  v1 = [2, 1]
  #벡터는 계산을 제외하고는 원점에서 시작
  #head_with = float 또는 없음, 기본값: 3*with : 전체 화살촉의 총 너비입니다.
  #v1[0] = x좌표 2
  #v1[1] = y좌표 1
  plt.arrow(0,0,v1[0], v1[1], head_width=0.1, color='#790D90')
  #글씨 위치 입력
  plt.text(2.2, 1.1, 'v1')

  #벡터는 행렬이므로 계산을 하기 위해 array로 바꿔줘서 수학적인 계산이 가능하게 함. 
  w1 = np.array(v1)*2

  벡터의 스칼라곱(실수배)

  벡터의 실수배 연산을 벡터에 스칼라를 곱한다. 벡터 : 크기와 방향을 갖는 물리량 스칼라 : 크기만 갖는 물리량 링크텍스트

np.dot 벡터의 내적 구하기

#np.dot을 사용하지 않을 경우에는 

#벡터값
v1 = [2, 1]
v2 = [-3, 2]
#벡터 계산할 수 있도록 array로 배열
arr_v1 = np.array(v1)
arr_v2 = np.array(v2)
#각각 곱하기 
arr_v1 * arr_v2

>> array([-6,  2])

# 벡터내적계산하는 방법을 알고 있어야 함. 
(arr_v1 * arr_v2).sum()
>> -4

#np.dot()으로 벡터의 내적 구하기
np.dot(v1, v2)

>> -4

• 데이터를 연속적인 공간에 저장
• 순서를 가지며 각 원소에 차례로 index가 할당됨
• 서로 다른 자료형을 원소로 가질 수 있음
• 수치적 연산은 불가능

#list()로 문자열 원소
df = list('cute')
df

>>  ['c', 'u', 't', 'e']

#index가 0~2인 원소 출력
for i in range(3):
    print(df[i])

>>> c
    u
    t

#문자열 반복
for i in range(3):
    print(df)

['c', 'u', 't', 'e']
['c', 'u', 't', 'e']
['c', 'u', 't', 'e']

# []로 숫자형 원소를 갖는 list 생성
numList = [1,2,3]
numList

>>> [1, 2, 3]

#list의 합
df + numList

>>> ['c', 'u', 't', 'e', 1, 2, 3]

#list의 곱
print(df*2)
print()

>>> ['c', 'u', 't', 'e', 'c', 'u', 't', 'e']

#문자열과 숫자형을 원소로 갖는 list 생성
#자료형이 혼합되어도 본래 자료형은 그대로 유지
testList = [0,'a',4.6]

type(testList[0])

Array

• numpy 배열
• 순서를 가지며 각 원소에 차례대로 index 할당
• 동일한 자료형만 원소로 가질 수 있음
• 수치적 연산 가능

``` np.array=()로 array생성

자료형이 폰합되어 있는 경우 모두 문자열로 처리됨

arr_a = np.array([5, 3.2, 'a']) type(arr_a[0])

numpy.str

• 하나의 숫자(실수)를 나타냅니다.
• 변수에 저장하여 표기할 수 있습니다.
• 양수, 음수 모두 가능합니다.

  $a = 5 \quad b = 1.81 \quad c=-3e \quad d=\pi$

스칼라와 벡터

• 스칼라 : 크기
• 벡터 : 크기 + 방향이 존재

Vector

• 순서를 갖는 1차원 형태의 배열로 list 또는 array로 나타냅니다. #2개면 2차원 3개면 3차원 ...
• 헤드부분이 벡터의 성분을 향해서 있음
• 성분의 개수는 벡터의 차원을 의미합니다.

  $\begin{align} \vec{a} = \begin{bmatrix}

       8\\
       9

  \end{bmatrix} \qquad \vec{b} = \begin{bmatrix}

      -4\\
       7\\
       1

  \end{bmatrix} \qquad \vec{c} = \begin{bmatrix}

       5.5332

  \end{bmatrix} \qquad \vec{d} = \begin{bmatrix}

       Pl\\
       x\\
       y\\
       \frac{2}{3}

  \end{bmatrix} \end{align}$

  벡터의 스칼라곱

  스칼라 + 스칼라 => 스칼라 스칼라 * 스칼라 => 스칼라 (#스칼라는 숫자) 스칼라 + 벡터 => 더하기 불가능 (같은 종류만 가능함) 스칼라 * 벡터 => 벡터 벡터 + 벡터 => 벡터 벡터 * 벡터 => 스칼라

            벡터 (중간에 `x` 표시)
            텐서
            ![](https://velog.velcdn.com/images/ddoy_eon/post/0e07e627-954b-4c1a-add4-0ee0e5e645e3/image.png)
           ![](https://velog.velcdn.com/images/ddoy_eon/post/ddacd605-bc61-4319-9072-f398cb054847/image.png)

  직각좌표계 단위벡터들 사이의 스칼라곱

• 같은 단위벡터들 사이의 스칼라곱은 1
• 다른 단위벡터들 사이의 스칼라곱은 0

  직교하는 두 벡터와 스칼라곱

  직교는 스칼라 곱으로 판단

벡터의 크기

• 벡터의 선의 길이 = 벡터의 크기
• Norm 혹은 length, Magnitude라고 합니다.
  • 벡터의 길이를 나타냅니다. 따라서 음수가 될 수 없습니다.
  • 벡터의 모든 성분이 $0$이면 벡터의 크기도 $0$입니다. ;영벡터 : 방향을 고려하지 않음
  • 벡터의 크기를 나타내는 기호 : $||v||$와 같이 표기합니다.
    • 값이 1이라면 단위벡터 : 크기가 1로 조정, 방향을 나타내는 데 집중함.
  • 피타고라스 정리를 사용하여 구할 수 있습니다.

• 두 벡터가 서로 같을 조건
  • 크기와 방향이 동일하면 위치와 상관없음
  • 
  • - 는 방향이 반대임을 나타냄

$v = [a, b, c, \cdots]$

$||v|| = \sqrt{a^2 + b^2 + c^2 + \cdots}$

벡터의 내적

• Dot Product라고 합니다.
• 두 벡터에 대해서 서로 대응하는 [인덱스가 같은 값]각각의 성분을 곱한 뒤 모두 합하여 구합니다. 이때 두 벡터의 차원이 같아야 합니다.[성분의 개수가 달라 짝이 맞지 않으면 내적 불가능]
• np.dot()을 사용해 구할 수 있습니다.
• 벡터를 내적한 값은 스칼라입니다.

  $v_1 = [a_1, a_2, a_3, \cdots]$

  $v_2 = [b_1, b_2, b_3, \cdots]$

  $v_1 \cdot v_2 = a_1b_1 + a_2b_2 + a_3b_3 + \cdots$

: 벡터 F와 벡터 S의 내적은 두개의 벡터의 크기를 곱한 후 cos을 곱한 값

• 벡터를 내적한 값 = 스칼라

벡터의 직교(Orthogonality) : 두 벡터의 내적이 0이면 두 벡터는 서로 수직입니다.

• 영벡터가 아닌 두 벡가 직교하기 위한 필요충분조건은 a· b=0

링크텍스트

단위 벡터 Unit Vector

• 길이가 $1$인 벡터입니다.
• 모든 벡터는 단위 벡터의 선형 결합으로 표기할 수 있습니다.

  $v = [2,5] = [2,0] + [0,5] = 2[1,0] + 5[0,1] = 2\hat{i} + 5\hat{j}$ [2,5]는 [2,0] + [0,5] 의 합임 [2,0] 은 2[1,0] 이고 [0,5]은 5[0,1]라고 나타낼 수 있다. 여기서[1,0] hat{i},[0,1] hat{j}은 단위가 1인 단위벡터가 된다. 💡Tip

• 크기가 $1$인 길이를 단위 길이(unit length)라고 합니다.
• 선형 결합(linear combination) : 벡터 $v_1, v_2, \cdots, v_n$와 스칼라 $a_1, a_2, \cdots, a_n$에 대하여 다음과 같이 벡터의 스칼라곱과 합으로 나타낸 것입니다.

  $a_1v_1 + a_2v_2 + \cdots + a_nv_n$

Colab한글 깨짐 현상 해결 방법

• Step 1. 폰트 설치 (아래 코드 실행) Step 2. 런타임 재시작 (런타임 > 런타임 다시 시작) Step 3. 라이브러리 임포트 (폰트 설치 이후 코드 실행)

  # 폰트 설치
  !apt-get update -qq
  !apt-get install fonts-nanum* -qq
  !rm ~/.cache/matplotlib -rf입력하세요

#폰트 설정 #정해져 있는 코드 #한글이 깨지지 않도록 하는 코드 
path = '/usr/share/fonts/truetype/nanum/NanumGothic.ttf' # 나눔 고딕
font_name = fm.FontProperties(fname=path, size=20).get_name() # 기본 폰트 사이즈 : 20
plt.rc('font', family=font_name)
fm._rebuild()
mpl.rcParams['axes.unicode_minus'] = False
%matplotlib inline

시각화 하기 위해 필요한 라이브러리

import pandas as pd
import numpy as np
import matplotlib.pylab as plt
import matplotlib.font_manager as fm
import matplotlib as mpl 
import seaborn as sns

plot 함수

• plot 데이터 집합을 도표, 그래프로 표시
• plot 함수는 kind라는 옵션으로 다양한 그래프 시각화 가능
  • kind 옵션: line bar hist box pie scatter area

라인(line)

#figsize 그래프의 크기 결정
df.plot(kind ='line', figsize=(가로,세로), title ='제목')

#원하는 컬럼만 따로 지정해서 그리기 
df1['원하는 컬럼명'].plot(kind='line', figsize(가로,세로), title='제목')

바(bar)

#막대 그래프
#컬럼별로 평균을 냄
groupby한 컬럼| 컬럼1 |컬럼2 |컬럼3
해당1           평균   평균   평균
해당2           평균   평균   평균
해당3           평균   평균   평균
bar_df = df1.groupby(df1.컬럼).mean()

bar_df.plot(kind='bar', figsize=(가로,세로), title='제목')

#전치 연산
#행과 열을 바꿈
bar_df.T.plot(kind='bar', figsize=(가로,세로), title='제목')

히스토그램 (hist)

• 빈도수를 알아볼 때 사용

  df1.plot(kind='hist', figsize=(가로,세로), title = '제목')
  

#빈(bin)개수 지정 #이진법 df1.plot(bins=숫자, kind='hist', figsize=(가로,세로), title = '제목')

#### 박스(box)

df1.plot(kind ='box', figsize=(가로,세로), title = '제목')

#### 파이(pie)

#value_counts : 얼마나 반복되는 지 pie_df=df2['컬럼'].value_counts() df1.plot(kind ='pie', figsize=(가로,세로), title = '제목')

#레이블 추가 #autopct = %자동계산, 소수점 첫째 자리까지 계산 #font 는 %값 나타냄 df1.plot(kind ='pie', figsize=(가로,세로), title = '제목',autopct='%.1f%%', fontsize=20)

#### 산점도(scatter)

#나이에 따른 타이타닉 승선 요금 f2.plot(kind='scatter', figsize=(가로,세로) , x='age', y='fare', title='나이에 따른 타이타닉 승선 요금')

#버블차트 #버블에 100을 곱하여 더 크게 볼 수 있음 df2.plot(kind='scatter', figsize=(15,8) , x='age', y='fare', title='나이에 따른 타이타닉 승선 요금', s=df2['pclass']*100) ```

• 구체적인 로직을 적용하고 싶을 경우
• 로직이 정의된 함수를 만들고, apply() 함수에 대입

  #def 함수 정의 코드임 
  #replace_xero : file명
  #x = input 들어오는 값들 
  def replace_zero(x):
    if x ==0: #input인자가 0일 경우에
        x =165 #값이 0일 경우에 165로 대체하라 
    return x #아닐 경우에 다시 반환하라 

  #apply에 (함수코드 파일명)을 입력해주면 함수가 적용됨
  df['컬럼명']=df['컬럼명'].apply(replace_zero)
  df

  lamda 함수

• def정의된 함수와 동일한 기능
• 한줄로 작성가능 def return 작성하지 않아도 괜찮음
• 로직이 복잡하지 않을 경우에 사용
• 가독성이 좋고 간편함
• lamda '입력변수':'리턴값' '조건문(옵션)'

#적용하고 싶은 컬럼명 
#  x가 0일 경우에 x를 50으로 반환해라 
# x가 0일 아닌 경우라면 input값 그대로 반환해라 
df['컬럼명']=df['컬럼명'].apply(lamda x:50 if x ==0 else x)

#집계된 컬럼 만들기 #파생 컬럼 생성 #dataframe 마지막 열에 생성됨 
df['컬럼명1'+'컬럼명2'] = df.apply(lamda x: x['컬럼명1']+x['컬럼명2'],axis=1)

map 함수

• 데이터 값을 특정한 값으로 mapping하고 싶은 경우 사용
• 하나의 컬럼인, Series 형으로만 적용가능
  • df['컬럼명'].map('매핑정보')
  • key : value

    map_info = {'M' : '남자',
           'F' : '여자'}
    

df['컬럼명'] =df['컬럼명'].map(map_info) ```

• 결측값 : 자료에 누락된 값
• NaN, N/A, NULL, 0값 등 다양한 방식으로 존재

.replace('바꾸고 싶은 값','교체할 값')

#df에 존재하는 0값을  numpy에서 제공하는 결측값 NaN으로 교체 
 df = df.replace(0, np.NaN)

결측 데이터 확인 isnull() , notnull()

#결측값 = True로 존재함
df.isnull()

#isnull의 반대로 나타남 
#결측값 = False로 존재함
df.notnull()

# 결측값 = True = 1
df.isnull().sum()

결측 데이터 제거dropna()

#결측인 값 존재하면 존재하는 행 모두 삭제 
#결측값이 많은 경우 dropna사용을 자제함 => 다 사라지기 때문에 
df.dropna()

#subset=['컬럼명'] 옵션 지정하면 해당 컬럼만 검사 
#옵션을 넣어줌 
#[컬럼] 결측값만 삭제하고 나머지는 결측값이 존재해도 삭제하지 않음
#[컬럼]이 존재하지 않을 때, 데이터 분석이 불가능 하다는 판단이 있는 경우 사용
#사용자 의사결정에 기반함
df.dropna(subset=['컬럼명'])
df.dropna(subset=['컬럼명1','컬럼명2']

결측 데이터 치환fillna()

• fillna('결측값을 대체할 값')

  #해당하는 컬럼에 존재하는 결측값을 fillna를 통해서 값을 채워줌
  df['컬럼']=df['컬럼'].fillna('결측값을 대체할 값')

  평균값으로 대체fillna('평균값')

  #결측값 대체할 컬럼의 평균을 먼저 구해줌 
  #mean_column은 임의로 지정한 값임
  #df['컬럼'].mean() => 평균값임
  mean_column = df['컬럼'].mean()
  df['컬럼']=df['컬럼'].fillna(mean_column)

  최빈값으로 대체fillna('최빈값')

• value_counts() : 값을 세어주는 함수를 통해서 최빈값 알아냄

  #해당 컬럼에 존재하는 값 중에서 최빈값을 숫자로 나타내 줌
  df['컬럼'].value_counts()

  #index형태로 바꿔줌
  df['컬럼'].value_counts().index
  

#index에서 최빈값 추출 #0번째가 맨 앞 = 최빈값 df['컬럼'].value_counts().index[0]

df['컬럼'] = df['컬럼'].fillna(df['컬럼'].value_counts.index[0])

#### 인덱스 재정렬 reset_index()
* 결측치 처리 과정에서, 데이터 프레임의 인덱스가 바뀌는 현상 발생
* reset_index() 인덱스 정렬

drop=True 옵션은 이전의 인덱스를 버린다는 의미 drop 안 하면 기존의 인덱스를 인식함 df = df.reset_index(drop=True)

### 중복값 처리 

#임의로 중복값 생성 #마지막 값을 똑같이 중복시킨다는 의미 df = df.append(df.iloc[-1]).reset_index(drop=True)

#### 중복데이터 탐색 duplicated()

#중복된 행 찾기 df[df.duplicated()]

#특정 열에서 중복 값 찾기 True False로 나타남 df['컬럼'].duplicated()

#### 중복데이터 제거 drop_duplicates()

#기본적으로 '완벽히' 중복된 행을 제거 df.drop_duplicates()

#특정 열을 기준으로 제거 #keep = 'first'가 지정값 #['컬럼']을 기준으로 중복된 컬럼은 다 삭제 후, 맨 앞에 컬럼만 존재 df.drop_duplicates(subset=['컬럼'])

#특정 열을 기준으로 제거하는 데 마지막 값을 남김 df.drop_duplicates(subset=['컬럼'], keep='last') ```

#문자열로 변경
df['컬럼명'] = df['컬럼명'].astype('str')

#타입 확인하는 방법
# 추출하고자 하는 행[0]
type(df['컬럼명'][0])

pd.to_datetime(df['컬럼명'])

• datetim
  • epandas에서 날짜와 시간 데이터를 처리 하기 위해 지원하는 자료형
    • datetime 자료형 변환 : 연산가능

      df['컬럼']=pd.to_datetime(df['컬럼'])

  • Timestamp* : 변환완료
  • .dt* : 슬라이싱 준비

    #연도 추출
    df['컬럼'].dt.year
    #월 추출
    df['컬럼'].dt.month
    #일 추출
    df['컬럼'].dt.day
    #요일 추출 (월요일: 0, 화요일: 1, 수요일: 2, 목요일: 3, 금요일: 4, 토요일: 5, 일요일: 6)
    df['컬럼'].dt.dayofweek

데이터 프레임에 추가하는 방법

#컬럼명은 지정
#표 컬럼에 ['Year_컬럼']['Month_컬럼']['Day_컬럼']새롭게 추가
df['Year_컬럼']=df['컬럼'].dt.year
df['Month_컬럼']=df['컬럼'].dt.month
df['Day_컬럼']=df['컬럼'].dt.day

산술연산

사칙연산

• df['컬럼'] + df['컬럼']
• df['컬럼'] - df['컬럼']
• df['컬럼'] * df['컬럼']
• df['컬럼'] / df['컬럼']
• df['컬럼'] +10 값 전체에다가 10 씩 더해주는 것임.

  datetime 연산

• 날짜/시가 연산 하기 위한 조건 : pd.Timedelta
• pd.to_timedelta(df['컬럼명'], unit='시간 간격 단위')
• df['컬럼명'] = pd.to_timedelta(df['컬럼명'], unit='시간 간격 단위')

  통계 연산

• 행 계산 (axis = 0), 열 계산 (axis = 1)

  #행 평균 #위에서 아래로
  df.mean(axis=0)

  #열 평균 #왼쪽에서 오른쪽으로
  df.sum(axis=1)

• 행 가져오기 (df['행 시작 인덱스' : '행 끝 인덱스']) 행 가져오기는 연속적으로 데이터를 불러옴

  #행 하나 가져오기 
  df[0:1]
  

#행 여러개 가져오기 #index 0번, 1번 행을 가져옴 df[0:2]

#5 이상인 행 가져오기 df[5:]

#### 특정열에서 값 가져오기 

#특정 컬럼에서 0번재 값 가져오기 df['컬럼명'][0]

### 열(column)선택하기 
* _**열은 '컬럼명'지정 행은'index'지정**_
* 열 하나 가져오기 (**df['컬럼명'] or df.컬럼명**)
* 범위 설정 df[df.columns[시작인덱스 : 끝 인덱스]]

#컬럼이 어떤 것들이 있는 지 확인 df.coulmns

컬럼 여러 개 지정시 []중복 사용학 ㅣ!!

df[['컬럼명1','컬럼명2']]

### loc, iloc
* df.loc['행':'열']
* df.iloc['행':'열']

### loc
* '특정 레이블 label=(index로 이해하기)'통해 접근
* **index 기준으로 찾는 것**을 loc로 이해하기 
* **location** 약어

#0번째,3번째,5번째 행을 가져온다고 오해 말기 !! #index에 0,3,5라고 적혀 있는 행을 가져오는 것임 df.loc[[0,3,5]]

#### 숫자 인덱스 형에서 문자열 인덱스로 변경하는 방법
### 인덱스 이름 변경.set_index()

#새로운 파일이름 = #기존에 사용하고 있던 파일 복사 loc_df = df.copy()

파일명.index = 파일명['컬럼명']
파일명.set_index('컬럼명') => 전체 index명 바뀜

loc_df.index = loc_df['변경하고자 하는 컬럼명'] loc_df.set_index('변경하고자 하는 컬럼 명')

loc_df.loc[['index명1','index명2']]

#### loc 조건문 사용(df.loc['조건문'])

#파일명.loc[파일명['컬럼명]=='원하는 값' #'컬럼'에서 ~인 경우에만 가져온다. #'컬럼'에서 ~이 아닌 경우에만 가져온다. df.loc[df['컬럼명']=='원하는 값'] df.loc[df['컬럼명']!='원하는 값'

#컬럼이 5이상인 경우에만 가져옴 df.loc[df['컬럼']>=5]

#### loc 특정 열 조회

#(행,열) 위치관계 잊지 않기 #'컬럼'에 대한 것만 가져오기 df.loc[:,['컬럼명']]

#중복 선택일 경우 [[]] df.loc[:,['컬럼1','컬럼2']]

#### loc 조건문 df.loc[:,'조건문']

#특정 열 가져오기 #특정 열 제외하고 가져오기 df.loc[:,df.columns == '컬럼명'] df.loc[:,df.columns != '컬럼명']

#### loc 행, 열 조건

#지정 컬럼에 속해 있는 열을 가져옴 df.loc[df['index']=='특정 index',['컬럼']] df.loc[df['index']=='특정 index',df.columns == '특정 컬럼']

### iloc 
* integer location
#### iloc 특정 행 조회

#0번째 가져옴 #지정해준 파일명.iloc[0] iloc_df.iloc[0] #0,1,3번째 가져옴 iloc_df.iloc[[0,1,3]]

#index이름이 필요 없음 #1번째부터 3번째까지 가져옴 iloc_df.iloc[1:3]

#### 특정 열 조회

#행은 다 가져오고, 컬럼 3번째에서 6번째까지 가져오기 iloc_df.iloc[:,3:6]

### [컬럼].isin('가져오고 싶은 값') 
* 내가 정한 list안에 있는 값들만 가져오고 싶을 때 사용

#원하는 값을 지정해주기 name = ['리스트 지정'] #컬럼 내에 지정된 리스트 값만 가져오기 #true와 false로 나타남 df['컬럼명'].isin(name)

dataframe 형태로 나타남

df.loc[df['컬럼'].isin(name)]

### 행 row, 열 column 추가/삭제
* 행 추가 : df.append(dict 또는 Series/DataFrame)
*    ignore_index = True 반드시 추가 
* 열 추가 : df['추가할 열 이름']='추가할 열 정보(list 또는 Series)
* 행/열 삭제
*    행 삭제 : df.drop(index=['삭제하려는 행 인덱스'])
*    열 삭제 : df.drop(columns=['삭제하려는 열 이름'])

#### Series 이용하여 행 추가 

type(df.iloc[1])

pandas.core.series.Series

#두번째 값을 뽑아서 추가 df.append(df.iloc[1]) ```

join 4가지 방식 'Inner Join' : 교집합 'Left Join' : 왼쪽 전체 'Right Join' : 오른쪽 전체 'Outer Join' : 합집합

df.join(df1, on='키 인덱스', how='조인 방법', #추가사항 sort='정렬여부'

set_index('지정할 열')

df.set_index('columns 중에 하나 쓰기')

merge

같은 컬럼만 있으면 사용 가능함.

pd.merge(df1, df2, on='컬럼', how='조인방법', sort='정렬')

#왼쪽df #오른쪽df1
pd.merge(df, df1, on='컬럼', how='left')
pd.merge(df, df1, on='컬럼', how='right')
pd.merge(df, df1, on='컬럼', how='inner')
pd.merge(df, df1, on='컬럼', how='outer')

Concat

• _concat_은 행이나 열 방향으로 데이터 프레임 붙일 수 있음

• 행 방향 :axis = 0 #위아래로 붙임
• 열 방향 :axis = 1 #왼쪽에서 오른쪽으로

pd.concat([df1, df2], axis='행 또는 열')

pd.concat([df1, df2], axis='행 또는 열', **join = 'inner'**) #겹치는 값만 뽑을 것임.

• pd.pivot_table(df, index='행 인덱스', columns = '열 인덱스' , values = '조회하고 싶은 값', aggfunc='집계 방식')

aggfunc : 'mean' 'sum' 'count'

groupby 사용하기 [그룹통계]

df.groupby('그룹').count()
df.groupby('그룹').mean()
df.groupby('그룹').var() #분산
df.groupby('그룹').std() #표준편차
df.groupby('그룹').min()
df.groupby('그룹').max()
df.groupby('그룹').sum()

df.groupby('그룹명')['추출하고자 하는 컬럼명']
**#그룹은 index로 위치**

#여러 개 그룹을 지정하고 싶다면 
#index가 늘어남
df.groupby(['그룹명','그룹명2'])

인덱스 분할 reset_index()

df.groupby(['그룹명','그룹명2']).reset_index() 
#두 개로 나뉘어있던 인덱스가 다시 '컬럼'으로 돌아감

get_group()

#DataFrame의 index가 나타남
df.groupby('그룹명').groups

df.groupby('그룹명').get_group('묶고자 하는 값')

agg()

df.groupby('그룹명').agg({'컬럼명1':'sum','컬럼명2':'mean'})

index로 '그룹명' 생기고 컬럼1에 대한 합계, 컬럼2에 대한 평균으로 컬럼 생성됨