파이썬은 스크립트 언어이므로 소스 코드를 파이썬 인터프리터로 해석하여 프로그램을 수행하게 된다.

하지만 사용자에게 파이썬으로 만든 프로그램을 배포하여 유효한 프로그램이 되기 위해서는 먼저 파이썬 인터프리터가 사용자의 PC에 설치되어 있어야 하며, 또한 사용자에게 소스를 그대로 배포해야한다는 단점이 존재한다.

일반적인 상업용 프로그램은 거의 모두가 바이너리 형태의 파일로 되어 있다.

파이썬 프로그램을 실행가능한 바이너리 파일(.exe)로 만드는 법을 살펴보기로 한다.

먼저 파이썬 프로그램을 실행파일(.exe)로 만드는 유틸리티인 py2exe 프로그램을 아래의 사이트에서 다운로드 받아서 설치한다.

http://starship.python.net/crew/theller/py2exe/

py2exe를 설치하기 전에 파이썬이 자신의 PC에 먼저 설치되어 있어야 한다.

현재(2004년 11월 8일)까지 최신 버전은 py2exe.0.5.4 이며, 이전 버전에는 0.4.2,와 0.5.3이 있는데. 0.4.2와 0.5 대 버전의 차이점은 setup 스크립트를 작성하는 방법과 디렉토리 구성 및 실행파일의 저장에 관한 규칙들이 많이 바뀌었다.

여기에서는 0.4.2버전과 0.5.3 버전을 이용하여 exe 바이너리 파일로 만드는 방법을 각각 설명하겠다.

<< 0.4.2 버전으로 exe 파일 만들기>>

자 이제 실제 소스를 가지고 실행파일을 만들어 보기로 한다.

아래와 같은 화면에 "HI sams~" 라고 디스플레이하는 아주 간단한 소스를 작성한다.

# test.py

if __name__ == "__main__":

    print 'HI sams~'

위의 소스는 콘솔화면에서 디스플레이 하는 간단한 소스이다.

py2exe를 이용해서 위의 test.py를 실행가능한 바이너리 파일로 작성하기 위해서는 아래와 같은 간단한 셋업 파일이 필요하다. 셋업 파일의 이름은 적당하게 짓는다.

# testsetup.py

from distutils.core import setup
import py2exe

setup(name='test', scripts=['testexe.py'])

위의 소스에서 name= 에 해당하는 것은 실행파일의 이름이며, scripts는 바이너리 파일로 만들 소스 이름이다.

testsetup.py가 존재하는 디렉토리에서 커맨드 모드로 다음과 같은 명령을 해보자.

python testsetup.py py2exe --help

이 명령으로 py2exe 의 다양한 옵션을 볼수 있을 것이다.

우리가 만들고자 하는 프로그램은 콘솔용 프로그램이므로 다음과 같은 명령을 이용한다.

python testsetup.py py2exe --console

모든 절차가 다 끝나면 test.py가 있는 디렉토리에 dist라는 디렉토리가 만들어지고, 그 아래에 test라는 디렉토리가 만들어진다. 이 곳에 test.exe가 만들어져 있을 것이다.

만약 test.py가 윈도용 프로그램으로 작성된 경우는

python testsetup.py py2exe --windows 라고 하면된다.

0.4.2 버전에서 실행파일의 생성은 메인 소스가 있는 디렉토리가 "A"라면 아래의 디렉토리에 생성된다.

A/dist/"파일명"

<<0.5 대 버전으로 exe 파일 만들기>>

위에서 예로 든 test.py를 그대로 이용하여 exe 파일로 만든다고 가정하자.

이제는 testsetup.py 파일만 0.5 버전대의 스크립트로 수정하면 된다. 다음과 같다.

# testsetup.py

from distutils.core import setup
import py2exe

setup(

      # version = "1.0" # 옵션

      # description = "MyTestProg" # 옵션

      # name = "Hi Man"

       console = ["test.py"], # 콘솔 프로그램으로 생성

       # windows = ["test.py"], # 윈도 프로그램으로 생성

)

실행은 다음과 같이 한다.

python testsetup.py py2exe

즉, 0.4.2와 달라진 점은 --console, --windows 와 같은 옵션이 스크립트 내에 포함된 형태로 변했다.

실행파일의 생성은 A/dist 바로 밑에 생성되며 실행에 필요한 라이브러리들이 library.zip 이라는 형태의 압축파일에 저장된다. 즉 프로그램을 배포할 때 실행파일과 함께 library.zip을 함께 배포하도록 해야 한다.

만약 수많은 자료들 중에 특정값을 기준으로 정렬한 후 값이 가장 큰 특정 개수만큼만 꺼집어 내는 간단한 방법이 없을까요?

서버 프로그램의 경우에서처럼 수많은 커넥션들 중에서 전송속도가 가장 큰 10개를 선택하고 싶다고 했을 경우에 말이죠~

위와 같은 경우 리스트를 이용하면 간단히 해결할 수 있습니다.

구체적인 예를 들며 살펴보기로 하죠.

<전송속도:소켓디스크립터> 쌍으로 이루어진 자료가 있다고 합시다.

전송속도는 해당 소켓디스크립터로 연결된 원격지와의 전송속도라가 가정합니다.

아래와 같은 리스트를 생각해봅니다.

[(전송속도, 소켓디스크립터), (전송속도, 소켓디스크립터),,,,,,]

즉 (전송속도, 소켓디스크립터) 튜플이 값인 리스트를 생각하는 겁니다.

아래의 소스를 봅시다

# socklist = (전송속도, 소켓디스크립터), count = 선택할 개수

def selectSortedSocks(socklist, count):

    mySocks = []

    for speed, sock in socklist:

        mySocks.append((-speed, sock))

    mySocks.sort()

    del mySocks[count:]

    mySocks = [x[1] for x in mySocks]

    return mySocks

위에서 정의한 함수를 간단히 살펴보죠.

위의 함수는 (전송속도, 소켓디스크립터)가 값인 리스트와 개수를 입력받으면, 리스트에서 속도가 가장 큰 순서의 입력한 개수 만큼의 소켓 디스크립터들을 리턴합니다.

그럼 코드를 설명하면,

입력된 인자인 socklist 에서 전송속도 부분을 음수로 바꾼 후 새로운 리스트에 입력합니다.

    for speed, sock in socklist:

        mySocks.append((-speed, sock))

     mySocks.sort()

그리고 정렬하면 값이 가장 큰 순서대로 정렬되죠. 즉 아래와 같이 정렬될 것입니다.

    정렬된 예 : [(-300, sock1), (-200, sock2), (-100, sock3)]

이 함수의 역할은 전송속도가 가장 큰 count개를 선택해서 소켓디스크립터들만 리턴하는 함수이므로, 전송속도가 순위 밖인 것은 모두 삭제한 후 소켓 디스크립터만을 선택하고 이를 리턴하면 됩니다.

    del mySocks[count:]

    mySocks = [x[1] for x in mySocks]

    return mySocks

자 그럼 아래의 코드를 삽입한 후 한번 실행해 볼까요??

if __name__ == "__main__":

    socklist = [(100, 'sock1'), (55, 'sock2'), (132, 'sock3'), (320, 'sock4'), (98, 'sock5')]

    result = selectSortedSock(socklist, 3)

    print result

결과는 아래와 같아야 하겠습니당~

['sock4', 'sock3', 'sock1']

그럼 리스트를 이용해서 위와 같은 부류의 문제에 직면하였을때는 쉽게 해결할 수 있으리라 생각됩니다. ^^

파이썬은 그 자체가 C로 작성되었다.

이런 맥락에서 생각해보면 파이썬에서 C모듈을 사용할수도 있을뿐 아니라 C에서 파이썬 모듈을 사용할수도 있을것 같다. -> 이말은 사실이다.

본론으로 들어가기전에 파일의 확장자에 대해 살포시 살펴보기로 하자.

파일의 확장자는 그 파일의 속성과 종류를 손쉽게 알려주는 역할을 한다. (이는 어떻게 보면 있어도 되고 없어도 되는 존재이며, 관습적으로 사용하게 된다.)

우리가 흔히 알고 있는 확장자로는 'exe', 'txt', 'jpg', 'mp3' 등 수없이 많다.

- lib : 정적 라이브러리 파일, 일반적으로 C, C++ 라이브러리다.

- dll : 동적 라이브러리 파일

- pyd : 파이썬이 사용하는 C 라이브러리

여기서는 C로 작성된 코드를 이용하여 pyd를 만들고 이 pyd를 이용해서 C 모듈을 이용하는 방법에 대해서 살펴본다.

1. 파이썬 코드에서 import를 하면 일어나는 일

파이썬에서 특정한 모듈을 사용하기 위해 import문을 이용하여 모듈을 지정한다. 파이썬이 사용하고 로드하는 모듈은 아래의 순서로 찾고 그와 일치하면 모듈을 초기화한 후에 지역 이름공간에 이름을 정의한다.

    - 기본적으로 탑재되어 있는 모듈들 : ex)socket, time 등

    - C로 만들어진 dll 파일(윈도에서는 pyd 파일)

    - 자체 제작한 파이썬 모듈

그러면 파이썬에서 import는 어떤 매커니즘으로 동작하는가? 이것을 함 알아보자.

import mylib

위의 코드를 수행할때 파이썬은 mylib 모듈을 로드하기 위해 다음의 절차에 따라 검색한다.

    1) sys.modules 에 등록되어 있는지 확인한다. 등록되어 있으면 로드한다.

    2) 1)에서 존재하지 않으면 sys.path의 디렉토리를 검색하면서 mylib 모듈을 찾는다.

다시 한번 요약하면, 외부 모듈을 import 하게되면 파이썬은

    1) 모듈이름과 일치하는 모듈을 찾는다.

    2) 모듈을 초기화 한다.

    3) 모듈이름을 지역이름공간에 할당한다.

2. 파이썬에서 이용할 C 모듈 만들기

여기서 우리는 우리가 만든 C 모듈을 파이썬에서 사용하고 싶다. 즉,

import (우리가 만든 C 모듈) 하고 싶다 이 말이다.

우리가 C로 만든 모듈을 파이썬에서 이용하고자 할때 역시 위에서 서술한 import 절차에 따라 모듈을 찾고 로드하게 된다.

우리가 유의해야 할 곳은 바로 모듈을 초기화 하는 부분이다. 나머지 절차는 파이썬이 다 알아서 해준다.

파이썬에서 사용하는 C모듈은 리눅스에서는 .so 확장자 형태로, 윈도에서는 .pyd 확장자 형태로 빌드되어 파이썬 패키지 디렉토리의 Lib/site-package 디렉로리로 복사되므로서 사용가능하게 된다.

    1) C로 소스코드를 작성한다.

    2) 작성한 C 소스코드를 컴파일하여 파이썬이 이용가능한 .so (리눅스에서) 및 .pyd(윈도용) 파일로 빌드한다.

    3) .so 및 .pyd 파일을 파이썬 디렉토리의 Lib/site-package로 복사한다.

그러면 하나의 실제 C모듈을 만들어 적용하므로서 설명해보자.

파이썬이 C 모듈을 import 하게되면 초기화를 위해 "init+모듈이름" 으로 된 함수를 호출한다. 모듈이름이 mylib 이면 initmylib()을 호출한다는 말이다.

그러므로 우리의 C 소스에는 위에서 설명한 초기화를 위한 함수 init+모듈이름 으로 된 함수가 존재해야만 한다.

예제로 만들 모듈은 입력한 문자열을 pylog.txt 라는 파일에 기록하는 모듈이다. 주석을 달았으므로 주석을 참조하도록 한다.

// mylib.c

#include "Python.h"
#include <stdio.h>

static PyObject *ErrorObject;

// 실제 동작하는 함수

