Python Programming in the Eclipse IDE

.

Here too, we can put a check in the Remember my decsion checkbox: doing so says to terminate in the future without prompting for confirmation. Or, we can leave this box unchecked (recommended), at the cost of having to click the OK button in this window every time that we stop Eclipse by clicking the terminate window button; on the positive side, we won't accidentally terminate Eclipse, because we need to confirm the termination.

If we ever put a check in one of these "do not prompt again" checkboxes, but later want to restore these prompts, we can do it as follows. Once Eclipse appears on the screen, select Window | Preferences. Then disclose General (click its disclosre icon) and Startup and Shutdown (ditto) and then click on the Workspaces entry. We should ultimately see the following window (I am running this on my own computer, where my username is pattis).

.

We can check or uncheck the Prompt for workspace on startup box for our preference (recommended to leave this box checked), then click Apply and Close (or just Apply to see/set more preferences).

Now click on Startup and Shutdow entry. You should see the following window.

.

We can check or uncheck the Confirm exit when closing last window box for our preference (recommended to leave this box checked), then click Apply and Close (or just Apply to see/set more preferences).

Practice starting and stopping Eclipse, setting these prompt/confirm preferences as described above, and observing their behavior. After starting Eclipse, change the size of its main window, and note that when you stop and then restart it, the window will be the same size: Eclipse remembers the size of this window. In fact, once we start using Eclipse for real programming, whenever it starts it will appear exactly as it appeared when we last stopped it (same size, same geometry, same files open, etc). Therefore, it is simple to resume working in exactly the same context that we were in when we lat stopped Eclipse.

While we are examining preferences, let's illustrate one more that is useful. Select Window | Preferences | PyDev | Editor | Auto Imports and uncheck the Do auto import? checkbox (illustrated below) and then click Apply and Close (or just Apply to see/set more preferences).

Doing so is especially important for Mac users, relating to our automatic grading program, which I run on my PC.

If we want the names of the perspectives to appear in the icon, we can right-click any icon and chose Show Text as follows

and these perspective icons would appear as

View: Each perspective contains a variety of views that allow us to view, navigate, and edit information about a project. So, views are not just for looking: we can use views to change information too. A view may appear as a single tab, or it may be one of many tabs in a tabbed window, containing many views, of which only one is active at a time- the top one. The PyDev perspective contains a variety of standard views illustrated above. Going clockwise from the top left,

• The PyDev Package Explorer view is the only tab in a window that shows all the code (modules and libraries, and their files) under a project name. Here the project name is Demo and it contains a module named Script.py. The next line (Python37...) shows the libraries available; we can disclose it (by clicking the >), and if we do, we can then elide it (by clicking the v that replaced the >).

• An Editor view is a tabbed window containing one tab per file being edited; here the only file being edited is a module named Script.py so there is only one tab in this editor window. The tab contains the name (here Script) of the resource being edited; if we hover over the tab that views a .py file, Eclipse displays the name of the project folder and the module name itself: here Demo/Script.py. If the resource is not in a project (e.g., a module in a library), its path is displayed before its folder's name.

• The Outline view is the only tab in a window that shows a high-level outline: where names (imports, variables, and functions/methods) in the module in the active editor tab are defined or redefined. When can click a name in the Outline view, the Python code (re)defining that name will appear in its Editor tab; so the Outline view is one way to navigate a large file containing Python code. The Script.py file is trivial, so the outline contains no usefule information for this example.

.

Because these views are related, some information is propagated into multiple views: e.g., the red indicators that there are syntax errors in the code. When such errors appear/disappear in/from one window, they often simultaneously appear/disappear in/from others.

Toolbar: The workbench toolbar appears under the menu bar that includes the drop-down menus labeled File, Edit, Refactoring, etc. The toolbar's buttons here act as short cuts for common operations in a perspective; we can also invoke these operations with the pull-down menus, but clicking these buttons is faster. The picture above labels the Make New, Debug, and Run/Rerun buttons, which are the most useful. The buttons on the toolbar change when we change the perspective. We can customize toolbars within a perspective, but we will not cover this topic here.

Generally, we can manipulate the perspective and views (in a perspective) in a few interesting ways.

Perspectives:

• We can remove a perspective name from the workbench by right-clicking its icon and selecting Close: we did this for the Java perspective, which we don't need, but initially appeared when we installed Eclipse.

• We can restore a closed perspective name P by selecting Window | Open Perspective | P or by clicking the Open Perspective button and selecting P.

• We can elide a perspective name, just displaying its icons by right-clicking any perspective and then selecting Show Text (toggling whether its text is shown).

• We can rearrange the order of perspectives by closing them all and then restoring them in the order we want them to appear: PyDev followed by Debug is recommended. We can also do this for most perspecives by dragging/dropping them.

View:

• We can remove a view by right-clicking its tab and selecting Close, or pressing the X on its tab after the view's name.

• We can restore a view V by selecting Window | Show View | V.

• If two view tabs share a vertical boundary, we can drag the boundary left or right to change the relative size of the tabs (lengthing one and shotening the other); if two view tabs share a horizontal boundary, we can drag the boundary up or down to change the relative size of the tabs (lengthing one and shotening the other)

• We can dock view tabs/windows to create different tilings of a perspective, by dragging and dropping a tab/window in the desired configuration.

• We can restore all standard views for a perspective (and their standard tiling) by selecting Window | Perspective Reset Perspective... from the menu.

Finally we can click the triangle to the right of the Choose Active Console icon to see all active Consoles: at present, one run of the Demo.py script (numbered 1) and one PyDev Console (numbered 2, with a circle to its left, indcicating that it is the one we see in the Console view).

When we have multiple active Consoles, we can click any line here to select viewing that Console. We can also click the icon itself to show the "next" Console: "next" means the one labelled with the higher number, or the one labelled 1 if there is no higher number.

• Change Eclipse (Workbench Window) Size: We can increase or decrease the size of the entire Eclipse window by hovering over one of its boundaries (or corners) until the cursor turns into two opposite-pointing arrows, and then dragging and dropping the boundary (corner) to the desired location The view windows will adjust their size proportionately.

• Change Horizontal/Vertical Window Space Allocation: We can change the horizontal space allocation among windows by moving the mouse to the blue vertical boundary between any windows (the mouse icon becomes two horizontal arrows), and then dragging the boundary left or right. Likewise, we can change the vertical space allocation among windows by moving the mouse to the blue horizontal boundary between any windows (the mouse icon becomes two vertical arrows), and then dragging the boundary up or down. Window(s) on one side of the boundary expand as window(s) on the other side shrink. Scrolling bars may appear/disappear as needed by these adjustments.

• Minimize/Restore/Maximize Views: We can minimize or maximize any window by pressing the required icon, which appears at the right of any tabs in that window: (). If we minimize a window, we can restore it similarly (); if we maximize a window, we can minimize or midimize/restore it as well (). We can also toggle between a midimized/restored and maximized view by double-clicking its tab (the most useful operation of the bunch).

• Delete/Restore Views: We can delete any view/tab by clicking its terminate (X) button. We can restore any deleted view V via the Window pull-down menu by selecting Window | Show View | V.

• Move Views/Tabs: We can move any tab to any view. We do so by dragging the tab to the view that we want it to be positioned in: before, after, or between any other tabs for that view. We can also use this mechanism to change the order of the tabs in any view. For example, we can move the Console view so that it appears to the right of the Script tab in the Editor view; we can then change move to appear to the left of the Script tab.

• Rearrange View/Tab Window Docking Structure: We can rearrange how the windows dock with each other, to allow for increased flexibility in how views appear within a perspective. In docking operations, we click a tab or entire view (to select it) and then drag and drop it to the desired location (which can even be outside the Eclipse window: just floating on the desktop!). When dragged, one of a set of possible outlines will appear that indicates how the new docking will be performed. Here is a short movie illustrating docking commands in Eclipse. (download this .avi file; if double-clicking does not run it correctly (with picture and sound), try hovering over it -or right-clicking it- and clicking Windows Media Player.)

  By choosing Window | Perspective | Reset Perspective... from the menu, Eclipse will restore all the views in a perspective to the standard one for that perspective.

• Disclose in the PyDev Package Explorer View: In the PyDev Package Explorer view, click the disclosure trianglesd to examine/discose their contents (going from > to v) or hide/elide their contents (going from v to >).

