오리오리오리

제너레이터는 지연 평가(lazy evaluation) 구현체이다.

즉, 객체의 값을 미리 생성해서 저장해 두지 않고 해당 객체를 사용할 때 값을 계산해서 반환해준다.

제너레이터는 소괄호()를 이용한 컴프리헨션으로 생성할 수 있다.

num = (x for x in range(10))
print(num)

>><generator object <genexpr> at 0x00000214166F4AC8>

위의 설명처럼 객체를 사용할 때 값을 계산해주므로 for문으로 제너레이터를 사용해보면

num = (x for x in range(10))
for x in num:
    print(x, end=' ')
    
>>0 1 2 3 4 5 6 7 8 9 

next함수로도 제너레이터의 사용이 가능하다. next함수는 제너레이터의 다음 값을 반환해준다.

num = (x for x in range(3))
print(next(num))
print(next(num))
print(next(num))

>>0
>>1
>>2

정해진 범위를 벗어나면 StopIteration 에러가 발생한다.

num = (x for x in range(3))
print(next(num))
print(next(num))
print(next(num))
print(next(num))

>>0
1
2
Traceback (most recent call last):
  File "..............................", line 5, in <module>
    print(next(num))
StopIteration

제너레이터는 다른 이터레이터(iterator)와 달리 값을 계산해서 반환해주고 나면 값을 소비하고 더 이상 기억하지 않는다.

(재사용이 불가능하다.)

num = (x for x in range(10))
for x in num:
    print(x, end=' ')

for x in num:			#두 번째 for문에서는 아무것도 출력이 되지않는다.
    print(x, end=' ')
    
>>0 1 2 3 4 5 6 7 8 9 

yield를 이용한 제너레이터 생성

def문을 이용한 함수 내부에 yield 키워드를 사용하여 제너레이터의 생성이 가능하다.

아래와 같이 값을 단순 지정해줄 수도 있고

def gen():
    yield 0
    yield 1
    yield 2

x=gen()		#제너레이터 x 생성
for i in x:
    print(i)
    
>>0
1
2

보통 함수와 같이 내부에 for문과 if문을 사용할 수도 있다.

def gen():
    for i in range(3):
        yield i

x=gen()
for i in x:
    print(i)
    
    
>>0
1
2

아래와 같이 함수에 인자를 받으면 더 다양한 제너레이터를 생성할 수 있다.

또한 반복문을 이용하여 매번 다른 값을 생성하여 반환해준다면 재사용도 가능할 것이다.

import random

def broken_dice(n):     #1~6까지의 주사위 값중 n을 제외하고 리턴
    while True:
        number = random.randint(1, 6) # 1~6까지 정수 중 랜덤하게 숫자를 뽑는다.
        if number != n: #  랜덤하게 뽑은 숫자, n이 아니라면 리턴
            yield number

dice=broken_dice(5)
for i in range(6):
    print(next(dice))
    
>>2
2
2
1
1
4

출처:https://wikidocs.net/22802

파이썬은 컴프리헨션이라는 문법을 지원한다.

컴프리헨션을 이용하면 list, dict, set을 좀 더 간단한 방법으로 작성할 수 있다.

리스트 컴프리헨션

리스트 컴프리헨션의 작성법은 아래와 같다.

num = [x for x in range(10)]

위의 컴프리헨션문을 for문으로 표기하면 아래와 같다.

num = []
for x in range(10):
	num.append(x)
 

append(x)를 대신하여 컴프리헨션문에서는 for문 앞에 변수명만 적어주면 된다.

컴프리헨션문 내에서 if문과 다중 for문도 사용이 가능하다.(if문도 여러개 사용 가능)

num = [x for x in range(10) if x%2==0]  #if문을 이용하여 짝수만 저장
print(num)

>>[0, 2, 4, 6, 8]

다중 for문 작성법(왼쪽 for문이 먼저 작동한다.)