static PyObject* write_log(PyObject *self, PyObject *args) // 인자는 이와같이 고정된다.
{
    char* msg;
    FILE *fp;
   
    if(!PyArg_ParseTuple(args, "s", &msg))
        return NULL;
   
    fp = fopen("c:\\pylog.txt", "wt+");
    fprintf(fp, msg);

    fclose(fp);
   
    return Py_BuildValue("i", 0);   
}

/* methods 구조체 배열에 지정되는 정보는 {"실제사용할 메쏘드명", 메쏘드명에 대응하는 실제 동작하는 함수명, 인자 종류} */

static struct PyMethodDef methods[] =
{
    {"wlog", write_log, METH_VARARGS},
    {NULL, NULL}
};

//

void initmylib()
{
    PyObject* m;
   

   // Py_InitModule("모듈명", 이모듈에 적용된 메쏘드들을 담을 구조체배열 포인터)
    m = Py_InitModule("mylib", methods);

    ErrorObject = Py_BuildValue("s", "error");
}

위의 C 코드를 컴파일하기 위해 setup.py 함수를 작성해야 한다.

# setup.py

from distutils.core import setup, Extension

setup(name = "mylib",
        version = "1.0",
        description = "print log",
        author = "Samsjang",
        author_email = "samsjang@cdnetworks.co.kr",
        url = "http://www.cdnetworks.co.kr",
        ext_modules = [Extension("mylib", ["mylib.c"])]
        )

위의 소스에서 ext_modules에는 적용할 모듈명과 그 모듈의 구현코드를 기록한다. 나머지 부분의 기타 정보를 기록해둔 메타정보에 불과하다.

리눅스 및 윈도에서 아래와 같이 빌드하고 설치한다.

python setup.py install

위의 명령은 리눅스에서는 gcc를 호출하며, 윈도에서는 visual C++ 컴파일러가 구동되면서 빌드한 후 파이썬 디렉토리의 Lib/site-packages 디렉토리에 mylib.so 또는 mylib.pyd  파일이 생성된다.

자 그럼 C모듈인 mylib 모듈을 실제 파이썬 코드에서 적용해보자.

# test.py

import mylib

if __name__ == '__main__':    
    mylib.wlog('I love U')

위의 결과는 C:\\pylog.txt 파일에 "I love U" 라는 글을 남긴다.

이 지침서는 앞으로 더 많은 작업을 하게 될 것이다. 나는 여러분의 어떠한 비평이라도 환영하며 여러분은 원하시는 바의 사양에 대해 비평해 주시기 바란다. 전자메일을 나에게 보내셔서 방대한 분량의 일을 완성하고, 개선하고, 그리고 비평들에 대해 더욱 주의를 기울이게 하여 주시면 감사하겠다 :)

기분좋은 프로그래밍은, 여러분의 인생을 그리고 어쩌면 세계를 바꿀지도 모를 일이다.

하고자 하는바=[ '에러들','모듈을 만드는 방법','루프에 대하여 더 자세히','문자열에 대하여 더 자세히', '파일 입출력','온라인 도움말을 사용하는 법','try문','pickle모듈','여러분이 제안하고 내가 보기에 좋은 생각이라고 여겨지는 모든 것']

FAQ

input 문을 가지고 프로그램을 쓸 수 없어요

여러분이 IDLE를 사용하고 있다면 명령어 라인을 시도해 보세요. 이 문제는 IDLE 0.6 그 이상에서는 해결된거로 보입니다. 여러분이 구형 버젼을 사용하고 있다면 파이썬 2.0이나 더 신버젼으로 업그레이드 하세요

인쇄가 가능한 버젼이 있읍니까?

네, 다음 질문을 보세요.

PDF 혹은 zip으로 압축된 버젼이 있나요?

네, http://www.honors.montana.edu/~jjc/easytut/ 로 가시면 몇가지의 다른 버젼을 보실 수 있읍니다.

이 지침서는 무엇으로 작성하셨나요?

L^ATEX 입니다, easytut.tex 파일을 보세요.

내 질문에 대한 답이 여기에 없네요

나에게 전자메일을 보내 물어보세요. 여러분이 무엇을 하려고 하였는지, 무슨일이 일어났는지, 여러분은 무엇을 예상했는지, 에러 메시지, 파이썬의 버젼, (사용중인) 운영체제, 그리고 여러분의 고양이가 키보드 위를 뛰어 다니지는 않았는지, 등등을 첨부하여 주시면 도움이 되겠습니다. (우리집 고양이는 스페이스 바와 콘트롤 키를 좋아한답니다.)

가장 마지막으로 언제 변경되었는지 그리고 무엇이 변경되었는지요?

2000-Dec-16, 에러 처리의 장이 추가되었습니다.
2000-Dec-22, 구형 설치방법이 삭제 되었습니다.
2001-Jan-16, 프로그램의 버그가 고쳐졌고, 리스트 섹션에 예제와 데이타를 추가 하였습니다.
2001-Apr-5, 철자, 문법, 프로그램을 분석하는 법이 추가되었습니다, PDF 버젼의 url버그를 고쳤습니다.
2001-May-13, 디버깅에 관한 장이 추가되었습니다.

자, 이제 여러분은 완벽한 프로그램을 가지고 있으며, 한가지 세부사항만 빼고는, 그것은 결점없이 실행된다. 그것은 사용자의 무효한 입력에 충돌을 일으킬 것이다. 걱정하지 마라, 왜냐하면 파이썬은 여러분을 위하여 특별한 제어 구조를 구지고 있기 때문이다. 그것을 일컬어 try라고 부르며 그것은 뭔가를 하려고 시도한다.
여기에 한가지 문제점을 가지고 있는 프로그램의 예제가 있다:

print "Type Control C or -1 to exit"
number = 1
while number != -1:
    number = int(raw_input("Enter a number: "))
    print "You entered: ",number

여러분이 @#&를 입력해 넣을 때 프로그램이 다음과 같은 출력을 보이는 것을 주목하라:

Traceback (innermost last):
  File "try_less.py", line 4, in ?
    number = int(raw_input("Enter a number: "))
ValueError: invalid literal for int(): @#&

여러분이 볼 수 있듯이 int 함수는 숫자 @#&에 불행해 한다 (물론 틀림없이 그럴거다). 마지막 라인을 보면 그 프로그램이 무엇인지 알 수 있다; 파이썬은 ValueError 를 발견했다. 어떻게 우리의 프로그램이 이것을 다룰 수 있을까? 우리가 먼저 해야 할일은 : 에러가 발생한 지점을 try 블록에 집어 넣는다, 그리고 둘째로 : 파이썬에게 ValueError들을 다루는 법을 가르쳐 준다.
다음의 프로그램이 이 일을 한다.

print "Type Control C or -1 to exit"
number = 1
while number != -1:
    try:
        number = int(raw_input("Enter a number: "))
        print "You entered: ",number
    except ValueError:
        print "That was not a number."

이제 우리가 새로운 프로그램을 실행하고 거기에다 @#&를 주면 프로그램은 우리에게 ``That was not a number.''라고 말해주고서는 그전에 자신이 하던 작업을 계속한다.

여러분의 프로그램이 어떤 에러들을 계속 가지고 있고 여러분이 다루는 법을 알고 있다면, try 블록에 코드를 집어 넣어라, 그리고 그 에러를 처리하는 방법을 except블록에 집어 넣어라.

파일 입출력

#Write a file
out_file = open("test.txt","w")
out_file.write("This Text is going to out file\nLook at it and see\n")
out_file.close()

#Read a file
in_file = open("test.txt","r")
text = in_file.read()
in_file.close()

print text,

This Text is going to out file
Look at it and see

파일 입출력의 개요는 다음과 같다.:

1. open 함수로 파일 객체를 가져온다.
2. 그 파일 객체에 대하여 (어떤 상태로 열렸느냐에 따라) 읽기 또는 쓰기를 한다.
3. 그것을 닫는다.

첫째 단계는 파일객체를 획득하는 것이다. 이것을 하는 방법은 open 함수를 사용하는 것이다. 그 형식은 file_object = open(filename,mode)이며 file_object 는 파일 객체를 담을 변수이다, filename 화일이름을 나타내는 문자열이며, mode 는 "r"로 읽기(read)를, "w" 로 쓰기(w) 를 나타낸다. 다음으로 그 파일 객체의 함수는 호출될 수 있다. 두개의 가장 일반적인 함수는 read 와 write 이다. write 함수는 문자열을 파일의 끝에다가 추가한다. read 함수는 파일에서 다음의 것을 읽는다 그리고 그것을 문자열로 반환한다. 만일 아무런 인수도 주어지지 않는다면 그것은 (이 예제에서 실행된 것 같이) 전체 화일을 반환할 것이다.

이제 여기에 우리가 이전에 만들었던 전화 번호 프로그램의 새로운 버전이 있다:

import string

def print_numbers(numbers):
    print "Telephone Numbers:"
    for x in numbers.keys():
        print "Name: ",x," \tNumber: ",numbers[x]
    print

def add_number(numbers,name,number):
    numbers[name] = number

def lookup_number(numbers,name):
    if numbers.has_key(name):
        return "The number is "+numbers[name]
    else:
        return name+" was not found"

def remove_number(numbers,name):
    if numbers.has_key(name):
        del numbers[name]
    else:
        print name," was not found"


def load_numbers(numbers,filename):
    in_file = open(filename,"r")
    while 1:
        in_line = in_file.readline()
        if in_line == "":
            break
        in_line = in_line[:-1]
        [name,number] = string.split(in_line,",")
        numbers[name] = number
    in_file.close()

def save_numbers(numbers,filename):
    out_file = open(filename,"w")
    for x in numbers.keys():
        out_file.write(x+","+numbers[x]+"\n")
    out_file.close()


def print_menu():
    print '1. Print Phone Numbers'
    print '2. Add a Phone Number'
    print '3. Remove a Phone Number'
    print '4. Lookup a Phone Number'
    print '5. Load numbers'
    print '6. Save numbers'
    print '7. Quit'
    print

phone_list = {}
menu_choice = 0
print_menu()
while menu_choice != 7:
    menu_choice = input("Type in a number (1-7):")
    if menu_choice == 1:
        print_numbers(phone_list)
    elif menu_choice == 2:
        print "Add Name and Number"
        name = raw_input("Name:")
        phone = raw_input("Number:")
        add_number(phone_list,name,phone)
    elif menu_choice == 3:
        print "Remove Name and Number"
        name = raw_input("Name:")
        remove_number(phone_list,name)
    elif menu_choice == 4:
        print "Lookup Number"
	name = raw_input("Name:")
        print lookup_number(phone_list,name)
    elif menu_choice == 5:
        filename = raw_input("Filename to load:")
        load_numbers(phone_list,filename)
    elif menu_choice == 6:
        filename = raw_input("Filename to save:")
        save_numbers(phone_list,filename)
    elif menu_choice == 7:
        pass
    else:
        print_menu()
print "Goodbye"

> python tele2.py
1. Print Phone Numbers
2. Add a Phone Number
3. Remove a Phone Number
4. Lookup a Phone Number
5. Load numbers
6. Save numbers
7. Quit

Type in a number (1-7):2
Add Name and Number
Name:Jill
Number:1234
Type in a number (1-7):2
Add Name and Number
Name:Fred
Number:4321
Type in a number (1-7):1
Telephone Numbers:
Name:  Jill     Number:  1234
Name:  Fred     Number:  4321

Type in a number (1-7):6
Filename to save:numbers.txt
Type in a number (1-7):7
Goodbye

> python tele2.py
1. Print Phone Numbers
2. Add a Phone Number
3. Remove a Phone Number
4. Lookup a Phone Number
5. Load numbers
6. Save numbers
7. Quit

Type in a number (1-7):5
Filename to load:numbers.txt
Type in a number (1-7):1
Telephone Numbers:
Name:  Jill     Number:  1234
Name:  Fred     Number:  4321

