For the Python evaluation system, the default return type is "Expression":

Numbers, strings, lists and associations are automatically imported for the "Expression" return type:

The return type of "String" returns a string of the result by calling the Python function repr:

Evaluate Python code using a specified "Evaluator":

An Association can be used to automatically provision a Python virtual environment:

"Dependencies" can be a list of strings that specify Python packages, using pip conventions to specify versions:

The File wrapper can also be used in order to specify "Dependencies" for an evaluator:

Specify an "EnvironmentName" to customize the virtual environment folder name:

Specify a "BaseDirectory" to change the installation directory:

"PythonRuntime" can be used to download a specific version:

Use the File wrapper to use your own Python installation:

Use "SessionProlog" to perform a side effect at the start of a session:

Use "SessionEpilog" to perform a side effect at the end of a session:

Use "Prolog" to perform a side effect before every evaluation:

Use "Epilog" to perform a side effect after every evaluation:

When only a string of Python code is provided, the command is directly executed:

The above is equivalent to writing the command using this form:

Use a File wrapper to run the code in a file:

The above is equivalent to writing the command using this form:

Use a URL wrapper to directly run code hosted online:

The above is equivalent to writing the command using this form:

Put code in a CloudObject:

Evaluate directly from the cloud:

The above is equivalent to writing the command using this form:

By default, the command is executed using the "ReturnType" specified during the session creation:

Specifying a "ReturnType" in the command overrides the "ReturnType" for the session:

Use "Arguments" to call a Python function with arguments:

When a non-list argument is provided, a single argument is passed to the function:

If you need to pass a list as the first argument, you must wrap it with an extra list explicitly:

You can define a function inside "Command" and directly call it with "Arguments":

The same result can be achieved by using a Rule:

You can also pass arguments by creating an ExternalFunction:

Use "Constants" to permanently set global variables before the command runs:

When running a command, you can inline a TemplateExpression:

You can explicitly fill TemplateSlot using "TemplateArguments":

When a non-list argument is provided, a single template argument is passed to the template:

If you need to pass a list as the first argument, you must wrap it with an extra list explicitly:

You can name template slots and use an Association to pass named arguments to the template:

Run an ExternalOperation that represents arbitrary code evaluation in Python:

Use the second argument to pass an evaluation context:

Define an ExternalOperation that creates a function in Python:

Define a function call by running the ExternalOperation "Call":

Run the external operation representing the function call using ExternalEvaluate:

Any argument of the "Call" operation can be an ExternalOperation:

Arguments can also be passed directly in ExternalEvaluate by doing the following:

The result is equivalent of running the following Python code:

Create an ExternalFunction for a Python function:

Call the function by running the operation "Call":

The same result can be achieved by doing the following:

Create an ExternalObject for a Python function:

Call the function by running the operation "Call":

The same result can be achieved by doing the following:

Alternatively, you can use ExternalObject subvalues:

Close the session:

Start a Python session to work with dates:

Return an ExternalObject for a datetime object:

Extract the year attribute by using "GetAttribute":

The same can be done using an ExternalObject subvalue:

For the Python evaluator, "GetAttribute" is the default operation, and ExternalOperation can be omitted:

The result is equivalent to running the following Python code:

Delete the session:

Start a Python session to work with decimal numbers:

Get the context for the decimal module:

Set the precision to 6:

Check that the precision was set to 6:

The result is equivalent to running the following Python code:

Delete the session:

Start a Python session:

Create a Python dictionary and return it as an ExternalObject:

Extract the "name" item by using "GetItem":

The result is equivalent to running the following Python code:

Delete the session:

Create an ExternalOperation that represents a dictionary:

Create a new ExternalOperation to get the item "name":

Run the operation using ExternalEvaluate:

Start a Python session:

Create an ExternalObject with a dictionary:

Set the item "name" to "joe":

Check that the item was set to "joe":

Get the whole dictionary as an association, by using Expression:

Delete the session:

Define an ExternalObject that imports the "datetime" module:

Return the module as an ExternalObject:

Define an ExternalObject that imports the date from the "datetime" module:

Call the operation with arguments using ExternalEvaluate:

Define an ExternalObject that imports the "datetime" module:

Use an ExternalFunction to call the method:

Delete the session:

Define an ExternalObject that imports the fractions module:

Initialize the fraction by using ExternalObject subvalues:

The same can be done with the following syntax:

Delete the session:

Define an "Import" operation that imports "ip_address":

Create an address instance using ExternalEvaluate:

Use String as the return type to show the Python string version of the instance:

Define an "Import" operation that imports "ip_address":

Create an address instance using another ExternalOperation:

Execute the operation in ExternalEvaluate:

Create an ExternalObject that represents the current date:

Use "Expression" to return the object as a Wolfram Language expression:

The Cast operation can also run in ExternalObject subvalues:

The symbol Expression is a shortcut for the same:

Return the object as a string:

The symbol String is a shortcut for the same:

Return the object as an ExternalObject:

The symbol ExternalObject is a shortcut for the same:

The same can be achieved by using "ReturnType" in ExternalEvaluate:

Delete the session: