반응형
SMALL

1. 외부데이터 수입해서 다루기(복습)


2. Group by : groupby(by=[묶는기준], as_index=False )

한개열 또는 여러열을 기준으로 집계하는 함수.

집계하고자하는 열 이름을 by 파라미터에 입력하고 호출하면 된다.

 as_index=False : 인덱스 손질. 설정하지 않으면 판다스(Pandas) 복합 인덱스로 올라가서 변환하거나 사용하기 어렵다.

 

1) 한개 열을 기준으로 집계하기

df = pd.DataFrame({
    '상품번호':['상품1','상품2','상품3','상품4'],
    '수량' : [2,3,5,10]
})
df

기본적으로 groupby만 해도 이미 집계는 되어있는 상태이다.

단, generator 상태이기 때문에 추가적으로 산술통계를 써서 원하는 값을 도출하는 방식으로 쓰인다.

#상품번호별로 묶기, 인덱스 손질하는 코드 추가
df.groupby(by=['상품번호'],as_index=False)

다양한 산술통계를 써서 결과를 보자.

# min: 상품번호별 판매된 총수량
df.groupby(by=['상품번호'],as_index=False).sum()
# min: 상품번호별 판매된 최소 수량
df.groupby(by=['상품번호'],as_index=False).min()
# min: 상품번호별 판매된 최대 수량
df.groupby(by=['상품번호'],as_index=False).max()
# mean: 상품번호별 판매된 평균 수량
df.groupby(by=['상품번호'],as_index=False).mean()
#count : 상품번호별 판매 수
df.groupby(by=['상품번호'],as_index=False).count()

 

2) 여러 열을 기준으로 집계하기

import pandas as pd
df = pd.DataFrame({'고객번호' : ['고객1', '고객2', '고객3', '고객4'],
                    '상품번호':['상품1','상품2','상품3','상품4'],
                    '수량' : [2,3,5,10]})

[연습문제] 연도를 그룹으로 해서 지역명이 경기만 그룹화해서 총 갯수를 그룹별로 출력하기

오라클 식으로 풀면 select count(*), 연도 from apt where 지역명=='경기' group by 연도

#지역명이 경기인 것만 연도별로 그룹화해서 슬라이스한다.
aptGroupby = aptData.loc[aptData.지역명=='경기'].groupby(['연도'],as_index=False)
#그거 총 갯수 세서 다시 aptGroupby에 넣줌
aptGroupby=aptGroupby.count()
aptGroupby
#거기서 연도와 지역명만 가져오기
aptGroupby[['연도','지역명']]

plt.bar(aptGroupby.index,aptGroupby['지역명'],color='#55c8ff',width=0.5,
       label='경기지역') #bar(x,y)
plt.legend()
plt.title('시각화 결과')
plt.xlabel('지역명')
plt.ylabel('총 갯수')
plt.grid
plt.show()


3. 데이터를 JSON으로 바꿔서 저장하기 : to_json

궁극적으로 데이터프레임에서 만든 json을 디장고로 보내서 사용하거나 spring MVC를 사용하는 것이 목표다.

파이썬은 기본적으로 읽어들이거나 내보내는 형식이 자바에 비해 훨씬 간단하다. 읽어들이는 경우 import os 를 이용해서 w(write), r(read) 등 간단한 약어를 사용할 수 있다. 내보내기 역시 마찬가지다. 

force_ascii=False : 유니코드 방지

외부에서 저장된 파일을 읽어왔을 때 결과가 잘 나온다.

[참고] 파일명을 쓰지 않으면 저장은 되지 않고 출력만 된다.

json으로 저장할 때 여러가지 옵션을 설정할 수 있다. 각 설정별로 결과값을 비교해보자.

- records : 컬럼에 따른 데이터만 출력(가로로 한줄씩 컬럼명을 key값으로 출력)

# records : 데이터만 출력(가로로 한줄씩 컬럼명을 key값으로 출력)
aa.to_json(orient='records', force_ascii=False)
# json 데이터
[{"sno":"A001","student":"홍길동","kor":85,"eng":90,"math":85},
{"sno":"B001","student":"이순자","kor":95,"eng":95,"math":75},
{"sno":"A002","student":"왕서방","kor":85,"eng":95,"math":75},
{"sno":"B002","student":"영심이","kor":80,"eng":80,"math":100},
{"sno":"A003","student":"호철이","kor":90,"eng":65,"math":70},
{"sno":"B003","student":"가진이","kor":75,"eng":100,"math":80}]

records

- split : column 데이터, index 데이터, value 데이터를 나눠서 출력. key값에서 특정 칼럼이 필요할 때 사용한다.

