<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 <pre>
함수의 return은 오직 한개의 객체만 리턴한다. 
보통 튜플로 리턴을 할 경우 여러개의 변수로 한번에 받게 할 수 있어 마치 return이 여러개의 값을 동시에 리턴하는 것처럼 보이지만
튜플이라는 객체 하나를 리턴하는 것이다.
</pre>
Step1:  함수가 생성되면 함수 자체도 객체이다. 그리고 그객체의 주소를 swap라는 변수가 참조한다.
Step2:  <pre>
nameSpace 는 프로그램에서 쓰이는 이름이 저장되는 공간이다. 
여기서 이름이란 객체 참조 변수를 말하는 것이다. 
함수 안에는 별도의 이름공간이 생성이 된다. 그 이름 공간을 Local scope, 함수 밖은 global scope 이라고 하고 
파이썬에서 정의한 내용에 대한 영역을 내장 영역(built-in-scope)라고 한다. 
함수 안에서 어떤 네임을 사용할 경우 그 함수 스코프 내에 이름이 없는경우 상의 스코프를 뒤진다. 
찾는 순서는  Local -> global -> built-in 순으로 검색 한다. 
이걸 스코핑 룰 이라 한다. 
</pre>
Step3:  <pre>
global이 하는 일은 새로운 지역 변수를 만들거나 복사하는 것이 아니라 
단지 전역 영역의 값을 지역 영역에 참조할 수 있게 전역변수의 레퍼런스를 지역변수 영역 이름공간에 생성하는 것이다. 
</pre>
Step5:  <pre>
아래와 같이 람다를 여러줄에 걸쳐 표현 할 수 있지만 안티 패턴이다. 
</pre>
Step6:  <pre>
시퀀스형 자료는 속성으로 이터레이터 객체를 가지고 있다.
</pre>
<ASSISTANT_TASK:>
Python Code:
def swap(a,b):
    return b,a #튜플이 반환된다. 
a = 1
b = 2
a,b = swap(a,b)
print(a,b)
print(swap)
Explanation: <pre>
함수의 return은 오직 한개의 객체만 리턴한다. 
보통 튜플로 리턴을 할 경우 여러개의 변수로 한번에 받게 할 수 있어 마치 return이 여러개의 값을 동시에 리턴하는 것처럼 보이지만
튜플이라는 객체 하나를 리턴하는 것이다.
</pre>
End of explanation
def intersect(prelist, postlist):
    ret_list = []
    for x in prelist:
        if x in postlist and x not in ret_list:
            ret_list.append(x)
    return ret_list
list1 = "HELLO"
list2 = "CLS"
print(intersect(list1, list2))
a = 10 # Namespace:global 이다.
b = 20 # Namespace:global 이다.
def sum(x,y):
    return x+y
print(sum(a,b)) #x,y 가 글로벌 네임스테이스의 a,b의 주소를 참조하게 된다.
def sum2(x,y):
    x = 1            # 1이라는 객체를 생성하고 그 주소를 변수 x가 새롭게 참조 한다. 변수 x의 네임스페이스는 sum2이다. 
    return x+y
x = 10  # 10은 이뮤터블이다. 즉 10 객체는 오퍼레이션이 없다. 10자체를 변경시키는 오퍼레이션이 없다. 
print(sum2(x,b))  #x,y가 x=10 과 b를 참조한다. 그러나 sum2네임스페이스안에서 x는 새로운 객체 1을 참조 하는 것으로 변경 된다. 
print(x)
def change(x):
    print(x[0])
    print(type(x[0]))
    print(id(x))
    print(id(x[0]))
    print(id(x[1]))
    print(id(x[2]))
    x[0] = 'H'
w_list = ["S", "A", "M"]  # 리스트는 뮤터블한 객체이다 함수 안에서 내용을 변경 할 수 있다. 뮤터블이기 때문에 그렇다. 
change(w_list)
print(w_list)
def change2(x):
    x = x[:]   # clone를 해서 변경을 한다. 그러면 외부의 list는 그대로 있게 된다. 
    x[0] = "H"
w_list = ["S","A","M"]
print(w_list)
change2(w_list)
print(w_list)
Explanation: 함수가 생성되면 함수 자체도 객체이다. 그리고 그객체의 주소를 swap라는 변수가 참조한다.
End of explanation
a = [1,2,3]
def scoping():
    a = [4,5,6]
    print(a)
scoping()
print(a)
x = 1
def func(a):
    return a + x  #x를 찾지만 local scope내의 이름공간에 x가 정의 되지 않았기 때문에 상위 scope에서 찾는다. 단 사용하는것 만가능함 상위 스코프의 변수에 조작은 못함
