#02 컬렉션 자료형

함수와 메소드

함수

• 코드의 반복을 줄이거나 어떠한 기능을 하기 위해 특정 코드를 모아둔 것

s = "ABCD" 
len(s) # 단독으로 동작 => 함수 
>>> 4

메소드

• 객체(값)에 소속되어 있는 함수

s.lower() # 객체에 붙어서 동작 => 메소드
>>> 'abcd'

컬렉션 자료형(Colleciton data type)

• 여러가지 요소를 하나로 묶어서 담을 수 있는 데이터 타입
  • 문법적인 요소들을 빼고 다 담을 수 있음
  • 객체, 변수, 함수, 클래스 등 모두
  • list, set, dict, tuple

자료형의 특징

Sequence 자료형 - 연속, 열거되어 있음 - 순서, 순번(index)이 있음	Non-Sequence 자료형 - 연속, 열거되어 있지않음 - 순서, 순번(index)이 없음
Mutable 자료형 - 수정이 가능한 객체(값) - ex) 컬렉션 자료형 중 list, set, dict	Imutable 자료형 - 수정이 불가능한 객체(값) - ex) int, float, str, bool, 컬렉션 자료형 중 tuple

List

• Sequence 자료형
• Mutable 자료형
• 중복 데이터 저장 가능
• [ ]를 이용해서 만듦

lst = [1, 2, 3, 3, ["four", None, True, 0.4231]]
lst
>>> [1, 2, 3, 3, ['four', None, True, 0.4231]]

type(lst)
>>> list

len(lst)
>>> 5

lst = [11, 200, 7, 9, 10]
sorted(lst, reverse=False) # False : 내림차순 / True : 오름차순
>>> [200, 11, 10, 9, 7]

max(lst) / min(lst) / sum(lst) # 최대 / 최소 / 평균

Sequence 다루기

• Sequence는 순번(index)이 있음
• 파이썬의 index는 2종류가 있음
  • 양수 index : 0부터 시작, 왼쪽에서 오른쪽으로 1씩 증가
  • 음수 index : -1부터 오른쪽에서 왼쪽으로 1씩 감소
• index는 무조건 정수로 입력해야 함

lst = [1, 2, 3, 3, ["four", None, True, 0.4231]]
lst
>>> [1, 2, 3, 3, ['four', None, True, 0.4231]]

lst[0]
>>> 1

lst[4]
>>> ['four', None, True, 0.4231]

lst[-2]
>>> 3

lst[-1]
['four', None, True, 0.4231]

슬라이싱(Slicing)

• index를 사용해서 Sequence를 잘라냄
• Sequence에서 특정 범위를 가리킴
• [start:end:step]
  • start부터 end-1까지의 부분을 step만큼 건너뛰면서 잘라냄
  • start, end, step은 생략이 가능
  • start를 생략하면 자동으로 0이 들어감
  • end를 생략하면 자동으로 Sequence의 길이(len(list))가 들어감
  • step을 생략하면 자동으로 1이 들어감
  • step은 양수(정방향)와 음수(역방향)를 이용해서 방향 설정이 가능함

lst = ["a", "b", "c", "d", "e", "f", "g"]
lst
>>> ['a', 'b', 'c', 'd', 'e', 'f', 'g']

lst[0:3]
>>> ['a', 'b', 'c']

lst[2:4]
>>> ['c', 'd']

lst[-3:-1]
>>> ['e', 'f']

lst[:] # = lst[0:len(lst)]
['a', 'b', 'c', 'd', 'e', 'f', 'g']

lst[3:]
>>> ['d', 'e', 'f', 'g']

lst[:5]
>>> ['a', 'b', 'c', 'd', 'e']

lst[-5:]
>>> ['c', 'd', 'e', 'f', 'g']

lst[:-1]
>>> ['a', 'b', 'c', 'd', 'e', 'f']

lst[::] # = lst[0:len(lst):1]
>>> ['a', 'b', 'c', 'd', 'e', 'f', 'g']

lst[0::2]
>>> ['a', 'c', 'e', 'g']

lst[::-2]
>>> ['g', 'e', 'c', 'a']

lst[::-1] # 역방향 정렬
>>> ['g', 'f', 'e', 'd', 'c', 'b', 'a']

lst = [10, 20, 30, 40, 50, 60, 70]
lst
>>> [10, 20, 30, 40, 50, 60, 70]

lst[-1:-5:-1]
>>> [70, 60, 50, 40]

lst[-2:-6:-1]
>>> [3, 2, 1, 0]

lst[5:1:-1]
>>> [60, 50, 40, 30]

num_list = [2, 3, 4, 5, 6, 7, 8, 9, 10 ,11, 12, 13, 14, 15]
num_list[1:-6:3] # 10보다 작은 3의 배수만 오름차순으로 슬라이싱
>>> [3, 6, 9]

num_list = [2, 3, 4, 5, 6, 7, 8, 9, 10 ,11, 12, 13, 14, 15]
num_list[-7::-3] # 10보다 작은 3의 배수만 내림차순으로 슬라이싱
>>> [9, 6, 3]

List는 변경 가능

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst[1] = 10000
lst
>>> [1, 10000, 3, 4, 5, 6, 7, 8, 9, 10]

lst[:1] = 3 # 슬라이싱 -> List 반환. List와 int를 비교해서 에러 발생
>>> TypeError: can only assign an iterable

lst[1:] = [3] # 길이가 달라도 List에 List를 담는 것은 가능
lst
>>> [1, 3]

lst[1:] = [1001, 1002, 1003, 1004]
lst
>>> [1, 1001, 1002, 1003, 1004]

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

lst[1::2] = [0] # 연속적인 공간이 아닌 List가 슬라이싱 되면 수정이 안됨
>>> ValueError: attempt to assign sequence of size 1 to extended slice of size 5

List의 다양한 메소드

• .append() : list의 제일 뒤에 값을 추가
• .sort() : list를 오름차순으로 정렬
• .pop() : 제일 뒤에 있는 데이터를 꺼내고 삭제, index값을 줄 경우 해당 index값을 꺼내고 삭제
• .extend() : list와 list를 합침
• .insert() : index의 위치에 값을 추가
• .remove() : list에서 값을 찾아 삭제
  • 키워드 del : list의 경우 특정 index값을 삭제

lst = [1, 2, 3, 4]
lst.append(0)
lst
>>> [1, 2, 3, 4, 0]

sorted(lst)
>>> [0, 1, 2, 3, 4]

lst
>>> [1, 2, 3, 4, 0]

lst.sort() # sorted()와의 차이점 : .sort()는 변환된 값을 반환
lst
>>> [0, 1, 2, 3, 4]

print(lst.pop())
lst
>>> 4
[0, 1, 2, 3]

print(lst.pop())
lst
>>> 3
[0, 1, 2]

lst.pop(1)
lst
>>> [0, 2]

lst = [1, 2, 3]
lst.extend([4, 5, 6])
lst # List가 합쳐짐
>>> [1, 2, 3, 4, 5, 6]

lst = [1, 2 ,3]
lst.append([4, 5, 6])
lst # List 안에 하나의 객체로 들어감
>>> [1, 2, 3, [4, 5, 6]]

lst = [1, 2, 3]
lst.insert(0,9)
lst
>>> [9, 1, 2, 3]

lst = [10, 20, 30]
lst.remove(20)
lst
>>> [10, 30]

lst = [10, 20, 30]
del lst[1]
lst
>>> [10, 30]

# Quiz 1. 다음의 리스트에서 앞에서부터 하나씩 꺼내 값을 출력하면서 모든 값을 꺼내시오
# lst = [1, 2, 3, 4]
# 내 답안
lst = [1, 2, 3, 4]
while 0 < len(lst) < 5:
    print(lst.pop(0))
lst
>>> 1
2
3
4
[]

# Quiz 2, 다음의 리스트에서 2의 배수만 내림차순으로 슬라이싱 하시오
# num_list = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
# num_list
# 내 답안
num_list = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
num_list[-2::-2]
>>> [14, 12, 10, 8, 6, 4, 2]

# Quiz 3. 다음의 리스트에서 sort 메소드와 인덱싱만을 이용하여 최대값과 최솟값을 구하시오
# num_list = [6, 7, 8, 9, 10, 11, 12, 13, 14 ,15 ,2 ,3 ,4, 5]
# num_list
# 내 답안
num_list = [6, 7, 8, 9, 10, 11, 12, 13, 14 ,15 ,2 ,3 ,4, 5]
num_list.sort()
num_list[-1], num_list[0]
>>> (15, 2)

연산자를 이용한 List를 조작

• 하나의 요소를 추가할 때는 .append() 메소드가 더 빠르고, 리스트끼리 합칠 때는 +가 조금 더 빠름

list1 = [1, 2, 3]
list2 = [4, 5, 6] 
list1 + list2 
>>> [1, 2, 3, 4, 5, 6]

list1 + [2] # 원본 데이터의 수정X
>>> [1, 2, 3, 2]  
list1.append(2) # 원본 데이터의 수정O  
>>> [1, 2, 3, 2]

list1 * 3
>>> [1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2]

2 in list1
>>> True

1004 not in list1
>>> True

list1 == [1, 2, 3, 4, 5, 6]
>>> False

list1 == [1, 2, 3, 2] # 각 index 위치에 맞는 요소의 값을 검사
>>> True

list1 != [1, 2, 3, 2]
>>> False

is 연산자와 is not 연산자

• 같은 객체인지 아닌지 검사
• 어떠한 연산결과로 나온 변수의 값을 True인지 False인지 None값을 체크할 때 주로 is와 is not 연산자를 사용

lst = [1, 2, 3]

lst is [1, 2, 3]
>>> False

tmp = lst
tmp is lst
>>> True

tmp is not lst
>>> False

is_num = True
is_num is True
>>> True

data_list != None
data_list is not None
>>> False

Tuple

• Sequence 자료형
• imutable 자료형 : 변경 불가능 => list에 비해 메모리 적게 차지, 속도 빠름
• 중복 데이터 저장 가능
• ( )를 이용해서 만듦 (생략 가능)
• 프로그램이 실행되는 동안 튜플은 안에 있는 요소들이 변경이 일어나면 안되는 경우 사용

tuples = ()
tuples
>>> ()

type(tuples)
>>> tuple

tuples = "h", "e", "l", "l", "o"
tuples
>>> ('h', 'e', 'l', 'l', 'o')

tuples[::-1]
>>> ('o', 'l', 'l', 'e', 'h')

a = 1
b = 2
a, b
>>> (1, 2)

tuples[0] = "j" # 변경 불가능
>>> TypeError: 'tuple' object does not support item assignment

tuples.count("l") # 인자로 넣은 값이 몇 개 있는지 반환
>>> 2

tuples + tuples
>>> ('h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o')

tuples * 3
>>> ('h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o', 'h', 'e', 'l', 'l', 'o')

"h" in tuples
>>> True

"d" not in tuples
>>> True

tuples is not tuples * 3
>>> True

# 슬라이싱 복습
# 다음의 tuple에서 슬라이싱을 활용하여 짝수만 출력
# num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
num_tuple[1::2]
>>> (2, 4, 6, 8, 10)

# 짝수를 역순으로 출력
num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
num_tuple[::-2]
>>> (10, 8, 6, 4, 2)

# 함수 복습
# num_tuple의 최댓값, 최솟값, 합계, 튜플 안의 요소 개수를 출력
num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
max(num_tuple), min(num_tuple), sum(num_tuple), len(num_tuple)
>>> (10, 1, 55, 10)

sorted(num_tuple, reverse = True)
>>> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Set

