공부정리

 json이란 JavaScript Object Notation의 줄임말로, JavaScript 에서 객체를 표현하는데 사용되는

방식에서 파생된 경량의 데이터 교환 형식이다.  데이터를 직렬화(Serialization)하는데 자주 사용되는

형식이다.  Python 에서는 json을 다루기 위한 내장모듈 json을 지원한다. 

json 모듈의 가장 기본적인 네 가지 메소드와 사용 예시는 다음과 같다.

import json

# 예시용 오브젝트
sample_object = {
    "json_string": "string_example",
    "json_number": 100,
    "json_array": [1, 2, 3, 4, 5],
    "json_object": { "name":"John", "age":30},
    "json_bool": True
}

# Python 오브젝트를 json 문자열로 파싱
json_string = json.dumps(sample_object)
print(json_string)

# json 문자열을 Python 오브젝트로 파싱
json_object = json.loads(json_string)
for key in json_object:
    print(key)

# 실행 결과
# {"json_string": "string_example", "json_number": 100, "json_array": [1, 2, 3, 4, 5], "json_object": {"name": "John", "age": 30}, "json_bool": true}
# json_string
# json_number
# json_array
# json_object
# json_bool

dumps 와 loads 를 사용하여 Python 객체를 json 문자열로 파싱하고 다시 Python 객체로 파싱한 코드이다.

import json

# 예시용 오브젝트
sample_object = {
    "json_string": "string_example",
    "json_number": 100,
    "json_array": [1, 2, 3, 4, 5],
    "json_object": { "name":"John", "age":30},
    "json_bool": True
}

# Python 오브젝트를 json 문자열로 파싱하여 파일에 쓴다
f = open('json_file', 'w')
json_string = json.dump(sample_object, f)

# 저장한 파일을 읽어들여 다시 Python 오브젝트로 파싱한다.
f = open('json_file', 'r')
json_object = json.load(f)
for key in json_object:
    print(key)

# 실행 결과
# json_string
# json_number
# json_array
# json_object
# json_bool

dump 와 load 를 사용하여 Python 객체를 json 파일로 저장하고 그 파일을 읽어들여 다시 Python 객체로 파싱한

코드이다.

1. 조건문 (if, elif, else)

# score>90 : A | score>80 : B | other : C

# score가 90보다 큰 경우
if score > 90:
	print('A')
    
# score가 90보다 크지는 않지만 80보다는 큰 경우
elif score > 80:
	print('B')
    
# 위 두 조건을 모두 만족하지 않는 경우
else:
	print('C')

 파이썬의 조건문 또한 다른 언어에서의 if else문과 거의 유사한 형태를 가진다.  else if 는 elif로 표기하며 이전

기본문법에도 설명했듯이 블록은 들여쓰기로 구분한다.  조건문 내의 명령문이 한 줄일 경우 : 뒤에 바로 명령문을

이어붙여 한줄로 처리하는 것도 가능하다.  조건문 자리에 숫자형 데이터가 올 경우 0은 False, 그 외에는 True로

처리하며 문자열이나 리스트 등이 올 경우 비어있으면 False, 비어있지 않으면 True로 처리한다.

 파이썬에서 조건문 내부는 비워둘 수 없기 때문에 미구현 상태로 둘 경우 아무것도 하지 않고 넘어가는 pass 키워드나

의도적으로 예외를 발생시키는 raise 키워드를 사용 가능하다.(미구현 상태임을 나타내기 위해)

 파이썬에는 switch문에 대응하는 문법은 존재하지 않기 때문에 조건문은 if문이 전부이며 굳이 switch문을 써야하는

상황일 경우 dictionary에 함수를 매핑하는 방식을 사용할 수는 있다.

2. 반복문 (while문, for문)

 - while 문

num = 0
while num<11:
	print(num)
    num += 1
    
#실행결과
0
1
2
3
4
5
6
7
8
9
10

 조건문이 참인 동안은 내부의 명령문을 반복수행한다.  다른 언어의 while문과 마찬가지로 break, continue 키워드를

사용 가능하며 do while문은 별도로 존재하지 않는다.  

 - for 문

# 일반적인 for문
nums = [1, 2, 3, 4, 5]
for num in nums:
	print(num, end=' ')	# 실행결과: 1 2 3 4 5
    
print()

# 언패킹을 활용한 for문
pairs = [(1, 5), (2, 4), (3, 3)]
for x, y in pairs:
	print(f'({x}, {y})', end=' ')	# 실행결과: (1, 5) (2, 4) (3, 3)

print()

# range를 활용한 for문
for i in range(10):
	print(i, end=' ')	# 실행결과: 0 1 2 3 4 5 6 7 8 9

 파이썬의 for문은 기본적으로 Java의 enhanced for와 같은 구조로 돼어있다.  for <var> in <iterable>의 형태로

iterable한 자료구조 내부의 데이터들을 순차적으로 참조하는 방식이다.  또한 참조할 데이터가 튜플이나 리스트 등의

형태일 경우 여러개의 변수에 언패킹하여 참조하는 것도 가능하다. 

 다른 언어에서 사용하던 인덱스 방식의 for문을 사용하고 싶을 경우 range와 함께 사용 가능하다. range는 유한한 구간 내의 정수들의 집합을 나타내는 자료구조이다.  range에 대한 자세한 내용은 이후 별도로 포스팅하기로 한다.

  Python에서 함수를 선언할 때 이름 앞에 * 또는 **이 붙은 특수한 형태의 매개변수를 사용 가능하다.  

 1.  *매개변수 (가변 개수 매개변수)

def func1(*args):
	print(args)
   

def func2(num, *args):
	print(num, args)
  
   
func1(1, 2, 3, 4)	# 실행결과: (1, 2, 3, 4)
func2(1, 2, 3, 4)	# 실행결과: 1 (2, 3, 4)

 매개변수명 앞에 *을 붙일 경우 매개변수들을 튜플의 형태로 묶어 전달받게된다.  이러한 형태의 매개변수는 하나만

사용 가능하며(두 개 이상 사용될 경우 서로 구분이 불가능) 일반적인 매개변수와 함께 사용 가능하다. 이 경우 일반

변수는 호출 시에 변수이름을 명시하거나 가변 개수 매개변수보다 먼저 입력받도록 선언해야한다.

2. **매개변수 (키워드 매개변수)

def func1(**args):
	print(args)


def func2(num, **args):
	print(num, args)
   
   
func1(a=2)		# 실행결과: {'a': 2}
func2(3, a=3)		# 실행결과: 3 {'a': 3}

 매개변수명 앞에 **을 붙일 경우 key=value형태의 매개변수를 dictionary 타입으로 저장한다.  일반 매개변수나

가변 개수 매개변수와 혼용할 경우 반드시 마지막으로 입력받도록 선언해야한다. 

 파이썬에서 값을 입력받는 다양한 방법에 대해 알아본다

1. input()

print(input())	# 결과: 마지막 개행문자를 제외한 라인 전체

 input()은 파이썬에서 사용자 입력을 받기 위한 가장 기본적인 함수이다.  기본적으로 line 단위로 입력을 받는 함수이며

입력받은 내용을 마지막의 개행문자를 제거한 문자열의 형태로 반환한다.  EOF를 읽을 경우 EOFError를 발생시킨다.

인자로 문자열을 넘겨줄 경우 개행없이 출력해준다.(prompt)

2. sys.stdin.readline()

import sys
input = sys.stdin.readline()
print(input())	# 결과: 마지막의 개행문자를 포함한 라인 전체

 sys.stdin.readline()은 input()과 마찬가지로 사용자 입력을 line 단위로 받을 수 있는 함수이다.  input()과 다른 점은

마지막 개행문자를 제거해주지 않으며 prompt 매개변수를 받지 않는다는것, 그리고 EOF를 만났을때 EOFError를 

발생시키지 않고 빈 문자열을 반환한다는 점이다.  

 많은 양의 입력을 처리해야 할 때 sys.stdin에 정의된 함수들은 사용자 입력을 받아오기 위한 버퍼를 생성하여

입력을 처리하기에 내장함수 input을 사용하는 것 보다 매우 빠른 속도를 보인다.

3. sys.stdin.readlines()

import sys
input = sys.stdin.read()
s = input()

 sys.stdin.readlines()는 입력을 line 단위로 끊어 리스트의 형태로 반환하는 함수이다.  readline 함수를 여러번 호출하여 리스트에 집어넣은 것과 같다. 

4. sys.stdin.read()

import sys
input = sys.stdin.read()
s = input()

 sys.stdin.read()는 EOF를 만나기 전까지 모든 입력을 하나의 문자열로 반환하는 함수이다.  

 힙(heap)은 느슨한 정렬상태를 유지하여 루트 노드에 항상 최대, 혹은 최소값이 오도록 하는 트리형

자료구조이다. 이 구조를 활용하여 삽입된 데이터중 보다 우선순위가 높은 것을 먼저 반환하는

우선순위 큐를 구현할 수 있다.

파이썬에서는 heapq 모듈에 정의된 함수를 사용하여 리스트를 우선순위 큐로 사용한다.

import heapq

q = []

heapq.heappush(q, 3)
heapq.heappush(q, 1)
heapq.heappush(q, 8)

for _ in range(len(q)):
 print(heapq.heappop(q), end=' ') # 결과: 1 3 8

 위 코드와 같이 heappush() , heappop() 함수를 통해 힙을 유지하며 삽입하고 최소값을 우선적으로 반환받을 수 있다.

heapq는 기본적으로 최소 힙이며 최대 힙을 구현하고싶을 경우 키 값을 음수형태로 취하는 방식을 사용할 수 있다.

heappop()은 O(1)의 시간복잡도를, heappush()는 O(logN)의 시간 힙(heap)은 느슨한 정렬상태를 유지하여 루트 노드에 항상 최대, 혹은 최소값이 오도록 하는 트리형 자료구조이다.

이 구조를 활용하여 삽입된 데이터중 보다 우선순위가 높은 것을 먼저 반환하는 우선순위 큐를 구현 가능하다.

파이썬에서는 heapq 모듈에 정의된 함수를 사용하여 리스트를 우선순위 큐로 사용할 수 있다.

import heapq

q = []
heapq.heappush(q, 3)
heapq.heappush(q, 1)
heapq.heappush(q, 8)
for _ in range(len(q)):
	print(heapq.heappop(q), end=' ') # 결과: 1 3 8

 위 코드와 같이 heappush() , heappop() 함수를 통해 힙을 유지하며 삽입하고 최소값을 우선적으로 반환받을 수 있다.

heapq는 기본적으로 최소 힙이며 최대 힙을 구현하고싶을 경우 키 값을 음수형태로 취하는 방식을 사용할 수 있다.

heappop()은 O(1)의 시간복잡도를, heappush()는 O(logN)의 시간복잡도를 가진다.

값의 삭제 없이 최소값을 확인만 하고싶은 경우 단순히 인덱스 0 을 참조하면 된다.

기존에 값이 들어있는 리스트를 힙으로 사용하려면 heapq.heapify(<리스트>) 함수를 사용할 수 있다.

heapify() 함수는 리스트의 요소들을 하나하나 heappush()한 것과 같은 결과를 내며 O(N)의 시간복잡도를 가진다.

 데크(deque)는 큐(queue)의 일종으로 양 방향에서 삽입/삭제가 가능한 선형자료구조이다.

파이썬에서는 collections 모듈에 정의된 데크를 사용 가능하다.

from collections import deque

q = deque()

q.append(3)
print(q)	# 결과: deq([3])

q.appendleft(4)
print(q)	# 결과: deque([4, 3])

print(q.popleft())
print(q)	# 결과: deque([3])

 위 코드와 같이 기존 리스트에서 사용 가능했던 append(), pop()에 더해 좌측 끝에서 삽입/삭제를 수행하는

appendleft(), popleft() 함수를 사용 가능하다.  이 두 함수는 O(1)의 시간복잡도를 가지기에 기존 리스트에서

insert()와 del 을 사용한 좌측 끝의 삽입 삭제보다 효율적이다.

 파이썬은 함수의 재귀호출 횟수가 기본 1000회로 제한되어있다.  기본 횟수 이상으로 재귀호출을 해야할 경우

제한 횟수를 다시 설정해줘야한다.

import sys

# 현재 재귀 제한 횟수를 가져옴
limit = sys.getrecursionlimit()
print(limit)	# 결과: 1000

# 재귀 제한 횟수를 재설정
sys.setrecursionlimit(1500)

# 변경된 재귀 제한 횟수를 가져옴
limit = sys.getrecursionlimit()
print(limit)	# 결과: 1500

 위 코드와 같이 sys.getrecursionlimit() 함수를 호출하여 현재 재귀호출 횟수 제한 값을 가져오고

