Python

Python
Notes for Professionals
®

Notes for Professionals

700+ pages
of professional hints and tricks

Disclaimer
GoalKicker.com This is an unocial free book created for educational purposes and is
not aliated with ocial Python® group(s) or company(s).
Free Programming Books All trademarks and registered trademarks are
the property of their respective owners
Contents
About ................................................................................................................................................................................... 1
Chapter 1: Getting started with Python Language ...................................................................................... 2
Section 1.1: Getting Started ........................................................................................................................................... 2
Section 1.2: Creating variables and assigning values ................................................................................................ 6
Section 1.3: Block Indentation ..................................................................................................................................... 10
Section 1.4: Datatypes ................................................................................................................................................. 11
Section 1.5: Collection Types ...................................................................................................................................... 15
Section 1.6: IDLE - Python GUI .................................................................................................................................... 19
Section 1.7: User Input ................................................................................................................................................. 21
Section 1.8: Built in Modules and Functions .............................................................................................................. 21
Section 1.9: Creating a module ................................................................................................................................... 25
Section 1.10: Installation of Python 2.7.x and 3.x ....................................................................................................... 26
Section 1.11: String function - str() and repr() ........................................................................................................... 28
Section 1.12: Installing external modules using pip ................................................................................................... 29
Section 1.13: Help Utility ............................................................................................................................................... 31
Chapter 2: Python Data Types ............................................................................................................................ 33
Section 2.1: String Data Type ..................................................................................................................................... 33
Section 2.2: Set Data Types ....................................................................................................................................... 33
Section 2.3: Numbers data type ................................................................................................................................ 33
Section 2.4: List Data Type ......................................................................................................................................... 34
Section 2.5: Dictionary Data Type ............................................................................................................................. 34
Section 2.6: Tuple Data Type ..................................................................................................................................... 34
Chapter 3: Indentation ............................................................................................................................................. 35
Section 3.1: Simple example ....................................................................................................................................... 35
Section 3.2: How Indentation is Parsed ..................................................................................................................... 35
Section 3.3: Indentation Errors ................................................................................................................................... 36
Chapter 4: Comments and Documentation .................................................................................................. 37
Section 4.1: Single line, inline and multiline comments ............................................................................................ 37
Section 4.2: Programmatically accessing docstrings .............................................................................................. 37
Section 4.3: Write documentation using docstrings ................................................................................................ 38
Chapter 5: Date and Time ...................................................................................................................................... 41
Section 5.1: Parsing a string into a timezone aware datetime object .................................................................... 41
Section 5.2: Constructing timezone-aware datetimes ............................................................................................ 41
Section 5.3: Computing time dierences .................................................................................................................. 43
Section 5.4: Basic datetime objects usage ............................................................................................................... 43
Section 5.5: Switching between time zones .............................................................................................................. 44
Section 5.6: Simple date arithmetic ........................................................................................................................... 44
Section 5.7: Converting timestamp to datetime ...................................................................................................... 45
Section 5.8: Subtracting months from a date accurately ....................................................................................... 45
Section 5.9: Parsing an arbitrary ISO 8601 timestamp with minimal libraries ...................................................... 45
Section 5.10: Get an ISO 8601 timestamp .................................................................................................................. 46
Section 5.11: Parsing a string with a short time zone name into a timezone aware datetime object ................ 46
Section 5.12: Fuzzy datetime parsing (extracting datetime out of a text) ............................................................ 47
Section 5.13: Iterate over dates .................................................................................................................................. 48
Chapter 6: Date Formatting .................................................................................................................................. 49
Section 6.1: Time between two date-times ............................................................................................................... 49
Section 6.2: Outputting datetime object to string .................................................................................................... 49
 Section 6.3: Parsing string to datetime object ......................................................................................................... 49
Chapter 7: Enum .......................................................................................................................................................... 50
Section 7.1: Creating an enum (Python 2.4 through 3.3) ......................................................................................... 50
Section 7.2: Iteration ................................................................................................................................................... 50
Chapter 8: Set ............................................................................................................................................................... 51
Section 8.1: Operations on sets .................................................................................................................................. 51
Section 8.2: Get the unique elements of a list .......................................................................................................... 52
Section 8.3: Set of Sets ................................................................................................................................................ 52
Section 8.4: Set Operations using Methods and Builtins ......................................................................................... 52
Section 8.5: Sets versus multisets .............................................................................................................................. 54
Chapter 9: Simple Mathematical Operators ................................................................................................. 56
Section 9.1: Division ..................................................................................................................................................... 56
Section 9.2: Addition .................................................................................................................................................... 57
Section 9.3: Exponentiation ........................................................................................................................................ 58
Section 9.4: Trigonometric Functions ........................................................................................................................ 59
Section 9.5: Inplace Operations ................................................................................................................................. 60
Section 9.6: Subtraction .............................................................................................................................................. 60
Section 9.7: Multiplication ........................................................................................................................................... 60
Section 9.8: Logarithms .............................................................................................................................................. 61
Section 9.9: Modulus ................................................................................................................................................... 61
Chapter 10: Bitwise Operators ............................................................................................................................. 63
Section 10.1: Bitwise NOT ............................................................................................................................................ 63
Section 10.2: Bitwise XOR (Exclusive OR) .................................................................................................................. 64
Section 10.3: Bitwise AND ............................................................................................................................................ 65
Section 10.4: Bitwise OR .............................................................................................................................................. 65
Section 10.5: Bitwise Left Shift .................................................................................................................................... 65
Section 10.6: Bitwise Right Shift .................................................................................................................................. 66
Section 10.7: Inplace Operations ................................................................................................................................ 66
Chapter 11: Boolean Operators ............................................................................................................................ 67
Section 11.1: `and` and `or` are not guaranteed to return a boolean ...................................................................... 67
Section 11.2: A simple example ................................................................................................................................... 67
Section 11.3: Short-circuit evaluation ......................................................................................................................... 67
Section 11.4: and ........................................................................................................................................................... 68
Section 11.5: or .............................................................................................................................................................. 68
Section 11.6: not ............................................................................................................................................................ 69
Chapter 12: Operator Precedence ...................................................................................................................... 70
Section 12.1: Simple Operator Precedence Examples in python ............................................................................. 70
Chapter 13: Variable Scope and Binding ......................................................................................................... 71
Section 13.1: Nonlocal Variables ................................................................................................................................. 71
Section 13.2: Global Variables .................................................................................................................................... 71
Section 13.3: Local Variables ...................................................................................................................................... 72
Section 13.4: The del command ................................................................................................................................. 73
Section 13.5: Functions skip class scope when looking up names ......................................................................... 74
Section 13.6: Local vs Global Scope ........................................................................................................................... 75
Section 13.7: Binding Occurrence ............................................................................................................................... 77
Chapter 14: Conditionals ......................................................................................................................................... 78
Section 14.1: Conditional Expression (or "The Ternary Operator") ......................................................................... 78
Section 14.2: if, elif, and else ....................................................................................................................................... 78
Section 14.3: Truth Values ........................................................................................................................................... 78
 Section 14.4: Boolean Logic Expressions ................................................................................................................... 79