# split : 특정 칼럼 설정
aa.to_json(orient='split',force_ascii=False)
# json 데이터
{"columns":["sno","student","kor","eng","math"],
"index":[0,1,2,3,4,5],
"data":[["A001","홍길동",85,90,85],
        ["B001","이순자",95,95,75],
        ["A002","왕서방",85,95,75],
        ["B002","영심이",80,80,100],
        ["A003","호철이",90,65,70],
        ["B003","가진이",75,100,80]]}

split 

- table: 스키마(데이터베이스의 전체적인 논리적 구조 / PK값, pandas 버전 등)를 추가한 데이터. 이 DateFrame과 관련된 모든 정보를 포함한다.

# table : DF 정보 포함
aa.to_json(orient='table',force_ascii=False)
# json 데이터
{"schema": {"fields":[{"name":"index","type":"integer"},
                       {"name":"sno","type":"string"},
                       {"name":"student","type":"string"},
                       {"name":"kor","type":"integer"},
                       {"name":"eng","type":"integer"},
                       {"name":"math","type":"integer"}],
			"primaryKey":["index"],
			"pandas_version":"0.20.0"
            }, 
"data": [{"index":0,"sno":"A001","student":"홍길동","kor":85,"eng":90,"math":85},
         {"index":1,"sno":"B001","student":"이순자","kor":95,"eng":95,"math":75},
         {"index":2,"sno":"A002","student":"왕서방","kor":85,"eng":95,"math":75},
         {"index":3,"sno":"B002","student":"영심이","kor":80,"eng":80,"math":100},
         {"index":4,"sno":"A003","student":"호철이","kor":90,"eng":65,"math":70},
         {"index":5,"sno":"B003","student":"가진이","kor":75,"eng":100,"math":80}]
}

table

그냥 처음부터 정보를 제한해서 저장하는 방법도 있다.

- index : 대표 key 값을 인덱스로 준다.(column은 data의 키값이다.)

#인덱스
aa.to_json(orient='index',force_ascii=False)
# json 데이터
{
"0":{"sno":"A001","student":"홍길동","kor":85,"eng":90,"math":85},
"1":{"sno":"B001","student":"이순자","kor":95,"eng":95,"math":75},
"2":{"sno":"A002","student":"왕서방","kor":85,"eng":95,"math":75},
"3":{"sno":"B002","student":"영심이","kor":80,"eng":80,"math":100},
"4":{"sno":"A003","student":"호철이","kor":90,"eng":65,"math":70},
"5":{"sno":"B003","student":"가진이","kor":75,"eng":100,"math":80}
}

 

- columns: 대표 key 값을 컬럼으로 준다.(index는 data의 키값이다.)

#컬럼
aa.to_json(orient='columns',force_ascii=False)
# json 데이터
{
"sno":{"0":"A001","1":"B001","2":"A002","3":"B002","4":"A003","5":"B003"},
"student":{"0":"홍길동","1":"이순자","2":"왕서방","3":"영심이","4":"호철이","5":"가진이"},
"kor":{"0":85,"1":95,"2":85,"3":80,"4":90,"5":75},
"eng":{"0":90,"1":95,"2":95,"3":80,"4":65,"5":100},
"math":{"0":85,"1":75,"2":75,"3":100,"4":70,"5":80}
}

 

- values : 값만 묶어서 보내주자.

#값만 보내주기(키값은 나중에 설정하자.)
aa.to_json(orient='values',force_ascii=False)
# json 데이터
[["A001","홍길동",85,90,85],["B001","이순자",95,95,75],["A002","왕서방",85,95,75],
["B002","영심이",80,80,100],["A003","호철이",90,65,70],["B003","가진이",75,100,80]]

4. Django에서 데이터프레임을 json 데이터로 변환 후 차트 그리기

1. 우선 html 파일을 간단하게 만들자.

버튼을 누르면 json 데이터를 이용한 c3js 차트가 나오도록 하자.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div style="width:450px;margin:auto">
    <div><input type="button" value="click" id="jsonLoad"></div>
    <div id="target"></div>
    <!-- chart를 출력하기 위한 UI -->
    <div id="chart1"></div>
</div>

<!-- C3JS 라이브러리 불러오기 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
<script src="https://d3js.org/d3.v3.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/c3/0.4.11/c3.min.js"></script>

</body>
</html>

버튼을 클릭하면 jsonLoad로 이동한다.

 

2. views.py 에서 jsonLoad를 정의해주자.

