Allice's Adventure in the Bit Land

데이터 표현에 따라 의미도 달리 전달된다.

2022-02-19T13:12:00.003+09:00

이 포스트는 본인 Tistory, Blogger 및 Naver에 중복 포스팅 한 것임.

데이터 과학자로 여러가지 업무를 수행하지만 결국 마지막은 데이터 표현과 이에 대한 설명과 해석을 글로 쓰는 것으로 끝난다.

근래 어느 특정 암종의 치료제 후보 물질 관련 출판을 하며 기전 설명과 관련한 추가적인 증거를 제시해야 했다.

샘플 수가 적었기 때문에 점도표 (dot plot)으로 표현하는 것을 고려했다.

이 포스트에서 원본 데이터를 사용할 수는 없어, 유사한 예를 위해 아래와 같이 toy dataset을 우선 만들었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 #Check necessary packages
packages <- c('ggplot2', 'plyr', 'ggpubr')
install.packages(setdiff(packages, rownames(installed.packages())))  
 
#Load packages
library(ggplot2)
library(plyr)
library(ggpubr)
 
#Set working directory
setwd('~/Tmp')
 
#Create a toy dataset as a matrix
matrix_data=matrix(c(92,129,64,'DMSO','Cell.line1', 
                     134,126,77,'DMSO','Cell.line2', 
                     135,143,64,'DMSO','Cell.line3', 
                     85,128,52,'Treat1','Cell.line1', 
                     146,118,60,'Treat1','Cell.line2', 
                     123,122,76,'Treat1','Cell.line3', 
                     103,111,55,'Treat2','Cell.line1', 
                     150,121,64,'Treat2','Cell.line2', 
                     122,116,78,'Treat2','Cell.line3'), byrow=T, ncol=5)
print(matrix_data)
Colored by Color Scripter cs

그림 1. The output of matrix of toy dataset

ggplot2 패키지는 dataframe 객체를 입력 받으므로, 해당 matrix에서 dataframe을 생성 해야 한다. 또한 R에서 matrix를 만들 때, 숫자와 글자 데이터를 혼용하면 모든 값이 글자 데이터형으로 설정되기 때문에 이를 숫자형으로 casting 해줘야 한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 #Create a dataframe from a matrix
dataframe_data=as.data.frame(matrix_data)
print(dataframe_data)
 
#Set columns and rows names
colnames(dataframe_data) = c('Gene1', 'Gene2', 'Gene3', 'Group', 'Cell.line')
rownames(dataframe_data) = c('Cell.line1.DMSO', 'Cell.line2.DMSO', 'Cell.line3.DMSO', 
                             'Cell.line1.Treat1', 'Cell.line2.Treat1', 'Cell.line3.Treat1', 
                             'Cell.line1.Treat2', 'Cell.line2.Treat2', 'Cell.line3.Treat2')
 
#Convert data types of numeric columns
#In the case of the dataframe creation from the matrix with mixed data
#All column is set as character by default
dataframe_data <- transform(dataframe_data, Gene1 = as.numeric(Gene1), 
                            Gene2 = as.numeric(Gene2),
                            Gene3 = as.numeric(Gene3))
 
print(dataframe_data)
 
Colored by Color Scripter cs

그림 2. The output of dataframe of toy dataset

이제 ggplot2로 점도표를 그려보자. 점도표와 함께 평균 값을 함께 그리기 위하여 stat_summary를 추가하였다. 테마는 grid line을 싫어하기 때문에 theme_classic()으로 잡아 준 후, 그 외 theme으로 legend는 없애고 x와 y tick labels는 출판 시 보통 지정된 최저 폰트 사이즈는 8이므로 그렇게 지정하였다. 각각의 plot 개체는 ggarrange()로 하나의 panel로 묶어 주었다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36 #Variable for default font size in a plot
fontsize <- 8
 
