[Python] 헷갈리는 문법 정리

Python 헷갈리는 문법

• Python에서 변수 _는 최근 출력된 값을 저장하고 있음
• string에서 \을 문자로 표현시 \\과 같이 \를 두번 사용하여 escape처리
• 여러줄의 string을 작성하려면 """ ~ """ 혹은 ''' ~ ''' 으로 작성
• pass : 아무 동작도 수행하지 않음
• unicode string 사용시 u'~~' 문자열 내부에 유니코드 문자 사용시 \nXXXX
  • utf-8로 인코딩시 u'~~'.encode('utf-8')
  • 실제 인코딩시 명확하게 표시하기

문법 에러와 예외

Python에서 에러는 크게 SyntaxErrors(문법 에러)와 Exceptions(예외)로 구분할 수 있다. Exception의 경우에는 예외처리가 가능하다.

• 예외가 발생했을 때 수행할 문장들을 except [Error]: ... 블락에 작성해준다.
• 에러를 직접 발생시킬 경우 raise [ValueError]

try:
    task ...
except [Error]:
    task ...

함수 인자의 기본값 설정

함수의 매개변수는 함수가 import 될 때 초기화된다. 기본값을 지정한 매개변수가 list, dictionary, class의 instance 인 경우 차이점이 발생한다.

• f1 함수처럼 만들 경우, List가 재할당 되지 않기 때문에 처음에 정의된 L을 계속 사용해 리스트에 요소값이 누적된다.
• f2 함수처럼 매 호출시에 재할당을 해주어야 초기값을 유지할 수 있다.

>>> def f1(a, L=[]):
...     L.append(a)
...     return L
...
>>> print f1(1), f1(2), f1(3)
[1] [1, 2] [1, 2, 3]

>>> def f2(a, L=None):
...     if L is None:
...             L = []
...     L.append(a)
...     return L
...
>>> print f2(1), f2(2), f2(3)
[1] [2] [3]

커맨드라인에서 함수를 define하는 경우, def 끝난 후, 매개변수 초기화가 이루어진다.

• 매개변수로 class instance 를 생성했기 때문에, class A의 생성자 부분의 코드가 실행된다.

>>> class A():
...     def __init__(self):
...         print("A class init")
...
>>> def f(a=A()):
...     print "f function call"
...
A class init
>>> f()
f function call

함수가 import 될 때 초기화되는 것을 확인해보기

• class A, function f를 function_init.py 작성했을 경우
• module을 import하면서 함수도 같이 import 되어 초기값설정이 된다.

# function_init.py
class A():
        def __init__(self):
                print"A Class init"

def f(a=A()):
        print "f function call"

>>> import function_init
A Class init

함수안에서 함수 import

• 중복 import시 문제 생기는지?
• python은 module을 중복으로 import 하더라도 중복해서 로드하지는 않는다.

가변인자

• Python에서는 오버로딩이 불가능하기 때문에, 경우에 따라 다른 개수의 입력값을 받을 수 있도록 가변인자를 사용한다.
• 매개변수
  *args : tuple 자료형 형태로 매개변수를 받는 경우
  **kwargs : 키워드 매개변수, dictionary 자료형 형태로 매개변수를 받는 경우
• *args 에 List를 전달할 경우에는 tuple 내부에 list가 저장된다.
• 두 매개변수를 한번에 사용할 경우 *args, **kwargs 순서로 받아야한다.
• **kwargs, *args 순서로 정의할 경우, (SyntaxError)문법에러가 발생한다.

# 가변인자 예제 - arbitrary_argument.py
def func(var, *args, **kwargs):
        print "var type:", type(var), var
        print "args type:", type(args), args
        for arg in args:
                print "- arg:", type(arg), arg
        keys = sorted(kwargs.keys())

        print "kwargs type:", type(kwargs)
        for kw in keys:
                print "- key:value =", kw, ":", kwargs[kw]

from arbitrary_argument import func
>>> func(0, [1,2,3]) # args tuple 내부에 [1,2,3] list가 저장된다.
var type: <type 'int'> 0
args type: <type 'tuple'> ([1, 2, 3],)
- arg: <type 'list'> [1, 2, 3]

>>> func(0, 1, "arg2", [1,2,3], key1='value1')
var type: <type 'int'> 0
args type: <type 'tuple'> (1, 'arg2', [1, 2, 3])
- arg: <type 'int'> 1
- arg: <type 'str'> arg2
- arg: <type 'list'> [1, 2, 3]
kwargs type: <type 'dict'>
- key:value = key1 : value1

함수 포인터

C에서의 함수 포인터 예제

executer 함수를 호출할 때 매개변수로 add 함수의 메모리주소를 전달한다. executer 함수는 매개변수로 받은 함수를 사용할 수 있다.

• add : int형 a, b를 인자로 받아서 int형으로 반환하는 함수
• executer : 매개변수로 함수포인터를 입력받아 출력하는 함수

#include <stdio.h>

int add(int a, int b) // int형 a, b를 인자로 받아서 int형으로 반환하는 함수
{
    return a + b;
}

void executer(int (*fp)(int, int)) // 매개변수로 함수포인터를 입력받아 출력하는 함수
{
    printf("%d\n", fp(10, 20)); // 인자로 받은 함수를 사용
}

int main()
{
    executer(add); // executer 함수를 호출할 때 매개변수로 add의 메모리주소를 전달
    return 0;
}

Python 에서의 함수 포인터 예제

Python에서 함수를 매개변수로 받고 싶을 때는 함수포인터를 가지고 있는 변수 add를 함수 executer의 인자로 넘겨준다.

executer는 매개변수로 받은 변수가 갖고 있는 함수포인터를 이용해 함수를 사용할 수 있다.

>>> def add(a, b):
...     return a + b
...
>>> def executer(func, a, b):
...     print "add function", func(a, b)
...
>>> executer(add, 10, 20)
add function 30

속성값 함수 getattr, setattr

getattr(object, name)

• object에 존재하는 속성값을 반환한다.
• name에 해당하는 속성이 존재하지 않는 경우 AttributeError가 발생한다 (예외처리 가능)

setattr(object, name, value)

• object에 존재하는 속성값을 바꾸거나, 새로운 속성을 생성하여 값을 대입한다.

# class 에 대한 사용
>>> class C:
...     class_var = 0
...     def __init__(self, instance_var): #생성자 부분
...         self.instance_var = instance_var
...
>>> c1 = C(1) # instance_var=1 을 갖는 instance c1를 만든다.
>>> getattr(c1, 'instance_var') # c1.x 와 같은 역할을 한다.
1
>>> getattr(c1, 'class_var') # class 속성이므로 instance에서 접근가능하다.
0

# instance c1의 속성 추가
>>> setattr(c1, 'instance_var2', 11) # instance c1의 instance_var2 속성을 만들어 11을 대입한다.
>>> getattr(c1, 'instance_var2') # instance c1에 instance_var2 속성이 생긴다.
11
>>> getattr(C, 'instance_var2') # class C에는 instance 속성이 추가되지 않는다.
AttributeError : class C has no attribute 'instance_var2'

# class C의 속성 추가
>>> setattr(C, 'class_var2', 2) # class C에 class_var2라는 속성을 만들어 2를 대입한다.
>>> print getattr(C, 'class_var2'), getattr(c1, 'class_var2')
2 2 # class 속성을 추가했으므로 c1에서도 접근 가능한 속성이다.

# instance c2 생성
>>> c2 = C(2) # instance_var=1을 갖는 instance c2를 만든다.
>>> print getattr(c2, 'class_var2') # class 속성이므로 instance c2에서도 접근가능하다.
3 3

# module에 대한 사용
>>> import simpleClass
>>> getattr(simpleClass, 'C') # module에 존재하는 class C의 주소를 반환한다.
<class simpleClass.C at 0x7f08ce775600>
>>> getattr(simpleClass.C, 'class_attr') # class C의 class_attr의 값을 반환한다.
[]
>>> setattr(simpleClass, 'D', 0) # module에 변수 D를 만들어 0를 대입한다.
>>> getattr(simpleClass, 'D')
0

---

 

• 전공과 관련된 포스팅은 Markdown 을 활용해보려고, 이번 포스팅부터 시작!
• 티스토리에서 Markdown 사용하는 법