NumPy Arrays

NumPy Arrays

Introduction to NumPy Arrays

• NumPy arrays are designed for data analysis, offering specific functionalities such as element-wise mathematics and matrix operations, unlike general-purpose Python data structures like lists, tuples, dictionaries, and sets.

• NumPy arrays are similar to lists as they store sequences of objects but are optimized for numerical operations and handling multi-dimensional data.

Key Differences Between Lists and NumPy Arrays

• Heterogeneous vs. Homogeneous Data: Lists can store items of different types (heterogeneous), whereas NumPy arrays store items of the same type (homogeneous).

• Dimensionality: NumPy arrays have dimensions, allowing them to be one-dimensional (like lists), two-dimensional (tables or matrices), or multi-dimensional.

Accessing NumPy Arrays

• To use NumPy arrays, import the NumPy package using import numpy as np. The alias np is a common shorthand for NumPy.

• If NumPy is not installed, it can be installed via the command line using pip install numpy.

• The Anaconda distribution of Python includes NumPy and other data science packages by default.

Creating NumPy Arrays

• NumPy arrays can be created by passing a list into the np.array() function. Example:
  my_list = [1, 2, 3, 4] my_array = np.array(my_list) type(my_array) # Output: numpy.ndarray

• Multi-dimensional arrays can be created by passing a list of lists to np.array():
  my_array_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

Array Attributes

• .shape: Returns the dimensions of the array as a tuple (rows, columns).
  my_array_2d.shape # Output: (2, 4)

• .size: Returns the total number of elements in the array.
  my_array_2d.size # Output: 8

• .dtype: Returns the data type of the elements in the array.
  my_array_2d.dtype # Output: int64

Special Array Creation Functions

• np.identity(n): Creates an identity matrix of dimension n \times n, with ones on the diagonal.
  identity_matrix = np.identity(5)

• np.ones(shape): Creates an array filled with ones.
  ones_array = np.ones((2, 4))

• np.zeros(shape): Creates an array filled with zeros.
  zeros_array = np.zeros((4, 6))

Indexing and Slicing

• Indexing and slicing in NumPy arrays are similar to Python lists.
  my_array = np.array([1, 2, 3, 4, 5]) my_array[3] # Returns 4 (index 3) my_array[3:] # Returns [4, 5] (from index 3 to the end)

• Reversing an array using slicing:
  my_array[::-1] # Returns [5, 4, 3, 2, 1]

Indexing in Two-Dimensional Arrays

• To index a 2D array, use comma-separated indices within square brackets: array[row, column].
  two_d_array = np.array([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12], [13, 14, 15, 16, 17, 18]]) two_d_array[1, 4] # Returns 11 (row 1, column 4)

• Slicing in two dimensions allows you to extract segments of the array.

• Reversing a two-dimensional array:
  two_d_array[::-1, ::-1] # Reverses both dimensions

Array Manipulation

• .reshape(shape): Changes the dimensions of an array.
  reshaped_array = np.reshape(two_d_array, (6, 3))

• np.ravel(array, order='C' or 'F'): Unravels a multi-dimensional array into a one-dimensional array.

  • order = 'C' unravels by rows.

  • order = 'F' unravels by columns (Fortran style).
    raveled_array = np.ravel(two_d_array, order='C')

• .flatten(): Flattens a multi-dimensional array into a one-dimensional array (returns a copy).
  flattened_array = two_d_array.flatten()

• .T: Returns the transpose of a two-dimensional array (rows become columns and vice versa).
  transposed_array = two_d_array.T

• .flipud(): Flips an array vertically (up-down).

• .fliplr(): Flips an array horizontally (left-right).

• .rot90(k=n): Rotates an array by 90 degrees n times.

• np.roll(array, shift, axis): Shifts elements in an array along a specified axis.
  rolled_array = np.roll(two_d_array, 2, axis=1) # shift each row by 2 columns

• If the axis argument is not specified, the array is flattened before rolling.

Array Concatenation

• np.concatenate((array1, array2), axis): Joins two arrays along a specified axis.

  new_array = np.array([[19, 20, 21],
                        [22, 23, 24],
                        [25, 26, 27]])
  concatenated_array = np.concatenate((two_d_array, new_array), axis=1)
  

• When concatenating, the dimensions along the specified axis must match for a valid matrix.

Element-Wise Math Operations

• NumPy arrays allow for efficient element-wise math operations, which are faster than using loops with lists.

• Scalar operations are applied to each element in the array.
  array = np.array([1, 2, 3, 4]) array + 100 # Adds 100 to each element array * 2 # Multiplies each element by 2 array ** 2 # Squares each element array % 2 # Modulus 2 for each element

• Element-wise operations between two NumPy arrays of the same dimension:
  small_array = np.array([[1, 2], [3, 4]]) small_array + small_array # Adds corresponding elements small_array * small_array # Multiplies corresponding elements small_array ** small_array # Element-wise exponentiation

NumPy Math Functions

• np.mean(array, axis): Calculates the mean of an array (optionally along a specified axis).

• np.std(array): Calculates the standard deviation of an array.

• np.sum(array, axis): Calculates the sum of elements in an array (optionally along a specified axis).

• np.log(array): Calculates the natural logarithm of each element.

• np.sqrt(array): Calculates the square root of each element.

• np.dot(array1, array2): Calculates the dot product of two arrays (for 1D arrays) or performs matrix multiplication (for 2D arrays).
  row1 = two_d_array[0, :] row2 = two_d_array[1, :] dot_product = np.dot(row1, row2)

• Matrix multiplication with np.dot():
  matrix_product = np.dot(small_array, small_array)

Conclusion:

• NumPy arrays are powerful and efficient for numerical calculations, especially with multi-dimensional data.

• However, NumPy arrays are limited to homogeneous data types. For datasets with mixed data types, pandas data frames are used.