Input
An input is information, a value, or an action supplied to a system, program, or computation for processing or to influence its behavior.
Grokking Machine Learning
A property or characteristic of a data example that a model can use to make predictions.
- How it is used
- Supplies the properties a predictive model uses to estimate a label, from email classifications to house prices.
- How deep it goes
- Defines features as table columns, works through a weighted house-price input, and develops categorical and numerical preprocessing.
- Examples
- Uses email size and words, pet properties, house room counts, and passenger columns as concrete inputs.
- What you can do after
- Apply it via Pandas and Scikit-Learn to prepare feature columns, separate them from labels, and train and evaluate models.
Learn AI-Assisted Python Programming, Second Edition
A parameter is a named input specified by a function definition that receives information when the function is called.
- How it is used
- Characterizes books for supervised-learning predictions about unknown authors.
- How deep it goes
- Defines features, works through sentence-length calculation, and uses simple punctuation rules while deferring more accurate phrase analysis.
- Examples
- Uses average sentence length, punctuation-based sentence complexity, average word length, repetition, and weighted signature comparisons.
- What you can do after
- Apply it by calculating descriptive values and assembling signatures for machine-learning comparisons.
Read how Learn AI-Assisted Python Programming, Second Edition explains input →
Get Programming: Learn to code with Python
Information supplied to a program or software component for processing.
- How it is used
- Uses input to start calculations, guide user interactions, and specify what reusable tasks receive.
- How deep it goes
- Works through prompting, storing, converting, and testing inputs, then explains parameter values in function calls.
- Examples
- Uses a square calculator, a name mashup, function calls, and a file of names and phone numbers.
- What you can do after
- Build it from scratch: prompt for and process user responses, supply function arguments, and test varied inputs.
Read how Get Programming: Learn to code with Python explains input →
Fight Fraud with Machine Learning
A feature is an input variable representing a measurable property of an instance for a machine-learning model.
- How it is used
- Uses input properties to detect fraud through rules or trained classifiers.
- How deep it goes
- Works through feature ranking, distribution analysis, engineered columns, and threshold-based rules; defers detailed feature-extraction implementations beyond audio conversion.
- Examples
- Uses phishing-email fields, webpage hyperlink and dash counts, transaction columns, and MFCC matrices from voice samples.
- What you can do after
- Apply it via scikit-learn and plotting tools to rank numerical inputs, inspect distributions, choose rule thresholds, and assess accuracy.
Statistics Every Programmer Needs
A feature is an input attribute of an observation used by a predictive model to make decisions or generate predictions.
- How it is used
- Supplies observed attributes for predicting a numeric response with linear regression or a binary outcome with logistic regression.
- How deep it goes
- Defines predictors by their relationship to targets, demonstrates Python input selection, and evaluates significance and multicollinearity; does not develop general feature engineering.
- Examples
- Uses Stage 1 split times to predict Stage 2 times and raisin morphology to predict variety.
- What you can do after
- Apply it via statsmodels by selecting predictors, fitting regression models, and reviewing significance and multicollinearity before retaining features.
Machine Learning System Design
An input variable or derived input representation provided to a machine-learning model.
- How it is used
- Uses features and learned representations as inputs that supply patterns for model learning and prediction.
- How deep it goes
- Explains feature generation and selection through transformations, practical criteria, and design examples rather than algorithm derivations.
- Examples
- Illustrates inputs with retail sales lags and promotion calendars, plus image-search distances and prospective user signals.
- What you can do after
- Evaluate feature candidates against prediction quality, interpretability, computation time, and pipeline stability.
Grokking Machine Learning, Second Edition
A property or characteristic of data used as an input to a model or, when selected for prediction, as a target label.
- How it is used
- Uses inputs as the properties from which supervised models predict labels.
- How deep it goes
- Defines inputs as table columns, then explains weights, preprocessing, and decision-tree threshold splits.
- Examples
- Uses pets, house rooms and prices, spam emails, and app recommendations with platform and age.
- What you can do after
- Apply it via scikit-learn after selecting, scaling, and encoding housing inputs for linear regression.
Read how Grokking Machine Learning, Second Edition explains input →
AI-Powered Search
A feature is a numerical attribute of a document, query, or query-document relationship used to represent evidence for ranking.
- How it is used
- Uses numerical features as evidence in manual scoring functions and learned search-ranking models.
- How deep it goes
- Defines features and explains logging, domain selection, training coverage, interactions, and evaluation trade-offs.
- Examples
- Compares title scores, overview scores, and release years for movie judgments, and examines missing promotion values in product training data.
- What you can do after
- Evaluate and understand ranking features, their training-data coverage, and their contribution to search relevance.
Math and Architectures of Deep Learning
A measured or encoded property used as an input variable to a machine-learning model.
- How it is used
- Frames real-world problems as functions that transform quantifiable inputs into predicted classes or values.
- How deep it goes
- Defines numeric input variables, vector instances, continuous versus categorical forms, and min-max normalization without detailing feature engineering.
- Examples
- Uses cat-object hardness and sharpness, stock-selling variables, driving-speed variables, and face images.
- What you can do after
- Evaluate/understand how numeric properties become input vectors that a trained model maps to predictions.
Read how Math and Architectures of Deep Learning explains input →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
An input value is a value supplied to configure a Terraform input variable.
- How it is used
- Uses input values to customize reusable modules and distinguish environments without editing their configuration.
- How deep it goes
- Explains declarations, defaults, validation, references, module arguments, and root assignment methods; defers more complex module behavior.
- Examples
- Uses an AWS instance’s subnet and instance type, a subnet data lookup, and HCL and JSON variable files.
- What you can do after
- Apply it via Terraform variable blocks, module arguments, and variable files to configure reusable infrastructure with checked inputs.
Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains input →
The Well-Grounded Rubyist, Fourth Edition
A parameter is a named input in a method definition or block that receives a corresponding argument when the callable is invoked.
- How it is used
- Defines how Ruby methods and blocks receive values supplied by calls or yields.
- How deep it goes
- Works through required, default-valued, and starred binding and ordering; defers full treatment of keyword arguments.
- Examples
- Uses a Celsius converter, mixed method signatures, and iteration with `times`.
- What you can do after
- Practice/perform method signature design and predict which values bind to positional, default-valued, and starred parameters.
Read how The Well-Grounded Rubyist, Fourth Edition explains input →
Knowledge Graphs and LLMs in Action
A feature is an input variable or measurable attribute selected from data for training a predictive model.
- How it is used
- Uses measurable attributes or graph-derived values as inputs for predictive models and node or pair classification.
- How deep it goes
- Explains manual metrics, neighborhood scope, metapath weighting, and shortest-path computation, while deferring detailed representation-learning treatment.
- Examples
- Uses weather measurements, a fraud-detection network, geodesic hop counts, and metapaths linking metformin with type 2 diabetes.
- What you can do after
- Build it from scratch by extracting interpretable graph metrics, shortest-path indicators, or degree-weighted metapath values for model inputs.
Read how Knowledge Graphs and LLMs in Action explains input →
The Design of Web APIs, Second Edition
An input is information or a business concept necessary to achieve a step in a user-oriented workflow.
- How it is used
- Identifies what users must provide for workflow steps and carries those needs into API operations and requests.
- How deep it goes
- Traces inputs from coarse business concepts through merged action inputs, HTTP placement, and schemas, deferring property-level detail until data modeling.
- Examples
- Uses shopping-cart and catalog scenarios, a product-reference parameter, money-transfer changes, and a trail-segment exercise.
- What you can do after
- Practice/perform input identification, request placement, and schema description while checking consumer usability and change compatibility.
Read how The Design of Web APIs, Second Edition explains input →
100 C++ Mistakes and How to Avoid Them
A parameter list is the ordered sequence of parameters declared by a function or constructor.
- How it is used
- Uses parameter lists to design clear, safe function and constructor interfaces.
- How deep it goes
- Explains passing trade-offs, evaluation-order pitfalls, and a parameter-object alternative with corrected C++ examples.
- Examples
- Uses string concatenation, an increasing-values loop, and a constructor with name and date fields.
- What you can do after
- Apply parameter-design practices to clarify calls, avoid unintended modification, and separate side effects from argument expressions.
Read how 100 C++ Mistakes and How to Avoid Them explains input →
Grokking Algorithms, Second Edition
A feature is an observable attribute or input variable used to characterize an item for comparison or prediction.
- How it is used
- Represents fruits, users, or days as comparable inputs for KNN classification or regression.
- How deep it goes
- Works through numeric vectors, distance, and feature-selection trade-offs, but defers cosine similarity.
- Examples
- Uses fruit size and color, movie-category ratings, bakery conditions, and stock-market guesses.
- What you can do after
- Practice/perform feature extraction and selection by representing items numerically and choosing relevant, balanced inputs for KNN.
Read how Grokking Algorithms, Second Edition explains input →
Pro Angular 16
An input property is a directive or component property that receives a value from a template binding.
- How it is used
- Supplies changing template data to directives and components so they can adapt host elements, templates, or rendered content.
- How deep it goes
- Defines binding syntax, decorator aliases, lifecycle timing, component usage, and testing, but does not detail decorator configuration beyond the basic alias.
- Examples
- Uses conditional table classes, a themed custom button, template outlet context data, and a host component for testing.
- What you can do after
- Apply it via Angular bindings and @Input decorators, then test received values through a host component and rendered output.
The Art of AI Product Development
A feature is an input variable representing a measurable property of an example supplied to a machine-learning model.
- How it is used
- Uses input features to represent examples for clustering, classification, and reusable prompt templates.
- How deep it goes
- Explains feature relevance, scaling, refinement, and interpretation, but does not detail mathematical representations or implementation code.
- Examples
- Uses customer purchase behavior, browsing activity, product preferences, user profiles, and dynamic prompt variables as examples.
- What you can do after
- Apply it by selecting, scaling, and refining variables that make model outputs more relevant, interpretable, and actionable.
Digital Twins in Action
A feature is an input variable or measurable property used to characterize an instance in analytical or machine learning processing.
- How it is used
- Uses features to turn operational measurements into inputs for analytical models and forecasts.
- How deep it goes
- Explains feature transformations and demonstrates column selection and model training, without detailing the calculations for each transformation.
- Examples
- Uses temperature deviations and lagged indoor temperatures to illustrate contextual and temporal features.
- What you can do after
- Apply it via scikit-learn by selecting feature columns and training a one-hour-ahead temperature forecast.
Also covered in
- Grokking AI Algorithms, Second Edition
- Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
- Modern Angular
- Grokking AI Applications
- Tiny Python Projects: Learn coding and testing with puzzles and games
- Python Workout, Second Edition
- Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
- Modern C
- Python How-To
- Django in Action
- Rust Servers, Services, and Apps
- LLMs in Production
What to know first
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- generationGeneration is the production of an output by a computational model from supplied input or context, often using patterns learned from data.
Related concepts
- function declarationpart of · A function declaration is a source-language construct that introduces a function by specifying its name and parameter interface, and may also provide its implementation.
- command-line argumentcontrasts with · A command-line argument is a value or option supplied to a program when it is invoked, providing input or affecting its behavior.
- constantkind of · A constant is a value or named binding treated as fixed rather than reassigned or modified during a computation, whether this is enforced by a language or followed by convention.
- factoryused by · A factory is a function, method, or component that creates and returns values or objects while encapsulating construction or selection logic.
- function argumentcontrasts with · A function argument is a value or expression supplied when a function or method is invoked, providing input to the called operation.
- linear regressionproduced by · Linear regression is a statistical method that models a numeric response as a linear function of one or more predictor variables with fitted parameters.
Questions about input
What is input?
An input is information, a value, or an action supplied to a system, program, or computation for processing or to influence its behavior.
Which Manning books explain input?
Grokking Machine Learning, Learn AI-Assisted Python Programming, Second Edition, Get Programming: Learn to code with Python, Fight Fraud with Machine Learning, Statistics Every Programmer Needs, Machine Learning System Design, Grokking Machine Learning, Second Edition, AI-Powered Search and 10 more.
What should I know before learning input?
Manning books that teach input usually introduce function, language model, Python and generation first.
What is the difference between input and command-line argument?
An input is information, a value, or an action supplied to a system, program, or computation for processing or to influence its behavior. A command-line argument is a value or option supplied to a program when it is invoked, providing input or affecting its behavior.
What is input a kind of?
Input is a kind of constant. A constant is a value or named binding treated as fixed rather than reassigned or modified during a computation, whether this is enforced by a language or followed by convention.
What is input part of?
Input is part of function declaration. A function declaration is a source-language construct that introduces a function by specifying its name and parameter interface, and may also provide its implementation.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.

















