초보 기술블로그

이것이 코딩테스트다 챕터 7 이진탐색

CleStella — Mon, 27 May 2024 16:41:30 +0900

순차 탐색

말 그대로 리스트나 배열의 앞에서부터 원하는 아이템을 찾는 방식

순차 탐색 방식

이진 탐색(Binary Search)

탐색 범위를 절반으로 줄이며 아이템을 찾는 방식.

배열 내부의 데이터가 정렬되어 있어야 사용 가능하다

시작점,끝점,중간점을 조절하며 아이템을 찾는다

초기 시작점은 배열의 첫 인덱스(0), 초기 끝점은 배열의 마지막 인덱스, 중간점은 항상 시작점과 끝점의 절반

아이템을 찾거나 배열에 아이템이 없다고 판단될 때까지 반복한다.

이진 탐색 방식

이진 탐색 트리(Binary Search Tree, BST)

트리 자료구조 중 특정한 특징을 가진 트리.

이진 탐색 트리의 특징

모든 노드는 2개 이하의 자식 노드를 가진다
왼쪽 자식 노드 < 부모 노드 < 오른쪽 자식 노드를 만족시킨다

BST의 예시

이것이 코딩테스트다 챕터 6 정렬

CleStella — Mon, 20 May 2024 13:16:20 +0900

정렬이란?

= >데이터를 특정한 기준에 따라서 순서대로 나열하는 것

'알고리즘의 효율성'을 쉽게 이해할 수 있어 알고리즘의 초반 단계에서 공부함.

선택 정렬

가장 작은 데이터를 맨 앞의 데이터와 바꾸고, 다음으로 작은 데이터를 선택해 두 번째 데이터와 바꾸는 과정을 반복

선택 정렬 과정

array = [7,5,9,0,3,1,6,2,4,8]
for i in range(len(array)):
	min_index = i //가장 작은 인덱스를 저장해 둠
    for j in range(i+1,len(array)): //가장 작은 인덱스 다음 번호부터 가장 작은 값을 찾음
    	if array[min_index] > array[j]:
        	min_index = j
    array[i], array[min_index] = array[min_index], array[i] // 두 개의 순서를 바꿈

print(array)
//선택정렬의 코드

선택 정렬은 N-1번 만큼 가장 작은 수를 찾기 위해 비교 연산을 진행하기 때문에,

N+(N-1)+(N-2)+...+2 ~= N(N+1)/2 정도의 시간 복잡도를 가지고 있다고 할 수 있고,

이를 가장 큰 차수만 차용하여 O(N^2)형태로 표현할 수 있다.

삽입 정렬

데이터를 하나씩 확인하며 각 데이터를 적절한 위치에 삽입하는 방식

데이터가 적절한 위치에 들어가기 전에 그 앞까지는 데이터가 정렬되어있다고 가정함.

따라서 '데이터가 거의 정렬되어 있을 때' 가장 효율적임.

삽입 정렬의 과정

array = [7,5,9,0,3,1,6,2,4,8]

for i in range(1, len(array)):
	for j in range(i,0,-1):
    	if array[j] < array[j-1]:
        	array[j],array[j-1] = array[j-1], array[j]
        else:
        	break
 print(array)
 
 //삽입 정렬의 코드

삽입 정렬도 앞선 선택 정렬과 같이 반복문을 두개 연달아 사용했기 때문에

시간 복잡도는 O(N^2)형태라고 볼 수 있다.

퀵 정렬

기준 데이터를 설정하고 그 기준보다 큰 데이터와 작은 데이터의 위치를 바꾼다.

'피벗'이라는 기준을 설정해 보통 정렬을 진행하는데, 가장 대표적인 '호어 분할' 방식에서는

리스트의 첫 번째 데이터를 피벗으로 설정해 정렬을 진행한다.

퀵 소트의 진행 과정

앞에서부터 피벗보다 큰 데이터와 작은 데이터의 위치를 변경하며 정렬을 진행한다.

만약 두 데이터의 위치가 서로 엇갈리면(큰 데이터가 뒤쪽, 작은 데이터가 앞쪽)

