Commits

Yong Choi  committed ab2f94a

translating ch 11

  • Participants
  • Parent commits d9350cc

Comments (0)

Files changed (1)

File JythonIDE.rst

-Chapter 11:  Using Jython in an IDE
-+++++++++++++++++++++++++++++++++++
+11장. 통합개발환경에서 자이썬 사용하기
+++++++++++++++++++++++++++++++++++++++
 
-In this chapter, we will discuss developing Jython applications
-using two of the most popular integrated development environments,
-Eclipse and Netbeans. There are many other development environments
-available for Python and Jython today; however, these two are
-perhaps the most popular and contain the most Jython-specific
-tools. Eclipse has had a plug-in known as PyDev for a number of
-years, and this plug-in provides rich support for developing and
-maintaining Python and Jython applications alike. Netbeans began to
-include Python and Jython support with version 6.5 and later. The
-Netbeans IDE also provides rich support for development and
-maintenance of Python and Jython applications.
+이 장에서는, 가장 인기있는 두 가지 통합개발환경, 이클립스와 넷빈을 사용한 자이썬 애플리케이션 개발에 대해 설명한다.
+요즘은 파이썬과 자이썬 개발에 쓸 수 있는 다른 개발 환경도 많이 있지만, 그 두 가지가 아마도 가장 인기 있고 자이썬에 적합한 도구를 갖추고 있을 것이다.
+이클립스에는 여러 해 전부터 PyDev로 알려진 플러그인이 있었는데, 이 플러그인은 파이썬과 자이썬 애플리케이션을 유지하기 위한 풍부한 지원을 제공한다.
+넷빈은 6.5 버전부터 파이썬과 자이썬 지원을 포함하기 시작했다.
+넷빈 통합개발환경 역시 파이썬과 자이썬 애플리케이션 개발과 유지보수를 위한 풍부한 지원을 제공한다.
 
-Please note that in this chapter we will refer to Python/Jython as
-Jython. All of the IDE options discussed are available for both
-Python and Jython unless otherwise noted. For readability and
-consistency sake, we'll not refer to both Python and Jython
-throughout this chapter unless there is some feature that is not
-available for Python or Jython specifically. Also note that we will
-call the plug-ins discussed by their names, so in the case of
-Netbeans the plug-in is called Netbeans Python Plug-in. This
-plug-in works with both Python and Jython in all cases.
+이 장에서는 파이썬과 자이썬을 자이썬으로 부르도록 하겠다.
+별도로 명시하지 않는 한 통합개발환경의 모든 선택사항은 파이썬과 자이썬에서 사용할 수 있다.
+쉽게 읽을 수 있도록 하고 일관성을 위해서, 파이썬이나 자이썬에 해당되지 않는 기능 이외에는 파이썬과 자이썬을 구분하지 않을 것이다.
+플러그인은 원래 이름 그대로 부를 것이므로, 넷빈의 경우에는 넷빈 파이썬 플러그인으로 부르도록 하겠다.
+이 플러그인은 모든 경우에 파이썬과 자이썬 양쪽에서 작동한다.
 
-Eclipse
-=======
+이클립스
+========
 
-Naturally, you will need to have Eclipse installed on your machine
-to use Jython with it. The latest available version when this book
-is being written is Eclipse 3.5 (also known as Eclipse Galileo),
-and it is the recommended version to use to follow this section.
-Versions 3.2, 3.3, and 3.4 will work, too, although there will be
-minor user interface differences which may confuse you while
-following this section.
+이클립스에서 자이썬을 사용하려면 당연히 컴퓨터에 이클립스부터 설치해야 할 것이다.
+이 책을 쓸 당시 최근 버전은 이클립스 3.5(이클립스 갈릴레오로 알려져 있기도 하다)이며, 이 장에서 권장하는 버전이기도 하다.
+3.2, 3.3 그리고 3.4 버전도 사용할 수 있지만, 사소한 사용자 인터페이스의 차이가 있기 때문에 이 장에서는 혼동될 수도 있다.
 
-If you don't have Eclipse installed on your machine, go to
-www.eclipse.org/downloads and download the version for Java
-developers.
+이클립스가 컴퓨터에 설치되어 있지 않으면 www.eclipse.org/downloads에서 자바 개발자용 버전을 다운로드하기 바란다.
 
-Installing PyDev
-----------------
+PyDev 설치
+----------
 
-Eclipse doesn't include built-in Jython support. Thus, we will use
-PyDev, an excellent plug-in which adds support for the Python
-language and includes specialized support for Jython. PyDev's home
-page is http://pydev.org, but you won't need to manually download
-and install it.
+이클립스에는 자이썬 지원이 포함되어 있지 않다.따라서, 우리는 자이썬에 대한 특화된 지원과 함께 파이썬 언어에 대한 지원을 추가해주는 훌륭한 플러그인인 PyDev를 사용할 것이다.
+PyDev의 홈 페이지는 http://pydev.org\ 이지만 수동으로 다운로드하여 설치할 필요는 없다.
 
-To install the plug-in, start Eclipse and go to Help>Install new
-Software..., and type http://pydev.org/updates into the 'Work with'
-input box. Press Enter. After a short moment, you will see an entry
-for PyDev in the bigger box below. Just select it, clicking on the
-checkbox that appears at the left of PyDev (see Figure 11-1), and
-then click the Next button.
+플러그인을 설치하려면 이클립스를 시작하고 도움말 > Install New Software...로 가서 'Work with' 입력 상자에 http://pydev.org/updates\ 를 입력한다.
+Enter를 누른다.
+잠시 후에, 아래의 큰 상자에 PyDev에 대한 항목이 표시된다.그것을 선택하고 PyDev의 왼쪽에 표시한 다음 (그림 11-1 참조), 다음 버튼을 누른다.
 
 .. image:: images/chapter11-pydev-installation-1.png
-   :alt: PyDev Installation
-Figure 11-1. Installing PyDev
+   :alt: PyDev 설치
+그림 11-1. PyDev 설치
 
-After this, just follow the wizard, read the license agreement,
-and, if you agree with the Eclipse Public License v1.0, accept it.
-Then click the Finish button.
+그 다음은, 마법사를 따라서, 라이선스 동의서를 읽고, 이클립스 공중 라이선스 버전 1.0에 동의하는 경우에는 수락한다.
+그런 다음 완료 단추를 누른다.
 
-Once the plug-in has been installed by Eclipse, you will be asked
-if you want to restart the IDE to enable the plug-in. As that is
-the recommended option, do so. Once Eclipse restarts itself, you
-will enjoy full Python support on the IDE.
+이클립스에 의해 플러그인이 설치되고 나면, 플러그인을 사용할 수 있도록 하기 위해 통합개발환경을 재시작할 것인지 물어볼 것이다. 그것을 권장하므로, 그렇게 하도록 하자.
+이클립스를 재시작하고 나면, 통합개발환경에서 모든 파이썬 지원을 누릴 수 있다.
 
-Minimal Configuration
----------------------
+최소 구성
+---------
 
-Before starting a PyDev project you must tell PyDev which Python
-interpreters are available. In this context, an interpreter is just
-a particular installation of some implementation of Python. When
-starting you will normally only need one interpreter, and for this
-chapter we will only use Jython 2.5.1. To configure it, open the
-Eclipse Preferences dialog (via Windows>Preferences in the main
-menu bar). On the text box located at the top of the left panel
-(called 'Filter text'), type 'Jython.' This will filter the myriad
-of Eclipse (and PyDev!) options and will present us with a much
-simplified view, in which you will spot the 'Interpreter – Jython'
-section on the left.
+PyDev 프로젝트를 시작하기 전에 사용가능한 파이썬 번역기가 어느 것인지를 PyDev에게 알려주어야 한다.여기서 번역기란 파이썬 구현을 설치한 것을 말한다.
+일반적으로 번역기는 하나만 있으면 되며, 이 장에서는 자이썬 2.5.1만을 사용할 것이다.
+설정을 위해서, 이클립스 환경설정 창을 연다(주 메뉴 막대에서 창>환경 설정).
+왼쪽 상단 패널의 텍스트 상자('필터 텍스트'라고 한다)에 'Jython'이라고 입력한다.
+이것은 이클립스의 (또한 PyDev의!) 무수히 많은 선택사항을 걸러서 아주 단순하게 보여주며, 왼쪽의 'Interpreter - Jython'을 선택하면 된다.
 
-Once you have selected the 'Interpreter – Jython' section, you will
-be presented with an empty list of Jython interpreters at the top
-of the right side. We clearly need to fix that! So, click the New
-button, enter 'Jython 2.5.1' as the Interpreter Name, click Browse,
-and find jython.jar inside your Jython 2.5.1 installation.
+'Interpreter - Jython' 부분을 선택하면, 오른편 위에 자이썬 번역기 목록이 비어있을 것이 보일 것이다.우리는 그것을 고치면 된다.
+그러므로, '새로 작성' 버튼을 누르고, 'Jython 2.5.1'을 번역기 이름으로 입력하고, Browse를 누르고, 자이썬 2.5.1 설치본에서 jython.jar를 찾는다.
 
 .. note::
+    
+    이것이 우리가 이 장에서 사용할 수 있는 유일한 런타임이라 할지라도, 번역기의 이름을 정할 때에는 여기에서 제시된 구현 이름 (Jython)과 전체 버전 (2.5.1) 모두를 포함하는 명명법을 사용하기를 권한다.
+    그렇게 함으로써 나중에 새로운 번역기를 추가할 때 발생할지 모를 혼란과 충돌을 피할 수 있다.
 
-    Even if this is the only runtime we will use in this
-    chapter, we recommend you use a naming schema like the one proposed
-    here, including both the implementation name (Jython) and the full
-    version (2.5.1) on the interpreter name. This will avoid confusion
-    and name clashing when adding new interpreters in the future.
-
-After selecting the jython.jar file, PyDev will automatically
-detect the default, global sys.path entries. PyDev always infer the
-right values, so unless you have very special needs, just accept
-the default selection and click OK.
+jython.jar 파일을 선택한 후에는, PyDev는 자동으로 기본값인, 전역 sys.path 항목을 찾아낼 것이다.
+PyDev은 항상 올바른 값을 추론하므로, 매우 특별한 요구 사항이 없다면 그저 기본 설정값을 받아들이고 확인 버튼을 누르면 된다.
    
-If all has gone well, you will now see an entry on the list of
-Jython interpreters, representing the information you just entered.
-It will be similar to Figure 11-2 (of course, your filesystem paths
-will differ).
+모두 잘 되었다면, 방금 입력한 정보를 반영하고 있는 자이썬 번역기 목록이 보일 것이다.
+그림 11-2과 비슷할 것이다(물론 파일 시스템 경로는 다를 수 있다).
 
 .. image:: images/chapter11-pydev-configuration-1.png
-   :alt: PyDev Configuration: Jython Interpreter
-Figure 11-2. List of Jython interpreters
+   :alt: PyDev 설정: Jython 번역기
+그림 11-2. 자이썬 번역기 목록
 
-That's all. Click OK and you will be ready to develop with Jython
-while enjoying the support provided by a modern IDE.
+이것이 전부이다!
+확인을 누르면 현대적인 통합개발환경의 지원을 즐기면서 자이썬으로 개발을 할 준비가 된 것이다.
 
-If you are curious, you may want to explore the other options found
-on the Preferences window, below the PyDev section (after clearing
-the search filter we used to quickly go to the Jython interpreter
-configuration). But in our experience, it's rarely needed to change
-most of the other options available.
+호기심이 생긴다면, 환경 설정 창의 PyDev 부분 아래의 다른 선택사항들을 살펴보라(자이썬 번역기 설정으로 빨리 이동하기 위해 사용했던 검색 필터를 지우고 나서).
+하지만 경험상으로는, 다른 선택사항 중에 딱히 바꿔야 할 것은 없다.
 
-In the next sections we will take a look to the more important
-PyDev features to have a more pleasant learning experience and make
-you more productive.
+다음 절에서는 보다 즐거운 배움의 경험을 선사하며 여러분을 보다 생산적으로 만들어줄 PyDev의 주요 기능을 살펴보도록 하겠다.
 
-Hello PyDev!: Creating Projects and Executing Modules
------------------------------------------------------
+Hello PyDev!: 프로젝트 만들기 및 모듈 실행
+------------------------------------------
 
-Once you see the first piece of example code on this chapter, it
-may seem overly simplistic. It is, indeed, a very dumb example. The
-point is to keep the focus on the basic steps you will perform for
-the lifecycle of any Python-based project inside the Eclipse IDE,
-which will apply to simple and complex projects. So, as you
-probably guessed, our first project will be a Hello World. Let's
-start it!
+이 장의 첫번째 예제 코드는 지나치게 단순해 보일 것이다.그것은 사실 아주 바보 같은 예제이다.
+간단한 프로젝트에나 복잡한 프로젝트에나 적용할 수 있는, 이클립스 통합개발환경 내의 어떠한 파이썬 기반 프로젝트의 라이프 사이클을 위해서든 행하여야 할 기본 절차에 초점을 맞추는 것이다.
+그래서, 아마 짐작하겠지만, 우리의 첫번째 프로젝트는 Hello World이다.
+시작하자!
 
-Go to File>New >Project. You will be presented with a potentially
-long list of all the kinds of projects you can create with Eclipse.
-Select PyDev Project under the PyDev group (you can also use the
-filter text box at the top and type 'PyDev Project' if it's faster
-for you).
+파일>새로 작성>프로젝트로 가도록 하자.이클립스로 생성할 수 있는 모든 종류의 프로젝트의 목록이 표시된다.
+PyDev 그룹 아래의 PyDev Project를 선택하자(상단 필터 텍스트 상자에 'PyDev Project'라고 치는 것이 더 빠르다면 그렇게 해도 된다).
 
-The next dialog will ask you for your project properties. As the
-project name, we will use LearningPyDev. In the 'Project contents'
-field, check the 'Use default' checkbox, so PyDev will create a
-directory with the same name as the project inside the Eclipse
-workspace (which is the root path of your eclipse projects).
-Because we are using Jython 2.5.1, we will change the project type
-to Jython and the grammar version to 2.5. We will leave the
-Interpreter alone, which will default to the Jython interpreter we
-just defined on the Minimal Configuration section. We will also
-leave checked the 'Create default 'src' folder and add it to the
-pythonpath' option, because it's a common convention on Eclipse
-projects.
+다음 대화 상자는 프로젝트 속성에 대해 물을 것이다.
+프로젝트 이름은 LearningPyDev라고 하자.
+'Project contents' 란에 'Use default'를 체크하여, PyDev가 이클립스 작업공간 내의 프로젝트와 같은 이름의 디렉토리를 생성하도록 하자(이클립스 프로젝트의 최상위 경로가 된다).
+우리는 Jython 2.5.1를 사용하고 있기 때문에, Project type은 Jython으로, grammer version은 2.5로 바꾼다.
+Interpreter는 최소 구성 절에서 Jython interpreter로 정의한 것이 default이므로 그대로 둔다.
+'Create default 'src' folder and add it to the pythonpath' 선택사항도 이클립스의 관행이므로 체크된 대로 둔다.
 
-After you click Finish, PyDev will create your project, which will
-only contain an empty src directory and a reference to the
-interpreter being used. Let's create our program now.
+완료를 누르면, PyDev는 빈 src 디렉토리와 사용할 번역기에 대한 참조만 가진 프로젝트를 생성한다.이제 우리의 프로그램을 만들어 보자.
 
-Right-click on the project, and select New>PyDev Module. Leave the
-Package blank and enter 'main' in the Name field. PyDev offers some
-templates to speed up the creation of new modules, but we won't use
-them, as our needs are rather humble. So leave the Template field
-empty and click Finish.
+프로젝트를 오른쪽 클릭하고 새로 작성> PyDev 모듈을 선택한다.
+Package는 공백으로 두고 Name 란에 'main'을 입력한다.
+PyDev는 새로운 모듈을 빨리 만들 수 있는 템플릿을 제공하지만, 우리는 더 간단한 것을 만들 것이므로 사용하지 않을 것이다.
+그래서 Template 란을 비워두고 완료를 클릭한다.
 
-PyDev will present you an editor for the main.py file it just
-created. It's time to implement our program. Write the following
-code in the editor:
+PyDev는 방금 생성한 main.py를 위한 편집기를 선물할 것이다.
+우리의 프로그램을 구현할 시간이다.편집기에서 다음 코드를 작성하자.
 
-Listing 11-1.
+예제 11-1.
 ::
     
     if __name__ == "__main__":
 
 
 
-and then press Ctrl + F11 to run this program. Select Jython Run
-from the dialog presented and click OK. The program will run and
-the text 'Hello PyDev!' will appear on the console, located on the
-bottom area of the IDE.
+그리고 나서 프로그램을 실행하려면 Ctrl + F11을 누른다.나타나는 대화창에서 Jython Run을 선택하고 확인을 클릭한다.
+프로그램이 실행되어 'Hello PyDev!'가 통합개발환경의 하단 영역에 있는 콘솔에 나타날 것이다.
 
 .. note::
     
-    When describing the hotkeys (such as Ctrl + F11 for
-    'Jython Run'), we're using the PC keyboard convention. Mac
-    users should press the Command key instead of Ctrl for all the
-    hotkeys listed on this chapter, unless otherwise noted.
+    ('Jython Run'에 Ctrl + F11 같은) 단축키에 대해 설명할 때에는 PC 키보드의 관습을 따르도록 하겠다.
+    Mac 사용자는 따로 언급하지 않는 한, 이 장에 나오는 모든 단축키에 대해 Ctrl 키 대신에 Command 키를 누르면 된다.
 
-If you manually typed the program, you probably noted that the IDE
-knows that in Python a line ending in ':' marks the start of a
-block and will automatically put your cursor at the appropriate
-level of indentation in the next line. See what happens if you
-manually override this decision and put the print statement at the
-same indentation level of the if statement and save the file. The
-IDE will highlight the line flagging the error. If you hover at the
-error mark, you will see the explanation of the error, as seen in
-Figure 11-3.
+수동으로 프로그램을 입력하다보면, 통합개발환경이 파이썬에서는 ':' 부호로 행이 끝나면 블록이 시작된다는 것을 알고서 자동으로 커서를 적당한 들여쓰기 수준으로 갖다놓는다는 것을 아마 눈치채게 될 것이다.
+이러한 결정을 무시하고 출력문을 if와 같은 수준의 들여쓰기에 놓고 파일을 저장하면 어떻게 될까.
+통합개발환경은 그 줄에 오류가 있다는 강조 표시를 할 것이다.
+오류 표시 위에 마우스 포인터를 올려두면 그림 11-3과 같이 오류에 대한 설명이 나타날 것이다.
 
 .. image:: images/chapter11-pydev-editing-1.png
-   :alt: PyDev Highlighting a Simple Error
-Figure 11-3. Error explanation appears when you hover over the
-error mark.
+   :alt: PyDev의 간단한 오류 강조
+그림 11-3. 오류 표시 위로 마우스 포인터를 올려두면 오류에 대한 설명이 표시된다.
 
