Python_02(자료구조)

자료구조 : 여러 개의 값들을 모아서 관리하는 데이터 타입.

파이썬에서 지원하는 4가지 방식
List, Tuple, Dictionary, Set

List - 순서(Index)가 있고 중복을 허용한다. List 데이터는 동일한 종류의 값들이 적합하다.

동일한 종류가 아닐 경우 인덱스의 순서와 그에 맞는 데이터의 의미를 기억해두어야 한다.

List를 구성하는 원소들의 변경이 가능하다, Indexing, Slicing 사용 가능

# 생성
l1 = [10, 20, 30, 40, 50, 10, 10, 10] # 중복된 값을 넣어도 상관 없다.
print(l1)
print(type(l1))

l2 = ['a', 20, 1.2, True] # 다른 타입의 값들을 넣을 수 있다.
print(l2)

Indexing - 하나의 원소를 조회하거나 변경할 때 사용
Slicing - 범위로 조회하거나 그 범위의 값들을 변경한다. 리스트[시작 index : 종료 index : 간격] 

* reverse : 간격을 음수로 설정하면 가능하다. ex) 리스트[: : -1] => 마지막 index ~ 0번 index 까지 의미. Reverse 한다.

# indexing
print(l1[0], l1[-8]) # 양수 인덱스, 음수 인덱스 다 사용가능
print(l1[4], l1[-4])

# 변경이 가능하다.(mutable) <-> 문자열과의 차이
l1[0] = 1000
print(l1[0])

# 삭제 가능 -> 리스트의 원소들도 각각 하나의 변수 취급이기에 삭제도 일반 변수를 삭제하는 것처럼 del(피연산자).
del l1[1]

# 추가 -> 마지막 인덱스에 원소를 추가.
l1.append(10000)

# slicing
l2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l2[1:8:3] # 1번 인덱스에서 (8-1)번 인덱스까지 3의 간격 만큼 인덱스 증가 -> 1, 4, 7번 인덱스 조회

l2[::-1] # reverse

# 변경
l2[2:5] = [20, 30, 40]
l2[6:] = [1000, 2000] # 양 쪽의 요소의 개수가 달라도 된다. 이 문제의 경우 요소의 개수가 4개인 리스트의 일부를 2개의 요소로 변경

 

List 연산자 : - 리스트 + 리스트 = 두 리스트의 원소들을 합친 리스트를 반환 

(리스트1.extend(리스트2) = 리스트1에 리스트2가 합쳐진다)
- 리스트 * 정수 = 같은 리스트의 원소들을 정수번 합친 리스트를 반환 그 외 : in, not in, len(리스트)

l1 = [1, 2, 3]
l2 = [100, 200, 300, 400]
l3 = l1 + l2 # 두 리스트의 값을 합친 새로운 리스트를 생성.

중첩 리스트 : List의 원소로 List를 가지는 것 ex) 리스트[0][1] * 인덱스 두 번 사용한 경우이며, 세번 이상 중첩도 가능하다.

l1 = [1, 2, 3]
l2 = ['가', '나', '다', '라']
l3 = [l1, l2]

l3[0][1] # 이중 인덱스 활용

List 대입 : 리스트의 원소들을 각각 다른 변수에 대입하는 표현식(변수의 개수와 리스트 원소의 개수가 같아야 함)

v1, v2, v3 = [10, 20, 30] # 리스트를 이용해서 여러개의 변수를 간편하게 정의, 양쪽의 개수가 같아야함.

v11, v22, v33 = 1, 2, 3 # tuple 대입, 리스트 대입과 유사하다.

List 주요 메소드 : 형식 -> 리스트.메소드명(적합한 값), append, extend, sort, insert 등

Tuple - 순서(Index)가 있고 중복을 허용한다(List와 동일). Tuple은 변경불가 
튜플명 = (value, value, ...)등으로 표현, 괄호 생략 가능.
원소가 하나인 Tuple을 만들고 싶다면 튜플명 = (value, )처럼 Tuple 생성. 쉼표를 뒤에 붙이지 않으면 연산자 우선순위 괄호가 된다.
Indexing과 Slicing을 리스트와 동일하게 이용할 수 있지만 조회만 가능하고 변경할 수는 없다.

