import math

x1 = (-b + math.sqrt(b*b - 4*a*c)) / (2.0*a)
x2 = (-b - math.sqrt(b*b - 4*a*c)) / (2.0*a)

D = b*b - 4*a*c
a2 = 2 * a
sd = math.sqrt(D)
x1 = (-b + sd) / a2
x2 = (-b - sd) /a2

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

print add(1, 2)
print

def myabs(x):
    if x < 0 : x = -x
    return x

print abs(-4)
print myabs(-4)

def addabs(a, b):
    c = add(a, b)
    return myabs(c)

addabs(-5, -7)

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

add

c = add(10, 30)
print c

40 + add(5,10)

f = add
print f(4, 5)

print f

print f is add

def simple():
    pass

simple()

def addmember(memberlist, newmember):
    if newmember not in memberlist:   # 기존 멤버가 아니면
        memberlist.append(newmember)  # 추가

#리스트에 초기 멤버 설정
members = ['kim', 'lee', 'park', 'youn']

# 새로운 멤버 추가
addmember(members, 'jo')

# (이미 존재하는) 새로운 멤버 추가
addmember(members, 'kim')

print members

def addmember(memberlist, newmembers):
    if type(newmembers) not in (type([]), type(())):
        newmembers = [newmembers]
    for m in newmembers:
        if m not in memberlist: #기존 멤버가 아니면
            memberlist.append(m) #추가!

members = ['kim', 'lee', 'park', 'youn']

addmember(members, 'jung')
print members

addmember(members, 'lee')
print members

addmember(members, ['kim', 'jo', 'jae'])
print members

addmember(members, ('sang', 'oh', 'jae'))
print members

def f1(b):
    b = 100

a = 200
f1(a)
print a

def f2(b):
    b = "abc"

a = "def"
f2(a)
print a

def f3(b):
    b = (1,2,3)

a = (4,5,6)
f3(a)
print a

def f4(b):
    b[1] = 10

a = [4,5,6]
f4(a)
print a

def f5(b):
    b['a'] = 10

a = {"a":1, "b":2}
f5(a)
print a

def f6(b):
    b = [1, 2, 3]
    b[1] = 10

a = [4,5,6]
f6(a)
print a

def nothing():
    return

print nothing()

def f():
    return

f()
a = f()
print a

def print_menu():
    print '1. Snack'
    print '2. Snake'
    print '3. Snick'
    
print_menu()

a = print_menu()

print a

def abs(x):
    if x < 0 : return -x
    return x

print abs(-10)

def swap(x, y):
    return y, x   # 튜플로 리턴된다.

a = 10
b = 20
print a, b
print 

a, b = swap(a, b) # 결과적으로 a, b = b, a와 동일
print a, b
print

a = 10
b = 20
x = swap(a, b)
print x[0], x[1]  # 하나의 이름으로 튜플을 받아서 처리할 수 도있다.

print divmod(9, 5)
print

a, b = divmod(9, 5)
print a, b

def length_list(l):
    res = []
    for el in l:
        res.append(len(el))
    return res

l = ['python', 'pyson', 'pythong', 'pydon']
print length_list(l)

l = ['python', 'pyson', 'pythong', 'pydon']
print [len(s) for s in l]

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

c = add(1, 3.4)
d = add('dynamic', 'typing')
e = add(['list'], ['and', 'list'])
print c
print d
print e

class MyClass:
    def __add__(self, b):
        return 'add %s is called' % b

c = MyClass()
print c + 1
print
print c + 'abc'
print
print c + 'anaconda'

# g, h는 전역 변수
g = 10
h = 5

def f(a):          # a는 지역 변수
    h = a + 10     # h는 지역, 새로 l-value로 정의했음
    b = h + a + g  # b도 지역, g는 r-value이므로 기존 값을 참조 - 전역 변수
    return b

print f(h)         # 함수 호출시에 사용되는 변수는 해당 위치의 스코프에서 값을 찾음 - 전역 변수
print h            # 전역 변수 h는 변함 없음

h = 5

def f(a):      # a는 지역
    global h   # h 변수를 전역이라고 미리 선언함
    h = a + 10 # h는 l-velue로 정의되더라도 미리 선언된 내용 때문에 전역 변수
    return h

print f(10)
print h        # 전역 변수 h 값이 함수 내에서 변경되었음

g = 10

def f():
    a = g      # l-value로 사용되는 g는 전역 변수
    g = 20     # r-value로 정의되는 g는 지역 변수
    return a

print f()

g = 10

def f():
    global g    # g는 전역 변수로 선언됨
    a = g       # a는 지역 변수, g는 전역 변수
    g = 20      # g는 전역 변수
    return a

print f()

l = []
print dir(l)

print __builtin__.abs(-5)

print __builtin__.bool(0)

print dir(__builtins__)

x = 2
def F():
    x = 1
    def G():
        print x
    G()

F()

def f(x):
    def g(i):
        print i,
        if i: g(i-1)
    g(x)
    
f(3)

def bank_account1(initial_balance):
    balance = initial_balance
    def deposit(amount):
        balance = balance + amount
        return balance
    def withdraw(amount):
        balance = balance - amount
        return balance
    return deposit, withdraw

d, w = bank_account1(100)
print d(100)

