Video Summary - Семинар. Библиотека Numpy

Overview

The video is a seminar-style tutorial on NumPy (“Nam Ban/Nam Pie” in the auto-subtitles). It covers:

Why NumPy is useful for fast array-based data processing
How to use NumPy for:
- array creation
- indexing
- operations
- masking
- reshaping
- linear algebra

Why NumPy (performance motivation)

The tutorial motivates NumPy with two examples showing that Python loops are slow (multi-second runtimes):

Creating an array of many values and multiplying them by 5
Summing an array by iterating element-by-element

NumPy speeds things up by operating on whole arrays at once, with implementations in low-level C. NumPy operations are typically element-wise across arrays—without manual Python loops.

Installation / environment notes

With Anaconda + Jupyter, NumPy is often already installed.
If not, the speaker suggests installing with pip install (two similar commands are mentioned for different Python locations/versions).
Before installing, use terminal / Python commands (subtitles imply a where python-style step) such as python -c to confirm which Python environment is currently active.

Import and core data types

Import

The standard import shown is:

import numpy as np

Array dtype and homogeneity

When creating arrays, the data type is controlled by dtype (example uses float64).
NumPy arrays should be homogeneous; mixed types trigger casting to a “higher” type.
- Example: a list containing integers and a string becomes a string-dtype array.

Creating 1D arrays

Basic workflow

Create a Python list
Convert it with np.array(...)
Optionally specify dtype

Introspection helpers

nbytes: memory size of the array
dtype / type: inspect element and array types

Finding functions in documentation

Use ?function_name for docs
Use wildcard-like search (e.g., prefix*?) to find functions by name

The tutorial describes documentation searching as similar to a “search engine.”

Common array properties

(Also generalized to multidimensional arrays.)

shape: dimensions per axis (e.g., 2 x 3 x 4)
ndim: number of dimensions
size: total number of elements
len(...): element count along the first axis

Indexing and iteration guidance

Python-style indexing:
- starts at 0
- negative indices -1, -2, ... access from the end
The tutorial warns that looping over elements in Python defeats NumPy’s speed advantage.
Loops are acceptable if you truly must iterate (briefly demonstrated).

Tutorial exercises (with solutions)

1) Primes array exercise

Create a NumPy array of the first 4 primes:

[2, 3, 5, 7]

Output includes:
- array contents
- element dtype via dtype
- memory/shape info

2) Range construction + defaults

Uses arange as a range-like sequence generator (start, stop, step)
If float values are involved, dtype becomes float.

3) Grid / `linspace` & step logic

Uses linspace(start, stop, num_points) for a fixed-count sequence
Computes step by looking at the difference between adjacent points

4) Logarithmic spacing

Uses logspace(...) where spacing is exponent-based

Array creation helpers

zeros(n) / ones(n)
- Can specify dtype (example mentions float64 as the default when not specified)
zeros_like(other_array) / ones_like(other_array)
- Create arrays of zeros/ones with the same shape and dtype as a reference array

Arithmetic, broadcasting vs scalar ops, and dtype promotion

Element-wise arithmetic

a + b, a - b, a * b, a / b
Requires same-sized arrays

Scalar + array

Example: 5 * a, 10 + b
Scalar is applied to each element

Powers

Array as base and/or exponent
x ** y is element-wise

Dtype promotion

When dtypes differ, NumPy casts to a larger type
- Example: float64 dominates int16 after operations

Universal (ufunc) elementary functions

NumPy “universal functions” (ufuncs) apply element-wise, including:

sin, cos, log, exp
inverse trig functions, etc.

Invalid math behavior

log of negative numbers does not reliably raise exceptions; results can be undefined-like.
Division by zero proceeds and returns values such as 0, inf, or -inf depending on the case.

Logical operations and quantifiers

Comparisons (element-wise)

a > b, a == scalar, etc.

Quantifier-like operations

