코어애니메이션 시작하기

코코아 터치에서 코어 애니메이션을 사용할 일은 게임 류의 앱을 만들기 전에는 그리 많이 필요하지 않을 수 있다. 하지만 여러 가지 효과가 한 번에 결합된 애니메이션이나 키 프레임 애니메이션1을 적용하는 것을 가능하게 한다. 이번 포스트에서는 iOS에서 코어 애니메이션을 구현하는 법에 대해 알아보고자 한다.

코어 애니메이션은 레이어 기반으로 애니메이션이 구현된다. 이 점은 코코아 애니메이션과 크게 다르지 않다. 또한 상당히 세분화된 애니메이션이 가능하다고 했는데 이것을 개념적으로 먼저 짚고 넘어가고자 한다.

먼저 코어 애니메이션은 그 종류에 따라 CABasicAnimation과 CAKeyFrameAnimation, CATransition으로 구분된다. CABasicAnimation은 각각의 레이어요소에 대한 기본적인 애니메이션이다. CAKeyFrameAnimation은 패스를 따라 움직이는 등, 주어진 키 프레임 사이를 이동하는 애니메이션이 될 수 있다. CATransition은 레이어가 나타나거나 사라질 때 적용되는 레이어 컨텐츠 전체에 대한 애니메이션이다. 이들은 약간의 상속 구조가 다르지만, 대체로 기본적인 사용방법은 동일하다고 보면 되고, 이들의 사용 방법을 알아보자.

코어 애니메이션 레이어 (CALayer)는 각각의 UIView에 하나씩 기본적으로 적용되어 있다. 뷰가 계층구조를 가지는 것과 같이, 레이어도 계층 구조를 가질 수 있다. 즉 뷰 하나에 여러 개의 CALayer가 들어갈 수 있다는 것이다. 각각의 레이어는 애니메이션 스택을 가지고 있다. 여기에 CAAnimation 객체를 만들어서 추가하면 레이어는 해당 애니메이션을 실행하게 된다. 즉, 다음과 같은 방식으로 작업을 진행할 수 있다.

  1. CALayer 객체를 생성한다.
  2. CALayer에 그려질 컨텐츠를 입힌다. (이미지나 패스를 그린다)
  3. CAAnimation 객체를 생성한다.
  4. 애니메이션 객체에 재생시간, 가속곡선, 초기값, 최종값을 정의해준다.
  5. 완성된 애니메이션 객체를 레이어의 animations에 추가한다. 이 때 해당 애니메이션이 레이어의 어떤 속성에 적용되는 것인지 키패스를 사용하여 명시한다.
  6. 애니메이션 스택을 장착한 레이어를 현재 뷰의 레이어에 서브 레이어로 추가한다.
  7. 이제 코어 애니메이션 프레임워크에 의해 애니메이션이 재생된다.

예제 – 궤도를 따라 도는 원 만들기

궤도를 따라 원이 화면에서 회전하는 애니메이션을 구현해보도록 하겠다. 이를 위해서는 새 프로젝트를 생성하고 QuartzCore 프레임워크를 연결해야 한다.

루트 뷰 컨트롤러의 viewDidload에서 모든 게 구현된다.

-(void)viewDidLoad
{
  // 궤도가 되는 원을 그리는 레이어를 생성한다. 원을 그리지 않고,
  // 레이어의 모서리를 둥글게하여 레이어 외곽선으로 궤도를 표현한다.
  CALayer *orbit1 = [CALayer layer];
  orbit1.bounds = CGRectMake(0,0,200,200);
  orbit1.position = self.view.center;
  orbit1.cornerRadius = 100;
  orbit1.borderColor = [UIColor redColor].CGColor;
  orbit1.borderWidth = 1.5;

  // 궤도를 따라 도는 위성을 그리고 이를 궤도 레이어에 추가한다.
  CALayer *planet1 = [CALayer layer];
  planet1.bounds = CGRectMake(0,0,20,20);
  planet1.position = CGPointMake(100,0);
  planet1.cornerRadius = 10;
  planet1.backgroundColor = [UIColor redColor].CGColor;
  [orbit1 addSubLayer:planet1];

  // 궤도는 원형으로 보일 것이므로 궤도 레이어 자체를 회전할 것이다.
  // 궤도의 회전에 쓰일 애니메이션을 생성한다.
  CABasicAnimation *ani1 = [CABasicAnimation animationWithKeyPath:@"transform.rotation"];
  ani1.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionLinear];
  ani1.fromValue = [NSNumber numberWithFloat:0];
  ani1.toValue = [NSNumber numberWithFloat:(360*M_PI)/180)];
  ani1.repeatCount = HUGE_VALF;
  ani1.duration = 5.0;
  [orbit1 addAnimation:ani1 forKey:@"transform"];

  // 궤도 레이어를 뷰에 표시한다.
  [self.view.layer addSublayer:orbit1];
}