-Expect the same kind of feedback for whatever syntax error you
-made. It helps to avoid the frustration of going on edit-run loops
-only to find further minor syntax errors.
+어떤 구문 오류를 내더라도 같은 식으로 반응이 돌아온다고 보면 된다.
+사소한 문법 오류를 찾기 위해 고치고 실행시키는 쳇바퀴를 도는 좌절을 피하는 데 도움이 되는 기능이다.
 
-Passing Command-line Arguments and Customizing Execution
---------------------------------------------------------
+명령줄 인수 전달하기와 맞춤 실행
+--------------------------------
 
-Command line arguments may seem old fashioned, but they are
-actually a very simple and effective way to let programs interact
-with the outside. Because you have learned to use Jython as a
-scripting language, it won't be uncommon to write scripts that will
-take their input from the command line (note that for unattended
-execution, reading input from the command line is way more
-convenient that obtaining data from the standard input, let alone
-using a GUI).
+명령줄 인수는 구식인 것처럼 보여도 사실은 프로그램이 외부와 상호작용할 수 있는 매우 간단하고 효과적인 방법이다.
+자이썬을 스크립트 언어로서 배웠기 때문에, 명령줄에서 입력을 받아들이는 스크립트를 짜는 것이 생소하지 않을 것이다(무인 실행을 위해서는, 명령행으로부터 입력을 읽어들이는 것이 GUI를 통하지 않고서 표준입력으로부터 데이터를 얻는데 있어 보다 편리한 방법인 것이다).
 
-As you have probably guessed, we will make our toy program to take
-a command line argument. The argument will represent the name of
-the user to greet, to build a more personalized solution. Here is
-how our main.py should look:
+아마 짐작하겠지만, 우리는 명령줄 인수를 받아들이는 장난감 프로그램을 만들 것이다.
+보다 개인화된 솔루션을 만들기 위해, 인수는 인사를 건넬 사용자의 이름을 대표하도록 할 것이다.
+우리의 main.py는 이렇게 생겼다.
 
-Listing 11-2.
+예제 11-2.
 ::
     
     import sys
             print "Hello %s!" % sys.argv[1]
 
 
-If you hit Ctrl + F11 again, you will see the 'Sorry I can't greet
-you...' message on the console. It makes sense, because you didn't
-pass the name. Not to say that it was your fault, as you didn't
-have a chance to say your name.
+Ctrl + F11을 다시 치면, 콘솔에 'Sorry I can't greet you...' 메시지가 뜨는 것이 보일 것이다.
+이름을 알려주지 않았으니 그럴 법도 하다.
+이름을 말할 기회를 주지 않았으니, 여러분의 잘못은 아니다.
 
-To specify command line arguments, go to the Run>Run Configurations
-menu, and you will find an entry named 'LearningPyDev main.py' in
-the Jython Run section on the left. It will probably be already
-selected, but if it's not, select it manually. Then, on the main
-section of the dialog, you will find ways to customize the
-execution of our script. You can change aspects such as the current
-directory, pass special argument to the JVM, change the interpreter
-to use, set environment variables, and so on. We just need to
-specify an argument, so let's type 'Bob' in the 'Program arguments'
-box and click Run.
+명령줄 인수를 지정하려면 실행> 실행 구성 메뉴로 가서, 왼쪽의 Jython Run에서 'LearningPyDev main.py'라는 이름의 항목을 찾도록 하자.
+이미 선택이 되어있을 것인데, 혹시 그렇지 않다면 수동으로 선택하도록 하라.
+그런 다음, 대화 상자의 주 영역에서, 우리 스크립트 실행을 커스터마이즈하는 방법을 찾을 것이다.
+당신은 현재 디렉토리와 같은 측면을 변경한다든지, JVM에 특별한 인자를 전달한다든지, 사용할 번역기를 변경한다든지, 환경 변수를 설정한다든지 하는 것들을 할 수 있다.
+우리는 그저 인수만 지정할 것이므로, 'Program arguments' 상자에 'Bob'을 입력하고 실행을 클릭하자.
 
-As you'd expect, the program now prints 'Hello Bob!' on the
-console. Note that the value you entered is remembered; that is, if
-you press Ctrl + F11 now, the program will print 'Hello Bob!'
-again. Some people may point out that this behavior makes testing
-this kind of program very awkward, because the Run Configurations
-dialog will have to be opened each time the arguments need to be
-changed. But if we really want to test our programs (which is a
-good idea), we should do it in the right way. We will look into
-that soon, but first let's finish our tour on basic IDE features.
+예상한대로, 프로그램은 이제 'Hello Bob!'을 콘솔에 출력한다.
+입력한 값은 기억된다는 것에 주의하기 바란다;다시 말해서, 지금 Ctrl + F11을 누른다면 프로그램은 'Hello Bob!'을 또 출력할 것이다.
+인자를 바꿀 때마다 실행 구성 창을 매번 띄워야한다는 점 때문에, 어떤 사람들은 이런 프로그램을 시험하기 위해 이렇게 하는 것이 매우 이상하다고 지적할 것이다.
+그렇지만 우리가 정말로 우리의 프로그램을 시험하고자 한다면(좋은 생각이다), 우리는 올바른 방법으로 시험을 해야할 것이다.
+그건 곧 살펴보겠지만, 일단은 통합개발환경의 기본 기능에 대한 여행을 마무리하는 것이 우선이다.
 
-Playing with the Editor
------------------------
+편집기 갖고 놀기
+----------------
 
-Let's extend our example code a bit more, providing different ways
-to greet our users, in different languages. We will use the
-optparse module to process the arguments this time. Refer to
-Chapter 9 if you want to remember how to use optparse. We will also
-use decorators (seen in Chapter 4) to make it trivial to extend our
-program with new ways to greet our users. So, our little
-main.py has grown a bit now.
+이제 우리의 예제 코드를 좀 더 확장해서, 다른 방법과 언어로 사용자에게 인사를 해보자.
+이번에는 인수 처리를 위해 optparse 모듈을 사용할 것이다.
+optparse의 사용법에 대해 기억을 되살리려면 9장을 참조하기 바란다.
+우리는 새로운 방법을 사용자를 맞이하도록 프로그램을 확장하기 위해 장식자를 사용할 것이다. (4장을 보라)
+자, 우리의 조그만 main.py가 이제 조금 커졌다.
 
-Listing 11-3.
+예제 11-3.
 ::
     
     # -*- coding: utf-8 -*-
 
 
 
