03. 튜플형, 세트형, 사전형

03. 튜플 형, 세트 형, 사전 형

 

1.     튜플 형(Tuple Type)

A.     변경할 수 없는(Immutable) 리스트 형

                       i.         코드

>>> movie = '슈퍼맨II', 1980, '배트맨', 1989      #튜플 생성

>>> movie                                                 #튜플 값 확인

('슈퍼맨II', 1980, '배트맨', 1989)

>>> movie[1]                                              #튜플 2 번째 값 확인

1980

>>> movie[-2 : ]              #튜플 끝에서 2번째 값부터 끝까지 자르기

('배트맨', 1989)

>>> movie[1] = 1982       #튜플 2 번째 값 변경 시도(형 오류 발생)

Traceback (most recent call last):

  File "<pyshell#4>", line 1, in <module>

                             movie[1] = 1982

TypeError: 'tuple' object does not support item assignment

형 오류 : 튜플 형태는 변경 불가

 

                      ii.         튜플 형은 ‘서로 다른 종류의 데이터 형’으로 이루어진 항목들을 변수에 바로 풀어 쓰는 언패킹 혹은 색인을 매기는 용도로 사용

                     iii.         튜플 형을 선얼 할 때는 일반적인 리스트 형과 같이 [ ]로 데이터를 선언하는 것이 아닌 아무 것도 없는 상태 혹은 소괄호( )로 선언을 하게 된다.

B.     튜플 안의 리스트

                       i.         코드

>>> t2 = [1, 2, 3], [4, 5, 6]    #리스트 2개로 이루어진 튜플 선언

>>> t2                             #튜플 값 확인

([1, 2, 3], [4, 5, 6])

>>> t2[0] = [7, 8, 9]         #튜플 첫 번째 항목 값 변경 시도(오류)

Traceback (most recent call last):

 File "<pyshell#7>", line 1, in <module>

    t2[0] = [7, 8, 9]             

TypeError: 'tuple' object does not support item assignment

>>> t2[0][0] = 7               

>>> t2                                           #튜플 값 확인

([7, 2, 3], [4, 5, 6])

 

                      ii.         리스트 형의 데이터를 튜플 형태로 선언한다.

                     iii.         리스트 형의 데이터는 바꿀 수 있지만 리스트 자체를 바꿀 수는 없다.

 

C.     빈 튜플 혹은 항목이 하나 있는 튜플 생성 시 문법 주의

                       i.         코드

>>> empty = ( )                          #빈 튜플 생성() 대신 tuple() 사용 가능

>>> type(empty)                          #데이터 형 확인

<class 'tuple'>

>>> len(empty)                            #튜플 길이 확인

0

 

>>> empty2 = tuple()                    #tuple()로 빈 튜플 생성

>>> type(empty2)                           #데이터 형 확인

<class 'tuple'>

>>> len(empty2)                             #튜플 길이 확인

0

 

>>> singleton = '안녕하세요',        #항목이 하나인 튜플 생성(,콤마 필수)

>>> type(singleton)                      #데이터 형 확인

<class 'tuple'>

>>> len(singleton)                        #튜플 길이 확인

1

 

>>> test = ('안녕하세요')               #콤마 없이 항목 하나인 튜플 생성 시도

>>> type(test)                              #데이터 형 확인 (문자열 형)

<class 'str'>

>>> len(test)                                #길이 확인 (문자열 길이 반환)

5

 

D.     패킹(Packing)과 언패킹(Unpacking)

                       i.         패킹은 하나의 키워드로 데이터의 그룹을 만드는 것으로 생각하면 된다. 즉, 튜플을 생성 하는 것 자체가 패킹을 하는 것으로 봐도 무관하다.

 

                      ii.         언패킹 코드

>>> movie = '슈퍼맨II', 1980, '배트맨', 1989      #튜플 생성

>>> a, b, c, d = movie                      #튜플 항목별 할당(Unpacking)

>>> a

'슈퍼맨II'

>>> b

1980

>>> c

'배트맨'

>>> d

1989

 

                     iii.         언 패킹은 튜플형태의 데이터들을 변수 하나 하나에 저장시키는 것이다.

데이터 수에 맞지 않을 때 : 

ValueError: too many values to unpack (expected 2)

 

                     iv.         튜플 ↔ 리스트 각각의 형 변환

>>> movie_list = list(movie)              #튜플→리스트 형 변환

>>> type(movie_list)                         #데이터 형 확인

<class 'list'>

>>> movie_list                            #데이터 값 확인(대괄호 기호 확인)

['슈퍼맨II', 1980, '배트맨', 1989]

>>> tuple(movie_list)           #리스트→튜플 형 변환(소괄호 기호 확인)

('슈퍼맨II', 1980, '배트맨', 1989)

 

2.     세트 형(Set Type) 혹은 집합 형

A.     색인에 의한 순서가 없으며 중복이 허용되지 않는 데이터 들의 집합

B.     { }중괄호 형태로 선언하지만, 중괄호 기호 만으로는 선언이 불가능한 부분도 있기 때문에 set( )라는 함수를 이용한다.

C.     빈 세트형은 생성은 반드시 set( ) 함수로만 가능하다.

                       i.         in 키워드를 이용한 소스 코드

>>> lang = {'java', 'java', 'python', 'c++', 'python'}    

#세트 형 생성

>>> lang                                                                   

#세트 형 값 확인(중복 제거 확인)

{'c++', 'python', 'java'}

>>> 'java' in lang                                          

#항목 존재 유무 확인

True

>>> 'javascript' in lang                                  

 #항목 존재 유무 확인

False

 

                      ii.         연산자를 이용한 집합 이용 소스 코드

>>> a = set('abracadabra')   #세트형 변환을 통한 중복 문자 제거

>>> a                                            #중복 문자 제거 확인

{'c', 'a', 'd', 'r', 'b'}

 

>>> b = set('alacazam')                    

#세트형 변환을 통한 중복 문자 제거

>>> b                                            

#중복 문자 제거 확인

{'z', 'c', 'a', 'l', 'm'}

>>> a - b                                      

 #a에만 존재하는 문자(차집합)

{'r', 'd', 'b'}

 

>>> a | b                                       #a와 b의 합집합

{'z', 'c', 'a', 'd', 'r', 'l', 'm', 'b'}

 

>>> a & b                                      #a와 b의 교집합

{'c', 'a'}

 

>>> a ^ b                                      

#a와 b의 여집합 (합집합 - 교집합)

{'z', 'r', 'l', 'm', 'd', 'b'}

 

3.     사전형(Dictionary Type)

A.     전체 항목이 정렬되지 않은 키(Key)와 값(Value)의 쌍으로 구성된 집합

B.     변수명 = { ‘키(Key)’ : 값(Value), ‘키2(Key)’ : 값2(Value)…}

                       i.         기본 소스 코드

>>> balls = { 'red' : 4, 'blue' : 3, 'green' : 5}            #사전형 생성

>>> balls               #값 확인

{'red': 4, 'blue': 3, 'green': 5}

>>> type(balls)                      #데이터형 확인

<class 'dict'>

>>> len(balls)                       #사전형 길이 확인

3

 

                      ii.         사전형의 값 추가 및 삭제

>>> balls[ 'black' ] = 1       #검은 공 항목 추가

>>> balls                          #사전 값 확인(검은 공 추가)

{'red': 4, 'blue': 3, 'green': 5, 'black': 1}

>>> del balls[ 'green' ]        #녹색 공 항목 제거

>>> balls                          #사전 값 확인(녹색 공 제거)

{'red': 4, 'blue': 3, 'black': 1}

 

                     iii.         값 변경

>>> balls[ 'black' ] = 3      

 #기존 검은색 공 값 변경

>>> balls                         

 #사전 값 확인(검은색 공 1 → 3 변경)

{'red': 4, 'blue': 3, 'black': 3}

 

                     iv.         키의 리스트형 keys( ), 값의 리스트형 values( ), 각각의 정렬 sorted( )

>>> list(balls.keys())           #사전 키 추출 후 리스트형 변환

['red', 'blue', 'black']

>>> sorted(balls.keys())      #사전 키 추출 후 오름차순 정렬

['black', 'blue', 'red']

>>> list(balls.values())         #사전 값 추출 후 리스트형 변환

[4, 3, 3]

>>> sorted(balls.values())    #사전 값 추출 후 오름차순 정렬

[3, 3, 4]

 

                      v.         항목 존재 유무 확인

>>> 'blue' in balls #키 존재 유무 확인

True

>>> 'white' not in balls       #키 누락 유무 확인

True

>>> 'white' in balls             #키 존재 유무 확인

False

 

                     vi.         사전형으로의 형 변환 dict( )함수

>>> dict( [ ( 'brown', 3 ), ( 'gray', 7 ) ] )

#리스트 안의 항목이 키와 값의 쌍으로 이루어진 튜플인 경우

{'brown': 3, 'gray': 7}

>>> dict (brown = 3, gray = 7)

#키가 단순한 문자열인 경우, dict 함수의 인자값 형태로 진행

{'brown': 3, 'gray': 7}

 

 

4.     Wrap – up

 

 

>>> #리스트 생성 예제, 변경 가능, 중복 허용

>>> pockets = [4, 6, 1, 9]

>>> #튜플 생성 예제, 변경 불가, 중복 허용

>>> movie = '슈퍼맨II', 1980, '배트맨', 1989

>>> #세트 생성 예제, 변경 가능, 중복 불가

>>> color = { 'red', 'red', 'blue', 'green', 'blue'}

>>> color

{'blue', 'red', 'green'}

>>> #사전형 생성 예제, 변경 가능, 중복 불가

>>> balls = { 'red' : 4, 'blue' : 3, 'green' : 5}