Mastering Interoperability: How to Run PowerShell Commands in Python Efficiently
Picture this: you are an expert engineer working on a crucial automation project. You have been using Python for your code, but you suddenly come across a problem that requires the functionality of Powershell. How do you integrate these two seemingly disparate languages? The answer lies in knowing _how to run a Powershell command in Python_.
This comprehensive guide will take you through the five essential steps to achieve a seamless fusion between Python and Powershell. We’ll explore various techniques and dive into the reasoning behind each method. By the end of this article, you will be armed with the knowledge necessary to tackle any challenging situation where Python and Powershell need to coexist in harmony.
**Step 1: Understand the subprocess module in Python**
The first step in running a Powershell command in Python is to familiarize yourself with the _subprocess_ module. This module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. It provides a consistent interface for creating and interacting with additional processes in a robust and efficient manner.
It is important to note that the subprocess module supersedes the older modules such as os.system, os.spawn*, and commands. Therefore, it is highly recommended to use the subprocess module for new projects.
**Step 2: Explore PowerShell command execution options**
To call a Powershell command from Python, it is crucial to understand the different ways to execute Powershell cmdlets or scripts. Here are some examples:
– Using the `-Command` flag: When launching Powershell from the command line or another script, you can utilize the `-Command` flag to specify the command you wish to execute.
“`
powershell.exe -Command “Get-Process”
“`
– Using the `-File` flag: If you prefer to store your Powershell code in a script file, you can run it using the `-File` flag followed by the file path.
“`
powershell.exe -File “C:scriptsexample_script.ps1”
“`
– Implementing the `-ExecutionPolicy` flag: In some cases, you might encounter execution policy restrictions that prevent the execution of Powershell scripts. To work around this, include the `-ExecutionPolicy` flag with the `Bypass` value.
“`
powershell.exe -ExecutionPolicy Bypass -File “C:scriptsexample_script.ps1”
“`
**Step 3: Utilize the subprocess module to call Powershell commands**
Now that you are familiar with the subprocess module and the possible ways to execute Powershell commands, it’s time to put the two together. The following examples demonstrate various techniques for invoking Powershell commands from within a Python script using the subprocess module:
– **Example 1:** Running a simple cmdlet
result = subprocess.run([“powershell.exe”, “-Command”, “Get-Process”], capture_output=True, text=True)
print(result.stdout)
“`
– **Example 2:** Executing a Powershell script file
result = subprocess.run([“powershell.exe”, “-File”, “C:\scripts\example_script.ps1”], capture_output=True, text=True)
print(result.stdout)
“`
– **Example 3:** Bypassing the execution policy
result = subprocess.run([“powershell.exe”, “-ExecutionPolicy”, “Bypass”, “-File”, “C:\scripts\example_script.ps1”], capture_output=True, text=True)
print(result.stdout)
“`
**Step 4: Error checking and return codes**
In the previous step, we were able to execute Powershell commands from within our Python code. However, it is of utmost importance to also handle errors and check return codes to ensure the success of the execution.
The _subprocess.run()_ function returns an object with a `returncode` attribute containing the return code of the executed command. A return code of zero typically indicates successful execution, while non-zero values signify an error.
See also Unlocking the Power of Free Universal Dashboard for Windows PowerShell: A Comprehensive Guide
Consider adding error checking to your Python script by examining the `returncode` attribute as shown in the example below:
result = subprocess.run([“powershell.exe”, “-Command”, “Get-Process”], capture_output=True, text=True)
if result.returncode == 0:
print(“Powershell command executed successfully.”)
print(result.stdout)
else:
print(“An error occurred during Powershell command execution.”)
print(result.stderr)
“`
**Step 5: Using PEP 8 guidelines for clear and concise code**
As a final tip, always adhere to _PEP 8_ guidelines when writing Python code. This best practice ensures that your code remains clean, cohesive, and easily readable by other engineers. Following these guidelines will not only make your code more maintainable but also minimize technical debt within your team or organization.
By following these five key steps, you have unlocked the potential to run Powershell commands in your Python scripts effortlessly. The seamless integration of Python and Powershell will undoubtedly open up new opportunities for development and automation in your projects. Happy coding!
Run a PowerShell Script From Within the Python Program
- Python subprocess.Popen() Method
- Run a PowerShell Script From Within the Python Program Using the Popen() Method
Windows PowerShell consists of tens of in-built cmdlets, which provide a rich set of features. Some of these features are unique and only available via PowerShell; hence, it is very useful if we can use PowerShell scripts within other programming languages like Python.
This article will focus on executing PowerShell logic from Python code.
Python subprocess.Popen() Method
In Python, the external programs can be executed using the subprocess.Popen() method. The subprocess module consists of several more efficient methods than the ones available in the old os module; hence, it is recommended to use the subprocess module instead of the os module.
Since we will run a PowerShell code from the Python program, the most convenient approach is to use the Popen class in the subprocess module. It creates a separate child process to execute an external program.
The one thing to keep in mind is that this process is platform-dependent.
Whenever you call subprocess.Popen() , the Popen constructor is called. It accepts multiple parameters, as shown in the following.
subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0) As a Sequence of Arguments
Popen(["path_to_external_program_executable", "command_args1", "command_args2", . ]) As a Single Command String
Popen('path_to_external_program_executable -command_param1 arg1 -command_param2 arg2 . ') The sequence of arguments is recommended with the Popen constructor.
The next important argument is the stdout parameter which we will be used in the next section. This specifies the standard output that the process should use.
Run a PowerShell Script From Within the Python Program Using the Popen() Method
First, create a simple PowerShell script that prints to the console window.
We will be saving it as sayhello.ps1 .
Next, we will be creating a Python script, runpsinshell.py . Since we will use the subprocess.Popen() command, we must import the subprocess module first.
Then we will call the Popen constructor with the args and stdout parameters, as shown in the following.
p = subprocess.Popen(["powershell.exe", "D:\\codes\\sayhello.ps1"], stdout=sys.stdout) As you can see, the arguments have been passed as a sequence which is the recommended way. The first argument is the external program executable name, and the next is the file path to the previously created PowerShell script.
Another important thing to remember is that we should specify the standard output parameter as sys.stdout . To use the sys.stdout in your Python program, we must also import the sys module.
The final program should look as follows.
import subprocess, sys p = subprocess.Popen(["powershell.exe", "D:\\codes\\sayhello.ps1"], stdout=sys.stdout) p.communicate() Finally, let’s run the Python program, as shown in the following.
As expected, the PowerShell script has been executed from the Python code and printed the Hello, World! string to the PowerShell window.
The Python program can also be written by passing the Popen constructor arguments as a single string.
import subprocess, sys p = subprocess.Popen('powershell.exe -ExecutionPolicy RemoteSigned -file "D:\\codes\\sayhello.ps1"', stdout=sys.stdout) p.communicate() Nimesha is a Full-stack Software Engineer for more than five years, he loves technology, as technology has the power to solve our many problems within just a minute. He have been contributing to various projects over the last 5+ years and working with almost all the so-called 03 tiers(DB, M-Tier, and Client). Recently, he has started working with DevOps technologies such as Azure administration, Kubernetes, Terraform automation, and Bash scripting as well.
Run PowerShell function from Python script
I have a need to run a PowerShell function from a Python script. Both the .ps1 and the .py files currently live in the same directory. The functions I want to call are in the PowerShell script. Most answers I’ve seen are for running entire PowerShell scripts from Python. In this case, I’m trying to run an individual function within a PowerShell script from a Python script. Here is the sample PowerShell script:
# sample PowerShell Function hello < Write-Host "Hi from the hello function : )" >Function bye < Write-Host "Goodbye" >Write-Host "PowerShell sample says hello." import argparse import subprocess as sp parser = argparse.ArgumentParser(description='Sample call to PowerShell function from Python') parser.add_argument('--functionToCall', metavar='-f', default='hello', help='Specify function to run') args = parser.parse_args() psResult = sp.Popen([r'C:\WINDOWS\system32\WindowsPowerShell\v1.0\powershell.exe', '-ExecutionPolicy', 'Unrestricted', '. ./samplePowerShell', args.functionToCall], stdout = sp.PIPE, stderr = sp.PIPE) output, error = psResult.communicate() rc = psResult.returncode print "Return code given to Python script is: " + str(rc) print "\n\nstdout:\n\n" + str(output) print "\n\nstderr: " + str(error) So, somehow, I want to run the ‘hello()’ or the ‘bye()’ function that is in the PowerShell sample. It would also be nice to know how to pass in parameters to the function. Thanks!