#!/usr/bin/env python
# coding: utf-8

# # 수업 보충 자료

# ## 12. E-learning 22, 23 보충 자료

# -  보충 내용 없음

# ## 11. E-learning 21 보충 자료

# 1) Python 에서 Java에서 문법적으로 제공되는 것과 비슷하게 abstract class를 생성할 수 있나?
# - Python 문법 자체적으로 abstract class 지원하지 않음
# - abc 모듈을 활용하여 abstract class 생성할 수 있음 (참고적으로만 알아둘 것)
#   - http://zaiste.net/2013/01/abstract_classes_in_python/

# 2) Python 에서 Java에서 문법적으로 제공되는 것과 비슷하게 interface를 생성할 수 있나?
# - Python 문법 자체적으로 interface 지원하지 않음
# - interface를 지우너하는 모듈도 존재하지 않음

# ## 10. E-learning 19, 20 보충 자료

# -  보충 내용 없음

# ## 9. E-learning 17, 18 보충 자료

# ### 1) 전역공간과 지역공간 내 이름 알아내기-globals(), locals(), dir()

# - globals(): 전역 이름(심볼 테이블) 및 해당 이름에 할당된 객체의 repr (또는 str) 형태를 사전으로 반환
# - locals(): 지역 이름(심볼 테이블) 및 해당 이름에 할당된 객체의 repr (또는 str) 형태를 사전으로 반환
# - 최상위 모듈 수준에서 위 두 함수는 동일한 결과를 반환
# - dit(): 현재 이름 공간에 존재하는 이름 리스트 반환

# In[1]:


print globals()


# In[2]:


print locals()


# In[3]:


x = 10
print globals().keys()
print dir()


# In[4]:


print locals().keys()


# In[7]:


a = 1
b = 2

def f():
    localx = 10
    localy = 20
    print '함수 내에서 전역 이름:', globals().keys()
    print 
    print '함수 내에서 지역 이름:', locals().keys()
    
f()
print
print '모듈 수준에서의 전역 이름:', globals().keys()
print
print '모듈 수준에서의 지역 이름:', locals().keys()


# ### 2) 특정 객체 내부에 지니고 있는 이름 알아보기 
# - dir(객체)
#   : 이름 리스트 리스트 반환
# - 객체.\_\_dict\_\_
#   : 이름 및 해당 이름에 할당된 객체의 repr (또는 str) 형태를 사전으로 지님

# In[11]:


import string
print dir(string)
print string.__dict__.keys()


# In[17]:


for name, val in string.__dict__.items():
    print 'name = %-20s, type = %s' % (name, type(val))


# ### 3) 모듈의 재적재
# - 이미 메모리에 적재되어 있는 모듈은 다시 import 하더라도 기존에 적재되어 있는 모듈이 그대로 다시 이용된다.

# In[12]:


import mymath
mymath.mypi = 6.2   # 값 수정(원래 모듈 파일에 정의된 값은 3.14)

import mymath       # 다시 import
print mymath.mypi   # 3.14가 아니라 6.2 -> 즉 이미 적재되어 있는 모듈 그냥 이용


# - reload(모듈)
#   - 메모리에 등록된 것과 관계없이 해당 모듈의 파일에서 새롭게 다시 메모리에 재적재 시키는 내장 함수

# In[13]:


print mymath.mypi
reload(mymath)
print mymath.mypi


# ### 4) 윈도우즈/MAC/리눅스에서 편하게 PYTHONPATH 설정하기

# - CMD 창 (터미널 창)에서 다음과 같이 수행
#   - set PYTHONPATH=C:\Python\Mymodules

# ## 8. E-learning 15, 16 보충 자료

# ### 1) 함수 정의시에 예상할 수 없는 키워드 인수 처리하기
# - 함수를 정의할 때 예측할 수 없는 인수를 선언하여 사전 타입으로 그러한 인수를 받을 수 있다.
#   - 함수 정의시에 **var 형태의 인수 정의

# In[10]:


def f(width, height, **kw):
    print width, height
    print kw
    value = 0
    for key in kw:
        value += kw[key]
    return value

print f(width=10, height=5, depth=10, diamension=3)


# In[13]:


print f(10, 5, depth=10, diamension=3)


# - 첫 두 개의 인수 다음에는 반드시 키워드 인수로만 함수 호출 가능

# In[11]:


print f(width=10, height=5, 10, 3)


# In[12]:


print f(10, 5, 10, 3)


# - 함수 선언시에 예상할 수 없는 키워드 인수는 맨 마지막에 선언해야 한다.
#   - 함수 선언시 인수 선언 나열 방법
#     - 일반 인수 -> 키워드 인수 -> 가변 인수 -> 예상치 못하는 키워드 인수

# In[18]:


def g(a, b, k = 1, *args, **kw):
    print a, b
    print args
    print kw

g(1, 2, 3, 4, 5, c=6, d=7)


# ### 2) 함수 호출시에 사용 가능한 튜플 인수 및 사전 인수
# - 함수 호출에 사용될 인수값들이 튜플에 있다면 "*튜플변수"를 이용하여 함수 호출이 가능

# In[19]:


def h(a, b, c):
    print a, b, c
    
args = (1, 2, 3)
h(*args)


# - 함수 호출에 사용될 인수값들이 사전에 있다면 "**사전변수"를 이용하여 함수 호출이 가능

# In[20]:


dargs = {'a':1, 'b':2, 'c':3}
h(**dargs)


# - 튜플 인수와 사전 인수를 동시에 사용

# In[21]:


args = (1,2)
dargs = {'c':3}
h(*args, **dargs)


# ### 3) Trivial 람다 함수 및 키워드 인수/가변 인수/예상치 못하는 키워드 인수를 지닌 람다 함수

# In[23]:


lambda: 1


# In[24]:


f = lambda: 1
f()


# In[25]:


vargs = lambda x, *args: args
print vargs(1, 2, 3, 4, 5)


# In[27]:


kwords = lambda x, y=1, *args, **kw: kw
kwords(1, 2, 3, 4, a=5, b=6)


# ### 4) 람다 함수 보충
# - 다음 4가지 프로그램은 동일함

# In[1]:


def f1(x):
    return x*x + 3*x - 10

def f2(x):
    return x*x*x

def g(func):
    return [func(x) for x in range(-10, 10)]

print g(f1)
print g(f2)


# In[4]:


def g(func):
    return [func(x) for x in range(-10, 10)]

print g(lambda x: x*x + 3*x - 10)
print g(lambda x: x*x*x)


# In[5]:


print [(lambda x: x*x + 3*x - 10)(x) for x in range(-10, 10)]
print [(lambda x: x*x*x)(x) for x in range(-10, 10)]


# In[7]:


print map(lambda x: x*x + 3*x - 10, range(-10, 10))
print map(lambda x: x*x*x, range(-10, 10))


# ### 5) map 및 filter 함수 보충

# - map함수에 시퀀스 자료형을 두 개 이상 할당할 수 있다.
#   - 시퀀스 자료형이 n개 이면 function의 인자도 n개 이어야 함

# In[28]:


Y1 = map(lambda x, y: x + y, [1, 2, 3, 4, 5], [6, 7, 8, 9, 10])
Y2 = map(lambda x, y, z: x + y + z, [1, 2, 3], [4, 5, 6], [7, 8, 9])
print Y1
print Y2


# - 두 개 이상의 시퀀스 자료형들에 대해 map 함수를 사용하여 순서쌍 만들기
#   - function 인자를 None으로 할당

# In[29]:


a = ['a', 'b', 'c', 'd']
b = [1, 2, 3, 4]
print map(None, a, b)


# In[30]:


a = ['a', 'b', 'c', 'd']
b = [1, 2, 3, 4]
c = [5, 6, 7, 8]
print map(None, a, b, c)


# - 두 개의 시퀀스 자료형의 원소의 개수가 다르면 부족한 원소에는 None을 할당

# In[31]:


a = ['a', 'b']
b = [1, 2, 3, 4]
print map(None, a, b)


# - 순서쌍을 만드는 전용 내장 함수 zip은 None을 추가하지 않고 짧은 인자를 기준으로 나머지는 버린다.

# In[32]:


a = ['a', 'b']
b = [1, 2, 3, 4]
print zip(a, b)


# In[33]:


print zip([1, 2, 3], [4, 5, 6, 7, 8])


# - filter의 첫 인자의 함수로서 None을 할당하면 seq 자료형에 있는 각 원소값 자체들을 평가하여 참인 것들만 필터링한다.

# In[34]:


L = ['high', False, 'level', '', 'built-in', '', 'function', 0, 10]
L = filter(None, L)
print L


# ### 6) 함수 객체의 속성
# - 함수도 객체이며 속성을 지닌다.
#   - \_\_doc\_\_, func_doc: 문서 문자열
#   - \_\_name\_\_, func_name: 함수 이름
#   - func_defaults: 기본 인수 값들

# In[35]:


def f(a, b, c=1):
    'func attribute testing'
    localx = 1
    localy = 2
    return 1 


# In[42]:


print f.__doc__       # 문서 문자열
print f.func_doc
print

print f.__name__      # 함수의 이름
print f.func_name
print

print f.func_defaults # 기본 인수값들


# ## 7. E-learning 13, 14 보충 자료

# ### 1) 프로그램 예제-1
# #### 임의의 텍스트 파일 내 문자 수를 출력하는 프로그램을 작성하라.

# - 해법 1

# In[22]:


f = open('supplement.ipynb')
print len(f.read())
f.close()


# - 해법 2

# In[23]:


import os
os.path.getsize('supplement.ipynb')


# - 윈도우즈에서 만든 파일에 위 예제들을 수행하면 os.path.getsize('t.txt')가 라인수만큼 더 큼
#   - 이유
#     - 리눅스와 Mac에서는 라인 구분 제어 문자로 '\012' 한 문자를 사용
#     - 윈도우즈에서는 라인을 구분하는 제어 문자로 '\015\012' 두 개의 문자를 사용함

# In[24]:


import os
os.linesep


# - ![linesep](images/win_os_linesep.png)

