liveBook · Manning

Map

Also called dictionary, lookup table, dict, associative arrays

A map is an associative data structure that stores key-value associations and supports retrieving values by key.

How 49 Manning books explain it

Python Workout, Second Edition

A dictionary is a mutable mapping in Python that associates hashable keys with values and preserves insertion order in modern implementations.

How it is used
Uses dictionaries for records, name–value associations, accumulation, dispatch tables, and transforming data from files or JSON.
How deep it goes
Explains hashing, key constraints, lookup strategy, idioms, edge cases, nested structures, comprehensions, and dictionary-based design exercises.
Examples
Practices menus, rainfall totals, dictionary differences, dispatch tables, flipped dictionaries, file statistics, configuration data, and JSON records.
What you can do after
Build it from scratch by choosing keys, retrieving values, accumulating data, comparing dictionaries, and composing dictionary-based solutions.

Read how Python Workout, Second Edition explains Map →

A Pythonic Adventure: From Python basics to a working web app

A Python dictionary is a mutable mapping that associates unique keys with values for lookup and assignment.

How it is used
Collects customer order details so menus, confirmation, saving, and printing can pass one order value around.
How deep it goes
Defines key-value storage and demonstrates empty creation, assignment, return, form collection, and template lookup without discussing dictionary internals.
Examples
Uses a coffee order with name, drink, flavor, and topping, plus submitted web-form values rendered on a page.
What you can do after
Build it from scratch as an order dictionary, populate it from input or a form, return it, and retrieve values by key.

Read how A Pythonic Adventure: From Python basics to a working web app explains Map →

Learn Go with Pocket-Sized Projects

An associative array is a collection that associates keys with values rather than using only positional indexes.

How it is used
Uses maps for lookup, unique collections, counts, test cases, and cache storage.
How deep it goes
Defines map behavior and key constraints, then demonstrates initialization, lookup, iteration, counting, membership, testing, and generic storage.
Examples
Implements a multilingual phrasebook, book-occurrence counter, reading-recommendation set, named test cases, and generic cache.
What you can do after
Build maps from scratch for lookups, counting, membership checks, and key-value storage in Go.

Read how Learn Go with Pocket-Sized Projects explains Map →

Grokking Algorithms, Second Edition

A dictionary is a Python mapping data structure that associates keys with corresponding values.

How it is used
Maps keys to values for quick lookups, duplicate checks, caching, and graph representations.
How deep it goes
Explains dictionary operations and hash-table mechanics through collisions, performance, load factor, and resizing, without requiring a from-scratch implementation.
Examples
Uses produce prices, a phone book, voter records, cached pages, and graph nodes as key-value examples.
What you can do after
Apply it via Python dictionaries to store and retrieve values, test membership, and model relationships.

Read how Grokking Algorithms, Second Edition explains Map →

Python Workout: 50 ten-minute exercises

A dict is Python's mutable mapping type that associates hashable keys with values.

How it is used
Uses dictionaries as lookup tables, small databases, grouped records, accumulators, and function-facing data containers.
How deep it goes
Explains creation, lookup, membership, iteration, accumulation, comparison, parsing, and hashing, but does not detail dictionary implementation internals.
Examples
Demonstrates menus, rainfall totals, log grouping, file counts, password records, dictionary differences, reversals, and keyword-generated XML.
What you can do after
Apply it via Python syntax to build lookups, accumulate data, compare mappings, parse records, and transform collections.

Read how Python Workout: 50 ten-minute exercises explains Map →

Python How-To

How it is used
Uses dictionaries to associate project data with keys and retrieve values efficiently.
How deep it goes
Explains access, construction, hashability, and lookup efficiency, while focusing on essential uses rather than an exhaustive reference.
Examples
Uses task urgencies, paired task IDs and titles, action functions, and CSV rows as dictionary examples.
What you can do after
Apply it using Python’s dict, views, get, zip, and comprehensions to construct and access key–value data.

Read how Python How-To explains Map →

The Well-Grounded Rubyist, Fourth Edition

A key-value data structure that associates keys with corresponding values and preserves the insertion order of its keys.

How it is used
Uses key/value lookup to associate data such as state names with abbreviations and to package related method arguments.
How deep it goes
Works through creation, lookup, defaults, insertion order, and transformations without descending into hash implementation internals.
Examples
Demonstrates state-abbreviation lookup, missing-key defaults, filtering pairs, and passing city data as a final hash argument.
What you can do after
Build it from scratch with Ruby hash literals or constructors, then retrieve, update, and transform key/value pairs.

Read how The Well-Grounded Rubyist, Fourth Edition explains Map →

The Quick Python Book, Fourth Edition

How it is used
Uses Python dictionaries for keyed storage, counting, sparse matrices, caching, and function selection.
How deep it goes
Explains operations, dynamic views, hashability, and practical patterns, while identifying hash tables as the implementation without detailing their internals.
Examples
Demonstrates word counts, a sparse matrix, cached function results, and string-keyed function dispatch.
What you can do after
Apply Python dictionaries to keyed lookup, counting, sparse storage, and caching.

Read how The Quick Python Book, Fourth Edition explains Map →

Learn Haskell by Example

An associative list is a list of key-value pair elements that represents mappings between values.

How it is used
Models line numbering, graph adjacency, and word-permutation lookup through key-value associations.
How deep it goes
Builds an associative-list map through tuple types, membership, zip/unzip, and a recursive alteration operation, while deferring faster replacements.
Examples
Uses numbered text lines, graph nodes and edges, paired lists, and a small integer associative list for alterations.
What you can do after
Build it from scratch as an associative-list map that checks membership and adds, removes, or conditionally updates mappings.

Read how Learn Haskell by Example explains Map →

100 Go Mistakes and How to Avoid Them

A map is a Go data structure that associates keys with values and requires keys to satisfy comparability rules.

How it is used
Uses maps to examine correctness, memory, concurrency, decoding, and performance mistakes in Go programs.
How deep it goes
Explains bucket collisions, growth, retained memory, iteration, and synchronization with concrete code and measurements.
Examples
Uses a million-entry allocation experiment, a customer-balance cache, JSON decoding, and byte-slice lookups.
What you can do after
Diagnose/debug map ordering, retained memory, and data races; apply size hints and synchronization where appropriate.

Read how 100 Go Mistakes and How to Avoid Them explains Map →

Grokking Data Structures

A dictionary is an associative data structure that maps keys to values and supports operations such as lookup, insertion, and deletion by key.

How it is used
Uses key-based lookup to find stored values, track card collections, count occurrences, and remove duplicates.
How deep it goes
Defines insertion, retrieval, and deletion, then compares implementation costs and explains hash-table tradeoffs.
Examples
Uses baseball-card lookup, duplicate removal, Python occurrence counting, and a table of implementation costs.
What you can do after
Evaluate/understand map implementations by comparing the costs of key-based insertion, search, and deletion.

Read how Grokking Data Structures explains Map →

Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond

How it is used
Stores and retrieves keyed data when keys may be objects or when ordered key–value iteration matters.
How deep it goes
Works through construction, methods, iteration, destructuring, selection tradeoffs, and exercises; does not detail the internal storage mechanism.
Examples
Uses search-facet rendering, object-keyed card state, and sorting and inversion exercises.
What you can do after
Apply it via JavaScript Map to iterate keyed data, retrieve values, and track state by object reference.

Read how Get Programming with JavaScript Next: New features of ECMAScript 2015, 2016, and beyond explains Map →

Tiny Python Projects: Learn coding and testing with puzzles and games

An empty dictionary is a dictionary containing no key-value mappings.

How it is used
Uses mappings to encode characters, look up file lines, represent records, and eliminate duplicate words.
How deep it goes
Explains creation, mutation, lookup, membership, iteration, methods, key constraints, and applied patterns, without covering implementation internals.
Examples
Demonstrates knight answers, digit substitution, letter-indexed poetry lines, CSV records, and unique word collection.
What you can do after
Build lookup tables, safely retrieve values, transform text, index file contents, and convert delimited records into dictionaries.

Read how Tiny Python Projects: Learn coding and testing with puzzles and games explains Map →

Get Programming: Learn to code with Python

How it is used
Uses dictionaries to connect paired data and retrieve a value by its key.
How deep it goes
Works through creation, updates, removal, iteration, and key restrictions, but gives only a brief hash-function explanation.
Examples
Uses grocery quantities, student grades, song ratings, word counts, and shape-area functions as examples.
What you can do after
Build it from scratch to store paired data, update entries, count words, and support document comparison.