-Take a little time to play with this code in the editor. Try
-pressing Ctrl + Space (don't change Ctrl with Command if you are
-using Mac OS X; this hotkey is the same on every platform), which
-is the shortcut for automatic code completion (also known as
-Intellisense in Microsoft's parlance) on different locations. It
-will provide completion for import statements (try completing that
-line just after the import token, or in the middle of the
-OptionParser token) and attribute or method access (like on
-sys.exit or parser.add_option or even in
-JFrame.EXIT_ON_CLOSE which is accessing a Java class!) It also
-provides hints about the parameters in the case of methods.
+이 코드를 갖고 편집기에서 좀 놀아보도록 하자.
+코드 자동 완성(마이크로소프트 식으로는 인텔리센스라고 부른다) 단축키인 Ctrl + 스페이스를 서로 다른 곳에서 눌러보라(이 단축키는 모든 플랫폼에서 동일하므로, 맥 OS X를 사용하더라도 Ctrl을 Command로 바꾸지 않도록 하라).
+그것은 가져오기 구문을 완성시켜주며(import만 치거나 OptionParser의 중간에서 완성시켜보라) 속성 또는 메소드 접근을 완성시켜준다(sys.exit나 parser.add_option 같은 것, 심지어 자바 클래스의 JFrame.EXIT_ON_CLOSE까지도!).그것은 또한 메소드의 경우에는 매개 변수에 대한 힌트를 제공한다.
 
-In general, every time you type a dot, the automatic completion
-list will pop up, if the IDE knows enough about the symbol you just
-typed to provide help. But you can also call for help at any point.
-For example, go to the bottom of the code and type 'message(.'
-Suppose you just forgot the order of the parameters to that
-function. Solution: Press Ctrl + Space and PyDev will complete the
-statement, using the name of the formal parameters of the
-function.
+일반적으로, 방금 입력한 기호에 대하여 도움을 주기 충분할 만큼 통합개발환경이 알고 있다면, 마침표를 칠 때마다 자동완성목록이 뜬다.
+하지만 어느 때든지 도움을 호출할 수 있다.
+예를 들어, 코드 끝으로 가서 'message('를 입력해보라.
+그 함수의 매개변수 순서를 잊어버렸다고 하자.
+해결 방법은 Ctrl + 스페이스를 누르고 그 함수의 매개변수 이름으로 구문을 완성시키는 것이다.
 
-Also try Ctrl + Space on keywords like 'def.' PyDev will provide
-you little templates that may save you some typing. You can
-customize the templates on the PyDev>Editor>Templates section of
-the Eclipse Preferences window (available on the Window>Preferences
-main menu).
+또한 'def' 같은 열쇠말에 대해 Ctrl + 스페이스를 시험해보라.PyDev는 타이핑을 줄일 수 있도록 약간의 템플릿을 제공할 것이다.
+이클립스 환경 설정 창(메인 메뉴에서 창>환경 설정)의 PyDev>편집기>템플릿에서 템플릿을 원하는 대로 설정할 수 있다.
 
-The other thing you may have noted now that we have a more sizable
-program with some imports, functions, and global variables is that
-the Outline panel on the right side of the IDE window shows a
-tree-structure view of code being edited showing such features. It
-also displays classes, by the way.
+여기서 주목할 만한 또 다른 점은, 가져오기한 것, 함수, 전역변수를 가진 보다 규모가 있는 프로그램을 통합개발환경의 오른쪽 아웃라인 패널에서 트리구조로 보여준다는 점이다.
+그것은 클래스도 역시 보여준다.
 
-And don't forget to run the code! Of course, it's not really
-spectacular to see that after pressing Ctrl + F11 we still get the
-same boring 'Hello Bob!' text on the console. But if you edit the
-command line argument (via the Run Configurations dialog) to the
-following: 'Bob --lang es --ui window,' you will get a nice window
-greeting Bob in Spanish. Also see what happens if you specify a non
-supported UI (say, --ui speech) or an unsupported language. We even
-support the --help! So we have a generic, polyglot greeter which
-also happens to be reasonably robust and user friendly (for command
-line program standards that is).
+그리고 코드를 실행하는 것을 잊지 않도록 하라!물론, Ctrl + F11을 누른 후에 콘솔에 여전히 지루한 'Hello Bob!' 텍스트를 보여준다는 것은 그리 대단치는 않다.
+하지만 (실행 구성 대화창을 통해) 명령줄 인자를 'Bob --lang es --ui window'와 같이 편집한다면 스페인어로 밥에게 인사를 건네는 훌륭한 창이 뜰 것이다.
+또한 지원이 되지 않는 UI(이를테면, --ui speech)라든지 지원되지 않는 언어를 지정한다면 어떤 일이 일어나는지도 보라.
+우리는 심지어 --help도 지원한다!
+그러니까 우리는 (명령줄 프로그램 표준에서) 튼튼하고 사용자 친화적인 일반적인 다국어 인사를 가진다.
 
-At this point you are probably tired of manually testing the
-program editing the command line argument on that dialog. Just one
-more section and we will see a better way to test our program using
-the IDE. Actually, part of the next section will help us move
-toward the solution.
+지금쯤 여러분은 아마도 대화창에서 명령줄 인수를 편집해가며 프로그램을 테스트하느라 지쳤을 것이다.
+한 단락 뒤에는 통합개발환경을 사용하여 프로그램을 테스트하는 더 나은 방법을 보게 될 것이다.
+사실, 다음 절의 일부가 그 해결책으로 나아가는데 도움이 될 것이다.
 
-A Bit of Structure: Packages, Modules, and Navigation
------------------------------------------------------
+구조 맛보기: 패키지, 모듈, 그리고 네비게이션
+--------------------------------------------
 
-If you like simplicity you may be asking (or swearing, depending on
-your character) why we over-engineered the last example. There are
-simpler (in the sense of a more concise and understandable code)
-solutions to the same problem statement. But we needed to grow the
-toy code to explore another aspect of IDEs, which for some people
-are a big reason to use them: organizing complex code bases. And
-you don't expect me to put a full-blown Pet Store example in this
-book to get to that point, do you?
+단순성을 좋아한다면 지난 예제를 과도하게 고친 이유를 물을지(혹은 독자의 성격에 따라서는 욕을 할지) 모른다. 
+같은 문제 구문에 대해 (더욱 간결하고 이해하기 쉬운 코드라는 의미에서) 더 간단한 해결책이 있다. 
+하지만 우리는 장난감 코드를 좀 더 발전시켜서 통합개발환경의 또 다른 측면, 즉 사람들이 통합개발환경을 사용하는 이유인 복잡한 코드 바탕의 조직화에 대해 살펴볼 필요가 있다. 
+그러니 이 책에서는 본격적인 애완동물 상점 예제를 기대하지 않기 바란다.
 
-So, let's suppose that the complications we introduced (mainly the
-registry of UIs exposed via decorators) are perfectly justified,
-because we are working on a slightly complicated problem. In other
-words: let's extrapolate.
+그러면, 우리가 약간 복잡한 문제를 다루고 있기 때문에 (주로 장식자를 통해 노출된 UI의 등록) 확실하게 납득할 만한 복잡성에 직면하고 있다고 가정하자. 
+다시 말해서, 추정하자.
 
-The point is, we know that the great majority of our projects can't
-be confined to just one file (one Python module). Even our very
-dumb example is starting to get unpleasant to read. And, when we
-realize that we need more than one module, we also realize we need
-to group our modules under a common umbrella, to keep it clear that
-our modules form a coherent thing together and to lower the chances
-of name clashing with other projects. So, as seen in Chapter 8, the
-Python solution to this problem is modules and packages.
+요점은, 우리의 프로젝트의 거의 대부분을 단 하나의 파일(한 개의 파이썬 모듈)에 국한할 수 없다는 사실이다. 
+심지어 우리의 아주 바보 같은 예제는 읽기에도 불쾌해지기 시작한다. 
+그리고, 우리가 한 개의 모듈 이상을 필요로 한다는 것을 깨달을 때, 우리 모듈이 가까운 것들을 함께 그리고 다른 프로젝트와 이름이 충돌하는 기회를 줄이기 위해 공통된 우산 아래로 그룹화할 필요가 있다는 것을 깨닫는 것이다. 
+따라서, 8장에서 보았던 것과 같이, 이러한 문제에 대한 파이썬의 해결책은 모듈과 패키지이다.
 
-Our plan is to organize the code as follows: everything will go
-under the package 'hello.' The core logic, including the language
-support, will go into the package itself (into its __init__.py
-file) and each UI will go into its own module under the 'hello'
-package. The main.py script will remain as the command line entry
-point.
+우리의 계획은 모든 것을 'hello' 패키지 아래에 오도록 코드를 구성하는 것이다.
+언어 지원 등의 핵심 로직은 패키지 자체(__init__.py 파일)로 보내고, 각 UI는 'hello' 패키지 아래의 자체 모듈 아래로 이동하는 것이다. 
+main.py 스크립트는 명령줄 진입 지점으로 남겨둔다.
 
-Right-click on the project and select New>PyDev Package. Enter
-'hello' as the Name and click Finish. PyDev will create the package
-and open an editor for its __init.py__ file. As we said, we
-will move the core logic to this package, so this file will contain
-the following code, extracted from our previous version of the main
-code:
+프로젝트를 오른쪽 클릭하고 새로 작성>PyDev 패키지를 선택한다. 
+이름으로 'hello'를 입력하고 완료를 클릭한다.
+PyDev가 패키지를 생성하고 그것의 __init__.py 파일이 편집기에서 열릴 것이다. 
+우리가 말했듯이, 우리는 이 패키지의 핵심 로직을 이동시킬 것이므로, 이 파일은 이전 버전의 메인 코드로부터 추출한 다음과 같은 코드를 가질 것이다.
 
-Listing 11-4.
+예제 11-4.
 ::
     
     # -*- coding: utf-8 -*-
 
 
 
-Note that we embraced the idea of modularizing our code, providing
-exceptions to notify clients of problems when calling the greeter,
-instead of directly printing messages on the standard output.
+우리는 우리의 코드를 모듈화하는 아이디어를 받아들여서, greeter를 호출할 때 발생하는 문제를 표준 출력에 직접 찍는 대신, 클라이언트에게 알려주는 예외를 제공할 것임에 주의하라.
 
-Now we will create the hello.console module containing the console
-UI. Right-click on the project, select New>PyDev Module, Enter
-'hello' as the Package and 'console' as the Name. You can avoid
-typing the package name if you right-click on the package instead
-of the project. Click Finish and copy the print_message
-function there:
+이제 우리는 콘솔 UI를 갖는 hello.console 모듈을 생성했다.
+프로젝트를 마우스 오른쪽 단추로 누르고, 새로 만들기>PyDev Module을 선택하고, 'hello'를 패키지로, 'console'을 이름으로 입력하라.
+프로젝트 대신 패키지를 오른쪽 클릭한다면 패키지 이름을 타이핑하는 것을 피할 수 있다.
+완료를 클릭하고 print_message 함수를 거기에 복사한다.
 
-Listing 11-5.
+예제 11-5.
 ::
     
     from hello import register_ui
 
 
 
-Likewise, create the window module inside the hello package, and
-put there the code for show_message_as_window:
+마찬가지로, hello 패키지 내부 창 모듈을 만들고 거기에 show_message_as_window에 대한 코드를 삽입 :
 
-Listing 11-6.
+예제 11-6.
 ::
     
     from javax.swing import JFrame, JLabel
 
 
 
-Finally, the code for our old main.py is slightly reshaped into the
-following:
+마침내, 우리의 오랜 main.py는 아래와 같이 모양이 약간 바뀌었다.
 
-Listing 11-7.
+예제 11-7.
 ::
     
     import sys
 
 .. tip:: 
 
-   Until now, we have used PyDev's wizards to create new modules and
-   packages. But, as you saw on Chapter 7, modules are just files with the
-   ``.py`` extension located on the ``sys.path`` or inside packages, and
-   packages are just directories that happen to contain a ``__init__.py``
-   file. So you may want to create modules using :menuselection:`New --> File`
-   and packages using :menuselection:`New --> Folder` if you don't like the
-   wizards.
+   지금까지는, PyDev의 마법사를 사용하여 새로운 모듈과 패키지를 생성하였다.
+   하지만, 7장에서 본 것과 같이, 모듈은 그저 ``sys.path`` 또는 내부 패키지에 위치한 ``.py`` 확장자를 가진 파일일 뿐이며, 패키지는 ``__init__.py`` 파일을 가지게 된 디렉토리에 불과하다.
+   그러므로 마법사를 쓰는 것이 내키지 않는다면, :menuselection:`New --> File`\ 을 사용하여 새로운 모듈을 만들거나 :menuselection:`New --> Folder`\ 를 사용하여 패키지를 만들 수 있다.
 
 
-Now we have our code split over many files. On a small project,
-navigating through it using the left-side project tree (called the
-PyDev Package Explorer) isn't difficult, but you can imagine that
-on a project with dozens of files it would be. So we will see some
-ways to ease the navigation of a code base.
+이제 우리의 코드는 많은 파일로 분할되어 있다.작은 프로젝트에서는 왼쪽편 프로젝트 트리(PyDev 패키지 탐색기라고 한다)를 돌아다니는 것이 어렵지 않겠지만, 수십 개의 파일이 있는 프로젝트라면 만만치 않을 것이다.
+그래서 코드를 찾기 쉽게하게 하는 몇 가지 방법을 알아보겠다.
 
