Python 개념 정리 - 객체란 ( mutable vs immutable )

본 포스팅에서는 파이썬의 mutable 객체와 immutable 객체에 대해  is 연산자, id 함수, == 연산자를 중심으로 설명하고 있습니다.

2018. 5. 10 - 최초작성

2018. 7. 19

파이썬에서 모든 것은 객체(object)입니다.

객체가 생성된 후 ID는 변경되지 않으며 해당 객체가 프로그램 실행 중에 유일한 객체라는 것을 보장합니다. ( id 함수를 사용하면 객체의 ID를 확인할 수 있습니다. )

특정 객체가 저장된 메모리 주소를 가리키는 고유 ID라고 생각할 수 있지만 실제 메모리 주소는 아닙니다.

(CPython에서는 id 함수가 객체가 저장된 실제 메모리 주소를 리턴합니다.)

파이썬에서는 객체를 비교하기 위해 id 함수와 is 연산자가 제공됩니다.

• id(object)

id 함수는 아규먼트로 제공된 객체를 위한 고유한 상수를 리턴합니다.  

두 객체의 id 함수 리턴값이 같다면 두 객체는 동일한 객체입니다.

리턴값을 객체의 실제 메모리상의 주소라 보기는 힘들지만 해당 객체를 가리키는 유일한 상수입니다.

CPython의 경우에는 객체의 실제 메모리 주소를 사용합니다.

• a is b

is 연산자는 a, b가 같은 객체라면(id 함수의 리턴값이 같다면) True를 리턴합니다.

is 연산자를 이용하여 다음처럼 비교해보면 객체의 값이 같지만 False를 리턴하는 경우가 있기 때문에 주의해야 합니다.

• 변수 is 변수

• 변수 is 객체

• 객체 is 객체

파이썬에서는 값이 같더라도 별개의 객체로 보는 경우가 대부분이기 때문입니다.

데이터를 비교할 때에는 == 연산자를 사용하여 두 객체의 값이 동일한지 테스트해야 합니다.

is 연산자는 같은 객체인지 확인하거나 객체가 파이썬 상수(None, True, False)와 같은지 확인할 때에만 사용하도록  합니다.

파이썬 3.6.5의 인터프리터를 기준으로 하고 있으며 PyCharm 같은 IDE에서는 실행 결과가 다른 경우가 있으니 주의해야 합니다.

파이썬에는 mutable 데이터 타입과 immutable 데이터 타입이 있습니다.

• mutable 객체

객체를 생성한 후, 객체의 값을 수정 가능, 변수는 값이 수정된 같은 객체를 가리키게됨, 예)  list, set, dict

• immutable 객체

객체를 생성한 후, 객체의 값을 수정 불가능, 변수는 해당 값을 가진 다른 객체를 가리키게됨, 예) int, float, complex, bool, string, tuple, frozen set

쉽게 구별하는 방법은 변수에 대입한 값을 수정했을 때  전후의 id 함수 리턴값을 비교해보는 겁니다.

같으면 mutable 객체, 다르면 immutable 객체입니다.

파이썬에서 변수는 자신에게 대입된 객체를 가리키는 일종의 포인터 같은 존재입니다.

C언어에서 대입(assignment)은 오른쪽에 있는 값을 변수에 저장하라는 의미입니다.

변수 선언시 저장할 데이터의 타입을 지정해줘야 하며 변수가 자체 저장공간을 할당받습니다.

int a = 1;   // 변수 a와 1은 같은 존재라 볼 수 있습니다.

파이썬 언어에서 대입은 오른쪽에 있는 값을 가지는 객체를 변수가 가리키라는 의미입니다.

변수 선언이라는 개념이 없으며 변수는 타입을 갖지 않습니다.

왜냐면 파이썬에서는 문자열이나 숫자, 리스트 같은 데이터 자체가 객체이기 때문입니다.  

변수는 자체 저장공간을 할당 받지 않으며 객체를 가리키기만 합니다.

a = 1 // 변수 a와 1은 별개의 존재입니다.

변수에 새로운 객체를 대입하거나 객체를 가리키고 있는 변수를 다른 변수에 대입하는 경우의 동작은 mutable 객체와 immutable 객체 간에도 차이가 있지만, 타입 별로도 차이가 있습니다.

