# NumPy Exercises, Practice, Solution

## NumPy

NumPy is a Python package providing fast, flexible, and expressive data structures designed to make working with 'relationa' or 'labeled' data both easy and intuitive. It aims to be the fundamental high-level building block for doing practical, real world data analysis in Python.

The best way we learn anything is by practice and exercise questions. Here you have the opportunity to practice the NumPy concepts by solving the exercises starting from basic to more complex exercises. A sample solution is provided for each exercise. It is recommended to do these exercises by yourself first before checking the solution.

Hope, these exercises help you to improve your NumPy coding skills. Currently, following sections are available, we are working hard to add more exercises .... Happy Coding!

**List of NumPy Exercises:**

- NumPy Basic [ 59 exercises with solution ]
- NumPy arrays [ 205 exercises with solution ]
- NumPy Linear Algebra [ 19 exercises with solution ]
- NumPy Random [ 17 exercises with solution ]
- NumPy Sorting and Searching [ 9 exercises with solution ]
- NumPy Mathematics [ 41 exercises with solution ]
- NumPy Statistics [ 14 exercises with solution ]
- NumPy DateTime [ 7 exercises with solution ]
- NumPy String [ 22 exercises with solution ]
- More to come

**NumPy Basics**

Operator | Description |
---|---|

np.array([1,2,3]) | 1d array |

np.array([(1,2,3),(4,5,6)]) | 2d array |

np.arange(start,stop,step) | range array |

**Placeholders**

Operator | Description |
---|---|

np.linspace(0,2,9) | Add evenly spaced values btw interval to array of length |

np.zeros((1,2)) | Create and array filled with zeros |

np.ones((1,2)) | Creates an array filled with ones |

np.random.random((5,5)) | Creates random array |

np.empty((2,2)) | Creates an empty array |

**Array**

Syntax | Description |
---|---|

array.shape | Dimensions (Rows,Columns) |

len(array) | Length of Array |

array.ndim | Number of Array Dimensions |

array.dtype | Data Type |

array.astype(type) | Converts to Data Type |

type(array) | Type of Array |

**Copying/Sorting**

Operators | Description |
---|---|

np.copy(array) | Creates copy of array |

other = array.copy() | Creates deep copy of array |

array.sort() | Sorts an array |

array.sort(axis=0) | Sorts axis of array |

**Array Manipulation**

**Adding or Removing Elements**

Operator | Description |
---|---|

np.append(a,b) | Append items to array |

np.insert(array, 1, 2, axis) | Insert items into array at axis 0 or 1 |

np.resize((2,4)) | Resize array to shape(2,4) |

np.delete(array,1,axis) | Deletes items from array |

**Combining Arrays**

Operator | Description |
---|---|

np.concatenate((a,b),axis=0) | Concatenates 2 arrays, adds to end |

np.vstack((a,b)) | Stack array row-wise |

np.hstack((a,b)) | Stack array column wise |

**Splitting Arrays**

Operator | Description |
---|---|

numpy.split() | Split an array into multiple sub-arrays. |

np.array_split(array, 3) | Split an array in sub-arrays of (nearly) identical size |

numpy.hsplit(array, 3) | Split the array horizontally at 3rd index |

**More**

Operator | Description |
---|---|

other = ndarray.flatten() | Flattens a 2d array to 1d |

array = np.transpose(other) array.T |
Transpose array |

inverse = np.linalg.inv(matrix) | Inverse of a given matrix |

**Mathematics**

**Operations**

Operator | Description |
---|---|

np.add(x,y) x + y |
Addition |

np.substract(x,y) x - y |
Subtraction |

np.divide(x,y) x / y |
Division |

np.multiply(x,y) x @ y |
Multiplication |

np.sqrt(x) | Square Root |

np.sin(x) | Element-wise sine |

np.cos(x) | Element-wise cosine |

np.log(x) | Element-wise natural log |