Section 14.5: Using the cmp function to get the comparison result of two objects ............................................. 81
Section 14.6: Else statement ....................................................................................................................................... 81
Section 14.7: Testing if an object is None and assigning it ...................................................................................... 82
Section 14.8: If statement ............................................................................................................................................ 82
Chapter 15: Comparisons ........................................................................................................................................ 83
Section 15.1: Chain Comparisons ................................................................................................................................ 83
Section 15.2: Comparison by `is` vs `==` ...................................................................................................................... 84
Section 15.3: Greater than or less than ...................................................................................................................... 85
Section 15.4: Not equal to ........................................................................................................................................... 85
Section 15.5: Equal To ................................................................................................................................................. 86
Section 15.6: Comparing Objects ............................................................................................................................... 86
Chapter 16: Loops ....................................................................................................................................................... 88
Section 16.1: Break and Continue in Loops ................................................................................................................ 88
Section 16.2: For loops ................................................................................................................................................ 90
Section 16.3: Iterating over lists .................................................................................................................................. 90
Section 16.4: Loops with an "else" clause .................................................................................................................. 91
Section 16.5: The Pass Statement .............................................................................................................................. 93
Section 16.6: Iterating over dictionaries .................................................................................................................... 94
Section 16.7: The "half loop" do-while ........................................................................................................................ 95
Section 16.8: Looping and Unpacking ....................................................................................................................... 95
Section 16.9: Iterating dierent portion of a list with dierent step size ............................................................... 96
Section 16.10: While Loop ............................................................................................................................................ 97
Chapter 17: Arrays ...................................................................................................................................................... 99
Section 17.1: Access individual elements through indexes ....................................................................................... 99
Section 17.2: Basic Introduction to Arrays ................................................................................................................. 99
Section 17.3: Append any value to the array using append() method ................................................................ 100
Section 17.4: Insert value in an array using insert() method ................................................................................ 100
Section 17.5: Extend python array using extend() method ................................................................................... 100
Section 17.6: Add items from list into array using fromlist() method .................................................................. 101
Section 17.7: Remove any array element using remove() method ..................................................................... 101
Section 17.8: Remove last array element using pop() method ............................................................................ 101
Section 17.9: Fetch any element through its index using index() method ........................................................... 101
Section 17.10: Reverse a python array using reverse() method ........................................................................... 101
Section 17.11: Get array buer information through buer_info() method ........................................................ 102
Section 17.12: Check for number of occurrences of an element using count() method .................................... 102
Section 17.13: Convert array to string using tostring() method ............................................................................ 102
Section 17.14: Convert array to a python list with same elements using tolist() method .................................. 102
Section 17.15: Append a string to char array using fromstring() method ........................................................... 102
Chapter 18: Multidimensional arrays .............................................................................................................. 103
Section 18.1: Lists in lists ............................................................................................................................................ 103
Section 18.2: Lists in lists in lists in.. .......................................................................................................................... 103
Chapter 19: Dictionary ............................................................................................................................................ 105
Section 19.1: Introduction to Dictionary ................................................................................................................... 105
Section 19.2: Avoiding KeyError Exceptions ........................................................................................................... 106
Section 19.3: Iterating Over a Dictionary ................................................................................................................. 106
Section 19.4: Dictionary with default values ........................................................................................................... 107
Section 19.5: Merging dictionaries ........................................................................................................................... 108
Section 19.6: Accessing keys and values ................................................................................................................ 108
Section 19.7: Accessing values of a dictionary ....................................................................................................... 109
 Section 19.8: Creating a dictionary .......................................................................................................................... 109