>>> a = 1       # 변수 a에 정수 객체 1을 대입한 후 >>> b = a       # 변수 b에 변수 a를 대입하면 >>> a is b      # 변수 a, b는 같은 객체를 가리키게 됩니다. True >>> a = 2       # 하지만 변수 a를 사용하여 객체의 값을 변경하면 >>> a is b False           # 변수 a와 b는 별개의 객체를 가리키게 됩니다. >>> a;b         # 변수 a와 b가 가리키는 객체의 값이 다릅니다. 2 1 >>> a = [1, 2, 3]   # 변수 a에 리스트 객체 [1, 2, 3]을 대입한 후 >>> b = a           # 변수 b에 변수 a를 대입하면 >>> a is b          # 변수 a, b는 같은 객체를 가리키게 됩니다. True >>> a.append(4)     # 변수 a를 사용하여 객체의 값을 변경해도 >>> a is b True                # 변수 a와 b는 같은 객체를 가리키고 있습니다. >>> a;b             # 변수 a와 b가 가리키는 객체의 값이 같습니다. [1, 2, 3, 4] [1, 2, 3, 4]

다른 객체를 포함하고 있는 복합 객체(compound object)가 아니라면 얕은 복사(shallow copy)와 깊은 복사(deep copy) 간에 차이가 없습니다.

똑같이 새로운 객체를 생성합니다.  복합 객체의 경우에 어떤 차이가 생기는지는 리스트 항목에서 다룹니다.

import copy a = [ 1, 2, 3] b = a      # 대입 c = copy.copy(a) # 얕은 복사 d = copy.deepcopy(a) # 깊은 복사 print(a, b, c, d) # [1, 2, 3] [1, 2, 3] [1, 2, 3] [1, 2, 3]  모두 같은 값을 가지지만 print(id(a), id(b), id(c), id(d)) # 2310639565896 2310639565896 2310639565960 2310639559368 # 객체의 id를 출력해보면 변수 a와 b만 같은 객체를 가리킵니다.   b[0]=100  # 변수 b가 가리키는 리스트 객체의 첫번째 원소를 수정했더니 print(a, b, c, d) # [100, 2, 3] [100, 2, 3] [1, 2, 3] [1, 2, 3] # 변수 a가 가리키는 리스트 객체의 첫번째 원소만 영향을 받습니다. # copy 모듈의 메소드를 사용하여 복사한 c와 d는 그렇지 않습니다. c[0]=200 d[1]=300 print(a, b, c, d) # [100, 2, 3] [100, 2, 3] [200, 2, 3] [1, 300, 3] # 변수 c와 d가 가리키는 객체는 독립적인 객체입니다. # 얕은 복사와 깊은 복사간에 차이가 없습니다.

정수(Integer)

파이썬에서 정수는 int 클래스 타입의 객체입니다.

>>> type(-5) <class 'int'> >>> isinstance(-5, int) True

정수 타입의 객체는 생성 후  값 수정이 불가능한 immutable 객체입니다.

>>> a = 10 >>> id(a) 1831365936 >>> a = a + 1   # 변수에 대입한 값을 수정한 후 id 함수 리턴값이 달라졌습니다. >>> id(a) 1831365968

>>> a = 10 # 변수 a가 정수 객체를 가리키도록 합니다. >>> id(a) 1508732208 >>> id(10) 1508732208 >>> >>> a = a + 1 # 변수 a가 가리키는 정수 객체에 1을 더합니다. >>> id(a) 1508732240    # 변수 a가 가리키는 객체만 바뀌었을 뿐 >>> id(10)     1508732208    # 객체 10은 그대로입니다.

효율성을 위해 -5에서 256 사이의 정수는 캐시해 둡니다.  

“The current implementation keeps an array of integer objects for all integers between -5 and 256, when you create an int in that range you actually just get back a reference to the existing object.“

https://docs.python.org/3/c-api/long.html#c.PyLong_FromLong

이 범위에 있는 정수의 경우에는 매번 새로운 객체가 생성되지 않고 기존에 메모리에 생성되어 있는 객체를 참조합니다.

변수에 대입하지 않은 정수 객체도 값이 같으면 같은 객체입니다.

