공부정리

 딕셔너리(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하다는 점을 제외하면 리스트와 거의 다른 점이 없기때문에 
리스트의 기능 중 값을 변경하지 않는 것들은 모두 튜플에서도 사용 가능하며 리스트와의
비교연산 또한 가능하다.

리스트는 다른 언어의 배열과 같은 역할을 하는 기본 자료구조이다.
하지만 파이썬의 리스트는 배열과는 달리 여러 강력한 기능들을 제공한다.

선언

my_list = []				# 빈 리스트 선언
my_list2 = [1, 2, 3, 4]			# 정수형 데이터를 넣은 리스트
my_list3 = [1, 'hello', [2,3,4]]	# 여러 타입의 데이터를 넣은 리스트

 위와같이 리스트는 기본적으로 대괄호안에 데이터를 콤마(,)로 구분하여 생성 가능하다. 특이하게도 하나의 리스트에
들어갈 데이터들간에 타입이 통일되어야 할 필요는 없으며 숫자형 같은 기본적인 자료는 물론 리스트나 튜플 등의
자료구조도 iterable하다면 무엇이든 리스트에 들어갈 수 있다. 

참조

my_list = [1, 3, 5, 7, 9]
print(my_list[3])			# 실행결과 : 7
my_list[2] = 4
print(my_list)				# 실행결과: [1, 3, 4, 7, 9]

 리스트의 참조는 C나 Java의 배열과 동일하게 <리스트>[인덱스] 의 형태로 이루어진다.

값의 변경은 <리스트>[변경할_데이터의_인덱스] = <변경할_값> 의 형태로 가능하다.

삽입

1. append

my_list = [1, 2, 3, 4, 5]
my_list.append(6)
print(my_list)			# 실행결과 : [1, 2, 3, 4, 5, 6]

 리스트의 끝에 데이터를 삽입할 경우 리스트에 내장된 append 메소드를 사용한다.  append 함수에 전달할 인자로는
숫자형 등의 기본 자료형이나 문자열, 리스트, 튜플 등의 iterable한 자료구조들을 사용할 수 있다. 

2. insert

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, 6)
print(my_list)			# 실행결과 : [1, 2, 6, 3, 4, 5]

 리스트의 원하는 인덱스에 데이터를 삽입할 경우 리스트에 내장된 insert 메소드를 사용한다. 
위 코드에서 my_list.insert(2, 6)을 호출하여 인덱스 2에 데이터값 6을 삽입한 것을 확인할 수 있다.

확장

my_list = [1, 2, 3, 4, 5]
my_list.append([6, 7, 8, 9])
print(my_list)		# 실행결과 : [1, 2, 3, 4, 5, [6, 7, 8, 9]]

my_list2 = [1, 2, 3, 4, 5]
my_list2.extend([6, 7, 8, 9])
print(my_list2)		# 실행결과 : [1, 2, 3, 4, 5, 6, 7, 8, 9]

 append 메소드에 인자로 iterable한 인스턴스를 전달할 경우 그 인스턴스 자체가 하나의 데이터로서 삽입된다.

하지만 extend 메소드를 사용할 경우 전달된 인스턴스 내부의 데이터를 각각 리스트에 삽입한 결과를 얻을 수 있다.

삭제

1. del 명령어

my_list = ['alice', [2, 3, 4, 5], 7]
print(my_list)		# 실행결과 : ['alice', [2, 3, 4, 5], 7]
del my_list[1]
print(my_list)		# 실행결과 : ['alice', 7]

 리스트의 기본적인 데이터 삭제는 del 명령어를 사용할 수 있다.  del <리스트>[삭제할_데이터의_인덱스] 의 형태이다.

2. pop 메소드

my_list = [1, 2, 3, 4, 5]
print(my_list)		# 실행결과 : [1, 2, 3, 4, 5]
print(my_list.pop())	# 실행결과 : 5
print(my_list)		# 실행결과 : [1, 2, 3, 4]

 리스트에 내장된 pop 메소드를 사용할 경우 stack과 같이 가장 마지막의 데이터를 반환하고 리스트 내에서 삭제한다.

append 메소드와 pop 메소드만을 사용해서 값의 삽입/삭제를 실행할 경우 리스트를 stack과 동일하게 사용 가능하다.

3. remove 메소드

my_list = [1, 3, 2, 4, 5]
print(my_list)		# 실행결과 : [1, 3, 2, 4, 5, 3]
my_list.remove(3)
print(my_list)		# 실행결과 : [1, 2, 4, 5, 3]

 리스트에 내장된 remove 메소드는 인자로 넘겨준 데이터와 리스트의 데이터들을 대조하여 처음으로 발견된
동일한 데이터를 삭제한다.  

