Study-Note

[Algorithm/JAVA] Comparator, Comparable

칸타탓 — Sun, 31 Jan 2021 16:50:04 +0900

Comparable 인터페이스 (java.lang)

객체 간의 일반적인 정렬이 필요할 때, Comparable 인터페이스를 확장한다.

정렬할 객체에 Comparable 인터페이스를 implements 한 후, CompareTo() 메서드를 오버라이드 하여 정렬

CompareTo()

- 현재 객체 < 파라미터로 넘어온 객체 : 음수 리턴

- 현재 객체 = 파라미터로 넘어온 객체 : 0 리턴

- 현재 객체 > 파라미터로 넘어온 객체 : 양수 리턴

Comparator 인터페이스 (java.util)

객체 간의 특정한 정렬이 필요할 때, Comparator 인터페이스를 확장해서 특정 기준을 정의하는 compare() 메서드를 구현한다.

기본적인 정렬 기준과 다르게 정렬하고 싶을 때 사용

Comparator 인터페이스를 implements 한 후, compare() 메서드를 오버라이드한 클래스를 작성한다.

compare()

- 첫 번째 파라미터로 넘어온 객체 < 두 번째 파라미터로 넘어온 객체 : 음수 리턴 (유지)
- 첫 번째 파라미터로 넘어온 객체 = 두 번째 파라미터로 넘어온 객체 : 0 리턴 (유지)

- 첫 번째 파라미터로 넘어온 객체 > 두 번째 파라미터로 넘어온 객체 : 양수 리턴 (두 객체 자리 변경)

역으로 정렬하기 예제(내림차순)

Arrays.sort(time, new Comparator<int[]>() {
	@Override
	public int compare(int[] o1, int[] o2) {
		// 0: 시작 시간, 1: 종료 시간
		// 끝시간이 같을 경우 시작 시간 정렬
		if(o1[1] == o2[1]) {
			return Integer.compare(o1[0], o2[0]);
		}
		// 종료 시간 정렬
		return Integer.compare(o1[1], o2[1]);
	}
});

객체 정렬 예제 (나이를 기준으로 객체 정렬)

public static void main(String[] args) {
    Student s1 = new Student("name1", 27); 
    Student s2 = new Student("name2", 31); 
    Student s3 = new Student("name3", 30);
    
    Student[] arr = new Student[]{s1, s2, s3};
    
    Arrays.sort(arr, new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
            return o1.getAge() - o2.getAge();
        }
    });
    
    for(Student s : arr) {
        System.out.println(s.getName() + " " + s.getAge());
    }
}

[BOJ] 2667번: 단지번호붙이기 (Java)

칸타탓 — Tue, 24 Nov 2020 22:08:30 +0900

[Java] 2667 - 단지번호붙이기

[문제]

<그림 1>과 같이 정사각형 모양의 지도가 있다. 1은 집이 있는 곳을, 0은 집이 없는 곳을 나타낸다. 철수는 이 지도를 가지고 연결된 집들의 모임인 단지를 정의하고, 단지에 번호를 붙이려 한다. 여기서 연결되었다는 것은 어떤 집이 좌우, 혹은 아래위로 다른 집이 있는 경우를 말한다. 대각선상에 집이 있는 경우는 연결된 것이 아니다. <그림 2>는 <그림 1>을 단지별로 번호를 붙인 것이다. 지도를 입력하여 단지수를 출력하고, 각 단지에 속하는 집의 수를 오름차순으로 정렬하여 출력하는 프로그램을 작성하시오.

[풀이]

대표적인 DFS, BFS로 풀 수 있는 문제이다. DFS가 더 익숙해서 DFS로 풀었다.

주어진 2차원 배열을 DFS로 탐색하면서 1일 경우 단지수가 존재함(count)을 체크하면 된다.

0	1	1	0	1	0	0
0	1	1	0	1	0	1
1	1	1	0	1	0	1
0	0	0	0	1	1	1
0	1	0	0	0	0	0
0	1	1	1	1	1	0
0	1	1	1	0	0	0

좌표 [0, 0] 부터 상, 하, 좌, 우 순서로 탐색을 시작한다.

좌표 [0, 0]은 0이므로 건너뛰고, 1인 [0, 1]에서 시작한다. (방문했으므로 visit 배열에 true 표시)

배열의 범위를 벗어나면 안되므로 배열이 0보다 크고, N보다 작을 경우 그리고 아직 방문하지 않았을 경우에만 DFS를 돌린다.

[0, 1] -> [1, 1] -> [2, 1] -> [2, 0] -> [2, 2] -> [1, 2] -> [0, 2] 순서로 재귀적으로 호출하며 깊게 타고 들어가면서 탐색을 진행한다.

count = 1이 끝났으면 count를 1 증가시켜서 [0, 4]부터 반복적으로 DFS를 다시 진행한다.

탐색이 끝나고 난 뒤에는 아래와 같이 단지수가 기록된다.

0	1	1	0	2	0	0
0	1	1	0	2	0	2
1	1	1	0	2	0	2
0	0	0	0	2	2	2
0	1	0	0	0	0	0
0	1	1	1	1	1	0
0	1	1	1	0	0	0

이와 같이 반복해준 후, 최종적인 단지의 갯수와 오름차순으로 정렬한 단지 내의 집의 수를 출력해주면 되는 문제이다.

[코드]

package algorithm.Baekjoon;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class BOJ_2667 {
    static int map[][];
    static boolean visit[][]; // 방문 여부
    static int N; // 지도 최대 크기
    static int count = 1; // 총 단지 수
    static int x[] = {-1, 1, 0, 0}; // row
    static int y[] = {0, 0, -1, 1}; // col

    public static void dfs(int i, int j) {
        map[i][j] = count; // 방문한 집 표시
        visit[i][j] = true;

        // 상하좌우로 이동하며 탐색
        for(int k=0; k<x.length; k++) {
            int ix = i + x[k];
            int jy = j + y[k];

            // 배열의 범위를 벗어나지 않는 범위 내에서 탐색
            if(ix >= 0 && ix < N && jy >= 0 && jy < N) {
                if(map[ix][jy] == 1 && !visit[ix][jy]) { // 집이 있으면서 방문하지 않은 곳
                    dfs(ix, jy); // 연결 되어있는 단지 탐색
                }
            }
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());

        map = new int[N][N];
        for(int i=0; i<N; i++) {
            String[] input = br.readLine().split("");
            for(int j=0; j<N; j++) {
                map[i][j] = Integer.parseInt(input[j]);
            }
        }
        /*
        for(int i=0; i<N; i++) {
            String input = scan.next();
            for(int j=0; j<N; j++) {
                map[i][j] = input.charAt(j)-'0';
            }
        }
        */

        visit = new boolean[N][N];
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                if(map[i][j] == 1 && !visit[i][j]) { // 집이 있으면서 방문하지 않은 곳
                    dfs(i, j); // 연결 되어있는 단지 탐색
                    count++; // 다음 단지 수로 이동
                }
            }
        }

        // 총 단지 수
        System.out.println(count-1);
        // 단지 내 집의 수
        int result[] = new int[count];
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                if(map[i][j] != 0)
                    result[map[i][j]]++;
            }
        }
        // 단지수를 오름차순으로 정렬하여 출력
        Arrays.sort(result);
        for(int i=1; i<result.length; i++) {
            System.out.println(result[i]);
        }
    }
}

[Algorithm] 그래프(Graph)

칸타탓 — Sun, 15 Nov 2020 01:38:38 +0900

그래프 (Graph)

* 그래프 자료구조란

노드와 노드를 연결하는 간선으로 구성된 자료구조이다.
그래프의 순회는 DFS 혹은 BFS로 이루어진다.
노드 사이에 양방향 경로를 가질 수 있으므로, 2개 이상의 경로가 가능하다.
루트 노드, 부모-자식 관계가 존재하지 않는다.
아래와 같이 방향이 존재할 수도 있고, 존재하지 않을 수도 있다.

