[정리 02] 표준 데이터 타입(Standard Data-Type)

Numbers

• 파이썬은 동적으로 타입이 변하기 때문에, 정수를 저장한 변수에 실수도 저장할 수 있다. 물론 다른 타입도 가능하다.

>>> x = 1
>>> type(x)
<class 'int'>
>>> x = 0.5
>>> type(x)
<class 'float'>

• 변수의 크기는 지정되지 않으므로 C언어의 long long 과 int 크기의 숫자도 같은 변수에 저장된다.

  • 단, 값이 매우 클 경우 inf 또는 지수 형태(예시: 1e+123)로 표현된다.

>>> x = 1e123
>>> x
1e+123
>>> '%d' % x
'999999999999999977709969731404129670057984297594921577392083322662491290889839886077866558841507631684757522070951350501376'

• immutable: 불변 객체(생성 후 상태를 바꿀 수 없는 객체), 다른 변수로 동일한 메모리 주소에 쓰기 작업 수행 시 복사되어 원본이 변하지 않는다.

  • y = x 라인까지는 두 변수 모두 같은 메모리를 참조하지만, y에 연산을 수행할 경우 메모리가 복사되어 원본 데이터가 변경되지 않는다.

>> x = 3
>> y = x
>> y += 1
>> x
3
>> y
4

 

String

• 문자열 타입으로, 큰 따옴표와 작은 따옴표 모두 문자열로 표현된다. "blabla" 와 'blabla' 는 같다.

>>> x = "abcd"
>>> type(x)
<class 'str'>
>>> x == 'abcd'
True

 

• immutable: 불변 객체(생성 후 상태를 바꿀 수 없는 객체), 다른 변수로 동일한 메모리 주소에 쓰기 작업 수행 시 복사되어 원본이 변하지 않는다.

>> x = 'abcd'
>> y = x
>> y += 'e'
>> x
'abcd'
>> y
'abcde'

• 파이썬에서는 시퀀스 형에 대해 슬라이싱(slicing) 기능을 제공하는데, 앞으로 설명할 튜플과 리스트, 그리고 문자열은 시퀀스 형에 해당된다. 단, 문자열은 리스트와 달리 특정 위치에 값을 할당할 수 없으며, 수정하길 원한다면 다음과 같이 슬라이싱을 활용할 수 있다.

  • 파이썬에서는 슬라이싱과 관련해서 유용한 연산들을 많이 할 수 있는데, 대표적인 예로 문자열 뒤집기가 있다.

>>> x = 'helloempty'
>>> y = 'emptyworld'
>>> x + y
'helloemptyemptyworld'
>>> x[:5] + y[-5:]
'helloworld'
>>> x[::-1] # 문자열 뒤집기
'ytpmeolleh'

• 지원하는 메소드는 다음과 같고, 호출 시 원본은 바뀌지 않는다.