• Non-Sequence 자료형 : 데이터의 저장 순서를 보장하지 않음 => 인덱싱과 슬라이싱, 산술 연산 지원하지 않음
• Mutable 자료형 : 변경 가능
• 중복 데이터 저장 불가능
• { }를 이용해서 만듦

sets = {} # 이렇게 만들면 dict가 만들어짐
type(sets)
>>> dict

sets = set()
type(sets) # 빈 set은 함수를 이용해서 생성
>>> set

sets = {1001, 1002, 1003, 1001, 1001, 11, 131, 1004, 15, 1003, 1005}
sets
>>> {11, 15, 131, 1001, 1002, 1003, 1004, 1005}

sorted(sets, reverse = True)
>>> [1005, 1004, 1003, 1002, 1001, 131, 15, 11]

1001 in sets
>>> True

11 not in sets
>>> False

Set의 다양한 메소드

• .intersection() : 교집합
• .union() : 합집합
• .difference() : 차집합
• .add() : 하나의 값을 더함
• .update() : 여러 값을 더함
• .remove() : 특정 값을 제거

A = {1, 2, 3}
B = {2, 3, 4}
A, B
>>> ({1, 2, 3}, {2, 3, 4})

A.intersection(B) # 교집합
>>> {2, 3}

A.union(B) # 합집합
>>> {1, 2, 3, 4}

A.difference(B) # 차집합
>>> {1}

a = {1, 2, 3}
a.add(100)
a
>>> {1, 2, 3, 100}

a = {1, 2, 3}
a.add(1) # 중복값은 추가해도 변화 X
a
>>> {1, 2, 3}

a.update([4, 5, 6, 7, 8, 9, 10])
a
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

a.remove(4)
a
>>> {1, 2, 3, 5, 6, 7, 8, 9, 10}

dict

• Non-Sequence 자료형
• Mutable 자료형
• key-value 구조
• key는 중복을 허용하지 않음, value는 중복 허용
• { key : value, key : value, key : value, ... }

city = {}
type(city)
>>> dict

city = {
    "한국" : "부산",
    "일본" : "교토",
    "캐나다" : "오타와"
}
city
>>> {'일본': '교토', '캐나다': '오타와', '한국': '부산'}

city["한국"] # dict의 값을 가져올 땐 key를 활용
>>> '부산'

city["중국"] # 없는 key의 value를 가져오려 하면 에러
>>> KeyError: '중국'

dict의 다양한 메소드

• .get() : key의 유무를 안전하게 확인 가능
• .update() : 여러 개의 key와 value 값을 수정
• .pop() : 삭제하고자 하는 key를 제거, value를 반환
• .keys() : dict 내의 key 값들만을 확인
• .values() : dict 내의 value 값들만을 확인
• .items() : dict 내의 key와 value 값들을 확인

city.get("중국") # .get() 메소드를 사용해서 없는 key여도 에러가 발생하지 않음 => 안전

city.get("중국", "없음") # 중국이라는 key가 없을 경우 '없음'이라는 value 반환
>>> '없음'

city["중국"] = "베이징" # 중국 key가 없으니 key와 value가 추가됨
city
>>> {'일본': '교토', '중국': '베이징', '캐나다': '오타와', '한국': '부산'}

city["일본"] = "도쿄" # 일본 key의 value 수정
city
>>> {'일본': '도쿄', '중국': '베이징', '캐나다': '오타와', '한국': '부산'}

add_city = {"중국" : "상하이", "미국" : "워싱턴"}
city.update(add_city) # .update() 메소드로 여러개의 key와 value를 추가 또는 수정
city
>>> {'미국': '워싱턴', '일본': '도쿄', '중국': '상하이', '캐나다': '오타와', '한국': '부산'}

del city["일본"] # key가 일본인 key와 value 쌍을 삭제
city
>>> {'미국': '워싱턴', '중국': '상하이', '캐나다': '오타와', '한국': '부산'}