• The file being edited has changed (see the file-change indicator).
• Disclosure circles appear for multi-line code: here a multi-line string and a multi-line function/method definition, both fully disclosed. By clicking, we can elide these to a single line or disclose their full contents.
• Which lines have changed (see the purple coloring of the line numbers); if the change is one or more deleted lines, a small horizontal line appears where the lines used to be).
• As the Editor view changes, the contents of the Outline view changes automatically: here we have defined a cheer_up as a function/method (see big M in frontof it) and sadness as a variable.

To save the changed contents of an Editor view to its file, right-click in the view and select Save; note that this option will not be selectable if the file has not changed: if the file-change indicator is absent. Another way to issues this command is just by typing ctrl/s on the keyboard when this tab is selected. After issuing this command, the file is updated to contain all the information currently in the tab for this module.

If instead we right-clicked the view and selected the Revert File command, the view would would be restored to the file's contents when it was last saved. So, use Save and Revert File carefully: we will be using Save much more than Revert File, and we can always select the Edit | Undo Typing command (or just press ctrl/z to undo any changes (and selecting this command multiple times undoes multiple changes; if we go too far with ctrl/z, we can press ctrl/y to redo undone commands). If we issued the Save command in the window above, it would be updated and appear as follows.

Note the disappearance of the asterisk (the file-changed indicator) and the purple change bars. Often, if we forget to save a file, and perform some othe operation in Eclipse -such as running a script- Eclipse will ask us whether to save the file(s) first.

In the Eclipse editor, whenever we type an opening delimiter -e.g., a parenthesis, brace, bracket, or quotation mark- the editor automatically supplies the matching closing delimeter, and then repositions the cursor between the two so, that we can easily type the delimited entity. Related to this behavior, if the cursor is followed by a closing delimiter, and we type that same closing delimiter, the Editor just moves the cursor past it. This editor behavior can be a little confusing, until we get used to it; but for writing programs, this is useful behavior.

Likewise, whenever we double-click directly after an opening delimiter (except for the quotation mark), the editor automatically highlights all information between that delimiter and its matching closing delimiter. Below I double-clicked just to the right of the first opening parenthesis on line 10.

This operation -matching opening and closing delimiters- is often useful when we are debugging (removing errors from) our programs: errors related to correctly matching opening to closing delimiters.

We can hide any mult-line code (here the top string and cheer_up function/method) from the Editor view by clicking its disclosure circle. Generally throughout Eclipse clicking on a + means disclose the elided information; clicking on a - means hide the disclosed information. In the Editor view below, we have hidden the cheer_up function/method: notice how it shows the header of the method, but not its body, instead showing . With this mechanism we can temporarily hide the parts of our Python code that we are not currently interested in seeing in detail, allowing us to see more code in the tab that we are interested in seeing.

In fact, if we hover over a disclosure circle that is eliding information, the cursor will change to a hand (not shown below) and Eclipse will temporarily display the elided information in a yellow box, while keeping it elided in the Editor view (so we can peek at it).

If we hover over a name in an Editor view, Eclipse shows us something interesting about that name: its definition.

If we click on a name in the Editor view, Eclipse selects that name as a token and shows us other places in that Editor window where this same name appears, by putting the name in a yellow background.

Likewise, in complicated modules, with many names, we can use the Outline view to rapidly examine selected names in the module. By clicking an entry in the Outline view, Eclipse shows us where it was defined in the Editor view (its defintion is outlined in blue) and where it is used (outlined in yellow).

Finally, whenever we start typing a token, Eclipse displays possible completions for that token based on Python keywords. Until it recognizes a correct token, Eclipse marks the code with a syntax error icon (), indicating an error (as illustrated below). We will soon learn how to find and fix Python syntax errors in Eclipse. Note that because we typed a p, the * indicator once again prefaces Script.

We can continue typing the token, or double-click one of the keywords to have Eclipse complete the token. If we press ↵ Eclipse will complete the token with the highlighted completion (and we can use the ↑ and ↓ keys to scroll through the possible completions before using ↵ to make our selection). Don't be distracted by this mechanism; it is probably best to just keep typing your code and ignore the completions. Pressing Shift/↵ tells Eclipse to ignore word complettion for this word.