# 제이슨 파일로 바꿀 데이터프레임
def make_dfall():
    df_all = pd.DataFrame({'sno': ['A001', 'B001', 'A002', 'B002', 'A003', 'B003'],
                           'student': ['홍길동', '이순자', '왕서방', '영심이', '호철이', '가진이'],
                           'kor': [85, 95, 85, 80, 90, 75],
                           'eng': [90, 95, 95, 80, 65, 100],
                           'math': [85, 75, 75, 100, 70, 80]
                           })
    return df_all

#위에서 정의한 make_dfall를 split으로 해서 데이터를 보낸다.
def loadJson(request):
    df = make_dfall()[['student', 'kor', 'eng', 'math']]
    print(df)
    df.to_json('test.json', orient='split', force_ascii=False)
    f = open('/home/kosmo_03/PycharmProjects/myapps/test.json')
    aa = json.load(f)
    print(aa)
    return JsonResponse(aa, json_dumps_params={'ensure_ascii': False}, safe=False)
#데이터 로드 후 JsonResponse로 로드한 aa를 응답해주자.

 

3. urls.py 에 링크 등록한다.

    # -------------------------------------------------
    path('chart3', views.chart3),
    path('loadJson', views.loadJson),

 

4. chart3.html에 script를 추가한다.

버튼을 누르면 차트가 나온다. 차트를 누르는 버튼의 id를 jsonLoad으로 했으므로, 그 기능을 심어주자.

$('#jsonLoad').click(function(){ : html에서 정의한 idjsonLoad인 값을 클릭하면 함수 실행. 

 

ajax를 자세히 보면,

url:'loadJson' :  url.py에 정의한 요청이 들어오면 정의한 뷰를 실행한다.

function(data) : 실행에 성공하면, data(=view에서 응답한 aa) 를 이용해서 차트를 만드는 makeBarChart 함수를 실행한다. 단, data(=aa)의 data 컬럼과, columns컬럼을 키값으로 가진 value 값을 가져온다.

index는 가져오지 않는 것.

<script>

$(function(){
    $('#jsonLoad').click(function(){
    //아이디가 jsonLoad인 값을 클릭하면 함수 실행.
        $.ajax({
                url:'loadJson', 
                //url.py에 정의한 요청이 들어오면 정의한 뷰가 실행 .있는것 중 loadJson 가져와
                success:function(data){ //여기 데이터는 view에서 response한 aa
               		makeBarChart(data.data,data.columns);  //makeBarChart function 실행해(아래에 있는거)
                				//제이슨 데이터 안에 있는 data와 columns를 가져온다.
                } //end success
         });//end ajax
     }); //click end
     
}); //end $(function(){

</script>
</body>
</html>

 

5. 데이터 차트에 맞게 수정

일단 데이터는 가지고 왔다. 하지만 우리가 필요한 데이터를 정제할 필요가 있다.

우리는 이것들만 필요하다.

function makeBarChart(jsonData, dcol){
    var datas = [];
    // [n개의 컬럼들]
    var dcolumns = dcol.slice(1, dcol.length);
    //첫번째 컬럼 슬라이스

    for(var key in jsonData){ //jsonData : 실제 이름, 점수 데이터
        datas.push(jsonData[key]); //2. 배열에 저장한다.
    }

차트를 만드는 makeBarChart 함수를 정의하자. dcol과 jsonData가 컬럼과 data인가?

우선 jsonDatadcol 이라는 변수를 쓸건데, 각각 차트에 필요한 이름, 점수값을 가진 배열과 컬럼명이다.

컬럼명은 원래 제일 왼쪽에 있는 애가 컬럼명이 되었다. 이걸 잘라주자.

var dcolumns = dcol.slice(1,dcol.length);

컬럼을 슬라이스해주자.

 

for문을 이용해서 남은 파란색 jsonDatadatas에 넣어준다.

c3를 생성한다.

1) data를 설정할 때, 컬럼이 위에서 파란색으로 넣은 데이터다. 맨 왼쪽에 있는 것(이름)이 인덱스가 된다.

2) axis 축을 설정하는데 x축을 남은 노란색 컬럼으로 지정한다.

axis에서 설정한 x축

function makeBarChart(jsonData, dcol){
    var datas = [];
    // [n개의 컬럼들]
    var dcolumns = dcol.slice(1, dcol.length);
    //첫번째 컬럼 슬라이스

    for(var key in jsonData){ //jsonData : 실제 이름, 점수 데이터
        datas.push(jsonData[key]); //2. 배열에 저장한다.
    }
 
    //c3js.com bar 샘플 코드를 복사
    var chart = c3.generate({
   		bindto : '#chart1',
    	data: {columns: datas, type: 'bar'},// jsonData를 바인딩한다.
   		bar: {width: {ratio: 0.5} },
    	axis: { x: {type: 'category',categories: dcolumns} }
            	// X축에 읽어온 컬럼의 category 를 지정한다.
    });//end var chart
}// end function makeBarChart
}); //end $(function(){