-First, let's suppose you are reading main.py and want to jump to
-the definition of the hello.greet function, called on line 17.
-Instead of manually changing to such a file and scanning until
-finding the function, just press Ctrl and click greet. PyDev will
-automatically move you into the definition. This also works on most
-variables and modules (try it on the import statements, for
-example).
+첫째, main.py를 읽고 있으며, 17행에서 호출하는 hello.greet 함수의 정의로 이동하고 싶다고 하자.
+수동으로 그 파일로 이동하여 그 함수를 찾는 대신에, 그저 Ctrl을 누르고 greet을 클릭한다.
+PyDev는 자동으로 그 정의로 이동합니다.이것은 대부분의 변수나 모듈에 대해서도 동작한다(예제의 import 문에 대해서 시도해보라).
 
-Another good way to quickly jump between files without having to
-resort to the Package Explorer is to use Ctrl + Shift + R, which is
-the shortcut for "Open Resource". Just type (part of) the file name
-you want to jump to and PyDev will search on every package and
-directory of your open projects.
+패키지 탐색기에 의지하지 않고 파일 사이를 넘나들 수 있는 또 다른 좋은 방법으로 "자원 열기"의 지름길인 Ctrl + Shift + R이 있다.
+그냥 열고 싶은 파일 이름의 일부분만 치면 PyDev가 열려있는 프로젝트의 모든 패키지와 디렉토리를 검색해준다.
 
-Now that you have many files, note that you don't need to
-necessarily have the file you want to run opened and active on the
-editor. For every script you run (using the procedure in which you
-need to be editing the program and then press Ctrl + F11) the IDE
-will remember that such script is something you are interested in
-running and will add it to the "Run History". You can access the
-"Run History" on the main menu under Run -> Run History, or in the
-dropdown button located in the main toolbar, along the green "play"
-icon. In both places you will find the latest programs you ran, and
-many times using this list and selecting the script you want to
-re-run will be more convenient than jumping to the script on the
-editor and then pressing Ctrl + F11.
+많은 파일이 있으니, 수행하고 싶은 파일을 반드시 열어서 편집기에서 활성화시켜야 할 필요는 없다는 것을 알아두라.
+(프로그램을 편집한 다음 Ctrl + F11을 누르는 절차를 사용하여) 수행하는 모든 스크립트에 대해 통합개발환경은 수행중에 관심 있는 것을 기억하여 "히스토리 실행"에 추가한다.
+주 메뉴의 실행 -> 히스토리 실행 또는 주 도구모음의 녹색 "실행" 아이콘의 드롭다운 버튼을 통해 "히스토리 실행"에 접근할 수 있다.
+두 곳 모두에서 최근에 수행한 프로그램을 찾을 수 있으며, 이 목록을 사용하여 재실행하고자 하는 스크립트를 선택하는 것이 스크립트로 이동하여 Ctrl + F11을 누르는 것보다는 한층 편리할 것이다.
 
-Finally, the IDE internally records a history of your "jumps"
-between files, just like a web browser do for web pages you visit.
-And just like a web browser you can go back and forward. To do
-this, use the appropriate button on the toolbar or the default
-shortcuts which are Ctrl + Left and Ctrl + Right.
+마지막으로, 웹 브라우저에서 웹 페이지를 방문하는 것과 마찬가지로 통합개발환경은 내부적으로 파일을 넘나든 기록을 갖고 있다.
+그러므로 마치 웹 브라우저처럼 앞뒤로 이동할 수 있다.
+이동을 위해서는 도구모음의 적당한 버튼을 누르거나 기본 지름길인 Ctrl + 왼쪽화살표 및 Ctrl + 오른쪽화살표를 누르면 된다.
 
-Testing
--------
+테스트
+------
 
-Okay, it's about time to explore our options to test our code,
-without resorting to the cumbersome manual black box testing we
-have been doing changing the command line argument and observing
-the output.
+자, 이제는 우리가 여태껏 명령 줄 변수를 바꿔가며 출력결과를 관찰해왔던 성가신 수동 블랙 박스 테스트에 의지하지 않고 우리의 코드를 시험할 수 있는 선택 사항들을 살펴볼 시간이다.
 
-PyDev supports running PyUnit tests from the IDE, so we will write
-them. Let's create a module named tests on the hello package with
-the following code:
+PyDev는 통합개발환경에서 PyUnit 테스트를 실행할 수 있도록 지원하며, 우리는 그것을 작성할 것이다.
+다음 코드와 같이 hello 패키지에 tests라는 이름의 모듈을 생성하자.
 
-Listing 11-8.
+예제 11-8.
 ::
     
     import unittest
 
 
 
-As you can see, the test covers the functionality of the
-dispatching of messages to different UIs. A nice feature of PyDev
-is the automatic discovery of tests, so you don't need to code
-anything else to run the previous tests. Just right-click on the
-src folder on the Package Explorer and select Run As>Jython
-unit-test. You will see the output of the test almost immediately
-on the console:
+위와 같이 시험은 서로 다른 사용자 인터페이스에 메시지를 디스패치하는 기능을 커버한다.
+PyDev의 좋은 기능은 시험의 자동 발견으로, 이전의 테스트를 실행하기 위해 어떤 것도 코딩할 필요가 없다.
+그저 패키지 탐색기에서 src 폴더를 오른쪽 단추로 클릭하고 실행 도구>Jython unit-test를 선택하면 된다.
+거의 즉시 콘솔에서 시험 결과를 볼 수 있을 것이다.
 
-Listing 11-9.
+예제 11-9.
 ::
     
     Finding files...
     OK
 
 
-Python's unittest is not the only testing option on the Python
-world. A convenient way to do tests which are more black-box-like
-than unit test, though equally automated is doctest.
+파이썬의 unittest가 파이썬 세계에서 선택할 수 있는 유일한 시험 방법은 아니다.
+단위 테스트만큼 자동화되어 있으면서도, 더욱 블랙 박스답게 시험을 할 수 있는 편리한 방법인 doctest가 있다.
 
 .. note::
     
-    We will cover testing tools in much greater detail in
-    Chapter 18, so take a look at that chapter if you feel too
-    disoriented.
+    시험 도구에 대해서는 18장에서 자세히 다룰 것이므로, 따라가기 힘들면 그 장을 보기 바란다.
 
 
-The nice thing about doctests is that they look like an interactive
-session with the interpreter, which makes them quite legible and
-easy to create. We will test our console module using a doctest.
+doctests가 좋은 점은, 그것들이 번역기의 대화식 세션과 같이 보이기 때문에 상당히 읽기 쉽고 만들기 쉽다는 것이다.
+우리는 doctest를 사용하여 console 모듈을 시험할 것이다.
 
-First, click the right-most button on the console's toolbar (you
-will recognize it as the one with a plus sign on its upper
-left-hand corner, which has the Open Console tip when you pass the
-mouse over it). From the menu, select PyDev Console. To the next
-dialog, answer Jython Console. After doing this you will get an
-interactive interpreter embedded on the IDE.
+먼저, 콘솔의 도구막대(왼쪽 위 모서리에 더하기 기호로 된 것 옆에, 마우스로 지나칠 때 콘솔 열기라는 팁이 나오는 것)에서 오른쪽 클릭한다.
+메뉴에서, PyDev 콘솔을 선택한다.
+다음 대화 상자에서 Jython Console이라고 답한다.
+이렇게 하면 통합개발환경에 포함된 대화식 번역기를 쓸 수 있게 된다.
 
-Let's start exploring our own code using the interpreter:
+번역기를 사용하여 우리의 코드를 탐험하도록 하자.
 
-Listing 11-10.
+예제 11-10.
 ::
     
     >>> from hello import console
 
 
 
-We highly encourage you to type those two commands yourself. You
-will note how code completion also works on the interactive
-interpreter!
+이 두 명령을 직접 입력해보기를 강력히 권하는 바이다.
+코드 자동완성이 어떻게 대화식 번역기에서도 작동하는지 알게 될 것이다!
 
-Back to the topic, we just interactively checked that our console
-module works as expected. The cool thing is that we can copy and
-paste this very snippet as a doctest that will serve to
-automatically check that the behavior we just tested will stay the
-same in the future.
+본론으로 돌아가서, 우리는 콘솔 모듈이 예상대로 작동하는지 그저 대화식으로 확인해보았다.
+멋진 것은 우리는 이런 단편적인 코드(snipper)를 doctest에 복사하여 붙여넣음으로써, 방금 시험했던 것을 앞으로 똑같은 자동으로 실행하도록 만들 수 있다는 것이다.
 
-Create a module named doctests inside the 'hello' package and paste
-those three lines from the interactive console, surrounding them by
-triple quotes (because they are not syntactically correct Python
-code after all). After adding a little of boilerplate to make this
-file executable, it will look like this:
+'hello' 패키지에 doctest라는 이름의 모듈을 만들고 대화식 콘솔로부터 그 세 줄을 붙여넣어 세개씩으로 둘러싸서 붙여넣도록 하라(왜냐하면 그것들은 문법적으로는 전혀 올바른 파이썬 코드가 아니기 때문이다).
+이 파일을 실행가능하게 만들기 위해 간단한 상용구를 덧붙이고 나면, 이렇게 보일 것이다.
 