Section 19.9: Creating an ordered dictionary ......................................................................................................... 110
Section 19.10: Unpacking dictionaries using the ** operator ................................................................................. 110
Section 19.11: The trailing comma ............................................................................................................................ 111
Section 19.12: The dict() constructor ........................................................................................................................ 111
Section 19.13: Dictionaries Example ......................................................................................................................... 111
Section 19.14: All combinations of dictionary values .............................................................................................. 112
Chapter 20: List ......................................................................................................................................................... 113
Section 20.1: List methods and supported operators ............................................................................................ 113
Section 20.2: Accessing list values .......................................................................................................................... 118
Section 20.3: Checking if list is empty ..................................................................................................................... 119
Section 20.4: Iterating over a list ............................................................................................................................. 119
Section 20.5: Checking whether an item is in a list ................................................................................................ 120
Section 20.6: Any and All .......................................................................................................................................... 120
Section 20.7: Reversing list elements ...................................................................................................................... 121
Section 20.8: Concatenate and Merge lists ............................................................................................................ 121
Section 20.9: Length of a list .................................................................................................................................... 122
Section 20.10: Remove duplicate values in list ....................................................................................................... 122
Section 20.11: Comparison of lists ............................................................................................................................ 123
Section 20.12: Accessing values in nested list ........................................................................................................ 123
Section 20.13: Initializing a List to a Fixed Number of Elements ........................................................................... 124
Chapter 21: List comprehensions ...................................................................................................................... 126
Section 21.1: List Comprehensions ........................................................................................................................... 126
Section 21.2: Conditional List Comprehensions ...................................................................................................... 128
Section 21.3: Avoid repetitive and expensive operations using conditional clause ............................................ 130
Section 21.4: Dictionary Comprehensions ............................................................................................................... 131
Section 21.5: List Comprehensions with Nested Loops .......................................................................................... 132
Section 21.6: Generator Expressions ........................................................................................................................ 134
Section 21.7: Set Comprehensions ........................................................................................................................... 136
Section 21.8: Refactoring filter and map to list comprehensions ......................................................................... 136
Section 21.9: Comprehensions involving tuples ...................................................................................................... 137
Section 21.10: Counting Occurrences Using Comprehension ............................................................................... 138
Section 21.11: Changing Types in a List .................................................................................................................... 138
Section 21.12: Nested List Comprehensions ............................................................................................................ 138
Section 21.13: Iterate two or more list simultaneously within list comprehension .............................................. 139
Chapter 22: List slicing (selecting parts of lists) ....................................................................................... 140
Section 22.1: Using the third "step" argument ........................................................................................................ 140
Section 22.2: Selecting a sublist from a list ............................................................................................................ 140
Section 22.3: Reversing a list with slicing ................................................................................................................ 140
Section 22.4: Shifting a list using slicing .................................................................................................................. 140
Chapter 23: groupby() ............................................................................................................................................ 142
Section 23.1: Example 4 ............................................................................................................................................. 142
Section 23.2: Example 2 ............................................................................................................................................ 142
Section 23.3: Example 3 ............................................................................................................................................ 143
Chapter 24: Linked lists ......................................................................................................................................... 145
Section 24.1: Single linked list example ................................................................................................................... 145
Chapter 25: Linked List Node ............................................................................................................................. 149
Section 25.1: Write a simple Linked List Node in python ....................................................................................... 149
Chapter 26: Filter ...................................................................................................................................................... 150
 Section 26.1: Basic use of filter ................................................................................................................................. 150
Section 26.2: Filter without function ........................................................................................................................ 150
Section 26.3: Filter as short-circuit check ............................................................................................................... 151
Section 26.4: Complementary function: filterfalse, ifilterfalse .............................................................................. 151
Chapter 27: Heapq ................................................................................................................................................... 153
Section 27.1: Largest and smallest items in a collection ....................................................................................... 153
Section 27.2: Smallest item in a collection .............................................................................................................. 153
Chapter 28: Tuple ..................................................................................................................................................... 155
Section 28.1: Tuple ..................................................................................................................................................... 155
Section 28.2: Tuples are immutable ........................................................................................................................ 156
Section 28.3: Packing and Unpacking Tuples ........................................................................................................ 156
Section 28.4: Built-in Tuple Functions ..................................................................................................................... 157
Section 28.5: Tuple Are Element-wise Hashable and Equatable ......................................................................... 158
Section 28.6: Indexing Tuples ................................................................................................................................... 159
Section 28.7: Reversing Elements ............................................................................................................................ 159
Chapter 29: Basic Input and Output ............................................................................................................... 160
Section 29.1: Using the print function ...................................................................................................................... 160
Section 29.2: Input from a File ................................................................................................................................. 160
Section 29.3: Read from stdin .................................................................................................................................. 162
Section 29.4: Using input() and raw_input() .......................................................................................................... 162
Section 29.5: Function to prompt user for a number ............................................................................................ 162
Section 29.6: Printing a string without a newline at the end ................................................................................. 163
Chapter 30: Files & Folders I/O ......................................................................................................................... 165
Section 30.1: File modes ............................................................................................................................................ 165
Section 30.2: Reading a file line-by-line .................................................................................................................. 166
Section 30.3: Iterate files (recursively) .................................................................................................................... 167
Section 30.4: Getting the full contents of a file ...................................................................................................... 167
Section 30.5: Writing to a file ................................................................................................................................... 168
Section 30.6: Check whether a file or path exists .................................................................................................. 169
Section 30.7: Random File Access Using mmap .................................................................................................... 170
Section 30.8: Replacing text in a file ....................................................................................................................... 170
Section 30.9: Checking if a file is empty ................................................................................................................. 170
Section 30.10: Read a file between a range of lines .............................................................................................. 171
Section 30.11: Copy a directory tree ........................................................................................................................ 171
Section 30.12: Copying contents of one file to a dierent file .............................................................................. 171
Chapter 31: os.path .................................................................................................................................................. 172
Section 31.1: Join Paths ............................................................................................................................................. 172
Section 31.2: Path Component Manipulation .......................................................................................................... 172
Section 31.3: Get the parent directory ..................................................................................................................... 172
Section 31.4: If the given path exists ........................................................................................................................ 172
Section 31.5: check if the given path is a directory, file, symbolic link, mount point etc .................................... 173
Section 31.6: Absolute Path from Relative Path ..................................................................................................... 173
Chapter 32: Iterables and Iterators ................................................................................................................ 174
Section 32.1: Iterator vs Iterable vs Generator ....................................................................................................... 174
Section 32.2: Extract values one by one ................................................................................................................. 175
Section 32.3: Iterating over entire iterable ............................................................................................................. 175
Section 32.4: Verify only one element in iterable .................................................................................................. 175
Section 32.5: What can be iterable .......................................................................................................................... 176
Section 32.6: Iterator isn't reentrant! ....................................................................................................................... 176
Chapter 33: Functions ............................................................................................................................................. 177
Section 33.1: Defining and calling simple functions ............................................................................................... 177
Section 33.2: Defining a function with an arbitrary number of arguments ........................................................ 178
Section 33.3: Lambda (Inline/Anonymous) Functions .......................................................................................... 181
Section 33.4: Defining a function with optional arguments .................................................................................. 183
Section 33.5: Defining a function with optional mutable arguments ................................................................... 184
Section 33.6: Argument passing and mutability .................................................................................................... 185
Section 33.7: Returning values from functions ....................................................................................................... 186
Section 33.8: Closure ................................................................................................................................................. 186
Section 33.9: Forcing the use of named parameters ............................................................................................ 187
Section 33.10: Nested functions ............................................................................................................................... 188
Section 33.11: Recursion limit .................................................................................................................................... 188
Section 33.12: Recursive Lambda using assigned variable ................................................................................... 189
Section 33.13: Recursive functions ........................................................................................................................... 189
Section 33.14: Defining a function with arguments ................................................................................................ 190
Section 33.15: Iterable and dictionary unpacking .................................................................................................. 190
Section 33.16: Defining a function with multiple arguments ................................................................................. 192
Chapter 34: Defining functions with list arguments .............................................................................. 193
Section 34.1: Function and Call ................................................................................................................................. 193
Chapter 35: Functional Programming in Python ...................................................................................... 194
Section 35.1: Lambda Function ................................................................................................................................ 194
Section 35.2: Map Function ...................................................................................................................................... 194
Section 35.3: Reduce Function ................................................................................................................................. 194
Section 35.4: Filter Function ..................................................................................................................................... 194
Chapter 36: Partial functions .............................................................................................................................. 195
Section 36.1: Raise the power ................................................................................................................................... 195
Chapter 37: Decorators ......................................................................................................................................... 196
Section 37.1: Decorator function .............................................................................................................................. 196
Section 37.2: Decorator class ................................................................................................................................... 197
Section 37.3: Decorator with arguments (decorator factory) .............................................................................. 198
Section 37.4: Making a decorator look like the decorated function .................................................................... 200
Section 37.5: Using a decorator to time a function ............................................................................................... 200
Section 37.6: Create singleton class with a decorator .......................................................................................... 201
Chapter 38: Classes ................................................................................................................................................. 202
Section 38.1: Introduction to classes ........................................................................................................................ 202
Section 38.2: Bound, unbound, and static methods .............................................................................................. 203
Section 38.3: Basic inheritance ................................................................................................................................ 205
Section 38.4: Monkey Patching ................................................................................................................................ 207
Section 38.5: New-style vs. old-style classes .......................................................................................................... 207
Section 38.6: Class methods: alternate initializers ................................................................................................. 208
Section 38.7: Multiple Inheritance ............................................................................................................................ 210
Section 38.8: Properties ............................................................................................................................................ 212
Section 38.9: Default values for instance variables ............................................................................................... 213
Section 38.10: Class and instance variables ........................................................................................................... 214
Section 38.11: Class composition .............................................................................................................................. 215
Section 38.12: Listing All Class Members ................................................................................................................. 216
Section 38.13: Singleton class ................................................................................................................................... 217
Section 38.14: Descriptors and Dotted Lookups .................................................................................................... 218
Chapter 39: Metaclasses ....................................................................................................................................... 219
 Section 39.1: Basic Metaclasses ............................................................................................................................... 219