sys.setrecursionlimit() 함수를 호출하여 횟수 제한을 재설정 할 수 있다.

 집합(Set)은 순서가 없고(non-sequence) 변경 가능(mutable)하며 중복을 허용하지 않는 자료구조이다.

집합의 원소로 다양한 타입의 데이터가 사용될 수 있지만 mutable한 데이터는 사용 불가능하다. 

주로 멤버십(집합과 원소의 포함 관계) 검사나 데이터의 중복의 제거, 합집합, 교집합, 차집합 등의 집합 간 연산을 활용하기 위한 용도로 사용된다.

선언

my_set1 = {1, 2, 3, 4, 5}
my_set2 = set([1, 2, 3])
my_set3 = set('hello')
print(my_set1)	# 실행결과: {1, 2, 3, 4, 5}
print(my_set2)	# 실행결과: {1, 2, 3}
print(my_set3)	# 실행결과: {'l', 'h', 'o', 'e'}

 집합의 선언은 중괄호 안에 직접 원소를 명시하는 방식과 set 메소드를 호출하는 방식이 있다.

set 메소드의 인자로는 iterable한 인스턴스가 올 수 있으며 집합이 생성되는 과정에서 중복은 제거되며
순서는 유지되지 않는다.  이러한 성질을 활용하여 중복 데이터를 제거하기 위해 집합을 활용하기도 한다.

삽입

1. add 메소드

my_set = {1, 2, 3, 4, 5}
my_set.add(6)
print(my_set)	# 실행결과: {1, 2, 3, 4, 5, 6}

  집합에 하나의 값을 추가한다. 

2. update 메소드

my_set = {1, 2, 3, 4, 5}
my_set.update([5, 6, 7])
print(my_set)	# 실행결과: {1, 2, 3, 4, 5, 6, 7}

  집합에 여러개의 값을 추가한다.  이 과정에서 중복데이터는 제거된다.

삭제

1. remove 메소드

my_set = {1, 2, 3, 4, 5}
my_set.remove(3)
print(my_set)		# 실행결과: {1, 2, 4, 5}

my_set.remove(3)	# 실행결과: KeyError 발생

 인자로 넘겨준 값을 삭제한다.  제거하려는 데이터가 존재하지 않는 경우 KeyError를 발생시킨다

2. discard 메소드

my_set = {1, 2, 3, 4, 5}
my_set.discard(3)
print(my_set)		# 실행결과: {1, 2, 4, 5}
my_set.discard(3)
print(my_set)		# 실행결과: {1, 2, 4, 5}

 remove와 동일하게 인자로 넘겨준 값을 삭제한다.  remove와 달리 제거하려는 데이터가 존재하지 않아도 에러를

발생시키지 않는다.

집합연산

my_set1 = {1, 2, 3, 4, 5}
my_set2 = {4, 5, 6, 7, 8}

# 합집합
uni_set1 = my_set1 | my_set2
uni_set2 = my_set1.union(my_set2)
print(uni_set1)		# 실행결과: {1, 2, 3, 4, 5, 6, 7, 8}
print(uni_set2)		# 실행결과: {1, 2, 3, 4, 5, 6, 7, 8}

# 차집합
dif_set1 = my_set1 - my_set2
dif_set2 = my_set1.difference(my_set2)
print(dif_set1)		# 실행결과: {1, 2, 3}
print(dif_set2)		# 실행결과: {1, 2, 3}

# 교집합
int_set1 = my_set1 & my_set2
int_set2 = my_set1.intersection(my_set2)
print(int_set1)		# 실행결과: {4, 5}
print(int_set2)		# 실행결과: {4, 5}

# 대칭차집합 (합집합 - 교집합)
sym_set1 = my_set1 ^ my_set2
sym_set2 = my_set1.symmetric_difference(my_set2)
print(sym_set1)		# 실행결과: {1, 2, 3, 6, 7, 8}
print(sym_set2)		# 실행결과: {1, 2, 3, 6, 7, 8}

 집합 연산에는 연산자를 사용한 방식과 연산을 위한 set의 내장메소드를 사용하는 방법이 있다.

합집합 연산 : 연산자 | 또는 내장메소드 union

차집합 연산 : 연산자 - 또는 내장메소드 difference

교집합 연산 : 연산자 & 또는 내장메소드 intersection