* 관련 용어

정점(vertex, node): 위치의 개념
간선(edge): 위치 간의 관계, 노드를 연결하는 선 (link, branch)
인접 정점(adjacent vertex): 간선에 의해 직접 연결된 정점
경로(path): 어느 한 정점에서 다른 정점 까지의 경로
싸이클(cycle): 단순 경로의 시작 정점과 종료 정점이 동일한 경우
단순 경로(Simple Path): 경로 중에서 반복되는 정점이 없는 경우
정점의 차수(degree): 무방향 그래프에서 하나의 정점에 인접한 정점의 수
진입 차수(in-degree): 유방향 그래프에서 외부에서 오는 간선의 수
진출 차수(out-degree): 유방향 그래프에서 외부로 향하는 간선의 수

* 그래프의 종류

무방향 그래프(Undirected Graph)
- 간선에 방향성이 없는 그래프
- 간선을 통해 양방향으로 갈 수 있다.
- A <-> B 이므로 (A, B), (B, A)는 동일하다.
유방향 그래프(Directed Graph)
- 간선에 방향성을 가진 그래프
- 간선에 방향성이 존재하는 그래프이다.
- A -> B, B -> A가 각각 존재하므로 (A, B), (B, A)는 다르다.
비순환 그래프(Acyclic Graph)
- 사이클이 없는 그래프
연결 그래프
- 무방향 그래프에 있는 모든 정점 쌍에 대해 항상 경로가 존재하는 경우
- 트리는 사이클을 가지지 않는 연결 그래프이다.
비연결 그래프
- 무방향 그래프에서 특정 정점 쌍 사이에 경로가 존재하지 않는 경우
완전 그래프
- 그래프에 속해있는 모든 정점이 서로 연결되어 있는 그래프

* 그래프를 구현하는 방법

1. 인접 행렬 (adjacency matrix)

무방향

방향

인접 행렬은 그래프의 연결관계를 NxN의 boolean 행렬로 나타내는 방식으로 이차원 배열을 사용한다.
adj[i][j]와 같이 정점 i에서 정점 j로 가는 간선이 있다면 1, 없다면 0으로 표시한다.

2. 인접 리스트(adjacency list)

그래프를 표현하는 가장 일반적인 방법이다.
모든 정점을 인접 리스트에 저장하는데, 이에는 ArrayList나 LinkedList를 사용한다.
정점의 번호를 알고있다면 이 번호를 배열의 인덱스로 하여 각 정점의 리스트에 쉽게 접근할 수 있다.

[참고한 곳]

kingpodo.tistory.com/46

gmlwjd9405.github.io/2018/08/13/data-structure-graph.html

[Algorithm/Java] Iterator, ListIterator

칸타탓 — Sat, 14 Nov 2020 22:19:21 +0900

Java의 Iterator, ListIterator

* Iterator<E>

컬렉션 프레임워크에서 저장된 요소를 읽어오는 방법을 표준화하기 위해 사용한다.

Collection 인터페이스에서는 Iterator 인터페이스를 구현한 클래스의 인스턴스를 반환하는 iterator() 메소드를 정의하여 각 요소에 접근하도록 하고 있다.

Collection 인터페이스를 상속받는 List와 Set 인터페이스 또한 iterator() 메소드를 사용할 수 있습니다. (Map 제외)

- List 데이터를 반복하는 방법

1. for( int i =0; i<list.length; i++) { ... }

2. for( String str : list ) { ... }

3. Iterator<String> iter = list.iterator();

while(iter.hasNext()) { System.out.println(iter.next()); }

- Map 자료구조에서 사용하기

Set<String> keys = map.keySet(); // Map의 Key를 가져온다
Iterator<String> iter = keys.iterator(); // Set 자료구조를 통해 사용
while(iter.hasNext()) {
    String key = iter.next();
    System.out.printf(key, map.get(key));
}

- 관련 메서드

hasNext()	iteration이 다음 요소를 가지고 있는지 boolean 형태로 반환
next()	iteration의 다음 요소를 반환
remove()	해당 반복자로 반환되는 마지막 요소를 현재 컬렉션에서 제거

* ListIterator<E>

Iterator 인터페이스를 상속받아 여러 기능을 추가한 인터페이스이다.

Iterator 인터페이스는 컬렉션의 요소에 접근할 때 한 방향으로만 이동할 수 있다.

ListIterator 인터페이스는 컬렉션 요소의 대체, 추가, 인덱스 검색 등을 위한 작업에서 양방향으로 이동하는 것을 지원한다.

단, List 인터페이스를 구현한 List 컬렉션 클래스에서만 listIterator() 메소드를 통해 사용할 수 있다.

- 순방향 및 역방향 출력

LinkedList<Integer> lnkList = new LinkedList<Integer>();
lnkList.add(4);
lnkList.add(2);
lnkList.add(3);
lnkList.add(1);

ListIterator<Integer> iter = lnkList.listIterator();
while (iter.hasNext()) { // 순방향
    System.out.print(iter.next() + " ");
}

while (iter.hasPrevious()) { // 역방향
    System.out.print(iter.previous() + " ");
}

- 관련 메서드

void add(E e)	해당 리스트에 전달된 요소를 추가
boolean hasNext()	해당 리스트를 순방향으로 순회할 때 다음 요소를 가지고 있으면 true 반환, 더 이상 다음 요소를 가지고 있지 않으면 false 반환
boolean hasPrevious()	해당 리스트를 역방향으로 순회할 때 다음 요소를 가지고 있으면 true 반환, 더 이상 다음 요소를 가지고 있지 않으면 false 반환
E next()	리스트의 다음 요소를 반환하고, 커서의 위치를 순방향으로 이동
int nextIndex()	다음 next() 메소드를 호출하면 반환될 요소의 인덱스 반환
E previous()	리스트의 이전 요소를 반환하고, 커서의 위치를 역방향으로 이동
int previousIndex()	다음 previous() 메소드를 호출하면 반환될 요소의 인덱스 반환
void remove()	next()나 previous() 메소드에 의해 반환된 가장 마지막 요소를 리스트에서 제거
void set(E e)	next()나 previous() 메소드에 의해 반환된 가장 마지막 요소를 전달된 객체로 대체

[Algorithm/Java] LinkedList 자료구조

칸타탓 — Sat, 14 Nov 2020 21:42:04 +0900

LinkedList 자료구조

DFS(깊이 우선 탐색) 구현 시에 LinkedList를 사용한다.

각 노드가 데이터와 포인터를 가지고 한 줄로 연결되어 있는 방식의 자료구조이다.

객체를 추가하거나 삭제하면 앞, 뒤 링크만 변경되고 나머지 링크는 변경되지 않는다.

데이터 추가나 삭제 시 인덱스가 밀리거나 당겨지는 일이 없기에 ArrayList에 비해 추가, 삭제가 용이하다.

(1) 선언 방법

LinkedList list = new LinkedList();

LinkedList<Student> student = new LinkedList<Student>(); // 타입 지정

LinkedList<Student> members = new LinkedList<Student>(); // 타입 지정

(2) 값 추가하기

list.addFirst(1); // 가장 앞에 데이터 추가

list.addLast(2); // 가장 마지막에 데이터 추가

list.add(3); // 가장 마지막에 데이터 추가

list.add(1, 10); // index 1 뒤에 데이터 10 추가

(3) 값 삭제하기

list.removeFirst(); // 가장 앞의 데이터 제거

list.removeLast(); // 가장 마지막 데이터 제거

list.remove(1); // index 1 제거, 생략시 index 0 제거

list.clear(); // 모든 값 제거

(4) 크기 구하기

list.size();

(5) 값 검색하기

System.out.println(list.contains(1)); // list에 1이 있는지 Boolean 값 반환

System.out.println(list.indexOf(1)); // 1이 있다면 해당하는 index 반환, 없다면 -1 반환

[Algorithm] BFS, 너비 우선 탐색

칸타탓 — Sat, 14 Nov 2020 21:07:39 +0900

BFS, 너비 우선 탐색

* 너비 우선 탐색

임의의 루트 노드에서 시작해서 인접한 노드를 먼저 탐색하는 방법이다.

임의의 루트 노드로부터 가장 가까운 노드를 먼저 탐색하고, 멀리 있는 것을 가장 나중에 탐색한다.

어떤 노드를 탐색했는 지를 반드시 기록해야 하며, 일반적으로 큐를 사용해 선입선출을 원칙으로 탐색한다.

1) 깊이가 1인 노드, 2인 노드, 3인 노드... 를 반복하며 탐색하고, 방문한 노드는 큐에 기록한다.

2) 큐에 들어있는 노드를 하나씩 꺼내고 인접해 있는 노드를 차례로 방문한다.

3) 큐에 있는 노드가 없어질 때까지 반복한다.

* 적용 예시

두 노드 사이의 최단 경로를 알고싶을 때
임의의 경로를 찾고자 할 때

* 탐색 과정

- 연습 문제

www.acmicpc.net/problem/1260

programmers.co.kr/learn/courses/30/lessons/43162

[참고한 곳] gmlwjd9405.github.io/2018/08/14/algorithm-dfs.html

[CS] 파이썬으로 시작하는 데이터 사이언스 (5)

칸타탓 — Mon, 9 Nov 2020 22:23:46 +0900

10 minutes to pandas (판다스 실습)

참고 : pandas.pydata.org/pandas-docs/version/1.0.0/getting_started/10min.html

- numpy, pandas 사용하기

> import numpy as np

> import pandas as pd

numpy : 행렬이나 대규모 다차원 배열을 쉽게 처리 할 수 있도록 지원하는 파이썬 라이브러리

- Object 생성하기

(1) Series 만들기

s = pd.Series([1, 3, 5, np.nan, 6, 8])

0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

(2) DataFrame 만들기

dates = pd.date_range('20201110', periods=6)

# 6개의 날짜 정보가 들어간다
DatetimeIndex(['2020-11-10', '2020-11-11', '2020-11-12', '2020-11-13',
'2020-11-14', '2020-11-15'], dtype='datetime64[ns]', freq='D')

# 여러 타입의 데이터가 들아갈 수 있다.
df2 = pd.DataFrame({'A': 1.,
		'B': pd.Timestamp('20201110'),
		'C': pd.Series(1, index=list(range(4)), dtype='float32'),
		'D': np.array([3] * 4, dtype='int32'),
		'E': pd.Categorical(["test", "train", "test", "train"]),
		'F': 'foo'})

	A	B		C	D	E	F
0	1.0	2020-11-10	1.0	3	test	foo
1	1.0	2020-11-10	1.0	3	train	foo
2	1.0	2020-11-10	1.0	3	test	foo
3	1.0	2020-11-10	1.0	3	train	foo

# df2.dtypes을 통해 데이터 타입 조회 가능
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object

- Data 조회하기

# 지정하지 않으면 모든 데이터 출력
df2.head()
# 하위 3개의 데이터
df2.tail(3)

# index 조회하기
df2.index
# Int64Index([0, 1, 2, 3], dtype='int64') 출력

df2.columns
# Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')

to_numpy() : pandas 객체를 numpy 배열 객체인 ndarray로 반환한다.

df2.to_numpy()

array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']],
      dtype=object)
      
# 통계 요약
df2.describe()
	A	C	D
count	4.0	4.0	4.0
mean	1.0	1.0	3.0
std	0.0	0.0	0.0
min	1.0	1.0	3.0
25%	1.0	1.0	3.0
50%	1.0	1.0	3.0
75%	1.0	1.0	3.0
max	1.0	1.0	3.0

# .sort_index()는 인덱스(index)를 기준으로, .sort_values()는 컬럼의 값을 기준으로 데이터 정렬

df2.sort_index(axis=1, ascending=False)
	F	E	D	C	B		A
0	foo	test	3	1.0	2020-11-10	1.0
1	foo	train	3	1.0	2020-11-10	1.0
2	foo	test	3	1.0	2020-11-10	1.0
3	foo	train	3	1.0	2020-11-10	1.0

# B 값을 기준으로 데이터 정렬
df2.sort_values(by='B')

# 여러 개의 컬럼 값을 기준으로 값을 정렬하고 싶을 때
df2.sort_values(by=['B', 'E'] ,ascending=False)

- 데이터 다루기(인덱싱)

[] : 레이블이나 위치 정수를 기반으로 인덱싱한다.
[ : ] : 슬라이싱을 활용하여 인덱싱한다.
[boolean value] : 불린 벡터를 이용하여 인덱싱한다.
loc[lable] : 레이블을 기반으로 인덱싱한다.
iloc[position] : 위치 정수를 기반으로 인덱싱한다.
at[label] : 레이블을 기반으로 인덱싱한다.
iat[position] : 위치 정수를 기반으로 인덱싱한다.

# 단일 열을 얻기(Series)
df2['A']
0    1.0
1    1.0
2    1.0
3    1.0
Name: A, dtype: float64

# 행 분할하기 (0~2번째 행까지)
df2[0:3]
	A	B		C	D	E	F
0	1.0	2020-11-10	1.0	3	test	foo
1	1.0	2020-11-10	1.0	3	train	foo
2	1.0	2020-11-10	1.0	3	test	foo

# 값을 기준으로 분할할 수도 있다
df2['2020-11-10':'2020-11-11']

# loc
# 열이 아닌 행 단위로 데이터 조회
df.loc[0]
# 1차원 Sereis 형태의 데이터가 리턴된다.
A                      1
B    2020-11-10 00:00:00
C                      1
D                      3
E                   test
F                    foo
G                    one
Name: 0, dtype: object

df.loc[[0]]
# 2차원 배열을 입력하면 2차원인 DataFrame 형태의 데이터 출력
	A	B		C	D	E	F	G
0	1.0	2020-11-10	1.0	3	test	foo	one

# 여러 행 명을 사용하여 데이터를 가져올 수도 있다.
# 0, 1번째 행 데이터를 가져온다.
df.loc[[0, 1]]

# 특정 행만 제외하고 가져올 수 있다.
# 2번째 행만 제외하고 데이터를 DataFrame 형태로 가져온다.
df.loc[df.index != 2]
A	B		C	D	E	F	G
0	1.0	2020-11-10	1.0	3	test	foo	one
1	1.0	2020-11-10	1.0	3	train	foo	one
3	1.0	2020-11-10	1.0	3	train	foo	three

# 열 조회하기
# 모든 행은 :으로 표시
# 쉼표(,)를 입력하고 열명을 입력하면 해당 열만 가져온다.
df.loc[:, 'A']
0    1.0
1    1.0
2    1.0
3    1.0
Name: A, dtype: float64

# DataFrame으로 가져오기
df.loc[:, ['A']]

# 특정 컬럼(B열)만 제외하고 가져오기
df.loc[:, df.columns != 'B']
	A	C	D	E	F	G
0	1.0	1.0	3	test	foo	one
1	1.0	1.0	3	train	foo	one
2	1.0	1.0	3	test	foo	two
3	1.0	1.0	3	train	foo	three

# 행과 열 정보 동시에 가져오기
# 실제 값 하나만 리턴된다. 1.0
df.loc[0, 'A']

# 2차원 DataFrame 리턴
df.loc[[0, 1], ['A', 'B']]
	A	B
0	1.0	2020-11-10
1	1.0	2020-11-10

loc, iloc의 차이 : loc는 레이블을 기반으로 데이터에 접근하지만, iloc는 위치 정수를 기반으로 데이터에 접근한다.

loc와 at의 차이 : 레이블을 통해 값에 접근한다는 점이 공통점이나, at은 하나의 요소에만 접근할 수 있다.

iloc와 iat의 차이 : 위치 정수를 통해 값에 접근한다는 점이 공통점이나, iat은 하나의 요소에만 접근할 수 있다.

# at
# Timestamp('2020-11-10 00:00:00'), 0행 B열에 해당하는 하나의 요소 리턴
df.at[0, 'B']

# iat
# 'test', 0행 4열의 데이터가 출력된다.
df.iat[0, 4]

# iloc
# 위치 정수를 반드시 입력해주어야 한다.
df.iloc[0]
A                      1
B    2020-11-10 00:00:00
C                      1
D                      3
E                   test
F                    foo
G                    one
Name: 0, dtype: object

# 0행 6열의 값 하나를 가져온다. 'one'이 출력
df.iloc[0, 6]

불린 인덱싱을 사용하면 특정 조건에 맞는 데이터만 추출할 수 있다.

# Bool 인덱싱
# 한 번 더 []로 감싸주어야 한다, A가 1보다 클 경우 출력
df2[df2['A'] > 1]

# 필터링 사용하기, one three를 포함하고 있는 경우 출력
df = df2.copy()
df['G'] = ['one', 'one', 'two', 'three']
df[df['G'].isin(['one', 'three'])]
	A	B		C	D	E	F	G
0	1.0	2020-11-10	1.0	3	test	foo	one
1	1.0	2020-11-10	1.0	3	train	foo	one
3	1.0	2020-11-10	1.0	3	train	foo	three

[CS] 파이썬으로 시작하는 데이터 사이언스 (4)

칸타탓 — Mon, 9 Nov 2020 22:23:36 +0900

데이터 분석을 위한 파일 경로 설정하기

- %mv

- %pwd

- %ls
- pd.read_csv
- cp949

- 설정 방법

1) 새로운 노트북 생성하기

2) 공공데이터 포털로 이동하여 원하는 데이터 다운받기

3) 다운받은 데이터를 주피터 노트북의 위치로 옮기기 : %mv

4) data 폴더 내에 판다스로 csv 파일 불러오기

pd.read_csv("./data/도로교통공단_교통사고_다발지역_20201104.csv", encoding="cp949")

* 도움말 : Shift + Tab

[CS] 파이썬으로 시작하는 데이터 사이언스 (3)

칸타탓 — Sun, 8 Nov 2020 22:42:23 +0900

판다스 치트시트 활용하기

- pandas

- dataframe

- series

- sort

- drop

- groupby

- pivot table

- plot

- Pandas 사용하기

수식으로 계산할 수 있고 시각화도 할 수 있는 데이터 분석도구이다. 엑셀로는 힘든 대용량의 데이터를 분석할 수 있다.

import pandas as pd로 라이브러리를 불러온 후 사용한다.

- Pandas 따라해보기
pandas.pydata.org/pandas-docs/version/1.0.0/getting_started/10min.html

pandas.pydata.org/Pandas_Cheat_Sheet.pdf

- 관련 문법 익히기

1) DataFrame : 2차원의 자료구조

2개 이상의 프레임을 가져올 때는 데이터 프레임 형태로 가져와야 한다.

df = pd.DataFrame({
  "a" : [4, 5, 6],
  "b" : [7, 8, 9],
  "c" : [10, 11, 12]
},index = [1, 2, 3])
# 모든 값 출력
df

a, b, c 컬럼을 가진 데이터 프레임 생성

2) Series : 1차원의 자료구조

df["a"]를 입력하면 a 컬럼에 있는 4, 5, 6의 값이 출력된다.

Series 형태가 아닌 Data Frame 형태로 출력하고 싶은 경우 df[["a"]]로 입력한다.