# 생성
t1 = (10, 20, 30, 40, 50) # ()로 감싼다.

t2 = 10, 20, 30, 40, 50, 60 # () 생략 가능

t3 = (10, 5.2, True, "abc") # 다른 타입들을 모을 수 있다.
t4 = 10, 5.2, True, "abc"

# 원소가 1개인 tuple -> 쉼표 활용
t6 = (30,)

# 양수/음수 index
print(t2[0],t2[-6])
print(t2[5],t2[-1])

t2[2] = 100 # 원소를 변경할 수 없다.
# 생성할 때 가지는 원소들을 변경할 수 없다. -> 불변의 타입(Immutable type)

t2[1:5] # Slicing

t2[::-1] # reverse
# 조회결과를 새로운 tuple에 넣어서 반환 -> t2 자체가 바뀌는 것이 아님.

Tuple 연산자 - tuple + tuple :두 tuple의 원소들을 합친 tuple을 반환한다.
tuple * 정수 : 같은 tuple의 원소들을 정수번 합친 tuple를 반환한다.
in, not in 연산자

- 값 in tuple : tuple의 원소로 값이 있으면 True, 없으면 False 반환
- 값 not in tuple : tuple의 원소로 값이 없으면 True, 있으면 False 반환
len(tuple) : tuple의 원소 개수 반환

t3 = t1 + t2
t3

10 in t2, 100 in t2

10 not in t2, 100 not in t2

len(t2), len(t3)

Dictionary - 키(key)-값(value)쌍으로 데이터를 관리, 순서는 중요하지 않다, key중복을 허용하지 않는다, value 중복가능
key-value 쌍으로 묶은 데이터 한개를 item 또는 entry라고 한다.
구문 : 1. { 키 : 값, 키 : 값, 키 : 값 }
2. dict(key=value, key=value) 함수 이용
키(key)는 불변(Immutable)의 값들만 사용 가능하다. (숫자, 문자열, 튜플) 일반적으로 문자열을 사용한다.
in, not in -> 연산자에서 dictionary의 key로 값이 있는지

# 첫 번째 생성 방법
fruits_counts = {"사과" : 100, "배" : 50, "수박" : 60, "귤" : 70}

# 두 번째 생성 방법
customer_info2 = dict(id = "id-1000", password = "eifoergji", name = "이순신")

Dictionary 원소 조회 및 변경 : 조회 - dictionary명[key명], 변경 - dictionary명[key명] = 변경할 값

변경시 없는 키 값일 경우 새로운 item을 추가한다.

# 원소 조회
fruits_counts["사과"]

# 원소 변경
fruits_counts["사과"] = 2 # 있는 key에 값을 할당 -> 변경

fruits_counts["바나나"] # 없는 키에 값을 할당 -> 추가

Dictionary 연산자 : - in, not in 연산자 -> key로 값이 있으면 True 없으면 False

len(dictionary) -> dictionary의 Item의 개수 반환

customer_info = {"name" : "홍길동", 
                 "age" : 20, 
                 "email" : "fegw.com", 
                 "address" : "서울",
                "hobby" : ["게임", "스포츠"]}
                
# in, not in은 key가 있는지/없는지 여부
"name" in customer_info

if "weight" in customer_info:
    print(customer_info["weight"]) # weight 키가 있으면 조회
else:
    print("몸무게 없음") # weight 키가 없으면 실행.

Dictionary 메소드 : 

get(key[, 기본값])  -> key의 item의 값을 반환한다. 단 key가 없을 경우 None또는 기본값을 반환한다.
pop(key) -> key의 item의 값을 반환하면서 dictionary에서 삭제한다. 없는 key일 경우 KeyError발생
clear() -> dictionary의 모든 item들을 삭제한다.
del dict[key] -> key의 item을 제거한다.
items() -> item의 key, value를 튜플로 묶어 모아 반환한다.
keys() -> key값들만 모아 반환한다.
values() -> value값들만 모아 반환한다.