Read how Get Programming: Learn to code with Python explains Map →

Fast Python: High performance techniques for large datasets

How it is used
Uses dictionaries to retrieve station data by key and assess data-structure speed and memory costs.
How deep it goes
Compares hash lookup with list searches and examines shallow and nested memory sizes, without detailing hash-function design.
Examples
Uses list-versus-set membership timings and a station-keyed defaultdict containing yearly weather files.
What you can do after
Evaluate dictionary lookup and memory costs against workload-specific alternatives using benchmarks and object-size inspection.

Read how Fast Python: High performance techniques for large datasets explains Map →

Go in Action, Second Edition

A map is a Go associative data structure that associates keys with values.

How it is used
Uses maps to index collection values by meaningful keys and model domain data.
How deep it goes
Explains initialization, lookup, iteration, shared modification, and hash-table buckets, while deferring concurrent map access safety.
Examples
Uses fruit shipping weights, membership checks, age filtering, and recipe-based grocery-list aggregation.
What you can do after
Apply Go maps to initialize keyed data, test presence, filter entries, and aggregate domain values.

Read how Go in Action, Second Edition explains Map →

Pandas Workout: 200 exercises to make you a stronger data analyst

A mutable Python mapping from unique keys to values.

How it is used
Uses mappings to clean categorical data, assemble DataFrames, and dispatch file-format operations without repeated code.
How deep it goes
Explains key-value mappings through three executable patterns but stops short of dictionary internals or a general Python reference.
Examples
Uses vehicle-color normalization, Series-based DataFrame construction, and timed CSV, JSON, and feather read-write loops.
What you can do after
Apply dictionaries through pandas replacement, DataFrame construction, and loops that invoke stored methods or reader functions.

Read how Pandas Workout: 200 exercises to make you a stronger data analyst explains Map →

Advanced Algorithms and Data Structures

A dictionary is an abstract data structure that stores key-value associations and supports operations such as lookup, insertion, and deletion.

How it is used
Supports fast lookup, insertion, and removal when applications associate values with arbitrary keys.
How deep it goes
Defines the abstract API, compares array and tree alternatives, and explains hashing, collisions, and amortized performance.
Examples
Uses contact lists, word associations, spell-checking, heap membership, and local cache access as concrete applications.
What you can do after
Evaluate map implementations and apply their APIs to fast in-memory lookup, updates, membership checks, and synchronization.

Read how Advanced Algorithms and Data Structures explains Map →

Secrets of the JavaScript Ninja, Second Edition

A collection type that stores key-value associations and supports efficient lookup by key.

How it is used
Use maps as dictionaries for associating keys with values, including cases where plain-object properties create lookup problems.
How deep it goes
Explains prototype-property and key-coercion pitfalls through examples, recommends Map, and stops short of detailing its API.
Examples
Uses a localization dictionary, an inherited constructor lookup, and HTML elements whose object keys collide after string conversion.
What you can do after
Apply JavaScript’s built-in Map instead of a plain object when prototype properties or non-string keys could disrupt lookups.

Read how Secrets of the JavaScript Ninja, Second Edition explains Map →

Java Persistence with Spring Data and Hibernate epub

Map is a Java collection interface representing key-value associations in which each key maps to at most one value.

How it is used
Models persistent key-value collections and entity relationships in Java domain models.
How deep it goes
Works through collection tables, key types, embeddables, entity associations, and relationship tradeoffs.
Examples
Maps image filenames to names or components, and items to users through a category-owned association.
What you can do after
Apply it via Hibernate to map basic, embeddable, and entity keys or values to persistent tables.

Read how Java Persistence with Spring Data and Hibernate epub explains Map →

High Performance Unity Game Development

A lookup table is a data structure that maps keys to corresponding values for retrieval.

How it is used
Maps enemy identifiers to balance data or current indices where a key-based lookup is needed.
How deep it goes
Explains hashing, buckets, collision chains, resizing, and measured lookup costs, then gives a capacity-planned loading implementation.
Examples
Uses enemy-name lookups, an array-versus-dictionary benchmark, and saved enemy identifiers remapped during loading.
What you can do after
Operate/configure it by reserving C# Dictionary capacity for infrequent loading lookups and using preassigned array indices during gameplay.