4. clear 메소드

my_list = [1, 3, 2, 4, 5, 3]
print(my_list)	# 실행결과 : [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)	# 실행결과 : []

 리스트에 내장된 clear 메소드는 리스트 내의 모든 데이터를 삭제한다.  결과는 del <리스트>[ : ]를 호출한 것과 같다.

슬라이싱

my_list = ['zero', 'one', 'two', 'three', 'four', 'five']
my_sub_list = my_list[2:5]
print(my_sub_list)			# 실행결과 : ['two', 'three', 'four']

 리스트에서 원하는 구간만을 가져올 경우 <리스트>[첫_인덱스 : 마지막_인덱스+1] 의 형태로 슬라이싱이 가능하다.

위 코드와 같이 구간을 [2 : 5] 로 지정할 경우 인덱스 2부터 4까지 총 세개의 데이터를 잘라서 반환한다.

정렬

1. sort()

my_list = [1, 4, 2, 5, 3]
print(my_list)		# 실행결과 : [1, 4, 2, 5, 3]
my_list.sort()
print(my_list)		# 실행결과 : [1, 2, 3, 4, 5]

 리스트에는 리스트에 들어있는 데이터들을 정렬해주는 sort() 메소드가 내장되어있다.  sort() 메소드를 호출할 경우

리스트에 들어있는 값들이 모두 서로 비교 가능하다면 기준에 맞게 오름차순으로 정렬해준다.

2. sorted()

my_list = [1, 4, 2, 5, 3]
print(my_list)				# 실행결과 : [1, 4, 2, 5, 3]
my_list_sorted = sorted(my_list)
print(my_list)				# 실행결과 : [1, 4, 2, 5, 3]
print(my_list_sorted)			# 실행결과 : [1, 2, 3, 4, 5]

 리스트를 정렬하는 방법으로 sorted() 라는 메소드도 존재한다. 이 메소드는 인자로 정렬하려는 리스트를 전달하여
호출하면 원본 리스트는 건드리지 않고 정렬한 결과만을 리스트의 형태로 반환하는 메소드이다. 
위 코드를 실행해보면 원본인 my_list는 그대로지만 sorted() 메소드의 반환값을 저장한 my_list_sorted는 정렬된 상태로
출력되는 것을 확인할 수 있다.

3. 추가인자 - reverse

# 추가인자 reverse
my_list = [1, 4, 2, 5, 3]
print(my_list)		# 실행결과 : [1, 4, 2, 5, 3]
my_list.sort(reverse=True)		
print(my_list)		# 실행결과 : [5, 4, 3, 2, 1]

 sort(), sorted() 메소드에 추가인자로 reverse 값을 전달할 수 있다.  위 코드처럼 reverse 값으로 True를 전달할 경우

정렬조건을 반대로 하여 내림차순 정렬이 되는 것을 확인할 수 있다.

4. 추가인자 - key

# 추가인자 key
my_list = [[1, 3], [5, 2], [5, 1], [6, 4], [2, 7]]
my_list_sorted1 = sorted(my_list, key = lambda x : x[0])
my_list.sort(key = lambda x : (-x[0], x[1]))
print(my_list)		# 실행결과 : [[6, 4], [5, 1], [5, 2], [2, 7], [1, 3]]
print(my_list_sorted1)	# 실행결과 : [[1, 3], [2, 7], [5, 2], [5, 1], [6, 4]]

 sort(), sorted() 메소드에 추가인자로 key 값을 전달할 수도 있다.  key는 정렬의 기준을 제시하는 함수이다.
위 코드는 람다함수를 key로 전달하여 my_list_sorted1 에는 리스트의 첫 인자를 기준으로 오름차순 정렬한 결과를,

my_list에는 리스트의 첫 인자를 기준으로는 내림차순, 첫 인자가 같다면 둘째 인자를 기준으로 오름차순 정렬한 결과를

저장한 것이다.

카운팅

my_list = [1, 3, 2, 4, 5, 3, 3]
how_many_three = my_list.count(3)
print(how_many_three)	# 실행결과 : 3

 리스트에 내장된 count 메소드는 인자로 전달된 데이터와 같은 데이터가 리스트 내부에 몇개 있는지 반환한다.

위 코드에선 my_list에 3이 3개 존재하기 때문에 3이 반환되는 것을 볼 수 있다.

복사 ( 대입, list.copy(), copy.deepcopy() )

import copy
my_list = [1, 2, 3, 4, [5, 6, 7, 8]]

my_list_copy1 = my_list			# 단순 대입
my_list_copy2 = my_list.copy()		# 얕은 복사
my_list_copy3 = copy.deepcopy(my_list)	# 깊은 복사

my_list[0] = 9
my_list[4][0] = 7

print(my_list_copy1)	# 실행결과 : [9, 2, 3, 4, [7, 6, 7, 8]]
print(my_list_copy2)	# 실행결과 : [1, 2, 3, 4, [7, 6, 7, 8]]
print(my_list_copy3)	# 실행결과 : [1, 2, 3, 4, [5, 6, 7, 8]]

단순대입으로 복사한 my_list_copy1 의 경우 원본과 같은 인스턴스를 가리키기 때문에 my_list의 변경이 모두 반영된다.

얕은복사본을 저장한 my_list_copy2 의 경우 리스트의 내장메소드인 copy를 사용하여 my_list와는 별도의 인스턴스지만
마지막 데이터인 리스트 [5, 6, 7, 8]의 경우 같은 인스턴스를 가리키기 때문에 my_list의 두 번째 변경이 반영된다.

깊은복사본을 저장한 my_list_copy3의 경우 copy 모듈의 deepcopy 메소드를 사용하여 리스트 데이터도 값만 같은
별도의 인스턴스를 가리키기 때문에 my_list에 가해진 변경이 일체 영향을 미치지않는 것을 볼 수 있다.

copy 모듈에 대해서는 추후 모듈에 대해 공부할 때 추가적으로 정리하도록 한다.

출력문 

 python에선 숫자나 문자열 등의 데이터를 출력하는 코드를 다음과같이 간단하게 작성 가능하다

print('Hello World!')	# 실행결과 : Hello World!

 또한 여러개의 값을 이어서 출력할 경우 다음과 같이 작성 가능하다

print('Hello', 'World!')  # 실행결과 : Hello World!

이처럼 이어서 출력할 값들을 ,(콤마)로 구분할 경우 값 사이를 띄어쓰기로 구분하여 출력된다.

자료형

• 숫자형
  • int : 정수 자료형
  • float : 실수 자료형
  • complex : 복소수 자료형
• 논리형 : True / False

기본 자료구조

• 시퀀스(Sequence) : 문자열, 리스트, 튜플
• 매핑 : 사전(dictionary)
• 집합(set)

변수선언

• 변수의 타입을 런타임에 동적으로 추론하는 방식이기에 선언 후 초기화가 불가능
• 초기화되지 않았음을 표현하기 위해 None을 초기화 값으로 사용

# var		// 초기화 없이 선언할 수 없음
var = None
var = 3

연산

• 기본적인 사칙연산 ( +, -, *, / )
  • 기존에 배운 언어와 달리 정수형끼리의 나누기 연산의 결과도 실수형태이다.

• 몫/나머지 : a//b (몫) , a%b (나머지)
• 제곱 : n**k
• 문자열의 연산
  • 문자열+문자열 : 두 문자열을 이어붙인 문자열이 결과로 반환된다.
  • 문자열*정수형 : 문자열을 곱한 정수만큼 반복하여 이어붙인 문자열이 결과로 반환된다.

print(3 / 5)	# 실행결과 : 0.6
print(7 // 5) 	# 실행결과 : 1
print(7 % 5)	# 실행결과 : 2
print(2 ** 4)	# 실행결과 : 16
print('Hello' + 'World!')	# 실행결과 : HelloWorld!
print('Hello World!' * 3)	# 실행결과 : Hello World!Hello World!Hello World!

주석

• ㄱ한줄 주석 : # 뒤의 모든 내용을 주석으로 처리한다.
• 여러줄 주석 : """ ~ """ , ''' ~ ''' 3연속의 큰따옴표 또는 작은따옴표 사이의 내용을 주석으로 처리한다.
• 윈도우 환경에서 대부분의 idle에서는 ctrl+/ 단축키로 주석처리가 가능하다
• 파이썬 자체 idle의 경우 alt+3으로 주석 처리, alt+4로 주석 제거가 가능하다.

# 한줄 주석
print('Hello')
'''
여러줄
주석
'''
print('World!')


# 실행결과
Hello
World!

들여쓰기

• python에서는 다른 언어에서 보통 중괄호로 나타내던 명령어의 종속성을 들여쓰기로 표현함
• 보통 띄어쓰기 4번의 들여쓰기로 구분하는것을 추천함

for num in [1,2,3]
    print(num)		# 들여쓰기로 for문에 종속됨

 코딩테스트 준비를 시작하면서 주로 쓰던 언어인 자바보다 python을 사용하는게
유리할 수 있다는 이야기를 들었다. 마침 요즘 인기있는 언어이기도 하고 node.js와 함께
서버개발에도 사용된다고 해서 백엔드 개발자가 목표인 나에게도 배울 가치가 있다고 생각하여 공부를 시작한다.