customer_info.get("weight", -1) # -1 : default 값 -> weight 키가 없으면 반환될 값

v = customer_info.pop("address") # address의 값을 반환하면서 제거
print(v)
print(customer_info)

del customer_info["email"] # 삭제만

customer_info.keys() # key값들만 모아서 반환

customer_info.values() # value들만 모아서 반환

customer_info.items() # key, value를 tuple로 묶어서 반환.

Set - 중복 허용하지 않는다. 중복을 없애는 것이 목적이다. 순서는 의미가 없다. 식별자도 없다. -> index, slicing, key값이 없다.
구문 : {값, 값, 값 }, 원소 삽입시에 중복된 원소가 있을 경우 삽입되지 않는다.

# 생성
s1 = {1, 2, 3, 4, 5}

s2 = {1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4, 5, 5, 1, 2, 3, 4, 5} # 중복은 저장되지 않는다. -> unique value만 남는다.

s2[0] # 개별 원소를 조회할 수 없다. indexing 불가 (index가 없다.)

Set 연산자
in, not in 연산자
값 in Set -> Set의 원소로 값이 있으면 True, 없으면 False 반환
값 not in Set -> Set의 원소로 값이 없으면 True, 있으면 False 반환
len(Set) -> Set의 원소의 개수 반환

10 in s2, 1 in s2

10 not in s2, 1 not in s2

len(s2)

집합연산 연산자 및 메소드 : 
- 합집합 : 집합A | 집합B, 집합A.union(집합B)
- 교집합 : 집합A & 집합B, 집합A.intersection(집합B)
- 차집합 : 집합A - 집합B, 집합A.difference(집합B)

# set 생성
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 합집합
set3 = set1 | set2 # 두 셋을 합친 새로운 셋이 반환.
set4 = set1.union(set2)

# 교집합
set5 = set1 & set2
set6 = set1.intersection(set2)

# 차집합
set7 = set1 - set2
set8 = set1.difference(set2)

자료구조 변환 함수 (! dictionary로 바꿀 수는 없다.)
list(자료구조)
대상 자료구조/Iterable을 List로 변환한다.
tuple(자료구조)
대상 자료구조/Iterable을 Tuple로 변환
set(자료구조)
대상 자료구조/Iterable을 Set으로 변환
! 변경할 대상이 dictionary일 경우에는 key값들만 모아서 변환한다.

t = (1, 2, 3, 4, 5)
# t에 100을 추가: tuple -> list로 변환 -> 값을 추가 -> tuple로 변환
l = list(t)
l.append(100)
t = tuple(l)
t # immutable(불변)의 특징을 가지고 있는 tuple의 원소를 추가할 수 있다.

Iterable : 반복가능한 객체. 다음 값 달라는 요청받으면 값을 제공한다. 제공할 값을 다 줄 때까지 요청을 받을때 마다 순차적으로 하나씩 제공한다.
Iterable이 제공하는 값을 반복문을 이용해 조회할 경우 for in문을 사용한다. 대표적으로 자료구조, 문자열 등이 있다.

- 정리

 

자료구조 : 한개의 변수가 여러개의 값으로 구성되는 경우 ex) 고객의 정보 : 이름, 나이, 주소, 전화번호 등 여러 값이 모여 하나의 값이 된다. 이 때 자료구조(값들을 모아서 관리하는 것)을 이용한다.

파이썬에서의 자료구조 : list, tuple, dictionary, set
list, tuple : 데이터를 모았을 때 순서로 식별가능(데이터가 모두 같은 종류의 값)
tuple - immutable(불변), list - mutable(가변)
dictionary : 순서로 식별되지 않음 -> 각 값의 이름(key)로 식별
set : 중복된 값을 가질 수 없음, 순서가 없음(순서로 식별되지 않음)
len(자료구조) 함수 : 자료구조 내의 원소의 개수를 반환