Read how High Performance Unity Game Development explains Map →

Julia as a Second Language

A dictionary is a mutable associative collection that maps keys to values, with each dictionary specifying or inferring the types of its keys and values.

How it is used
Uses dictionaries for key-based lookup in conversion, product selection, and substitution mappings.
How deep it goes
Explains construction, typing, mutation, and lookup tradeoffs while deferring hash-table mechanics.
Examples
Illustrates Roman-numeral values, pizza prices, screw product numbers, and substitution alphabets.
What you can do after
Apply it via Julia’s Dict to construct typed lookup tables and retrieve values by key.

Read how Julia as a Second Language explains Map →

Practices of the Python Pro

How it is used
Uses key-to-value mappings to retrieve data, represent configuration, and replace repetitive conditional branches.
How deep it goes
Defines mappings, retrieval, sorting, performance, and refactoring applications without descending into dictionary internals.
Examples
Demonstrates state capitals, choice-to-word mappings, and HTTP response-format configuration.
What you can do after
Apply Python dictionaries to retrieve values and simplify choice-based or configuration-driven code.

Read how Practices of the Python Pro explains Map →

API Design Patterns

A map is a collection of key-value pairs in which keys identify associated values and may be dynamically defined.

How it is used
Stores arbitrary, dynamic key-value data inside resources when a predefined schema would be too restrictive.
How deep it goes
Defines maps, contrasts schemas, explains bounds, and specifies nested field-mask syntax without detailing storage internals.
Examples
Uses ChatRoom configuration, grocery ingredient amounts, JSON objects, and nested settings field-mask paths.
What you can do after
Build it from scratch by choosing maps for dynamic fields, bounding their contents, and addressing nested entries with valid field masks.

Read how API Design Patterns explains Map →

Data Analysis with LLMs

A Python dictionary is a mutable mapping data structure that associates keys with values.

How it is used
Uses dictionaries to describe chat messages, organize multimodal input, look up encoded images, and prepare fine-tuning samples.
How deep it goes
Shows dictionary literals, nested values, and entries added during image loading; does not examine mapping internals.
Examples
Shows a user chat message, a text-and-image prompt, a PNG filename-to-image map, and labeled review interactions.
What you can do after
Build it from scratch as message dictionaries or filename-to-image maps for GPT-4o workflows.

Read how Data Analysis with LLMs explains Map →

D3.js in Action, Third Edition

A JavaScript Map is a key-value collection that preserves associations between keys and values and supports lookup by key.

How it is used
Uses a Map to translate hidden Canvas pixel colors into the visualization nodes under the pointer.
How deep it goes
Explains initialization, uniqueness checking, insertion, and retrieval, but does not survey the broader Map API.
Examples
Demonstrates a nodesColors Map that associates generated RGB colors with circles representing paintings.
What you can do after
Apply Map with Canvas getImageData() to identify hovered visualization nodes and display their metadata.

Read how D3.js in Action, Third Edition explains Map →

Latency

A lookup table is a data structure that stores precomputed values indexed for rapid retrieval.

How it is used
Uses maps for in-memory key–value storage and lookup tables to retrieve precomputed results on latency-sensitive paths.
How deep it goes
Explains lookup complexity and collisions, and implements a map-backed store without detailing hash table internals.
Examples
Demonstrates a replicated string key–value store and precomputed storage usage, quota, and forecasts.
What you can do after
Evaluate hash table lookup costs and apply a map in an in-memory replicated key–value store.

Read how Latency explains Map →

Build Your Own Robot: Using Python, CRICKIT, and Raspberry Pi

A dictionary is a mapping data structure that associates keys with corresponding values.

How it is used
Organizes robot settings, hardware objects, colors, and joystick identifiers for readable keyed access.
How deep it goes
Demonstrates creating dictionaries, indexing and get lookups, and iterating keys in runnable robot programs; does not discuss implementation internals.
Examples
Uses motor calibration maps, RGB color names for a blinking LED, and button and axis number maps for joystick output.
What you can do after
Apply it via Python dictionaries to retrieve robot configuration, hardware, and human-readable event labels by key.