궤도를 따라 도는 빨간색 위성 주위를 도는 다른 위성을 하나 더 만들어보도록 하겠다. 색상과 크기만 다르고 완전히 동일한 코드이다. 아래 코드를 위의 orbit1 레이어를 위 코드의 맨 아래쪽에 추가해주자.

  CALayer *orbit2 = [CALayer layer];
  orbit2.bounds = CGRectMake(0,0,120,120);
  orbit2.position = self.view.center;
  orbit2.cornerRadius = 60;
  orbit2.borderColor = [UIColor blueColor].CGColor;
  orbit2.borderWidth = 1.5;

  CALayer *planet2 = [CALayer layer];
  planet2.bounds = CGRectMake(0,0,16,16);
  planet2.position = CGPointMake(60,0);
  planet2.cornerRadius = 30;
  planet2.backgroundColor = [UIColor blueColor].CGColor;
  [orbit2 addSubLayer:planet2];

  CABasicAnimation *ani2 = [CABasicAnimation animationWithKeyPath:@"transform.rotation"];
  ani2.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionLinear];
  ani2.fromValue = [NSNumber numberWithFloat:0];
  ani2.toValue = [NSNumber numberWithFloat:(360*M_PI)/180)];
  ani2.repeatCount = HUGE_VALF;
  ani2.duration = 5.0;
  [orbit2 addAnimation:ani1 forKey:@"transform"];

  // 궤도 레이어를 뷰에 표시할 때, 큰 궤도에 덧붙인다.
  [orbit1 addSubLayer:orbit2];

참고로 CALayer와 CGLayer는 글자 하나 차이지만, 완전히 다르다. CGLayer는 고성능/고품질을 위한 그래픽처리를 위해 만들어졌고, 실제 사용 용도는 off-screen 렌더링에 사용된다. 이에 비해 CALayer는 실제 뷰가 어떻게 움직일 것인지를 레이어로 추상화하여 처리하기 위한 것으로 둘은 개념도 다르고 서로 호환되지 않는다.

  1. 키 프레임 애니메이션은 보통 여러 이미지를 순차적으로 표시하는 애니메이션으로 예제들이 많이 나오는데, 사실은 애니메이션 중간 중간에 타겟을 설정하고 순서대로 흘러가는 애니메이션이다. 패스를 따라 움직이는 애니메이션이 이런 키 프레임 애니메이션으로 구현된다.

[Python101] 006 로직(1) – 조건과 조건문

사실, “자료의 유형”에 대해 먼저 다루어야 하는 게 아닌가 싶기도 하지만 그보다든 더 ‘일반적인’ 내용을 다루는 게 맞겠다는 생각에 로직을 먼저 설명하기로 결정했다. 자료의 유형은 사실 대부분의 프로그래밍 서적에서 맨 먼저 다루는 형태인데, 파이썬에서는 일부 매우 중요한 자료형을 제외하고는 ‘개념’만 이해하면 될 정도로 기본적인 내용은 단순하기 때문에 이 부분들은 차근차근히 알아 나가면 될 것 같아서 먼저 로직에 대해 설명해보기로 하겠다.

프로그램은 사람이 정의해준 절차에 따라 컴퓨터가 연속적으로 일을 처리해 나가도록 하는 일종의 “작업 지시서”이다. 당연하게도 파이썬은 소스코드에 명시한대로 일을 처리해 나간다. 하지만 항상 모든 프로그램이 “정해진 일을 순서대로 처리하기만”하는 것은 아니다. 특정한 조건에 따라서 조금씩 다르게 일을 처리해야 하는 경우가 있다. 또한 반복적인 처리를 언제까지 혹은 몇 번이나 반복해야 하는지를 매번 판단해야 하는 상황이 있을 수 있다.

즉 프로그램의 흐름(flow)은 항상 직선으로 나아가는 것이 아니라 많은 상황이나 조건에 따라서 갈림길 중 하나를 택해서 진행되거나, 같은 코스를 수차례 뱅글뱅글 돌게되는 상황이 있을 수 있는 것이다. 이러한 프로그램의 흐름을 결정하는 원리를 “로직”이라고 부른다. 그리고 이 “로직”은 기본적으로 “논리적 판단”을 따르게 된다.

논리적 판단, 참과 거짓

이 때 말하는 논리적 판단이란 아주 간단히 “참”이냐 “거짓”이냐 그 자체이다. 컴퓨터는 이 두가지 경우만은 판단할 수 있다. 모든 것이 딱 부러지게 참 아니면 거짓이되는 것이다. 파이썬에서 참은 True 거짓은 False라고 정의되어 있다. 그리고 이런 참, 거짓을 계산(?)하기 위해서 비교 연산과 논리 연산이라는 것을 하게 된다.

True 와 False 는 참고로 파이썬에는 0, 1 처럼 미리 약속되어 있는 값이다. False는 0 또는 None 과 유사한 개념으로 이해하면 된다. True는 1 혹은 0이 아닌 어떤 것이 될 수 있다.

비교 연산

참이다 거짓이다라는 것은 수학 시간에 배우는 명제의 참과 거짓과는 닮았으면서도 비슷하다. 논리적으로 참과 거짓을 결합하여 계산하는 방식은 수학의 그것을 닮았지만, 컴퓨터는 사람의 언어로 만들어진 명제를 이해하지 못한다. 다만 “3은 2보다 크다”라는 명제를 “3 > 2″라는 수식으로 써 줄 때 이를 계산하여 그것이 참인지 거짓인지를 판별할 수 있는 것이다. 결국 어떤 값이 어떤 값과 같다 / 크다 / 작다를 판별하는 것만이 판단의 기준이 된다.

이러한 판단을 위해서 비교 연산자라는 것을 사용한다. 비교 연산자에는 다음과 같은 것들이 있다.

  • == : 등호(=)를 2개 연속으로 사용하여 A == B 와 같은 형식으로 사용한다. 실제로 A 와 B가 동일한 값이라면 이 식은 참(True)이 된다.
  • >, >= : 크다와 크거나 같다를 의미한다. A >= B 는 A>B 이거나 A==B이면 참이 된다.
  • <,<= :  작다와 작거나 같다를 의미한다.
  • != : 같지 않다는 의미이다.

