book

Python for Finance, 3rd Edition

Name: Python for Finance, 3rd Edition
Author: Yves Hilpisch
ISBN: 9798341674424

by Yves Hilpisch

March 2027

Intermediate

750 pages

14h 17m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Brief Table of Contents (Not Yet Final)
Preface
Who This Book Is ForHow This Book Is OrganizedMajor ReferencesFrom the Same AuthorAbout the Code ExamplesWorking with GenAIConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgmentsReferences
I. Python and Finance
1. Why Python for Finance?
The Strategic Role of Python in FinancePython as a LanguageThe Python Ecosystem for FinanceTechnology, Data, and the Financial IndustryFrom Spreadsheets to Code-First WorkflowsPython in an AI-First LandscapeWhy the Book Is Organized Around WorkflowsWhere We Are Heading Next
2. Python Fluency and GenAI
Why Python Fluency Matters in the GenAI EraReading and Critiquing Generated CodeAsking for Better Code, Not Just More CodeValidating Code with Data and TestsCollaboration Patterns for Different RolesStudentsLecturers and TrainersProfessionalsA Minimal Workflow ExampleUsing GenAI Safely in FinanceWhere We Are Heading Next
3. Python Infrastructure
Why Infrastructure MattersInstalling PythonLinux and macOSWindowsWorking with the ShellShells on Linux and macOSShells on WindowsManaging Environments with venv and pipCreating a Virtual EnvironmentInstalling Packages with pipEditors on the ShellGetting Started with nanoUsing vim as a Portable Power ToolNotebooks: JupyterLab and ColabJupyterLab LocallyGoogle ColabPutting It All TogetherInfrastructure Checklist by OSmacOSLinuxWindowsWhere We Are Heading Next
II. Mastering the Basics
4. Data Types and Structures
Why Data Types MatterBuilt-In Scalar TypesFloating-Point Precision and Safer AlternativesCore Containers and Their RolesLists and TuplesDictionariesSetsCopying and MutabilityHandy Built-Ins for IterationControl Flow Essentialsif / elif / elsefor loopswhile loopsbreak and continueAny and All for PredicatesExceptions: try / except / else / finallyComprehensionsList comprehensionsDict comprehensionsSet comprehensionsType Hints for ClarityWhere We Are Heading Next
5. Numerical Computing with NumPy
Why NumPy for FinanceCreating Your First ArraysArray Attributes and DtypesArray Creation RoutinesWorking with Dimensions and Indexing1D and 2D IndexingSlicing and ViewsAggregations and the Axis ArgumentBoolean Masks and Conditional LogicBuilding Boolean Masksnp.where for Vectorized If-ElseVectorization and BroadcastingReplacing Loops with Array OperationsBroadcasting Rules by ExampleRandom Numbers and Simple SimulationsUsing the Modern Generator InterfaceA One-Step Monte Carlo ExamplePerformance and Memory LayoutComparing Python Loops and NumPyRow-Major and Column-Major AccessStructured Arrays for Tabular DataDefining a Structured dtypeFiltering with Structured ArraysInteroperability with Python and pandasConverting Between Lists and ArraysBridging to pandasWhere We Are Heading Next
6. Data Analysis with pandas
Why pandas for FinanceCore Data Structures: Series and DataFrameCreating a SeriesCreating a DataFrameIndexing and SelectionColumn and Row SelectionLabel-Based Selection with .loc[]Position-Based Selection with .iloc[]Working with Time-Indexed DataUsing DatetimeIndexResampling and AggregationHandling Missing DataDetecting Missing ValuesDropping and Filling Missing ValuesGrouped Operations and Simple AggregationsGrouping by SymbolMultiple AggregationsComputing Simple ReturnsReading Data from CSV FilesInteroperability with NumPyWhere We Are Heading Next