작은 데이터와 피벗의 위치를 변경하여 분할을 수행한다.

만약 분할된 리스트의 길이가 1인 경우에는 해당 리스트에 대해서 정렬을 중지한다.

피벗의 위치가 변경되면 이후 분할된 리스트에 대해 동일한 작업을 반복하여 정렬을 진행한다.

//가장 대표적으로 사용되는 직관적인 퀵 정렬 소스코드
def quick_sort(li, start, end):
    if start >= end:
        return
    pivot = start
    left = start + 1
    right = end
    while left <= right:
        while left <= end and li[left] <= li[pivot]:
            left += 1
        while right > start and li[right] >= li[pivot]:
            right -= 1
        if left > right:
            li[right], li[pivot] = li[pivot], li[right]
        else:
            li[left], li[right] = li[right], li[left]
    quick_sort(li, start, right - 1)
    quick_sort(li, right + 1, end)

array = [5, 7, 9, 0, 3, 1, 6, 2, 4, 8]


quick_sort(array, 0, len(array) - 1)
print(array)

퀵 정렬은 N개의 데이터를 절반씩 나눈다고 도식화 시

O(Nlog(N))의 시간 복잡도를 지닌다.

계수 정렬

가장 큰 데이터와 가장 작은 데이터의 범위가 담기도록 리스트를 생성하고

데이터의 갯수만큼 해당 인덱스에 1을 더해 개수를 저장하고 이후 개수가 저장된 리스트의 앞에서부터 개수만큼 출력

따라서

"데이터의 크기 범위가 제한되어 정수 형태로 표현할 수 있을 때"만 사용 가능하다.

array = [7, 5, 9, 0, 3, 1, 6, 2, 9, 1, 4, 8, 0, 5, 2]
count = [0] * (max(li) + 1)
for i in range(len(array)):
	count[array[i]] += 1
for i in range(len(count)):
    for j in range(count[i]):
    	print(i, end = ' ')
//계수 정렬 소스코드

이것이 코딩테스트다 챕터 5 DFS/BFS

CleStella — Mon, 13 May 2024 14:11:58 +0900

DFS/BFS를 알기 전 기본 지식

1. 스택(stack)

선입후출(FILO(First In Last Out))방식을 사용하는 자료구조.

Top이라는 포인터를 지정해 위치를 설정함.

stack의 작동 원리

Push()
스택에 원소를 추가한다.
Pop()
스택 가장 위에 있는 원소를 삭제하고 그 원소를 반환한다.
Top()
스택 가장 위에 있는 원소를 반환한다. (삭제하지는 않는다.)
IsEmpty()
스택이 비어있다면 True, 비어있지 않으면 False를 반환한다

2.큐

후입선출(FIFO(First In First Out))방식을 사용하는 자료구조

Front포인터를 두어 제거 연산을, Rear 포인터를 두어 입력 연산을 담당함.

queue의 작동 원리

Push()
큐에 원소를 추가한다.
Pop()
스택 가장 위에 있는 원소를 삭제하고 그 원소를 반환한다.
IsEmpty()
큐가 비어있다면 True, 비어있지 않으면 False를 반환한다

3.재귀함수

말 그대로 자기 자신을 호출하는 함수를 의미한다.

가장 대표적인 예시인 팩토리얼을 재귀로 구현한 방식과 재귀를 이용하지 않은 방식으로 표현하면

//재귀를 이용한 방식
int factorial(int n) { 
    if (n === 1) { 
        return 1; 
    } 
    return n * factorial(n-1);
}

//재귀를 이용하지 않은 방식
int factorial_nonrecursive(int n) {
	result = 1
    for i in range(1,n+1):
    	result *=i
    return result
}

재귀를 이용한 방식이 코드가 짧고 간편하다.

따라서, 재귀함수는 변수를 여럿 만들 필요가 없고 반복문을 사용하지 않아도 되기에 간결한 코드가 된다는 장점이 있으나연속적으로 함수를 호출하면서 지역변수, 매개변수, 반환값을 stack에 저장하며 지연이 생긴다는 단점도 있다.

장점