대화형 쉘에서 다음 수식들을 평가해 도록 하자. 수식을 입력하고 엔터를 치면 True 혹은 False로 결과값이 출력된다. 수식을 실제로 실행하여 평가하기 전에 결과가 True 인지 False인지 먼저 생각해보고, 실행한 결과가 자신의 생각과 맞는지 확인해보자.

  • 1 == 13
  • 13 == “13″
  • 4 > 5
  • -2 <= -2
  • 2 == 2
  • -4 * 0 >= 0
  • ‘Hello’ == “Hello”

논리연산자

비교 연산자는 쉽다. 하지만 현실은 그리 녹록하지 않다. 단순비교를 넘어서 많은 경우에 2개 혹은 3개 가량의 조건을 동시에 고려해야 하는 경우가 많다. 논리 연산자는 여러 개의 조건을 동시에 평가하는데 사용한다. 예를 들자면 가스 밸브의 압력이 10~20 사이일 때가 정상이라고 할 때 가스 밸브의 압력이 정상인지를 판단하기 위해서는 다음의 두 조건을 동시에 만족해야 한다.

  1. 밸브압력 >= 10
  2. 밸브압력 <= 20

이 두 개의 조건을 하나로 묶어주는 것이 논리 연산자이다. 논리 연산자는 역시 의외로 간단하다.

  • AND : A AND B – A도 참, B도 참인 경우에만 참이된다. A가 참, B가 거짓인 경우에는 A AND B는 거짓이다. 즉 2개의 조건이 모두 참인 경우만 참이 된다.
  • OR : A OR B – A, B 둘 중의 하나만 참이면 참이다. OR은 “~ 혹은 ~”의 뜻이므로 글자 그대로 생각하면 된다.
  • NOT A : A의 논리값을 뒤집는다. A가 참이면 NOT A는 거짓, A가 거짓이면 NOT A는 참이된다.

그리고 비교 연산자와 논리 연산자들을 결합하여 보통 우리는 “조건”을 만들어 낼 수 있다. 하나의 조건은 비교 연산을 통해 참/거짓으로 구분되는 식이며, 여러 개의 조건은 다시 논리 연산자를 통해 하나의 조건으로 합성될 수 있다.

위에서 언급한 가스 밸브의 경우, 조건식은 다음과 같이 만들어진다.

{밸브 압력} >= 10 and {밸브 압력} <= 20

밸브의 압력이 10~20 사이의 값일 때만 두 식을 모두 만족하게 되는 것이다.

자 이제 다시 다음 20개의 식의 결과가 True 인지 False 인지 각각 생각해보고 대화형 쉘에서 실행하여 그 결과를 확인해 보라.

  1. True and True
  2. False and True
  3. 1 == 1 and 2 == 1
  4. “test” == “test”
  5. 1 == 1 or 2 != 1
  6. True and 1 == 1
  7. False and 0 != 0
  8. True or 1 == 1
  9. “test” == “testing”
  10. 1 != 0 and 2 == 1
  11. “test” != “testing”
  12. “test” == 1
  13. not (True and False)
  14. not (1==1 and 0 != 1)
  15. not (10==1 or 1000 == 1000)
  16. not (1 != 10 or 3 == 4)
  17. not (“testing” == “testing” and “Zed” == “Cool Guy”)
  18. 1 == 1 and not (“testing” == 1 or 1 == 0)
  19. “chunky” == “bacon” and not (3 == 4 or 3 == 3)
  20. 3 == 3 and not (“testing” == “testing” or “Python” == “Fun”)

조건문

조건식에 대해서 기본적인 내용을 (사실 저게 전부임) 알아보았으니, 조건에 따른 분기를 어떻게 만드는지 살펴보도록 하겠다.

거의 모든 프로그래밍 언어는 조건문을 처리할 수 있는 문법을 가지고 있고, 대부분의 언어가 if….를 사용한다. 파이썬도 마찬가지로 if 문을 사용한다. 파이썬의 if 문의 사용 방법은 다음과 같다.

if 조건 :
조건이 참일 때 실행할 문장

if 다음에 조건 식을 쓴 다음 콜론(:)으로 끝난다. 그런다음, 조건이 참일 때 동작할 문장들을 들여쓰기 해서 써 준다. if 구문의 완료 지점은 들여쓰기를 하지 않는 라인을 만날 때 까지이다.

위의 if 문을 사용하면 조건이 참일 때에만 특정한 명령들을 실행할 수 있게 된다. 만약, 조건이 참일 때는 A라는 동작을 하고 조건이 거짓일 때는 B라는 동작을 수행하도록 하려면 어떻게 할까? 이 때는 else 문을 쓴다.

if 조건:
    조건이 참일 때 실행할 명령 ...
else:
    조건이 거짓일 때 실행할 명령 ....

그리고 많은 경우에는 조건 1, 조건 2, 조건 3… 등 각각의 경우에 따라 다른 동작을 하고 싶을 때도 있을 것이다. (예를 들어 점수의 영역에 따라 수우미양가를 매길 때처럼) 이 때는 다음과 같이 elif를 사용하여 제2, 제3의 조건을 붙여 나갈 수 있다.

if 조건1:
    조건 1이 참일 때 실행할 명령
elif 조건2:
    조건 1이 거짓일 때, 다시 조건 2를 검사하여 조건2가 참일 때 실행
elif 조건3:
    다시 조건 3일 때 명령
...
else:
    위의 모든 조건이 거짓일 때 실행하는 명령

만약 어떤 점수에 따라 학점을 A,B,C,D,F 로 나눠주는 코드를 작성한다면 다음과 같이 될 것이다.

#ex12.py
#-*-coding:utf-8

def checkGrade(point):
  if point >= 90:
    return "A"
  elif point >= 80:
    return "B"
  elif point >=70:
    return "C"
  elif point >=50:
    return "D"
  else:
    return "F"

myPoint = 85

print "My Point is %d, so my grade is %s" %(myPoint, checkGrade(myPoint))

ex12.py는 지금까지 배운 내용들은 나름 잘 요약하고 있는 예제라 할 수 있겠다. 먼저 점수에 따라 학점을 판별하는 처리는 checkGrade()라는 함수를 만들어서 처리한다.

이 함수는 조건문을 계속 사용하여 90점 이상인 경우에는  A, 80점 이상인 경우에는 B…와 같은 식으로 등급을 문자열로 반환해준다. 함수가 return 문을 만나면 결과값을 반환하고 더 이상 실행되지 않는다.

그리고 myPoint에 점수를 대입한 뒤, 점수와 그 처리 결과를 하나의 문장에서 print 하도록 했다.

조건문은 단순히 조건식을 평가하여 참/거짓의 여부에 따라 갈림길의 방향을 선택하는 장치라고 볼 수 있으며, 다양한 상황을 유연하여 처리할 수 있게끔하는 기본적인 프로그램의 논리 처리이다. 프로그램은 이 조건문과 다음에 배울 반복문을 통해 사람이 일일이 간섭하지 않고 (내지는 사람에게 매번 귀찮게 물어보지 않고) 알아서 많은 처리를 빠르게 할 수 있게 된다.

다음 순서는 반복문에 대해 배워보도록 하겠다. 그리고 반복과 조건을 결합하여 할 수 있는 몇 가지 재밌는(?) 실험들을 조금 해 볼 것이다.

[잡담] 스레싱, 버벅이는 컴퓨터

컴퓨터의 메모리는 물리적으로 그 크기가 한정되어 있는데 비해, 메모리를 사용하고자 하는 프로그램은 많다. 특히 윈도와 같은 환경에서는 동시에 여러가지의 프로세스가 동시에 실행되면서 시스템이 운용되는데, 이런 경우 특정한 프로그램이 많은 양의 메모리를 필요로한다면 운영체제는 “페이징”이라는 기법을 사용해서 부족한 메모리를 최대한 활용하게 한다.

페이징이란 메모리의 내용을 그대로 하드디스크에 써두고, 따로 써둔 메모리를 비워 여유 공간을 확보하는 방법이다. 그렇다, 윈도에서 흔히 말하는 “가상메모리”가 바로 이 페이징을 말한다.

윈도를 사용하다보면 메모리가 아직 여유 공간이 20~40% 이상 남아 있음에도 불구하고 하드디스크를 미친 듯이 읽으며 반응이 없거나 계속해서 잠깐 잠깐 멈추는 것처럼 동작하는 경우를 종종 느낄 수 있다. 이런 경우 재부팅을 해보기도 하지만 만약 메모리를 많이 차지하는 프로그램을 몇 가지 계속 사용해야 하는 경우라면 얼마 지나지 않아 이러한 상태를 반복적으로 만나게 된다.

컴퓨터가 계속해서 페이징을 하면서 버벅이는것을 스레싱(Thrashing)이라고 한다. 스레싱을 일반적으로 컴퓨터에 장착된 물리적인 자원보다도 더 많은 자원을 계속적으로 필요로 할 때 발생한다. 2GB가 물려 있는 PC에서 여러 프로그램들이 필요로하는 메모리의 양이 그보다 많을 때 시스템은 계속해서 페이징을 하면서 순차적으로 각 프로그램들에게 필요한 메모리를 공급해 주려하게 된다.

이 때, 일반적으로 디스크에 입출력이 일어날 때 실제 프로세스는 잠시 대기하게 되어 실제로 프로세스가 CPU를 사용하는 일은 적고, 시스템은 계속 페이징을 하게되다보니 사용자가 느끼기에 컴퓨터가 멈추는 것처럼 보이는 것이 스레딩이다. 즉 컴퓨터가 프로세스를 실행하는 것보다 각 프로세스에게 자원을 돌려 막기 식으로 할당하느라 아무것도 못하는 상태를 말한다.

이미 말했지만 스레딩은 컴퓨터에 장착된 메모리가 부족할 때 발생한다. 하지만 경험적으로 윈도 상에서는 메모리의 여유공간이 꽤 남아 있음에도 스레딩을 경험할 수 있다. 이는 실제 메모리 상에는 여유공간이 있지만, OS가 프로세스에 할당해줄 수 있는 메모리의 주소가 부족할 때도 같은 증상이 발생할 수 있다. (특히 여유 메모리가 30% 미만일 때 프로그램 사이를 전환하면 이런 증상을 경험하기 쉽다.)

윈도XP의 경우 자원 관리가 그리 괜찮은 수준이 아니어서 그렇다고 하더라도 비스타나 7에 이르면서도 이런 자원의 효율적인 관리는 여전히 만족할만한 수준으로 이뤄내고 있지는 못하는 것 같다.

몇 년 전 주로 쓰는 컴퓨터의 운영 체제를 리눅스로 바꿨을 때, 이러한 스레딩을 별로 경험하지 못한다는 걸 알았고 맥으로 전향한 이후에도 상당히 쾌적한 (심지어 몇 달씩 컴퓨터를 끄지 않아도 되는) 사용을 계속해 왔다.