-Listing 11-11.
+예제 11-11.
 ::
     
     
 
 
 
-After doing this, you can run this test via the Run>Jython
-run*menu* while doctests.py is the currently active file on the
-editor. If all goes well, you will get the following output:
+이렇게 하고 나면, 편집기에서 doctests.py 파일이 활성화되어 있을 때 실행 도구>Jython Run *메뉴*\ 를 통해 이 시험을 실행할 수 있다.
+문제 없이 잘 된다면, 다음과 같은 출력을 얻을 것이다.
 
-Listing 11-12.
+예제 11-12.
 ::
     
     Trying:
     Test passed.
 
 
-After running the doctest you will notice that your interactive
-console has gone away, replaced by the output console showing the
-test results. To go back to the interactive console, look for the
-console button in the console tab toolbar, exactly at the left of
-the button you used to spawn the console. Then on the drop-down
-menu select the PyDev Console, as shown in Figure 11-4.
+Adoctest를 실행한 후에는 대화식 콘솔이 사라지고, 출력 콘솔에 시험 결과가 보여질 것이다.
+대화식 콘솔로 돌아가려면, 탭 도구막대에서 콘솔을 spawn하는데 사용하였던 단추의 바로 왼쪽에 있는 콘솔 단추를 찾으면 된다.
+그런 다음 그림 11-4에서와 같이 아래로 펼쳐지는 메뉴에서 PyDev 콘솔을 선택하자.
 
 .. image:: images/chapter11-pydev-console-select.png
    :alt: Bringing back the interactive console.
    
-Figure 11-4. Selecting PyDev Console
+그림 11-4. Selecting PyDev Console
 
-As you can see, you can use the interactive console to play with
-your code, try ideas, and test them. And later a simple test can be
-made just by copying and pasting text from the same interactive
-console session. Of special interest is the fact that, because
-Jython code can access Java APIs quite easily, you can also test
-classes written with Java in this way.
+보는 바와 같이, 대화식 콘솔을 사용하여 코드를 실행하고, 아이디어를 시도하고, 시험할 수 있다.
+그리고 나중에는 같은 대화식 콘솔 세션으로부터 텍스트를 단지 복사해서 붙여넣음으로써 간단히 시험해볼 수 있다.
+자이썬 코드는 자바 API에 아주 쉽게 접근할 수 있으므로, 자바로 작성한 클래스도 이런 식으로 시험해볼 수 있다는 것이 특히 흥미로운 점이라 하겠다.
 
-Adding Java Libraries to the Project
-------------------------------------
+자바 프로젝트에 라이브러리 추가
+-------------------------------
 
-Finally, we will show you how to integrate Java libraries into your
-project. We said some pages ago that we could add a 'speech'
-interface for our greeter. It doesn't sound like a bad idea after
-all, because (like with almost any aspect) the Java world has good
-libraries to solve that problem.
+끝으로, 프로젝트에 자바 라이브러리를 통합하는 방법을 보여주도록 하겠다.몇 페이지 앞에서 우리의 인사 프로그램에 '말하기' 기능을 추가할 수 있다고 했다.
+그리 나쁜 생각은 아닐 것이다. 자바 세계에는 (어떤 형태로든) 그 문제를 해결해줄 좋은 라이브러리가 있기 때문이다.
 
-We will use the FreeTTS library, which can be downloaded from
-http://freetts.sourceforge.net/docs/index.php. (You should download
-the binary version.)
+우리는 http://freetts.sourceforge.net/docs/index.php\ 에서 다운로드할 수 있는 FreeTTS 라이브러리를 사용할 것이다.(바이너리 버전을 다운로드해야한다.)
 
-After downloading FreeTTS, you will have to extract the archive on
-some place on your hard disk. Then, we will import a JAR file from
-FreeTTS into our PyDev project.
+FreeTTS을 다운로드 후, 하드 디스크에 어딘가에 압축을 풀어야 한다.그런 다음, FreeTTS로부터 우리의 PyDev 프로젝트에 JAR 파일을 가져온다.
 
-Right-click the project and select Import. Then choose General>File
-System and browse to the directory in which you expanded FreeTTS
-and select it. Finally, expand the directory on the left side panel
-and check the lib subdirectory. See Figure 11-5.
+프로젝트를 오른쪽 클릭하고 가져오기를 선택한다.그 다음에 일반>파일 시스템을 선택하고 FreeTTS가 있는 디렉토리를 선택한다.
+마지막으로, 왼쪽 패널에있는 디렉토리를 펼쳐서 lib 디렉토리를 선택한다. 그림 11-5를 보라.
 
 .. image:: images/chapter11-pydev-importing-freetts.png
    :alt: Importing ``freetts.jar`` into the PyDev Project
    
-Figure 11-5. Adding Java libraries to the project
+그림 11-5. 프로젝트에 자바 라이브러리 추가
 
-After clicking Finish, you will see that the files are now part of
-your project.
+마침을 클릭하면 해당 파일이 이제 프로젝트의 일부가 된 것을 볼 수 있을 것이다.
 
 .. tip::
     
-    Alternatively, and depending on your operating system, the
-    same operation can be performed copying the files or folders from
-    the file manager and pasting it into the project (either via menu,
-    keyboard shortcuts, or drag and drop).
+    사용중인 운영 체제에 따라, (메뉴, 단축키, 또는 드래그 앤 드롭을 통해) 파일 관리자에서 파일이나 폴더를 복사하여 프로젝트에 붙여넣음으로써 동일한 조작을 수행할 수 있다.
 
-Now, the files are part of the project, but we need to tell PyDev
-that lib/freetts.jar is a JAR file and should be added to the
-sys.path of our project environment. To do this, right-click on the
-project and select Properties. Then, on the left panel of the
-dialog, select PyDev - PYTHONPATH. Then click the 'Add zip/jar/egg'
-button and select the lib/freetts.jar file on the right side of the
-dialog that will appear. Click OK on both dialogs and you are ready
-to use this library from Python code.
+자, 파일은 프로젝트의 일부분이지만 우리는 lib 디렉토리 / freetts.jar은 JAR 파일이며, 우리의 사업 환경의 sys.path에 추가되어 있어야 PyDev 얘기해야합니다.
+그렇게 하려면, 프로젝트를 오른쪽 클릭하여 특성을 선택한다.
+다음으로, 대화 상자의 왼쪽 패널에서, PyDev - PYTHONPATH를 선택한다.
+Then click the 'Add zip/jar/egg' button and select the lib/freetts.jar file on the right side of the dialog that will appear.
+Click OK on both dialogs and you are ready to use this library from Python code.
 
 The code for our new hello.speech module is as follows:
 
-Listing 11-13.
+예제 11-13.
 ::
     
     from com.sun.speech.freetts import VoiceManager
 .. image:: images/chapter11-pydev-debug-session.png
    :alt: PyDev's Jython Debugger.
    
-Figure 11-6. Debugging perspective
+그림 11-6. Debugging perspective
 
 The perspective offers the typical elements of a debugger. In the
 upper left area in the contents of the 'Debug' tab we have the call
 right-hand area of the main IDE Window (which will have the Debug
 button pushed while staying in the debugging perspective).
 
-Conclusion about Eclipse
-------------------------
+이클립스에 대한 결론
+--------------------
 
-PyDev is a very mature plug-in for the Eclipse platform, which can
-be an important element in your toolbox. Automatic completion and
-suggestions help a lot when learning new APIs (both Python APIs and
-Java APIs!) especially if paired with the interactive console. It
-is also a good way to introduce a whole team into Jython or into a
-specific Jython project, because the project-level configuration
-can be shared via normal source control systems. Not to mention
-that programmers coming from the Java world will find themselves
-much more comfortable on a familiar environment.
+PyDev 당신의 도구 상자에 중요한 요소가 될 수있는 이클립스 플랫폼은 매우 성숙한 플러그인이다.자동 완성과 제안 기능은 특히 인터랙티브 콘솔에 대응하는 경우에 새로운 API(파이썬과 자바 양쪽 다!)를 배우는 데 있어 많은 도움이 된다.
+프로젝트 수준의 구성을 보통의 소스 관리 시스템을 통해 공유할 수 있으므로, 전체 팀에 자이썬 또는 특정 자이썬 프로젝트를 소개하기에도 좋다.
+자바 쪽에서 온 개발자들에게는 익숙한 환경이 주는 편안함은 말할 것도 없다.
 
-To us, IDEs are a useful part of our toolbox, and tend to shine on
-big codebases and/or complex code which we may not completely
-understand yet. Powerful navigation and refactoring abilities are
-key to the process of understanding such projects and are features
-that should only improve in the future. Even if the refactoring
-capabilities are not still as complete as the state of the art on
-Java IDEs, we encourage you to try them on PyDev: 'Extract local
-variable,' 'Inline local variable,' and 'Extract method' are quite
-useful. Even if the alternative of doing the refactor manually
-isn't as painful with Python as with Java (or any other statically
-typed language without type inference), when the IDE can do the
-right thing for you and avoid some mechanical work, you will be
-more productive.
+우리에게 통합개발환경은 우리 도구들 중에 유용한 부분이며, 우리가 미처 완전히 이해하지 못하고 있는 코드 기반 및 복잡한 코드를 빛나게 한다.
+강력한 네비게이션과 리팩토링 기능은 그러한 프로젝트를 이해하는 데 있어 주요한 프로세스이며 미래에 나아질 것이다.
+리팩토링 능력은 아직 자바 통합개발환경만큼 완전하지는 않지만, PyDev에 있는 'Extract local variable', 'Inline local variable', 'Extract method'는 꽤 유용하므로 써보기 바란다.
+파이썬에서는 수작업으로 리팩토링하는 것이 자바(혹은 type inference를 제공하지 않는 다른 정적 유형 언어)에서만큼 힘들지는 않다 하더라도, 통합개발환경이 기계적인 일을 대신 처리해주므로 생산성이 보다 높아질 것이다.
 