가독성: 코드가 더 직관적이고 읽기 쉬우며 변수를 여러개 만들 필요가 없다.
문제 해결이 편함: 재귀식을 그대로 가져오면 되기 때문에 문제 해결에 대한 접근을 손쉽게 얻을 수 있다.

단점

성능: 지속적인 함수 호출로 호출 스택에 작업이 지속적으로 추가되어 성능 저하가 발생할 수 있다.

이런 식으로 반복되는 값에 대한 예외 처리가 없는 경우도 성능 저하 발생 가능

4. 그래프

노드와 간선으로 이루어진 자료구조를 말한다.

노드(Node) : 데이터를 저장하는 위치, 정점(Vertex)라고도 함.
간선(Edge) : 노드와 노드, 정점과 정점을 연결하는 선

보통 그래프를 표현하는 방식은 인접 행렬 방식과 인접 리스트 방식으로 나뉨

인접 행렬(Adjacency Matrix) 방식

2차원 배열로 그래프의 연결 관계를 표현하는 방식

연결이 되어있지 않은 노드끼리는 무한의 비용/0으로 가정함.

모든 관계를 저장하기 때문에 노드 개수가 많을수록 메모리가 낭비됨

인접 리스트(Adjacency List) 방식

'연결 리스트'라는 자료구조를 이용해 구현(C++/Java), 파이썬은 기본 리스트 라이브러리 사용 가능

리스트로 그래프의 연결 관계를 표현하는 방식

두 개의 노드가 연결되어있는지 확인하는 과정이 필요해 정보를 얻는 속도가 느림

인접 행렬과 인접 리스트 방식

DFS(Depth-First-Search)

말 그대로 깊이 우선 탐색 방식을 의미한다.

구현 시 대부분 재귀함수를 이용한다.

아래 그림과 동작 과정,코드를 통해 이를 이해해보자

일반적으로 DFS의 동작 과정은 다음과 같다.

탐색 시작 노드를 스택에 삽입하고 방문 처리를 한다
스택의 최상단 노드에 방문하지 않은 인접 노드가 있으면 그 인접 노드를 스택에 넣고 방문 처리.
방문하지 않은 인접 노드가 없으면 스택에서 최상단 노드를 꺼낸다.
2번의 과정을 더 이상 수행할 수 없을 때까지 반복한다.

DFS 동작 방식 GIF

보통 코딩테스트/문제에서는 관행적으로 번호가 낮은 순으로 처리하기에 정렬의 필요성 존재.

def dfs(graph,v,visited):
	visited[v] = True
    print(v,end=' ')
    for i in graph[v]:
    	if not visited[i]:
        	dfs(graph,i,visited)

graph=[[],[2,3,8],[1,7],[1,4,5],[3,5],[3,4],[7],[2,6,8],[1,7]]
visited=[False]*9
dfs(graph,1,visited)

dfs의 예시는 다음과 같으며, 보통 visited 행렬을 따로 만들어 사용하는 경우가 많다.

보통 DFS는 다음과 같은 상황에 사용한다.

모든 경우를 하나하나 전부 탐색하는 완전탐색 문제(조합, 순열)
단순히 두 지점 간의 경로가 존재하는지 여부를 찾는 문제(조건문 넣으면 중간에 종료 가능) => 백트래킹

BFS(Breadth-First-Search)

말 그대로 너비 우선 탐색 방식을 의미한다.

보통 선입선출 방식인 큐 자료구조를 이용해서 구현한다.

아래 그림과 동작 과정,코드를 통해 이를 이해해보자

일반적으로 BFS의 동작 과정은 다음과 같다.

탐색 시작 노드를 큐에 삽입하고 방문 처리를 한다.
큐에서 노드를 꺼내 해당 노드의 인접 노드 중에서 방문하지 않은 노드를
모두 큐에 삽입하고 방문처리를 한다.
2번의 과정을 더 이상 수행할 수 없을 때까지 반복한다.

BFS 동작 방식 GIF

from collections import deque

def bfs(graph,start,visited):
	queue = deque([start])
    visited[start]=True
    while queue:
    	v = queue.popleft()
    	print(v, end=' ')
    	for i in graph[v]:
        	if not visited[i]:
            	queue.append(i)
        		visited[i]=True