Type in a number (1-7):7
Goodbye

이 프로그램의 새로운 부분은 다음과 같다:

def load_numbers(numbers,filename):
    in_file = open(filename,"r")
    while 1:
        in_line = in_file.readline()
        if len(in_line) == 0:
            break
        in_line = in_line[:-1]
        [name,number] = string.split(in_line,",")
        numbers[name] = number
    in_file.close()

def save_numbers(numbers,filename):
    out_file = open(filename,"w")
    for x in numbers.keys():
        out_file.write(x+","+numbers[x]+"\n")
    out_file.close()

먼저 우리는 그 프로그램에서 저장하는 부분을 살펴 볼 것이다. 먼저 그것은 open(filename,"w") 명령어로 파일 객체를 생성한다. 다음으로 그것은 전화번호들 각각을 위하여 'out_file.write(x+","+numbers[x]+"\n")' 명령어로 하나의 라인을 생성해 나간다. 이것은 이름, 컴마, 전화번호를 포함하는 하나의 라인을 출력하고 다음에 새로운 라인이 출력된다.

읽어들이는 부분은 약간은 더 복잡하다. 그것은 파일 객체를 획득하는 것으로 시작한다. 그리고 그것은 break서술문을 만날 때까지 회돌이를 유지하기 위하여 'while 1:'을 사용한다. 다음으로 in_line = in_file.readline()라는 코드로 한 라인을 읽어 들인다. getline함수는 파일의 끝에 다다르면 빈 문자열(len(string) == 0)을 반환할 것이다. if 서술문은 이것을 점검해서 만일 그런 일이 일어난다면 while회돌이를 빠져나온다. 물론 readline 함수가 새로운라인 문자를 그 라인의 끝에서 반환하지 않았다면 빈 문자열이 빈 라인인지 혹은 파일의 마지막인지 말해줄 방법이 없으므로 새로운라인 문자는 getline 이 반환해준 곳에 남는다.

그러므로 우리는 그 새로운라인 문자를 제거해야 한다. in_line = in_line[:-1] 라인은 우리를 위하여 마지막 문자를 제거 함으로써 이일을 해준다. 다음의 [name,number] = string.split(in_line,",") 라인은 컴마위치에서 이름과 전화번호로 그 라인을 분할한다. 그리고나서 이것은 numbers 사전에 등록된다.

문자열의 복수

이제 문자열로 할수 있는 기가 막힌 꼼수하나를 보이겠다.:

def shout(string):
    for character in string:
        print "Gimme a "+character
        print "'"+character+"'"

shout("Lose")

def middle(string):
    print "The middle character is:",string[len(string)/2]

middle("abcdefg")
middle("The Python Programming Language")
middle("Atlanta")

그 출력은 다음과 같다:

Gimme a L
'L'
Gimme a o
'o'
Gimme a s
's'
Gimme a e
'e'
The middle character is: d
The middle character is: r
The middle character is: a

다음의 사양은 문자열의 어떤 특별한 사양을 보여준다:

def to_upper(string):
    ## Converts a string to upper case
    upper_case = ""
    for character in string:
        if 'a' <= character <= 'z':
            location = ord(character) - ord('a')
            new_ascii = location + ord('A')
            character = chr(new_ascii)
        upper_case = upper_case + character
    return upper_case

print to_upper("This is Text")

THIS IS TEXT

이제 더 짧은 타이핑 연습을 위해 :

print "Integer to String"
print repr(2)
print repr(23445)
print repr(-23445)
print "String to Integer"
print int("14234")
print int("12345")
print int("-3512")
print "Float to String"
print repr(234.423)
print repr(62.562)
print repr(-134.5660)
print "Float to Integer"
print int(51.523)
print int(224.63)
print int(-1234.562)

친숙하게 보이는 출력은 다음과 같다:

Integer to String
2
23445
-23445
String to Integer
14234
12345
-3512
Float to String
234.423
62.562
-134.566
Float to Integer
51
224
-1234

여러분이 아직까지 이해가 가지 않는다면 (역주: 가르쳐 주면) repr 함수가 정수를 문자열로, int함수가 문자열을 정수로 변환할수 있다. repr 함수는 어떤 것의 출력가능한 형태를 돌려준다. 여기에 이러한 약간의 예가 있다:

>>> repr(1)
'1'
>>> repr(234.14)
'234.14'
>>> repr([4,42,10])
'[4, 42, 10]'

>>> v=eval('123')
>>> print v,type(v)
123 <type 'int'>  <- 정수형
>>> v=eval('645.123')
>>> print v,type(v)
645.123 <type 'float'>  <- 소수형
>>> v=eval('[1,2,3]')
>>> print v,type(v)
[1, 2, 3] <type 'list'> <- 리스트형

하나의 유용한 문자열 함수는 split 함수이다. 여기에 예가 있다:

>>> import string
>>> string.split("This is a bunch of words")
['This', 'is', 'a', 'bunch', 'of', 'words']
>>> string.split("First batch, second batch, third, fourth",",")
['First batch', ' second batch', ' third', ' fourth']

예 제

#This program requires a excellent understanding of decimal numbers
def to_string(in_int):
    "Converts an integer to a string"
    out_str = ""
    prefix = ""
    if in_int < 0:
        prefix = "-"
        in_int = -in_int
    while in_int / 10 != 0:
        out_str = chr(ord('0')+in_int % 10) + out_str
        in_int = in_int / 10
    out_str = chr(ord('0')+in_int % 10) + out_str
    return prefix + out_str

def to_int(in_str):
    "Converts a string to an integer"
    out_num = 0
    if in_str[0] == "-":
        multiplier = -1
        in_str = in_str[1:]
    else:
        multiplier = 1
    for x in range(0,len(in_str)):
        out_num = out_num * 10 + ord(in_str[x]) - ord('0')
    return out_num * multiplier

print to_string(2)
print to_string(23445)
print to_string(-23445)
print to_int("14234")
print to_int("12345")
print to_int("-3512")

2
23445
-23445
14234
12345
-3512

리스트에 대하여 더 자세히

여기에 지표를 사용하여 리스트의 구성요소에 접근하는 약간의 예제가 있다:

>>> list = ['zero','one','two','three','four','five']
>>> list[0]
'zero'
>>> list[4]
'four'
>>> list[5]
'five'

>>> list[len(list)-1]
'five'
>>> list[len(list)-2]
'four'
>>> list[-1]
'five'
>>> list[-2]
'four'
>>> list[-6]
'zero'

리스트의 부분으로 들어가는 또 다른 유용한 방법은 썰기이다. 여기에 여러분에게 썰기가 무엇에 유용한지 아이디어를 제공하는 또 다른 예제가 있다.:

>>> list = [0,'Fred',2,'S.P.A.M.','Stocking',42,"Jack","Jill"]
>>> list[0]
0
>>> list[7]
'Jill'
>>> list[0:8]
[0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, 'Jack', 'Jill']
>>> list[2:4]
[2, 'S.P.A.M.']
>>> list[4:7]
['Stocking', 42, 'Jack']
>>> list[1:5]
['Fred', 2, 'S.P.A.M.', 'Stocking']

>>> list[-4:-2]
['Stocking', 42]
>>> list[-4]
'Stocking'
>>> list[-4:6]
['Stocking', 42]

>>> list[:2]
[0, 'Fred']
>>> list[-2:]
['Jack', 'Jill']
>>> list[:3]
[0, 'Fred', 2]
>>> list[:-5]
[0, 'Fred', 2]

poem = ["<B>","Jack","and","Jill","</B>","went","up","the","hill","to","<B>",\
"fetch","a","pail","of","</B>","water.","Jack","fell","<B>","down","and",\
"broke","</B>","his","crown","and","<B>","Jill","came","</B>","tumbling",\
"after"]

def get_bolds(list):
        true = 1
        false = 0
        ## is_bold tells whether or not the we are currently looking at
        ## a bold section of text.
        is_bold = false
        ## start_block is the index of the start of either an unbolded
        ## segment of text or a bolded segment.
        start_block = 0
        for index in range(len(list)):
                ##Handle a starting of bold text
                if list[index] == "<B>":
                        if is_bold:
                                print "Error:  Extra Bold"
                        ##print "Not Bold:",list[start_block:index]
                        is_bold = true
                        start_block = index+1
                ##Handle end of bold text
                if list[index] == "</B>":
                        if not is_bold:
                                print "Error: Extra Close Bold"
                        print "Bold [",start_block,":",index,"] ",\
                        list[start_block:index]
                        is_bold = false
                        start_block = index+1

get_bolds(poem)

Bold [ 1 : 4 ]  ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ]  ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ]  ['down', 'and', 'broke']
Bold [ 28 : 30 ]  ['Jill', 'came']

get_bold함수는 하나의 리스트를 불러들여 단어와 토큰으로 분리한다. 그 함수가 찾는 토큰은 굵은 글씨체의 시작을 나타내는 '<B>'와 굵은 글씨체의 마지막을 나타내는 ' <\B>' 이다. 그 함수 get_bold는 진행하면서 처음과 마지막 토큰을 탐색한다.

리스트의 다음 사양은 그들을 복사하는 것이다. 여러분이 다음과 같이 간단한 어떤 것을 시도해 본다면:

>>> a = [1,2,3]
>>> b = a
>>> print b
[1, 2, 3]
>>> b[1] = 10
>>> print b
[1, 10, 3]
>>> print a
[1, 10, 3]

>>> a = [1,2,3]
>>> b = a
>>> b = b*2
>>> print a
[1, 2, 3]
>>> print b
[1, 2, 3, 1, 2, 3]

리스트를 복사하는 여러 방법들이 있다. 대부분의 경우에 있어서 잘 작동하는 가장 간단한 것은 썰기(slice) 연산자이다:

>>> a = [1,2,3]
>>> b = a[:]
>>> b[1] = 10
>>> print a
[1, 2, 3]
>>> print b
[1, 10, 3]

>>> import copy
>>> a = [[1,2,3],[4,5,6]]
>>> b = a[:]
>>> c = copy.deepcopy(a)
>>> b[0][1] = 10
>>> c[1][1] = 12
>>> print a
[[1, 10, 3], [4, 5, 6]]
>>> print b
[[1, 10, 3], [4, 5, 6]]
>>> print c
[[1, 2, 3], [4, 12, 6]]

지금까지 여러분은 아마도 왜 참조가 사용되는지 도대체 이해가 안갈 것이다? 기본적인 이유는 속력 때문이다. 수천의 요소들 모두를 복사하는 것 보다는 그것들을 참조하는 편이 훨씬 더 빠르다. 그러지 않아야 할때 데이타가 변하는 괴이한 문제를 여러분이 가지더라도 참조에 관하여 여러분은 단지 이 사실만은 기억하라.

모듈을 사용하기

import calendar

year = input("Type in the year number:")
calendar.prcal(year)

Type in the year number:2001
                                  2001                                  

       January                  February                    March       
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
 1  2  3  4  5  6  7                1  2  3  4                1  2  3  4     
 8  9 10 11 12 13 14       5  6  7  8  9 10 11       5  6  7  8  9 10 11     
15 16 17 18 19 20 21      12 13 14 15 16 17 18      12 13 14 15 16 17 18     
22 23 24 25 26 27 28      19 20 21 22 23 24 25      19 20 21 22 23 24 25     
29 30 31                  26 27 28                  26 27 28 29 30 31

from calendar import prcal

year = input("Type in the year number:")
prcal(year)

from time import time, ctime

prev_time = ""
while(1):
    the_time = ctime(time())
    if(prev_time != the_time):
        print "The time is:",ctime(time())
        prev_time = the_time