-Finally, the debugging capabilities of PyDev are superb and will
-end your days of using print as a poor man's debugger (seriously,
-we did that for a while!) Even more advanced Python users who
-master the art of import pdb; pdb.set_trace() should give it a
-try.
+끝으로, PyDev의 디버깅 능력은 대단하므로 가난한 자의 디버거 마냥 print를 사용할 일은 없어질 것이다.(사실 우리가 그동안 그렇게 해왔다!)
+import pdb; pdb.set_trace()의 비법을 마스터한 파이썬 고급 사용자라고 해도 한번쯤 시도해보기 바란다.
 
-Now, PyDev isn't the only IDE available for Jython. If you are
-already using the Netbeans IDE or didn't like Eclipse or PyDev for
-some reason, take a look at the rest of this chapter, in which we
-will cover the Netbeans plug-in for Python development.
+자, PyDev만 자이썬에서 유일한 통합개발환경은 아니다.넷빈 통합개발환경을 이미 사용하고 있거나, 어떤 이유로 해서 이클립스 및 PyDev를 좋아하지 않는다면, 이 장의 나머지 부분에서 파이썬 개발을 위한 넷빈 플러그인을 다룰 것이니 살펴보기 바란다.
 
-Netbeans
-========
+넷빈
+====
 
 The Netbeans integrated development environment has been serving
 the Java community well for over ten years now. During that time,
 by now that includes additional packages that you may wish to use.
 As this is the case, go ahead and add your
 Jython installation as a platform option and make it the default
-(see Figure 11-7).
+(see 그림 11-7).
 
 .. image:: images/chapter11-nbplatformmgr.jpg
    :alt: Netbeans Python Platform Manager.
    
-Figure 11-7. Adding your Jython installation as a platform option
+그림 11-7. Adding your Jython installation as a platform option
 and making it the default
 
 To do so, click on the New button underneath the platform listing.
 
 .. image:: Ch11JuneauJythonIDE_files/image016.png
 
-Figure 11-8.
+그림 11-8.
 
 If you are interested in utilizing a Java API that exists within
 the standard Java library, then you are in great shape. As you
 previously downloaded to your project classpath. You will also have
 to add the jython.jar file for the appropriate version of Jython
 that you wish to use. In our case, we will utilize the Jython 2.5.1
-release. See Figure 11-9.
+release. See 그림 11-9.
 
 
 
 .. image:: Ch11JuneauJythonIDE_files/image018.png
-Figure 11-9. Adding the JAR file
+그림 11-9. Adding the JAR file
 
 The next step is to ensure that any and all Jython modules that you
 wish to use are in your CLASSPATH somewhere. This can be easily
 Netbeans Java debugger, you may want to de-select the 'Stop at the
 first line' checkbox. Otherwise the debugger will not load your
 module right away, but rather stop execution at the first line of
-your module and wait for you to continue. See Figure 11-10.
+your module and wait for you to continue. See 그림 11-10.
 
 .. image:: Ch11JuneauJythonIDE_files/image020.png
-Figure 11-10. The Netbeans Python debugger
+그림 11-10. The Netbeans Python debugger
 
 Making use of the Python debugger included with Netbeans is much
 like working from the Jython interactive interpreter from the
 margin to the left of the line in your code where you would like
 the debugger to halt program execution. In our case, let's open the
 HockeyRoster.py module and set a breakpoint in the code as shown in
-Figure 11-11.
+그림 11-11.
 
 .. image:: Ch11JuneauJythonIDE_files/image022.png
-Figure 11-11. Setting a breakpoint in the code
+그림 11-11. Setting a breakpoint in the code
 
 
 Now that we've set a breakpoint, we need to start our debugger.
 so, right-click on your project and select Properties. When the
 properties window opens, select Run in the left-hand side of the
 window. You should now type or browse to the module that you wish
-to use as a starting point for your program. See Figure 11-12.
+to use as a starting point for your program. See 그림 11-12.
 
 .. image:: Ch11JuneauJythonIDE_files/image024.png
 
-Figure 11-12. Click Browse to select the module you wish to use as
+그림 11-12. Click Browse to select the module you wish to use as
 a starting point.
 
-Note that this may already be automatically filled in for you by
-Netbeans. Once you've ensured that you have set the main module,
-you can begin the debugging session. To do so, you can either
-select your program and use the Debug menu option, or you can
-right-click on the project and select Debug. Once you've started
-the debugger, you will see a series of messages appearing in the
-debugging window near the bottom of the IDE window to indicate that
-the debugger has been started. After a few seconds, you will see
-the messages stop writing in the debugger output window, and the
-editor will focus on the first line of code in your main module and
-highlight it in green. See Figure 11-13.
+이것은 이미 Netbeans에 의해 자동으로 채워져있을 수도 있다.
+일단 주 모듈을 설정했음을 확인했다면, 디버깅 세션을 시작할 수 있다.
+그렇게 하려면 프로그램을 선택하고 Debug 메뉴를 선택하거나, 프로젝트를 오른쪽 클릭하여 Debug를 선택하면 된다.
+디버거를 일단 시작하면, IDE 아래쪽의 디버깅 창에 디버거가 시작되었음을 알리는 메시지들이 나타나는 것을 볼 수 있을 것이다.
+몇 초 후에 디버거 출력 창에 메시지가 나타나는 것이 멈추면, 편집기에서 주 모듈의 첫 행에 초점이 맞춰지고 녹색으로 표시될 것이다.
+그림 11-13을 보라.
 
 .. image:: Ch11JuneauJythonIDE_files/image026.png
-Figure 11-13. Beginning the debugging session
+그림 11-13. 디버깅 세션을 시작
 
-To continue the debugger to the first line of code that is
-executed, select the green Continue button in the toolbar, or press
-the F5 key. You should see the program will begin to execute within
-the debugger output window and it will halt to allow us to enter a
-selection. See Figure 11-14.
+첫 줄에 걸려있는 디버거를 계속 하려면, 도구모음에서 녹색의 Continue 단추를 선택하거나 F5 키를 누른다.
+디버거 출력창을 통해 프로그램이 실행되기 시작하고, 선택을 입력할 수 있도록 멈추는 것을 볼 수 있을 것이다. 
+그림 11-14를 보라.
 
 
 
 .. image:: Ch11JuneauJythonIDE_files/image028.png
-Figure 11-14. The debugger output window
+그림 11-14. 디버거 출력 창
 
-Make sure your cursor is within the debugger output window and
-enter 1 to add a player. When you hit the Enter button to continue,
-the program will not continue to execute, but instead it will halt
-at the breakpoint that we have set up. In the editor you will see
-the line which we added a breakpoint to is now highlighted in
-green. The debugger has suspended state at this point in the
-program, and this affords us the ability to perform tasks to see
-exactly what is occurring at this point in the program. For
-instance, if you select the Variables tab in the lower portion of
-the Netbeans IDE, you will be able to see the values of all local
-variables at this current point in the program. See Figure 11-15.
+커서가 디버거 출력창에 있는지 확인하고 1을 입력하여 선수를 추가한다.
+Enter 단추를 눌러서 계속하면, 프로그램은 실행을 계속하는 대신, 여러분이 지정해둔 중단점에서 멈춘다.
+중단점으로 설정해둔 행이 편집기에서 녹색으로 강조된 것을 볼 수 있을 것이다.
+이때 디버거는 이 프로그램에서 정지 상태이며, 그로 하여금 프로그램이 이 시점에서 정확히 무슨 일이 벌어지고 있는지 확인할 수 있도록 해준다.
+예를 들어, 넷빈 IDE 하단의 Variables 탭을 선택하면, 프로그램의 현재 상태의 모든 지역 변수를 볼 수 있다. 그림 11-5를 보라.
 
 .. image:: Ch11JuneauJythonIDE_files/image030.png
-Figure 11-15. The values of all local variables at this current
-point in the program
+그림 11-15. 프로그램의 현재 시점에서의 모든 지역 변수의 값
 
-You can also select the Call Stack tab to see the execution order
-of your program to this point. See Figure 11-16.
+또한 Call Stack 탭을 선택하여 프로그램의 현 시점의 실행 순서를 볼 수 있다. 그림 11-5를 보라.
 
 .. image:: Ch11JuneauJythonIDE_files/image032.png
-Figure 11-16. The execution order of your program
+그림 11-16. 프로그램의 실행 순서
 
