[Python] 데이터 전처리
1. 중복 데이터 처리
- 하나의 데이터 셋에서 동일한 관측 값이 2개 이상 중복되는 경우 분석 결과를 왜곡할 수 있음
1) duplicated()
- 데이터의 중복 여부를 bool의 Series로 리턴
2) drop_duplicates()
- 매개변수를 대입하지 않으면 모든 컬럼의 값이 일치하는 경우 제거
- subset 옵션: [‘컬럼 이름’]이나 [[‘컬럼’, ‘이름’, ‘list’]]를 대입하면 중복을 제거하고 첫번째 데이터만 유지
- keep 옵션: 위의 경우에서 마지막 데이터를 유지
- inplace 옵션 : 원본에 직접 작업
pandas와 DataFrame은 원본을 복제해서 수정하고 리턴
실시간으로 대량 발생하는 데이터는 데이터베이스에 바로 저장 못함
데이터 -> csv 파일에 기록 (유효성 검사를 할 수 없어서 잘못된 데이터가 저장되는 경우 발생) -> 데이터베이스에 반영
3) 중복 데이터 제거 실습
df = pd.DataFrame([['안녕하세요', '반갑습니다', '헬로우', '키아 오라', '반갑습니다'],
['한국', '한국', '미국', '뉴질랜드', '한국']])
#행 열 전치
df = df.T
df.columns = ['인사말', '국가']
print(df)| 인사말 국가 0 안녕하세요 한국 1 반갑습니다 한국 2 헬로우 미국 3 키아 오라 뉴질랜드 4 안녕하세요 한국 |
# 모든 컬럼에서 중복된 경우를 확인
print(df.duplicated())| 0 False 1 False 2 False 3 False 4 True dtype: bool |
# 하나의 컬럼에서 중복된 경우를 확인
print(df.duplicated(subset=['국가'])) #국가 컬럼의 값이 중복된 경우 확인| 0 False 1 True 2 False 3 False 4 True dtype: bool |
# 중복 데이터 제거
print(df.drop_duplicates(subset=['국가']))| 인사말 국가 0 안녕하세요 한국 2 헬로우 미국 3 키아 오라 뉴질랜드 |
- 기본적으로는 앞의 데이터를 보존하고 뒤의 중복값을 제거한다.
- 마지막 데이터를 보존하려면 keep 옵션 사용
print(df.drop_duplicates(subset=['국가'], keep='last')) # 마지막 데이터 보존| 인사말 국가 2 헬로우 미국 3 키아 오라 뉴질랜드 4 반갑습니다 한국 |
2. 함수 적용
1) apply
- Series나 DataFrame에 사용할 수 있는 함수
- Series: 각 요소에 적용해서 결과를 Series로 리턴
- DataFrame: 기본적으로 열 단위로 대입하고 DataFrame으로 리턴. axis=1을 설정하면 행 단위로 적용
import seaborn as sns
titanic = sns.load_dataset('titanic')
titanic.info()| <class 'pandas.core.frame.DataFrame'> RangeIndex: 891 entries, 0 to 890 Data columns (total 15 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 survived 891 non-null int64 1 pclass 891 non-null int64 2 sex 891 non-null object 3 age 714 non-null float64 4 sibsp 891 non-null int64 5 parch 891 non-null int64 6 fare 891 non-null float64 7 embarked 889 non-null object 8 class 891 non-null category 9 who 891 non-null object 10 adult_male 891 non-null bool 11 deck 203 non-null category 12 embark_town 889 non-null object 13 alive 891 non-null object 14 alone 891 non-null bool dtypes: bool(2), category(2), float64(2), int64(4), object(5) memory usage: 80.7+ KB |
df = titanic[['sex', 'age']]
print(df.head())| sex age 0 male 22.0 1 female 38.0 2 female 26.0 3 female 35.0 4 male 35.0 |
# 사용자 함수
# 실수 1개를 받아서 1을 더해서 리턴하는 함수
def plusone(data:float) -> float:
return data + 1
# 함수를 만들어서 적용
df['age'] = df['age'].apply(plusone)
print(df.head())| sex age 0 male 23.0 1 female 39.0 2 female 27.0 3 female 36.0 4 male 36.0 |
# 람다 함수
# 람다 함수를 이용해서 위와 동일한 작업 수행
df['age'] = df['age'].apply(lambda data : data+1)
# 브로드캐스트
df['age'] = df['age'] + 1
# 열의 모든 내용 대문자로 변경
# 문자열 클래스에 대문자로 변경해주는 메소드가 있는지 확인
df['sex'] = df['sex'].apply(str.upper)
print(df.head())| sex age 0 MALE 25.0 1 FEMALE 41.0 2 FEMALE 29.0 3 FEMALE 38.0 4 MALE 38.0 |
# 주의 에러
df = df.apply(str.upper)
print(df.head())TypeError: descriptor 'upper' for 'str' objects doesn't apply to a 'Series' object
- 데이터 프레임에 apply를 사용하면 함수에 열이 대입
- 하나의 열에 str.upper를 적용한 것이므로 에러 발생
- 데이터 프레임에 apply를 적용할 때는 Series를 매개변수로 받아서 처리하는 함수 필요
#Series를 받아서 각 데이터가 null인지 확인
def missing_value(series: pd.Series) -> pd.Series:
return series.isnull()
result = df.apply(missing_value)
print(result.head())| sex age 0 False False 1 False False 2 False False 3 False False 4 False False |
*SQL에서 where name = null을 하면 데이터가 없다고 나온다. insull을 사용해야 한다.
* null을 연산하면 null이 된다. null and False면 null이다.
그래서 항상 if(!=null)을 넣어줬음.
* 프로그래밍 언어에서는 Φ 이런게 null
* 데이터분석은 코드를 끊어서 봐야 한다.
2) pipe
- DataFrame 객체를 함수에 매핑할 때 사용
- 하나의 값으로 작업하는 함수를 대입하면 동일한 구조의 데이터를 리턴
- 모든 요소에 함수를 적용해서 그 결과를 가지고 데이터를 다시 생성해서 리턴
- 집계 함수를 대입하면 열 단위로 함수를 적용해서 Series 리턴
- Series를 리턴하는 함수를 호출해서 집계하면 하나의 값을 리턴
#Series를 받아서 Nan 여부를 리턴하는 함수
def missing_value(x:pd.Series) -> pd.Series:
return x.isnull()
#Series를 받아서 True의 개수를 리턴하는 함수
def missing_count(x:pd.Series) -> int:
return missing_value(x).sum()
#DataFrame을 받아서 총 Nan의 개수를 리턴하는 함수
def total_number_missing(x:pd.DataFrame) -> int:
return missing_count(x).sum()- dataframe을 직접 넣기보다는 series로 작업을 많이 함!
타이타닉
df = titanic[['age', 'embarked']]
print(df.info())| <class 'pandas.core.frame.DataFrame'> RangeIndex: 891 entries, 0 to 890 Data columns (total 2 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 age 714 non-null float64 1 embarked 889 non-null object dtypes: float64(1), object(1) memory usage: 14.1+ KB None |
print(df.pipe(missing_value))| age embarked 0 False False 1 False False 2 False False 3 False False 4 False False .. ... ... 886 False False 887 False False 888 True False 889 False False 890 False False [891 rows x 2 columns] |
print(df.pipe(missing_count))| age 177 embarked 2 dtype: int64 |
- Series를 받아서 1개의 데이터(정수)를 리턴하는 함수 적용
- Series를 리턴 - 각 열의 결과
print(df.pipe(total_number_missing))- DataFrame을 받아서 집계한 후 하나의 값을 리턴함수를 적용
- 하나의 값을 리턴
| 179 |
3. 컬럼 재구성
1) 열 순서 변경 sorted()
- DataFrame[재구성할 열 이름의 list]
columns = list(titanic.columns.values) #원래는 ndarray
print(columns)| ['survived', 'pclass', 'sex', 'age', 'sibsp', 'parch', 'fare', 'embarked', 'class', 'who', 'adult_male', 'deck', 'embark_town', 'alive', 'alone'] |
# 열 정렬
titanic_sorted = titanic[sorted(columns)]
titanic_sorted
2) 날짜 컬럼 분할 split()
df = pd.read_excel('./data/주가데이터.xlsx')
print(df.info())
print(df.head())| <class 'pandas.core.frame.DataFrame'> RangeIndex: 20 entries, 0 to 19 Data columns (total 7 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 연월일 20 non-null datetime64[ns] 1 당일종가 20 non-null int64 2 전일종가 20 non-null int64 3 시가 20 non-null int64 4 고가 20 non-null int64 5 저가 20 non-null int64 6 거래량 20 non-null int64 dtypes: datetime64[ns](1), int64(6) memory usage: 1.2 KB 연월일 당일종가 전일종가 시가 고가 저가 거래량 0 2018-07-02 10100 600 10850 10900 10000 137977 1 2018-06-29 10700 300 10550 10900 9990 170253 2 2018-06-28 10400 500 10900 10950 10150 155769 3 2018-06-27 10900 100 10800 11050 10500 133548 4 2018-06-26 10800 350 10900 11000 10700 63039 |
# - 기준으로 분할 str.split()
#날짜 컬럼 문자열로 변환
df['연월일'] = df['연월일'].astype('str')
dates = df['연월일'].str.split("-")| 0 [2018, 07, 02] 1 [2018, 06, 29] 2 [2018, 06, 28] 3 [2018, 06, 27] 4 [2018, 06, 26] |
df['연'] = dates.str.get(0)
df['월'] = dates.str.get(1)
df['일'] = dates.str.get(2)| 연월일 당일종가 전일종가 시가 고가 저가 거래량 연 월 일 0 2018-07-02 10100 600 10850 10900 10000 137977 2018 07 02 1 2018-06-29 10700 300 10550 10900 9990 170253 2018 06 29 2 2018-06-28 10400 500 10900 10950 10150 155769 2018 06 28 3 2018-06-27 10900 100 10800 11050 10500 133548 2018 06 27 4 2018-06-26 10800 350 10900 11000 10700 63039 2018 06 26 |
4. 필터링
- 조건에 맞는 데이터만 추출
titanic = sns.load_dataset('titanic')
# age가 10 ~ 19인 데이터만 추출
ages = titanic[(titanic['age'] >= 10) & (titanic['age'] <20)]
ages['age'].unique()| array([14. , 15. , 19. , 18. , 11. , 17. , 16. , 14.5, 12. , 10. , 13. ]) |
# age가 10세 미만이고 sex가 female인 데이터 중에서 age,sex,alone 컬럼만 추출 loc[ [ ] ]
condition = (titanic['age']<10) & (titanic['sex']== 'female')
result = titanic.loc[condition, ['age','sex','alone']]| age sex alone 10 4.0 female False 24 8.0 female False 43 3.0 female False 58 5.0 female False 119 2.0 female False |
# sibsp가 3, 4, 5인 데이터 추출 isin()
#sibsp가 3, 4, 5인 데이터 추출
조건 = (titanic['sibsp'].isin([3, 4, 5]))
결과 = titanic.loc[조건, :]
print(결과['sibsp'].unique())| [3 4 5] |
5. 데이터 결합
- 데이터가 분할된 경우 합치는 기능
- join처럼 키를 가지고 옆으로 결합하거나, 동일한 컬럼이면 세로로 결합
1) concat
- 구성 형태와 속성이 동일하면 행 또는 열 방향으로 이어붙임
- Series끼리는 옆으로 합쳐 DataFrame 생성
- DataFrame끼리는 상하로 합쳐서 하나의 DataFrame으로 생성
- 한쪽에만 존재하는 컬럼도 합쳐짐, 값은 Nan
- axis=1을 설정하면 옆으로 결합
- 이 경우에는 join 옵션 사용
- 기본은 outer, inner 설정 가능
df1 = pd.DataFrame({'a': ['a0', 'a1', 'a2', 'a3'],
'b': ['b0', 'b1', 'b2', 'b3'],
'c': ['c0', 'c1', 'c2', 'c3']},
index=[0, 1, 2, 3])
df2 = pd.DataFrame({'a': ['a2', 'a3', 'a4', 'a5'],
'b': ['b2', 'b3', 'b4', 'b5'],
'c': ['c2', 'c3', 'c4', 'c5'],
'd': ['d2', 'd3', 'd4', 'd5']},
index=[2, 3, 4, 5])
#세로 결합
print(pd.concat([df1, df2]))| a b c d 0 a0 b0 c0 NaN 1 a1 b1 c1 NaN 2 a2 b2 c2 NaN 3 a3 b3 c3 NaN 2 a2 b2 c2 d2 3 a3 b3 c3 d3 4 a4 b4 c4 d4 5 a5 b5 c5 d5 |
- concat 옵션이 없는 경우: Set 연산처럼 세로 방향으로 결합
- 컬럼의 이름이 다른 경우는 NaN 값으로 컬럼을 생성해서 결합
#가로 결합
print(pd.concat([df1, df2], axis=1))| a b c a b d 0 a0 b0 c0 NaN NaN NaN 1 a1 b2 c2 NaN NaN NaN 2 a2 b2 c2 a4 b4 b4 3 a3 b3 c3 a5 b5 b5 4 NaN NaN NaN a6 a6 a6 5 NaN NaN NaN a7 a7 a7 |
- 기본적으로 index를 기준으로 결합
- Outer Join처럼 수행
# inner join
print(pd.concat([df1, df2], axis=1, join='inner'))| a b c a b d 2 a2 b2 c2 a4 b4 b4 3 a3 b3 c3 a5 b5 b5 |
2) append
python에서 append가 _append(프라이빗)으로 변경됐음
- 인덱스와 상관없이 컬럼 이름만으로 상하 결합
- 최신 버전에서 API 변경
3) combine_first
- 두 데이터 셋의 인덱스가 겹치는 경우 데이터 정렬 기능까지 제공
print(df1.combine_first(df2))| a b c d 0 a0 b0 c0 NaN 1 a1 b2 c2 NaN 2 a2 b2 c2 b4 3 a3 b3 c3 b5 4 a6 a6 NaN a6 5 a7 a7 NaN a7 |
4) merge
- 2개의 데이터프레임을 합치는 메소드
- 데이터프레임만 설정하면 동일한 이름의 컬럼을 가지고 JOIN 수행
- key 옵션: 컬럼 설정 가능
- left_on 과 right_on 옵션: 컬럼의 이름이 다른 경우, 직접 컬럼 이름 설정
- how 옵션: inner, left, right, outer 설정으로 outer join 수행
- suffixes 옵션: 튜플로 2개의 문자열을 설정하면 동일한 이름이 있는 경우 _이름 추가
- 생략하면 _x, _y
- sort 옵션: 기본적으로 key를 기준으로 정렬 수행. 정렬 하지 않으려면 sort = False
5) join
- merge와 유사
- 기본적으로 행 인덱스를 키 사용
- 키 설정이 가능하고 how 옵션 존재
- merge는 pandas 함수, join은 DataFrame의 메소드
price = pd.read_excel('./data/stock price.xlsx')
valuation = pd.read_excel('./data/stock valuation.xlsx') |
 |