대칭차집합 연산 : 연산자 ^ 또는 내장메소드 symmetric_difference

포함관계

my_set1 = {1, 2, 3, 4, 5}
my_set2 = {3, 4, 5}
my_set3 = {6, 7, 8}

# 부분집합 여부 (a.issubset(b) : a가 b의 부분집합일 경우 True, 아닐경우 False)
print(my_set1.issubset(my_set2))	# 실행결과: False
print(my_set2.issubset(my_set1))	# 실행결과: True

# 상위집합 여부 (a.issuperset(b) : a가 b를 포함할 경우 True, 아닐경우 False)
print(my_set2.issuperset(my_set1))	# 실행결과: False
print(my_set1.issuperset(my_set2))	# 실행결과: True

# 교집합 유무 (a.isdisjoint(b) : a와 b의 교집합이 없을 경우 True, 아닐경우 False)
print(my_set1.isdisjoint(my_set2))	# 실행결과: False
print(my_set1.isdisjoint(my_set3))	# 실행결과: True

 집합간의 포함관계를 확인하기 위한 내장 메소드로 issubset, issuperset, isdisjoint 가 있다.

 복사의 경우 다른 자료구조들과 마찬가지로 내장된 copy메소드를 호출하여 얕은 복사본을 만들 수 있다.

집합의 경우 그 원소로 immutable한 값만이 올 수 있기에 깊은복사는 의미가 없다.

 딕셔너리(Dictionary)는 데이터를 <Key, Value> 한 쌍의 형태로 저장하는 non-sequence한(순서가없는)
자료구조이다.  Key 값을 인덱스로 사용하여 데이터를 저장하기 때문에 키 값을 통해 데이터에 빠르게
접근할 수 있다. 

선언

my_dict = { }
my_dict2 = {'red':1, 'blue':2, 'green':3}
print(my_dict)		# 실행결과 : {}
print(my_dict2)		# 실행결과 : {'red': 1, 'blue': 2, 'green': 3}

my_tuple = (('red', 1), ('blue', 2), ('green', 3))
my_dict3 = dict(my_tuple)
print(my_dict3)		# 실행결과 : {'red': 1, 'blue': 2, 'green': 3}

 딕셔너리는 중괄호 안에 key, value 를 콜론(:)으로 구분하여 나열하거나 dict() 메소드에 key,value 형태의 데이터들을 가진 map 또는 iterable한 인스턴스를 인자로 넘겨 생성 가능하다. (튜플, 리스트, 딕셔너리 등)

참조

my_dict = {'red':1, 'blue':2, 'green':3}
print(my_dict['red'])		# 실행결과 : 1
print(my_dict.get('red'))	# 실행결과 : 1

 딕셔너리의 데이터 참조는 <딕셔너리>[참조할_KEY값] 또는 <딕셔너리>.get(<참조할_KEY값>) 메소드의
호출을 통해 가능하다.  get 메소드의 경우 추가인자로 default값을 줄 수 있는데, 이는 딕셔너리에 찾으려는
Key 값이 없을 경우 반환할 값을 의미한다.  지정하지 않을 경우 None으로 설정되어있다.

삽입

my_dict = {'red':1, 'blue':2, 'green':3}
my_dict['black'] = 0
print(my_dict)	# 실행결과 : {'red': 1, 'blue': 2, 'green': 3, 'black': 0}

 딕셔너리의 데이터 삽입은 <딕셔너리>[추가할_KEY값] = [추가할_VALUE값] 의 형태로 이루어진다.

딕셔너리는 삽입 순서를 보장하기 때문에 출력 시 Key, Value 쌍은 삽입한 순서대로 보여진다.

삭제

my_dict = {'red':1, 'blue':2, 'green':3, 'white':4, 'orange':5}
del my_dict['red']
print(my_dict.pop('blue'))		# 실행결과 : 2
print(my_dict.popitem())		# 실행결과 : {'orange': 5}
print(my_dict)    			# 실행결과 : {'green': 3, 'white': 4}
my_dict.clear()
print(my_dict)				# 실행결과 : {}

 딕셔너리의 데이터 삭제는 리스트와 동일하게 del 명령어를 사용한방법, clear 메소드를 통한 전체삭제가 가능하며 pop(<삭제할_KEY값>) 메소드의 호출로 특정 키값을 비복원 추출 형태로 삭제 가능하다.
