Script Programming(스크립트 프로그래밍)

정의 (소수와 합성수)
    1보다 큰 양의 정수 n에 대하여
    (i) n = a * b 를 만족하고 1보다 큰 두 양의 정수 a와 b가 존재하면,
        n을 합성수(合成數, composite number)라고 한다. 참고로 이 경우,
        a, b 중에 적어도 하나는 sqrt(n) 보다 작거나 같다.
        합성수의 예로는 4, 6, 9, 24, 143 등이 있다.
    (ii) n = a * b 를 만족하고 1보다 큰 두 양의 정수 a와 b가 존재하지 않으면,
         즉 n을 두 양의 정수의 곱으로 표현하는 방법이 1*n과 n*1 두 가지 뿐이면,
         n을 소수(素數, prime number)라고 한다.  소수의 예로는 2, 3, 5, 7, 11 등이 있다.
         n이 소수인지 아닌지 확인하려면, 
         n을 2 보다 크거나 같고 sqrt(n) 보다 작거나 같은 모든 정수로 나누어 본다.
         이 경우 언제나 나누어 떨어지지  않으면 n은 소수이고, 그렇지 않으면 n은 합성수이다.
    

우선 다음의 Python 소스 코드는 명령행 인자로 전달 받은 양의 정수 n을
2 및 3, 5, 7, ... , sqrt(n) 이하의 홀수들로 나누어 보아 n이 합성수인지 아닌지
확인하는 애플리케이션 소스이다. 확인하는데 걸린 경과 시간도 알려준다.

이제 다음은 정수의 인수분해 능력이 뛰어난  Pollard의 rho 방법(일명 거북이와 토끼 알고리즘, tortoise-hair algorithm)을 구현한  Python 소스 코드이다. 이 알고리즘은 소수에 대해서는 시간이 많이 걸리지만, 합성수에 대해서는 시간이 매우 적게 걸린다는 것이 특징이다.

 

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

초등학교 때 배우는 두 정수의 곱셈표를 만들어 주는 Python 소스이다.
(이 소스는 Jython이나 IronPython에서도 수정없이 그대로 실행된다.)

이항 연산자 // 는 Python의 정수나눗셈 연산자이다.

실행> python makeMultTable.py 230 5100
결과>

         230
   x )   5100
     ------
         23
       115
     ------
       1173000

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

다음은 초등학교에서 배우는 나눗셈 계산표를 만들어주는 Python 소스 코드이다.
나눗셈 계산표를 완성하고 나서 약수, 배수 관계를 알려준다.

아래의 소스는 Jython에서는 수정없이 그대로 실행되지만,
IronPython에서는 인코딩 선언 부분을

        # -*- encoding: ms949 -*-

대신

        # -*- encoding: cp949 -*-
        # -*- encoding: CP949 -*-
        # -*- encoding: euc-kr -*-
        # -*- encoding: EUC-KR -*-

중 하나로 수정해야 실행된다.

1. # -*- encoding: ms949 -*-
3. #  Filename: makeDivisionTable.py
4. #
5. #  Purpose:  Make a division table in a handy written form.
6. #
7. #  Execute: python makeDivisionTable.py 12345 32
8. #           python makeDivisionTable.py 500210 61
9. #
10. #     Date:  2008/05/15
11. #   Author:  PH Kim   [ pkim ((AT)) scripts.pe.kr ]
13. import sys
15. def printUsage():
16.     # print("Using: python makeDivisionTable.py [numerator] [denominator]")
17.     # print("Make a division table in a handy written form.")
18.     print("사용법: python makeDivisionTable.py [피제수] [제수]")
19.     print("손으로 작성한 형태의 나눗셈 표를 만들어준다.")
21. def simplify(v, width):
22.     t = "%ld" % v
23.     if t[-2:] == ".0":
24.         t = t[0:len(t) - 2]
25.     slen = len(t)
26.     if slen < width:
27.         t = " " * (width - slen) + t
28.     return t
30. def getSuffix(v):
31.     t = v % 10L
32.     suffix = "은"
33.     if "2459".find("%d" % t) >= 0:
34.         suffix = "는"
35.     return suffix
37. def makeTable(numer, denom, quotient):
38.     strNumer = "%ld" % numer
39.     strDenom = "%ld" % denom
40.     strQuotient = "%ld" % quotient
41.     lenN = len(strNumer)
42.     lenD = len(strDenom)
43.     lenQ = len(strQuotient)
44.     offsetLeft = 3 + lenD + 3
45.     spaces = "                                                                                 "
46.     uline  = "_" * (lenN + 2)
47.     sline  = "-" * lenN
48.     bias = lenN - lenQ
49.     print(spaces[0:offsetLeft] + spaces[0:bias] + "%ld" % quotient)
50.     print(spaces[0:offsetLeft - 2] + uline)
51.     sys.stdout.write("   " + strDenom + " ) " + strNumer)
53.     strTmpR = strNumer[0: bias + 1]
54.     tmpR = long(strTmpR)
55.     tmpSub = 0L
56.     oneDigit = None
58.     for i in range(0, lenQ):
59.         if strQuotient[i: i + 1] == "0":
60.             if i + 1 < lenQ:
61.                 oneDigit = strNumer[bias + i + 1: bias + i + 2]
62.                 sys.stdout.write(oneDigit)
63.                 strTmpR = strTmpR + oneDigit
64.                 tmpR = long(strTmpR)
65.         else:
66.             print
67.             tmpSub = long(strQuotient[i: i + 1]) * denom
68.             print(spaces[0: offsetLeft] + simplify(tmpSub, bias + i + 1))
69.             print(spaces[0: offsetLeft] + sline)
70.             tmpR = tmpR - tmpSub
71.             if tmpR == 0L and i + 1 < lenQ:
72.                 sys.stdout.write(spaces[0: offsetLeft] + spaces[0: bias + i + 1])
73.             else:
74.                 sys.stdout.write(spaces[0: offsetLeft] + simplify(tmpR, bias + i + 1))
76.             strTmpR = "%ld" % tmpR
77.             if i + 1 < lenQ:
78.                 oneDigit = strNumer[bias + i + 1: bias + i + 2]
79.                 if oneDigit != None:
80.                     sys.stdout.write(oneDigit)
81.                     strTmpR = strTmpR + oneDigit
82.                 tmpR = long(strTmpR)
84.     print
85.     return tmpR
88. if len(sys.argv) < 3:
89.     printUsage()
90.     exit(1)
92. a = None
93. b = None
95. try:
96.     a = long(sys.argv[1])
97.     b = long(sys.argv[2])
98. except ValueError:
99.     print("피제수: %s, 제수: %s" % (sys.argv[1], sys.argv[2]))
100.     print("숫자 입력에 오류가 있습니다.")
101.     sys.exit(1)
103. if a <= 0L:
104.     print("피제수: %ld" % a)
105.     print("피제수는 양의 정수라야 합니다.")
106.     sys.exit(1)
107. elif b <= 0L:
108.     print("제수: %ld" % b)
109.     print("제수는 양의 정수라야 합니다.");
110.     sys.exit(1)
112. q = a / b
113. r = a % b
115. sys.stdout.write("나눗셈 %ld ÷ %ld 의 결과: " % (a, b))
116. sys.stdout.write("몫: %ld, " % q)
117. print("나머지: %ld" % r)
118. print
120. k = makeTable(a, b, q)
122. if k == r:
123.     print("\n나머지: %ld" % k)
124. if k == 0L:
125.     print("%ld = %ld x %ld" % (a, b, q))
126.     print("%ld%s %ld의 배수(mupltiple)이다." % (a, getSuffix(a), b))
127.     print("%ld%s %ld의 약수(divisor)이다." % (b, getSuffix(b), a))
128. else:
129.     print("%ld = %ld x %ld + %ld" % (a, b, q, r))
130.     print("%ld%s %ld의 배수(mupltiple)가 아니다." % (a, getSuffix(a), b))

실행> python makeDivisionTable.py 500210 61

나눗셈 500210 ÷ 61 의 결과: 몫: 8200, 나머지: 10

          8200
      ________
   61 ) 500210
        488
        ------
         122
         122
        ------
            10

나머지: 10
500210 = 61 x 8200 + 10
500210은 61의 배수(mupltiple)가 아니다.

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

Python 언어에서도 한 개의 소스 파일에 여러 개의 클래스가 존재해도 된다. 또 클래스명과 다른 파일명으로 저장해도 된다. Python 언어도 Java 언어 처럼 대소문자 구별을 엄격히 하므로 클래스를 선언하고 그 클래스로 객체 생성할 때 대소문자 구별을 꼭 지켜야 한다.

다음은 두 개의 클래스로 구성되어 있다.
Parent는 부모 클래스이고 Child는 Parent에서 상속 받은 자식 클래스이다.

실행> python testSubclassing.py
I am a child, named as Dooly


Jython에서도 수정없이 그대로 실행된다.

실행> jython testSubclassing.py
I am a child, named as Dooly


IronPython에서도 수정없이 그대로 실행된다.

실행> ipy testSubclassing.py
I am a child, named as Dooly

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-동일조건변경허락 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

콘솔에 삼각형

         *
       * *
      *   *
     *     *
    *       *
   *         *
  *           *
 *             *
*****************

을 출력하는 Python 소스 코드를 작성해 보자. 이런 소스 코드의 작성은 학원이나 학교에서 프로그래밍 입문자에게 과제로 많이 주어지는 것 중의 하나이다. 코끼리를 보거나 만진 사람들이 저마다 그 생김새를 말할 때 제각기 다르게 표현할 수 있듯이 이런 소스 코드의 작성도 알고 보면 얼마든지 많은 방법이 있을 것이다. 여기서는 쉬운 코드 부터 작성해 보고 차츰차츰 소스를 바꾸어 가면서 Python 프로그래밍의 기초부분을 터득해 보기로 한다.

모든 소스 코드에서는 삼각형 출력 부분 담당 함수 printTriange()를 별도로 구현하였다.

우선 첫번 째 예제는 Python의 컨솔 출력 함수 print의 사용법만 알면 누구나 코딩할 수 있는 매우 단순한 소스 코드이다.


삼각형 출력 예제 1
#  Filename: printTriangle1.py
#            Print a triangle on console.
#
#  Execute: python printTriangle1.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

def printTriange():
    print "        *        "
    print "       * *       "
    print "      *   *      "
    print "     *     *     "
    print "    *       *    "
    print "   *         *   "
    print "  *           *  "
    print " *             * "
    print "*****************"

printTriange()




위의 소스 코드는 아무 알고리즘도 없는 너무 단순한 코드이다. 이런 코드를 작성했다간 출력 모양이나 크기를 변경해야 하는 상황을 맞이하면 워드프로세서로 문서 만드는 것 이상으로 많은 수작업을 하거나 아니면 포기하는 지경에 이를 수도 있다. 그래서 다음 처럼 좀 더 나은 소스 코드를 작성하였다. 그런데 Python 언어의 출력 함수 print 의 언어 간 호환성에 문제가 있다. print 문은 Groovy 언어의 println처럼 스트링을 출력 후 새 줄 문자(newline, '\n')을 추가한다. 그리고 끝에 콤마를 추가한

        print string,

문은 출력 후 차후 print 구문을 만날 시 빈간 문자(' ')를 하나 추가한다. 자바 언어의 System.out.print 나 Groovy 언어의 print 에 해당하는 Python의 출력 구문이나 출력 함수는 없을끼? 이 질문에 대한 대답은

        import sys
        sys.stdout.write(string)

이다. 이 경우 print 구문과 달리 string을 반드시 괄호 속에 넣어야 한다. 아래의 소스 코드에서는 아예 write() 함수를 작성하여 이의 사용을 더 편하게 하였다.




삼각형 출력 예제 2
#  Filename: printTriangle2.py
#            Print a triangle on console.
#
#  Execute: python printTriangle2.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

import sys

def write(s):
    sys.stdout.write(s)

def printTriange():
    for i in range(0, 8):
        for k in range(0, 8-i):
            write(" ")
        for k in range(0, 2*i+1):
            if k == 0 or k == 2*i:
                write("*")
            else:
                write(" ")
        for k in range(0, 8-i):
            write(" ")
        print

    for i in range(0, 17):
        write("*")
    print

printTriange()



위의 소스 코드는 Python의 컨솔 출력 함수 print 와 sys.std.write() 그리고 for 반복 구문을 적절히 사용하여 구현되었다. 숫자 몇 곳만 수정하면 출력되는 삼각형의 크기를 바꿀 수 있다. 한 줄에 출력될 문자를 구성하는 알고리즘은 위의 예제와 근본적으로 같지만 print, sys.std.write 를 사용하지 않고, 그대신 문자의 리스트를 만들어 한 즐씩 출력하는 소스 코드를 다음 예제와 같이 작성해 보았다.
또 빈칸 17개의 문자로 구성된 리스트를 생성하기 위한 구문은

        whites = [" "]*17

이다. (string*number 또는 list*number 의 구문은 Groovy, Ruby 언어에서도 지원된다.)



삼각형 출력 예제 3
#  Filename: printTriangle3.py
#            Print a triangle on console.
#
#  Execute: python printTriangle3.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

def printTriange():
    line2 = [" "]*17
    for i in range(0, 8):
        line2 = [" "]*17
        line2[8-i] =  '*'
        line2[8+i] =  '*'
        print "".join(line2)

    line2 = [" "]*17
    for i in range(0, 17):
        line2[i] =  '*'
    print "".join(line2)

printTriange()




별(*) 문자를 이용하여 삼각형을 출력하는 일은 빈칸 문자와 별 문자를 적당한 좌표(위치)에 촐력하는 일이다. 출력될 한 줄의 스트링을 완성한 후 하나의 print 구문으로 출력하는 기법으로 소스 코드를 작성해 보았다. 소스 코드 중에

        whites = " "*17
        stars = "*"*17

은 지정된 개수(여기서는 17) 만큼 string을 중복 연결하는 구문이다.




삼각형 출력 예제 4
#  Filename: printTriangle4.py
#            Print a triangle on console.
#
#  Execute: python printTriangle4.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

def printTriange():
    whites = " "*17
    stars  = "*"*17
    line2 = "%s%s%s" % (whites[0:8], "*", whites[0:7])
    print line2
    for i in range(1, 8):
        line2 = "%s%s%s%s%s" % (whites[:8-i], "*", whites[8-i:7+i], "*", whites[7+i:])
        print line2
    print stars

printTriange()




string은 immutable이라 그 내용을 변경할 수 없지만, 리스트는 그 요소(item)를 아무 때 나 변경할 수 있다. 한줄에 출력될 각 문자를 리스트 타입의 변수 line2에 저장한 다음 print 문으로 출력 시

    "".join(line2)

로 그 리스트의 모든 요소(item)가 모두 연결되어 출력되게 하였다.



삼각형 출력 예제 5
#  Filename: printTriangle5.py
#            Print a triangle on console.
#
#  Execute: python printTriangle5.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

def printTriange():
    whites = " "*17
    stars  = "*"*17
    start = 8
    line2 = [" "]*17
    line2[start] = "*"
    print "".join(line2)
    for i in range(1, 8):
        line2 = [" "]*17
        line2[start - i] = stars[start - i]
        line2[start + i] = stars[start + i]
        print "".join(line2)
    print stars

printTriange()




출력되는 삼각형이 좌우 대칭이라는 사실에 착안하여, 다음 소스 코드에서는  각 줄을 처음 8자, 중앙 한 문자, 끝 8자(처음 8자의 역순)로 string을 만들어 출력하였다.



삼각형 출력 예제 6
#  Filename: printTriangle6.py
#            Print a triangle on console.
#
#  Execute: python printTriangle6.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

import array

def reverse(chars):
    aa = array.array('c', chars)
    aa.reverse()
    return aa.tostring()
   
def printTriange():
    whites = " "*8
    stars  = "*"*8
    start = 8
    line = whites + '*' + whites
    print line
    for i in range(1, 8):
        line = whites[:-i] + '*' + whites[-i:-1]
        print line + ' ' + reverse(line)
    line = stars + '*' + stars
    print line

printTriange()




다음 소스 코드는 한 줄에 출력될 문자열의 데이터를 17비트 이진법 수로 구성하고, 이 이진법수의 비트가 0인 곳에는 빈칸을, 1인 곳에는 별(*)을 출력하는 기법으로 작성되었다.



삼각형 출력 예제 7
#  Filename: printTriangle7.py
#            Print a triangle on console.
#
#  Execute: python printTriangle7.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def itoa(num, radix=10):
   isNegative = False
   if num < 0:
      isNegative = True
      num = -num
   arr = []
   q, r = num, 0
   while q >= radix:
      q, r = divmod(q, radix)
      arr.append(BASE36[r])
   arr.append(BASE36[q])
   if isNegative:
      arr.append("-")
   arr.reverse()
   return ''.join(arr)

def printTriange():
    start = 0x100
    total = 0
    val = start
    data = ""
    for k in range(0, 8):
        val = (start << k) | (start >> k)
        data = itoa(val, 2)
        s = ""
        for i in range(0, 17 - len(data)):
            s += " "
        for i in range(0, len(data)):
            if data[i] == '0':
                s += " "
            else:
                s += "*"
        print s
        total += val

    val = (start << 8) | (start >> 8)
    total += val
    data = itoa(total, 2)
    s = ""
    for i in range(0, 17 - len(data)):
        s += " "
    for i in range(0, len(data)):
        if data[i] == '0':
            s += " "
        else:
            s += "*"
    print s

printTriange()




기본적인 원리는 위의 소스 코드와 같지만 이진법수의 한 비트 마다 한 문자씩 츨력하는 대신에 출력될 한 줄의 string을 완성하여 이를 print 구문으로 출력하는 기법으로 재작성한 것이 다음의 소스 코드이다. anotherString = string.replace(원본, 타겟) 을 이용하여 모든 0을 빈칸으로, 모든 1을 별(*) 문자로 바꾸었으며, 별(*) 문자만으로 이루어진 마지막 줄 출력을 위해 변수 total을 준비하였다. for 반복 구문의 블럭 내에서 구문

            total |= val

이 하는 일이 무엇인지 이해할 수 있으면 좋겠다.




삼각형 출력 예제 8
#  Filename: printTriangle8.py
#            Print a triangle on console.
#
#  Execute: python printTriangle8.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

import array

def reverse(chars):
    aa = array.array('c', chars)
    aa.reverse()
    return aa.tostring()
   
BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def itoa(num, radix=10):
   isNegative = False
   if num < 0:
      isNegative = True
      num = -num
   arr = []
   q, r = num, 0
   while q >= radix:
      q, r = divmod(q, radix)
      arr.append(BASE36[r])
   arr.append(BASE36[q])
   if isNegative:
      arr.append("-")
   arr.reverse()
   return ''.join(arr)

def printTriange():
    zeros  = "00000000"
    start = 0x100
    total = 0
    val = start
    line = ""
    data = ""
    for k in range(0, 8):
        val = (start << k) | (start >> k)
        data = itoa(val, 2)
        line = zeros[0:17-len(data)] + data
        line = line.replace("0", " ")
        line = line.replace("1", "*")
        print line
        total |= val

    val = (start << 8) | (start >> 8)
    total |= val
    line = itoa(total, 2)
    line = line.replace("0", " ")
    line = line.replace("1", "*")
    print line

printTriange()




소스 코드가 처음 것 보다 매우 복잡해졌지만, Python의 리스트를 이용해서 구현해 보았다. Python 언어 외에 Groovy, Ruby 언어 같은 스크립팅 언어에서도 리스트와 맵은 매우 중요하게 취급되며, 구문에서도 이를 위한 문법을 제공하고 있다. 별(*) 문자만으로 구성된 마지막 줄 출력을 위해 리스트 타입의 변수 last를 준비하였다. 또 리스트에 속한 모든 item을 출력하는 Python 코드

        print "".join(data)

는 음미해볼 만한 부분이다.



삼각형 출력 예제 9
#  Filename: printTriangle9.py
#            Print a triangle on console.
#
#  Execute: python printTriangle9.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

def printTriange():
    start = 8
    data = [" "]*17
    last = [" "]*17

    data[start] = "*"
    last[start] = "*"
    print "".join(data)
    data[start] = " "

    for k in range(1, 8):
        data[start - k] = "*"
        last[start - k] = "*"
        data[start + k] = "*"
        last[start + k] = "*"
        print "".join(data)
        data[start - k] = " "
        data[start + k] = " "

    last[start - 8] = "*"
    last[start + 8] = "*"
    print "".join(last)

printTriange()





다음 예제는 수학에서 xy-좌표평면에 점을 찍듯이 논리 구문

             (x + y - 8 == 0) or (y - x + 8 == 0) or (y - 8 == 0)

가 참이 되는 위치에 별(*) 문자를 표시하는 기법으로 작성된 소스 코드이다.




삼각형 출력 예제 10
#  Filename: printTriangle10.py
#            Print a triangle on console.
#
#  Execute: python printTriangle10.py
#
#      Date:  2008/04/02
#    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]

import sys

def printTriange():
    for y in range(0, 9):
        for x in range(0, 17):
            if (x + y - 8 == 0) or (y - x + 8 == 0) or (y - 8 == 0):
                a = '*'
            else:
                a = ' '
            sys.stdout.write(a)
        print

printTriange()








이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

        * * * * * * * * * *

을 출력한다. 그렇다면 연속적으로 출력되는 별(*) 문자 사이의 공백문자가 출력되지 않게 할 수는 없을까?  이 질문에 대한 답은 당연히 "있다"이다.  sys 모듈의  sys.stdout.write(string) 함수를 사용하면 된다. 예를 들어, 파이썬 소스 코드

        import sys
        for i in range(10): sys.stdout.write("*")
        sys.stdout.write("\n")

은

        **********

를 출력한다.


참고 자료:  Python Gotchas




This work is licensed under the Creative Commons Attribution 2.0 License

ASCII(애스키)란 American Standard Code for Information Interchange의 줄임글로서, 영문자에 기초한 문자 인코딩이다.  이 문자 인코딩에는 C0 제어문자(C0 control character)도 포함되어 있다.  ( 참고:  ASCII - Wikipedia, the free encyclopedia )

다음은  7bit ASCII 코드표를 만들어 보여주는 Python 소스 코드이다. 소스 코드 중에 진법변환에 필요한 함수

        convertAtoI(string, radix)
        convertItoA(number, radix)

의 구현도 포함되어 있다.

(아래의 소스는 Jython이나 IronPython에서도 수정없이 그대로 실행된다.)

1. #  Filename: makeAsciiTable.py
2. #            Make a table of ascii codes.
3. #
4. #  Execute: python makeAsciiTable.py
5. #
6. #      Date:  2008/03/28
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. import sys
11. BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
13. def println(s=None):
14.     if s == None:
15.         print
16.     else:
17.         print(s)
19. def printUsage():
20.     println("Usage: python makeAsciiTable.py")
21.     println("Make a table of ascii codes.")
23. def convertItoA(num, radix):
24.     isNegative = False
25.     if num < 0:
26.         isNegative = True
27.         num = -num
29.     arr = ""
30.     q = num
31.     r = 0
33.     while q >= radix:
34.         r = q % radix
35.         q = q / radix
36.         arr += BASE36[r]
37.     arr += BASE36[q]
39.     if isNegative:
40.         arr += "-"
42.     n = len(arr)
43.     ret = ""
44.     for i in range(0, n):
45.         ret += arr[n - i - 1]
47.     return ret
49. def convertAtoI(srcStr, radix):
50.     isNegative = False
51.     ret = 0
52.     m = len(srcStr)
53.     val = 0
54.     c = srcStr[0]
56.     if c == '-':
57.         isNegative = True
58.     elif c >= '0' and c <= '9':
59.         ret = ord(c) - ord('0')
60.     elif c >= 'A' and c <= 'Z':
61.         ret = (ord(c) - ord('A')) + 10
62.     elif c >= 'a' and c <= 'z':
63.         ret = (ord(c) - ord('a')) + 10
65.     if ret >= radix:
66.         println("        Invalid character!")
67.         return ret
69.     for i in range(1, m):
70.         c = srcStr[i]
71.         ret *= radix
72.         if c >= '0' and c <= '9':
73.             val = ord(c) - ord('0')
74.         elif c >= 'A' and c <= 'Z':
75.             val = (ord(c) - ord('A')) + 10
76.         elif c >= 'a' and c <= 'z':
77.             val = (ord(c) - ord('a')) + 10
79.         if val >= radix:
80.             println("        Invalid character!")
81.             return ret
83.         ret += val
85.     return ret
87. asc = [
88.     "NUL", "SOH", "STX", "ETX", "EOT",
89.     "ENQ", "ACK", "BEL", "BS", "HT",
90.     "LF", "VT", "FF", "CR", "SO",
91.     "SI", "DLE", "DC1", "DC2", "DC3",
92.     "DC4", "NAK", "SYN", "ETB", "CAN",
93.     "EM", "SUB", "ESC", "FS", "GS",
94.     "RS", "US", "Spc"
95. ]
97. control  = [
98.     "NUL (null)",
99.     "SOH (start of heading)",
100.     "STX (start of text)",
101.     "ETX (end of text)",
102.     "EOT (end of transmission)",
103.     "ENQ (enquiry)",
104.     "ACK (acknowledge)",
105.     "BEL (bell)",
106.     "BS  (backspace)",
107.     "TAB (horizontal tab)",
108.     "LF  (line feed, NL new line)",
109.     "VT  (vertical tab)",
110.     "FF  (form feed, NP new page)",
111.     "CR  (carriage return)",
112.     "SO  (shift out)",
113.     "SI  (shift in)",
114.     "DLE (data link escape)",
115.     "DC1 (device control 1)",
116.     "DC2 (device control 2)",
117.     "DC3 (device control 3)",
118.     "DC4 (device control 4)",
119.     "NAK (negative acknowledge)",
120.     "SYN (synchronous idle)",
121.     "ETB (end of trans. block)",
122.     "CAN (cancel)",
123.     "EM  (end of medium)",
124.     "SUB (substitute, EOF end of file)",
125.     "ESC (escape)",
126.     "FS  (file separator)",
127.     "GS  (group separator)",
128.     "RS  (record separator)",
129.     "US  (unit separator)",
130. ]
132. def makeTable():
133.     sbuf = ""
134.     abuf = ""
135.     tbuf = ""
137.     sbuf = "    "
138.     for i in range(0, 8):
139.         sbuf += "+----"
140.     sbuf += "+"
141.     println(sbuf)
143.     sbuf = "    "
144.     sbuf += "| 0- "
145.     sbuf += "| 1- "
146.     sbuf += "| 2- "
147.     sbuf += "| 3- "
148.     sbuf += "| 4- "
149.     sbuf += "| 5- "
150.     sbuf += "| 6- "
151.     sbuf += "| 7- "
152.     sbuf += "|"
153.     println(sbuf)
155.     sbuf = "+---"
156.     for i in range(0, 8):
157.         sbuf += "+----"
158.     sbuf += "+"
159.     println(sbuf)
161.     for i in range(0, 16):
162.         tbuf = ""
163.         sbuf = convertItoA(i, 16)
164.         tbuf += "| " + sbuf + " "
165.         for j in range(0, 8):
166.             if j*16 + i <= 32:
167.                 abuf = "| %-3s" % asc[j*16 + i]
168.             elif j*16 + i == 127:
169.                 abuf = "| %-3s" % "DEL"
170.             else:
171.                 c = chr(j*16 + i)
172.                 abuf = "| %2c " % c
173.             tbuf += abuf
174.         tbuf += "|"
175.         println(tbuf)
177.     sbuf = "+---"
178.     for i in range(0, 8):
179.         sbuf += "+----"
180.     sbuf += "+"
181.     println(sbuf)
182.     println("")
184.     for i in range(0, 16):
185.         tbuf = "%-30s  %-34s" % (control[i], control[i+16])
186.         println(tbuf)
189. if len(sys.argv) > 1 and "-h" == sys.argv[1]:
190.     printUsage()
191.     sys.exit(1)
193. makeTable()

