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 ....................................................................................................................................... 9
Section 1.4: Datatypes ................................................................................................................................................. 11
Section 1.5: Collection Types ...................................................................................................................................... 15
Section 1.6: IDLE - Python GUI .................................................................................................................................... 19
Section 1.7: User Input ................................................................................................................................................. 20
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 ............................................................................................................................................... 30
Chapter 2: Python Data Types ............................................................................................................................ 32
Section 2.1: String Data Type ..................................................................................................................................... 32
Section 2.2: Set Data Types ....................................................................................................................................... 32
Section 2.3: Numbers data type ................................................................................................................................ 32
Section 2.4: List Data Type ......................................................................................................................................... 33
Section 2.5: Dictionary Data Type ............................................................................................................................. 33
Section 2.6: Tuple Data Type ..................................................................................................................................... 33
Chapter 3: Indentation ............................................................................................................................................. 34
Section 3.1: Simple example ....................................................................................................................................... 34
Section 3.2: How Indentation is Parsed ..................................................................................................................... 34
Section 3.3: Indentation Errors ................................................................................................................................... 35
Chapter 4: Comments and Documentation .................................................................................................. 36
Section 4.1: Single line, inline and multiline comments ............................................................................................ 36
Section 4.2: Programmatically accessing docstrings .............................................................................................. 36
Section 4.3: Write documentation using docstrings ................................................................................................ 37
Chapter 5: Date and Time ...................................................................................................................................... 40
Section 5.1: Parsing a string into a timezone aware datetime object .................................................................... 40
Section 5.2: Constructing timezone-aware datetimes ............................................................................................ 40
Section 5.3: Computing time dierences .................................................................................................................. 42
Section 5.4: Basic datetime objects usage ............................................................................................................... 42
Section 5.5: Switching between time zones .............................................................................................................. 43
Section 5.6: Simple date arithmetic ........................................................................................................................... 43
Section 5.7: Converting timestamp to datetime ...................................................................................................... 44
Section 5.8: Subtracting months from a date accurately ....................................................................................... 44
Section 5.9: Parsing an arbitrary ISO 8601 timestamp with minimal libraries ...................................................... 44
Section 5.10: Get an ISO 8601 timestamp .................................................................................................................. 45
Section 5.11: Parsing a string with a short time zone name into a timezone aware datetime object ................ 45
Section 5.12: Fuzzy datetime parsing (extracting datetime out of a text) ............................................................ 46
Section 5.13: Iterate over dates .................................................................................................................................. 47
Chapter 6: Date Formatting .................................................................................................................................. 48
Section 6.1: Time between two date-times ............................................................................................................... 48
Section 6.2: Outputting datetime object to string .................................................................................................... 48
 Section 6.3: Parsing string to datetime object ......................................................................................................... 48
Chapter 7: Enum .......................................................................................................................................................... 49
Section 7.1: Creating an enum (Python 2.4 through 3.3) ......................................................................................... 49
Section 7.2: Iteration ................................................................................................................................................... 49
Chapter 8: Set ............................................................................................................................................................... 50
Section 8.1: Operations on sets .................................................................................................................................. 50
Section 8.2: Get the unique elements of a list .......................................................................................................... 51
Section 8.3: Set of Sets ................................................................................................................................................ 51
Section 8.4: Set Operations using Methods and Builtins ......................................................................................... 51
Section 8.5: Sets versus multisets .............................................................................................................................. 53
Chapter 9: Simple Mathematical Operators ................................................................................................. 55
Section 9.1: Division ..................................................................................................................................................... 55
Section 9.2: Addition .................................................................................................................................................... 56
Section 9.3: Exponentation ......................................................................................................................................... 57
Section 9.4: Trigonometric Functions ........................................................................................................................ 58
Section 9.5: Inplace Operations ................................................................................................................................. 58
Section 9.6: Subtraction .............................................................................................................................................. 59
Section 9.7: Multiplication ........................................................................................................................................... 59
Section 9.8: Logarithms .............................................................................................................................................. 60
Section 9.9: Modulus ................................................................................................................................................... 60
Chapter 10: Bitwise Operators ............................................................................................................................. 61
Section 10.1: Bitwise NOT ............................................................................................................................................ 61
Section 10.2: Bitwise XOR (Exclusive OR) .................................................................................................................. 62
Section 10.3: Bitwise AND ............................................................................................................................................ 63
Section 10.4: Bitwise OR .............................................................................................................................................. 63
Section 10.5: Bitwise Left Shift .................................................................................................................................... 63
Section 10.6: Bitwise Right Shift .................................................................................................................................. 64
Section 10.7: Inplace Operations ................................................................................................................................ 64
Chapter 11: Boolean Operators ............................................................................................................................ 65
Section 11.1: `and` and `or` are not guaranteed to return a boolean ...................................................................... 65
Section 11.2: A simple example ................................................................................................................................... 65
Section 11.3: Short-circuit evaluation ......................................................................................................................... 65
Section 11.4: and ........................................................................................................................................................... 66
Section 11.5: or .............................................................................................................................................................. 66
Section 11.6: not ............................................................................................................................................................ 67
Chapter 12: Operator Precedence ...................................................................................................................... 68
Section 12.1: Simple Operator Precedence Examples in python ............................................................................. 68
Chapter 13: Filter ......................................................................................................................................................... 69
Section 13.1: Basic use of filter .................................................................................................................................... 69
Section 13.2: Filter without function ........................................................................................................................... 69
Section 13.3: Filter as short-circuit check .................................................................................................................. 70
Section 13.4: Complementary function: filterfalse, ifilterfalse ................................................................................. 70
Chapter 14: Arrays ..................................................................................................................................................... 72
Section 14.1: Access individual elements through indexes ....................................................................................... 72
Section 14.2: Basic Introduction to Arrays ................................................................................................................ 72
Section 14.3: Append any value to the array using append() method .................................................................. 73
Section 14.4: Insert value in an array using insert() method .................................................................................. 73
Section 14.5: Extend python array using extend() method ..................................................................................... 73
Section 14.6: Add items from list into array using fromlist() method .................................................................... 73
 Section 14.7: Remove any array element using remove() method ....................................................................... 74
Section 14.8: Remove last array element using pop() method .............................................................................. 74
Section 14.9: Fetch any element through its index using index() method ............................................................. 74
Section 14.10: Reverse a python array using reverse() method ............................................................................. 74
Section 14.11: Get array buer information through buer_info() method .......................................................... 75
Section 14.12: Check for number of occurrences of an element using count() method ...................................... 75
Section 14.13: Convert array to string using tostring() method .............................................................................. 75
Section 14.14: Convert array to a python list with same elements using tolist() method .................................... 75
Section 14.15: Append a string to char array using fromstring() method ............................................................. 75
Chapter 15: Dictionary .............................................................................................................................................. 76
Section 15.1: Introduction to Dictionary ..................................................................................................................... 76
Section 15.2: Avoiding KeyError Exceptions .............................................................................................................. 77
Section 15.3: Iterating Over a Dictionary ................................................................................................................... 77
Section 15.4: Dictionary with default values ............................................................................................................. 78
Section 15.5: Merging dictionaries .............................................................................................................................. 79
Section 15.6: Accessing keys and values ................................................................................................................... 79
Section 15.7: Accessing values of a dictionary ......................................................................................................... 80
Section 15.8: Creating a dictionary ............................................................................................................................ 80
Section 15.9: Creating an ordered dictionary ........................................................................................................... 81
Section 15.10: Unpacking dictionaries using the ** operator ................................................................................... 81
Section 15.11: The trailing comma .............................................................................................................................. 82
Section 15.12: The dict() constructor .......................................................................................................................... 82
Section 15.13: Dictionaries Example ........................................................................................................................... 82
Section 15.14: All combinations of dictionary values ................................................................................................ 83
Chapter 16: List ............................................................................................................................................................. 84
Section 16.1: List methods and supported operators ............................................................................................... 84
Section 16.2: Accessing list values .............................................................................................................................. 89
Section 16.3: Checking if list is empty ........................................................................................................................ 90
Section 16.4: Iterating over a list ................................................................................................................................ 90
Section 16.5: Checking whether an item is in a list ................................................................................................... 91
Section 16.6: Any and All ............................................................................................................................................. 91
Section 16.7: Reversing list elements ......................................................................................................................... 92
Section 16.8: Concatenate and Merge lists ............................................................................................................... 92
Section 16.9: Length of a list ....................................................................................................................................... 93
Section 16.10: Remove duplicate values in list .......................................................................................................... 93
Section 16.11: Comparison of lists ............................................................................................................................... 94
Section 16.12: Accessing values in nested list ............................................................................................................ 94
Section 16.13: Initializing a List to a Fixed Number of Elements .............................................................................. 95
Chapter 17: List comprehensions ........................................................................................................................ 97
Section 17.1: List Comprehensions .............................................................................................................................. 97
Section 17.2: Avoid repetitive and expensive operations using conditional clause .............................................. 99
Section 17.3: Dictionary Comprehensions ............................................................................................................... 101
Section 17.4: Generator Expressions ........................................................................................................................ 102
Section 17.5: Set Comprehensions ........................................................................................................................... 104
Section 17.6: Comprehensions involving tuples ...................................................................................................... 104
Section 17.7: Counting Occurrences Using Comprehension ................................................................................. 105
Section 17.8: Changing Types in a List .................................................................................................................... 105
Chapter 18: List slicing (selecting parts of lists) ....................................................................................... 107
Section 18.1: Using the third "step" argument ......................................................................................................... 107
Section 18.2: Selecting a sublist from a list ............................................................................................................. 107
 Section 18.3: Reversing a list with slicing ................................................................................................................. 107
Section 18.4: Shifting a list using slicing ................................................................................................................... 107
Chapter 19: Linked lists .......................................................................................................................................... 109
Section 19.1: Single linked list example .................................................................................................................... 109
Chapter 20: Linked List Node ............................................................................................................................. 113
Section 20.1: Write a simple Linked List Node in python ....................................................................................... 113
Chapter 21: Tuple ...................................................................................................................................................... 114
Section 21.1: Tuple ...................................................................................................................................................... 114
Section 21.2: Tuples are immutable ......................................................................................................................... 115
Section 21.3: Packing and Unpacking Tuples ......................................................................................................... 115
Section 21.4: Built-in Tuple Functions ...................................................................................................................... 116
Section 21.5: Tuple Are Element-wise Hashable and Equatable .......................................................................... 117
Section 21.6: Indexing Tuples ................................................................................................................................... 118
Section 21.7: Reversing Elements ............................................................................................................................. 118
Chapter 22: Functions ............................................................................................................................................. 119
Section 22.1: Defining and calling simple functions ............................................................................................... 119
Section 22.2: Defining a function with an arbitrary number of arguments ........................................................ 120
Section 22.3: Lambda (Inline/Anonymous) Functions .......................................................................................... 123
Section 22.4: Defining a function with optional arguments .................................................................................. 125
Section 22.5: Defining a function with optional mutable arguments .................................................................. 126
Section 22.6: Argument passing and mutability .................................................................................................... 127
Section 22.7: Returning values from functions ...................................................................................................... 128
Section 22.8: Closure ................................................................................................................................................. 128
Section 22.9: Forcing the use of named parameters ............................................................................................ 129
Section 22.10: Nested functions ............................................................................................................................... 130
Section 22.11: Recursion limit .................................................................................................................................... 130
Section 22.12: Recursive Lambda using assigned variable .................................................................................. 131
Section 22.13: Recursive functions ........................................................................................................................... 131
Section 22.14: Defining a function with arguments ................................................................................................ 132
Section 22.15: Iterable and dictionary unpacking .................................................................................................. 132
Section 22.16: Defining a function with multiple arguments ................................................................................. 134
Chapter 23: Defining functions with list arguments ............................................................................... 135
Section 23.1: Function and Call ................................................................................................................................. 135
Chapter 24: Functional Programming in Python ..................................................................................... 136
Section 24.1: Lambda Function ................................................................................................................................ 136
Section 24.2: Map Function ...................................................................................................................................... 136
Section 24.3: Reduce Function ................................................................................................................................. 136
Section 24.4: Filter Function ..................................................................................................................................... 136
Chapter 25: Partial functions ............................................................................................................................. 137
Section 25.1: Raise the power ................................................................................................................................... 137
Chapter 26: Decorators ......................................................................................................................................... 138
Section 26.1: Decorator function .............................................................................................................................. 138
Section 26.2: Decorator class .................................................................................................................................. 139
Section 26.3: Decorator with arguments (decorator factory) ............................................................................. 140
Section 26.4: Making a decorator look like the decorated function .................................................................... 141
Section 26.5: Using a decorator to time a function ............................................................................................... 142
Section 26.6: Create singleton class with a decorator .......................................................................................... 143
Chapter 27: Classes ................................................................................................................................................. 144
Section 27.1: Introduction to classes ........................................................................................................................ 144
 Section 27.2: Bound, unbound, and static methods .............................................................................................. 145
Section 27.3: Basic inheritance ................................................................................................................................ 147
Section 27.4: Monkey Patching ................................................................................................................................ 149
Section 27.5: New-style vs. old-style classes .......................................................................................................... 149
Section 27.6: Class methods: alternate initializers ................................................................................................. 150
Section 27.7: Multiple Inheritance ............................................................................................................................ 152
Section 27.8: Properties ............................................................................................................................................ 154
Section 27.9: Default values for instance variables ............................................................................................... 155
Section 27.10: Class and instance variables ........................................................................................................... 156
Section 27.11: Class composition .............................................................................................................................. 157
Section 27.12: Listing All Class Members ................................................................................................................. 158
Section 27.13: Singleton class ................................................................................................................................... 159
Section 27.14: Descriptors and Dotted Lookups .................................................................................................... 160
Chapter 28: Metaclasses ....................................................................................................................................... 161
Section 28.1: Basic Metaclasses ............................................................................................................................... 161
Section 28.2: Singletons using metaclasses ........................................................................................................... 162
Section 28.3: Using a metaclass .............................................................................................................................. 162
Section 28.4: Introduction to Metaclasses .............................................................................................................. 162
Section 28.5: Custom functionality with metaclasses ........................................................................................... 163
Section 28.6: The default metaclass ....................................................................................................................... 164
Chapter 29: String Methods ................................................................................................................................ 166
Section 29.1: Changing the capitalization of a string ............................................................................................. 166
Section 29.2: str.translate: Translating characters in a string .............................................................................. 167
Section 29.3: str.format and f-strings: Format values into a string ..................................................................... 167
Section 29.4: String module's useful constants ...................................................................................................... 168
Section 29.5: Stripping unwanted leading/trailing characters from a string ..................................................... 170
Section 29.6: Reversing a string .............................................................................................................................. 170
Section 29.7: Split a string based on a delimiter into a list of strings .................................................................. 171
Section 29.8: Replace all occurrences of one substring with another substring ................................................ 172
Section 29.9: Testing what a string is composed of .............................................................................................. 172
Section 29.10: String Contains .................................................................................................................................. 175
Section 29.11: Join a list of strings into one string .................................................................................................. 175
Section 29.12: Counting number of times a substring appears in a string ......................................................... 175
Section 29.13: Case insensitive string comparisons ............................................................................................... 176
Section 29.14: Justify strings .................................................................................................................................... 177
Section 29.15: Test the starting and ending characters of a string ..................................................................... 177
Section 29.16: Conversion between str or bytes data and unicode characters ................................................. 178
Chapter 30: String Formatting .......................................................................................................................... 180
Section 30.1: Basics of String Formatting ............................................................................................................... 180
Section 30.2: Alignment and padding ..................................................................................................................... 181
Section 30.3: Format literals (f-string) .................................................................................................................... 182
Section 30.4: Float formatting ................................................................................................................................. 182
Section 30.5: Named placeholders .......................................................................................................................... 183
Section 30.6: String formatting with datetime ....................................................................................................... 184
Section 30.7: Formatting Numerical Values ........................................................................................................... 184
Section 30.8: Nested formatting .............................................................................................................................. 185
Section 30.9: Format using Getitem and Getattr ................................................................................................... 185
Section 30.10: Padding and truncating strings, combined .................................................................................... 185
Section 30.11: Custom formatting for a class ......................................................................................................... 186
Chapter 31: Conditionals ....................................................................................................................................... 188
 Section 31.1: Conditional Expression (or "The Ternary Operator") ....................................................................... 188
Section 31.2: if, elif, and else ..................................................................................................................................... 188
Section 31.3: Truth Values ......................................................................................................................................... 188
Section 31.4: Boolean Logic Expressions ................................................................................................................. 189
Section 31.5: Using the cmp function to get the comparison result of two objects ........................................... 191
Section 31.6: Else statement ..................................................................................................................................... 191
Section 31.7: Testing if an object is None and assigning it .................................................................................... 191
Section 31.8: If statement .......................................................................................................................................... 192
Chapter 32: Loops .................................................................................................................................................... 193
Section 32.1: Break and Continue in Loops ............................................................................................................. 193
Section 32.2: For loops ............................................................................................................................................. 195
Section 32.3: Iterating over lists ............................................................................................................................... 195
Section 32.4: Loops with an "else" clause ............................................................................................................... 196
Section 32.5: The Pass Statement ........................................................................................................................... 198
Section 32.6: Iterating over dictionaries .................................................................................................................. 199
Section 32.7: The "half loop" do-while ..................................................................................................................... 200
Section 32.8: Looping and Unpacking .................................................................................................................... 200
Section 32.9: Iterating dierent portion of a list with dierent step size ............................................................ 201
Section 32.10: While Loop ......................................................................................................................................... 202
Chapter 33: Using loops within functions ..................................................................................................... 203
Section 33.1: Return statement inside loop in a function ....................................................................................... 203
Chapter 34: Importing modules ........................................................................................................................ 204
Section 34.1: Importing a module ............................................................................................................................ 204
Section 34.2: The __all__ special variable ............................................................................................................ 205
Section 34.3: Import modules from an arbitrary filesystem location .................................................................. 206
Section 34.4: Importing all names from a module ................................................................................................ 206
Section 34.5: Programmatic importing ................................................................................................................... 207
Section 34.6: PEP8 rules for Imports ....................................................................................................................... 207
Section 34.7: Importing specific names from a module ........................................................................................ 208
Section 34.8: Importing submodules ....................................................................................................................... 208
Section 34.9: Re-importing a module ...................................................................................................................... 208
Section 34.10: __import__() function ..................................................................................................................... 209
Chapter 35: Dierence between Module and Package ........................................................................ 210
Section 35.1: Modules ................................................................................................................................................ 210
Section 35.2: Packages ............................................................................................................................................. 210
Chapter 36: Math Module ..................................................................................................................................... 211
Section 36.1: Rounding: round, floor, ceil, trunc ...................................................................................................... 211
Section 36.2: Trigonometry ...................................................................................................................................... 212
Section 36.3: Pow for faster exponentiation ........................................................................................................... 213
Section 36.4: Infinity and NaN ("not a number") ................................................................................................... 213
Section 36.5: Logarithms .......................................................................................................................................... 216
Section 36.6: Constants ............................................................................................................................................. 216
Section 36.7: Imaginary Numbers ........................................................................................................................... 217
Section 36.8: Copying signs ...................................................................................................................................... 217
Section 36.9: Complex numbers and the cmath module ...................................................................................... 217
Chapter 37: Complex math .................................................................................................................................. 220
Section 37.1: Advanced complex arithmetic ........................................................................................................... 220
Section 37.2: Basic complex arithmetic ................................................................................................................... 221
Chapter 38: Collections module ........................................................................................................................ 222
 Section 38.1: collections.Counter .............................................................................................................................. 222
Section 38.2: collections.OrderedDict ...................................................................................................................... 223
Section 38.3: collections.defaultdict ......................................................................................................................... 224
Section 38.4: collections.namedtuple ...................................................................................................................... 225
Section 38.5: collections.deque ................................................................................................................................ 226
Section 38.6: collections.ChainMap ......................................................................................................................... 227
Chapter 39: Operator module ............................................................................................................................ 229
Section 39.1: Itemgetter ............................................................................................................................................ 229
Section 39.2: Operators as alternative to an infix operator ................................................................................. 229
Section 39.3: Methodcaller ....................................................................................................................................... 229
Chapter 40: JSON Module ................................................................................................................................... 231
Section 40.1: Storing data in a file ........................................................................................................................... 231
Section 40.2: Retrieving data from a file ................................................................................................................ 231
Section 40.3: Formatting JSON output ................................................................................................................... 231
Section 40.4: `load` vs `loads`, `dump` vs `dumps` .................................................................................................. 232
Section 40.5: Calling `json.tool` from the command line to pretty-print JSON output ...................................... 233
Section 40.6: JSON encoding custom objects ....................................................................................................... 233
Section 40.7: Creating JSON from Python dict ...................................................................................................... 234
Section 40.8: Creating Python dict from JSON ...................................................................................................... 234
Chapter 41: Sqlite3 Module .................................................................................................................................. 235
Section 41.1: Sqlite3 - Not require separate server process .................................................................................. 235
Section 41.2: Getting the values from the database and Error handling ............................................................ 235
Chapter 42: The os Module ................................................................................................................................. 237
Section 42.1: makedirs - recursive directory creation ........................................................................................... 237
Section 42.2: Create a directory .............................................................................................................................. 238
Section 42.3: Get current directory .......................................................................................................................... 238
Section 42.4: Determine the name of the operating system ............................................................................... 238
Section 42.5: Remove a directory ........................................................................................................................... 238
Section 42.6: Follow a symlink (POSIX) ................................................................................................................... 238
Section 42.7: Change permissions on a file ............................................................................................................ 238
Chapter 43: The locale Module ......................................................................................................................... 239
Section 43.1: Currency Formatting US Dollars Using the locale Module ............................................................. 239
Chapter 44: Itertools Module ............................................................................................................................ 240
Section 44.1: Combinations method in Itertools Module ....................................................................................... 240
Section 44.2: itertools.dropwhile .............................................................................................................................. 240
Section 44.3: Zipping two iterators until they are both exhausted ...................................................................... 241
Section 44.4: Take a slice of a generator ............................................................................................................... 241
Section 44.5: Grouping items from an iterable object using a function .............................................................. 242
Section 44.6: itertools.takewhile ............................................................................................................................... 243
Section 44.7: itertools.permutations ........................................................................................................................ 243
Section 44.8: itertools.repeat .................................................................................................................................... 244
Section 44.9: Get an accumulated sum of numbers in an iterable ...................................................................... 244
Section 44.10: Cycle through elements in an iterator ............................................................................................ 244
Section 44.11: itertools.product ................................................................................................................................. 244
Section 44.12: itertools.count .................................................................................................................................... 245
Section 44.13: Chaining multiple iterators together ............................................................................................... 246
Chapter 45: Asyncio Module ............................................................................................................................... 247
Section 45.1: Coroutine and Delegation Syntax ..................................................................................................... 247
Section 45.2: Asynchronous Executors ................................................................................................................... 248
 Section 45.3: Using UVLoop ..................................................................................................................................... 249
Section 45.4: Synchronization Primitive: Event ....................................................................................................... 249
Section 45.5: A Simple Websocket .......................................................................................................................... 250
Section 45.6: Common Misconception about asyncio .......................................................................................... 250
Chapter 46: Random module ............................................................................................................................. 252
Section 46.1: Creating a random user password ................................................................................................... 252
Section 46.2: Create cryptographically secure random numbers ....................................................................... 252
Section 46.3: Random and sequences: shue, choice and sample .................................................................... 253
Section 46.4: Creating random integers and floats: randint, randrange, random, and uniform ...................... 254
Section 46.5: Reproducible random numbers: Seed and State ............................................................................ 255
Section 46.6: Random Binary Decision ................................................................................................................... 256
Chapter 47: Functools Module .......................................................................................................................... 257
Section 47.1: partial ................................................................................................................................................... 257
Section 47.2: cmp_to_key ....................................................................................................................................... 257
Section 47.3: lru_cache ............................................................................................................................................. 257
Section 47.4: total_ordering ..................................................................................................................................... 258
Section 47.5: reduce .................................................................................................................................................. 259
Chapter 48: The dis module ............................................................................................................................... 260
Section 48.1: What is Python bytecode? ................................................................................................................. 260
Section 48.2: Constants in the dis module .............................................................................................................. 260
Section 48.3: Disassembling modules ..................................................................................................................... 260
Chapter 49: The base64 Module ...................................................................................................................... 262
Section 49.1: Encoding and Decoding Base64 ....................................................................................................... 263
Section 49.2: Encoding and Decoding Base32 ....................................................................................................... 264
Section 49.3: Encoding and Decoding Base16 ........................................................................................................ 264
Section 49.4: Encoding and Decoding ASCII85 ...................................................................................................... 265
Section 49.5: Encoding and Decoding Base85 ....................................................................................................... 265
Chapter 50: Queue Module .................................................................................................................................. 267
Section 50.1: Simple example ................................................................................................................................... 267
Chapter 51: Deque Module ................................................................................................................................... 268
Section 51.1: Basic deque using ................................................................................................................................ 268
Section 51.2: Available methods in deque ............................................................................................................... 268
Section 51.3: limit deque size .................................................................................................................................... 269
Section 51.4: Breadth First Search ........................................................................................................................... 269
Chapter 52: Usage of "pip" module: PyPI Package Manager ............................................................ 270
Section 52.1: Example use of commands ............................................................................................................... 270
Section 52.2: Handling ImportError Exception ....................................................................................................... 270
Section 52.3: Force install ......................................................................................................................................... 271
Chapter 53: Webbrowser Module ..................................................................................................................... 272
Section 53.1: Opening a URL with Default Browser ............................................................................................... 272
Section 53.2: Opening a URL with Dierent Browsers .......................................................................................... 273
Chapter 54: pyautogui module ......................................................................................................................... 274
Section 54.1: Mouse Functions .................................................................................................................................. 274
Section 54.2: Keyboard Functions ........................................................................................................................... 274
Section 54.3: ScreenShot And Image Recognition ................................................................................................. 274
Chapter 55: Plotting with Matplotlib .............................................................................................................. 275
Section 55.1: Plots with Common X-axis but dierent Y-axis : Using twinx() ....................................................... 275
Section 55.2: Plots with common Y-axis and dierent X-axis using twiny() ....................................................... 276
Section 55.3: A Simple Plot in Matplotlib ................................................................................................................. 278
 Section 55.4: Adding more features to a simple plot : axis labels, title, axis ticks, grid, and legend ................ 279
Section 55.5: Making multiple plots in the same figure by superimposition similar to MATLAB ...................... 280
Section 55.6: Making multiple Plots in the same figure using plot superimposition with separate plot
commands ......................................................................................................................................................... 281
Chapter 56: Comparisons ..................................................................................................................................... 283
Section 56.1: Chain Comparisons ............................................................................................................................. 283
Section 56.2: Comparison by `is` vs `==` ................................................................................................................... 284
Section 56.3: Greater than or less than ................................................................................................................... 285
Section 56.4: Not equal to ........................................................................................................................................ 285
Section 56.5: Equal To ............................................................................................................................................... 286
Section 56.6: Comparing Objects ............................................................................................................................ 286
Chapter 57: Sorting, Minimum and Maximum ............................................................................................ 288
Section 57.1: Make custom classes orderable ........................................................................................................ 288
Section 57.2: Special case: dictionaries ................................................................................................................... 290
Section 57.3: Using the key argument .................................................................................................................... 291
Section 57.4: Default Argument to max, min .......................................................................................................... 291
Section 57.5: Getting a sorted sequence ................................................................................................................ 292
Section 57.6: Extracting N largest or N smallest items from an iterable ............................................................ 292
Section 57.7: Getting the minimum or maximum of several values .................................................................... 293
Section 57.8: Minimum and Maximum of a sequence ........................................................................................... 293
Chapter 58: Variable Scope and Binding ..................................................................................................... 294
Section 58.1: Nonlocal Variables .............................................................................................................................. 294
Section 58.2: Global Variables ................................................................................................................................. 294
Section 58.3: Local Variables ................................................................................................................................... 295
Section 58.4: The del command .............................................................................................................................. 296
Section 58.5: Functions skip class scope when looking up names ...................................................................... 297
Section 58.6: Local vs Global Scope ........................................................................................................................ 298
Section 58.7: Binding Occurrence ............................................................................................................................ 300
Chapter 59: Basic Input and Output ............................................................................................................... 301
Section 59.1: Using the print function ...................................................................................................................... 301
Section 59.2: Input from a File ................................................................................................................................. 301
Section 59.3: Read from stdin .................................................................................................................................. 303
Section 59.4: Using input() and raw_input() .......................................................................................................... 303
Section 59.5: Function to prompt user for a number ............................................................................................ 303
Section 59.6: Printing a string without a newline at the end ................................................................................. 304
Chapter 60: Files & Folders I/O ......................................................................................................................... 306
Section 60.1: File modes ............................................................................................................................................ 306
Section 60.2: Reading a file line-by-line ................................................................................................................. 307
Section 60.3: Iterate files (recursively) .................................................................................................................... 308
Section 60.4: Getting the full contents of a file ...................................................................................................... 308
Section 60.5: Writing to a file ................................................................................................................................... 309
Section 60.6: Check whether a file or path exists .................................................................................................. 310
Section 60.7: Random File Access Using mmap .................................................................................................... 311
Section 60.8: Replacing text in a file ....................................................................................................................... 311
Section 60.9: Checking if a file is empty ................................................................................................................. 311
Section 60.10: Read a file between a range of lines .............................................................................................. 312
Section 60.11: Copy a directory tree ........................................................................................................................ 312
Section 60.12: Copying contents of one file to a dierent file .............................................................................. 312
Chapter 61: Indexing and Slicing ....................................................................................................................... 313
Section 61.1: Basic Slicing .......................................................................................................................................... 313
 Section 61.2: Reversing an object ............................................................................................................................ 314
Section 61.3: Slice assignment .................................................................................................................................. 314
Section 61.4: Making a shallow copy of an array .................................................................................................. 314
Section 61.5: Indexing custom classes: __getitem__, __setitem__ and __delitem__ .................................... 315
Section 61.6: Basic Indexing ...................................................................................................................................... 316
Chapter 62: Generators ......................................................................................................................................... 317
Section 62.1: Introduction .......................................................................................................................................... 317
Section 62.2: Infinite sequences ............................................................................................................................... 319
Section 62.3: Sending objects to a generator ........................................................................................................ 320
Section 62.4: Yielding all values from another iterable ......................................................................................... 321
Section 62.5: Iteration ............................................................................................................................................... 321
Section 62.6: The next() function ............................................................................................................................. 321
Section 62.7: Coroutines ........................................................................................................................................... 322
Section 62.8: Refactoring list-building code ........................................................................................................... 322
Section 62.9: Yield with recursion: recursively listing all files in a directory ........................................................ 323
Section 62.10: Generator expressions ..................................................................................................................... 324
Section 62.11: Using a generator to find Fibonacci Numbers ............................................................................... 324
Section 62.12: Searching ........................................................................................................................................... 324
Section 62.13: Iterating over generators in parallel ............................................................................................... 325
Chapter 63: Reduce ................................................................................................................................................. 326
Section 63.1: Overview ............................................................................................................................................... 326
Section 63.2: Using reduce ....................................................................................................................................... 326
Section 63.3: Cumulative product ............................................................................................................................ 327
Section 63.4: Non short-circuit variant of any/all .................................................................................................. 327
Chapter 64: Map Function ................................................................................................................................... 328
Section 64.1: Basic use of map, itertools.imap and future_builtins.map ............................................................. 328
Section 64.2: Mapping each value in an iterable ................................................................................................... 328
Section 64.3: Mapping values of dierent iterables .............................................................................................. 329
Section 64.4: Transposing with Map: Using "None" as function argument (python 2.x only) .......................... 331
Section 64.5: Series and Parallel Mapping .............................................................................................................. 331
Chapter 65: Exponentiation ................................................................................................................................. 334
Section 65.1: Exponentiation using builtins: ** and pow() ....................................................................................... 334
Section 65.2: Square root: math.sqrt() and cmath.sqrt ......................................................................................... 334
Section 65.3: Modular exponentiation: pow() with 3 arguments .......................................................................... 335
Section 65.4: Computing large integer roots ......................................................................................................... 335
Section 65.5: Exponentiation using the math module: math.pow() ..................................................................... 336
Section 65.6: Exponential function: math.exp() and cmath.exp() ......................................................................... 337
Section 65.7: Exponential function minus 1: math.expm1() .................................................................................... 337
Section 65.8: Magic methods and exponentiation: builtin, math and cmath ...................................................... 338
Section 65.9: Roots: nth-root with fractional exponents ....................................................................................... 339
Chapter 66: Searching ............................................................................................................................................ 340
Section 66.1: Searching for an element ................................................................................................................... 340
Section 66.2: Searching in custom classes: __contains__ and __iter__ .......................................................... 340
Section 66.3: Getting the index for strings: str.index(), str.rindex() and str.find(), str.rfind() .............................. 341
Section 66.4: Getting the index list and tuples: list.index(), tuple.index() .............................................................. 342
Section 66.5: Searching key(s) for a value in dict .................................................................................................. 342
Section 66.6: Getting the index for sorted sequences: bisect.bisect_left() .......................................................... 343
Section 66.7: Searching nested sequences ............................................................................................................. 343
Chapter 67: Counting .............................................................................................................................................. 345
Section 67.1: Counting all occurence of all items in an iterable: collections.Counter ......................................... 345
 Section 67.2: Getting the most common value(-s): collections.Counter.most_common() ................................ 345
Section 67.3: Counting the occurrences of one item in a sequence: list.count() and tuple.count() .................. 345
Section 67.4: Counting the occurrences of a substring in a string: str.count() ................................................... 346
Section 67.5: Counting occurences in numpy array .............................................................................................. 346
Chapter 68: Manipulating XML .......................................................................................................................... 347
Section 68.1: Opening and reading using an ElementTree ................................................................................... 347
Section 68.2: Create and Build XML Documents .................................................................................................... 347
Section 68.3: Modifying an XML File ........................................................................................................................ 348
Section 68.4: Searching the XML with XPath .......................................................................................................... 348
Section 68.5: Opening and reading large XML files using iterparse (incremental parsing) ............................. 349
Chapter 69: Parallel computation .................................................................................................................... 350
Section 69.1: Using the multiprocessing module to parallelise tasks ................................................................... 350
Section 69.2: Using a C-extension to parallelize tasks .......................................................................................... 350
Section 69.3: Using Parent and Children scripts to execute code in parallel ...................................................... 350
Section 69.4: Using PyPar module to parallelize ................................................................................................... 351
Chapter 70: Processes and Threads ............................................................................................................... 352
Section 70.1: Global Interpreter Lock ....................................................................................................................... 352
Section 70.2: Running in Multiple Threads .............................................................................................................. 353
Section 70.3: Running in Multiple Processes ........................................................................................................... 354
Section 70.4: Sharing State Between Threads ....................................................................................................... 354
Section 70.5: Sharing State Between Processes .................................................................................................... 355
Chapter 71: Multithreading .................................................................................................................................. 356
Section 71.1: Basics of multithreading ...................................................................................................................... 356
Section 71.2: Communicating between threads ..................................................................................................... 357
Section 71.3: Creating a worker pool ....................................................................................................................... 358
Section 71.4: Advanced use of multithreads ........................................................................................................... 358
Section 71.5: Stoppable Thread with a while Loop ................................................................................................. 360
Chapter 72: Writing extensions ......................................................................................................................... 361
Section 72.1: Hello World with C Extension ............................................................................................................. 361
Section 72.2: C Extension Using c++ and Boost ..................................................................................................... 361
Section 72.3: Passing an open file to C Extensions ................................................................................................ 363
Chapter 73: Unit Testing ....................................................................................................................................... 364
Section 73.1: Test Setup and Teardown within a unittest.TestCase ..................................................................... 364
Section 73.2: Asserting on Exceptions ..................................................................................................................... 364
Section 73.3: Testing Exceptions .............................................................................................................................. 365
Section 73.4: Choosing Assertions Within Unittests ............................................................................................... 366
Section 73.5: Unit tests with pytest .......................................................................................................................... 367
Section 73.6: Mocking functions with unittest.mock.create_autospec ................................................................ 370
Chapter 74: Regular Expressions (Regex) ................................................................................................... 372
Section 74.1: Matching the beginning of a string ................................................................................................... 372
Section 74.2: Searching ............................................................................................................................................ 373
Section 74.3: Precompiled patterns ......................................................................................................................... 373
Section 74.4: Flags .................................................................................................................................................... 374
Section 74.5: Replacing ............................................................................................................................................. 375
Section 74.6: Find All Non-Overlapping Matches ................................................................................................... 375
Section 74.7: Checking for allowed characters ...................................................................................................... 376
Section 74.8: Splitting a string using regular expressions ..................................................................................... 376
Section 74.9: Grouping .............................................................................................................................................. 376
Section 74.10: Escaping Special Characters ........................................................................................................... 377
 Section 74.11: Match an expression only in specific locations ............................................................................... 378
Section 74.12: Iterating over matches using `re.finditer` ........................................................................................ 379
Chapter 75: Incompatibilities moving from Python 2 to Python 3 .................................................. 380
Section 75.1: Integer Division .................................................................................................................................... 380
Section 75.2: Unpacking Iterables ........................................................................................................................... 381
Section 75.3: Strings: Bytes versus Unicode ........................................................................................................... 383
Section 75.4: Print statement vs. Print function ...................................................................................................... 385
Section 75.5: Dierences between range and xrange functions ......................................................................... 386
Section 75.6: Raising and handling Exceptions ...................................................................................................... 387
Section 75.7: Leaked variables in list comprehension ........................................................................................... 389
Section 75.8: True, False and None ......................................................................................................................... 390
Section 75.9: User Input ............................................................................................................................................ 390
Section 75.10: Comparison of dierent types ........................................................................................................ 390
Section 75.11: .next() method on iterators renamed .............................................................................................. 391
Section 75.12: filter(), map() and zip() return iterators instead of sequences .................................................... 392
Section 75.13: Renamed modules ............................................................................................................................ 392
Section 75.14: Removed operators <> and ``, synonymous with != and repr() .................................................... 393
Section 75.15: long vs. int .......................................................................................................................................... 393
Section 75.16: All classes are "new-style classes" in Python 3 .............................................................................. 394
Section 75.17: Reduce is no longer a built-in .......................................................................................................... 395
Section 75.18: Absolute/Relative Imports ............................................................................................................... 395
Section 75.19: map() .................................................................................................................................................. 397
Section 75.20: The round() function tie-breaking and return type ...................................................................... 398
Section 75.21: File I/O ................................................................................................................................................ 399
Section 75.22: cmp function removed in Python 3 ................................................................................................ 399
Section 75.23: Octal Constants ................................................................................................................................ 400
Section 75.24: Return value when writing to a file object ..................................................................................... 400
Section 75.25: exec statement is a function in Python 3 ....................................................................................... 400
Section 75.26: encode/decode to hex no longer available .................................................................................. 401
Section 75.27: Dictionary method changes ............................................................................................................ 401
Section 75.28: Class Boolean Value ........................................................................................................................ 402
Section 75.29: hasattr function bug in Python 2 .................................................................................................... 403
Chapter 76: Virtual environments .................................................................................................................... 404
Section 76.1: Creating and using a virtual environment ........................................................................................ 404
Section 76.2: Specifying specific python version to use in script on Unix/Linux ................................................ 406
Section 76.3: Creating a virtual environment for a dierent version of python ................................................. 406
Section 76.4: Making virtual environments using Anaconda ................................................................................ 406
Section 76.5: Managing multiple virtual enviroments with virtualenvwrapper ................................................... 407
Section 76.6: Installing packages in a virtual environment ................................................................................... 408
Section 76.7: Discovering which virtual environment you are using .................................................................... 409
Section 76.8: Checking if running inside a virtual environment ............................................................................ 410
Section 76.9: Using virtualenv with fish shell .......................................................................................................... 410
Chapter 77: Copying data .................................................................................................................................... 412
Section 77.1: Copy a dictionary ................................................................................................................................ 412
Section 77.2: Performing a shallow copy ............................................................................................................... 412
Section 77.3: Performing a deep copy .................................................................................................................... 412
Section 77.4: Performing a shallow copy of a list .................................................................................................. 412
Section 77.5: Copy a set ........................................................................................................................................... 412
Chapter 78: Context Managers (“with” Statement) ............................................................................... 414
Section 78.1: Introduction to context managers and the with statement ............................................................ 414
 Section 78.2: Writing your own context manager ................................................................................................. 414
Section 78.3: Writing your own contextmanager using generator syntax ......................................................... 415
Section 78.4: Multiple context managers ................................................................................................................ 416
Section 78.5: Assigning to a target .......................................................................................................................... 416
Section 78.6: Manage Resources ............................................................................................................................. 417
Chapter 79: Hidden Features ............................................................................................................................. 418
Section 79.1: Operator Overloading ........................................................................................................................ 418
Chapter 80: Unicode and bytes ........................................................................................................................ 419
Section 80.1: Encoding/decoding error handling .................................................................................................. 419
Section 80.2: File I/O ................................................................................................................................................. 419
Section 80.3: Basics ................................................................................................................................................... 420
Chapter 81: The __name__ special variable ............................................................................................ 422
Section 81.1: __name__ == '__main__' ................................................................................................................. 422
Section 81.2: Use in logging ...................................................................................................................................... 422
Section 81.3: function_class_or_module.__name__ ........................................................................................... 422
Chapter 82: Checking Path Existence and Permissions ......................................................................... 424
Section 82.1: Perform checks using os.access ........................................................................................................ 424
Chapter 83: Python Networking ....................................................................................................................... 425
Section 83.1: Creating a Simple Http Server ........................................................................................................... 425
Section 83.2: Creating a TCP server ........................................................................................................................ 425
Section 83.3: Creating a UDP Server ....................................................................................................................... 426
Section 83.4: Start Simple HttpServer in a thread and open the browser .......................................................... 426
Section 83.5: The simplest Python socket client-server example ........................................................................ 427
Chapter 84: The Print Function ......................................................................................................................... 428
Section 84.1: Print basics ........................................................................................................................................... 428
Section 84.2: Print parameters ................................................................................................................................ 429
Chapter 85: os.path ................................................................................................................................................. 431
Section 85.1: Join Paths ............................................................................................................................................ 431
Section 85.2: Path Component Manipulation ......................................................................................................... 431
Section 85.3: Get the parent directory .................................................................................................................... 431
Section 85.4: If the given path exists ....................................................................................................................... 431
Section 85.5: check if the given path is a directory, file, symbolic link, mount point etc ................................... 432
Section 85.6: Absolute Path from Relative Path .................................................................................................... 432
Chapter 86: Creating Python packages ........................................................................................................ 433
Section 86.1: Introduction .......................................................................................................................................... 433
Section 86.2: Uploading to PyPI ............................................................................................................................... 433
Section 86.3: Making package executable ............................................................................................................. 435
Chapter 87: Parsing Command Line arguments ...................................................................................... 437
Section 87.1: Hello world in argparse ...................................................................................................................... 437
Section 87.2: Using command line arguments with argv ..................................................................................... 437
Section 87.3: Setting mutually exclusive arguments with argparse .................................................................... 438
Section 87.4: Basic example with docopt ............................................................................................................... 439
Section 87.5: Custom parser error message with argparse ................................................................................. 439
Section 87.6: Conceptual grouping of arguments with argparse.add_argument_group() ............................. 440
Section 87.7: Advanced example with docopt and docopt_dispatch ................................................................. 441
Chapter 88: HTML Parsing ................................................................................................................................... 443
Section 88.1: Using CSS selectors in BeautifulSoup ............................................................................................... 443
Section 88.2: PyQuery .............................................................................................................................................. 443
Section 88.3: Locate a text after an element in BeautifulSoup ............................................................................ 444
Chapter 89: Subprocess Library ....................................................................................................................... 445
Section 89.1: More flexibility with Popen ................................................................................................................. 445
Section 89.2: Calling External Commands .............................................................................................................. 446
Section 89.3: How to create the command list argument .................................................................................... 446
Chapter 90: setup.py .............................................................................................................................................. 447
Section 90.1: Purpose of setup.py ............................................................................................................................ 447
Section 90.2: Using source control metadata in setup.py .................................................................................... 447
Section 90.3: Adding command line scripts to your python package ................................................................ 448
Section 90.4: Adding installation options ................................................................................................................ 448
Chapter 91: Sockets ................................................................................................................................................. 450
Section 91.1: Raw Sockets on Linux .......................................................................................................................... 450
Section 91.2: Sending data via UDP ......................................................................................................................... 450
Section 91.3: Receiving data via UDP ...................................................................................................................... 451
Section 91.4: Sending data via TCP ......................................................................................................................... 451
Section 91.5: Multi-threaded TCP Socket Server .................................................................................................... 451
Chapter 92: Recursion ............................................................................................................................................ 454
Section 92.1: The What, How, and When of Recursion .......................................................................................... 454
Section 92.2: Tree exploration with recursion ........................................................................................................ 457
Section 92.3: Sum of numbers from 1 to n .............................................................................................................. 458
Section 92.4: Increasing the Maximum Recursion Depth ...................................................................................... 458
Section 92.5: Tail Recursion - Bad Practice ............................................................................................................ 459
Section 92.6: Tail Recursion Optimization Through Stack Introspection ............................................................ 459
Chapter 93: Type Hints .......................................................................................................................................... 461
Section 93.1: Adding types to a function ................................................................................................................. 461
Section 93.2: NamedTuple ....................................................................................................................................... 462
Section 93.3: Generic Types ..................................................................................................................................... 462
Section 93.4: Variables and Attributes .................................................................................................................... 462
Section 93.5: Class Members and Methods ............................................................................................................ 463
Section 93.6: Type hints for keyword arguments .................................................................................................. 463
Chapter 94: pip: PyPI Package Manager ..................................................................................................... 464
Section 94.1: Install Packages .................................................................................................................................. 464
Section 94.2: To list all packages installed using `pip` ........................................................................................... 464
Section 94.3: Upgrade Packages ............................................................................................................................. 464
Section 94.4: Uninstall Packages ............................................................................................................................. 465
Section 94.5: Updating all outdated packages on Linux ...................................................................................... 465
Section 94.6: Updating all outdated packages on Windows ................................................................................ 465
Section 94.7: Create a requirements.txt file of all packages on the system ....................................................... 465
Section 94.8: Using a certain Python version with pip .......................................................................................... 466
Section 94.9: Create a requirements.txt file of packages only in the current virtualenv .................................. 466
Section 94.10: Installing packages not yet on pip as wheels ................................................................................ 467
Chapter 95: Exceptions .......................................................................................................................................... 470
Section 95.1: Catching Exceptions ............................................................................................................................ 470
Section 95.2: Do not catch everything! ................................................................................................................... 470
Section 95.3: Re-raising exceptions ......................................................................................................................... 471
Section 95.4: Catching multiple exceptions ............................................................................................................ 471
Section 95.5: Exception Hierarchy ........................................................................................................................... 472
Section 95.6: Else ....................................................................................................................................................... 474
Section 95.7: Raising Exceptions .............................................................................................................................. 474
Section 95.8: Creating custom exception types ..................................................................................................... 475
 Section 95.9: Practical examples of exception handling ....................................................................................... 475
Section 95.10: Exceptions are Objects too .............................................................................................................. 476
Section 95.11: Running clean-up code with finally .................................................................................................. 476
Section 95.12: Chain exceptions with raise from .................................................................................................... 477
Chapter 96: Web scraping with Python ......................................................................................................... 478
Section 96.1: Scraping using the Scrapy framework ............................................................................................. 478
Section 96.2: Scraping using Selenium WebDriver ................................................................................................ 478
Section 96.3: Basic example of using requests and lxml to scrape some data ................................................. 479
Section 96.4: Maintaining web-scraping session with requests ........................................................................... 479
Section 96.5: Scraping using BeautifulSoup4 ......................................................................................................... 480
Section 96.6: Simple web content download with urllib.request .......................................................................... 480
Section 96.7: Modify Scrapy user agent ................................................................................................................. 480
Section 96.8: Scraping with curl ............................................................................................................................... 480
Chapter 97: Distribution ........................................................................................................................................ 482
Section 97.1: py2app ................................................................................................................................................. 482
Section 97.2: cx_Freeze ............................................................................................................................................ 483
Chapter 98: Property Objects ............................................................................................................................ 484
Section 98.1: Using the @property decorator for read-write properties ............................................................ 484
Section 98.2: Using the @property decorator ....................................................................................................... 484
Section 98.3: Overriding just a getter, setter or a deleter of a property object ................................................. 485
Section 98.4: Using properties without decorators ............................................................................................... 485
Chapter 99: Overloading ....................................................................................................................................... 488
Section 99.1: Operator overloading ......................................................................................................................... 488
Section 99.2: Magic/Dunder Methods ..................................................................................................................... 489
Section 99.3: Container and sequence types ......................................................................................................... 490
Section 99.4: Callable types ..................................................................................................................................... 491
Section 99.5: Handling unimplemented behaviour ................................................................................................ 491
Chapter 100: Debugging ....................................................................................................................................... 493
Section 100.1: Via IPython and ipdb ......................................................................................................................... 493
Section 100.2: The Python Debugger: Step-through Debugging with _pdb_ .................................................... 493
Section 100.3: Remote debugger ............................................................................................................................. 495
Chapter 101: Reading and Writing CSV .......................................................................................................... 496
Section 101.1: Using pandas ...................................................................................................................................... 496
Section 101.2: Writing a TSV file ............................................................................................................................... 496
Chapter 102: Dynamic code execution with `exec` and `eval` ............................................................. 497
Section 102.1: Executing code provided by untrusted user using exec, eval, or ast.literal_eval ....................... 497
Section 102.2: Evaluating a string containing a Python literal with ast.literal_eval ........................................... 497
Section 102.3: Evaluating statements with exec ..................................................................................................... 497
Section 102.4: Evaluating an expression with eval ................................................................................................. 498
Section 102.5: Precompiling an expression to evaluate it multiple times ............................................................ 498
Section 102.6: Evaluating an expression with eval using custom globals ........................................................... 498
Chapter 103: PyInstaller - Distributing Python Code .............................................................................. 499
Section 103.1: Installation and Setup ........................................................................................................................ 499
Section 103.2: Using Pyinstaller ................................................................................................................................ 499
Section 103.3: Bundling to One Folder ..................................................................................................................... 500
Section 103.4: Bundling to a Single File ................................................................................................................... 500
Chapter 104: Iterables and Iterators ............................................................................................................. 501
Section 104.1: Iterator vs Iterable vs Generator ...................................................................................................... 501
Section 104.2: Extract values one by one ............................................................................................................... 502
 Section 104.3: Iterating over entire iterable ............................................................................................................ 502
Section 104.4: Verify only one element in iterable ................................................................................................. 502
Section 104.5: What can be iterable ........................................................................................................................ 503
Section 104.6: Iterator isn't reentrant! ...................................................................................................................... 503
Chapter 105: Data Visualization with Python ............................................................................................. 504
Section 105.1: Seaborn ............................................................................................................................................... 504
Section 105.2: Matplotlib ........................................................................................................................................... 506
Section 105.3: Plotly ................................................................................................................................................... 507
Section 105.4: MayaVI ............................................................................................................................................... 509
Chapter 106: The Interpreter (Command Line Console) ....................................................................... 511
Section 106.1: Getting general help .......................................................................................................................... 511
Section 106.2: Referring to the last expression ...................................................................................................... 511
Section 106.3: Opening the Python console ............................................................................................................ 512
Section 106.4: The PYTHONSTARTUP variable ...................................................................................................... 512
Section 106.5: Command line arguments ............................................................................................................... 512
Section 106.6: Getting help about an object ........................................................................................................... 513
Chapter 107: *args and **kwargs ...................................................................................................................... 515
Section 107.1: Using **kwargs when writing functions ............................................................................................ 515
Section 107.2: Using *args when writing functions ................................................................................................. 515
Section 107.3: Populating kwarg values with a dictionary .................................................................................... 516
Section 107.4: Keyword-only and Keyword-required arguments ........................................................................ 516
Section 107.5: Using **kwargs when calling functions ........................................................................................... 516
Section 107.6: **kwargs and default values ............................................................................................................ 516
Section 107.7: Using *args when calling functions ................................................................................................. 517
Chapter 108: Garbage Collection ...................................................................................................................... 518
Section 108.1: Reuse of primitive objects ................................................................................................................ 518
Section 108.2: Eects of the del command ............................................................................................................ 518
Section 108.3: Reference Counting .......................................................................................................................... 519
Section 108.4: Garbage Collector for Reference Cycles ....................................................................................... 519
Section 108.5: Forcefully deallocating objects ....................................................................................................... 520
Section 108.6: Viewing the refcount of an object ................................................................................................... 521
Section 108.7: Do not wait for the garbage collection to clean up ...................................................................... 521
Section 108.8: Managing garbage collection ......................................................................................................... 521
Chapter 109: Pickle data serialisation ............................................................................................................ 523
Section 109.1: Using Pickle to serialize and deserialize an object ......................................................................... 523
Section 109.2: Customize Pickled Data ................................................................................................................... 523
Chapter 110: urllib ..................................................................................................................................................... 525
Section 110.1: HTTP GET ............................................................................................................................................ 525
Section 110.2: HTTP POST ......................................................................................................................................... 525
Section 110.3: Decode received bytes according to content type encoding ....................................................... 526
Chapter 111: Binary Data ....................................................................................................................................... 527
Section 111.1: Format a list of values into a byte object ......................................................................................... 527
Section 111.2: Unpack a byte object according to a format string ....................................................................... 527
Section 111.3: Packing a structure ............................................................................................................................. 527
Chapter 112: Python and Excel ........................................................................................................................... 529
Section 112.1: Read the excel data using xlrd module ............................................................................................ 529
Section 112.2: Format Excel files with xlsxwriter ..................................................................................................... 529
Section 112.3: Put list data into a Excel's file ............................................................................................................ 530
Section 112.4: OpenPyXL ........................................................................................................................................... 531
 Section 112.5: Create excel charts with xlsxwriter ................................................................................................... 531
Chapter 113: Idioms .................................................................................................................................................. 534
Section 113.1: Dictionary key initializations .............................................................................................................. 534
Section 113.2: Switching variables ............................................................................................................................ 534
Section 113.3: Use truth value testing ....................................................................................................................... 534
Section 113.4: Test for "__main__" to avoid unexpected code execution .......................................................... 535
Chapter 114: Method Overriding ....................................................................................................................... 536
Section 114.1: Basic method overriding .................................................................................................................... 536
Chapter 115: Data Serialization .......................................................................................................................... 537
Section 115.1: Serialization using JSON .................................................................................................................... 537
Section 115.2: Serialization using Pickle ................................................................................................................... 537
Chapter 116: Python concurrency ..................................................................................................................... 539
Section 116.1: The multiprocessing module ............................................................................................................. 539
Section 116.2: The threading module ....................................................................................................................... 540
Section 116.3: Passing data between multiprocessing processes ........................................................................ 540
Chapter 117: Introduction to RabbitMQ using AMQPStorm ................................................................. 542
Section 117.1: How to consume messages from RabbitMQ ................................................................................... 542
Section 117.2: How to publish messages to RabbitMQ .......................................................................................... 543
Section 117.3: How to create a delayed queue in RabbitMQ ................................................................................. 543
Chapter 118: Descriptor .......................................................................................................................................... 546
Section 118.1: Simple descriptor ................................................................................................................................ 546
Section 118.2: Two-way conversions ....................................................................................................................... 547
Chapter 119: Multiprocessing ............................................................................................................................... 548
Section 119.1: Running Two Simple Processes ........................................................................................................ 548
Section 119.2: Using Pool and Map .......................................................................................................................... 548
Chapter 120: tempfile NamedTemporaryFile ............................................................................................ 550
Section 120.1: Create (and write to a) known, persistant temporary file ............................................................. 550
Chapter 121: Input, Subset and Output External Data Files using Pandas .................................. 551
Section 121.1: Basic Code to Import, Subset and Write External Data Files Using Pandas ................................ 551
Chapter 122: Writing to CSV from String or List ....................................................................................... 553
Section 122.1: Basic Write Example .......................................................................................................................... 553
Section 122.2: Appending a String as a newline in a CSV file ............................................................................... 553
Chapter 123: Unzipping Files ................................................................................................................................ 554
Section 123.1: Using Python ZipFile.extractall() to decompress a ZIP file ........................................................... 554
Section 123.2: Using Python TarFile.extractall() to decompress a tarball ........................................................... 554
Chapter 124: Working with ZIP archives ....................................................................................................... 555
Section 124.1: Examining Zipfile Contents ............................................................................................................... 555
Section 124.2: Opening Zip Files .............................................................................................................................. 555
Section 124.3: Extracting zip file contents to a directory ....................................................................................... 556
Section 124.4: Creating new archives ...................................................................................................................... 556
Chapter 125: Stack ................................................................................................................................................... 557
Section 125.1: Creating a Stack class with a List Object ........................................................................................ 557
Section 125.2: Parsing Parentheses ......................................................................................................................... 558
Chapter 126: Profiling ............................................................................................................................................. 559
Section 126.1: %%timeit and %timeit in IPython ...................................................................................................... 559
Section 126.2: Using cProfile (Preferred Profiler) ................................................................................................... 559
Section 126.3: timeit() function ................................................................................................................................. 559
Section 126.4: timeit command line ......................................................................................................................... 560
 Section 126.5: line_profiler in command line .......................................................................................................... 560
Chapter 127: User-Defined Methods ............................................................................................................... 561
Section 127.1: Creating user-defined method objects ............................................................................................ 561
Section 127.2: Turtle example ................................................................................................................................... 562
Chapter 128: Working around the Global Interpreter Lock (GIL) ..................................................... 563
Section 128.1: Multiprocessing.Pool .......................................................................................................................... 563
Section 128.2: Cython nogil: ...................................................................................................................................... 564
Chapter 129: Deployment ..................................................................................................................................... 565
Section 129.1: Uploading a Conda Package ........................................................................................................... 565
Chapter 130: Logging .............................................................................................................................................. 567
Section 130.1: Introduction to Python Logging ....................................................................................................... 567
Section 130.2: Logging exceptions ........................................................................................................................... 568
Chapter 131: Database Access ............................................................................................................................ 571
Section 131.1: SQLite ................................................................................................................................................... 571
Section 131.2: Accessing MySQL database using MySQLdb ................................................................................. 576
Section 131.3: Connection .......................................................................................................................................... 577
Section 131.4: PostgreSQL Database access using psycopg2 .............................................................................. 578
Section 131.5: Oracle database ................................................................................................................................ 579
Section 131.6: Using sqlalchemy ............................................................................................................................... 580
Chapter 132: Python HTTP Server .................................................................................................................... 582
Section 132.1: Running a simple HTTP server ......................................................................................................... 582
Section 132.2: Serving files ........................................................................................................................................ 582
Section 132.3: Basic handling of GET, POST, PUT using BaseHTTPRequestHandler ......................................... 583
Section 132.4: Programmatic API of SimpleHTTPServer ....................................................................................... 584
Chapter 133: Web Server Gateway Interface (WSGI) ............................................................................. 586
Section 133.1: Server Object (Method) ..................................................................................................................... 586
Chapter 134: Python Server Sent Events ..................................................................................................... 587
Section 134.1: Flask SSE ............................................................................................................................................. 587
Section 134.2: Asyncio SSE ........................................................................................................................................ 587
Chapter 135: Connecting Python to SQL Server ....................................................................................... 588
Section 135.1: Connect to Server, Create Table, Query Data ................................................................................ 588
Chapter 136: Sockets And Message Encryption/Decryption Between Client and Server
............................................................................................................................................................................................ 589
Section 136.1: Server side Implementation .............................................................................................................. 589
Section 136.2: Client side Implementation ............................................................................................................... 591
Chapter 137: Alternatives to switch statement from other languages ........................................ 593
Section 137.1: Use what the language oers: the if/else construct ...................................................................... 593
Section 137.2: Use a dict of functions ...................................................................................................................... 593
Section 137.3: Use class introspection ..................................................................................................................... 594
Section 137.4: Using a context manager ................................................................................................................. 595
Chapter 138: List Comprehensions ................................................................................................................... 596
Section 138.1: Conditional List Comprehensions ..................................................................................................... 596
Section 138.2: List Comprehensions with Nested Loops ........................................................................................ 597
Section 138.3: Refactoring filter and map to list comprehensions ....................................................................... 598
Section 138.4: Nested List Comprehensions ........................................................................................................... 599
Section 138.5: Iterate two or more list simultaneously within list comprehension .............................................. 600
Chapter 139: List destructuring (aka packing and unpacking) ......................................................... 601
Section 139.1: Destructuring assignment ................................................................................................................. 601
 Section 139.2: Packing function arguments ............................................................................................................ 602
Section 139.3: Unpacking function arguments ....................................................................................................... 604
Chapter 140: Accessing Python source code and bytecode .............................................................. 605
Section 140.1: Display the bytecode of a function ................................................................................................. 605
Section 140.2: Display the source code of an object ............................................................................................. 605
Section 140.3: Exploring the code object of a function .......................................................................................... 606
Chapter 141: Mixins ................................................................................................................................................... 607
Section 141.1: Mixin ..................................................................................................................................................... 607
Section 141.2: Overriding Methods in Mixins ............................................................................................................ 608
Chapter 142: Attribute Access ............................................................................................................................ 609
Section 142.1: Basic Attribute Access using the Dot Notation ............................................................................... 609
Section 142.2: Setters, Getters & Properties ............................................................................................................ 609
Chapter 143: ArcPy .................................................................................................................................................. 611
Section 143.1: Printing one field's value for all rows of feature class in file geodatabase using Search
Cursor ................................................................................................................................................................. 611
Section 143.2: createDissolvedGDB to create a file gdb on the workspace ....................................................... 611
Chapter 144: Abstract Base Classes (abc) .................................................................................................. 612
Section 144.1: Setting the ABCMeta metaclass ....................................................................................................... 612
Section 144.2: Why/How to use ABCMeta and @abstractmethod ...................................................................... 612
Chapter 145: Plugin and Extension Classes ................................................................................................. 614
Section 145.1: Mixins ................................................................................................................................................... 614
Section 145.2: Plugins with Customized Classes ..................................................................................................... 615
Chapter 146: Websockets ..................................................................................................................................... 617
Section 146.1: Simple Echo with aiohttp ................................................................................................................... 617
Section 146.2: Wrapper Class with aiohttp .............................................................................................................. 617
Section 146.3: Using Autobahn as a Websocket Factory ...................................................................................... 618
Chapter 147: Immutable datatypes(int, float, str, tuple and frozensets) .................................. 620
Section 147.1: Individual characters of strings are not assignable ....................................................................... 620
Section 147.2: Tuple's individual members aren't assignable ............................................................................... 620
Section 147.3: Frozenset's are immutable and not assignable ............................................................................. 620
Chapter 148: String representations of class instances: __str__ and __repr__
methods ........................................................................................................................................................................ 621
Section 148.1: Motivation ........................................................................................................................................... 621
Section 148.2: Both methods implemented, eval-round-trip style __repr__() .................................................. 625
Chapter 149: Polymorphism ................................................................................................................................ 626
Section 149.1: Duck Typing ....................................................................................................................................... 626
Section 149.2: Basic Polymorphism ......................................................................................................................... 626
Chapter 150: Non-ocial Python implementations ............................................................................... 629
Section 150.1: IronPython .......................................................................................................................................... 629
Section 150.2: Jython ................................................................................................................................................ 629
Section 150.3: Transcrypt ......................................................................................................................................... 630
Chapter 151: 2to3 tool ............................................................................................................................................. 633
Section 151.1: Basic Usage ......................................................................................................................................... 633
Chapter 152: Abstract syntax tree ................................................................................................................... 635
Section 152.1: Analyze functions in a python script ................................................................................................ 635
Chapter 153: Unicode .............................................................................................................................................. 637
Section 153.1: Encoding and decoding .................................................................................................................... 637
Chapter 154: Python Serial Communication (pyserial) ......................................................................... 638
 Section 154.1: Initialize serial device ......................................................................................................................... 638
Section 154.2: Read from serial port ....................................................................................................................... 638
Section 154.3: Check what serial ports are available on your machine .............................................................. 638
Chapter 155: Neo4j and Cypher using Py2Neo ......................................................................................... 640
Section 155.1: Adding Nodes to Neo4j Graph .......................................................................................................... 640
Section 155.2: Importing and Authenticating .......................................................................................................... 640
Section 155.3: Adding Relationships to Neo4j Graph ............................................................................................. 640
Section 155.4: Query 1 : Autocomplete on News Titles .......................................................................................... 640
Section 155.5: Query 2 : Get News Articles by Location on a particular date ..................................................... 641
Section 155.6: Cypher Query Samples .................................................................................................................... 641
Chapter 156: Basic Curses with Python .......................................................................................................... 642
Section 156.1: The wrapper() helper function ......................................................................................................... 642
Section 156.2: Basic Invocation Example ................................................................................................................ 642
Chapter 157: Performance optimization ....................................................................................................... 643
Section 157.1: Code profiling ..................................................................................................................................... 643
Chapter 158: Templates in python ................................................................................................................... 645
Section 158.1: Simple data output program using template ................................................................................. 645
Section 158.2: Changing delimiter ............................................................................................................................ 645
Chapter 159: Pillow ................................................................................................................................................... 646
Section 159.1: Read Image File ................................................................................................................................. 646
Section 159.2: Convert files to JPEG ........................................................................................................................ 646
Chapter 160: The pass statement .................................................................................................................... 647
Section 160.1: Ignore an exception ........................................................................................................................... 647
Section 160.2: Create a new Exception that can be caught .................................................................................. 647
Chapter 161: py.test ................................................................................................................................................. 648
Section 161.1: Setting up py.test ................................................................................................................................ 648
Section 161.2: Intro to Test Fixtures .......................................................................................................................... 648
Section 161.3: Failing Tests ........................................................................................................................................ 651
Chapter 162: Heapq ................................................................................................................................................. 653
Section 162.1: Largest and smallest items in a collection ...................................................................................... 653
Section 162.2: Smallest item in a collection ............................................................................................................ 653
Chapter 163: tkinter ................................................................................................................................................. 655
Section 163.1: Geometry Managers .......................................................................................................................... 655
Section 163.2: A minimal tkinter Application ........................................................................................................... 656
Chapter 164: CLI subcommands with precise help output .................................................................. 658
Section 164.1: Native way (no libraries) ................................................................................................................... 658
Section 164.2: argparse (default help formatter) .................................................................................................. 658
Section 164.3: argparse (custom help formatter) .................................................................................................. 659
Chapter 165: PostgreSQL ...................................................................................................................................... 661
Section 165.1: Getting Started ................................................................................................................................... 661
Chapter 166: Python Persistence ...................................................................................................................... 662
Section 166.1: Python Persistence ............................................................................................................................ 662
Section 166.2: Function utility for save and load .................................................................................................... 663
Chapter 167: Turtle Graphics .............................................................................................................................. 664
Section 167.1: Ninja Twist (Turtle Graphics) ............................................................................................................ 664
Chapter 168: Design Patterns ............................................................................................................................. 665
Section 168.1: Introduction to design patterns and Singleton Pattern ................................................................. 665
Section 168.2: Strategy Pattern ................................................................................................................................ 667
 Section 168.3: Proxy ................................................................................................................................................... 668
Chapter 169: Multidimensional arrays ........................................................................................................... 670
Section 169.1: Lists in lists .......................................................................................................................................... 670
Section 169.2: Lists in lists in lists in.. ........................................................................................................................ 670
Chapter 170: Audio ................................................................................................................................................... 672
Section 170.1: Working with WAV files ..................................................................................................................... 672
Section 170.2: Convert any soundfile with python and mpeg ............................................................................ 672
Section 170.3: Playing Windows' beeps ................................................................................................................... 672
Section 170.4: Audio With Pyglet .............................................................................................................................. 673
Chapter 171: Pyglet .................................................................................................................................................. 674
Section 171.1: Installation of Pyglet ........................................................................................................................... 674
Section 171.2: Hello World in Pyglet ......................................................................................................................... 674
Section 171.3: Playing Sound in Pyglet ..................................................................................................................... 674
Section 171.4: Using Pyglet for OpenGL ................................................................................................................... 674
Section 171.5: Drawing Points Using Pyglet and OpenGL ...................................................................................... 674
Chapter 172: Flask .................................................................................................................................................... 676
Section 172.1: Files and Templates ........................................................................................................................... 676
Section 172.2: The basics .......................................................................................................................................... 676
Section 172.3: Routing URLs ..................................................................................................................................... 677
Section 172.4: HTTP Methods ................................................................................................................................... 678
Section 172.5: Jinja Templating ............................................................................................................................... 678
Section 172.6: The Request Object ........................................................................................................................... 679
Chapter 173: groupby() .......................................................................................................................................... 681
Section 173.1: Example 4 ............................................................................................................................................ 681
Section 173.2: Example 2 ........................................................................................................................................... 681
Section 173.3: Example 3 ........................................................................................................................................... 682
Chapter 174: pygame ............................................................................................................................................. 684
Section 174.1: Pygame's mixer module .................................................................................................................... 684
Section 174.2: Installing pygame ............................................................................................................................. 685
Chapter 175: hashlib ................................................................................................................................................ 686
Section 175.1: MD5 hash of a string ......................................................................................................................... 686
Section 175.2: algorithm provided by OpenSSL ..................................................................................................... 687
Chapter 176: getting start with GZip .............................................................................................................. 688
Section 176.1: Read and write GNU zip files ............................................................................................................ 688
Chapter 177: ctypes ................................................................................................................................................. 689
Section 177.1: ctypes arrays ...................................................................................................................................... 689
Section 177.2: Wrapping functions for ctypes ........................................................................................................ 689
Section 177.3: Basic usage ........................................................................................................................................ 690
Section 177.4: Common pitfalls ................................................................................................................................ 690
Section 177.5: Basic ctypes object ........................................................................................................................... 691
Section 177.6: Complex usage .................................................................................................................................. 692
Chapter 178: Creating a Windows service using Python ...................................................................... 693
Section 178.1: A Python script that can be run as a service .................................................................................. 693
Section 178.2: Running a Flask web application as a service ............................................................................... 694
Chapter 179: Mutable vs Immutable (and Hashable) in Python ....................................................... 695
Section 179.1: Mutable vs Immutable ....................................................................................................................... 695
Section 179.2: Mutable and Immutable as Arguments .......................................................................................... 697
Chapter 180: Python speed of program ....................................................................................................... 699
 Section 180.1: Deque operations .............................................................................................................................. 699
Section 180.2: Algorithmic Notations ....................................................................................................................... 699
Section 180.3: Notation ............................................................................................................................................. 700
Section 180.4: List operations ................................................................................................................................... 701
Section 180.5: Set operations ................................................................................................................................... 701
Chapter 181: configparser .................................................................................................................................... 703
Section 181.1: Creating configuration file programatically .................................................................................... 703
Section 181.2: Basic usage ........................................................................................................................................ 703
Chapter 182: Commonwealth Exceptions ..................................................................................................... 704
Section 182.1: Other Errors ........................................................................................................................................ 704
Section 182.2: NameError: name '???' is not defined ............................................................................................. 705
Section 182.3: TypeErrors ......................................................................................................................................... 706
Section 182.4: Syntax Error on good code .............................................................................................................. 707
Section 182.5: IndentationErrors (or indentation SyntaxErrors) ........................................................................... 708
Chapter 183: Optical Character Recognition .............................................................................................. 710
Section 183.1: PyTesseract ........................................................................................................................................ 710
Section 183.2: PyOCR ................................................................................................................................................ 710
Chapter 184: graph-tool ....................................................................................................................................... 712
Section 184.1: PyDotPlus ............................................................................................................................................ 712
Section 184.2: PyGraphviz ......................................................................................................................................... 712
Chapter 185: Python Virtual Environment - virtualenv ......................................................................... 714
Section 185.1: Installation .......................................................................................................................................... 714
Section 185.2: Usage ................................................................................................................................................. 714
Section 185.3: Install a package in your Virtualenv ............................................................................................... 714
Section 185.4: Other useful virtualenv commands ................................................................................................. 715
Chapter 186: sys ........................................................................................................................................................ 716
Section 186.1: Command line arguments ................................................................................................................ 716
Section 186.2: Script name ........................................................................................................................................ 716
Section 186.3: Standard error stream ...................................................................................................................... 716
Section 186.4: Ending the process prematurely and returning an exit code ...................................................... 716
Chapter 187: virtual environment with virtualenvwrapper ................................................................ 717
Section 187.1: Create virtual environment with virtualenvwrapper ...................................................................... 717
Chapter 188: Create virtual environment with virtualenvwrapper in windows ........................ 719
Section 188.1: Virtual environment with virtualenvwrapper for windows ............................................................ 719
Chapter 189: Python Requests Post ................................................................................................................ 720
Section 189.1: Simple Post ......................................................................................................................................... 720
Section 189.2: Form Encoded Data ......................................................................................................................... 721
Section 189.3: File Upload ......................................................................................................................................... 721
Section 189.4: Responses .......................................................................................................................................... 722
Section 189.5: Authentication ................................................................................................................................... 722
Section 189.6: Proxies ................................................................................................................................................ 723
Chapter 190: Python Lex-Yacc ........................................................................................................................... 725
Section 190.1: Getting Started with PLY ................................................................................................................... 725
Section 190.2: The "Hello, World!" of PLY - A Simple Calculator ........................................................................... 725
Section 190.3: Part 1: Tokenizing Input with Lex ...................................................................................................... 727
Section 190.4: Part 2: Parsing Tokenized Input with Yacc ..................................................................................... 730
Chapter 191: ChemPy - python package ....................................................................................................... 734
Section 191.1: Parsing formulae ................................................................................................................................ 734
Section 191.2: Balancing stoichiometry of a chemical reaction ............................................................................ 734
 Section 191.3: Balancing reactions ........................................................................................................................... 734
Section 191.4: Chemical equilibria ............................................................................................................................ 735
Section 191.5: Ionic strength ...................................................................................................................................... 735
Section 191.6: Chemical kinetics (system of ordinary dierential equations) ..................................................... 735
Chapter 192: pyaudio .............................................................................................................................................. 737
Section 192.1: Callback Mode Audio I/O .................................................................................................................. 737
Section 192.2: Blocking Mode Audio I/O ................................................................................................................. 738
Chapter 193: shelve .................................................................................................................................................. 740
Section 193.1: Creating a new Shelf .......................................................................................................................... 740
Section 193.2: Sample code for shelve .................................................................................................................... 741
Section 193.3: To summarize the interface (key is a string, data is an arbitrary object): .................................. 741
Section 193.4: Write-back ......................................................................................................................................... 741
Chapter 194: IoT Programming with Python and Raspberry PI ....................................................... 743
Section 194.1: Example - Temperature sensor ........................................................................................................ 743
Chapter 195: kivy - Cross-platform Python Framework for NUI Development ....................... 746
Section 195.1: First App .............................................................................................................................................. 746
Chapter 196: Call Python from C# .................................................................................................................... 748
Section 196.1: Python script to be called by C# application .................................................................................. 748
Section 196.2: C# code calling Python script .......................................................................................................... 748
Chapter 197: Similarities in syntax, Dierences in meaning: Python vs. JavaScript ............. 750
Section 197.1: `in` with lists ......................................................................................................................................... 750
Chapter 198: Raise Custom Errors / Exceptions ....................................................................................... 751
Section 198.1: Custom Exception .............................................................................................................................. 751
Section 198.2: Catch custom Exception ................................................................................................................... 751
Chapter 199: Pandas Transform: Preform operations on groups and concatenate the
results ............................................................................................................................................................................. 752
Section 199.1: Simple transform ............................................................................................................................... 752
Section 199.2: Multiple results per group ................................................................................................................ 753
Chapter 200: Security and Cryptography ................................................................................................... 754
Section 200.1: Secure Password Hashing ............................................................................................................... 754
Section 200.2: Calculating a Message Digest ........................................................................................................ 754
Section 200.3: Available Hashing Algorithms ......................................................................................................... 754
Section 200.4: File Hashing ...................................................................................................................................... 755
Section 200.5: Generating RSA signatures using pycrypto .................................................................................. 755
Section 200.6: Asymmetric RSA encryption using pycrypto ................................................................................ 756
Section 200.7: Symmetric encryption using pycrypto .......................................................................................... 757
Chapter 201: Secure Shell Connection in Python ...................................................................................... 758
Section 201.1: ssh connection ................................................................................................................................... 758
Chapter 202: Python Anti-Patterns ................................................................................................................. 759
Section 202.1: Overzealous except clause .............................................................................................................. 759
Section 202.2: Looking before you leap with processor-intensive function ....................................................... 759
Chapter 203: Common Pitfalls ........................................................................................................................... 761
Section 203.1: List multiplication and common references ................................................................................... 761
Section 203.2: Mutable default argument .............................................................................................................. 764
Section 203.3: Changing the sequence you are iterating over ............................................................................ 765
Section 203.4: Integer and String identity .............................................................................................................. 768
Section 203.5: Dictionaries are unordered ............................................................................................................. 769
Section 203.6: Variable leaking in list comprehensions and for loops ................................................................ 770
 Section 203.7: Chaining of or operator ................................................................................................................... 770
Section 203.8: sys.argv[0] is the name of the file being executed ...................................................................... 771
Section 203.9: Accessing int literals' attributes ...................................................................................................... 771
Section 203.10: Global Interpreter Lock (GIL) and blocking threads ................................................................... 772
Section 203.11: Multiple return .................................................................................................................................. 773
Section 203.12: Pythonic JSON keys ....................................................................................................................... 773
Credits ............................................................................................................................................................................ 775
You may also like ...................................................................................................................................................... 789
About

Please feel free to share this PDF with anyone for free,
latest version of this book can be downloaded from:
http://GoalKicker.com/PythonBook

This Python® Notes for Professionals book is compiled from Stack Overflow
Documentation, the content is written by the beautiful people at Stack Overflow.
Text content is released under Creative Commons BY-SA, see credits at the end
of this book whom contributed to the various chapters. Images may be copyright
of their respective owners unless otherwise specified

This is an unofficial free book created for educational purposes and is not
affiliated with official Python® group(s) or company(s) nor Stack Overflow. All
trademarks and registered trademarks are the property of their respective
company owners

The information presented in this book is not guaranteed to be correct nor

accurate, use at your own risk

Please send feedback and corrections to [email protected]

Python® Notes for Professionals 1

Chapter 1: Getting started with Python
Language
Python 3.x
Version Release Date
[3.7] 2017-05-08
3.6 2016-12-23
3.5 2015-09-13
3.4 2014-03-17
3.3 2012-09-29
3.2 2011-02-20
3.1 2009-06-26
3.0 2008-12-03
Python 2.x
Version Release Date
2.7 2010-07-03
2.6 2008-10-02
2.5 2006-09-19
2.4 2004-11-30
2.3 2003-07-29
2.2 2001-12-21
2.1 2001-04-15
2.0 2000-10-16

Section 1.1: Getting Started

Python is a widely used high-level programming language for general-purpose programming, created by Guido van
Rossum and first released in 1991. Python features a dynamic type system and automatic memory management
and supports multiple programming paradigms, including object-oriented, imperative, functional programming,
and procedural styles. It has a large and comprehensive standard library.

Two major versions of Python are currently in active use:

Python 3.x is the current version and is under active development.

Python 2.x is the legacy version and will receive only security updates until 2020. No new features will be
implemented. Note that many projects still use Python 2, although migrating to Python 3 is getting easier.

You can download and install either version of Python here. See Python 3 vs. Python 2 for a comparison between
them. In addition, some third-parties offer re-packaged versions of Python that add commonly used libraries and
other features to ease setup for common use cases, such as math, data analysis or scientific use. See the list at the
official site.

Verify if Python is installed

To confirm that Python was installed correctly, you can verify that by running the following command in your
favorite terminal (If you are using Windows OS, you need to add path of python to the environment variable before
using it in command prompt):

$ python --version

Python 3.x Version ≥ 3.0

If you have Python 3 installed, and it is your default version (see Troubleshooting for more details) you should see

Python® Notes for Professionals 2

something like this:

$ python --version
Python 3.6.0

Python 2.x Version ≤ 2.7

If you have Python 2 installed, and it is your default version (see Troubleshooting for more details) you should see
something like this:

$ python --version
Python 2.7.13

If you have installed Python 3, but $ python --version outputs a Python 2 version, you also have Python 2
installed. This is often the case on MacOS, and many Linux distributions. Use $ python3 instead to explicitly use the
Python 3 interpreter.

Hello, World in Python using IDLE

IDLE is a simple editor for Python, that comes bundled with Python.

How to create Hello, World program in IDLE

Open IDLE on your system of choice.

In older versions of Windows, it can be found at All Programs under the Windows menu.
In Windows 8+, search for IDLE or find it in the apps that are present in your system.
On Unix-based (including Mac) systems you can open it from the shell by typing $ idle
python_file.py.
It will open a shell with options along the top.

In the shell, there is a prompt of three right angle brackets:

>>>

Now write the following code in the prompt:

>>> print("Hello, World")

Hit Enter .

>>> print("Hello, World")

Hello, World

Hello World Python file

Create a new file hello.py that contains the following line:

Python 3.x Version ≥ 3.0

print('Hello, World')

Python 2.x Version ≥ 2.6

You can use the Python 3 print function in Python 2 with the following import statement:

from __future__ import print_function

Python 2 has a number of functionalities that can be optionally imported from Python 3 using the __future__

Python® Notes for Professionals 3

module, as discussed here.

Python 2.x Version ≤ 2.7

If using Python 2, you may also type the line below. Note that this is not valid in Python 3 and thus not
recommended because it reduces cross-version code compatibility.

print 'Hello, World'

In your terminal, navigate to the directory containing the file hello.py.

Type python hello.py, then hit the Enter key.

$ python hello.py
Hello, World

You should see Hello, World printed to the console.

You can also substitute hello.py with the path to your file. For example, if you have the file in your home directory
and your user is "user" on Linux, you can type python /home/user/hello.py.

Launch an interactive Python shell

By executing (running) the python command in your terminal, you are presented with an interactive Python shell.
This is also known as the Python Interpreter or a REPL (for 'Read Evaluate Print Loop').

$ python
Python 2.7.12 (default, Jun 28 2016, 08:46:01)
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Hello, World'
Hello, World
>>>

If you want to run Python 3 from your terminal, execute the command python3.

$ python3
Python 3.6.0 (default, Jan 13 2017, 00:00:00)
[GCC 6.1.1 20160602] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('Hello, World')
Hello, World
>>>

Alternatively, start the interactive prompt and load file with python -i <file.py>.

In command line, run:

$ python -i hello.py
"Hello World"
>>>

There are multiple ways to close the Python shell:

>>> exit()

Python® Notes for Professionals 4

or

>>> quit()

Alternatively, CTRL + D will close the shell and put you back on your terminal's command line.

If you want to cancel a command you're in the middle of typing and get back to a clean command prompt, while
staying inside the Interpreter shell, use CTRL + C .

Try an interactive Python shell online.

Other Online Shells

Various websites provide online access to Python shells.

Online shells may be useful for the following purposes:

Run a small code snippet from a machine which lacks python installation(smartphones, tablets etc).
Learn or teach basic Python.
Solve online judge problems.

Examples:

Disclaimer: documentation author(s) are not affiliated with any resources listed below.

https://www.python.org/shell/ - The online Python shell hosted by the official Python website.
https://ideone.com/ - Widely used on the Net to illustrate code snippet behavior.
https://repl.it/languages/python3 - Powerful and simple online compiler, IDE and interpreter. Code, compile,
and run code in Python.
https://www.tutorialspoint.com/execute_python_online.php - Full-featured UNIX shell, and a user-friendly
project explorer.
http://rextester.com/l/python3_online_compiler - Simple and easy to use IDE which shows execution time

Run commands as a string

Python can be passed arbitrary code as a string in the shell:

$ python -c 'print("Hello, World")'

Hello, World

This can be useful when concatenating the results of scripts together in the shell.

Shells and Beyond

Package Management - The PyPA recommended tool for installing Python packages is PIP. To install, on your
command line execute pip install <the package name>. For instance, pip install numpy. (Note: On windows
you must add pip to your PATH environment variables. To avoid this, use python -m pip install <the package
name>)

Shells - So far, we have discussed different ways to run code using Python's native interactive shell. Shells use
Python's interpretive power for experimenting with code real-time. Alternative shells include IDLE - a pre-bundled
GUI, IPython - known for extending the interactive experience, etc.

Programs - For long-term storage you can save content to .py files and edit/execute them as scripts or programs

Python® Notes for Professionals 5

with external tools e.g. shell, IDEs (such as PyCharm), Jupyter notebooks, etc. Intermediate users may use these
tools; however, the methods discussed here are sufficient for getting started.

Python tutor allows you to step through Python code so you can visualize how the program will flow, and helps you
to understand where your program went wrong.

PEP8 defines guidelines for formatting Python code. Formatting code well is important so you can quickly read what
the code does.

Section 1.2: Creating variables and assigning values

To create a variable in Python, all you need to do is specify the variable name, and then assign a value to it.

<variable name> = <value>

Python uses = to assign values to variables. There's no need to declare a variable in advance (or to assign a data
type to it), assigning a value to a variable itself declares and initializes the variable with that value. There's no way to
declare a variable without assigning it an initial value.

# Integer
a = 2
print(a)
# Output: 2

# Integer
b = 9223372036854775807
print(b)
# Output: 9223372036854775807

# Floating point
pi = 3.14
print(pi)
# Output: 3.14

# String
c = 'A'
print(c)
# Output: A

# String
name = 'John Doe'
print(name)
# Output: John Doe

# Boolean
q = True
print(q)
# Output: True

# Empty value or null data type

x = None
print(x)
# Output: None

Variable assignment works from left to right. So the following will give you an syntax error.

0 = x
=> Output: SyntaxError: can't assign to literal

Python® Notes for Professionals 6

You can not use python's keywords as a valid variable name. You can see the list of keyword by:

import keyword
print(keyword.kwlist)

Rules for variable naming:

1. Variables names must start with a letter or an underscore.

x = True # valid
_y = True # valid

9x = False # starts with numeral

=> SyntaxError: invalid syntax

$y = False # starts with symbol

=> SyntaxError: invalid syntax

2. The remainder of your variable name may consist of letters, numbers and underscores.

has_0_in_it = "Still Valid"

3. Names are case sensitive.

x = 9
y = X*5
=>NameError: name 'X' is not defined

Even though there's no need to specify a data type when declaring a variable in Python, while allocating the
necessary area in memory for the variable, the Python interpreter automatically picks the most suitable built-in
type for it:

a = 2
print(type(a))
# Output: <type 'int'>

b = 9223372036854775807
print(type(b))
# Output: <type 'int'>

pi = 3.14
print(type(pi))
# Output: <type 'float'>

c = 'A'
print(type(c))
# Output: <type 'str'>

name = 'John Doe'

print(type(name))
# Output: <type 'str'>

q = True
print(type(q))
# Output: <type 'bool'>

x = None
print(type(x))

Python® Notes for Professionals 7

# Output: <type 'NoneType'>

Now you know the basics of assignment, let's get this subtlety about assignment in python out of the way.

When you use = to do an assignment operation, what's on the left of = is a name for the object on the right. Finally,
what = does is assign the reference of the object on the right to the name on the left.

That is:

a_name = an_object # "a_name" is now a name for the reference to the object "an_object"

So, from many assignment examples above, if we pick pi = 3.14, then pi is a name (not the name, since an object
can have multiple names) for the object 3.14. If you don't understand something below, come back to this point
and read this again! Also, you can take a look at this for a better understanding.

You can assign multiple values to multiple variables in one line. Note that there must be the same number of
arguments on the right and left sides of the = operator:

a, b, c = 1, 2, 3
print(a, b, c)
# Output: 1 2 3

a, b, c = 1, 2
=> Traceback (most recent call last):
=> File "name.py", line N, in <module>
=> a, b, c = 1, 2
=> ValueError: need more than 2 values to unpack

a, b = 1, 2, 3
=> Traceback (most recent call last):
=> File "name.py", line N, in <module>
=> a, b = 1, 2, 3
=> ValueError: too many values to unpack

The error in last example can be obviated by assigning remaining values to equal number of arbitrary variables.
This dummy variable can have any name, but it is conventional to use the underscore (_) for assigning unwanted
values:

a, b, _ = 1, 2, 3
print(a, b)
# Output: 1, 2

Note that the number of _ and number of remaining values must be equal. Otherwise 'too many values to unpack
error' is thrown as above:

a, b, _ = 1,2,3,4
=>Traceback (most recent call last):
=>File "name.py", line N, in <module>
=>a, b, _ = 1,2,3,4
=>ValueError: too many values to unpack (expected 3)

You can also assign a single value to several variables simultaneously.

a = b = c = 1
print(a, b, c)
# Output: 1 1 1

Python® Notes for Professionals 8

When using such cascading assignment, it is important to note that all three variables a, b and c refer to the same
object in memory, an int object with the value of 1. In other words, a, b and c are three different names given to the
same int object. Assigning a different object to one of them afterwards doesn't change the others, just as expected:

a = b = c = 1 # all three names a, b and c refer to same int object with value 1
print(a, b, c)
# Output: 1 1 1
b = 2 # b now refers to another int object, one with a value of 2
print(a, b, c)
# Output: 1 2 1 # so output is as expected.

The above is also true for mutable types (like list, dict, etc.) just as it is true for immutable types (like int, string,
tuple, etc.):

x = y = [7, 8, 9] # x and y refer to the same list object just created, [7, 8, 9]
x = [13, 8, 9] # x now refers to a different list object just created, [13, 8, 9]
print(y) # y still refers to the list it was first assigned
# Output: [7, 8, 9]

So far so good. Things are a bit different when it comes to modifying the object (in contrast to assigning the name to
a different object, which we did above) when the cascading assignment is used for mutable types. Take a look
below, and you will see it first hand:

x = y = [7, 8, 9] # x and y are two different names for the same list object just created, [7,
8, 9]
x[0] = 13 # we are updating the value of the list [7, 8, 9] through one of its names, x
in this case
print(y) # printing the value of the list using its other name
# Output: [13, 8, 9] # hence, naturally the change is reflected

Nested lists are also valid in python. This means that a list can contain another list as an element.

x = [1, 2, [3, 4, 5], 6, 7] # this is nested list

print x[2]
# Output: [3, 4, 5]
print x[2][1]
# Output: 4

Lastly, variables in Python do not have to stay the same type as which they were first defined -- you can simply use
= to assign a new value to a variable, even if that value is of a different type.

a = 2
print(a)
# Output: 2

a = "New value"
print(a)
# Output: New value

If this bothers you, think about the fact that what's on the left of = is just a name for an object. First you call the int
object with value 2 a, then you change your mind and decide to give the name a to a string object, having value
'New value'. Simple, right?

Section 1.3: Block Indentation

Python uses indentation to define control and loop constructs. This contributes to Python's readability, however, it

Python® Notes for Professionals 9

requires the programmer to pay close attention to the use of whitespace. Thus, editor miscalibration could result in
code that behaves in unexpected ways.

Python uses the colon symbol (:) and indentation for showing where blocks of code begin and end (If you come
from another language, do not confuse this with somehow being related to the ternary operator). That is, blocks in
Python, such as functions, loops, if clauses and other constructs, have no ending identifiers. All blocks start with a
colon and then contain the indented lines below it.

For example:

def my_function(): # This is a function definition. Note the colon (:)

a = 2 # This line belongs to the function because it's indented
return a # This line also belongs to the same function
print(my_function()) # This line is OUTSIDE the function block

or

if a > b: # If block starts here

print(a) # This is part of the if block
else: # else must be at the same level as if
print(b) # This line is part of the else block

Blocks that contain exactly one single-line statement may be put on the same line, though this form is generally not
considered good style:

if a > b: print(a)
else: print(b)

Attempting to do this with more than a single statement will not work:

if x > y: y = x
print(y) # IndentationError: unexpected indent

if x > y: while y != z: y -= 1 # SyntaxError: invalid syntax

An empty block causes an IndentationError. Use pass (a command that does nothing) when you have a block with
no content:

def will_be_implemented_later():
pass

Spaces vs. Tabs

In short: always use 4 spaces for indentation.

Using tabs exclusively is possible but PEP 8, the style guide for Python code, states that spaces are preferred.

Python 3.x Version ≥ 3.0

Python 3 disallows mixing the use of tabs and spaces for indentation. In such case a compile-time error is
generated: Inconsistent use of tabs and spaces in indentation and the program will not run.

Python 2.x Version ≤ 2.7

Python 2 allows mixing tabs and spaces in indentation; this is strongly discouraged. The tab character completes
the previous indentation to be a multiple of 8 spaces. Since it is common that editors are configured to show tabs

Python® Notes for Professionals 10

as multiple of 4 spaces, this can cause subtle bugs.

Citing PEP 8:

When invoking the Python 2 command line interpreter with the -t option, it issues warnings about code
that illegally mixes tabs and spaces. When using -tt these warnings become errors. These options are
highly recommended!

Many editors have "tabs to spaces" configuration. When configuring the editor, one should differentiate between
the tab character ('\t') and the Tab key.

The tab character should be configured to show 8 spaces, to match the language semantics - at least in cases
when (accidental) mixed indentation is possible. Editors can also automatically convert the tab character to
spaces.
However, it might be helpful to configure the editor so that pressing the Tab key will insert 4 spaces,
instead of inserting a tab character.

Python source code written with a mix of tabs and spaces, or with non-standard number of indentation spaces can
be made pep8-conformant using autopep8. (A less powerful alternative comes with most Python installations:
reindent.py)

Section 1.4: Datatypes

Built-in Types
Booleans

bool: A boolean value of either True or False. Logical operations like and, or, not can be performed on booleans.

x or y # if x is False then y otherwise x

x and y # if x is False then x otherwise y
not x # if x is True then False, otherwise True

In Python 2.x and in Python 3.x, a boolean is also an int. The bool type is a subclass of the int type and True and
False are its only instances:

issubclass(bool, int) # True

isinstance(True, bool) # True

isinstance(False, bool) # True

If boolean values are used in arithmetic operations, their integer values (1 and 0 for True and False) will be used to
return an integer result:

True + False == 1 # 1 + 0 == 1
True * True == 1 # 1 * 1 == 1

Numbers

int: Integer number

a = 2
b = 100
c = 123456789

Python® Notes for Professionals 11

 d = 38563846326424324

Integers in Python are of arbitrary sizes.

Note: in older versions of Python, a long type was available and this was distinct from int. The two have
been unified.

float: Floating point number; precision depends on the implementation and system architecture, for
CPython the float datatype corresponds to a C double.

a = 2.0
b = 100.e0
c = 123456789.e1

complex: Complex numbers

a = 2 + 1j
b = 100 + 10j

The <, <=, > and >= operators will raise a TypeError exception when any operand is a complex number.

Strings
Python 3.x Version ≥ 3.0

str: a unicode string. The type of 'hello'

bytes: a byte string. The type of b'hello'

Python 2.x Version ≤ 2.7

str: a byte string. The type of 'hello'

bytes: synonym for str
unicode: a unicode string. The type of u'hello'

Sequences and collections

Python differentiates between ordered sequences and unordered collections (such as set and dict).

strings (str, bytes, unicode) are sequences

reversed: A reversed order of str with reversed function

a = reversed('hello')

tuple: An ordered collection of n values of any type (n >= 0).

a = (1, 2, 3)
b = ('a', 1, 'python', (1, 2))
b[2] = 'something else' # returns a TypeError

Supports indexing; immutable; hashable if all its members are hashable

list: An ordered collection of n values (n >= 0)

a = [1, 2, 3]

Python® Notes for Professionals 12

 b = ['a', 1, 'python', (1, 2), [1, 2]]
b[2] = 'something else' # allowed

Not hashable; mutable.

set: An unordered collection of unique values. Items must be hashable.

a = {1, 2, 'a'}

dict: An unordered collection of unique key-value pairs; keys must be hashable.

a = {1: 'one',
2: 'two'}

b = {'a': [1, 2, 3],

'b': 'a string'}

An object is hashable if it has a hash value which never changes during its lifetime (it needs a __hash__()
method), and can be compared to other objects (it needs an __eq__() method). Hashable objects which
compare equality must have the same hash value.

Built-in constants

In conjunction with the built-in datatypes there are a small number of built-in constants in the built-in namespace:

True: The true value of the built-in type bool

False: The false value of the built-in type bool
None: A singleton object used to signal that a value is absent.
Ellipsis or ...: used in core Python3+ anywhere and limited usage in Python2.7+ as part of array notation.
numpy and related packages use this as a 'include everything' reference in arrays.
NotImplemented: a singleton used to indicate to Python that a special method doesn't support the specific
arguments, and Python will try alternatives if available.

a = None # No value will be assigned. Any valid datatype can be assigned later

Python 3.x Version ≥ 3.0

None doesn't have any natural ordering. Using ordering comparison operators (<, <=, >=, >) isn't supported anymore
and will raise a TypeError.

Python 2.x Version ≤ 2.7

None is always less than any number (None < -32 evaluates to True).

Testing the type of variables

In python, we can check the datatype of an object using the built-in function type.

a = '123'
print(type(a))
# Out: <class 'str'>
b = 123
print(type(b))

Python® Notes for Professionals 13

# Out: <class 'int'>

In conditional statements it is possible to test the datatype with isinstance. However, it is usually not encouraged
to rely on the type of the variable.

i = 7
if isinstance(i, int):
i += 1
elif isinstance(i, str):
i = int(i)
i += 1

For information on the differences between type() and isinstance() read: Differences between isinstance and
type in Python

To test if something is of NoneType:

x = None
if x is None:
print('Not a surprise, I just defined x as None.')

Converting between datatypes

You can perform explicit datatype conversion.

For example, '123' is of str type and it can be converted to integer using int function.

a = '123'
b = int(a)

Converting from a float string such as '123.456' can be done using float function.

a = '123.456'
b = float(a)
c = int(a) # ValueError: invalid literal for int() with base 10: '123.456'
d = int(b) # 123

You can also convert sequence or collection types

a = 'hello'
list(a) # ['h', 'e', 'l', 'l', 'o']
set(a) # {'o', 'e', 'l', 'h'}
tuple(a) # ('h', 'e', 'l', 'l', 'o')

Explicit string type at definition of literals

With one letter labels just in front of the quotes you can tell what type of string you want to define.

b'foo bar': results bytes in Python 3, str in Python 2

u'foo bar': results str in Python 3, unicode in Python 2
'foo bar': results str
r'foo bar': results so called raw string, where escaping special characters is not necessary, everything is
taken verbatim as you typed

normal = 'foo\nbar' # foo

# bar
escaped = 'foo\\nbar' # foo\nbar
raw = r'foo\nbar' # foo\nbar

Python® Notes for Professionals 14

Mutable and Immutable Data Types

An object is called mutable if it can be changed. For example, when you pass a list to some function, the list can be
changed:

def f(m):
m.append(3) # adds a number to the list. This is a mutation.

x = [1, 2]
f(x)
x == [1, 2] # False now, since an item was added to the list

An object is called immutable if it cannot be changed in any way. For example, integers are immutable, since there's
no way to change them:

def bar():
x = (1, 2)
g(x)
x == (1, 2) # Will always be True, since no function can change the object (1, 2)

Note that variables themselves are mutable, so we can reassign the variable x, but this does not change the object
that x had previously pointed to. It only made x point to a new object.

Data types whose instances are mutable are called mutable data types, and similarly for immutable objects and
datatypes.

Examples of immutable Data Types:

int, long, float, complex

str
bytes
tuple
frozenset

Examples of mutable Data Types:

bytearray
list
set
dict

Section 1.5: Collection Types

There are a number of collection types in Python. While types such as int and str hold a single value, collection
types hold multiple values.

Lists

The list type is probably the most commonly used collection type in Python. Despite its name, a list is more like an
array in other languages, mostly JavaScript. In Python, a list is merely an ordered collection of valid Python values. A
list can be created by enclosing values, separated by commas, in square brackets:

int_list = [1, 2, 3]
string_list = ['abc', 'defghi']

Python® Notes for Professionals 15

A list can be empty:

empty_list = []

The elements of a list are not restricted to a single data type, which makes sense given that Python is a dynamic
language:

mixed_list = [1, 'abc', True, 2.34, None]

A list can contain another list as its element:

nested_list = [['a', 'b', 'c'], [1, 2, 3]]

The elements of a list can be accessed via an index, or numeric representation of their position. Lists in Python are
zero-indexed meaning that the first element in the list is at index 0, the second element is at index 1 and so on:

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']

print(names[0]) # Alice
print(names[2]) # Craig

Indices can also be negative which means counting from the end of the list (-1 being the index of the last element).
So, using the list from the above example:

print(names[-1]) # Eric
print(names[-4]) # Bob

Lists are mutable, so you can change the values in a list:

names[0] = 'Ann'
print(names)
# Outputs ['Ann', 'Bob', 'Craig', 'Diana', 'Eric']

Besides, it is possible to add and/or remove elements from a list:

Append object to end of list with L.append(object), returns None.

names = ['Alice', 'Bob', 'Craig', 'Diana', 'Eric']

names.append("Sia")
print(names)
# Outputs ['Alice', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Add a new element to list at a specific index. L.insert(index, object)

names.insert(1, "Nikki")
print(names)
# Outputs ['Alice', 'Nikki', 'Bob', 'Craig', 'Diana', 'Eric', 'Sia']

Remove the first occurrence of a value with L.remove(value), returns None

names.remove("Bob")
print(names) # Outputs ['Alice', 'Nikki', 'Craig', 'Diana', 'Eric', 'Sia']

Get the index in the list of the first item whose value is x. It will show an error if there is no such item.

name.index("Alice")

Python® Notes for Professionals 16

0

Count length of list

len(names)
6

count occurrence of any item in list

a = [1, 1, 1, 2, 3, 4]
a.count(1)
3

Reverse the list

a.reverse()
[4, 3, 2, 1, 1, 1]
# or
a[::-1]
[4, 3, 2, 1, 1, 1]

Remove and return item at index (defaults to the last item) with L.pop([index]), returns the item

names.pop() # Outputs 'Sia'

You can iterate over the list elements like below:

for element in my_list:

print (element)

Tuples

A tuple is similar to a list except that it is fixed-length and immutable. So the values in the tuple cannot be changed
nor the values be added to or removed from the tuple. Tuples are commonly used for small collections of values
that will not need to change, such as an IP address and port. Tuples are represented with parentheses instead of
square brackets:

ip_address = ('10.20.30.40', 8080)

The same indexing rules for lists also apply to tuples. Tuples can also be nested and the values can be any valid
Python valid.

A tuple with only one member must be defined (note the comma) this way:

one_member_tuple = ('Only member',)

or

one_member_tuple = 'Only member', # No brackets

or just using tuple syntax

one_member_tuple = tuple(['Only member'])

Dictionaries

Python® Notes for Professionals 17

A dictionary in Python is a collection of key-value pairs. The dictionary is surrounded by curly braces. Each pair is
separated by a comma and the key and value are separated by a colon. Here is an example:

state_capitals = {
'Arkansas': 'Little Rock',
'Colorado': 'Denver',
'California': 'Sacramento',
'Georgia': 'Atlanta'
}

To get a value, refer to it by its key:

ca_capital = state_capitals['California']

You can also get all of the keys in a dictionary and then iterate over them:

for k in state_capitals.keys():
print('{} is the capital of {}'.format(state_capitals[k], k))

Dictionaries strongly resemble JSON syntax. The native json module in the Python standard library can be used to
convert between JSON and dictionaries.

set

A set is a collection of elements with no repeats and without insertion order but sorted order. They are used in
situations where it is only important that some things are grouped together, and not what order they were
included. For large groups of data, it is much faster to check whether or not an element is in a set than it is to do
the same for a list.

Defining a set is very similar to defining a dictionary:

first_names = {'Adam', 'Beth', 'Charlie'}

Or you can build a set using an existing list:

my_list = [1,2,3]
my_set = set(my_list)

Check membership of the set using in:

if name in first_names:
print(name)

You can iterate over a set exactly like a list, but remember: the values will be in a arbitrary, implementation-defined
order.

defaultdict

A defaultdict is a dictionary with a default value for keys, so that keys for which no value has been explicitly
defined can be accessed without errors. defaultdict is especially useful when the values in the dictionary are
collections (lists, dicts, etc) in the sense that it does not need to be initialized every time when a new key is used.

A defaultdict will never raise a KeyError. Any key that does not exist gets the default value returned.

For example, consider the following dictionary

Python® Notes for Professionals 18

>>> state_capitals = {
'Arkansas': 'Little Rock',
'Colorado': 'Denver',
'California': 'Sacramento',
'Georgia': 'Atlanta'
}

If we try to access a non-existent key, python returns us an error as follows

>>> state_capitals['Alabama']
Traceback (most recent call last):

File "<ipython-input-61-236329695e6f>", line 1, in <module>

state_capitals['Alabama']

KeyError: 'Alabama'

Let us try with a defaultdict. It can be found in the collections module.

>>> from collections import defaultdict

>>> state_capitals = defaultdict(lambda: 'Boston')

What we did here is to set a default value (Boston) in case the give key does not exist. Now populate the dict as
before:

>>> state_capitals['Arkansas'] = 'Little Rock'

>>> state_capitals['California'] = 'Sacramento'
>>> state_capitals['Colorado'] = 'Denver'
>>> state_capitals['Georgia'] = 'Atlanta'

If we try to access the dict with a non-existent key, python will return us the default value i.e. Boston

>>> state_capitals['Alabama']
'Boston'

and returns the created values for existing key just like a normal dictionary

>>> state_capitals['Arkansas']
'Little Rock'

Section 1.6: IDLE - Python GUI

IDLE is Python’s Integrated Development and Learning Environment and is an alternative to the command line. As
the name may imply, IDLE is very useful for developing new code or learning python. On Windows this comes with
the Python interpreter, but in other operating systems you may need to install it through your package manager.

The main purposes of IDLE are:

Multi-window text editor with syntax highlighting, autocompletion, and smart indent
Python shell with syntax highlighting
Integrated debugger with stepping, persistent breakpoints, and call stack visibility
Automatic indentation (useful for beginners learning about Python's indentation)
Saving the Python program as .py files and run them and edit them later at any them using IDLE.

In IDLE, hit F5 or run Python Shell to launch an interpreter. Using IDLE can be a better learning experience for

Python® Notes for Professionals 19

new users because code is interpreted as the user writes.

Note that there are lots of alternatives, see for example this discussion or this list.

Troubleshooting

Windows

If you're on Windows, the default command is python. If you receive a "'python' is not recognized" error,
the most likely cause is that Python's location is not in your system's PATH environment variable. This can be
accessed by right-clicking on 'My Computer' and selecting 'Properties' or by navigating to 'System' through
'Control Panel'. Click on 'Advanced system settings' and then 'Environment Variables...'. Edit the PATH variable
to include the directory of your Python installation, as well as the Script folder (usually
C:\Python27;C:\Python27\Scripts). This requires administrative privileges and may require a restart.

When using multiple versions of Python on the same machine, a possible solution is to rename one of the
python.exe files. For example, naming one version python27.exe would cause python27 to become the
Python command for that version.

You can also use the Python Launcher for Windows, which is available through the installer and comes by
default. It allows you to select the version of Python to run by using py -[x.y] instead of python[x.y]. You
can use the latest version of Python 2 by running scripts with py -2 and the latest version of Python 3 by
running scripts with py -3.

Debian/Ubuntu/MacOS

This section assumes that the location of the python executable has been added to the PATH environment
variable.

If you're on Debian/Ubuntu/MacOS, open the terminal and type python for Python 2.x or python3 for Python
3.x.

Type which python to see which Python interpreter will be used.

Arch Linux

The default Python on Arch Linux (and descendants) is Python 3, so use python or python3 for Python 3.x and
python2 for Python 2.x.

Other systems

Python 3 is sometimes bound to python instead of python3. To use Python 2 on these systems where it is
installed, you can use python2.

Section 1.7: User Input

Interactive input

Python® Notes for Professionals 20

To get input from the user, use the input function (note: in Python 2.x, the function is called raw_input instead,
although Python 2.x has its own version of input that is completely different):

Python 2.x Version ≥ 2.3

name = raw_input("What is your name? ")

# Out: What is your name? _

Security Remark Do not use input() in Python2 - the entered text will be evaluated as if it were a
Python expression (equivalent to eval(input()) in Python3), which might easily become a vulnerability.
See this article for further information on the risks of using this function.

Python 3.x Version ≥ 3.0

name = input("What is your name? ")

# Out: What is your name? _

The remainder of this example will be using Python 3 syntax.

The function takes a string argument, which displays it as a prompt and returns a string. The above code provides a
prompt, waiting for the user to input.

name = input("What is your name? ")

# Out: What is your name?

If the user types "Bob" and hits enter, the variable name will be assigned to the string "Bob":

name = input("What is your name? ")

# Out: What is your name? Bob
print(name)
# Out: Bob

Note that the input is always of type str, which is important if you want the user to enter numbers. Therefore, you
need to convert the str before trying to use it as a number:

x = input("Write a number:")
# Out: Write a number: 10
x / 2
# Out: TypeError: unsupported operand type(s) for /: 'str' and 'int'
float(x) / 2
# Out: 5.0

NB: It's recommended to use try/except blocks to catch exceptions when dealing with user inputs. For instance, if
your code wants to cast a raw_input into an int, and what the user writes is uncastable, it raises a ValueError.

Section 1.8: Built in Modules and Functions

A module is a file containing Python definitions and statements. Function is a piece of code which execute some
logic.

>>> pow(2,3) #8

To check the built in function in python we can use dir(). If called without an argument, return the names in the
current scope. Else, return an alphabetized list of names comprising (some of) the attribute of the given object, and
of attributes reachable from it.

Python® Notes for Professionals 21

>>> dir(__builtins__)
[
'ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'BufferError',
'BytesWarning',
'DeprecationWarning',
'EOFError',
'Ellipsis',
'EnvironmentError',
'Exception',
'False',
'FloatingPointError',
'FutureWarning',
'GeneratorExit',
'IOError',
'ImportError',
'ImportWarning',
'IndentationError',
'IndexError',
'KeyError',
'KeyboardInterrupt',
'LookupError',
'MemoryError',
'NameError',
'None',
'NotImplemented',
'NotImplementedError',
'OSError',
'OverflowError',
'PendingDeprecationWarning',
'ReferenceError',
'RuntimeError',
'RuntimeWarning',
'StandardError',
'StopIteration',
'SyntaxError',
'SyntaxWarning',
'SystemError',
'SystemExit',
'TabError',
'True',
'TypeError',
'UnboundLocalError',
'UnicodeDecodeError',
'UnicodeEncodeError',
'UnicodeError',
'UnicodeTranslateError',
'UnicodeWarning',
'UserWarning',
'ValueError',
'Warning',
'ZeroDivisionError',
'__debug__',
'__doc__',
'__import__',
'__name__',
'__package__',
'abs',
'all',

Python® Notes for Professionals 22

 'any',
'apply',
'basestring',
'bin',
'bool',
'buffer',
'bytearray',
'bytes',
'callable',
'chr',
'classmethod',
'cmp',
'coerce',
'compile',
'complex',
'copyright',
'credits',
'delattr',
'dict',
'dir',
'divmod',
'enumerate',
'eval',
'execfile',
'exit',
'file',
'filter',
'float',
'format',
'frozenset',
'getattr',
'globals',
'hasattr',
'hash',
'help',
'hex',
'id',
'input',
'int',
'intern',
'isinstance',
'issubclass',
'iter',
'len',
'license',
'list',
'locals',
'long',
'map',
'max',
'memoryview',
'min',
'next',
'object',
'oct',
'open',
'ord',
'pow',
'print',
'property',
'quit',
'range',

Python® Notes for Professionals 23

 'raw_input',
'reduce',
'reload',
'repr',
'reversed',
'round',
'set',
'setattr',
'slice',
'sorted',
'staticmethod',
'str',
'sum',
'super',
'tuple',
'type',
'unichr',
'unicode',
'vars',
'xrange',
'zip'
]

To know the functionality of any function, we can use built in function help .

>>> help(max)
Help on built-in function max in module __builtin__:
max(...)
max(iterable[, key=func]) -> value
max(a, b, c, ...[, key=func]) -> value
With a single iterable argument, return its largest item.
With two or more arguments, return the largest argument.

Built in modules contains extra functionalities.For example to get square root of a number we need to include math
module.

>>> import math

>>> math.sqrt(16) # 4.0

To know all the functions in a module we can assign the functions list to a variable, and then print the variable.

>>> import math

>>> dir(math)

['__doc__', '__name__', '__package__', 'acos', 'acosh',

'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign',
'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1',
'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma',
'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10',
'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt',
'tan', 'tanh', 'trunc']

it seems __doc__ is useful to provide some documentation in, say, functions

>>> math.__doc__
'This module is always available. It provides access to the\nmathematical
functions defined by the C standard.'

In addition to functions, documentation can also be provided in modules. So, if you have a file named

Python® Notes for Professionals 24

helloWorld.py like this:

"""This is the module docstring."""

def sayHello():
"""This is the function docstring."""
return 'Hello World'

You can access its docstrings like this:

>>> import helloWorld

>>> helloWorld.__doc__
'This is the module docstring.'
>>> helloWorld.sayHello.__doc__
'This is the function docstring.'

For any user defined type, its attributes, its class's attributes, and recursively the attributes of its class's base
classes can be retrieved using dir()

>>> class MyClassObject(object):

... pass
...
>>> dir(MyClassObject)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__',
'__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
'__sizeof__', '__str__', '__subclasshook__', '__weakref__']

Any data type can be simply converted to string using a builtin function called str. This function is called by default
when a data type is passed to print

>>> str(123) # "123"

Section 1.9: Creating a module

A module is an importable file containing definitions and statements.

A module can be created by creating a .py file.

# hello.py
def say_hello():
print("Hello!")

Functions in a module can be used by importing the module.

For modules that you have made, they will need to be in the same directory as the file that you are importing them
into. (However, you can also put them into the Python lib directory with the pre-included modules, but should be
avoided if possible.)

$ python
>>> import hello
>>> hello.say_hello()
=> "Hello!"

Modules can be imported by other modules.

# greet.py
import hello

Python® Notes for Professionals 25

hello.say_hello()

Specific functions of a module can be imported.

# greet.py
from hello import say_hello
say_hello()

Modules can be aliased.

# greet.py
import hello as ai
ai.say_hello()

A module can be stand-alone runnable script.

# run_hello.py
if __name__ == '__main__':
from hello import say_hello
say_hello()

Run it!

$ python run_hello.py
=> "Hello!"

If the module is inside a directory and needs to be detected by python, the directory should contain a file named
__init__.py.

Section 1.10: Installation of Python 2.7.x and 3.x

Note: Following instructions are written for Python 2.7 (unless specified): instructions for Python 3.x are
similar.

WINDOWS

First, download the latest version of Python 2.7 from the official Website (https://www.python.org/downloads/).
Version is provided as an MSI package. To install it manually, just double-click the file.

By default, Python installs to a directory:

C:\Python27\

Warning: installation does not automatically modify the PATH environment variable.

Assuming that your Python installation is in C:\Python27, add this to your PATH:

C:\Python27\;C:\Python27\Scripts\

Now to check if Python installation is valid write in cmd:

python --version

Python® Notes for Professionals 26

Python 2.x and 3.x Side-By-Side

To install and use both Python 2.x and 3.x side-by-side on a Windows machine:

1. Install Python 2.x using the MSI installer.

Ensure Python is installed for all users.

Optional: add Python to PATH to make Python 2.x callable from the command-line using python.

2. Install Python 3.x using its respective installer.

Again, ensure Python is installed for all users.

Optional: add Python to PATH to make Python 3.x callable from the command-line using python. This
may override Python 2.x PATH settings, so double-check your PATH and ensure it's configured to your
preferences.
Make sure to install the py launcher for all users.

Python 3 will install the Python launcher which can be used to launch Python 2.x and Python 3.x interchangeably
from the command-line:

P:\>py -3
Python 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 17:54:52) [MSC v.1900 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

C:\>py -2
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 20:42:59) [MSC v.1500 32 Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

To use the corresponding version of pip for a specific Python version, use:

C:\>py -3 -m pip -V
pip 9.0.1 from C:\Python36\lib\site-packages (python 3.6)

C:\>py -2 -m pip -V
pip 9.0.1 from C:\Python27\lib\site-packages (python 2.7)

LINUX

The latest versions of CentOS, Fedora, Redhat Enterprise (RHEL) and Ubuntu come with Python 2.7.

To install Python 2.7 on linux manually, just do the following in terminal:

wget --no-check-certificate https://www.python.org/ftp/python/2.7.X/Python-2.7.X.tgz

tar -xzf Python-2.7.X.tgz
cd Python-2.7.X
./configure
make
sudo make install

Also add the path of new python in PATH environment variable. If new python is in /root/python-2.7.X then run
export PATH = $PATH:/root/python-2.7.X

Now to check if Python installation is valid write in terminal:

Python® Notes for Professionals 27

python --version

Ubuntu (From Source)

If you need Python 3.6 you can install it from source as shown below (Ubuntu 16.10 and 17.04 have 3.6 version in
the universal repository). Below steps have to be followed for Ubuntu 16.04 and lower versions:

sudo apt install build-essential checkinstall

sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-
dev libc6-dev libbz2-dev
wget https://www.python.org/ftp/python/3.6.1/Python-3.6.1.tar.xz
tar xvf Python-3.6.1.tar.xz
cd Python-3.6.1/
./configure --enable-optimizations
sudo make altinstall

macOS

As we speak, macOS comes installed with Python 2.7.10, but this version is outdated and slightly modified from the
regular Python.

The version of Python that ships with OS X is great for learning but it’s not good for development. The
version shipped with OS X may be out of date from the official current Python release, which is
considered the stable production version. (source)

Install Homebrew:

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Install Python 2.7:

brew install python

For Python 3.x, use the command brew install python3 instead.

Section 1.11: String function - str() and repr()

There are two functions that can be used to obtain a readable representation of an object.

repr(x) calls x.__repr__(): a representation of x. eval will usually convert the result of this function back to the
original object.

str(x) calls x.__str__(): a human-readable string that describes the object. This may elide some technical detail.

repr()

For many types, this function makes an attempt to return a string that would yield an object with the same value
when passed to eval(). Otherwise, the representation is a string enclosed in angle brackets that contains the name
of the type of the object along with additional information. This often includes the name and address of the object.

str()

For strings, this returns the string itself. The difference between this and repr(object) is that str(object) does
not always attempt to return a string that is acceptable to eval(). Rather, its goal is to return a printable or 'human

Python® Notes for Professionals 28

readable' string. If no argument is given, this returns the empty string, ''.

Example 1:

s = """w'o"w"""
repr(s) # Output: '\'w\\\'o"w\''
str(s) # Output: 'w\'o"w'
eval(str(s)) == s # Gives a SyntaxError
eval(repr(s)) == s # Output: True

Example 2:

import datetime
today = datetime.datetime.now()
str(today) # Output: '2016-09-15 06:58:46.915000'
repr(today) # Output: 'datetime.datetime(2016, 9, 15, 6, 58, 46, 915000)'

When writing a class, you can override these methods to do whatever you want:

class Represent(object):

def __init__(self, x, y):

self.x, self.y = x, y

def __repr__(self):
return "Represent(x={},y=\"{}\")".format(self.x, self.y)

def __str__(self):
return "Representing x as {} and y as {}".format(self.x, self.y)

Using the above class we can see the results:

r = Represent(1, "Hopper")
print(r) # prints __str__
print(r.__repr__) # prints __repr__: '<bound method Represent.__repr__ of
Represent(x=1,y="Hopper")>'
rep = r.__repr__() # sets the execution of __repr__ to a new variable
print(rep) # prints 'Represent(x=1,y="Hopper")'
r2 = eval(rep) # evaluates rep
print(r2) # prints __str__ from new object
print(r2 == r) # prints 'False' because they are different objects

Section 1.12: Installing external modules using pip

pip is your friend when you need to install any package from the plethora of choices available at the python
package index (PyPI). pip is already installed if you're using Python 2 >= 2.7.9 or Python 3 >= 3.4 downloaded from
python.org. For computers running Linux or another *nix with a native package manager, pip must often be
manually installed.

On instances with both Python 2 and Python 3 installed, pip often refers to Python 2 and pip3 to Python 3. Using
pip will only install packages for Python 2 and pip3 will only install packages for Python 3.

Finding / installing a package

Searching for a package is as simple as typing

$ pip search <query>

Python® Notes for Professionals 29

# Searches for packages whose name or summary contains <query>

Installing a package is as simple as typing (in a terminal / command-prompt, not in the Python interpreter)

$ pip install [package_name] # latest version of the package

$ pip install [package_name]==x.x.x # specific version of the package

$ pip install '[package_name]>=x.x.x' # minimum version of the package

where x.x.x is the version number of the package you want to install.

When your server is behind proxy, you can install package by using below command:

$ pip --proxy http://<server address>:<port> install

Upgrading installed packages

When new versions of installed packages appear they are not automatically installed to your system. To get an
overview of which of your installed packages have become outdated, run:

$ pip list --outdated

To upgrade a specific package use

$ pip install [package_name] --upgrade

Updating all outdated packages is not a standard functionality of pip.

Upgrading pip

You can upgrade your existing pip installation by using the following commands

On Linux or macOS X:

$ pip install -U pip

You may need to use sudo with pip on some Linux Systems

On Windows:

py -m pip install -U pip

or

python -m pip install -U pip

For more information regarding pip do read here.

Section 1.13: Help Utility

Python has several functions built into the interpreter. If you want to get information of keywords, built-in
functions, modules or topics open a Python console and enter:

Python® Notes for Professionals 30

>>> help()

You will receive information by entering keywords directly:

>>> help(help)

or within the utility:

help> help

which will show an explanation:

Help on _Helper in module _sitebuiltins object:

class _Helper(builtins.object)
| Define the builtin 'help'.
|
| This is a wrapper around pydoc.help that provides a helpful message
| when 'help' is typed at the Python interactive prompt.
|
| Calling help() at the Python prompt starts an interactive help session.
| Calling help(thing) prints help for the python object 'thing'.
|
| Methods defined here:
|
| __call__(self, *args, **kwds)
|
| __repr__(self)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)

You can also request subclasses of modules:

help(pymysql.connections)

You can use help to access the docstrings of the different modules you have imported, e.g., try the following:

>>> help(math)

and you'll get an error

>>> import math

>>> help(math)

And now you will get a list of the available methods in the module, but only AFTER you have imported it.

Close the helper with quit

Python® Notes for Professionals 31

Chapter 2: Python Data Types
Data types are nothing but variables you use to reserve some space in memory. Python variables do not need an
explicit declaration to reserve memory space. The declaration happens automatically when you assign a value to a
variable.

Section 2.1: String Data Type

String are identified as a contiguous set of characters represented in the quotation marks. Python allows for either
pairs of single or double quotes. Strings are immutable sequence data type, i.e each time one makes any changes
to a string, completely new string object is created.

a_str = 'Hello World'

print(a_str) #output will be whole string. Hello World
print(a_str[0]) #output will be first character. H
print(a_str[0:5]) #output will be first five characters. Hello

Section 2.2: Set Data Types

Sets are unordered collections of unique objects, there are two types of set :

1. Sets - They are mutable and new elements can be added once sets are defined

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

print(basket) # duplicates will be removed
> {'orange', 'banana', 'pear', 'apple'}
a = set('abracadabra')
print(a) # unique letters in a
> {'a', 'r', 'b', 'c', 'd'}
a.add('z')
print(a)
> {'a', 'c', 'r', 'b', 'z', 'd'}

2. Frozen Sets - They are immutable and new elements cannot added after its defined.

b = frozenset('asdfagsa')
print(b)
> frozenset({'f', 'g', 'd', 'a', 's'})
cities = frozenset(["Frankfurt", "Basel","Freiburg"])
print(cities)
> frozenset({'Frankfurt', 'Basel', 'Freiburg'})

Section 2.3: Numbers data type

Numbers have four types in Python. Int, float, complex, and long.

int_num = 10 #int value

float_num = 10.2 #float value
complex_num = 3.14j #complex value
long_num = 1234567L #long value

Python® Notes for Professionals 32

Section 2.4: List Data Type
A list contains items separated by commas and enclosed within square brackets [].lists are almost similar to arrays
in C. One difference is that all the items belonging to a list can be of different data type.

list = [123,'abcd',10.2,'d'] #can be a array of any data type or single data type.
list1 = ['hello','world']
print(list) #will ouput whole list. [123,'abcd',10.2,'d']
print(list[0:2]) #will output first two element of list. [123,'abcd']
print(list1 * 2) #will gave list1 two times. ['hello','world','hello','world']
print(list + list1) #will gave concatenation of both the lists.
[123,'abcd',10.2,'d','hello','world']

Section 2.5: Dictionary Data Type

Dictionary consists of key-value pairs.It is enclosed by curly braces {} and values can be assigned and accessed
using square brackets[].

dic={'name':'red','age':10}
print(dic) #will output all the key-value pairs. {'name':'red','age':10}
print(dic['name']) #will output only value with 'name' key. 'red'
print(dic.values()) #will output list of values in dic. ['red',10]
print(dic.keys()) #will output list of keys. ['name','age']

Section 2.6: Tuple Data Type

Lists are enclosed in brackets [ ] and their elements and size can be changed, while tuples are enclosed in
parentheses ( ) and cannot be updated. Tuples are immutable.

tuple = (123,'hello')
tuple1 = ('world')
print(tuple) #will output whole tuple. (123,'hello')
print(tuple[0]) #will output first value. (123)
print(tuple + tuple1) #will output (123,'hello','world')
tuple[1]='update' #this will give you error.

Python® Notes for Professionals 33

Chapter 3: Indentation
Section 3.1: Simple example
For Python, Guido van Rossum based the grouping of statements on indentation. The reasons for this are explained
in the first section of the "Design and History Python FAQ". Colons, :, are used to declare an indented code block,
such as the following example:

class ExampleClass:
#Every function belonging to a class must be indented equally
def __init__(self):
name = "example"

def someFunction(self, a):

#Notice everything belonging to a function must be indented
if a > 5:
return True
else:
return False

#If a function is not indented to the same level it will not be considers as part of the parent class
def separateFunction(b):
for i in b:
#Loops are also indented and nested conditions start a new indentation
if i == 1:
return True
return False

separateFunction([2,3,5,6,1])

Spaces or Tabs?

The recommended indentation is 4 spaces but tabs or spaces can be used so long as they are consistent. Do not
mix tabs and spaces in Python as this will cause an error in Python 3 and can causes errors in Python 2.

Section 3.2: How Indentation is Parsed

Whitespace is handled by the lexical analyzer before being parsed.

The lexical analyzer uses a stack to store indentation levels. At the beginning, the stack contains just the value 0,
which is the leftmost position. Whenever a nested block begins, the new indentation level is pushed on the stack,
and an "INDENT" token is inserted into the token stream which is passed to the parser. There can never be more
than one "INDENT" token in a row (IndentationError).

When a line is encountered with a smaller indentation level, values are popped from the stack until a value is on top
which is equal to the new indentation level (if none is found, a syntax error occurs). For each value popped, a
"DEDENT" token is generated. Obviously, there can be multiple "DEDENT" tokens in a row.

The lexical analyzer skips empty lines (those containing only whitespace and possibly comments), and will never
generate either "INDENT" or "DEDENT" tokens for them.

At the end of the source code, "DEDENT" tokens are generated for each indentation level left on the stack, until just
the 0 is left.

For example:

Python® Notes for Professionals 34

if foo:
if bar:
x = 42
else:
print foo

is analyzed as:

<if> <foo> <:> [0]

<INDENT> <if> <bar> <:> [0, 4]
<INDENT> <x> <=> <42> [0, 4, 8]
<DEDENT> <DEDENT> <else> <:> [0]
<INDENT> <print> <foo> [0, 2]
<DEDENT>

The parser than handles the "INDENT" and "DEDENT" tokens as block delimiters.

Section 3.3: Indentation Errors

The spacing should be even and uniform throughout. Improper indentation can cause an IndentationError or
cause the program to do something unexpected. The following example raises an IndentationError:

a = 7
if a > 5:
print "foo"
else:
print "bar"
print "done"

Or if the line following a colon is not indented, an IndentationError will also be raised:

if True:
print "true"

If you add indentation where it doesn't belong, an IndentationError will be raised:

if True:
a = 6
b = 5

If you forget to un-indent functionality could be lost. In this example None is returned instead of the expected False:

def isEven(a):
if a%2 ==0:
return True
#this next line should be even with the if
return False
print isEven(7)

Python® Notes for Professionals 35

Chapter 4: Comments and Documentation
Section 4.1: Single line, inline and multiline comments
Comments are used to explain code when the basic code itself isn't clear.

Python ignores comments, and so will not execute code in there, or raise syntax errors for plain english sentences.

Single-line comments begin with the hash character (#) and are terminated by the end of line.

Single line comment:

# This is a single line comment in Python

Inline comment:

print("Hello World") # This line prints "Hello World"

Comments spanning multiple lines have """ or ''' on either end. This is the same as a multiline string, but
they can be used as comments:

"""
This type of comment spans multiple lines.
These are mostly used for documentation of functions, classes and modules.
"""

Section 4.2: Programmatically accessing docstrings

Docstrings are - unlike regular comments - stored as an attribute of the function they document, meaning that you
can access them programmatically.

An example function
def func():
"""This is a function that does nothing at all"""
return

The docstring can be accessed using the __doc__ attribute:

print(func.__doc__)

This is a function that does nothing at all

help(func)

Help on function func in module __main__:

func()

This is a function that does nothing at all

Another example function

Python® Notes for Professionals 36

function.__doc__ is just the actual docstring as a string, while the help function provides general information
about a function, including the docstring. Here's a more helpful example:

def greet(name, greeting="Hello"):

"""Print a greeting to the user `name`

Optional parameter `greeting` can change what they're greeted with."""

print("{} {}".format(greeting, name))

help(greet)

Help on function greet in module __main__:

greet(name, greeting='Hello')

Print a greeting to the user name

Optional parameter greeting can change what they're greeted with.

Advantages of docstrings over regular comments

Just putting no docstring or a regular comment in a function makes it a lot less helpful.

def greet(name, greeting="Hello"):

# Print a greeting to the user `name`
# Optional parameter `greeting` can change what they're greeted with.

print("{} {}".format(greeting, name))

print(greet.__doc__)

None

help(greet)

Help on function greet in module main:

greet(name, greeting='Hello')

Section 4.3: Write documentation using docstrings

A docstring is a multi-line comment used to document modules, classes, functions and methods. It has to be the
first statement of the component it describes.

def hello(name):
"""Greet someone.

Print a greeting ("Hello") for the person with the given name.
"""

print("Hello "+name)

class Greeter:
"""An object used to greet people.

Python® Notes for Professionals 37

 It contains multiple greeting functions for several languages
and times of the day.
"""

The value of the docstring can be accessed within the program and is - for example - used by the help command.

Syntax conventions
PEP 257

PEP 257 defines a syntax standard for docstring comments. It basically allows two types:

One-line Docstrings:

According to PEP 257, they should be used with short and simple functions. Everything is placed in one line, e.g:

def hello():
"""Say hello to your friends."""
print("Hello my friends!")

The docstring shall end with a period, the verb should be in the imperative form.

Multi-line Docstrings:

Multi-line docstring should be used for longer, more complex functions, modules or classes.

def hello(name, language="en"):

"""Say hello to a person.

Arguments:
name: the name of the person
language: the language in which the person should be greeted
"""

print(greeting[language]+" "+name)

They start with a short summary (equivalent to the content of a one-line docstring) which can be on the same line
as the quotation marks or on the next line, give additional detail and list parameters and return values.

Note PEP 257 defines what information should be given within a docstring, it doesn't define in which format it
should be given. This was the reason for other parties and documentation parsing tools to specify their own
standards for documentation, some of which are listed below and in this question.

Sphinx

Sphinx is a tool to generate HTML based documentation for Python projects based on docstrings. Its markup
language used is reStructuredText. They define their own standards for documentation, pythonhosted.org hosts a
very good description of them. The Sphinx format is for example used by the pyCharm IDE.

A function would be documented like this using the Sphinx/reStructuredText format:

def hello(name, language="en"):

"""Say hello to a person.

:param name: the name of the person

:type name: str
:param language: the language in which the person should be greeted
:type language: str

Python® Notes for Professionals 38

 :return: a number
:rtype: int
"""

print(greeting[language]+" "+name)
return 4

Google Python Style Guide

Google has published Google Python Style Guide which defines coding conventions for Python, including
documentation comments. In comparison to the Sphinx/reST many people say that documentation according to
Google's guidelines is better human-readable.

The pythonhosted.org page mentioned above also provides some examples for good documentation according to
the Google Style Guide.

Using the Napoleon plugin, Sphinx can also parse documentation in the Google Style Guide-compliant format.

A function would be documented like this using the Google Style Guide format:

def hello(name, language="en"):

"""Say hello to a person.

Args:
name: the name of the person as string
language: the language code string

Returns:
A number.
"""

print(greeting[language]+" "+name)
return 4

Python® Notes for Professionals 39

Chapter 5: Date and Time
Section 5.1: Parsing a string into a timezone aware datetime
object
Python 3.2+ has support for %z format when parsing a string into a datetime object.

UTC offset in the form +HHMM or -HHMM (empty string if the object is naive).

Python 3.x Version ≥ 3.2

import datetime
dt = datetime.datetime.strptime("2016-04-15T08:27:18-0500", "%Y-%m-%dT%H:%M:%S%z")

For other versions of Python, you can use an external library such as dateutil, which makes parsing a string with
timezone into a datetime object is quick.

import dateutil.parser
dt = dateutil.parser.parse("2016-04-15T08:27:18-0500")

The dt variable is now a datetime object with the following value:

datetime.datetime(2016, 4, 15, 8, 27, 18, tzinfo=tzoffset(None, -18000))

Section 5.2: Constructing timezone-aware datetimes

By default all datetime objects are naive. To make them timezone-aware, you must attach a tzinfo object, which
provides the UTC offset and timezone abbreviation as a function of date and time.

Fixed Offset Time Zones

For time zones that are a fixed offset from UTC, in Python 3.2+, the datetime module provides the timezone class, a
concrete implementation of tzinfo, which takes a timedelta and an (optional) name parameter:

Python 3.x Version ≥ 3.2

from datetime import datetime, timedelta, timezone

JST = timezone(timedelta(hours=+9))

dt = datetime(2015, 1, 1, 12, 0, 0, tzinfo=JST)

print(dt)
# 2015-01-01 12:00:00+09:00

print(dt.tzname())
# UTC+09:00

dt = datetime(2015, 1, 1, 12, 0, 0, tzinfo=timezone(timedelta(hours=9), 'JST'))

print(dt.tzname)
# 'JST'

For Python versions before 3.2, it is necessary to use a third party library, such as dateutil. dateutil provides an
equivalent class, tzoffset, which (as of version 2.5.3) takes arguments of the form dateutil.tz.tzoffset(tzname,
offset), where offset is specified in seconds:

Python 3.x Version < 3.2

Python® Notes for Professionals 40

Python 2.x Version < 2.7

from datetime import datetime, timedelta

from dateutil import tz

JST = tz.tzoffset('JST', 9 * 3600) # 3600 seconds per hour

dt = datetime(2015, 1, 1, 12, 0, tzinfo=JST)
print(dt)
# 2015-01-01 12:00:00+09:00
print(dt.tzname)
# 'JST'

Zones with daylight savings time

For zones with daylight savings time, python standard libraries do not provide a standard class, so it is necessary to
use a third party library. pytz and dateutil are popular libraries providing time zone classes.

In addition to static time zones, dateutil provides time zone classes that use daylight savings time (see the
documentation for the tz module). You can use the tz.gettz() method to get a time zone object, which can then
be passed directly to the datetime constructor:

from datetime import datetime

from dateutil import tz
local = tz.gettz() # Local time
PT = tz.gettz('US/Pacific') # Pacific time

dt_l = datetime(2015, 1, 1, 12, tzinfo=local) # I am in EST

dt_pst = datetime(2015, 1, 1, 12, tzinfo=PT)
dt_pdt = datetime(2015, 7, 1, 12, tzinfo=PT) # DST is handled automatically
print(dt_l)
# 2015-01-01 12:00:00-05:00
print(dt_pst)
# 2015-01-01 12:00:00-08:00
print(dt_pdt)
# 2015-07-01 12:00:00-07:00

CAUTION: As of version 2.5.3, dateutil does not handle ambiguous datetimes correctly, and will always default to
the later date. There is no way to construct an object with a dateutil timezone representing, for example
2015-11-01 1:30 EDT-4, since this is during a daylight savings time transition.

All edge cases are handled properly when using pytz, but pytz time zones should not be directly attached to time
zones through the constructor. Instead, a pytz time zone should be attached using the time zone's localize
method:

from datetime import datetime, timedelta

import pytz

PT = pytz.timezone('US/Pacific')
dt_pst = PT.localize(datetime(2015, 1, 1, 12))
dt_pdt = PT.localize(datetime(2015, 11, 1, 0, 30))
print(dt_pst)
# 2015-01-01 12:00:00-08:00
print(dt_pdt)
# 2015-11-01 00:30:00-07:00

Be aware that if you perform datetime arithmetic on a pytz-aware time zone, you must either perform the
calculations in UTC (if you want absolute elapsed time), or you must call normalize() on the result:

Python® Notes for Professionals 41

dt_new = dt_pdt + timedelta(hours=3) # This should be 2:30 AM PST
print(dt_new)
# 2015-11-01 03:30:00-07:00
dt_corrected = PT.normalize(dt_new)
print(dt_corrected)
# 2015-11-01 02:30:00-08:00

Section 5.3: Computing time dierences

the timedelta module comes in handy to compute differences between times:

from datetime import datetime, timedelta

now = datetime.now()
then = datetime(2016, 5, 23) # datetime.datetime(2016, 05, 23, 0, 0, 0)

Specifying time is optional when creating a new datetime object

delta = now-then

delta is of type timedelta

print(delta.days)
# 60
print(delta.seconds)
# 40826

To get n day's after and n day's before date we could use :

n day's after date:

def get_n_days_after_date(date_format="%d %B %Y", add_days=120):

date_n_days_after = datetime.datetime.now() + timedelta(days=add_days)

return date_n_days_after.strftime(date_format)

n day's before date:

def get_n_days_before_date(self, date_format="%d %B %Y", days_before=120):

date_n_days_ago = datetime.datetime.now() - timedelta(days=days_before)

return date_n_days_ago.strftime(date_format)

Section 5.4: Basic datetime objects usage

The datetime module contains three primary types of objects - date, time, and datetime.

import datetime

# Date object
today = datetime.date.today()
new_year = datetime.date(2017, 01, 01) #datetime.date(2017, 1, 1)

# Time object
noon = datetime.time(12, 0, 0) #datetime.time(12, 0)

# Current datetime
now = datetime.datetime.now()

Python® Notes for Professionals 42

# Datetime object
millenium_turn = datetime.datetime(2000, 1, 1, 0, 0, 0) #datetime.datetime(2000, 1, 1, 0, 0)

Arithmetic operations for these objects are only supported within same datatype and performing simple arithmetic
with instances of different types will result in a TypeError.

# subtraction of noon from today

noon-today
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.date'
However, it is straightforward to convert between types.

# Do this instead
print('Time since the millenium at midnight: ',
datetime.datetime(today.year, today.month, today.day) - millenium_turn)

# Or this
print('Time since the millenium at noon: ',
datetime.datetime.combine(today, noon) - millenium_turn)

Section 5.5: Switching between time zones

To switch between time zones, you need datetime objects that are timezone-aware.

from datetime import datetime

from dateutil import tz

utc = tz.tzutc()
local = tz.tzlocal()

utc_now = datetime.utcnow()
utc_now # Not timezone-aware.

utc_now = utc_now.replace(tzinfo=utc)
utc_now # Timezone-aware.

local_now = utc_now.astimezone(local)
local_now # Converted to local time.

Section 5.6: Simple date arithmetic

Dates don't exist in isolation. It is common that you will need to find the amount of time between dates or
determine what the date will be tomorrow. This can be accomplished using timedelta objects

import datetime

today = datetime.date.today()
print('Today:', today)

yesterday = today - datetime.timedelta(days=1)

print('Yesterday:', yesterday)

tomorrow = today + datetime.timedelta(days=1)

print('Tomorrow:', tomorrow)

print('Time between tomorrow and yesterday:', tomorrow - yesterday)

Python® Notes for Professionals 43

This will produce results similar to:

Today: 2016-04-15
Yesterday: 2016-04-14
Tomorrow: 2016-04-16
Difference between tomorrow and yesterday: 2 days, 0:00:00

Section 5.7: Converting timestamp to datetime

The datetime module can convert a POSIX timestamp to a ITC datetime object.

The Epoch is January 1st, 1970 midnight.

import time
from datetime import datetime
seconds_since_epoch=time.time() #1469182681.709

utc_date=datetime.utcfromtimestamp(seconds_since_epoch) #datetime.datetime(2016, 7, 22, 10, 18, 1,

709000)

Section 5.8: Subtracting months from a date accurately

Using the calendar module

import calendar
from datetime import date

def monthdelta(date, delta):

m, y = (date.month+delta) % 12, date.year + ((date.month)+delta-1) // 12
if not m: m = 12
d = min(date.day, calendar.monthrange(y, m)[1])
return date.replace(day=d,month=m, year=y)

next_month = monthdelta(date.today(), 1) #datetime.date(2016, 10, 23)

Using the dateutils module

import datetime
import dateutil.relativedelta

d = datetime.datetime.strptime("2013-03-31", "%Y-%m-%d")
d2 = d - dateutil.relativedelta.relativedelta(months=1) #datetime.datetime(2013, 2, 28, 0, 0)

Section 5.9: Parsing an arbitrary ISO 8601 timestamp with

minimal libraries
Python has only limited support for parsing ISO 8601 timestamps. For strptime you need to know exactly what
format it is in. As a complication the stringification of a datetime is an ISO 8601 timestamp, with space as a
separator and 6 digit fraction:

str(datetime.datetime(2016, 7, 22, 9, 25, 59, 555555))

# '2016-07-22 09:25:59.555555'

but if the fraction is 0, no fractional part is output

str(datetime.datetime(2016, 7, 22, 9, 25, 59, 0))

Python® Notes for Professionals 44

# '2016-07-22 09:25:59'

But these 2 forms need a different format for strptime. Furthermore, strptime' does not support at all
parsing minute timezones that have a:in it, thus2016-07-22 09:25:59+0300can be parsed, but the
standard format2016-07-22 09:25:59+03:00` cannot.

There is a single-file library called iso8601 which properly parses ISO 8601 timestamps and only them.

It supports fractions and timezones, and the T separator all with a single function:

import iso8601
iso8601.parse_date('2016-07-22 09:25:59')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)
iso8601.parse_date('2016-07-22 09:25:59+03:00')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<FixedOffset '+03:00' ...>)
iso8601.parse_date('2016-07-22 09:25:59Z')
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)
iso8601.parse_date('2016-07-22T09:25:59.000111+03:00')
# datetime.datetime(2016, 7, 22, 9, 25, 59, 111, tzinfo=<FixedOffset '+03:00' ...>)

If no timezone is set, iso8601.parse_date defaults to UTC. The default zone can be changed with default_zone
keyword argument. Notably, if this is None instead of the default, then those timestamps that do not have an
explicit timezone are returned as naive datetimes instead:

iso8601.parse_date('2016-07-22T09:25:59', default_timezone=None)
# datetime.datetime(2016, 7, 22, 9, 25, 59)
iso8601.parse_date('2016-07-22T09:25:59Z', default_timezone=None)
# datetime.datetime(2016, 7, 22, 9, 25, 59, tzinfo=<iso8601.Utc>)

Section 5.10: Get an ISO 8601 timestamp

Without timezone, with microseconds
from datetime import datetime

datetime.now().isoformat()
# Out: '2016-07-31T23:08:20.886783'

With timezone, with microseconds

from datetime import datetime
from dateutil.tz import tzlocal

datetime.now(tzlocal()).isoformat()
# Out: '2016-07-31T23:09:43.535074-07:00'

With timezone, without microseconds

from datetime import datetime
from dateutil.tz import tzlocal

datetime.now(tzlocal()).replace(microsecond=0).isoformat()
# Out: '2016-07-31T23:10:30-07:00'

See ISO 8601 for more information about the ISO 8601 format.

Section 5.11: Parsing a string with a short time zone name into
a timezone aware datetime object
Using the dateutil library as in the previous example on parsing timezone-aware timestamps, it is also possible to

Python® Notes for Professionals 45

parse timestamps with a specified "short" time zone name.

For dates formatted with short time zone names or abbreviations, which are generally ambiguous (e.g. CST, which
could be Central Standard Time, China Standard Time, Cuba Standard Time, etc - more can be found here) or not
necessarily available in a standard database, it is necessary to specify a mapping between time zone abbreviation
and tzinfo object.

from dateutil import tz

from dateutil.parser import parse

ET = tz.gettz('US/Eastern')
CT = tz.gettz('US/Central')
MT = tz.gettz('US/Mountain')
PT = tz.gettz('US/Pacific')

us_tzinfos = {'CST': CT, 'CDT': CT,

'EST': ET, 'EDT': ET,
'MST': MT, 'MDT': MT,
'PST': PT, 'PDT': PT}

dt_est = parse('2014-01-02 04:00:00 EST', tzinfos=us_tzinfos)

dt_pst = parse('2016-03-11 16:00:00 PST', tzinfos=us_tzinfos)

After running this:

dt_est
# datetime.datetime(2014, 1, 2, 4, 0, tzinfo=tzfile('/usr/share/zoneinfo/US/Eastern'))
dt_pst
# datetime.datetime(2016, 3, 11, 16, 0, tzinfo=tzfile('/usr/share/zoneinfo/US/Pacific'))

It is worth noting that if using a pytz time zone with this method, it will not be properly localized:

from dateutil.parser import parse

import pytz

EST = pytz.timezone('America/New_York')
dt = parse('2014-02-03 09:17:00 EST', tzinfos={'EST': EST})

This simply attaches the pytz time zone to the datetime:

dt.tzinfo # Will be in Local Mean Time!

# <DstTzInfo 'America/New_York' LMT-1 day, 19:04:00 STD>

If using this method, you should probably re-localize the naive portion of the datetime after parsing:

dt_fixed = dt.tzinfo.localize(dt.replace(tzinfo=None))
dt_fixed.tzinfo # Now it's EST.
# <DstTzInfo 'America/New_York' EST-1 day, 19:00:00 STD>)

Section 5.12: Fuzzy datetime parsing (extracting datetime out

of a text)
It is possible to extract a date out of a text using the dateutil parser in a "fuzzy" mode, where components of the
string not recognized as being part of a date are ignored.

from dateutil.parser import parse

Python® Notes for Professionals 46

dt = parse("Today is January 1, 2047 at 8:21:00AM", fuzzy=True)
print(dt)

dt is now a datetime object and you would see datetime.datetime(2047, 1, 1, 8, 21) printed.

Section 5.13: Iterate over dates

Sometimes you want to iterate over a range of dates from a start date to some end date. You can do it using
datetime library and timedelta object:

import datetime

# The size of each step in days

day_delta = datetime.timedelta(days=1)

start_date = datetime.date.today()
end_date = start_date + 7*day_delta

for i in range((end_date - start_date).days):

print(start_date + i*day_delta)

Which produces:

2016-07-21
2016-07-22
2016-07-23
2016-07-24
2016-07-25
2016-07-26
2016-07-27

Python® Notes for Professionals 47

Chapter 6: Date Formatting
Section 6.1: Time between two date-times
from datetime import datetime

a = datetime(2016,10,06,0,0,0)
b = datetime(2016,10,01,23,59,59)

a-b
# datetime.timedelta(4, 1)

(a-b).days
# 4
(a-b).total_seconds()
# 518399.0

Section 6.2: Outputting datetime object to string

Uses C standard format codes.

from datetime import datetime

datetime_for_string = datetime(2016,10,1,0,0)
datetime_string_format = '%b %d %Y, %H:%M:%S'
datetime.strftime(datetime_for_string,datetime_string_format)
# Oct 01 2016, 00:00:00

Section 6.3: Parsing string to datetime object

Uses C standard format codes.

from datetime import datetime

datetime_string = 'Oct 1 2016, 00:00:00'
datetime_string_format = '%b %d %Y, %H:%M:%S'
datetime.strptime(datetime_string, datetime_string_format)
# datetime.datetime(2016, 10, 1, 0, 0)

Python® Notes for Professionals 48

Chapter 7: Enum
Section 7.1: Creating an enum (Python 2.4 through 3.3)
Enums have been backported from Python 3.4 to Python 2.4 through Python 3.3. You can get this the enum34
backport from PyPI.

pip install enum34

Creation of an enum is identical to how it works in Python 3.4+

from enum import Enum

class Color(Enum):
red = 1
green = 2
blue = 3

print(Color.red) # Color.red
print(Color(1)) # Color.red
print(Color['red']) # Color.red

Section 7.2: Iteration

Enums are iterable:

class Color(Enum):
red = 1
green = 2
blue = 3

[c for c in Color] # [<Color.red: 1>, <Color.green: 2>, <Color.blue: 3>]

Python® Notes for Professionals 49

Chapter 8: Set
Section 8.1: Operations on sets
with other sets

# Intersection
{1, 2, 3, 4, 5}.intersection({3, 4, 5, 6}) # {3, 4, 5}
{1, 2, 3, 4, 5} & {3, 4, 5, 6} # {3, 4, 5}

# Union
{1, 2, 3, 4, 5}.union({3, 4, 5, 6}) # {1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5} | {3, 4, 5, 6} # {1, 2, 3, 4, 5, 6}

# Difference
{1, 2, 3, 4}.difference({2, 3, 5}) # {1, 4}
{1, 2, 3, 4} - {2, 3, 5} # {1, 4}

# Symmetric difference with

{1, 2, 3, 4}.symmetric_difference({2, 3, 5}) # {1, 4, 5}
{1, 2, 3, 4} ^ {2, 3, 5} # {1, 4, 5}

# Superset check
{1, 2}.issuperset({1, 2, 3}) # False
{1, 2} >= {1, 2, 3} # False

# Subset check
{1, 2}.issubset({1, 2, 3}) # True
{1, 2} <= {1, 2, 3} # True

# Disjoint check
{1, 2}.isdisjoint({3, 4}) # True
{1, 2}.isdisjoint({1, 4}) # False

with single elements

# Existence check
2 in {1,2,3} # True
4 in {1,2,3} # False
4 not in {1,2,3} # True

# Add and Remove

s = {1,2,3}
s.add(4) # s == {1,2,3,4}

s.discard(3) # s == {1,2,4}
s.discard(5) # s == {1,2,4}

s.remove(2) # s == {1,4}
s.remove(2) # KeyError!

Set operations return new sets, but have the corresponding in-place versions:

method in-place operation in-place method

union s |= t update
intersection s &= t intersection_update
difference s -= t difference_update
symmetric_difference s ^= t symmetric_difference_update

Python® Notes for Professionals 50

For example:

s = {1, 2}
s.update({3, 4}) # s == {1, 2, 3, 4}

Section 8.2: Get the unique elements of a list

Let's say you've got a list of restaurants -- maybe you read it from a file. You care about the unique restaurants in
the list. The best way to get the unique elements from a list is to turn it into a set:

restaurants = ["McDonald's", "Burger King", "McDonald's", "Chicken Chicken"]

unique_restaurants = set(restaurants)
print(unique_restaurants)
# prints {'Chicken Chicken', "McDonald's", 'Burger King'}

Note that the set is not in the same order as the original list; that is because sets are unordered, just like dicts.

This can easily be transformed back into a List with Python's built in list function, giving another list that is the
same list as the original but without duplicates:

list(unique_restaurants)
# ['Chicken Chicken', "McDonald's", 'Burger King']

It's also common to see this as one line:

# Removes all duplicates and returns another list

list(set(restaurants))

Now any operations that could be performed on the original list can be done again.

Section 8.3: Set of Sets

{{1,2}, {3,4}}

leads to:

TypeError: unhashable type: 'set'

Instead, use frozenset:

{frozenset({1, 2}), frozenset({3, 4})}

Section 8.4: Set Operations using Methods and Builtins

We define two sets a and b

>>> a = {1, 2, 2, 3, 4}
>>> b = {3, 3, 4, 4, 5}

NOTE: {1} creates a set of one element, but {} creates an empty dict. The correct way to create an
empty set is set().

Python® Notes for Professionals 51

Intersection

a.intersection(b) returns a new set with elements present in both a and b

>>> a.intersection(b)
{3, 4}

Union

a.union(b) returns a new set with elements present in either a and b

>>> a.union(b)
{1, 2, 3, 4, 5}

Difference

a.difference(b) returns a new set with elements present in a but not in b

>>> a.difference(b)
{1, 2}
>>> b.difference(a)
{5}

Symmetric Difference

a.symmetric_difference(b) returns a new set with elements present in either a or b but not in both

>>> a.symmetric_difference(b)
{1, 2, 5}
>>> b.symmetric_difference(a)
{1, 2, 5}

NOTE: a.symmetric_difference(b) == b.symmetric_difference(a)

Subset and superset

c.issubset(a) tests whether each element of c is in a.

a.issuperset(c) tests whether each element of c is in a.

>>> c = {1, 2}
>>> c.issubset(a)
True
>>> a.issuperset(c)
True

The latter operations have equivalent operators as shown below:

Method Operator
a.intersection(b) a & b
a.union(b) a|b
a.difference(b) a - b
a.symmetric_difference(b) a ^ b
a.issubset(b) a <= b
a.issuperset(b) a >= b
Disjoint sets

Sets a and d are disjoint if no element in a is also in d and vice versa.

Python® Notes for Professionals 52

>>> d = {5, 6}
>>> a.isdisjoint(b) # {2, 3, 4} are in both sets
False
>>> a.isdisjoint(d)
True

# This is an equivalent check, but less efficient

>>> len(a & d) == 0
True

# This is even less efficient

>>> a & d == set()
True

Testing membership

The builtin in keyword searches for occurances

>>> 1 in a
True
>>> 6 in a
False

Length

The builtin len() function returns the number of elements in the set

>>> len(a)
4
>>> len(b)
3

Section 8.5: Sets versus multisets

Sets are unordered collections of distinct elements. But sometimes we want to work with unordered collections of
elements that are not necessarily distinct and keep track of the elements' multiplicities.

Consider this example:

>>> setA = {'a','b','b','c'}

>>> setA
set(['a', 'c', 'b'])

By saving the strings 'a', 'b', 'b', 'c' into a set data structure we've lost the information on the fact that 'b'
occurs twice. Of course saving the elements to a list would retain this information

>>> listA = ['a','b','b','c']

>>> listA
['a', 'b', 'b', 'c']

but a list data structure introduces an extra unneeded ordering that will slow down our computations.

For implementing multisets Python provides the Counter class from the collections module (starting from version
2.7):

Python 2.x Version ≥ 2.7

>>> from collections import Counter

>>> counterA = Counter(['a','b','b','c'])

Python® Notes for Professionals 53

>>> counterA
Counter({'b': 2, 'a': 1, 'c': 1})

Counter is a dictionary where where elements are stored as dictionary keys and their counts are stored as
dictionary values. And as all dictionaries, it is an unordered collection.

Python® Notes for Professionals 54

Chapter 9: Simple Mathematical Operators
Python does common mathematical operators on its own, including integer and float division, multiplication,
exponentiation, addition, and subtraction. The math module (included in all standard Python versions) offers
expanded functionality like trigonometric functions, root operations, logarithms, and many more.

Section 9.1: Division

Python does integer division when both operands are integers. The behavior of Python's division operators have
changed from Python 2.x and 3.x (see also Integer Division ).

a, b, c, d, e = 3, 2, 2.0, -3, 10

Python 2.x Version ≤ 2.7

In Python 2 the result of the ' / ' operator depends on the type of the numerator and denominator.

a / b # = 1

a / c # = 1.5

d / b # = -2

b / a # = 0

d / e # = -1

Note that because both a and b are ints, the result is an int.

The result is always rounded down (floored).

Because c is a float, the result of a / c is a float.

You can also use the operator module:

import operator # the operator module provides 2-argument arithmetic functions

operator.div(a, b) # = 1
operator.__div__(a, b) # = 1

Python 2.x Version ≥ 2.2

What if you want float division:

Recommended:

from __future__ import division # applies Python 3 style division to the entire module
a / b # = 1.5
a // b # = 1

Okay (if you don't want to apply to the whole module):

a / (b * 1.0) # = 1.5
1.0 * a / b # = 1.5
a / b * 1.0 # = 1.0 (careful with order of operations)

from operator import truediv

truediv(a, b) # = 1.5

Python® Notes for Professionals 55

Not recommended (may raise TypeError, eg if argument is complex):

float(a) / b # = 1.5
a / float(b) # = 1.5

Python 2.x Version ≥ 2.2

The ' // ' operator in Python 2 forces floored division regardless of type.

a // b # = 1
a // c # = 1.0

Python 3.x Version ≥ 3.0

In Python 3 the / operator performs 'true' division regardless of types. The // operator performs floor division and
maintains type.

a / b # = 1.5
e / b # = 5.0
a // b # = 1
a // c # = 1.0

import operator # the operator module provides 2-argument arithmetic functions

operator.truediv(a, b) # = 1.5
operator.floordiv(a, b) # = 1
operator.floordiv(a, c) # = 1.0

Possible combinations (builtin types):

int and int (gives an int in Python 2 and a float in Python 3)

int and float (gives a float)
int and complex (gives a complex)
float and float (gives a float)
float and complex (gives a complex)
complex and complex (gives a complex)

See PEP 238 for more information.

Section 9.2: Addition

a, b = 1, 2

# Using the "+" operator:

a + b # = 3

# Using the "in-place" "+=" operator to add and assign:

a += b # a = 3 (equivalent to a = a + b)

import operator # contains 2 argument arithmetic functions for the examples

operator.add(a, b) # = 5 since a is set to 3 right before this line

# The "+=" operator is equivalent to:

a = operator.iadd(a, b) # a = 5 since a is set to 3 right before this line

Possible combinations (builtin types):

int and int (gives an int)

Python® Notes for Professionals 56

 int and float (gives a float)
int and complex (gives a complex)
float and float (gives a float)
float and complex (gives a complex)
complex and complex (gives a complex)

Note: the + operator is also used for concatenating strings, lists and tuples:

"first string " + "second string" # = 'first string second string'

[1, 2, 3] + [4, 5, 6] # = [1, 2, 3, 4, 5, 6]

Section 9.3: Exponentation

a, b = 2, 3

(a ** b) # = 8
pow(a, b) # = 8

import math
math.pow(a, b) # = 8.0 (always float; does not allow complex results)

import operator
operator.pow(a, b) # = 8

Another difference between the built-in pow and math.pow is that the built-in pow can accept three arguments:

a, b, c = 2, 3, 2

pow(2, 3, 2) # 0, calculates (2 ** 3) % 2, but as per Python docs,

# does so more efficiently

Special functions

The function math.sqrt(x) calculates the square root of x.

import math
import cmath
c = 4
math.sqrt(c) # = 2.0 (always float; does not allow complex results)
cmath.sqrt(c) # = (2+0j) (always complex)

To compute other roots, such as a cube root, raise the number to the reciprocal of the degree of the root. This
could be done with any of the exponential functions or operator.

import math
x = 8
math.pow(x, 1/3) # evaluates to 2.0
x**(1/3) # evaluates to 2.0

The function math.exp(x) computes e ** x.

math.exp(0) # 1.0
math.exp(1) # 2.718281828459045 (e)

The function math.expm1(x) computes e ** x - 1. When x is small, this gives significantly better precision than
math.exp(x) - 1.

Python® Notes for Professionals 57

math.expm1(0) # 0.0

math.exp(1e-6) - 1 # 1.0000004999621837e-06
math.expm1(1e-6) # 1.0000005000001665e-06
# exact result # 1.000000500000166666708333341666...

Section 9.4: Trigonometric Functions

a, b = 1, 2

import math

math.sin(a) # returns the sine of 'a' in radians

# Out: 0.8414709848078965

math.cosh(b) # returns the inverse hyperbolic cosine of 'b' in radians

# Out: 3.7621956910836314

math.atan(math.pi) # returns the arc tangent of 'pi' in radians

# Out: 1.2626272556789115

math.hypot(a, b) # returns the Euclidean norm, same as math.sqrt(a*a + b*b)

# Out: 2.23606797749979

Note that math.hypot(x, y) is also the length of the vector (or Euclidean distance) from the origin (0, 0)
to the point (x, y).

To compute the Euclidean distance between two points (x1, y1) & (x2, y2) you can use math.hypot as
follows

math.hypot(x2-x1, y2-y1)

To convert from radians -> degrees and degrees -> radians respectively use math.degrees and math.radians

math.degrees(a)
# Out: 57.29577951308232

math.radians(57.29577951308232)
# Out: 1.0

Section 9.5: Inplace Operations

It is common within applications to need to have code like this :

a = a + 1

or

a = a * 2

There is an effective shortcut for these in place operations :

a += 1
# and
a *= 2

Python® Notes for Professionals 58

Any mathematic operator can be used before the '=' character to make an inplace operation :

-= decrement the variable in place

+= increment the variable in place
*= multiply the variable in place
/= divide the variable in place
//= floor divide the variable in place # Python 3
%= return the modulus of the variable in place
**= raise to a power in place

Other in place operators exist for the bitwise operators (^, | etc)

Section 9.6: Subtraction

a, b = 1, 2

# Using the "-" operator:

b - a # = 1

import operator # contains 2 argument arithmetic functions

operator.sub(b, a) # = 1

Possible combinations (builtin types):

int and int (gives an int)

int and float (gives a float)
int and complex (gives a complex)
float and float (gives a float)
float and complex (gives a complex)
complex and complex (gives a complex)

Section 9.7: Multiplication

a, b = 2, 3

a * b # = 6

import operator
operator.mul(a, b) # = 6

Possible combinations (builtin types):

int and int (gives an int)

int and float (gives a float)
int and complex (gives a complex)
float and float (gives a float)
float and complex (gives a complex)
complex and complex (gives a complex)

Note: The * operator is also used for repeated concatenation of strings, lists, and tuples:

3 * 'ab' # = 'ababab'
3 * ('a', 'b') # = ('a', 'b', 'a', 'b', 'a', 'b')

Python® Notes for Professionals 59

Section 9.8: Logarithms
By default, the math.log function calculates the logarithm of a number, base e. You can optionally specify a base as
the second argument.

import math
import cmath

math.log(5) # = 1.6094379124341003
# optional base argument. Default is math.e
math.log(5, math.e) # = 1.6094379124341003
cmath.log(5) # = (1.6094379124341003+0j)
math.log(1000, 10) # 3.0 (always returns float)
cmath.log(1000, 10) # (3+0j)

Special variations of the math.log function exist for different bases.

# Logarithm base e - 1 (higher precision for low values)

math.log1p(5) # = 1.791759469228055

# Logarithm base 2
math.log2(8) # = 3.0

# Logarithm base 10
math.log10(100) # = 2.0
cmath.log10(100) # = (2+0j)

Section 9.9: Modulus

Like in many other languages, Python uses the % operator for calculating modulus.

3 % 4 # 3
10 % 2 # 0
6 % 4 # 2

Or by using the operator module:

import operator

operator.mod(3 , 4) # 3
operator.mod(10 , 2) # 0
operator.mod(6 , 4) # 2

You can also use negative numbers.

-9 % 7 # 5
9 % -7 # -5
-9 % -7 # -2

If you need to find the result of integer division and modulus, you can use the divmod function as a shortcut:

quotient, remainder = divmod(9, 4)

# quotient = 2, remainder = 1 as 4 * 2 + 1 == 9

Python® Notes for Professionals 60

Chapter 10: Bitwise Operators
Bitwise operations alter binary strings at the bit level. These operations are incredibly basic and are directly
supported by the processor. These few operations are necessary in working with device drivers, low-level graphics,
cryptography, and network communications. This section provides useful knowledge and examples of Python's
bitwise operators.

Section 10.1: Bitwise NOT

The ~ operator will flip all of the bits in the number. Since computers use signed number representations — most
notably, the two's complement notation to encode negative binary numbers where negative numbers are written
with a leading one (1) instead of a leading zero (0).

This means that if you were using 8 bits to represent your two's-complement numbers, you would treat patterns
from 0000 0000 to 0111 1111 to represent numbers from 0 to 127 and reserve 1xxx xxxx to represent negative
numbers.

Eight-bit two's-complement numbers

Bits Unsigned Value Two's-complement Value

0000 0000 0 0
0000 0001 1 1
0000 0010 2 2
0111 1110 126 126
0111 1111 127 127
1000 0000 128 -128
1000 0001 129 -127
1000 0010 130 -126
1111 1110 254 -2
1111 1111 255 -1

In essence, this means that whereas 1010 0110 has an unsigned value of 166 (arrived at by adding (128 * 1) +
(64 * 0) + (32 * 1) + (16 * 0) + (8 * 0) + (4 * 1) + (2 * 1) + (1 * 0)), it has a two's-complement value
of -90 (arrived at by adding (128 * 1) - (64 * 0) - (32 * 1) - (16 * 0) - (8 * 0) - (4 * 1) - (2 * 1) -
(1 * 0), and complementing the value).

In this way, negative numbers range down to -128 (1000 0000). Zero (0) is represented as 0000 0000, and minus
one (-1) as 1111 1111.

In general, though, this means ~n = -n - 1.

# 0 = 0b0000 0000
~0
# Out: -1
# -1 = 0b1111 1111

# 1 = 0b0000 0001
~1
# Out: -2
# -2 = 1111 1110

# 2 = 0b0000 0010
~2
# Out: -3
# -3 = 0b1111 1101

Python® Notes for Professionals 61

# 123 = 0b0111 1011
~123
# Out: -124
# -124 = 0b1000 0100

Note, the overall effect of this operation when applied to positive numbers can be summarized:

~n -> -|n+1|

And then, when applied to negative numbers, the corresponding effect is:

~-n -> |n-1|

The following examples illustrate this last rule...

# -0 = 0b0000 0000
~-0
# Out: -1
# -1 = 0b1111 1111
# 0 is the obvious exception to this rule, as -0 == 0 always

# -1 = 0b1000 0001
~-1
# Out: 0
# 0 = 0b0000 0000

# -2 = 0b1111 1110
~-2
# Out: 1
# 1 = 0b0000 0001

# -123 = 0b1111 1011

~-123
# Out: 122
# 122 = 0b0111 1010

Section 10.2: Bitwise XOR (Exclusive OR)

The ^ operator will perform a binary XOR in which a binary 1 is copied if and only if it is the value of exactly one
operand. Another way of stating this is that the result is 1 only if the operands are different. Examples include:

# 0 ^ 0 = 0
# 0 ^ 1 = 1
# 1 ^ 0 = 1
# 1 ^ 1 = 0

# 60 = 0b111100
# 30 = 0b011110
60 ^ 30
# Out: 34
# 34 = 0b100010

bin(60 ^ 30)
# Out: 0b100010

Python® Notes for Professionals 62

Section 10.3: Bitwise AND
The & operator will perform a binary AND, where a bit is copied if it exists in both operands. That means:

# 0 & 0 = 0
# 0 & 1 = 0
# 1 & 0 = 0
# 1 & 1 = 1

# 60 = 0b111100
# 30 = 0b011110
60 & 30
# Out: 28
# 28 = 0b11100

bin(60 & 30)

# Out: 0b11100

Section 10.4: Bitwise OR

The | operator will perform a binary "or," where a bit is copied if it exists in either operand. That means:

# 0 | 0 = 0
# 0 | 1 = 1
# 1 | 0 = 1
# 1 | 1 = 1

# 60 = 0b111100
# 30 = 0b011110
60 | 30
# Out: 62
# 62 = 0b111110

bin(60 | 30)
# Out: 0b111110

Section 10.5: Bitwise Left Shift

The << operator will perform a bitwise "left shift," where the left operand's value is moved left by the number of bits
given by the right operand.

# 2 = 0b10
2 << 2
# Out: 8
# 8 = 0b1000

bin(2 << 2)
# Out: 0b1000

Performing a left bit shift of 1 is equivalent to multiplication by 2:

7 << 1
# Out: 14

Performing a left bit shift of n is equivalent to multiplication by 2**n:

3 << 4

Python® Notes for Professionals 63

# Out: 48

Section 10.6: Bitwise Right Shift

The >> operator will perform a bitwise "right shift," where the left operand's value is moved right by the number of
bits given by the right operand.

# 8 = 0b1000
8 >> 2
# Out: 2
# 2 = 0b10

bin(8 >> 2)
# Out: 0b10

Performing a right bit shift of 1 is equivalent to integer division by 2:

36 >> 1
# Out: 18

15 >> 1
# Out: 7

Performing a right bit shift of n is equivalent to integer division by 2**n:

48 >> 4
# Out: 3

59 >> 3
# Out: 7

Section 10.7: Inplace Operations

All of the Bitwise operators (except ~) have their own in place versions

a = 0b001
a &= 0b010
# a = 0b000

a = 0b001
a |= 0b010
# a = 0b011

a = 0b001
a <<= 2
# a = 0b100

a = 0b100
a >>= 2
# a = 0b001

a = 0b101
a ^= 0b011
# a = 0b110

Python® Notes for Professionals 64

Chapter 11: Boolean Operators
Section 11.1: `and` and `or` are not guaranteed to return a
boolean
When you use or, it will either return the first value in the expression if it's true, else it will blindly return the second
value. I.e. or is equivalent to:

def or_(a, b):

if a:
return a
else:
return b

For and, it will return its first value if it's false, else it returns the last value:

def and_(a, b):

if not a:
return a
else:
return b

Section 11.2: A simple example

In Python you can compare a single element using two binary operators--one on either side:

if 3.14 < x < 3.142:

print("x is near pi")

In many (most?) programming languages, this would be evaluated in a way contrary to regular math: (3.14 < x) <
3.142, but in Python it is treated like 3.14 < x and x < 3.142, just like most non-programmers would expect.

Section 11.3: Short-circuit evaluation

Python minimally evaluates Boolean expressions.

>>> def true_func():

... print("true_func()")
... return True
...
>>> def false_func():
... print("false_func()")
... return False
...
>>> true_func() or false_func()
true_func()
True
>>> false_func() or true_func()
false_func()
true_func()
True
>>> true_func() and false_func()
true_func()
false_func()
False
>>> false_func() and false_func()

Python® Notes for Professionals 65

false_func()
False

Section 11.4: and

Evaluates to the second argument if and only if both of the arguments are truthy. Otherwise evaluates to the first
falsey argument.

x = True
y = True
z = x and y # z = True

x = True
y = False
z = x and y # z = False

x = False
y = True
z = x and y # z = False

x = False
y = False
z = x and y # z = False

x = 1
y = 1
z = x and y # z = y, so z = 1, see `and` and `or` are not guaranteed to be a boolean

x = 0
y = 1
z = x and y # z = x, so z = 0 (see above)

x = 1
y = 0
z = x and y # z = y, so z = 0 (see above)

x = 0
y = 0
z = x and y # z = x, so z = 0 (see above)

The 1's in the above example can be changed to any truthy value, and the 0's can be changed to any falsey value.

Section 11.5: or
Evaluates to the first truthy argument if either one of the arguments is truthy. If both arguments are falsey,
evaluates to the second argument.

x = True
y = True
z = x or y # z = True

x = True
y = False
z = x or y # z = True

x = False
y = True
z = x or y # z = True

Python® Notes for Professionals 66

x = False
y = False
z = x or y # z = False

x = 1
y = 1
z = x or y # z = x, so z = 1, see `and` and `or` are not guaranteed to be a boolean

x = 1
y = 0
z = x or y # z = x, so z = 1 (see above)

x = 0
y = 1
z = x or y # z = y, so z = 1 (see above)

x = 0
y = 0
z = x or y # z = y, so z = 0 (see above)

The 1's in the above example can be changed to any truthy value, and the 0's can be changed to any falsey value.

Section 11.6: not

It returns the opposite of the following statement:

x = True
y = not x # y = False

x = False
y = not x # y = True

Python® Notes for Professionals 67

Chapter 12: Operator Precedence
Python operators have a set order of precedence, which determines what operators are evaluated first in a
potentially ambiguous expression. For instance, in the expression 3 * 2 + 7, first 3 is multiplied by 2, and then the
result is added to 7, yielding 13. The expression is not evaluated the other way around, because * has a higher
precedence than +.

Below is a list of operators by precedence, and a brief description of what they (usually) do.

Section 12.1: Simple Operator Precedence Examples in python

Python follows PEMDAS rule. PEMDAS stands for Parentheses, Exponents, Multiplication and Division, and Addition
and Subtraction.

Example:

>>> a, b, c, d = 2, 3, 5, 7
>>> a ** (b + c) # parentheses
256
>>> a * b ** c # exponent: same as `a * (b ** c)`
7776
>>> a + b * c / d # multiplication / division: same as `a + (b * c / d)`
4.142857142857142

Extras: mathematical rules hold, but not always:

>>> 300 / 300 * 200

200.0
>>> 300 * 200 / 300
200.0
>>> 1e300 / 1e300 * 1e200
1e+200
>>> 1e300 * 1e200 / 1e300
inf

Python® Notes for Professionals 68

Chapter 13: Filter
Parameter Details
function callable that determines the condition or None then use the identity function for filtering (positional-only)
iterable iterable that will be filtered (positional-only)

Section 13.1: Basic use of filter

To filter discards elements of a sequence based on some criteria:

names = ['Fred', 'Wilma', 'Barney']

def long_name(name):
return len(name) > 5

Python 2.x Version ≥ 2.0

filter(long_name, names)
# Out: ['Barney']

[name for name in names if len(name) > 5] # equivalent list comprehension

# Out: ['Barney']

from itertools import ifilter

ifilter(long_name, names) # as generator (similar to python 3.x filter builtin)
# Out: <itertools.ifilter at 0x4197e10>
list(ifilter(long_name, names)) # equivalent to filter with lists
# Out: ['Barney']

(name for name in names if len(name) > 5) # equivalent generator expression

# Out: <generator object <genexpr> at 0x0000000003FD5D38>

Python 2.x Version ≥ 2.6

# Besides the options for older python 2.x versions there is a future_builtin function:
from future_builtins import filter
filter(long_name, names) # identical to itertools.ifilter
# Out: <itertools.ifilter at 0x3eb0ba8>

Python 3.x Version ≥ 3.0

filter(long_name, names) # returns a generator

# Out: <filter at 0x1fc6e443470>
list(filter(long_name, names)) # cast to list
# Out: ['Barney']

(name for name in names if len(name) > 5) # equivalent generator expression

# Out: <generator object <genexpr> at 0x000001C6F49BF4C0>

Section 13.2: Filter without function

If the function parameter is None, then the identity function will be used:

list(filter(None, [1, 0, 2, [], '', 'a'])) # discards 0, [] and ''

# Out: [1, 2, 'a']

Python 2.x Version ≥ 2.0.1

[i for i in [1, 0, 2, [], '', 'a'] if i] # equivalent list comprehension

Python 3.x Version ≥ 3.0.0

(i for i in [1, 0, 2, [], '', 'a'] if i) # equivalent generator expression

Python® Notes for Professionals 69

Section 13.3: Filter as short-circuit check
filter (python 3.x) and ifilter (python 2.x) return a generator so they can be very handy when creating a short-
circuit test like or or and:

Python 2.x Version ≥ 2.0.1

# not recommended in real use but keeps the example short:

from itertools import ifilter as filter

Python 2.x Version ≥ 2.6.1

from future_builtins import filter

To find the first element that is smaller than 100:

car_shop = [('Toyota', 1000), ('rectangular tire', 80), ('Porsche', 5000)]

def find_something_smaller_than(name_value_tuple):
print('Check {0}, {1}$'.format(*name_value_tuple)
return name_value_tuple[1] < 100
next(filter(find_something_smaller_than, car_shop))
# Print: Check Toyota, 1000$
# Check rectangular tire, 80$
# Out: ('rectangular tire', 80)

The next-function gives the next (in this case first) element of and is therefore the reason why it's short-circuit.

Section 13.4: Complementary function: filterfalse, ifilterfalse

There is a complementary function for filter in the itertools-module:

Python 2.x Version ≥ 2.0.1

# not recommended in real use but keeps the example valid for python 2.x and python 3.x
from itertools import ifilterfalse as filterfalse

Python 3.x Version ≥ 3.0.0

from itertools import filterfalse

which works exactly like the generator filter but keeps only the elements that are False:

# Usage without function (None):

list(filterfalse(None, [1, 0, 2, [], '', 'a'])) # discards 1, 2, 'a'
# Out: [0, [], '']

# Usage with function

names = ['Fred', 'Wilma', 'Barney']

def long_name(name):
return len(name) > 5

list(filterfalse(long_name, names))
# Out: ['Fred', 'Wilma']

# Short-circuit useage with next:

car_shop = [('Toyota', 1000), ('rectangular tire', 80), ('Porsche', 5000)]
def find_something_smaller_than(name_value_tuple):
print('Check {0}, {1}$'.format(*name_value_tuple)
return name_value_tuple[1] < 100
next(filterfalse(find_something_smaller_than, car_shop))
# Print: Check Toyota, 1000$

Python® Notes for Professionals 70

# Out: ('Toyota', 1000)

# Using an equivalent generator:

car_shop = [('Toyota', 1000), ('rectangular tire', 80), ('Porsche', 5000)]
generator = (car for car in car_shop if not car[1] < 100)
next(generator)

Python® Notes for Professionals 71

Chapter 14: Arrays
Parameter Details
b Represents signed integer of size 1 byte
B Represents unsigned integer of size 1 byte
c Represents character of size 1 byte
u Represents unicode character of size 2 bytes
h Represents signed integer of size 2 bytes
H Represents unsigned integer of size 2 bytes
i Represents signed integer of size 2 bytes
I Represents unsigned integer of size 2 bytes
w Represents unicode character of size 4 bytes
l Represents signed integer of size 4 bytes
L Represents unsigned integer of size 4 bytes
f Represents floating point of size 4 bytes
d Represents floating point of size 8 bytes
"Arrays" in Python are not the arrays in conventional programming languages like C and Java, but closer to lists. A
list can be a collection of either homogeneous or heterogeneous elements, and may contain ints, strings or other
lists.

Section 14.1: Access individual elements through indexes

Individual elements can be accessed through indexes. Python arrays are zero-indexed. Here is an example :

my_array = array('i', [1,2,3,4,5])

print(my_array[1])
# 2
print(my_array[2])
# 3
print(my_array[0])
# 1

Section 14.2: Basic Introduction to Arrays

An array is a data structure that stores values of same data type. In Python, this is the main difference between
arrays and lists.

While python lists can contain values corresponding to different data types, arrays in python can only contain
values corresponding to same data type. In this tutorial, we will understand the Python arrays with few examples.

If you are new to Python, get started with the Python Introduction article.

To use arrays in python language, you need to import the standard array module. This is because array is not a
fundamental data type like strings, integer etc. Here is how you can import array module in python :

from array import *

Once you have imported the array module, you can declare an array. Here is how you do it:

arrayIdentifierName = array(typecode, [Initializers])

In the declaration above, arrayIdentifierName is the name of array, typecode lets python know the type of array
and Initializers are the values with which array is initialized.

Python® Notes for Professionals 72

Typecodes are the codes that are used to define the type of array values or the type of array. The table in the
parameters section shows the possible values you can use when declaring an array and it's type.

Here is a real world example of python array declaration :

my_array = array('i',[1,2,3,4])

In the example above, typecode used is i. This typecode represents signed integer whose size is 2 bytes.

Here is a simple example of an array containing 5 integers

from array import *

my_array = array('i', [1,2,3,4,5])
for i in my_array:
print(i)
# 1
# 2
# 3
# 4
# 5

Section 14.3: Append any value to the array using append()

method
my_array = array('i', [1,2,3,4,5])
my_array.append(6)
# array('i', [1, 2, 3, 4, 5, 6])

Note that the value 6 was appended to the existing array values.

Section 14.4: Insert value in an array using insert() method

We can use the insert() method to insert a value at any index of the array. Here is an example :

my_array = array('i', [1,2,3,4,5])

my_array.insert(0,0)
#array('i', [0, 1, 2, 3, 4, 5])

In the above example, the value 0 was inserted at index 0. Note that the first argument is the index while second
argument is the value.

Section 14.5: Extend python array using extend() method

A python array can be extended with more than one value using extend() method. Here is an example :

my_array = array('i', [1,2,3,4,5])

my_extnd_array = array('i', [7,8,9,10])
my_array.extend(my_extnd_array)
# array('i', [1, 2, 3, 4, 5, 7, 8, 9, 10])

We see that the array my_array was extended with values from my_extnd_array.

Section 14.6: Add items from list into array using fromlist()

Python® Notes for Professionals 73

method
Here is an example:

my_array = array('i', [1,2,3,4,5])

c=[11,12,13]
my_array.fromlist(c)
# array('i', [1, 2, 3, 4, 5, 11, 12, 13])

So we see that the values 11,12 and 13 were added from list c to my_array.

Section 14.7: Remove any array element using remove()

method
Here is an example :

my_array = array('i', [1,2,3,4,5])

my_array.remove(4)
# array('i', [1, 2, 3, 5])

We see that the element 4 was removed from the array.

Section 14.8: Remove last array element using pop() method

pop removes the last element from the array. Here is an example :

my_array = array('i', [1,2,3,4,5])

my_array.pop()
# array('i', [1, 2, 3, 4])

So we see that the last element (5) was popped out of array.

Section 14.9: Fetch any element through its index using index()
method
index() returns first index of the matching value. Remember that arrays are zero-indexed.

my_array = array('i', [1,2,3,4,5])

print(my_array.index(5))
# 5
my_array = array('i', [1,2,3,3,5])
print(my_array.index(3))
# 3

Note in that second example that only one index was returned, even though the value exists twice in the array

Section 14.10: Reverse a python array using reverse() method

The reverse() method does what the name says it will do - reverses the array. Here is an example :

my_array = array('i', [1,2,3,4,5])

my_array.reverse()
# array('i', [5, 4, 3, 2, 1])

Python® Notes for Professionals 74

Section 14.11: Get array buer information through
buer_info() method
This method provides you the array buffer start address in memory and number of elements in array. Here is an
example:

my_array = array('i', [1,2,3,4,5])

my_array.buffer_info()
(33881712, 5)

Section 14.12: Check for number of occurrences of an element

using count() method
count() will return the number of times and element appears in an array. In the following example we see that the
value 3 occurs twice.

my_array = array('i', [1,2,3,3,5])

my_array.count(3)
# 2

Section 14.13: Convert array to string using tostring() method

tostring() converts the array to a string.

my_char_array = array('c', ['g','e','e','k'])

# array('c', 'geek')
print(my_char_array.tostring())
# geek

Section 14.14: Convert array to a python list with same

elements using tolist() method
When you need a Python list object, you can utilize the tolist() method to convert your array to a list.

my_array = array('i', [1,2,3,4,5])

c = my_array.tolist()
# [1, 2, 3, 4, 5]

Section 14.15: Append a string to char array using

fromstring() method
You are able to append a string to a character array using fromstring()

my_char_array = array('c', ['g','e','e','k'])

my_char_array.fromstring("stuff")
print(my_char_array)
#array('c', 'geekstuff')

Python® Notes for Professionals 75

Chapter 15: Dictionary
Parameter Details
key The desired key to lookup
value The value to set or return

Section 15.1: Introduction to Dictionary

A dictionary is an example of a key value store also known as Mapping in Python. It allows you to store and retrieve
elements by referencing a key. As dictionaries are referenced by key, they have very fast lookups. As they are
primarily used for referencing items by key, they are not sorted.

creating a dict

Dictionaries can be initiated in many ways:

literal syntax
d = {} # empty dict
d = {'key': 'value'} # dict with initial values

Python 3.x Version ≥ 3.5

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict

d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

dict comprehension
d = {k:v for k,v in [('key', 'value',)]}

see also: Comprehensions

built-in class: dict()

d = dict() # emtpy dict
d = dict(key='value') # explicit keyword arguments
d = dict([('key', 'value')]) # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)

modifying a dict

To add items to a dictionary, simply create a new key with a value:

d['newkey'] = 42

It also possible to add list and dictionary as value:

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

To delete an item, delete the key from the dictionary:

del d['newkey']

Python® Notes for Professionals 76

Section 15.2: Avoiding KeyError Exceptions
One common pitfall when using dictionaries is to access a non-existent key. This typically results in a KeyError
exception

mydict = {}
mydict['not there']

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
KeyError: 'not there'

One way to avoid key errors is to use the dict.get method, which allows you to specify a default value to return in
the case of an absent key.

value = mydict.get(key, default_value)

Which returns mydict[key] if it exists, but otherwise returns default_value. Note that this doesn't add key to
mydict. So if you want to retain that key value pair, you should use mydict.setdefault(key, default_value),
which does store the key value pair.

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

An alternative way to deal with the problem is catching the exception

try:
value = mydict[key]
except KeyError:
value = default_value

You could also check if the key is in the dictionary.

if key in mydict:
value = mydict[key]
else:
value = default_value

Do note, however, that in multi-threaded environments it is possible for the key to be removed from the dictionary
after you check, creating a race condition where the exception can still be thrown.

Another option is to use a subclass of dict, collections.defaultdict, that has a default_factory to create new entries in
the dict when given a new_key.

Section 15.3: Iterating Over a Dictionary

If you use a dictionary as an iterator (e.g. in a for statement), it traverses the keys of the dictionary. For example:

Python® Notes for Professionals 77

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
print(key, d[key])
# c 3
# b 2
# a 1

The same is true when used in a comprehension

print([key for key in d])

# ['c', 'b', 'a']

Python 3.x Version ≥ 3.0

The items() method can be used to loop over both the key and value simultaneously:

for key, value in d.items():

print(key, value)
# c 3
# b 2
# a 1

While the values() method can be used to iterate over only the values, as would be expected:

for key, value in d.values():

print(key, value)
# 3
# 2
# 1

Python 2.x Version ≥ 2.2

Here, the methods keys(), values() and items() return lists, and there are the three extra methods iterkeys()
itervalues() and iteritems() to return iteraters.

Section 15.4: Dictionary with default values

Available in the standard library as defaultdict

from collections import defaultdict

d = defaultdict(int)
d['key'] # 0
d['key'] = 5
d['key'] # 5

d = defaultdict(lambda: 'empty')
d['key'] # 'empty'
d['key'] = 'full'
d['key'] # 'full'

[*] Alternatively, if you must use the built-in dict class, using dict.setdefault() will allow you to create a default
whenever you access a key that did not exist before:

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d

Python® Notes for Professionals 78

{'Another_key': ['This worked!']}

Keep in mind that if you have many values to add, dict.setdefault() will create a new instance of the initial value
(in this example a []) every time it's called - which may create unnecessary workloads.

[*] Python Cookbook, 3rd edition, by David Beazley and Brian K. Jones (O’Reilly). Copyright 2013 David Beazley and Brian
Jones, 978-1-449-34037-7.

Section 15.5: Merging dictionaries

Consider the following dictionaries:

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}

>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5+
>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

As this example demonstrates, duplicate keys map to their lattermost value (for example "Clifford" overrides
"Nemo").

Python 3.3+
>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

With this technique the foremost value takes precedence for a given key rather than the last ("Clifford" is thrown
out in favor of "Nemo").

Python 2.x, 3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

This uses the lattermost value, as with the **-based technique for merging ("Clifford" overrides "Nemo").

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update uses the latter dict to overwrite the previous one.

Section 15.6: Accessing keys and values

When working with dictionaries, it's often necessary to access all the keys and values in the dictionary, either in a
for loop, a list comprehension, or just as a plain list.

Given a dictionary like:

mydict = {
'a': '1',
'b': '2'
}

Python® Notes for Professionals 79

You can get a list of keys using the keys() method:

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

If instead you want a list of values, use the values() method:

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

If you want to work with both the key and its corresponding value, you can use the items() method:

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

NOTE: Because a dict is unsorted, keys(), values(), and items() have no sort order. Use sort(), sorted(), or an
OrderedDict if you care about the order that these methods return.

Python 2/3 Difference: In Python 3, these methods return special iterable objects, not lists, and are the equivalent
of the Python 2 iterkeys(), itervalues(), and iteritems() methods. These objects can be used like lists for the
most part, though there are some differences. See PEP 3106 for more details.

Section 15.7: Accessing values of a dictionary

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

The above code will print 1234.

The string "Hello" in this example is called a key. It is used to lookup a value in the dict by placing the key in
square brackets.

The number 1234 is seen after the respective colon in the dict definition. This is called the value that "Hello" maps
to in this dict.

Looking up a value like this with a key that does not exist will raise a KeyError exception, halting execution if
uncaught. If we want to access a value without risking a KeyError, we can use the dictionary.get method. By
default if the key does not exist, the method will return None. We can pass it a second value to return instead of
None in the event of a failed lookup.

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

In this example w will get the value None and x will get the value "nuh-uh".

Section 15.8: Creating a dictionary

Rules for creating a dictionary:

Every key must be unique (otherwise it will be overridden)

Every key must be hashable (can use the hash function to hash it; otherwise TypeError will be thrown)

Python® Notes for Professionals 80

 There is no particular order for the keys.

# Creating and populating it with values

stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary

dictionary = {}

# And populating it after

dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists

mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list

mydict['a'].append(4) # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four') # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples

iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:

dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:

dictionary = dict.fromkeys((milk, eggs)) # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5)) # => {'milk': 2, 'eggs': 5}

Section 15.9: Creating an ordered dictionary

You can create an ordered dictionary which will follow a determined order when iterating over the keys in the
dictionary.

Use OrderedDict from the collections module. This will always return the dictionary elements in the original
insertion order when iterated over.

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"

for key in d:
print(key, d[key])

Section 15.10: Unpacking dictionaries using the ** operator

You can use the ** keyword argument unpacking operator to deliver the key-value pairs in a dictionary into a
function's arguments. A simplified example from the official documentation:

>>>
>>> def parrot(voltage, state, action):
... print("This parrot wouldn't", action, end=' ')
... print("if you put", voltage, "volts through it.", end=' ')

Python® Notes for Professionals 81

... print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

As of Python 3.5 you can also use this syntax to merge an arbitrary number of dict objects.

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}

>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

As this example demonstrates, duplicate keys map to their lattermost value (for example "Clifford" overrides
"Nemo").

Section 15.11: The trailing comma

Like lists and tuples, you can include a trailing comma in your dictionary.

role = {"By day": "A typical programmer",

"By night": "Still a typical programmer", }

PEP 8 dictates that you should leave a space between the trailing comma and the closing brace.

Section 15.12: The dict() constructor

The dict() constructor can be used to create dictionaries from keyword arguments, or from a single iterable of
key-value pairs, or from a single dictionary and keyword arguments.

dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}

dict([('d', 4), ('e', 5), ('f', 6)]) # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3) # {'a': 1, 'b': 2, 'c': 3}

Section 15.13: Dictionaries Example

Dictionaries map keys to values.

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

Dictionary values can be accessed by their keys.

print "Little " + car["color"] + " " + car["model"] + "!"

# This would print out "Little Red Corvette!"

Dictionaries can also be created in a JSON style:

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

Python® Notes for Professionals 82

Dictionary values can be iterated over:

for key in car:

print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette

Section 15.14: All combinations of dictionary values

options = {
"x": ["a", "b"],
"y": [10, 20, 30]
}

Given a dictionary such as the one shown above, where there is a list representing a set of values to explore for the
corresponding key. Suppose you want to explore "x"="a" with "y"=10, then "x"="a" with"y"=10, and so on until
you have explored all possible combinations.

You can create a list that returns all such combinations of values using the following code.

import itertools

options = {
"x": ["a", "b"],
"y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

This gives us the following list stored in the variable combinations:

[{'x': 'a', 'y': 10},

{'x': 'b', 'y': 10},
{'x': 'a', 'y': 20},
{'x': 'b', 'y': 20},
{'x': 'a', 'y': 30},
{'x': 'b', 'y': 30}]

Python® Notes for Professionals 83

Chapter 16: List
The Python List is a general data structure widely used in Python programs. They are found in other languages,
often referred to as dynamic arrays. They are both mutable and a sequence data type that allows them to be indexed
and sliced. The list can contain different types of objects, including other list objects.

Section 16.1: List methods and supported operators

Starting with a given list a:

a = [1, 2, 3, 4, 5]

1. append(value) – appends a new element to the end of the list.

# Append values 6, 7, and 7 to the list

a.append(6)
a.append(7)
a.append(7)
# a: [1, 2, 3, 4, 5, 6, 7, 7]

# Append another list

b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]

# Append an element of a different type, as list elements do not need to have the same type
my_string = "hello world"
a.append(my_string)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]

Note that the append() method only appends one new element to the end of the list. If you append a list to
another list, the list that you append becomes a single element at the end of the first list.

# Appending a list to another list

a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
a[8]
# Returns: [8,9]

2. extend(enumerable) – extends the list by appending elements from another enumerable.

a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9, 10]

# Extend list by appending all elements from b

a.extend(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

# Extend list with elements from a non-list enumerable:

a.extend(range(3))
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]

Lists can also be concatenated with the + operator. Note that this does not modify any of the original lists:

Python® Notes for Professionals 84

 a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

3. index(value, [startIndex]) – gets the index of the first occurrence of the input value. If the input value is
not in the list a ValueError exception is raised. If a second argument is provided, the search is started at that
specified index.

a.index(7)
# Returns: 6

a.index(49) # ValueError, because 49 is not in a.

a.index(7, 7)
# Returns: 7

a.index(7, 8) # ValueError, because there is no 7 starting at index 8

4. insert(index, value) – inserts value just before the specified index. Thus after the insertion the new
element occupies position index.

a.insert(0, 0) # insert 0 at position 0

a.insert(2, 5) # insert 5 at position 2
# a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

5. pop([index]) – removes and returns the item at index. With no argument it removes and returns the last
element of the list.

a.pop(2)
# Returns: 5
# a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
a.pop(8)
# Returns: 7
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# With no argument:
a.pop()
# Returns: 10
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

6. remove(value) – removes the first occurrence of the specified value. If the provided value cannot be found, a
ValueError is raised.

a.remove(0)
a.remove(9)
# a: [1, 2, 3, 4, 5, 6, 7, 8]
a.remove(10)
# ValueError, because 10 is not in a

7. reverse() – reverses the list in-place and returns None.

a.reverse()
# a: [8, 7, 6, 5, 4, 3, 2, 1]

There are also other ways of reversing a list.

Python® Notes for Professionals 85

 8. count(value) – counts the number of occurrences of some value in the list.

a.count(7)
# Returns: 2

9. sort() – sorts the list in numerical and lexicographical order and returns None.

a.sort()
# a = [1, 2, 3, 4, 5, 6, 7, 8]
# Sorts the list in numerical order

Lists can also be reversed when sorted using the reverse=True flag in the sort() method.

a.sort(reverse=True)
# a = [8, 7, 6, 5, 4, 3, 2, 1]

If you want to sort by attributes of items, you can use the key keyword argument:

import datetime

class Person(object):
def __init__(self, name, birthday, height):
self.name = name
self.birthday = birthday
self.height = height

def __repr__(self):
return self.name

l = [Person("John Cena", datetime.date(1992, 9, 12), 175),

Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]

l.sort(key=lambda item: item.name)

# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item.birthday)

# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item.height)

# l: [John Cena, Chuck Norris, Jon Skeet]

In case of list of dicts the concept is the same:

import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},

{'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
{'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]

l.sort(key=lambda item: item['name'])

# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item['birthday'])

# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item['height'])

# l: [John Cena, Chuck Norris, Jon Skeet]

Python® Notes for Professionals 86

 Sort by sub dict :

import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175,

'weight': 100}},
{'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180,
'weight': 90}},
{'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185,
'weight': 110}}]

l.sort(key=lambda item: item['size']['height'])

# l: [John Cena, Chuck Norris, Jon Skeet]

Better way to sort using attrgetter and itemgetter

Lists can also be sorted using attrgetter and itemgetter functions from the operator module. These can help
improve readability and reusability. Here are some examples,

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
{'name':'chetan','age':18,'salary':5000},
{'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age

people.sort(key=by_salary) #in-place sorting by salary

itemgetter can also be given an index. This is helpful if you want to sort based on indices of a tuple.

list_of_tuples = [(1,2), (3,4), (5,0)]

list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

Use the attrgetter if you want to sort by attributes of an object,

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),

Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above
example

person.sort(key=attrgetter('name')) #sort by name

by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday

10. clear() – removes all items from the list

a.clear()
# a = []

11. Replication – multiplying an existing list by an integer will produce a larger list consisting of that many copies
of the original. This can be useful for example for list initialization:

b = ["blah"] * 3
# b = ["blah", "blah", "blah"]

Python® Notes for Professionals 87

 b = [1, 3, 5] * 5
# [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]

Take care doing this if your list contains references to objects (eg a list of lists), see Common Pitfalls - List
multiplication and common references.

12. Element deletion – it is possible to delete multiple elements in the list using the del keyword and slice
notation:

a = list(range(10))
del a[::2]
# a = [1, 3, 5, 7, 9]
del a[-1]
# a = [1, 3, 5, 7]
del a[:]
# a = []

13. Copying

The default assignment "=" assigns a reference of the original list to the new name. That is, the original name
and new name are both pointing to the same list object. Changes made through any of them will be reflected
in another. This is often not what you intended.

b = a
a.append(6)
# b: [1, 2, 3, 4, 5, 6]

If you want to create a copy of the list you have below options.

You can slice it:

new_list = old_list[:]

You can use the built in list() function:

new_list = list(old_list)

You can use generic copy.copy():

import copy
new_list = copy.copy(old_list) #inserts references to the objects found in the original.

This is a little slower than list() because it has to find out the datatype of old_list first.

If the list contains objects and you want to copy them as well, use generic copy.deepcopy():

import copy
new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.

Obviously the slowest and most memory-needing method, but sometimes unavoidable.

Python 3.x Version ≥ 3.0

Python® Notes for Professionals 88

copy() – Returns a shallow copy of the list

aa = a.copy()
# aa = [1, 2, 3, 4, 5]

Section 16.2: Accessing list values

Python lists are zero-indexed, and act like arrays in other languages.

lst = [1, 2, 3, 4]
lst[0] # 1
lst[1] # 2

Attempting to access an index outside the bounds of the list will raise an IndexError.

lst[4] # IndexError: list index out of range

Negative indices are interpreted as counting from the end of the list.

lst[-1] # 4
lst[-2] # 3
lst[-5] # IndexError: list index out of range

This is functionally equivalent to

lst[len(lst)-1] # 4

Lists allow to use slice notation as lst[start:end:step]. The output of the slice notation is a new list containing
elements from index start to end-1. If options are omitted start defaults to beginning of list, end to end of list and
step to 1:

lst[1:] # [2, 3, 4]
lst[:3] # [1, 2, 3]
lst[::2] # [1, 3]
lst[::-1] # [4, 3, 2, 1]
lst[-1:0:-1] # [4, 3, 2]
lst[5:8] # [] since starting index is greater than length of lst, returns empty list
lst[1:10] # [2, 3, 4] same as omitting ending index

With this in mind, you can print a reversed version of the list by calling

lst[::-1] # [4, 3, 2, 1]

When using step lengths of negative amounts, the starting index has to be greater than the ending index otherwise
the result will be an empty list.

lst[3:1:-1] # [4, 3]

Using negative step indices are equivalent to the following code:

reversed(lst)[0:2] # 0 = 1 -1
# 2 = 3 -1

The indices used are 1 less than those used in negative indexing and are reversed.

Python® Notes for Professionals 89

Advanced slicing

When lists are sliced the __getitem__() method of the list object is called, with a slice object. Python has a builtin
slice method to generate slice objects. We can use this to store a slice and reuse it later like so,

data = 'chandan purohit 22 2000' #assuming data fields of fixed length

name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)

#now we can have more readable slices

print(data[name_slice]) #chandan purohit
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

This can be of great use by providing slicing functionality to our objects by overriding __getitem__ in our class.

Section 16.3: Checking if list is empty

The emptiness of a list is associated to the boolean False, so you don't have to check len(lst) == 0, but just lst
or not lst

lst = []
if not lst:
print("list is empty")

# Output: list is empty

Section 16.4: Iterating over a list

Python supports using a for loop directly on a list:

my_list = ['foo', 'bar', 'baz']

for item in my_list:
print(item)

# Output: foo
# Output: bar
# Output: baz

You can also get the position of each item at the same time:

for (index, item) in enumerate(my_list):

print('The item in position {} is: {}'.format(index, item))

# Output: The item in position 0 is: foo

# Output: The item in position 1 is: bar
# Output: The item in position 2 is: baz

The other way of iterating a list based on the index value:

for i in range(0,len(my_list)):
print(my_list[i])
#output:
>>>
foo
bar

Python® Notes for Professionals 90

baz

Note that changing items in a list while iterating on it may have unexpected results:

for item in my_list:

if item == 'foo':
del my_list[0]
print(item)

# Output: foo
# Output: baz

In this last example, we deleted the first item at the first iteration, but that caused bar to be skipped.

Section 16.5: Checking whether an item is in a list

Python makes it very simple to check whether an item is in a list. Simply use the in operator.

lst = ['test', 'twest', 'tweast', 'treast']

'test' in lst
# Out: True

'toast' in lst
# Out: False

Note: the in operator on sets is asymptotically faster than on lists. If you need to use it many times on
potentially large lists, you may want to convert your list to a set, and test the presence of elements on
the set.

slst = set(lst)
'test' in slst
# Out: True

Section 16.6: Any and All

You can use all() to determine if all the values in an iterable evaluate to True

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

Likewise, any() determines if one or more values in an iterable evaluate to True

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

While this example uses a list, it is important to note these built-ins work with any iterable, including generators.

Python® Notes for Professionals 91

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

Section 16.7: Reversing list elements

You can use the reversed function which returns an iterator to the reversed list:

In [3]: rev = reversed(numbers)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Note that the list "numbers" remains unchanged by this operation, and remains in the same order it was originally.

To reverse in place, you can also use the reverse method.

You can also reverse a list (actually obtaining a copy, the original list is unaffected) by using the slicing syntax,
setting the third argument (the step) as -1:

In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

In [2]: numbers[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

Section 16.8: Concatenate and Merge lists

1. The simplest way to concatenate list1 and list2:

merged = list1 + list2

2. zip returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument
sequences or iterables:

alist = ['a1', 'a2', 'a3']

blist = ['b1', 'b2', 'b3']

for a, b in zip(alist, blist):

print(a, b)

# Output:
# a1 b1
# a2 b2
# a3 b3

If the lists have different lengths then the result will include only as many elements as the shortest one:

alist = ['a1', 'a2', 'a3']

blist = ['b1', 'b2', 'b3', 'b4']
for a, b in zip(alist, blist):
print(a, b)

# Output:
# a1 b1

Python® Notes for Professionals 92

 # a2 b2
# a3 b3

alist = []
len(list(zip(alist, blist)))

# Output:
# 0

For padding lists of unequal length to the longest one with Nones use itertools.zip_longest
(itertools.izip_longest in Python 2)

alist = ['a1', 'a2', 'a3']

blist = ['b1']
clist = ['c1', 'c2', 'c3', 'c4']

for a,b,c in itertools.zip_longest(alist, blist, clist):

print(a, b, c)

# Output:
# a1 b1 c1
# a2 None c2
# a3 None c3
# None None c4

3. Insert to a specific index values:

alist = [123, 'xyz', 'zara', 'abc']

alist.insert(3, [2009])
print("Final List :", alist)

Output:

Final List : [123, 'xyz', 'zara', 2009, 'abc']

Section 16.9: Length of a list

Use len() to get the one-dimensional length of a list.

len(['one', 'two']) # returns 2

len(['one', [2, 3], 'four']) # returns 3, not 4

len() also works on strings, dictionaries, and other data structures similar to lists.

Note that len() is a built-in function, not a method of a list object.

Also note that the cost of len() is O(1), meaning it will take the same amount of time to get the length of a list
regardless of its length.

Section 16.10: Remove duplicate values in list

Removing duplicate values in a list can be done by converting the list to a set (that is an unordered collection of
distinct objects). If a list data structure is needed, then the set can be converted back to a list using the function
list():

Python® Notes for Professionals 93

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

Note that by converting a list to a set the original ordering is lost.

To preserve the order of the list one can use an OrderedDict

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

Section 16.11: Comparison of lists

It's possible to compare lists and other sequences lexicographically using comparison operators. Both operands
must be of the same type.

[1, 10, 100] < [2, 10, 100]

# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

If one of the lists is contained at the start of the other, the shortest list wins.

[1, 10] < [1, 10, 100]

# True

Section 16.12: Accessing values in nested list

Starting with a three-dimensional list:

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

Accessing items in the list:

print(alist[0][0][1])
#2
#Accesses second element in the first list in the first list

print(alist[1][1][2])
#10
#Accesses the third element in the second list in the second list

Performing support operations:

alist[0][0].append(11)
print(alist[0][0][2])
#11
#Appends 11 to the end of the first list in the first list

Python® Notes for Professionals 94

Using nested for loops to print the list:

for row in alist: #One way to loop through nested lists

for col in row:
print(col)
#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#[12, 13, 14]

Note that this operation can be used in a list comprehension or even as a generator to produce efficiencies, e.g.:

[col for row in alist for col in row]

#[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

Not all items in the outer lists have to be lists themselves:

alist[1].insert(2, 15)
#Inserts 15 into the third position in the second list

Another way to use nested for loops. The other way is better but I've needed to use this on occasion:

for row in range(len(alist)): #A less Pythonic way to loop through lists

for col in range(len(alist[row])):
print(alist[row][col])

#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#15
#[12, 13, 14]

Using slices in nested list:

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]
#Slices still work

The final list:

print(alist)
#[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

Section 16.13: Initializing a List to a Fixed Number of Elements

For immutable elements (e.g. None, string literals etc.):

my_list = [None] * 10
my_list = ['test'] * 10

For mutable elements, the same construct will result in all elements of the list referring to the same object, for
example, for a set:

>>> my_list=[{1}] * 10

Python® Notes for Professionals 95

>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

Instead, to initialize the list with a fixed number of different mutable objects, use:

my_list=[{1} for _ in range(10)]

Python® Notes for Professionals 96

Chapter 17: List comprehensions
List comprehensions in Python are concise, syntactic constructs. They can be utilized to generate lists from other
lists by applying functions to each element in the list. The following section explains and demonstrates the use of
these expressions.

Section 17.1: List Comprehensions

A list comprehension creates a new list by applying an expression to each element of an iterable. The most basic
form is:

[ <expression> for <element> in <iterable> ]

There's also an optional 'if' condition:

[ <expression> for <element> in <iterable> if <condition> ]

Each <element> in the <iterable> is plugged in to the <expression> if the (optional) <condition> evaluates to true
. All results are returned at once in the new list. Generator expressions are evaluated lazily, but list comprehensions
evaluate the entire iterator immediately - consuming memory proportional to the iterator's length.

To create a list of squared integers:

squares = [x * x for x in (1, 2, 3, 4)]

# squares: [1, 4, 9, 16]

The for expression sets x to each value in turn from (1, 2, 3, 4). The result of the expression x * x is appended
to an internal list. The internal list is assigned to the variable squares when completed.

Besides a speed increase (as explained here), a list comprehension is roughly equivalent to the following for-loop:

squares = []
for x in (1, 2, 3, 4):
squares.append(x * x)
# squares: [1, 4, 9, 16]

The expression applied to each element can be as complex as needed:

# Get a list of uppercase characters from a string

[s.upper() for s in "Hello World"]
# ['H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']

# Strip off any commas from the end of strings in a list

[w.strip(',') for w in ['these,', 'words,,', 'mostly', 'have,commas,']]
# ['these', 'words', 'mostly', 'have,commas']

# Organize letters in words more reasonably - in an alphabetical order

sentence = "Beautiful is better than ugly"
["".join(sorted(word, key = lambda x: x.lower())) for word in sentence.split()]
# ['aBefiltuu', 'is', 'beertt', 'ahnt', 'gluy']

else

else can be used in List comprehension constructs, but be careful regarding the syntax. The if/else clauses should
be used before for loop, not after:

Python® Notes for Professionals 97

# create a list of characters in apple, replacing non vowels with '*'
# Ex - 'apple' --> ['a', '*', '*', '*' ,'e']

[x for x in 'apple' if x in 'aeiou' else '*']

#SyntaxError: invalid syntax

# When using if/else together use them before the loop

[x if x in 'aeiou' else '*' for x in 'apple']
#['a', '*', '*', '*', 'e']

Note this uses a different language construct, a conditional expression, which itself is not part of the
comprehension syntax. Whereas the if after the for…in is a part of list comprehensions and used to filter elements
from the source iterable.

Double Iteration

Order of double iteration [... for x in ... for y in ...] is either natural or counter-intuitive. The rule of
thumb is to follow an equivalent for loop:

def foo(i):
return i, i + 0.5

for i in range(3):
for x in foo(i):
yield str(x)

This becomes:

[str(x)
for i in range(3)
for x in foo(i)
]

This can be compressed into one line as [str(x) for i in range(3) for x in foo(i)]

In-place Mutation and Other Side Effects

Before using list comprehension, understand the difference between functions called for their side effects
(mutating, or in-place functions) which usually return None, and functions that return an interesting value.

Many functions (especially pure functions) simply take an object and return some object. An in-place function
modifies the existing object, which is called a side effect. Other examples include input and output operations such
as printing.

list.sort() sorts a list in-place (meaning that it modifies the original list) and returns the value None. Therefore, it
won't work as expected in a list comprehension:

[x.sort() for x in [[2, 1], [4, 3], [0, 1]]]

# [None, None, None]

Instead, sorted() returns a sorted list rather than sorting in-place:

[sorted(x) for x in [[2, 1], [4, 3], [0, 1]]]

# [[1, 2], [3, 4], [0, 1]]

Using comprehensions for side-effects is possible, such as I/O or in-place functions. Yet a for loop is usually more

Python® Notes for Professionals 98

readable. While this works in Python 3:

[print(x) for x in (1, 2, 3)]

Instead use:

for x in (1, 2, 3):

print(x)

In some situations, side effect functions are suitable for list comprehension. random.randrange() has the side
effect of changing the state of the random number generator, but it also returns an interesting value. Additionally,
next() can be called on an iterator.

The following random value generator is not pure, yet makes sense as the random generator is reset every time the
expression is evaluated:

from random import randrange

[randrange(1, 7) for _ in range(10)]
# [2, 3, 2, 1, 1, 5, 2, 4, 3, 5]

Whitespace in list comprehensions

More complicated list comprehensions can reach an undesired length, or become less readable. Although less
common in examples, it is possible to break a list comprehension into multiple lines like so:

[
x for x
in 'foo'
if x not in 'bar'
]

Section 17.2: Avoid repetitive and expensive operations using

conditional clause
Consider the below list comprehension:

>>> def f(x):

... import time
... time.sleep(.1) # Simulate expensive function
... return x**2

>>> [f(x) for x in range(1000) if f(x) > 10]

[16, 25, 36, ...]

This results in two calls to f(x) for 1,000 values of x: one call for generating the value and the other for checking the
if condition. If f(x) is a particularly expensive operation, this can have significant performance implications.
Worse, if calling f() has side effects, it can have surprising results.

Instead, you should evaluate the expensive operation only once for each value of x by generating an intermediate
iterable (generator expression) as follows:

>>> [v for v in (f(x) for x in range(1000)) if v > 10]

[16, 25, 36, ...]

Or, using the builtin map equivalent:

Python® Notes for Professionals 99

>>> [v for v in map(f, range(1000)) if v > 10]
[16, 25, 36, ...]

Another way that could result in a more readable code is to put the partial result (v in the previous example) in an
iterable (such as a list or a tuple) and then iterate over it. Since v will be the only element in the iterable, the result is
that we now have a reference to the output of our slow function computed only once:

>>> [v for x in range(1000) for v in [f(x)] if v > 10]

[16, 25, 36, ...]

However, in practice, the logic of code can be more complicated and it's important to keep it readable. In general, a
separate generator function is recommended over a complex one-liner:

>>> def process_prime_numbers(iterable):

... for x in iterable:
... if is_prime(x):
... yield f(x)
...
>>> [x for x in process_prime_numbers(range(1000)) if x > 10]
[11, 13, 17, 19, ...]

Another way to prevent computing f(x) multiple times is to use the @functools.lru_cache()(Python 3.2+)
decorator on f(x). This way since the output of f for the input x has already been computed once, the second
function invocation of the original list comprehension will be as fast as a dictionary lookup. This approach uses
memoization to improve efficiency, which is comparable to using generator expressions.

Say you have to flatten a list

l = [[1, 2, 3], [4, 5, 6], [7], [8, 9]]

Some of the methods could be:

reduce(lambda x, y: x+y, l)

sum(l, [])

list(itertools.chain(*l))

However list comprehension would provide the best time complexity.

[item for sublist in l for item in sublist]

The shortcuts based on + (including the implied use in sum) are, of necessity, O(L^2) when there are L sublists -- as
the intermediate result list keeps getting longer, at each step a new intermediate result list object gets allocated,
and all the items in the previous intermediate result must be copied over (as well as a few new ones added at the
end). So (for simplicity and without actual loss of generality) say you have L sublists of I items each: the first I items
are copied back and forth L-1 times, the second I items L-2 times, and so on; total number of copies is I times the
sum of x for x from 1 to L excluded, i.e., I * (L**2)/2.

The list comprehension just generates one list, once, and copies each item over (from its original place of residence
to the result list) also exactly once.

Python® Notes for Professionals 100

Section 17.3: Dictionary Comprehensions
A dictionary comprehension is similar to a list comprehension except that it produces a dictionary object instead of
a list.

A basic example:

Python 2.x Version ≥ 2.7

{x: x * x for x in (1, 2, 3, 4)}

# Out: {1: 1, 2: 4, 3: 9, 4: 16}

which is just another way of writing:

dict((x, x * x) for x in (1, 2, 3, 4))

# Out: {1: 1, 2: 4, 3: 9, 4: 16}

As with a list comprehension, we can use a conditional statement inside the dict comprehension to produce only
the dict elements meeting some criterion.

Python 2.x Version ≥ 2.7

{name: len(name) for name in ('Stack', 'Overflow', 'Exchange') if len(name) > 6}

# Out: {'Exchange': 8, 'Overflow': 8}

Or, rewritten using a generator expression.

dict((name, len(name)) for name in ('Stack', 'Overflow', 'Exchange') if len(name) > 6)

# Out: {'Exchange': 8, 'Overflow': 8}

Starting with a dictionary and using dictionary comprehension as a key-value pair filter

Python 2.x Version ≥ 2.7

initial_dict = {'x': 1, 'y': 2}

{key: value for key, value in initial_dict.items() if key == 'x'}
# Out: {'x': 1}

Switching key and value of dictionary (invert dictionary)

If you have a dict containing simple hashable values (duplicate values may have unexpected results):

my_dict = {1: 'a', 2: 'b', 3: 'c'}

and you wanted to swap the keys and values you can take several approaches depending on your coding style:

swapped = {v: k for k, v in my_dict.items()}

swapped = dict((v, k) for k, v in my_dict.iteritems())
swapped = dict(zip(my_dict.values(), my_dict))
swapped = dict(zip(my_dict.values(), my_dict.keys()))
swapped = dict(map(reversed, my_dict.items()))

print(swapped)
# Out: {a: 1, b: 2, c: 3}

Python 2.x Version ≥ 2.3

If your dictionary is large, consider importing itertools and utilize izip or imap.

Python® Notes for Professionals 101

Merging Dictionaries

Combine dictionaries and optionally override old values with a nested dictionary comprehension.

dict1 = {'w': 1, 'x': 1}

dict2 = {'x': 2, 'y': 2, 'z': 2}

{k: v for d in [dict1, dict2] for k, v in d.items()}

# Out: {'w': 1, 'x': 2, 'y': 2, 'z': 2}

However, dictionary unpacking (PEP 448) may be a preferred.

Python 3.x Version ≥ 3.5

{**dict1, **dict2}
# Out: {'w': 1, 'x': 2, 'y': 2, 'z': 2}

Note: dictionary comprehensions were added in Python 3.0 and backported to 2.7+, unlike list comprehensions,
which were added in 2.0. Versions < 2.7 can use generator expressions and the dict() builtin to simulate the
behavior of dictionary comprehensions.

Section 17.4: Generator Expressions

Generator expressions are very similar to list comprehensions. The main difference is that it does not create a full
set of results at once; it creates a generator object which can then be iterated over.

For instance, see the difference in the following code:

# list comprehension
[x**2 for x in range(10)]
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Python 2.x Version ≥ 2.4

# generator comprehension
(x**2 for x in xrange(10))
# Output: <generator object <genexpr> at 0x11b4b7c80>

These are two very different objects:

the list comprehension returns a list object whereas the generator comprehension returns a generator.

generator objects cannot be indexed and makes use of the next function to get items in order.

Note: We use xrange since it too creates a generator object. If we would use range, a list would be created. Also,
xrange exists only in later version of python 2. In python 3, range just returns a generator. For more information,
see the Differences between range and xrange functions example.

Python 2.x Version ≥ 2.4

g = (x**2 for x in xrange(10))

print(g[0])

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
TypeError: 'generator' object has no attribute '__getitem__'

g.next() # 0
g.next() # 1

Python® Notes for Professionals 102

g.next() # 4
...
g.next() # 81

g.next() # Throws StopIteration Exception

Traceback (most recent call last):

File "<stdin>", line 1, in <module>
StopIteration

Python 3.x Version ≥ 3.0

NOTE: The function g.next() should be substituted by next(g) and xrange with range since
Iterator.next() and xrange() do not exist in Python 3.

Although both of these can be iterated in a similar way:

for i in [x**2 for x in range(10)]:

print(i)

"""
Out:
0
1
4
...
81
"""

Python 2.x Version ≥ 2.4

for i in (x**2 for x in xrange(10)):

print(i)

"""
Out:
0
1
4
.
.
.
81
"""

Use cases

Generator expressions are lazily evaluated, which means that they generate and return each value only when the
generator is iterated. This is often useful when iterating through large datasets, avoiding the need to create a
duplicate of the dataset in memory:

for square in (x**2 for x in range(1000000)):

#do something

Another common use case is to avoid iterating over an entire iterable if doing so is not necessary. In this example,
an item is retrieved from a remote API with each iteration of get_objects(). Thousands of objects may exist, must
be retrieved one-by-one, and we only need to know if an object matching a pattern exists. By using a generator
expression, when we encounter an object matching the pattern.

Python® Notes for Professionals 103

def get_objects():
"""Gets objects from an API one by one"""
while True:
yield get_next_item()

def object_matches_pattern(obj):
# perform potentially complex calculation
return matches_pattern

def right_item_exists():
items = (object_matched_pattern(each) for each in get_objects())
for item in items:
if item.is_the_right_one:

return True
return False

Section 17.5: Set Comprehensions

Set comprehension is similar to list and dictionary comprehension, but it produces a set, which is an unordered
collection of unique elements.

Python 2.x Version ≥ 2.7

# A set containing every value in range(5):

{x for x in range(5)}
# Out: {0, 1, 2, 3, 4}

# A set of even numbers between 1 and 10:

{x for x in range(1, 11) if x % 2 == 0}
# Out: {2, 4, 6, 8, 10}

# Unique alphabetic characters in a string of text:

text = "When in the Course of human events it becomes necessary for one people..."
{ch.lower() for ch in text if ch.isalpha()}
# Out: set(['a', 'c', 'b', 'e', 'f', 'i', 'h', 'm', 'l', 'o',
# 'n', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y'])

Live Demo

Keep in mind that sets are unordered. This means that the order of the results in the set may differ from the one
presented in the above examples.

Note: Set comprehension is available since python 2.7+, unlike list comprehensions, which were added in 2.0. In
Python 2.2 to Python 2.6, the set() function can be used with a generator expression to produce the same result:

Python 2.x Version ≥ 2.2

set(x for x in range(5))

# Out: {0, 1, 2, 3, 4}

Section 17.6: Comprehensions involving tuples

The for clause of a list comprehension can specify more than one variable:

[x + y for x, y in [(1, 2), (3, 4), (5, 6)]]

# Out: [3, 7, 11]

Python® Notes for Professionals 104

[x + y for x, y in zip([1, 3, 5], [2, 4, 6])]
# Out: [3, 7, 11]

This is just like regular for loops:

for x, y in [(1,2), (3,4), (5,6)]:

print(x+y)
# 3
# 7
# 11

Note however, if the expression that begins the comprehension is a tuple then it must be parenthesized:

[x, y for x, y in [(1, 2), (3, 4), (5, 6)]]

# SyntaxError: invalid syntax

[(x, y) for x, y in [(1, 2), (3, 4), (5, 6)]]

# Out: [(1, 2), (3, 4), (5, 6)]

Section 17.7: Counting Occurrences Using Comprehension

When we want to count the number of items in an iterable, that meet some condition, we can use comprehension
to produce an idiomatic syntax:

# Count the numbers in `range(1000)` that are even and contain the digit `9`:
print (sum(
1 for x in range(1000)
if x % 2 == 0 and
'9' in str(x)
))
# Out: 95

The basic concept can be summarized as:

1. Iterate over the elements in range(1000).

2. Concatenate all the needed if conditions.
3. Use 1 as expression to return a 1 for each item that meets the conditions.
4. Sum up all the 1s to determine number of items that meet the conditions.

Note: Here we are not collecting the 1s in a list (note the absence of square brackets), but we are passing the ones
directly to the sum function that is summing them up. This is called a generator expression, which is similar to a
Comprehension.

Section 17.8: Changing Types in a List

Quantitative data is often read in as strings that must be converted to numeric types before processing. The types
of all list items can be converted with either a List Comprehension or the map() function.

# Convert a list of strings to integers.

items = ["1","2","3","4"]
[int(item) for item in items]
# Out: [1, 2, 3, 4]

# Convert a list of strings to float.

items = ["1","2","3","4"]
map(float, items)

Python® Notes for Professionals 105

# Out:[1.0, 2.0, 3.0, 4.0]

Python® Notes for Professionals 106

Chapter 18: List slicing (selecting parts of
lists)
Section 18.1: Using the third "step" argument
lst = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

lst[::2]
# Output: ['a', 'c', 'e', 'g']

lst[::3]
# Output: ['a', 'd', 'g']

Section 18.2: Selecting a sublist from a list

lst = ['a', 'b', 'c', 'd', 'e']

lst[2:4]
# Output: ['c', 'd']

lst[2:]
# Output: ['c', 'd', 'e']

lst[:4]
# Output: ['a', 'b', 'c', 'd']

Section 18.3: Reversing a list with slicing

a = [1, 2, 3, 4, 5]

# steps through the list backwards (step=-1)

b = a[::-1]

# built-in list method to reverse 'a'

a.reverse()

if a = b:
print(True)

print(b)

# Output:
# True
# [5, 4, 3, 2, 1]

Section 18.4: Shifting a list using slicing

def shift_list(array, s):
"""Shifts the elements of a list to the left or right.

Args:
array - the list to shift
s - the amount to shift the list ('+': right-shift, '-': left-shift)

Returns:
shifted_array - the shifted list

Python® Notes for Professionals 107

 """
# calculate actual shift amount (e.g., 11 --> 1 if length of the array is 5)
s %= len(array)

# reverse the shift direction to be more intuitive

s *= -1

# shift array with list slicing

shifted_array = array[s:] + array[:s]

return shifted_array

my_array = [1, 2, 3, 4, 5]

# negative numbers
shift_list(my_array, -7)
>>> [3, 4, 5, 1, 2]

# no shift on numbers equal to the size of the array

shift_list(my_array, 5)
>>> [1, 2, 3, 4, 5]

# works on positive numbers

shift_list(my_array, 3)
>>> [3, 4, 5, 1, 2]

Python® Notes for Professionals 108

Chapter 19: Linked lists
A linked list is a collection of nodes, each made up of a reference and a value. Nodes are strung together into a
sequence using their references. Linked lists can be used to implement more complex data structures like lists,
stacks, queues, and associative arrays.

Section 19.1: Single linked list example

This example implements a linked list with many of the same methods as that of the built-in list object.

class Node:
def __init__(self, val):
self.data = val
self.next = None

def getData(self):
return self.data

def getNext(self):
return self.next

def setData(self, val):

self.data = val

def setNext(self, val):

self.next = val

class LinkedList:
def __init__(self):
self.head = None

def isEmpty(self):
"""Check if the list is empty"""
return self.head is None

def add(self, item):

"""Add the item to the list"""
new_node = Node(item)
new_node.setNext(self.head)
self.head = new_node

def size(self):
"""Return the length/size of the list"""
count = 0
current = self.head
while current is not None:
count += 1
current = current.getNext()
return count

def search(self, item):

"""Search for item in list. If found, return True. If not found, return False"""
current = self.head
found = False
while current is not None and not found:
if current.getData() is item:
found = True
else:
current = current.getNext()

Python® Notes for Professionals 109

 return found

def remove(self, item):

"""Remove item from list. If item is not found in list, raise ValueError"""
current = self.head
previous = None
found = False
while current is not None and not found:
if current.getData() is item:
found = True
else:
previous = current
current = current.getNext()
if found:
if previous is None:
self.head = current.getNext()
else:
previous.setNext(current.getNext())
else:
raise ValueError
print 'Value not found.'

def insert(self, position, item):

"""
Insert item at position specified. If position specified is
out of bounds, raise IndexError
"""
if position > self.size() - 1:
raise IndexError
print "Index out of bounds."
current = self.head
previous = None
pos = 0
if position is 0:
self.add(item)
else:
new_node = Node(item)
while pos < position:
pos += 1
previous = current
current = current.getNext()
previous.setNext(new_node)
new_node.setNext(current)

def index(self, item):

"""
Return the index where item is found.
If item is not found, return None.
"""
current = self.head
pos = 0
found = False
while current is not None and not found:
if current.getData() is item:
found = True
else:
current = current.getNext()
pos += 1
if found:
pass
else:
pos = None

Python® Notes for Professionals 110

 return pos

def pop(self, position = None):

"""
If no argument is provided, return and remove the item at the head.
If position is provided, return and remove the item at that position.
If index is out of bounds, raise IndexError
"""
if position > self.size():
print 'Index out of bounds'
raise IndexError

current = self.head
if position is None:
ret = current.getData()
self.head = current.getNext()
else:
pos = 0
previous = None
while pos < position:
previous = current
current = current.getNext()
pos += 1
ret = current.getData()
previous.setNext(current.getNext())
print ret
return ret

def append(self, item):

"""Append item to the end of the list"""
current = self.head
previous = None
pos = 0
length = self.size()
while pos < length:
previous = current
current = current.getNext()
pos += 1
new_node = Node(item)
if previous is None:
new_node.setNext(current)
self.head = new_node
else:
previous.setNext(new_node)

def printList(self):
"""Print the list"""
current = self.head
while current is not None:
print current.getData()
current = current.getNext()

Usage functions much like that of the built-in list.

ll = LinkedList()
ll.add('l')
ll.add('H')
ll.insert(1,'e')
ll.append('l')
ll.append('o')
ll.printList()

Python® Notes for Professionals 111

H
e
l
l
o

Python® Notes for Professionals 112

Chapter 20: Linked List Node
Section 20.1: Write a simple Linked List Node in python
A linked list is either:

the empty list, represented by None, or

a node that contains a cargo object and a reference to a linked list.

#! /usr/bin/env python

class Node:
def __init__(self, cargo=None, next=None):
self.car = cargo
self.cdr = next
def __str__(self):
return str(self.car)

def display(lst):
if lst:
w("%s " % lst)
display(lst.cdr)
else:
w("nil\n")

Python® Notes for Professionals 113

Chapter 21: Tuple
A tuple is a immutable list of values. Tuples are one of Python's simplest and most common collection types, and
can be created with the comma operator (value = 1, 2, 3).

Section 21.1: Tuple

Syntactically, a tuple is a comma-separated list of values:

t = 'a', 'b', 'c', 'd', 'e'

Although not necessary, it is common to enclose tuples in parentheses:

t = ('a', 'b', 'c', 'd', 'e')

Create an empty tuple with parentheses:

t0 = ()
type(t0) # <type 'tuple'>

To create a tuple with a single element, you have to include a final comma:

t1 = 'a',
type(t1) # <type 'tuple'>

Note that a single value in parentheses is not a tuple:

t2 = ('a')
type(t2) # <type 'str'>

To create a singleton tuple it is necessary to have a trailing comma.

t2 = ('a',)
type(t2) # <type 'tuple'>

Note that for singleton tuples it's recommended (see PEP8 on trailing commas) to use parentheses. Also, no white
space after the trailing comma (see PEP8 on whitespaces)

t2 = ('a',) # PEP8-compliant
t2 = 'a', # this notation is not recommended by PEP8
t2 = ('a', ) # this notation is not recommended by PEP8

Another way to create a tuple is the built-in function tuple.

t = tuple('lupins')
print(t) # ('l', 'u', 'p', 'i', 'n', 's')
t = tuple(range(3))
print(t) # (0, 1, 2)

These examples are based on material from the book Think Python by Allen B. Downey.

Python® Notes for Professionals 114

Section 21.2: Tuples are immutable
One of the main differences between lists and tuples in Python is that tuples are immutable, that is, one cannot
add or modify items once the tuple is initialized. For example:

>>> t = (1, 4, 9)
>>> t[0] = 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Similarly, tuples don't have .append and .extend methods as list does. Using += is possible, but it changes the
binding of the variable, and not the tuple itself:

>>> t = (1, 2)
>>> q = t
>>> t += (3, 4)
>>> t
(1, 2, 3, 4)
>>> q
(1, 2)

Be careful when placing mutable objects, such as lists, inside tuples. This may lead to very confusing outcomes
when changing them. For example:

>>> t = (1, 2, 3, [1, 2, 3])

(1, 2, 3, [1, 2, 3])
>>> t[3] += [4, 5]

Will both raise an error and change the contents of the list within the tuple:

TypeError: 'tuple' object does not support item assignment

>>> t
(1, 2, 3, [1, 2, 3, 4, 5])

You can use the += operator to "append" to a tuple - this works by creating a new tuple with the new element you
"appended" and assign it to its current variable; the old tuple is not changed, but replaced!

This avoids converting to and from a list, but this is slow and is a bad practice, especially if you're going to append
multiple times.

Section 21.3: Packing and Unpacking Tuples

Tuples in Python are values separated by commas. Enclosing parentheses for inputting tuples are optional, so the
two assignments

a = 1, 2, 3 # a is the tuple (1, 2, 3)

and

a = (1, 2, 3) # a is the tuple (1, 2, 3)

are equivalent. The assignment a = 1, 2, 3 is also called packing because it packs values together in a tuple.

Note that a one-value tuple is also a tuple. To tell Python that a variable is a tuple and not a single value you can use

Python® Notes for Professionals 115

a trailing comma

a = 1 # a is the value 1
a = 1, # a is the tuple (1,)

A comma is needed also if you use parentheses

a = (1,) # a is the tuple (1,)

a = (1) # a is the value 1 and not a tuple

To unpack values from a tuple and do multiple assignments use

# unpacking AKA multiple assignment

x, y, z = (1, 2, 3)
# x == 1
# y == 2
# z == 3

The symbol _ can be used as a disposable variable name if one only needs some elements of a tuple, acting as a
placeholder:

a = 1, 2, 3, 4
_, x, y, _ = a
# x == 2
# y == 3

Single element tuples:

x, = 1, # x is the value 1
x = 1, # x is the tuple (1,)

In Python 3 a target variable with a * prefix can be used as a catch-all variable (see Unpacking Iterables ):

Python 3.x Version ≥ 3.0

first, *more, last = (1, 2, 3, 4, 5)

# first == 1
# more == [2, 3, 4]
# last == 5

Section 21.4: Built-in Tuple Functions

Tuples support the following build-in functions

Comparison

If elements are of the same type, python performs the comparison and returns the result. If elements are different
types, it checks whether they are numbers.

If numbers, perform comparison.

If either element is a number, then the other element is returned.
Otherwise, types are sorted alphabetically .

If we reached the end of one of the lists, the longer list is "larger." If both list are same it returns 0.

tuple1 = ('a', 'b', 'c', 'd', 'e')

tuple2 = ('1','2','3')

Python® Notes for Professionals 116

tuple3 = ('a', 'b', 'c', 'd', 'e')

cmp(tuple1, tuple2)
Out: 1

cmp(tuple2, tuple1)
Out: -1

cmp(tuple1, tuple3)
Out: 0

Tuple Length

The function len returns the total length of the tuple

len(tuple1)
Out: 5

Max of a tuple

The function max returns item from the tuple with the max value

max(tuple1)
Out: 'e'

max(tuple2)
Out: '3'

Min of a tuple

The function min returns the item from the tuple with the min value

min(tuple1)
Out: 'a'

min(tuple2)
Out: '1'

Convert a list into tuple

The built-in function tuple converts a list into a tuple.

list = [1,2,3,4,5]
tuple(list)
Out: (1, 2, 3, 4, 5)

Tuple concatenation

Use + to concatenate two tuples

tuple1 + tuple2
Out: ('a', 'b', 'c', 'd', 'e', '1', '2', '3')

Section 21.5: Tuple Are Element-wise Hashable and Equatable

hash( (1, 2) ) # ok
hash( ([], {"hello"}) # not ok, since lists and sets are not hashabe

Thus a tuple can be put inside a set or as a key in a dict only if each of its elements can.

{ (1, 2) } # ok

Python® Notes for Professionals 117

{ ([], {"hello"}) ) # not ok

Section 21.6: Indexing Tuples

x = (1, 2, 3)
x[0] # 1
x[1] # 2
x[2] # 3
x[3] # IndexError: tuple index out of range

Indexing with negative numbers will start from the last element as -1:

x[-1] # 3
x[-2] # 2
x[-3] # 1
x[-4] # IndexError: tuple index out of range

Indexing a range of elements

print(x[:-1]) # (1, 2)
print(x[-1:]) # (3,)
print(x[1:3]) # (2, 3)

Section 21.7: Reversing Elements

Reverse elements within a tuple

colors = "red", "green", "blue"

rev = colors[::-1]
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Or using reversed (reversed gives an iterable which is converted to a tuple):

rev = tuple(reversed(colors))
# rev: ("blue", "green", "red")
colors = rev
# colors: ("blue", "green", "red")

Python® Notes for Professionals 118

Chapter 22: Functions
Parameter Details
arg1, ..., argN Regular arguments
*args Unnamed positional arguments
kw1, ..., kwN Keyword-only arguments
**kwargs The rest of keyword arguments

Functions in Python provide organized, reusable and modular code to perform a set of specific actions. Functions
simplify the coding process, prevent redundant logic, and make the code easier to follow. This topic describes the
declaration and utilization of functions in Python.

Python has many built-in functions like print(), input(), len(). Besides built-ins you can also create your own
functions to do more specific jobs—these are called user-defined functions.

Section 22.1: Defining and calling simple functions

Using the def statement is the most common way to define a function in python. This statement is a so called single
clause compound statement with the following syntax:

def function_name(parameters):
statement(s)

function_name is known as the identifier of the function. Since a function definition is an executable statement its
execution binds the function name to the function object which can be called later on using the identifier.

parameters is an optional list of identifiers that get bound to the values supplied as arguments when the function is
called. A function may have an arbitrary number of arguments which are separated by commas.

statement(s) – also known as the function body – are a nonempty sequence of statements executed each time the
function is called. This means a function body cannot be empty, just like any indented block.

Here’s an example of a simple function definition which purpose is to print Hello each time it’s called:

def greet():
print("Hello")

Now let’s call the defined greet() function:

greet()
# Out: Hello

That’s an other example of a function definition which takes one single argument and displays the passed in value
each time the function is called:

def greet_two(greeting):
print(greeting)

After that the greet_two() function must be called with an argument:

greet_two("Howdy")
# Out: Howdy

Also you can give a default value to that function argument:

Python® Notes for Professionals 119

def greet_two(greeting="Howdy"):
print(greeting)

Now you can call the function without giving a value:

greet_two()
# Out: Howdy

You'll notice that unlike many other languages, you do not need to explicitly declare a return type of the function.
Python functions can return values of any type via the return keyword. One function can return any number of
different types!

def many_types(x):
if x < 0:
return "Hello!"
else:
return 0

print(many_types(1))
print(many_types(-1))

# Output:
0
Hello!

As long as this is handled correctly by the caller, this is perfectly valid Python code.

A function that reaches the end of execution without a return statement will always return None:

def do_nothing():
pass

print(do_nothing())
# Out: None

As mentioned previously a function definition must have a function body, a nonempty sequence of statements.
Therefore the pass statement is used as function body, which is a null operation – when it is executed, nothing
happens. It does what it means, it skips. It is useful as a placeholder when a statement is required syntactically, but
no code needs to be executed.

Section 22.2: Defining a function with an arbitrary number of

arguments
Arbitrary number of positional arguments:

Defining a function capable of taking an arbitrary number of arguments can be done by prefixing one of the
arguments with a *

def func(*args):
# args will be a tuple containing all values that are passed in
for i in args:
print(i)

func(1, 2, 3) # Calling it with 3 arguments

# Out: 1
# 2
# 3

Python® Notes for Professionals 120

list_of_arg_values = [1, 2, 3]
func(*list_of_arg_values) # Calling it with list of values, * expands the list
# Out: 1
# 2
# 3

func() # Calling it without arguments

# No Output

You can't provide a default for args, for example func(*args=[1, 2, 3]) will raise a syntax error (won't even
compile).

You can't provide these by name when calling the function, for example func(*args=[1, 2, 3]) will raise a
TypeError.

But if you already have your arguments in an array (or any other Iterable), you can invoke your function like this:
func(*my_stuff).

These arguments (*args) can be accessed by index, for example args[0] will return the first argument

Arbitrary number of keyword arguments

You can take an arbitrary number of arguments with a name by defining an argument in the definition with two *
in front of it:

def func(**kwargs):
# kwargs will be a dictionary containing the names as keys and the values as values
for name, value in kwargs.items():
print(name, value)

func(value1=1, value2=2, value3=3) # Calling it with 3 arguments

# Out: value1 1
# value2 2
# value3 3

func() # Calling it without arguments

# No Out put

my_dict = {'foo': 1, 'bar': 2}

func(**my_dict) # Calling it with a dictionary
# Out: foo 1
# bar 2

You can't provide these without names, for example func(1, 2, 3) will raise a TypeError.

kwargs is a plain native python dictionary. For example, args['value1'] will give the value for argument value1. Be
sure to check beforehand that there is such an argument or a KeyError will be raised.

Warning

You can mix these with other optional and required arguments but the order inside the definition matters.

The positional/keyword arguments come first. (Required arguments).

Then comes the arbitrary *arg arguments. (Optional).
Then keyword-only arguments come next. (Required).
Finally the arbitrary keyword **kwargs come. (Optional).

Python® Notes for Professionals 121

# |-positional-|-optional-|---keyword-only--|-optional-|
def func(arg1, arg2=10 , *args, kwarg1, kwarg2=2, **kwargs):
pass

arg1 must be given, otherwise a TypeError is raised. It can be given as positional (func(10)) or keyword
argument (func(arg1=10)).
kwarg1 must also be given, but it can only be provided as keyword-argument: func(kwarg1=10).
arg2 and kwarg2 are optional. If the value is to be changed the same rules as for arg1 (either positional or
keyword) and kwarg1 (only keyword) apply.
*args catches additional positional parameters. But note, that arg1 and arg2 must be provided as positional
arguments to pass arguments to *args: func(1, 1, 1, 1).
**kwargs catches all additional keyword parameters. In this case any parameter that is not arg1, arg2,
kwarg1 or kwarg2. For example: func(kwarg3=10).
In Python 3, you can use * alone to indicate that all subsequent arguments must be specified as keywords.
For instance the math.isclose function in Python 3.5 and higher is defined using def math.isclose (a, b,
*, rel_tol=1e-09, abs_tol=0.0), which means the first two arguments can be supplied positionally but the
optional third and fourth parameters can only be supplied as keyword arguments.

Python 2.x doesn't support keyword-only parameters. This behavior can be emulated with kwargs:

def func(arg1, arg2=10, **kwargs):

try:
kwarg1 = kwargs.pop("kwarg1")
except KeyError:
raise TypeError("missing required keyword-only argument: 'kwarg1'")

kwarg2 = kwargs.pop("kwarg2", 2)
# function body ...

Note on Naming

The convention of naming optional positional arguments args and optional keyword arguments kwargs is just a
convention you can use any names you like but it is useful to follow the convention so that others know what you
are doing, or even yourself later so please do.

Note on Uniqueness

Any function can be defined with none or one *args and none or one **kwargs but not with more than one of
each. Also *args must be the last positional argument and **kwargs must be the last parameter. Attempting to use
more than one of either will result in a Syntax Error exception.

Note on Nesting Functions with Optional Arguments

It is possible to nest such functions and the usual convention is to remove the items that the code has already
handled but if you are passing down the parameters you need to pass optional positional args with a * prefix and
optional keyword args with a ** prefix, otherwise args with be passed as a list or tuple and kwargs as a single
dictionary. e.g.:

def fn(**kwargs):
print(kwargs)
f1(**kwargs)

def f1(**kwargs):
print(len(kwargs))

fn(a=1, b=2)

Python® Notes for Professionals 122

# Out:
# {'a': 1, 'b': 2}
# 2

Section 22.3: Lambda (Inline/Anonymous) Functions

The lambda keyword creates an inline function that contains a single expression. The value of this expression is
what the function returns when invoked.

Consider the function:

def greeting():
return "Hello"

which, when called as:

print(greeting())

prints:

Hello

This can be written as a lambda function as follows:

greet_me = lambda: "Hello"

See note at the bottom of this section regarding the assignment of lambdas to variables. Generally, don't
do it.

This creates an inline function with the name greet_me that returns Hello. Note that you don't write return when
creating a function with lambda. The value after : is automatically returned.

Once assigned to a variable, it can be used just like a regular function:

print(greet_me())

prints:

Hello

lambdas can take arguments, too:

strip_and_upper_case = lambda s: s.strip().upper()

strip_and_upper_case(" Hello ")

returns the string:

HELLO

They can also take arbitrary number of arguments / keyword arguments, like normal functions.

greeting = lambda x, *args, **kwargs: print(x, args, kwargs)

Python® Notes for Professionals 123

greeting('hello', 'world', world='world')

prints:

hello ('world',) {'world': 'world'}

lambdas are commonly used for short functions that are convenient to define at the point where they are called
(typically with sorted, filter and map).

For example, this line sorts a list of strings ignoring their case and ignoring whitespace at the beginning and at the
end:

sorted( [" foo ", " bAR", "BaZ "], key=lambda s: s.strip().upper())
# Out:
# [' bAR', 'BaZ ', ' foo ']

Sort list just ignoring whitespaces:

sorted( [" foo ", " bAR", "BaZ "], key=lambda s: s.strip())
# Out:
# ['BaZ ', ' bAR', ' foo ']

Examples with map:

sorted( map( lambda s: s.strip().upper(), [" foo ", " bAR", "BaZ "]))
# Out:
# ['BAR', 'BAZ', 'FOO']

sorted( map( lambda s: s.strip(), [" foo ", " bAR", "BaZ "]))
# Out:
# ['BaZ', 'bAR', 'foo']

Examples with numerical lists:

my_list = [3, -4, -2, 5, 1, 7]

sorted( my_list, key=lambda x: abs(x))
# Out:
# [1, -2, 3, -4, 5, 7]

list( filter( lambda x: x>0, my_list))

# Out:
# [3, 5, 1, 7]

list( map( lambda x: abs(x), my_list))

# Out:
[3, 4, 2, 5, 1, 7]

One can call other functions (with/without arguments) from inside a lambda function.

def foo(msg):
print(msg)

greet = lambda x = "hello world": foo(x)

greet()

prints:

Python® Notes for Professionals 124

hello world

This is useful because lambda may contain only one expression and by using a subsidiary function one can run
multiple statements.

NOTE

Bear in mind that PEP-8 (the official Python style guide) does not recommend assigning lambdas to variables (as we
did in the first two examples):

Always use a def statement instead of an assignment statement that binds a lambda expression directly
to an identifier.

Yes:

def f(x): return 2*x

No:

f = lambda x: 2*x

The first form means that the name of the resulting function object is specifically f instead of the generic
<lambda>. This is more useful for tracebacks and string representations in general. The use of the
assignment statement eliminates the sole benefit a lambda expression can offer over an explicit def
statement (i.e. that it can be embedded inside a larger expression).

Section 22.4: Defining a function with optional arguments

Optional arguments can be defined by assigning (using =) a default value to the argument-name:

def make(action='nothing'):
return action

Calling this function is possible in 3 different ways:

make("fun")
# Out: fun

make(action="sleep")
# Out: sleep

# The argument is optional so the function will use the default value if the argument is
# not passed in.
make()
# Out: nothing

Warning

Mutable types (list, dict, set, etc.) should be treated with care when given as default attribute. Any
mutation of the default argument will change it permanently. See Defining a function with optional
mutable arguments.

Python® Notes for Professionals 125

Section 22.5: Defining a function with optional mutable
arguments
There is a problem when using optional arguments with a mutable default type (described in Defining a function
with optional arguments), which can potentially lead to unexpected behaviour.

Explanation

This problem arises because a function's default arguments are initialised once, at the point when the function is
defined, and not (like many other languages) when the function is called. The default values are stored inside the
function object's __defaults__ member variable.

def f(a, b=42, c=[]):

pass

print(f.__defaults__)
# Out: (42, [])

For immutable types (see Argument passing and mutability) this is not a problem because there is no way to
mutate the variable; it can only ever be reassigned, leaving the original value unchanged. Hence, subsequent are
guaranteed to have the same default value. However, for a mutable type, the original value can mutate, by making
calls to its various member functions. Therefore, successive calls to the function are not guaranteed to have the
initial default value.

def append(elem, to=[]):

to.append(elem) # This call to append() mutates the default variable "to"
return to

append(1)
# Out: [1]

append(2) # Appends it to the internally stored list

# Out: [1, 2]

append(3, []) # Using a new created list gives the expected result
# Out: [3]

# Calling it again without argument will append to the internally stored list again
append(4)
# Out: [1, 2, 4]

Note: Some IDEs like PyCharm will issue a warning when a mutable type is specified as a default
attribute.

Solution

If you want to ensure that the default argument is always the one you specify in the function definition, then the
solution is to always use an immutable type as your default argument.

A common idiom to achieve this when a mutable type is needed as the default, is to use None (immutable) as the
default argument and then assign the actual default value to the argument variable if it is equal to None.

def append(elem, to=None):

if to is None:
to = []

Python® Notes for Professionals 126

 to.append(elem)
return to

Section 22.6: Argument passing and mutability

First, some terminology:

argument (actual parameter): the actual variable being passed to a function;

parameter (formal parameter): the receiving variable that is used in a function.

In Python, arguments are passed by assignment (as opposed to other languages, where arguments can be
passed by value/reference/pointer).

Mutating a parameter will mutate the argument (if the argument's type is mutable).

def foo(x): # here x is the parameter

x[0] = 9 # This mutates the list labelled by both x and y
print(x)

y = [4, 5, 6]
foo(y) # call foo with y as argument
# Out: [9, 5, 6] # list labelled by x has been mutated
print(y)
# Out: [9, 5, 6] # list labelled by y has been mutated too

Reassigning the parameter won’t reassign the argument.

def foo(x): # here x is the parameter, when we call foo(y) we assign y to x

x[0] = 9 # This mutates the list labelled by both x and y
x = [1, 2, 3] # x is now labeling a different list (y is unaffected)
x[2] = 8 # This mutates x's list, not y's list

y = [4, 5, 6] # y is the argument, x is the parameter

foo(y) # Pretend that we wrote "x = y", then go to line 1
y
# Out: [9, 5, 6]

In Python, we don’t really assign values to variables, instead we bind (i.e. assign, attach) variables
(considered as names) to objects.

Immutable: Integers, strings, tuples, and so on. All operations make copies.
Mutable: Lists, dictionaries, sets, and so on. Operations may or may not mutate.

x = [3, 1, 9]
y = x
x.append(5) # Mutates the list labelled by x and y, both x and y are bound to [3, 1, 9]
x.sort() # Mutates the list labelled by x and y (in-place sorting)
x = x + [4] # Does not mutate the list (makes a copy for x only, not y)
z = x # z is x ([1, 3, 9, 4])
x += [6] # Mutates the list labelled by both x and z (uses the extend function).
x = sorted(x) # Does not mutate the list (makes a copy for x only).
x
# Out: [1, 3, 4, 5, 6, 9]
y
# Out: [1, 3, 5, 9]
z

Python® Notes for Professionals 127

# Out: [1, 3, 5, 9, 4, 6]

Section 22.7: Returning values from functions

Functions can return a value that you can use directly:

def give_me_five():
return 5

print(give_me_five()) # Print the returned value

# Out: 5

or save the value for later use:

num = give_me_five()
print(num) # Print the saved returned value
# Out: 5

or use the value for any operations:

print(give_me_five() + 10)
# Out: 15

If return is encountered in the function the function will be exited immediately and subsequent operations will not
be evaluated:

def give_me_another_five():
return 5
print('This statement will not be printed. Ever.')

print(give_me_another_five())
# Out: 5

You can also return multiple values (in the form of a tuple):

def give_me_two_fives():
return 5, 5 # Returns two 5

first, second = give_me_two_fives()

print(first)
# Out: 5
print(second)
# Out: 5

A function with no return statement implicitly returns None. Similarly a function with a return statement, but no
return value or variable returns None.

Section 22.8: Closure

Closures in Python are created by function calls. Here, the call to makeInc creates a binding for x that is referenced
inside the function inc. Each call to makeInc creates a new instance of this function, but each instance has a link to a
different binding of x.

def makeInc(x):
def inc(y):
# x is "attached" in the definition of inc

Python® Notes for Professionals 128

 return y + x

return inc

incOne = makeInc(1)
incFive = makeInc(5)

incOne(5) # returns 6
incFive(5) # returns 10

Notice that while in a regular closure the enclosed function fully inherits all variables from its enclosing
environment, in this construct the enclosed function has only read access to the inherited variables but cannot
make assignments to them

def makeInc(x):
def inc(y):
# incrementing x is not allowed
x += y
return x

return inc

incOne = makeInc(1)
incOne(5) # UnboundLocalError: local variable 'x' referenced before assignment

Python 3 offers the nonlocal statement (Nonlocal Variables ) for realizing a full closure with nested functions.

Python 3.x Version ≥ 3.0

def makeInc(x):
def inc(y):
nonlocal x
# now assigning a value to x is allowed
x += y
return x

return inc

incOne = makeInc(1)
incOne(5) # returns 6

Section 22.9: Forcing the use of named parameters

All parameters specified after the first asterisk in the function signature are keyword-only.

def f(*a, b):

pass

f(1, 2, 3)
# TypeError: f() missing 1 required keyword-only argument: 'b'

In Python 3 it's possible to put a single asterisk in the function signature to ensure that the remaining arguments
may only be passed using keyword arguments.

def f(a, b, *, c):

pass

f(1, 2, 3)
# TypeError: f() takes 2 positional arguments but 3 were given

Python® Notes for Professionals 129

f(1, 2, c=3)
# No error

Section 22.10: Nested functions

Functions in python are first-class objects. They can be defined in any scope

def fibonacci(n):
def step(a,b):
return b, a+b
a, b = 0, 1
for i in range(n):
a, b = step(a, b)
return a

Functions capture their enclosing scope can be passed around like any other sort of object

def make_adder(n):
def adder(x):
return n + x
return adder
add5 = make_adder(5)
add6 = make_adder(6)
add5(10)
#Out: 15
add6(10)
#Out: 16

def repeatedly_apply(func, n, x):

for i in range(n):
x = func(x)
return x

repeatedly_apply(add5, 5, 1)
#Out: 26

Section 22.11: Recursion limit

There is a limit to the depth of possible recursion, which depends on the Python implementation. When the limit is
reached, a RuntimeError exception is raised:

def cursing(depth):
try:
cursing(depth + 1) # actually, re-cursing
except RuntimeError as RE:
print('I recursed {} times!'.format(depth))

cursing(0)
# Out: I recursed 1083 times!

It is possible to change the recursion depth limit by using sys.setrecursionlimit(limit) and check this limit by
sys.getrecursionlimit().

sys.setrecursionlimit(2000)
cursing(0)
# Out: I recursed 1997 times!

Python® Notes for Professionals 130

From Python 3.5, the exception is a RecursionError, which is derived from RuntimeError.

Section 22.12: Recursive Lambda using assigned variable

One method for creating recursive lambda functions involves assigning the function to a variable and then
referencing that variable within the function itself. A common example of this is the recursive calculation of the
factorial of a number - such as shown in the following code:

lambda_factorial = lambda i:1 if i==0 else i*lambda_factorial(i-1)

print(lambda_factorial(4)) # 4 * 3 * 2 * 1 = 12 * 2 = 24

Description of code

The lambda function, through its variable assignment, is passed a value (4) which it evaluates and returns 1 if it is 0
or else it returns the current value (i) * another calculation by the lambda function of the value - 1 (i-1). This
continues until the passed value is decremented to 0 (return 1). A process which can be visualized as:

Section 22.13: Recursive functions

A recursive function is a function that calls itself in its definition. For example the mathematical function, factorial,
defined by factorial(n) = n*(n-1)*(n-2)*...*3*2*1. can be programmed as

def factorial(n):

Python® Notes for Professionals 131

 #n here should be an integer
if n == 0:
return 1
else:
return n*factorial(n-1)

the outputs here are:

factorial(0)
#out 1
factorial(1)
#out 1
factorial(2)
#out 2
factorial(3)
#out 6

as expected. Notice that this function is recursive because the second return factorial(n-1), where the function
calls itself in its definition.

Some recursive functions can be implemented using lambda, the factorial function using lambda would be
something like this:

factorial = lambda n: 1 if n == 0 else n*factorial(n-1)

The function outputs the same as above.

Section 22.14: Defining a function with arguments

Arguments are defined in parentheses after the function name:

def divide(dividend, divisor): # The names of the function and its arguments
# The arguments are available by name in the body of the function
print(dividend / divisor)

The function name and its list of arguments are called the signature of the function. Each named argument is
effectively a local variable of the function.

When calling the function, give values for the arguments by listing them in order

divide(10, 2)
# output: 5

or specify them in any order using the names from the function definition:

divide(divisor=2, dividend=10)
# output: 5

Section 22.15: Iterable and dictionary unpacking

Functions allow you to specify these types of parameters: positional, named, variable positional, Keyword args
(kwargs). Here is a clear and concise use of each type.

def unpacking(a, b, c=45, d=60, *args, **kwargs):

print(a, b, c, d, args, kwargs)

Python® Notes for Professionals 132

>>> unpacking(1, 2)
1 2 45 60 () {}
>>> unpacking(1, 2, 3, 4)
1 2 3 4 () {}
>>> unpacking(1, 2, c=3, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, c=3)
1 2 3 4 () {}

>>> pair = (3,)

>>> unpacking(1, 2, *pair, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, *pair)
1 2 3 4 () {}
>>> unpacking(1, 2, *pair, c=3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'
>>> unpacking(1, 2, c=3, *pair)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'

>>> args_list = [3]

>>> unpacking(1, 2, *args_list, d=4)
1 2 3 4 () {}
>>> unpacking(1, 2, d=4, *args_list)
1 2 3 4 () {}
>>> unpacking(1, 2, c=3, *args_list)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'
>>> unpacking(1, 2, *args_list, c=3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'

>>> pair = (3, 4)

>>> unpacking(1, 2, *pair)
1 2 3 4 () {}
>>> unpacking(1, 2, 3, 4, *pair)
1 2 3 4 (3, 4) {}
>>> unpacking(1, 2, d=4, *pair)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, *pair, d=4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'

>>> args_list = [3, 4]

>>> unpacking(1, 2, *args_list)
1 2 3 4 () {}
>>> unpacking(1, 2, 3, 4, *args_list)
1 2 3 4 (3, 4) {}
>>> unpacking(1, 2, d=4, *args_list)
Traceback (most recent call last):

Python® Notes for Professionals 133

 File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, *args_list, d=4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'

>>> arg_dict = {'c':3, 'd':4}

>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {}
>>> arg_dict = {'d':4, 'c':3}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {}
>>> arg_dict = {'c':3, 'd':4, 'not_a_parameter': 75}
>>> unpacking(1, 2, **arg_dict)
1 2 3 4 () {'not_a_parameter': 75}

>>> unpacking(1, 2, *pair, **arg_dict)

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'
>>> unpacking(1, 2, 3, 4, **arg_dict)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'd'

# Positional arguments take priority over any other form of argument passing
>>> unpacking(1, 2, **arg_dict, c=3)
1 2 3 4 () {'not_a_parameter': 75}
>>> unpacking(1, 2, 3, **arg_dict, c=3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unpacking() got multiple values for argument 'c'

Section 22.16: Defining a function with multiple arguments

One can give a function as many arguments as one wants, the only fixed rules are that each argument name must
be unique and that optional arguments must be after the not-optional ones:

def func(value1, value2, optionalvalue=10):

return '{0} {1} {2}'.format(value1, value2, optionalvalue1)

When calling the function you can either give each keyword without the name but then the order matters:

print(func(1, 'a', 100))

# Out: 1 a 100

print(func('abc', 14))
# abc 14 10

Or combine giving the arguments with name and without. Then the ones with name must follow those without but
the order of the ones with name doesn't matter:

print(func('This', optionalvalue='StackOverflow Documentation', value2='is'))

# Out: This is StackOverflow Documentation

Python® Notes for Professionals 134

Chapter 23: Defining functions with list
arguments
Section 23.1: Function and Call
Lists as arguments are just another variable:

def func(myList):
for item in myList:
print(item)

and can be passed in the function call itself:

func([1,2,3,5,7])

1
2
3
5
7

Or as a variable:

aList = ['a','b','c','d']
func(aList)

a
b
c
d

Python® Notes for Professionals 135

Chapter 24: Functional Programming in
Python
Functional programming decomposes a problem into a set of functions. Ideally, functions only take inputs and
produce outputs, and don’t have any internal state that affects the output produced for a given input.below are
functional techniques common to many languages: such as lambda, map, reduce.

Section 24.1: Lambda Function

An anonymous, inlined function defined with lambda. The parameters of the lambda are defined to the left of the
colon. The function body is defined to the right of the colon. The result of running the function body is (implicitly)
returned.

s=lambda x:x*x
s(2) =>4

Section 24.2: Map Function

Map takes a function and a collection of items. It makes a new, empty collection, runs the function on each item in
the original collection and inserts each return value into the new collection. It returns the new collection.

This is a simple map that takes a list of names and returns a list of the lengths of those names:

name_lengths = map(len, ["Mary", "Isla", "Sam"])

print(name_lengths) =>[4, 4, 3]

Section 24.3: Reduce Function

Reduce takes a function and a collection of items. It returns a value that is created by combining the items.

This is a simple reduce. It returns the sum of all the items in the collection.

total = reduce(lambda a, x: a + x, [0, 1, 2, 3, 4])

print(total) =>10

Section 24.4: Filter Function

Filter takes a function and a collection. It returns a collection of every item for which the function returned True.

arr=[1,2,3,4,5,6]
[i for i in filter(lambda x:x>4,arr)] # outputs[5,6]

Python® Notes for Professionals 136

Chapter 25: Partial functions
Param details
x the number to be raised
y the exponent
raise the function to be specialized

As you probably know if you came from OOP school, specializing an abstract class and use it is a practice you
should keep in mind when writing your code.

What if you could define an abstract function and specialize it in order to create different versions of it? Thinks it as
a sort of function Inheritance where you bind specific params to make them reliable for a specific scenario.

Section 25.1: Raise the power

Let's suppose we want raise x to a number y.

You'd write this as:

def raise_power(x, y):

return x**y

What if your y value can assume a finite set of values?

Let's suppose y can be one of [3,4,5] and let's say you don't want offer end user the possibility to use such function
since it is very computationally intensive. In fact you would check if provided y assumes a valid value and rewrite
your function as:

def raise(x, y):

if y in (3,4,5):
return x**y
raise NumberNotInRangeException("You should provide a valid exponent")

Messy? Let's use the abstract form and specialize it to all three cases: let's implement them partially.

from functors import partial

raise_to_three = partial(raise, y=3)
raise_to_four = partial(raise, y=4)
raise_to_five = partial(raise, y=5)

What happens here? We fixed the y params and we defined three different functions.

No need to use the abstract function defined above (you could make it private) but you could use partial applied
functions to deal with raising a number to a fixed value.

Python® Notes for Professionals 137

Chapter 26: Decorators
Parameter Details
f The function to be decorated (wrapped)

Decorator functions are software design patterns. They dynamically alter the functionality of a function, method, or
class without having to directly use subclasses or change the source code of the decorated function. When used
correctly, decorators can become powerful tools in the development process. This topic covers implementation and
applications of decorator functions in Python.

Section 26.1: Decorator function

Decorators augment the behavior of other functions or methods. Any function that takes a function as a parameter
and returns an augmented function can be used as a decorator.

# This simplest decorator does nothing to the function being decorated. Such
# minimal decorators can occasionally be used as a kind of code markers.
def super_secret_function(f):
return f

@super_secret_function
def my_function():
print("This is my secret function.")

The @-notation is syntactic sugar that is equivalent to the following:

my_function = super_secret_function(my_function)

It is important to bear this in mind in order to understand how the decorators work. This "unsugared" syntax makes
it clear why the decorator function takes a function as an argument, and why it should return another function. It
also demonstrates what would happen if you don't return a function:

def disabled(f):
"""
This function returns nothing, and hence removes the decorated function
from the local scope.
"""
pass

@disabled
def my_function():
print("This function can no longer be called...")

my_function()
# TypeError: 'NoneType' object is not callable

Thus, we usually define a new function inside the decorator and return it. This new function would first do
something that it needs to do, then call the original function, and finally process the return value. Consider this
simple decorator function that prints the arguments that the original function receives, then calls it.

#This is the decorator

def print_args(func):
def inner_func(*args, **kwargs):
print(args)
print(kwargs)
return func(*args, **kwargs) #Call the original function with its arguments.

Python® Notes for Professionals 138

 return inner_func

@print_args
def multiply(num_a, num_b):
return num_a * num_b

print(multiply(3, 5))
#Output:
# (3,5) - This is actually the 'args' that the function receives.
# {} - This is the 'kwargs', empty because we didn't specify keyword arguments.
# 15 - The result of the function.

Section 26.2: Decorator class

As mentioned in the introduction, a decorator is a function that can be applied to another function to augment its
behavior. The syntactic sugar is equivalent to the following: my_func = decorator(my_func). But what if the
decorator was instead a class? The syntax would still work, except that now my_func gets replaced with an instance
of the decorator class. If this class implements the __call__() magic method, then it would still be possible to use
my_func as if it was a function:

class Decorator(object):
"""Simple decorator class."""

def __init__(self, func):

self.func = func

def __call__(self, *args, **kwargs):

print('Before the function call.')
res = self.func(*args, **kwargs)
print('After the function call.')
return res

@Decorator
def testfunc():
print('Inside the function.')

testfunc()
# Before the function call.
# Inside the function.
# After the function call.

Note that a function decorated with a class decorator will no longer be considered a "function" from type-checking
perspective:

import types
isinstance(testfunc, types.FunctionType)
# False
type(testfunc)
# <class '__main__.Decorator'>

Decorating Methods

For decorating methods you need to define an additional __get__-method:

from types import MethodType

class Decorator(object):
def __init__(self, func):
self.func = func

Python® Notes for Professionals 139

 def __call__(self, *args, **kwargs):
print('Inside the decorator.')
return self.func(*args, **kwargs)

def __get__(self, instance, cls):

# Return a Method if it is called on an instance
return self if instance is None else MethodType(self, instance)

class Test(object):
@Decorator
def __init__(self):
pass

a = Test()

Inside the decorator.

Warning!

Class Decorators only produce one instance for a specific function so decorating a method with a class decorator
will share the same decorator between all instances of that class:

from types import MethodType

class CountCallsDecorator(object):
def __init__(self, func):
self.func = func
self.ncalls = 0 # Number of calls of this method

def __call__(self, *args, **kwargs):

self.ncalls += 1 # Increment the calls counter
return self.func(*args, **kwargs)

def __get__(self, instance, cls):

return self if instance is None else MethodType(self, instance)

class Test(object):
def __init__(self):
pass

@CountCallsDecorator
def do_something(self):
return 'something was done'

a = Test()
a.do_something()
a.do_something.ncalls # 1
b = Test()
b.do_something()
b.do_something.ncalls # 2

Section 26.3: Decorator with arguments (decorator factory)

A decorator takes just one argument: the function to be decorated. There is no way to pass other arguments.

But additional arguments are often desired. The trick is then to make a function which takes arbitrary arguments
and returns a decorator.

Python® Notes for Professionals 140

Decorator functions
def decoratorfactory(message):
def decorator(func):
def wrapped_func(*args, **kwargs):
print('The decorator wants to tell you: {}'.format(message))
return func(*args, **kwargs)
return wrapped_func
return decorator

@decoratorfactory('Hello World')
def test():
pass

test()

The decorator wants to tell you: Hello World

Important Note:

With such decorator factories you must call the decorator with a pair of parentheses:

@decoratorfactory # Without parentheses

def test():
pass

test()

TypeError: decorator() missing 1 required positional argument: 'func'

Decorator classes
def decoratorfactory(*decorator_args, **decorator_kwargs):

class Decorator(object):
def __init__(self, func):
self.func = func

def __call__(self, *args, **kwargs):

print('Inside the decorator with arguments {}'.format(decorator_args))
return self.func(*args, **kwargs)

return Decorator

@decoratorfactory(10)
def test():
pass

test()

Inside the decorator with arguments (10,)

Section 26.4: Making a decorator look like the decorated

Python® Notes for Professionals 141

function
Decorators normally strip function metadata as they aren't the same. This can cause problems when using meta-
programming to dynamically access function metadata. Metadata also includes function's docstrings and its name.
functools.wraps makes the decorated function look like the original function by copying several attributes to the
wrapper function.

from functools import wraps

The two methods of wrapping a decorator are achieving the same thing in hiding that the original function has
been decorated. There is no reason to prefer the function version to the class version unless you're already using
one over the other.

As a function
def decorator(func):
# Copies the docstring, name, annotations and module to the decorator
@wraps(func)
def wrapped_func(*args, **kwargs):
return func(*args, **kwargs)
return wrapped_func

@decorator
def test():
pass

test.__name__

'test'

As a class
class Decorator(object):
def __init__(self, func):
# Copies name, module, annotations and docstring to the instance.
self._wrapped = wraps(func)(self)

def __call__(self, *args, **kwargs):

return self._wrapped(*args, **kwargs)

@Decorator
def test():
"""Docstring of test."""
pass

test.__doc__

'Docstring of test.'

Section 26.5: Using a decorator to time a function

import time
def timer(func):
def inner(*args, **kwargs):
t1 = time.time()

Python® Notes for Professionals 142

 f = func(*args, **kwargs)
t2 = time.time()
print 'Runtime took {0} seconds'.format(t2-t1)
return f
return inner

@timer
def example_function():
#do stuff

example_function()

Section 26.6: Create singleton class with a decorator

A singleton is a pattern that restricts the instantiation of a class to one instance/object. Using a decorator, we can
define a class as a singleton by forcing the class to either return an existing instance of the class or create a new
instance (if it doesn't exist).

def singleton(cls):
instance = [None]
def wrapper(*args, **kwargs):
if instance[0] is None:
instance[0] = cls(*args, **kwargs)
return instance[0]

return wrapper

This decorator can be added to any class declaration and will make sure that at most one instance of the class is
created. Any subsequent calls will return the already existing class instance.

@singleton
class SomeSingletonClass:
x = 2
def __init__(self):
print("Created!")

instance = SomeSingletonClass() # prints: Created!

instance = SomeSingletonClass() # doesn't print anything
print(instance.x) # 2

instance.x = 3
print(SomeSingletonClass().x) # 3

So it doesn't matter whether you refer to the class instance via your local variable or whether you create another
"instance", you always get the same object.

Python® Notes for Professionals 143

Chapter 27: Classes
Python offers itself not only as a popular scripting language, but also supports the object-oriented programming
paradigm. Classes describe data and provide methods to manipulate that data, all encompassed under a single
object. Furthermore, classes allow for abstraction by separating concrete implementation details from abstract
representations of data.

Code utilizing classes is generally easier to read, understand, and maintain.

Section 27.1: Introduction to classes

A class, functions as a template that defines the basic characteristics of a particular object. Here's an example:

class Person(object):
"""A simple class.""" # docstring
species = "Homo Sapiens" # class attribute

def __init__(self, name): # special method

"""This is the initializer. It's a special
method (see below).
"""
self.name = name # instance attribute

def __str__(self): # special method

"""This method is run when Python tries
to cast the object to a string. Return
this string when using print(), etc.
"""
return self.name

def rename(self, renamed): # regular method

"""Reassign and print the name attribute."""
self.name = renamed
print("Now my name is {}".format(self.name))

There are a few things to note when looking at the above example.

1. The class is made up of attributes (data) and methods (functions).

2. Attributes and methods are simply defined as normal variables and functions.
3. As noted in the corresponding docstring, the __init__() method is called the initializer. It's equivalent to the
constructor in other object oriented languages, and is the method that is first run when you create a new
object, or new instance of the class.
4. Attributes that apply to the whole class are defined first, and are called class attributes.
5. Attributes that apply to a specific instance of a class (an object) are called instance attributes. They are
generally defined inside __init__(); this is not necessary, but it is recommended (since attributes defined
outside of __init__() run the risk of being accessed before they are defined).
6. Every method, included in the class definition passes the object in question as its first parameter. The word
self is used for this parameter (usage of self is actually by convention, as the word self has no inherent
meaning in Python, but this is one of Python's most respected conventions, and you should always follow it).
7. Those used to object-oriented programming in other languages may be surprised by a few things. One is that
Python has no real concept of private elements, so everything, by default, imitates the behavior of the
C++/Java public keyword. For more information, see the "Private Class Members" example on this page.
8. Some of the class's methods have the following form: __functionname__(self, other_stuff). All such
methods are called "magic methods" and are an important part of classes in Python. For instance, operator
overloading in Python is implemented with magic methods. For more information, see the relevant

Python® Notes for Professionals 144

 documentation.

Now let's make a few instances of our Person class!

>>> # Instances
>>> kelly = Person("Kelly")
>>> joseph = Person("Joseph")
>>> john_doe = Person("John Doe")

We currently have three Person objects, kelly, joseph, and john_doe.

We can access the attributes of the class from each instance using the dot operator . Note again the difference
between class and instance attributes:

>>> # Attributes
>>> kelly.species
'Homo Sapiens'
>>> john_doe.species
'Homo Sapiens'
>>> joseph.species
'Homo Sapiens'
>>> kelly.name
'Kelly'
>>> joseph.name
'Joseph'

We can execute the methods of the class using the same dot operator .:

>>> # Methods
>>> john_doe.__str__()
'John Doe'
>>> print(john_doe)
'John Doe'
>>> john_doe.rename("John")
'Now my name is John'

Section 27.2: Bound, unbound, and static methods

The idea of bound and unbound methods was removed in Python 3. In Python 3 when you declare a method within
a class, you are using a def keyword, thus creating a function object. This is a regular function, and the surrounding
class works as its namespace. In the following example we declare method f within class A, and it becomes a
function A.f:

Python 3.x Version ≥ 3.0

class A(object):
def f(self, x):
return 2 * x
A.f
# <function A.f at ...> (in Python 3.x)

In Python 2 the behavior was different: function objects within the class were implicitly replaced with objects of type
instancemethod, which were called unbound methods because they were not bound to any particular class instance.
It was possible to access the underlying function using .__func__ property.

Python 2.x Version ≥ 2.3

A.f

Python® Notes for Professionals 145

# <unbound method A.f> (in Python 2.x)
A.f.__class__
# <type 'instancemethod'>
A.f.__func__
# <function f at ...>

The latter behaviors are confirmed by inspection - methods are recognized as functions in Python 3, while the
distinction is upheld in Python 2.

Python 3.x Version ≥ 3.0

import inspect

inspect.isfunction(A.f)
# True
inspect.ismethod(A.f)
# False

Python 2.x Version ≥ 2.3

import inspect

inspect.isfunction(A.f)
# False
inspect.ismethod(A.f)
# True

In both versions of Python function/method A.f can be called directly, provided that you pass an instance of class A
as the first argument.

A.f(1, 7)
# Python 2: TypeError: unbound method f() must be called with
# A instance as first argument (got int instance instead)
# Python 3: 14
a = A()
A.f(a, 20)
# Python 2 & 3: 40

Now suppose a is an instance of class A, what is a.f then? Well, intuitively this should be the same method f of class
A, only it should somehow "know" that it was applied to the object a – in Python this is called method bound to a.

The nitty-gritty details are as follows: writing a.f invokes the magic __getattribute__ method of a, which first
checks whether a has an attribute named f (it doesn't), then checks the class A whether it contains a method with
such a name (it does), and creates a new object m of type method which has the reference to the original A.f in
m.__func__, and a reference to the object a in m.__self__. When this object is called as a function, it simply does
the following: m(...) => m.__func__(m.__self__, ...). Thus this object is called a bound method because when
invoked it knows to supply the object it was bound to as the first argument. (These things work same way in Python
2 and 3).

a = A()
a.f
# <bound method A.f of <__main__.A object at ...>>
a.f(2)
# 4

# Note: the bound method object a.f is recreated *every time* you call it:
a.f is a.f # False
# As a performance optimization you can store the bound method in the object's
# __dict__, in which case the method object will remain fixed:
a.f = a.f

Python® Notes for Professionals 146

a.f is a.f # True

Finally, Python has class methods and static methods – special kinds of methods. Class methods work the same
way as regular methods, except that when invoked on an object they bind to the class of the object instead of to the
object. Thus m.__self__ = type(a). When you call such bound method, it passes the class of a as the first
argument. Static methods are even simpler: they don't bind anything at all, and simply return the underlying
function without any transformations.

class D(object):
multiplier = 2

@classmethod
def f(cls, x):
return cls.multiplier * x

@staticmethod
def g(name):
print("Hello, %s" % name)

D.f
# <bound method type.f of <class '__main__.D'>>
D.f(12)
# 24
D.g
# <function D.g at ...>
D.g("world")
# Hello, world

Note that class methods are bound to the class even when accessed on the instance:

d = D()
d.multiplier = 1337
(D.multiplier, d.multiplier)
# (2, 1337)
d.f
# <bound method D.f of <class '__main__.D'>>
d.f(10)
# 20

It is worth noting that at the lowest level, functions, methods, staticmethods, etc. are actually descriptors that
invoke __get__, __set__ and optionally __del__ special methods. For more details on classmethods and
staticmethods:

What is the difference between @staticmethod and @classmethod in Python?

Meaning of @classmethod and @staticmethod for beginner?

Section 27.3: Basic inheritance

Inheritance in Python is based on similar ideas used in other object oriented languages like Java, C++ etc. A new
class can be derived from an existing class as follows.

class BaseClass(object):
pass

class DerivedClass(BaseClass):
pass

Python® Notes for Professionals 147

The BaseClass is the already existing (parent) class, and the DerivedClass is the new (child) class that inherits (or
subclasses) attributes from BaseClass. Note: As of Python 2.2, all classes implicitly inherit from the object class,
which is the base class for all built-in types.

We define a parent Rectangle class in the example below, which implicitly inherits from object:

class Rectangle():
def __init__(self, w, h):
self.w = w
self.h = h

def area(self):
return self.w * self.h

def perimeter(self):
return 2 * (self.w + self.h)

The Rectangle class can be used as a base class for defining a Square class, as a square is a special case of
rectangle.

class Square(Rectangle):
def __init__(self, s):
# call parent constructor, w and h are both s
super(Square, self).__init__(s, s)
self.s = s

The Square class will automatically inherit all attributes of the Rectangle class as well as the object class. super() is
used to call the __init__() method of Rectangle class, essentially calling any overridden method of the base class.
Note: in Python 3, super() does not require arguments.

Derived class objects can access and modify the attributes of its base classes:

r.area()
# Output: 12
r.perimeter()
# Output: 14

s.area()
# Output: 4
s.perimeter()
# Output: 8

Built-in functions that work with inheritance

issubclass(DerivedClass, BaseClass): returns True if DerivedClass is a subclass of the BaseClass

isinstance(s, Class): returns True if s is an instance of Class or any of the derived classes of Class

# subclass check
issubclass(Square, Rectangle)
# Output: True

# instantiate
r = Rectangle(3, 4)
s = Square(2)

isinstance(r, Rectangle)
# Output: True
isinstance(r, Square)

Python® Notes for Professionals 148

# Output: False
# A rectangle is not a square

isinstance(s, Rectangle)
# Output: True
# A square is a rectangle
isinstance(s, Square)
# Output: True

Section 27.4: Monkey Patching

In this case, "monkey patching" means adding a new variable or method to a class after it's been defined. For
instance, say we defined class A as

class A(object):
def __init__(self, num):
self.num = num

def __add__(self, other):

return A(self.num + other.num)

But now we want to add another function later in the code. Suppose this function is as follows.

def get_num(self):
return self.num

But how do we add this as a method in A? That's simple we just essentially place that function into A with an
assignment statement.

A.get_num = get_num

Why does this work? Because functions are objects just like any other object, and methods are functions that
belong to the class.

The function get_num shall be available to all existing (already created) as well to the new instances of A

These additions are available on all instances of that class (or its subclasses) automatically. For example:

foo = A(42)

A.get_num = get_num

bar = A(6);

foo.get_num() # 42

bar.get_num() # 6

Note that, unlike some other languages, this technique does not work for certain built-in types, and it is not
considered good style.

Section 27.5: New-style vs. old-style classes

Python 2.x Version ≥ 2.2.0

New-style classes were introduced in Python 2.2 to unify classes and types. They inherit from the top-level object

Python® Notes for Professionals 149

type. A new-style class is a user-defined type, and is very similar to built-in types.

# new-style class
class New(object):
pass

# new-style instance
new = New()

new.__class__
# <class '__main__.New'>
type(new)
# <class '__main__.New'>
issubclass(New, object)
# True

Old-style classes do not inherit from object. Old-style instances are always implemented with a built-in instance
type.

# old-style class
class Old:
pass

# old-style instance
old = Old()

old.__class__
# <class __main__.Old at ...>
type(old)
# <type 'instance'>
issubclass(Old, object)
# False

Python 3.x Version ≥ 3.0.0

In Python 3, old-style classes were removed.

New-style classes in Python 3 implicitly inherit from object, so there is no need to specify MyClass(object)
anymore.

class MyClass:
pass

my_inst = MyClass()

type(my_inst)
# <class '__main__.MyClass'>
my_inst.__class__
# <class '__main__.MyClass'>
issubclass(MyClass, object)
# True

Section 27.6: Class methods: alternate initializers

Class methods present alternate ways to build instances of classes. To illustrate, let's look at an example.

Let's suppose we have a relatively simple Person class:

class Person(object):

Python® Notes for Professionals 150

 def __init__(self, first_name, last_name, age):
self.first_name = first_name
self.last_name = last_name
self.age = age
self.full_name = first_name + " " + last_name

def greet(self):
print("Hello, my name is " + self.full_name + ".")

It might be handy to have a way to build instances of this class specifying a full name instead of first and last name
separately. One way to do this would be to have last_name be an optional parameter, and assuming that if it isn't
given, we passed the full name in:

class Person(object):

def __init__(self, first_name, age, last_name=None):

if last_name is None:
self.first_name, self.last_name = first_name.split(" ", 2)
else:
self.first_name = first_name
self.last_name = last_name

self.full_name = self.first_name + " " + self.last_name

self.age = age

def greet(self):
print("Hello, my name is " + self.full_name + ".")

However, there are two main problems with this bit of code:

1. The parameters first_name and last_name are now misleading, since you can enter a full name for
first_name. Also, if there are more cases and/or more parameters that have this kind of flexibility, the
if/elif/else branching can get annoying fast.

2. Not quite as important, but still worth pointing out: what if last_name is None, but first_name doesn't split
into two or more things via spaces? We have yet another layer of input validation and/or exception
handling...

Enter class methods. Rather than having a single initializer, we will create a separate initializer, called
from_full_name, and decorate it with the (built-in) classmethod decorator.

class Person(object):

def __init__(self, first_name, last_name, age):

self.first_name = first_name
self.last_name = last_name
self.age = age
self.full_name = first_name + " " + last_name

@classmethod
def from_full_name(cls, name, age):
if " " not in name:
raise ValueError
first_name, last_name = name.split(" ", 2)
return cls(first_name, last_name, age)

def greet(self):
print("Hello, my name is " + self.full_name + ".")

Python® Notes for Professionals 151

Notice cls instead of self as the first argument to from_full_name. Class methods are applied to the overall class,
not an instance of a given class (which is what self usually denotes). So, if cls is our Person class, then the returned
value from the from_full_name class method is Person(first_name, last_name, age), which uses Person's
__init__ to create an instance of the Person class. In particular, if we were to make a subclass Employee of Person,
then from_full_name would work in the Employee class as well.

To show that this works as expected, let's create instances of Person in more than one way without the branching
in __init__:

In [2]: bob = Person("Bob", "Bobberson", 42)

In [3]: alice = Person.from_full_name("Alice Henderson", 31)

In [4]: bob.greet()
Hello, my name is Bob Bobberson.

In [5]: alice.greet()
Hello, my name is Alice Henderson.

Other references:

Python @classmethod and @staticmethod for beginner?

https://docs.python.org/2/library/functions.html#classmethod

https://docs.python.org/3.5/library/functions.html#classmethod

Section 27.7: Multiple Inheritance

Python uses the C3 linearization algorithm to determine the order in which to resolve class attributes, including
methods. This is known as the Method Resolution Order (MRO).

Here's a simple example:

class Foo(object):
foo = 'attr foo of Foo'

class Bar(object):
foo = 'attr foo of Bar' # we won't see this.
bar = 'attr bar of Bar'

class FooBar(Foo, Bar):

foobar = 'attr foobar of FooBar'

Now if we instantiate FooBar, if we look up the foo attribute, we see that Foo's attribute is found first

fb = FooBar()

and

>>> fb.foo
'attr foo of Foo'

Here's the MRO of FooBar:

Python® Notes for Professionals 152

>>> FooBar.mro()
[<class '__main__.FooBar'>, <class '__main__.Foo'>, <class '__main__.Bar'>, <type 'object'>]

It can be simply stated that Python's MRO algorithm is

1. Depth first (e.g. FooBar then Foo) unless

2. a shared parent (object) is blocked by a child (Bar) and
3. no circular relationships allowed.

That is, for example, Bar cannot inherit from FooBar while FooBar inherits from Bar.

For a comprehensive example in Python, see the wikipedia entry.

Another powerful feature in inheritance is super. super can fetch parent classes features.

class Foo(object):
def foo_method(self):
print "foo Method"

class Bar(object):
def bar_method(self):
print "bar Method"

class FooBar(Foo, Bar):

def foo_method(self):
super(FooBar, self).foo_method()

Multiple inheritance with init method of class, when every class has own init method then we try for multiple
ineritance then only init method get called of class which is inherit first.

for below example only Foo class init method getting called Bar class init not getting called

class Foo(object):
def __init__(self):
print "foo init"

class Bar(object):
def __init__(self):
print "bar init"

class FooBar(Foo, Bar):

def __init__(self):
print "foobar init"
super(FooBar, self).__init__()

a = FooBar()

Output:

foobar init
foo init

But it doesn't mean that Bar class is not inherit. Instance of final FooBar class is also instance of Bar class and Foo
class.

print isinstance(a,FooBar)
print isinstance(a,Foo)

Python® Notes for Professionals 153

print isinstance(a,Bar)

Output:

True
True
True

Section 27.8: Properties

Python classes support properties, which look like regular object variables, but with the possibility of attaching
custom behavior and documentation.

class MyClass(object):

def __init__(self):
self._my_string = ""

@property
def string(self):
"""A profoundly important string."""
return self._my_string

@string.setter
def string(self, new_value):
assert isinstance(new_value, str), \
"Give me a string, not a %r!" % type(new_value)
self._my_string = new_value

@string.deleter
def x(self):
self._my_string = None

The object's of class MyClass will appear to have have a property .string, however it's behavior is now tightly
controlled:

mc = MyClass()
mc.string = "String!"
print(mc.string)
del mc.string

As well as the useful syntax as above, the property syntax allows for validation, or other augmentations to be added
to those attributes. This could be especially useful with public APIs - where a level of help should be given to the
user.

Another common use of properties is to enable the class to present 'virtual attributes' - attributes which aren't
actually stored but are computed only when requested.

class Character(object):
def __init__(name, max_hp):
self._name = name
self._hp = max_hp
self._max_hp = max_hp

# Make hp read only by not providing a set method

@property
def hp(self):
return self._hp

Python® Notes for Professionals 154

 # Make name read only by not providing a set method
@property
def name(self):
return self.name

def take_damage(self, damage):

self.hp -= damage
self.hp = 0 if self.hp <0 else self.hp

@property
def is_alive(self):
return self.hp != 0

@property
def is_wounded(self):
return self.hp < self.max_hp if self.hp > 0 else False

@property
def is_dead(self):
return not self.is_alive

bilbo = Character('Bilbo Baggins', 100)

bilbo.hp
# out : 100
bilbo.hp = 200
# out : AttributeError: can't set attribute
# hp attribute is read only.

bilbo.is_alive
# out : True
bilbo.is_wounded
# out : False
bilbo.is_dead
# out : False

bilbo.take_damage( 50 )

bilbo.hp
# out : 50

bilbo.is_alive
# out : True
bilbo.is_wounded
# out : True
bilbo.is_dead
# out : False

bilbo.take_damage( 50 )
bilbo.hp
# out : 0

bilbo.is_alive
# out : False
bilbo.is_wounded
# out : False
bilbo.is_dead
# out : True

Section 27.9: Default values for instance variables

If the variable contains a value of an immutable type (e.g. a string) then it is okay to assign a default value like this

Python® Notes for Professionals 155

class Rectangle(object):
def __init__(self, width, height, color='blue'):
self.width = width
self.height = height
self.color = color

def area(self):
return self.width * self.height

# Create some instances of the class

default_rectangle = Rectangle(2, 3)
print(default_rectangle.color) # blue

red_rectangle = Rectangle(2, 3, 'red')

print(red_rectangle.color) # red

One needs to be careful when initializing mutable objects such as lists in the constructor. Consider the following
example:

class Rectangle2D(object):
def __init__(self, width, height, pos=[0,0], color='blue'):
self.width = width
self.height = height
self.pos = pos
self.color = color

r1 = Rectangle2D(5,3)
r2 = Rectangle2D(7,8)
r1.pos[0] = 4
r1.pos # [4, 0]
r2.pos # [4, 0] r2's pos has changed as well

This behavior is caused by the fact that in Python default parameters are bound at function execution and not at
function declaration. To get a default instance variable that's not shared among instances, one should use a
construct like this:

class Rectangle2D(object):
def __init__(self, width, height, pos=None, color='blue'):
self.width = width
self.height = height
self.pos = pos or [0, 0] # default value is [0, 0]
self.color = color

r1 = Rectangle2D(5,3)
r2 = Rectangle2D(7,8)
r1.pos[0] = 4
r1.pos # [4, 0]
r2.pos # [0, 0] r2's pos hasn't changed

See also Mutable Default Arguments and “Least Astonishment” and the Mutable Default Argument.

Section 27.10: Class and instance variables

Instance variables are unique for each instance, while class variables are shared by all instances.

class C:
x = 2 # class variable

Python® Notes for Professionals 156

 def __init__(self, y):
self.y = y # instance variable

C.x
# 2
C.y
# AttributeError: type object 'C' has no attribute 'y'

c1 = C(3)
c1.x
# 2
c1.y
# 3

c2 = C(4)
c2.x
# 2
c2.y
# 4

Class variables can be accessed on instances of this class, but assigning to the class attribute will create an instance
variable which shadows the class variable

c2.x = 4
c2.x
# 4
C.x
# 2

Note that mutating class variables from instances can lead to some unexpected consequences.

class D:
x = []
def __init__(self, item):
self.x.append(item) # note that this is not an assigment!

d1 = D(1)
d2 = D(2)

d1.x
# [1, 2]
d2.x
# [1, 2]
D.x
# [1, 2]

Section 27.11: Class composition

Class composition allows explicit relations between objects. In this example, people live in cities that belong to
countries. Composition allows people to access the number of all people living in their country:

class Country(object):
def __init__(self):
self.cities=[]

def addCity(self,city):
self.cities.append(city)

Python® Notes for Professionals 157

class City(object):
def __init__(self, numPeople):
self.people = []
self.numPeople = numPeople

def addPerson(self, person):

self.people.append(person)

def join_country(self,country):
self.country = country
country.addCity(self)

for i in range(self.numPeople):
person(i).join_city(self)

class Person(object):
def __init__(self, ID):
self.ID=ID

def join_city(self, city):

self.city = city
city.addPerson(self)

def people_in_my_country(self):
x= sum([len(c.people) for c in self.city.country.cities])
return x

US=Country()
NYC=City(10).join_country(US)
SF=City(5).join_country(US)

print(US.cities[0].people[0].people_in_my_country())

# 15

Section 27.12: Listing All Class Members

The dir() function can be used to get a list of the members of a class:

dir(Class)

For example:

>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__',
'__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__',
'__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count',
'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

It is common to look only for "non-magic" members. This can be done using a simple comprehension that lists
members with names not starting with __:

>>> [m for m in dir(list) if not m.startswith('__')]

['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse',
'sort']

Python® Notes for Professionals 158

Caveats:

Classes can define a __dir__() method. If that method exists calling dir() will call __dir__(), otherwise Python
will try to create a list of members of the class. This means that the dir function can have unexpected results. Two
quotes of importance from the official python documentation:

If the object does not provide dir(), the function tries its best to gather information from the object’s dict
attribute, if defined, and from its type object. The resulting list is not necessarily complete, and may be
inaccurate when the object has a custom getattr().

Note: Because dir() is supplied primarily as a convenience for use at an interactive prompt, it tries to
supply an interesting set of names more than it tries to supply a rigorously or consistently defined set of
names, and its detailed behavior may change across releases. For example, metaclass attributes are not
in the result list when the argument is a class.

Section 27.13: Singleton class

A singleton is a pattern that restricts the instantiation of a class to one instance/object. For more info on python
singleton design patterns, see here.

class Singleton:
def __new__(cls):
try:
it = cls.__it__
except AttributeError:
it = cls.__it__ = object.__new__(cls)
return it

def __repr__(self):
return '<{}>'.format(self.__class__.__name__.upper())

def __eq__(self, other):

return other is self

Another method is to decorate your class. Following the example from this answer create a Singleton class:

class Singleton:
"""
A non-thread-safe helper class to ease implementing singletons.
This should be used as a decorator -- not a metaclass -- to the
class that should be a singleton.

The decorated class can define one `__init__` function that

takes only the `self` argument. Other than that, there are
no restrictions that apply to the decorated class.

To get the singleton instance, use the `Instance` method. Trying

to use `__call__` will result in a `TypeError` being raised.

Limitations: The decorated class cannot be inherited from.

"""

def __init__(self, decorated):

Python® Notes for Professionals 159

 self._decorated = decorated

def Instance(self):
"""
Returns the singleton instance. Upon its first call, it creates a
new instance of the decorated class and calls its `__init__` method.
On all subsequent calls, the already created instance is returned.

"""
try:
return self._instance
except AttributeError:
self._instance = self._decorated()
return self._instance

def __call__(self):
raise TypeError('Singletons must be accessed through `Instance()`.')

def __instancecheck__(self, inst):

return isinstance(inst, self._decorated)

To use you can use the Instance method

@Singleton
class Single:
def __init__(self):
self.name=None
self.val=0
def getName(self):
print(self.name)

x=Single.Instance()
y=Single.Instance()
x.name='I\'m single'
x.getName() # outputs I'm single
y.getName() # outputs I'm single

Section 27.14: Descriptors and Dotted Lookups

Descriptors are objects that are (usually) attributes of classes and that have any of __get__, __set__, or
__delete__ special methods.

Data Descriptors have any of __set__, or __delete__

These can control the dotted lookup on an instance, and are used to implement functions, staticmethod,
classmethod, and property. A dotted lookup (e.g. instance foo of class Foo looking up attribute bar - i.e. foo.bar)
uses the following algorithm:

1. bar is looked up in the class, Foo. If it is there and it is a Data Descriptor, then the data descriptor is used.
That's how property is able to control access to data in an instance, and instances cannot override this. If a
Data Descriptor is not there, then

2. bar is looked up in the instance __dict__. This is why we can override or block methods being called from an
instance with a dotted lookup. If bar exists in the instance, it is used. If not, we then

3. look in the class Foo for bar. If it is a Descriptor, then the descriptor protocol is used. This is how functions
(in this context, unbound methods), classmethod, and staticmethod are implemented. Else it simply returns
the object there, or there is an AttributeError

Python® Notes for Professionals 160

Chapter 28: Metaclasses
Metaclasses allow you to deeply modify the behaviour of Python classes (in terms of how they're defined,
instantiated, accessed, and more) by replacing the type metaclass that new classes use by default.

Section 28.1: Basic Metaclasses

When type is called with three arguments it behaves as the (meta)class it is, and creates a new instance, ie. it
produces a new class/type.

Dummy = type('OtherDummy', (), dict(x=1))

Dummy.__class__ # <type 'type'>
Dummy().__class__.__class__ # <type 'type'>

It is possible to subclass type to create an custom metaclass.

class mytype(type):
def __init__(cls, name, bases, dict):
# call the base initializer
type.__init__(cls, name, bases, dict)

# perform custom initialization...

cls.__custom_attribute__ = 2

Now, we have a new custom mytype metaclass which can be used to create classes in the same manner as type.

MyDummy = mytype('MyDummy', (), dict(x=2))

MyDummy.__class__ # <class '__main__.mytype'>
MyDummy().__class__.__class__ # <class '__main__.mytype'>
MyDummy.__custom_attribute__ # 2

When we create a new class using the class keyword the metaclass is by default chosen based on upon the
baseclasses.

>>> class Foo(object):

... pass

>>> type(Foo)
type

In the above example the only baseclass is object so our metaclass will be the type of object, which is type. It is
possible override the default, however it depends on whether we use Python 2 or Python 3:

Python 2.x Version ≤ 2.7

A special class-level attribute __metaclass__ can be used to specify the metaclass.

class MyDummy(object):
__metaclass__ = mytype
type(MyDummy) # <class '__main__.mytype'>

Python 3.x Version ≥ 3.0

A special metaclass keyword argument specify the metaclass.

class MyDummy(metaclass=mytype):

Python® Notes for Professionals 161

 pass
type(MyDummy) # <class '__main__.mytype'>

Any keyword arguments (except metaclass) in the class declaration will be passed to the metaclass. Thus class
MyDummy(metaclass=mytype, x=2) will pass x=2 as a keyword argument to the mytype constructor.

Read this in-depth description of python meta-classes for more details.

Section 28.2: Singletons using metaclasses

A singleton is a pattern that restricts the instantiation of a class to one instance/object. For more info on python
singleton design patterns, see here.

class SingletonType(type):
def __call__(cls, *args, **kwargs):
try:
return cls.__instance
except AttributeError:
cls.__instance = super(SingletonType, cls).__call__(*args, **kwargs)
return cls.__instance

Python 2.x Version ≤ 2.7

class MySingleton(object):
__metaclass__ = SingletonType

Python 3.x Version ≥ 3.0

class MySingleton(metaclass=SingletonType):
pass

MySingleton() is MySingleton() # True, only one instantiation occurs

Section 28.3: Using a metaclass

Metaclass syntax
Python 2.x Version ≤ 2.7

class MyClass(object):
__metaclass__ = SomeMetaclass

Python 3.x Version ≥ 3.0

class MyClass(metaclass=SomeMetaclass):
pass

Python 2 and 3 compatibility with six

import six

class MyClass(six.with_metaclass(SomeMetaclass)):
pass

Section 28.4: Introduction to Metaclasses

What is a metaclass?

In Python, everything is an object: integers, strings, lists, even functions and classes themselves are objects. And
every object is an instance of a class.

To check the class of an object x, one can call type(x), so:

Python® Notes for Professionals 162

>>> type(5)
<type 'int'>
>>> type(str)
<type 'type'>
>>> type([1, 2, 3])
<type 'list'>

>>> class C(object):

... pass
...
>>> type(C)
<type 'type'>

Most classes in python are instances of type. type itself is also a class. Such classes whose instances are also
classes are called metaclasses.

The Simplest Metaclass

OK, so there is already one metaclass in Python: type. Can we create another one?

class SimplestMetaclass(type):
pass

class MyClass(object):
__metaclass__ = SimplestMetaclass

That does not add any functionality, but it is a new metaclass, see that MyClass is now an instance of
SimplestMetaclass:

>>> type(MyClass)
<class '__main__.SimplestMetaclass'>

A Metaclass which does Something

A metaclass which does something usually overrides type's __new__, to modify some properties of the class to be
created, before calling the original __new__ which creates the class:

class AnotherMetaclass(type):
def __new__(cls, name, parents, dct):
# cls is this class
# name is the name of the class to be created
# parents is the list of the class's parent classes
# dct is the list of class's attributes (methods, static variables)

# here all of the attributes can be modified before creating the class, e.g.

dct['x'] = 8 # now the class will have a static variable x = 8

# return value is the new class. super will take care of that
return super(AnotherMetaclass, cls).__new__(cls, name, parents, dct)

Section 28.5: Custom functionality with metaclasses

Functionality in metaclasses can be changed so that whenever a class is built, a string is printed to standard
output, or an exception is thrown. This metaclass will print the name of the class being built.

class VerboseMetaclass(type):

Python® Notes for Professionals 163

 def __new__(cls, class_name, class_parents, class_dict):
print("Creating class ", class_name)
new_class = super().__new__(cls, class_name, class_parents, class_dict)
return new_class

You can use the metaclass like so:

class Spam(metaclass=VerboseMetaclass):
def eggs(self):
print("[insert example string here]")
s = Spam()
s.eggs()

The standard output will be:

Creating class Spam

[insert example string here]

Section 28.6: The default metaclass

You may have heard that everything in Python is an object. It is true, and all objects have a class:

>>> type(1)
int

The literal 1 is an instance of int. Lets declare a class:

>>> class Foo(object):

... pass
...

Now lets instantiate it:

>>> bar = Foo()

What is the class of bar?

>>> type(bar)
Foo

Nice, bar is an instance of Foo. But what is the class of Foo itself?

>>> type(Foo)
type

Ok, Foo itself is an instance of type. How about type itself?

>>> type(type)
type

So what is a metaclass? For now lets pretend it is just a fancy name for the class of a class. Takeaways:

Everything is an object in Python, so everything has a class

The class of a class is called a metaclass
The default metaclass is type, and by far it is the most common metaclass

Python® Notes for Professionals 164

But why should you know about metaclasses? Well, Python itself is quite "hackable", and the concept of metaclass
is important if you are doing advanced stuff like meta-programming or if you want to control how your classes are
initialized.

Python® Notes for Professionals 165

Chapter 29: String Methods
Section 29.1: Changing the capitalization of a string
Python's string type provides many functions that act on the capitalization of a string. These include :

str.casefold
str.upper
str.lower
str.capitalize
str.title
str.swapcase

With unicode strings (the default in Python 3), these operations are not 1:1 mappings or reversible. Most of these
operations are intended for display purposes, rather than normalization.

Python 3.x Version ≥ 3.3

str.casefold()

str.casefold creates a lowercase string that is suitable for case insensitive comparisons. This is more aggressive
than str.lower and may modify strings that are already in lowercase or cause strings to grow in length, and is not
intended for display purposes.

"XßΣ".casefold()
# 'xssσ'

"XßΣ".lower()
# 'xßς'

The transformations that take place under casefolding are defined by the Unicode Consortium in the
CaseFolding.txt file on their website.

str.upper()

str.upper takes every character in a string and converts it to its uppercase equivalent, for example:

"This is a 'string'.".upper()
# "THIS IS A 'STRING'."
str.lower()

str.lower does the opposite; it takes every character in a string and converts it to its lowercase equivalent:

"This IS a 'string'.".lower()
# "this is a 'string'."
str.capitalize()

str.capitalize returns a capitalized version of the string, that is, it makes the first character have upper case and
the rest lower:

"this Is A 'String'.".capitalize() # Capitalizes the first character and lowercases all others
# "This is a 'string'."
str.title()

str.title returns the title cased version of the string, that is, every letter in the beginning of a word is made upper
case and all others are made lower case:

Python® Notes for Professionals 166

"this Is a 'String'".title()
# "This Is A 'String'"
str.swapcase()

str.swapcase returns a new string object in which all lower case characters are swapped to upper case and all
upper case characters to lower:

"this iS A STRiNG".swapcase() #Swaps case of each character

# "THIS Is a strIng"

Usage as str class methods

It is worth noting that these methods may be called either on string objects (as shown above) or as a class method
of the str class (with an explicit call to str.upper, etc.)

str.upper("This is a 'string'")
# "THIS IS A 'STRING'"

This is most useful when applying one of these methods to many strings at once in say, a map function.

map(str.upper,["These","are","some","'strings'"])
# ['THESE', 'ARE', 'SOME', "'STRINGS'"]

Section 29.2: str.translate: Translating characters in a string

Python supports a translate method on the str type which allows you to specify the translation table (used for
replacements) as well as any characters which should be deleted in the process.

str.translate(table[, deletechars])
Parameter Description
table It is a lookup table that defines the mapping from one character to another.
deletechars A list of characters which are to be removed from the string.

The maketrans method (str.maketrans in Python 3 and string.maketrans in Python 2) allows you to generate a
translation table.

>>> translation_table = str.maketrans("aeiou", "12345")

>>> my_string = "This is a string!"
>>> translated = my_string.translate(translation_table)
'Th3s 3s 1 str3ng!'

The translate method returns a string which is a translated copy of the original string.

You can set the table argument to None if you only need to delete characters.

>>> 'this syntax is very useful'.translate(None, 'aeiou')

'ths syntx s vry sfl'

Section 29.3: str.format and f-strings: Format values into a

string
Python provides string interpolation and formatting functionality through the str.format function, introduced in
version 2.6 and f-strings introduced in version 3.6.

Given the following variables:

Python® Notes for Professionals 167

i = 10
f = 1.5
s = "foo"
l = ['a', 1, 2]
d = {'a': 1, 2: 'foo'}

The following statements are all equivalent

"10 1.5 foo ['a', 1, 2] {'a': 1, 2: 'foo'}"

>>> "{} {} {} {} {}".format(i, f, s, l, d)

>>> str.format("{} {} {} {} {}", i, f, s, l, d)

>>> "{0} {1} {2} {3} {4}".format(i, f, s, l, d)

>>> "{0:d} {1:0.1f} {2} {3!r} {4!r}".format(i, f, s, l, d)

>>> "{i:d} {f:0.1f} {s} {l!r} {d!r}".format(i=i, f=f, s=s, l=l, d=d)

>>> f"{i} {f} {s} {l} {d}"

>>> f"{i:d} {f:0.1f} {s} {l!r} {d!r}"

For reference, Python also supports C-style qualifiers for string formatting. The examples below are equivalent to
those above, but the str.format versions are preferred due to benefits in flexibility, consistency of notation, and
extensibility:

"%d %0.1f %s %r %r" % (i, f, s, l, d)

"%(i)d %(f)0.1f %(s)s %(l)r %(d)r" % dict(i=i, f=f, s=s, l=l, d=d)

The braces uses for interpolation in str.format can also be numbered to reduce duplication when formatting
strings. For example, the following are equivalent:

"I am from Australia. I love cupcakes from Australia!"

>>> "I am from {}. I love cupcakes from {}!".format("Australia", "Australia")

>>> "I am from {0}. I love cupcakes from {0}!".format("Australia")

While the official python documentation is, as usual, thorough enough, pyformat.info has a great set of examples
with detailed explanations.

Additionally, the { and } characters can be escaped by using double brackets:

"{'a': 5, 'b': 6}"

>>> "{{'{}': {}, '{}': {}}}".format("a", 5, "b", 6)

>>> f"{{'{'a'}': {5}, '{'b'}': {6}}"

See String Formatting for additional information. str.format() was proposed in PEP 3101 and f-strings in PEP 498.

Section 29.4: String module's useful constants

Python's string module provides constants for string related operations. To use them, import the string module:

Python® Notes for Professionals 168

>>> import string

string.ascii_letters:

Concatenation of ascii_lowercase and ascii_uppercase:

>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.ascii_lowercase:

Contains all lower case ASCII characters:

>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'

string.ascii_uppercase:

Contains all upper case ASCII characters:

>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

string.digits:

Contains all decimal digit characters:

>>> string.digits
'0123456789'

string.hexdigits:

Contains all hex digit characters:

>>> string.hexdigits
'0123456789abcdefABCDEF'

string.octaldigits:

Contains all octal digit characters:

>>> string.octaldigits
'01234567'

string.punctuation:

Contains all characters which are considered punctuation in the C locale:

>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'

string.whitespace:

Contains all ASCII characters considered whitespace:

>>> string.whitespace
' \t\n\r\x0b\x0c'

In script mode, print(string.whitespace) will print the actual characters, use str to get the string returned
above.

string.printable:

Python® Notes for Professionals 169

Contains all characters which are considered printable; a combination of string.digits, string.ascii_letters,
string.punctuation, and string.whitespace.

>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~
\t\n\r\x0b\x0c'

Section 29.5: Stripping unwanted leading/trailing characters

from a string
Three methods are provided that offer the ability to strip leading and trailing characters from a string: str.strip,
str.rstrip and str.lstrip. All three methods have the same signature and all three return a new string object
with unwanted characters removed.

str.strip([chars])

str.strip acts on a given string and removes (strips) any leading or trailing characters contained in the argument
chars; if chars is not supplied or is None, all white space characters are removed by default. For example:

>>> " a line with leading and trailing space ".strip()

'a line with leading and trailing space'

If chars is supplied, all characters contained in it are removed from the string, which is returned. For example:

>>> ">>> a Python prompt".strip('> ') # strips '>' character and space character
'a Python prompt'

str.rstrip([chars]) and str.lstrip([chars])

These methods have similar semantics and arguments with str.strip(), their difference lies in the direction from
which they start. str.rstrip() starts from the end of the string while str.lstrip() splits from the start of the
string.

For example, using str.rstrip:

>>> " spacious string ".rstrip()

' spacious string'

While, using str.lstrip:

>>> " spacious string ".rstrip()

'spacious string '

Section 29.6: Reversing a string

A string can reversed using the built-in reversed() function, which takes a string and returns an iterator in reverse
order.

>>> reversed('hello')
<reversed object at 0x0000000000000000>
>>> [char for char in reversed('hello')]
['o', 'l', 'l', 'e', 'h']

reversed() can be wrapped in a call to ''.join() to make a string from the iterator.

Python® Notes for Professionals 170

>>> ''.join(reversed('hello'))
'olleh'

While using reversed() might be more readable to uninitiated Python users, using extended slicing with a step of
-1 is faster and more concise. Here , try to implement it as function:

>>> def reversed_string(main_string):

... return main_string[::-1]
...
>>> reversed_string('hello')
'olleh'

Section 29.7: Split a string based on a delimiter into a list of

strings
str.split(sep=None, maxsplit=-1)

str.split takes a string and returns a list of substrings of the original string. The behavior differs depending on
whether the sep argument is provided or omitted.

If sep isn't provided, or is None, then the splitting takes place wherever there is whitespace. However, leading and
trailing whitespace is ignored, and multiple consecutive whitespace characters are treated the same as a single
whitespace character:

>>> "This is a sentence.".split()

['This', 'is', 'a', 'sentence.']

>>> " This is a sentence. ".split()

['This', 'is', 'a', 'sentence.']

>>> " ".split()

[]

The sep parameter can be used to define a delimiter string. The original string is split where the delimiter string
occurs, and the delimiter itself is discarded. Multiple consecutive delimiters are not treated the same as a single
occurrence, but rather cause empty strings to be created.

>>> "This is a sentence.".split(' ')

['This', 'is', 'a', 'sentence.']

>>> "Earth,Stars,Sun,Moon".split(',')
['Earth', 'Stars', 'Sun', 'Moon']

>>> " This is a sentence. ".split(' ')

['', 'This', 'is', '', '', '', 'a', 'sentence.', '', '']

>>> "This is a sentence.".split('e')

['This is a s', 'nt', 'nc', '.']

>>> "This is a sentence.".split('en')

['This is a s', 't', 'ce.']

The default is to split on every occurrence of the delimiter, however the maxsplit parameter limits the number of
splittings that occur. The default value of -1 means no limit:

>>> "This is a sentence.".split('e', maxsplit=0)

['This is a sentence.']

Python® Notes for Professionals 171

>>> "This is a sentence.".split('e', maxsplit=1)
['This is a s', 'ntence.']

>>> "This is a sentence.".split('e', maxsplit=2)

['This is a s', 'nt', 'nce.']

>>> "This is a sentence.".split('e', maxsplit=-1)

['This is a s', 'nt', 'nc', '.']
str.rsplit(sep=None, maxsplit=-1)

str.rsplit ("right split") differs from str.split ("left split") when maxsplit is specified. The splitting starts at the
end of the string rather than at the beginning:

>>> "This is a sentence.".rsplit('e', maxsplit=1)

['This is a sentenc', '.']

>>> "This is a sentence.".rsplit('e', maxsplit=2)

['This is a sent', 'nc', '.']

Note: Python specifies the maximum number of splits performed, while most other programming languages
specify the maximum number of substrings created. This may create confusion when porting or comparing code.

Section 29.8: Replace all occurrences of one substring with

another substring
Python's str type also has a method for replacing occurences of one sub-string with another sub-string in a given
string. For more demanding cases, one can use re.sub.

str.replace(old, new[, count]):

str.replace takes two arguments old and new containing the old sub-string which is to be replaced by the new sub-
string. The optional argument count specifies the number of replacements to be made:

For example, in order to replace 'foo' with 'spam' in the following string, we can call str.replace with old =
'foo' and new = 'spam':

>>> "Make sure to foo your sentence.".replace('foo', 'spam')

"Make sure to spam your sentence."

If the given string contains multiple examples that match the old argument, all occurrences are replaced with the
value supplied in new:

>>> "It can foo multiple examples of foo if you want.".replace('foo', 'spam')
"It can spam multiple examples of spam if you want."

unless, of course, we supply a value for count. In this case count occurrences are going to get replaced:

>>> """It can foo multiple examples of foo if you want, \

... or you can limit the foo with the third argument.""".replace('foo', 'spam', 1)
'It can spam multiple examples of foo if you want, or you can limit the foo with the third
argument.'

Section 29.9: Testing what a string is composed of

Python's str type also features a number of methods that can be used to evaluate the contents of a string. These

Python® Notes for Professionals 172

are str.isalpha, str.isdigit, str.isalnum, str.isspace. Capitalization can be tested with str.isupper,
str.islower and str.istitle.

str.isalpha

str.isalpha takes no arguments and returns True if the all characters in a given string are alphabetic, for example:

>>> "Hello World".isalpha() # contains a space

False
>>> "Hello2World".isalpha() # contains a number
False
>>> "HelloWorld!".isalpha() # contains punctuation
False
>>> "HelloWorld".isalpha()
True

As an edge case, the empty string evaluates to False when used with "".isalpha().

str.isupper, str.islower, str.istitle

These methods test the capitalization in a given string.

str.isupper is a method that returns True if all characters in a given string are uppercase and False otherwise.

>>> "HeLLO WORLD".isupper()

False
>>> "HELLO WORLD".isupper()
True
>>> "".isupper()
False

Conversely, str.islower is a method that returns True if all characters in a given string are lowercase and False
otherwise.

>>> "Hello world".islower()

False
>>> "hello world".islower()
True
>>> "".islower()
False

str.istitle returns True if the given string is title cased; that is, every word begins with an uppercase character
followed by lowercase characters.

>>> "hello world".istitle()

False
>>> "Hello world".istitle()
False
>>> "Hello World".istitle()
True
>>> "".istitle()
False

str.isdecimal, str.isdigit, str.isnumeric

str.isdecimal returns whether the string is a sequence of decimal digits, suitable for representing a decimal
number.

str.isdigit includes digits not in a form suitable for representing a decimal number, such as superscript digits.

Python® Notes for Professionals 173

str.isnumeric includes any number values, even if not digits, such as values outside the range 0-9.

isdecimal isdigit isnumeric

12345 True True True

?2??5 True True True
?²³????? False True True
?? False False True
Five False False False

Bytestrings (bytes in Python 3, str in Python 2), only support isdigit, which only checks for basic ASCII digits.

As with str.isalpha, the empty string evaluates to False.

str.isalnum

This is a combination of str.isalpha and str.isnumeric, specifically it evaluates to True if all characters in the
given string are alphanumeric, that is, they consist of alphabetic or numeric characters:

>>> "Hello2World".isalnum()
True
>>> "HelloWorld".isalnum()
True
>>> "2016".isalnum()
True
>>> "Hello World".isalnum() # contains whitespace
False
str.isspace

Evaluates to True if the string contains only whitespace characters.

>>> "\t\r\n".isspace()
True
>>> " ".isspace()
True

Sometimes a string looks “empty” but we don't know whether it's because it contains just whitespace or no
character at all

>>> "".isspace()
False

To cover this case we need an additional test

>>> my_str = ''

>>> my_str.isspace()
False
>>> my_str.isspace() or not my_str
True

But the shortest way to test if a string is empty or just contains whitespace characters is to use strip(with no
arguments it removes all leading and trailing whitespace characters)

>>> not my_str.strip()

True

Python® Notes for Professionals 174

Section 29.10: String Contains
Python makes it extremely intuitive to check if a string contains a given substring. Just use the in operator:

>>> "foo" in "foo.baz.bar"

True

Note: testing an empty string will always result in True:

>>> "" in "test"

True

Section 29.11: Join a list of strings into one string

A string can be used as a separator to join a list of strings together into a single string using the join() method. For
example you can create a string where each element in a list is separated by a space.

>>> " ".join(["once","upon","a","time"])

"once upon a time"

The following example separates the string elements with three hyphens.

>>> "---".join(["once", "upon", "a", "time"])

"once---upon---a---time"

Section 29.12: Counting number of times a substring appears

in a string
One method is available for counting the number of occurrences of a sub-string in another string, str.count.

str.count(sub[, start[, end]])

str.count returns an int indicating the number of non-overlapping occurrences of the sub-string sub in another
string. The optional arguments start and end indicate the beginning and the end in which the search will take
place. By default start = 0 and end = len(str) meaning the whole string will be searched:

>>> s = "She sells seashells by the seashore."

>>> s.count("sh")
2
>>> s.count("se")
3
>>> s.count("sea")
2
>>> s.count("seashells")
1

By specifying a different value for start, end we can get a more localized search and count, for example, if start is
equal to 13 the call to:

>>> s.count("sea", start)

1

is equivalent to:

>>> t = s[start:]

Python® Notes for Professionals 175

>>> t.count("sea")
1

Section 29.13: Case insensitive string comparisons

Comparing string in a case insensitive way seems like something that's trivial, but it's not. This section only
considers unicode strings (the default in Python 3). Note that Python 2 may have subtle weaknesses relative to
Python 3 - the later's unicode handling is much more complete.

The first thing to note it that case-removing conversions in unicode aren't trivial. There is text for which
text.lower() != text.upper().lower(), such as "ß":

>>> "ß".lower()
'ß'

>>> "ß".upper().lower()
'ss'

But let's say you wanted to caselessly compare "BUSSE" and "Buße". You probably also want to compare "BUSSE"
and "BUẞE" equal - that's the newer capital form. The recommended way is to use casefold:

Python 3.x Version ≥ 3.3

>>> help(str.casefold)
"""
Help on method_descriptor:

casefold(...)
S.casefold() -> str

Return a version of S suitable for caseless comparisons.

"""

Do not just use lower. If casefold is not available, doing .upper().lower() helps (but only somewhat).

Then you should consider accents. If your font renderer is good, you probably think "ê" == "ê" - but it doesn't:

>>> "ê" == "ê"

False

This is because they are actually

>>> import unicodedata

>>> [unicodedata.name(char) for char in "ê"]

['LATIN SMALL LETTER E WITH CIRCUMFLEX']

>>> [unicodedata.name(char) for char in "ê"]

['LATIN SMALL LETTER E', 'COMBINING CIRCUMFLEX ACCENT']

The simplest way to deal with this is unicodedata.normalize. You probably want to use NFKD normalization, but
feel free to check the documentation. Then one does

>>> unicodedata.normalize("NFKD", "ê") == unicodedata.normalize("NFKD", "ê")

True

To finish up, here this is expressed in functions:

Python® Notes for Professionals 176

import unicodedata

def normalize_caseless(text):
return unicodedata.normalize("NFKD", text.casefold())

def caseless_equal(left, right):

return normalize_caseless(left) == normalize_caseless(right)

Section 29.14: Justify strings

Python provides functions for justifying strings, enabling text padding to make aligning various strings much easier.

Below is an example of str.ljust and str.rjust:

interstates_lengths = {
5: (1381, 2222),
19: (63, 102),
40: (2555, 4112),
93: (189,305),
}
for road, length in interstates_lengths.items():
miles,kms = length
print('{} -> {} mi. ({} km.)'.format(str(road).rjust(4), str(miles).ljust(4),
str(kms).ljust(4)))

40 -> 2555 mi. (4112 km.)

19 -> 63 mi. (102 km.)
5 -> 1381 mi. (2222 km.)
93 -> 189 mi. (305 km.)

ljust and rjust are very similar. Both have a width parameter and an optional fillchar parameter. Any string
created by these functions is at least as long as the width parameter that was passed into the function. If the string
is longer than width alread, it is not truncated. The fillchar argument, which defaults to the space character ' '
must be a single character, not a multicharacter string.

The ljust function pads the end of the string it is called on with the fillchar until it is width characters long. The
rjust function pads the beginning of the string in a similar fashion. Therefore, the l and r in the names of these
functions refer to the side that the original string, not the fillchar, is positioned in the output string.

Section 29.15: Test the starting and ending characters of a

string
In order to test the beginning and ending of a given string in Python, one can use the methods str.startswith()
and str.endswith().

str.startswith(prefix[, start[, end]])

As it's name implies, str.startswith is used to test whether a given string starts with the given characters in
prefix.

>>> s = "This is a test string"

>>> s.startswith("T")
True
>>> s.startswith("Thi")
True
>>> s.startswith("thi")
False

Python® Notes for Professionals 177

The optional arguments start and end specify the start and end points from which the testing will start and finish.
In the following example, by specifying a start value of 2 our string will be searched from position 2 and afterwards:

>>> s.startswith("is", 2)
True

This yields True since s[2] == 'i' and s[3] == 's'.

You can also use a tuple to check if it starts with any of a set of strings

>>> s.startswith(('This', 'That'))

True
>>> s.startswith(('ab', 'bc'))
False
str.endswith(prefix[, start[, end]])

str.endswith is exactly similar to str.startswith with the only difference being that it searches for ending
characters and not starting characters. For example, to test if a string ends in a full stop, one could write:

>>> s = "this ends in a full stop."

>>> s.endswith('.')
True
>>> s.endswith('!')
False

as with startswith more than one characters can used as the ending sequence:

>>> s.endswith('stop.')
True
>>> s.endswith('Stop.')
False

You can also use a tuple to check if it ends with any of a set of strings

>>> s.endswith(('.', 'something'))

True
>>> s.endswith(('ab', 'bc'))
False

Section 29.16: Conversion between str or bytes data and

unicode characters
The contents of files and network messages may represent encoded characters. They often need to be converted to
unicode for proper display.

In Python 2, you may need to convert str data to Unicode characters. The default ('', "", etc.) is an ASCII string, with
any values outside of ASCII range displayed as escaped values. Unicode strings are u'' (or u"", etc.).

Python 2.x Version ≥ 2.3

# You get "© abc" encoded in UTF-8 from a file, network, or other data source

s = '\xc2\xa9 abc' # s is a byte array, not a string of characters

# Doesn't know the original was UTF-8
# Default form of string literals in Python 2
s[0] # '\xc2' - meaningless byte (without context such as an encoding)
type(s) # str - even though it's not a useful one w/o having a known encoding

Python® Notes for Professionals 178

u = s.decode('utf-8') # u'\xa9 abc'
# Now we have a Unicode string, which can be read as UTF-8 and printed
properly
# In Python 2, Unicode string literals need a leading u
# str.decode converts a string which may contain escaped bytes to a Unicode
string
u[0] # u'\xa9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u) # unicode

u.encode('utf-8') # '\xc2\xa9 abc'

# unicode.encode produces a string with escaped bytes for non-ASCII characters

In Python 3 you may need to convert arrays of bytes (referred to as a 'byte literal') to strings of Unicode characters.
The default is now a Unicode string, and bytestring literals must now be entered as b'', b"", etc. A byte literal will
return True to isinstance(some_val, byte), assuming some_val to be a string that might be encoded as bytes.

Python 3.x Version ≥ 3.0

# You get from file or network "© abc" encoded in UTF-8

s = b'\xc2\xa9 abc' # s is a byte array, not characters

# In Python 3, the default string literal is Unicode; byte array literals need a
leading b
s[0] # b'\xc2' - meaningless byte (without context such as an encoding)
type(s) # bytes - now that byte arrays are explicit, Python can show that.

u = s.decode('utf-8') # '© abc' on a Unicode terminal

# bytes.decode converts a byte array to a string (which will, in Python 3, be
Unicode)
u[0] # '\u00a9' - Unicode Character 'COPYRIGHT SIGN' (U+00A9) '©'
type(u) # str
# The default string literal in Python 3 is UTF-8 Unicode

u.encode('utf-8') # b'\xc2\xa9 abc'

# str.encode produces a byte array, showing ASCII-range bytes as unescaped
characters.

Python® Notes for Professionals 179

Chapter 30: String Formatting
When storing and transforming data for humans to see, string formatting can become very important. Python
offers a wide variety of string formatting methods which are outlined in this topic.

Section 30.1: Basics of String Formatting

foo = 1
bar = 'bar'
baz = 3.14

You can use str.format to format output. Bracket pairs are replaced with arguments in the order in which the
arguments are passed:

print('{}, {} and {}'.format(foo, bar, baz))

# Out: "1, bar and 3.14"

Indexes can also be specified inside the brackets. The numbers correspond to indexes of the arguments passed to
the str.format function (0-based).

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))

# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

Named arguments can be also used:

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))

# Out: "X value is: 2. Y value is: 3."

Object attributes can be referenced when passed into str.format:

class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value)) # "0" is optional
# Out: "My value is: 6"

Dictionary keys can be used as well:

my_dict = {'key': 6, 'other_key': 7}

print("My other key is: {0[other_key]}".format(my_dict)) # "0" is optional
# Out: "My other key is: 7"

Same applies to list and tuple indices:

my_list = ['zero', 'one', 'two']

print("2nd element is: {0[2]}".format(my_list)) # "0" is optional
# Out: "2nd element is: two"

Note: In addition to str.format, Python also provides the modulo operator %--also known as the string
formatting or interpolation operator (see PEP 3101)--for formatting strings. str.format is a successor of %

Python® Notes for Professionals 180

 and it offers greater flexibility, for instance by making it easier to carry out multiple substitutions.

In addition to argument indexes, you can also include a format specification inside the curly brackets. This is an
expression that follows special rules and must be preceded by a colon (:). See the docs for a full description of
format specification. An example of format specification is the alignment directive :~^20 (^ stands for center
alignment, total width 20, fill with ~ character):

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format allows behaviour not possible with %, for example repetition of arguments:

t = (12, 45, 22222, 103, 6)

print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*t)
# Out: 12 22222 45 22222 103 22222 6 22222

As format is a function, it can be used as an argument in other functions:

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']

from datetime import datetime,timedelta

once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)

delta = timedelta(days=13, hours=8, minutes=20)

gen = (once_upon_a_time + x * delta for x in xrange(5))

print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))

#Out: 2010-07-01 12:00:00
# 2010-07-14 20:20:00
# 2010-07-28 04:40:00
# 2010-08-10 13:00:00
# 2010-08-23 21:20:00

Section 30.2: Alignment and padding

Python 2.x Version ≥ 2.6

The format() method can be used to change the alignment of the string. You have to do it with a format expression
of the form :[fill_char][align_operator][width] where align_operator is one of:

< forces the field to be left-aligned within width.

> forces the field to be right-aligned within width.
^ forces the field to be centered within width.
= forces the padding to be placed after the sign (numeric types only).

fill_char (if omitted default is whitespace) is the character used for the padding.

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

Python® Notes for Professionals 181

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

Note: you could achieve the same results using the string functions ljust(), rjust(), center(), zfill(), however
these functions are deprecated since version 2.5.

Section 30.3: Format literals (f-string)

Literal format strings were introduced in PEP 498 (Python3.6 and upwards), allowing you to prepend f to the
beginning of a string literal to effectively apply .format to it with all variables in the current scope.

>>> foo = 'bar'

>>> f'Foo is {foo}'
'Foo is bar'

This works with more advanced format strings too, including alignment and dot notation.

>>> f'{foo:^7s}'
' bar '

Note: The f'' does not denote a particular type like b'' for bytes or u'' for unicode in python2. The formating is
immediately applied, resulting in a normal stirng.

The format strings can also be nested:

>>> price = 478.23

>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

The expressions in an f-string are evaluated in left-to-right order. This is detectable only if the expressions have side
effects:

>>> def fn(l, incr):

... result = l[0]
... l[0] += incr
... return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

Section 30.4: Float formatting

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)

Python® Notes for Professionals 182

'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

Same hold for other way of referencing:

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

Floating point numbers can also be formatted in scientific notation or as percentages:

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

You can also combine the {0} and {name} notations. This is especially useful when you want to round all variables
to a pre-specified number of decimals with 1 declaration:

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)

'Hello! 1.12, 2.35, 34.57'

Section 30.5: Named placeholders

Format strings may contain named placeholders that are interpolated using keyword arguments to format.

Using a dictionary (Python 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

Using a dictionary (Python 3.2+)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map allows to use dictionaries without having to unpack them first. Also the class of data (which might
be a custom type) is used instead of a newly filled dict.

Without a dictionary:
>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'

Python® Notes for Professionals 183

Section 30.6: String formatting with datetime
Any class can configure its own string formatting syntax through the __format__ method. A type in the standard
Python library that makes handy use of this is the datetime type, where one can use strftime-like formatting
codes directly within str.format:

>>> from datetime import datetime

>>> 'North America: {dt:%m/%d/%Y}. ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016. ISO: 2016-07-21.'

A full list of list of datetime formatters can be found in the official documenttion.

Section 30.7: Formatting Numerical Values

The .format() method can interpret a number in different formats, such as:

>>> '{:c}'.format(65) # Unicode character

'A'

>>> '{:d}'.format(0x0a) # base 10

'10'

>>> '{:n}'.format(0x0a) # base 10 using current locale for separators

'10'

Format integers to different bases (hex, oct, binary)

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal

'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal

'A'

>>> '{:o}'.format(10) # base 8 - Octal

'12'

>>> '{:b}'.format(10) # base 2 - Binary

'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix

'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

Use formatting to convert an RGB float tuple to a color hex string:

>>> r, g, b = (1.0, 0.4, 0.0)

>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

Only integers can be converted:

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

Python® Notes for Professionals 184

Section 30.8: Nested formatting
Some formats can take additional parameters, such as the width of the formatted string, or the alignment:

>>> '{:.>10}'.format('foo')
'.......foo'

Those can also be provided as parameters to format by nesting more {} inside the {}:

>>> '{:.>{}}'.format('foo', 10)

'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

In the latter example, the format string '{:{}{}{}}' is modified to '{:*^15}' (i.e. "center and pad with * to total
length of 15") before applying it to the actual string 'foo' to be formatted that way.

This can be useful in cases when parameters are not known beforehand, for instances when aligning tabular data:

>>> data = ["a", "bbbbbbb", "ccc"]

>>> m = max(map(len, data))
>>> for d in data:
... print('{:>{}}'.format(d, m))
a
bbbbbbb
ccc

Section 30.9: Format using Getitem and Getattr

Any data structure that supports __getitem__ can have their nested structure formatted:

person = {'first': 'Arthur', 'last': 'Dent'}

'{p[first]} {p[last]}'.format(p=person)
# 'Arthur Dent'

Object attributes can be accessed using getattr():

class Person(object):
first = 'Zaphod'
last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

Section 30.10: Padding and truncating strings, combined

Say you want to print variables in a 3 character column.

Note: doubling { and } escapes them.

s = """

pad
{{:3}} :{a:3}:

truncate

Python® Notes for Professionals 185

{{:.3}} :{e:.3}:

combined
{{:>3.3}} :{a:>3.3}:
{{:3.3}} :{a:3.3}:
{{:3.3}} :{c:3.3}:
{{:3.3}} :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

Output:

pad
{:3} :1 :

truncate
{:.3} :555:

combined
{:>3.3} : 1:
{:3.3} :1 :
{:3.3} :333:
{:3.3} :555:

Section 30.11: Custom formatting for a class

Note:

Everything below applies to the str.format method, as well as the format function. In the text below, the
two are interchangeable.

For every value which is passed to the format function, Python looks for a __format__ method for that argument.
Your own custom class can therefore have their own __format__ method to determine how the format function will
display and format your class and it's attributes.

This is different than the __str__ method, as in the __format__ method you can take into account the formatting
language, including alignment, field width etc, and even (if you wish) implement your own format specifiers, and
your own formatting language extensions.1

object.__format__(self, format_spec)

For example :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
def __init__(self,a,b,c):
self.a, self.b, self.c = a,b,c

def __format__(self, format_spec):

""" Implement special semantics for the 's' format specifier """
# Reject anything that isn't an s
if format_spec[-1] != 's':
raise ValueError('{} format specifier not understood for this object',
format_spec[:-1])

Python® Notes for Professionals 186

 # Output in this example will be (<a>,<b>,<c>)
raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
# Honor the format language by using the inbuilt string format
# Since we know the original format_spec ends in an 's'
# we can take advantage of the str.format method with a
# string argument we constructed above
return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out : (1,2,3)
# Note how the right align and field width of 20 has been honored.

Note:

If your custom class does not have a custom __format__ method and an instance of the class is passed to
the format function, Python2 will always use the return value of the __str__ method or __repr__
method to determine what to print (and if neither exist then the default repr will be used), and you will
need to use the s format specifier to format this. With Python3, to pass your custom class to the format
function, you will need define __format__ method on your custom class.

Python® Notes for Professionals 187

Chapter 31: Conditionals
Conditional expressions, involving keywords such as if, elif, and else, provide Python programs with the ability to
perform different actions depending on a boolean condition: True or False. This section covers the use of Python
conditionals, boolean logic, and ternary statements.

Section 31.1: Conditional Expression (or "The Ternary

Operator")
The ternary operator is used for inline conditional expressions. It is best used in simple, concise operations that are
easily read.

The order of the arguments is different from many other languages (such as C, Ruby, Java, etc.), which may
lead to bugs when people unfamiliar with Python's "surprising" behaviour use it (they may reverse the order).
Some find it "unwieldy", since it goes contrary to the normal flow of thought (thinking of the condition first
and then the effects).

n = 5

"Greater than 2" if n > 2 else "Smaller than or equal to 2"

# Out: 'Greater than 2'

The result of this expression will be as it is read in English - if the conditional expression is True, then it will evaluate
to the expression on the left side, otherwise, the right side.

Tenary operations can also be nested, as here:

n = 5
"Hello" if n > 10 else "Goodbye" if n > 5 else "Good day"

They also provide a method of including conditionals in lambda functions.

Section 31.2: if, elif, and else

In Python you can define a series of conditionals using if for the first one, elif for the rest, up until the final
(optional) else for anything not caught by the other conditionals.

number = 5

if number > 2:
print("Number is bigger than 2.")
elif number < 2: # Optional clause (you can have multiple elifs)
print("Number is smaller than 2.")
else: # Optional clause (you can only have one else)
print("Number is 2.")

Outputs Number is bigger than 2

Using else if instead of elif will trigger a syntax error and is not allowed.

Section 31.3: Truth Values

The following values are considered falsey, in that they evaluate to False when applied to a boolean operator.

Python® Notes for Professionals 188

 None
False
0, or any numerical value equivalent to zero, for example 0L, 0.0, 0j
Empty sequences: '', "", (), []
Empty mappings: {}
User-defined types where the __bool__ or __len__ methods return 0 or False

All other values in Python evaluate to True.

Note: A common mistake is to simply check for the Falseness of an operation which returns different Falsey values
where the difference matters. For example, using if foo() rather than the more explicit if foo() is None

Section 31.4: Boolean Logic Expressions

Boolean logic expressions, in addition to evaluating to True or False, return the value that was interpreted as True
or False. It is Pythonic way to represent logic that might otherwise require an if-else test.

And operator

The and operator evaluates all expressions and returns the last expression if all expressions evaluate to True.
Otherwise it returns the first value that evaluates to False:

>>> 1 and 2
2

>>> 1 and 0
0

>>> 1 and "Hello World"

"Hello World"

>>> "" and "Pancakes"

""

Or operator

The or operator evaluates the expressions left to right and returns the first value that evaluates to True or the last
value (if none are True).

>>> 1 or 2
1

>>> None or 1
1

>>> 0 or []
[]

Lazy evaluation

When you use this approach, remember that the evaluation is lazy. Expressions that are not required to be
evaluated to determine the result are not evaluated. For example:

>>> def print_me():

print('I am here!')
>>> 0 and print_me()

Python® Notes for Professionals 189

0

In the above example, print_me is never executed because Python can determine the entire expression is False
when it encounters the 0 (False). Keep this in mind if print_me needs to execute to serve your program logic.

Testing for multiple conditions

A common mistake when checking for multiple conditions is to apply the logic incorrectly.

This example is trying to check if two variables are each greater than 2. The statement is evaluated as - if (a) and
(b > 2). This produces an unexpected result because bool(a) evaluates as True when a is not zero.

>>> a = 1
>>> b = 6
>>> if a and b > 2:
... print('yes')
... else:
... print('no')

yes

Each variable needs to be compared separately.

>>> if a > 2 and b > 2:

... print('yes')
... else:
... print('no')

no

Another, similar, mistake is made when checking if a variable is one of multiple values. The statement in this
example is evaluated as - if (a == 3) or (4) or (6). This produces an unexpected result because bool(4) and
bool(6) each evaluate to True

>>> a = 1
>>> if a == 3 or 4 or 6:
... print('yes')
... else:
... print('no')

yes

Again each comparison must be made separately

>>> if a == 3 or a == 4 or a == 6:
... print('yes')
... else:
... print('no')

no

Using the in operator is the canonical way to write this.

>>> if a in (3, 4, 6):

... print('yes')
... else:
... print('no')

Python® Notes for Professionals 190

no

Section 31.5: Using the cmp function to get the comparison

result of two objects
Python 2 includes a cmp function which allows you to determine if one object is less than, equal to, or greater than
another object. This function can be used to pick a choice out of a list based on one of those three options.

Suppose you need to print 'greater than' if x > y, 'less than' if x < y and 'equal' if x == y.

['equal', 'greater than', 'less than', ][cmp(x,y)]

# x,y = 1,1 output: 'equal'

# x,y = 1,2 output: 'less than'
# x,y = 2,1 output: 'greater than'

cmp(x,y) returns the following values

Comparison Result
x<y -1
x == y 0
x>y 1

This function is removed on Python 3. You can use the cmp_to_key(func) helper function located in functools in
Python 3 to convert old comparison functions to key functions.

Section 31.6: Else statement

if condition:
body
else:
body

The else statement will execute it's body only if preceding conditional statements all evaluate to False.

if True:
print "It is true!"
else:
print "This won't get printed.."

# Output: It is true!

if False:
print "This won't get printed.."
else:
print "It is false!"

# Output: It is false!

Section 31.7: Testing if an object is None and assigning it

You'll often want to assign something to an object if it is None, indicating it has not been assigned. We'll use aDate.

The simplest way to do this is to use the is None test.

if aDate is None:

Python® Notes for Professionals 191

 aDate=datetime.date.today()

(Note that it is more Pythonic to say is None instead of == None.)

But this can be optimized slightly by exploiting the notion that not None will evaluate to True in a boolean
expression. The following code is equivalent:

if not aDate:
aDate=datetime.date.today()

But there is a more Pythonic way. The following code is also equivalent:

aDate=aDate or datetime.date.today()

This does a Short Circuit evaluation. If aDate is initialized and is not None, then it gets assigned to itself with no net
effect. If it is None, then the datetime.date.today() gets assigned to aDate.

Section 31.8: If statement

if condition:
body

The if statements checks the condition. If it evaluates to True, it executes the body of the if statement. If it
evaluates to False, it skips the body.

if True:
print "It is true!"
>> It is true!

if False:
print "This won't get printed.."

The condition can be any valid expression:

if 2 + 2 == 4:
print "I know math!"
>> I know math!

Python® Notes for Professionals 192

Chapter 32: Loops
Parameter Details
boolean expression expression that can be evaluated in a boolean context, e.g. x < 10
variable variable name for the current element from the iterable
iterable anything that implements iterations

As one of the most basic functions in programming, loops are an important piece to nearly every programming
language. Loops enable developers to set certain portions of their code to repeat through a number of loops which
are referred to as iterations. This topic covers using multiple types of loops and applications of loops in Python.

Section 32.1: Break and Continue in Loops

break statement

When a break statement executes inside a loop, control flow "breaks" out of the loop immediately:

i = 0
while i < 7:
print(i)
if i == 4:
print("Breaking from loop")
break
i += 1

The loop conditional will not be evaluated after the break statement is executed. Note that break statements are
only allowed inside loops, syntactically. A break statement inside a function cannot be used to terminate loops that
called that function.

Executing the following prints every digit until number 4 when the break statement is met and the loop stops:

0
1
2
3
4
Breaking from loop

break statements can also be used inside for loops, the other looping construct provided by Python:

for i in (0, 1, 2, 3, 4):

print(i)
if i == 2:
break

Executing this loop now prints:

0
1
2

Note that 3 and 4 are not printed since the loop has ended.

If a loop has an else clause, it does not execute when the loop is terminated through a break statement.

Python® Notes for Professionals 193

continue statement

A continue statement will skip to the next iteration of the loop bypassing the rest of the current block but
continuing the loop. As with break, continue can only appear inside loops:

for i in (0, 1, 2, 3, 4, 5):

if i == 2 or i == 4:
continue
print(i)

0
1
3
5

Note that 2 and 4 aren't printed, this is because continue goes to the next iteration instead of continuing on to
print(i) when i == 2 or i == 4.

Nested Loops

break and continue only operate on a single level of loop. The following example will only break out of the inner
for loop, not the outer while loop:

while True:
for i in range(1,5):
if i == 2:
break # Will only break out of the inner loop!

Python doesn't have the ability to break out of multiple levels of loop at once -- if this behavior is desired,
refactoring one or more loops into a function and replacing break with return may be the way to go.

Use return from within a function as a break

The return statement exits from a function, without executing the code that comes after it.

If you have a loop inside a function, using return from inside that loop is equivalent to having a break as the rest of
the code of the loop is not executed (note that any code after the loop is not executed either):

def break_loop():
for i in range(1, 5):
if (i == 2):
return(i)
print(i)
return(5)

If you have nested loops, the return statement will break all loops:

def break_all():
for j in range(1, 5):
for i in range(1,4):
if i*j == 6:
return(i)
print(i*j)

will output:

1 # 1*1

Python® Notes for Professionals 194

2 # 1*2
3 # 1*3
4 # 1*4
2 # 2*1
4 # 2*2
# return because 2*3 = 6, the remaining iterations of both loops are not executed

Section 32.2: For loops

for loops iterate over a collection of items, such as list or dict, and run a block of code with each element from
the collection.

for i in [0, 1, 2, 3, 4]:

print(i)

The above for loop iterates over a list of numbers.

Each iteration sets the value of i to the next element of the list. So first it will be 0, then 1, then 2, etc. The output
will be as follow:

0
1
2
3
4

range is a function that returns a series of numbers under an iterable form, thus it can be used in for loops:

for i in range(5):
print(i)

gives the exact same result as the first for loop. Note that 5 is not printed as the range here is the first five
numbers counting from 0.

Iterable objects and iterators

for loop can iterate on any iterable object which is an object which defines a __getitem__ or a __iter__ function.
The __iter__ function returns an iterator, which is an object with a next function that is used to access the next
element of the iterable.

Section 32.3: Iterating over lists

To iterate through a list you can use for:

for x in ['one', 'two', 'three', 'four']:

print(x)

This will print out the elements of the list:

one
two
three
four

The range function generates numbers which are also often used in a for loop.

Python® Notes for Professionals 195

 for x in range(1, 6):
print(x)

The result will be a special range sequence type in python >=3 and a list in python <=2. Both can be looped through
using the for loop.

1
2
3
4
5

If you want to loop though both the elements of a list and have an index for the elements as well, you can use
Python's enumerate function:

for index, item in enumerate(['one', 'two', 'three', 'four']):

print(index, '::', item)

enumerate will generate tuples, which are unpacked into index (an integer) and item (the actual value from the list).
The above loop will print

(0, '::', 'one')

(1, '::', 'two')
(2, '::', 'three')
(3, '::', 'four')

Iterate over a list with value manipulation using map and lambda, i.e. apply lambda function on each element in the
list:

x = map(lambda e : e.upper(), ['one', 'two', 'three', 'four'])

print(x)

Output:

['ONE', 'TWO', 'THREE', 'FOUR'] # Python 2.x

NB: in Python 3.x map returns an iterator instead of a list so you in case you need a list you have to cast the result
print(list(x)) (see
http://stackoverflow.com/documentation/python/809/incompatibilities-between-python-2-and-python-3/8186/map
) in http://stackoverflow.com/documentation/python/809/incompatibilities-between-python-2-and-python-3 ).

Section 32.4: Loops with an "else" clause

The for and while compound statements (loops) can optionally have an else clause (in practice, this usage is fairly
rare).

The else clause only executes after a for loop terminates by iterating to completion, or after a while loop
terminates by its conditional expression becoming false.

for i in range(3):
print(i)
else:
print('done')

i = 0

Python® Notes for Professionals 196

while i < 3:
print(i)
i += 1
else:
print('done')

output:

0
1
2
done

The else clause does not execute if the loop terminates some other way (through a break statement or by raising
an exception):

for i in range(2):
print(i)
if i == 1:
break
else:
print('done')

output:

0
1

Most other programming languages lack this optional else clause of loops. The use of the keyword else in
particular is often considered confusing.

The original concept for such a clause dates back to Donald Knuth and the meaning of the else keyword becomes
clear if we rewrite a loop in terms of if statements and goto statements from earlier days before structured
programming or from a lower-level assembly language.

For example:

while loop_condition():
...
if break_condition():
break
...

is equivalent to:

# pseudocode

<<start>>:
if loop_condition():
...
if break_condition():
goto <<end>>
...
goto <<start>>

<<end>>:

Python® Notes for Professionals 197

These remain equivalent if we attach an else clause to each of them.

For example:

while loop_condition():
...
if break_condition():
break
...
else:
print('done')

is equivalent to:

# pseudocode

<<start>>:
if loop_condition():
...
if break_condition():
goto <<end>>
...
goto <<start>>
else:
print('done')

<<end>>:

A for loop with an else clause can be understood the same way. Conceptually, there is a loop condition that
remains True as long as the iterable object or sequence still has some remaining elements.

Why would one use this strange construct?

The main use case for the for...else construct is a concise implementation of search as for instance:

a = [1, 2, 3, 4]
for i in a:
if type(i) is not int:
print(i)
break
else:
print("no exception")

To make the else in this construct less confusing one can think of it as "if not break" or "if not found".

Some discussions on this can be found in [Python-ideas] Summary of for...else threads, Why does python use 'else'
after for and while loops? , and Else Clauses on Loop Statements

Section 32.5: The Pass Statement

pass is a null statement for when a statement is required by Python syntax (such as within the body of a for or
while loop), but no action is required or desired by the programmer. This can be useful as a placeholder for code
that is yet to be written.

for x in range(10):
pass #we don't want to do anything, or are not ready to do anything here, so we'll pass

Python® Notes for Professionals 198

In this example, nothing will happen. The for loop will complete without error, but no commands or