#Create a dot plot
#each size of elements in the plot is adjusted for image file
p1 <- ggplot(dataframe_data, aes(x=Group, y=Gene1, fill=Group)) + 
  geom_dotplot(binaxis='y', stackdir='center', dotsize=2) + 
  stat_summary(fun=mean, color='black', size=0.1) +  
  theme_classic() + 
  theme(legend.position='none', 
        text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p2 <- ggplot(dataframe_data, aes(x=Group, y=Gene2, fill=Group)) +
  geom_dotplot(binaxis='y', stackdir='center', dotsize=2) + 
  stat_summary(fun=mean, color='black', size=0.1) + 
  theme_classic() + 
  theme(legend.position='none', 
        text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p3 <- ggplot(dataframe_data, aes(x=Group, y=Gene3, fill=Group)) +
  geom_dotplot(binaxis='y', stackdir='center', dotsize=2) + 
  stat_summary(fun=mean, color='black', size=0.1) + 
  theme_classic() + 
  theme(legend.position='none', 
        text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
 
#combine all plots in one panel 3 x 1
pan1 <- ggarrange(p1, p2, p3, ncol = 3, nrow = 1)
#save as a png format file
ggsave('image1.png', plot = pan1, width = 9,  height = 4,  units = 'cm')
#display plot
pan1
Colored by Color Scripter cs

그림 3. Dot plots of toy dataset. Red, green, and blue dots represent expression levels of genes by groups, respectively. The black dot represents the mean value of gene expression of each group.

위 그림에서 보면 Gene2와 Gene3는 대조군 (control group)인 DMSO를 처리한 것에 비해 독립된 두 실험군 (case groups; Treat1 and Treat2)에서 평균 값 (black dots)이 내려간 것이 보이고, Gene1은 약간 내리거나 오르는 양상을 보였다. 전달하는 메시지가 약하다는 평가가 있었다. 그래서 다시 이 것을 전통적으로 생물학 실험에서 많이 제시하는 (가능하면 사용하지 말 것을 권고하는) 막대도표 + 에러바 (속칭 dynamite plot)로 다시 표현해보았다.

에러바를 그리기 위해서는 평균 값과 표준편차 (standard deviation) 값을 구해야 하므로, 데이터 프레임에 그룹별로 평균과 표준편차 값을 계산하여 대체하는 함수를 만들었다. 이 함수는 아래와 같이 데이터프레임을 넘겨받는다.

그림 4. A subset of toy dataset.

그리고 아래와 같이 이를 집계하여 리턴해주는 함수이다.

그림 5. The output of description of a subset of toy dataset

함수명은 data_summary()로 하였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82 #Data summary function to get mean and standard deviation (sd) of values by group
data_summary <- function(data, varname, groupnames){
  summary_func <- function(x, col){
    
    c(mean = mean(x[[col]], na.rm=TRUE),
      sd = sd(x[[col]], na.rm=TRUE))
  }
  data_sum<-ddply(data, groupnames, .fun=summary_func,
                  varname)
  data_sum <- rename(data_sum, c('mean' = varname))
  return(data_sum)
}
 
 
#Get mean and sd of Gene1 by Group
df2 <- data_summary(dataframe_data, varname='Gene1', groupnames=c('Group'))
#plot barplot
p4 <- ggplot(df2, aes(x=Group, y=Gene1,  fill=Group)) + 
  geom_bar(stat='identity', color='black', position=position_dodge()) +
  geom_errorbar(aes(ymin=Gene1-sd, ymax=Gene1+sd), width=.2,
                position=position_dodge(.9)) + 
  theme_classic() + 
  theme(legend.position='none', 
        text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
 
#Get mean and sd of Gene2 by Group
df2 <- data_summary(dataframe_data, varname='Gene2', groupnames=c('Group'))
#plot barplot
p5 <- ggplot(df2, aes(x=Group, y=Gene2,  fill=Group)) + 
  geom_bar(stat='identity', color='black', position=position_dodge()) +
  geom_errorbar(aes(ymin=Gene2-sd, ymax=Gene2+sd), width=.2,
                position=position_dodge(.9)) + 
  theme_classic() + 
  theme(legend.position='none', 
        text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
 
#Get mean and sd of Gene3 by Group
df2 <- data_summary(dataframe_data, varname='Gene3', groupnames=c('Group'))
p6 <- ggplot(df2, aes(x=Group, y=Gene3,  fill=Group)) + 
  geom_bar(stat='identity', color='black', position=position_dodge()) +
  geom_errorbar(aes(ymin=Gene3-sd, ymax=Gene3+sd), width=.2,
                position=position_dodge(.9)) + 
  theme_classic() + 
  theme(legend.position='none', 
        text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
 
pan2 <- ggarrange(p4, p5, p6, ncol = 3, nrow = 1)
ggsave('image2.png', plot = pan2, width = 9,  height = 4,  units = 'cm')
pan2
 
#Draw line plot with dot by cell lines
p7 <- ggplot(dataframe_data, 
             aes(x=Group, y=Gene1, group=Cell.line, 
                 color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p8 <- ggplot(dataframe_data, 
             aes(x=Group, y=Gene2, group=Cell.line, 
                 color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p9 <- ggplot(dataframe_data, 
             aes(x=Group, y=Gene3, group=Cell.line, 
                 color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
 
pan3 <- ggarrange(p7, p8, p9, ncol = 3, nrow = 1)
ggsave('image3.png', plot = pan3, width = 9,  height = 4,  units = 'cm')
pan3
Colored by Color Scripter cs

그림 6. Bar plots with standard deviation (SD) error bars of toy dataset.

위 그림 3과 같이 Gene2와 Gene3에서는 독립된 약물 투입 그룹 (Treat1 and Treat2 groups)에서 감소되는 경향을 확인 할 수 있었으나 전달되는 시각 효과가 적다고 판단했다.

그래서 이번에는 선도표 (line plot)으로 데이터를 표현 해보기로 하였다. 그리고 각각의 세포주 (cell line) 별로 다르게 그려보기로 하였다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #Draw line plot with dot by cell lines
p7 <- ggplot(dataframe_data, 
             aes(x=Group, y=Gene1, group=Cell.line, 
                 color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p8 <- ggplot(dataframe_data, 
             aes(x=Group, y=Gene2, group=Cell.line, 
                 color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p9 <- ggplot(dataframe_data, 
             aes(x=Group, y=Gene3, group=Cell.line, 
                 color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
 
pan3 <- ggarrange(p7, p8, p9, ncol = 3, nrow = 1)
ggsave('image3.png', plot = pan3, width = 9,  height = 4,  units = 'cm')
pan3
Colored by Color Scripter cs

그림 7. Line plots of toy dataset. Red circle, green triangle, and blue square represent cell line1, cell line2, and cell line3, respectively.

앞선 점도표 및 막대도표 대비하여 Gene2의 경우 훨씬 드라마틱하게 떨어지는 느낌을 준다. 하지만 Gene1의 경우나 Gene3의 경우 Treat2 그룹에서 올라가서 마치 증가된 것과 같은 느낌을 주는 것도 마찬가지다. 실험군인 Treat1과 Treat2는 독립적인 실험 결과이므로 나열 순서는 의미가 없다. 그래서 x축의 나열 순서를 DMSO, Treat2, Treat1 순으로 수정을 해보기로 했다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 #Set order of Group
level_order <- c('DMSO', 'Treat2', 'Treat1')
 
p10 <- ggplot(dataframe_data, 
              aes(x=factor(Group, level = level_order), y=Gene1, 
                  group=Cell.line, color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p11 <- ggplot(dataframe_data, 
              aes(x=factor(Group, level = level_order), y=Gene2, 
                  group=Cell.line, color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
p12 <- ggplot(dataframe_data, 
              aes(x=factor(Group, level = level_order), y=Gene3, 
                  group=Cell.line, color=Cell.line, shape = Cell.line)) + 
  geom_point(size=1)+geom_line()+theme_classic()+
  theme(legend.position='none', text = element_text(size = fontsize), 
        axis.text.x = element_text(angle = -315, hjust = 1), 
        axis.title.x=element_blank())
 
pan4 <- ggarrange(p10, p11, p12, ncol = 3, nrow = 1)
ggsave('image4.png', plot = pan4, width = 9,  height = 4,  units = 'cm')
pan4
Colored by Color Scripter cs

그림 8. Line plots of toy dataset in the order of DMSO, Treat2, and Treat1. Red circle, green triangle, and blue square represent cell line1, cell line2, and cell line3, respectively.

Gene2는 앞서 그림 7에 비해 떨어지는 것이 드라마틱하지 않지만, Gene 3의 경우 대조군인 DMSO에 비해 떨어지는 Treat2, Treat1에서 더 떨어지는 느낌을 주었으며, Gene1의 경우도 빨간색 원의 Cellline 1과 파란색의 Celline 3에서 DMSO에 비해 떨어지는 것이 보이므로, DMSO에 비해 Treat1과 Treat2에서 Gene1, Gene2, 및 Gene3에서 떨어지는 경향성이 보인다라는 메시지를 가장 잘 전달한다고 판단하였다.

위 그림 3, 그림 6, 그림 7과 그림 8을 하나로 묶었다.

1
2
3
4
5
6 #Wrap up all pannels into one image with labels
pan5 <- ggarrange(pan1, pan2, pan3, pan4, ncol = 1, nrow = 4, 
                  labels = c('A', 'B', 'C', 'D'), font.label = list(size = 12))
ggsave('image5.png', plot = pan5, width = 9,  height = 16,  units = 'cm')
pan5
 
Colored by Color Scripter cs

그림 9. Plots of toy dataset.

프로그래밍 언어에서 데이터 타입은 왜 사용할까?

2021-04-11T17:14:00.004+09:00

프로그래밍 언어에서 데이터 타입은 왜 사용할까?

프로그래밍 언어에 대한 관심이 참 높은 요즘입니다. 어린이들에게 코딩 교육을 한다는 사교육 기관도 많고, 또 아이들 학습때문에 혹은 취미생활로 또는 시스템 트레이딩 등 투자활동을 하기 위해 코딩을 익히려는 관심이 점점 증가하는 것 같습니다. 이 블로그에서는 프로그래밍 언어를 익히는데 있어서 필수적인 개념을 쉽게 설명하는 것을 목적으로 합니다. 설명의 구체적인 예는 누구나 쉽게 접근할 수 있고 현대 프로그래밍에 가장 앞선 모습을 보이는 python 3를 기준으로 합니다.

프로그래밍 언어 교재 중 많은 수가 도입부에서 몇 가지 데이터 타입에 대한 설명으로부터 시작합니다. 문자열인 String, 정수형인 Integer, 실수형인 Float, 참과 거짓을 나타내는 Boolean 등에 대해 설명을 나열하지만 잘 와닿지 않는 것 같습니다. 왜 데이터 타입을 사용해야 할까요?

이 글에서 결론부터 우선 말하자면, 프로그래밍 언어로 작성 (코딩)한 내용을 컴퓨터가 이해하고 실행할 수 있도록 해주는 번역 및 실행하는 과정에서 컴파일러나 인터프리터가 해당 값을 어떻게 다루어야 하는지 지시하기 위한 것이기 때문입니다. 몇 가지 사례로 위 결론을 구체화 해보겠습니다.

예를 들어, python 3에서 정수형 (int) 데이터 타입 둘을 * 연산자로 연결하면 python 인터프리터는 이를 곱셈으로 인식합니다.

>>> 14 * 3

하지만 문자열 (str) 데이터 타입의 값과 정수형 데이터 타입의 값 둘을 * 연산자로 연결하면 인터프리터는 이를 해당 문자열을 지정된 회수만큼 반복하는 문자로 만들어줄 것으로 인식합니다.

>>> ’ho’ * 3

‘hohoho’

모든 컴퓨터 프로그래밍 언어는 Java, C#과 같이 명시적으로 선언하고 데이터 타입에 따라 값에 대한 연산 혹은 함수를 적용 할 때 다르게 처리하도록 하거나 python이나 Javascript 등과 같이 인터프리터가 알아서 유추할 수 있게 힌트를 주어 눈치껏 처리하도록 하는 방식으로 되어있습니다.

다시 python으로 돌아가서 python은 홑따옴표 혹은 쌍따옴표를 사용하여 인터프리터에게 문자열이라는 힌트를 줍니다.

>>> my_id = ‘monolith’

>>> print(my_id)

monolith

>>> my_id = “monolith”

>>> print(my_id)

monolith

여러 줄의 문자를 변수에 할당하고 싶을 때에는 엔터에 해당하는 관습적인 특수문자열인 \n을 사용할 수 있습니다. (아래 예제 코드에 구분하기 쉽도록 해당 특수 기호를 붉은 색으로 칠했습니다.)

>>> my_id = ‘monolith\nmy favorite number is 42’

>>> print(my_id)

monolith

my favorite number is 42

python에서는 특수하게 여러 줄의 문자를 특수기호를 사용하지 않고 변수에 할당하고 싶다면 아래와 같이 홑따옴표나 쌍따옴표를 연속으로 3개 붙여주면 됩니다.

>>> my_id = ‘’’monolith

my favorite number is 42’’’

>>> print(my_id)

monolith

my favorite number is 42

다만 홑따옴표와 쌍따옴표를 혼용해서는 안됩니다. 왜냐면 아래와 같은 방식으로 사용해야 하는 경우가 있기 때문입니다.

>>> my_script = ‘He shouted “Get out!”’

>>> print(my_script)

He shouted “Get out!”

숫자 값을 다루는 데이터 형은 정수형 (int)와 실수형 (float)으로 나뉩니다. C++ 등에서는 long integer나 double 등도 있으나 python에서는 길이 제약을 따로 두지 않습니다. python 인터프리터에 정수형이냐 실수형이냐 힌트는 숫자를 할당할 때, 소수점이 있는지 여부입니다. 참고로 #은 대부분의 컴퓨터 프로그래밍 언어에서 주석 (comment; 코딩한 내용이 컴퓨터가 실행가능한 코드로 변환될 때 제외되는 부분)을 나타낼 때 관습적으로 사용합니다.

>>> my_number = 42 #정수형

>>> my_number = 42.0 #실수형

그러면 정수형 값과 정수형 값을 나누는 것과 정수형 값과 실수형 값을 나누는 것은 어떻게 차이가 날지 보겠습니다.

>>> 42 / 2

21.0

>>> 42/2.0

21.0

둘 간 차이는 없습니다. python 2에서는 정수형 값들 간 나누기는 정수형 값을 인터프리터가 돌려주었으나 수학적으로 실수형 값으로 되돌려주는 것이 더 정확하기 때문에, 현재는 실수형 값을 되돌려줍니다. 곱셈도 마찬가지일까요?

>>> 21*2

>>> 21*2.0

42.0

정수형간 곱셈은 정수가 나오는 것이 수학적으로 옳기 때문에, 정수형으로 리턴합니다.

숫자형 값을 사용할 때, 유용한 것은 지수형을 사용하여 긴 값을 짧게 표현 할 수 있습니다.

>>> 1e4

10000.0

>>> 1e-4

0.0001

다만 1을 생략한 e4와 같은 표기는 변수 이름이나 함수 이름 등과 구분 할 수 없기 때문에 인터프리터가 받아주지 않습니다. 코딩을 잘 하기 위해서는 아래와 같은 오류 메시지를 절대 그냥 넘기지 말고 무슨 의미인지 파악하기 위해 정독하는 것이 필수입니다.

>>> e4

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

NameError: name 'e4' is not defined

python에서는 두 값이 같은지 여부를 확인하는 연산자 ==과 다른지 여부를 확인하는 연산자 != 가 있습니다.

>>> 2 == 2

True

>>> 10000.0 == 1e4

True

재밌는 것은 정수형인 10000은 실수형인 1e4와 당연하게도 같다고 봅니다.

>>> 10000 == 1e4

True

실수형으로 1.0으로 기입한 것은 인터프리터는 소수점 자리수를 표기한 것으로 보기 때문입니다.

아래처럼 정수형 1과 실수형 1.1간 비교는 당연히 다르다고 판단해줍니다.

>>> 1 == 1.1

False

실수형 값을 정수형 값으로 변환해 주는 함수로 int()라는 것이 있습니다.

>>> int(1.1)

그래서 실수형 값 1.1을 정수형으로 변환 후 1과 비교하면 당연히 같다고 판단합니다.

>>> 1 == int(1.1)

True

그러면 1.5나 1.6을 정수형으로 변환하면 어떻게 될까요?

>>> int(1.5)

>>> int(1.6)

'정수형으로 값을 변환하는 것은 두 정수 중에서 0에 가깝게 한다'

출처 입력

는 원칙이 수학적으로 옳기 때문에 인터프리터는 1.9는 1과 2 중에서 0에 가까운 1을 되돌려 줍니다. 그러므로 1과 int(1.9)는 같습니다.

소수점 첫째 자리에서 반올림을 하려면 (속칭 사사오입) int()함수가 아니라 round()함수를 사용하면 됩니다. 이 함수는 반올림 하려는 값과 소수점 몇 째 자리까지 남길 것 인가를 지정하는 인수(parameter)를 함께 넘겨주면 됩니다. 1.4를 소수점 첫째 자리에서 반올림 하려 한다면 아래와 같이 하면 됩니다.

>>> round(1.4, 0)

1.0

>>> round(1.5, 0)

2.0

python에서는 무리수 또한 지원을 합니다.

>>> 1 + 1j

(1+1j)

>>> 2 * (1 + 1j)

(2+2j)

다만 아래처럼 무리수 부분에 괄호로 두 수를 구분하지 않으면 인터프리터는 허수부를 그냥 더한 것으로 오해하기 때문에 주의해야 합니다.

>>> 2 * 1 + 1j

(2+1j)

아래처럼 무리수의 실수부와 허수부를 띄워쓰기 없이 붙여써도 마찬가지 결과입니다. 수학적으로 연산자 우선순위를 피하기 위한 구분은 괄호를 쓰는 것을 기본 원칙으로 하기 때문입니다.

>>> 2 * 1+1j

(2+1j)

무리수간 곱셈 연산도 당연히 가능합니다.

>>> (2+1j)*(2+1j)

(3+4j)

>>> (2+1j)*(2-1j)

(5+0j)

이제는 코딩에서 데이터 형을 사용하는 이유를 좀 더 포괄적으로 말해보겠습니다. 1960년대 미의회는 인공지능 (AI) 학회에 인공지능이 사람의 언어를 이해할 수 있을지를 문의 합니다. 인공지능 학회의 답변은 불가능하다 였습니다. 그 이유는 컴퓨터 프로그래밍 언어는 문맥 자유 문법 (Context free grammar)을 기초로 한 것이기 때문에 인간의 언어를 이해할 수 없다는 것이고 그래서 인간이 구축한 지식을 습득하여 포괄적인 지적능력을 갖출 수 없다는 결론이 나옵니다.

예를 들어, 어떤 사람이 '사과'라는 단어를 갑자기 말하면 그 말을 한 사람 (화자)과 듣는 사람 (청자)간 동일한 것을 연상할 수도 있지만 대다수는 제 각각 다른 대상을 떠올리기 일쑤입니다. 누군가는 어떤 잘못에 대한 뉘우침으로 하는 말을 하는 것으로 생각하겠지만, 또다른 누군가는 과일을 말하는 것으로 생각 할 수도 있습니다. 혹은 과일을 떠올린 사람들도 제 각각인게, 누군가는 거기서 한발 더 나아가 'Big apple'이라 불리는 뉴욕을 떠올릴 수도, 누군가는 컴퓨터 및 스마트폰 브랜드인 애플사를, 앨런 튜닝의 일화를, 백설공주가 깨어문 사과를, 혹은 누군가는 성서 속 선악과를 떠올릴 수도 있습니다. 그래서 우리는 해당 말을 한 사람이 앞서 혹은 이어서 하는 말을 듣고서야 무엇을 말하는지 파악할 수 있습니다. 그리고 문맥에 따라 반응하게 되는 것입니다.

컴퓨터 프로그래밍언어는 문맥을 다룰 능력이 없기 때문에 우리가 코딩에서 사용하는 값이 무엇인지 정확하게 지칭 (C, C++, Java, C#, Type script 등과 같은 언어)하거나 적당하게 힌트를 주거나 (python, R, Basic 등과 같은 언어) 하게 됩니다. 즉 * 라는 연산자를 사용했을 때, 이 것이 숫자의 곱셈을 뜻하는 것인지 문자열의 반복을 뜻하는 것인지, 혹은 + 연산자를 사용했을 때 이 것이 숫자의 덧셈을 뜻하는 것인지 두 문자열의 결합을 뜻하는 것인지 데이터 타입이 없다면 컴퓨터는 판단을 내릴 수 없습니다. 오로지 데이터 타입에 따라 행동을 달리 합니다. 이 것을 객체지향 기술에서 다형성 (polymorphism)이라 하고 기본적으로 데이터 타입에 따라 동일한 연산자 혹은 함수가 다르게 처리하도록 하게하는 객체지향 기술에서 가장 핵심이 되는 것입니다.

위의 AI에 관한 것으로 다시 돌아가서 그러므로, 컴퓨터가 인간의 어떤 메시지든 지식이든 다루는 것에 대한 문맥을 파악할 수 없어 인간의 지적 능력을 뛰어넘는 general AI가 나올 수 없습니다. 그래서 터미네이터 속 세상은 올 수 없습니다. 다만 이 것과 기계가 사고 (생각)을 하느냐는 다른 것입니다. 기계는 당연히 사고를 합니다. 이에 대해서는 나중에 다시 다루도록 하겠습니다.

#python #파이썬 #코딩 #coding #code #데이터타입 #데이터형 #datatype

Exercise 4.3-Answer

2012-04-07T20:34:00.001+09:00

from: http://openbookproject.net/thinkcs/python/english3e/functions.html#exercises

Write a non-fruitful function draw_poly(t, n, sz) which makes a turtle draw a regular polygon. When called with draw_poly(tess, 8, 50), it will draw a shape like this:

  1: # -*- coding: UTF-8 -*-
  2: #!/usr/bin/env python
  3: import turtle
  4: 
  5: def createWindow(bgcolor, title):
  6:     w = turtle.Screen()
  7:     w.bgcolor(bgcolor)
  8:     w.title(title)
  9:     return w
 10: 
 11: def createTurtle(color, size):
 12:     t = turtle.Turtle()
 13:     t.pensize(size)
 14:     t.color(color)
 15:     return t
 16: 
 17: def draw_poly(t, n, sz):
 18:     for i in range(n):
 19:         t.forward(sz)
 20:         t.left(360 / n)
 21: 
 22: wn = createWindow("lightgreen", "Exercises 4.3")
 23: tess = createTurtle("hotpink", 3)
 24: 
 25: draw_poly(tess, 8, 50)
 26: 
 27: wn.mainloop()
 28:

Exercise 4.2-Answer

2012-04-07T20:32:00.001+09:00

from: http://openbookproject.net/thinkcs/python/english3e/functions.html#exercises

Write a program to draw this. Assume the innermost square is 20 units per side, and each successive square is 20 units bigger, per side, than the one inside it.

  1: # -*- coding: UTF-8 -*-
  2: #!/usr/bin/env python
  3: 
  4: import turtle
  5: 
  6: def createWindow(bgcolor, title):
  7:     w = turtle.Screen()
  8:     w.bgcolor(bgcolor)
  9:     w.title(title)
 10:     return w
 11: 
 12: def createTurtle(color, size):
 13:     t = turtle.Turtle()
 14:     t.pensize(size)
 15:     t.color(color)
 16:     return t
 17: 
 18: def jump(t, l):
 19:     t.penup()
 20:     t.backward(l)
 21:     t.right(90)
 22:     t.forward(l)
 23:     t.left(90)
 24:     t.pendown()
 25: 
 26: def draw_square(t, l):
 27:     for i in range(4):
 28:         t.forward(l)
 29:         t.left(90)
 30:     jump(t, 10)
 31: 
 32: wn = createWindow("lightgreen", "Exercises 4.2")
 33: tess = createTurtle("hotpink", 3)
 34: 
 35: for i in range(5):
 36:     draw_square(tess, 20 * (i + 1))
 37: 
 38: wn.mainloop()
 39:

Exercise 4.1-Answer

2012-04-07T20:30:00.001+09:00

from: http://openbookproject.net/thinkcs/python/english3e/functions.html#exercises

Write a non-fruitful function to draw a square. Use it in a program to draw the image shown below. Assume each side is 20 units. (Hint: notice that the turtle has already moved away from the ending point of the last square when the program ends.)

  1: # -*- coding: UTF-8 -*-
  2: #!/usr/bin/env python
  3: 
  4: import turtle
  5: 
  6: def createWindow(bgcolor, title):
  7:     w = turtle.Screen()
  8:     w.bgcolor(bgcolor)
  9:     w.title(title)
 10:     return w
 11: 
 12: def createTurtle(color, size):
 13:     t = turtle.Turtle()
 14:     t.pensize(size)
 15:     t.color(color)
 16:     return t
 17: 
 18: def jump(t, l):
 19:     t.penup()
 20:     t.forward(l)
 21:     t.pendown()
 22: 
 23: def draw_square(t, l):
 24:     for i in range(4):
 25:         t.forward(l)
 26:         t.left(90)
 27:     jump(t, l * 2)
 28: 
 29: 
 30: wn = createWindow("lightgreen", "Exercises 4.1")
 31: tess = createTurtle("hotpink", 3)
 32: 
 33: for i in range(5):
 34:     draw_square(tess, 20)
 35: 
 36: wn.mainloop()
 37:

Exercise 3.2-Answer

2012-04-07T20:28:00.001+09:00

from: http://openbookproject.net/thinkcs/python/english3e/hello_little_turtles.html#exercises

Write a program to draw a face of a clock that looks something like this:

  1: # -*- coding: UTF-8 -*-
  2: #!/usr/bin/env python
  3: 
  4: import turtle           # turtle을 사용할 수 있도록 한다.
  5: 
  6: wn = turtle.Screen()
  7: wn.title("A face of a clock")
  8: wn.bgcolor("lightgreen")
  9: 
 10: alex = turtle.Turtle()
 11: alex.pensize(3)
 12: alex.speed(0)
 13: alex.shape("turtle")
 14: alex.color("blue")
 15: 
 16: for i in range(12):
 17:     alex.penup()
 18:     alex.forward(80)
 19:     alex.pendown()
 20:     alex.forward(10)
 21:     alex.penup()
 22:     alex.forward(30)
 23:     alex.stamp()
 24:     alex.backward(120)
 25:     alex.right(30)
 26: 
 27: alex.stamp()
 28: 
 29: wn.mainloop()           # 사용자가 윈도우를 닫을 때까지 기다린다.
 30:

Exercise 3.1–Answer

2012-04-07T20:22:00.001+09:00

from: http://openbookproject.net/thinkcs/python/english3e/hello_little_turtles.html#exercises

Write a program to draw a shape like this:

Hints:

Try this on a piece of paper, moving and turning your cellphone as if it was a turtle. Watch how many complete rotations your cellphone makes before you complete the star. Since each full rotation is 360 degrees, you can figure out the total number of degrees that your phone was rotated through. If you divide that by 5, because there are five points to the star, you’ll know how many degrees to turn the turtle at each point.
You can hide a turtle behind its invisibility cloak if you don’t want it shown. It will still draw its lines if its pen is down. The method is invoked as tess.hideturtle() . To make the turtle visible abain, use tess.showturtle() .

  1: # -*- coding: UTF-8 -*-
  2: #!/usr/bin/env python
  3: 
  4: import turtle           # turtle을 사용할 수 있도록 한다.
  5: 
  6: wn = turtle.Screen()
  7: wn.title("Star")
  8: 
  9: alex = turtle.Turtle()
 10: alex.pensize(5)
 11: alex.speed(1)
 12: 
 13: for i in range(5):
 14:     alex.forward(200)
 15:     alex.right(144)
 16: 
 17: alex.hideturtle()
 18: wn.mainloop()           # 사용자가 윈도우를 닫을 때까지 기다린다.
 19:

Python Persistence (1) : Pickle 모듈

2011-11-19T02:51:00.001+09:00

Python 3.2 Pickle 모듈

오늘 포스트는 인제대학교 의용공학과 전공 과정인 중급실용전산 수업에서 다뤘던 Persistence 관련 모듈 중 Pickle에 관한 것이다. 컴퓨터 프로그래밍에 있어 영속화를 익히는 과정은 대체적으로 ASCII 포맷의 Text 파일 다루기, Binary 포맷의 파일 다루기, 시리얼화(serialization), 마크업(HTML, XML 등의 ASCII 또는 그 외 Binary Markup), 데이터베이스 전체를 다루거나 또는 그 일부만 언급한 책자도 많다. 위 과정에서 채택한 주교재인 Head First Programming 에선 시리얼화를 이용한 영속화 모듈인 Pickle과 Shelve를 다루지 않으므로 이를 보강하는 의도에서 이 포스트와 다음 포스트인 Python Persistence (2) : Shelve 모듈에서 이들에 대해 살펴보도록 한다.

Pickle이나 Shelve와 같은 시리얼화를 이용한 영속화 작업을 수행하는 이유는 프로그램에서 생성한 객체의 실행 시 담고 있는 그 상태 값을 그대로 컴퓨터의 저장 매체에 저장했다가 추후에 그대로 사용하기 위한 목적을 쉽게 달성하기 위해서다. C#이나 Java 등에서도 이러한 시리얼화를 지원하지만 Python은 Pickle 및 Shelve 모듈로 간단히 구현할 수 있도록 했다.

Pickle 모듈을 이용한 코드 예제는 간단한 일정관리용 콘솔 프로그램으로 하도록 한다. 우선 콘솔용 UI를 아래와 같이 작성했고, 그 출력은 다음과 같다.

  1: #!/usr/bin/env python
  2: # -*- coding: UTF-8 -*-
  3: 
  4: def clearAll():
  5:     return []
  6: 
  7: def printList(items):
  8:     print ("-" * 30)
  9:     print ("%d개의 일정이 등록되어 있습니다." % len(items))
 10:     for item in items:
 11:         print("\t%s" % item)
 12:     print ("-" * 30)
 13: 
 14: import pickle
 15: 
 16: toDo = [] # 사용자가 입력한 일정 담을 리스트
 17: menu = ["출력", "전체 제거", "추가"]    # 메뉴 리스트
 18: running = True
 19: 
 20: print ("*" * 30)
 21: print ("일정관리")
 22: print ("*" * 30)
 23: 
 24: while running:
 25:     option = 1
 26: 
 27:     for m in menu:
 28:         print ("%d. %s" % (option, m))
 29:         option += 1
 30:     print ("%d. %s" % (option, "종료"))
 31:     try:
 32:         command = int(input("원하는 메뉴 번호를 입력하세요: "))
 33:     except ValueError:
 34:         command = 0
 35: 
 36:     if command == option:
 37:         running = False
 38:     elif command == 1:
 39:         printList(toDo)
 40:     elif command == 2:
 41:         toDo = clearAll()
 42:     elif command == 3:
 43:         do = input("\t일정명: ")
 44:         toDo.append(do)
 45:         printList(toDo)

Pickle 모듈을 사용하기 위해서는 14행과 같이 모듈을 import 한다. Pickle에서는 파일을 바이너리 포맷으로 다루게 되므로 파일 읽거나 쓸 때 파일모드는 반드시 binary 포맷으로 해야 한다. 즉 open() 내장 함수의 모드 파라메터를 ‘rb’와 ‘wb’로 해야 한다. 우선 파일을 저장하는 save() 함수를 다음과 같이 작성했다. Pickle 모듈의 파일 저장 함수는 dump() 이다. 오류처리 구문을 제외하면 이 함수는 with 문을 통해 파일 처리를 Python의 Context Manager에 위임하고, 저장할 객체(이 예제에서는 list object)와 파일 핸들러를 pickle.dump() 함수에 파라메터로 넘겨주는 것이 다이다.

  1: def save(items, fname="items.todo"):
  2:     """
  3:     save todo items into binary file
  4:     """
  5:     try:
  6:         with open(fname, "wb") as fh:
  7:             pickle.dump(items, fh)
  8:     except IOError as ioerr:
  9:         print ("File Error: %s" % str(ioerr))
 10:     except pickle.PickleError as pklerr:
 11:         print ("Pickle Error: %s" % str(pklerr))

위 save() 함수를 첫 코드에 작성 후, 첫 코드의 46번째 줄에 save(toDo)를 추가하면 프로그램 실행 시 파일이 생성된다. 여기서 save(toDo) 코드는 while 문이 종료되는 시점에 호출되도록 들여쓰기(indentation)을 주의해야 한다. 코드 일부와 그 실행 시 예는 아래와 같으며, 생성된 파일(items.todo)에 저장된 내용도 그 아래 표시했다.

23: ...
24: while running:
25: ...
45:         printList(toDo)
46: save(toDo)

이제 프로그램 실행 시 Pickle 모듈로 저장한 파일이 있다면 이를 읽어 들여 되돌려 주는 load() 함수를 추가한다. 기존에 생성된 파일이 없으면 save() 함수에 빈 리스트 하나를 파라메터로 넘겨 비어있는 파일 하나를 만들도록 했다. 그 코드는 아래와 같다. 오류처리 구문을 제외하면, save() 함수와 마찬가지로 파일 핸들러를 얻고 이를 pickle.load() 함수에 파라메터로 넘겨 파일을 읽어 들이면 된다.

  1: def load(fname="items.todo"):
  2:     """
  3:     load todo items binary file into memory
  4:     and assigns its values to corresponding object's states
  5:     """
  6:     savedItems = [] # 빈 리스트 생성
  7:     try:
  8:         with open(fname, "rb") as fh:
  9:             savedItems = pickle.load(fh)
 10:     except IOError as ioerr:
 11:         save(savedItems, fname) # create empty file
 12:     except pickle.PickleError as pklerr:
 13:         print ("Pickle Error: %s" % str(pklerr))
 14:     finally:
 15:         return savedItems

이 프로그램의 메인 부분에 해당하는 첫 코드의 16행 toDo = [] 코드를 아래와 같이 수정 후 프로그램을 실행 후, 출력 메뉴를 선택하면 그 아래 그림에 나타낸 것과 같이 앞서 save() 함수 적용 후 입력한 내용이 출력되는 것을 확인 할 수 있다.

...
16: toDo = load() # 사용자가 입력한 일정 담을 리스트
...

이 포스트에서는 Python에서 Pickle 모듈을 이용한 영속화 예제를 살펴봤다. 이 예제의 경우 단일한 일정목록을 그 개수에 제한 없이 사용할 수 있지만 날짜와 같은 구분 지을 수 있는 키로 여러 데이터 세트를 상황에 맞게 사용하려면 리스트 대신 딕셔너리 객체를 이용하면 되지만 시리얼화로 저장한 파일 내용 전체를 읽어 들여야 해서 비효율 적이다. 필요한 부분만 별도로 관리할 수 있는 모듈이 포스트 처음에 언급한 Shelve 모듈이다. 이는 다음 포스트에서 살펴보도록 한다. 이 프로그램의 전체 코드는 아래와 같다.

  1: #!/usr/bin/env python
  2: # -*- coding: UTF-8 -*-
  3: #-------------------------------------------------------------------------------
  4: # Name:        TodoListPickle
  5: # Purpose:      Pickle 모듈을 이용한 파일 영속화(persistence) 예제
  6: #
  7: # Author:      oscarpark
  8: #
  9: # Created:     18-11-2011
 10: # Copyright:   (c) oscarpark 2011
 11: # Licence:     Licence Free
 12: #-------------------------------------------------------------------------------
 13: 
 14: 
 15: def clearAll():
 16:     return []
 17: 
 18: def printList(items):
 19:     print ("-" * 30)
 20:     print ("%d개의 일정이 등록되어 있습니다." % len(items))
 21:     for item in items:
 22:         print("\t%s" % item)
 23:     print ("-" * 30)
 24: 
 25: def save(items, fname="items.todo"):
 26:     """
 27:     save todo items into binary file
 28:     """
 29:     try:
 30:         with open(fname, "wb") as fh:
 31:             pickle.dump(items, fh)
 32:     except IOError as ioerr:
 33:         print ("File Error: %s" % str(ioerr))
 34:     except pickle.PickleError as pklerr:
 35:         print ("Pickle Error: %s" % str(pklerr))
 36: 
 37: def load(fname="items.todo"):
 38:     """
 39:     load todo items binary file into memory
 40:     and assigns its values to corresponding object's states
 41:     """
 42:     savedItems = [] # 빈 리스트 생성
 43:     try:
 44:         with open(fname, "rb") as fh:
 45:             savedItems = pickle.load(fh)
 46:     except IOError as ioerr:
 47:         save(savedItems, fname) # create empty file
 48:     except pickle.PickleError as pklerr:
 49:         print ("Pickle Error: %s" % str(pklerr))
 50:     finally:
 51:         return savedItems
 52: 
 53: import pickle
 54: 
 55: toDo = load() # 사용자가 입력한 일정 담을 리스트
 56: menu = ["출력", "전체 제거", "추가"]    # 메뉴 리스트
 57: running = True
 58: 
 59: print ("*" * 30)
 60: print ("일정관리")
 61: print ("*" * 30)
 62: 
 63: while running:
 64:     option = 1
 65: 
 66:     for m in menu:
 67:         print ("%d. %s" % (option, m))
 68:         option += 1
 69:     print ("%d. %s" % (option, "종료"))
 70:     try:
 71:         command = int(input("원하는 메뉴 번호를 입력하세요: "))
 72:     except ValueError:
 73:         command = 0
 74: 
 75:     if command == option:
 76:         running = False
 77:     elif command == 1:
 78:         printList(toDo)
 79:     elif command == 2:
 80:         toDo = clearAll()
 81:         save(toDo)
 82:     elif command == 3:
 83:         do = input("\t일정명: ")
 84:         toDo.append(do)
 85:         printList(toDo)
 86: save(toDo)

BuzzNet Tags: Python 3.2,Persistence,Pickle

측정 단위 문제: How to avoid the dependence on the choice of measurement units?

2011-11-18T04:29:00.001+09:00

우리는 다양한 부면의 데이터를 수집하고 이들 속에 어떤 상관(correlation) 혹은 연관(association) 관계를 찾는다. 이들 데이터 중 일부는 인공의 기준을 세우고 단위를 부여한다. 동일한 속성을 가리키는 값이라 해도 그 단위에 따라 다른 값으로 나타나는데 이로 인해 그 결과가 상이하게 되기도 한다.
예를 들어, 4명의 나이와 키를 아래와 같이 수집했고, 이를 아래 표와 같이 정리했다고 하자.

Table 1. Age(in years) and height(in centimeters) of 4 people.

Person	Age (years)	Height (cm)
A	25	180
B	30	180
C	25	165
D	30	165

Python으로 이들 데이터를 matplotlib 모듈을 이용해 도표를 그려보자.
참고로 matplotlib는 Python 2.x 만 제공하고 있고 또 LaTeX를 기능을 사용하는 경우도 있기 때문에 공식 웹 사이트가 아닌 다른 곳에서 Python 3.2용 matplotlib를 받아서 설치 해야 한다.
이 사이트는 Unofficial Windows Binaries for Python Extension Packages로 그 외에도 유용한 패키지가 많다. 그리고 Windows용 TeX는 TeX Live를 받아서 설치 했는데 Linux Mint에서와 마찬가지로 texlive-latex-base와 texlive-latex-recommended 뿐만 아니라 texlive-math-extra와 texlive-fonts-extra도 함께 설치 해야 한다. 또 Windows에서 TeX Live 패스 설정을 하지 않는다면 문제가 발생하는데, 이는 googling으로 해결하면 된다. 물론 TeX 설치가 힘들다면 그냥 matplotlib 모듈에서 TeX 기능을 사용치 않거나 굳이 써야 하면 Mac이나 Linux에서 사용하는걸 권한다. (개인적으론 Mac에서 설정 잡는 것이 편했다.)

  1: import matplotlib.pyplot as plt
  2: 
  3: fig = plt.figure()
  4: 
  5: fig.suptitle('The dependence on the choice of measurement units', fontsize=14, fontweight='bold')
  6: ax = fig.add_subplot(111)
  7: fig.subplots_adjust(top=0.85)
  8: 
  9: ax.set_title('Height versus age')
 10: ax.set_xlabel('Age (YEARS)')
 11: ax.set_ylabel('Height (CM)')
 12: 
 13: x = [25, 30, 25, 30] # age
 14: y = [180, 180, 165, 165] # height
 15: persons = ["A", "B", "C", "D"]
 16: 
 17: ax.scatter(x,y,s=120, zorder=2)
 18: 
 19: for i in range(4):
 20:     #ax.plot(x[i], y[i], c="red", marker = 'o')
 21:     #ax.scatter(x[i], y[i],s=70, zorder=2)
 22:     ax.text(x[i], y[i] * 1.01 , persons[i], color='black')
 23: 
 24: ax.axis([15, 50, 150, 190])
 25: ax.grid()
 26: plt.show()
 27:

위 코드를 실행하면 다음과 같은 도표를 확인 할 수 있다. 이 도표를 통해 데이터를 눈으로 가까운 것과 먼 것을 나눠보면 {A, B}와 {C, D}가 될 것이다.

Table 1에서 신장 값을 센티미터 단위로 나타냈던 것을 피트 단위를 이용한다면 아래 Table 2와 같이 나타난다. (1ft = 30.48 cm)

Table 2. Age(in years) and height(in feet) of 4 people.

Person	Age (years)	Height (feet)
A	25	5.91
B	30	5.91
C	25	5.41
D	30	5.41

이 데이터를 도표 상 나타내도록 코드를 일부 수정하여 아래 코드에 나타내었다. 단, 수정된 위치 및 추가 된 것만 나타냈다. 위 코드 행과 맞춰보면 된다.

...
11: ax.set_ylabel('Height (Ft)')
...
16: y = [float(("%1.2f") % (i / 30.48)) for i in y]
...
24: ax.axis([15, 50, 3, 8])

이 도표를 통해 데이터를 눈으로 가까운 것과 먼 것을 나눠보면 {A, C}와 {B, D}가 될 것이다. 물론 이 두 도표는 Height 축의 비율(scale)에 의한 착시 현상이 존재한다. 아래 코드와 같이 24 행을 수정하면 figure01과 같이 나타낼 수 있다. 결국 이 비율 문제도 이 포스트에서 다루는 문제와 같은 것이다.

24: ax.axis([15, 50,
        float(("%1.2f") % (150 / 30.48)),
        float(("%1.2f") % (190 / 30.48))])

이런 문제를 해결하기 위해서는 데이터를 단위가 없는 표준화된 데이터로 변환하는데 일반적으로 표준편차(standard deviation)를 구해 표준점수(standard score, z-score)로 환산한다. 다만 표준편차의 경우 데이터 값과 그 표본 평균(일반적으로 산술평균)차를 제곱함으로 인해 점수가 부풀려지는 경우가 발생할 수 있다.

절대 평균 편차(mean absolute deviation)을 구하면 이런 경향을 피할 수 있다. 절대 평균 편차는 각 값과 표본 평균 차의 절대치를 취해 원래 값과 비례하도록 한다.

이를 구하여 도표로 그리는 코드를 다음과 같이 작성했고 그 결과는 아래와 같다. 이 코드를 실행 후, 다시 17행에 있는 피트 단위로 변환하는 코드의 주석을 제거 후 실행해도 동일한 결과를 얻게 된다. 14~16행에 데이터를 좀 더 추가해서 수행해보는 것도 좋다.

  1: import matplotlib.pyplot as plt
  2: import math
  3: 
  4: fig = plt.figure()
  5: 
  6: fig.suptitle('The dependence on the choice of measurement units', fontsize=14, fontweight='bold')
  7: ax = fig.add_subplot(111)
  8: fig.subplots_adjust(top=0.85)
  9: 
 10: ax.set_title('Height versus age')
 11: ax.set_xlabel('Age (z-score)')
 12: ax.set_ylabel('Height (z-score)')
 13: 
 14: x = [25, 30, 25, 30] # age
 15: y = [180, 180, 165, 165] # height
 16: persons = ["A", "B", "C", "D"]
 17: #y = [float(("%1.2f") % (i / 30.48)) for i in y]
 18: 
 19: # calculates means of x and y
 20: mx, my = math.fsum(x) / len(x), math.fsum(y) / len(y)
 21: 
 22: # calculates mads of x and y
 23: sx, sy = (1/len(x)) * math.fsum(math.fabs(i - mx) for i in x), \
 24:         (1/len(y)) * math.fsum(math.fabs(i - my) for i in y)
 25: 
 26: # calculates each z-scores of x and y elements
 27: # and assigns them into new lists madx, mady
 28: # z_socre = (xi - mean) / s_mad
 29: madx, mady = [ (i - mx) / sx for i in x ], \
 30:             [ (i - my) / sy for i in y ]
 31: 
 32: ax.scatter(madx, mady, s=120, zorder=2)
 33: 
 34: for i in range(4):
 35:     ax.text(madx[i], mady[i] * 1.2 , persons[i], color='black')
 36: 
 37: ax.axis([-2, 2, -2, 2])
 38: ax.grid()
 39: plt.show()

이 포스트에서는 동일한 속성에 대한 여러 단위에 의한 표현형을 가지는 값을 단위를 배제하고 표준 점수로 나타내는 과정을 Python 3.2와 matplotlib 모듈로 작성해 보였다. 여기에 보인 도표는 모두 matplotlib에서 그려진 이미지를 저장한 것이다. 실제 코드를 실행하면 아래 그림과 같은 윈도우가 실행된다. 저장 버튼을 눌러 PNG 포맷 이미지로 저장 매체에 저장할 수 있다.

이 포스트를 통해 원래 전하고자 했던 바는, 컴퓨터 프로그래밍 언어에 있어 마일스톤(milestone)인 Python의 간편함과 유용성을 보이고자 한데 있다. 물론 matplotlib 모듈의 경우 Windows 환경에서 Python 3.2와 조합 시 설치부터 어려움을 유발하고 또한 matplotlib 자체가 차트 및 그래프의 A to Z까지 모두 제공하다 보니 일견 어려울 수도 있지만 matplotlib 웹 사이트 내 갤러리 및 예제를 참조하다 보면 Python 문법 차체의 간결함과 일관된 패턴이 상승효과를 유발해 수월하게 익힐 수 있다. 이제 공과 대학은 Matlab과 작별을 고해도 될 시점이라 생각한다.

BuzzNet Tags: Python 3.2,matplotlib,Windows 7,Mean Absolute Derivation

데이터 이전: 파이썬과 SQLite3

2011-11-17T00:25:00.001+09:00

분산된 웹 환경하에서 여러 데이터를 취합하거나 혹은 단일 데이터 저장소로부터 내려받은 데이터를 다른 저장소로 이전해야 하는 경우가 종종 발생한다. 예를 들어 공개된 생명정보 데이터베이스로부터 쿼리 결과를 FASTA 포맷으로 다운로드 받아 이를 전문화된 라이브러리 구축을 위해 별도의 데이터 저장소로 옮기는 등의 작업이 빈번히 발생할 수 있다.

참고로, 사적으로 여러 차례 언급해왔지만 단 한번 수행하고 오랜 시간 동안 반복하지 않을 일이라면, 예를 들어, 일년에 두세 차례 수행하고 말 일이라면, 그 데이터 양이 얼마든지 간에 손으로 해치우고 마는 것이 훨씬 일을 간결하게 할 수 있다. 혹은 데이터 양이 많고 일부분에서 손이 많이 가며 반복적 패턴이 있다면 딱 그 부분만 처리하도록 코드를 작성하는 것이 더 효율적이다.

이 포스팅은 파이썬으로 데이터 이전을 수행하는 과정에 있어 많은 부분을 자동적으로 처리하기 위해 고려해야 할 부분과 내가 선호하는 방법에 대해 풀어 설명하는 목적으로 작성했다. 여기서 다루는 내용은 Microsoft SQL Server 예제 데이터베이스인 AdventureWorks로부터 ASCII 포맷으로 내려 받은 데이터를 파이썬과 이에 내장된 SQLite 모듈을 이용해 SQLite3 데이터베이스로 이전하는 코드이다.

AdventureWorks 데이터베이스의 Address, Customer, CustomerAddress, Product, ProductCategory, ProductModel, SalesOrderHeader, SalesOrderDetail 테이블로부터 일부 데이터를 가공해 ASCII 포맷 Text 파일로 내려 받았다. 이들 테이블에 관한 상세 내역은 AdventureWorks Data Dictionary 페이지를 참조토록 한다. 첨언하면, 데이터베이스 설계, 프로그래밍, 관리, 튜닝 등을 공부하는데 이런 예제 데이터베이스를 활용하는 것이 가장 효율적인 방법이었다.

각 필드 구분자는 탭(\t)을 사용했고 이 값들과 사상(mapping)하는 필드 명은 아래 SQLite3 데이터베이스에 테이블 생성을 위한 SQL DDL(Data Definition Language)문으로 확인 할 수 있다.

SQLite는 프로그래밍 라이브러리로 이는 단일 데이터베이스 파일을 In-Memory에서 다루는 데이터베이스 엔진이다. SQLite는 여러 이종 플랫폼에서 광범위하게 이용되고 있다. 이에 관한 상세한 내용은 SQLite 공식 웹 사이트에서 확인 할 수 있다.

SQLite에 새로운 데이터베이스 파일을 생성하기 위해 다음 명령을 실행 후, SQL DDL로 테이블을 생성했다.

  1: DROP TABLE IF EXISTS SalesOrderDetail;
  2: DROP TABLE IF EXISTS SalesOrderHeader;
  3: DROP TABLE IF EXISTS Product;
  4: DROP TABLE IF EXISTS ProductModel;
  5: DROP TABLE IF EXISTS ProductCategory;
  6: DROP TABLE IF EXISTS CustomerAddress;
  7: DROP TABLE IF EXISTS Customers;
  8: DROP TABLE IF EXISTS Address;
  9: 
 10: CREATE TABLE Address
 11: (
 12:         AddressID                       INTEGER,
 13:         AddressLine1                    TEXT,
 14:         AddressLine2                    TEXT,
 15:         City                            TEXT,
 16:         StateProvince                   TEXT,
 17:         CountryRegion                   TEXT,
 18:         PostalCode                      TEXT,
 19:         PRIMARY KEY(AddressID ASC)
 20: );
 21: 
 22: CREATE TABLE CustomerAddress
 23: (
 24:         CustomerID                      INTEGER,
 25:         AddressID                       INTEGER,
 26:         AddressType                     TEXT,
 27:         PRIMARY KEY(CustomerID ASC, AddressID ASC)
 28: );
 29: 
 30: CREATE TABLE Customers
 31: (
 32:         CustomerID                      INTEGER,
 33:         Title                           TEXT,
 34:         FirstName                       TEXT,
 35:         MiddleName                      TEXT,
 36:         LastName                        TEXT,
 37:         Suffix                          TEXT,
 38:         CompanyName                     TEXT,
 39:         EmailAddress                    TEXT,
 40:         Phone                           TEXT,
 41:         SalesPerson                     TEXT,
 42:         PRIMARY KEY(CustomerID ASC)
 43: );
 44: 
 45: CREATE TABLE Product
 46: (
 47:         ProductID                       INTEGER,
 48:         Name                            TEXT,
 49:         ProductNumber                   TEXT,
 50:         Color                           TEXT,
 51:         StandardCost                    REAL,
 52:         ListPrice                       REAL,
 53:         Size                            TEXT,
 54:         Weight                          TEXT,
 55:         ProductCategoryID               INTEGER,
 56:         ProductModelID                  INTEGER,
 57:         PRIMARY KEY(ProductID ASC)
 58: );
 59: 
 60: CREATE TABLE ProductCategory
 61: (
 62:         ProductCategoryID               INTEGER,
 63:         ParentProductCategoryID         INTEGER,
 64:         Name                            TEXT,
 65:         PRIMARY KEY(ProductCategoryID ASC)
 66: );
 67: 
 68: CREATE TABLE ProductModel
 69: (
 70:         ProductModelID          INTEGER,
 71:         Name                    TEXT,
 72:         PRIMARY KEY(ProductModelID ASC)
 73: );
 74: 
 75: CREATE TABLE SalesOrderHeader
 76: (
 77:         SalesOrderID                    INTEGER,
 78:         RevisionNumber                  INTEGER,
 79:         OrderDate                       TEXT,
 80:         DueDate                         TEXT,
 81:         ShipDate                        TEXT,
 82:         Status                          INTEGER,
 83:         OnlineOrderFlag                 INTEGER,
 84:         SalesOrderNumber                TEXT,
 85:         PurchaseOrderNumber             TEXT,
 86:         AccountNumber                   TEXT,
 87:         CustomerID                      INTEGER,
 88:         ShipToAddressID                 INTEGER,
 89:         BillToAddressID                 INTEGER,
 90:         ShipMethod                      TEXT,
 91:         CreditCardApprovalCode          INTEGER,
 92:         SubTotal                        REAL,
 93:         TaxAmt                          REAL,
 94:         Freight                         REAL,
 95:         TotalDue                        REAL,
 96:         PRIMARY KEY(SalesOrderID ASC)
 97: );
 98: 
 99: CREATE TABLE SalesOrderDetail
100: (
101:         SalesOrderID                    INTEGER,
102:         SalesOrderDetailID              INTEGER,
103:         OrderQty                        INTEGER,
104:         ProductID                       INTEGER,
105:         UnitPrice                       REAL,
106:         UnitPriceDiscount               REAL,
107:         LineTotal                       REAL,
108:         PRIMARY KEY(SalesOrderDetailID ASC)
109: );

여기서는 테이블 간 관계성(relationship)을 설정하지 않았는데, 그 이유는 SQLite 엔진은 외래 키 사용이 기본적으로 막혀 있기 때문이다. 이를 PRAGMA foreign_keys = ON; 명령으로 옵션 변경을 할 수 있지만 기본 키만 설정했다. SQLite 엔진에서 외래 키 옵션을 확인하기 위해서는 PRAGMA foreign_keys; 라 입력하면 0(불가) / 1(가능)으로 설정 값이 나온다.

SQLite의 데이터 타입은 5가지(TEXT, INTEGER, REAL, BLOB, NONE)이며, 이에 관한 상세한 사항은 다음 웹 페이지 Datatypes In SQLite Version3 를 참고토록 한다.

생성한 테이블 다이어그램은 아래와 같다.

예제 데이터베이스 AdventureWorks 데이터는 아래 그림과 같이 ASCII 포맷으로 데이터 타입에 관한 원래 정보는 해당 파일에서 이미 소실된 상태이다.

각 값들과 SQLite 테이블의 필드 순서는 일치 시켰으므로 그 순서는 중요치 않지만 각 데이터 타입에 맞게 처리해야 할 필요가 있다.

그래서 각 테이블 마다 필드에 사상하는 데이터 타입을 기술한 scheme.meta 라는 이름의 ASCII 파일을 생성해 아래 내용을 저장했고 이를 데이터 이전 작업에서 쉐도우 데이터로 활용했다.

  1: Address;int,str,str,str,str,str,str
  2: CustomerAddress;int,int,str
  3: Customers;int,str,str,str,str,str,str,str,str,str
  4: Product;int,str,str,str,float,float,str,str,int,int
  5: ProductCategory;int,int,str
  6: ProductModel;int,str
  7: SalesOrderHeader;int,int,str,str,str,int,int,str,str,str,int,int,int,str,int,float,float,float,float
  8: SalesOrderDetail;int,int,int,int,float,float,float

세미콜론으로 구분되는 두 필드는 각각 테이블 명과 각 필드 데이터 타입에 사상하는 파이썬 데이터 타입 리스트이다. 파이썬에서는 이를 읽어, 키-값 쌍을 가지는 딕셔너리를 생성하여 메타 정보로 활용한다. 아래는 이 과정을 수행하는 코드 일부이며 전체 코드는 포스트 마지막에 표시한다.

fname은 해당 함수의 인자로 파일 경로이며, with 구문으로 파일을 열어 파이썬의 Context Manager에 그 처리를 이양했기 때문에 파일 닫기 작업은 불필요하다.

  1: with open(fname, "r") as fh:
  2:   for line in fh:
  3:       t, s = line.split(";")
  4:       q[t] = s.replace("\n", "")
  5:   return q

데이터 베이스에 여러 값을 입력하는데 여러 테크닉이 존재하는데 여기서는 여러 쿼리를 실행하는 방법을 선택했다. 이는 일반적으로 손쉽게 행하는 반복 구문을 이용해 한번에 하나의 레코드 세트를 프로그램에서 집어 넣는 것이 아니라 레코드 세트에 해당하는 복수의 투플(tuple)을 가진 리스트를 생성 후 이를 하나의 쿼리와 묶어 처리토록 하는 것이다.

예를 들어 ABC란 테이블에 5개 필드에 두 개의 데이터 열을 넣고자 하면 값 리스트는 rows = [(1, 2, 3, 4, 5), (6, 7, 8, 9, 10)]과 같이 생성한 후 아래 코드와 같이 실행하면 된다.

  1: cursor.executemany("INSERT INTO ABC VALUES(?, ?, ?, ?, ?)", rows)
  2: db.commit()

각 데이터 파일을 읽어 위 코드와 같이 테이블 별 데이터 세트로 만든 후, cursor.executemany(querySlot, dataSetList)로 호출하면 되는데 이를 먼저 보인 후 고려 사항에 대해 다룬다.

  1: for key in tablesScheme.keys():
  2:     if VERBOSE:
  3:         print("TABLE: %s" % key, end=", ")
  4:     rows = []
  5:     scheme = tablesScheme[key].split(",")
  6:     with open("AW" + key + ".txt", "r") as fh:
  7:         for data in fh:
  8:             value = data.replace("\n", "").split("\t")
  9:             rows.append(tuple(i for i in evalRow(scheme, value)))
 10:         cursor.executemany("INSERT INTO %s VALUES(%s)"
 11:             % (key, createSlot(scheme)), rows)
 12:         db.commit()
 13: 
 14:         if VERBOSE:
 15:             print("%d rows are effected." % cursor.rowcount)

1 행에서 tablesScheme는 scheme.meta 파일을 읽어 생성한 딕셔너리로 tablesScheme.keys()는 모든 등록된 키를 되돌려준다. 이 후 각 키(즉 테이블 이름)으로 그 값을 받아와 scheme 리스트로 할당한다.

ASCII 파일(AW[테이블명].txt)를 열어 데이터를 받아와 한 줄씩 처리한다. rows 리스트에 담는 것은 레코드 세트(데이터 파일의 개별 행)의 값을 가진 투플로 만들어야 하므로 9 행에서는 tuple() 내장 함수로 들어오는 값을 모아 투플로 생성 후 rows 리스트에 담았다(append).

여기서 문제는 텍스트 파일에서 읽어 들인 값은 모두 문자열로 취급되고 그 데이터 타입에 대한 정보가 없으므로 이를 데이터 쉐도우 파일 scheme.meta에 기입한 데로 데이터 타입을 인식토록 하는 것이다.이를 수행하는 evalRow() 함수를 작성했고 그 내용은 아래와 같다.

  1: for i in range(len(meta)):
  2:     if data[i] == "NULL": yield None
  3:     elif meta[i] == "str": yield data[i]
  4:     else:
  5:         yield eval(meta[i] + "(" + data[i] + ")")
  6:

1행은 첫 번째 파라메터 meta 인수로 받은 데이터 쉐도우의 필드 개수만큼 반복을 수행한다.

2행에서 value 인수로 받은 입력 할 데이터 값이 NULL로 표기 되어 있으면 파이썬의 None 타입 되돌린다.

3행에서 데이터 쉐도우의 필드 타입이 str이면 그 값 그대로 되돌린다.

4~5행에서 그 외 int나 float이면 이를 eval() 함수로 문자열 값을 evaluation 토록 했다. 아래 코드와 같이 4~5행을 작성해도 되나 직접적인 변환(casting) 보다는 파이썬이 직접 처리토록 하는 것을 선호하기 때문에 eval() 함수를 활용했다.

  1: elif meta[i] == "int": yield int(data[i])
  2: else: yield float(data[i])

반환 값은 return 구문 대신 yield로 생성자(generator) 함수로 만들었다. 이 때문에 각 값에 대한 판별이 완료될 때마다 값을 함수 호출 지점으로 반환하며 이로 인해 이전 코드 9 행과 같이 for 루프로 해당 함수에서 나오는 값을 하나씩 처리할 수 있다.

이전 코드 11행의 createSlot() 함수는 scheme 리스트에 담긴 원소 수 만큼 물음표(?)를 쉼표로 구분해 생성하는 함수로 그 코드는 아래와 같다. 생성한 결과를 리턴 시 문자열 맨 마지막의 두 개는 잉여의 쉼표와 공백이 하나 더 붙으므로 문자열[0:-2]로 문자열의 마지막 두 개는 제외토록 제한 했다.

  1: return ("?, " * len(scheme))[0:-2]

이에 관한 전체 코드는 다음과 같다. 96행 VERBOSE 변수는 1로 설정했는데, 0으로 설정할 경우 프로그램 수행 과정 상 아무런 출력을 하지 않는다. INSERT, UPDATE, DELETE 구문 수행 후 적용 받은 레코드 세트 수를 확인하려면 90 행과 같이 cursor.rowcount 속성 값을 확인하면 된다.

  1: #!/usr/bin/env python
  2: # -*- coding: utf-8 -*-
  3: #-------------------------------------------------------------------------------
  4: # Name:        adworksmigration
  5: # Purpose:     adventureworks sample data베이스에서
  6: #              text파일로 가져온 파일을 읽어
  7: #              sqlite database로 migration
  8: #
  9: # Author:      oscarpark
 10: #
 11: # Created:     16-11-2011
 12: # Copyright:   (c) oscarpark 2011
 13: # Licence:     licence free
 14: #-------------------------------------------------------------------------------
 15: 
 16: def createSlot(scheme):
 17:     """
 18:     주어진 리스트 원소 개수 만큼 '?, ' 를 생성하고 마지막 ', '는 제외 후 리턴
 19:     """
 20:     return ("?, " * len(scheme))[0:-2]
 21: 
 22: def evalRow(meta, data):
 23:     """
 24:     meta 리스트 내 나열된 타입에 맞춰
 25:     같은 index의 data 리스트 내 값을 캐스팅하여 리턴함.
 26:     """
 27:     if not meta or not data:
 28:         raise ValueError("meta리스트나 data리스트가 빈 리스트 입니다.")
 29: 
 30:     if len(meta) != len(data):
 31:         raise ValueError("meta리스트와 data리스트 크기가 같아야 합니다.")
 32:     try:
 33:         for i in range(len(meta)):
 34:             if data[i] == "NULL": yield None
 35:             elif meta[i] == "str": yield data[i]
 36:             else:
 37:                 yield eval(meta[i] + "(" + data[i] + ")")
 38:     except Exception as err:
 39:         raise (err)
 40: 
 41: def getScheme(fname):
 42:     """
 43:     테이블 명과 필드 타입이 들어 있는 파일을 읽어
 44:     키-값 쌍의 딕셔너리를 리턴함.
 45:     """
 46:     q = {}      # create an empty dictionary for returning
 47:     try:
 48:         # open file
 49:         with open(fname, "r") as fh:
 50:             for line in fh:
 51:                 t, s = line.split(";")
 52:                 q[t] = s.replace("\n", "")
 53:             return q
 54:     except IOError as ioerr:
 55:         raise (ioerr)
 56:     except Exception as err:
 57:         raise (err)
 58: 
 59: def patchData(VERBOSE):
 60:     import sqlite3
 61: 
 62:     tablesScheme = getScheme("scheme.meta")
 63: 
 64:     db = sqlite3.connect("AdventureWorks.sdb")
 65: 
 66:     cursor = db.cursor()
 67: 
 68:     for key in tablesScheme.keys():
 69:         if VERBOSE:
 70:             print("TABLE: %s" % key, end=", ")
 71:         rows = []
 72:         scheme = tablesScheme[key].split(",")
 73:         with open("AW" + key + ".txt", "r") as fh:
 74:             for data in fh:
 75:                 value = data.replace("\n", "").split("\t")
 76:                 rows.append(tuple(i for i in evalRow(scheme, value)))
 77:             """
 78:             NOTE: 위 for loop와 아래 cursor.excutemany / db.commit의
 79:                     indentation 주의
 80:             여러 쿼리를 실행해야 할 경우, executemany() 메소드로 가능하다.
 81:             쿼리 VALUES 절에서 이하에서 각 필드값에 물음표(?)로 대체하고,
 82:             두번째 파라메터에 해당 값에 대응하는 투플의 리스트를 준다.
 83:             단 물음표 개수는 반드시 투플의 원소 개수와 일치해야 한다.
 84:             """
 85:             cursor.executemany("INSERT INTO %s VALUES(%s)"
 86:                 % (key, createSlot(scheme)), rows)
 87:             db.commit()
 88: 
 89:             if VERBOSE:
 90:                 print("%d rows are effected." % cursor.rowcount)
 91: 
 92:     cursor.close()
 93:     db.close()
 94: 
 95: def main():
 96:     VERBOSE = 1
 97:     patchData(VERBOSE)
 98: 
 99: if __name__ == '__main__':
100:     main()
101:

위 모듈 adworksmigration.py를 직접 실행 시 데이터 이전 작업이 수행되며 그 결과는 아래와 같이 출력됐다. 위 코드의 patchData() 함수 내 데이터베이스 / 파일 이용 부분에는 별도의 예외 처리는 작성하지 않았다. 99행 조건절로 인해 이 모듈을 import 시에는 patchData() 함수가 바로 실행되지 않는다.

터틀 모듈로 만드는 Fractal

2011-09-28T15:39:00.001+09:00

이 포스트 내 코드는 Microsoft사 Small Basic Getting Started Guide의 Appendix A: Fun Samples에 게재된 Turtle Fractal을 python으로 포팅한 것이다.

터틀 그래픽 모듈에 관한 설명은 이전 포트스를 참조토록 한다.

pyscripter 혹은 python IDLE에서 아래와 같이 코드를 작성한다.

위 draw(x) 함수는

1. 파라메터 x 값(초기 값 60) 만큼 turtle 객체 인스턴스인 alex를 이동

2. theta(30도) 만큼 좌측으로 회전

3. distance를 이동 감쇠 상수 delta(기본 값 10) 만큼 감소 시킨 값을 파라메터로 재귀호출

[재귀 반복]

4. turtle 인스턴스를 우측으로 theta * 2만큼 회전

5. 3과 같은 파라메터 값을 주고 재귀호출

[재귀 반복]

6. turtle 인서턴스를 좌측으로 theta 만큼 회전

7. turtle 인스턴스를 x 값만큼 뒤로 이동

한다. 위 코드 실행 결과는 다음과 같다.

위 코드를 아래 같이 수정 후 실행 시, 결과는 그 아래 그림과 같다.

프랙탈과 관련해서 좀 더 알고 싶다면 아래 링크를 참조하거나 혹은 Wolfram Research 사의 Wolfram 아저씨 글이나 책을 찾아보면 좋다.

1. http://en.wikipedia.org/wiki/Fractal

Hello, little turtles!

2011-09-21T16:58:00.001+09:00

이 포스트에서 사용한 코드 중 별도 코멘트가 없는 것은 모두 아래 사이트 내 파이썬 코드를 이용 한 것임.

http://openbookproject.net/thinkcs/python/english3e/hello_little_turtles.html

거북이 한 마리 샀다네.

어항도 준비했다네.

그 이름 alex라 했다네.

alex는 50 units 가더니 좌를 보더군, 그리고 이네 30 units 가더군.

1967년 Papert 교수와 동료들이 MIT에서 설계한 프로그래밍 언어 Logo 개발 후, 이 언어를 활용해 프로그래밍 언어 습득, 인공지능 연구, 그림, 애니메이션, 음악, 게임, 시뮬레이션 등을 수행 할 수 있는 “컴퓨터 기반 마이크로 월드”로 turtle 이다. turtle은 여러 프로그래밍 언어에 이식되었고, 파이썬도 turtle 모듈을 포함하고 있다.

파이썬에서 터틀을 사용하기 위해선

1. turtle.py 모듈을 임포트 후

2. turtle이 놀 수 있는 공간 생성

3. turtle 인스턴스 생성

4. 명령 수행(전후좌우 이동 및 회전 등)

5. 2에서 생성한 공간 실행(화면에 나타내기)

과정을 수행한다.

위 코드 실행 결과는 아래와 같다.

위 터틀 실행 결과 화면에서 wn으로 명명한 canvas는 turtle이 거주 할 수 있는 공간이며, alex는 turtle의 인스턴스이다.

다음과 같이 canvas와 turtle을 꾸밀 수도 있다. 이용 가능한 색상은 다음 웹 사이트에서 확인 가능하다. (http://www.tcl.tk/man/tcl8.4/TkCmd/colors.htm)

canvas의 인스턴스 wn을 생성 후, 배경 색상과 타이틀(윈도우 실행 시 타이틀 바에 나타낼 내용.)을 하고, turtle 인스턴스인 tess 생성 후 tess의 색상과 크기를 지정 했다. 이 후 tess를 움직이고 나서 canvas를 보이도록 했다. 위 코드 실행 결과는 아래와 같다.

* 주의 : 첫 코드 실행 후, 실행 결과 화면을 닫은 후 위 코드를 수정토록 한다.

canvas에 하나 혹은 그 이상의 turtle 인스턴스를 생성 할 수 있다. 아래 코드는 turtle 클래스의 인스턴스로 tess와 alex를 생성 한 후 각각 움직이도록 했다.

tess는 좌로 120도씩 회전하며 삼각형을, alex는 좌로 90도씩 회전하며 사각형을 그린다. 실행 결과는 아래와 같다.

첫 코드에 다음과 같이 turtle의 인스턴스에 shape과 speed를 설정 후 실행 해보자. 실행 결과는 아래와 같이 화살표 대신 거북이 모양으로 나오며 움직임도 빠르다.

이제까지는 turtle이 움직일 때마다 직선으로 이동 경로가 그어졌는데, penup() 메소드 호출 후 움직이면 이동 경로가 그어지지 않는다. 다시 이동 경로를 그리려면 pendown() 메소드를 호출하면 된다. 또 stamp() 메소드를 호출 하면, turtle이 위치한 곳에 흔적(도장)을 남기게 된다. 아래 코드를 보자.

이 코드는 30회 루프(range(30) 함수는 0부터 29까지 정수를 생성한다.) 시행하며 tess.stamp() 메소드 호출로 발 도장을 찍고, 이동 거리를 3 증가 후, 앞으로 이동 거리 만큼 이동 시키고 우측으로 24도 만큼 회전한다. 이 코드 실행 결과는 아래와 같다.

위 30회 반복 시행 코드를 100회 시행으로 수정 후 random을 적용하여 확률적으로 자국을 남기도록 수정했다. randint(1, 3) 함수를 통해 1, 2, 3 중에 하나가 임의로 생성되고 생성된 수를 2로 나눈 후 몫을 구해 짝수인 경우(즉, 2인 경우)에만 stamp() 메소드를 시행토록 했다. 아래는 수정한 코드와 그 실행한 결과이다.

위 코드와 같이 몇 가지 규칙(stamp를 찍을 지 여부를 확률적으로 판별하거나, 혹은 이동 경로를 설정하는 함수를 만들거나 - sine 파를 따라 움직이는 alex라던지)을 적용하고 turtle의 움직임을 통해 손쉽게 데이터 시각화를 수행할 수 있다. 물론 교육학적으로 봤을 때도, console에 열심히 Hello World를 출력하는 것보다 흥미 유발에 있어 더욱 효과적이지만.

다음 웹 사이트를 읽고, 또 다음 키워드에 대해 조사하면 재미있는 것을 많이 얻을 수 있다.

http://openbookproject.net/thinkcs/python/english3e/hello_little_turtles.html

키워드: Scratch, Logo, Scheme, Fractal, Genetic Algorithm, Game theory…

중복하지 않는 난수 발생 기법 Part 3-Shuffling

2011-06-07T13:41:00.001+09:00

이전 포스팅에선 C#과 파이썬에서 random 클래스 사용과 고려해야 할 점에 대해 살펴봤다. 이번에는 셔플링(shuffling; 카드섞기) 기법에 대해 다루도록 한다.

Contents
1. Array in C# and List in Python
2. random in C# and Python
3. Shuffling
4. Shuffling in Python
5. Lottery

3. Shuffling

셔플링 혹은 카드섞기 기법은 다음과 같은 절차를 거친다.

1) 뽑기 원하는 항목으로 채운 배열 혹은 리스트를 준비한다.

2) 배열 또는 리스트 인덱스 범위에 드는 두 난수를 얻는다.

3) 두 인덱스에 해당하는 요소를 교환한다.

4) 위 2), 3) 과정을 지정된 회수만큼 반복한다.

위 과정을 그림으로 설명하겠다. 1에서 6까지 6장의 카드가 있고, 흰색과 검은색 주사위가 아래 그림과 같이 있다고 하자. 흰색과 검은색 두 주사위를 각각 굴려 나온 숫자 위치에 있는 카드를 서로 교환한다. (물론 두 주사위를 굴리는 것은 독립실행이다.)

두 주사위를 굴렸더니 각각 3과 1이 나왔다. 그래서 첫 번째 위치에 있는 카드와 세 번째 위치에 있는 카드를 뽑아 자리를 교체했다.

다시 두 주사위를 굴렸더니 이번에는 각각 4와 2가 나왔다. 앞에서 시행한 바와 같이 두 카드 자리를 교체했다.

마지막으로 두 주사위를 굴렸더니 이번에는 두 주사위 모두 1이 나왔다. 첫 번째 카드를 뽑았다 다시 넣었다. (혹은 첫 번째 자리에 카드를 첫 번째 카드 자리와 교체 했다.)

위 과정을 시행 후 3장의 카드를 맨 위에서 차례로 꺼내면, 원래 1, 2, 3이었던 카드가 3, 4, 1 (혹은 정렬을 시행하면 1, 3, 4) 가 된다. 이를 카드 섞기 기법이라 한다.

C# 코드로 이를 작성하자면 우선 1부터 45까지 든 배열과 난수 발생을 위한 Random 클래스의 인스턴스가 필요로 하다.

아래 그림과 같이 private scope을 가지도록 int 형 배열과 Random 클래스 인스턴스를 선언했다.

난수 발생 메소드는 배열 인덱스에 맞춰, 0에서 44 범위에서 int 형 난수 하나를 얻도록 했고(Random 클래스의 Next(min, max) 메소드로 얻는 난수 N은 min ≤ N < max 범위를 가지는 임의의 정수이다.) 배열 요소간 교환(swap) 메소드는 다음과 같이 작성했다. (이 포스팅에서 작성한 C# 코드는 Console App. 이므로 private scope 변수 및 메소드를 static으로 선언했다.)

이후 프로그램 시작 지점 void Main(string[] args)에서 루프를 시행 후 인덱스 0에서 5까지 6개 숫자를 추출하면 된다. 여기서는 보너스 번호가 6번째 숫자임을 감안하고 첫 5개 숫자를 정렬해 결과를 보여주도록 했다.

실행 결과는 다음과 같다.

파이썬에서는 random 클래스에서 제공하는 메소드만으로 위와 같은 카드 섞기 기법을 이용할 수 있지만 이 포스팅에선 우선 위 C# 코드와 같은 방식으로 코드를 작성하겠다.

random 클래스를 불러오고, 1부터 45까지 연속된 정수를 포함한 리스트를 하나 생성 했다.

난수 발생 메소드(rollDice)와 배열 요소 교환 메소드(swapDeck)은 아래와 같이 작성했다. 파이썬의 경우 기존 프로그래밍 언어와 달리 메소드 결과를 1개 이상 복수로 리턴 할 수 있다. rollDice() 메소드에서 return 구문 다음에 두 개 리턴 값을 돌려주며 이를 받기 위해선 a, b = rollDice() 형태로 받아주면 된다.

100회 루프를 시행 후 얻은 결과를 얻는 코드를 아래에 나타내었다. 파이썬의 리스트에서 list[:6] 으로 콜론 후 숫자는 리턴 할 인자 개수를 의미한다. 예를 들어 인덱스 1에서 시작해서 10개 값을 얻고자 하면 list[1:10] 이라하면 인덱스 1부터 10까지 10개 값을 리턴한다.

아래 코드에서 result = lottoDeck[:5]는 lottoDeck 리스트의 인덱스 0부터 시작하는 5개 요소 값을 result에 할당 하란 뜻이다. 이를 list.sort() 메소드를 통해 소팅 후 result 리스트와 lottoDeck[5] 값을 쉘에서 나타내도록 했다.(파이썬 쉘에서는 변수 명을 기입하면 값이 표시된다.)

혹은 result.append(lottoDeck[5]) 를 해서 result 리스트에 lottoDeck[5] 값을 추가 할 수도 있다.

다음 포스트에선 카드 섞기 기법을 파이썬 random 클래스가 제공하는 메소드로 더 쉽게 접근토록 한다.

중복하지 않는 난수 발생 기법 Part 2-random in C# and Python

2011-06-02T03:23:00.001+09:00

이전 포스팅에선 C#과 Python에서 데이터 그룹을 이용하기 위해 배열(Array)와 리스트(List)를 사용하는 방법에 대해 살펴봤다. 이번 포스팅에선 난수 발생을 위한 random 사용과 고려해야 할 점을 다루도록 한다.

Contents
1. Array in C# and List in Python
2. random in C# and Python
3. Shuffling
4. Shuffling in Python
5. Lottery

2. random in C# and Python

C#은 난수 발생기로 Random 클래스를 제공한다. 네임스페이스 System에 속한 클래스이므로 별도의 네임스페이스 선언을 하지 않아도 된다.

2005년 10월 19일자에 네이버 블로그에 포스팅했던 C#에서의 Shuffling 기법에서 Random 클래스 사용시 발생한 문제와 그 해결을 자세히 다루었기 때문에 결론만 말하자면 “프로그램 내에서 Random 클래스의 인스턴스는 단 한번만 생성하고 이를 계속 사용토록 하라”는 것이다.

0부터 100사이 난수를 발생하는 코드 작성을 아래 두 가지 방법으로 비교해보자.

Case 1 : 메소드 호출을 통한 경우 – 인스턴스 반복 생성

위 코드에선 randomPick() 메소드 호출 시마다 Random 클래스의 새로운 인스턴스가 생성된다.

코드 실행 결과를 보면 다음과 유사하게 된다.

Case 2 : 인스턴스를 한번 생성 후 반복 호출을 통한 경우

위 코드는 Random 클래스 인스턴스를 한번 생성 후 해당 인스턴스를 통해 난수를 반복해서 얻는다.

코드 실행 결과를 보면 다음과 유사하게 된다.

두 실행 결과간 차이를 알아보기 힘들다면 아래와 같은 코드와 그 실행 결과를 살펴보자. 아래 코드는 두 방법으로 각각 생성한 난수를 제너릭(generic) 리스트 클래스의 인스턴스에 넣은 후 생성된 난수의 개수를 구하여 콘솔에 출력하는 것이다. 생성된 난수 개수를 구하는 것은 Linq를 이용하였다. private 영역에서 생성한 Random 클래스의 인스턴스(rand1)의 경우는 seed를 제외했는데 seed를 주더라도 유사한 결과를 얻게 된다. 매번 새롭게 인스턴스가 생성되는 rand2 경우 seed를 제외하면 매우 나쁜 결과를 얻게 된다.

위 코드를 실행하면, 생성된 난수 목록을 세미콜론(;)으로 구분하여 보여준 후, 난수 개수를 내림차순으로 보여준다.

이런 현상이 발생하는 원인은 명확하다. 메소드 호출로 Random 클래스 인스턴스 생성 시 할당하는 seed가 나쁘기 때문이다. Random 클래스를 이용 시, 많은 이들이 seed로 ticks를 습관적으로 사용하는데, patch time이 짧은 상태에서 사용하는 것 자체가 문제를 일으킨다. 아래 코드로 이를 확인해보자.

위 코드는 10회 동안 ticks를 호출하여, 원래 리턴 타입인 long 타입 값과 이를 int 타입으로 변환(casting) 한 값을 콘솔로 출력하는 것이다.

즉 메소드 호출 patch 타임이 ticks 값 변화를 선행하기 때문에 발생하는 문제라 할 수 있다. 이를 해결 하는 방법으로 다음과 같이 코드를 수정 할 수 있다. 다만 이렇게 인스턴스를 반복해서 생성하는 것 보다는 인스턴스를 한번 생성 후 난수를 반복해서 생성하는 것이 여러모로 좋다.

C#의 Random 클래스에서 Next() 메소드는 int 타입의 정수를 리턴 한다. Next() 메소드는 Next(), Next(int maxValue), Next(int minValue, int maxValue) 3개 메소드가 오버로딩 되어 있으며, 주의 할 점은 minValue는 포함이나, maxValue는 제외, 즉 Next(n) 일 경우엔 0 ≤ x < n 이고, Next(m, n) 일 경우엔 m ≤ x < n 의 결과를 얻는다. 0과 0.1 사이 double 타입 실수 값을 얻고자 한다면 NextDouble() 메소드를 사용한다.

파이썬에서 random을 이용하기 위해선 random 모듈 불러오기(import)를 먼저 해야 한다. 난수 발생 함수는 C#에서와 마찬가지로 정수형 데이터나 실수형 데이터를 되돌려 주는데 그 종류는 C#에 비해 매우 다양하다. 예를 들어, 정규분포에서 난수 값을 돌려주는 random.normalvariate(mu, sigma)나 가우스 분포에서 되돌려주는 random.gauss(mu, sigma) 지수 분포나 베타 분포 등도 구비되어 있다. 여기서는 기본 함수 중 0과 1 사이 실수 형 난수를 되돌려주는 random.random(), 지정된 값 사이(최대 값 포함) random.uniform(a, b), 연속하는 정수 범위 중 난수를 되돌려주는(최대 값 포함하는) random.randint(a, b)과 일정한 증가 값을 가지는 정수 범위 중 난수를 되돌려주는(최대 값 제외) random.randrange([start], stop, [, step])만 살펴보겠다. 참고로 파이썬 또한 random 모듈 호출 시 seed 값을 주지 않으면 시스템 시간을 seed로 이용한다.

아래 코드는 random.random() 함수를 이용해 50회 반복 시행한 것이다. print() 문의 종료는 기본 값인 줄 바꿈 대신 세미 콜론(;)으로 대신하였다.

발생 한 난수 개수를 얻기 위해 itertool 모듈을 함께 불러와서 리스트 클래스의 빈 인스턴스를 하나 생성 후 리스트에 50개 난수를 넣고 그 개수를 계산했다. 첫 번째 개수 구하는 코드는 [생성된 값, 개수] 리스트로 생성했고, 두 번째 코드는 개수만 다시 리턴토록 했다. itertools.groupby(sorted(li))로 인해 발생 한 난수는 내림차순으로 정렬 된 상태로 출력된다.

다음 코드는 지정된 정수 범위 내 실수형 난수를 발생하는 random.uniform(a, b)로 주의 할 점은 발생하는 실수형 난수 N은 a ≤ N ≤ b 라는 점이다. 단, python documentation(v2.7.1 기준)에 따르면 b 값은 생성 될 수도 있고 아닐 수도 있는데 이는 a + (b – a) * random() 계산 후 소수부의 정수화(rounding) 결과에 따라 달라진다는 점을 주의해야 한다.

지정된 범위 내 정수형 난수를 생성하는 random.randint(a, b)의 경우도 정수형 난수 N은 a ≤ N ≤ b 사이에서 발생한다.

마지막으로 random.randrange([start], stop [, step])으로 발생하는 정수형 난수 N은 stop 에 지정한 값보다 작다. start 생략 시엔 0으로 고정된다. 또한 아래 코드에 생성된 난수 목록에 보이다 싶이, start와 stop 사이 연속하는 값이 아닌 stop 보다 작은 step 배수 값 중에 난수가 발생한다.

이번 포스트에선 C#과 python에서 random을 통해 난수 생성에 대해 살펴봤다. 다음 포스트에선 카드 섞기 혹은 셔플링(shuffling)이라 불리는 기법을 다루도록 한다.

중복하지 않는 난수 발생 기법 Part 1–Array in C# and List in Python

2011-06-01T15:38:00.001+09:00

네이버 등을 검색해보면 로또 번호 생성기 소스가 많이 돌아다닌다. 랜덤을 이용해 번호 6개를 생성하는데 너나 할 것 없이 난수 발생 후 앞서 추출한 난수 목록에서 중복하는지 여부를 살펴보고 있으면 무시하고 없으면 추가하는 형태로 프로그램을 작성한다.

이를 보고 있으면 마치, “1부터 n까지 연속하는 자연수의 합을 구하라” 혹은 “m부터 n까지 연속하는 자연수의 합을 구하라”라고 물으면 어김없이 for (int i = 1; i < n + 1; i++) { result += i; } 라는 식으로 프로그램을 작성하는 것과 같은 난감함을 느낀다. 또는 DB 시퀄 쿼리 작성 시, 레코드 마다 어떤 작업을 처리해야 할 때 아무 생각 없이 cursor를 휘갈겨 쓰는 것과도 같다. (http://oscarsjpark.blogspot.com/2011/05/sql-query.html)

앞으로 총 5개 포스트를 통해 C#과 Python으로 로또 번호 추출 프로그램을 다룰 것이다. 이와 같은 중복하지 않는 난수 발생 기법은 보드 게임(화투, 포커 등) 또는 통계 처리를 위한 표본 선정 등에 동일하게 적용 할 수 있다.

Contents
1. Array in C# and List in Python
2. random in C# and Python
3. Shuffling
4. Shuffling in Python
5. Lottery

1. Array in C# and List

C#에서 배열 선언은 기존 C계열 언어에서와 그 용법은 동일하거나 유사하다. 로또의 경우 1부터 45까지 연속된 자연수 모음이므로 다음과 같이 선언할 수 있다.

// C#

static int[] lottoDeck = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                                  16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
                                  28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
                                  40, 41, 42, 43, 44, 45};

static 키워드로 할당 했을 때와 하지 않았을 때 차이를 메모리 내 heap과 stack을 언급하며 설명 하는 것은 너무 멀리 나가니 이에 대해 궁금하다면 Effective C# 등과 같은 서적을 참고하면 된다.

파이썬 기본 데이터 타입은 Number, String 그리고 List만 제공한다. (물론 List를 prototype으로 삼아 Hash를 제공하고 있다. 또 indexing 되지 않는 set도 제공한다.) 파이썬의 List 용법은 LISP에서와 같으며, C# 또는 자바에선 ArrayList, List<> (generic) 등과 같다.

# Python

lottoDeck = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
                   16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
                   28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
                   40, 41, 42, 43, 44, 45]

Python에는 range 함수가 있어 아래와 같은 코드도 가능하다.

# Python

lottoDeck = range(1, 46)

IDLE 인터프리터에서 range를 이용한 것을 아래 그림에서 볼 수 있다. 단 range(min, max) 함수 호출 시, min 파라메터는 포함관계이고, max 파라메터는 제외관계이다.

흥미로운 것은 실제 모든 값을 나열하여 리스트를 생성한 것과 range로 만들었을 때 아래 그림과 같이 차이가 나는데 이는 python이 생성한 list 객체가 실제 데이터를 가질 수도 있지만 생성 규칙(production rule)을 가질 수도 있기 때문이다. 이는 근래 각광받는 언어학자인 Steve Pinker가 그의 저서 단어와 규칙에서 밝힌 바와 같이 인간의 마음 사전과 동일하다. 즉 영어에서 boy 가 boys 가 되고, work 가 worked 가 되는 것과 같은 규칙에 의해 변하는 단어는 암기 하지 않는다. 하지만 child 가 children 으로, calclus 가 calculi 로, run 이 ran 과 같이 불규칙하게 변하는 단어만 마음 사전에 담아두면 된다. (불규칙 단어는 약 120 ~ 170 여 개가 된다고 한다. 사실 이들 불규칙 단어도 핑커의 연구 결과에 따르면 음성학적인 규칙을 따르지만…)

값 할당으로 만든 리스트와 달리 생성 규칙에 의해 만들어진 리스트는 값 요청 시에 해당 값을 되돌려 주게 되므로 리스트 내 요소(element) 값을 변경 할 수 없다.

Python에서 리스트 내 요소간 교환(swap)을 하고자 한다면 값 할당을 통해 리스트를 생성해야만 한다.

다음 포스트에선 난수 생성을 위한 random을 활용하는 방법에 대해 살펴보도록 한다.

SQL Query–커서 대체하기

2011-05-31T13:48:00.001+09:00

본 글은 2006년 12월 12일 본인의 네이버 블로그 (http://blog.naver.com/ezmis)에 포스팅 한 글을 본 블로그로 가져와 일부 수정한 것임을 밝힌다. 원문 주소는 다음과 같다.

http://blog.naver.com/ezmis/130012110941

레코드를 한 행씩 처리하는 방법으로 커서를 사용하는 경우가 많다.그러나 커서를 이용할 경우 다량의 데이터 처리에 문제가 있다.

가령 데이터 수가 일정 이하 일 때, 초당 100건씩 처리했다고 해서 1만 건을 처리하는데 10초가 걸리는 것이 아니다.

커서의 실행 예상 시간은 아래 그래프와 같다 할 수 있다.

커서 사용은 손쉬운 선택이나 동시에 고통(?)의 길로 밀어 넣는 작업이기도 하다.

아래는 Microsoft에서 제공한 MS SQL Server 2000 개발자를 위한 튜닝 가이드에서 발췌한 내용이다.

"커서는 내부적으로 임시 테이블을 사용하기 때문에 임시 테이블을 쓴다고 부하가 더 발생하진 않습니다. 오히려 커서의 부가적 기능 때문에 서버 자원을 더 낭비하게 됩니다. (커서로 할 수 있는 건, 임시 테이블이나 테이블 변수로도 모두 처리가 가능합니다.)"

(임시 테이블과 테이블 변수 간의 수행 속도에 관해 논란의 여지가 있다. 2003년도 12월자 Windows & .NET Magazine에 의하면, 데이터의 수가 커질 수록 임시 테이블의 수행 속도가 테이블 변수 보다 더 빨라진다고 한다. 이는 기존의 MS사의 입장과는 상반된 것이다.)

위 가이드에 따라서 실제 업무에서 커서 대신 테이블 변수를 이용한 배치 작업의 예이다.

-- ORACLE로부터 직위 정보를 읽어들여 local server의 직위 정보에 반영한다.

-- ACTION_TYPE 필드 플래그가 R이면 등록, M이면 수정, D이면 삭제

SET NOCOUNT ON

DECLARE @tmpPosition TABLE
(
     nid int identity(1, 1) not null,
     idx int,
     csName varchar(50),
     idx_ClassSystem int,
     iSeq int,
     iState int,
     act_type varchar(1)
)

-- 커서문에서 for select 에 해당

INSERT INTO @tmpPosition(idx, csName, idx_ClassSystem, iSeq, iState, act_type)
(
          SELECT
                    CAST(POSITION_ID AS INT),
                    RTRIM(SUBSTRING(POSITION_NAME, 1, 50)),
                    (SELECT idx FROM mc_ClassSystem
                              WHERE idx_Uplevel = 0),
                    CAST(POSITION_ORDER AS INT),
                    1, ACTION_TYPE
          FROM OPENQUERY
          (ORA10G,
          'SELECT
                    POSITION_ID, POSITION_NAME, POSITION_ORDER,
                    ACTION_TYPE
          FROM
                    ORGDBADM.TKMID_POSITIONINFORMATION
          WHERE IS_CHECK_CON = ''N''
          ORDER BY MODIFY_DATE ASC'
     )
)

DECLARE @i int, @maxno int, @idx int, @csName varchar(50),
@idx_ClassSystem int, @iSeq int, @iState int, @act varchar(1)

-- fetch into에 해당

SELECT @i = 1, @maxno = max(nid) FROM @tmpPosition

WHILE @i <= @maxno
BEGIN
          SELECT @idx = idx, @csName = csName,
                    @idx_ClassSystem = idx_ClassSystem, @iSeq = iSeq,
                    @iState = iState, @act = act_type
          FROM
                    @tmpPosition
          WHERE
                    nid = @i

          IF @act = 'R'
          BEGIN
                    SET IDENTITY_INSERT mc_ClassPosition ON

                    INSERT INTO mc_ClassPosition(idx, csName,
                              idx_ClassSystem, iSeq, iState)
                    VALUES(@idx, @csName,
                              @idx_ClassSystem, @iSeq, @iState)

                    SET IDENTITY_INSERT mc_ClassPosition OFF
          END
          ELSE IF @act = 'M'
          BEGIN
                    UPDATE mc_ClassPosition
                    SET csName = @csName,
                         idx_ClassSystem = @idx_ClassSystem,
                         iSeq = @iSeq,
                         iState = @iState
                    WHERE
                         idx = @idx
          END
          ELSE IF @act = 'D'
          BEGIN
                    DELETE mc_ClassPosition WHERE idx = @idx
          END

          SET @i = @i + 1
END

-- 기타 후 처리

Microsoft 사에서 나온 MS-SQL Server와 관련된 참고 자료들을 보면 하드디스크 I/O가 일어나는 임시 테이블보다는 테이블 변수가 메모리 상에서 형성되고 처리되기 때문에 더욱 높은 성능을 가질 수 있다라고 명시가 되어있다.

그리고 위 언급한 MS SQL Server 2000 개발자를 위한 튜닝 가이드에서도 아래와 같이 언급하고 있다.

"결론부터 말씀 드리자면, 커서보다는 임시 테이블이 임시 테이블보다는 테이블 변수를 사용하는 것이 성능에 보탬이 됩니다."

그런데 2003년도 12월자 Windows & .NET Magazine에 의하면 테이블 변수 또한 하드디스크 I/O가 일어나는데다가 SQL 서버 엔진 내에서 병렬처리 쿼리 계획을 생성하지 못 한다는, SQL 서버 개발팀의 고위 관계자의 발언이 인용되어있다.

현재 이 부분에 대해서는 MS사로부터 어떠한 공식적인 입장표명이 없다. (거기다가 이미 MS사는 MS SQL 2005 서버로 넘어가버렸다...)

SQL 서버 테이블 변수는 가급적 소규모 쿼리나 데이터 집합을 위한 용도로 사용하고, 대용량 데이터 집합의 처리는 임시 테이블을 사용하는 것이 바람직하다고 SQL 서버 개발팀에서 권고한다고 하니 각자의 판단에 맞겨야 하겠다.

MS SQL Server 2000 개발자를 위한 튜닝 가이드는 MSDN이나 아래 사이트에서 그 내용을 확인 할 수 있다.

http://www.dbguide.net/tuning_guide/tuning_guide_11.jsp

Mac에서 Eclipse와 PyDev 설정하기

2011-05-25T15:20:00.001+09:00

본인이 소유한 맥은 구형 맥 미니 G4 PPC 모델로 현재 Mac OS X 10.4 Tiger로 구동되며 간단한 사양은 아래와 같다.

OS X 10.5 레퍼드로 갈아타고 싶지만(10.6 스노 레퍼드는 이 사양으로는 감히 덤비지도 못할…) Apple #에서도 이미 판매 중단된 지 오래고, 중고 retail CD로 구하기도 너무 힘들어 일단 반포기 상태. IPad야 Win7 PC에 설치한 ITunes 이용하기 때문에 큰 문제는 없지만 Tiger에 eclipse 설치부터 머리가 지끈 지끈. Good job Apple™

Eclipse 다운로드

현재 Eclipse 최종 버전은 3.6 코드네임 Helios이며 곧 Indigo가 출시 예정이다. OS X 10.4 Tiger에서 구동 가능한 버전은 Eclipse 3.4 Ganymede 가 마지막 버전이다. 다음 웹 사이트를 방문하여 Ganymede를 다운 받는다.

http://eclipse.org/downloads/packages/release/ganymede/sr2

미러 사이트가 제공되지 않아 다운로드 완료까지 오랜 시간이 걸렸다.

Python 다운로드

Mac OS X 10.4 Tiger에는 Python 2.3 버전이 아래 그림과 같이 기본 탑재되어 있지만 Python 2.x 최종 버전은 Python 2.7.1 이고 또한 Python2와 Python3은 근본적으로 변화가 크기 때문에 Python3의 최종 버전인 Python3.2를 다운 받았다.

Python 3.2 다운로드는 아래 사이트에서 Python 3.2 Mac OS X 32-bit i386/PPC Installer (for Mac OS X 10.3 through 10.6)으로 dmg 파일을 내려 받았다.

http://python.org/download/

Python 설치

다운로드 완료한 python-3.2-macosx10.3.dmg 파일을 마운트 시 ‘마운트 실패’ 류의 메시지가 떴는데 구글링해보니 Mac OS X 10.3.1 업그레이드 이후 이런 현상이 나타난다는 말이 많았다. 이 문제 해결은 아래와 같이 처리 후 Python을 설치했다.

디스크 마운트 문제 해결

1. 응용프로그램 > 유틸리티 > 디스크 > 디스크 유틸리티 실행
2. 디스크 권한 복구 버튼 클릭
3. Finder에서 시스템/라이브러리/Extensions.kextcache 파일 삭제
4. Finder에서 시스템/라이브러리/Caches/com.apple.kernalcaches 폴더 삭제
5. 시스템 재시작

Eclipse 설치

다운로드 완료한 파일 eclipse-java-ganymede-SR2-macosx-carbon.tar.gz의 압축을 푼 후 디스크 루트로 복사했다. (유닉스 베이스 엄밀히 말하자면, NeXT Step의 Mach와 FreeBSD 베이스 OS이기에 적당한 슬라이스에 배치해야 겠지만… 그냥 귀찮…)

PyDev 설치

Eclipse에서 plug-in 설치는 Ganymede 기준으로 Help > Software Updates… 를 통해 하면 되지만, 소프트웨어 URL에 http://pydev.org/updates로 입력 후 내려 받기는 되어도 설치가 제대로 되질 않았다. 그래서 우선 아래 사이트에서 PyDev 2.0 플러긴 파일인 org.python.pydev.feature-2.0.0.2011040403.zip 을 내려 받았다.

http://sourceforge.net/projects/pydev/files/

압축을 푼 후, plugins 폴더와 features 폴더 각각의 파일을 eclipse 폴더 내 plugins 폴더와 features 폴더에 복사 해 넣었다.

Eclipse 설정

새로 eclipse를 시작 후, Eclipse > Preferences 메뉴로 들어가서 Pydev > Interpreter – Python 메뉴에 들어가면 Python 인터프리터와 패스 등이 비어있다. New… 버튼을 누른 후 “Select Interpreter” 창이 뜨면 Browse… 버튼을 눌러 설치한 Python 3.2 패스를 찾아 들어가면 된다. 해당 패스는 /Library/Frameworks/Python.framework/Versions/3.2/Resources/Python.app/Contents/MacOS/ 폴더 내 Python을 지정하면 된다.

위와 같이 성공적으로 인터프리터 패스를 지정하면 라이브러리 패스는 자동으로 인식된다.