실행> python makeAsciiTable.py

   
    +----+----+----+----+----+----+----+----+
    | 0- | 1- | 2- | 3- | 4- | 5- | 6- | 7- |
+---+----+----+----+----+----+----+----+----+
| 0 | NUL| DLE| Spc|  0 |  @ |  P |  ` |  p |
| 1 | SOH| DC1|  ! |  1 |  A |  Q |  a |  q |
| 2 | STX| DC2|  " |  2 |  B |  R |  b |  r |
| 3 | ETX| DC3|  # |  3 |  C |  S |  c |  s |
| 4 | EOT| DC4|  $ |  4 |  D |  T |  d |  t |
| 5 | ENQ| NAK|  % |  5 |  E |  U |  e |  u |
| 6 | ACK| SYN|  & |  6 |  F |  V |  f |  v |
| 7 | BEL| ETB|  ' |  7 |  G |  W |  g |  w |
| 8 | BS | CAN|  ( |  8 |  H |  X |  h |  x |
| 9 | HT | EM |  ) |  9 |  I |  Y |  i |  y |
| A | LF | SUB|  * |  : |  J |  Z |  j |  z |
| B | VT | ESC|  + |  ; |  K |  [ |  k |  { |
| C | FF | FS |  , |  < |  L |  \ |  l |  | |
| D | CR | GS |  - |  = |  M |  ] |  m |  } |
| E | SO | RS |  . |  > |  N |  ^ |  n |  ~ |
| F | SI | US |  / |  ? |  O |  _ |  o | DEL|
+---+----+----+----+----+----+----+----+----+

NUL (null)                      DLE (data link escape)
SOH (start of heading)          DC1 (device control 1)
STX (start of text)             DC2 (device control 2)
ETX (end of text)               DC3 (device control 3)
EOT (end of transmission)       DC4 (device control 4)
ENQ (enquiry)                   NAK (negative acknowledge)
ACK (acknowledge)               SYN (synchronous idle)
BEL (bell)                      ETB (end of trans. block)
BS  (backspace)                 CAN (cancel)
TAB (horizontal tab)            EM  (end of medium)
LF  (line feed, NL new line)    SUB (substitute, EOF end of file)
VT  (vertical tab)              ESC (escape)
FF  (form feed, NP new page)    FS  (file separator)
CR  (carriage return)           GS  (group separator)
SO  (shift out)                 RS  (record separator)
SI  (shift in)                  US  (unit separator)

컴퓨터 프로그래밍에서 꼭 알아두어야 할 주요 진법은 당연히 10진법, 2진법, 8진법, 16진법이다.
다음은  0 에서 15 까지의 정수를 10진법, 2진법, 8진법, 16진법의 표로 만들어 보여주는 Python 소스 코드이다. 진법 변환에 필요한 함수

        convertAtoI(string, radix)
        convertItoA(number, radix)

를 Python 코드로 자체 작성하여 사용하였다.

(아래의 소스는 Jython이나 IronPython에서도 수정없이 그대로 실행된다.)

1. #  Filename: makeRadixTable.py
2. #            Show the radix table with 10-, 2-, 8-, 16-radices.
3. #
4. #  Execute: python makeRadixTable.py
5. #
6. #      Date:  2008/03/28
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. import sys
11. BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
13. def println(s=None):
14.     if s == None:
15.         print
16.     else:
17.         print(s)
19. def printUsage():
20.     println("Usage: python makeRadixTable.py")
21.     println("Show the radix table with 10-, 2-, 8-, 16-radices.")
23. def convertItoA(num, radix):
24.     isNegative = False
25.     if num < 0:
26.         isNegative = True
27.         num = -num
29.     arr = ""
30.     q = num
31.     r = 0
33.     while q >= radix:
34.         r = q % radix
35.         q = q / radix
36.         arr += BASE36[r]
38.     arr += BASE36[q]
39.     if isNegative:
40.         arr += "-"
42.     n = len(arr)
43.     ret = ""
44.     for i in range(0, n):
45.         ret += arr[n - i - 1]
47.     return ret
49. def convertAtoI(srcStr, radix):
50.     isNegative = False
51.     ret = 0
52.     m = len(srcStr)
53.     val = 0
54.     c = srcStr[0]
56.     if c == '-':
57.         isNegative = True
58.     elif c >= '0' and c <= '9':
59.         ret = ord(c) - ord('0')
60.     elif c >= 'A' and c <= 'Z':
61.         ret = (ord(c) - ord('A')) + 10
62.     elif c >= 'a' and c <= 'z':
63.         ret = (ord(c) - ord('a')) + 10
65.     if ret >= radix:
66.         println("        Invalid character!")
67.         return ret
69.     for i in range(1, m):
70.         c = srcStr[i]
71.         ret *= radix
72.         if c >= '0' and c <= '9':
73.             val = ord(c) - ord('0')
74.         elif c >= 'A' and c <= 'Z':
75.             val = (ord(c) - ord('A')) + 10
76.         elif c >= 'a' and c <= 'z':
77.             val = (ord(c) - ord('a')) + 10
79.         if val >= radix:
80.             println("        Invalid character!")
81.             return ret
83.         ret += val
84.     return ret
86. def makeTable():
87.     sbuf = ""
88.     abuf = ""
89.     tbuf = ""
91.     for i in range(0, 4):
92.         sbuf += "+-------"
94.     sbuf += "+"
95.     println(sbuf)
97.     sbuf = "|  Dec"
98.     sbuf += "\t|   Bin"
99.     sbuf += "\t|  Oct"
100.     sbuf += "\t|  Hex  |"
101.     println(sbuf)
103.     sbuf = ""
104.     for i in range(0, 4):
105.         sbuf += "+-------"
106.     sbuf += "+"
107.     println(sbuf)
109.     for i in range(0, 16):
110.         sbuf = "|   %2d" % i
111.         abuf = convertItoA(i, 2)
112.         tbuf = "\t|  %4s" % abuf
113.         sbuf += tbuf
115.         abuf = convertItoA(i, 8)
116.         tbuf = "\t|   %2s" % abuf
117.         sbuf += tbuf
119.         abuf = convertItoA(i, 16)
120.         tbuf = "\t|    %-2s |" % abuf
121.         sbuf += tbuf
122.         println(sbuf)
124.     sbuf = ""
125.     for i in range(0, 4):
126.         sbuf += "+-------"
127.     sbuf += "+"
128.     println(sbuf)
130. if len(sys.argv) > 1 and "-h" == sys.argv[1]:
131.     printUsage()
132.     sys.exit(1)
134. makeTable()

실행> python makeRadixTable.py

+-------+-------+-------+-------+
|  Dec  |   Bin |  Oct  |  Hex  |
+-------+-------+-------+-------+
|    0  |     0 |    0  |    0  |
|    1  |     1 |    1  |    1  |
|    2  |    10 |    2  |    2  |
|    3  |    11 |    3  |    3  |
|    4  |   100 |    4  |    4  |
|    5  |   101 |    5  |    5  |
|    6  |   110 |    6  |    6  |
|    7  |   111 |    7  |    7  |
|    8  |  1000 |   10  |    8  |
|    9  |  1001 |   11  |    9  |
|   10  |  1010 |   12  |    A  |
|   11  |  1011 |   13  |    B  |
|   12  |  1100 |   14  |    C  |
|   13  |  1101 |   15  |    D  |
|   14  |  1110 |   16  |    E  |
|   15  |  1111 |   17  |    F  |
+-------+-------+-------+-------+

다음은  대화형 모드(interactive mode)에서 진법 변환(radix conversion)하는 Python 소스 코드이다.
메뉴는 주메뉴 Command: (S)et radix, (A)bout, (Q)uit or E(x)it
와 부메뉴 SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
로 구성되어 있으며, 진법 변환의 핵심은 Python의 빌트인 함수 int(string, radix)와 소스 코드에 자체 작성된 함수 itoa(number, radix)의 사용이다.

         val = int(s, srcRdx)
         ret = itoa(val, destRdx)

지원되는 진법은 2진법에서 36진법까지이다.
(Jython으로는 finally: 구문 때문에 실행이 안된다.)

1. #  Filename: convertRadix.py
2. #            Convert radix in a interactive mode.
3. #
4. #  Execute: python convertRadix.py
5. #
6. #      Date:  2008/03/25
7. #    Author:  PH Kim   [ pkim (AT) scripts.pe.kr ]
9. import sys
11. def println(s=None):
12.     if s != None:
13.         print(s)
14.     else:
15.         print
17. def printUsage():
18.     println("Usage: python convertRadix.py")
19.     println("Convert radix in a interactive mode, where the maximum radix is 36.")
21. def printAbout():
22.     println("    About: Convert radix in a interactive mode.")
24. def printMainMenu():
25.     println("  Command: (S)et radix, (A)bout, (Q)uit or E(x)it")
27. def printMainPrompt():
28.     print("  Prompt>"),
30. def printSubMenu(srcRadix, destRadix):
31.     println("    Convert Radix_" + str(srcRadix) + " to Radix_" + str(destRadix))
32.     println("    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit")
34. def printSubPrompt():
35.     print("    Input Value>>"),
37. BASE36 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
39. def itoa(num, radix=10):
40.    isNegative = False
41.    if num < 0:
42.       isNegative = True
43.       num = -num
45.    arr = []
46.    q, r = num, 0
47.    while q >= radix:
48.       q, r = divmod(q, radix)
49.       arr.append(BASE36[r])
51.    arr.append(BASE36[q])
52.    if isNegative:
53.       arr.append("-")
55.    arr.reverse()
56.    return ''.join(arr)
58. def convertRadix(s, srcRdx, destRdx):
59.     ret = ""
60.     try:
61.         val = int(s, srcRdx)
62.         ret = itoa(val, destRdx)
63.         return ret.upper()
64.     except ValueError:
65.         println("    Error: Cannot convert radix " + str(srcRdx))
66.         ret = "????"
67.     finally:
68.         return ret.upper()
70. def doConvert(srcRadix, destRadix):
71.     line = ""
72.     cmd = ""
73.     srcStr = ""
74.     destStr = ""
75.     println("")
77.     printSubMenu(srcRadix, destRadix)
78.     try:
79.         while True:
80.             printSubPrompt()
81.             cmd = raw_input()
82.             while cmd == None:
83.                 cmd = raw_input()
85.             if "main()" == cmd:
86.                 return
87.             elif "exit()" == cmd or "quit()" == cmd:
88.                 sys.exit(0)
90.             try:
91.                 int(cmd, srcRadix)
92.                 srcStr = cmd
93.                 destStr = convertRadix(srcStr, srcRadix, destRadix)
94.                 println("        ( " + srcStr + " )_" + str(srcRadix) +  "   --->   ( " + destStr + " )_" + str(destRadix))
95.                 println("")
96.             except ValueError:
97.                  pass
98.     except RuntimeError:
99.         print sys.exc_value
101. def doStart():
102.     line = ""
103.     cmd = ""
104.     srcRadix = 10
105.     destRadix = 10
106.     srcStr = ""
107.     destStr = ""
108.     onlyOnce = True
110.     try:
111.         while True:
112.             println()
113.             if onlyOnce:
114.                 println("  The supported maximum radix is 36.")
115.                 onlyOnce = False
117.             printMainMenu()
118.             printMainPrompt()
119.             cmd = raw_input()
120.             while cmd == None:
121.                 cmd = raw_input()
123.             if "qQxX".find(cmd) >= 0 and len(cmd) == 1:
124.                 sys.exit(0)
125.             elif "aA".find(cmd) >= 0 and len(cmd) == 1:
126.                 printAbout()
127.             elif "sS".find(cmd) >= 0 and len(cmd) == 1:
128.                 line = raw_input("  Input the source and target radices (say, 16 2): ")
129.                 st = line.split(" ")
130.                 while len(st) < 2:
131.                     line = raw_input("  Input the source and target radices (say, 16 2): ")
132.                     st = line.split(" ")
134.                 srcRadix = int(st[0])
135.                 destRadix = int(st[1])
136.                 doConvert(srcRadix, destRadix)
137.     except RuntimeError:
138.         print sys.exc_value
141. # Begin here
142. if len(sys.argv) > 1 and "-h" == sys.argv[1]:
143.     printUsage()
144.     sys.exit(1)
146. doStart()

실행> python convertRadix.py

  The supported maximum radix is 36.
  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> s
  Input the source and target radices (say, 16 2): 10 8

    Convert Radix_10 to Radix_8
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 200
        ( 200 )_10   --->   ( 310 )_8

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> S
  Input the source and target radices (say, 16 2): 8 10

    Convert Radix_8 to Radix_10
    SubCommand: 'main()' to goto Main menu, 'exit()' or 'quit()' to exit
    Input Value>> 2666
        ( 2666 )_8   --->   ( 1462 )_10

    Input Value>> main()

  Command: (S)et radix, (A)bout, (Q)uit or E(x)it
  Prompt> x




IronPython의 경우에는 구문

    print 스트링,

이 Python과 달리 끝에 빈칸을 곧 바로 추가하지 않고, 빈칸 출력을 유보하고 있다가 다음 print 문을 만날 때 이 빈칸을 먼저 출력한 후 주어진 스트링을 출력한다. raw_input()과 함께 쓰일 때는 이 빈칸 하나 때문에 신경이 쓰이기도 한다. 그래서 프롬프트를 출력하는 함수를

def printMainPrompt(): 
     print("  Prompt> "),

def printSubPrompt(): 
     print("    Input Value>> "),

로 수정해야 한다.





이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.