Python Code Running Assistance
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.
Open the class Solver.py for editing F4, and right-click the editor background. Then choose 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 the Run or Debug buttons (or choose Run or Debug commands 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 chosenfrom the context menu. Now, as this run/debug configuration is marked with the green circle, it is current.
Look at the main toolbar on the second image: the current run/debug configuration is visible in the combobox. To its right you see the buttons , , , , ; the run/debug configuration in the combobox is Solver.
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.
OK, now click the down arrow to reveal the available commands and, below the separator line, 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
Choose this command to save the temporary run/debug configuration 'Solver' - now this configuration becomes permanent. As such, it gets the normal icon.
Edit run/debug configuration
This command is first in the list. Choose Run/Debug Configurations dialog opens:, and see the
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, you want to change the Java interpreter to use a remote or other local interpreter. OK, select the interpreter of your choice in the Java page - then any newly created run/debug configuration of the Java type will use this interpreter.
Under the Python node, you see the only run/debug configuration Solver. It belongs to the Java type, and is created against the pattern Python. 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). As an example, create a new run/debug configuration of the Python type for the same Solver script, and call it 'Solver1'.
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 with the following values of a, b, and c:
To enable redirecting, select the Redirect input from checkbox and specify the path to the in.txt file.
Save the Run/Debug configuration and run it. Preview the execution results in the Run tool window.
You've already executed the Solver script in one of the most straight-forward ways. Let us now explore the other ways to run a script.
As you have already learnt, running a script means in fact launching the current run/debug configuration. So, to run the Solver script, follow this procedure:
On the main toolbar, click the run/debug configuration combobox, and make sure that 'Solver' run/debug configuration is the current one.
Do one of the following:
Click the Run button , located next to the run/debug configuration combobox.
From the main menu, choose.
Now you can observe results in the Run tool window.
We won't discuss here why testing is necessary - let's just assume that it is so, and discuss how IntelliJ IDEA can help with it.
Selecting a test runner
First, choose the test runner. To do that, click on the main toolbar to open the Settings/Preferences dialog, and under the Tools node, click Python Integrated Tools page. Here is where you will select the default test runner:
In this case, this is Unittests. Apply changes and close the dialog.
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 from the main menu, choose. 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 opened in the editor:
IntelliJ IDEA has produced a test class for us. However, this is but a stub, and lacks the actual testing functionality. So, we’ll import the class to be tested, and add a test method. The resulting code might be as follows:
Running a test
When ready with the testing code, right-click the test class name - the Run node of the context menu shows Unittests run/debug configuration.
Launch it and observe results in the Test Runner tab of the Run tool window:
First of all, why do we need debugging? Suppose, you hit a runtime error. How to find out its origin? 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?
Here we'll use the Python line 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'll see how the line at breakpoint changes its color.
By the way, removing breakpoints is same easy - just click the gutter.
Hover your mouse pointer 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.
So, we are now ready for debugging. Let's start.
First of all, select the same Solver run/debug configuration from the run/debug configurations combobox, and click the Debug icon to the right.
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.
Refer to the product documentation for details.
Working in the Debugger 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 the part Debug code of the documentation.
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, and then, on the toolbar of this tab, click the button :
The Java prompt appears, and the console becomes interactive. Try to execute Java commands in this interactive console:
Note that interactive console provides code completion Ctrl+Space and history (Up/Down arrow keys). Refer to the page for more information.
You can always invoke the debug console by using the commandfrom the main menu.
REPL - Running in an interactive console
Finally, if you are used to working with an Python console, you can also do that right from within IntelliJ IDEA. To launch the console, choose from the main menu: