파이썬 (python) 자료형

 

---

자료 형

---

자료형 마다 부여된 성질을 이해해야 한다.

Sequence(연속적인 값이 이어진 형태)/집합/매핑 → Iterable(for문으로 순차접근 가능)

Literal(상수) → Immutable(변경불가능)

str(문자열) → Literal(상수) 이면서 Iterable(순차접근 가능)한 특수한 형태.

자료형	Iterable	Literal / Container	Mutable / Immutable
int	X	Literal	Immutable
float	X	Literal	Immutable
list	O	Container (Sequence)	Mutable
tuple	O	Container (Sequence)	Immutable
range	O	Container (Sequence)	Immutable
str	O	Literal (Sequence)	Immutable
bytes	O	Literal (Sequence)	Immutable
byte array	O	Container (Sequence)	Mutable
set	O	Container (Set)	Mutable
frozenset	O	Container (Set)	Immutable
dict	O	Container (Mapping)	Mutable

데이터 저장 방식에 따른 분류

   - Literal 형 : 변경불가한 단일 데이터

   - Container 형 : 여러가지 객체를 내부에 저장

      - Sequence 형 : 순서있는 복수 데이터모음

      - Set 형 : 순서, 중복없는 복수 데이터모음

      - Mapping 형 : key:value를 1대1 매핑한 복수 데이터모음 (key는 중복x)

 

변경 가능성에 따른 분류

   - 변경 가능(Mutable)    : 데이터 변경이 가능한 성질 (데이터 추가/삭제 등의 메소드 존재)

   - 변경 불가(Immutable) : 데이터 변경 불가능한 성질. 변경되는 것 처럼 보이지만, 실제로는 새 객체 만들어짐.

 

이터러블(Iterable)

다음 요소에 순차적으로 접근하여 조회 가능한 형태 (반복문 사용가능)

Iterable은 for문에서 iterator object로 변환되어 순차 접근 가능한 객체로 이용됨

파이썬(python) - 이터레이션 형 (Iteration)

---

숫자 형 (Numeric)

int, float, complex

---

int 정수형 (Literal / Immutable)

정수 표현범위의 제한이 없음. Big Integer 문제풀기 좋음.

x의 y제곱을 나타내는 ** 연산자
a = 3
b = 4
a ** b = 81

나눗셈 후 몫을 반환하는 // 연산자
7 / 4 = 1.75 (나눈 값)
7 // 4 = 1   (몫)
7 % 4 = 3    (나머지)
divmod(a,b) = (몫,나머지)
divmod(5,2) = (2,1)

bool 불리언 

int 의 하위에 속하는 자료형.

1=True, 0=False를 나타냄. 기본값은 0.

 

float 실수형 (Literal / Immutable)

부동소수점 나타기 위한 자료형

import math
math.ceil()     : 올림
math.floor()    : 내림

round(float, n) : 반올림 소수점 n+1자리에서 반올림하여 n자리까지 나타냄

 

---

시퀀스 형 (Sequence)

(list, tuple, range, str, bytes, bytearray)

 

여러 객체 저장하는 자료형. 자료구조의 성격을 띄며, 순서가 있다. (index로 참조가능)

---

 

공통 시퀀스 연산  (Sequence)

	연산	결과
포함여부	x in s	s 의 항목 중 하나가 x 와 같으면 True, 그렇지 않으면 False
미포함여부	x not in s	s 의 항목 중 하나가 x 와 같으면 False, 그렇지 않으면 True
연결	s + t	s 와 t 의 이어 붙이기
반복	s * n 또는 n * s	s 를 그 자신에 n 번 더하는 것과 같습니다
인덱싱	s[i]	s 의 i 번째 항목, 0에서 시작합니다
슬라이스	s[i:j]	s 의 i 에서 j 까지의 슬라이스
슬라이스	s[i:j:k]	s 의 i 에서 j 까지 스텝 k 의 슬라이스 k는 몇개씩 끊어서 가져올지를 말함. a=['a','b','c','d','e'] a[::2] : ['a','c','e'] a[::-1] : ['e','d','c','b','a']
길이	len(s)	s 의 길이
최소값	min(s)	s 의 가장 작은 항목
최대값	max(s)	s 의 가장 큰 항목
인덱싱	s.index(x[, i[, j]])	(인덱스 i 또는 그 이후에, 인덱스 j 전에 등장하는) s 의 첫 번째 x 의 인덱스
개수	s.count(x)	s 등장하는 x 의 총수

 