#기본 조인
- 아무런 옵션이 없으면 동일한 컬럼으로 Join
- 기본적으로 Inner Join 수행
print(pd.merge(price, valuation)) |
print(pd.merge(price, valuation, how='outer', on='id')) |
# join하는 컬럼의 이름이 다를 때
print(pd.merge(price, valuation, how='right', left_on='stock_name', right_on='name')) |
#기본적으로 index로 조인
price.index=price['id']
valuation.index = valuation['id']
#동일한 컬럼 이름 제거
price.drop(['id'], axis=1, inplace=True)
valuation.drop(['id'], axis=1, inplace=True)
print(price.join(valuation))
6. 그룹연산
1) 그룹화
- 어떤 기준에 따라 그룹별로 나누어서 관찰
- groupby 함수 이용, 컬럼 이름이나 컬럼 이름의 list를 대입해서 그룹화
- 그룹화 후 get_group(그룹이름)을 이용하면 그룹화된 개별 그룹의 데이터를 가져오는 것이 가능
- 그룹화한 데이터는 iteration(for 사용)이 가능
- 2개의 데이터를 튜플로 리턴
- (그룹의 이름, 그룹의 데이터)
# titanic 데이터를 class 별로 그룹화
df = titanic[['age', 'sex', 'class', 'fare', 'survived']]grouped = df.groupby(['class'])
for key, group in grouped:
print(key, group) |
# 그룹 count
#count
for key, group in grouped:
print(key, len(group))| ('First',) 216 ('Second',) 184 ('Third',) 491 |
# 특정 그룹의 데이터 선택
group3 = grouped.get_group('Third') |
# 2개 열로 그룹화
grouped = df.groupby(['class', 'sex'])
for key, group in grouped:
print(key)| ('First', 'female') ('First', 'male') ('Second', 'female') ('Second', 'male') ('Third', 'female') ('Third', 'male') |
- key 가 2개 항목의 튜프로 생성
group3m = grouped.get_group(('Third', 'male')) |
2) 집계
- count(null 제외), size(null 포함), mean, std, min, max,
quantile(q=0.25|0.5|0.75), sum, var, sem, describe, first, last, nth
#표준편차
df = titanic[['class', 'age']]
grouped = df.groupby(['class'])
std_all = grouped.std()
print(std_all) |
- 사용자 정의 함수 적용: agg 함수 호출해서 넘겨주기
#데이터 모임을 가지고 하나의 값을 리턴하는 함수
def min_max(x):
return x.max() - x.min()
#사용자정의 함수 집계
result = grouped.agg(min_max)
result |
- 사용자 정의 함수 적용해서 데이터 변환 : transform 함수 호출
- map: 하나의 데이터를 받아서 하나의 데이터를 리턴하는 함수 생성해서 데이터 묶음에 적용하면
하나 하나의 데이터를 함수에 대입해서 호출한 후 결과를 묶어서 데이터의 묶음을 리턴하는 함수
Z-score: (값-평균) / 표준편차
def z_score(x):
return (x-x.mean()) / x.std()
age_zscore = grouped.transform(z_score)
age_zscore |
- 음수는 평균보다 아래
- 양수는 평균보다 위
3) 멀티 인덱스
- 인덱스가 1 Level이 아닌 여러 Level로 구성되는 것
- 그룹화를 할 때 하나의 컬럼이 아니라 여러 컬럼으로 하는 경우 멀티 인덱스 생성
df = titanic[['class', 'sex', 'age']]
grouped = df.groupby(['class', 'sex'])
for key in grouped:
print(key) ... |
gdf = grouped.mean()
gdf |
# 특정 class 출력
gdf.loc['First'] |
# 특정 sex 출력
gdf.xs('male', level='sex') |
# 특정 행 출력
gdf.loc[('First', 'female')]| age 85 Name: (First, female), dtype: int64 |
4) pivot table
- 데이터를 그룹화하기 위한 함수
- 멀티 인덱스는 한 방향에 인덱스가 여러 개 적용
- 피벗 테이블은 양 방향에 인덱스를 적용
df = titanic[['class', 'sex', 'age']]
result = pd.pivot_table(df, index='class', columns='sex', values='age',
aggfunc='sum')
result |
7. 데이터 구조화
- stacked와 unstacked
- stacked: 가로 방향으로 넓게 펼쳐진 데이터를 세로 방향으로 길게 만드는 작업 - 컬럼을 인덱스로 활용
- unstacked: 세로 방향으로 길게 펼쳐진 데이터를 가로 방향으로 넓게 만드는 작업 - 인덱스를 다시 컬럼으로 활용
- stacked 작업을 할 때는 NaN 데이터를 어떻게 처리할 것인지 결정
1) stack()
- stacked 작업을 수행해주는 함수
mul_index = pd.MultiIndex.from_tuples([('cust_1', '2015'), ('cust_1', '2016'),
('cust_2', '2015'), ('cust_2', '2015')])
data = pd.DataFrame(data=np.arange(16).reshape(4,4), index=mul_index,
columns=['prd_1', 'prd_2', 'prd_3', 'prd_4'], dtype='int')
print(data) |
stacked = data.stack()| cust_1 2015 prd_1 0 prd_2 1 prd_3 2 prd_4 3 2016 prd_1 4 prd_2 5 prd_3 6 prd_4 7 cust_2 2015 prd_1 8 prd_2 9 prd_3 10 prd_4 11 2016 prd_1 12 prd_2 13 prd_3 14 prd_4 15 dtype: int32 |
2) unstack
- unstacked 작업을 수행해주는 함수
- 멀티인덱스인 경우 어떤
#첫 레벨의 인덱스가 컬럼이 됩니다. cust_1 > 2015,6 > prd
unstacked1 = stacked.unstack(level=0)
unstacked2 = stacked.unstack(level=1)
print(unstacked1)
print(unstacked2)
#다단으로 구성된 인덱스의 경우는 여러 번 unstack 가능
print(unstacked2.unstack())| cust_1 cust_2 2015 prd_1 0 8 prd_2 1 9 prd_3 2 10 prd_4 3 11 2016 prd_1 4 12 prd_2 5 13 prd_3 6 14 prd_4 7 15 2015 2016 cust_1 prd_1 0 4 prd_2 1 5 prd_3 2 6 prd_4 3 7 cust_2 prd_1 8 12 prd_2 9 13 prd_3 10 14 prd_4 11 15 2015 2016 prd_1 prd_2 prd_3 prd_4 prd_1 prd_2 prd_3 prd_4 cust_1 0 1 2 3 4 5 6 7 cust_2 8 9 10 11 12 13 14 15 |
8. 숫자 데이터 전처리
1) 단위 환산
- 하나의 데이터 셋에서 서로 다른 측정 단위를 사용하게 되면 전체 데이터의 일관성 측면에서 문제가 발생할 수 있기 때문에 측정 단위를 동일하게 맞춰야 함
- mpg 데이터는 자동차에 대한 연비인데, 미국에서는 갤런당 마일을 사용하고 우리나라에서는 L당 km 사용
- 이럴 때 단위환산이 편리하다.
- 1마일은 1.60934 km, 1갤런은 3.7841 L
mpg = pd.read_csv('./data/auto-mpg.csv', header=None)
mpg.columns = ['mpg', 'cylinders', 'displacement', 'horsepower', 'weight', 'acceleration', 'model year', 'origin', 'name']#갤런 당 마일을 리터 당 킬로미터로 변환하는 상수
mpg_to_kpi = 1.60934 / 3.7841
mpg['kpi'] = mpg['mpg'] * mpg_to_kpi |
2) 자료형 변환
- 컬럼의 자료형은 dtypes 속성이나 info()를 이용해서 가능
- 엑셀 파일이나 csv를 읽다보면 숫자 데이터를 문자열로 읽어오는 경우가 있음
- 엑셀 파일에서 천 단위 구분 기호가 있는 경우: thousand 옵션에 (,)를 설정해서 읽어오면 해결
- 숫자로 인식할 수 없는 데이터가 포함된 경우
- 숫자로 인식할 수 없는 데이터를 숫자로 변환하거나 제거한 후 숫자로 변경
mpg.dtypes| mpg float64 cylinders int64 displacement float64 horsepower object weight float64 acceleration float64 model year int64 origin int64 name object dtype: object |
# 숫자로 변환
mpg['horsepower'] = mpg['horsepower'].astype('float')
mpg.dtypesValueError: could not convert string to float: '?'
# 인식할 수 없는 데이터 확인
mpg['horsepower'].unique()
# Null로 치환하여 제거하고 숫자로 변환
#?를 NaN으로 치환
mpg['horsepower'].replace('?', np.nan, inplace=True)
#NaN 제거
mpg.dropna(subset=['horsepower'], inplace=True)
#실수 자료형으로 변경
mpg['horsepower'] = mpg['horsepower'].astype('float')
mpg.dtypes| ... horsepower float64 ... |
- 자료형을 범주형으로 변경하고자 하면 category로 자료형 설정
- origin은 국가를 의미하는 범주형 인데 숫자 자료형, Category나 String으로 변경해주는게 좋다.
- origin의 데이터를 1 -> USA, 2-> EU, 3-> JAPAN으로 치환
- replace에 dict를 대입하면 key를 찾아서 value로 치환
mpg['origin']| 0 1 1 1 2 1 3 1 4 1 |
mpg['origin'].replace({1:'USA', 2:'EU', 3:'JAPAN'}, inplace=True)
mpg['origin'].unique()
mpg['origin'].head()| array(['USA', 'JAPAN', 'EU'], dtype=object) 0 USA 1 USA 2 USA 3 USA 4 USA Name: origin, dtype: object |
- model year 컬럼의 값을 범주형(category)로 치환
- category: 특정 값만을 가져야 하는 자료형
- 문자열이나 숫자 자료형은 원핫 인코딩이 안되는 경우가 발생할 수 있음
- 원핫 인코딩: 범주형의 데이터를 숫자형으로 만들 때 각각의 값을 컬럼으로 만드는 건데 문자열이나 숫자형은 안될 수 있음
mpg['model year'] = mpg['model year'].astype('category')
mpg.info()| 6 model year 392 non-null category |
# 서울시 구별 CCTV와 인구 관계 분석
[전처리] 서울시 구별 CCTV와 인구 관계 분석
1. 서울시 자치구별 CCTV 현황 데이터 가져오기 - http://data.seoul.go.kr/ 열린데이터광장 메인 데이터분류,데이터검색,데이터활용 data.seoul.go.kr - CCTV 검색 - xlsx 파일을 다운로드(파일 이름을 cctv로 수
yachae4910.tistory.com
# 지도 출력
[전처리] 지도 출력 Choropleth
https://github.com/southkorea/southkorea-maps 한국 지리정보 사이트 1. 데이터 읽어오기 state_unemployment = 'data/US_Unemployment_Oct2012.csv' state_data = pd.read_csv(state_unemployment) print(state_data.head()) State Unemployment 0 AL 7.1
yachae4910.tistory.com
# 서울시 범죄 현황 시각화
[전처리] 서울시 범죄 현황 시각화
- https://data.seoul.go.kr/ - 서울시 5대 점죄 발생현황 통계 데이터 - crime.txt 1. 데이터 가져오기 import pandas as pd import folium import json criminal = pd.read_csv('./data/crime.txt', sep='\t', thousands=',', encoding='utf-8') 2.
yachae4910.tistory.com
# Cartogram
 |
 |
[전처리] 인구 소멸 지역 Cartogram
- 국가 통계 포털에서 인구 정보 내려받기 http://kosis.kr/statHtml/statHtml.do?orgId=101&tblId=DT_1IN1509& KOSIS kosis.kr 기본코드 import pandas as pd import numpy as np import platform import matplotlib.pyplot as plt %matplotlib inline p
yachae4910.tistory.com