You'll often hear Python referred to as "Jython" by advanced users of Ignition. Python is the language, Jython is the implementation of the language that we use. Most users of Python use the implementation called "CPython" - they just don't realize it. See http://en.wikipedia.org/wiki/Python_(programming_language)#Implementations.
One of the powerful things about using Jython is that your script has access to the entire Java standard library. In the Client, this will be Java 5 or above. When running under the Gateway, this will be Java 6 and above. For more information, see Accessing Java.
Many scripting users are blown away by their script's speed. We can't take credit for this - the Jython engine hot-compiles (compiles the code when it is run) your Jython code to Java bytecode, which means it runs natively in the JVM, which in turn can hot-compile it to machine code. It's fast.
Ignition uses Jython 2.5. Jython is the Python programming language implemented over the Java Virtual Machine. When looking at outside documentation, such as on www.python.org, verify that you are looking at the correct version of the documentation.
Jython 2.5 allows us to use the standard functions and tools in Python 2.5, so if you want to look up something in the Python docs, make sure to use version 2.5 (https://docs.python.org/2/).
Many HMI/SCADA packages use VBA, or Visual Basic for Applications. As such, many engineers switching to our software inquire about it. There are a variety of reasons we don't use VBA:
Luckily, Python is a simple language to get started with, and using it in an event-driven system takes away a lot of the extra code that normally makes programming time consuming. For those that are already familiar with scripting (and those of you that are learning), we also have a huge list of functions inside Ignition to do some of the common tasks in a single line of code. These System Functions are available while typing. Just start with "system." and press ctrl-space to see a list of available functions.
Python is used in many places in Ignition. Each location has it's own events that trigger your scripts to run, and add functionality to your projects in different ways. The most apparent place is in event handlers on components and other objects in Ignition Clients. Project and Gateway event scripts are another major place where Python is used.
Every component has "events" associated with them. Things like when the mouse is clicked, a key is pressed, or a value changes. Each type of component has a slightly different set of events based on what you do with that component. For example, all of them have the Property Change event, but only components that can be activated have the focus events.
Scripts can be set to activate on specific events in the Client or in the Gateway. These scripts may run every 5 seconds, on a tag change, or when the Client or Gateway start up or shut down. There is even a messaging system that allows you to create functions that will run on demand when called by another script.
Extension Functions are chunks of code that allow you con interact with some of the basic parts of components that would otherwise be hidden. They vary for each component and not all components have them because they are so specialized. These functions allow you to do things like configure a cell or create a right-click menu in a table, or change the way the Easy Chart works.
Create your own reusable blocks of code in the Script Library. You can set up these Script Modules that exist in just one Project, or ones that are shared between all projects on a Gateway. Once completed, these functions can be called from anywhere in Ignition just like our system.* functions.
You might want to have a table contain all the scripting to edit it's contents, or a button that does a complicated check before continuing. Using Custom Methods allow you to add functions just like the Scripting Modules, but attach them directly to a specific component. This means that if you have a template or component used in several places, you can set up common functions that will stay with the component.