* 차이 (1차원과 2차원 구조)

3) Subset (일부 값만 불러오기)

# df["a", "b"]
# 두 개 이상의 값을 불러올 때 Series 형태로 불러올 경우 키값 오류 발생

df[["a", "b"]]
# DataFrame 형태로 불러와야 한다.

# df의 a의 컬럼 값 중 4보다 큰 값만 가져오겠다
# df["a"] > 4는 Boolean 값
df[df["a"] > 4]

4) Summarize Data : 빈도수

Categorical한 값의 빈도수를 구하기

# a 컬럼에서 6은 1번, 5는 1번, 4는 1번 존재
df["a"].value_counts()

5) Reshaping

# a 컬럼을 정렬하기
df["a"].sort_values()
1    4
2    5
3    6
Name: a, dtype: int64

# a 값을 기준으로 정렬하기
df.sort_values("a")
	a	b	c
1	4	7	10
2	5	8	11
3	6	9	12

# 역순으로 정렬하기
df.sort_values("a", ascending=False)
	a	b	c
3	6	9	12
2	5	8	11
1	4	7	10

# 특정 칼럼 버리기
# axis : 0이면 행을 기준으로 삭제, 1은 열을 기준으로 삭제
# df.drop(["c"], axis=1)만 수행하는 것이 아니라 df에 다시 담아주어야 한다.
df = df.drop(["c"], axis=1)

	a	b
1	4	7
2	5	8
3	6	9

6) Group Data

# 컬럼의 평균값 구하기 (mean)
# a 컬럼값을 Groupby하여 b의 컬럼값 평균값 구하기
# 만약 a에 4가 2번 존재하고 각각 6, 8이 들어있다면 7이 평균값으로 b에 들어가게 됨
df.groupby(["a"])["b"].mean()

df.groupby(["a"])["b"].agg(["mean", "count", "sum"])
	mean	count	sum
a			
4	7	1	7
5	8	1	8
6	9	1	9

# 데이터 요약
df.groupby(["a"])["b"].describe()
	count	mean	std	min	25%	50%	75%	max
a								
4	1.0	7.0	NaN	7.0	7.0	7.0	7.0	7.0
5	1.0	8.0	NaN	8.0	8.0	8.0	8.0	8.0
6	1.0	9.0	NaN	9.0	9.0	9.0	9.0	9.0

a
4    7
5    8
6    9
Name: b, dtype: int64
# 4의 평균, 8의 평균, 9의 평균

pd.pivot_table(df, index="a")
	b	c
a		
4	7	10
5	8	11
6	9	12

# 더한 값을 구하고자 하는 경우
pd.pivot_table(df, index="a", values="b", aggfunc="sum")
	b
a	
4	7
5	8
6	9

7) Plotting : 시각화(기본적으로 선 그래프)

# 꺾은선 그래프
df.plot()

# 막대 그래프
df.plot.bar()

# 밀도함수
df.plot.density()

[CS] 파이썬으로 시작하는 데이터 사이언스 (2)

칸타탓 — Sun, 8 Nov 2020 22:36:58 +0900

데이터 분석에 필요한 파이썬 기초 문법

- import : import를 통해 파이썬의 라이브러리나 패키지를 가져올 수 있다.

- boolean : True(1), False(0)

- string : 앞 뒤 공백 제거하기 - address = address.strip(), 문자열 포함여부(address.startswith(""), 혹은 "" in address)

- list : append(원소 추가하기), 슬라이싱(address:[:2]), 원소 포함 여부 확인하기("" in address_list)

- for : enumerate를 통해 원소와 index 함께 가져오기 - for i, val in enumerate(lang):

- len() : 문자열, 리스트 길이 확인하기

- split(기준 문자) : 문자열 자르기

- join : 두 리스트 연결하여 문자열 만들기(" ".join(address_list))

- Zen of Python

PEP20 에 선언되어 있는 파이썬의 철학이 담긴 이스터에그 출력하기

> import this