# ### 2) 프로그램 예제-2
# #### 임의의 텍스트 파일 내 단어 수를 출력하는 프로그램을 작성하라. 여기서 단어란, 공백으로 분리된 문자의 모임을 뜻한다.

# - 해법 1

# In[4]:


f = open('supplement.ipynb')
s = f.read()
n = len(s.split())
print n
f.close()


# - 해법 2

# In[5]:


n = len(open('supplement.ipynb').read().split())
print n


# ### 3) 프로그램 예제-3
# #### 임의의 텍스트 파일 내 라인 수를 출력하는 프로그램을 작성하라.

# - 해법 1

# In[15]:


f = open('supplement.ipynb')
s = f.read()
print s.count('\n')
f.close()


# - 해법 2

# In[16]:


f = open('supplement.ipynb')
print len(f.readlines())
f.close()


# - 해법 3

# In[17]:


print open('supplement.ipynb').read().count('\n')


# - 해법 4

# In[18]:


print len(open('supplement.ipynb').readlines())


# ### 4) 다양한 파일 처리 모드

# - open 내장 함수의 두번째 인자 mode 설명
#   - 두번째 인자 mode 생략시에는 읽기 전용(r) 모드로 설정
#  
# |  Mode  |          간단 설명        |    자세한 설명
# |--------|-----------------------------|------------|
# |  'r'   |          읽기 전용(기본 모드)     | 파일 객체를 읽기 모드로 생성하고, 파일 포인터를 파일 처음 위치에 놓는다.|
# |  'w'   |          쓰기 전용(기존 파일 내용 삭제)         | 파일이 존재하지 않으면 새로운 파일을 쓰기 모드로 생성하고, 해당 파일이 이미 존재하면 내용을 모두 없에면서 쓰기 모드로 생성하고, 파일 포인터를 파일 처음 위치에 놓는다.  |
# |  'a'   |      파일 끝에 추가(쓰기 전용)   | 파일이 존재하지 않으면 새롭게 파일을 생성하면서 쓰기 모드로 생성하고, 해당 파일이 이미 존재하면 파일 객체을 쓰기 모드로 생성하면서 파일 포인터를 파일의 마지막 위치에 놓는다 (그래서, 이후 작성되는 내용은 파일의 뒷 부분에 추가).|
# |  'r+'  |      읽고 쓰기 | 파일 객체를 읽고 쓸 수 있도록 생성한다. 파일 포인터를 파일 처음 위치에 놓는다. |
# |  'w+'  |      읽고 쓰기(기존 파일 내용 삭제) | 파일 객체를 읽고 쓸 수 있도록 생성한다. 파일이 존재하지 않으면 새로운 파일을 생성하고, 해당 파일이 이미 존재하면 내용을 모두 없에면서 생성하고, 파일 포인터를 파일 처음 위치에 놓는다.|
# |  'a+'  |      읽고 쓰기(파일 끝에 추가) | 파일 객체를 읽고 쓸 수 있도록 생성한다. 파일이 존재하지 않으면 새롭게 파일을 생성하고, 해당 파일이 이미 존재하면 파일 객체을 생성하면서 파일 포인터를 파일의 마지막 위치에 놓는다 (그래서, 이후 작성되는 내용은 파일의 뒷 부분에 추가). |
# 
# 
#   - 이진 파일로 저장을 위해서는 아래 모드 사용
# 
# |  Mode  |          간단 설명        |
# |--------|-----------------------------|
# |  'rb'  |      이진 파일 읽기 전용 |
# |  'wb'  |      이진 파일 쓰기 전용(기존 파일 내용 삭제) |
# |  'ab'  |      이진 파일 끝에 추가(쓰기 전용) |
# |  'rb+' |      이진 파일 읽고 쓰기 |
# |  'wb+' |      이진 파일 읽고 쓰기(기존 파일 내용 삭제) |
# |  'ab+' |      이진 파일 끝에 추가(읽기도 가능) |
# 
# 
# 

# ## 6. E-learning 11, 12 보충 자료

# ### 1) 프로그램 예제
# - 100개의 소문자를 랜덤하게 생성하여 출력한다.
# - 생성된 각 소문자의 개수를 카운트하여 출력한다.

# In[7]:


import random

def getRandomLowerCaseLetter():
    return chr(random.randint(ord('a'), ord('z')))

def createList():
    '''
    소문자를 랜덤하게 생성하여 담은 리스트를 반환한다.
    '''
    chars = []
    
    for i in range(100):
        chars.append(getRandomLowerCaseLetter())
    
    #위 코드는 아래 코드와 동일
    #chars = [getRandomLowerCaseLetter() for i in range(100)]
    
    return chars

def displayList(chars):
    '''
    리스트에 포함된 문자를 한 행에 20개씩 출력한다.
    '''
    for i in range(len(chars)):
        if (i + 1) % 20 == 0:
            print chars[i]
        else:
            print chars[i],

def countLetters(chars):
    '''
    0으로 초기화된 26개의 정수리스트를 생성한 후 인자로 주어진 chars에 있는 각 문자들의 개수를 저장한다.
    '''
    counts = [0] * 26
    
    for i in range(len(chars)):
        counts[ord(chars[i]) - ord('a')] += 1    
    
    return counts