>>> id(1) 1755147280   >>> id(1) 1755147280  # 변수에 대입하지 않은 정수 1객체는 항상 같은 객체입니다.(id 함수의 리턴값이 동일) >>> a = 1 >>> b = 1 >>> id(a) 1755147280 >>> id(b)   # 변수 a,b가 같은 객체를 가리킵니다. 1755147280 >>> id(1)       1755147280

경계값 벗어난 정수의 경우에는 같은 값을 가진  객체라도 동일한 객체가 아니기때문에 is 연산자로 객체의 값을 비교하면 안됩니다.

>>> id(257) 2127316758256 >>> id(257)     # 변수에 대입하지 않은 정수 257 객체는 계속 새로운 객체로 생성됩니다. 2127316758256   # 하지만 변수에 대입되기 전까지는 같은 메모리 위치를 재사용하기 때문에 id 함수의 리턴값이 같습니다. >>> id(258)     # 정수 257 객체가 아니더라도 같은 메모리 위치를 재사용합니다. 2127316758256 >>> a = 257 >>> id(a)        2127316758256   # 변수가 해당 객체를 참조하기 시작하면 >>> id(257)        2127319722704   # 다른 메모리 위치에 정수 객체가 생성됩니다. >>> b = 257 >>> id(b)      2127319722704 >>> a == b   # 변수 a, b가 가리키는 객체의 값은 같지만 True >>> a is b   # 변수 a,b가 가리키는 객체는 같지 않습니다. False

정수 객체의 값을 비교시 is 연산자 대신에 == 연산자를 사용해야 합니다.

-5 ~ 256 사이의 정수 경우에는 아무 문제 없어 보이지만

>>> a = 15 >>> b = 5 * 3 >>> a == b   # 변수 a, b가 가리키는 객체의 값이 같습니다. True >>> a is b   # 변수 a,b가 가리키는 객체는 같습니다. True

그외 범위의 정수에 대해 똑같은 연산을 하면 문제가 발생합니다.

>>> a = 1000 >>> b = 10 * 100 >>> a == b   # 변수 a, b가 가리키는 객체의 값은 같지만 True >>> a is b   # 변수 a, b는 별개의 객체를 가리킵니다.   False

이외에도 여러가지 경우가 있기 때문에 정수 객체 비교시 is를 사용하면 안됩니다.

실수(float)

파이썬에서 실수는 float 클래스 타입의 객체입니다.

>>> type(0.1) <class 'float'>

실수 타입의 객체는 생성 후  값 수정이 불가능한 immutable 객체입니다.

>>> a = 0.1 >>> id(a) 2610206020256 >>> a = a + 0.2  # 변수에 대입한 값을 수정한 후 id 함수 리턴값이 달라졌습니다. >>> id(a) 2610206019944

같은 값을 가진 실수 객체라도 동일한 객체가 아니기때문에 is 연산자로 객체의 값을 비교하면 안됩니다.

>>> id(1.1) 2610206019872 >>> id(1.1)           # 변수에 대입하지 않은 실수 1.1 객체는 계속 새로운 객체로 생성됩니다. 2610206019872  # 하지만 변수에 대입되기 전까지는 같은 메모리 위치를 재사용하기 때문에 id 함수의 리턴값이 같습니다. >>> id(2.1)           # 실수 1.1 객체가 아니더라도 같은 메모리 위치를 재사용합니다. 2610206019872 >>> a = 1.1         # 변수가 해당 객체를 참조하기 시작하면 >>> id(a) 2610206019872 >>> id(1.1) 2610206019944    # 다른 메모리 위치에 실수 객체가 생성됩니다. >>> b = 1.1 >>> id(b) 2610206019944 >>> a == b        True             # 변수 a, b가 가리키는 객체의 값은 같지만 >>> a is b        False          # 변수 a,b가 가리키는 객체는 같지 않습니다.

객체의 값을 비교시 is 연산자 대신에 == 연산자를 사용해야 합니다.

>>> a = 1000.0 >>> b = 10.0 * 100.0 >>> a == b      True              # 변수 a, b가 가리키는 객체의 값은 같지만 >>> a is b False             # 변수 a, b는 별개의 개체입니다.

문자열(string)

파이썬에서 문자열은 str 클래스 타입의 객체입니다.

>>> type('abc') <class 'str'>

문자열 타입의 객체는 생성 후  값 수정이 불가능한 immutable 객체입니다.