가변 시퀀스 연산 (Sequence and Mutable)

list, set, bytearray

	연산	결과
변경	s[i] = x	s 의 항목 i 를 x 로 대체합니다
변경	s[i:j] = t	i 에서 j 까지의 s 슬라이스가 이터러블 t 의 내용으로 대체됩니다
변경 (삭제)	del s[i:j]	s[i:j] = [] 와 같습니다
변경	s[i:j:k] = t	s[i:j:k] 의 항목들이 t 의 항목들로 대체됩니다
변경 (삭제)	del s[i:j:k]	리스트에서 s[i:j:k] 의 항목들을 제거합니다
추가	s.append(x)	시퀀스의 끝에 x 를 추가합니다 (s[len(s):len(s)] = [x] 와 같습니다)
변경 (삭제)	s.clear()	s 에서 모든 항목을 제거합니다 (del s[:] 와 같습니다)
복사	s.copy()	s 의 얕은 복사본을 만듭니다 (s[:] 와 같습니다)
확장	s.extend(t) 또는 s += t	t 의 내용으로 s 를 확장합니다 (대부분 s[len(s):len(s)] = t 와 같습니다)
반복	s *= n	내용이 n 번 반복되도록 s 를 갱신합니다
삽입	s.insert(i, x)	x 를 s 의 i 로 주어진 인덱스에 삽입합니다 (s[i:i] = [x] 와 같습니다)
조회&삭제	s.pop([i])	i 에 있는 항목을 꺼냄과 동시에 s 에서 제거합니다
삭제	s.remove(x)	s[i] 가 x 와 같은 첫 번째 항목을 s 에서 제거합니다
뒤집기	s.reverse()	제자리에서 s 의 항목들의 순서를 뒤집습니다

 

 

---

리스트 형 (list)

(Sequence / Container / Mutable)

---

list  리스트형 (Sequence / Container / Mutable)

class list([iterable])

• 대괄호를 사용하여 빈 리스트를 표시하기: []
• 대괄호를 사용하여 쉼표로 항목 구분하기: [a], [a, b, c]
• 리스트 컴프리헨션 사용하기: [x for x in iterable]
• 형 생성자를 사용하기: list() 또는 list(iterable)

 

리스트의 각 요소끼리 더하기

[1,2,3] + [4,5,6] = [1,2,3,4,5,6] 이다.

각 요소끼리 더하고 싶을땐 아래와 같이 map함수와 operator 사용

import operator
new_arr[n] = list(map(operator.add, [1,2,3], [4,5,6]))
[5,7,9]

---

튜플 형 (tuple)

(Sequence / Container / Immutable)

---

tuple 튜플형 (Sequence / Container / Immutable)

class tuple([iterable])

값 변경할 필요 없는 다양한 데이터 유형 다루는데 사용 

• 괄호를 사용하여 빈 튜플을 나타내기: ()
• 단일 항목 튜플을 위해 끝에 쉼표를 붙이기: a, 또는 (a,)
• 항목을 쉼표로 구분하기: a, b, c 또는 (a, b, c)
• 내장 tuple() 사용하기: tuple() 또는 tuple(iterable)

---

range

(Sequence / Immutable)

---

range (Sequence)

범위 생성자. 표현 범위와 무관하게 같은 메모리 사용하는 것이 장점.

class range(stop)

class range(start, stop[, step])

r = range(0, 20, 2)
>>> r
range(0, 20, 2)

보통 list로 변환해서 사용해야 함.
list(range(10)) = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 

 

---

 

텍스트 시퀀스 형 (str)

(Sequence / Literal / Immutable)

---

str 텍스트 시퀀스 형 (Sequence / Literal / Immutable)

문자열 만드는 방법 (문자열은 한번 만들면 수정 불가)
1. "내용"
2. '내용'
3. """내용"""
4. '''내용'''


문자열 안에 작은따옴표나 큰따옴표를 포함시키고 싶을 때
1. 문자열 안에 ' 포함         : " A'B "
2. 문자열 안에 " 포함         : ' A"B '
3. \' (특수문자 앞에 \붙이기) : ' A\'B '
→ \를 문자의 일부로 사용하고 싶을땐 raw string 사용 : print(r'C:\some\name')



여러 줄인 문자열을 변수에 대입하고 싶을 때
1. 줄을 바꾸기 위한 이스케이프 코드 \n 삽입         : " ABC\nABC "
2. 연속된 작은따옴표 3개(''') 또는 큰따옴표 3개(""") 사용
multiline='''
... Life is too short
... You need python
... '''

multiline="""
... Life is too short
... You need python
... """

>>> multiline: "\n... Life is too short\n... You need python\n... "
주의점 : 위와같이 하면 맨앞에 \n이 들어간다. 
이를 방지하려면 아래와 같이 첫줄에 \를 붙임.

multiline="""\
... Life is too short
... You need python
... """

 

문자열 연산하기

문자열 연결하기 : + 연산자
head = "Python"
tail = " is fun!"
head + tail
'Python is fun!'

혹은 'Python' 'is fun' : 이렇게 해도 이어짐. (긴 문자열 보기좋게 쪼갤때 유용)
변수 '문자열'           : 이건 안됨.
    
   
문자열 반복 : * 연산자
*가 문자열을 만났을 땐 문자열을 n번 반복하라는 의미로 쓰인다
a = "python"
a * 2
'pythonpython'




a = "Life is too short, You need Python"
Life is too short, You need Python
0         1         2         3 
0123456789012345678901234567890123

문자열 인덱싱
a[0]  : 'L'
a[-1] : 'n'   : 음수는 끝에서 부터 카운트한다.

문자열 슬라이싱 [시작:끝] = [Inclusive:Exclusive]
a[0:4] : 'Life'
a[19:] : 'You need Python'   (끝번호 생략하면 마지막까지)
a[:17] : 'Life is too short' (시작번호 생략하면 처음부터)
a[19:-7] : 'You need'        (음수 역시 가능)
a[-2:] : 'on'
a[999:] : ''                 (범위 벗어나면 부드럽게 처리)
a[:999] : 'Life is too short, You need Python' (범위 벗어나면 부드럽게 처리)
a[999] : ERROR발생!!         (인덱스는 범위 벗어나면 ERROR)

문자열 메서드

길이
len() : 문자열의 길이 반환 (문자열 아니더라도 공통 사용되는 연산임)


찾기
str.startswith(prefix, start, end) : prefix시작하면 True (start(0부터), end로 범위지정)
str.endswith(suffix, start, end)   : suffix로 끝나면 True (start(0부터), end로 범위지정)
str.find(sub, start, end)
부분문자열의 인덱스 반환. 못찾으면 -1 반환
- 사용가능  : 문자열
- 사용불가  : 리스트, 튜플, 딕셔너리 자료형
- in 연산자 : 부분문자열이 포함되었는지 확인 (찾을문자 in 문자열) 있으면 True
str.index(sub, start, end)
find와 유사. 부분문자열 못찾으면 ValueError 발생
- 사용가능  : 문자열, 리스트, 튜플 자료형
- 사용불가  : 딕셔너리
str.rfind(sub, start, end) : find와 동일. 오른쪽에서 부터 찾는다.
str.rindex(sub, start, end) : index와 동일. 
str.count(sub, start, end) : start~end 범위에서 문자열sub가 중첩하지 않고 등장한 횟수 반환


출력
str.expandtabs(tabsize=8)     : \t 를 원하는 만큼 스페이스로 변경
'01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
'01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'


검사
str.isalnum()    : 1개이상 문자 존재 and 모두 알파벳/숫자 = True
str.isalpha()    : 1개이상 문자 존재 and 모두 알파벳 = True
str.isdecimal()  : 1개이상 문자 존재 and 모두 10진수 = True
str.isdigit()    : 1개이상 문자 존재 and 모두 Digit/Deicimal = True
str.isnumeric()  : 1개이상 문자 존재 and 모두 숫자 = True
str.isspace()    : 1개이상 문자 존재 and 모두 공백 = True
str.isascii()    : 빈문자열 or 모든문자 ASCII = True
str.islower()    : 모두 소문자 = True
str.isupper()    : 모두 대문자 = True


대소문자 변환
str.lower()      : 소문자로 변환
str.upper()      : 대문자로 변환
str.swapcase()   : 대소문자 반대로
str.capitalize() : (문장)첫 문자를 대문자로
str.title()      : (단어) 첫 문자를 대문자로

정렬 및 채우기
str.ljust(width,fillchar=' ') : 왼쪽 정렬된 문자열을 길이 width로 돌려줌. fillchar 기본값은 공백
'   abc'.ljust(10) → 'abc       '
str.rjust(width,fillchar=' ') : 오른쪽 정렬된 문자열을 길이 width로 돌려줌. fillchar 기본값은 공백

제거
str.removeprefix(prefix) : prefix로 시작하면 제거하여 반환. 아니면 문자열 그대로 반환
str.removesuffix(suffix) : suffix로 끝나면 제거하여 반환. 아니면 문자열 그대로 반환
str.strip(chars=' ')     : 왼/오른쪽에서 chars제거하여 반환. chars생략되면 공백
str.lstrip(chars=' ')    : 왼쪽에서 chars제거하여 반환.
str.rstrip(chars=' ')    : 오른쪽에서 chars제거하여 반환.
a='11112...21111'
a.strip('1')   : 2...2 → 붙어있는것 다 제거됨
a.strip('1,2') : ... → 여러 인자 가능


치환
str.replace(old,new,count) : old → new로 치환. 앞에서 count개수 만큼만 치환


나누기
str.partition(sep) : sep 기준으로 나눠서 3-튜플(앞부분, sep, 뒷부분)로 반환. sep없으면(문자열,'','') 
str.split(sep=None, maxsplit=-1) : sep을 기준으로 최대 maxsplit번(-1이면 무한~) 나눠서 리스트로 반환
'1,,2'.split(',')     = ['1','','2']
'1,2,3'.split(',',1)  = ['1','2,3']
'1<>2'.split('<>')    = ['1','2']
'  1  2  3  '.split() = ['1','2','3']

병합
str.join(

 

출력 포매팅

1. % 서식문자 사용
- python 2 이상 지원
- 2개 이상의 값을 넣으려면 마지막 % 다음 괄호 안에 콤마(,)로 구분하여 각각의 값을 넣어 주면 된다.

print("%d" % (10))
10
print("%10d" % (10)
        10
print("-10d" % (10)
10        
print("-2f" % (3.141592))
3.14
print("10.2e" % (3.141592))
  3.14e+00
print("%d / %d = %.2f" % (5, 3, 5/3))
5 / 3 = 1.67
number = 3
"I eat %d apples." % number
'I eat 3 apples.'


포맷 코드와 숫자 함께 사용하기
1. 정렬과 공백
  빈칸 채우고 마지막에 문자열로
  >>> "%10s" % "hi"
  '        hi'
  문자열 채우고 나머지를 공백으로
  >>> "%-10sjane." % 'hi'
  'hi        jane.'
2. 소수점 표현하기
  >>> "%0.4f" % 3.42134234
  '3.4213'
  >>> "%10.4f" % 3.42134234
  '    3.4213'
  
  
문자열 포맷 코드
코드  설명
%s  문자열(String)     -> 어떠한 값이라도 문자열로 변환해 넣을 수 있다.
%c  문자 1개(character)
%d  정수(Integer)
%f  부동소수(floating-point)
%o  8진수
%x  16진수
%%  Literal % (문자 % 자체)
[포매팅 연산자 %d와 %를 같이 쓸 때는 %%를 쓴다]
>>> "Error is %d%." % 98
틀렸습니다.
>>> "Error is %d%%." % 98
'Error is 98%.'
   
  

2. format(value, format_spec) 함수 사용
- python 3 이상 지원
1) 내장함수 print(format(3.141592, "5.2f"))
2) 메소드   print('num1:{0}, num2:{1}'.format(5, 1.1))
숫자 바로 대입하기
>>> "I eat {0} apples".format(3)
'I eat 3 apples'
문자열 바로 대입하기
>>> "I eat {0} apples".format("five")
'I eat five apples'
이름으로 넣기
>>> "I ate {number} apples. so I was sick for {day} days.".format(number=10, day=3)
'I ate 10 apples. so I was sick for 3 days.'
인덱스와 이름을 혼용해서 넣기
>>> "I ate {0} apples. so I was sick for {day} days.".format(10, day=3)
'I ate 10 apples. so I was sick for 3 days.'

왼쪽 정렬
>>> "{0:<10}".format("hi")
'hi        '
:<10 표현식을 사용하면 치환되는 문자열을 왼쪽으로 정렬하고 문자열의 총 자릿수를 10으로 맞출 수 있다.

오른쪽 정렬
>>> "{0:>10}".format("hi")
'        hi'
오른쪽 정렬은 :< 대신 :>을 사용하면 된다. 화살표 방향을 생각하면 어느 쪽으로 정렬되는지 바로 알 수 있을 것이다.

가운데 정렬
>>> "{0:^10}".format("hi")
'    hi    '
:^ 기호를 사용하면 가운데 정렬도 가능하다.

공백 채우기
>>> "{0:=^10}".format("hi")
'====hi===='
>>> "{0:!<10}".format("hi")
'hi!!!!!!!!'
채워 넣을 문자 값은 정렬 문자 <, >, ^ 바로 앞에 넣어야 한다. 

{ 또는 } 문자 표현하기
>>> "{{ and }}".format()
'{ and }'




3. f-string
- python 3.6 이상 지원
- 사용법 : f'문자열 {변수} 문자열'
value = 1
result = f'value: {value}'
>> value: 1

주의점 f포맷팅 내의 dictionary 값 호출은 따옴표가 아닌 쌍따옴표를 써야함.
f'value: dict["value"]' (O)
f'value: dict['value']' (X)

{value:<자릿수} : 자릿수 만큼에서 왼쪽 정렬
{value:^자릿수} : 자릿수 만큼에서 중간 정렬
{value:>자릿수} : 자릿수 만큼에서 오른쪽 정렬

{{{value}}}     : 진짜 중괄호 출력하고 싶을때
>> {1}

>>> name = '홍길동'
>>> age = 30
>>> f'나의 이름은 {name}입니다. 나이는 {age}입니다.'
'나의 이름은 홍길동입니다. 나이는 30입니다.'

f 문자열 포매팅은 위와 같이 name, age와 같은 변수 값을 생성한 후에 그 값을 참조할 수 있다. 
또한 f 문자열 포매팅은 표현식을 지원하기 때문에 다음과 같은 것도 가능하다.
※ 표현식이란 문자열 안에서 변수와 +, -와 같은 수식을 함께 사용하는 것을 말한다.
>>> age = 30
>>> f'나는 내년이면 {age+1}살이 된다.'
'나는 내년이면 31살이 된다.'
딕셔너리를 이렇게 가능
>>> d = {'name':'홍길동', 'age':30}
>>> f'나의 이름은 {d["name"]}입니다. 나이는 {d["age"]}입니다.'
'나의 이름은 홍길동입니다. 나이는 30입니다.'
>>> f'{"hi":<10}'  # 왼쪽 정렬
'hi        '
>>> f'{"hi":>10}'  # 오른쪽 정렬
'        hi'
>>> f'{"hi":^10}'  # 가운데 정렬
'    hi    '

 

---

집합 형 (set)

(set, frozenset)

---

set 집합 형 (Set / Container / Mutable)

class set([iterable])

서로 다른 객체의 순서 없는 컬렉션으로, 원소 위치, 삽입 순서 기록하지 않음.

멤버십 검사, 시퀀스에서 중복 제거, 교집합,합집합,차집합,대칭 차집합 등 연산 가능

Sequence형이 아니므로, 인덱싱,슬라이싱 등의 동작불가

Mutable (가변) 이므로 해시값 없음.

• 중괄호 안에 쉼표로 구분된 요소 나열하기: {'jack', 'sjoerd'}
• 집합 컴프리헨션 사용하기: {c for c in 'abracadabra' if c not in 'abc'}
• 형 생성자 사용하기: set(), set('foobar'), set(['a', 'b', 'foo'])

frozenset(Set / Container / Immutable)

class frozenset([iterable])

집합의 요소는 반드시 해시가능해야 함.

Immutable 이므로 해시가능. 딕셔너리 키나 다른 집합의 원소로 사용 가능.

isdisjoint(other) : 집합이 other 와 공통 원소를 갖지 않는 경우(교집합=공집합) True
issubset(other)
set <= other      : 집합의 모든 원소가 other 에 포함되는지 검사합니다.
set < other       : 집합이 other 의 진부분집합인지 검사 set <= other and set != other.

issuperset(other)
set >= other      : other 의 모든 원소가 집합에 포함되는지 검사합니다.
set > other       : 집합이 other 의 진상위집합인지 검사 set >= other and set != other.

union(*others)
set | other | ... : 집합과 others의 합집합 반환

intersection(*others)
set & other & ... : 집합과 others의 교집합 반환

difference(*others)
set - other - ... : 집합과 others의 차집합 반환

symmetric_difference(other)
set ^ other       : 집합이나 other에 포함되어 있으나 교집합이 아닌것 반환

update(*others)
set |= other      : 집합을 갱신해서, 모든 others의 원소들을 더합니다.

intersection_update(*others)
set &= other       : 집합을 갱신해서, 교집합만 남김

difference_update(*others)
set -= other       : 집합을 갱신해서, others에 있는 원소들을 제거합니다.

symmetric_difference_update(other)
set ^= other       : 집합을 갱신해서, 두 집합의 어느 한 곳에만 포함된 원소들만 남깁니다.

add(elem)          : 원소 elem 을 집합에 추가.
remove(elem)       : 원소 elem 을 집합에서 제거. elem 가 집합에 없다면 KeyError 발생.
discard(elem)      : 원소 elem 이 집합에 포함되어 있으면 제거
pop()              : 집합으로부터 임의의 원소를 제거해 반환. 공집합이면 KeyError 발생
clear()            : 집합의 모든 원소를 제거

 

합집합 활용 문제

1764번: 듣보잡

차집합 활용 문제

14889번: 스타트와 링크

---

매핑 형 (mapping)

(dict)

---

dict 매핑형 (Mapping / Container / Mutable)

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

해시 가능 값을 임의 객체에 대응. Mutable 한 값들은 키로 사용 불가.

일부로 set처럼 중복해서 쓰지 못한다는걸 강조하기 위해 중괄호 쓰는것 같음.

• 중괄호 안에 쉼표로 구분된 key: value 쌍을 나열하기: {'jack': 4098, 'sjoerd': 4127} 또는 {4098: 'jack', 4127: 'sjoerd'}
• 딕셔너리 컴프리헨션 사용하기: {}, {x: x ** 2 for x in range(10)}
• 형 생성자 사용하기: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)
• fromkeys() 함수 사용 dict = dict.fromkeys(seq, 값=None) : seq요소를 key로 사용하고 값은 동일하게 설정 가능   

2개의 객체가 있는 이터러블이 주어지면, 
첫 번째 객체 = 키 / 두 번째 객체 = 값으로 매핑됨.

>>> a = dict(one=1, two=2, three=3)                   : 튜플 → 딕셔너리
>>> b = {'one': 1, 'two': 2, 'three': 3}              
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3])) : 리스트 → 튜플 → 딕셔너리
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])  : 리스트(튜플)  → 딕셔너리
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True


조회
d[key]                  : 키가 key인 값을 반환 key 가 매핑에 없는 경우 KeyError 발생
get(key[, default=None) : key 가 딕셔너리에 있으면 값, 없으면 default 반환. KeyError 발생안함
setdefault(key[, default=None]) : key가 존재하면 해당 값, 없으면 key:default 삽입 후 default 반환. 
key in d                : d 에 키 key 가 있으면 True 를, 그렇지 않으면 False
key not in d            : not key in d 와 동등합니다.

len(d)         : 딕셔너리에 있는 항목의 수 반환
list(d)        : 모든 키를 리스트로 반환
iter(d)        : 딕셔너리의 키에 대한 이터레이터를 반환. 이것은 iter(d.keys()) 의 단축
items()        : 딕셔너리 항목들((key, value) 쌍들)의 새 뷰를 돌려줍니다.
keys()         : 딕셔너리 키들의 새 뷰를 돌려줍니다.
values()       : 딕셔너리 값들의 새 뷰를 돌려줍니다.
한 dict.values() 뷰와 다른 dict.values() 뷰 간의 동등 비교는 항상 False를 반환합니다. 
이것은 dict.values()를 자신과 비교할 때도 적용
>>> d = {'a': 1}
>>> d.values() == d.values()
False

reversed(d) : 딕셔너리의 키에 대한 역순 이터레이터를 돌려줍니다. 이것은 reversed(d.keys()) 의 단축
버전 3.8에 추가.



제거
del d[key]     : d 에서 d[key] 를 제거합니다. key 가 매핑에 없는 경우 KeyError 발생.
pop(key[, default]) : key 가 딕셔너리에 있으면 제거하고 그 값을 돌려줍니다. 그렇지 않으면 default 를 돌려줍니다. default 가 주어지지 않고 key 가 딕셔너리에 없으면 KeyError 를 일으킵니다.

popitem() : 딕셔너리에서 (key, value) 쌍을 제거하고 돌려줍니다. 쌍은 LIFO 순서로 반환됩니다.
popitem() 은 집합 알고리즘에서 종종 사용되듯이 딕셔너리를 파괴적으로 이터레이션 하는 데 유용합니다. 
딕셔너리가 비어 있으면 popitem() 호출은 KeyError 를 일으킵니다.
버전 3.7에서 변경: 이제 LIFO 순서가 보장됩니다. 이전 버전에서는, popitem()가 임의의 키/값 쌍을 반환합니다.

clear()        : 딕셔너리에서 모든 항목을 제거


갱신
d[key] = value : d[key] 를 value 로 설정합니다.
update([other]) : other 가 제공하는 키/값 쌍으로 사전을 갱신합니다. 기존 키는 덮어씁니다. None 을 돌려줍니다.
다른 딕셔너리 객체 나 키/값 쌍(길이 2인 튜플이나 다른 이터러블)을 주는 이터레이터를 모두 받아들입니다. 키워드 인자가 지정되면, 딕셔너리는 그 키/값 쌍으로 갱신됩니다.
d.update(red=1, blue=2).

classmethod fromkeys(iterable[, value])
iterable 이 제공하는 값들을 키로 사용하고 모든 값을 value 로 설정한 새 딕셔너리 반환
seq = ('name', 'age', 'sex')
dict.fromkeys(seq)     : {'age': None, 'name': None, 'sex': None}
dict.fromkeys(seq, 10) : {'age': 10, 'name': 10, 'sex': 10}  → 모든 value 동일

copy()         : 딕셔너리의 얕은 복사본을 반환

d | other : d와 other의 병합된 키와 값으로 새 딕셔너리를 만듭니다. 둘 다 딕셔너리이어야 합니다. d와 other가 키를 공유하면 other의 값이 우선합니다.
버전 3.9에 추가.

d |= other : other의 키와 값으로 딕셔너리 d를 갱신합니다. other는 매핑이나 키/값 쌍의 이터러블일 수 있습니다. d와 other가 키를 공유하면 other의 값이 우선합니다.
버전 3.9에 추가.

딕셔너리는 (순서와 관계없이) 같은 (key, value) 쌍들을 가질 때, 그리고 그때만 같다고 비교됩니다. 순서 비교(〈<〉, 〈<=〉, 〈>=〉, 〈>〉)는 TypeError 를 일으킵니다.
딕셔너리는 삽입 순서를 유지합니다. 키를 갱신해도 순서에는 영향을 미치지 않습니다. 삭제 후에 추가된 키는 끝에 삽입됩니다.

 

딕셔너리 뷰 객체

dict.keys(), values(), items() 가 반환하는 객체는 뷰 객체

keys() : 고유하므로 집합과 유사함 → set에 정의된 연산 사용 가능.

len(dictview)  : 딕셔너리에 있는 항목 수를 돌려줍니다.

iter(dictview) : 딕셔너리에서 키, 값, 항목((key, value) 튜플로 표현됩니다)에 대한 이터레이터를 돌려줍니다.
키와 값은 삽입 순서로 이터레이션 됩니다. 이 때문에 zip()을 사용해서 (value, key) 쌍을 만들 수 있습니다
pairs = zip(d.values(), d.keys())
또는 pairs = [(v, k) for (k, v) in d.items()]
딕셔너리에 항목을 추가/삭제하는 동안 뷰를 이터레이션 하면 RuntimeError 발생 또는 모든 항목을 이터레이션 하지 못할 수 있습니다.
버전 3.7에서 변경: 딕셔너리의 순서가 삽입 순서임이 보장됩니다.

x in dictview  : x 가 하부 딕셔너리의 키, 갑, 항목에 있는 경우 True 를 돌려줍니다 
(마지막의 경우 x 는 (key, value) 튜플이어야 합니다).

reversed(dictview)
딕셔너리의 키, 값 또는 항목에 대한 역방향 이터레이터를 반환합니다. 뷰는 삽입의 역순으로 이터레이트됩니다.
버전 3.8에서 변경: 딕셔너리 뷰는 이제 역 탐색할 수 있습니다.

 

 

타입 확인

type(값) : 타입

isinstance(값, 타입) : True/False

 

특정 타입인지 확인 / 타입검사 / 타입확인

value = 1

type(value) : 객체의 타입 반환
- output : <clase 'type'>

isinstance(value, type) : 객체가 특정 타입인지 True/False로 반환
- type은 int, str, list, dict, tuple 등으로 입력
- output : True/False

isinstance(value, (type1,type2...)) : 여러 type중 하나면 True 

 

타입 변경

int 타입으로 변환
int(5.55) = 5
int('a') = 1
int(True) = 1

float 타입으로 변환
float(10) = 10.0
float(True) = 1.0
float('3') = 3.0

str 타입으로 변환
str(10) = '10'
str(10.0) = '10.0'
str(True) = 'TRUE'

유니코드 ↔ str 변환
chr(65) = A
ord('A') = 65

bool 타입으로 변환
bool(1) = True
bool('a') = True
bool('dkjfaskas') = True
bool(0) = False
bool(0.0) = False
bool('') = False

list(iterable)
tuple(iterable)
set(iterable)
dict(iterable)