Section 39.2: Singletons using metaclasses ........................................................................................................... 220
Section 39.3: Using a metaclass .............................................................................................................................. 220
Section 39.4: Introduction to Metaclasses .............................................................................................................. 220
Section 39.5: Custom functionality with metaclasses ........................................................................................... 221
Section 39.6: The default metaclass ....................................................................................................................... 222
Chapter 40: String Formatting ......................................................................................................................... 224
Section 40.1: Basics of String Formatting ............................................................................................................... 224
Section 40.2: Alignment and padding ..................................................................................................................... 225
Section 40.3: Format literals (f-string) .................................................................................................................... 226
Section 40.4: Float formatting ................................................................................................................................. 226
Section 40.5: Named placeholders ......................................................................................................................... 227
Section 40.6: String formatting with datetime ....................................................................................................... 228
Section 40.7: Formatting Numerical Values ........................................................................................................... 228
Section 40.8: Nested formatting .............................................................................................................................. 229
Section 40.9: Format using Getitem and Getattr ................................................................................................... 229
Section 40.10: Padding and truncating strings, combined .................................................................................... 229
Section 40.11: Custom formatting for a class ......................................................................................................... 230
Chapter 41: String Methods ................................................................................................................................ 232
Section 41.1: Changing the capitalization of a string ............................................................................................. 232
Section 41.2: str.translate: Translating characters in a string ............................................................................... 233
Section 41.3: str.format and f-strings: Format values into a string ...................................................................... 234
Section 41.4: String module's useful constants ....................................................................................................... 235
Section 41.5: Stripping unwanted leading/trailing characters from a string ...................................................... 236
Section 41.6: Reversing a string ............................................................................................................................... 237
Section 41.7: Split a string based on a delimiter into a list of strings ................................................................... 237
Section 41.8: Replace all occurrences of one substring with another substring ................................................ 238
Section 41.9: Testing what a string is composed of ............................................................................................... 239
Section 41.10: String Contains ................................................................................................................................... 241
Section 41.11: Join a list of strings into one string ................................................................................................... 241
Section 41.12: Counting number of times a substring appears in a string .......................................................... 242
Section 41.13: Case insensitive string comparisons ................................................................................................ 242
Section 41.14: Justify strings ..................................................................................................................................... 243
Section 41.15: Test the starting and ending characters of a string ...................................................................... 244
Section 41.16: Conversion between str or bytes data and unicode characters .................................................. 245
Chapter 42: Using loops within functions .................................................................................................... 247
Section 42.1: Return statement inside loop in a function ...................................................................................... 247
Chapter 43: Importing modules ........................................................................................................................ 248
Section 43.1: Importing a module ............................................................................................................................ 248
Section 43.2: The __all__ special variable ............................................................................................................ 249
Section 43.3: Import modules from an arbitrary filesystem location .................................................................. 250
Section 43.4: Importing all names from a module ................................................................................................ 250
Section 43.5: Programmatic importing ................................................................................................................... 251
Section 43.6: PEP8 rules for Imports ....................................................................................................................... 251
Section 43.7: Importing specific names from a module ........................................................................................ 252
Section 43.8: Importing submodules ....................................................................................................................... 252
Section 43.9: Re-importing a module ...................................................................................................................... 252
Section 43.10: __import__() function ..................................................................................................................... 253
Chapter 44: Dierence between Module and Package ...................................................................... 254
Section 44.1: Modules ................................................................................................................................................ 254
 Section 44.2: Packages ............................................................................................................................................. 254
Chapter 45: Math Module .................................................................................................................................... 255
Section 45.1: Rounding: round, floor, ceil, trunc ...................................................................................................... 255
Section 45.2: Trigonometry ...................................................................................................................................... 256
Section 45.3: Pow for faster exponentiation ........................................................................................................... 257
Section 45.4: Infinity and NaN ("not a number") ................................................................................................... 257
Section 45.5: Logarithms .......................................................................................................................................... 260
Section 45.6: Constants ............................................................................................................................................ 260
Section 45.7: Imaginary Numbers ........................................................................................................................... 261
Section 45.8: Copying signs ..................................................................................................................................... 261
Section 45.9: Complex numbers and the cmath module ...................................................................................... 261
Chapter 46: Complex math ................................................................................................................................. 264
Section 46.1: Advanced complex arithmetic ........................................................................................................... 264
Section 46.2: Basic complex arithmetic .................................................................................................................. 265
Chapter 47: Collections module ....................................................................................................................... 266
Section 47.1: collections.Counter .............................................................................................................................. 266
Section 47.2: collections.OrderedDict ...................................................................................................................... 267
Section 47.3: collections.defaultdict ......................................................................................................................... 268
Section 47.4: collections.namedtuple ...................................................................................................................... 269
Section 47.5: collections.deque ................................................................................................................................ 270
Section 47.6: collections.ChainMap .......................................................................................................................... 271
Chapter 48: Operator module ........................................................................................................................... 273
Section 48.1: Itemgetter ............................................................................................................................................ 273
Section 48.2: Operators as alternative to an infix operator ................................................................................. 273
Section 48.3: Methodcaller ....................................................................................................................................... 273
Chapter 49: JSON Module .................................................................................................................................... 275
Section 49.1: Storing data in a file ............................................................................................................................ 275
Section 49.2: Retrieving data from a file ................................................................................................................ 275
Section 49.3: Formatting JSON output ................................................................................................................... 275
Section 49.4: `load` vs `loads`, `dump` vs `dumps` ................................................................................................... 276
Section 49.5: Calling `json.tool` from the command line to pretty-print JSON output ...................................... 277
Section 49.6: JSON encoding custom objects ........................................................................................................ 277
Section 49.7: Creating JSON from Python dict ...................................................................................................... 278
Section 49.8: Creating Python dict from JSON ...................................................................................................... 278
Chapter 50: Sqlite3 Module ................................................................................................................................. 279
Section 50.1: Sqlite3 - Not require separate server process ................................................................................. 279
Section 50.2: Getting the values from the database and Error handling ........................................................... 279
Chapter 51: The os Module ................................................................................................................................... 281
Section 51.1: makedirs - recursive directory creation ............................................................................................ 281
Section 51.2: Create a directory ............................................................................................................................... 282
Section 51.3: Get current directory .......................................................................................................................... 282
Section 51.4: Determine the name of the operating system ................................................................................ 282
Section 51.5: Remove a directory ............................................................................................................................ 282
Section 51.6: Follow a symlink (POSIX) .................................................................................................................... 282
Section 51.7: Change permissions on a file ............................................................................................................. 282
Chapter 52: The locale Module .......................................................................................................................... 283
Section 52.1: Currency Formatting US Dollars Using the locale Module ............................................................. 283
Chapter 53: Itertools Module .............................................................................................................................. 284
Section 53.1: Combinations method in Itertools Module ....................................................................................... 284
 Section 53.2: itertools.dropwhile .............................................................................................................................. 284
