@@ -0,0 +1,28 @@
+f = open('photo.jpg', 'r+')
+jpgdata = f.read()
+f.close()
+
+'''
+3가지 에러 가능성
+1. To make sure that the file gets closed whether an exception occurs or not, pack it into a with statement
+If you want to read the file, pass in r
+If you want to read and write the file, pass in r+
+If you want to overwrite the file, pass in w
+If you want to append to the file, pass in a
+
+2.open does not allow explicit encoding specification in Python 2.x. However, the function io.open is available in both Python 2.x and 3.x (where it is an alias of open), and does the right thing.
+
+3. you must rely on metadata (for example, in HTTP headers) to know the encoding. Increasingly, formats just define the encoding to be UTF-8.
+'''
+
+import io
+with open('photo.jpg', 'rb') as inf:
+    jpgdata = inf.read()
+
+if jpgdata.startswith(b'\xff\xd8'):
+    text = u'This is a JPEG file (%d bytes long)\n'
+else:
+    text = u'This is a random file (%d bytes long)\n'
+
+with io.open('summary.txt', 'w', encoding='utf-8') as outf:
+    outf.write(text % len(jpgdata))
@@ -0,0 +1,33 @@
+'''
+ In that case you have two choices. The first one is to distribute 2 modules, one for Python 2 and the other for Python 3. The other choice is to modify your current code and make it compatible with both Python 2 and 3.
+'''
+
+# The first and most important method is to use __future__ imports. It allows you to import Python 3 functionality in Python 2. 
+print
+# Output:
+
+from __future__ import print_function
+print(print)
+# Output: <built-in function print>
+
+try:
+    import urllib.request as urllib_request  # for Python 3
+except ImportError:
+    import urllib2 as urllib_request  # for Python 2
+  
+  '''
+  Now whenever you try to use the modules which are abandoned in Python 3, it raises a NameError like this:
+
+from future.builtins.disabled import *
+
+apply()
+# Output: NameError: obsolete Python 2 builtin apply is disabled
+External standard-library backports
+
+There are a few packages in the wild which provide Python 3 functionality in Python 2. For instance, we have:
+
+enum pip install enum34
+singledispatch pip install singledispatch
+pathlib pip install pathlib
+'''
+
@@ -0,0 +1,15 @@
+'''
+generators are data producers
+coroutines are data consumers
+'''
+
+
+'''
+파이썬 generator, yield
+함수로부터 만들어진 제너레이터 객체가 for 루프를 통해 처음 실행될 때 Python은 함수 내에 있는 코드를 yield 키워드를 만나기 전까지 실행하고 첫 번째 루프의 값을 반환하게 됩니다. 다음 루프 때에는 yield 키워드 뒤에 있는 코드를 실행하고 다시 루프를 돌면서 반환할 값이 아예 없을 때까지 계속 같은 과정을 반복하게 됩니다
+https://tech.ssut.me/what-does-the-yield-keyword-do-in-python/
+
+Coroutines consume values which are sent to it. A very basic example would be a grep alternative in Python:
+
+http://www.dabeaz.com/coroutines/Coroutines.pdf
+'''
@@ -0,0 +1,36 @@
+# Function caching allows us to cache the return values of a function depending on the arguments. It can save time when an I/O bound function is periodically called with the same arguments. 
+
+
+from functools import lru_cache
+
+@lru_cache(maxsize=32)
+def fib(n):
+    if n < 2:
+        return n
+    return fib(n-1) + fib(n-2)
+
+print([fib(n) for n in range(10)])
+# Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+fib.cache_clear()
+
+from functools import wraps
+
+def memoize(function):
+    memo = {}
+    @wraps(function)
+    def wrapper(*args):
+        try:
+            return memo[args]
+        except KeyError:
+            rv = function(*args)
+            memo[args] = rv
+            return rv
+    return wrapper
+
+@memoize
+def fibonacci(n):
+    if n < 2: return n
+    return fibonacci(n - 1) + fibonacci(n - 2)
+
+fibonacci(25)
@@ -0,0 +1,18 @@
+'''
+Context managers allow you to allocate and release resources precisely when you want to. The most widely used example of context managers is the with statement. Suppose you have two related operations which you’d like to execute as a pair, with a block of code in between. Context managers allow you to do specifically that. 
+'''
+
+'''While comparing it to the first example we can see that a lot of boilerplate code is eliminated just by using with. The main advantage of using a with statement is that it makes sure our file is closed without paying attention to how the nested block exits.'''
+
+from contextlib import contextmanager
+
+@contextmanager
+def open_file(name):
+    f = open(name, 'w')
+    try:
+        yield f
+    finally:
+        f.close()
+
+with open_file('some_file') as f:
+    f.write('hola!')