List
A list is an ordered collection of elements arranged in a sequence.
A Pythonic Adventure: From Python basics to a working web app
A Python list is an ordered, mutable collection that can contain values of different types, including other lists.
- How it is used
- Uses lists to build coffee-shop menus, present choices, and collect saved orders.
- How deep it goes
- Defines lists and zero-based indices, then works through looping, input conversion, retrieval, and append usage without storage internals.
- Examples
- Demonstrates drinks, flavors, and toppings menus, numbered selections, and a list of order dictionaries.
- What you can do after
- Apply it via Python to create menus, print their items, and retrieve selections by converted numeric index.
Read how A Pythonic Adventure: From Python basics to a working web app explains list →
Get Programming: Learn to code with Python
- How it is used
- Stores ordered, changeable collections, from grocery items to words extracted for document comparison.
- How deep it goes
- Works through creation, indexing, mutation, copying, and applications; does not develop list implementation internals.
- Examples
- Uses grocery lists, pancake stacks, store queues, and document words, alongside short code checks.
- What you can do after
- Build it from scratch: create and change lists, then use them to model a stack or queue.
Read how Get Programming: Learn to code with Python explains list →
Tiny Python Projects: Learn coding and testing with puzzles and games
An empty list is a list containing zero elements.
- How it is used
- Uses lists to collect, transform, validate, format, and represent ordered program state.
- How deep it goes
- Explains creation, length, indexing, slicing, membership, mutation, sorting, joining, and construction patterns through runnable examples.
- Examples
- Demonstrates picnic arguments, mutable song verses, random word selection, CSV records, DNA-like text mutation, and Tic-Tac-Toe boards.
- What you can do after
- Build it from scratch, modify ordered collections safely, format their contents, and choose appropriate list-construction techniques.
Read how Tiny Python Projects: Learn coding and testing with puzzles and games explains list →
Python How-To
- How it is used
- Stores ordered, changeable collections such as tasks while supporting indexing, updates, and rearrangement.
- How deep it goes
- Explains container selection, slicing, lookup costs, and FIFO trade-offs through practical cases rather than exhaustively cataloging list methods.
- Examples
- Uses task collections, stock-list containment checks, custom-class searches, and a customer queue.
- What you can do after
- Build it from scratch as a mutable collection, then evaluate when a tuple, set, or deque better fits the task.
Fast Python: High performance techniques for large datasets
- How it is used
- Uses lists as a baseline for temperature searches and file-data storage before testing alternative data structures.
- How deep it goes
- Works through membership benchmarks, interval-search trade-offs, and container-versus-element memory costs rather than general list operations.
- Examples
- Benchmarks temperature membership and distinct-integer membership, then measures a file-data list with `sys.getsizeof`.
- What you can do after
- Diagnose/debug with `%timeit` and `sys.getsizeof`, then choose sets for repeated exact membership or ordered lists for interval searches.
Read how Fast Python: High performance techniques for large datasets explains list →
Idiomatic Rust
A linked list is a sequence of elements in which each element stores a reference or pointer to another element in the sequence.
- How it is used
- Uses a linked list to develop recursive generics and idiomatic collection iteration, then questions its use as a Vec replacement.
- How deep it goes
- Works through node representation and three iterator modes, including unsafe reference handling, but treats the initial boxed-node design as impractical.
- Examples
- Shows recursive node listings, list traversal, string-to-integer collection, and append/find/remove benchmarks against Vec and HashSet.
- What you can do after
- Build it from scratch as a generic iterator-equipped exercise, or evaluate whether Vec better fits measured collection operations.
Python Workout, Second Edition
A list is a mutable ordered collection in Python.
- How it is used
- Uses mutable ordered collections to store, search, transform, extend, and modify related values.
- How deep it goes
- Explains mutation, sequence retrieval, slicing, accumulation, sorting, and comprehensions, stopping short of implementation internals.
- Examples
- Demonstrates character translation, accumulated Pig Latin output, sliced sequences, comprehensions, and object attributes containing Scoop instances.
- What you can do after
- Apply lists via indexing, slicing, append, join, sorting, and comprehensions in practical Python transformations.
Elixir in Action, Third Edition
A list is an ordered Elixir data structure whose elements can be traversed and combined through list operations.
- How it is used
- Supports ordered, variable-size collections and sequential data construction.
- How deep it goes
- Explains linked structure, immutability, sharing, operation costs, head-tail construction, and IO-list optimization.
- Examples
- Uses prime numbers, membership checks, indexed lookup, replacement, head-tail patterns, and nested output construction.
- What you can do after
- Apply it via List, Enum, pattern matching, and IO functions while choosing operations according to their traversal costs.
Kotlin in Action, 2E
MutableList is a Kotlin mutable collection type whose elements can be read and modified through its invariant type parameter.
- How it is used
- Separates read-only list parameters from mutation-capable MutableList parameters in Kotlin APIs.
- How deep it goes
- Explains creation, mutation, nullability, Java interoperation, and variance-based safety without detailing collection implementations.
- Examples
- Uses name replacement, line-by-line number parsing, Java parser interfaces, and unsafe mixed-type mutation scenarios.
- What you can do after
- Apply it via Kotlin collection factories and operations while choosing mutability and nullability that match API contracts.
Learn Haskell by Example
A list is an ordered sequence data structure whose elements can be processed recursively from its first element and remaining tail.
- How it is used
- Uses lists to represent character collections and recursively search or transform strings.
- How deep it goes
- Defines notation, homogeneous typing, constructors, pattern matching, and recursive implementations, while deferring generalization of transformations.
- Examples
- Demonstrates typed numeric and Boolean lists, recursive length and index functions, and a Caesar cipher over a String.
- What you can do after
- Build it from scratch with empty and nonempty patterns to search or transform a list recursively.
Clojure: The Essential Reference
A list is a Clojure sequential collection whose elements are traversed in order and which is optimized for access at the ends.
- How it is used
- Positions lists as direct sequences for head-first collection operations, particularly stacks, and as structures involved in compiling Clojure code.
- How deep it goes
- Defines construction and return behavior, works through head insertion and stack uses, and contrasts list with cons on counting and reduction.
- Examples
- Demonstrates head insertion, reversal with into, nearest-smaller-value search, and delimiter checking with a stack.
- What you can do after
- Build it from scratch with list and conj, then use head-first operations to implement a stack or reverse a collection.
F# in Action: A Revised Edition of Get Programming with F#
In F#, a list is an immutable ordered collection whose elements can be processed as a sequence.
- How it is used
- Transforms collection data through declarative pipelines instead of mutable loops and summaries.
- How deep it goes
- Defines syntax, immutability, pipeline operations, debugging, performance cautions, pattern matching, and collection trade-offs.
- Examples
- Uses soccer results for an away-win query and loan requests for list-pattern matching.
- What you can do after
- Apply it via List functions, FSI inspection, and pattern matching to query and classify immutable collections.
Read how F# in Action: A Revised Edition of Get Programming with F# explains list →
Functional Programming in Scala, Second Edition
A list is an ordered collection whose elements are linked sequentially and whose structure is preserved by list-processing operations.
- How it is used
- Represents ordered data with pure operations that preserve inputs and produce new lists.
- How deep it goes
- Defines Nil and Cons, explains head and tail, and practices map, filter, flatMap, and generalized list processing.
- Examples
- Uses Nil, Cons, integer and string lists, element transformations, predicate filtering, paired-list addition, and flatMap duplication.
- What you can do after
- Build it from scratch with Nil and Cons, then implement reusable map, filter, flatMap, and generalized list functions.
Read how Functional Programming in Scala, Second Edition explains list →
Learn AI-Assisted Python Programming, Second Edition
An empty list is a list containing no elements.
- How it is used
- Uses lists to package a variable number of values as one function argument and process those values in practical examples.
- How deep it goes
- Defines lists as collections of values and demonstrates function calls and processing, while deferring broader list details to later treatment.
- Examples
- Demonstrates Scrabble word selection and longest-word tests using ordinary, single-item, tied, and empty-string lists.
- What you can do after
- Apply lists through Python function calls and test list-processing behavior across common and edge-case inputs.
Read how Learn AI-Assisted Python Programming, Second Edition explains list →
100 Java Mistakes and How to Avoid Them
List is the Java collection interface for an ordered sequence of elements that may contain duplicates.
- How it is used
- Uses List for ordered, duplicate-tolerant collections, array bridging, content comparison, and membership tests.
- How deep it goes
- Explains varargs internals, boxing, equality requirements, null behavior, defensive fixes, and static-analysis limits.
- Examples
- Uses Arrays.asList() searches, equal integer lists, unmodifiable collections, and null-sensitive collection factories.
- What you can do after
- Diagnose misleading array searches, choose compatible equality comparisons, guard nullable membership tests, and heed analyzer warnings.
Read how 100 Java Mistakes and How to Avoid Them explains list →
API Design Patterns
A list is an ordered collection of values that can be addressed by position and may contain nested lists or other data types.
- How it is used
- Represents bounded, simple collections inherent to an API resource, such as a book’s categories or tags.
- How deep it goes
- Explains addressing, atomic replacement, consistency risks, bounds, defaults, and when to choose subcollections.
- Examples
- Uses a Book resource with a categories string list and contrasts inline lists with separately managed category resources.
- What you can do after
- Evaluate whether an API field should be an atomic bounded list, a defaulted value, or a paginated subcollection.
ScyllaDB in Action
A list is an ordered collection type that can contain multiple values, including duplicate values, of one specified type.
- How it is used
- Stores small, ordered groups of same-typed values inside ScyllaDB rows.
- How deep it goes
- Explains declaration, insertion, concatenation, removal, indexing, replacement, and non-idempotent append behavior.
- Examples
- Uses CQL commands that insert, append, remove, replace, delete, select, and reset a three-element text list.
- What you can do after
- Operate/configure typed lists with CQL and recognize when duplicate-producing updates or unbounded growth require another design.
Grokking Data Structures
A list is a Python sequence type that stores an ordered collection of elements and supports dynamic resizing and heterogeneous element types.
- How it is used
- Uses Python lists as flexible, dynamically resizing containers and as array-like storage inside larger data structures.
- How deep it goes
- Defines the list abstraction and compares implementations, but defers detailed Python list operations and implementation internals.
- Examples
- Demonstrates lists through array comparisons, a custom array implementation, and a heap whose elements occupy a Python list.
- What you can do after
- Evaluate whether Python lists, typed arrays, or linked lists fit a container’s flexibility and performance requirements.
How Computers Make Books
A list is an ordered collection of elements that can be empty or decomposed into a first element and a remaining sublist.
- How it is used
- Uses lists to demonstrate how structured data supports increasingly complex programs.
- How deep it goes
- Defines heads, tails, emptiness, concatenation, and recursive list algorithms, without detailing underlying storage.
- Examples
- Uses empty lists, ordered number lists, length, sum, reversal, and insertion sorting as worked examples.
- What you can do after
- Build it from scratch by defining list length, sum, reversal, insertion, and sorting functions.
Go in Action, Second Edition
A list is an ordered collection of elements that supports sequential access and typically dynamic size.
- How it is used
- Uses a generic interface to organize ordered data and reuse collection algorithms across implementations.
- How deep it goes
- Works through a linked-list implementation, including node linking, bounds checks, equality searches, indexed access, and reversal.
- Examples
- Demonstrates LinkedList[int] operations and reverses a list through a generic List interface.
- What you can do after
- Build it from scratch as a type-safe linked list and apply reusable functions such as reversal through its generic interface.
Fabulous Adventures in Data Structures and Algorithms
A list is an ordered collection of elements that supports sequence-oriented operations.
- How it is used
- Uses sorted lists to implement word containment and prefix lookup when hash sets are unavailable.
- How deep it goes
- Implements binary search, insertion-index decoding, prefix iteration, and asymptotic costs for string comparisons.
- Examples
- Demonstrates a sorted word list supporting Contains and StartsWith operations.
- What you can do after
- Apply it via C# List<string>.BinarySearch and StartsWith to build sorted word lookup and prefix enumeration.
Read how Fabulous Adventures in Data Structures and Algorithms explains list →
Related concepts
- 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.
- tuplecontrasts with · A tuple is a finite, ordered collection of elements treated as a single composite value or record.
- splitproduced by · Split is an operation or function that divides a string or sequence into parts according to a separator, pattern, or other rule.
- arrayalternative to · An array is an indexed, ordered collection of elements arranged in one or more dimensions, with elements accessed by position.
- sortedproduced by · sorted is a Python built-in function that returns a new list containing an iterable’s elements in sorted order without modifying the original iterable.
- linked listkind of · An ordered sequence of elements stored in separate nodes connected by links or references rather than in one contiguous storage region.
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.