[2024.01.22] 데이터 구조

체리마루·2024년 1월 22일

SSAFY

데이터 구조 (Data Structure)

: 여러 데이터를 효과적으로 사용, 관리하기 위한 구조 (str, list, dict 등)

메서드 (method)

: 객체(클래스)에 속한 함수
-> 객체의 상태를 조작하거나 동작을 수행

특징:
메서드는 클래스 내부에 정의되는 함수
클래스는 파이썬에서 '타입을 표현하는 방법'이며 이미 은연중에 사용해왔음
예를 들어 help 함수를 통해 str을 호출해보면 class였다는 것을 확인 가능

시퀀스 데이터 구조

문자열 조회/탐색 및 검증 메서드

s.find(x) : x의 첫 번째 위치를 반환. 없으면 -1을 반환

print('banana'.find('a')) #1
print('banana'.find('z')) #-1

s.index(x) : x의 첫 번째 위치를 반환. 없으면, 오류 발생

print('banana'.index('a')) #1
print('banana'.index('z')) #없으면 ValueError

s.isalpha() : 알파벳 문자 여부
*단순 알파벳이 아닌 유니코드 상 Letter (한국어도 포함)

string1 = 'Hello'
string2 = '123'
string3 = '12a3'
print(string1.isalpha()) #True
print(string2.isalpha()) #False
print(string3.isalpha()) #False

s.isupper() : 대문자 여부
s.islower() : 소문자 여부

string1 = 'HELLO'
string2 = 'Hello'
print(string1.isupper()) #True
print(string2.isupper()) #False
print(string1.islower()) #False
print(string2.islower()) #False

문자열 조작 메서드 (새 문자열 반환)

s.replace(old, new[,count]) : 바꿀 대상 글자를 새로운 글자로 바꿔서 전환
(*문자열은 원본을 변경할 수 없기 때문)
[count] 인자는 선택적으로 추가 가능
=> '베커스-나우르 표기법'

text = 'Hello, world!'
new_text = text.replace('world', 'Python')
print(new_text) #Hello, Python!

s.strip([chars]) : 문자열의 시작과 끝에 있는 공백이나 특정 문자를 제거

text = '  Hello, world!   '
new_text = text.strip()
print(new_text) # 'Hello, world!'

s.split(sep=None, maxsplit=-1) : 공백이나 특정 문자를 기준으로 분리하여 문자열의 리스트로 반환

text = 'Hello, world!'
words = text.split(',')
print(words) #['Hello', ' world!']

'separator'.join([iterable]) : 구분자로 iterable을 합침

words = ['Hello', 'world!']
text = '-'.join(words)
print(text) # 'Hello-world!'

s.capitalize() : 가장 첫 번째 글자를 대문자로 변경
s.title() : 문자열 내 띄어쓰기 기준으로 각 단어의 첫 글자를 대문자로, 나머지는 소문자로 변환
s.upper() : 모두 대문자로 변경
s.lower() : 모두 소문자로 변경
s.swapcase() : 대<->소문자 서로 변경

text = 'heLLo, woRld!'
new_text1 = text.capitalize()
new_text2 = text.title()
new_text3 = text.upper()
new_text4 = text.swapcase()

print(new_text1) #Hello, world!
print(new_text2) #Hello, World!
print(new_text3) #HELLO, WORLD!
print(new_text4) #HEllO, WOrLD!

*메서드는 이어서 사용 가능함

text = 'heLLo, woRld!'
new_text = text.swapcase().replace('l', 'z')
print(new_text)

리스트 값 추가 및 삭제 메서드

L.append(x) : 리스트 마지막에 항목 x를 추가

my_list = [1, 2, 3]
my_list.append(4)
print(my_list) #[1, 2, 3, 4]

my_list = [1, 2, 3, 4]
my_list.append([4, 5, 6])
print(my_list) #[1, 2, 3, 4, [4, 5, 6]] - 요소가 풀리지 않고 그대로 들어감

L.extend(m) : Iterable m의 모든 항목들을 리스트 끝에 추가 (+=과 같은 기능)