def displayCounts(counts):
    '''
    각 문자별로 카운트를 한 행에 10개씩 출력한다.
    '''
    for i in range(len(counts)):
        if (i + 1) % 10 == 0:
            print chr(i + ord('a')), counts[i]
        else:
            print chr(i + ord('a')), counts[i],

if __name__ == '__main__':
    chars = createList()
    displayList(chars)
    print
    counts = countLetters(chars)
    displayCounts(counts)


# ### 2) 집합의 성능

# In[20]:


import random
import time

NUMBER_OF_ELEMENTS = 10000

lst = list(range(NUMBER_OF_ELEMENTS))
random.shuffle(lst)

s = set(lst)

# 해당 원소가 집합/리스트에 포함되어 있는지 검사
startTime = time.time()
for i in range(NUMBER_OF_ELEMENTS):
    i in s
endTime = time.time()
runTime = int((endTime - startTime) * 1000)
print runTime, "ms"

startTime = time.time()
for i in range(NUMBER_OF_ELEMENTS):
    i in lst
endTime = time.time()
runTime = int((endTime - startTime) * 1000)
print runTime, "ms"

# 해당 원소를 집합/리스트로 부터 제거
startTime = time.time()
for i in range(NUMBER_OF_ELEMENTS):
    s.remove(i)
endTime = time.time()
runTime = int((endTime - startTime) * 1000)
print runTime, "ms"

startTime = time.time()
for i in range(NUMBER_OF_ELEMENTS):
    lst.remove(i)
endTime = time.time()
runTime = int((endTime - startTime) * 1000)
print runTime, "ms"


# ### 3) 단어 세기
# - 다음 주어진 문자열 s에서 ,와 .을 제거하고
# - 모든 문자를 소문자로 변경하고
# - 각각의 단어의 출현 빈도를 출력하시오.

# In[3]:


# -*-coding:utf-8 -*-
s = "We propose to start by making it possible to teach progra\
mming in python, an existing scripting language, and to focus \
on creating a new development enviroment and teaching \
materials for it."
 
# 대치 과정
s=s.replace(',','')
s=s.replace('.','')
s=s.lower()
 
#공백 단위로 단어 쪼개고 단어 넣을 딕셔너리 선언
listSplited = s.split()
words = {}
 
#단어 쪼개놓은 리스트에서 각각 단어의 개수 세기
for i in listSplited:
    if not i in dicWords.keys():
        words[i]=1
    else:
        words[i]=dicWords[i]+1
         
#포맷을 이용한 출력
format = "%s : %d"
  
for i in dicWords:
    print format % (i, words[i])


# ## 5. E-learning 9, 10 보충 자료

# ### 1) 리스트를 배열처럼 활용하기

# - 1차원 배열처럼 활용하기

# In[8]:


a = [1, 2, 3, 4, 5]
b = range(10)
print a
print a[0]
print b
print b[1]


# - 0으로 초기화된 사이즈 10인 1차원 배열 생성

# In[9]:


a = [0] * 10
a


# - 2차원 배열처럼 활용하기

# In[10]:


mat = [     [1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]     ]
print mat
print mat[1][2]


# ### 2) 리스트 내포
# - 다음은 고등학교 수학에서 배운 집합의 표기 방법이다.
#   - A = {x^2 | x in {0, ..., 9}}
#   - B = {1, 2, 4, 8, 16, ..., 2^16}
#   - C = {x | x in S and x is odd}
# 
# - 파이썬의 리스트 내포(list comprehension)는 바로 위 집합 표기법과 유사한 방식의 리터럴이다. 
# - 위 집합들을 리스트 내포 방식으로 표현하면 다음과 같다. 
#   - A = [x**2 for x in range(10)]
#   - B = [2**i for i in range(17)]
#   - C = [x for x in S if x % 2 == 1]

# - 예 1. 피타고라스 삼각형의 각 3변의 길이 리스트 (각 변의 길이는 30 보다 작아야 함)

# In[1]:


[(x,y,z) for x in range(1,30) for y in range(x,30) for z in range(y,30) if x**2 + y**2 == z**2]


# - 예 2. 중첩 리스트 내포

# In[2]:


list_a = ['A', 'B']
list_b = ['C', 'D']
print [x+y for x in list_a for y in list_b]
print
print [[x+y for x in list_a] for y in list_b]


# - 위 예제의 마지막 코드는 아래와 동일하다.

# In[3]:


l = []
for y in list_b:
    l2 = []
    for x in list_a:
        l2.append(x+y)
    l.append(l2)
print l


# - 예 3. 리스트 내포를 활용한 2차원 배열 생성

# In[11]:


mat = [ [0]*4 for x in range(3)]
print mat

mat[0][0] = 100
print mat


# ### 3) 특별 속성
# - 특별 속성: 파이썬 내에 존재하는 모든 객체 마다 부여되는 특별한 Read-only 속성
#   - [참고]: https://docs.python.org/2/library/stdtypes.html#object.__dict__

# In[4]:


print __name__      # 로컬 이름 
print

print __doc__       # 로컬에 지정된 문서문자열
print


# In[5]:


import math

print "math.__name__: ", math.__name__
print
print dir(math)  # dir() 내장 함수에 모듈을 인자로 전달하면 해당 모듈이 지원하는 멤버 변수 및 함수 목록을 얻는다.
print
print "math.__doc__:", math.__doc__
print
print "math.log10.__doc__: ", math.log10.__doc__


# ### 4) 명령행 인수

# In[ ]:


# file: arg.py
import sys
print sys.argv


# In[ ]:


# python arg.py -l -a -v a b c


# ### 5) [참고] numpy 모듈을 활용한 배열 생성
# - 여러가지 종류의 배열 생성 가능
# - 배열 자체에 많은 산술 연산을 효과적으로 처리 가능
# - 선형대수에 관한 각종 수학적 연산을 효과적으로 지원

# In[14]:


from numpy import *
a = array(((1,2,3), (4,5,6), (7, 8, 9))) # 3*3 행렬 생성
print a
print

b = zeros((3,3))
print b
print

c = ones((3,3))
print c
print


# - 배열 자체에 산술 연산을 효과적으로 처리 가능

# In[18]:


f = a + c     # 각 원소들끼리의 덧셈
print f
print

d = a * a     # 각 원소들끼리의 곱셈
print d
print

e = dot(a, c) # 일반적인 행렬 곱셈 
print e
print


# - 선형대수에 관한 각종 수학적 연산을 효과적으로 지원

# In[16]:


from numpy.linalg import *
g = inv(a)
print g
print

h = eig(a)
print h
print


# ## 4. E-learning 7, 8 보충 자료

# ### 1) unicode 추가 설명

# In[7]:


a = unicode("한글과 세종대왕", 'utf-8')
b = u"한글과 세종대왕"


# In[9]:


print a == b
print a is b


# In[23]:


print ord('A')    # ord(): 문자의 ASCII 코드값 반환
print chr(65)     # char(): ASCII 코드 65를 지니는 문자를 반환


# - http://www.fileformat.info/info/unicode/char/ac00/index.htm

# In[27]:


print unichr(0xac00)  # unichr():  UNICODE 코드 0xac00를 지니는 문자를 반환
print unichr(44032)   


# In[29]:


i = 0
while i < 1000:
    print unichr(0xac00 + i),
    i = i + 1


# ### 2) str()과 repr()의 차이
# - str(): 객체의 비공식적인 (informal) 문자열 표현 - 가능하면 읽기 편하게...
# - repr(): 객체의 공식적인 (official) 문자열 표현 - 가능하면 실제 객체를 완벽하게 표현할 수 있도록...
# - [참고] http://pinocc.tistory.com/168

# In[10]:


f = 1.23456789123456789
print f
print str(f)
print repr(f)        # repr()은 유효 숫자를 길게 출력


# In[16]:


print "%s, %r" % (f, f)   # str()과 repr() 호출


# In[17]:


print "%s -- %s" % ((1, 2), [3, 4, 5])   # str() 호출


# In[13]:


print "%r -- %r" % ((1, 2), [3, 4, 5])   # str() 대신에 repr() 내장 함수 사용


# In[18]:


g = 0.3
print str(g)
print repr(g)


# In[19]:


h = 'Hello'
print str(h)
print repr(h)


# In[20]:


x = eval(str(h))


# - repr() 내장함수에 의하여 반환된 문자열은 eval() 내장함수에 의하여 interpret 가 가능함 

# In[22]:


x = eval(repr(h))


# ### 3) 문서 문자열 (Documentation String, docstring)

# In[30]:


def add(a, b):
    "add(a, b) returns a+b"
    return a + b


# In[31]:


print add.__doc__


# In[32]:


help(add)


# In[34]:


get_ipython().run_line_magic('pinfo', 'add')


# ### 4) string 모듈 상수

# In[35]:


import string

print string.digits
print string.octdigits
print string.hexdigits
print string.letters
print string.lowercase
print string.uppercase
print string.punctuation   # 각종 기호들
print
print string.printable     # 인쇄 가능한 모든 문자들
print string.whitespace    # 공백 문자들 '\011\012\013\014\015'


# In[36]:


x = 'a'
print x in string.uppercase
print x in string.lowercase


# In[37]:


d = string.letters + string.digits
print d


# In[38]:


userid = raw_input('your id:')


# In[39]:


d = string.letters + string.digits
for ch in userid:
    if ch not in d:
        print 'invalid user id'
        break


# ### 5) 문자열 붙이기 코딩 방법 비교 (중요)

# In[42]:


import time
start_time = time.time()
s = ''
for k in range(1000000):
    s += 'python'
end_time = time.time()
print end_time - start_time


# In[43]:


start_time = time.time()
t = []
for k in range(1000000):
    t.append('python')
s = ''.join(t)
end_time = time.time()
print end_time - start_time


# In[44]:


start_time = time.time()
s = 'python' * 1000000
end_time = time.time()
print end_time - start_time


# ## 3. E-learning 5, 6 보충 자료

# ### 1) 비트연산자