func(1)
def func2(a):
    x = 2
    return a+x #x를 local scope내의 이름공간서 찾는데 있어서 그걸로 사용한다. 
func2(1)
def func3(a):
    try:
        x = x + 1  
    except UnboundLocalError:
        print("에러 발생함")
    else:
        return a + x
func3(1)
Explanation: <pre>
nameSpace 는 프로그램에서 쓰이는 이름이 저장되는 공간이다. 
여기서 이름이란 객체 참조 변수를 말하는 것이다. 
함수 안에는 별도의 이름공간이 생성이 된다. 그 이름 공간을 Local scope, 함수 밖은 global scope 이라고 하고 
파이썬에서 정의한 내용에 대한 영역을 내장 영역(built-in-scope)라고 한다. 
함수 안에서 어떤 네임을 사용할 경우 그 함수 스코프 내에 이름이 없는경우 상의 스코프를 뒤진다. 
찾는 순서는  Local -> global -> built-in 순으로 검색 한다. 
이걸 스코핑 룰 이라 한다. 
</pre>
End of explanation
g = 1
def testScope(a):
    global g  #전역 스코프에 존재하는 변수의 값을 변경 할 수 있게 한다. 
    g = 2 #java는 이렇게 하면 전역에 있는 값이 수정되지만 파이썬은 타입개념이 없어 이렇게만 하면 그냥 지역변수 선언이다 그래서 전역에 영향을 미치도록 하기 위해서 global을 사용한다.
    return g + a
testScope(1)
g
print(dir())
print(dir(func2))
dir(__name__)
print(globals())
def argTest(a,b,c):
    print(a,b,c)
argTest(a=1,b=2,3)  #키워드인자 들이 일반 인자보다 나중에 써야 한다. 
argTest(1,a=1,b=2)  #이렇게 하면 일반인자 뒤에 키워드 인자들을 사용했으니 될거 같은데 안된다.
argTest(1,b=2,c=3) #일반인자의 순서는 시그니처 순으로 무조건 와야 한다.
argTest(a=1,2,c=3)  #이렇게 하더라도 두번째 인자인 2 앞에 키워드인자 a=1이 사용이되어서 안된다.
def test(*args):
    print(type(args))
    print(args)
test(1,2,3,4,5)
def union(*args):
    res = []
    for i in args:
        for x in i:
            if x not in res:
                res.append(x)
    return res
union("ham","mma", "spam")
def urlBuilder(server, **args):
    print(server)
    for i in args.keys():
        print(i, " : ",args[i])
        
urlBuilder("gg",a = "val_a", b = "val_b", c = "val_c")
(lambda x : x+1)(1)
b = lambda x: x+1
b(3)
Explanation: <pre>
global이 하는 일은 새로운 지역 변수를 만들거나 복사하는 것이 아니라 
단지 전역 영역의 값을 지역 영역에 참조할 수 있게 전역변수의 레퍼런스를 지역변수 영역 이름공간에 생성하는 것이다. 
</pre>
End of explanation
def testLambda(g):
    g(1,2,3)
testLambda(lambda a,b,c: print("sum id ", \
                              a+b+c, ": type id a ", type(a) ,\
                              ":list object is ", zip([a,b,c])))
def fibo(n):
    if n<2: return 1
    return fibo(n-1) + fibo(n-2)
fibo(3)
fibo(4)
for i in range(0,10):
    print(fibo(i))
temp = {}
def newFibo(n):
    if n in temp.keys():
        return temp[n]
    
    if n<2: 
        temp[n] = 1
        return 1
    
    temp[n] = newFibo(n-1) + newFibo(n-2)
    return temp[n]
    
    
    
newFibo(1)
newFibo(2)
newFibo(3)
newFibo(4)
temp = {}
for i in range(10):
    print(newFibo(i))
print(temp)
def plus(a,b):
    return a+b
help(plus)
def minus(a,b):
    return a+b
help(minus)
plus.__doc__ = "a,b의 더한 값을 반환 합니다."
help(plus)
def fac(n):
    
     팩토리얼 함수 입니다.
     >>> fac(6)
    
    if n == 1:
        return n
    return n * fac(n-1)
print(fac(3))
help(fac)
for key in {"a":1,"b":2}:
    print(key)
Explanation: <pre>
아래와 같이 람다를 여러줄에 걸쳐 표현 할 수 있지만 안티 패턴이다. 
</pre>
End of explanation
s = "abc"
it = iter(s)
print(it)
next(it)
next(it)
next(it)
next(it)
it.__next__()
it = iter(s)
it.__next__()
it.__next__()
it.__next__()
it.__next__()
next(iter("ab"))
Explanation: <pre>
시퀀스형 자료는 속성으로 이터레이터 객체를 가지고 있다.
</pre>
End of explanation
<END_TASK>