Python array the term is "Python list" usage: everyday plain Python code NumPy array: data manipulation that needs to be fast can use Python lists if speed isn't a concern supports fast and convenient vectorized functions: write np.sqrt(array) instead of [math.sqrt(number) for number in your_list] elegantly handles arbitrary number of dimensions Pandas dataframe: for data wrangling in SQL-like language similar to in-memory SQLite database supports NumPy's vectorized functions basically a glorified NumPy array with column names More on reddit.com

Let's break it down: input() gets user input and returns a string, e.g. "1 2 3 4 5" input().split() splits that input on whitespaces, e.g. ["1", "2", "3", ...] int() converts a string to a integer, e.g. "1" -> 1 map(fn, sequence) applies the function fn to each element in the sequence, e.g. fn(sequence[0]), fn(sequence[1]), ... map(int, input().split()) applies int to each string element in the input, e.g. ["1", "2", "3", ...] -> int("1"), int("2"), ... list() turns any iterator/generator to a list, e.g. int("1"), int("2"), ... => [1, 2, 3, ...] Example: In []: list(map(int, input().split())) Input: 1 2 3 4 5 Out[]: [1, 2, 3, 4, 5] Note: this is the same as, which may be easier to read: In []: [int(n) for n in input().split()] Input: 1 2 3 4 5 Out[]: [1, 2, 3, 4, 5] More on reddit.com

Short Answer: Yes, Numpy uses C and Fortran for the expensive computations and this is what makes it so fast.

Long Answer: Loops and function calls are dog slow in dynamic languages, unless JITed, then they are just slow (except for luajit2, I hear).

When your code is too slow you usually code a function in a static language ( C or Fortran ) and bind it to python via its C-API or ctypes. A related approach is to use cython, which lets you code in a python alike language, generates C code from it and AFAIK uses the C-API to bind it.

You often face the situation that you have to copy your data into a data structure that the C function can handle. In case of a matrix, imagine a list of lists, where each row is a list. For each function call into C you'd have to copy it into a continuous piece of memory to make it accessible for C.

The core idea of Numpy is to circumvent this expensive copies by always managing the data in a C compatible data structure in the background, while presenting you a pythonic list alike interface to work with it.

So there are two reasons why Numpy is fast:

• It uses C for the heavy lifting

• It avoids copies while doing so.

More on reddit.com

That's right. A numpy array is a real array in a computer science sense, which means it cannot be resized. Since appending requires resizing, numpy is forced to create a whole new array with a bigger allocation and copy all the old data over before adding any new data. This takes a lot of time. Python lists are resizeable therefore appending is very fast. More on reddit.com