스택처럼 마지막에 삽입된 데이터쌍을 삭제/반환하고 싶을 경우 popitem() 메소드를 사용 가능하다.

pop 메소드의 경우 삭제 후 value만을 반환하지만 popitem 메소드의 경우 key, value쌍을 반환한다. 

기타 메소드

1. <KEY> in <딕셔너리>

my_dict = {'red':1, 'blue':2, 'green':3}
print('red' in my_dict)	# 실행결과 : True
print('red' not in my_dict)	# 실행결과 : False

 <KEY> in <딕셔너리> 연산은 <딕셔너리>에 저장된 키 값에 <KEY>가 존재하는지 여부를 논리형으로 반환

not in 연산의 경우 in 연산의 반대의 결과를 반환

2. list(<딕셔너리>)

my_dict = {'red':1, 'blue':2, 'green':3}
list_form_my_dict = list(my_dict)
print(list_form_my_dict)  # 실행결과 : ['red', 'blue', 'green']

 list 메소드에 딕셔너리를 인자로 넘길 경우 딕셔너리에 저장된 key 값들을 리스트화하여 반환한다. value, 또는
<key, value>쌍의 형태로 리스트화 하고싶다면 각각의 뷰 객체를 반환하는 <딕셔너리>.values(), <딕셔너리>.items()을
인자로넘겨야 한다.

3. reverse(<딕셔너리>)

my_dict = {'red':1, 'blue':2, 'green':3}
print(list(reversed(my_dict)))  # 실행결과 : ['green', 'blue', 'red']

 reverse 메소드에 딕셔너리를 인자로 넘길 경우 딕셔너리에 저장된 key 값들의 역순 이터레이터를 반환한다.

list 메소드와 마찬가지로 value나 <key, value>쌍의 형태로 역순 이터레이터를 얻고싶다면 <딕셔너리>.values(), 
<딕셔너리>.items()을 인자로넘겨야 한다.

 튜플은 리스트와 거의 같은 기능을 가지지만 리스트와 달리 불변(Immutable) 타입이라는 특징을 가진다.

리스트가 보통 같은 타입의 데이터를 저장하며 데이터의 접근 또한 iterating의 형태로 이루어진다면

튜플은 대개 다른 타입의 데이터들을 저장하고 indexing이나 unpacking의 형태로 접근하는 경우가 많다.

딕셔너리(Dictionary)나 집합(Set)에 사용하는 경우 튜플에 같은 타입의 데이터를 저장하는 경우도 있다.

선언

my_tuple = (1, 2, 3, 4, 5)	# 길이 5의 튜플이 생성된다
my_tuple2 = (1)			# 튜플이 아닌 값 1을 가지는 숫자형 변수가 된다
my_tuple3 = (1,)		# 길이 1의 튜플이 생성된다
my_tuple4 = 1, 2, 3, 4		# 길이 4의 튜플이 생성된다

 튜플을 선언 및 초기화할 때는 데이터를 콤마(,)로 구분해주면 된다. 괄호는 넣어도 넣지않아도 상관없다.

다만 유의해야할 점은 단순히 괄호안에 하나의 데이터를 넣으면 튜플이 아니라 그 데이터를 가리키는 

단순한 변수가 되기때문에 크기 1의 튜플을 만들고싶다면 위 코드처럼 콤마(,)를 넣어줘야한다.

언패킹 (Unpacking)

my_info = ('scala', 27, (95, 80, 97))
my_name, my_age, my_score = my_info
print(my_name)	# 실행결과 : scala
print(my_age)	# 실행결과 : 27
print(my_score) # 실행결과 : (95, 80, 97)

 튜플의 데이터 접근에 주로 사용되는 방식으로 언급했던 언패킹(Unpacking) 방식이다. 

좌변에 나열한 변수들에 튜플에 저장된 순서대로 값을 저장한다.  언패킹 대상 변수의 수가 튜플의 크기와
일치하지 않을 경우에는 에러가 발생한다.  당연하게도 언패킹은 리스트에서도 똑같이 사용 가능하다. 

 튜플은 기본적으로 immutable하다는 점을 제외하면 리스트와 거의 다른 점이 없기때문에 
리스트의 기능 중 값을 변경하지 않는 것들은 모두 튜플에서도 사용 가능하며 리스트와의
비교연산 또한 가능하다.