num=[[x,y] for x in [1,2,3] for y in [4,5,6]]
print(num)

>>[[1, 4], [1, 5], [1, 6], [2, 4], [2, 5], [2, 6], [3, 4], [3, 5], [3, 6]]

셋 컴프리헨션

위 리스트 컴프리헨션의 대괄호[]만 중괄호{}로 바꿔주면된다. 내부 코드 작성법은 동일.

딕셔너리 컴프리헨션

컴프리헨션문을 중괄호{}로 감싸고 key:value의 형태로 내용을 채우면 딕셔너리의 생성이 가능하다.

li = ['A','B','C']
di = {x:0 for x in li}	#value는 0
print(di)

>>{'A': 0, 'B': 0, 'C': 0}

컴프리헨션을 이용하여 기존 딕셔너리를 새롭게 변경할 수도 있다.

old={'A':10,'B':10,'C':20,'D':10}
new={k:v for k,v in old.items() if v!=20}	#items메소드를 이용해 old에서 key와 value를 가져옴
print(new)

>>{'A': 10, 'B': 10, 'D': 10}	#if문을 이용해 20이라는 value를 가진 key 제거

튜플 컴프리헨션

위의 방법대로라면 소괄호()를 사용하여 튜플 컴프리헨션을 작성할 수 있을 것 같다.

num = (x for x in range(10))
print(num)

>><generator object <genexpr> at 0x00000220CCDD4AC8>

하지만 생각과 달리 generator(제너레이터)가 생성된다.

제너레이터에 대해서는 다음 글에서 설명하겠다.

파이썬에서 함수는 기본적으로 def를 이용하여 작성하지만, 람다를 사용하면 좀 더 간결한 코드로 작성이 가능하고 메모리 절약도 가능하다.

람다함수는 위와 같은 형태로 작성한다.

람다함수의 또 다른 이름이 익명함수인 만큼 "이름 없는 함수"로 작성이 가능하다.

함수의 이름이 정해지지 않았으니 재사용은 불가능하다.

print((lambda x:x**2)(3))	#람다함수는 정의와 동시에 사용할 수 있다.

>>9

하지만 람다함수를 변수에 저장하게 되면 def문을 이용해서 작성한 함수와 똑같이 재사용이 가능하다.

f=lambda x:x**2		#f에 람다함수 저장
print(f(3))

>>9

람다함수는 보통 아래와 같이 딱 한번 필요한 함수를 정의하는데 자주 사용된다.

li=[1,2,3,4,5]
li=list(map(lambda x:x**2,li))
print(li)

>>[1, 4, 9, 16, 25]

전역 변수

스크립트 전체에서 접근할 수 있는 변수

(함수 바깥에서 만들어진 변수)

x=1		#전역변수
def f():
    print(x)

f()
print(x)

>>1
>>1

지역 변수

해당 변수를 만든 함수 안에서만 접근할 수 있는 변수

(함수 내부에서 만들어진 변수)

def f():
	x=1			#지역변수
    print(x)	#접근가능, 제대로 출력이 된다.
    
f()
print(x)		#에러 발생, 변수 x를 만든 함수 밖에서는 변수 x를 사용할 수 없다.

>>1
Traceback (most recent call last):
  File "...................", line 6, in <module>
    print(x)
NameError: name 'x' is not defined		#x가 정의되지않음

함수 안에서 전역 변수 사용

함수 안에서 전역 변수를 변경하려 하면 에러가 발생한다.

x=1
def f():
    x +=1		#에러 발생
    print(x)

f()

>>Traceback (most recent call last):
  File "//", line 6, in <module>
    f()
  File "//", line 3, in f
    x +=1
UnboundLocalError: local variable 'x' referenced before assignment
#지역변수 x가 할당되지않았는데 참조함.

하지만 global 키워드를 사용하면 전역 변수의 변경이 가능하다.