# - ~ : 비트 반전 (보수)
# - <<: 왼쪽으로 비트 이동
#   - a << b: a \* 2 \** b 와 동일
# - \>>: 오른쪽으로 비트 이동
#   - a >> b: a / 2 \** b 와 동일
# - & : 비트 단위 AND
# - | : 비트 단위 OR
# - ^ : 비트 단위 XOR

# In[19]:


import math
def bitcounter(n):
    return math.floor(math.log(n,2)) + 1


# In[20]:


a = 3                 # "0000 0011"
print a.bit_length()  # 해당 수치를 표현하기 위한 비트의 개수를 반환 
print bin(a)          # 해당 수치를 2진수로 변환


# In[21]:


b = a << 2            # "0000 1100", 오른쪽에는 0으로 채워짐 (a * 2 ** 2 와 동일)
print b
print b.bit_length()
print bin(b)


# In[22]:


print 1 << 128   # 1 * 2 ** 128 과 동일 (롱형으로 자동변환)


# In[23]:


c = 4            # "0000 0100"
print c >> 1     # "0000 0010", 왼쪽에도 0으로 채워짐, 4 / 2 ** 1과 동일

d = 16
print d >> 3     # 16 / 2 ** 3과 동일 


# - [참고] 2의 보수법으로 음수를 메모리에 표현하는 방법
#   - http://goo.gl/CIVefJ
#   - http://goo.gl/5bJ0v5

# In[24]:


e = -4           # "1111 1100"  
print e >> 1     # "1111 1110", 음수의 경우 왼쪽에는 1로 채워짐


# - Exclusive OR (XOR)
#   - 서로 같은 비트이면 False
#   - 서로 다른 비트이면 True

# In[25]:


f = 3
print f & 2         #0000 0011 bit_and 0000 0010 = 0000 0010
print f | 8         #0000 0011 bit_or 0000 1000 = 0000 1011
print 0x0f ^ 0x06   #0000 1111 exclusive_or 0000 0110 = 0000 1001


# ### 2) 코드 학습: 시각 다루기

# - Unix Epoch: 1970년 1월 1일 0시

# In[26]:


import time

currentTime = time.time()           # Unix Epoch 부터 현재까지 경과된 시각을 GMT/UST 기준 및 ms 단위로 얻어온다.
print currentTime

totalSeconds = int(currentTime)     # 1970년 1월 1일 0시 이후부터 현재시각까지의 전체 초 값을 얻어온다.
print "totalSeconds -", totalSeconds
currentSecond = totalSeconds % 60   # 현재 시각의 초 값을 얻어온다.

totalMinutes = totalSeconds // 60   # 전체 분 값을 계산한다. 
print "totalMinutes -", totalMinutes
currentMinute = totalMinutes % 60   # 현재 시각의 분 값을 얻어온다.

totalHours = totalMinutes // 60      # 전체 시 값을 계산한다.
print "totalHours -", totalHours
currentHours = totalHours % 24      # 현재 시각의 시 값을 얻어온다.

print "현재 시각은", currentHours, ":", currentMinute, ":", currentSecond, "GMT 입니다."


# - 대한민국의 Time Zone 및 로컬타임 얻기

# In[27]:


print time.tzname
print
localtime = time.localtime()
print localtime


# - 대한민국의 Time Zone 및 GMT/UST Time Zone 사이의 Offset 얻어오기
#   - https://en.wikipedia.org/wiki/List_of_UTC_time_offsets 에서 확인

# In[28]:


print localtime.tm_hour - currentHours


# ### 3) 코드 학습: 숫자 맞추기 게임 소스

# In[29]:


# This is a guess the number game.
import random

guessesTaken = 0

print('Hello! What is your name?')
myName = raw_input()

number = random.randint(1, 20) # return random integer in range [a, b], including both end points.
print('Well, ' + myName + ', I am thinking of a number between 1 and 20.')

while guessesTaken < 6:
    print('Take a guess.') 
    guess = int(input())

    guessesTaken = guessesTaken + 1

    if guess < number:
        print('Your guess is too low.')

    if guess > number:
        print('Your guess is too high.')

    if guess == number:
        break

if guess == number:
    guessesTaken = str(guessesTaken)
    print('Good job, ' + myName + '! You guessed my number in ' + guessesTaken + ' guesses!')

if guess != number:
    number = str(number)
    print('Nope. The number I was thinking of was ' + number)


# ### 4) [참고] turtle 모듈 활용하기
#  - https://opentechschool.github.io/python-beginners/ko/simple_drawing.html
#  - http://openbookproject.net/thinkcs/python/english3e/hello_little_turtles.html
#  - https://www.youtube.com/watch?v=vEkiaHtdwIk
#  - https://python-turtle-demo.googlecode.com/files/SevenWaysToUseTurtle-PyCon2009.pdf

# In[1]:


import turtle

t = turtle.Turtle()
t.pensize(3)             # 펜 사이즈를 3으로 설정한다.
t.penup()                # 펜을 종이로 부터 들어올린다.
t.goto(-200, -50)        # 해당 좌표로 이동한다.
t.pendown()              # 펜을 종이에 놓는다.
t.circle(40, steps=3)    # 반지름이 40인 원을 3 step으로만 그린다. ==> 삼각형이 그려짐

