Enrol to start learning
Reading is open to everyone. Enrolling is free, and it is what unlocks the audio lessons, practice tests and progress tracking.
12.3. Executing MATLAB Scripts in Python
Interactive Audio Lesson
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Today, we’re going to explore how to execute MATLAB scripts using Python. Can anyone tell me what a .m file is?
Isn’t it a script written in MATLAB?
Exactly! .m files are MATLAB script files. In Python, we can run these scripts using the MATLAB Engine API. So, how do we start this API in Python?
We need to import matlab.engine?
Right! After that, we initiate the MATLAB engine with eng = matlab.engine.start_matlab(). This allows us to communicate with the MATLAB session.
What command do we use to run a script?
Good question! We use eng.run('myscript.m', nargout=0). The nargout=0 indicates that we don't expect any output back from the script.
Can we pass parameters into that script?
Yes! We can set variables in the MATLAB workspace from Python, like eng.workspace['x'] = 42, so the script can use it. This is pretty powerful!
To summarize, we import the MATLAB engine, start it, run our scripts, and pass parameters directly into MATLAB’s workspace.
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free account
Now that we know how to run scripts, let’s discuss how we can retrieve results after execution. What's an example of getting back a variable from MATLAB?
Would it be something like result = eng.workspace['y']?
Perfect! This line retrieves the variable 'y' from the MATLAB workspace back into Python. This allows us to use MATLAB’s calculations in our Python environment.
What kind of data can we get back?
Great follow-up! You can retrieve various data types, such as numbers, arrays, and even strings. Just be mindful of the data type conversions between Python and MATLAB!
Can you give us an example of all this?
Sure! For instance, if you modify y based on some input x in your MATLAB script, after execution, you might access result in Python and use it for further analysis.
In summary, we can pass parameters into our scripts, run them, and extract results back into our Python code efficiently.
Unlock the classroom podcast
The transcript is above and free to read. A free account plays the conversation back.
Create a free accountLet’s look at a simple implementation. Imagine you have a MATLAB script that computes the sum of an array. How would we set that up in Python?
We start with importing the MATLAB engine and then run the script?
Correct! And we’d also need to prepare the input array in Python, converting it to the appropriate MATLAB type first.
How do we convert it to MATLAB type?
You would use matlab.double() to convert a Python list, for example. This handles the data type difference.
And after we run the script, we can retrieve the sum in Python?
Yes! Once your script finishes running, you'll access the output variable to retrieve the result. Always ensure your script outputs as expected, and you check the types when extracting!
As a summary, always convert your inputs correctly, run the script, and extract your results into Python for further use.
Overview
Short Summary
This section explains how to execute MATLAB scripts in Python, allowing parameter passing and workspace interaction.
Medium Summary
In this section, you'll learn about how to run MATLAB .m scripts directly from Python using the MATLAB Engine API. It covers key commands for executing scripts, passing parameters, and retrieving results from the MATLAB workspace.
Detailed Summary
Executing MATLAB Scripts in Python
In this section, we explore how to effectively execute MATLAB scripts (.m files) from within Python using the MATLAB Engine API, which provides seamless interaction between the two programming environments. The main command used for running a MATLAB script is eng.run('myscript.m', nargout=0), where eng is the MATLAB engine instance previously started. Additionally, you can pass parameters into the MATLAB workspace using commands like eng.workspace['x'] = 42 to set variables accessed by the script. After executing the script, results can be extracted back to Python using result = eng.workspace['y']. This integration allows users to take advantage of MATLAB's powerful numerical capabilities while leveraging Python's flexibility, ultimately enhancing productivity in scientific computing.
Audio Book
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free account• MATLAB .m scripts can be executed using: • eng.run('myscript.m', nargout=0)
Detailed Explanation
In this step, we learn how to execute MATLAB scripts directly from Python. The main command we need is eng.run('myscript.m', nargout=0) which runs the specified MATLAB script with the name 'myscript.m'. The nargout=0 parameter indicates that we do not expect any outputs to be returned from this function call.
Examples & Analogies
Think of it like sending a chef a handwritten recipe (your MATLAB script) to cook a dish. You do not need to see the dish made (no output needed), but you trust the chef (MATLAB) to execute the instructions properly.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free account• Parameters can be passed via workspace: • eng.workspace['x'] = 42 eng.eval('y = x + 10;', nargout=0)
Detailed Explanation
This chunk explains how we can pass parameters from Python to MATLAB. We first set a value in the MATLAB workspace by using eng.workspace['x'] = 42, which essentially creates a variable 'x' in MATLAB with a value of 42. We can then use eng.eval('y = x + 10;', nargout=0) to perform a calculation where MATLAB creates a new variable 'y' that is the result of 'x + 10'. Here, we're again indicating we do not expect a result back with nargout=0.
Examples & Analogies
Imagine you are sending a grocery list (parameter 'x') to a friend (MATLAB) and then asking them to prepare a meal using the grocery items you specified,, like adding an extra ingredient (10) to your original list. You don’t need to see what they concoct; you trust them to follow your list.
Unlock the audio lesson
The script is above and free to read. A free account plays it back, in the voice you pick.
Create a free account• result = eng.workspace['y']
Detailed Explanation
In this final chunk, we discuss how to retrieve results from MATLAB back into Python. After running our calculations in MATLAB, we can access the results by accessing the MATLAB workspace directly. The command result = eng.workspace['y'] will fetch the value of variable 'y' from MATLAB and store it in a Python variable called 'result'.
Examples & Analogies
This step is like checking back with your friend after they tell you about the meal they made using the ingredients from the grocery list. You ask them about the final dish (variable 'y') and they let you know how it turned out (the result in Python).
--
Key Concepts
Core takeaways and short definitions to help you quickly recall the key ideas from this section.
MATLAB Engine API: An interface that facilitates communication between Python and MATLAB.
Running Scripts: The command used to execute .m files from Python.
Workspace Interaction: The ability to pass and retrieve variables between Python and MATLAB.
Examples
Memory Aids
Interactive tools to help you remember key concepts
Stories
Flash Cards
Glossary
MATLAB Script
A script written for MATLAB, with a .m file extension, used for numerical computations.
MATLAB Engine API
An interface that allows Python scripts to interact with a MATLAB session.
nargout
A parameter used in MATLAB to specify the number of output arguments to return.
workspace
The environment in MATLAB where variables are stored and can be accessed during operations.