Map
A map is an associative data structure that stores key-value associations and supports retrieving values by key.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Also covered in
- Learn C++ by Example
- Data-Oriented Programming in JavaIn early access (MEAP)
- Learn Generative AI with PyTorch
- Kafka Streams in Action, Second Edition
- Python Concurrency with asyncio
- C++ Concurrency in Action, Second Edition
- Just Use Postgres!
- Functional Programming in C#, Second Edition
- ScyllaDB in Action
- Algorithms Every Programmer Should KnowIn early access (MEAP)
- Build a Text-to-Image Generator (from Scratch)
- Server-Side WebAssembly
What to know first
- arrayAn array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- listA list is an ordered collection of elements arranged in a sequence.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
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.
- key-value pairhas part · A key-value pair is a data association in which a key identifies or provides access to its corresponding value.
- arrayuses · An array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
- dict.getused by · dict.get is a Python dictionary method that returns the value for a key or a specified default when the key is absent.
- OrderedDictincludes · OrderedDict is a Python dictionary subclass that preserves insertion order and provides operations for explicitly rearranging entries.
- constant timemeasures · Constant time is an asymptotic running-time bound, conventionally denoted O(1), that remains bounded independently of input size.
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.
















