x=1				#전역 변수
def f():
    global x	#전역 변수 x를 사용하겠다고 명시
    x+=1
    print(x)

f()
print(x)

>>2
>>2		#전역 변수 x도 변경이 된 것을 볼 수 있다.

※global을 이용하여 함수 내에서 전역 변수를 만들 수 있다.

def f():
    global x
    x=1
    print(x)

f()
print(x)		#함수 밖에서 x 호출

>>1
>>1

파이썬에서 객체는 변경가능한(mutable) 객체와 변경불가능(immutable) 객체로 나뉜다.

mutable객체로는 list, set, dictionary 가 있고

위의 셋을 제외한 bool, int, float등이 immutable객체이다.

mutable

List

x=[1,2,3]
print(id(x))
x[2]=5		
print(id(x))	#값을 바꿔도 주소는 그대로


>>2066410918472
>>2066410918472

Set

x={0:True,1:True,2:True}
print(id(x))
x[0]=False		#{0:False,1:True,2:True}
print(id(x))	#값을 바꿔도 주소는 그대로

>>3146876058024
>>3146876058024

immutable

Int

x=1
print(id(x))
x+=1
print(id(x))

>>140712646963456
>>140712646963488

String

x='Python'
x[0]='A'	#에러 발생


>>Traceback (most recent call last):
  File ".....................................", line 2, in <module>
    x[0]='A'
TypeError: 'str' object does not support item assignment

x='Python'
print(id(x))
x+='3'
print(id(x))

>>1813087795312
>>1813087831536

지금까지 파이썬에서 입력을 받기 위해서 input()을 사용했다.

하지만 파이썬으로 알고리즘 문제를 풀 때 input()을 이용해 많은 입력을 받다 보면 시간 초과가 발생한다.

시간 초과를 방지하기 위해 input()보다 더 빠른 sys모듈의 sys.stdin.readline()을 사용해보자.

import sys
x=sys.stdin.readline()
print(x)

>>Python	#입력
Python		#출력

sys.stdin.readline()은 문자열 마지막의 줄 바꿈 문자까지 읽기 때문에 strip()을 이용해 줄 바꿈 문자를 제거해주는 것이 좋다.

import sys
x=sys.stdin.readline().strip()
print(x)
print('Java')

>>Python	#입력
Python		#출력
Java

함수, 메서드를 작성할 때 대부분의 경우 매개변수의 개수를 명확히 지정해준다.

하지만 때로는 내가 작성한 함수의 인자로 몇 개가 입력될지 모를 때가 있다.

그럴 때는 매개변수에 *를 붙이면 여러 개의 입력값(인자)을 하나의 튜플로 받을 수 있다.

이러한 함수를 가변인자함수라고한다.

def print_animal(*args):	
    for name in args:				#for문을 이용해 튜플의 모든 내용 출력
        print(name,end=' ');

    print();

print_animal('dog','cat','lion');	#튜플('dog','cat','lion')를 인자로 전달
print_animal('tiger','cat');		#튜플('tiger','cat')를 인자로 전달

>>dog cat lion 
>>tiger cat 

(*매개변수)를 마지막에만 작성해주면 그 앞에 다른 매개변수를 포함해도 함수는 정상적으로 작동된다.

def print_animal(num,*args):
    print(num,end=' ');
    for name in args:
        print(name,end=' ');

    print();

print_animal(3,'dog','cat','lion');
print_animal(2,'tiger','cat');

>>3 dog cat lion 
>>2 tiger cat 

위의 예제에서는 함수의 인자를 위치 인자(Positional arguments)로 전달했지만 아래와 같이 키워드 인자(keyword arguments)를 전달받는 가변인자함수도 생성이 가능하다.

def print_animal(**kwargs):		# 매개변수의 이름앞에(**)를 붙여준다.
   print(kwargs)			#딕셔너리 형태로 전달받는다.
   for x in kwargs:
       print(kwargs[x])