my_list = [1, 2, 3, 4]
my_list.extend([4, 5, 6])
print(my_list) #[1, 2, 3, 4, 4, 5, 6] - 요소가 풀려서 들어감

L.insert(i, x) : 리스트 인덱스 i에 항목 x를 삽입

my_lst = [1, 2, 3]
my_lst.insert(1, 5)
print(my_lst) #[1, 5, 2, 3]

L.remove(x) : 리스트 가장 왼쪽에 있는 항목(첫 번째) x를 제거. 항목이 존재하지 않을 경우, ValueError

my_lst = [1, 2, 3]
my_lst.remove(2)
print(my_lst) #[1, 3]

my_lst = [1, 2, 3]
my_lst.remove(5)
print(my_lst) #ValueError

L.pop() : 리스트 가장 오른쪽에 있는 항목(마지막)을 반환 후 제거
L.pop(i) : 리스트 인덱스 i에 있는 항목을 반환 후 제거

my_lst = [1, 2, 3, 4, 5]
item1 = my_lst.pop()
item2 = my_lst.pop(0)

print(item1) #5
print(item2) #1
print(my_lst) #[2, 3, 4]

L.clear() : 리스트의 모든 항목 삭제

my_lst = [1, 2, 3]
my_lst.clear()
print(my_lst) #[]

리스트 탐색 및 정렬 메서드

L.index(x, start, end) : 리스트에 있는 항목 중 가장 왼쪽에 있는 항목 x의 인덱스를 반환

my_lst = [1, 2, 3]
index = my_lst.index(2)
print(index) #1

L.reverse() : 리스트의 순서를 역순으로 변경 (정렬 x)

my_lst = [1, 3, 2, 8, 1, 9]
my_lst.reverse()
print(my_lst) #[9, 1, 8, 2, 3, 1]

L.sort() : 원본 리스트를 정렬 (매개변수 이용가능)

my_lst = [3, 2, 1]
my_lst.sort()
print(my_lst) #[1, 2, 3]

#내림차순
my_lst.sort(reverse=True)
print(my_lst) #[3, 2, 1]

L.count(x) : 리스트에서 항목 x의 개수를 반환

my_lst = [1, 2, 2, 3, 3, 3]
count = my_lst.count(3)
print(count) #3

복사

데이터 타입과 복사

: 파이썬에서는 데이터의 분류에 따라 복사가 달라짐
: "변경 가능한 데이터 타입"과 "변경 불가능한 데이터 타입"을 다르게 다룸

변경 가능한 데이터 타입의 복사

a = [1, 2, 3, 4]
b = a
b[0] = 100

print(a) #[100, 2, 3, 4]
print(b) #[100, 2, 3, 4]

변경 불가능한 데이터 타입의 복사

a = 20
b = a
b = 10

print(a) #20
print(b) #10

복사 유형

할당 (Assignment)

original_lst = [1, 2, 3]
copy_lst = original_lst

copy_lst[0] = 'hello'
print(original_lst)

*할당 연산자(=)를 통한 복사는 해당 객체에 대한 객체 참조를 복사

얕은 복사 (Shallow copy)

a = [1, 2, 3]
b = a[:]
print(a, b) #[1, 2, 3] [1, 2, 3]

b[0] = 100
print(a, b) #[1, 2, 3] [100, 2, 3]

*예시) 슬라이싱을 통해 생성된 객체는 원본 객체와 독립적으로 존재

*얕은 복사의 한계: 2차원 리스트와 같이 변경 가능한 객체 안에 변경 가능한 객체가 있는 경우

a = [1, 2, [1, 2]]
b = a[:]
print(a, b) #[1, 2, [1, 2]] [1, 2, [1, 2]]

b[2][0] = 100
print(a, b) #[1, 2, [100, 2]] [1, 2, [100, 2]]

깊은 복사 (Deep copy)

import copy

original_lst = [1, 2, [1, 2]]
deep_copied_lst = copy.deepcopy(original_lst)

deep_copied_lst[2][0] = 100

print(original_lst) #[1, 2, [1, 2]]
print(deep_copied_lst) #[1, 2, [100, 2]]

*예시) 내부에 중첩된 모든 객체까지 새로운 객체 주소를 참조하도록 함