np.dot(x,y) | Dot product |

np.roots([1,0,-4]) | Roots of a given polynomial coefficients |

**Comparison**

Operator | Description |
---|---|

== | Equal |

!= | Not equal |

< | Smaller than |

> | Greater than |

<= | Smaller than or equal |

>= | Greater than or equal |

np.array_equal(x,y) | Array-wise comparison |

**Basic Statistics**

Operator | Description |
---|---|

np.mean(array) | Mean |

np.median(array) | Median |

array.corrcoef() | Correlation Coefficient |

np.std(array) | Standard Deviation |

**More**

Operator | Description |
---|---|

array.sum() | Array-wise sum |

array.min() | Array-wise minimum value |

array.max(axis=0) | Maximum value of specified axis |

array.cumsum(axis=0) | Cumulative sum of specified axis |

**Slicing and Subsetting**

Operator | Description |
---|---|

array[i] | 1d array at index i |

array[i,j] | 2d array at index[i][j] |

array[i<4] | Boolean Indexing, see Tricks |

array[0:3] | Select items of index 0, 1 and 2 |

array[0:2,1] | Select items of rows 0 and 1 at column 1 |

array[:1] | Select items of row 0 (equals array[0:1, :]) |

array[1:2, :] | Select items of row 1 |

[comment]: <> ( | array[1,...] |

array[ : :-1] | Reverses array |

[ Want to contribute to Python Pandas exercises? Send your code (attached with a .zip file) to us at w3resource[at]yahoo[dot]com. Please avoid copyrighted materials.]

Test your Python skills with w3resource's quiz

## Python: Tips of the Day

**Serialization:**

Sometimes you may need to save your Python object locally for later use or Network transfers. Python has fantastic libraries for serialization such as Json and Pickle.

Serialization is storing data structures in the program so they don't just disappear after the program is terminated.

There is also marshal library but it's more primitive and can't handle certain techniques such as class instances and recursion. Marshal is closer to json in its scope of serialization.

So, when would you use pickle, cpickle, json or ujson?

cpickle and ujson are faster versions of respective libraries that take advantage of C implementations in Python. So they'd always be favorable for speed reasons.

Apart from that, json is a more secure and readable version of serialization than pickle which comes at a cost of speed.

While you can take care of almost any data structure in Python with Json it gets inefficient with large files or uncommon objects. Pickle on the other hand operates in a sweet spot where you'd like to work with large files (multiple GBs) and still don't want to be bothered with database solutions.

The thing is depending on your application, you may have to watch out for security vulnerabilities pickle introduces to the system so it's usually wise to seek out json or database solutions before resorting to pickle when possible.

import pickle lst = ["LST", "LGA", "SFO", "BOM", "JFK", "MIA"] x = pickle.dumps(lst) print(x)

Output:

b'\x80\x03]q\x00(X\x03\x00\x00\x00LSTq\x01X\x03\x00\x00\x00LGAq\x02X\x03\x00\x00\x00SFOq\x03X\x03\x00\x00\x00BOMq\x04X\x03\x00\x00\x00JFKq\x05X\x03\x00\x00\x00MIAq\x06e.'

import pickle lst = ["LST", "LGA", "SFO", "BOM", "JFK", "MIA"] x = pickle.dumps(lst) print(pickle.loads(x))

Output:

['LST', 'LGA', 'SFO', 'BOM', 'JFK', 'MIA']

**Weekly Trends**- Java Basic Programming Exercises
- SQL Subqueries
- Adventureworks Database Exercises
- C# Sharp Basic Exercises
- SQL COUNT() with distinct
- JavaScript String Exercises
- JavaScript HTML Form Validation
- Java Collection Exercises
- SQL COUNT() function
- SQL Inner Join
- JavaScript functions Exercises
- Python Tutorial
- Python Array Exercises
- SQL Cross Join
- C# Sharp Array Exercises