컴퓨터는 별로 느려지지 않았지만 메모리 사용량이 99%에 달했을 때 솔직히 개인적으로 충격을 받았다. 그렇다 유닉스 계열 (엄밀히 리눅스를 유닉스 계열이라 칭하는 게 정확한 표현인지는 모르겠으나)에서는 정말이지 극도로 메모리를 잘 활용하고 있더라는 걸 깨닫는 순간.

맥을 사용해온지 만2년이 되는 것 같다. 역시나 맥에서도 스레싱을 거의 경험해보지 못한 것 같다. 회사에서 무거운 아웃룩, 파워포인트, 엑셀을 거의 항상 띄워두고 일하다 보면 회사 컴퓨터도 맥으로 지급해주면 얼마나 좋을까 하는 생각을 오늘도 해 본다. 만약 이런 버벅임 때문에 컴퓨터를 쓰기가 힘든 지경이고 업그레이드를 고민하고 있다면, 더 높은 성능의 컴퓨터를 사기보다는 리눅스나 맥으로의 전향을 고려해 보는 것이 정신 건강에 좋을 것이라고 말해주고 싶다.

[Python101] 005 함수,모듈, 그리고 도움이 되는 도구들

지난 시간까지 기본적인 프로그래밍에 필요한 “입출력”을 다루는 부분을 간단하게 나마 살펴보았다. 실제로 지금까지의 내용은 뭔가 설명이 필요하거나 개념적인 이해를 도모하는 부분과는 조금 거리가 있었고, 마치 조리법처럼 “이렇게 하면 이렇게 이렇게 됩니다.” 정도였기에 경우에 따라서는 조금 재미도 떨어지고 지겨운 부분이 없지 않아 있었을 것으로 생각된다.

이번 시간부터는 프로그램을 구성하는 단위와 이를 어떻게 만드는지, 그리고 프로그램의 흐름은 어떤 식으로 만들어지는지를 살펴보고자 한다.

모듈

모듈(Module)이라는 것은 다른 것으로 대체 가능한 어떤 구성 요소를 뜻하는데, 파이썬에서는 미리 만들어두었다가 필요할 때 꺼내 쓰는 레고 조각같은 프로그램의 조각을 말한다. 보통 프로그램의 소스 코드가 몇 백줄에서 몇 천줄까지 커지는 크고 복잡한 프로그램을 만든다면 이를 하나의 파일에 모두 작성하게 되면 사소한 오타로 인해 발생하는 에러를 잡기도 힘들어지고, 나중에 어떤 부분을 수정해야할 때 큰 범위를 일일이 찾아야 하므로 상당히 불편하고 어려워진다. 파이썬 프로그램 소스는 그 단위 단위가 모두 ‘모듈’이고, (뒤에서 설명할) 단위 프로그램 내의 함수나 클래스 같은 것들도 한 편으로는 모듈이라고 할 수 있다.

예를 들어 운영 체제에서 어떤 파일이나 폴더가 있는지를 검사하고, 파일을 복사, 삭제하거나, 폴더에 파일이 몇 개나 들어있는지를 알아내는 함수들을 만들었다고 하자. 나중에 이런 기능을 다른 프로그램에서도 사용해야 한다면, 그 때가서 똑같은 기능을 일일이 구현하는 것은 상당히 번거로운 일이 될 수도 있다.

그래서 이런 여러 개의 함수를 path(경로)라는 모듈로 묶어준다. 그리고 이런 경로와 관련된 것외에 운영체제의 특성이나 명령과 관련되는 모듈들을 다시 묶어서 os라는 모듈로 만들어둘 수 있겠다. 그리고 이게 파이썬이 기본적으로 제공하는 os 라이브러리의 정체가 된다.

from os.path import exists

라는 구문을 통해서 파일의 존재여부를 알아낼 수 있는 exists()라는 함수를 이미 사용해 본 바가 있다. (이는 우리가 구현한 것이 아니라 이미 구현되어 있는 함수를 가져다 사용한 예이다.)

파이썬을 설치하면 기본적으로 함께 설치되는 표준 라이브러리에도 활용가치가 높은 모듈들이 많이 있으며, 또 이미 많은 개발자들이 유용한 모듈들을 만들어서 공개해두고 있어 엄청나게 많은 활용 가능한 모듈들이 있다. 그래서 파이썬으로 작은 유틸리티를 만드는 일은 무척이나 쉬울 수 있다. (거의 필요한 기능들은 찾아보면 다 만들어져 있어서) 마치 레고로 자동차를 조립하는 것처럼 핸들, 바퀴, 차대 등의 부속품을 import 하여 필요한 모듈들이 함께 동작하도록 만들어주면 되는 것이다.

import / from… import

지금 편집하고 있는 소스코드 파일이 아닌 다른 곳에서 모듈을 가져와서 사용할 때 import 명령을 사용한다. import 명령은 다른 모듈 파일의 전체 혹은 일부를 현재 프로그램으로 반입해 오는 명령이다. 반입한 객체는 마치 미리 정의한 것과 같은 효과를 갖게 된다. 덕분에 프로그램 소스 코드가 간결해지고, 만들어야 하는 코드가 적어진다. (게다가 이렇게 모듈로 만들어둔 프로그램은 다른 프로그램에서 쉽게 재사용할 수 있게 된다.)

또한 모듈로 작성된 파일 내에서 그 일부만 반입해오는 경우에는 from 모듈이름 import 실제 반입할 모듈과 같은 식으로 코드를 반입할 수 있다.

