Summary  
This chapter shows how to represent and manipulate vectors using NumPy arrays in Python, covering vector addition, magnitude calculation with np.linalg.norm, and dot product computation. It also demonstrates visualizing vectors and their resultant using Matplotlib’s quiver function.  

General domain of usage  
Scientific computing

## Defining Vectors in Python

In Python, we use NumPy arrays to define 2D vectors like this:



import numpy as np

v1 = np.array([2, 1])
v2 = np.array([1, 3])

print(f'v1 = {v1}')
print(f'v2 = {v2}')

These represent the vectors:

$$
\vec{v}_1 = (2, 1), \quad \vec{v}_2 = (1, 3)
$$

These can now be added, subtracted, or used in dot product and magnitude calculations.

## Vector Addition

To compute vector addition:



import numpy as np

v1 = np.array([2, 1])
v2 = np.array([1, 3])

v3 = v1 + v2
print(f'v3 = v1 + v2 = {v3}')

This performs:

$$
(2, 1) + (1, 3) = (3, 4)
$$

This matches the rule for vector addition:

$$
\vec{a} + \vec{b} = (a_1 + b_1, \; a_2 + b_2)
$$

## Vector Magnitude (Length)

To calculate magnitude in Python:

```python
np.linalg.norm(v)
```

For vector `[3, 4]`:


import numpy as np

print(np.linalg.norm([3, 4]))  # 5.0


This uses the formula:

$$
|\vec{a}| = \sqrt{a_1^2 + a_2^2}
$$

## Dot Product

To calculate the dot product:


import numpy as np

print(np.dot([1, 2], [2, 3]))

Which gives:

$$
[1, 2] \cdot [2, 3] = 1 \cdot 2 + 2 \cdot 3 = 8
$$

Dot product general rule:

$$
\vec{a} \cdot \vec{b} = a_1 b_1 + a_2 b_2
$$

## Visualizing Vectors with Matplotlib

You can use the `quiver()` function in Matplotlib to draw arrows representing vectors and their resultant. Each arrow shows the position, direction, and magnitude of a vector.

* **Blue:** $$\vec{v}_1$$, drawn from the origin;
* **Green:** $$\vec{v}_2$$, starting at the head of $$\vec{v}_1$$;
* **Red:** resultant vector, drawn from the origin to the final tip.

**Example:**



import matplotlib.pyplot as plt

fig, ax = plt.subplots()

# v1
ax.quiver(0, 0, 2, 1, color='blue', angles='xy', scale_units='xy', scale=1)

# v2 (head-to-tail)
ax.quiver(2, 1, 1, 3, color='green', angles='xy', scale_units='xy', scale=1)

# resultant
ax.quiver(0, 0, 3, 4, color='red', angles='xy', scale_units='xy', scale=1)

plt.xlim(0, 5)
plt.ylim(0, 5)
plt.grid(True)
plt.title('Vector Addition (Head-to-Tail Method)')
plt.show()

**Parameters (based on the first `quiver` call):**

```python
ax.quiver(0, 0, 2, 1, color='blue', angles='xy', scale_units='xy', scale=1)
```

* **`0, 0`** – starting point of the vector (origin);
* **`2, 1`** – vector components in the x and y directions;
* **`color='blue'`** – sets the arrow color to blue;
* **`angles='xy'`** – draws the arrow using Cartesian coordinates (x–y plane);
* **`scale_units='xy'`** – scales the arrow according to the same units as the axes;
* **`scale=1`** – keeps the arrow’s true length (no automatic scaling).

This plot shows the **head-to-tail vector addition**, where the red vector represents the sum $$\vec{v}_1 + \vec{v}_2$$.


Which code correctly computes the dot product of $$[1,2]$$ and $$[2,3]$$?

Master the mathematical foundations essential for data science. Explore core concepts in functions, calculus, linear algebra, probability, and dimensionality reduction. Build both theoretical understanding and practical coding experience to strengthen your ability to analyze data, model complex systems, and apply advanced techniques in machine learning.

Explore the foundation of mathematical functions. Learn different types of algebraic and transcendental functions, their properties, and how to implement them in Python to solve real-world problems.

Master the concepts of sets and series, from basic operations to practical applications. Gain hands-on experience implementing set operations and working with arithmetic and geometric series in Python.

Develop a solid understanding of limits, derivatives, integrals, and partial derivatives. Connect theory to practice by implementing these concepts in Python and applying them to optimization through gradient descent.

Build strong knowledge of vectors, matrices, and transformations. Learn decomposition methods and eigenvalue analysis, while reinforcing concepts with Python coding challenges and practical data science applications.

Dive into probability theory and statistics. Study conditional probability, Bayes' theorem, and statistical measures. Implement key concepts in Python, simulate distributions, and strengthen your skills through challenges and quizzes.

Implementing Vectors in Python

Defining Vectors in Python

Vector Addition

Vector Magnitude (Length)

Dot Product

Visualizing Vectors with Matplotlib