>>> a = 'abc' >>> id(a) 1421244119952 >>> a = a + 'd'  # 변수에 대입한 값을 수정한 후 id 함수 리턴값이 달라졌습니다. >>> id(a) 1421276091312

>>> a = 'abc' # 변수 a가 문자열 객체를 가리키도록 합니다. >>> id(a) 1421244119952 >>> id('abc') 1421244119952 >>> a = a + 'd'   # 변수 a가 가리키는 객체의 값을 변경하려하면 >>> id(a) 1421276091312     # 변수 a가 가리키는 객체만 바뀔 뿐 >>> id('abc')      1421244119952     # 'abc' 객체는 그대로입니다.

문자열이 a ~ z, A ~ Z, 0~9, _ 문자로만 구성되는 경우에는 기존에 생성된 객체가 있다면 해당 객체를 참조합니다.

>>> a = 'azAZ09_' >>> b = 'azAZ09_' >>> id(a), id(b) (2841044653368, 2841044653368) >>> a is b True >>> a == b True >>> a is 'azAZ09_' True >>> a == 'azAZ09_' True

id 함수가 똑같은 문자열에 대해 같은 값을 리턴합니다.

>>> id('azAZ09_') 2091230172416 >>> id('azAZ09_') 2091230172416 >>> a = 'azAZ09_' >>> id('azAZ09_') 2091230172416 >>> id('azAZ09_') 2091230172416

a ~ z, A ~ Z, 0~9, _  외 문자가 문자열에 포함되어 있으면 변수에 똑같은 문자열을 대입하더라도 그 때마다 새로운 객체를 생성합니다.

>>> a = 'azAZ09_!'      # 변수 a와 b에 똑같은 문자열을 대입했지만 >>> b = 'azAZ09_!' >>> id(a), id(b) (2841044647152, 2841044647216) >>> a is b   # 변수 a와 b는 다른 객체를 가리키고 있습니다. False >>> a == b True # 문자열에 a~z, A~Z, 0~9, _ 외의 문자가 포함되어 있다면 # 다음처럼 is 연산자로 비교시 False가 되므로 주의해야 합니다. >>> a is 'azAZ09_!' False >>> a == 'azAZ09_!' True

a~z, A~Z, 0~9, _만으로 구성된 문자열 객체의 값을 비교하더라도  is 연산자를 사용하면 안됩니다.

변수에 대입 전에 문자열을 조합하는 것은 문제없어보이지만

>>> a = 'a' + 'bc' >>> b = 'abc' >>> id(a), id(b), id('abc') (2091227298704, 2091227298704, 2091227298704) >>> a is b True >>> a == b True >>> a is 'abc' True >>> a == 'abc' True

다음처럼 변수 a1, a2에 따로 문자열을 대입한 후,  변수 a에서 조합하여 대입하면 is 연산자로 비교시 문제가 생깁니다.

>>> a1 = 'a' >>> a2 = 'bc' >>> b = 'abc' >>> a = a1 + a2 >>> id(a), id(b), id('abc') (2091230173312, 2091227298704, 2091227298704) >>> a == b    # 변수 a, b가 가리키는 객체의 값이 같지만 True >>> a is b    # 변수 a, b가 가리키는 객체는 별개의 객체입니다. False >>> a == 'abc'   # 변수 a가 가리키는 객체와 'abc' 객체의 값은 같지만 True >>> a is 'abc'   # is 연산자로 비교하면 False가 리턴됩니다. False

동일한 문자로 구성된 문자열을 항상 같은 객체로 처리하고 싶으면 sys.intern 메소드를 사용하면 됩니다.

>>> import sys >>> a = sys.intern('azAZ09_!') >>> b = sys.intern('azAZ09_!') >>> a == b True >>> a is b True >>> a == sys.intern('azAZ09_!') True >>> a is sys.intern('azAZ09_!') True

input 함수등을 사용하여 키보드 입력받은 후 값 비교시에도 is를 사용하면 안됩니다.  

ascii 한 문자를 입력으로 받아서 비교시에는 문제가 없지만

>>> a = input("input sth=") input sth=9 >>> a == '9' True >>> a is '9' True >>> a = input("input sth=") input sth=a >>> a == 'a' True >>> a is 'a' True >>> a = input("input sth=") input sth=* >>> a == '*' True >>> a is '*' True

