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
- Uses lists to hold and manipulate ordered project data, including tasks and extracted records.
- How deep it goes
- Explains mutation, slicing, sorting, searches, and container trade-offs through worked examples rather than an exhaustive list reference.
- Examples
- Uses task records, fruit slices, stock-list containment, and a customer waiting queue to demonstrate list operations and alternatives.
- What you can do after
- Apply list construction, mutation, slicing, sorting keys, and searches to project data, and evaluate alternatives for lookup or FIFO needs.
Fast Python: High performance techniques for large datasets
- How it is used
- Uses lists as a baseline for optimizing membership searches and memory-intensive data processing.
- How deep it goes
- Benchmarks membership alternatives and examines container memory, including CPython lookup and allocation details.
- Examples
- Uses station temperature readings and file contents represented as lists to investigate lookup and memory costs.
- What you can do after
- Evaluate list performance and choose alternatives according to membership, ordering, and memory needs.
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.
High Performance Unity Game Development
A C# List is a dynamically sized sequence collection that stores elements in an internal array and provides indexed access and element operations.
- How it is used
- Handles changing enemy collections while motivating scrutiny of allocation and iteration costs in data-oriented game code.
- How deep it goes
- Explains resizing and element shifting, then benchmarks indexed access without establishing the precise cause of its slowdown.
- Examples
- Uses changing enemy data, Count-and-Capacity growth, and a Unity increment benchmark comparing List with an array.
- What you can do after
- Evaluate/understand List costs and choose between preallocated List storage and an array with an explicit count.
Read how High Performance Unity Game Development explains list →
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
- Serves as the immutable collection for querying records through functional pipelines and holding variable numbers of domain values.
- How deep it goes
- Explains literals, immutable linked-list behavior, pipelines, pattern matching, and append trade-offs without descending into implementation internals.
- Examples
- Uses a soccer away-win query, a team-appearance exercise, and loan-request patterns to demonstrate list operations.
- What you can do after
- Apply it via F# List.filter, List.countBy, and List.maxBy to query records; diagnose intermediate results with FSI.
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 →
Type-Driven Development with Idris
List is Idris's generic data type for ordered sequences of values, without encoding their length in the type.
- How it is used
- Uses lists as a common composite type for collections whose elements share a type and whose length is not specified in the type.
- How deep it goes
- Defines list syntax, constructors, concatenation, and ranges, while leaving length out of the type.
- Examples
- Shows integer and string literals, an explicitly typed empty list, concatenation, cons construction, and numeric ranges.
- What you can do after
- Apply Idris list literals, cons, concatenation, range notation, and explicit typing for empty lists.
Also covered in
- C# Concurrency: Asynchronous and multithreaded programming
- Data-Oriented Programming in JavaIn early access (MEAP)
- Building Quantum Software with Python
- BDD in Action, Second Edition
- Grokking Algorithms, Second Edition
- Learn Generative AI with PyTorch
- Software Design for Python Programmers
- Functional Design and Architecture: Examples in Haskell
- Refactoring to Rust
- Java Persistence with Spring Data and Hibernate epub
- Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
- Software Engineering for Data ScientistsIn early access (MEAP)
What to know first
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- stringA string is a programming-language value representing textual data as an ordered sequence of characters or encoded units.
- MapA map is an associative data structure that stores key-value associations and supports retrieving values by key.
- arrayAn array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
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.
- splitproduced by · Split is an operation or function that divides a string or sequence into parts according to a separator, pattern, or other rule.
- tuplecontrasts with · A tuple is a finite, ordered collection of values grouped as a single composite value, often with elements of different types.
- arrayalternative to · An array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
- 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.
- statekind of · State is information describing the condition or configuration of a system or computation at a particular time that may influence its behavior or subsequent transitions.
Questions about list
What is list?
A list is an ordered collection of elements arranged in a sequence.
Which Manning books explain list?
A Pythonic Adventure: From Python basics to a working web app, Get Programming: Learn to code with Python, Tiny Python Projects: Learn coding and testing with puzzles and games, Python How-To, Fast Python: High performance techniques for large datasets, Idiomatic Rust, Python Workout, Second Edition, Elixir in Action, Third Edition and 15 more.
What should I know before learning list?
Manning books that teach list usually introduce Python, string, Map and array first.
What is the difference between list and tuple?
A list is an ordered collection of elements arranged in a sequence. A tuple is a finite, ordered collection of values grouped as a single composite value, often with elements of different types.
What is list a kind of?
List is a kind of data structure. A data structure is an organized representation of data and its relationships that supports defined operations for storing, accessing, or modifying it.
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.






