</script>

 

실행 후 버튼을 누르면, 

그래프가 출력된다.

 

▼ 전체 코드

더보기

views.py

urls.py

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div style="width:450px;margin:auto">
    <div><input type="button" value="click" id="jsonLoad"></div>
    <div id="target"></div>
    <!-- chart를 출력하기 위한 UI -->
    <div id="chart1"></div>
</div>
<!-- C3JS 라이브러리 불러오기 -->
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
<script src="https://d3js.org/d3.v3.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/c3/0.4.11/c3.min.js"></script>
<script>

$(function(){
    $('#jsonLoad').click(function(){
    //아이디가 jsonLoad인 값을 클릭하면 함수 실행.
        $.ajax({
                url:'loadJson', //url.py에 정의한 요청이 들어오면 정의한 뷰가 실행 .있는것 중 loadJson 가져와
                success:function(data){ //여기 데이터는 view에서 response한 aa
               		makeBarChart(data.data,data.columns);  //makeBarChart function 실행해(아래에 있는거)
                				//제이슨 데이터 안에 있는 data와 columns를 가져온다.
                } //end success
         });//end ajax
     }); //click end


function makeBarChart(jsonData, dcol){
    var datas = [];
    // [n개의 컬럼들]
    var dcolumns = dcol.slice(1, dcol.length);
    //첫번째 컬럼 슬라이스

    for(var key in jsonData){ //jsonData : 실제 이름, 점수 데이터
        datas.push(jsonData[key]); //2. 배열에 저장한다.
    }
 
    //c3js.com bar 샘플 코드를 복사
    var chart = c3.generate({
   		bindto : '#chart1',
    	data: {columns: datas, type: 'bar'},// jsonData를 바인딩한다.
   		bar: {width: {ratio: 0.5} },
    	axis: { x: {type: 'category',categories: dcolumns} }
            	// X축에 읽어온 컬럼의 category 를 지정한다.
    });//end var chart
}// end function makeBarChart
}); //end $(function(){

</script>
</body>
</html>

views.py

def chart3(request):
    return render(request, "survey/chart3.html")


def loadJson(request):
    df = make_dfall()[['student', 'kor', 'eng', 'math']]
    print(df)
    df.to_json('test.json', orient='split', force_ascii=False)
    f = open('/home/kosmo_03/PycharmProjects/myapps/test.json')
    aa = json.load(f)
    print(aa)
    return JsonResponse(aa, json_dumps_params={'ensure_ascii': False}, safe=False)


def make_dfall():
    df_all = pd.DataFrame({'sno': ['A001', 'B001', 'A002', 'B002', 'A003', 'B003'],
                           'student': ['홍길동', '이순자', '왕서방', '영심이', '호철이', '가진이'],
                           'kor': [85, 95, 85, 80, 90, 75],
                           'eng': [90, 95, 95, 80, 65, 100],
                           'math': [85, 75, 75, 100, 70, 80]
                           })
    return df_all

urls.py

  # -------------------------------------------------
    path('chart3', views.chart3),
    path('loadJson', views.loadJson),
]

 


반응형
LIST
반응형
SMALL

# 결측치

# 결측값이 있는지 여부 확인 : isnull()

# 결측값 없는 것들 확인 : notnull()

# 세로줄(열)별 결측값 갯수 : df.isnull().sum() 
# 가로줄(행)별 결측값 갯수 : df.isnull().sum(1) 

 


# 결측치 시각화하기 : 
missingno

▼missingno 설치 방법

더보기

!pip list |grep missingno
!pip list |grep missingno #설치 확인

#결측치를 시각화하는 방법 : missingno
import missingno as msno
msno.matrix(df_all,figsize=(18,6))


# 병합 : pd.merge()

- 그냥 merge를 쓰면 키값이 겹치는 애들만 병합이 된다.

-> 속성값으로 join의 종류(how)와 기준열(on)을 정할 수 있음.

df_all=pd.merge(df_left,df_right,how ='outer',on='KEY')


# 수치형 데이터 정보 출력(#산술통계)

# 데이터 요약정보 : describe() 

- count : 갯수
=> 오라클에서는 count(sapay), count(*)
      count(sapay) : null이 존재한다면 계산되지 않는 것 / count(*) : null이 있어도 계산됨
- mean : 평균
- std : 표준편차
- min : 최소값, 0
- max : 최댓값,100
- 4분위값 : 보통 머신러닝에서 이상치값 정리할 때 4분위를 나눠서 위아래를 잘라낸다.(박스플롯에서 사용)
   ->0사분위(최소값(min)), 1사분위(25%), 2사분위(50%, 중앙값(median)), 3사분위(75%), 4사분위(최댓값(max))

# 산술통계 연습하기

#numpy로 배열 생성
a= np.array([7,9,16,36,39,45,45,46,48,51])

#길이(갯수)
len(a) #10
#평균
np.mean(a)
#최대 #34.2
np.max(a)
#중위값
np.median(a) #42.0
#2사분위(50%)
np.percentile(a,50) #42.0
#1사분위(25%)
np.percentile(a,25) #21.0
#표준편차
np.std(a) #16.054905792311583

#describe 할 때는 데이터 프레임으로 바꿔서 써야한다.
mydata = pd.DataFrame(a)
mydata.describe()

+추가

#정규분포 생성하기 : np.random.randn()

- 랜덤한 정규분포 난수를 발생해서 DateFrame을 생성한다. 괄호 안(너비,높이) 크기만큼의 정규분포행렬이 생성된다.

정규분포를 담은 6x4 데이터 프레임 생성

#유일한 값별로 갯수 세기 : value_counts()

 

# 백분위수 구하기 : percentile()

(numpy 함수) np.percentile(데이터, 백분위수, 파라미터 옵션)

- 백분위수(Percentile)는 오름차순 정렬했을 때 0을 최소값, 100을 최대값으로 백분율로 나타낸 특정 위치 값

- 사분위수는 25, 50, 75를 기준 점으로 나눠져 1분위부터 4분위까지 존재하게 된다. 백분위수 q 값은 0부터 100 값을 사용한다.

치수의 값들 중 1사분위에 해당하는 값인 0.1이 출력

[interpolation 파라미터 옵션]

정렬된 데이터 i와 j가 있을 때,
- linear : i + (j - i) * fraction (기본값)
- lower : i
- higher : j
- nearest : i or j whichever is nearest
- midpoint : (i + j) / 2

각 결과 비교

# NaN 데이터 처리(# null값 처리)

왜 필요해?

보통 머신러닝에서 연속형일 경우에는 0에 대한 데이터가 많아지면 문제가 생기기 때문에 null 값 또는 0에 대해 따로 전처리를 한다.

# NaN 값을 다른것으로 대체 : fillna()

a['컬럼명']=a['컬럼명'].fillna(바꿀값) -> 초기화시켜주는 것.

# NaN값 추가 : np.NaN

# NaN값이 있으면 전체 삭제 : dropna()

#행 기준 : dropna(axis=0) / 열 기준 :  dropna(axis=1)

 

# 데이터 삭제 : drop()

# index 삭제(가로줄 전체 삭제) #column 삭제(세로줄 전체 삭제)

df.drop(df.index[0:3],axis=0)

: 인덱스순서번호로 0번부터 3번까지 행방향(가로줄)로 삭제

0이면 열방향(세로), 1이면 행방향(가로)axis=0 / 그냥 숫자만 적는 것도 가능

# 인덱스번호로 삭제

df.drop([df.columns[0]],1)

: 인덱스순서번호로 0번 열방향(세로줄)로 삭제(그냥 숫자만 적음)


# 데이터 앞, 뒤, 중간 뜯어보기

 

#데이터 상단만 보기 : head()

#데이터 하단만 보기 : tail()   #데이터 끝

#데이터 중간만 보기 : loc 사용

++추가

# 일부 데이터 값 변경하기

- loc[범위] ->콜론 : [시작순서번호 : 끝순서번호] / 콤마 : [행범위,열범위]

이렇게도 가능하다.


 #날짜 인덱스 지정하기 : date_range

pd.date_range(start = '날짜',end='날짜', freq = '시간단위')

-> 시작점만 지정해준 뒤 periods로 범위를 지정해줄 수도 있다.


# bar 차트 그리기 #막대그래프

# Matplotlib이란?

 파이썬에서 데이타를 차트나 플롯(Plot)으로 그려주는 라이브러리로 가장 많이 사용되는 데이타 시각화(Data Visualization) 패키지. 라인 플롯, 바 차트, 파이차트, 히스토그램, Box Plot, Scatter Plot 등을 비롯하여 다양한 차트와 플롯 스타일을 지원한다.

- 수입

