Python Functions and Lambda Functions: A Math-Based Introduction

Python offers three primary libraries for mathematical computing: NumPy provides low-level array operations and linear algebra functions like matrix inversion and eigenvalue calculation; SciPy builds upon NumPy to offer advanced numerical methods including FFT transforms, curve fitting, and system solving; SymPy enables symbolic mathematics by treating variables as algebraic symbols rather than numerical values, allowing exact equation solving and expression manipulation. Each library serves different computational needs, with NumPy and SciPy focusing on numerical computations while SymPy handles symbolic algebra, and developers should select the appropriate tool based on whether they need numerical efficiency, advanced mathematical functions, or exact symbolic solutions.

Numpy provides optimized arrays for numerical work, requiring uniform data types and enabling element-wise operations. Matrix multiplication uses @ operator. SymPy handles symbolic mathematics, allowing algebraic manipulation of equations with symbols. For indeterminate structures, SymPy sets up equilibrium and compatibility equations, solving algebraically before numerical substitution. This combination enables solving complex engineering problems that would be painful manually.

This tutorial demonstrates how to convert symbolic SymPy expressions into numerical values using two primary methods: the evalf() function for single-point evaluation (which can specify precision) and the lambdify() function for efficient batch evaluation across multiple points. The video shows how to use NumPy's linspace() to generate arrays of evaluation points, then apply the lambdified expression to obtain corresponding numerical outputs. Finally, it demonstrates plotting these numerical results using Matplotlib's plt.plot() function to visualize mathematical expressions like parabolas.

SymPy is a pure Python symbolic mathematics library that enables exact symbolic computation without numerical approximation, supporting operations like symbol definition, expression manipulation (expand, simplify, factor), calculus (differentiation, integration), equation solving, unit conversion, and efficient numerical evaluation through lambdify for integration with NumPy and Pandas.

This video demonstrates two methods for solving systems of linear equations in Python: using SymPy's symbolic computation with solve_linear_system() which handles equations directly and returns exact solutions, and using NumPy's numerical approach with np.linalg.solve() which requires separating coefficients into a matrix and constants into a vector, returning floating-point solutions that can be converted to integers.

The Newton-Raphson method is an iterative numerical technique for finding roots of a function, implemented in Python using the formula x_new = x_old - f(x_old)/f'(x_old), where the function and its derivative are evaluated at each iteration until convergence within a specified tolerance.

Implementing Newton-Raphson in Python involves creating a function that accepts the target function, initial guess, tolerance, and maximum iterations. The implementation requires calculating the function value and its numerical derivative at each iteration. For numerical differentiation, the central difference formula [f(x+dx) - f(x-dx)]/(2*dx) is used with dx = 1e-6. The algorithm iteratively applies x_new = x - f(x)/f'(x) until the function value falls below tolerance or maximum iterations are reached. Edge cases include checking for near-zero derivatives which would cause division errors. Example applications demonstrate solving quadratic equations and transcendental equations like x² - e^(-x) - 1 = 0, showing convergence to accurate solutions.

The Newton-Raphson method is an iterative numerical technique for finding roots of equations, implemented in Python by repeatedly applying the formula x₁ = x₀ - f(x₀)/f'(x₀) until the function value at the new approximation falls below a specified tolerance or the maximum number of iterations is reached.

Implement the Newton-Raphson algorithm in Python: initialize u = alpha, then loop n times computing u = u - f(u)/g(u) where g is the derivative function. Verify syntax and execute the script. Call the function with iteration count and initial guess. The initial guess should be close to the actual root for optimal convergence. This demonstrates how Python scripts can leverage calculator functions for numerical root-finding.

This section covers numerical integration and root-finding methods. The trapezium rule approximates the area under a curve by dividing it into trapezoids. With n ordinates and height h = (b - a)/n, the area ≈ h/2 [y₀ + 2(y₁ + y₂ + ... + yₙ₋₁) + yₙ]. For y = 2x²e^x from 0 to 1 with 5 ordinates, h = 0.25, and the approximation is 0.7067. For exact integration, use integration by parts: ∫u dv = uv - ∫v du. For ∫x²e^x dx, let u = x², dv = e^x dx, so du = 2x dx, v = e^x. Then ∫x²e^x dx = x²e^x - ∫2xe^x dx. Apply integration by parts again to ∫2xe^x dx with u = 2x, dv = e^x dx, giving 2xe^x - ∫2e^x dx = 2xe^x - 2e^x. The Newton-Raphson method finds roots using xₙ₊₁ = xₙ - f(xₙ)/f'(xₙ). For f(x) = x³ + 3x + 7, f'(x) = 3x² + 3. Starting with x₀ = 1, x₁ = 1 - (1 + 3 + 7)/(3 + 3) = 1 - 11/6 = -5/6 ≈ -0.833.

Python 2.1 introduced optional support for non-global outer scopes through 'co_freevars', and Python 2.2 made this required. Each time a function referencing outer scope variables is created, a new mapping must be preserved because the outer scope may exit. The '__closure__' attribute contains cell objects for free variables. Python 3 introduced 'nonlocal' allowing functions to rebind outer scope variables, unlike Python 2 which only allows mutation of mutable objects. Common closure uses include inner functions, lambda functions, callbacks, and decorators. Decorators are particularly important because they run at function definition time and must preserve references to the original function.

This section covers advanced Python programming patterns. Closures are functions that remember values from enclosing scopes even after execution, storing the function with its environment. They enable functions to access variables from their creation context. Decorators modify function behavior by wrapping them with additional functionality, using @ syntax for clean application. Functions can return other functions, enabling dynamic creation of specialized functions. map() applies a function to each item in an iterable, returning a map object. filter() applies a function and returns only items where it returns True. reduce() applies a two-argument function cumulatively to iterable elements, returning a single result. These concepts enable powerful code patterns for state preservation, cross-cutting concerns, and functional programming approaches.

Python uses the LEGB (Local, Enclosed, Global, Built-in) rule to determine variable scope, where Local has highest priority followed by Enclosed (non-local), then Global, and finally Built-in; nested functions enable decorators, which are wrapper functions that augment or modify other functions by taking a function as an argument and returning a new function, allowing additional functionality to be added without changing the original function's code.

Python provides powerful advanced features for function handling. Star args captures unlimited positional arguments into a tuple, while star star kwargs captures keyword arguments into a dictionary. Functions are first-class citizens that can be stored, passed, and returned dynamically. Closures enable nested functions to access outer scope variables, creating function factories. Decorators modify function behavior using the @ syntax, adding functionality like logging without changing original code. The non-local keyword allows nested functions to modify enclosing scope variables. These features enable flexible, dynamic, and maintainable Python code.

Variables have scope: global variables are accessible throughout the script, while local variables exist only within their defining function. The 'global' keyword allows functions to modify global variables. The 'nonlocal' keyword enables inner functions to access and modify variables from enclosing functions. Closures occur when a function returns another function that captures variables from its outer scope, creating private data accessible only through the closure. Currying transforms multi-argument functions into sequences of single-argument functions, enabling partial application where arguments can be fixed to create specialized functions. Lambda functions provide concise anonymous function syntax for short operations, commonly used as callbacks.