문자열을 입력하여 is 연산자로 비교해보면 값이 같은 객체인데도 False를 리턴합니다.

>>> a = input("input sth=") input sth=abc >>> a == 'abc' True >>> a is 'abc' False >>> a = input("input sth=") input sth=123 >>> a == '123' True >>> a is '123' False

리스트(list)

파이썬에서 문자열은 list 클래스 타입의 객체입니다.

>>> type([1, 2, 3]) <class 'list'>

리스트 타입의 객체는 생성 후  값 수정이 가능한 mutable 객체입니다.

>>> a = [1, 2, 3] >>> id(a) 1421276052552 >>> a[0] = 0    # 변수에 대입한 값을 수정한 후 id 함수 리턴값이 변화없습니다.   >>> id(a) 1421276052552

>>> a = [1, 2, 3]   # 리스트 객체 [1, 2, 3]을 변수 a가 가리킵니다. >>> b = a           # 변수 b도 같은 리스트 객체를 가리키게 됩니다. >>> id(a), id(b) (1629394911880, 1629394911880) >>> a is b      True >>> a == b       True >>> a[0] = 0         # 변수 a가 가리키는 리스트 객체의 첫번째 원소값을 변경해도(새로운 원소를 추가/삭제해도) >>> id(a), id(b) (1629394911880, 1629394911880) >>> a is b        # 변수 a와 b는 여전히 같은 객체를 가리킵니다. True >>> a == b        # 그래서 두 변수가 가리키는 객체의 값이 동일하게 변경되어 있습니다.   True >>> a, b ([0, 2, 3], [0, 2, 3])

두 변수에 대입된 리스트의 원소가 같더라도 다른 객체입니다.

>>> a = [1, 2, 3] >>> b = [1, 2, 3] >>> id(a), id(b) (1629396565064, 1629396595336) >>> a == b     # 변수 a와 b가 가리키는 리스트 객체의 값은 동일하지만 True >>> a is b     # 두 객체는 별개의 객체입니다. False >>> a[0] = 0   # 변수 a가 가리키는 리스트 객체의 값을 변경해도 >>> id(a), id(b) (1629396565064, 1629396595336) >>> a, b ([0, 2, 3], [1, 2, 3])  # 변수 b가 가리키는 리스트 객체에는 영향을 주지 않습니다. >>> a is b False >>> a == b False

리스트 객체의 원소가 immutable 객체인 경우에는 얕은 복사(shallow copy)와 깊은 복사(deep copy)간에 차이가 없습니다.

>>> import copy >>> a = [1, 2, 3] >>> b = copy.copy(a)   # b = a[:] 와  b = list(a)로도 가능 >>> c = copy.deepcopy(a) >>> a == b == c    # shallow copy, deep copy하면 원본 리스트와 값이 같습니다. True >>> id(a), id(b), id(c)  # 하지만 변수가 별개의 개체를 가리키게 됩니다. (2202655015560, 2202656698888, 2202656701704) >>> a[0] = -1  # 원본 a와 얕은 복사한 b와 깊은 복사한 c는 수정시 서로 영향을 주지 않습니다. >>> b[1] = -2 >>> c[2] = -3 >>> a; b; c [-1, 2, 3] [1, -2, 3] [1, 2, -3]

리스트 객체의 원소가 mutable 객체인 경우에는 얕은 복사를 하면 새로 생성된 리스트 객체의 원소가 기존 리스트 객체의 원소를 참조합니다.

>>> import copy >>> a = [['a', 'b', 'c'], [1, 2, 3]] >>> b = copy.copy(a) >>> a == b True >>> a is b          # 변수 a, b는 별개의 객체를 가리키고 있지만 False >>> a[0] is b[0]    # 두 리스트 객체의 원소가 같은 객체를 가리키고 있습니다. True >>> a[1] is b[1] True >>> a[0].append('d')  # 그래서 한쪽 리스트 객체의 원소가 가리키는 객체의 값을 변경하면 >>> a, b ([['a', 'b', 'c', 'd'], [1, 2, 3]], [['a', 'b', 'c', 'd'], [1, 2, 3]]) # 양쪽 객체에 모두 반영 됩니다.

깊은 복사를 해주면 객체의 원소도 새로운 객체가 됩니다.