모듈을 통째로 반입한 경우에는 그 하위에 있는 함수를 사용할 때 모듈.함수()와 같은 식으로 . 구분자를 써서 이들을 연결해 줘야 하지만 from 모듈 import 함수한 경우에는 함수 이름을 그대로 사용해주면 된다.

실제로 모듈을 만들어서 사용하는 예는 이 글의 말미에서 다시 다루기로 하고, 이번에는 함수에 대해 알아보도록 하겠다.

함수

함수는 프로그래밍에서 가장 중요한 개념 중의 하나이다. 함수는 “가장 작은 온전한 프로그램의 최소 단위”이다. 이 말이 무슨 뜻인고 하니, 우리가 흔히 ‘함수’라고 하면 y=2x+5와 같이 중고등학교 수학시간에 배운 함수를 떠올리게 된다. 음… 맞다. 함수는 딱 저렇게 생겨서 동작하게 된다. 여전히 감이 잘 오지 않는데, 이 함수를 잘 살펴보도록 하자.

x = 1 을 넣으면 y = 7이 된다. x = 2 를 넣으면 y = 9가 된다. 즉 어떤 값을 입력 (x에 대입)해 주면 이 값을 처리하여 그 결과값을 돌려주고 있다. 그리고 그 결과는 “입력된 값을 2배하고, 거기에 5를 더한다”는 처리를 한 결과값이다.

프로그래밍에서의 함수는 “가장 작은 프로그램의 단위”라고 했다. 프로그램 자체가 입력을 받아 이를 처리하고 그 결과를 출력해주는 기계 장치이므로, 이러한 프로그램의 특성을 함수는 그대로 가지고 있다. 그래서 프로그램 그 자체도 함수이며, 프로그램은 작고, 많은 함수들이 결합된 형태로 만들어진다.

그럼 어떤 기능을 함수로 만들면 좋을까? 답은 “반복적으로 하게 되는 작업”을 함수로 만들면 된다. 그 역시 감이 잘 오지 않는다면 “함수는 타이핑을 줄여주는 테크닉”이라고 처음에 생각해도 크게 무리가 없다.

함수 만들기

실제로 함수를 한 번 만들어 보자. 함수를 만드는 키워드는 def 이다. 함수는 다음과 같이 생성한다.

def 함수이름(인자값, ...):
    <# 어떤 동작을 하는 코드들 #>
    [return 반환값]

def (define) 키워드 다음에 함수의 이름을 쓴다. 그런 다음 함수가 받는 인자값의 이름을 써준다. 문장의 끝은 콜론으로 끝나고, 실제 함수가 해야 하는 동작은 모두 들여쓰기 해준다. 위에서 이야기한 y =  2x + 5를 파이썬 함수로 만들어보자.

def doublePlusFive(x):
    y = 2*x + 5
    return 5

print(doublePlusFive(1)) #==> 7
print(doublePlusFive(2)) #==> 9
print(doublePlusFive(5)) #==> 15

물론 위의 예제에서는 함수를 만드는 예를 보이다보니 저럴 거면 왜 함수를 쓰느냐고 할 수 있는데, 만약 섭씨나 화씨 온도를 서로 변환해야 하는 경우를 생각해보자. 섭씨온도를 화씨 온도로 바꾸는 식은 다음과 같다.

℉ = ℃ * 9 / 5 + 32

반대로 화씨 온도를 섭씨온도로 바꾸는 식은 다음과 같다. (위의 식을 바꾼 것에 지나지 않는다.)

℃ = (℉ - 32) * 5 / 9

그럼 화씨와 섭씨를 각각 바꿔주는 함수는 다음과 같이 작성할 수 있을 것이다.

#ex12.py
def FtoC(fh):
  return (fh-32) * 5 / 9.0

def CtoF(cd):
  return cd*9/5.0 + 32

이렇게 함수로 만들어두면 나중에는 FtoC(45) 라고만 쓰면 화씨 45도가 섭씨 몇 도에 해당하는지 쉽게 알 수 있게된다. 만약 코드상으로 저 공식을 바로 사용하는 것도 “똑같은” 방법이라 할 수 있겠지만 1) 시간이 지나고 나서는 이 공식이 뭔지 기억이 안날 수도 있고, 2) 나중에 다시 같은 공식을 써야할 때 공식이 생각나지 않는 경우가 생길 수 있다.

대신에 함수를 사용하면 1)함수의 이름으로 이게 무슨 처리를 하는지 유추할 수 있고 2) 함수를 모듈로 만들어 놓으면 굳이 공식을 기억하지 않아도 함수를 바로 사용할 수 있다.

함수와 모듈

위의 소스 코드를 ex12.py로 저장하고 이를 모듈로 사용하는 ex13.py를 새로 작성해보도록하자.

#ex13.py
#-*-coding:utf-8
#이 파일은 ex12.py와 같은 폴더에 저장해야 함.

import ex12

celsius = 25
farenheit = 45