print_animal(a='cat',b='dog',c='lion')

>>{'a': 'cat', 'b': 'dog', 'c': 'lion'}	#딕셔너리 형태로 전달받는다.
>>cat
>>dog
>>lion

위의 두 예시를 함께 사용할 수도 있다.

단, 위치 인자가 키워드 인자보다 항상 앞에 위치해야 된다.

def print_animal(*args,**kwargs):
    print(args)
    print(kwargs)
  

print_animal('tiger','rabbit',a='cat',b='dog',c='lion')

>>('tiger', 'rabbit')
>>{'a': 'cat', 'b': 'dog', 'c': 'lion'}

프로그램을 작성하다 보면 수많은 오류가 발생한다.

파이썬에서는 try, except, finally문을 이용해 실행 시 발생할 수 있는 오류들에 대한 예외처리를 할 수 있다.

try:
	오류가 발생할 수 있는 코드
except:
	예외 처리
finally:
	오류와 상관없이 항상 실행되는 코드

다른 수를 0으로 나누면 발생하는 오류인 ZeroDivisionError를 예시로 들겠다.

print(1/0);

>>Traceback (most recent call last):
  File ".............................................", line 1, in <module>
    print(1/0);
ZeroDivisionError: division by zero

예외처리를 하기 위해서는 먼저 오류가 발생할 수 있는 코드를 try 키워드 내에 작성해준다.

이후 해당 오류를 except 뒤에 표시한 뒤 오류를 처리하는 코드를 except 키워드 내에 작성해준다.

try:
    print(1/0);
except ZeroDivisionError:
    print("0으로는 나눌 수 없습니다.");
    
>>0으로는 나눌 수 없습니다.

파이썬이 생성하는 오류 메시지도 직접 전달받을 수 있다.

try:
    print(1/0);
except ZeroDivisionError as e:
    print(e);
    
>>division by zero

except문은 여러개 작성 가능하다.

try:
    x=[0];
    print(x[3]);
except ZeroDivisionError as e:
    print(e);
except IndexError as e:			#존재하지않는 인덱스 참조
    print(e);
    
    
>>list index out of range

finally문 내에 작성한 코드는 오류가 발생하든 발생하지 않든 무조건 실행된다.

try:
    print(1/0);
except ZeroDivisionError:
    print("0으로는 나눌 수 없습니다.");
finally:
    print("finally~");
    
>>0으로는 나눌 수 없습니다.
>>finally~

오류 발생시키기

파이썬에서는 raise문을 이용해 원하는 타입의 오류를 발생시킬 수 있다.

Ex) 상속받는 클래스에게 메서드 오버라이딩(재정의)를 강제하고 싶을 때.

class A:
    def play(self):
        raise NotImplementedError;		#꼭 작성해야하는 부분을 구현하지 않았을때 발생시키는 오류

class B(A):
    pass;

b=B();
print(b.play());


>>Traceback (most recent call last):
  File "............................................", line 9, in <module>
    print(b.play());
  File "............................................", line 3, in play
    raise NotImplementedError;
NotImplementedError

에러 클래스를 통해 객체를 생성하면 출력 시에 에러 메시지도 함께 출력할 수 있다.

raise IndexError("인덱스 에러")

>>Traceback (most recent call last):
  File "...................................", line 1, in <module>
    raise IndexError("인덱스 에러")
IndexError: 인덱스 에러

조건의 참 거짓으로 에러를 발생시키고 싶다면 assert문을 사용할 수도 있다.

x=1
assert x!=1, "x는 1입니다"		#assert <<조건>>, <<에러메시지>>

>>Traceback (most recent call last):
  File "..................................", line 2, in <module>
    assert x!=1, "x는 1입니다"
AssertionError: x는 1입니다

조건이 거짓이면 입력받은 에러메시지와 함께 AssertionError를 발생시킨다.

