NumPy is more than a container for numbers: it ships with a large library of ready-made functions that do the heavy lifting of engineering computation. These fall into a few families you will use again and again: mathematical and arithmetic functions (element-wise addition, powers, exponentials, trigonometry), statistical functions (mean, median, standard deviation, min/max, sums along an axis), linear algebra functions in numpy.linalg (matrix multiplication, determinants, inverses, solving Ax = b, eigenvalues), array manipulation functions (reshape, transpose, concatenate, stack, split), sorting and searching functions (sort, argsort, argmax, where, searchsorted), and input/output functions for loading and saving data (loadtxt, genfromtxt, save, savetxt).
This matters in EGN3214 because engineering problems usually arrive as tables of measurements or systems of equations, not as single scalars. Writing Python loops over thousands of sensor readings is slow and error-prone; calling a vectorized NumPy function on the whole array is one line, far faster, and much closer to the mathematical notation you already use in statics, circuits, and thermodynamics.
As you watch the videos below, pay attention to three things: (1) the distinction between element-wise operations (the * operator) and true matrix operations (np.dot, the @ operator, or numpy.linalg routines) — this is the single most common source of bugs; (2) how shapes and axes control what a function returns, especially for statistics computed along rows versus columns; and (3) when a problem outgrows NumPy and is better handled by a specialized library such as SciPy. Keep a notebook open and retype the examples rather than only watching.
A broad introduction to NumPy arrays with an emphasis on linear algebra, from the Socratica channel. Expect coverage of how arrays are created and shaped, how arithmetic on arrays is vectorized, and how NumPy performs matrix operations such as products, inverses, and solving systems quickly compared with plain Python.
Socratica is a well-regarded producer of concise, carefully scripted Python tutorials, and this video connects the mathematical and arithmetic function family directly to the linear algebra subtopic in a single clear narrative.
A longer, worked tutorial that walks through arithmetic operations on NumPy arrays and then moves into linear algebra operations. The pace allows for live demonstration of the operations in code, so you can see the syntax, the printed output, and the difference between element-wise and matrix-level computation.
At roughly twenty minutes it gives more hands-on screen time than a short overview, making it a good follow-along companion for practicing the arithmetic and numpy.linalg functions yourself.
An overview of SciPy, the collection of scientific modules built on top of NumPy arrays. The video introduces what SciPy adds beyond NumPy — specialized routines for areas such as optimization, integration, interpolation, signal processing, and advanced linear algebra — and shows how SciPy functions consume and return ordinary NumPy arrays.
It sets the boundary of the topic: once you know NumPy's built-in function families, this clarifies which engineering tasks reach past them, and it reinforces that the NumPy array remains the common data structure across the scientific Python stack.
Together these videos reinforce the module outcomes. The Socratica array video and the Demystify with Ajay tutorial both demonstrate array creation and shaping (MO1) and vectorized element-wise arithmetic across arrays without Python loops (MO2), while their indexing and slicing examples support selecting subsets of data (MO3). Their linear algebra segments map directly onto solving systems of equations and computing eigenvalues with numpy.linalg (MO4), and the array-wide mathematical and statistical functions shown — sums, means, trigonometric and power functions applied to whole arrays — underpin characterizing engineering data (MO5). The SciPy video extends the picture, showing where NumPy's function library hands off to more specialized scientific routines, which is useful context as you choose the right tool for a given computation.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
NumPy (Numerical Python) is the foundation of almost all scientific and engineering computing in Python. At its core is a single data structure: the ndarray, an N-dimensional array of elements that all share one data type and sit in a contiguous block of memory. That design is what makes NumPy fast — operations are applied to whole arrays at once by compiled code rather than by stepping through items one at a time in Python.
In this course, NumPy is the bridge between the general-purpose Python you already know and real numerical engineering work: sensor data, measurement series, coordinate sets, matrices of coefficients, and simulation results. Before you can create arrays, index them, or do linear algebra, you need a clear mental model of how an ndarray differs from a Python list. A list can hold mixed types and grows easily, but it stores references to scattered objects; an ndarray is fixed in size and homogeneous, which is exactly what allows vectorized arithmetic and the attributes you will rely on throughout the module.
As you watch, focus on four things: what NumPy is and what problems it was built to solve; how an ndarray is created and what it actually stores; concrete comparisons of speed, memory, and behavior between arrays and lists (notice how + behaves differently for each); and the key attributes that describe an array — shape, ndim, size, and dtype. Try typing the examples yourself and printing those attributes for every array you make; it is the fastest way to build intuition for the rest of the module.
The second entry in a Python data science tutorial series, this video focuses specifically on comparing NumPy arrays with standard Python lists. Expect hands-on code demonstrations of how each structure is created and how they differ in typing, memory behavior, and the results of arithmetic operations, likely including timing comparisons that show why arrays are preferred for numerical work.
It targets the 'NumPy Arrays vs. Python Lists' subtopic directly and at length, giving you enough runtime to see worked examples rather than a one-line claim that arrays are faster. Note that the series is produced in a German-language Data Science context, so use the on-screen code as your main reference.
A lecture from the IIT Madras B.S. Degree 'Programming in Python' course that introduces the NumPy library and then explains the array-versus-list distinction. As a classroom-style lecture it should cover what NumPy is, why it exists alongside core Python, how to import it and build arrays, and the reasoning behind the ndarray's homogeneous, fixed-size design.
It is a university lecture from a structured programming course, so the explanation is paced for students meeting NumPy for the first time and covers both 'What Is NumPy?' and the list comparison in one place.
A short, high-level IBM Technology explainer that positions NumPy against Pandas: what each library is for, what data structures they provide, and when an engineer or analyst would reach for one versus the other. It frames NumPy as the numerical array layer that other libraries, including Pandas, are built on top of.
It gives useful context for 'What Is NumPy?' by showing where NumPy sits in the wider Python data ecosystem, and at under six minutes from a reputable producer it is an efficient orientation before you dive into array mechanics.
These videos establish the conceptual groundwork the rest of the module depends on. Understanding that an ndarray is homogeneous, fixed-size, and contiguous explains why creation functions like np.array(), np.arange(), and np.linspace() exist and must be chosen deliberately (MO1), and why element-wise arithmetic and broadcasting work on arrays but not on lists (MO2). The emphasis on shape, ndim, size, and dtype prepares you to reason about which elements you are selecting when you move on to slicing, Boolean masking, and fancy indexing (MO3), and to keep track of dimensions when passing matrices to numpy.linalg for solving systems and finding eigenvalues (MO4). Finally, seeing where NumPy fits among Python's numerical tools motivates its use for descriptive statistics and evaluating mathematical functions over whole datasets at once (MO5).
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Every NumPy workflow begins with getting data into an array. Sometimes that data already exists as a Python list or tuple and simply needs converting; more often, you need to generate it — a time vector for a simulation, a grid of sample points for plotting a function, a matrix of zeros to accumulate results, an identity matrix for a linear algebra step, or random values for a Monte Carlo trial. NumPy provides a dedicated creation function for each of these cases, and choosing the right one makes your code shorter, faster, and easier to read.
In this course, array creation is the foundation everything else rests on. The vectorized arithmetic, indexing, linear algebra, and statistics you will use later all assume you can produce arrays of the right shape and data type to begin with. Pay particular attention to the distinction between np.arange(), which is defined by a step size and excludes the endpoint, and np.linspace(), which is defined by a count of points and includes the endpoint — this difference causes a large share of beginner errors in engineering scripts.
As you watch, keep a few questions in mind: What arguments does each function take, and what does it return? What is the dtype of the resulting array, and when does that matter? How do the shape and reshape operations relate to the number of elements? Try typing each example into your own Python session and then changing one argument at a time to see what happens.
An introductory tutorial on creating NumPy arrays, opening a longer Python-for-data-science playlist. Based on its title and position in the series, it should cover importing NumPy, building arrays from Python lists and nested lists, and inspecting basic attributes such as shape and data type. Expect the pace of a first-contact lesson, with code typed out and explained line by line.
It directly addresses the 'Creating Arrays from Python Sequences' subtopic and gives you the vocabulary (array, shape, dtype) that the remaining videos assume. As the first entry in an established tutorial series, it is pitched at exactly the level of someone meeting NumPy for the first time.
A focused walkthrough of NumPy's built-in generator functions: arange() for evenly spaced sequences by step, zeros(), ones(), and full() for constant-value initialization, and reshape() for changing the layout of an existing array. The description indicates each function is demonstrated with concrete code examples.
This is the closest match to the 'Range' and 'Constant-Value Initialization Functions' subtopics, and the inclusion of reshape() helps you connect the number of elements an array holds to the shape it can take.
A later episode in the same series that gathers additional array-creation techniques beyond the basic np.array() call. Given its title and placement, it likely surveys functions such as linspace, identity or eye, and random generation, showing when each is the natural choice.
It fills in the remaining subtopics — linspace, identity and diagonal matrices, and random arrays — and reinforces the idea that NumPy offers a specialized constructor for each common pattern rather than requiring loops.
Together these three videos cover the construction functions named in MO1: converting Python sequences with np.array(), generating evenly spaced values with np.arange() and np.linspace(), filling arrays with zeros(), ones(), and full(), and producing identity and random arrays. They also build the shape and dtype awareness you will need downstream — broadcasting in MO2 depends on understanding array shapes, indexing in MO3 depends on knowing how arrays are laid out, the linear algebra work in MO4 frequently starts from an identity or zero matrix, and the statistical and function-evaluation tasks in MO5 typically begin with a linspace-generated input range.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
In NumPy, arithmetic and mathematical operations are applied element by element across an entire array at once. Writing a + b, a * 2, or np.sin(a) tells NumPy to loop internally in compiled code rather than in Python, which is why vectorized code is both shorter to write and dramatically faster than an equivalent for-loop. The functions that perform these element-wise operations — np.add, np.sqrt, np.exp, np.sin, and many others — are called universal functions, or ufuncs.
This matters for engineering work because measurement data, time steps, node positions, and sensor channels naturally live in arrays. Converting a column of readings from volts to pressure, computing the magnitude of force components, or evaluating a model at a thousand time points all become single expressions. Related ideas follow from the same mechanism: comparison operators (>, <=, ==) applied to an array return a Boolean array of the same shape, which can then be used as a mask, and aggregate reductions such as sum(), mean(), min(), max(), and std() collapse an array down to a summary value, optionally along a chosen axis.
As you watch, pay attention to three things: the shapes of the arrays going into each operation and coming out, when broadcasting lets arrays of different shapes combine (and when it raises an error), and the difference between an operation that returns a full array and a reduction that returns a single number. Try typing the examples yourself and checking .shape and .dtype after each step.
A short overview of core NumPy array operations, aimed at showing how computations are performed efficiently on arrays rather than through Python loops. Expect demonstrations of basic element-wise arithmetic and common built-in array methods and functions.
Its brevity and focus on operations make it a good orientation to the whole topic, setting up vectorized arithmetic and the general idea of applying functions across an array at once.
A focused tutorial on arithmetic with NumPy arrays, covering addition, subtraction, multiplication, and division applied element-wise between arrays and between an array and a scalar. It is part of WsCube Tech's structured NumPy tutorial series, so the examples are presented step by step in a coding environment.
It gives direct, hands-on coverage of the vectorized arithmetic subtopic, and being from an established tutorial series it keeps the syntax and terminology consistent and easy to follow.
A quick explainer on broadcasting: how NumPy stretches arrays of different but compatible shapes so that element-wise operations can still be performed. The description indicates it also walks through the rules that determine when broadcasting is allowed.
Broadcasting is the rule set that makes element-wise operations work beyond identically shaped arrays, so this video fills in the shape-compatibility reasoning that the arithmetic videos assume.
Together these videos target MO2 most directly: the first two build fluency with vectorized element-wise arithmetic on arrays, and the third supplies the broadcasting rules needed to combine arrays of compatible but different shapes without writing loops. Because element-wise comparisons produce Boolean arrays, the operations shown here also underpin the Boolean masking skills in MO3, and the ufunc and reduction patterns introduced here are the same ones used to evaluate trigonometric functions and compute descriptive statistics in MO5. The arrays used in the demonstrations assume the creation functions from MO1, so watching these clips reinforces that earlier material in an applied setting.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Broadcasting is the rule set NumPy uses to carry out arithmetic between arrays whose shapes are not identical but are compatible. Instead of forcing you to tile or copy data so that both operands have the same shape, NumPy conceptually stretches the smaller array along the dimensions where it has length 1 or where a dimension is missing. The result is code that looks like simple algebra — adding a scalar offset to a sensor array, subtracting a row of column means from a data matrix, or building a 2D grid from two 1D vectors — while running at compiled speed with no extra memory for the stretched copies.
In this course, broadcasting is what makes vectorized engineering computation practical. Once you can combine a (100, 3) array of measurements with a (3,) array of calibration constants, or a column vector of times with a row vector of frequencies, you stop writing nested Python loops and start writing expressions that mirror the equations in your textbook. Broadcasting is also the most common source of confusing bugs for new NumPy users, because a shape mismatch either raises an error or, worse, silently produces an array of the wrong shape.
As you watch, keep three things in the front of your mind. First, the actual rule: compare shapes from the trailing (rightmost) dimension backward, and dimensions are compatible only if they are equal or one of them is 1. Second, the role of reshaping tools such as reshape, np.newaxis, and None in deliberately creating a length-1 axis so that an operation broadcasts the way you intend. Third, how to read a ValueError about operands that could not be broadcast together, and how to use .shape to diagnose it before you run anything else.
A focused walkthrough of how NumPy adds and combines arrays of different shapes, from the mCoding channel. Based on its title and description, it explains the broadcasting mechanism itself — how shapes are compared and aligned — and works through concrete code examples rather than treating broadcasting as a side note. Source code is provided by the producer so you can run the same examples yourself.
mCoding is a well-regarded Python channel known for precise, technically careful explanations, and this is a full-length video devoted entirely to broadcasting, which makes it the best fit for the 'What Is Broadcasting?' and 'Broadcasting Rules' subtopics.
A lecture segment from Sebastian Raschka's deep learning course that places broadcasting in the context of vectors, matrices, and linear algebra operations in NumPy and PyTorch. Expect coverage of array dimensionality and shape, how computational libraries extend standard linear algebra conventions, and where broadcasting fits into matrix and vector arithmetic.
Raschka is a university instructor and author, and the linear-algebra framing connects broadcasting to the vector and matrix patterns engineers actually use, supporting the 'Common Broadcasting Patterns in Engineering' subtopic.
A short tutorial that covers NumPy indexing, slicing, and broadcasting together in under seven minutes. It is a compact, hands-on demonstration showing how elements and subarrays are selected and then how arrays of differing shapes are combined in arithmetic expressions.
Its brevity makes it a useful review or quick refresher, and pairing broadcasting with indexing and slicing reinforces the connection between selecting array subsets and operating on them — a link you will need when debugging shape mismatches.
These three videos together target MO2 directly: the mCoding video establishes what broadcasting is and the shape-compatibility rules that let you combine arrays without explicit Python loops, while Raschka's lecture shows those rules operating on the vectors and matrices typical of engineering and linear-algebra work. The Acadaimy tutorial reinforces MO2 and also touches MO3 by presenting indexing and slicing alongside broadcasting, which helps you recognize how the shape of a selected subarray determines whether a later operation will broadcast correctly. Collectively they give you both the rule you can apply mechanically and the shape-reasoning habits needed to avoid broadcasting errors in your own code.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Once you can create NumPy arrays, the next essential skill is getting data back out of them. Indexing and slicing let you pull a single element, a row, a column, a sub-block, or a scattered set of values from an array. In engineering work this is how you isolate a sensor channel from a data matrix, trim a transient from the start of a time series, or grab every tenth sample from a long measurement record.
This topic moves from simple to advanced. Basic integer indexing uses positions (remember: counting starts at 0, and negative indices count from the end). Slicing uses the start:stop:step pattern and extends to multiple dimensions, such as A[1:4, 0:2]. Boolean (mask) indexing builds an array of True/False values from a condition and uses it to filter data, which is how you answer questions like "which readings exceeded the limit?" Fancy indexing passes an array or list of integers to select elements in any order, with repeats allowed. Finally, np.where gives you conditional selection: either the positions where a condition holds, or an element-wise choice between two values.
As you watch, pay close attention to three things: whether the result is a view into the original array or a copy (slices are views, fancy and Boolean indexing produce copies), how the shape of the result follows from the shape of the index, and how multi-dimensional indexing separates row and column specifications with a comma. Try every example in your own notebook and deliberately change the indices to see what breaks and why.
A focused tutorial on NumPy array indexing from the WsCube Tech NumPy Mastery series, covering how to access individual elements by position in one-dimensional and multi-dimensional arrays. Expect coverage of zero-based indexing, negative indexing, and the row/column comma notation used for 2D arrays, demonstrated live in Python. The pacing is beginner-friendly with worked examples rather than theory.
It is the most direct match for the Basic Integer Indexing subtopic and establishes the position-based notation that all the later techniques (slicing, masking, fancy indexing) build on.
From the same NumPy course series, this video reviews array creation and then works through slicing operations and array attributes. Look for the start:stop:step syntax, omitting values to take everything from or to an endpoint, step sizes for skipping elements, and slicing along two dimensions at once. The attributes portion (shape, size, dtype, ndim) helps you predict and verify the shape of each slice you extract.
It covers the Slicing Arrays subtopic in depth while reinforcing array creation from earlier in the module, and the attribute discussion gives you a practical way to check that a slice returned what you expected.
A short, targeted quick-tip video on fancy indexing, the technique of passing a list or array of integer indices to select multiple arbitrary elements at once. In three minutes it demonstrates how fancy indexing differs from a simple slice, including selecting elements out of order or repeating selections. It is the natural follow-on once basic indexing and slicing feel comfortable.
It addresses the Fancy (Integer Array) Indexing subtopic specifically and concisely, which is the step most students find unintuitive after mastering ordinary slices.
Together these videos target MO3 directly: the first builds integer indexing, the second builds slicing and the shape awareness needed to confirm your selections, and the third introduces fancy integer-array indexing. The creation and attribute material in the second video also reinforces MO1. Boolean masking and np.where are listed as subtopics but are only lightly touched by these videos, so plan to supplement them with the course notes and practice problems, where you will combine conditions with comparison operators and use np.where to filter or recode engineering datasets before computing statistics in later topics.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Engineering data rarely arrives in the shape an algorithm expects. A sensor log may come in as one long 1-D stream when you need a table of rows and columns; a matrix may need to be transposed before it can be multiplied; results from several trials may need to be joined into one block, or split back apart. NumPy handles all of this through shape manipulation: operations that rearrange how the same underlying data is presented, usually without copying or changing a single value.
In this topic you will work with reshape to change dimensions, transpose (and the .T attribute) to swap axes, flatten and ravel to collapse an array back to one dimension, hstack/vstack/concatenate and the split functions to join and separate arrays, and techniques such as squeeze, np.newaxis, and expand_dims to add or remove length-one dimensions. These tools are the connective tissue between the array creation, indexing, and linear algebra skills covered elsewhere in this module.
As you watch, pay attention to three things: whether the total number of elements is preserved (reshape requires it), whether the result is a view sharing memory with the original or an independent copy (ravel versus flatten is the classic example), and which axis an operation acts along. Keep a Python session open and retype the examples with your own small arrays — shape errors are far easier to understand once you have caused a few deliberately.
A focused tutorial on np.reshape from a long-running NumPy/data science series. Based on its title and placement in the playlist, it should demonstrate converting arrays between 1-D, 2-D, and higher-dimensional shapes, the requirement that the element count match, and likely the use of -1 to let NumPy infer one dimension automatically.
It isolates reshaping — the foundational operation of this topic — in a short, single-concept lesson, which makes it a good starting point before combining shape changes with stacking or transposing. Note that the narration is in German; the code shown on screen is standard NumPy and follows along easily, and captions can help.
This video works through several array manipulation functions in one session: ravel for flattening, squeeze for dropping length-one dimensions, and transpose for swapping axes, alongside linspace, np.tile, and repeat. The description indicates it explicitly contrasts repeat with np.tile, which are easy to confuse.
It covers three of our subtopics — flattening/raveling, transposing, and removing dimensions — in a single compact walkthrough, so you can see how these operations relate to each other rather than learning them in isolation.
A dedicated lesson on joining arrays, covering vertical and horizontal stacking and the dimension-compatibility rules that stacking requires. The description notes that arrays must have matching dimensions and flags the case of mixing 2-D and 3-D arrays, which will not stack.
Stacking is the subtopic most likely to produce confusing shape errors in practice, and this video spends its full length on the rules behind those errors rather than just the syntax.
These three videos round out the array-handling skills the module outcomes depend on. Reshaping and transposing determine whether arrays are broadcast-compatible, so they directly support the vectorized arithmetic work in MO2, and correctly shaped 2-D arrays are a prerequisite for the matrix operations and numpy.linalg routines in MO4. Flattening, squeezing, and adding axes change how indexing and slicing behave, reinforcing MO3, while stacking and splitting let you assemble arrays built with np.array, np.arange, or np.linspace (MO1) into the larger datasets you will then summarize with descriptive statistics and evaluate functions over in MO5.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.
Linear algebra is the mathematical backbone of most engineering computation. Circuit analysis, static equilibrium problems, finite element models, structural vibration, control systems, and least-squares curve fitting all reduce, at some point, to matrices and vectors. NumPy's numpy.linalg module gives you fast, well-tested implementations of these operations so you can focus on setting up the problem correctly rather than coding Gaussian elimination from scratch.
In this topic you will work with matrix multiplication (the @ operator, np.dot, np.matmul, and the related inner and outer products), solving systems of equations with np.linalg.solve, extracting eigenvalues and eigenvectors with np.linalg.eig, applying decompositions such as LU, QR, SVD, and Cholesky, and computing norms and determinants with np.linalg.norm and np.linalg.det. A recurring theme is the distinction between element-wise operations (the * operator) and true matrix operations (the @ operator) — a mistake here produces results that look plausible but are wrong.
As you watch, pay close attention to array shapes: which dimensions must match for a product to be legal, and what shape comes back. Also notice that results are floating point, so a determinant that should be exactly zero may come back as something like 1e-17; learn to interpret near-singular systems rather than trusting equality checks. Try to re-type the examples yourself as you watch, and then apply them to a small engineering system of your own.
A recent, polished overview of NumPy arrays framed specifically around doing linear algebra quickly in Python. Based on its title and framing, it should cover how arrays are created and shaped, how array operations differ from ordinary Python lists, and how NumPy's compiled routines make matrix and vector work fast. Expect demonstrations of core array arithmetic leading into linear algebra operations.
Socratica is a well-established producer of clear, carefully scripted Python tutorials, and this video is the most current of the three. It gives you the array foundation and performance rationale that the rest of the topic builds on.
A focused walkthrough of multiplication operations on NumPy arrays and matrices, distinguishing the dot product, the inner product, and the outer product. The description indicates worked examples with vectors and matrices so you can see what each function expects as input and what shape it returns.
Matrix multiplication is the first subtopic here, and this video treats it in depth rather than in passing — particularly useful for sorting out the frequently confused dot, inner, and outer products and the shape rules behind each.
A practical tour of common linear algebra operations in NumPy aimed at data science workflows. From its title and description, expect coverage of routines in the numpy.linalg family — things like determinants, inverses, solving systems, and eigen-decomposition — shown as short code examples rather than theory.
It ties several subtopics together in one place, including solving linear systems, eigenvalues, norms, and determinants, giving you a compact reference for which function to reach for in a given situation.
These videos target MO4 most directly: between them they demonstrate np.linalg routines for solving systems of linear equations and for computing eigenvalues and eigenvectors of square matrices, along with supporting operations such as determinants, inverses, and norms. The Socratica video reinforces MO1 and MO2 by reviewing array construction and vectorized, loop-free arithmetic, which is the prerequisite mindset for treating whole matrices as single objects. The matrix multiplication video sharpens the MO2 distinction between element-wise operations and true matrix products, while the shape-handling and slicing shown throughout all three reinforce the indexing skills of MO3 as you assemble coefficient matrices and right-hand-side vectors from engineering data.
These videos were chosen from YouTube on October 2, 2026. Each has captions; the player turns them on. Videos on YouTube can be changed or removed — if one no longer plays, tell your instructor. If a player does not appear, use its Watch on YouTube link.