import matplotlib as mpl
import matplotlib.pyplot as plt
#또는
%matplotlib inline

 

"%matplotlib inline" 를 넣게 되면, Shift + Enter를 치지 않고 Run 버튼을 눌러 실행하여 그래프를 얻을 수 있다.
이러한 % 명령은 Cell Magic 명령어라고 불리우는 것으로 이는 파이썬 코드가 아니라 Jupyter에게 특정 기능을 수행하도록 하는 명령이다. %matplotlib inline 명령은 Jupyter에게 matplotlib 그래프를 출력 영역에 표시할 것을 지시하는 명령이다.(출처)

- 차트 그리기

plt.plot(["Seoul","Paris","Seattle"], [30,25,55]) #차트 내용
plt.show() #차트출력

#또는
데이터이름.plot(kind='bar')

차트의 모양과 출력만 있으면 된다. 나머지는 옵션.

- 차트 옵션

다양한 옵션이 있다.

plt.bar(aa['student'],aa['kor'],color='#ffcc00',width=0.3,align='edge',label='kor')

-> plt.bar() 자체로 차트를 그릴 수 있다.

차례대로 x축데이터, y축데이터, 차트색깔, 폭, 차트위치,라벨이름 이다.

이 차트의 경우 가로로 되어있어서 height가 아닌 폭(width)로 두었다. 라벨 이름은 기본값으로 center로 설정되어있고, align='edge' 왼쪽 모서리를 의미한다.

plt.bar(aa['student'],aa['kor'],color='#ffcc00',width=0.3,align='edge',label='kor')
plt.grid(True) #격자무늬
plt.legend(loc=1) #legend 는 범례/ loc는 범례의 위치(숫자별로 다름)
plt.title('국어점수') #제목
plt.xlabel('학생이름') #x라벨
plt.ylabel('점수') #y라벨
plt.show()

 

 

이런식으로 옵션을 추가할 수 있다.


#지도데이터 시각화 : folium  #위도 경도로 지도 그리기

eaflet.js 기반으로 지도를 그려주고, 모바일에서도 쓸 수 있을만큼 가벼운 시각화 패키지.

지도 표시 : folium.Map(location=[위도,경도],zoom_start=줌범위)

!pip install folium #설치
import folium #수입

#위도와 경도를 찍어서 지도 표시하기
m = folium.Map(location =[35.873626,128.545482],zoom_start=15) #zoom_start = 10 :기본값
m.save('data1.html') #html로 저장
m

Marker 추가 : folium.Marker([위도,경도],tooltip='툴팁이름'popup='팝업이름').add_to(m)

반응형
LIST
반응형
SMALL

Pandas 

온전히 통계 분석을 위해 고안된 R 과는 다르게 python은 일반적인 프로그래밍 언어(general purpose programming language) 이며, 데이터 분석을 하기 위해서는 여러가지 라이브러리를 사용할 수 밖에 없다. 이 패키지들 중 R의 dataframe 데이터 타입을 참고하여 만든 것이 바로 pandas dataframe이다. pandas는 dataframe을 주로 다루기 위한 라이브러리이며, dataframe을 자유롭게 가공하는 것은 데이터 과학자들에게 중요하다.(출처) 

모양은 엑셀 시트를 하나의 데이터 타입으로 만들어 놓은 듯 하다. 행과 열로 이루어져 있어, 테이블의 형식으로 볼 수 있다. 

DataFrame 

Series들의 집합. 
여러개의 Series(행)이 모여 하나의 테이블형식의 데이터를 생성할 수 있다. 
행과 열이 있는 table 형태를 가진다. 


Series 

DataFrame의 한 컬럼 데이터세트. 
Series 역시 DataFrame의 인덱스와 동일한 인덱스를 가진다.  
Series는 테이블 형식의 데이터로 봤을때 하나의 레코드 즉, 행 값으로 생각하면 된다. 

=> 즉, Series는 컬럼이 하나인 데이터 구조체이고, DataFrame은 컬럼이 여러개인 데이터 구조체이다.


자료구조

리스트 튜플 딕셔너리
a=[1,2,3] a= (1,2,3) a={'kim' : 25, 'park' : 22, 'lee' : 34}
a={ "a" : [5,6,7], "b" : [8,9,10]} 

 

1. 튜플(tuple)

  • 리스트와 비교가 많이되며, 리스트와의 가장 큰 차이점은 요소를 삭제하거나 변경할 수 없다는 것. 이를 immutable(불변성) 이라고 표현함, iterable 함(반복 가능한 객체)
  • 리스트는 append, remove 메소드로 요소들을 추가하거나 삭제할 수 있지만 튜플은 이러한 메소드가 없음
  • 튜플 + 튜플 형식으로 요소를 추가할 수는 있으며, 삭제도 indexing을 통해서 삭제하고자 하는 요소의 index를 선택하지 않으면 가능하다. But, 이와 같은 방식은 억지로(?) append나 remove가 된 것 처럼 한 것이라 할 수 있음
  • 리시트에서는 예를 들어 a라는 리스트가 있을 때, a 자체를 변화를 줄 수 있지만, 튜플은 a라는 튜플 b라는 튜플이 있을때 c = a + b 형식으로 새로운 변수에 할당하는 방식으로 append와 결과적으로만 동일한 튜플을 만들 수 있는 것이다.
  • 또한, 다른 type의 데이터들을 담을 수 있음 ('a', 1, 3) 이런 식으로.

 

2. 리스트(list)

  • 튜플과 비교가 많이되며, 튜플과의 가장 큰 차이점은 요소를 삭제하거나 변경할 수 있다는 것. 이를 mutable(가변성)이라고 표현함, iterable 함(반복 가능한 객체)
  • 리스트는 append, remove 메소드로 요소들을 추가하거나 삭제할 수 있음
  • 튜플과 마찬가지로 리스트 + 리스트 형식으로 요소를 추가할 수 있음
  • 또한, 다른 type의 데이터들을 담을 수 있음 ['a', 1, 3] 이런 식으로.

 

3. 딕셔너리(dict)

  • 딕셔너리를 구현한 클래스는 셋(set)
  • 따라서, 딕셔너리는 셋처럼 중복이 불가능한 collection 자료형이고, mutable(가변성) 하며, key : value 라는 독특하고 유용한 구조로 이루어짐(중복이 불가능하다는 뜻은 key값들 끼리 중복이 불가능 하다는 뜻)
  • a라는 딕셔너리가 있을때 keys나 values 메소드를 활용하여 key나 value값 확인가능. key와 value를 모두 확인하고 싶을 때는 items 메소드를 사용
  • (참고) B = {'a' : [1]}라는 딕셔너리는 value가 list 형태이므로 B['a'].append or B['a'].remove 가 가능

 

4. 셋(set)

  • 셋은 순서가 없는 중복이 불가능한 collection 자료형이다. -> 내장모듈 collections 알아두면 좋음. mutable(가변성) 
  • 요소들 간의 순서가 없음 -> 따라서, indexing이 불가 -> not iterable
  • 중복제거 교집합, 합집합, 차집합 등의 수학적인 계산이 가능
  • 셋은 add(요소 1개 추가), update(여러요소 추가), remove 메소드를 활용하여 요소를 추가/삭제한다.
  • 합집합은 a | b로 표현, 차집합은 a - b로 표현, 교집합은 a & b로 표현

Series

# 자료구조 -> Series 생성 : pd.Series(자료구조)

# list -> Series로 바꾸기

a = pd.Series([22,23,44,55,28])

# dict -> Series로 바꾸기

a = pd.Series({'kim' : 25, 'park' : 22, 'lee' : 34})

# tuple -> Series로 바꾸기

a = pd.Series((10,20,30))


# 배열(Array)과 리스트(List) 차이

Array List
여러 데이터를 하나의 이름으로 그룹핑해서 관리 하기 위한 자료구조 여러 데이터들을 순서대로 빈틈없이 적재하기 위한 자료구조(=시퀀스)
인덱스가 변경되지 않는다(정해져있는 키값) 인덱스는 몇 번째 데이터인지만 나타냄(순서번호)
추가적인 삽입, 삭제가 일어나지 않으므로 검색에 유리 추가적인 삽이브 삭제가 일어남
데이터의 크기가 정해져 있음 데이터의 크기가 정해져 있지 않음

-> 파이썬에서는 list가 배열이다. 배열을 따로 제공하지 않음. 따라서 배열을 따로 사용하려면 numpy로 불러와야 한다.

array : 그룹핑(쉼표없음) list : 시퀀스(쉼표있음)


# 앨리먼트(요소) 출력 : .index / .values

#Series 인덱스(index) 출력(=key)

a.index / a.keys() / a.keys

-> rangeIndex : 기본 인덱스 범위가 안정해졌을때 알아서 지정해준 그 인덱스의 범위를 표시해준다.

#Series 값(value) 출력 : values / a[인덱스번호]

-> array로 출력 / -1의 경우 거꾸로

#Series 자료형(type) 출력 : type()


# Series 인덱스(index) 생성 : pd.Series( 자료구조 데이터 ,index=['가','나','다'])