Mentions functions corresponding to:
- “any” (at least one true)
- “all” (all true)

In-place operations

Uses compound assignment operators:

+=, -=, *=, /=, etc.

Notes:

These generally require dtype compatibility.
Incorrect operations (e.g., adding strings to numeric arrays) produce errors.

Cumulative sums and sorting

cumsum(): cumulative totals at each index
Sorting:
- np.sort(a): returns a sorted copy
- a.sort(): sorts in-place

Reshaping / combining / splitting / editing arrays

Concatenation

np.concatenate((a, b, ...))

Splitting

np.split(array, indices)
- Returns n+1 parts for n split points

Deleting / inserting

np.delete(...): not in-place; returns a new array
np.insert(...): also not in-place

Views vs copies

Slicing produces a view:
- changing a slice can affect the original array (shared memory)
copy() creates an independent array

Masking (boolean indexing)

A mask is a boolean array (same length/shape) used for selection:

a[mask] returns only elements where the mask is True

Example idea:

create masks based on divisibility (e.g., a % 3 == 0).

Trig identity verification exercise

Create angles with linspace(-4π, 4π, 100) (as described)
Verify numerically:

sin(x)^2 + cos(x)^2 == 1 (element-wise)

Uses round(...) to mitigate floating-point precision issues.

2D arrays / matrices

Creation

Similar to 1D, but using a list of lists (rows).
Properties like shape, ndim, size, etc. generalize.
- Example: shape = (rows, cols)

Indexing 2D

Two equivalent access styles:

a[row][col]
a[row, col]

Reshaping

Uses .reshape(new_shape_tuple) (or equivalent reshape via shape assignment)
Constraint:
- total number of elements must remain unchanged

Linear algebra matrix creation helpers

Identity matrix

np.eye(n)

Diagonal matrices

np.diag(diagonal_values) (or related diag(...) patterns)

Example task

Create an 8 x 8 matrix with:

an arithmetic progression on a diagonal
a reversing trick to target the secondary diagonal
uses -1 transformation to shift progression onto the secondary diagonal

Matrix multiplication and grids

Element-wise vs matrix multiplication

Element-wise: *
Matrix multiplication:
- np.dot(a, b) or a.dot(b)

Rules and notes:

Inner dimensions must match:
- columns of the first == rows of the second
In general:
- A.dot(B) != B.dot(A)

Meshgrid

np.meshgrid(x, y):
- creates 2D coordinate grids for graphs/surfaces

2D boolean mask + trace

Uses boolean conditions to select/filter matrix elements (e.g., elements >= 10 on a diagonal)
Demonstrates computation of trace using np.diag and a trace/sum-like operation

Concept reminder:

trace = sum of diagonal elements

Multidimensional arrays (ND arrays)

ND array creation

Example described:
- use np.arange(...) and reshape to build a 3D tensor
- sizes described like 8 x 2 x 4 and/or reshaped from 64 elements to 8 x 8 x 4-style

Axis-based reductions

sum(axis=...) reduces along chosen dimensions
axis can be:
- a single integer
- or a tuple of axes

Demonstrates summing along:

axis 0
axis 1
the last axis
multiple axes simultaneously

Output shapes shrink according to the reduction.

Linear algebra with NumPy (`linalg`)

Determinant, inverse, singularity & floating-point issues

Determinant: np.linalg.det(A)
Inverse: np.linalg.inv(A)

Warning:

If a matrix is singular/near-singular, floating-point rounding can produce a determinant that is tiny but non-zero.
This may lead to an incorrect inverse instead of a clean singularity error.
The speaker advises sanity-checking results.

Solving non-homogeneous linear systems

For:

A x = b

Use:

np.linalg.solve(A, b)

Verification described:

Multiply back by the inverse/analytically to confirm the computed x.

Eigenvalues and eigenvectors

np.linalg.eig(A) returns:
- eigenvalues and eigenvectors