Getting Started with Python: Understand key data structures and use Python in object-oriented programming

Cover\nTitle Page\nCopyright and Credits\nAbout Packt\nContributors\nTable of Contents\nPreface\nChapter 1: A Gentle Introduction to Python\n	A proper introduction\n	Enter the Python\n	About Python\n		Portability\n		Coherence\n		Developer productivity\n		An extensive library\n		Software quality\n		Software integration\n		Satisfaction and enjoyment\n	What are the drawbacks?\n	Who is using Python today?\n	Setting up the environment\n		Python 2 versus Python 3\n	Installing Python\n		Setting up the Python interpreter\n		About virtualenv\n		Your first virtual environment\n		Your friend, the console\n	How you can run a Python program\n		Running Python scripts\n		Running the Python interactive shell\n		Running Python as a service\n		Running Python as a GUI application\n	How is Python code organized?\n		How do we use modules and packages?\n	Python\'s execution model\n		Names and namespaces\n		Scopes\n		Objects and classes\n	Guidelines on how to write good code\n	The Python culture\n	A note on IDEs\n	Summary\nChapter 2: Built-in Data Types\n	Everything is an object\n	Mutable or immutable? That is the question\n	Numbers\n		Integers\n		Booleans\n		Real numbers\n		Complex numbers\n		Fractions and decimals\n	Immutable sequences\n		Strings and bytes\n			Encoding and decoding strings\n			Indexing and slicing strings\n			String formatting\n		Tuples\n	Mutable sequences\n		Lists\n		Byte arrays\n	Set types\n	Mapping types – dictionaries\n	The collections module\n		namedtuple\n		defaultdict\n		ChainMap\n	Enums\n	Final considerations\n		Small values caching\n		How to choose data structures\n		About indexing and slicing\n		About the names\n	Summary\nChapter 3: Iterating and Making Decisions\n	Conditional programming\n		A specialized else – elif\n		The ternary operator\n	Looping\n		The for loop\n			Iterating over a range\n			Iterating over a sequence\n		Iterators and iterables\n		Iterating over multiple sequences\n		The while loop\n		The break and continue statements\n		A special else clause\n	Putting all this together\n		A prime generator\n		Applying discounts\n	A quick peek at the itertools module\n		Infinite iterators\n		Iterators terminating on the shortest input sequence\n		Combinatoric generators\n	Summary\nChapter 4: Functions, the Building Blocks of Code\n	Why use functions?\n		Reducing code duplication\n		Splitting a complex task\n		Hiding implementation details\n		Improving readability\n		Improving traceability\n	Scopes and name resolution\n		The global and nonlocal statements\n	Input parameters\n		Argument passing\n		Assignment to argument names doesn\'t affect the caller\n		Changing a mutable affects the caller\n		How to specify input parameters\n			Positional arguments\n			Keyword arguments and default values\n			Variable positional arguments\n			Variable keyword arguments\n			Keyword-only arguments\n			Combining input parameters\n			Additional unpacking generalizations\n			Avoid the trap! Mutable defaults\n	Return values\n		Returning multiple values\n	A few useful tips\n	Recursive functions\n	Anonymous functions\n	Function attributes\n	Built-in functions\n	One final example\n	Documenting your code\n	Importing objects\n		Relative imports\n	Summary\nChapter 5: Files and Data Persistence\n	Working with files and directories\n		Opening files\n			Using a context manager to open a file\n		Reading and writing to a file\n			Reading and writing in binary mode\n			Protecting against overriding an existing file\n		Checking for file and directory existence\n		Manipulating files and directories\n			Manipulating pathnames\n		Temporary files and directories\n		Directory content\n		File and directory compression\n	Data interchange formats\n		Working with JSON\n			Custom encoding/decoding with JSON\n	IO, streams, and requests\n		Using an in-memory stream\n		Making HTTP requests\n	Persisting data on disk\n		Serializing data with pickle\n		Saving data with shelve\n		Saving data to a database\n	Summary\nChapter 6: Principles of Algorithm Design\n	Algorithm design paradigms\n	Recursion and backtracking\n		Backtracking\n		Divide and conquer - long multiplication\n		Can we do better? A recursive approach\n	Runtime analysis\n		Asymptotic analysis\n		Big O notation\n			Composing complexity classes\n			Omega notation (Ω)\n			Theta notation (ϴ)\n	Amortized analysis\n	Summary\nChapter 7: Lists and Pointer Structures\n	Arrays\n	Pointer structures\n	Nodes\n	Finding endpoints\n		Node\n			Other node types\n	Singly linked lists\n		Singly linked list class\n		Append operation\n	A faster append operation\n	Getting the size of the list\n	Improving list traversal\n	Deleting nodes\n		List search\n	Clearing a list\n	Doubly linked lists\n		A doubly linked list node\n			Doubly linked list\n		Append operation\n		Delete operation\n		List search\n	Circular lists\n		Appending elements\n		Deleting an element\n			Iterating through a circular list\n	Summary\nChapter 8: Stacks and Queues\n	Stacks\n		Stack implementation\n		Push operation\n		Pop operation\n			Peek\n		Bracket-matching application\n	Queues\n		List-based queue\n			Enqueue operation\n			Dequeue operation\n		Stack-based queue\n			Enqueue operation\n			Dequeue operation\n		Node-based queue\n			Queue class\n			Enqueue operation\n			Dequeue operation\n		Application of queues\n			Media player queue\n	Summary\nChapter 9: Trees\n	Terminology\n	Tree nodes\n	Binary trees\n		Binary search trees\n		Binary search tree implementation\n		Binary search tree operations\n			Finding the minimum and maximum nodes\n		Inserting nodes\n		Deleting nodes\n		Searching the tree\n		Tree traversal\n			Depth-first traversal\n				In-order traversal and infix notation\n				Pre-order traversal and prefix notation\n				Post-order traversal and postfix notation.\n			Breadth-first traversal\n		Benefits of a binary search tree\n		Expression trees\n			Parsing a reverse Polish expression\n		Balancing trees\n		Heaps\n	Summary\nChapter 10: Hashing and Symbol Tables\n	Hashing\n		Perfect hashing functions\n	Hash table\n		Putting elements\n		Getting elements\n		Testing the hash table\n		Using [] with the hash table\n		Non-string keys\n		Growing a hash table\n		Open addressing\n			Chaining\n		Symbol tables\n	Summary\nChapter 11: Graphs and Other Algorithms\n	Graphs\n	Directed and undirected graphs\n	Weighted graphs\n	Graph representation\n		Adjacency list\n		Adjacency matrix\n	Graph traversal\n		Breadth-first search\n		Depth-first search\n	Other useful graph methods\n	Priority queues and heaps\n		Inserting\n		Pop\n		Testing the heap\n	Selection algorithms\n	Summary\nChapter 12: Searching\n	Linear Search\n		Unordered linear search\n		Ordered linear search\n	Binary search\n	Interpolation search\n		Choosing a search algorithm\n	Summary\nChapter 13: Sorting\n	Sorting algorithms\n	Bubble sort\n	Insertion sort\n	Selection sort\n	Quick sort\n		List partitioning\n			Pivot selection\n		Implementation\n		Heap sort\n	Summary\nChapter 14: Selection Algorithms\n	Selection by sorting\n	Randomized selection\n		Quick select\n			Partition step\n	Deterministic selection\n		Pivot selection\n		Median of medians\n		Partitioning step\n	Summary\nChapter 15: Object-Oriented Design\n	Introducing object-oriented\n	Objects and classes\n	Specifying attributes and behaviors\n		Data describes objects\n		Behaviors are actions\n	Hiding details and creating the public interface\n	Composition\n	Inheritance\n		Inheritance provides abstraction\n		Multiple inheritance\n	Case study\n	Exercises\n	Summary\nChapter 16: Objects in Python\n	Creating Python classes\n		Adding attributes\n		Making it do something\n			Talking to yourself\n			More arguments\n		Initializing the object\n		Explaining yourself\n	Modules and packages\n		Organizing modules\n			Absolute imports\n			Relative imports\n	Organizing module content\n	Who can access my data?\n	Third-party libraries\n	Case study\n	Exercises\n	Summary\nChapter 17: When Objects Are Alike\n	Basic inheritance\n		Extending built-ins\n		Overriding and super\n	Multiple inheritance\n		The diamond problem\n		Different sets of arguments\n	Polymorphism\n	Abstract base classes\n		Using an abstract base class\n		Creating an abstract base class\n		Demystifying the magic\n	Case study\n	Exercises\n	Summary\nChapter 18: Expecting the Unexpected\n	Raising exceptions\n		Raising an exception\n		The effects of an exception\n		Handling exceptions\n		The exception hierarchy\n		Defining our own exceptions\n	Case study\n	Exercises\n	Summary\nChapter 19: When to Use Object-Oriented Programming\n	Treat objects as objects\n	Adding behaviors to class data with properties\n		Properties in detail\n		Decorators – another way to create properties\n		Deciding when to use properties\n	Manager objects\n		Removing duplicate code\n		In practice\n	Case study\n	Exercises\n	Summary\nChapter 20: Python Object-Oriented Shortcuts\n	Python built-in functions\n		The len() function\n		Reversed\n		Enumerate\n		File I/O\n		Placing it in context\n	An alternative to method overloading\n		Default arguments\n		Variable argument lists\n		Unpacking arguments\n	Functions are objects too\n		Using functions as attributes\n		Callable objects\n	Case study\n	Exercises\n	Summary\nChapter 21: The Iterator Pattern\n	Design patterns in brief\n	Iterators\n		The iterator protocol\n	Comprehensions\n		List comprehensions\n		Set and dictionary comprehensions\n		Generator expressions\n	Generators\n		Yield items from another iterable\n	Coroutines\n		Back to log parsing\n		Closing coroutines and throwing exceptions\n		The relationship between coroutines, generators, and functions\n	Case study\n	Exercises\n	Summary\nChapter 22: Python Design Patterns I\n	The decorator pattern\n		A decorator example\n		Decorators in Python\n	The observer pattern\n		An observer example\n	The strategy pattern\n		A strategy example\n		Strategy in Python\n	The state pattern\n		A state example\n		State versus strategy\n		State transition as coroutines\n	The singleton pattern\n		Singleton implementation\n		Module variables can mimic singletons\n	The template pattern\n		A template example\n	Exercises\n	Summary\nChapter 23: Python Design Patterns II\n	The adapter pattern\n	The facade pattern\n	The flyweight pattern\n	The command pattern\n	The abstract factory pattern\n	The composite pattern\n	Exercises\n	Summary\nChapter 24: Testing Object-Oriented Programs\n	Why test?\n		Test-driven development\n	Unit testing\n		Assertion methods\n		Reducing boilerplate and cleaning up\n		Organizing and running tests\n		Ignoring broken tests\n	Testing with pytest\n		One way to do setup and cleanup\n		A completely different way to set up variables\n		Skipping tests with pytest\n	Imitating expensive objects\n	How much testing is enough?\n	Case study\n		Implementing it\n	Exercises\n	Summary\nOther Books You May Enjoy\nIndex