graph=[[],[2,3,8],[1,7],[1,4,5],[3,5],[3,4],[7],[2,6,8],[1,7]]
visited=[False]*9
bfs(graph,1,visited)

bfs의 예시는 다음과 같으며, 보통 visited 행렬을 따로 만들어 사용하는 경우가 많다.

보통 BFS는 다음과 같은 상황에 사용한다.

최단경로 문제를 풀어야할때 => 제일 많이 사용
그래프의 깊이가 깊지 않을 경우

백준 22864 파이썬 문제 풀이

CleStella — Mon, 6 May 2024 18:52:39 +0900

문제는 위와 같고 코드는 아래와 같다.

a,b,c,m = map(int,input().split())
time=0
tired=0
work=0
while(time<24):
    if(tired+a<=m):
        tired+=a
        work+=b
    else:
        tired-=c
        if tired <0:
            tired = 0
    time+=1
print(work)

피로도 안에서 할 수 있는 모든 일을 한 후, 피로도가 일정 수준 이상 낮아졌을 경우 쉬는 과정을 반복,

만약 피로도가 음수일 경우에는 0으로 초기화함으로서 24시간 안에 할 수 있는 일의 양을 계산한다.

백준 10610 파이썬 문제 풀이

CleStella — Mon, 6 May 2024 18:49:30 +0900

문제는 위와 같고, 코드는 아래와 같다.

a_list=list(map(int,input()))
is_three=0
is_zero=True
result=0
iterat=0
for num in a_list:
    if num==0:
        is_zero = False
    result+=num
if (is_zero) or ((result%3)!=0):
    print(-1)
else:
    a_list.sort(reverse=True)
    for nums in a_list:
        print(nums,end="")

모든 자릿수의 합이 3의 배수여야 3의 배수를 만들 수 있다는 것은 자명한 사실이기에

모든 자릿수의 합이 3의 배수인지 확인하고, 이 값이 0인지도 확인한 후

입력받은 수를 역으로 정렬해 이를 출력했다.

백준 16953 파이썬 문제 풀이

CleStella — Mon, 6 May 2024 18:45:12 +0900

문제는 다음과 같고, 코드는 아래와 같다.