In addition if we press the ctrl/space command when Eclipse present us with keyword completions, it will present us with other "useful" code that might go here. Below I have highlighted the pow selection, and Eclipse provides me with information about it in yellow on the right. I can scroll through or select one of these entries as described above.

Again, it is probably best to ignore these other completions for now. There is a delicate balance beetween what information you should supply and what information Eclipse should provide.

Now it is time to go back and enter into Eclipse all the code illustrated in this section, and reread and practice doing all the operations discussed. Remember to type the code carefully, with letters in their correct case, proper punctuation, and proper spacing. Watch carefully what happens when you pres ↵ on lines that do or don't end with a colon (and what the backspace key does on indented lines). Once you are done entering this code, you can go to the next section and learn about executing/runnning it.

The most important thing to say here is that we need to terminate a launch before we can remove it from the Console view. There are two ways to do each.

1. Terminate Current Launch: terminate the script running in the Console view. It might be waiting for input, producing lots of/no output (talkative and silent infinite loops). It is an excellent idea to ensure that each running script is terminated before you rerun it to avoid clogging the computer with running scripts.

2. Remove Current Launch: remove the terminated script from the Console view (it must be already terminated to remove it). If there are other scripts running (or the Python Interpreter is runnning) one of those will take the place of the removed launch in the Console view. See Display Active Console or Cycle through Active Consoles to select any other launch to put in the Console.

3. Remove All Terminated Launches: remove all terminated scripts from appearing in the Console view. This is a big cleanup operation to get rid of (so they will never be seen again) all terminated scripts. You might want to keep around multiple terminated scripts, to see the different outputs they produce (but won't need to do this often).

4. Terminate Current Launch and Rerurn: terminate the current launch and rerun it in the same Consolve view.

5. Terminate All Launches: terminate all scripts running in all Console views. This is a big cleanup operation to terminate all scripts; typically it is followed by removing all these terminated scripts from the Console view.

6. Display Selected Console: select which console to show in the Console view. Click this black triangle to get a list of all scripts (running or terminated but not removed) and all Python Interpreters, which can be shown in the Console tab; choose which one to show.

7. Cycle through Active Consoles: see the next script in the Console view. Repeated clicking this button cycles through all scripts running and terminated (but not removed) and all Python Interpreters that can be selected.

8. Open Console: we used this to open the Python Interpreter in a Console tab. We can also use it to create more Console tabs, but that option is not very useful.

The biggest problems with Console views is that whenever we run a script (or start a Python Interpreter) it takes over the Console. If we need to see other launches, we must use the black triangle to the right of the Display Selected Console button to select one, or click the button itself to cycle through the various launches. It might be simpler to have multiple Console view tabs, but Eclipse doesn't support this features.

Practice all these operations until you are comfortable using the Console view while running and rerunning programs, and using the Python Interpreter.

• When Eclipse detects a problem at a token, often either that token is wrong, or the one before it is wrong (less frequently the incorrect token appears even earlier in the script, and even less frequently later). Check all these places in the appropriate order.
• Sometimes an error/warning message makes no sense: it says that there is one kind of problem in our code, but we actually have to correct a different kind of problem. Using Eclipse repeatedly will give you insight into how to interpret errors.
• Problems snowball: one mistake can cause many error/warning messages to appear; by fixing one mistake, many message may disappear.

• Fix the first problem (or if you are confident, the first few). If the a second error makes no sense, a previous error might be causing the problem (snowballing). Always find and fix at least one error; don't spend time fixing more than a few, because after fixing some earlier errors later ones might disappear or change.
• Save the script to see what syntax errors Eclipse reports.
• Try to run a program that shows a confusing error message; sometimes the error message will disappear or change to one that is clearer.
• Repeat this process until there are no syntax errors left.
• To make progress, we must correct at least one error during each editing session before saving the file. And, fixing only one error at a time ensures that we won't get confused by snowball errors.

  You can show the Problems view (Windows | Show View | Problems to see a summary of the errors. Here is what it would like for the Errors.py file above.

  

  Notice that the Problems view shows line 1 to have both an error and a warning: in the Editor view it just shows the (red) error. I don't recommend using this view: instead just work within the Editor view.