t.penup()
t.goto(-100, -50)
t.pendown()
t.circle(40, steps=4)

t.penup()
t.goto(0, -50)
t.pendown()
t.circle(40, steps=5)

t.penup()
t.goto(100, -50)
t.pendown()
t.circle(40, steps=6)

t.penup()
t.goto(200, -50)
t.pendown()
t.circle(40, steps=40)


#  <div style="text-align:center; width:auto; margin-left:auto; margin-right:auto;"><h4>Turtle의 펜 그리기 상태 메소드</div>
#  
# | 메소드 명 | 설명 | 
# | ---------- | :--------- |
# |turtle.pendown()|펜을 내려놓는다 - 움직일 때 그려진다.|
# |turtle.penup()|펜을 들어올린다 - 움직일 때 그려지지 않는다.|
# |turtle.pensize()|선의 두께를 특정 폭으로 설정한다.|

#  

#  <div style="text-align:center; width:auto; margin-left:auto; margin-right:auto;"><h4>Turtle의 이동 메소드</div>
# 
# |<div style="text-align:center"> 메소드 명</div> | <div style="text-align:center">설명 </div>| 
# | ---------- | :--------- |
# |turtle.forward(d)|turtle이 향하고 있는 방향으로 특정 거리 d만큼 앞으로 이동시킨다.|
# |turtle.backward(d)|turtle이 향하고 있는 반대 방향으로 특정 거리 d만큼 뒤로 이동시킨다. turtle의 방향은 바뀌지 않는다.|
# |turtle.right(angle)|turtle을 특정 각만큼 오른쪽으로 회전시킨다.|
# |turtle.left(angle)|turtle을 특정 각만큼 왼쪽으로 회전시킨다.|
# |turtle.goto(x,y)|turtle을 절대 위치 (x,y)로 옮긴다.|
# |turtle.setx(x)|turtle의 x 좌표를 특정 위치로 옮긴다.|
# |turtle.setx(y)|turtle의 y 좌표를 특정 위치로 옮긴다.|
# |turtle.setheading(angle)|특정 각도로 turtle의 방향을 설정한다. 0-동쪽, 90-북쪽, 180-서쪽, 270-남쪽.|
# |turtle.home()|turtle을 원점 (0,0)으로 옮기고 동쪽 방향으로 설정한다.|
# |turtle.circle(r, ext, steps)|특정 반지름 r, 경계 ext와 단계 step인 원을 그린다.|
# |turtle.dot(diameter, color)|특정 지름 diameter와 색상 color인 원을 그린다.|
# |turtle.undo()|turtle의 마지막 명령을 (반복적으로)되돌린다.|
# |turtle.speed(s)|1부터 10사이의 정수(10이 최대) s로 turtle의 속도를 설정한다.|
# 

#  

#  <div style="text-align:center; width:auto; margin-left:auto; margin-right:auto;"><h4>Turtle 펜 색상, 채우기와 그리기 메소드</div>
# 
# |<div style="text-align:center"> 메소드 명</div> | <div style="text-align:center">설명 </div>|
# | ---------- | :--------- |
# |turtle.color(c)|펜 색상을 c로 설정한다.|
# |turtle.fillcolor(c)|펜 채우기 색상을 c로 설정한다.|
# |turtle.begin_fill()|도형을 채우기 전에 이 메소드를 호출한다.|
# |turtle.end_fill()|begin_fill에 대한 마지막 호출전까지 그려진 도형을 채운다.|
# |turtle.filling()|채우기 상태를 반환한다. 채우기 상태이면 True, 그렇지 않으면 False|
# |turtle.clear()|창을 깨끗하게 지운다. turtle의 상태와 위치는 영향을 받지 않는다.|
# |turtle.reset()|창을 깨끗하게 지우고 turtle의 상태와 위치를 원래 기본값으로 재설정한다.|
# |turtle.screensize(w,h)|캔버스의 폭과 높이를 w와 h로 설정한다.|
# |turtle.hideturtle()|turtle을 보이지 않게 만든다.|
# |turtle.showturtle()|turtle을 보이게 만든다.|
# |turtle.isvisible()|turtle이 보이면 True를 반환한다.|
# |turtle.write(s,font=("Arial",8,"normal"))|현재 turtle의 위치에 문자열 s를 쓴다. 폰트는 폰트명, 폰트크기, 폰트유형의 세 값으로 구성된다.|

# ## 2. E-learning 3, 4 보충 자료

# ### 1) 파이썬에서 지원하는 각종 타입들 알아보기

# In[10]:


import types

dir(types)


# In[11]:


print type(123) is types.IntType
print type(123.0) is types.FloatType
print type('abc') is types.StringType
print type([]) is types.ListType
print type(()) is types.TupleType
print type({}) is types.DictionaryType


# ### 2) 레퍼런스 카운트 (Reference Count)와 쓰레기 수집 (Garbage Collection) 

# In[12]:


x = y = z = 100


# ![image](images/referenceCount1.png)

# In[13]:


del x


# ![image](images/referenceCount2.png)

# In[14]:


y = 200
z = 300


# ![image](images/referenceCount3.png)

