Fundamentals Of Python: Data Structures 2nd Edition by Kenneth Lambert 8214344324 9798214344324

Fundamentals Of Python: Data Structures 2nd Edition by Kenneth A. Lambert – Ebook PDF Instant Download/DeliveryISBN:  8214344324, 9798214344324 

Full download Fundamentals Of Python: Data Structures 2nd Edition after payment.

Product details:

ISBN-10 :  8214344324 

ISBN-13 :  9798214344324

Author :  Kenneth A. Lambert 

Written for computer programming students, hobbyists or professionals, Lambert’s FUNDAMENTALS OF PYTHON™: DATA STRUCTURES, 2E introduces object-oriented design and data structures using the popular Python™ programming language. The book presents a level of instruction that is ideal for readers with at least one semester of programming experience in an object-oriented language, such as Java™, C++ or Python™. Step-by-step instruction and focused exercises clearly address the design of collection classes with polymorphism and inheritance and multiple implementations of collection interfaces. This edition also covers the analysis of the space/time tradeoffs of different collection implementations and, more specifically, array-based implementations and link-based implementations. This edition’s thorough coverage of collections includes sets, lists, stacks, queues, trees, dictionaries and graphs. Trust FUNDAMENTALS OF PYTHON™: DATA STRUCTURES for the instruction in object-oriented design and data structures that your students need for success.

Fundamentals Of Python: Data Structures 2nd Table of contents:

Chapter 1. Basic Python Programming
Basic Program Elements
Programs and Modules
An Example Python Program: Guessing a Number
Editing, Compiling, and Running Python Programs
Program Comments
Lexical Elements
Spelling and Naming Conventions
Syntactic Elements
Literals
Operators and Expressions
Function Calls
The print Function
The input Function
Type Conversion Functions and Mixed-Mode Operations
Optional and Keyword Function Arguments
Variables and Assignment Statements
Python Data Typing
import Statements
Getting Help on Program Components
Control Statements
Conditional Statements
Using if __name__ == “__main__”
Loop Statements
Strings and Their Operations
Operators
Formatting Strings for Output
Objects and Method Calls
Built-In Python Collections and Their Operations
Lists
Tuples
Loops Over Sequences
Dictionaries
Searching for a Value
Pattern Matching with Collections
Creating New Functions
Function Definitions
Recursive Functions
Nested Function Definitions
Higher-Order Functions
Creating Anonymous Functions with lambda
Catching Exceptions
Files and Their Operations
Text File Output
Writing Numbers to a Text File
Reading Text from a Text File
Reading Numbers from a File
Reading and Writing Objects with pickle
Creating New Classes
Projects
Chapter 2. An Overview of Collections
Collection Types
Linear Collections
Hierarchical Collections
Graph Collections
Unordered Collections
Sorted Collections
A Taxonomy of Collection Types
Operations on Collections
Fundamental Operations on All Collection Types
Type Conversion
Cloning and Equality
Iterators and Higher-Order Functions
Implementations of Collections
Summary
Review Questions
Projects
Chapter 3. Searching, Sorting, and Complexity Analysis
Measuring the Efficiency of Algorithms
Measuring the Run Time of an Algorithm
Counting Instructions
Measuring the Memory Used by an Algorithm
Complexity Analysis
Orders of Complexity
Big-O Notation
The Role of the Constant of Proportionality
Search Algorithms
Search for the Minimum
Sequential Search of a List
Best-Case, Worst-Case, and Average-Case Performance
Binary Search of a Sorted List
Comparing Data Items
Basic Sort Algorithms
Selection Sort
Bubble Sort
Insertion Sort
Best-Case, Worst-Case, and Average-Case Performance Revisited
Faster Sorting
Overview of Quicksort
Merge Sort
An Exponential Algorithm: Recursive Fibonacci
Converting Fibonacci to a Linear Algorithm
Summary
Review Questions
Projects
Chapter 4. Arrays and Linked Structures
The Array Data Structure
Random Access and Contiguous Memory
Static Memory and Dynamic Memory
Physical Size and Logical Size
Operations on Arrays
Increasing the Size of an Array
Decreasing the Size of an Array
Inserting an Item into an Array That Grows
Removing an Item from an Array
Complexity Trade-Off: Time, Space, and Arrays
Two-Dimensional Arrays (Grids)
Processing a Grid
Creating and Initializing a Grid
Defining a Grid Class
Ragged Grids and Multidimensional Arrays
Linked Structures
Singly Linked Structures and Doubly Linked Structures
Noncontiguous Memory and Nodes
Defining a Singly Linked Node Class
Using the Singly Linked Node Class
Operations on Singly Linked Structures
Traversal
Searching
Replacement
Inserting at the Beginning
Inserting at the End
Removing at the Beginning
Removing at the End
Inserting at Any Position
Removing at Any Position
Complexity Trade-Off: Time, Space, and Singly Linked Structures
Variations on a Link
A Circular Linked Structure with a Dummy Header Node
Doubly Linked Structures
Summary
Review Questions
Projects
Chapter 5. Interfaces, Implementations, and Polymorphism
Developing an Interface
Designing the Bag Interface
Specifying Arguments and Return Values
Constructors and Implementing Classes
Preconditions, Postconditions, Exceptions, and Documentation
Coding an Interface in Python
Developing an Array-Based Implementation
Choose and Initialize the Data Structures
Complete the Easy Methods First
Complete the Iterator
Complete the Methods That Use the Iterator
The in Operator and the __contains__ Method
Complete the remove Method
Developing a Link-Based Implementation
Initialize the Data Structures
Complete the Iterator
Complete the Methods clear and add
Complete the Method remove
Run-Time Performance of the Two Bag Implementations
Testing the Two Bag Implementations
Diagramming the Bag Resource with UML
Summary
Review Questions
Projects
Chapter 6. Inheritance and Abstract Classes
Using Inheritance to Customize an Existing Class
Subclassing an Existing Class
Revising the __init__ Method
Adding a New __contains__ Method
Modifying the Existing add Method
Modifying the Existing __add__ Method
Run-Time Performance of ArraySortedBag
A Note on Class Hierarchies in Python
Using Abstract Classes to Eliminate Redundant Code
Designing an AbstractBag Class
Redoing the __init__ Method in AbstractBag
Modifying the Subclasses of AbstractBag
Generalizing the __add__ Method in AbstractBag
An Abstract Class for All Collections
Integrating AbstractCollection into the Collection Hierarchy
Using Two Iterators in the __eq__ Method
A Professional-Quality Framework of Collections
Summary
Review Questions
Projects
Chapter 7. Stacks
Overview of Stacks
Using a Stack
The Stack Interface
Instantiating a Stack
Example Application: Matching Parentheses
Three Applications of Stacks
Evaluating Arithmetic Expressions
Evaluating Postfix Expressions
Converting Infix to Postfix
Backtracking
Memory Management
Implementations of Stacks
Test Driver
Adding Stacks to the Collection Hierarchy
Array Implementation
Linked Implementation
The Role of the Abstract Stack Class
Time and Space Analysis of the Two Implementations
Summary
Review Questions
Projects
Chapter 8. Queues
Overview of Queues
The Queue Interface and Its Use
Two Applications of Queues
Simulations
Round-Robin CPU Scheduling
Implementations of Queues
A Linked Implementation of Queues
An Array Implementation
Time and Space Analysis for the Two Implementations
Priority Queues
Summary
Review Questions
Projects
Chapter 9. Lists
Overview of Lists
Using Lists
Index-Based Operations
Content-Based Operations
Position-Based Operations
Interfaces for Lists
Applications of Lists
Heap-Storage Management
Organization of Files on a Disk
Implementation of Other Collections
List Implementations
The Role of the AbstractList Class
An Array-Based Implementation
A Linked Implementation
Time and Space Analysis for the Two Implementations
Implementing a List Iterator
Role and Responsibilities of a List Iterator
Setting Up and Instantiating a List Iterator Class
The Navigational Methods in the List Iterator
The Mutator Methods in the List Iterator
Design of a List Iterator for a Linked List
Time and Space Analysis of List Iterator Implementations
Recursive List Processing
Basic Operations on a Lisp-Like List
Recursive Traversals of a Lisp-Like List
Building a Lisp-Like List
The Internal Structure of a Lisp-Like List
Printing Lisp-Like Lists in IDLE with __repr__
Lists and Functional Programming
Summary
Review Questions
Projects
Chapter 10. Trees
An Overview of Trees
Tree Terminology
General Trees and Binary Trees
Recursive Definitions of Trees
Why Use a Tree?
The Shape of Binary Trees
Binary Tree Traversals
Preorder Traversal
Inorder Traversal
Postorder Traversal
Level Order Traversal
Three Common Applications of Binary Trees
Heaps
Binary Search Trees
Expression Trees
Developing a Binary Search Tree
The Binary Search Tree Interface
Data Structure for the Linked Implementation
Complexity Analysis of Binary Search Trees
Recursive Descent Parsing and Programming Languages
Introduction to Grammars
Recognizing, Parsing, and Interpreting Sentences in a Language
Lexical Analysis and the Scanner
Parsing Strategies
An Array Implementation of Binary Trees
Implementing Heaps
Summary
Review Questions
Projects
Chapter 11. Sets and Dictionaries
Using Sets
The Python Set Class
A Sample Session with Sets
Applications of Sets
Relationship Between Sets and Bags
Relationship Between Sets and Dictionaries
Implementations of Sets
Array-Based and Linked Implementations of Sets
The AbstractSet Class
The ArraySet Class
Using Dictionaries
Array-Based and Linked Implementations of Dictionaries
The Entry Class
The AbstractDict Class
The ArrayDict Class
Complexity Analysis of the Array-Based and Linked Implementations of Sets and Dictionaries
Hashing Strategies
The Relationship of Collisions to Density
Hashing with Nonnumeric Keys
Linear Probing
Quadratic Probing
Chaining
Complexity Analysis
Hashing Implementation of Sets
Hashing Implementation of Dictionaries
Sorted Sets and Dictionaries
Summary
Review Questions
Projects
Chapter 12. Graphs
Why Use Graphs?
Graph Terminology
Representations of Graphs
Adjacency Matrix
Adjacency List
Analysis of the Two Representations
Further Run-Time Considerations
Graph Traversals
A Generic Traversal Algorithm
Breadth-First and Depth-First Traversals
Graph Components
Trees Within Graphs
Spanning Trees and Forests
Minimum Spanning Tree
Algorithms for Minimum Spanning Trees
Topological Sort
The Shortest-Path Problem
Dijkstra’s Algorithm
The Initialization Step
The Computation Step
Representing and Working with Infinity
Analysis
Floyd’s Algorithm
Analysis
Developing a Graph Collection
Example Use of the Graph Collection
The Class LinkedDirectedGraph
The Class LinkedVertex
The Class LinkedEdge

People also search for Fundamentals Of Python: Data Structures 2nd:

kenneth a lambert fundamentals of python pdf
    
fundamentals of python first programs 3rd edition pdf
    
fundamentals of python first programs 3rd edition
    
learn fundamentals of python
    
fundamentals of python data structures pdf

Tags: Fundamentals, Python, Data Structures, Kenneth Lambert