Python Code Running Assistance

Prerequisites

You have already created a Python project and populated it with the following code:
import math def demo(a, b, c): d = b ** 2 - 4 * a * c if d > 0: disc = math.sqrt(d) root1 = (-b + disc) / (2 * a) root2 = (-b - disc) / (2 * a) return root1, root2 elif d == 0: return -b / (2 * a) else: return "This equation has no roots" class Solver: pass if __name__ == '__main__': solver = Solver() a = int(input("a: ")) b = int(input("b: ")) c = int(input("c: ")) result = demo(a, b, c) print(result)
You have Python interpreter already configured. Note that for the current project your Python interpreter version should be 3.0 or later.

First run

Open the class Solver.py for editing F4, and right-click the editor background. Then choose Run 'Solver' from the context menu:

The script runs. Enter values for a, b, and c to review the output in the Run tool window:

Let's explore in detail what we've done and what we see.

Run/debug configuration - what is it?

Each script or test you wish to run or debug from within IntelliJ IDEA, needs a special profile that specifies the script name, working directory, and other important data required for running or debugging. IntelliJ IDEA comes with a number of such pre-defined profiles, or run/debug configurations, that serve patterns, against which you can create any number of run/debug configurations of your own.

Every time you click Run or Debug (or choose Run or Debug from the context menu), you actually launch the current run/debug configuration in the run or debug mode.

If you look at the very first image, you will notice that in the combobox there is no run/debug configuration at all; on the second image it appears, marked with the green circle. It means that the Solver run/debug configuration has been created automatically by IntelliJ IDEA, when you've chosen Run 'Solver' from the context menu. Now, as this run/debug configuration is marked with the green circle, it is current.

Look at the Run widget on the image: you see that solver is selected as the current run/debug configuration. To the right of it, you see the Run and Debug buttons.

You also see that its icon is shown semi-transparent. What does it mean? It means that the Solver run/debug configuration is temporary - IntelliJ IDEA has created it automatically.

Now click to see the available commands and the list of existing run/debug configurations:

Should you have more run/debug configurations, the list of existing ones will become broader. If you click one of the run/debug configurations in this list, it will become current.

Save run/debug configuration

Click More Actions to see additional running options, including Run with Coverage, Profile, Start the concurrency visualization session. Below, there are available actions for the current configuration.

Select Save Configuration - now this configuration becomes permanent and gets the normal icon.

Edit run/debug configuration

Now click near solver and select Edit configurations. The Run/Debug Configurations dialog opens:

Here you can see the solver configuration and its default settings.

The default configuration options are derived from the predefined Python template. Click the Edit configuration templates link, to preview and modify the patterns.

For example, here you change the default Java interpreter. Then it will ibe preselected in any newly created run/debug configuration of the Python type.

Let's go back to the Run/Debug Configurations dialog.

Under the Python node on the left, you see the only run/debug configuration solver. It is denoted with the icon of the normal opacity – which corresponds to the permanent run/debug configuration (remember, it became permanent because you've saved it – however, any specially created run/debug configuration also becomes permanent).

If you change anything in one of the existing run/debug configurations, then only this particular run/debug configuration will be affected.

Redirect standard input from a text file

You can use the Run/Debug Configuration dialog to automatically submit input values from a text file instead of typing them in the Run tool window.

Create the in.txt file in the project root with the following values of a, b, and c:
1 11 1
Click the Run widget and select Edit Configurations. If you have several run configurations, select solver on the left.
Click Modify options and select the Redirect input from. The corresponding field appears in the dialog.
Specify the path to the in.txt file in it.

Click Run at the bottom of the dialog to save the configuration and run it.

Redirecting data from a text file in standard input

Regular run

You've already executed the solver script in one of the most straight-forward ways. Let's now explore the other ways to run a script.

Make sure that 'solver' run/debug configuration is the current one in the Run widget.
Do one of the following:
- Click the Run button , located next to the run/debug configuration combobox.
- Press Shift+F10.
- Go to Run | Run.

Now you can observe results in the Run tool window.

Test run

We won't discuss here why testing is necessary – let's assume that it is so, and discuss how IntelliJ IDEA can help with it.

Creating a test

To run a test, you have to create it first. IntelliJ IDEA suggests a smart way to stub a test out: click the class name and then press Ctrl+Shift+T, or go to Navigate | Test in the main menu. If a test exists, you can jump directly to it; if it doesn't, IntelliJ IDEA will create it:

Click the suggested action, and IntelliJ IDEA will show the following dialog:

Click OK, and see the test class is opened in the editor:

IntelliJ IDEA has produced a test class for us. However, this is just a stub which lacks the actual testing functionality. So, we will import the class to be tested, and add a test method. The resulting code might be as follows:

import unittest

from Solver import Solver

class MyTestCase(unittest.TestCase):

    def test_negative_discr(self):

        s = Solver()

        self.assertRaises(Exception)

    def test_something(self):

        self.assertEqual(True, False)

if __name__ == '__main__':

    unittest.main()

Running a test

When ready with the testing code, right-click the test class name and select Run Python tests.

Launch it and observe results in the Test Runner tab of the Run tool window. To see successful test along with the failed ones, click Show Passed on the toolbar.

Debug run

First of all, why do we need debugging? Suppose, you hit a runtime error. Sometimes the reason of the error is clear. But in more complex case you may need to investigate and inspect the state of your program at different points in its execution. This is where debugging is necessary.

With IntelliJ IDEA, you can debug your applications without leaving the IDE. The only thing you need to do beforehand is to place breakpoints in the required places. Let's explore this in details.

Breakpoint - what is it?

A breakpoint is a line of the source code, where IntelliJ IDEA will suspend, when this line is reached. IntelliJ IDEA discerns several types of breakpoints, each one denoted with its own icon.

Setting breakpoints

This is definitely the easiest part of the process. Just click the gutter on the lines you want to explore – and the breakpoints are there:

Note that each breakpoint is denoted also with a red stripe over the entire line. This color corresponds to a breakpoint that has not yet been reached. Later we will see how the line at breakpoint changes its color.

By the way, removing breakpoints is same easy – click the gutter.

Hover over a breakpoint. IntelliJ IDEA shows a tooltip with the most essential breakpoint information – line number and script address. However, if you want to change breakpoint settings, you have to right-click a breakpoint. Try changing breakpoint settings for your own, and see how the breakpoint icon changes.

Debugging session

So, we are now ready for debugging. Let's start.

First of all, select the solver run/debug configuration in the Run widget and click .

What happens next?

IntelliJ IDEA starts, and then suspends execution at the first breakpoint.
The line at breakpoint becomes blue. It means that IntelliJ IDEA has reached the line with the breakpoint, but has not yet executed it.
Next to the executed lines in the editor, the values of the variables appear.
The Debug tool window appears. This tool window shows all the important information related to debugging, and allows managing the debugging process.

For more information, refer to the product documentation.

Working in the Threads and Variables tab

OK, we've paused at the first breakpoint. What's next?

Press F9 or click . The program will resume and pause at the next breakpoint. This way you can step through all the set breakpoints, observing the variables used in the application. For more information, refer to Debug code.

Working in the Console tab

Why do we need it at all? For example, you'd like to see the error messages, or perform some calculations not related to the current application... With IntelliJ IDEA this is not a problem.

Click the Console tab to bring it forward.

Try to execute Java commands in this interactive console:

Note that interactive console provides code completion Ctrl+Space and history (Up/Down arrow keys).

You can always invoke the debug console by using the command Tools | Open Debug Command Line from the main menu.

Last modified: 12 June 2024