Read how Build Your Own Robot: Using Python, CRICKIT, and Raspberry Pi explains Map →

Learn AI-Assisted Python Programming, Second Edition

How it is used
Uses dictionaries to model associations such as words and frequencies, quarterback names and passing yards, or letters and scores.
How deep it goes
Explains mappings, keys, values, uniqueness, mutability, indexing, methods, iteration, and key errors through interactive examples.
Examples
Demonstrates word frequencies, quarterback passing yards, Scrabble letter scores, method calls, key errors, updates, and iteration.
What you can do after
Apply dictionaries via Python to store associations, retrieve and update values, remove entries, and iterate through mappings.

Read how Learn AI-Assisted Python Programming, Second Edition explains Map →

Robotics for Programmers

A lookup table is a data structure that associates input values or keys with precomputed output values.

How it is used
Converts analog sensor readings into usable physical quantities during robot sensing.
How deep it goes
Defines indexed lookup and demonstrates implementation, while stopping short of production-ready error handling and interpolation.
Examples
Uses a voltage-to-distance array derived from an analog optical distance sensor’s measurement diagram.
What you can do after
Build it from scratch by discretizing sensor input, indexing stored values, and returning converted measurements.

Read how Robotics for Programmers explains Map →

Learn Rust in a Month of Lunches

How it is used
Stores key–value associations so values can be retrieved by key.
How deep it goes
Works through creation, insertion, lookup, ordering, overwrites, and entry-based updates with code examples.
Examples
Uses city populations, city-to-country lookup, book counts, and survey responses as examples.
What you can do after
Apply Rust HashMap methods to insert, retrieve, and update values, including counting repeated keys.

Read how Learn Rust in a Month of Lunches explains Map →

Investing for Programmers

A lookup table is a structured mapping that associates source identifiers or attributes with corresponding standardized values.

How it is used
Uses key–value mappings to reconcile asset identifiers, enrich holdings, and construct JSON-compatible API payloads.
How deep it goes
Explains mapping roles and demonstrates schemas, DataFrame merging, fallback values, and nested API payloads without discussing dictionary internals.
Examples
Demonstrates ticker mappings, asset metadata records, Notion title properties, page blocks, and chunked content payloads.
What you can do after
Apply via Python to organize metadata, merge lookup information, and send structured content through an API.

Read how Investing for Programmers explains Map →

Acing the Frontend Interview

A map data structure stores key-value associations while exposing operations for lookup and maintaining an insertion order in the JavaScript implementation described.

How it is used
Uses insertion order to track recency and evict the least recently used entry from an in-memory cache.
How deep it goes
Explains lookup, recency updates, insertion, and eviction; raises concurrent access without detailing a solution.
Examples
Demonstrates a TypeScript LRU cache and a React demo where a get operation updates recency.
What you can do after
Build an O(1) LRU cache using JavaScript or TypeScript Map operations for lookup, recency updates, and eviction.

Read how Acing the Frontend Interview explains Map →

Secrets of the JavaScript Ninja, Third Edition

A JavaScript Map is a collection that associates keys with values and permits keys of arbitrary value types, including objects.

How it is used
Uses Map to create dictionaries and associate values, such as external metadata, with keys of any type.
How deep it goes
Explains construction, entry operations, object-key identity, insertion-ordered iteration, and conversion, while only pointing toward WeakMap.
Examples
Demonstrates ninja metadata keyed by object references and a phone directory traversed by entries, keys, and values.
What you can do after
Apply JavaScript's Map API to associate values with arbitrary keys and iterate over the resulting mappings.

Read how Secrets of the JavaScript Ninja, Third Edition explains Map →

Rust in Action: Systems programming concepts and techniques

An associative array is an abstract data structure that maps keys to values without requiring integer indices.

How it is used
Uses key-value collections to associate names and amounts with related values in practical Rust programs.
How deep it goes
Explains basic operations, hash-based lookup, ordered iteration, and range queries with working examples.
Examples
Uses island capitals for insertion and lookup, and historical investments for ordered iteration and range queries.
What you can do after
Apply Rust’s HashMap and BTreeMap to store, retrieve, and iterate over key-value pairs.

Read how Rust in Action: Systems programming concepts and techniques explains Map →

