I started writing this since I've had several requests for users transitioning from Matlab to simplify the Python setup process. One drawback of Python's open-endedness is that because there's so many options, finding a starting point may be confusing. Unlike Matlab, Python doesn't come up with all of its packages pre-installed or a single GUI environment. Even the documentation for these packages is dispersed over the internet without a single repository, sometimes not even existing at all.

​

If you're a Matlab user, don't let this stop you from the transition. I myself struggled with the transition for 4 years until I finally made the plunge. Since then, I haven't looked back.

​

I'll try to outline several steps to take to get started with Python and end with a sample script that you should be able to run on your computer. Hopefully the explanations I give will ease you into a comfortable and somewhat familiar Python environment.

​

Installing Python

1. Visit the Python Anaconda website and download the correct version of Anaconda

   • Anaconda will install all the mainstream Python packages that are commonly used​.

   • Have the option to install Python 3+ version or Python 2.7 version. I would strongly advise you to install the Python 3+ version.

   • "Python 3" and "Python 2" are mostly compatible, but have some simple syntax differences that can prevent scripts working in both versions.

   • "Python 2" will no longer be supported by The Python Foundation as of 1/1/20

   • On PC, can choose between the 64-bit and 32-bit options. On Windows 10, can check this by right clicking on the the Windows logo in the start menu and choosing "system".

   • On Mac, choose downloading the graphical installer.

2. Install Anaconda

   • Install using the default or recommended settings.​

3. Choose an interface to interact with Python, recommendations listed below:

   • Jupyter Notebook: This is a good place to start. The interface runs out of your browser (I use Chrome) and works similarly to an interactive Matlab script. Very powerful for post data collection analysis. This comes with Anaconda.

   • PyCharm: A more complex environment useful for managing classes that you create. Can also be run Matlab script style if the virtual environment is setup properly, although this won't be straight forward if you're coming straight from Matlab. Also interacts with GIT very nicely and has an awesome interface for resolving GIT conflicts.

   • Pyzo: The first environment I used when transitioning from Matlab. Very light and Matlab like.

   • Spyder: A popular GUI based environment for those coming straight from Matlab. I've barely used it, but seems to be clunky and run very slow. This comes with Anaconda.

4. Open your Python Interface (example with Jupyter Notebook)​

   • Open up Anaconda Navigator​

   • Open Jupyter Notebook

5. Download and Open this sample interactive Python script with Jupyter Notebook​​

   • Run a cell of the script with shift+enter (run cell and move to next cell) or cntrl+enter (run cell and stay on current cell)

​

Getting to Know Python

Installing New Packages is very Easy

Before a package is imported into your script, you need to install it on your virtual environment. This is only true of packages that do not come with Anaconda, packages like numpy and pandas are pre-installed with Anaconda. 

​

List of Popular Packages

• numpy - Typically used for array and matrix manipulation similar to Matlab

• matplotlib - A library of plotting functions with functionality encompassing Matlab and syntax that's almost identical to Matlab

• pandas - A library that revolves around two extremely useful data structures not seen in Matlab: Dataframes and Sequences. Dataframes are like tables that can store large amounts of data and be very easily filtered and called upon. They also allow for very graphical interaction with large data.

​

You will Need to Import Packages at the Beginning of all your Scripts

Since there are so many Python packages, they can't be imported into a simple script. Each script needs to designate which packages it uses. This is also useful since it better organizes the code. Anyone viewing your code for the first time will know which packages your code relies on before actually reading the code. These can be installed in a normal Python console or even in a Jupyter Notebook cell with the simple code "pip install 'package'" without both sets of quotations.

​

There are Several Different ways to Import Packages

Since Python is open sourced, there is a potential for multiple packages have functions with identical names. As a result, the syntax used to import packages is also used to determine how each of it's classes and functions are called in your script. Here are a few different ways the popular "numpy" package can be called they can be called:

• "​import numpy" - imports numpy and all numpy functions need to be called using the full package name. ie my_array = numpy.array([1, 2, 3, 4]). This is the cleanest way to code since it avoids ambiguity as to the origin of the function or class.

• "import numpy as np" - imports numpy and all numpy functions can be called using the shortcut. ie my_array = np.array(]1, 2, 3, 4]). This is the most common way to import common packages.

• "import numpy as * " - imports all numpy functions without a need to call package name beforehand. ie my_array = array([1, 2, 3, 4]). May seem more convenient, but will ultimately lead to trouble since many packages have similarly named functions and classes. 

​

.ipynb and .py File Extensions are slightly Different

.ipynb refers to interactive Python files, such as those run by Jupyter Notebook. .py refers to standard Python files that can be run a script, or can house a class or function.

​

Python is a 0 Base Index System

The indices of an array start at 0, not 1 like Matlab.

​

The Matplotlib Package is Nearly Identical with Matlab Plotting Syntax

Functions like plot, xlabel, ylabel, title, legend, grid, and all their arguments are nearly identical between Python and Matlab.

​

Jupyter Notebook has a Native Debugger

Like Matlab, Jupyter Notebook (and PyCharm) has a debugger. While PyCharm's debugger works very similarly to Matlab, Jupyter Notebook's does not. Once some code has been run, if the code fails, it can then be debugged. In a seperate cell, type in "%debug" without the quotations, and run this cell. This will take you back to the lowest point in the code where script failed. All the variables that were part of this run are now loaded into the workspace. Typing in "up" or "down" will navigate you through the workspace. Often you want to navigate "up" until you reach code that you wrote or are familiar with. There you can check that the variables are all that you expect.