The time is: Sun Aug 20 13:40:04 2000
The time is: Sun Aug 20 13:40:05 2000
The time is: Sun Aug 20 13:40:06 2000
The time is: Sun Aug 20 13:40:07 2000
Traceback (innermost last):
  File "clock.py", line 5, in ?
    the_time = ctime(time())
KeyboardInterrupt

파이썬 라이브러리는 많은 유용한 함수들을 담고 있다. 이러한 함수들로 여러분의 프로그램은 더욱 더 능력을 갖게되고 그들중의 많은 것들은 파이썬에서의 프로그래밍을 쉽게 한다.

사 전

def print_menu():
    print '1. Print Phone Numbers'
    print '2. Add a Phone Number'
    print '3. Remove a Phone Number'
    print '4. Lookup a Phone Number'
    print '5. Quit'
    print
numbers = {}
menu_choice = 0
print_menu()
while menu_choice != 5:
    menu_choice = input("Type in a number (1-5):")
    if menu_choice == 1:
        print "Telephone Numbers:"
        for x in numbers.keys():
            print "Name: ",x," \tNumber: ",numbers[x]
        print
    elif menu_choice == 2:
        print "Add Name and Number"
        name = raw_input("Name:")
        phone = raw_input("Number:")
        numbers[name] = phone
    elif menu_choice == 3:
        print "Remove Name and Number"
        name = raw_input("Name:")
        if numbers.has_key(name):
            del numbers[name]
        else:
            print name," was not found"
    elif menu_choice == 4:
        print "Lookup Number"
        name = raw_input("Name:")
        if numbers.has_key(name):
            print "The number is",numbers[name]
        else:
            print name," was not found"
    elif menu_choice != 5:
        print_menu()

1. Print Phone Numbers
2. Add a Phone Number
3. Remove a Phone Number
4. Lookup a Phone Number
5. Quit

Type in a number (1-5):2
Add Name and Number
Name:Joe
Number:545-4464
Type in a number (1-5):2
Add Name and Number
Name:Jill
Number:979-46^H54
Type in a number (1-5):2
Add Name and Number
Name:Fred
Number:132-9874
Type in a number (1-5):1
Telephone Numbers:
Name:  Jill     Number:  979-454
Name:  Joe      Number:  545-4464
Name:  Fred     Number:  132-9874

Type in a number (1-5):4
Lookup Number
Name:Joe
The number is 545-4464
Type in a number (1-5):3
Remove Name and Number
Name:Fred
Type in a number (1-5):1
Telephone Numbers:
Name:  Jill     Number:  979-454
Name:  Joe      Number:  545-4464

Type in a number (1-5):5

for x in numbers.keys():
    print "Name: ",x," \tNumber: ",numbers[x]

if numbers.has_key(name):
    del numbers[name]

if numbers.has_key(name):
    print "The number is",numbers[name]