Software Engineering for Data Scientists

A dictionary is a mutable mapping data structure that associates unique keys with values for efficient lookup.

How it is used
Uses key-value mappings to replace long if-else chains and organize downloaded data by stock ticker.
How deep it goes
Explains key-value lookup through short Python examples and stops short of dictionary internals or broader operations.
Examples
Demonstrates weekday-name lookup and ticker-indexed stock-price data, including failures from an invalid ticker.
What you can do after
Apply it via Python to replace repetitive conditionals and store values associated with lookup keys.

Read how Software Engineering for Data Scientists explains Map →

Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools

A hash table is a key-value data structure that associates unique keys with corresponding values.

How it is used
Uses dictionaries to pass command parameters, construct structured objects, and assemble output dynamically in reusable PowerShell tools.
How deep it goes
Demonstrates literal construction, splatting, conditional keys, object creation, dynamic additions, and display-order tradeoffs.
Examples
Demonstrates CIM queries, machine-information objects, service arguments, and DNS results assembled from successful or failed lookups.
What you can do after
Apply dictionaries to shorten commands, create reusable structured output, and add properties conditionally before pipeline emission.

Read how Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools explains Map →

ASP.NET Core in Action, 3e

A dictionary is a key-value data structure that associates each key with a value.

How it is used
Uses key-value storage for API records and binds dictionaries from configuration or submitted form data.
How deep it goes
Explains CRUD access and binding rules, including supported key types and initialized collection behavior.
Examples
Uses a fruit catalog, configuration options, and selected currencies to demonstrate dictionary storage and binding.
What you can do after
Apply it via C# dictionaries to store keyed API data and bind keyed configuration or form values.

Read how ASP.NET Core in Action, 3e explains Map →

Code Like a Pro in Rust

How it is used
Uses HashMap for keyed retrieval where a sequence-oriented Vec is not the right fit.
How deep it goes
Explains key trait requirements and custom hasher methods, while deferring fuller discussion of traits and derive.
Examples
Demonstrates a MetroHash-backed string map and a compound key with derived traits.
What you can do after
Apply Rust’s HashMap with derived compound keys and a MetroHash hasher.

Read how Code Like a Pro in Rust explains Map →

Object-Oriented Software Design in C++

How it is used
Uses dictionaries to represent variable book attributes and support reusable catalogue searches.
How deep it goes
Defines key–value mapping and demonstrates typed implementation with map and variant, without detailing map internals.
Examples
Demonstrates book records, typed attribute tables, case-insensitive surname matching, and region-based cookbook searches.
What you can do after
Apply it via STL map and variant to model heterogeneous attributes and query matching records.

Read how Object-Oriented Software Design in C++ explains Map →

Vibe Engineering

A map is an associative data structure that stores values indexed by unique keys.

How it is used
Uses maps to index tokens, accelerate account lookup, and cache word-existence checks.
How deep it goes
Compares HashMap lookup and eager-versus-lazy cache costs, but stops short of explaining map internals.
Examples
Shows token-index vectors and account-ID lookup as concrete applications.
What you can do after
Apply HashMap-based lookup to account IDs and compare it with alternatives using benchmarks.

Read how Vibe Engineering explains Map →

Essential TypeScript 5, Third Edition

Map is a JavaScript built-in collection that stores key/value pairs and permits keys and values of arbitrary types.

How it is used
Organizes application objects by stable keys, replacing restrictive string-keyed object collections.
How deep it goes
Explains storage, lookup, iteration, and TypeScript generic restrictions through worked collections, without descending into runtime internals.
Examples
Uses TodoItem objects keyed by numeric IDs and products keyed by names.
What you can do after
Apply it via JavaScript and TypeScript to build typed keyed collections, retrieve values, and iterate over stored objects.

Read how Essential TypeScript 5, Third Edition explains Map →

Go in Practice, Second Edition

How it is used
Uses maps for dictionary-style collections, including accessing fields in JSON objects and representing valid options.
How deep it goes
Defines maps as dictionary-like collections and demonstrates accessing JSON fields through a typed map assertion.
Examples
Uses valid-language options and a parsed JSON object with a firstName field.
What you can do after
Apply maps to retrieve named fields from JSON objects with unknown structure.

Read how Go in Practice, Second Edition explains Map →