클래스란 관련된 함수와 변수의 모음으로써 "객체"의 구조와 행동을 정의하는 틀이다.

클래스는 class 키워드를 사용하여 작성할 수 있다.

class Book:		#클래스의 네이밍 컨벤션은 CamelCase를 사용.
    pass;		#실행할 코드가 없다는 것을 의미
help(Book);

>>Help on class Book in module __main__:	#help함수를 통해 Book이라는 클래스가 생성된걸 알 수 있다.

class Book(builtins.object)
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)


Process finished with exit code 0

사용자는 클래스 내부에 함수를 정의해 객체의 "행동"을 정의할 수 있다.

(클래스 내부의 함수를 메서드라고 한다.)

class Book:
    def read_book(self):	#함수와 다르게 메서드는 항상 첫번째 매개변수로 self를 정의. self는 객체 자신을 의미.
        return "reading....";


x = Book();
print(Book.read_book(x));	#Book의 메서드 사용에 객체 x를 인자로 전달해서 사용
print(x.read_book());		#간편하게 x객체와 . 으로 메서드 사용가능

>>reading....
>>reading....

클래스가 객체의 구조와 행동을 정의하는 틀이라고 했으니 이제 클래스의 "생성자"통해 객체를 생성해 보겠다.

class Book:
	pass;

x=Book();	#클래스명() 으로 객체 생성 (타 언어와 다르게 new 키워드가 없다.)

print(isinstance(x,Book));	#isinstance(a, b)는 a가 b의 객체이면 True를 반환해주는 함수

>>True

※ Python의 모든 타입(사용자가 생성한 클래스 포함)은 Object 클래스를 상속받는다. 
   (모든 타입은 Object 클래스의 모든 속성을 가지고 있고 재정의할 수 있다.)

class Book:
	pass;

print(isinstance(Book,object));
print(isinstance(str,object));

>>True
>>True

class Book:
   pass;
print(dir(Book));
print(dir(object));