-Once you've evaluated the program at the breakpoint, you can
-continue the program execution by stepping forward through the code
-using the buttons in the toolbar. You can also click the Continue
-button to run the program until it reaches the next breakpoint, or
-in this case because we have no more breakpoints, it will just
-continue the program execution as normal. The debugger is
-especially helpful if you are attempting to evaluate a specific
-line of code or portion of your program by stepping through the
-code and executing it line by line.
+일단 중단점에서 프로그램을 평가한 후에는, 도구모음의 단추를 사용하여 코드를 한 단계 진행할 수 있다.
+Continue 단추를 클릭하여 다음 중단점까지 프로그램을 실행할 수 있으며, 더 이상 중단점이 없는 경우에는 정상적으로 프로그램의 실행을 계속하게 된다.
+디버거는 코드를 단계적으로 진행하면서 한 줄, 한 줄 실행시키면서 프로그램 코드의 특정한 행을 평가하고자 할 때에 특히 유용하다.
 
 
-Another nice feature of the debugger is that you can set certain
-conditions on breakpoints. To do so, set a breakpoint in your code
-and then right-click on the breakpoint and select Breakpoint and
-then Properties from the resulting window. At this point you will
-see the additional breakpoint options. In this case, set up a
-condition that will cause the debugger to halt only if the
-*selection* variable is equal to 3, as shown in Figure 11-17.
+디버거의 또 다른 좋은 점은 중단점에서 특정한 조건을 설정할 수 있다는 것이다.
+코드에서 중단점을 설정하고 오른쪽 클릭하여, 창에서 Breakpoint를 선택한 다음 Properties를 선택한다.
+그렇게 하면 추가적인 중단점 선택사항이 표시된다.
+이 경우에는, 그림 11-17과 같이 조건을 설정하여 디버거가 *selection* 변수의 값이 3일 때에만 멈추도록 한다.
 
 .. image:: Ch11JuneauJythonIDE_files/image034.png
 
-Figure 11-17. Setting a condition for halting the debugger
+그림 11-17. 디버거 중단 조건 설정
 
-At this point you can run the debugger again, and if you select the
-option of 3 during your program execution you will notice that the
-debugger will halt.
+디버거의 실행을 재개할 수 있으며, 프로그램 실행 중에 3을 선택하면 디버거가 중단됨을 알 수 있을 것이다
 
-The Netbeans Python debugger offers enough options to fill up an
-entire chapter worth of reading, but hopefully the content covered
-in this section will help you get started. Once you've mastered the
-use of the debugger, it can save you lots of time.
+넷빈 파이썬 디버거는 이 장 전체를 채울 만큼 많은 기능을 제공하지만, 여러분이 시작하기에는 특히 이 섹션에서 다룬 내용이 도움이 되기를 기대한다.디버거의 사용법을 익히고 나면, 많은 시간을 절약할 수 있을 것이다.
 
-Other Netbeans Python Features
-==============================
+또 다른 넷빈 파이썬 기능
+========================
 
-There are a number of additional features in the Netbeans Python
-IDE support that we haven't touched upon yet. For instance, minimal
-refactoring support is available for any Python module. By
-right-clicking on the module in the project navigator or within a
-module, a bevy of additional options become available to you via
-the right-click menu. You'll see that there is a Refactoring option
-that becomes available. However at the time of this writing the
-only available refactoring options were Rename, Move, Copy, and
-Safely Delete. There is a Navigate feature that allows for one to
-perform shortcuts such as highlighting a variable and finding its
-declaration. The Navigate feature also allows you to jump to any
-line in your code by simply providing a line number. If your Python
-class is inheriting from some other object, you can use the
-Navigate feature to quickly go to the super implementation. It is
-easy to find the usages of any Python module, method, function, or
-variable by using the Find Usages feature. If your code is not
-formatted correctly, you can quickly have the IDE format it for you
-by choosing the Format option, which is also available in the
-right-click menu.
+넷빈 파이썬 IDE에는 우리가 손대지 않은 다른 많은 기능이 있다. 예들 들어, 임의의 파이썬 모듈에 대한 최소한의 리팩토링을 지원한다.
+프로젝트 네비게이터 또는 모듈 내에서 오른쪽 클릭하면, 메뉴에서 추가적인 선택을 할 수 있다. Refactoring 옵션을 사용할 수 있음을 알 수 있을 것이다.
+하지만 이 글을 쓰는 지금은 Rename, Move, Copy 그리고 Safely Delete만을 제공한다.
+변수를 강조하고 그것의 정의를 쉽게 찾아가도록 하는 Navigate 기능이 있다.
+또한 Navigate 기능은 행 번호를 가지고 코드를 쉽게 찾아갈 수 있도록 해준다.
+파이썬 클래스가 다른 개체를 상속하고 있다면, 역시 Navigate 기능을 통해 상위 클래스의 구현부로 쉽게 찾아갈 수 있다.
+Find Usages 기능을 사용하면 어떠한 파이썬 모듈, 메소드, 함수 및 변수를 쉽게 찾을 수 있다.
+코드가 제대로 포맷되지 않았다면, 오른쪽 클릭 메뉴에서 Format을 선택하면 IDE가 재빨리 포맷해준다.
 
-Another nice feature that is available in the right-click menu is
-Insert Code. This feature allows you to choose from a number of
-different templates in order to have the IDE auto-generate code for
-you. Once you select the Insert Code option, another menu appears
-allowing you to choose from a code templates including Property,
-Constructor, Method, and Class. Once a template is chosen, the IDE
-auto-generates the code to create a generic Python property,
-constructor, method, or class. You can then refine the
-automatically generated code to your needs. This feature allows the
-developer to type less, and if used widely throughout a program it
-can ensure that code is written in a consistent manner. See Figure
-11-18.
+오른쪽 클릭 메뉴의 또 다른 훌륭한 기능은 Insert Code이다.
+이 기능은 IDE 자동 생성 코드를 위하여 여러 템플릿들 중에 하나를 선택할 수 있도록 해준다.
+Insert Code를 선택하면, 다른 메뉴가 나타나서 Property, Constructor, Method 및 Class 중 하나의 코드 템플릿을 선택할 수 있도록 해준다.템플릿을 선택하면, IDE는 일반적인 파이썬 속성, 생성자, 메소드 또는 클래스의 코드를 자동으로 만들어준다.
+그런 다음 필요에 따라 자동으로 생성된 코드를 수정할 수 있다.
+이 기능은 개발자로 하여금 타자를 줄이고, 프로그램 전체에 걸쳐서 코드를 일관적으로 작성하도록 도와준다.
+그림 11-18을 보라.
 
 .. image:: Ch11JuneauJythonIDE_files/image036.png
 
-Figure 11-18. The very handy Insert Code option
+그림 11-18. 매우 편리한 Insert Code 옵션
 
-Another nice feature is Fast Import. This allows you to highlight
-an object in your code and automatically have the IDE import the
-required module for using the object. You also have the ability to
-Fix Imports, which will automatically clean up unused imports in
-your code.
+또 다른 멋진 기능으로 Fast Import가 있다. 이것은 개체를 사용하기 위해 필요한 모듈을 IDE가 자동으로 import해주는 기능이다.
+Fix Imports 기능도 있어서, 코드에서 사용하지 않는 import를 정리해준다.
 
-Along with all of the other features that are available with the
-Netbeans IDE, these additional features are like the icing on the
-cake! Keep in mind that you are not required to right-click each
-time that you wish to use one of these additional features, there
-are also keyboard shortcuts for each of them. The keyboard
-shortcuts will differ depending upon which operating system you are
-using.
+넷빈 IDE의 다른 모든 기능과 함께, 이러한 추가 기능들은 마치 케이크 위를 icing하는 것과 같다!
+이러한 추가적인 기능을 사용하기 위해 반드시 오른쪽 클릭을 할 필요 없이, 키보드 단축키를 사용할 수도 있다.
+단축키는 사용중인 운영 체제에 따라 차이가 있을 수 있다.
 
-Summary
-=======
+요약
+====
 
-As with most other programming languages, you have several options
-to use for an IDE when developing Jython. In this chapter we
-covered two of the most widely used IDE options for developing
-Jython applications, Netbeans and Eclipse. Eclipse offers a truly
-complete IDE solution for developing Jython applications, both
-stand alone and web-based. PyDev is under constant development and
-always getting better, adding new features and streamlining
-existing features.
+대부분의 다른 언어와 마찬가지로, 자이썬 개발에 있어서는 몇 가지 IDE 가운데에서 선택을 할 수 있다.
+이 장에서는 자이썬 개발에 있어서 가장 널리 사용되는 IDE인 넷빈과 이클립스를 살펴보았다.
+이클립스는 독립실행 및 웹 기반 양쪽의 자이썬 개발에 있어 완전한 IDE 솔루션이다. PyDev는 지속적으로 개발 및 개선이 이루어지고 있으며 새로운 기능이 계속 추가되고 있다.
 
-Netbeans Jython support is in still in development at the time of
-this writing. Many of the main features such as code completion and
-syntax coloring are already in place. It is possible to develop
-Jython applications including Jython and Java integration as well
-as web-based applications. In the future, Netbeans Jython support
-will develop to include many more features and they will surely be
-covered in future releases of this book.
+넷빈은 이 글을 쓰고 있는 현재 자이썬에 대한 지원이 개발중이다. 코드 완성과 구문 색상 강조 등의 주요 기능은 이미 자리를 잡고 있다.
+웹 기반 애플리케이션은 물론 자이썬과 자바 통합을 포함하는 자이썬 애플리케이션의 개발이 가능하다.
+앞으로, 넷빈의 자이썬 지원은 더욱 많은 기능을 지원하여 앞으로의 릴리스에서는 이 책을 모두 커버할 것이다.
 
-In the next chapter, we will take a look at developing some
-applications utilizing databases. The zxJDBC API will be covered
-and you'll learn how to develop Jython applications utilizing
-standard database transactions. Object relational mapping is also
-available for Jython in various forms, we'll discuss many of those
-options as well.
+다음 장에서, 우리는 데이터베이스를 사용하는 애플리케이션을 살펴볼 것이다.
+zxJDBC API를 다룰 것이며 표준 데이터베이스 트랜잭션을 사용하여 자이썬 애플리케이션을 개발하는 방법을 배울 것이다.
+개체 관계 대응 또한 여러 가지 형태로 자이썬에서 사용할 수 있으며, 많은 선택사항에 대하여 논의할 것이다.