7. Object-Oriented Programming
Why Object Orientation Matters in FinanceDefining Simple ClassesA Minimal ClassAdding MethodsSpecial Methods for Construction and RepresentationImproving Debugging with a Representation MethodUsing Dataclasses for BoilerplateModeling Portfolios with ClassesA Simple Portfolio ClassAdding Convenience MethodsDesigning for Responsibilities, Not HierarchiesExample: A Price Source InterfaceEncapsulation with PropertiesInheritance and Polymorphism in PortfoliosCombining Orthogonal ClassesWhere We Are Heading Next
8. Data Visualization
Why Visualization Matters in FinanceMatplotlib BasicsA First Line PlotPlotting Time Series from pandasLine Plots from a SeriesHistograms and DistributionsA Simple Returns HistogramMulti-Panel FiguresPrices and Returns in One FigureLine and Bar SubplotsDifferent Scales and Dual AxesScatter Plots for RelationshipsThree-Dimensional ViewsA 3D Surface PlotA 3D Scatter PlotWhere We Are Heading NextLab: The Importance of Return Tails for Investing and TradingWhy Tails MatterLoading a Daily Price SeriesLooking at the DistributionIdentifying the Extreme DaysRemoving Only a Few Extreme DaysSummarizing the Terminal EffectMeasuring Concentration in Absolute MovesWhy This Matters for Investing and Trading
III. Financial Data Science
9. Financial Time Series
Why Clean Time Series MatterInspecting the Raw EOD DataLoading Financial Time Series with a Local/Remote FallbackFirst Attempt: Reading Without Index or Date ParsingFixing Date Parsing and the Index at Import TimeWhat If You Forget parse_dates or index_col?Inspecting Time-Series Structure SystematicallyCreating a Sub-Sample with Missing DataBasic Missing-Data StrategiesReturns and Log Returns from EOD PricesResampling and Time AggregationRolling Statistics and Simple Moving AveragesVisualizing Time Series and Indicators with pandasPrice OverviewMoving Averages and Equity CurvesGrouping by Calendar PeriodsCorrelation Analysis Across AssetsWhere We Are Heading Next
10. Input/Output Operations
Why Input/Output Matters in FinanceA Scratch Folder for ExamplesBasic File I/O with the Standard LibraryWriting and Reading Text FilesSerializing Python Objects with pickleStoring Numerical Arrays with NumPySaving and Loading Arrays with np.save and np.loadBundling Multiple Arrays with np.savezInput/Output with pandasLoading EOD Prices from CSVWriting and Reading CSV FilesWorking with JSONCombining pandas with SQLiteStoring Time Series in HDF5Comparing SQLite and HDF5 for Larger PanelsHigh-Performance I/O with PyTablesCreating Compressed Tables and ArraysOut-of-Memory Computations with EArrayI/O with TsTablesSample Data for TsTablesStoring High-Frequency Data with TsTablesRetrieving Time Ranges EfficientlyOut-of-Core Patterns and Performance PreparationWhere We Are Heading Next
11. Performance Python
Measuring and Thinking About PerformanceLoops and VectorizationAveraging Random Numbers: Pure PythonList Comprehensions and Built-in sum()NumPy VectorizationJIT Compilation with NumbaSimple MultiprocessingCython: Static Compilation of the LoopClassic Algorithms and MicrobenchmarksFibonacci Numbers: Recursive vs IterativeEstimating Pi with Monte CarloBinomial Option PricingPure Python ImplementationNumba-Compiled Binomial TreeCython Binomial TreeMonte Carlo Option PricingVectorized Monte Carlo with NumPyJIT-Compiled Monte CarloCython Monte CarloRecursive EWMA on Time SeriesNaive Python LoopVectorized pandas EWMANumba-Accelerated EWMACython EWMAWhere We Are Heading Next
12. Mathematical Tools
Approximation and RegressionExample Function and Sample DataLinear Least-Squares Regression with NumPyBasis Functions and Nonlinear TrendsHandling Noisy and Unsorted DataInterpolation and SplinesRoot Finding and Convex OptimizationSolving for Yields via Root FindingA Simple Mean–Variance Portfolio ProblemGlobal and Local Optimization in Two DimensionsNumerical IntegrationIntegrating the Standard Normal DensityOption Pricing as an IntegralSymbolic Mathematics with SymPySolving Nonlinear Equations SymbolicallyDifferentiation and GreeksFrom Symbolic to Numerical FunctionsWhere We Are Heading Next
13. Stochastics
Random Numbers and DistributionsUniform and Normal SamplesSampling from Other DistributionsSimulation of Stochastic ProcessesDiscrete-Time Random WalkGeometric Brownian Motion PathsTerminal GBM Levels as Random VariablesSquare-Root Diffusion (CIR) via Euler SchemeExact Discretization of the Square-Root DiffusionMonte Carlo Valuation of OptionsEuropean Call Option under GBMAmerican Put Option via Least-Squares Monte CarloMonte Carlo Convergence BehaviourRisk MeasuresValue-at-Risk and Expected ShortfallWhere We Are Heading Next
14. Statistics
Normality DiagnosticsBenchmark: Geometric Brownian MotionReal-World Return DistributionsPortfolio Statistics and Efficient FrontiersData and Basic Portfolio StatisticsRandom Portfolios and Sharpe RatiosApproximating the Efficient FrontierBayesian Updating in a Simple ExampleBoxes, Hypotheses, and Bayes’ RuleWhere We Are Heading Next
15. Machine and Deep Learning
Supervised Learning with scikit-learnBinary Classification on a Two-Moons DatasetNonlinear SVM Classifiers on the Two-Moons DatasetRegression with Linear and Tree-Based ModelsUnsupervised Learning: PCA and ClusteringPCA and K-means on Synthetic BlobsThinking in PyTorchTensors, Gradients, and OptimizersA Simple MLP Classifier on the Two-Moons DatasetSequence Models and Financial Time SeriesFrom Prices to Lagged-Return WindowsLSTM Classification: Multi-Day Up/DownLSTM Regression: Next-Day Return PredictionWhere We Are Heading Next
16. NLP and LLM Foundations
Text Data in Quantitative FinanceFrom Raw Text to TokensCleaning and Simple TokenizationBuilding a VocabularyNumerical Representations of TextBag-of-Words and TF–IDFDense EmbeddingsClassical Text Models with scikit-learnSequence Models for TextTransformers and Self-AttentionA Toy Self-Attention CalculationVisualising Attention WeightsWorking with Pretrained LLMsExample: Summarizing a Transcript via CLIExample: Using an LLM from PythonRetrieval-Augmented NLP WorkflowsEvaluation, Robustness, and LimitationsWhere We Are Heading NextLab: Summarizing Earnings Surprises with LLMs and PythonWhy Earnings Surprises Make a Good First Text LabBuilding a Small Raw Text SampleAsking for Structured JSONBuilding the Schema in PythonConstructing Prompts ProgrammaticallyParsing Structured ResponsesFrom Records to a Review TableValidating the Output SchemaJoining Raw Text and Structured SummariesWhat to Validate ManuallyWhere This Workflow Can Lead
IV. Python for Asset Management
17. Asset Management Foundations
The Asset Management ProblemAsset Owners, Asset Managers, and MandatesObjectives, Horizons, and Risk ToleranceAsset Classes, Benchmarks, and UniversesAsset Classes and InstrumentsBenchmarks and Tracking ErrorDefining the Investable UniverseConstraints and Risk LimitsPosition, Sector, and Asset-Class LimitsLiquidity, Turnover, and CapacityRegulatory, ESG, and Client-Specific ConstraintsData Structures for Asset ManagementCross-Sectional SnapshotsPanel Data for Returns and HoldingsIdentifiers, Metadata, and Reference DataFrom Investment Policy to Quantitative WorkflowsMapping Mandates to Models and DataA High-Level Asset Management WorkflowWhere We Are Heading Next
18. Portfolio Construction and Risk
From Inputs to Portfolio WeightsDefining the Portfolio ProblemCollecting Returns, Risks, and BenchmarksEstimating Return and Risk InputsEstimating Expected ReturnsEstimating and Regularizing Covariance MatricesMean–Variance and Related Optimization ProblemsMinimum-Variance and Target-Return PortfoliosUtility and Risk-Budgeted PortfoliosConstraints, Risk Budgets, and ImplementabilityLong-Only, Leverage, and Position LimitsTurnover, Transaction Costs, and RebalancingRisk Budgets and Concentration ControlsFactor Exposures and Risk DecompositionBuilding a Simple Factor ModelDecomposing Portfolio RiskWhere We Are Heading NextLab: Building a Market Data Pipeline with EODHDWhy a Small Wrapper MattersReading Credentials Without Hard-Coding ThemWrapping the EOD EndpointDownloading One Daily Price SeriesBuilding a Multi-Symbol Market PanelPivoting the Panel into Price and Return ViewsVisualizing the Stored SampleWhy Store the Data Locally
19. Signals, Forecasts, and Portfolio Implementation
From Research Signals to Portfolio DecisionsSignal Definitions and Use CasesSeparating Research and Implementation LayersDesigning and Evaluating SignalsData Preparation and Feature EngineeringForecast Targets and LabelingBacktesting and Signal DiagnosticsFrom Signals to Scores, Ranks, and WeightsRebalancing, Turnover, and Transaction CostsEvaluating Forecast and Implementation QualityWhere We Are Heading Next
20. Asset Management Systems and Reporting
Reporting as the Interface to StakeholdersStakeholder Needs and Reporting CadenceFrom Raw Data to NarrativeCore Portfolio Reports and DashboardsHoldings and Exposure ReportsPerformance and Risk DashboardsCompliance and Constraint MonitoringData Pipelines and System ArchitectureIngesting and Validating DataRunning Analytics and Storing ResultsScheduling, Orchestration, and Failure HandlingPerformance Attribution and Feedback LoopsAttribution by Asset, Sector, and FactorLinking Attribution to Research and ImplementationGovernance, Compliance, and AuditabilityConfiguration, Code, and Data LineageControls, Approvals, and DocumentationWhere We Are Heading Next
21. A Small Asset Management Library in Python
Design Goals and Library LayoutCore Domain Objects: Instruments, Universes, and PortfoliosMarket Data and Returns: The MarketData ClassSignals and Forecast Targets: The SignalEnginePortfolio Construction: From Signals and Risk Inputs to WeightsRebalancing, Trades, and BacktestingPerformance, Risk, and ReportingEnd-to-End Workflow: A Toy Mandate in CodeWhere We Are Heading Nextassetlib Source CodePackage InitializerCore ModuleData ModuleSignals ModulePortfolio ModuleBacktest ModuleReporting ModuleLab: The Hidden Costs of Portfolio ConstraintsWhy Constraints Have Hidden CostsA Small Universe and BenchmarkEstimating Return and Risk InputsThree Portfolio VersionsHow the Weights ChangeLooking at Trade-Off MetricsRisk Contributions Can Shift TooWhat the Lab Shows
V. Algorithmic Trading
22. Efficient Markets and Hypothesis Testing
The Efficient Market Hypothesis as a BaselineWeak, Semi-Strong, and Strong Forms of EMHEMH, Benchmarks, and Passive InvestingPredictability as a Statistical QuestionNull and Alternative Hypotheses for ReturnsEffect Sizes, Power, and Multiple TestingDesigning and Interpreting TestsTests for Serial Dependence and RandomnessSimple Regression-Based Tests for SignalsDiagnostics for Time Series and SignalsTime-Series Plots and Correlation StructuresGranger Causality Tests for SignalsOut-of-Sample and Walk-Forward EvaluationFrom Statistical Evidence to Portfolio and Trading DecisionsEMH as a Time-Varying Baseline: Timmermann–Granger ViewDeciding When a Signal Is ActionableIntegrating EMH into Research LoopsReferences and Further ReadingWhere We Are Heading Next
23. Vectorized and Event-Based Backtesting
From EMH Baseline to BacktestsData and Features for a Baseline StrategyLoading Prices and ReturnsBuilding Features and Direction LabelsLogistic-Regression Baseline for Daily DirectionWalk-Forward PredictionsInspecting Out-of-Sample DiagnosticsVectorized Walk-Forward Backtest with Proportional CostsRunning the Cost-Aware BacktestComparing Equity CurvesVisualizing the Out-of-Sample CurvesA Minimal Event-Based BacktesterBars, Orders, and Account StateRe-Using the Walk-Forward Signal StreamComparing Event-Based and Vectorized ResultsVisualizing the Shared Signal StreamAnalysing Strategy PerformanceMeasuring Drawdowns and Recovery PeriodsBuilding a Performance Summary TableComparing Buy-and-Hold and Strategy MetricsWhy Event-Based Backtests Must Mirror the MarketWhere We Are Heading NextLab: Why Failed Backtests Still Look ConvincingWhy Failed Backtests Are DangerousLoading the Return SeriesFailure Mode 1: Look-Ahead BiasFailure Mode 2: Ignoring Trading CostsFailure Mode 3: Over-Tuning the BacktestA Backtest Review Checklist
24. Building a Market and Broker for Trading
Why a Separate Engine Layer?Package LayoutQuick Start: Importing the Public APIChoosing a Feed: Historical Replay or GBM SimulationPlacing Market Orders and Reading the Return ObjectsInspecting Positions and Account StateRegistering and Triggering Stop-Loss OrdersRunning a Session with a Strategy CallbackDesign BoundariesConclusionWhere We Are Heading Nextengine Source CodePackage InitializerModels ModuleData ModuleBroker ModuleSession Module
25. Automated Deployment of Trading Strategies
From Event-Based Backtest to DeploymentWhy Deployment Uses Resampled Bars, Not Raw TicksBuilding a Self-Contained Deployment ScriptRebuilding the Baseline ML Logic for DeploymentConfig, Logging, and Deployment StateThe Deployable Strategy ClassHistorical Replay Through engineFrom Historical Replay to Simulated Live StreamingResampling Ticks to a Decision IntervalLogging and MonitoringOperational Safeguards and BoundariesConclusionWhere We Are Heading Next
26. Algorithmic Trading in the Real World
From Research Edge to Economic EdgeA Simple Implementation-Shortfall CalculationBreak-Even Arithmetic and Hit RatesWhy Scale and Sophistication Do Not Guarantee OutperformanceHedge Funds Versus Simple BenchmarksReturn and Risk SummaryBenchmark Sensitivity and Capture RatiosCalendar-Year PerspectiveInterpreting the Hedge-Fund Evidence CarefullyWhen Algorithmic Trading Still Makes SenseConclusionWhere We Are Heading NextLab: Alpha Is RareWhy Alpha Claims Need a BenchmarkLoading the Monthly DataComparing Headline PerformanceEstimating Simple Benchmark ExposureLooking by Calendar YearTesting a Volatility-Scaling StoryWhat the Lab Shows
VI. Derivatives Analytics
27. Valuation Framework
From Risk-Neutral Valuation to a Software ArchitectureDesign Goals and Library Layout (dxlib)Time Handling and Year FractionsDeterministic Discounting as a Curve ObjectMarket Environments and Dependency InjectionDeterministic by Default, Interchangeable by DesignA Quick Interactive Sanity CheckWhere We Are Heading Nextdxlib Foundation Source CodeTime ModuleCurves ModuleEnvironment Module
28. Simulation of Financial Models
Simulation as an Interface ContractRandom Numbers and Variance ReductionTime Grids and Step SizesGeometric Brownian Motion (GBM)Jump Diffusion (Merton)Heston Stochastic VolatilityCIR Short Rate Paths (Extension Point for Stochastic Discounting)Diagnostics: Path Plots and Terminal DistributionsA Quick Interactive Sanity CheckWhere We Are Heading Nextdxlib Simulation Source CodeRandom ModuleProcesses Module
29. Derivatives Valuation
From Paths to ValuesDiscounting on a Year-Fraction Time GridPayoffs as Small, Explicit ClassesEuropean Valuation by Monte CarloWhy American Options Are DifferentThe Longstaff-Schwartz (LSM) AlgorithmImplementing LSM as a ClassAn American Put on an Equity IndexMonte Carlo Diagnostics (Figures)Interactive Session: Pricing a European and an American PutWhere We Are Heading Nextdxlib Valuation Source CodeDiscounting ModulePayoffs ModuleValuation ModuleLSM Module
30. Portfolio Valuation
Why Portfolios Need StructureA Minimal Pricing ContractPositions and AggregationBump-and-Revalue DeltaDiagnostic Figures (Portfolio Contributions)Interactive Session: Building and Valuing a Small BookWhere We Are Heading Nextdxlib Portfolio Source CodePortfolio Module
31. Market-Based Valuation
Why “Market-Based” MattersThe Dataset: A Snapshot of Index Options QuotesPut-Call Parity and Forward LevelsImplied Volatility via Black-76Selecting a Small Surface (3 Expiries × 5 Strikes)Figures: Smiles and Term StructureA Small Implied-Vol Surface ObjectHorizon-Split Calibration: Jump Diffusion then HestonShort Horizon: Jump Diffusion on One ExpiryLonger Horizon: Heston Global Step (Self-Contained)Local Step: Per-Expiry RefinementCalibration Fit Figure (Longer Horizons)Pricing with the Calibrated Heston Model (Monte Carlo)Interactive Session: Short-Horizon JD, Long-Horizon HestonWhere We Are Heading Nextdxlib Market-Based Valuation Source CodeBlack-Scholes ModuleMarket Data ModuleVolatility Surface ModuleHeston ModuleCalibration ModuleLab: Constructing the VIX from SPX Option DataWhat the VIX MeasuresFrom Realized Variance to a Log ContractThe Continuous Model-Free Variance FormulaThe Discrete VIX Variance FormulaLoading the Option SnapshotChoosing the VIX MaturitiesEstimating the Forward and Finding K0Building the Out-of-the-Money StripInterpolating to Thirty DaysComputing the VIX-Style Index LevelImplementation Choices That MatterWhat the Lab Shows
VII. Appendices
A. Linear Algebra and Optimization Toolkit
Vectors, Matrices, and ShapesNorms and Quadratic FormsLinear Systems and ConditioningEigenvalues and Factor StructureLeast Squares as ProjectionConstrained Optimization with SciPySymbolic Derivatives with SymPyImplementation ChecklistWhere We Are Heading Next
B. Probability, Statistics, and Stochastic Calculus Essentials
Random Variables and DistributionsExpectations, Variance, and Sampling ErrorThe Central Limit TheoremCovariance and CorrelationMaximum Likelihood EstimationBrownian MotionIto’s LemmaGeometric Brownian MotionImplementation ChecklistWhere We Are Heading Next
C. Numerical Methods and Simulation Notes
Root Finding and Implied QuantitiesNumerical IntegrationInterpolation of Curves and SurfacesFinite Differences and SensitivitiesMonte Carlo Estimators and Standard ErrorsVariance ReductionTime DiscretizationNumerical Robustness ChecklistClosing Perspective
Index
About the Author

Content preview from Python for Finance, 3rd Edition

Part II. Mastering the Basics

Every robust financial workflow depends on a solid grasp of Python fundamentals and numerical building blocks. This part deepens your understanding of data structures, numerical arrays, tabular analytics, object-oriented design, and visualization.

This part reinforces the foundations that later chapters rely on:

Chapter 4 reviews core data types and containers and shows how they appear in typical finance scripts.
Chapter 5 introduces NumPy arrays and vectorization as the backbone of fast numerical computing.
Chapter 6 focuses on pandas for tabular and time-series analysis, laying the groundwork for all later data work.
Chapter 7 strengthens object-oriented programming skills so that pricing, risk, and strategy logic can be packaged as reusable components.
Chapter 8 develops a visual vocabulary for financial data and emphasizes plots as diagnostic tools, not just presentation artifacts.

By the end of this part, you have a reliable core toolkit for numerical and data-centric work in finance.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0642572340759Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Python for Finance, 3rd Edition

by Yves Hilpisch

Part II. Mastering the Basics

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.