>>> x.
x.capitalize(    x.isalpha(       x.ljust(         x.split(
x.casefold(      x.isascii(       x.lower(         x.splitlines(
x.center(        x.isdecimal(     x.lstrip(        x.startswith(
x.count(         x.isdigit(       x.maketrans(     x.strip(
x.encode(        x.isidentifier(  x.partition(     x.swapcase(
x.endswith(      x.islower(       x.replace(       x.title(
x.expandtabs(    x.isnumeric(     x.rfind(         x.translate(
x.find(          x.isprintable(   x.rindex(        x.upper(
x.format(        x.isspace(       x.rjust(         x.zfill(
x.format_map(    x.istitle(       x.rpartition(
x.index(         x.isupper(       x.rsplit(
x.isalnum(       x.join(          x.rstrip(

메소드 이름	용도
capitalize()	첫 글자만 대문자로 바꾼 문자열을 반환
isalnum()	문자열에 숫자, 알파벳로만 구성되어 있으면 true, 아니면 false
isdigit()	문자열이 숫자로만 구성되어 있으면 true, 아니면 false
islower()	문자들이 모두 소문자이면 true, 아니면 false
isupper()	문자들이 모두 대문자이면 true, 아니면 false
isnumeric()	문자들이 모두 유니코드 문자이면 true, 아니면 false
isspace()	문자들이 모두 공백이면 true, 아니면 false
join([...])	배열 원소가 모두 문자열이면, 지금 문자열을 구분자로 하나로 합쳐서 반환
ljust(width, fillchar=' ')	문자열이 width보다 짧으면 좌측으로 정렬 후 나머지를 fillchar로 채워서 반환
rjust(width, fillchar=' ')	문자열이 width보다 짧으면 우측으로 정렬 후 앞부분을 fillchar로 채워서 반환
lower()	모든 대문자를 소문자로 바꿔서 반환
upper()	모든 소문자를 대문자로 바꿔서 반환
lstrip(ch=' ')	왼쪽에 ch를 모두 제거해서 반환. ex) " a cde" -> "a cde"
rstrip(ch=' ')	오른쪽에 ch를 모두 제거해서 반환. ex) "acd e " -> "acd e"
strip(ch=' ')	양쪽에 ch를 모두 제거해서 반환
replace(old, new[, max])	최대 max개까지 old를 new로 변경, max가 없으면 모두 변경한 후 반환
swapcase()	대문자는 소문자로, 소문자는 대문자로 바꾼 것을 반환

 

List

• 리스트 타입으로, 다른 타입의 데이터를 함께 저장할 수 있다.

>>> x = [1,2,3,'hi',0.5]
>>> x
[1, 2, 3, 'hi', 0.5]
>>> type(x)
<class 'list'>

• mutable: 가변 객체(생성 후에도 상태를 변경할 수 있는 객체), 다른 변수로 동일한 메모리 주소에 쓰기 작업 시 복사되지 않고 원본이 수정된다. 따라서 원본을 유지하려면 깊은 복사(deepcopy)를 해야 한다.

  • y = x 이후에도 두 변수는 모두 같은 메모리 주소를 참조한다.

>> x = [1,2]
>> y = x
>> y.append(3)
>> x
[1,2,3]
>> y
[1,2,3]
>> x = [1,2]
>> y = x.copy() # 깊은 복사를 할 경우 immutable 하게 사용 가능.
>> y.append(3)
>> x
[1,2]
>> y
[1,2,3]

• 동일한 타입의 데이터를 사용하길 원한다면 array 모듈을 사용해야 한다.

>>> import array
>>> A = array.array('i', [1,2,3,4])
>>> A.
A.append(       A.fromfile(     A.itemsize      A.tolist(
A.buffer_info(  A.fromlist(     A.pop(          A.tostring(
A.byteswap(     A.fromstring(   A.remove(       A.tounicode(
A.count(        A.fromunicode(  A.reverse(      A.typecode
A.extend(       A.index(        A.tobytes(
A.frombytes(    A.insert(       A.tofile(

• 지원하는 메소드는 다음과 같다.

>>> x.
x.append(   x.copy(     x.extend(   x.insert(   x.remove(   x.sort(
x.clear(    x.count(    x.index(    x.pop(      x.reverse(

메소드 이름	용도
append(element)	리스트의 끝에 원소를 추가
copy()	리스트를 복사하여 반환
extend([...])	리스트의 끝에 새 리스트를 추가
insert(index, element)	해당 위치에 원소를 삽입
remove(element)	원소를 삭제
sort()	리스트를 오름차순으로 정렬
clear()	리스트의 모든 원소를 제거
count(element)	리스트에 저장된 원소의 개수를 반환
index(element)	원소의 인덱스를 반환
pop()	리스트의 끝에서 원소를 제거한 후 반환
reverse()	리스트를 뒤집음

• 리스트의 원소를 지우는 방법은 del 키워드를 사용해서도 가능한데, 주로 원소를 모르고 인덱스로 연산할 때 유용하다.

>>> x = [1,2,3]
>>> x
[1, 2, 3]
>>> del x[2]
>>> x
[1, 2]

• 시퀀스 형(리스트, 문자열, 튜플 등)은 + 연산자와 * 연산자를 이용해서 합칠 수 있다. 매우 유용하다.

  • 단, 다른 시퀀스 형끼리는 연산할 수 없다.

>>> [1,2,3] + [4,5,6] + [7,8,9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [1,2] * 3
[1, 2, 1, 2, 1, 2]
>>> [[1,2,3], [4,5,6]] + [1,2,3]
[[1, 2, 3], [4, 5, 6], 1, 2, 3]
>>> "hello" + "world"
'helloworld'
>>> "A" * 12
'AAAAAAAAAAAA'
>>> (3,)*13 # 튜플은 원소가 1개일 때 뒤에 콤마(,)를 써야한다. 안그러면 스칼라 곱셈으로 계산된다.
(3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3)

 

Tuple

• 튜플 타입으로, 리스트와의 차이점은 다음과 같다.

  • 리스트는 []을, 튜플은 ()을 사용해서 선언한다.

  • 리스트는 크기나 원소를 동적으로 변경할 수 있으나, 튜플은 읽기만 가능(read-only)하다.

  • 리스트는 튜플보다 속도가 느리다.

• immutable: 불변 객체(생성 후 원본이 변하지 않는 객체), 다른 변수가 동일한 메모리 주소에 쓰기 작업 수행 시 복사되어 원본이 수정되지 않는다.

>> x = (1,2)
>> y = x
>> y += (3,)
>> x
(1,2)
>> y
(1,2,3)

• 지원하는 메소드는 다음과 같으며, count(element) 는 해당 원소의 개수를 반환하고, index(element) 는 해당 원소의 인덱스를 반환한다.

>>> x.
x.count(  x.index(

 

Dictionary

• 딕셔너리 타입으로, key와 value 쌍을 원소로 저장한다.

  • key는 unhashable type(해쉬 불가능 타입)의 데이터는 해당될 수 없다. 주로 문자열, 숫자, 커스텀 객체가 해당된다.

>>> x = {'k1':1, 'k2':2, 3:"hello"}
>>> type(x)
<class 'dict'>

[+] 객체를 키로 쓰는 경우 메모리 주소로 동일한 키인지 구분한다.

>>> class Obj:
...     pass
...
>>> o = Obj()
>>> o
<__main__.Obj object at 0x10c1fddc0>
>>> x = {}
>>> x[o] = 1
>>> x
{<__main__.Obj object at 0x10c1fddc0>: 1}

• mutable: 가변 객체(생성 후에도 원본이 변경되는 객체), 다른 변수에서 동일한 메모리에 쓰기 작업 수행 시 복사되지 않고 원본이 수정된다. 따라서 원본을 유지하려면 깊은 복사(deepcopy)를 해야 한다.

>> x = {'k1':2}
>> y = x
>> y['k2'] = 4
>> x
{'k1':2, 'k2':4}
>> y
{'k1':2, 'k2':4}

• 지원하는 메소드는 다음과 같다.

>>> x.
x.clear(       x.get(         x.pop(         x.update(
x.copy(        x.items(       x.popitem(     x.values(
x.fromkeys(    x.keys(        x.setdefault(

메소드 이름	용도
clear()	딕셔너리의 원소들을 모두 제거
get(key)	키에 해당되는 값을 반환
pop(key)	키에 해당되는 값을 제거해서 반환
update(dictionary)	현재 딕셔너리에 새로운 딕셔너리를 합침. 동일한 키가 있으면 새로운 값으로 수정된다.
copy()	딕셔너리를 복사해서 반환
items()	키와 값을 튜플 형태의 리스트로 반환. 주로 반복문에서 키와 값을 참조할 때 사용된다. 단, dict_items 라는 객체이며 리스트가 아니다. >>> y = x.items() >>> type(y) == type([]) False >>> type(y) <class 'dict_items'>
popitem()	마지막 아이템을 제거해서 반환
values()	값들만 리스트 형태로 반환하는데 dict_values 라는 객체이며 리스트는 아니다. >>> y = x.values() >>> type(y) == type([]) False >>> type(y) <class 'dict_values'>
fromkeys(seq[, value])	시퀀스형의 원소들을 키로 갖는 딕셔너리를 반환하며, value는 기본값으로 쓰이는데 없으면 None을 값으로 갖는다.
keys()	키만 리스트 형태로 반환하는데 dict_keys 라는 객체이며 리스트는 아니다. >>> y = x.keys() >>> type(y) == type([]) False >>> type(y) <class 'dict_keys'>
setdefault(key[, value])	해당 키에 대한 디폴트 값을 설정하는데, 키가 이미 있다면 바뀌지 않는다. value를 넘기지 않으면 None 이 설정된다.

 

set

• 집합 자료형으로, set() 또는 {} 으로 선언할 수 있다.

>>> x = set({1,2,3})
>>> y = {1,2,3}
>>> type(x), type(y)
(<class 'set'>, <class 'set'>)
>>> x == y
True

• 내부적으로 해쉬 테이블로 구현되어 있어 삽입/삭제/검색 시 O(1)의 비용이 든다.

• 데이터는 순서 없이 저장되므로, 삽입한 순서와는 다르게 저장된다.

• 인덱싱이나 슬라이싱이 불가능하다.

• mutable: 가변 객체(생성 후에도 원본이 변경되는 객체)

• 지원하는 메소드는 다음과 같다.

>>> x.
x.add(                          x.issubset(
x.clear(                        x.issuperset(
x.copy(                         x.pop(
x.difference(                   x.remove(
x.difference_update(            x.symmetric_difference(
x.discard(                      x.symmetric_difference_update(
x.intersection(                 x.union(
x.intersection_update(          x.update(
x.isdisjoint(

• 집합 자료형으로는 frozenset 도 있는데 둘의 차이는 해시가능(hashable)의 유무이다.

  • set은 가변형이며 add() 나 remove() 메소드로 원소를 추가하거나 삭제할 수 있다. 원소에 대한 해시값이 따로 존재하지 않는다.

  • frozenset은 불변형이며 원소를 수정할 수 없다. 단, 원소에 대한 해시값이 별도로 존재한다.

  • frozeonset 은 딕셔너리의 key로 사용할 수 있다.

>>> x = { set([1,2]):1 }
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> x = { frozenset([1,2]):1 }
>>> x
{frozenset({1, 2}): 1}

• frozenset 이 지원하는 메소드는 다음과 같다.

>>> x = frozenset()
>>> x.
x.copy(                  x.isdisjoint(            x.symmetric_difference(
x.difference(            x.issubset(              x.union(
x.intersection(          x.issuperset(

 

타입 변환 함수

• int() – converts any data type into integer type

• float() – converts any data type into float type

• ord() – converts characters into integer

• hex() – converts integers to hexadecimal

• oct() – converts integer to octal

• tuple() – This function is used to convert to a tuple.

• set() – This function returns the type after converting to set.

• list() – This function is used to convert any data type to a list type.

• dict() – This function is used to convert a tuple of order (key,value) into a dictionary.

• str() – Used to convert integer into a string.

• complex(real,imag) – This functionconverts real numbers to complex(real,imag) number.

• 모두 내장 함수(built-in function)이며, 인자로 주는 시퀀스형이 구조가 일치하지 않으면 예외를 일으킬 수 있다.

>>> int('123aa')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '123aa'
>>> int('123')
123

 

그 외

• 시퀀스 형 관련 연산: Comprehension

• 내장 유형(built-in type)에 대한 레퍼런스

• 내장 데이터형에 대한 레퍼런스

• 자료형에 따른 시간 복잡도