>>> import copy >>> a = [['a', 'b', 'c'], 1, 257 ] >>> b = copy.deepcopy(a) >>> a == b True >>> a is b    # 깊은 복사를 하면 리스트 객체만 새로 생성되는게 아니라 False >>> a[0] is b[0]    # 원소가 mutable 객체인 경우에는 해당 객체의 복사본이 새로 생성됩니다.   False >>> a[1] is b[1]    # 하지만 immutable 객체인 경우에는 기존 객체를 참조합니다. True >>> a[2] is b[2] True >>> a[0].append('d') # 변수 a, b가 가리키는 객체는 별개의 객체이기 때문에 한쪽 리스트 객체의 원소가 가리키는 객체의 값을 변경해도 >>> a; b [['a', 'b', 'c', 'd'], 1, 257] # 해당 객체의 값만 변할 뿐 [['a', 'b', 'c'], 1, 257]    # 다른 객체에는 영향을 주지 않습니다. >>> b[2] = 1000       >>> a; b [['a', 'b', 'c', 'd'], 1, 257] [['a', 'b', 'c'], 1, 1000]

튜플(tuple)

파이썬에서 튜플은 tuple 클래스 타입의 객체입니다.

>>> type((1,2,3)) <class 'tuple'>

튜플 타입의 객체는 생성 후  값 수정이 불가능한 immutable 객체입니다.

>>> a = (1, 2, 3) >>> id(a) 1421275979208 >>> a[0]=0            # 튜플를 수정하는 것은 불가능합니다. Traceback (most recent call last):  File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> a = (1, 2, 3) + (4,)   # 튜플 객체의 값을 변경하는 메소드를 제공하지 않기 때문에 이런 방법으로 원소를 추가해보면 >>> a (1, 2, 3, 4) >>> id(a)            # 변수 a는 다른 튜플 객체를 가리키게 됩니다. 1421276031320

똑같은 값을 가지는 튜플이라도 다른 객체로 생성됩니다.

>>> a = (100, 200, 300) >>> b = (100, 200, 300) >>> id(a), id(b) (2091230059976, 2091230060120) >>> a is b False >>> a == b True >>> a[0] == b[0] True >>> a[0] is b[0] True

튜플이 immutable 객체이지만  객체의 값으로 mutable 객체에 대한 참조를 포함할 수 있습니다.

튜플은 값을 변경할 수 없는 객체이지만 원소가 참조하고 있는 mutable 객체의 값 변경은 가능합니다.

>>> a = (1 , 'abc', [1, 2, 3]) >>> type(a) <class 'tuple'> >>> type(a[0]); id(a[0]) <class 'int'> 3914390504 >>> type(a[1]); id(a[1]) <class 'str'> 3907260768 >>> type(a[2]); id(a[2])     # 튜플 객체의 세번째 원소가 리스트 객체입니다. <class 'list'> 3906734720 # 튜플은 원소 값을 변경할 수 없습니다. >>> a[0]=1 Traceback (most recent call last):  File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment >>> a[1]=123 Traceback (most recent call last):  File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment # 하지만 세번째 원소는 리스트 객체에 대한  참조이기 때문에 해당 객체의 값변경이 가능합니다. >>> a[2].append(4) # 리스트 객체의 값을 변경해도 세번째 원소는 같은 리스트 객체를 참조하고 있습니다. >>> id(a[2]) 3906734720 >>> a (1, 'abc', [1, 2, 3, 4])  # 세번째 원소인 리스트의 값이 변경되었습니다. # 원소가 참조하는 mutable 객체의 값은 변경가능하지만.. # 원소를 다른 타입의 객체로 변경하는 것은 불가능합니다. >>> a[2]=5 Traceback (most recent call last):  File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment

참고

https://stackoverflow.com/questions/17246693/what-exactly-is-the-difference-between-shallow-copy-deepcopy-and-normal-assignm

https://stackoverflow.com/questions/306313/is-operator-behaves-unexpectedly-with-integers

https://stackoverflow.com/questions/13650293/understanding-pythons-is-operator

https://stackoverflow.com/questions/132988/is-there-a-difference-between-and-is-in-python

https://stackoverflow.com/questions/26595/is-there-any-difference-between-foo-is-none-and-foo-none

https://stackoverflow.com/questions/17599175/python-list-and

https://docs.python.org/3/library/index.html

https://docs.python.org/3/reference/datamodel.html