-> 딕셔너리일 경우, 키값이 시리즈의 인덱스로 설정되어 있기 때문에 시리즈를 생성할 때 새로운 인덱스를 부여하면 그 인덱스에 새로운 키로 생성 ->NaN


# 앨리먼트(요소) 변경

# 인덱스로 값(value) 변경

a['다']=100

# 인덱스(index) 변경

a.index = ['A','B','C']


DataFrame

# 자료구조 -> DataFrame 생성 : pd.DataFrame(자료구조)

자동으로 table 형태로 만들어진다.


# 앨리먼트(요소) 출력

#타입 출력 : df.dtypes

#정보 출력 : df.info()

-> df.info는 모든 테이블 값들이 다 출력된다.

#컬럼별로 값 출력

print(df.컬럼명)

-> 컬럼명을 리스트로 묶어서도 가능 : df[idx_list]


# 컬럼과 인덱스 설정

df = pd.DataFrame(cc, index=[1,2,3], columns=[a,b,c])

# index와 column 

  • index(행) :가로로 한줄한줄 의미
  • column(열):세로로 한줄한줄 의미
  • 각각의 이름을 붙여준다면 index=[세로를 대표] column=[가로를 대표]

# index와 column 값 변경

#새로운 column 추가

-> 딕셔너리를 데이터프레임의 값으로 처리할 때 키값이 다를 경우, 또는 새로운 칼럼을 추가할  경우 그 값은 NaN 으로 처리된다.

# df.컬럼명 = 0.7 처럼 통일해서 채워넣거나, 데이터로 연산 가능.

# 컬럼명으로 값 변경 또는 추가


# 다양한 DataFrame 메소드

# 범위 안 정수 출력 (5부터 14까지) : arrage

# 배열/테이블 모양을 만들기 : reshape

-> reshape()는 다차원으로 변형이 가능

#  Series 출력

키-값 쌍을 한 꺼번에 뽑아 내는 함수. generator 형식으로 뽑힌다. : items()

->generator : 리스트의 단점을 극복해서 리스트와 같은 자연현상을 조금 최소화 할 수 있다. 

 

# 중복데이터 처리 (실제로는 사라지지 않음. 보여지기만 하는것.) : df.drop_duplicates() 

-> df.drop_duplicates(inplace=True) : 바로 중복데이터 처리 적용(또는 초기화 : df = df.drop~~)

 

# 데이터프레임 크기 ex)5x3 형태 등 : df.shape

# 차원출력 ex) 2차원, 3차원 등 : df.ndim 

#컬럼 삭제 : del

 del df['컬럼명'] 

# 데이터 슬라이스

- df.loc[시작순서번호 : 끝순서번호] / [행범위,열범위] : 레이블 기반 인덱싱

- df.iloc[시작순서번호 : 끝순서번호] / [행범위,열범위] : 위치 정수 기반으로 인덱싱


# 비교연산자

-> 행(가로)을 가져온다.

# loc + 비교연산자

loc[시작순서번호 : 끝순서번호] / [행범위,열범위] : 열범위가 전체인 것.

# and / or 연산자 + 비교연산자


[ 나눔고딕 폰트 설치 ]

나눔 폰트 설치
글꼴 캐시 갱신

base에 설치 후 주피터 노트북에 추가 설치 해야한다.

#폰트 확인(주피터에서 확인해야 가져올 수 있음)
!ls -l /usr/share/fonts/truetype/nanum | grep NanumGothic*
#캐시 삭제
!rm. -rf ~/.cashe/matplotlib/*
#가져온 폰트 설치 
!fc-cache -fv
#설치 되어있는지 보기 위해 matplotlib 폰트 매니저로 폰트 있는지 확인
import matplotlib
import matplotlib.font_manager
#나눔 이름 붙은 폰트 있니?
[f.name for f in matplotlib.font_manager.fontManager.ttflist if 'Nanum' in f.name]

폰트를  설치한 후 한글이 깨지지 않는지 확인해준다.

#한글설정 #유니코드깨짐 #폰트설정

import matplotlib as mpl
import matplotlib.pyplot as plt
#유니코드 깨지는 현상 방지
mpl.rcParams['axes.unicode_minus'] = False
#폰트 설정
plt.rcParams['font.family'] = 'NanumGothic'

#테스트
plt.figure()
plt.grid(True)
plt.plot((1,1))
plt.title("한글테스트")
plt.show()

안깨지고 잘 출력된다.

 

반응형
LIST
반응형
SMALL

+ Recent posts

반응형
LIST