>>['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
>>['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

#Book클래스의 __dict__, __weakref__, __module__을 제외하고 모두 같은 것을 볼 수 있다.

클래스 내의 변수는 객체변수와 클래스 변수로 나뉜다.

객체 변수란 각 객체마다 가지고 있는 고유한 변수로서 다른 객체로부터 영향을 받지 않는 변수이다.

클래스 변수는 클래스로 만든 모든 객체들끼리 공유하는 변수이다.

객체 변수를 생성하기 위해서는 object 클래스로부터 상속받은 __init__ 메서드를 재정의 하면 된다.

class Book:
   def __init__(self,name:str,number:int):		#매개변수로 초기화할 값 전달받는다.
       self._name=name;							#self를 이용해 객체변수 생성 및 초기화
       self._number=number;

x=Book("Python Book","1234");
y=Book("C++ Book","5678");
y._name="Java Book";
print(x._name);
print(y._name);

>>Python Book			#y객체를 생성,변경해도 x객체의 객체변수는 바뀌지않는다.
>>Java Book				

클래스 변수를 생성하기 위해서는 메서드와 같이 class 키워드 내에 변수를 생성하면 된다.

class Book:
    name="Python Book";

x=Book();
y=Book();
print(x.name);				#모든 객체가 클래스변수를 공유하는 것을 볼 수 있다.
print(y.name,end='\n\n');

Book.name="Java Book";		#<클래스명>.<클래스변수>를 변경(모든 객체의 클래스변수 변경)
print(x.name);				
print(y.name,end='\n\n');

x.name="C++ Book";			#<객체명>.<클래스변수>변경(해당 객체의 클래스변수 변경)
print(x.name);
print(y.name,end='\n\n');



>>Python Book
>>Python Book

>>Java Book
>>Java Book

>>C++ Book
>>Java Book

object클래스의 __str__메서드를 재정의하여 print함수를 이용했을 때의 출력 형식을 바꿀 수 있다.

class Book:
   def __init__(self,name:str,number:int):
       self._name=name;
       self._number=number;

x=Book("Python Book","1234");
print(x);

>><__main__.Book object at 0x000001B105CC8A90>

class Book:
    def __init__(self,name:str,number:int):
       self._name=name;
       self._number=number;

    def __str__(self):
        return "Name:{}\nNumber:{}".format(self._name,self._number);

x=Book("Python Book","1234");
print(x);

>>Name:Python Book
  Number:1234

위와 같이 생성자와 메서드 정의, 메서드 재정의를 통해 클래스를 정의하고 객체를 생성할 수 있다.

복잡한 구조의 프로그램일수록 클래스를 많이 사용하여 불필요한 코드를 줄이고 가독성을 높이자.

리스트(List)

다른 언어의 "배열"과 비슷한 구조라고 생각하면 쉽다. 하지만 파이썬의 리스트는 동적 배열로서 인덱스 조절 없이 자유롭게 값의 추가와 삭제가 가능하다.

리스트는 값들을 [](대괄호)로 감싸서 표현이 가능하다. 자세한 설명은 예시를 보자.

x=[] #빈 리스트 선언
x=[1, 2.0, True, 'str'] #값을 할당하는 방법, 모든 자료형이 리스트에 들어갈 수 있다.
print(x[0])	#리스트를 인덱싱 하는 법, 인덱스는 0부터 시작.
print(x[-1])#음수 인덱싱 가능, 0을 기준으로 뒤로간다고 생각하면 편함.
print(x[0:2]) #리스트 슬라이싱, 인덱스 0부터 1까지의 값을 리스트로 반환.(2는 포함하지않는다.)
x.append(5); #리스트의 맨 뒤에 값을 추가하는 메서드
print(x);
x.insert(2,4); #2번 인덱스에 4라는 값을 추가하는 메서드
print(x);
del x[-1];      #해당 인덱스의 값을 리스트에서 삭제(예시에서는 맨 뒤의 값 삭제)
print(x);
x.remove(1);    #리스트에서 찾은 1 중 가장 낮은 인덱스를 가진 값 삭제(1이 존재하지않으면 오류)
print(x);
x.index(True);  #True라는 값을 가진 인덱스를 반환(위와 같이 True가 많으면 가장 낮은 인덱스 반환)


>>1
>>str
>>[1, 2.0]
>>[1, 2.0, True, 'str', 5]
>>[1, 2.0, 4, True, 'str', 5]
>>[1, 2.0, 4, True, 'str']
>>[2.0, 4, True, 'str']

리스트는 위와 같이 값들의 변경이 가능하고, 인덱스를 통해 정렬되어있다.

튜플(Tuple)

튜플은 ()(소괄호)를 이용해 생성한다. 리스트와 비슷하나 튜플은 값의 변경(추가 삭제 갱신)이 불가능하다.

x=(1,2,3,4);	#튜플 생성
x=(1)			#튜플x, int형 number.
x=(1,)			#튜플o, 한개의 값을 튜플로 만들 때는 ,구분자를 넣어주어야한다.
#x[1]=3     ->오류발생, (변경불가)
#del x[1]   ->오류발생, (삭제불가)
print(x[1]);
print(x[0:2]);  #인덱싱과 슬라이싱 가능, 리스트와 똑같이 [](대괄호)를 이용하여 인덱싱

>>2
>>(1, 2)

튜플 내 값은 변경이 불가능하나 튜플 내 객체는 변경이 가능하다.

x=([1,2],[3,4],[5,6]);
x[0][0]=3;	#2중 인덱싱 x[0]= [1,2]		->x[0][0]=1;
print(x);

>>([3, 2], [3, 4], [5, 6])

튜플또한 인덱싱이 가능한 정렬된 값들의 모음이다.

셋(Set)

셋이란 중복이 없는 정렬되지 않은 값들의 모음이다.(수학에서의 집합을 생각하면 편하다.) 정렬이 되지 않았으니 리스트, 튜플과는 다르게 인덱싱과 슬라이싱이 불가능하다.

셋은 {}(중괄호)를 이용해 생성할 수 있다. 하지만 빈 셋(Set)은 {}로 생성이 불가능하다.

x=set();
x={1,2,3};
x.add(3);           #3 추가
print(x);           #이미 3이란 값이 존재하므로 셋은 변하지 않는다.
x.remove(3);        #3 삭제
print(x);
x.update({2,3,4});  #한번에 여러개의 값 추가
print(x);
#print(x[1])        정렬이 되어있지않아 인덱싱 불가, 따라서 값의 변경도 불가능하다.


>>{1, 2, 3}
>>{1, 2}
>>{1, 2, 3, 4}

셋(Set)끼리의 연산

수학에서 사용하는 집합 연산(교집합, 합집합 등)이 셋(Set)에서도 가능하다.

x={0,1,2,3,4};
y={1,3,5,7,9};

print(x.difference(y));     #x-y    차집합
print(x.intersection(y));   #x&y    교집합
print(x.symmetric_difference(y));   #교집합의 여집합
print(x.union(y));          #x|y    합집합

>>{0, 2, 4}
>>{1, 3}
>>{0, 2, 4, 5, 7, 9}
>>{0, 1, 2, 3, 4, 5, 7, 9}

딕셔너리(Dictionary)

파이썬에서의 딕셔너리(dictionary)는 단어와 정의를 연결하는 사전과 비슷하다.

단어와 정의 대신 key와 value를 연결해주는 역할을 한다.

딕셔너리 내에서 key는 중복될 수 없고 변경이 불가능하다.(key를 모으면 셋(Set)이 된다.) value는 중복이 가능하다.

딕셔너리도 셋과 같이 {}(중괄호)를 이용해 생성할 수 있다. 

x={} 	#빈 딕셔너리 생성(Set이 {}로 빈 Set을 생성하지 못하는 이유)
x={'a':1,'b':2,'c':3};  #key와 value 사이에 콜론(:)을 넣어 서로를 연결
y={'c':3,'b':2,'a':1};
print(x==y)             #딕셔너리는 정렬이 되어있지않기 때문에 True 출력
print(x.keys())     #딕셔너리 x의 모든 key를 셋(Set)과 유사한 객체로 반환.
print(x.values())   #딕셔너리 x의 모든 value를 셋(Set)과 유사한 객체로 반환.
print(x.items())    #딕셔너리 x의 모든 key와 value쌍을 셋(Set)과 유사한 객체로 반환.
print(x.get('a'))   #a라는 key와 연결된 value를 반환. 해당 key가 없으면 None반환.
print(x.get('d',4)) #d라는 key와 연결된 value를 반환. 해당 key가 없으면 기본값으로 4 반환.
print(x['a']);      #인덱싱 가능 

>>True
>>dict_keys(['a', 'b', 'c'])
>>dict_values([1, 2, 3])
>>dict_items([('a', 1), ('b', 2), ('c', 3)])
>>1
>>4
>>1

컬렉션으로 여러 변수에 동시 할당

w={'a':2,'b':3,'c':4};
x=[1,2,3];
y=(4,5,6);
z={7,8,9};

a,b,c=w;	#딕셔너리는 key를 반환
print(a,b,c);

a,b,c=w.values();	#values() 메서드를 이용해 value 반환가능
print(a,b,c);

a,b,c=x;
print(a,b,c);

a,b,c=y;
print(a,b,c);

a,b,c=z;
print(a,b,c);



>>a b c
>>2 3 4
>>1 2 3
>>4 5 6
>>8 9 7

일반적인 할당문처럼 파이썬은 = 기호 오른쪽에 있는 모든 표현식을 먼저 평가하고, 이어서 왼쪽에 있는 변수에 그 값을 할당한다.