Slicing in Python stands for retrieving elements from a certain index to another index in a sequence. In this chapter, however, we will focus on slicing in **NumPy** arrays.
### Slicing in 1D Arrays
General syntax for slicing in 1D arrays is the following: `array[start:end:step]`. Let’s have a more detailed look at it:
* `start` is the index from which to start slicing;
* `end` is the index at which the slicing ends (the index itself is not included);
* `step` specifies the increments between the indices (`1` by default).

Here is an example to clarify everything:


import numpy as np
array = np.arange(1, 11)
print(f'Initial array: {array}')
print('-' * 47)
# slicing from the element at index 2 to the element at index 4 exclusive
print(array[2:4])
print('-' * 47)
# slicing from the first element to the element at index 5 exclusive
print(array[:5])
print('-' * 47)
# slicing from the element at index 5 to the last element inclusive
print(array[5:])
print('-' * 47)
# slicing from the first element to the last element inclusive with step=2
print(array[::2])
print('-' * 47)
# slicing from the element at index 4 to the element at index 2 exclusive (step=-1)
print(array[4:2:-1])
print('-' * 47)
# slicing from the last element to the first element inclusive (reversed array)
print(array[::-1])
print('-' * 47)
# slicing from the first element to the last inclusive (the same as our array)
print(array[:])

### Omitting start, end and step
As you can see, we can often **omit** the `start`, `end`, `step` or even all of them at the same time. `step`, for example, can be omitted when we want it to be equal to `1`. `start` and `end` can be omitted in the following scenarios:
1. Omitting `start`:
    * slicing from the first element (`step` is positive);
    * slicing from the last element (`step` is negative).
2. Omitting `end`:
    * slicing to the last element inclusive (`step` is positive);
    * slicing to the first element inclusive (`step` is negative).
<br>
<br>
### Slicing in 2D Arrays
Slicing in 2D and higher dimensional arrays works in a similar way as it does in 1D arrays. However, in 2D arrays there are already **two axes**. 

If we want to perform slicing only on **axis 0** to retrieve 1D arrays, then the syntax remains the same: `array[start:end:step]`. In case we want to perform slicing on the elements of these 1D arrays (**axis 1**), then the syntax is the following: `array[start:end:step, start:end:step]`. Basically, in this case the number of slices is equal to the **number of dimensions** of an array. 

Moreover, we can use slicing for one axis and **basic indexing** for the other axis. Let’s have a look at an example with 2D slicing:


The purple squares are the elements retrieved from slicing. Here is the code for this example:

import numpy as np
array_2d = np.array([
   [1, 2, 3, 4],
   [5, 6, 7, 8],
   [9, 10, 11, 12]
])
print(array_2d[1:])
print('-' * 15)
print(array_2d[:, 0])
print('-' * 15)
print(array_2d[1:, 1:-1])
print('-' * 15)
print(array_2d[:-1, ::2])
print('-' * 15)
print(array_2d[2, ::-1])

First of all, we will discuss the applications of NumPy and why it is popular. Afterwards you will learn various possible options to create different arrays in NumPy.

It's now time to learn how to use index notation to retrieve specific elements or subsets of data from arrays. You will also learn how to use indices to retrieve data based on certain conditions and handle missing values.

There are quite few of common operations on arrays which you may want to perform. Luckily, NumPy has built-in functions and methods for this purpose which you will learn here. 

It's time to discover how to efficiently use mathematical operations on NumPy arrays and apply them in some real-world problems.

Ultimate NumPy

Slicing

Slicing in 1D Arrays

Omitting start, end and step

Slicing in 2D Arrays

Task