a,b = input().split()
count = 1
while (int(b)>int(a)):
    if b[-1]=="1":
        b = b[0:-1]
        count+=1
    elif int(b)%2==0:
        b = str(int(b)//2)
        count+=1
    else:
        break
if a==b:
    print(count)
else:
    print(-1)

a,b를 입력을 받은 후,

a를 b로 변환시키는 것이 아니라

b를 a로 변환시킴으로서 문제를 해결해 나갔다.

따라서 가장 마지막에 1이 존재할 경우는 이를 제거하고,

2를 나눌 수 있다면 2로 나누는 과정 하나하나를 전부 연산 숫자로 생각하고

불가능할 경우 -1을 출력하도록 구현했다.

알고리즘 기초 지식 시간복잡도

CleStella — Mon, 6 May 2024 18:38:11 +0900

우리가 어떤 알고리즘이 더 나은 알고리즘인지 판단할 수 있는 척도는 무엇일까?

흔히 고려해 볼 수 있는 사항은 다음과 같다.

실행시간
코드의 길이
자주 발생하는 작업/연산의 수(소팅에서의 비교 연산)

그러나, 코드가 길다고 해서 실행 시간이 짧다는 보장이 없을 뿐더러, 실행시간의 경우에는 하드웨어의 차이에 따라

그 결과가 달라질 가능성이 높다고 볼 수 있다. 그렇다면, 우리는 어떤 기준을 가지고 이를 판단해야 할까.

시간복잡도

시간복잡도란, 이 중 필요한 단위연산을 기준으로 하는 복잡도를 의미하며,

알고리즘이 한 번 수행되는 동안 수행되는 단위연산의 수를 중심으로 비교한다.

이 단위연산은 해당 알고리즘에서 가장 많이, 필수적으로 수행되어야 하는 연산을 말한다.

보통 시간복잡도를 표현하기 위해 가장 많이 사용하는 표기법은 Big-O-Notation(빅오 표기법)이다.

Big-O-Notation

Big-O 표기법은 문제의 문제의 수행시간에 대한 함수의 표현식으로

문제의 크기에 비례하여 가장 빠르게 증가하는 연산에 관련된 함수로 표현하는 것을 의미한다.

이 함수를 "복잡도 함수"라고 부르며, 이 복잡도 함수가 작을수록 더 나은 알고리즘임을 의미하는 표기 방식이다.

보통 O(f(n))형태로 표현하며, 이 f(n)이 복잡도 함수이고,

연산수가 무한으로 증가한다면 최고차항의 수만 살펴보면 되기 때문에 보통 최고차항의 차수를 중심으로 판단한다.

Big-O notation의 함수와 수행 시간

이것이 코딩테스트다 챕터 4 구현

CleStella — Mon, 6 May 2024 18:25:32 +0900

구현이란?

구현은 '머릿속에 있는 알고리즘을 소스코드로 바꾸는 과정' 을 의미한다.

단순히 문제를 보고 떠오르는 과정을 코드로 옮기는 피지컬적인 문제들이 이에 해당한다고 볼 수 있다.

책에서는

"완전 탐색" 유형 => 모든 경우의 수를 주저 없이 다 계산하는 유형

"시뮬레이션" 유형 => 문제에서 제시한 알고리즘을 한 단계씩 차례대로 직접 수행해야 하는 유횽

을 모두 구현 유형으로 묶어서 다루고 있다.

보통 이 구현 문제들의 예시로는

알고리즘은 간단한데 코드가 지나칠 만큼 길어지는 문제
특정 소수점 자리까지 출력해야 하는 문제
문자열을 특정한 기준에 따라서 끊어 처리해야 하는 문제
적절한 라이브러리를 찾아서 사용해야 하는 문제
2차원 배열에서의 이동, 회전 등 까다로운 문제

문제들과 같은 예시들이 존재한다.

주의사항

c/c++과 java에서 주의해야 할 사항

보통 int 자료형을 다룰 때 다음 범위보다 큰 수가 존재할 경우 이를 다룰 수 없기 때문에 고려하여 코드를 구현해야 한다.

파이썬에서는 프로그래머가 직접 자료형을 지정하는 경우가 적기 때문에 이런 사항을 고려하는 일이 적다.

접근 방법

문제는 긴 경우가 많으나 큰 사고력을 필요로 하지는 않기 때문에

천천히 문제를 읽고 이를 코드로 옮기면 되는 경우가 많다.

이해가 되지 않는 경우에는 A4용지를 사용해 코드를 구체화 시켜 보는 것도 방법

코드업 기초 100제 51~98

CleStella — Mon, 8 Apr 2024 09:50:49 +0900

a,b=map(int,input().split())
print(a!=b)

a=int(input())
print(a!=0)

a=bool(int(input()))
print(a!=True)

a, b = input().split()
print(bool(int(a)) and bool(int(b)))

a, b = input().split()
print(bool(int(a)) or bool(int(b)))

a, b = input().split()
print(bool(int(a)) ^ bool(int(b)))

a, b = input().split()
print(bool(int(a)) == bool(int(b)))

a, b = input().split()
print(bool(int(a)) == bool(int(b)) == False)

print(~int(input()))

a, b =input().split()
print(int(a) & int(b))

a, b =input().split()
print(int(a) | int(b))

a, b =input().split()
print(int(a) ^ int(b))

a, b =input().split()
print(max(int(a),int(b)))

a, b, c =input().split()
print(min(int(a),int(b),int(c)))

a, b, c =input().split()
if int(a)%2==0:
    print(int(a))
if int(b)%2==0:
    print(int(b))
if int(c)%2==0:
    print(int(c))

a, b, c =input().split()
if int(a)%2==0:
    print("even")
else:
    print("odd")
if int(b)%2==0:
    print("even")
else:
    print("odd")
if int(c)%2==0:
    print("even")
else:
    print("odd")

a = int(input())
if a<=0 and a%2==0:
    print("A")
elif (a<=0):
    print("B")
elif (a%2==0):
    print("C")
else:
    print("D")

a = int(input())
if a>=90:
    print("A")
elif (a>=70):
    print("B")
elif (a>=40):
    print("C")
else:
    print("D")

a = input()
if a=="A":
    print("best!!!")
elif (a=="B"):
    print("good!!")
elif (a=="C"):
    print("run!")
elif (a=="D"):
    print("slowly~")
else:
    print("what?")

a = int(input())
if a<3 or a==12:
    print("winter")
elif a<6:
    print("spring")
elif a<9:
    print("summer")
else:
    print("fall")

while (True):
    a =int(input())
    if a!=0:
        print(a)
    else:
        break

a = int(input())
for b in range(a):
    print(a-b)

a = int(input())
for b in range(a):
    print(a-b-1)

a = ord(input())
b = ord('a')
while b<=a :
  print(chr(b), end=' ')
  b += 1

a = int(input())
for i in range(a+1):
    print(i)

a = int(input())
for i in range(a+1):
    print(i)

n = int(input())
s = 0
for i in range(1, n+1) :
  if i%2==0 :
    s += i
print(s)

a = "b"
while(True):
    a = input()
    if a=="q":
        print(a)
        break
    else:
        print(a)

a = int(input())
for i in range(a):
    if ((i*(i+1))//2>=a):
        print(i)
        break

a,b=input().split()
for i in range(int(a)):
    for j in range(int(b)):
        print(i+1,j+1,sep=" ")

a = int(input(),16)
for i in range(1, 16):
    print("%x".upper()%n,"*","%x".upper()%i, "=", "%x".upper()%(n*i), sep="")

n = list(map(str, range(1, int(input())+1)))
for i in n:
    if "3" in i or "6" in i or "9" in i:
        n[n.index(i)] = "X"  
print(" ".join(n))

a,b,c=input().split()
for i in range(int(a)):
    for j in range(int(b)):
        for k in range(int(c)):
            print(i,j,k,sep=" ")
print((i+1)*(j+1)*(k+1))

h,b,c,s = input().split()
print(format(h * b * c * s / 8 / 1024 / 1024, ".1f"), "MB")

w, h, b = map(int, input().split())
print(format(w * h * b / 8 / 1024 / 1024, ".2f"), "MB")

a = int(input())
for i in range(a+1):
    if ((i*(i+1))//2)>=a:
        print((i*(i+1))//2)
        break

a = int(input())
for i in range(1,a+1):
    if i%3==0:
        continue
    print(i,end=" ")

a,d,n = map(int,input().split())
print(a+d*(n-1))

a,r,n = map(int,input().split())
print(a*pow(r,(n-1)))

a,m,d,n= map(int,input().split())
result=a
for i in range(1,n):
    result=(result*m)+d
print(result)

import math
a,b,c= map(int,input().split())
print(math.lcm(a,b,c))

a = int(input())
a_list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23]
b_list = []
for i in range(23):
    b_list.append(0)
c_list = list(map(int,input().split()))
for j in c_list:
    b_list[a_list.index(j)]+=1
for k in b_list:
    print(k,end=" ")

a = int(input())
c_list = list(map(int,input().split()))
c_list = c_list[::-1]
for k in c_list:
    print(k,end=" ")

a = int(input())
c_list = list(map(int,input().split()))
c_list.sort()
print(c_list[0])

d=[]
for i in range(20) :
  d.append([])
  for j in range(20) : 
    d[i].append(0)
a = int(input())
for i in range(a):
    k,l = input().split()
    d[int(k)-1][int(l)-1]=1
for i in range(19):
  if i>=1:
      print("")
  for j in range(19):
    print(d[i][j],end=" ")

answer = []
for _ in range(19):
    arr = input().split()
    answer.append(arr)

n = int(input())

for _ in range(n):
    x, y = map(int, input().split())
    for k in range(19):
        answer[k][y-1] = str(int(not int(answer[k][y-1])))
        answer[x-1][k] = str(int(not int(answer[x-1][k])))
        
for k in answer:
    print(" ".join(k))

a, b = map(int, input().split())
matrix = [["0" for _ in range(b)] for _ in range(a)]

for _ in range(int(input())):
    l, d, x, y = map(int, input().split())
    if d == 0:
        for i in range(y-1, y+l-1):
            matrix[x-1][i] = "1"
    else:
        for i in range(x-1, x+l-1):
            matrix[i][y-1] = "1"

for k in matrix:
    print(" ".join(k))

matrix = []
for _ in range(10):
    matrix.append(input().split())
    
x, y = 1, 1
while x <= 8 and y <= 8:
    if matrix[x][y] == "2":
        matrix[x][y] = "9"
        break
    matrix[x][y] = "9"
    if matrix[x][y+1] == "1" and matrix[x+1][y] == "1":
        break
    elif matrix[x][y+1] == "1":
        x += 1
    else:
        y += 1

for k in matrix:
    print(" ".join(k))

파이썬 기초 문법 <클래스>

CleStella — Mon, 1 Apr 2024 12:22:24 +0900

클래스의 필요성

비슷한 기능과 쓰임을 가진 객체들을 신속하고 많이 만드는데 유리하며, 독립적으로 작용하는 객체를 만들 수 있기 때문.

만약 위 그림처럼 게임을 제작할 때 캐릭터들의 기본값을 저장해둔다고 하자.

기존의 방식으로는 검술사,요정,도적 등 각 직업의 체력,공격력,공격방법등을 전부 다시 정의해야 하지만

클래스를 사용하면 클래스 내부의 변수를 조정하는 것만으로도 새로운 직업을 만들 수도 있다.

클래스와 객체, 인스턴스

클래스(class)란 똑같은 무언가를 계속 만들어 낼 수 있는 설계 도면(과자 틀),

객체(object)란 클래스로 만든 피조물(과자 틀로 찍어 낸 과자)을 뜻한다.

또한, 각 객체들은 서로 독립적이며 영향을 주고받지 않는다.

인스턴스(instance)는 객체를 부르는 또 다른 표현이다. 다만, 인스턴스라는 말을 사용할 때에는

'a는 인스턴스다'라는 표현보다는 'a는 b클래스의 인스턴스다'라는 표현으로 사용한다.

파이썬에서의 클래스 정의

class Calculator:
     def __init__(self, first, second):
         self.first = first
         self.second = second
     def setdata(self, first, second):
         self.first = first
         self.second = second
     def add(self):
         result = self.first + self.second
         return result
     def mul(self):
         result = self.first * self.second
         return result
     def sub(self):
         result = self.first - self.second
         return result
     def div(self):
         result = self.first / self.second
         return result

위의 방식처럼 "class 클래스이름(입력받을 매개변수):" 의 형태로 정의하며,

그 아래에는 클래스 내부에서 사용할 내부변수와 함수의 정의로 이루어져 있다.

클래스의 상속

class 클래스_이름(상속할_클래스_이름)

기존 클래스를 변경하지 않고 기능을 추가하거나 기존 기능을 변경하려고 할 때 사용한다

예를 들어 위에 만든 calculator함수에 추가적으로 결괏값을 출력하는 함수를 만들고자 할 때

상속을 이용해서 제작할 수 있다.

class Print_Calculator(Calculator):
     def print_Cal(self):
     	print(Calculator.first,Calculator.second)

Calculator를 상속하여 Calculator의 멤버변수 first와 second를 리턴하는 함수

메서드 오버라이딩

부모 클래스(상속한 클래스)에 있는 메서드를 동일한 이름으로 다시 만드는 것을 말한다.

메서드를 오버라이딩하면 부모 클래스의 메서드 대신 오버라이딩한 메서드가 호출된다.

class SafeFourCal(Calculator)
	def div(self):
		if self.second == 0:  # 나누는 값이 0인 경우 0을 리턴하도록 수정
			return 0
		else:
			return self.first / self.second

위처럼 safeFourCal이라는 클래스로 Calculator 클래스를 상속받아 사용했을 때, div 함수를 오버라이딩하면

나누는 값이 0일 경우의 오류를 방지할 수 있다.