print(city.pop("중국")) # 삭제하고자 하는 key를 넣어 삭제, 해당 key의 value가 반환
city
>>> 상하이
{'미국': '워싱턴', '캐나다': '오타와', '한국': '부산'}

city.keys() # dict 내 key 값만 확인
>>> dict_keys(['한국', '캐나다', '미국'])

city.values() # dict 내 value 값만 확인
>>> dict_values(['부산', '오타와', '워싱턴'])

city.items() # dict 내 전체 key, value 값을 확인
>>> dict_items([('한국', '부산'), ('캐나다', '오타와'), ('미국', '워싱턴')])

"부산" in city.keys()
>>> False

("한국", "부산") in city.items()
>>> True

"일본" not in city
>>> True

"미국" not in city.values()
>>> True

num_dict = {
    0 : "제로",
    3.14 : "원주율"
}
num_dict[0], num_dict[3.14]
>>> ('제로', '원주율')

info_dict = {
    "name" : "bleck",
    "age" : 26,
    "score" : {
        "Python" : 99,
        "C+" : 99,
        "Java" : 99,
        "R" : 99,
        "JS" : 99
    },
    "etc" :{
        "my_dream" : "developer"
    }
}
info_dict
>>> {'age': 26,
 'etc': {'my_dream': 'developer'},
 'name': 'bleck',
 'score': {'C+': 99, 'JS': 99, 'Java': 99, 'Python': 99, 'R': 99}}
 >>> {'age': 26,
 'etc': {'my_dream': 'developer'},
 'name': 'bleck',
 'score': {'C+': 99, 'JS': 99, 'Java': 99, 'Python': 99, 'R': 99}}

 num_dict = {
    "mean" : 80,
    "std" : 3.5
}
# mean의 키를 avg라는 키로 .pop() 메소드를 이용하여 변경
num_dict["avg"] = num_dict.pop("mean")
num_dict
>>> {'avg': 80, 'std': 3.5}

grade = {
    "지원" : 100,
    "철수" : 80,
    "민수" : 70,
    "민영" : 60.5
}
grade
>>> {'민수': 70, '민영': 60.5, '지원': 100, '철수': 80}

grade["영희"]
>>> KeyError: '영희'

grade.get("영희", "결시")
>>> '결시'

컬렉션 자료형 변환

• list <=> tuple

lst = [1, 2, 3]
tuple(lst)
>>> (1, 2, 3)

tup = 1, 2, 3
list(tup)
>>> [1, 2, 3]

• set <=> list

sets = {"Apple", "Banana", "Mango"}
list(sets)
>>> ['Apple', 'Banana', 'Mango']

lst = ["Korea", "America", "Canada"]
set(lst)
>>> {'America', 'Canada', 'Korea'}

• set <=> list

city ={
    "한국" : "서울",
    "일본" : "도쿄",
    "미국" : "워싱턴"
}
list(city)
>>> ['한국', '일본', '미국']

set(city.values())
>>> {'도쿄', '서울', '워싱턴'}

set(city.items())
>>> {('미국', '워싱턴'), ('일본', '도쿄'), ('한국', '서울')}

tup_list = list(city.items())
tup_list
>>> [('한국', '서울'), ('일본', '도쿄'), ('미국', '워싱턴')]

dict(tup_list) # list를 key-value 형식의 dict로 변환
>>> {'미국': '워싱턴', '일본': '도쿄', '한국': '서울'}

text = "hello"
list(text) # 문자열을 list로 변환
>>> ['h', 'e', 'l', 'l', 'o']

set(text)
>>> {'e', 'h', 'l', 'o'}

lst = [1, 2, 3, [1, 3, 5]]
sett = {1, 2, 3, 4, 5}
dic = {"1" : "사과", "2" : "과일"}
tup = (1, 2, 3, 4 ,5)
print(lst, sett, dic, tup)
>>> [1, 2, 3, [1, 3, 5]] {1, 2, 3, 4, 5} {'1': '사과', '2': '과일'} (1, 2, 3, 4, 5)