# How to create a vector in Python using NumPy

## How to create a vector in Python using NumPy

NumPy is a general-purpose array-processing package. It provides a high-performance multidimensional array object, and tools for working with these arrays. It is the fundamental package for scientific computing with Python. Numpy is basically used for creating array of n dimensions.

Vector are built from components, which are ordinary numbers. We can think of a vector as a list of numbers, and vector algebra as operations performed on the numbers in the list. In other words vector is the numpy 1-D array.

In order to create a vector, we use np.array method.

Syntax : np.array(list)
Argument : It take 1-D list it can be 1 row and n columns or n rows and 1 column
Return : It returns vector which is numpy.ndarray

Note: We can create vector with other method as well which return 1-D numpy array for example np.arange(10), np.zeros((4, 1)) gives 1-D array, but most appropriate way is using np.array with the 1-D list.

Creating a Vector
In this example we will create a horizontal vector and a vertical vector

 `# importing numpy` `import` `numpy as np` `# creating a 1-D list (Horizontal)` `list1 ``=` `[``1``, ``2``, ``3``]` `# creating a 1-D list (Vertical)` `list2 ``=` `[[``10``],` `        ``[``20``],` `        ``[``30``]]` `# creating a vector1` `# vector as row` `vector1 ``=` `np.array(list1)` `# creating a vector 2` `# vector as column` `vector2 ``=` `np.array(list2)` `# showing horizontal vector` `print``(``"Horizontal Vector"``)` `print``(vector1)` `print``(``"----------------"``)` `# showing vertical vector` `print``(``"Vertical Vector"``)` `print``(vector2)`

Output :

```Horizontal Vector
[1 2 3]
----------------
Vertical Vector
[[10]
[20]
[30]]```

Basic Arithmetic operation:
In this example we will see do arithmetic operations which are element-wise between two vectors of equal length to result in a new vector with the same length

 `# importing numpy` `import` `numpy as np` `# creating a 1-D list (Horizontal)` `list1 ``=` `[``5``, ``6``, ``9``]` `# creating a 1-D list (Horizontal)` `list2 ``=` `[``1``, ``2``, ``3``]` `# creating first vector` `vector1 ``=` `np.array(list1)` `# printing vector1` `print``(``"First Vector          : "` `+` `str``(vector1))` `# creating second vector` `vector2 ``=` `np.array(list2)` `# printing vector2` `print``(``"Second Vector         : "` `+` `str``(vector2))` `# adding both the vector` `# a + b = (a1 + b1, a2 + b2, a3 + b3)` `addition ``=` `vector1 ``+` `vector2` `# printing addition vector` `print``(``"Vector Addition       : "` `+` `str``(addition))` `# subtracting both the vector` `# a - b = (a1 - b1, a2 - b2, a3 - b3)` `subtraction ``=` `vector1 ``-` `vector2` `# printing addition vector` `print``(``"Vector Subtraction   : "` `+` `str``(subtraction))` `# multiplying  both the vector` `# a * b = (a1 * b1, a2 * b2, a3 * b3)` `multiplication ``=` `vector1 ``*` `vector2` `# printing multiplication vector` `print``(``"Vector Multiplication : "` `+` `str``(multiplication))` `# dividing  both the vector` `# a / b = (a1 / b1, a2 / b2, a3 / b3)` `division ``=` `vector1 ``/` `vector2` `# printing division vector` `print``(``"Vector Division       : "` `+` `str``(division))`

Output :

```First Vector          : [5 6 9]
Second Vector         : [1 2 3]
Vector Addition       : [ 6  8 12]
Vector Subtraction   : [4 4 6]
Vector Multiplication : [ 5 12 27]
Vector Division       : [ 5 12 27]```

Vector Dot Product
In mathematics, the dot product or scalar product is an algebraic operation that takes two equal-length sequences of numbers and returns a single number.
For this we will use dot method.

 `# importing numpy` `import` `numpy as np` `# creating a 1-D list (Horizontal)` `list1 ``=` `[``5``, ``6``, ``9``]` `# creating a 1-D list (Horizontal)` `list2 ``=` `[``1``, ``2``, ``3``]` `# creating first vector` `vector1 ``=` `np.array(list1)` `# printing vector1` `print``(``"First Vector  : "` `+` `str``(vector1))` `# creating second vector` `vector2 ``=` `np.array(list2)` `# printing vector2` `print``(``"Second Vector : "` `+` `str``(vector2))` `# getting dot product of both the vectors` `# a . b = (a1 * b1 + a2 * b2 + a3 * b3)` `# a . b = (a1b1 + a2b2 + a3b3)` `dot_product ``=` `vector1.dot(vector2)` `# printing dot product` `print``(``"Dot Product   : "` `+` `str``(dot_product))`

Output:

```First Vector  : [5 6 9]
Second Vector : [1 2 3]
Dot Product   : 44```

Vector-Scalar Multiplication
Multiplying a vector by a scalar is called scalar multiplication. To perform scalar multiplication, we need to multiply the scalar by each component of the vector.

 `# importing numpy` `import` `numpy as np` `# creating a 1-D list (Horizontal)` `list1 ``=` `[``1``, ``2``, ``3``]` `# creating first vector` `vector ``=` `np.array(list1)` `# printing vector1` `print``(``"Vector  : "` `+` `str``(vector))` `# scalar value` `scalar ``=` `2` `# printing scalar value` `print``(``"Scalar  : "` `+` `str``(scalar))` ` ` `# getting scalar multiplication value` `# s * v = (s * v1, s * v2, s * v3)` `scalar_mul ``=` `vector ``*` `scalar` `# printing dot product` `print``(``"Scalar Multiplication : "` `+` `str``(scalar_mul))` ` `

Output

```Vector  : [1 2 3]
Scalar  : 2
Scalar Multiplication : [2 4 6]```

Last Updated on October 28, 2021 by admin

## numpy.log() in Pythonnumpy.log() in Python

numpy.log() in Python The numpy.log() is a mathematical function that helps user to calculate Natural logarithm of x where x belongs to all the input array elements. Natural logarithm log is the inverse of the exp(), so that log(exp(x)) = x. The natural logarithm is log

## numpy.argmax() in Pythonnumpy.argmax() in Python

numpy.argmax() in Python The numpy.argmax() function returns indices of the max element of the array in a particular axis. Syntax :  numpy.argmax(array, axis = None, out = None) Parameters :  array : Input array to work on axis : [int, optional]Along a

## numpy.subtract() in Pythonnumpy.subtract() in Python

numpy.subtract() in Python numpy.subtract() function is used when we want to compute the difference of two array.It returns the difference of arr1 and arr2, element-wise. Syntax : numpy.subtract(arr1, arr2, /, out=None, *, where=True, casting=’same_kind’, order=’K’, dtype=None, subok=True[, signature, extobj], ufunc ‘subtract’)

## Convert a NumPy array to an imageConvert a NumPy array to an image

Convert a NumPy array to an image NumPy Or numeric python is a popular library for array manipulation. Since images are just an array of pixels carrying various color codes. NumPy can be used to convert an array into image. Apart from

## numpy.zeros() in Pythonnumpy.zeros() in Python

numpy.zeros() in Python The numpy.zeros() function returns a new array of given shape and type, with zeros. Syntax: numpy.zeros(shape, dtype = None, order = 'C') Parameters : shape : integer or sequence of integers order : C_contiguous or F_contiguous C-contiguous order in

## Python – math.cos() functionPython – math.cos() function

Python | math.cos() function In Python, math module contains a number of mathematical operations, which can be performed with ease using the module. math.cos() function returns the cosine of value passed as argument. The value passed in this function should be in

## numpy.multiply() in Pythonnumpy.multiply() in Python

numpy.multiply() in Python numpy.multiply() function is used when we want to compute the multiplication of two array. It returns the product of arr1 and arr2, element-wise. Syntax : numpy.multiply(arr1, arr2, /, out=None, *, where=True, casting=’same_kind’, order=’K’, dtype=None, subok=True[, signature, extobj], ufunc ‘multiply’)

## Multiplication of two Matrices in Single line using Numpy in PythonMultiplication of two Matrices in Single line using Numpy in Python

Multiplication of two Matrices in Single line using Numpy in Python Matrix multiplication is an operation that takes two matrices as input and produces single matrix by multiplying rows of the first matrix to the column of the second matrix.In