Section 53.3: Zipping two iterators until they are both exhausted ...................................................................... 285
Section 53.4: Take a slice of a generator ............................................................................................................... 285
Section 53.5: Grouping items from an iterable object using a function .............................................................. 286
Section 53.6: itertools.takewhile ............................................................................................................................... 287
Section 53.7: itertools.permutations ........................................................................................................................ 287
Section 53.8: itertools.repeat .................................................................................................................................... 288
Section 53.9: Get an accumulated sum of numbers in an iterable ...................................................................... 288
Section 53.10: Cycle through elements in an iterator ............................................................................................ 288
Section 53.11: itertools.product ................................................................................................................................. 288
Section 53.12: itertools.count .................................................................................................................................... 289
Section 53.13: Chaining multiple iterators together ............................................................................................... 290
Chapter 54: Asyncio Module ............................................................................................................................... 291
Section 54.1: Coroutine and Delegation Syntax ..................................................................................................... 291
Section 54.2: Asynchronous Executors ................................................................................................................... 292
Section 54.3: Using UVLoop ..................................................................................................................................... 293
Section 54.4: Synchronization Primitive: Event ....................................................................................................... 293
Section 54.5: A Simple Websocket .......................................................................................................................... 294
Section 54.6: Common Misconception about asyncio .......................................................................................... 294
Chapter 55: Random module ............................................................................................................................. 296
Section 55.1: Creating a random user password ................................................................................................... 296
Section 55.2: Create cryptographically secure random numbers ....................................................................... 296
Section 55.3: Random and sequences: shue, choice and sample .................................................................... 297
Section 55.4: Creating random integers and floats: randint, randrange, random, and uniform ...................... 298
Section 55.5: Reproducible random numbers: Seed and State ............................................................................ 299
Section 55.6: Random Binary Decision ................................................................................................................... 300
Chapter 56: Functools Module ........................................................................................................................... 301
Section 56.1: partial ................................................................................................................................................... 301
Section 56.2: cmp_to_key ....................................................................................................................................... 301
Section 56.3: lru_cache ............................................................................................................................................. 301
Section 56.4: total_ordering ..................................................................................................................................... 302
Section 56.5: reduce .................................................................................................................................................. 303
Chapter 57: The dis module ................................................................................................................................ 304
Section 57.1: What is Python bytecode? ................................................................................................................. 304
Section 57.2: Constants in the dis module .............................................................................................................. 304
Section 57.3: Disassembling modules ..................................................................................................................... 304
Chapter 58: The base64 Module ....................................................................................................................... 306
Section 58.1: Encoding and Decoding Base64 ....................................................................................................... 307
Section 58.2: Encoding and Decoding Base32 ....................................................................................................... 308
Section 58.3: Encoding and Decoding Base16 ........................................................................................................ 309
Section 58.4: Encoding and Decoding ASCII85 ...................................................................................................... 309
Section 58.5: Encoding and Decoding Base85 ....................................................................................................... 310
Chapter 59: Queue Module .................................................................................................................................. 311
Section 59.1: Simple example ................................................................................................................................... 311
Chapter 60: Deque Module .................................................................................................................................. 312
Section 60.1: Basic deque using ............................................................................................................................... 312
Section 60.2: Available methods in deque .............................................................................................................. 312
Section 60.3: limit deque size ................................................................................................................................... 313
Section 60.4: Breadth First Search .......................................................................................................................... 313