# - 레퍼런스 카운트를 얻는 법
#   - sys 모듈의 getrefcount() 함수: 본 함수가 작업 처리를 하기 위해 원래 레퍼런스 값보다 1 큰 값을 반환함

# In[15]:


import sys

a1 = 191919
print sys.getrefcount(a1)  # 새로운 191919 객체를 만들고 이 객체에 대한 reference count 반환

a2 = 191919
print sys.getrefcount(a2)  # 역시 새로운 191919 객체를 만들고 이 객체에 대한 reference count 반환

print

a3 = a1
print sys.getrefcount(a3)  # a1이 참조하는 객체를 a3가 동시에 참조함
print sys.getrefcount(a1)  # a1과 a3가 참조하는 객체는 동일하며, reference count는 기존보다 1이 증가되어 있음 
print sys.getrefcount(a2)  # a2는 여전히 reference count가 이전 값과 동일함
print

aa1 = aa2 = aa3 = 202020
print sys.getrefcount(aa1)
print sys.getrefcount(aa2)
print sys.getrefcount(aa3)

print 

b1 = object()
print sys.getrefcount(b1)

b2 = object()
print sys.getrefcount(b2)

print

print sys.getrefcount('foobar')


# ### 3) 연습문제

# - int 형 객체 1에 대해 다음 예제를 살펴보고 위 예제와 결과가 왜 다른지 생각해 보시오. 

# In[16]:


a1 = 1
print sys.getrefcount(a1)

a2 = 1
print sys.getrefcount(a2)

print

a3 = a1
print sys.getrefcount(a3)
print sys.getrefcount(a1) 
print sys.getrefcount(a2)
print


# - 다음 사항을 읽고 요구하는 프로그램을 작성하시오.
#   * 정다각형은 모든 변의 길이와 내각의 크기가 같은 $n$개의 변으로 이루어진 다각형이다 (즉, 다각형이 등변이고 등각이다). 
#   * 한변의 길이가 $s$일 때 정다각형의 넓이를 계산하는 공식은 다음과 같다.
#     * $정다각형의 넓이 = (n \times s^2) / (4 \times tan(\pi / n))$
#   * 사용자로 부터 정다각형의 변의 개수와 변의 길이를 입력받고 정다각형의 넓이를 출력하는 프로그램을 작성하시오.
#   * 출력예는 다음과 같다.
#   
#       [출력예]
#    ```
#    변의 개수를 입력하세요: 5 
#    변의 길이를 입력하세요: 6.5
#    다각형의 넓이는 73.69017017488385 입니다.
#    ```

# In[17]:


n  = input("변의 개수를 입력하세요: ")
s  = input("변의 길이를 입력하세요: ")
area = (n*s*s)/(4*math.tan(math.pi/n))
print "다각형의 넓이는 "+str(area)+" 입니다."


# - 다음 사항을 읽고 요구하는 프로그램을 작성하시오.
#   * 사용자로 부터 ASCII 코드 (0부터 127 사이의 정수)를 입력받는다. 
#   * 입력받은 코드에 대한 문자를 출력하는 프로그램을 작성하시오.
#   * 출력예는 다음과 같다.
#     
#       [출력예]
#    ```
#    ASCII코드를 입력하세요: 69 
#    문자는 E 입니다.
#    ```

# In[18]:


code = input("ASCII코드를 입력하세요: ")
print "문자는 "+chr(code) +" 입니다."


# ## 1. E-learning 1, 2 보충 자료

# ### 1) 현재 이름 공간에 있는 이름 리스트 출력

# - dir() 내장 함수 사용
#   - 리턴형: 리스트 
#   
# - 아래 리스트 중 python 기본 이름
#   - \_\_builtin\_\_
#   - \_\_doc\_\_
#   - \_\_name\_\_
#   - \_\_package\_\_
#   
# - 나머지는 ipython이 자체적으로 생성한 이름들

# - 단순 이름만 출력: dir()
#   - 리턴형: 리스트

# In[1]:


dir()


# ### 2) 특정 객체가 지니고 있는 이름 리스트 출력

# In[2]:


a = 10
print dir(a)


# In[3]:


print dir(__builtin__)


# ### 3) 파이썬 버전 및 모듈들이 존재할 수 있는 패스 알아보기

# In[4]:


import sys
print sys.version
print
print sys.path


# In[5]:


print dir(sys)


# ### 4) 연습문제

# - 다음은 math 모듈을 가져오는 코딩이다. math 모듈을 가져온 후 math 모듈에 정의된 함수를 이용하여 -4.3 값을 반올림한 후 절대값을 취하는 코딩을 한 줄로 완성하라.

# In[6]:


import math


# In[7]:


math.fabs(round(-4.3))


# - 다음은 두 점의 좌표 (x1, y1), (x3, y2)를 나타내는 변수 값들이다. math 모듈에 정의된 함수를 이용하여 이 두 점 사이의 거리를 구하는 식을 한 줄로 완성하라. 

# In[8]:


x1 = 10
y1 = 20
x2 = 30
y2 = 40


# In[9]:


math.sqrt(math.pow(x1-x2,2)+math.pow(y1-y2,2))