요 약: 사전은 키와 값들을 가진다. 키는 문자열 혹은 숫자일 수 있다. 키는 값을 지시한다. 값은 어떠한 형태의 변수라도 가능하다.(리스트 혹은 사전까지도 포함하여 (그러한 사전이나 리스트는 물론 사전이나 리스트 자신들을 포함할 수 있다.( 거의 맞겄지요?:)) 여기에 사전에서 리스트를 사용하는 예제 하나가 있다:

max_points = [25,25,50,25,100]
assignments = ['hw ch 1','hw ch 2','quiz   ','hw ch 3','test']
students = {'#Max':max_points}

def print_menu():
    print "1. Add student"
    print "2. Remove student"
    print "3. Print grades"
    print "4. Record grade"
    print "5. Print Menu"
    print "6. Exit"

def print_all_grades():
        print '\t',
        for i in range(len(assignments)):
            print assignments[i],'\t',
        print
        keys = students.keys()
        keys.sort()
        for x in keys:
            print x,'\t',
            grades = students[x]
            print_grades(grades)

def print_grades(grades):
    for i in range(len(grades)):
        print grades[i],'\t\t',
    print

print_menu()
menu_choice = 0
while menu_choice != 6:
    print
    menu_choice = input("Menu Choice (1-6):")
    if menu_choice == 1:
        name = raw_input("Student to add:")
        students[name] = [0]*len(max_points)
    elif menu_choice == 2:
        name = raw_input("Student to remove:")
        if students.has_key(name):
            del students[name]
        else:
            print "Student: ",name," not found"
    elif menu_choice == 3:
        print_all_grades()

    elif menu_choice == 4:
        print "Record Grade"
        name = raw_input("Student:")
        if students.has_key(name):
            grades = students[name]
            print "Type in the number of the grade to record"
            print "Type a 0 (zero) to exit"
            for i in range(len(assignments)):
                print i+1,' ',assignments[i],'\t',
            print
            print_grades(grades)
            which = 1234
            while which != -1:
                which = input("Change which Grade:")
                which = which-1
                if 0 <= which < len(grades):
                    grade = input("Grade:")
                    grades[which] = grade
                elif which != -1:
                    print "Invalid Grade Number"
        else:
            print "Student not found"
    elif menu_choice != 6:
        print_menu()

1. Add student
2. Remove student
3. Print grades
4. Record grade
5. Print Menu
6. Exit

Menu Choice (1-6):3
        hw ch 1         hw ch 2         quiz            hw ch 3         test
#Max    25              25              50              25              100

Menu Choice (1-6):6
1. Add student
2. Remove student
3. Print grades
4. Record grade
5. Print Menu
6. Exit

Menu Choice (1-6):1
Student to add:Bill

Menu Choice (1-6):4
Record Grade
Student:Bill
Type in the number of the grade to record
Type a 0 (zero) to exit
1   hw ch 1     2   hw ch 2     3   quiz        4   hw ch 3     5   test
0               0               0               0               0
Change which Grade:1
Grade:25
Change which Grade:2
Grade:24
Change which Grade:3
Grade:45
Change which Grade:4
Grade:23
Change which Grade:5
Grade:95
Change which Grade:0

Menu Choice (1-6):3
        hw ch 1         hw ch 2         quiz            hw ch 3         test
#Max    25              25              50              25              100
Bill    25              24              45              23              95

Menu Choice (1-6):6

def print_all_grades():
        print '\t',
        for i in range(len(assignments)):
            print assignments[i],'\t',
        print
        keys = students.keys()
        keys.sort()
        for x in keys:
            print x,'\t',
            grades = students[x]
            print_grades(grades)

부울 표현식

a = 6
b = 7
c = 42
print 1, a == 6
print 2, a == 7
print 3,a == 6 and b == 7
print 4,a == 7 and b == 7
print 5,not a == 7 and b == 7
print 6,a == 7 or b == 7
print 7,a == 7 or b == 6
print 8,not (a == 7 and b == 6)
print 9,not a == 7 and b == 6

1 1
2 0
3 1
4 0
5 1
6 1
7 0
8 1
9 0

print 1, a == 6
print 2, a == 7

첫번째 표현식이 거짓이라면 전체 표현식이 거짓이라는 것을 알고 있으므로 파이썬은 바로 다음의 표현식을 점검하지 않는다는 것을 주목하라.

다음 라인, 'print 5,not a == 7 and b == 7' 은 not 연산자를 사용한다. not 은 단지 그 표현식의 반대값을 준다. (그 표현식은 'print 5,a != 7 and b == 7' 와 같이 다시 씌여질 수 있다.)
여기에 그 표를 보인다:

다음의 두 라인, 'print 6,a == 7 or b == 7' 그리고 'print 7,a == 7 or b == 6' 는 or 연산자를 사용한다. or 연산자는 첫 번째 표현식이 참이거나, 혹은 두 번째 표현식이 참이거나 아니면 둘 다 참이라면 참을 반환한다. 양자의 표현식 모두가 참이 아니라면 거짓을 반환한다. 여기에 그 표가 있다:

첫 번째 표현식이 참이라면 파이썬은 전체 표현식이 참이라는 것을 알고 있으므로 그 다음 두 번째의 표현식을 점검하지 않는다. 적어도 표현식의 절반이 참이라면 or문은 참이므로 이것은 작동한다. 첫번째 부분은 참이고 그리고 두 번째 부분은 참이거나 거짓일 수 있지만, 그러나 전체 표현식은 여전히 참이다.

다음의 두 라인, 'print 8,not (a == 7 and b == 6)' 그리고 'print 9,not a == 7 and b == 6'을 보면 괄호가 사용되어 표현식을 무리를 지을수 있으며 한 부분을 먼저 평가하도록 강제할 수 있다. 괄호가 표현식을 거짓에서 참으로 변경하였음을 주목하라. 이러한 일이 일어난 것은 괄호때문에 not 연산자가 'a == 7'라는 부분대신에 전체 표현식에 적용되었기 때문이다.

여기에 부울 표현식을 사용한 예제가 하나 있다:

list = ["Life","The Universe","Everything","Jack","Jill","Life","Jill"]

#make a copy of the list
copy = list[:]
#sort the copy
copy.sort()
prev = copy[0]
del copy[0]

count = 0

#go through the list searching for a match
while count < len(copy) and copy[count] != prev:
    prev = copy[count]
    count = count + 1

#If a match was not found then count can't be < len
#since the while loop continues while count is < len
#and no match is found
if count < len(copy):
    print "First Match: ",prev

그리고 여기에 출력이 있다:

First Match:  Jill

이 프로그램은 while count < len(copy and copy[count] 인 동안 계속하여 일치 여부를 점검한다.
count가 copy의 마지막 지표보다 크거나 일치가 발견되면 and 는 더 이상 참이 아니므로 루프를 빠져나온다. if 문은 while문이 일치가 발견되었기 때문에 빠져 나간것이 확실한지를 단순히 점검한다.

and의 또 다른 트릭이 이 예제에서 사용된다. 여러분은 and 테이블을 볼 때 세번째 항목이 ``false and won't check''임을 주목하라. 만약 count >= len(copy) (다른 말로 count < len(copy)이 거짓이) 라면 그러면 copy[count] 전혀 참조되지 않는다. 이것은 첫번째가 거짓이면 그러면 그들 둘은 참일수가 없다는 것을 파이썬이 알기 때문이다. 이것은 '짧은 회로'의 하나로 알려져 있는데 무엇인가 잘못되어서 and의 두번째 부분이 에러를 야기할 때 유용하게 쓰인다. count가 copy에 대하여 유효한 지표였는지를 점검하기 위하여 나는 첫 번째 표현식 (count < len(copy)) 을 사용하였다. (믿지 못하겠다면 `Jill' 과 `Life' 의 일치를 제거하고, 그것이 여전히 잘 작동하는가를 점검하라 그리고 count < len(copy) and copy[count] != prev의 순서를 copy[count] != prev and count < len(copy)로 뒤집어보라.)

부울 표현식은 여러분이 두개 이상의 다른 값들을 한 번에 점검하고자 할때 사용될 수 있다.

For 회돌이

onetoten = range(1,11)
for count in onetoten:
        print count

1
2
3
4
5
6
7
8
9
10

for count in range(1,11):
        print count

>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(-32, -20)
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> range(5,21)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> range(21,5)
[]

demolist = ['life',42, 'the universe', 6,'and',7,'everything']
for item in demolist:
    print "The Current item is:",
    print item

The Current item is: life
The Current item is: 42
The Current item is: the universe
The Current item is: 6
The Current item is: and
The Current item is: 7
The Current item is: everything

l = [2,4,6,8]
sum = 0
for num in l:
        sum = sum + num
print "The sum is: ",sum

The sum is:  20

l = [4, 5, 7, 8, 9, 1,0,7,10]
l.sort()
prev = l[0]
del l[0]
for item in l:
        if prev == item:
                print "Duplicate of ",prev," Found"
        prev = item

Duplicate of  7  Found

l = [4, 5, 7, 8, 9, 1,0,7,10]
print "l = [4, 5, 7, 8, 9, 1,0,7,10]","\tl:",l
l.sort()
print "l.sort()","\tl:",l
prev = l[0]
print "prev = l[0]","\tprev:",prev
del l[0]
print "del l[0]","\tl:",l
for item in l:
        if prev == item:
                print "Duplicate of ",prev," Found"
        print "if prev == item:","\tprev:",prev,"\titem:",item
        prev = item
        print "prev = item","\t\tprev:",prev,"\titem:",item

l = [4, 5, 7, 8, 9, 1,0,7,10]   l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()        l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
prev = l[0]     prev: 0
del l[0]        l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item:        prev: 0         item: 1
prev = item             prev: 1         item: 1
if prev == item:        prev: 1         item: 4
prev = item             prev: 4         item: 4
if prev == item:        prev: 4         item: 5
prev = item             prev: 5         item: 5
if prev == item:        prev: 5         item: 7
prev = item             prev: 7         item: 7
Duplicate of  7  Found
if prev == item:        prev: 7         item: 7
prev = item             prev: 7         item: 7
if prev == item:        prev: 7         item: 8
prev = item             prev: 8         item: 8
if prev == item:        prev: 8         item: 9
prev = item             prev: 9         item: 9
if prev == item:        prev: 9         item: 10
prev = item             prev: 10        item: 10

for 회돌이를 사용하는 또 다른 방법은 일정한 횟수의 작업을 하는 것이다. 여기에 피보나치 수열의 앞부분 9개의(주의:원본에는 11로 되어 있음) 숫자를 출력하는 코드가 있다:

a = 1
b = 1
for c in range(1,10):
        print a,
        n = a + b
        a = b
        b = n

1 1 2 3 5 8 13 21 34

리스트

하나 이상의 값을 가지는 변수

which_one = input("What month (1-12)? ")
months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',\
	'August', 'September', 'October', 'November', 'December']
if 1 <= which_one <= 12:
        print "The month is",months[which_one - 1]

그리고 출력의 예는 다음과 같다:

What month (1-12)? 3
The month is March

이 예에서 months가 리스트이다. months는 라인 months = ['January', 'February', 'March', 'April', 'May', 'June', 'July',\ 'August', 'September', 'October', 'November', 'December']로 정의 된다. (\가 기다란 라인을 나누는데 사용될 수 있음을 주목하라.) [ 와 ]는 각각 시작과 끝이며 컴마(``,'')로 리스트의 항목들을 분리한다. 리스트는 'months[which_one - 1]'에서 사용된다. 리스트는 0에서 시작하는 항목들로 구성된다. 다른 말로 하면, 여러분이 1월달을 원한다면 여러분은 months[0]를 사용할 수 있다. 리스트에 숫자 하나를 주어라 그러면 그 위치에 저장된 값을 돌려 줄 것이다.

서술문 'if 1 <= which_one <= 12:'는 which_one이 1과 12 사이에 포함될 때만 오직 참이 될 것이다. (다른 말로 하면, 여러분이 대수학에서 그것을 보았다면 당연히 그것이 여러분이 예상한 바이다.).

리스트를 일련의 상자로 생각할 수도 있다. 예를 들어, 'demolist = ['life',42, 'the universe', 6,'and',7]'에 의하여 생성되어진 상자들은 다음과 같이 보일 것이다:

각 상자들은 그 숫자에 의해 참조되어서 서술문 demolist[0]는 'life'를, demolist[1]은 42를 획득하게 되고, 그런식으로 demolist[5]는 7를 획득하게 된다.

리스트의 더 자세한 사양

demolist = ['life',42, 'the universe', 6,'and',7]
print 'demolist = ',demolist
demolist.append('everything')
print "after 'everything' was appended demolist is now:"
print demolist
print 'len(demolist) =', len(demolist)
print 'demolist.index(42) =',demolist.index(42)
print 'demolist[1] =', demolist[1]
#Next we will loop through the list
c = 0
while c < len(demolist):
    print 'demolist[',c,']=',demolist[c]
    c = c + 1
del demolist[2]
print "After 'the universe' was removed demolist is now:"
print demolist
if 'life' in demolist:
    print "'life' was found in demolist"
else:
    print "'life' was not found in demolist"
if 'amoeba' in demolist:
    print "'amoeba' was found in demolist"
if 'amoeba' not in demolist:
    print "'amoeba' was not found in demolist"
demolist.sort()
print 'The sorted demolist is ',demolist

그 출력은 다음과 같다:

demolist =  ['life', 42, 'the universe', 6, 'and', 7]
after 'everything' was appended demolist is now:
['life', 42, 'the universe', 6, 'and', 7, 'everything']
len(demolist) = 7
demolist.index(42) = 1
demolist[1] = 42
demolist[ 0 ]= life
demolist[ 1 ]= 42
demolist[ 2 ]= the universe
demolist[ 3 ]= 6
demolist[ 4 ]= and
demolist[ 5 ]= 7
demolist[ 6 ]= everything
After 'the universe' was removed demolist is now:
['life', 42, 6, 'and', 7, 'everything']
'life' was found in demolist
'amoeba' was not found in demolist
The sorted demolist is  [6, 7, 42, 'and', 'everything', 'life']

이 예제는 새로운 함수를 무더기로 사용하고 있다. 여러분은 전체 리스트를 단지 출력 print할 수만 있음을 주의하라. 다음으로 append 함수는 리스트의 끝이 새로운 항목 하나를 더하는데 사용되어진다. len 함수는 리스트에 얼마나 많은 항목이 있는지를 돌려준다. The index 함수는 항목의 위치가 리스트에서 어디인지를 말해준다. 'demolist.index(42)' 가 1을 돌려주고 demolist[1] 가 실행되면 42를 돌려준다는 것을 주목하라. '#Next we will loop through the list'라인은 프로그래머에게는 단지 여분이다( 또한 주석이라고도 부른다). 파이썬은 #로 시작하는 모든 라인을 무시할 것이다. 다음의 라인은 :

c = 0
while c < len(demolist):
    print 'demolist[',c,']=',demolist[c]
    c = c + 1

del명령어는 리스트에서 주어진 요소를 제거하는데에 사용된다. 다음의 라인 몇줄은 in 연산자를 사용하여 하나의 요소가 리스트에 포함되었는지 아닌지를 테스트한다.

이 예제는 이러한 사양을 더 유용하게 사용한다:

menu_item = 0
list = []
while menu_item != 9:
        print "--------------------"
        print "1. Print the list"
        print "2. Add a name to the list"
        print "3. Remove a name from the list"
        print "4. Change an item in the list"
        print "9. Quit"
        menu_item = input("Pick an item from the menu: ")
        if menu_item == 1:
                current = 0
                if len(list) > 0:
                        while current < len(list):
                                print current,". ",list[current]
                                current = current + 1
                else:
                        print "List is empty"
        elif menu_item == 2:
                name = raw_input("Type in a name to add: ")
                list.append(name)
        elif menu_item == 3:
                del_name = raw_input("What name would you like to remove: ")
                if del_name in list:
                        item_number = list.index(del_name)
                        del list[item_number]
                else:
                        print del_name," was not found"
        elif menu_item == 4:
                old_name = raw_input("What name would you like to change: ")
                if old_name in list:
                        item_number = list.index(old_name)
                        new_name = raw_input("What is the new name: ")
                        list[item_number] = new_name
                else:
                        print old_name," was not found"
print "Goodbye"

그리고 여기에 출력의 일부가 있다:

--------------------
1. Print the list
2. Add a name to the list
3. Remove a name from the list
4. Change an item in the list
9. Quit

Pick an item from the menu: 2
Type in a name to add: Jack

Pick an item from the menu: 2
Type in a name to add: Jill

Pick an item from the menu: 1
0 .  Jack
1 .  Jill

Pick an item from the menu: 3
What name would you like to remove: Jack

Pick an item from the menu: 4
What name would you like to change: Jill
What is the new name: Jill Peters

Pick an item from the menu: 1
0 .  Jill Peters

Pick an item from the menu: 9
Goodbye

긴 프로그램이다. 소스코드를 한번 살펴보자. 라인 'list = []'는 변수list를 아무런 항목(혹은 요소)도 같지 않는 리스트로 만든다. 다음의 중요한 라인은 while menu_item != 9:이다. 이 라인은 이 프로그램을 위한 메뉴시스템을 가능하게 해주는 회돌이를 시작한다. 다음의 라인 몇개는 메뉴를 보여주고, 프로그램의 어떤 부분이 실행될지를 결정한다.

다음의 코드는 :

current = 0
if len(list) > 0:
        while current < len(list):
                print current,". ",list[current]
                current = current + 1
else:
        print "List is empty"

그리고 나서 몇개의 라인 뒤에 서술문 'list.append(name)'가 나타난다. 그것은 append함수를 사용하여 리스트의 끝에다가 한개의 항목을 추가한다. 아래의 두개 라인으로 점프하라. 이 코드의 부분은 다음과 같다:

item_number = list.index(del_name)
del list[item_number]

다음 부분은 :

old_name = raw_input("What name would you like to change: ")
if old_name in list:
        item_number = list.index(old_name)
        new_name = raw_input("What is the new name: ")
        list[item_number] = new_name
else:
        print old_name," was not found"

예제들

test.py

## This program runs a test of knowledge

true = 1
false = 0

# First get the test questions
# Later this will be modified to use file io.
def get_questions():
    # notice how the data is stored as a list of lists
    return [["What color is the daytime sky on a clear day?","blue"],\
            ["What is the answer to life, the universe and everything?","42"],\
            ["What is a three letter word for mouse trap?","cat"]]

# This will test a single question
# it takes a single question in
# it returns true if the user typed the correct answer, otherwise false
def check_question(question_and_answer):
    #extract the question and the answer from the list
    question = question_and_answer[0]
    answer = question_and_answer[1]
    # give the question to the user
    given_answer = raw_input(question)
    # compare the user's answer to the testers answer
    if answer == given_answer:
        print "Correct"
        return true
    else:
        print "Incorrect, correct was:",answer
        return false

# This will run through all the questions
def run_test(questions):
    if len(questions) == 0:
        print "No questions were given."
        # the return exits the function
        return
    index = 0
    right = 0
    while index < len(questions):
        #Check the question
        if check_question(questions[index]):
            right = right + 1
        #go to the next question
        index = index + 1
    #notice the order of the computation, first multiply, then divide
    print "You got ",right*100/len(questions),"% right out of",len(questions)

#now lets run the questions
run_test(get_questions())

샘플 출력은 다음과 같다:

What color is the daytime sky on a clear day?green
Incorrect, correct was: blue
What is the answer to life, the universe and everything?42
Correct
What is a three letter word for mouse trap?cat
Correct
You got  66 % right out of 3

함수를 정의하기

함수를 생성하기

a = 23
b = -23

if a < 0:
    a = -a

if b < 0:
    b = -b

if a == b:
    print "The absolute values of", a,"and",b,"are equal"
else:
    print "The absolute values of a and b are different"

The absolute values of 23 and 23 are equal

a = 23
b = -23

def abs(num):
    if num < 0:
        num = -num
    return num

if abs(a) == abs(b):
    print "The absolute values of", a,"and",b,"are equal"
else:
    print "The absolute values of a and b are different"

The absolute values of 23 and -23 are equal

a 와 b의 값이 변하지 않았음을 주목하라. 함수는 물론 반환값을 가지지 않는 작업을 반복하는 데에도 쓰여질 수 있다. 여기에 예를 들면:

def hello():
    print "Hello"

def area(width,height):
    return width*height

def print_welcome(name):
    print "Welcome",name
    
hello()
hello()

print_welcome("Fred")
w = 4
h = 5
print "width =",w,"height =",h,"area =",area(w,h)

Hello
Hello
Welcome Fred
width = 4 height = 5 area = 20

함수는 반복되는 코드를 제거하는데에도 쓰일 수 있다.

예 제

factorial.py

#defines a function that calculates the factorial

def factorial(n):
    if n <= 1:
        return 1
    return n*factorial(n-1)

print "2! = ",factorial(2)
print "3! = ",factorial(3)
print "4! = ",factorial(4)
print "5! = ",factorial(5)

출력은 :

2! =  2
3! =  6
4! =  24
5! =  120

temperature2.py

#converts temperature to fahrenheit or celsius

def print_options():
    print "Options:"
    print " 'p' print options"
    print " 'c' convert from celsius"
    print " 'f' convert from fahrenheit"
    print " 'q' quit the program"

def celsius_to_fahrenheit(c_temp):
    return 9.0/5.0*c_temp+32

def fahrenheit_to_celsius(f_temp):
    return (f_temp - 32.0)*5.0/9.0

choice = "p"
while choice != "q":
    if choice == "c":
        temp = input("Celsius temperature:")
        print "Fahrenheit:",celsius_to_fahrenheit(temp)
    elif choice == "f":
        temp = input("Fahrenheit temperature:")
        print "Celsius:",fahrenheit_to_celsius(temp)
    elif choice != "q":
        print_options()
    choice = raw_input("option:")

샘플을 실행하면:

> python temperature2.py
Options:
 'p' print options
 'c' convert from celsius
 'f' convert from fahrenheit
 'q' quit the program
option:c
Celsius temperature:30 
Fahrenheit: 86.0
option:f
Fahrenheit temperature:60
Celsius: 15.5555555556
option:q

디버깅

디버깅이란 무엇인가?

프로그램을 시작하자 마자, 우리는 놀랍게도 우리가 생각했던대로의 프로그램을 가지는 것이 쉽지 않다는 것을 깨닫는다. 디버깅은 탐구되어져야만 하는 것이다. 나는 바로 그 때를 생생하게 기억한다. 내가 깨닫는 그 순간부터 나는 나의 인생의 대부분을 나의 프로그램에서 실수를 찾아 내는데에 사용하고 있었다.

- Maurice Wilkes discovers debugging, 1949

지금까지 여러분이 프로그램을 가지고 이리저리 놀다보면 프로그램이 때때로 여러분이 원하지 않았던 행동을 한다는 것을 아마도 여러분은 발견 할 것이다. 이것은 대단히 흔한 일이다. 디버깅은 컴퓨터가 무엇을 하는지 알아내는 처리과정이며 그리고 여러분이 원하는대로 프로그램이 실행되도록 하는 과정이다. 이것을 기술적일수도 있다. 한때 나는 거의 일주일이나 소비해서 버그를 추적하고 고친적이 있었는데 어떤 사람이 y가 있어야할 자리에 x를 넣어 놓아서 발생한 것이었다.

이 장은 전 장보다도 더욱 추상적이 될 것이다. 유용하다면 연락주세요

프로그램은 무엇을 해야 하는가?

가장 먼저 해야할 일은(이것은 당연하게 보인다) 프로그램이 정확히 동작하지 않을 때 그 프로그램이 무엇을 해야하는지를 추산해 보는 것이다. 약간의 테스트용 상황들을 고안해 보고 무슨일이 일어나는지 살펴보라. 예를 들어 내가 사각형의 길이( 모든 변의 길이의 합)를 계산하는 프로그램이 있다고 하자. 나는 다음과 같은 테스트 상황을 가진다 :

이제 나는 프로그램을 모든 케이스에 대하여 실행시켜서 그 프로그램이 내가 예상한바를 그대로 실행하고 있는지 살펴본다. 만약 그렇지 못하다면 나는 컴퓨터가 무엇을 하고 있는지 알 필요가 있다.

많은 검증케이스들이 잘 작동하지만 어떤 것들은 그렇지 않다. 만약 그렇다면 여러분은 잘 작동하는 프로그램들의 공통점이 무엇인지 알도록 노력해야 한다. 예를 들어 여기에 변의 길이를 계산하는 프로그램이 있다.(잠시후에 보게 될겁니다.):

Height: 3
Width: 4
perimeter =  15

Height: 2
Width: 3
perimeter =  11

Height: 4
Width: 4
perimeter =  16

Height: 2
Width: 2
perimeter =  8

Height: 5
Width: 1
perimeter =  8

첫음의 두 개의 입력에 대하여는 작동하지 않았음을 주목하라, 다음의 두개에는 잘 작동하고 마지막 한개에는 작동하지 않았다. 문제가 무엇인지 여러분이 알기만 한다면 원인을 찾아내는 것은 더욱 쉽다. 여러분의 프로그램을 가지고 필요하다면 더 많은 검증케이스들을 여러분은 시도해 보아야만 한다.

그 프로그램은 무엇을 하는가?

다음으로 해야할 일은 소스코드를 살펴보는 일이다. 프로그래밍을 하면서 해야할 가장 중요한 일은 소스를 읽는 것이다. 소스를 읽는 가장 좋은 방법은 코드를 훓어보는 것이다.

코드 훓어보기는 첫 번째 줄에서 시작해서, 프로그램이 끝날 때까지 아래로 진행된다. While 루프와 if 서술문이 뜻하는 바는 어떤 라인들은 실행되지 않을 것이고 어떤 라인들은 여러번 실행될 것이라는 것을 뜻한다. 각 라인에서 여러분은 파이썬이 무엇을 하였는지를 이해한다.

변의 길이를 계산하는 이 단순한 프로그램으로 시작해 보자. 타이프해 넣지 마시고 읽기만 하라. 실행하지 마라. 소스 코드는 이렇다 :

height = input("Height: ")
width = input("Width: ")
print "perimeter = ",width+height+width+width

Question: 파이썬이 처음으로 실행하는 라인은 무엇인가?
Answer: 첫 번째 라인이 항상 먼저 실행된다. 이경우에는 : height = input("Height: ") 이다.

Question: 그 라인은 무엇을 하는가?
Answer: Height: 를 출력하고, 사용자가 숫자 하나를 입력하기를 기다린다, 그리고 그것을 변수 height에 집어 넣는다.

Question: 다음으로 실행되는 라인은 무엇인가?
Answer: 일반적으로, 'width = input("Width: ")' 아래의 라인이다.

Question: 그 라인은 무엇을 하는가?
Answer: Width: 를 출력하고, 사용자가 숫자 하나를 입력하기를 기다려서, 그것을 변수 width에 집어 넣는다.

Question: 다음으로 실행되는 라인은 무엇인가?
Answer: 다음의 라인이 현재의 라인보다 들여쓰기 혹은 내어쓰기 되어 있지만 않다면, 그것은 바로 다음의 라인이다. 그러므로 다음 라인은 : 'print "perimeter = ",width+height+width+width' 이다 (그것은 또한 현재라인에 있는 함수를 실행할지도 모르지만, 그것은 앞으로의 장에서 다루겠다.)

Question: 그 라인은 무엇을 하는가?
Answer: 먼저 perimeter = 를 출력하고, 그리고 나서 width+height+width+width 를 출력한다.

Question: width+height+width+width는 길이를 적절히 계산하는가?
Answer: 어디 보자, 사각형의 변의 길이의 합은 아랫변의 너비 더하기 좌변의 높이 더하기 윗변의 너비 더하기 우변의 (히?) 합이다. 가장 마지막 항목은 우변의 길이, 혹은 높이가 되어야 한다.

Question: 왜 어떤 때는 길이가 '정확하게' 계산되었는지 이해하는가?
Answer: 너비와 높이가 같을 때는 정확하게 계산되었다.

우리가 거닐어 볼 다음 프로그램은 5개의 점을 화면에 출력하는 프로그램이다. 그렇지만, 이것이 그 프로그램이 출력 한것인데 :

. . . .

그리고 이것이 그 프로그램이다:

number = 5
while number > 1:
    print ".",
    number = number - 1
print

이 프로그램은 이제 들여쓰기된 부분(또는 제어 구조)을 가지므로 살펴보기에 더욱 복잡할 것이다. 이제 시작해보자

Question: 실행되어야 할 첫 번째 라인은 무엇인가?
Answer: 이 파일에서 첫번째 라인은: number = 5 이다.

Question: 그것은 무엇을 하는가?
Answer: 숫자 5를 number변수에 넣는다.

Question: 다음 라인은 무엇인가?
Answer: 다음 라인은: while number > 1: 이다

Question: 그것은 무엇을 하는가?
Answer: 에 , while 서술문은 일반적으로 자신의 서술문을 살펴 보고서, 만약 참이라면 다음의 들여쓰기된 코드를 실행하고, 그렇지 않으면 그 코드를 건너 뛴다.

Question: 그러면 그것은 지금 무엇을 하는가?
Answer: 만약 'number > 1' 이 참이라면 다음의 두 라인이 실행될 것이다.

Question: 그러면 number > 1 인가?
Answer: number에 넣어진 마지막 값이 5 이고 '5 > 1' 이므로 그렇다.

Question: 그럼 다음 라인은 무엇인가?
Answer: while 이 참이므로 다음 라인은 : 'print ".",' 이다

Question: 그 라인은 무엇을 하는가?
Answer: 한 개의 점을 찍는다. 그리고 서술문이 , 로 끝나므로 다음의 print서술문은 다음 라인에 출력되지 않을 것이다.

Question: 다음 라인은 무엇인가?
Answer: number = number - 1 이다 왜냐하면 그것이 다음 라인이며 아무런 들여쓰기 변화도 없기 때문이다.

Question: 그것은 무엇을 하는가?
Answer: 그것은 number - 1 을 계산한다, 그것은 number의 현재값 (5)이고 거기에서 1을 빼서, 그것을 number변수의 새로운 값으로 한다. 그래서 기본적으로 그것은 number의 값을 5 에서 4 로 변경한다.

Question: 다음 라인은 무엇인가?
Answer: 음, 들여쓰기가 되었으므로 우리는 어떤 종류의 제어 구조인지를 살펴보아야 한다. 그것은 while 회돌이다, 그래서 우리는 while 절로 되돌아 가야한다. 그 구문은 while number > 1:이다.

Question: 그것은 무엇을 하는가?
Answer: number 변수의 값을 살펴보고, 그 값은 4 인데, 그것과 1 을 비교해본다. '4 > ' 이므로 while 루프는 계속된다.

Question: 다음 라인은 무엇인가?
Answer: while 루프가 참이었으므로, 다음 라인은 : 'print ".",' 이다

Question: 그것은 무엇을 하는가?
Answer: 그 라인에 두 번째 점 하나를 출력한다.

Question: 다음 라인은 무엇인가?
Answer: 들여쓰기가 변하지 않았으므로 다음 라인은: 'number = number - 1' 이다

Question: 그러면 그것은 무엇을 하는가?
Answer: 그것은 현재의 number 값(4)을 보여주고, 1을 number에서 뺀다, 그럼 3이 되고 그러면 결국에 3이 새로운 number의 값이 된다.

Question: 다음 라인은 무엇인가?
Answer: while 회돌이의 마지막에 의해서 들여쓰기에 변화가 있으므로, 다음 라인은 : while number > 1: 이다.

Question: 그것은 무엇을 하는가?
Answer: 그것은 number의 현재 값(3)을 1과 비교한다. 3 > 1 이므로 while 회돌이는 계속된다.

Question: 다음 라인은 무엇인가?
Answer: while 회돌이 조건이 참이므로 다음 라인은 : print ".", 이다.

Question: 그리고 그것이 하는 바는?
Answer: 세 번째의 점이 그 라인에 출력된다.

Question: 다음 라인은 무엇인가?
Answer: 그것은 : number = number - 1 이다

Question: 그것은 무엇을 하나?
Answer: 그것은 현재의 number 값(3)을 취해서 거기에서 1을 빼고 2를 새로운 number의 값으로 만든다.

Question: 다음 라인은 무엇인가?
Answer: while 회돌이의 시작부분으로 되돌아 간다: while number > 1:

Question: 그것은 무엇을 하는가?
Answer: 그것은 현재의 number 값(2)와 1을 비교한다. 2 > 1 이므로 while 회돌이는 계속된다.

Question: 다음 라인은 무엇인가?
Answer: while 회돌이가 계속되므로 : print ".", 이다

Question: 그것은 무엇을 하는가?
Answer: 그것은 삶의 의미와, 우주와 그리고 모든 것들을 탐구한다. 농담입니다. (여러분을 환기시키려고 흐흐~)
그 라인은 화면에 네 번째 점을 출력한다.

Question: 다음 라인은 무엇인가?
Answer: 그것은: number = number - 1 이다.

Question: 그것은 무엇을 하는가?
Answer: 현재의 number 값(2)를 취해서 거기에서 1 을 빼고 1 을 새로운 number의 값으로 만든다.

Question: 다음 라인은 무엇인가?
Answer: while 회돌이로 다시 되돌아 간다: while number > 1:

Question: 그 라인은 무엇을 하는가?
Answer: 그것은 현재의 number 값(1)을 1과 비교한다. 1 > 1 은 거짓이므로 (일은 일보다 크지 않다), while회돌이를 탈출한다.

Question: 다음 라인은 무엇인가?
Answer: while 회돌이의 조건이 거짓이므로 다음 라인은 while 회돌이가 빠져 나온 이후의 라인이다, 또는: print

Question: 그 라인은 무엇을 하는가?
Answer: 화면에서 다음 라인으로 이동시킨다.

Question: 왜 그 프로그램이 점 5개를 찍지 않는가?
Answer: 회돌이가 1 점 빠르게 탈출한다.

Question: 어떻게 우리는 그것을 고칠 수 있나?
Answer: 회돌이를 1점 나중에 탈출시킨다.

Question: 그럼 어떻게 우리는 그것을 하나?
Answer: 여러가지 방법이 있다. 하나의 방법은 while 회돌이를 다음과 같이 바꾸는 것이다 : while number > 0: 또 다른 방법은 조건을 다음과 같이 바꾸는 것이다 : number >= 1 다른 방법도 많이 있다.

나는 어떻게 프로그램을 고치는가?

여러분은 프로그램이 무엇을 하는지를 이해할 필요가 있다. 여러분은 프로그램이 무엇을 해야하는지를 이해할 필요가 있다. 양자간의 차이점이 무엇인지를 이해해 보라. 디버깅은 반드시 배워야만 하는 기술이다. 여러분이 한시간이 지나도 이해할 수가 없어서 잠시 쉬고 있다면, 그 문제에 관하여 누군가와 상의 해보거나 고개를 푹 숙이고 숙고해 보라. 잠시 후에 돌아오면 여러분은 아마도 그 문제에 관하여 새로운 생각을 가지게 될 것이다. 행운을 빈다.

결 정

If 서술문

n = input("Number? ")
if n < 0:
        print "The absolute value of",n,"is",-n
else:
        print "The absolute value of",n,"is",n

여기에 내가 이 프로그램을 두 번 실행한 출력결과를 보인다:

Number? -34
The absolute value of -34 is 34

Number? 1
The absolute value of 1 is 1

자, 컴퓨터는 이 코드조각을 보고서 무엇을 하는가? 먼저 컴퓨터는 사용자에게 숫자 하나를 "n = input("Number? ")"사용하여 요구한다. 다음으로 컴퓨터는 "if n < 0:" 라인을 읽고서
만약 n 이 0 보다 작다면 파이썬은 "print "The absolute value of",n,"is",-n"라인을 실행하고
그렇지 않으면 "print "The absolute value of",n,"is",n"라인을 실행한다.

더욱 형식적으로 파이썬은 표현식 n < 0 이 참인가 거짓인가를 살핀다. if 서술문 다음에는 서술문의 블록이 따른다. 서술문이 참일 경우에 그 블록은 실행된다. 선택적으로 if 서술문 뒤에는 else 서술문이 있을 수 있다. else 서술문은 그 표현식이 거짓일 경우에 실행된다.

하나의 표현식이 가질수 있는 약간의 다른 예들이 있다. 여기에 그들 모두를 기술한 표를 보인다.:

if 명령어의 또 다른 사양은 elif 이다. elif else if 의 약자이며 원래의 if 서술문이 거짓이고 elif 부분이 참이라면 그 부분을 실행하라는 뜻이다.
여기에 하나의 예제가 있다:

a = 0
while a < 10:
        a = a + 1
        if a > 5:
                print a," > ",5
        elif a <= 7:
                print a," <= ",7
        else:
                print "Neither test was true"

그리고 그 출력은:

1  <=  7
2  <=  7
3  <=  7
4  <=  7
5  <=  7
6  >  5
7  >  5
8  >  5
9  >  5
10  >  5

if문이 참이 되지 못할 때에만 elif a <= 7 가 평가됨을 주목하라 . elif 로 한개의 if 서술문안에서 다중 테스를 할 수 있다.

예제

High_low.py

#Plays the guessing game higher or lower 
# (originally written by Josh Cogliati, improved by Quique)

#This should actually something that is semi random like the
# last digits of the time or something else, but that will have to
# wait till a later chapter.  (Extra Credit, modify it to be random
# after the Modules chapter)
number = 78
guess = 0

while guess != number : 
    guess = input ("Guess a number: ")

    if guess > number :
        print "Too high"

    elif guess < number :
            print "Too low"

print "Just right"

Sample run:

Guess a number:100
Too high
Guess a number:50
Too low
Guess a number:75
Too low
Guess a number:87
Too high
Guess a number:81
Too high
Guess a number:78
Just right

10까지 세기

While 회돌이

우리의 첫번째 제어 구조를 제시하련다. 평상적으로 컴퓨터는 첫 번째 라인에서 시작하여 아래로 내려간다. 제어 구조는 어떤 서술문이 실행되면 서술문이 실행되거나 결정되는 순서를 바꾼다. 여기에 while 제어 구조를 사용하는 프로그램을 위한 소스가 있다:

a = 0
while a < 10:
        a = a + 1
        print a

그리고 여기에 정말로 흥미진진한 출력이 있다 :

1
2
3
4
5
6
7
8
9
10

(여러분의 컴퓨터를 5달러짜리 계산기로 바꾸어도 더 나쁠것 같지 않다고 여러분은 생각하겠지?) 자 이 프로그램은 무엇을 하는가? 먼저 a = 0이라는 라인을 보고서 0을 만든다. 그리고 while a < 10:라는 라인을 보고서 컴퓨터는 a < 10인가를 점검한다. a는 0이라는 서술문을 컴퓨터가 처음으로 보았으므로 그것은 10 이하이다. 다른 말로 하면 a 가 10 이하인 동안에만 컴퓨터는 들여쓰기된 서술문들을 실행할 것이다.

여기에 while을 사용하는 또 다른 예제가 있다:

a = 1
s = 0
print 'Enter Numbers to add to the sum.'
print 'Enter 0 to quit.'
while a != 0 :
        print 'Current Sum:',s
        a = input('Number? ')
        s = s + a
print 'Total Sum =',s

처음으로 내가 이 프로그램을 실행했으므로 파이썬은 다음과 같은 것을 내 뱉는다:

  File "sum.py", line 3
    while a != 0 
                ^
SyntaxError: invalid syntax

Enter Numbers to add to the sum.
Enter 0 to quit.
Current Sum: 0
Number? 200
Current Sum: 200
Number? -15.25
Current Sum: 184.75
Number? -151.85
Current Sum: 32.9
Number? 10.00
Current Sum: 42.9
Number? 0
Total Sum = 42.9

표현식 "print 'Total Sum =',s "이 마지막에 한번 만 실행됨을 주목하라. while 서술문은 탭쓰기된 ( 들여쓰기된) 라인에만 영향을 미친다. != 은 같지 않다는 것을 의미한다 그래서 while a != 0 : 가 뜻하는 것은 a 가 0이 될 때까지 이후의 탭쓰기된 서술문들을 실행하라는 의미이다.

이제 우리는 while 루프를 다룬다, 영원히 실행되는 프로그램을 갖는 것은 가능하다. 이것을 하는 쉬운 방법은 프로그램을 다음과 같이 작성하는 것이다:

while 1 == 1:
     print "Help, I'm stuck in a loop."

이 프로그램은 우주가 열로 멸망하거나 여러분이 멈출때까지 "Help, I'm stuck in a loop."을 출력할 것이다. 여러분이 멈추는 방법은 Control (또는 Ctrl) 키와 `c' (문자)를 동시에 누르는 것이다. 이것으로 그 프로그램은 죽을 것이다. (주의: 때로는 여러분은 Control C 를 누른후에 엔터를 쳐야만 할 것이다.)

예 제

Fibonnaci.py

#This program calulates the fibonnaci sequence
a = 0
b = 1
count = 0
max_count = 20
while count < max_count:
    count = count + 1
    #we need to keep track of a since we change it
    old_a = a
    a = b
    b = old_a + b
    #Notice that the , at the end of a print statement keeps it
    # from switching to a new line
    print old_a,
print

출 력:

0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Password.py

Waits until a password has been entered.  Use control-C to break out with out
# the password

password = "foobar"

#note that != means not equal
while password != "unicorn":
    password = raw_input("Password:")
print "Welcome in"

샘플 실행:

Password:auo
Password:y22
Password:password
Password:open seaseme
Password:unicorn
Welcome in

누가 거기에 가지?

입력과 변수

print "Halt!"
s = raw_input("Who Goes there? ")
print "You may pass,", s

내가 그것을 실행시켜 여기에 나의 화면을 보인다면:

Halt!
Who Goes there? Josh
You may pass, Josh

물론 여러분이 그 프로그램을 실행시킬 때 여러분의 화면은 raw_input서술문 때문에 다르게 보일 것이다. 여러분이 그 프로그램을 실행시킨다면, 여러분은 아마도 어떻게 여러분의 이름을 타이프하고 그리고 엔터를 눌러야만 하는가를 깨닫았을 것이다( 설마 프로그램은 실행시켰겠지요? 그렇지요?). 그러면 그 프로그램은 약간의 텍스트와 또한 여러분의 이름을 출력해 낼 것이다. 이것은 입력의 예이다. 그 프로그램은 어떤 지점에 다다르면 그리고 사용자가 어떤 자료를 입력해주기를 기다린다. 그 자료는 나중에 프로그램이 사용하게 된다.

물론, 우리가 그 정보를 두어야 할 어떤 곳도 없다면, 사용자로부터 얻는 정보가 쓸모가 없을 것이다. 이곳이 바로 변수가 있는 곳이다. 이전의 프로그램에서 s는 변수이다. 변수는 여러조각의 데이타를 담을 수 있는 상자와 같은 것이다. 여기에 변수의 예를 보여주는 프로그램이 있다 :

a = 123.4
b23 = 'Spam'
first_name = "Bill"
b = 432
c = a + b
print "a + b is", c
print "first_name is", first_name
print "Sorted Parts, After Midnight or",b23

그리고 여기에 그 출력이 있다 :

a + b is 555.4
first_name is Bill
Sorted Parts, After Midnight or Spam

변수는 데이타를 저장한다. 위의 프로그램에서 변수는 a, b23, first_name, b, 그리고 c이다. 기본적인 형 두가지는 문자열과 숫자이다. 문자열은 문자들, 숫자 그리고 다른 문자들의 연속열이다. 이 예제에서 b23 와 first_name은 문자열을 담고있는 변수이다. Spam, Bill, a + b is, 그리고 first_name is 는 이프로그램에서 문자열이다.문자는 " 또는 '으로 둘러 쳐진다. 다른 타입의 변수는 숫자이다.

좋다, 자 우리는 이러한 변수들이라 부르는 상자들과 또한 다른 변수로 갈수 있는 데이타를 가지고 있다. 컴퓨터는 first_name = "Bill"와 같은 라인을 보고서 그것을 읽기를 'Bill이라는 스트링을 first_name라는 상자(혹은 변수)에 집어 넣어라'라고 읽을 것이다. 그리고는 c = a + b라는 서술문을 보게되고 읽기를 'a + b혹은 123.4 + 432 또는 555.4를 c에 집어 넣어라'라고 읽을 것이다.

여기에 변수 사용법에 대한 또 다른 예제가 있다:

a = 1
print a
a = a + 1
print a
a = a * 2
print a

그리고 물론 이것이 그 출력이다:

1
2
4

양쪽 모두에서 똑 같은 변수임에도 불구하고 컴퓨터는 여전히 그것을 다음과 같이 읽는다 : 먼저 저장해야할 데이타를 찾아라 그리고 데이타가 어디로 가는지를 찾아라

이 장을 떠나기 전에 프로그램을 하나 더 살펴보자 :

num = input("Type in a Number: ")
str = raw_input("Type in a String: ")
print "num =", num
print "num is a ",type(num)
print "num * 2 =",num*2
print "str =", str
print "str is a ",type(str)
print "str * 2 =",str*2

내가 맞이한 출력은 다음과 같다:

Type in a Number: 12.34
Type in a String: Hello
num = 12.34
num is a  <type 'float'>
num * 2 = 24.68
str = Hello
str is a  <type 'string'>
str * 2 = HelloHello

num는 input문으로 반면에 str은 raw_input문으로 할당되고 있음을 주목하라. raw_input은 문자열을 반환하는 반면에input은 숫자를 반환한다. 사용자가 숫자의 형태로 입력하기를 원한다면input을 사용하라 그러나 사용자가 문자열의 형태로 입력하기를 원한다면 raw_input을 사용하라.

프로그램의 후반부에서 type를 사용하는데 그것은 변수의 형을 말해 준다. 숫자들은 정수형int 이거나 소수형float이다 (그것들은 각각 integer 와 floating point의 약자이다). 문자열은 string이다. 언제 어떻게 파이썬이 하나의 수치를 정수로 곱셈을 해야 예상한 바가 일어나는지를 또한 주목하라. 그렇지만 하나의 문자열이 정수에 의하여 곱하여졌을때 그 문자열은 자신의 많은 복사본이 더해지게 된다.
다시 말하면 str * 2 = HelloHello.

예 제

Rate_times.py

#This programs calculates rate and distance problems
print "Input a rate and a distance"
rate = input("Rate:")
distance = input("Distance:")
print "Time:",distance/rate

샘플을 실행하면:

> python rate_times.py
Input a rate and a distance
Rate:5
Distance:10
Time: 2
> python rate_times.py 
Input a rate and a distance
Rate:3.52
Distance:45.6
Time: 12.9545454545

Area.py

#This program calculates the perimeter and area of a rectangle
print "Calculate information about a rectangle"
length = input("Length:")
width = input("Width:")
print "Area",length*width
print "Perimeter",2*length+2*width

샘플을 실행하면:

> python area.py
Calculate information about a rectangle
Length:4
Width:3
Area 12
Perimeter 14
> python area.py
Calculate information about a rectangle
Length:2.53
Width:5.2
Area 13.156
Perimeter 15.46

temperature.py

#Converts fahrenheit to celcius
temp = input("Farenheit temperature:")
print (temp-32.0)*5.0/9.0

샘플을 실행하면:

> python temperature.py
Farenheit temperature:32
0.0
> python temperature.py
Farenheit temperature:-40
-40.0
> python temperature.py
Farenheit temperature:212
100.0
> python temperature.py
Farenheit temperature:98.6
37.0

Hello, World

여러분이 알아야 할 것

인 쇄

print "Hello, World!"

여러분이 명령어 라인을 사용하여 프로그램을 실행하려면 그것을 텍스트 편집기 안에서 타이프하여, 그것을 hello.py 로 저장하고 그리고 ``python hello.py''로 그것을 실행하라.

그렇지 않으면 IDLE로 가서, 새로운 윈도우를 생성하고, 그것을 섹션1.4과 같이 작성하라.

이 프로그램이 실행되었을 때 여기에 그것이 출력하는 것을 나타내면:

Hello, World!

이제 여러분에게 매번 이것을 이야기 하지 않겠다. 그러나 내가 여러분에게 하나의 프로그램을 보여준다면, 여러분은 그것을 타이프해보고 실행하여 보기를 권장한다. 나로서는 그것을 타이프해 볼때 더 많은 것을 배웠고, 여러분 또한 그러리라 생각한다.

이제 여기에 더 복잡한 프로그램이 있다:

print "Jack and Jill went up a hill"
print "to fetch a pail of water;"
print "Jack fell down, and broke his crown,"
print "and Jill came tumbling after."

여러분이 이 프로그램을 실행하면 그것이 출력하는 바는:

Jack and Jill went up a hill
to fetch a pail of water;
Jack fell down, and broke his crown,
and Jill came tumbling after.

컴퓨터가 이 프로그램을 실행하면 그것은 먼저 이 라인을 본다:

print "Jack and Jill went up a hill"

Jack and Jill went up a hill

그리고나서 컴퓨터는 다음의 라인으로 가서 이것을 본다:

print "to fetch a pail of water;"

그래서 컴퓨터는 스크린에 다음을 찍어낸다:

to fetch a pail of water;

컴퓨터는 각각의 라인을 살피면서, 명령어를 따르고 그리고 다음 라인으로 간다. 컴퓨터는 프로그램의 끝에 도달하기까지 명령어를 계속하여 실행한다.

표 현 식

print "2 + 2 is", 2+2
print "3 * 4 is", 3 * 4
print 100 - 1, " = 100 - 1"
print "(33 + 2) / 5 + 11.5 = ",(33 + 2) / 5 + 11.5

그리고 여기에 그 프로그램이 실행되었을 때의 출력이 있다:

2 + 2 is 4
3 * 4 is 12
99  = 100 - 1
(33 + 2) / 5 + 11.5 =  18.5

여러분이 보듯이 파이썬은 여러분의 수천달러짜리 컴퓨터를 5달러짜리 계산기로 바꿀 수도 있다.

파이썬에는 6개의 기본적 처리가 있다:

나눗셈은 규칙을 따르고 있음을 주의하라, 만약 소수형태로 시작하지 않았다면, 반드시 소수형태로 끝나지 않는다. 다음의 프로그램은 이것을 보여준다:

print "14 / 3 = ",14 / 3
print "14 % 3 = ",14 % 3
print
print "14.0 / 3.0 =",14.0 / 3.0
print "14.0 % 3.0 =",14 % 3.0
print
print "14.0 / 3 =",14.0 / 3
print "14.0 % 3 =",14.0 % 3
print
print "14 / 3.0 =",14 / 3.0
print "14 % 3.0 =",14 % 3.0
print

14 / 3 =  4
14 % 3 =  2

14.0 / 3.0 = 4.66666666667
14.0 % 3.0 = 2.0

14.0 / 3 = 4.66666666667
14.0 % 3 = 2.0

14 / 3.0 = 4.66666666667
14 % 3.0 = 2.0

처리의 순서는 수학에서와 마찬가지이다:

1. 괄호 ()
2. 지수 **
3. 곲셈 *, 나눗셈 \, 그리고 나머지 %
4. 덧셈 + 그리고 뺄셈 -

사람과(다른 지능적 존재와)의 대화

프로그래밍을 할 때 때때로 여러분은 아주 복잡한 어떤 것을 하고 여러분이 무엇을 했는지 장래에 기억하지 못할 지도 모른다. 이러한 일이 일어나면 프로그램에는 아마도 주석이 붙여져야만 한다. 주석은 여러분과 다른 프로그래머들에게 무슨일이 일어나고 있는지 설명해주는 주의표시이다. 예를 들어:

#Not quite PI, but an incredible simulation
print 22.0/7.0

예 제

Denmark.py

print "Something's rotten in the state of Denmark."
print "                -- Shakespeare"

출 력 :

Something's rotten in the state of Denmark.
                -- Shakespeare

School.py

#This is not quite true outside of USA
# and is based on my dim memories of my younger years
print "Firstish Grade"
print "1+1 =",1+1
print "2+4 =",2+4
print "5-2 =",5-2
print
print "Thirdish Grade"
print "243-23 =",243-23
print "12*4 =",12*4
print "12/3 =",12/3
print "13/3 =",13/3," R ",13%3
print
print "Junior High"
print "123.56-62.12 =",123.56-62.12
print "(4+3)*2 =",(4+3)*2
print "4+3*2 =",4+3*2
print "3**2 =",3**2
print

출 력:

Firstish Grade
1+1 = 2
2+4 = 6
5-2 = 3

Thirdish Grade
243-23 = 220
12*4 = 48
12/3 = 4
13/3 = 4  R  1

Junior High
123.56-62.12 = 61.44
(4+3)*2 = 14
4+3*2 = 10
3**2 = 9

첫째중 첫째

자, 여러분은 프로그램을 해본 적이 없다. 이 지침서를 따라가면서 나는 프로그램의 방법을 여러분에게 가르치려고 노력할 것이다. 실제로 프로그램하는 방법을 배우는 데는 오직 한가지 길이 있다. 여러분은 코드를 읽고 써야만 한다. 나는 여러분에게 많은 코드를 보여줄 계획이다. 여러분은 내가 무슨일이 일어나는지 보여주기 위해서 여러분에게 보여준 코드를 타이프해 넣어야만 한다. 그것을 가지고 놀면서 변경해 보라. 일어날만한 일중 가장 최악의 경우는 그것이 멈추는 것일 뿐이다. 내가 코드를 타이프해 넣는다면 다음과 같은 형태가 될 것이다.:

##Python is easy to learn
print "Hello, World!"

이것은 다른 텍스트와 구별하기 쉬운 그런 형태이다. 조금 혼란스럽게 하기 위해 나는 또한 컴퓨터가 출력하는 것과 똑 같은 폰트로 인쇄해 볼 것이다.

이제, 더욱 중요한 일에 대해서 말하면. 파이썬에서 프로그램을 하기 위해서 여러분은 파이썬 소프트웨어가 필요하다. 여러분이 아직 파이썬 소프트웨어를 가지고 있지 않다면, http://www.python.org/download/ 로 가서 여러분의 컴퓨터에 적당한 버젼을 구하라. 그것을 내려받아서, 지시사항을 읽고 그리고 설치하라.

파이썬 설치하기

윈도우 설치기는 파일로 내려받을 수 있다. 그 파일은 내려받은 아이콘 위를 더블 클릭함으로써 실행될 수 있다. 설치는 진행되기 시작할 것이다.

여러분이 유닉스 소스형태로 구했다면 TK 확장모듈을 함께 컴파일하도록 해야만 IDLE을 사용할 수 있다.

상호작용 모드

Python 2.0 (#4, Dec 12 2000, 19:19:57)
[GCC 2.95.2 20000220 (Debian GNU/Linux)] on linux2
Type "copyright", "credits" or "license" for more information.
IDLE 0.6 -- press F1 for help
>>>

프로그램 작성과 실행

print "Hello, World!"

먼저 프로그램을 저장하라. File로 가고 Save에 가서. 그것을 'hello.py'로 저장하라. (여러분 원한다면 기본디렉토리가 아닌 다른 어떤 디렉토리에 그것을 저장할 수 있다.) 이제 그것이 저장되면 실행될 수 있다. 1

다음으로 Edit로 그리고 Run script로 가서 프로그램을 실행하라. 이것은 *Python Shell*윈도우에 Hello, World!를 출력할 것이다.

명령어라인에서 파이썬을 사용하기