print("섭씨 %d도는 화씨로 %f입니다." % (celsius, ex12.CtoF(celsius))
print("화씨 %d도는 섭씨로 %f입니다." % (farenheit, ex12.FtoC(farenheit))

ex13.py는 ex12.py의 내용을 ex12라는 이름의 모듈로 입수한다. 우리가 이미 작성한 ex12.py 파일내의 모든 내용이 이 부분에 덧붙는 다고 생각하면 된다.

또한 우리가 반입한 내용이 ex12 전체이기 때문에 그 속에 들어있는 함수를 사용할 때는 ex12.FtoC(), ex12.CtoF()와 같은 식으로 반입한 모듈의 이름을 앞에 붙여주고 점(.)으로 구분해 준다. 만약 FtoC(), CtoF()의 이름을 그대로 사용하고 싶다면 다음과 같이 import 구문을 바꿔주면 된다.

from ex12 import FtoC
from ex12 import CtoF

모듈의 위치

모듈로 반입해 올 수 있는 파일의 위치는 특정한 범위로 제한된다. 현재 실행되는 프로그램 소스와 같은 폴더에 있거나, 파이썬의 표준 모듈 폴더에 있어야 한다. 이 표준 모듈 폴더는 sys.path라는 곳에 저장되어 있는데 여기에 특정한 폴더를 추가해 줄 수도 있다. 이 방법에 대해서는 나중에 다시 살펴볼 기회가 있을 것이다.

대화형 쉘 활용하기

지금까지 대화형 쉘은 그저 “계산기” 정도의 용도로 쓴 것이 사실이다. 단순히 하나의 명령이 어떤 일을 하는지 이미 알고 있는 상황에서 print 명령을 쓴다거나 하는 일이 그리 ‘효율적’으로 느껴질리도 없다. 지금부터는 대화형 쉘을 어떻게 활용할 수 있는지 살펴보겠다.

함수를 테스트하기

대화형 쉘은 기본적으로 한 번에 한 줄의 명령을 실행할 수 있도록 만들어져 있다. 즉 명령문을 입력하고 엔터키를 누르면 해당 명령이 바로 실행되어 즉시 그 결과를 볼 수 있는 것이다.

하지만 함수를 만드는 def 구문을 쓸 때는 엔터를 누르더라도 바로 실행되지 않는다. 위에서 예를 들었던 doublePlusFive() 함수를 대화형 쉘 모드에서 입력해보라. def doublePlusFive(x): 하고 엔터를 누르면 프롬프트가 나오지 않고 들여쓰기 상태가 된다. 이 상태에서 함수의 나머지 코드를 입력하고, 엔터를 두 번 누르면 결과가 출력되지 않고 다시 프롬프트가 표시된다.

>>> def doublePlusFive(x):
y = 2*x+5
return y

>>> doublePlusFive(7)
19

다시 프롬프트에서 doublePlusFive(7)을 입력하고 엔터를 치면 해당 함수가 실행되어 계산 결과를 표시하게 된다. 즉 대화형 쉘은 메모리에 만들어진 수식이나 읽어들인 외부 모듈을 계속 가지고 있으므로 간단한 ‘테스트’를 해보는 데 큰 도움이 된다. 특히 앞으로 배우게 될 리스트와 관련하여 애매한 부분들은 대화형 쉘에서 간단히 시험해봄으로써 정확한 명령문을 결정하는 데 도움이 될 수 있다.

모듈 함수의 도움말을 보기

help() 명령은 특정한 모듈 혹은 함수의 도움말을 표시해주는 명령이다. 백문이 불여일견, help(max)라고 대화형 쉘에서 실행해보자. max()는 이름에서 유추할 수 있지만 최대 값을 구하는 함수이다. 이 함수의 help 결과는 다음과 같다.

>>> help(max)
Help on built-in function max in module __builtin__:

max(...)
max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value

With a single iterable argument, return its largest item.
With two or more arguments, return the largest argument.

help에서 표시하는 정보는 max가 __builtins__ 라는 특별한 이름의 모듈에 속해 있는 함수임을 알 수 있고, max(a, b, c, d…) 이런 식으로 쓰면 그 중에서 가장 큰 값을 반환한다는 설명을 볼 수 있다.

그러면 한 번 테스트해보자.

>>> someNumbers = (1,2,3,4,5)
>>> max(someNumbers)
5

someNumber라는 변수에 (1,2,3,4,5) 라는 숫자 묶음을 대입해주고, max를 통해 someNumber 중에서 가장 큰 숫자를 구하는 명령을 실행해보면 최대 값을 구해 반환하는 것을 볼 수 있다.

모듈이 어떤 기능을 수행할 수 있는지를 살펴보는 방법

우리는 방금 ‘최대값’을 구하는 함수를 어떻게 사용하는지 살펴보았다. 그렇다면, 반대로 최대값을 구하는 함수도 있지 않을까? 이름으로 유추해보자면 min()이라는 함수가 있을 것 같다. 그럼 그런 함수가 있는지 없는 지 어떻게 알 수 있을까?

이럴 때 유용하게 사용할 수 있는 함수가 있다. 바로 dir()이라는 함수이다. 이 함수는 인자로 받은 모듈에 포함되어 있는 하위 기능을 모두 열거해준다.

우리는 조금전 help(max)에서 이 기능이 “__builtins__”라는 특별한 모듈에 속해있다고 하는 것을 보았다. 양끝에 언더바(_)가 두 개씩 붙은 것은 “내부적으로”라는 의미라고 이해하면 되고 실제 글자로는 built-in된 모듈이라는 의미이다. dir 함수는 모듈의 내부 구성 요소를 볼 수 있는 명령이라 하였으니 이 __builtins__ 모듈의 내부에 정말 min 이라는 함수가 있는지 살펴보도록 하자.

>>> dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError',
'BaseException', 'BufferError', 'BytesWarning',
'DeprecationWarning', 'EOFError', 'Ellipsis',
'EnvironmentError', 'Exception', 'False', 'FloatingPointError',
'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError',
'ImportWarning', 'IndentationError', 'IndexError', 'KeyError',
'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError',
'None', 'NotImplemented', 'NotImplementedError', 'OSError',
'OverflowError', 'PendingDeprecationWarning', 'ReferenceError',
'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration',
'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit',
'TabError', 'True', 'TypeError', 'UnboundLocalError',
'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError',
'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning',
'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError',
'_', '__debug__', '__doc__', '__import__', '__name__',
'__package__', 'abs', 'all', 'any', 'apply', 'basestring',
'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable',
'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex',
'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod',
'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter',
'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
'hash', 'help', 'hex', 'id', 'input', 'int', 'intern',
'isinstance', 'issubclass', 'iter', 'len', 'license',
'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min',
'next', 'object', 'oct', 'open', 'ord', 'pow', 'print',
'property', 'quit', 'range', 'raw_input', 'reduce',
'reload', 'repr', 'reversed', 'round', 'set', 'setattr',
'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super',
'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

여기서 표시되는 이름들은 거의 모두가 내장 함수 혹은 내장 모듈들이다. 앞쪽에 대문자로 시작하는 것들은 거의 내장 모듈이나 상수들을 의미하며, 중간에 __로 둘러 싸여진 이름은 모듈 내에서 다시 “내부적으로” 사용되는 기능이다. 마지막에 abs… 부터가 실제 우리가 자주 사용하는 내장 함수 들의 이름이다.

이러한 내장 함수의 이름이나 사용법을 절대로 다 외울 필요가 없다. 앞으로 공부를 해 나가면서 필요한 함수들은 그만큼 자주 사용하게 될 것이니 자연스럽게 익히게 될 것이다. 대신, 뭔가 새로운 모듈이나 함수를 앞으로 접하게 된다면 dir 및 help 명령을 통해 사용법을 확인하고 다른 연관된 명령이 있는지 살펴보는 것은 큰 도움이 된다. 반드시 이런 식으로 공부를 해 나갈 것을 권한다.

[OSX] NSSavePanel / NSOpenPanel

맥용 앱에서 문서와 같은 파일을 저장하거나, 디스크로부터 열 때 액세스하게 될 파일을 사용자가 고를 수 있도록 하는 대화상자는 NSSavePanel에 의해 만들어진다. NSOpenPanel은 NSSavePanel과 비슷하게 생겼는데, 아니나 다를까 NSOpenPanel은 NSSavePanel을 상속 받아 만들어진 클래스이다.

NSOpenPanel 사용법

NSOpenPanel의 +openPanel을 사용하여 오픈 패널 객체를 구할 수 있으며, 이 객체를 세팅하고 실행하면 된다. 다음과 같은 절차를 따르면 된다.

  1. 오픈 패널이 일반 패널창으로 열릴지, 현재 창의 시트로 열릴지를 먼저 결정한다. 다른 창으로 열 파일을 선택한다면 일반 패널창으로 열면되고, 만약 현재 창에 통합할 문서를 고른다거나 하는 경우에는 현재 창에 시트로 여는 것이 맞을 것이다.
  2. NSOpenPanel의 +openPanel 메소드를 사용해 오픈 패널 객체를 얻는다.
  3. 오픈 패널의 속성을 조정한다. 속성을 조정하는 메소드는 뒤에서 다시 설명한다.
  4. 오픈 패널을 실행한다. 오픈 패널에서 선택한 이후의 동작은 completionHandler로 넘겨주는 코드 블럭에서 정의하면 된다.

openPanel의 속성 결정

파일이 아닌 디렉토리만 선택하게 한다든지, 새 폴더를 만들게 한다든지, 한 번에 여러 개 파일을 선택하게 한다든지 하는 옵션을 설정해야 한다. 이는 패널을 열기 전에 다음의 메소드들을 사용해서 지정하면 된다.

  • -setCanChooseFIles: > 파일을 선택할 수 있게 한다.
  • -setCanChooseDirectories: > 폴더를 선택할 수 있게 한다.
  • -setAllowsMultipleSelection: > 한 번에 여러 개 파일을 선택할 지 여부를 결정한다.

패널 열기

패널 창으로 열기

패널 창으로 열기위해서는 -beginWithCompletionHandler: 메소드를 사용한다. 완료 핸들러는 (NSInteger) result를 인수로 받게 된다. 이 값은 사용자가 패널에서 ‘완료’를 선택했는지, ‘취소’를 선택했는지를 구분할 수 있게 해준다. 오픈 패널을 여는 예는 다음과 같다.

-(void)openDocument
{
  NSOpenPanel *panel = [NSOpenPanel openPanel];
  [panel setCanChooseFiles:NO];
  [panel setCanChooseDirectories:YES];
  [panel setAllowsMultipleSelection:NO];
  [panel beginWithCompletionHandler:^(NSInteger result) {
    if (result == NSFileHandlingPanelOKButton) {
      NSURL *theURL = [panel URL];
      // 문서 열기....
    }
  }];
}

만약 시트로 여는 경우에는 시트가 붙을 창 객체의 포인터를 필요로하는 -beginSheetModalForWindow:withCompletionHandler: 를 사용하면 된다.

NSSavePanel 사용법

저장패널도 열기 패널과 기본적인 사용방법은 동일하다. 다만 ‘저장’을 위한 대화상자이기 때문에 복수의 파일을 선택할 수 없다. NSOpenPanel과의 차이는 속성을 설정하는 부분이 약간 다르다는 것인데, 이는 개발자 문서에서 확인하기 바란다.