Array
An array is an indexed, ordered collection of elements arranged in one or more dimensions, with elements accessed by position.
Deep Learning with PyTorch, Second Edition
A container for indexed collections of values.
- How it is used
- Represents indexed numerical data used as neural-network inputs, outputs, intermediate values, and parameters.
- How deep it goes
- Works through construction, indexing, broadcasting, and shared-storage views down to offsets and strides, without developing generalized tensor backends.
- Examples
- Uses indexed point coordinates, broadcast arithmetic on differently shaped tensors, and a shared-storage view changed through a selected row.
- What you can do after
- Build it from scratch with `torch.tensor`, inspect its shape, index values, and distinguish shared views from copies.
Read how Deep Learning with PyTorch, Second Edition explains array →
Math and Architectures of Deep Learning
An indexed sequence of values, here used to represent a signal processed by a convolution.
- How it is used
- Represents training data, images, layer values, and convolution signals as indexed numeric structures.
- How deep it goes
- Defines dimensional array views and demonstrates PyTorch shapes, indexing, slicing, images, and convolution interfaces without formal tensor distinctions.
- Examples
- Uses training-feature matrices, RGB images, image crops, batched images, and sliding local-average or edge-detection kernels.
- What you can do after
- Apply it via PyTorch by creating, indexing, slicing, reshaping, and supplying arrays to convolution operations.
Read how Math and Architectures of Deep Learning explains array →
Learn Generative AI with PyTorch
An array with one or more dimensions, used here as the general definition of a tensor.
- How it is used
- Uses numeric arrays to hold inputs for deep learning and multidimensional outputs for music generation.
- How deep it goes
- Works through creation, data types, shapes, indexing, reshaping, and dimension-wise operations without descending into tensor storage internals.
- Examples
- Uses presidential heights, two-column curve data, grayscale clothing images, and four-dimensional music pieces.
- What you can do after
- Apply it via PyTorch to create, index, reshape, and summarize numeric data before feeding it to models.
Grokking Data Structures
An array is a data structure that stores elements in an ordered, typically contiguous sequence accessed by index.
- How it is used
- Uses arrays to organize values by position, from fixed counters to collections filled as entries arrive.
- How deep it goes
- Works through indexing, memory layout, logical size and deletion, then distinguishes abstract behavior from implementation requirements.
- Examples
- Illustrates positions with an Advent calendar and uses six indexed counters to record dice rolls.
- What you can do after
- Build it from scratch as a fixed-capacity, unsorted container that tracks meaningful entries and supports order-insensitive deletion.
Julia as a Second Language
An array is an ordered collection of elements that can have any Julia-supported element type and can be organized in one or more dimensions.
- How it is used
- Uses arrays to organize spreadsheet-like data and calculate with columns of values.
- How deep it goes
- Works through construction, indexing, arithmetic, and shape queries, then adds slices and views; defers the details of element-type inference.
- Examples
- Uses pizza-sales quantities and prices, spreadsheet-style tables, and rocket-engine collections to demonstrate calculations, dimensions, and indexed access.
- What you can do after
- Apply it via Julia to create, inspect, index, transform, slice, and combine vectors and matrices.
Modern C
An array is a C aggregate containing a fixed sequence of items of the same type, accessed by indices.
- How it is used
- Groups same-type objects for indexed access, including nested arrays used as two-dimensional matrices.
- How deep it goes
- Works through declarations, initializers, lengths, operations, nested arrays, and array decay; defers the full pointer relationship until later.
- Examples
- Uses double arrays, designated initializers, equivalent multidimensional declarations, and pointer-based functions that sum array elements.
- What you can do after
- Build it from scratch: declare, initialize, index, and measure arrays while distinguishing an array object from a pointer parameter.
Deep Learning with Python, Third Edition
A numerical container whose elements are organized over one or more axes and manipulated by vectorized operations.
- How it is used
- Organizes training examples and model weights into numerical containers that neural-network layers can transform.
- How deep it goes
- Defines rank, shape, and dtype, then works through data layouts, layer operations, and input preparation without dense mathematical notation.
- Examples
- Uses MNIST image shapes, common dataset layouts, a Dense-layer expression, and multi-hot encoding of word-index sequences.
- What you can do after
- Apply it via NumPy or PyTorch to inspect array attributes, choose data shapes, and prepare batchable inputs.
Read how Deep Learning with Python, Third Edition explains array →
Inside Deep Learning: Math, Algorithms, Models
An array with any number of dimensions, including scalars, vectors, matrices, and higher-rank arrays.
- How it is used
- Organizes deep-learning data, inputs, outputs, and parameters for computation.
- How deep it goes
- Defines ranks, shapes, notation, slicing, and basic PyTorch operations without descending into array internals.
- Examples
- Uses scalars, vectors, matrices, three-dimensional arrays, NumPy conversion, slicing, summation, transposition, and boolean comparisons.
- What you can do after
- Apply it via PyTorch by creating arrays, reading shapes, converting NumPy values, slicing, and performing basic operations.
Read how Inside Deep Learning: Math, Algorithms, Models explains array →
Deep Learning with R, Third Edition
An R array is R's built-in multidimensional array data structure for storing values across one or more dimensions.
- How it is used
- Represents numerical data as multidimensional tensors for neural-network inputs and operations.
- How deep it goes
- Works through array construction, axes, rank, shape, data type, dataset shapes, and image reshaping; does not detail array storage internals.
- Examples
- Uses a 2 × 3 R array, MNIST image arrays, and shapes for tabular, sequence, image, and video data.
- What you can do after
- Practice/perform array construction, inspect rank and shape, and reshape image arrays for a Dense-layer model.
Read how Deep Learning with R, Third Edition explains array →
Learn Rust in a Month of Lunches
An array is a fixed-size Rust collection whose length is known at compile time and whose elements have one type.
- How it is used
- Uses arrays to hold ordered, same-type values when a fixed-size collection fits the job.
- How deep it goes
- Works through creation, types, repetition, indexing, and slices, but defers actual byte-buffer operations.
- Examples
- Shows string arrays, a repeated-zero byte buffer, indexed numbers, range slices, and mapped integers.
- What you can do after
- Build it from scratch with bracket or repetition syntax, then index, slice, and change elements without changing the array’s size.
100 C++ Mistakes and How to Avoid Them
An array is a fixed-layout sequence of elements accessed by position through an index.
- How it is used
- Guides container selection by exposing where arrays hinder correctness, readability, iteration, and maintenance.
- How deep it goes
- Explains array sizing, default construction, resizing, invalid elements, and indexing, but defers lower-level implementation details.
- Examples
- Uses Person arrays, vector replacements, raw-array summation, and iterator-based summation over vector and set containers.
- What you can do after
- Evaluate array usage and replace many collections with vectors or iterator-based interfaces when size, construction, or validity is difficult to manage.
Read how 100 C++ Mistakes and How to Avoid Them explains array →
Grokking Algorithms, Second Edition
An array is a data structure that stores elements in indexed positions, typically in contiguous memory.
- How it is used
- Uses arrays to store sequences whose items can be read directly by position.
- How deep it goes
- Explains contiguous memory, indexed reads, growth, insertion, and caching through comparisons with linked lists, without detailing an array implementation.
- Examples
- Illustrates arrays with numbered drawers, a growing to-do list, a fifth-item address calculation, and Python binary search.
- What you can do after
- Evaluate/understand when direct reads favor an array and when insertion costs favor a linked list.
Read how Grokking Algorithms, Second Edition explains array →
Modern C, Third Edition
An array is an aggregate object containing a fixed sequence of items of the same type, accessed by numeric indices.
- How it is used
- Groups ordered objects of one type for indexed access and for processing through pointer-and-length function interfaces.
- How deep it goes
- Explains declarations, nested arrays, element access, and operation restrictions; develops pointer relationships separately.
- Examples
- Uses double-array declarations, nested indexing, and array portions passed to a summing function with explicit lengths.
- What you can do after
- Apply C array declarations and indexing while avoiding whole-array assignment, comparison, and assumptions that pointers preserve array lengths.
DuckDB in Action
An array is an ordered collection of values that can be accessed by position and may be represented as a nested data structure in formats such as JSON.
- How it is used
- Uses arrays to transform nested JSON fields into queryable rows during exploratory data analysis.
- How deep it goes
- Explains schema inspection, one-level unnesting, recursive expansion, STRUCT projection, and explicit type casting.
- Examples
- Demonstrates football shot arrays, flattened STRUCT rows, schema descriptions, and team-level expected-goals aggregation.
- What you can do after
- Apply it via DuckDB to inspect nested arrays, flatten elements, correct types, and build analytical views.
Grokking Simplicity
An indexed JavaScript collection that stores an ordered sequence of values and can change size.
- How it is used
- Represents ordered collections and supports data-oriented processing, copying, selection, and incremental transformations.
- How deep it goes
- Explains indexing, length, mutation, copying, removal, and copy-on-write, but stops short of implementation internals.
- Examples
- Uses indexed values, end operations, subsequences, removed items, a mailing list, and moving loop data into an array.
- What you can do after
- Apply JavaScript array operations and refactor shared-list updates into a copy-on-write workflow.
Go in Action, Second Edition
An array is a fixed-length, indexed sequence of values of one element type that is itself a value in Go.
- How it is used
- Represents fixed-size ordered data and provides a contrast with slices when collection size must vary.
- How deep it goes
- Works through declarations, indexing, iteration, assignment, nested arrays, and function-copy costs; stops short of array-backed storage internals.
- Examples
- Uses integer and string literals, nested arrays, range-loop mutations, and a large image array passed to a function.
- What you can do after
- Build it from scratch with typed array declarations and indexed loops, then choose pointers or slices when copying or growth matters.
Learn Go with Pocket-Sized Projects
An array is a Go sequence of a fixed number of values of one type whose length is part of its type.
- How it is used
- Uses arrays for small collections whose size is fixed, while recommending slices for most variable-length collections.
- How deep it goes
- Defines array syntax, type-level length, resizing limits, iteration, and a minor allocation optimization, without deeper runtime internals.
- Examples
- Demonstrates [5]string declarations and a [4]image.Point neighbor array for maze navigation.
- What you can do after
- Evaluate/understand when a fixed-size Go collection is appropriate and distinguish it from a slice.
Read how Learn Go with Pocket-Sized Projects explains array →
C# Concurrency: Asynchronous and multithreaded programming
An array is a contiguous, indexed block of memory whose elements are stored sequentially.
- How it is used
- Uses contiguous storage as the performance-oriented foundation for standard collections and sequential memory scans.
- How deep it goes
- Explains memory layout, CPU caching, collection implementations, and immutable-copy trade-offs without detailing array allocation internals.
- Examples
- Uses standard collection implementations, a locked array-backed stack, and ImmutableArray<T> as concrete examples.
- What you can do after
- Evaluate array-backed designs by comparing scan speed, memory locality, copying cost, mutation frequency, and sharing requirements.
Read how C# Concurrency: Asynchronous and multithreaded programming explains array →
The Design of Web APIs, Second Edition
An array is an ordered collection of values in a serialized data format.
- How it is used
- Models ordered collections and grouped business data in portable API representations.
- How deep it goes
- Explains JSON representation, resource modeling, schema syntax, embedding trade-offs, and extensibility, while deferring array-size constraints.
- Examples
- Uses catalogs, product keywords, bank-account balances, transactions, owners, tags, and grouped transfer events.
- What you can do after
- Build it from scratch by modeling collections, defining items schemas, and choosing between embedded, object-based, and separate lists.
Read how The Design of Web APIs, Second Edition explains array →
Fast Python: High performance techniques for large datasets
- How it is used
- Uses arrays to reduce memory overhead, organize NumPy data, and illustrate parallel elementwise processing.
- How deep it goes
- Defines fixed-size, same-type storage and traces NumPy views through shared memory, shape, and strides; defers allocation details.
- Examples
- Demonstrates file bytes, reshaped and transposed NumPy views, and elementwise doubling.
- What you can do after
- Evaluate storage and execution trade-offs by comparing list overhead, shared-memory views, and sequential versus parallel array processing.
Read how Fast Python: High performance techniques for large datasets explains array →
.NET in Action, Second Edition
An array is an indexed, typically fixed-size sequence of elements of a specified type.
- How it is used
- Illustrates why C# array references permit heap compaction and why allocations can affect latency.
- How deep it goes
- Shows allocation, indexed access, and a pointer-based copy, then explains compaction without detailing garbage-collector algorithms.
- Examples
- Uses C# array-reading and pointer-copy listings alongside heap-allocation diagrams.
- What you can do after
- Evaluate/understand how array references allow compaction and why collection pauses matter for latency.
100 Go Mistakes and How to Avoid Them
A Go array is a fixed-length sequence of elements stored contiguously and serving as the backing storage for slices.
- How it is used
- Explains slice bounds and append side effects through backing storage, and diagnoses stale values when ranging over an array.
- How deep it goes
- Traces array copying during range and backing-array sharing during append, then gives targeted alternatives.
- Examples
- Uses a three-length, six-capacity slice, a modified array during range, and an append that changes another slice.
- What you can do after
- Diagnose/debug with it when range prints an old value or append unexpectedly changes a related slice.
Read how 100 Go Mistakes and How to Avoid Them explains array →
100 Java Mistakes and How to Avoid Them
An array is an indexed Java object or primitive container with a fixed length and a single component type.
- How it is used
- Diagnoses array mistakes involving variable-arity calls, collection substitutions, and content comparison.
- How deep it goes
- Explains compile-time wrapping and equality behavior with focused examples, but stops short of general array implementation internals.
- Examples
- Uses printAll calls, a generic contains helper, array equality, and explicit null casts as diagnostic examples.
- What you can do after
- Diagnose ambiguous calls, choose explicit casts, preserve array-versus-collection semantics, and compare array contents correctly.
Read how 100 Java Mistakes and How to Avoid Them explains array →
Code Like a Pro in Rust
An array is a sequence data structure whose elements share a type and can be iterated over and sliced.
- How it is used
- Uses arrays for fixed-length, same-type sequences and slices when sequence length may be determined at run time.
- How deep it goes
- Defines the length distinction and shows borrowing an array as a slice; defers detailed treatment of const generics.
- Examples
- Demonstrates a 64-byte zero-initialized array, its borrowed slice, and splitting that slice at element 32.
- What you can do after
- Practice/perform fixed-length array initialization and borrowing as a slice, while accounting for compile-time length requirements.
Data-Oriented Programming: Reduce software complexity
An ordered collection whose elements are accessed by numeric position.
- How it is used
- Uses arrays to represent a request's multiple selectable fields and validate their shape.
- How deep it goes
- Explains array types, element schemas, enumerated values, required fields, and validation outcomes.
- Examples
- Uses a book-search request whose fields array contains title, weight, and number_of_pages.
- What you can do after
- Apply it via JSON Schema to validate array contents and permitted field names.
Read how Data-Oriented Programming: Reduce software complexity explains array →
Learn AI-Assisted Python Programming, Second Edition
A two-dimensional list is a list whose elements represent rows or nested collections, forming a grid-like structure.
- How it is used
- Uses two-dimensional data to demonstrate how rows, columns, and nested loops work together.
- How deep it goes
- Explains list-of-lists storage, row and column indexing, and nested iteration without discussing array-library internals.
- Examples
- Uses a 2018 Winter Olympics medal table represented as rows of gold, silver, and bronze counts.
- What you can do after
- Build it from scratch with Python lists, retrieve individual values, and process every row and column using nested loops.
Read how Learn AI-Assisted Python Programming, Second Edition explains array →
Advanced Algorithms and Data Structures
An array is a data structure that stores elements associated with positions, typically supporting access to an element by its index.
- How it is used
- Organizes finite collections for indexed storage, retrieval, and comparison with alternative implementations.
- How deep it goes
- Defines indexed storage, distinguishes ADTs from implementations, shows contiguous-memory addressing, and compares selected operation costs.
- Examples
- Uses a character array, an unsorted-array dictionary, priority-queue alternatives, and array-indexed linked-list partitions.
- What you can do after
- Evaluate/understand when indexed arrays suit storage, lookup, insertion, removal, priority queues, and auxiliary indexing.
Read how Advanced Algorithms and Data Structures explains array →
Functional Programming in Scala, Second Edition
An array is an indexed, fixed-size sequence of elements stored in contiguous or logically contiguous positions.
- How it is used
- Uses arrays to demonstrate indexed traversal and locally scoped mutation.
- How deep it goes
- Explains recursive traversal and STArray primitives, stopping short of a complete quicksort implementation.
- Examples
- Demonstrates neighboring-element checks, fill from a Map, List conversion, and an in-place quicksort setting.
- What you can do after
- Build it from scratch by implementing indexed traversals and composing allocation, reading, writing, filling, and freezing operations.
Read how Functional Programming in Scala, Second Edition explains array →
Kotlin in Action, 2E
An array is an indexed, fixed-size sequence of elements of a specified type.
- How it is used
- Uses arrays for indexed data, Java method parameters, Kotlin vararg calls, and selected performance-sensitive cases.
- How deep it goes
- Explains array construction, indexing, initialization, collection conversion, boxing, primitive representations, and the preference for collections.
- Examples
- Demonstrates command-line arguments, alphabet generation, integer squares, primitive-array construction, and collection-to-vararg conversion.
- What you can do after
- Build and apply typed, nullable, generic, or primitive arrays and pass collections to array-based APIs.
Everyday Data Visualization
An array is an ordered collection of data elements represented in JSON with square brackets and comma-separated values.
- How it is used
- Groups related data values so they can be referenced together or handled through shared operations.
- How deep it goes
- Explains JSON syntax, one and two dimensions, deeper nesting, data-type consistency, and the clarifying role of objects.
- Examples
- Uses pill containers, weekday lists, time-slot lists, nested arrays, and named arrays inside objects.
- What you can do after
- Build it from scratch as one-dimensional or nested JSON data, then choose objects when names improve clarity.
Pro ASP.NET Core 7, Tenth Edition
An array is a fixed-size ordered data structure whose elements are accessed by numeric index and share a declared element type.
- How it is used
- Uses arrays to carry application data, render view models, and collect repeated form values through ASP.NET Core model binding.
- How deep it goes
- Explains typed and nullable array declarations, then works through rendering, repeated form names, null filtering, and explicit indexes.
- Examples
- Demonstrates Product[], string arrays in views, nullable product elements, repeated Data inputs, null filtering, and indexed form names.
- What you can do after
- Apply it via C# and ASP.NET Core by declaring typed arrays, handling nullable elements, rendering values, and binding repeated form inputs.
Learn C++ by Example
An array is a fixed-size sequence of elements stored in contiguous positions and accessed by index.
- How it is used
- Stores a known-size deck of cards in a small game where the collection should not grow.
- How deep it goes
- Explains compile-time sizing, storage differences, initialization, indexing, iterators, and data access without detailing array internals.
- Examples
- Builds a 52-card deck by combining four suits with thirteen face values.
- What you can do after
- Apply it via std::array to declare, initialize, traverse, index, and expose fixed-size collections.
Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
An array is an ordered collection of values that can be accessed as a single sequence.
- How it is used
- Supplies one or many values to PowerShell parameters and supports reusable command-line data handling.
- How deep it goes
- Defines creation, indexing, conversion, and iteration, while deferring more complex ways to supply lists.
- Examples
- Uses file paths, five strings, tab-delimited computer records, numeric ranges, and foreach output.
- What you can do after
- Apply it via PowerShell arrays, -join, -split, indexing, and foreach to process collections.
Python Workout: 50 ten-minute exercises
- How it is used
- Frames arrays through Python’s practical choice between list-based storage and genuinely fixed-type arrays.
- How deep it goes
- Distinguishes array constraints from list behavior and explains hidden resizing, but stops short of detailed allocation algorithms.
- Examples
- Uses append-growth measurements showing stable sizes followed by memory-allocation jumps.
- What you can do after
- Evaluate array-like choices and understand why Python lists usually replace fixed-size arrays.
Read how Python Workout: 50 ten-minute exercises explains array →
Essential TypeScript 5, Third Edition
An array is an ordered collection data structure whose elements are accessed by position.
- How it is used
- Uses arrays to store ordered JavaScript values and apply collection operations, then adds compile-time element restrictions for TypeScript applications.
- How deep it goes
- Explains creation, indexing, resizing, mutation methods, typed callbacks, unions, and object shapes, but does not discuss implementation internals.
- Examples
- Uses names and prices, typed product prices, forEach tax calculation, and mixed-shape product objects to expose ordinary and erroneous cases.
- What you can do after
- Apply it via JavaScript and TypeScript syntax to create, index, mutate, iterate, type, and diagnose arrays in application code.
Read how Essential TypeScript 5, Third Edition explains array →
Data Without Labels
A matrix is a rectangular arrangement of values organized into rows and columns.
- How it is used
- Represents images and text numerically so algorithms can perform mathematical and statistical calculations.
- How deep it goes
- Defines rectangular organization and demonstrates binary-vector encoding, but stops short of detailed array operations or implementation code.
- Examples
- Uses binary word vectors and an illustrated vacuum-cleaner image region represented as a matrix.
- What you can do after
- Apply matrix representations to encode text and image data for algorithmic analysis.
Python Workout, Second Edition
An array is a data structure whose elements occupy a fixed-size, homogeneous sequence of storage positions.
- How it is used
- Frames arrays through Python’s practical list and tuple programming exercises.
- How deep it goes
- Explains fixed size, homogeneity, pointer storage, spare capacity, reallocation, and measurement, but stops short of formal complexity analysis.
- Examples
- Uses alternating-sum and zip exercises plus sys.getsizeof measurements of list growth.
- What you can do after
- Evaluate how Python lists behave as array-like structures and practice processing list or tuple data.
Rust in Action: Systems programming concepts and techniques
An array is a contiguous, indexable sequence of a fixed number of elements whose size is part of its type.
- How it is used
- Supports fixed-size collections and iteration while building a text-search program that prints context around matches.
- How deep it goes
- Explains construction, type-level length, contiguous memory, iteration, and bounds-checked indexing, then connects arrays to slices and vectors.
- Examples
- Uses numeric literals, repeat expressions, iteration and summation, plus byte arrays for loading instructions into emulated memory.
- What you can do after
- Build it from scratch by declaring fixed-size Rust arrays, iterating over their elements, summing values, and accessing elements safely.
Read how Rust in Action: Systems programming concepts and techniques explains array →
Secrets of the JavaScript Ninja, Second Edition
An ordered, indexed collection of values.
- How it is used
- Uses arrays to handle item collections and begins exploring JavaScript collection handling.
- How deep it goes
- Explains creation, indexing, length, and out-of-range behavior without descending into implementation internals.
- Examples
- Uses arrays of ninjas and samurai to demonstrate creation, indexed access, and out-of-range reads.
- What you can do after
- Build it from scratch by creating arrays, reading indexed values, and extending them with assignments.
Read how Secrets of the JavaScript Ninja, Second Edition explains array →
Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond
A built-in JavaScript ordered, indexable collection type whose constructor can create arrays of specified length or elements.
- How it is used
- Stores collections and supports constructing arrays or searching their contents.
- How deep it goes
- Names construction and search methods but does not detail their behavior in the available excerpts.
- Examples
- Uses a DOM color update and an array of previous prisoner sentence lengths as examples.
- What you can do after
- Apply Array.from, Array.of, fill, includes, and find to construct or search arrays.
Related concepts
- loopused by · A loop is a programming control-flow construct that repeatedly executes a block of instructions according to an iteration rule or continuation condition.
- indexinguses · Indexing is the organization or use of positions, keys, or lookup structures to identify and retrieve selected data or elements.
- data structurekind of · A data structure is an organized representation of data and its relationships that supports defined operations for storing, accessing, or modifying it.
- fixed-size arrayincludes · A fixed-size array is an indexed collection whose storage capacity or length is established when it is created and remains unchanged.
- listalternative to · A list is an ordered collection of elements arranged in a sequence.
- vectorincludes · A vector is an ordered, indexed sequence of elements, often numerical, represented as a mathematical quantity or a computational collection.
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.