100 Java Mistakes and How to Avoid Them

HashMap is a Java map implementation that stores key-value associations using hashing.

How it is used
Warns against mutating objects used as HashMap keys or HashSet elements.
How deep it goes
Explains bucket selection, changed hash codes, equality inconsistencies, debugging consequences, and prevention choices.
Examples
Uses mutable lists, BitSet, Date, Calendar, LocalDateTime, and StringBuilder to expose key-related failures.
What you can do after
Diagnose failed lookups by checking key mutation, hashCode stability, equality consistency, and bucket-sensitive behavior.

Read how 100 Java Mistakes and How to Avoid Them explains Map →

Kotlin in Action, 2E

HashMap is a hash-table-based Java map implementation that stores key-value associations and uses key hash codes for lookup.

How it is used
Supports direct lookup, mutable updates, iteration, grouping, and collection-to-map transformations.
How deep it goes
Explains Kotlin syntax, destructuring, grouping, association directions, and duplicate-key overwrites without covering map implementation internals.
Examples
Uses binary character representations, age-based people groups, first-character string groups, and person-to-age associations.
What you can do after
Apply Kotlin map indexing, destructuring, groupBy, associate, associateWith, and associateBy to collection data.

Read how Kotlin in Action, 2E explains Map →

Software Design for Python Programmers

A dictionary is a collection that maps unique immutable keys to values.

How it is used
Models flexible book attributes while removing duplication between book-type and attribute subclasses.
How deep it goes
Explains keys, values, immutability, uniqueness, typed validation, matching, formatting, and catalogue searches.
Examples
Uses book metadata, enumeration keys, case-insensitive author searches, and region-based catalogue searches.
What you can do after
Build it from scratch to represent validated, searchable collections of changing name–value attributes.

Read how Software Design for Python Programmers explains Map →

Clojure: The Essential Reference

A map is an associative Clojure collection that stores values under keys.

How it is used
Uses maps for associative lookup, membership testing, and extracting key or value sequences.
How deep it goes
Defines supported map-like inputs, return behavior, ordering, and notable exceptions without detailing map implementation internals.
Examples
Demonstrates nil-valued entries, key membership, extracted sequences, filtered MapEntry values, and configuration scoring.
What you can do after
Apply map membership checks with contains? and extract keys or values with keys and vals.

Read how Clojure: The Essential Reference explains Map →

Elixir in Action, Third Edition

A map is an Elixir data structure that associates keys with values, with both keys and values allowed to be any term.

How it is used
Stores dynamic key-value collections and small named records in Elixir programs.
How deep it goes
Explains construction, lookup, missing-key behavior, updates, and field access without covering the complete Map API.
Examples
Uses empty maps, square-number mappings, Map.new/1, and a named Bob record.
What you can do after
Apply map literals, Map functions, access operators, and update syntax while choosing explicit missing-key behavior.

Read how Elixir in Action, Third Edition explains Map →

Local Image Generation

A dictionary is a key-value data structure that maps each key to an associated value.

How it is used
Organizes per-panel prompts and image dimensions for repeated Stable Diffusion generation.
How deep it goes
Defines keys, values, and nested dictionaries, then applies lookup during a configuration-driven loop.
Examples
Uses panel labels A–E mapped to prompts, heights, and widths for graphic-novel image generation.
What you can do after
Apply it via Python to group related settings and retrieve them while automating repeated image-generation tasks.

Read how Local Image Generation explains Map →

Also covered in

What to know first

Related concepts

Questions about Map

What is Map?

A map is an associative data structure that stores key-value associations and supports retrieving values by key.

Which Manning books explain Map?

Python Workout, Second Edition, A Pythonic Adventure: From Python basics to a working web app, Learn Go with Pocket-Sized Projects, Grokking Algorithms, Second Edition, Python Workout: 50 ten-minute exercises, Python How-To, The Well-Grounded Rubyist, Fourth Edition, The Quick Python Book, Fourth Edition and 41 more.

What should I know before learning Map?

Manning books that teach Map usually introduce array, Python, list and JSON first.

What kinds of Map are there?

Kinds of Map include OrderedDict.

What is Map a kind of?

Map 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.

What are the parts of Map?

Map includes key-value pair.

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.