Gain insights into utilizing NumPy for data manipulation and analytics. Learn about implementing concepts in both Python and NumPy through coding challenges and quizzes.

python.tar.gz

python3.6

Live3.6

If you're looking to grow your career in machine learning or data science in this day and age, adding a powerful library to your skill set is an important place to start. In that vein, Python has become one of the most widely used tools in the industry for serious data analytics, and NumPy is probably the most widely used data analytics library. With NumPy, you can manipulate data involving multi-dimensional arrays and matrices (think linear algebra).

Join us as we venture into the vast world of NumPy in this comprehensive course. Each lesson dive into the actual implementation of concepts in both pure Python and then NumPy, exploring how NumPy vectorization compares to traditional Python that uses a procedural and object-oriented approach.

Practice and test yourself along the way with in-browser coding challenges, quizzes, and more.

This course is intended for users who are already familiar with intermediate level Python.

From Python to Numpy

# Problem Description

Now let's look at another interesting example!

# Lagrangian vs Eulerian method

In classical field theory, the [Lagrangian specification](https://en.wikipedia.org/wiki/Lagrangian_and_Eulerian_specification_of_the_flow_field) of the field is a way of looking at fluid motion where the observer follows an individual fluid parcel as it moves through space and time. Plotting the position of an individual parcel through time gives the pathline of the parcel. This can be visualized as sitting in a boat and drifting down a river.

The [Eulerian specification](https://en.wikipedia.org/wiki/Lagrangian_and_Eulerian_specification_of_the_flow_field) of the flow field is a way of looking at fluid motion that focuses on specific locations in the space through which the fluid flows as time passes. This can be visualized by sitting on the bank of a river and watching the water pass the fixed location.

In other words, in the Eulerian case, you divide a portion of space into cells and each cell contains a velocity vector and other information, such as density and temperature. In the Lagrangian case, we need particle-based physics with dynamic interactions and generally, we need a high number of particles. Both methods have advantages and disadvantages and the choice between the two methods depends on the nature of your problem. Of course, you can also mix the two methods into a hybrid method.

However, the biggest problem for particle-based simulation is that particle interaction requires finding neighboring particles and this has a cost as we've seen in the boids case. If we target Python and NumPy only, it is probably better to choose the Eulerian method since vectorization will be almost trivial compared to the Lagrangian method.

# NumPy Implementation
I won't explain all the theory behind computational fluid dynamics because
first, I cannot (I'm not an expert at all in this domain) and there are many
resources online that explain this nicely (have a look at references below,
especially tutorial by L. Barba). Why choose a computational fluid as an example
then? Because results are (almost) always beautiful and fascinating. I couldn't
resist (look at the video below).

We'll further simplify the problem by implementing a method from computer
graphics where the goal is not correctness but convincing behavior. Jos Stam
wrote a very nice article for SIGGRAPH 1999 describing a technique to have
stable fluids over time (i.e. whose solution in the long term does not
diverge). [Alberto Santini](https://github.com/albertosantini/python-fluid)
wrote a Python replication a long time ago (using numarray!) such that I only
had to adapt it to modern NumPy and accelerate it a bit using modern NumPy
tricks.

I won't comment the code since it would be too long, but you can read the
original paper as well as the explanation by [Philip Rideout](http://prideout.net/blog/?p=58) on his blog. Below are some movies I've made
using this technique.


Now we will discuss a case study related to computation fluids and see which approach out of Eulerian and Lagrangian is easier to implement in NumPy.

Introduction

Anatomy of an Array

Code Vectorization

Problem Vectorization

Custom Vectorization

Beyond NumPy

Conclusion

Coding Example: Fluid Dynamics

Problem Description

Lagrangian vs Eulerian method