def bank_account2(initial_balance):
    balance = [initial_balance]
    def deposit(amount):
        balance[0] = balance[0] + amount
        return balance[0]
    
    def withdraw(amount):
        balance[0] = balance[0] - amount
        return balance[0]
    return deposit, withdraw

d, w = bank_account2(100)
print d(100)
print w(50)

def incr(a, step=1):
    return a + step

b = 1
b = incr(b)     # 1 증가
print b

b = incr(b, 10) # 10 증가
print b

def incr(step=1, a):
    return a + step

def incr(a, step=1, step2=10):
    return a + step + step2

print incr(10)

def area(height, width):
    return height * width

#순서가 아닌 이름으로 값이 전달
a = area(width=20, height=10)
print a

b = area(height='height string ', width=3)
print b

area(20, width=5)

area(width=5, 20)

def incr(a, step=1, step2=10, step3=100):
    return a + step + step2 + step3

print incr(10, 2, step2=100)

def incr(a, step=1, step2=10, step3=100):
    return a + step + step2 + step3

print incr(10, 2, step2=100, 200)

def incr(a, step=1, step2=10, step3=100):
    return a + step + step2 + step3

print incr(10, 2, step2=100, step3=200)

def varg(a, *arg):
    print a, arg

varg(1)
varg(2,3)
varg(2,3,4,5,6)

def printf(format, *args):
    print format % args

printf("I've spent %d days and %d night to do this", 6, 5)

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)

def g(a, b, *args, **kw):
    print a, b
    print args
    print kw
    
g(1,2,3,4, c=5, d=6)

def g(a, b, **kw, *args):
    print a, b
    print args
    print kw
    
g(1,2,3,4, c=5, d=6)

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

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

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

lambda: 1

f = lambda: 1
f()

g = lambda x, y: x + y
print g(1, 2)

incr = lambda x, inc = 1: x + inc
print incr(10) #inc 기본 인수 값으로 1 사용
print incr(10, 5)

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

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

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)

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)

#더하기, 빼기, 곱하기, 나누기에 해당하는 람다 함수 리스트 정의
func = [lambda x, y: x + y, lambda x, y: x - y, lambda x, y: x * y, lambda x, y: x / y]

#메뉴를 표시하고 메뉴를 입력받는다(0-4).
def menu():
    print "0. add"
    print "1. sub"
    print "2. mul"
    print "3. div"
    print "4. quit"
    return input('Select menu:')

#메뉴를 표시하고 선택된 메뉴를 실행한다.
while 1:
    sel = menu()                     # 메뉴 표시하고 키 입력 받음
    if sel < 0 or sel > len(func):   # 범위를 벗어나면 다시 메뉴 표시
        continue
    if sel == len(func):             # quit이면 종료
        break
    x = input('First operand:')      # 첫번째 인수
    y = input('Second operand:')     # 두번째 인수
    print 'Result =', func[sel](x,y) # 해당함수 호출

def f(x):
    return x * x

X = [1, 2, 3, 4, 5]
Y = map(f, X)
print Y

def f(x):
    return x * x

X = [1, 2, 3, 4, 5]
Y = []
for x in X:
    y = f(x)
    Y.append(y)
print Y

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

Y = map(lambda x: x * x + 4 * x + 5, range(10))
print Y

y = map(lambda x: len(x), ["Hello", "Python", "Programming"])
print y

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

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

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

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

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

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

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

print zip([1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12])

a = [[1, 2, 3], [4, 5, 6]]
print zip(*a)
print

b = [(1, 2, 3), (4, 5, 6)]
print zip(*b)
print

c = ([1, 2, 3], (4, 5, 6))
print zip(*c)
print

filter(lambda x: x > 2, [1, 2, 3, 34])

y = []
for x in [1, 2, 3, 34]:
    if x > 2:
        y.append(x)
print y

filter(lambda x: x % 2, [1, 2, 3, 4, 5, 6])

filter(lambda x: x % 2 - 1, [1, 2, 3, 4, 5, 6])

def F():
    x = 1
    print filter(lambda a: a > x, range(-5, 5))
    
F()

print filter(lambda x: x > 2, [1, 2, 3, 34])
print filter(lambda x: x > 2, (1, 2, 3, 34))
print filter(lambda x: x < 'a', 'abcABCdefDEF')

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

print reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])

print reduce(lambda x, y: x + y, [1, 2, 3, 4, 5], 100)

print reduce(lambda x, y: x + y * y, range(1, 11), 0)

x = 0
for y in range(1, 11):
    x = x + y * y
print x

print reduce(lambda x, y: y + x, 'abcde')

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

print f.__doc__       # 문서 문자열
print f.func_doc
print f.__name__      # 함수의 이름
print f.func_name
print
print f.func_defaults # 기본 인수값들

print f.func_code     # 함수의 코드 객체

def f(a, b, c, *args, **kw): # 함수 정의
    localx = 1
    localy = 2
    return 1

code = f.func_code           # 코드 객체 참조

print code.co_name           # 함수의 이름
print code.co_argcount       # 필수적인 인수의 개수
print code.co_nlocals        # 지역변수의 개수
print code.co_varnames       # 지역변수의 이름들

def sum(N):
    if N == 1:           # 종결 조건
        return 1         # 종결 조건이 만족할 때의 반환 값
    return N + sum(N-1)  # 재귀 호출

print sum(10)