Python® Notes for Professionals
Free

Python® Notes for Professionals

By Goalkicker.com (editor)
Free
Book Description


  1. Getting started with Python Language

  2. Python Data Types

  3. Indentation

  4. Comments and Documentation

  5. Date and Time

  6. Date Formatting

  7. Enum

  8. Set

  9. List comprehensions

  10. Simple Mathematical Operators

  11. Bitwise Operators

  12. Boolean Operators

  13. Operator Precedence

  14. Filter

  15. Arrays

  16. Dictionary

  17. List

  18. List slicing (selecting parts of lists)

  19. Linked lists

  20. Linked List Node

  21. Tuple

  22. Functions

  23. Defining functions with list arguments

  24. Functional Programming in Python

  25. Partial functions

  26. Decorators

  27. Classes

  28. Metaclasses

  29. String Methods

  30. String Formatting

  31. Conditionals

  32. Loops

  33. Using loops within functions

  34. Importing modules

  35. Difference between Module and Package

  36. Math Module

  37. Complex math

  38. Collections module

  39. Operator module

  40. JSON Module

  41. Sqlite3 Module

  42. The os Module

  43. The locale Module

  44. Itertools Module

  45. Asyncio Module

  46. Random module

  47. Functools Module

  48. The dis module

  49. The base64 Module

  50. Queue Module

  51. Deque Module

  52. Usage of "pip" module: PyPI Package Manager

  53. Webbrowser Module

  54. pyautogui module

  55. Plotting with Matplotlib

  56. Comparisons

  57. Sorting, Minimum and Maximum

  58. Variable Scope and Binding

  59. Basic Input and Output

  60. Files & Folders I/O

  61. Indexing and Slicing

  62. Generators

  63. Reduce

  64. Map Function

  65. Exponentiation

  66. Searching

  67. Counting

  68. Manipulating XML

  69. Parallel computation

  70. Processes and Threads

  71. Multithreading

  72. Writing extensions

  73. Unit Testing

  74. Regular Expressions (Regex)

  75. Incompatibilities moving from Python 2 to Python 3

  76. Virtual environments

  77. Copying data

  78. Context Managers (“with” Statement)

  79. Hidden Features

  80. Unicode and bytes

  81. The __name__ special variable

  82. Checking Path Existence and Permissions

  83. Python Networking

  84. The Print Function

  85. os.path

  86. Creating Python packages

  87. Parsing Command Line arguments

  88. HTML Parsing

  89. Subprocess Library

  90. setup.py

  91. Sockets

  92. Recursion

  93. Type Hints

  94. pip: PyPI Package Manager

  95. Exceptions

  96. Web scraping with Python

  97. Distribution

  98. Property Objects

  99. Overloading

  100. Debugging

  101. Reading and Writing CSV

  102. Dynamic code execution with `exec` and `eval`

  103. PyInstaller - Distributing Python Code

  104. Iterables and Iterators

  105. Data Visualization with Python

  106. The Interpreter (Command Line Console)

  107. *args and **kwargs

  108. Garbage Collection

  109. Pickle data serialisation

  110. urllib

  111. Binary Data

  112. Python and Excel

  113. Idioms

  114. Method Overriding

  115. Data Serialization

  116. Python concurrency

  117. Introduction to RabbitMQ using AMQPStorm

  118. Descriptor

  119. Multiprocessing

  120. tempfile NamedTemporaryFile

  121. Input, Subset and Output External Data Files using Pandas

  122. Writing to CSV from String or List

  123. Unzipping Files

  124. Working with ZIP archives

  125. Stack

  126. Profiling

  127. User-Defined Methods

  128. Working around the Global Interpreter Lock (GIL)

  129. Deployment

  130. Logging

  131. Database Access

  132. Python HTTP Server

  133. Web Server Gateway Interface (WSGI)

  134. Python Server Sent Events

  135. Connecting Python to SQL Server

  136. Sockets And Message Encryption/Decryption Between Client and Server

  137. Alternatives to switch statement from other languages

  138. List Comprehensions

  139. List destructuring (aka packing and unpacking)

  140. Accessing Python source code and bytecode

  141. Mixins

  142. Attribute Access

  143. ArcPy

  144. Abstract Base Classes (abc)

  145. Plugin and Extension Classes

  146. Websockets

  147. Immutable datatypes(int, float, str, tuple and frozensets)

  148. String representations of class instances: __str__ and __repr__ methods

  149. Polymorphism

  150. Non-official Python implementations

  151. 2to3 tool

  152. Abstract syntax tree

  153. Unicode

  154. Python Serial Communication (pyserial)

  155. Neo4j and Cypher using Py2Neo

  156. Basic Curses with Python

  157. Performance optimization

  158. Templates in python

  159. Pillow

  160. The pass statement

  161. py.test

  162. Heapq

  163. tkinter

  164. CLI subcommands with precise help output

  165. PostgreSQL

  166. Python Persistence

  167. Turtle Graphics

  168. Design Patterns

  169. Multidimensional arrays

  170. Audio

  171. Pyglet

  172. Flask

  173. groupby()

  174. pygame

  175. hashlib

  176. getting start with GZip

  177. ctypes

  178. Creating a Windows service using Python

  179. Mutable vs Immutable (and Hashable) in Python

  180. Python speed of program

  181. configparser

  182. Commonwealth Exceptions

  183. Optical Character Recognition

  184. graph-tool

  185. Python Virtual Environment - virtualenv

  186. sys

  187. virtual environment with virtualenvwrapper

  188. Create virtual environment with virtualenvwrapper in windows

  189. Python Requests Post

  190. Python Lex-Yacc

  191. ChemPy - python package

  192. pyaudio

  193. shelve

  194. IoT Programming with Python and Raspberry PI

  195. kivy - Cross-platform Python Framework for NUI Development

  196. Call Python from C#

  197. Similarities in syntax, Differences in meaning: Python vs. JavaScript

  198. Raise Custom Errors / Exceptions

  199. Pandas Transform: Preform operations on groups and concatenate the results

  200. Security and Cryptography

  201. Secure Shell Connection in Python

  202. Python Anti-Patterns

  203. Common Pitfalls

Table of Contents
  • Content list
  • About
  • Chapter 1: Getting started with Python Language
    • Section 1.1: Getting Started
    • Section 1.2: Creating variables and assigning values
    • Section 1.3: Block Indentation
    • Section 1.4: Datatypes
    • Section 1.5: Collection Types
    • Section 1.6: IDLE - Python GUI
    • Section 1.7: User Input
    • Section 1.8: Built in Modules and Functions
    • Section 1.9: Creating a module
    • Section 1.10: Installation of Python 2.7.x and 3.x
    • Section 1.11: String function - str() and repr()
    • Section 1.12: Installing external modules using pip
    • Section 1.13: Help Utility
  • Chapter 2: Python Data Types
    • Section 2.1: String Data Type
    • Section 2.2: Set Data Types
    • Section 2.3: Numbers data type
    • Section 2.4: List Data Type
    • Section 2.5: Dictionary Data Type
    • Section 2.6: Tuple Data Type
  • Chapter 3: Indentation
    • Section 3.1: Simple example
    • Section 3.2: How Indentation is Parsed
    • Section 3.3: Indentation Errors
  • Chapter 4: Comments and Documentation
    • Section 4.1: Single line, inline and multiline comments
    • Section 4.2: Programmatically accessing docstrings
    • Section 4.3: Write documentation using docstrings
  • Chapter 5: Date and Time
    • Section 5.1: Parsing a string into a timezone aware datetime object
    • Section 5.2: Constructing timezone-aware datetimes
    • Section 5.3: Computing time dierences
    • Section 5.4: Basic datetime objects usage
    • Section 5.5: Switching between time zones
    • Section 5.6: Simple date arithmetic
    • Section 5.7: Converting timestamp to datetime
    • Section 5.8: Subtracting months from a date accurately
    • Section 5.9: Parsing an arbitrary ISO 8601 timestamp with minimal libraries
    • Section 5.10: Get an ISO 8601 timestamp
    • Section 5.11: Parsing a string with a short time zone name into a timezone aware datetime object
    • Section 5.12: Fuzzy datetime parsing (extracting datetime out of a text)
    • Section 5.13: Iterate over dates
  • Chapter 6: Date Formatting
    • Section 6.1: Time between two date-times
    • Section 6.2: Outputting datetime object to string
    • Section 6.3: Parsing string to datetime object
  • Chapter 7: Enum
    • Section 7.1: Creating an enum (Python 2.4 through 3.3)
    • Section 7.2: Iteration
  • Chapter 8: Set
    • Section 8.1: Operations on sets
    • Section 8.2: Get the unique elements of a list
    • Section 8.3: Set of Sets
    • Section 8.4: Set Operations using Methods and Builtins
    • Section 8.5: Sets versus multisets
  • Chapter 9: List comprehensions
    • Section 9.1: List Comprehensions
    • Section 9.2: Avoid repetitive and expensive operations using conditional clause
    • Section 9.3: Dictionary Comprehensions
    • Section 9.4: Generator Expressions
    • Section 9.5: Set Comprehensions
    • Section 9.6: Comprehensions involving tuples
    • Section 9.7: Counting Occurrences Using Comprehension
    • Section 9.8: Changing Types in a List
  • Chapter 10: Simple Mathematical Operators
    • Section 10.1: Division
    • Section 10.2: Addition
    • Section 10.3: Exponentation
    • Section 10.4: Trigonometric Functions
    • Section 10.5: Inplace Operations
    • Section 10.6: Subtraction
    • Section 10.7: Multiplication
    • Section 10.8: Logarithms
    • Section 10.9: Modulus
  • Chapter 11: Bitwise Operators
    • Section 11.1: Bitwise NOT
    • Section 11.2: Bitwise XOR (Exclusive OR)
    • Section 11.3: Bitwise AND
    • Section 11.4: Bitwise OR
    • Section 11.5: Bitwise Left Shift
    • Section 11.6: Bitwise Right Shift
    • Section 11.7: Inplace Operations
  • Chapter 12: Boolean Operators
    • Section 12.1: `and` and `or` are not guaranteed to return a boolean
    • Section 12.2: A simple example
    • Section 12.3: Short-circuit evaluation
    • Section 12.4: and
    • Section 12.5: or
    • Section 12.6: not
  • Chapter 13: Operator Precedence
    • Section 13.1: Simple Operator Precedence Examples in python
  • Chapter 14: Filter
    • Section 14.1: Basic use of filter
    • Section 14.2: Filter without function
    • Section 14.3: Filter as short-circuit check
    • Section 14.4: Complementary function: filterfalse, ifilterfalse
  • Chapter 15: Arrays
    • Section 15.1: Access individual elements through indexes
    • Section 15.2: Basic Introduction to Arrays
    • Section 15.3: Append any value to the array using append() method
    • Section 15.4: Insert value in an array using insert() method
    • Section 15.5: Extend python array using extend() method
    • Section 15.6: Add items from list into array using fromlist() method
    • Section 15.7: Remove any array element using remove() method
    • Section 15.8: Remove last array element using pop() method
    • Section 15.9: Fetch any element through its index using index() method
    • Section 15.10: Reverse a python array using reverse() method
    • Section 15.11: Get array buer information through buer_info() method
    • Section 15.12: Check for number of occurrences of an element using count() method
    • Section 15.13: Convert array to string using tostring() method
    • Section 15.14: Convert array to a python list with same elements using tolist() method
    • Section 15.15: Append a string to char array using fromstring() method
  • Chapter 16: Dictionary
    • Section 16.1: Introduction to Dictionary
    • Section 16.2: Avoiding KeyError Exceptions
    • Section 16.3: Iterating Over a Dictionary
    • Section 16.4: Dictionary with default values
    • Section 16.5: Merging dictionaries
    • Section 16.6: Accessing keys and values
    • Section 16.7: Accessing values of a dictionary
    • Section 16.8: Creating a dictionary
    • Section 16.9: Creating an ordered dictionary
    • Section 16.10: Unpacking dictionaries using the ** operator
    • Section 16.11: The trailing comma
    • Section 16.12: The dict() constructor
    • Section 16.13: Dictionaries Example
    • Section 16.14: All combinations of dictionary values
  • Chapter 17: List
    • Section 17.1: List methods and supported operators
    • Section 17.2: Accessing list values
    • Section 17.3: Checking if list is empty
    • Section 17.4: Iterating over a list
    • Section 17.5: Checking whether an item is in a list
    • Section 17.6: Any and All
    • Section 17.7: Reversing list elements
    • Section 17.8: Concatenate and Merge lists
    • Section 17.9: Length of a list
    • Section 17.10: Remove duplicate values in list
    • Section 17.11: Comparison of lists
    • Section 17.12: Accessing values in nested list
    • Section 17.13: Initializing a List to a Fixed Number of Elements
  • Chapter 18: List slicing (selecting parts of lists)
    • Section 18.1: Using the third "step" argument
    • Section 18.2: Selecting a sublist from a list
    • Section 18.3: Reversing a list with slicing
    • Section 18.4: Shifting a list using slicing
  • Chapter 19: Linked lists
    • Section 19.1: Single linked list example
  • Chapter 20: Linked List Node
    • Section 20.1: Write a simple Linked List Node in python
  • Chapter 21: Tuple
    • Section 21.1: Tuple
    • Section 21.2: Tuples are immutable
    • Section 21.3: Packing and Unpacking Tuples
    • Section 21.4: Built-in Tuple Functions
    • Section 21.5: Tuple Are Element-wise Hashable and Equatable
    • Section 21.6: Indexing Tuples
    • Section 21.7: Reversing Elements
  • Chapter 22: Functions
    • Section 22.1: Defining and calling simple functions
    • Section 22.2: Defining a function with an arbitrary number of arguments
    • Section 22.3: Lambda (Inline/Anonymous) Functions
    • Section 22.4: Defining a function with optional arguments
    • Section 22.5: Defining a function with optional mutable arguments
    • Section 22.6: Argument passing and mutability
    • Section 22.7: Returning values from functions
    • Section 22.8: Closure
    • Section 22.9: Forcing the use of named parameters
    • Section 22.10: Nested functions
    • Section 22.11: Recursion limit
    • Section 22.12: Recursive Lambda using assigned variable
    • Section 22.13: Recursive functions
    • Section 22.14: Defining a function with arguments
    • Section 22.15: Iterable and dictionary unpacking
    • Section 22.16: Defining a function with multiple arguments
  • Chapter 23: Defining functions with list arguments
    • Section 23.1: Function and Call
  • Chapter 24: Functional Programming in Python
    • Section 24.1: Lambda Function
    • Section 24.2: Map Function
    • Section 24.3: Reduce Function
    • Section 24.4: Filter Function
  • Chapter 25: Partial functions
    • Section 25.1: Raise the power
  • Chapter 26: Decorators
    • Section 26.1: Decorator function
    • Section 26.2: Decorator class
    • Section 26.3: Decorator with arguments (decorator factory)
    • Section 26.4: Making a decorator look like the decorated function
    • Section 26.5: Using a decorator to time a function
    • Section 26.6: Create singleton class with a decorator
  • Chapter 27: Classes
    • Section 27.1: Introduction to classes
    • Section 27.2: Bound, unbound, and static methods
    • Section 27.3: Basic inheritance
    • Section 27.4: Monkey Patching
    • Section 27.5: New-style vs. old-style classes
    • Section 27.6: Class methods: alternate initializers
    • Section 27.7: Multiple Inheritance
    • Section 27.8: Properties
    • Section 27.9: Default values for instance variables
    • Section 27.10: Class and instance variables
    • Section 27.11: Class composition
    • Section 27.12: Listing All Class Members
    • Section 27.13: Singleton class
    • Section 27.14: Descriptors and Dotted Lookups
  • Chapter 28: Metaclasses
    • Section 28.1: Basic Metaclasses
    • Section 28.2: Singletons using metaclasses
    • Section 28.3: Using a metaclass
    • Section 28.4: Introduction to Metaclasses
    • Section 28.5: Custom functionality with metaclasses
    • Section 28.6: The default metaclass
  • Chapter 29: String Methods
    • Section 29.1: Changing the capitalization of a string
    • Section 29.2: str.translate: Translating characters in a string
    • Section 29.3: str.format and f-strings: Format values into a string
    • Section 29.4: String module's useful constants
    • Section 29.5: Stripping unwanted leading/trailing characters from a string
    • Section 29.6: Reversing a string
    • Section 29.7: Split a string based on a delimiter into a list of strings
    • Section 29.8: Replace all occurrences of one substring with another substring
    • Section 29.9: Testing what a string is composed of
    • Section 29.10: String Contains
    • Section 29.11: Join a list of strings into one string
    • Section 29.12: Counting number of times a substring appears in a string
    • Section 29.13: Case insensitive string comparisons
    • Section 29.14: Justify strings
    • Section 29.15: Test the starting and ending characters of a string
    • Section 29.16: Conversion between str or bytes data and unicode characters
  • Chapter 30: String Formatting
    • Section 30.1: Basics of String Formatting
    • Section 30.2: Alignment and padding
    • Section 30.3: Format literals (f-string)
    • Section 30.4: Float formatting
    • Section 30.5: Named placeholders
    • Section 30.6: String formatting with datetime
    • Section 30.7: Formatting Numerical Values
    • Section 30.8: Nested formatting
    • Section 30.9: Format using Getitem and Getattr
    • Section 30.10: Padding and truncating strings, combined
    • Section 30.11: Custom formatting for a class
  • Chapter 31: Conditionals
    • Section 31.1: Conditional Expression (or "The Ternary Operator")
    • Section 31.2: if, elif, and else
    • Section 31.3: Truth Values
    • Section 31.4: Boolean Logic Expressions
    • Section 31.5: Using the cmp function to get the comparison result of two objects
    • Section 31.6: Else statement
    • Section 31.7: Testing if an object is None and assigning it
    • Section 31.8: If statement
  • Chapter 32: Loops
    • Section 32.1: Break and Continue in Loops
    • Section 32.2: For loops
    • Section 32.3: Iterating over lists
    • Section 32.4: Loops with an "else" clause
    • Section 32.5: The Pass Statement
    • Section 32.6: Iterating over dictionaries
    • Section 32.7: The "half loop" do-while
    • Section 32.8: Looping and Unpacking
    • Section 32.9: Iterating dierent portion of a list with dierent step size
    • Section 32.10: While Loop
  • Chapter 33: Using loops within functions
    • Section 33.1: Return statement inside loop in a function
  • Chapter 34: Importing modules
    • Section 34.1: Importing a module
    • Section 34.2: The __all__ special variable
    • Section 34.3: Import modules from an arbitrary filesystem location
    • Section 34.4: Importing all names from a module
    • Section 34.5: Programmatic importing
    • Section 34.6: PEP8 rules for Imports
    • Section 34.7: Importing specific names from a module
    • Section 34.8: Importing submodules
    • Section 34.9: Re-importing a module
    • Section 34.10: __import__() function
  • Chapter 35: Dierence between Module and Package
    • Section 35.1: Modules
    • Section 35.2: Packages
  • Chapter 36: Math Module
    • Section 36.1: Rounding: round, floor, ceil, trunc
    • Section 36.2: Trigonometry
    • Section 36.3: Pow for faster exponentiation
    • Section 36.4: Infinity and NaN ("not a number")
    • Section 36.5: Logarithms
    • Section 36.6: Constants
    • Section 36.7: Imaginary Numbers
    • Section 36.8: Copying signs
    • Section 36.9: Complex numbers and the cmath module
  • Chapter 37: Complex math
    • Section 37.1: Advanced complex arithmetic
    • Section 37.2: Basic complex arithmetic
  • Chapter 38: Collections module
    • Section 38.1: collections.Counter
    • Section 38.2: collections.OrderedDict
    • Section 38.3: collections.defaultdict
    • Section 38.4: collections.namedtuple
    • Section 38.5: collections.deque
    • Section 38.6: collections.ChainMap
  • Chapter 39: Operator module
    • Section 39.1: Itemgetter
    • Section 39.2: Operators as alternative to an infix operator
    • Section 39.3: Methodcaller
  • Chapter 40: JSON Module
    • Section 40.1: Storing data in a file
    • Section 40.2: Retrieving data from a file
    • Section 40.3: Formatting JSON output
    • Section 40.4: `load` vs `loads`, `dump` vs `dumps`
    • Section 40.5: Calling `json.tool` from the command line to pretty-print JSON output
    • Section 40.6: JSON encoding custom objects
    • Section 40.7: Creating JSON from Python dict
    • Section 40.8: Creating Python dict from JSON
  • Chapter 41: Sqlite3 Module
    • Section 41.1: Sqlite3 - Not require separate server process
    • Section 41.2: Getting the values from the database and Error handling
  • Chapter 42: The os Module
    • Section 42.1: makedirs - recursive directory creation
    • Section 42.2: Create a directory
    • Section 42.3: Get current directory
    • Section 42.4: Determine the name of the operating system
    • Section 42.5: Remove a directory
    • Section 42.6: Follow a symlink (POSIX)
    • Section 42.7: Change permissions on a file
  • Chapter 43: The locale Module
    • Section 43.1: Currency Formatting US Dollars Using the locale Module
  • Chapter 44: Itertools Module
    • Section 44.1: Combinations method in Itertools Module
    • Section 44.2: itertools.dropwhile
    • Section 44.3: Zipping two iterators until they are both exhausted
    • Section 44.4: Take a slice of a generator
    • Section 44.5: Grouping items from an iterable object using a function
    • Section 44.6: itertools.takewhile
    • Section 44.7: itertools.permutations
    • Section 44.8: itertools.repeat
    • Section 44.9: Get an accumulated sum of numbers in an iterable
    • Section 44.10: Cycle through elements in an iterator
    • Section 44.11: itertools.product
    • Section 44.12: itertools.count
    • Section 44.13: Chaining multiple iterators together
  • Chapter 45: Asyncio Module
    • Section 45.1: Coroutine and Delegation Syntax
    • Section 45.2: Asynchronous Executors
    • Section 45.3: Using UVLoop
    • Section 45.4: Synchronization Primitive: Event
    • Section 45.5: A Simple Websocket
    • Section 45.6: Common Misconception about asyncio
  • Chapter 46: Random module
    • Section 46.1: Creating a random user password
    • Section 46.2: Create cryptographically secure random numbers
    • Section 46.3: Random and sequences: shue, choice and sample
    • Section 46.4: Creating random integers and floats: randint, randrange, random, and uniform
    • Section 46.5: Reproducible random numbers: Seed and State
    • Section 46.6: Random Binary Decision
  • Chapter 47: Functools Module
    • Section 47.1: partial
    • Section 47.2: cmp_to_key
    • Section 47.3: lru_cache
    • Section 47.4: total_ordering
    • Section 47.5: reduce
  • Chapter 48: The dis module
    • Section 48.1: What is Python bytecode?
    • Section 48.2: Constants in the dis module
    • Section 48.3: Disassembling modules
  • Chapter 49: The base64 Module
    • Section 49.1: Encoding and Decoding Base64
    • Section 49.2: Encoding and Decoding Base32
    • Section 49.3: Encoding and Decoding Base16
    • Section 49.4: Encoding and Decoding ASCII85
    • Section 49.5: Encoding and Decoding Base85
  • Chapter 50: Queue Module
    • Section 50.1: Simple example
  • Chapter 51: Deque Module
    • Section 51.1: Basic deque using
    • Section 51.2: Available methods in deque
    • Section 51.3: limit deque size
    • Section 51.4: Breadth First Search
  • Chapter 52: Usage of "pip" module: PyPI Package Manager
    • Section 52.1: Example use of commands
    • Section 52.2: Handling ImportError Exception
    • Section 52.3: Force install
  • Chapter 53: Webbrowser Module
    • Section 53.1: Opening a URL with Default Browser
    • Section 53.2: Opening a URL with Dierent Browsers
  • Chapter 54: pyautogui module
    • Section 54.1: Mouse Functions
    • Section 54.2: Keyboard Functions
    • Section 54.3: ScreenShot And Image Recognition
  • Chapter 55: Plotting with Matplotlib
    • Section 55.1: Plots with Common X-axis but dierent Y-axis : Using twinx()
    • Section 55.2: Plots with common Y-axis and dierent X-axis using twiny()
    • Section 55.3: A Simple Plot in Matplotlib
    • Section 55.4: Adding more features to a simple plot : axis labels, title, axis ticks, grid, and legend
    • Section 55.5: Making multiple plots in the same figure by superimposition similar to MATLAB
    • Section 55.6: Making multiple Plots in the same figure using plot superimposition with separate plot commands
  • Chapter 56: Comparisons
    • Section 56.1: Chain Comparisons
    • Section 56.2: Comparison by `is` vs `==`
    • Section 56.3: Greater than or less than
    • Section 56.4: Not equal to
    • Section 56.5: Equal To
    • Section 56.6: Comparing Objects
  • Chapter 57: Sorting, Minimum and Maximum
    • Section 57.1: Make custom classes orderable
    • Section 57.2: Special case: dictionaries
    • Section 57.3: Using the key argument
    • Section 57.4: Default Argument to max, min
    • Section 57.5: Getting a sorted sequence
    • Section 57.6: Extracting N largest or N smallest items from an iterable
    • Section 57.7: Getting the minimum or maximum of several values
    • Section 57.8: Minimum and Maximum of a sequence
  • Chapter 58: Variable Scope and Binding
    • Section 58.1: Nonlocal Variables
    • Section 58.2: Global Variables
    • Section 58.3: Local Variables
    • Section 58.4: The del command
    • Section 58.5: Functions skip class scope when looking up names
    • Section 58.6: Local vs Global Scope
    • Section 58.7: Binding Occurrence
  • Chapter 59: Basic Input and Output
    • Section 59.1: Using the print function
    • Section 59.2: Input from a File
    • Section 59.3: Read from stdin
    • Section 59.4: Using input() and raw_input()
    • Section 59.5: Function to prompt user for a number
    • Section 59.6: Printing a string without a newline at the end
  • Chapter 60: Files & Folders I/O
    • Section 60.1: File modes
    • Section 60.2: Reading a file line-by-line
    • Section 60.3: Iterate files (recursively)
    • Section 60.4: Getting the full contents of a file
    • Section 60.5: Writing to a file
    • Section 60.6: Check whether a file or path exists
    • Section 60.7: Random File Access Using mmap
    • Section 60.8: Replacing text in a file
    • Section 60.9: Checking if a file is empty
    • Section 60.10: Read a file between a range of lines
    • Section 60.11: Copy a directory tree
    • Section 60.12: Copying contents of one file to a dierent file
  • Chapter 61: Indexing and Slicing
    • Section 61.1: Basic Slicing
    • Section 61.2: Reversing an object
    • Section 61.3: Slice assignment
    • Section 61.4: Making a shallow copy of an array
    • Section 61.5: Indexing custom classes: __getitem__, __setitem__ and __delitem__
    • Section 61.6: Basic Indexing
  • Chapter 62: Generators
    • Section 62.1: Introduction
    • Section 62.2: Infinite sequences
    • Section 62.3: Sending objects to a generator
    • Section 62.4: Yielding all values from another iterable
    • Section 62.5: Iteration
    • Section 62.6: The next() function
    • Section 62.7: Coroutines
    • Section 62.8: Refactoring list-building code
    • Section 62.9: Yield with recursion: recursively listing all files in a directory
    • Section 62.10: Generator expressions
    • Section 62.11: Using a generator to find Fibonacci Numbers
    • Section 62.12: Searching
    • Section 62.13: Iterating over generators in parallel
  • Chapter 63: Reduce
    • Section 63.1: Overview
    • Section 63.2: Using reduce
    • Section 63.3: Cumulative product
    • Section 63.4: Non short-circuit variant of any/all
  • Chapter 64: Map Function
    • Section 64.1: Basic use of map, itertools.imap and future_builtins.map
    • Section 64.2: Mapping each value in an iterable
    • Section 64.3: Mapping values of dierent iterables
    • Section 64.4: Transposing with Map: Using "None" as function argument (python 2.x only)
    • Section 64.5: Series and Parallel Mapping
  • Chapter 65: Exponentiation
    • Section 65.1: Exponentiation using builtins: ** and pow()
    • Section 65.2: Square root: math.sqrt() and cmath.sqrt
    • Section 65.3: Modular exponentiation: pow() with 3 arguments
    • Section 65.4: Computing large integer roots
    • Section 65.5: Exponentiation using the math module: math.pow()
    • Section 65.6: Exponential function: math.exp() and cmath.exp()
    • Section 65.7: Exponential function minus 1: math.expm1()
    • Section 65.8: Magic methods and exponentiation: builtin, math and cmath
    • Section 65.9: Roots: nth-root with fractional exponents
  • Chapter 66: Searching
    • Section 66.1: Searching for an element
    • Section 66.2: Searching in custom classes: __contains__ and __iter__
    • Section 66.3: Getting the index for strings: str.index(), str.rindex() and str.find(), str.rfind()
    • Section 66.4: Getting the index list and tuples: list.index(), tuple.index()
    • Section 66.5: Searching key(s) for a value in dict
    • Section 66.6: Getting the index for sorted sequences: bisect.bisect_left()
    • Section 66.7: Searching nested sequences
  • Chapter 67: Counting
    • Section 67.1: Counting all occurence of all items in an iterable: collections.Counter
    • Section 67.2: Getting the most common value(-s): collections.Counter.most_common()
    • Section 67.3: Counting the occurrences of one item in a sequence: list.count() and tuple.count()
    • Section 67.4: Counting the occurrences of a substring in a string: str.count()
    • Section 67.5: Counting occurences in numpy array
  • Chapter 68: Manipulating XML
    • Section 68.1: Opening and reading using an ElementTree
    • Section 68.2: Create and Build XML Documents
    • Section 68.3: Modifying an XML File
    • Section 68.4: Searching the XML with XPath
    • Section 68.5: Opening and reading large XML files using iterparse (incremental parsing)
  • Chapter 69: Parallel computation
    • Section 69.1: Using the multiprocessing module to parallelise tasks
    • Section 69.2: Using a C-extension to parallelize tasks
    • Section 69.3: Using Parent and Children scripts to execute code in parallel
    • Section 69.4: Using PyPar module to parallelize
  • Chapter 70: Processes and Threads
    • Section 70.1: Global Interpreter Lock
    • Section 70.2: Running in Multiple Threads
    • Section 70.3: Running in Multiple Processes
    • Section 70.4: Sharing State Between Threads
    • Section 70.5: Sharing State Between Processes
  • Chapter 71: Multithreading
    • Section 71.1: Basics of multithreading
    • Section 71.2: Communicating between threads
    • Section 71.3: Creating a worker pool
    • Section 71.4: Advanced use of multithreads
    • Section 71.5: Stoppable Thread with a while Loop
  • Chapter 72: Writing extensions
    • Section 72.1: Hello World with C Extension
    • Section 72.2: C Extension Using c++ and Boost
    • Section 72.3: Passing an open file to C Extensions
  • Chapter 73: Unit Testing
    • Section 73.1: Test Setup and Teardown within a unittest.TestCase
    • Section 73.2: Asserting on Exceptions
    • Section 73.3: Testing Exceptions
    • Section 73.4: Choosing Assertions Within Unittests
    • Section 73.5: Unit tests with pytest
    • Section 73.6: Mocking functions with unittest.mock.create_autospec
  • Chapter 74: Regular Expressions (Regex)
    • Section 74.1: Matching the beginning of a string
    • Section 74.2: Searching
    • Section 74.3: Precompiled patterns
    • Section 74.4: Flags
    • Section 74.5: Replacing
    • Section 74.6: Find All Non-Overlapping Matches
    • Section 74.7: Checking for allowed characters
    • Section 74.8: Splitting a string using regular expressions
    • Section 74.9: Grouping
    • Section 74.10: Escaping Special Characters
    • Section 74.11: Match an expression only in specific locations
    • Section 74.12: Iterating over matches using `re.finditer`
  • Chapter 75: Incompatibilities moving from Python 2 to Python 3
    • Section 75.1: Integer Division
    • Section 75.2: Unpacking Iterables
    • Section 75.3: Strings: Bytes versus Unicode
    • Section 75.4: Print statement vs. Print function
    • Section 75.5: Dierences between range and xrange functions
    • Section 75.6: Raising and handling Exceptions
    • Section 75.7: Leaked variables in list comprehension
    • Section 75.8: True, False and None
    • Section 75.9: User Input
    • Section 75.10: Comparison of dierent types
    • Section 75.11: .next() method on iterators renamed
    • Section 75.12: filter(), map() and zip() return iterators instead of sequences
    • Section 75.13: Renamed modules
    • Section 75.14: Removed operators <> and ``, synonymous with != and repr()
    • Section 75.15: long vs. int
    • Section 75.16: All classes are "new-style classes" in Python 3
    • Section 75.17: Reduce is no longer a built-in
    • Section 75.18: Absolute/Relative Imports
    • Section 75.19: map()
    • Section 75.20: The round() function tie-breaking and return type
    • Section 75.21: File I/O
    • Section 75.22: cmp function removed in Python 3
    • Section 75.23: Octal Constants
    • Section 75.24: Return value when writing to a file object
    • Section 75.25: exec statement is a function in Python 3
    • Section 75.26: encode/decode to hex no longer available
    • Section 75.27: Dictionary method changes
    • Section 75.28: Class Boolean Value
    • Section 75.29: hasattr function bug in Python 2
  • Chapter 76: Virtual environments
    • Section 76.1: Creating and using a virtual environment
    • Section 76.2: Specifying specific python version to use in script on Unix/Linux
    • Section 76.3: Creating a virtual environment for a dierent version of python
    • Section 76.4: Making virtual environments using Anaconda
    • Section 76.5: Managing multiple virtual enviroments with virtualenvwrapper
    • Section 76.6: Installing packages in a virtual environment
    • Section 76.7: Discovering which virtual environment you are using
    • Section 76.8: Checking if running inside a virtual environment
    • Section 76.9: Using virtualenv with fish shell
  • Chapter 77: Copying data
    • Section 77.1: Copy a dictionary
    • Section 77.2: Performing a shallow copy
    • Section 77.3: Performing a deep copy
    • Section 77.4: Performing a shallow copy of a list
    • Section 77.5: Copy a set
  • Chapter 78: Context Managers (“with” Statement)
    • Section 78.1: Introduction to context managers and the with statement
    • Section 78.2: Writing your own context manager
    • Section 78.3: Writing your own contextmanager using generator syntax
    • Section 78.4: Multiple context managers
    • Section 78.5: Assigning to a target
    • Section 78.6: Manage Resources
  • Chapter 79: Hidden Features
    • Section 79.1: Operator Overloading
  • Chapter 80: Unicode and bytes
    • Section 80.1: Encoding/decoding error handling
    • Section 80.2: File I/O
    • Section 80.3: Basics
  • Chapter 81: The __name__ special variable
    • Section 81.1: __name__ == '__main__'
    • Section 81.2: Use in logging
    • Section 81.3: function_class_or_module.__name__
  • Chapter 82: Checking Path Existence and Permissions
    • Section 82.1: Perform checks using os.access
  • Chapter 83: Python Networking
    • Section 83.1: Creating a Simple Http Server
    • Section 83.2: Creating a TCP server
    • Section 83.3: Creating a UDP Server
    • Section 83.4: Start Simple HttpServer in a thread and open the browser
    • Section 83.5: The simplest Python socket client-server example
  • Chapter 84: The Print Function
    • Section 84.1: Print basics
    • Section 84.2: Print parameters
  • Chapter 85: os.path
    • Section 85.1: Join Paths
    • Section 85.2: Path Component Manipulation
    • Section 85.3: Get the parent directory
    • Section 85.4: If the given path exists
    • Section 85.5: check if the given path is a directory, file, symbolic link, mount point etc
    • Section 85.6: Absolute Path from Relative Path
  • Chapter 86: Creating Python packages
    • Section 86.1: Introduction
    • Section 86.2: Uploading to PyPI
    • Section 86.3: Making package executable
  • Chapter 87: Parsing Command Line arguments
    • Section 87.1: Hello world in argparse
    • Section 87.2: Using command line arguments with argv
    • Section 87.3: Setting mutually exclusive arguments with argparse
    • Section 87.4: Basic example with docopt
    • Section 87.5: Custom parser error message with argparse
    • Section 87.6: Conceptual grouping of arguments with argparse.add_argument_group()
    • Section 87.7: Advanced example with docopt and docopt_dispatch
  • Chapter 88: HTML Parsing
    • Section 88.1: Using CSS selectors in BeautifulSoup
    • Section 88.2: PyQuery
    • Section 88.3: Locate a text after an element in BeautifulSoup
  • Chapter 89: Subprocess Library
    • Section 89.1: More flexibility with Popen
    • Section 89.2: Calling External Commands
    • Section 89.3: How to create the command list argument
  • Chapter 90: setup.py
    • Section 90.1: Purpose of setup.py
    • Section 90.2: Using source control metadata in setup.py
    • Section 90.3: Adding command line scripts to your python package
    • Section 90.4: Adding installation options
  • Chapter 91: Sockets
    • Section 91.1: Raw Sockets on Linux
    • Section 91.2: Sending data via UDP
    • Section 91.3: Receiving data via UDP
    • Section 91.4: Sending data via TCP
    • Section 91.5: Multi-threaded TCP Socket Server
  • Chapter 92: Recursion
    • Section 92.1: The What, How, and When of Recursion
    • Section 92.2: Tree exploration with recursion
    • Section 92.3: Sum of numbers from 1 to n
    • Section 92.4: Increasing the Maximum Recursion Depth
    • Section 92.5: Tail Recursion - Bad Practice
    • Section 92.6: Tail Recursion Optimization Through Stack Introspection
  • Chapter 93: Type Hints
    • Section 93.1: Adding types to a function
    • Section 93.2: NamedTuple
    • Section 93.3: Generic Types
    • Section 93.4: Variables and Attributes
    • Section 93.5: Class Members and Methods
    • Section 93.6: Type hints for keyword arguments
  • Chapter 94: pip: PyPI Package Manager
    • Section 94.1: Install Packages
    • Section 94.2: To list all packages installed using `pip`
    • Section 94.3: Upgrade Packages
    • Section 94.4: Uninstall Packages
    • Section 94.5: Updating all outdated packages on Linux
    • Section 94.6: Updating all outdated packages on Windows
    • Section 94.7: Create a requirements.txt file of all packages on the system
    • Section 94.8: Using a certain Python version with pip
    • Section 94.9: Create a requirements.txt file of packages only in the current virtualenv
    • Section 94.10: Installing packages not yet on pip as wheels
  • Chapter 95: Exceptions
    • Section 95.1: Catching Exceptions
    • Section 95.2: Do not catch everything!
    • Section 95.3: Re-raising exceptions
    • Section 95.4: Catching multiple exceptions
    • Section 95.5: Exception Hierarchy
    • Section 95.6: Else
    • Section 95.7: Raising Exceptions
    • Section 95.8: Creating custom exception types
    • Section 95.9: Practical examples of exception handling
    • Section 95.10: Exceptions are Objects too
    • Section 95.11: Running clean-up code with finally
    • Section 95.12: Chain exceptions with raise from
  • Chapter 96: Web scraping with Python
    • Section 96.1: Scraping using the Scrapy framework
    • Section 96.2: Scraping using Selenium WebDriver
    • Section 96.3: Basic example of using requests and lxml to scrape some data
    • Section 96.4: Maintaining web-scraping session with requests
    • Section 96.5: Scraping using BeautifulSoup4
    • Section 96.6: Simple web content download with urllib.request
    • Section 96.7: Modify Scrapy user agent
    • Section 96.8: Scraping with curl
  • Chapter 97: Distribution
    • Section 97.1: py2app
    • Section 97.2: cx_Freeze
  • Chapter 98: Property Objects
    • Section 98.1: Using the @property decorator for read-write properties
    • Section 98.2: Using the @property decorator
    • Section 98.3: Overriding just a getter, setter or a deleter of a property object
    • Section 98.4: Using properties without decorators
  • Chapter 99: Overloading
    • Section 99.1: Operator overloading
    • Section 99.2: Magic/Dunder Methods
    • Section 99.3: Container and sequence types
    • Section 99.4: Callable types
    • Section 99.5: Handling unimplemented behaviour
  • Chapter 100: Debugging
    • Section 100.1: Via IPython and ipdb
    • Section 100.2: The Python Debugger: Step-through Debugging with _pdb_
    • Section 100.3: Remote debugger
  • Chapter 101: Reading and Writing CSV
    • Section 101.1: Using pandas
    • Section 101.2: Writing a TSV file
  • Chapter 102: Dynamic code execution with `exec` and `eval`
    • Section 102.1: Executing code provided by untrusted user using exec, eval, or ast.literal_eval
    • Section 102.2: Evaluating a string containing a Python literal with ast.literal_eval
    • Section 102.3: Evaluating statements with exec
    • Section 102.4: Evaluating an expression with eval
    • Section 102.5: Precompiling an expression to evaluate it multiple times
    • Section 102.6: Evaluating an expression with eval using custom globals
  • Chapter 103: PyInstaller - Distributing Python Code
    • Section 103.1: Installation and Setup
    • Section 103.2: Using Pyinstaller
    • Section 103.3: Bundling to One Folder
    • Section 103.4: Bundling to a Single File
  • Chapter 104: Iterables and Iterators
    • Section 104.1: Iterator vs Iterable vs Generator
    • Section 104.2: Extract values one by one
    • Section 104.3: Iterating over entire iterable
    • Section 104.4: Verify only one element in iterable
    • Section 104.5: What can be iterable
    • Section 104.6: Iterator isn't reentrant!
  • Chapter 105: Data Visualization with Python
    • Section 105.1: Seaborn
    • Section 105.2: Matplotlib
    • Section 105.3: Plotly
    • Section 105.4: MayaVI
  • Chapter 106: The Interpreter (Command Line Console)
    • Section 106.1: Getting general help
    • Section 106.2: Referring to the last expression
    • Section 106.3: Opening the Python console
    • Section 106.4: The PYTHONSTARTUP variable
    • Section 106.5: Command line arguments
    • Section 106.6: Getting help about an object
  • Chapter 107: *args and **kwargs
    • Section 107.1: Using **kwargs when writing functions
    • Section 107.2: Using *args when writing functions
    • Section 107.3: Populating kwarg values with a dictionary
    • Section 107.4: Keyword-only and Keyword-required arguments
    • Section 107.5: Using **kwargs when calling functions
    • Section 107.6: **kwargs and default values
    • Section 107.7: Using *args when calling functions
  • Chapter 108: Garbage Collection
    • Section 108.1: Reuse of primitive objects
    • Section 108.2: Eects of the del command
    • Section 108.3: Reference Counting
    • Section 108.4: Garbage Collector for Reference Cycles
    • Section 108.5: Forcefully deallocating objects
    • Section 108.6: Viewing the refcount of an object
    • Section 108.7: Do not wait for the garbage collection to clean up
    • Section 108.8: Managing garbage collection
  • Chapter 109: Pickle data serialisation
    • Section 109.1: Using Pickle to serialize and deserialize an object
    • Section 109.2: Customize Pickled Data
  • Chapter 110: urllib
    • Section 110.1: HTTP GET
    • Section 110.2: HTTP POST
    • Section 110.3: Decode received bytes according to content type encoding
  • Chapter 111: Binary Data
    • Section 111.1: Format a list of values into a byte object
    • Section 111.2: Unpack a byte object according to a format string
    • Section 111.3: Packing a structure
  • Chapter 112: Python and Excel
    • Section 112.1: Read the excel data using xlrd module
    • Section 112.2: Format Excel files with xlsxwriter
    • Section 112.3: Put list data into a Excel's file
    • Section 112.4: OpenPyXL
    • Section 112.5: Create excel charts with xlsxwriter
  • Chapter 113: Idioms
    • Section 113.1: Dictionary key initializations
    • Section 113.2: Switching variables
    • Section 113.3: Use truth value testing
    • Section 113.4: Test for "__main__" to avoid unexpected code execution
  • Chapter 114: Method Overriding
    • Section 114.1: Basic method overriding
  • Chapter 115: Data Serialization
    • Section 115.1: Serialization using JSON
    • Section 115.2: Serialization using Pickle
  • Chapter 116: Python concurrency
    • Section 116.1: The multiprocessing module
    • Section 116.2: The threading module
    • Section 116.3: Passing data between multiprocessing processes
  • Chapter 117: Introduction to RabbitMQ using AMQPStorm
    • Section 117.1: How to consume messages from RabbitMQ
    • Section 117.2: How to publish messages to RabbitMQ
    • Section 117.3: How to create a delayed queue in RabbitMQ
  • Chapter 118: Descriptor
    • Section 118.1: Simple descriptor
    • Section 118.2: Two-way conversions
  • Chapter 119: Multiprocessing
    • Section 119.1: Running Two Simple Processes
    • Section 119.2: Using Pool and Map
  • Chapter 120: tempfile NamedTemporaryFile
    • Section 120.1: Create (and write to a) known, persistant temporary file
  • Chapter 121: Input, Subset and Output External Data Files using Pandas
    • Section 121.1: Basic Code to Import, Subset and Write External Data Files Using Pandas
  • Chapter 122: Writing to CSV from String or List
    • Section 122.1: Basic Write Example
    • Section 122.2: Appending a String as a newline in a CSV file
  • Chapter 123: Unzipping Files
    • Section 123.1: Using Python ZipFile.extractall() to decompress a ZIP file
    • Section 123.2: Using Python TarFile.extractall() to decompress a tarball
  • Chapter 124: Working with ZIP archives
    • Section 124.1: Examining Zipfile Contents
    • Section 124.2: Opening Zip Files
    • Section 124.3: Extracting zip file contents to a directory
    • Section 124.4: Creating new archives
  • Chapter 125: Stack
    • Section 125.1: Creating a Stack class with a List Object
    • Section 125.2: Parsing Parentheses
  • Chapter 126: Profiling
    • Section 126.1: %%timeit and %timeit in IPython
    • Section 126.2: Using cProfile (Preferred Profiler)
    • Section 126.3: timeit() function
    • Section 126.4: timeit command line
    • Section 126.5: line_profiler in command line
  • Chapter 127: User-Defined Methods
    • Section 127.1: Creating user-defined method objects
    • Section 127.2: Turtle example
  • Chapter 128: Working around the Global Interpreter Lock (GIL)
    • Section 128.1: Multiprocessing.Pool
    • Section 128.2: Cython nogil:
  • Chapter 129: Deployment
    • Section 129.1: Uploading a Conda Package
  • Chapter 130: Logging
    • Section 130.1: Introduction to Python Logging
    • Section 130.2: Logging exceptions
  • Chapter 131: Database Access
    • Section 131.1: SQLite
    • Section 131.2: Accessing MySQL database using MySQLdb
    • Section 131.3: Connection
    • Section 131.4: PostgreSQL Database access using psycopg2
    • Section 131.5: Oracle database
    • Section 131.6: Using sqlalchemy
  • Chapter 132: Python HTTP Server
    • Section 132.1: Running a simple HTTP server
    • Section 132.2: Serving files
    • Section 132.3: Basic handling of GET, POST, PUT using BaseHTTPRequestHandler
    • Section 132.4: Programmatic API of SimpleHTTPServer
  • Chapter 133: Web Server Gateway Interface (WSGI)
    • Section 133.1: Server Object (Method)
  • Chapter 134: Python Server Sent Events
    • Section 134.1: Flask SSE
    • Section 134.2: Asyncio SSE
  • Chapter 135: Connecting Python to SQL Server
    • Section 135.1: Connect to Server, Create Table, Query Data
  • Chapter 136: Sockets And Message Encryption/Decryption Between Client and Server
    • Section 136.1: Server side Implementation
    • Section 136.2: Client side Implementation
  • Chapter 137: Alternatives to switch statement from other languages
    • Section 137.1: Use what the language oers: the if/else construct
    • Section 137.2: Use a dict of functions
    • Section 137.3: Use class introspection
    • Section 137.4: Using a context manager
  • Chapter 138: List Comprehensions
    • Section 138.1: Conditional List Comprehensions
    • Section 138.2: List Comprehensions with Nested Loops
    • Section 138.3: Refactoring filter and map to list comprehensions
    • Section 138.4: Nested List Comprehensions
    • Section 138.5: Iterate two or more list simultaneously within list comprehension
  • Chapter 139: List destructuring (aka packing and unpacking)
    • Section 139.1: Destructuring assignment
    • Section 139.2: Packing function arguments
    • Section 139.3: Unpacking function arguments
  • Chapter 140: Accessing Python source code and bytecode
    • Section 140.1: Display the bytecode of a function
    • Section 140.2: Display the source code of an object
    • Section 140.3: Exploring the code object of a function
  • Chapter 141: Mixins
    • Section 141.1: Mixin
    • Section 141.2: Overriding Methods in Mixins
  • Chapter 142: Attribute Access
    • Section 142.1: Basic Attribute Access using the Dot Notation
    • Section 142.2: Setters, Getters & Properties
  • Chapter 143: ArcPy
    • Section 143.1: Printing one field's value for all rows of feature class in file geodatabase using Search Cursor
    • Section 143.2: createDissolvedGDB to create a file gdb on the workspace
  • Chapter 144: Abstract Base Classes (abc)
    • Section 144.1: Setting the ABCMeta metaclass
    • Section 144.2: Why/How to use ABCMeta and @abstractmethod
  • Chapter 145: Plugin and Extension Classes
    • Section 145.1: Mixins
    • Section 145.2: Plugins with Customized Classes
  • Chapter 146: Websockets
    • Section 146.1: Simple Echo with aiohttp
    • Section 146.2: Wrapper Class with aiohttp
    • Section 146.3: Using Autobahn as a Websocket Factory
  • Chapter 147: Immutable datatypes(int, float, str, tuple and frozensets)
    • Section 147.1: Individual characters of strings are not assignable
    • Section 147.2: Tuple's individual members aren't assignable
    • Section 147.3: Frozenset's are immutable and not assignable
  • Chapter 148: String representations of class instances: __str__ and __repr__ methods
    • Section 148.1: Motivation
    • Section 148.2: Both methods implemented, eval-round-trip style __repr__()
  • Chapter 149: Polymorphism
    • Section 149.1: Duck Typing
    • Section 149.2: Basic Polymorphism
  • Chapter 150: Non-ocial Python implementations
    • Section 150.1: IronPython
    • Section 150.2: Jython
    • Section 150.3: Transcrypt
  • Chapter 151: 2to3 tool
    • Section 151.1: Basic Usage
  • Chapter 152: Abstract syntax tree
    • Section 152.1: Analyze functions in a python script
  • Chapter 153: Unicode
    • Section 153.1: Encoding and decoding
  • Chapter 154: Python Serial Communication (pyserial)
    • Section 154.1: Initialize serial device
    • Section 154.2: Read from serial port
    • Section 154.3: Check what serial ports are available on your machine
  • Chapter 155: Neo4j and Cypher using Py2Neo
    • Section 155.1: Adding Nodes to Neo4j Graph
    • Section 155.2: Importing and Authenticating
    • Section 155.3: Adding Relationships to Neo4j Graph
    • Section 155.4: Query 1 : Autocomplete on News Titles
    • Section 155.5: Query 2 : Get News Articles by Location on a particular date
    • Section 155.6: Cypher Query Samples
  • Chapter 156: Basic Curses with Python
    • Section 156.1: The wrapper() helper function
    • Section 156.2: Basic Invocation Example
  • Chapter 157: Performance optimization
    • Section 157.1: Code profiling
  • Chapter 158: Templates in python
    • Section 158.1: Simple data output program using template
    • Section 158.2: Changing delimiter
  • Chapter 159: Pillow
    • Section 159.1: Read Image File
    • Section 159.2: Convert files to JPEG
  • Chapter 160: The pass statement
    • Section 160.1: Ignore an exception
    • Section 160.2: Create a new Exception that can be caught
  • Chapter 161: py.test
    • Section 161.1: Setting up py.test
    • Section 161.2: Intro to Test Fixtures
    • Section 161.3: Failing Tests
  • Chapter 162: Heapq
    • Section 162.1: Largest and smallest items in a collection
    • Section 162.2: Smallest item in a collection
  • Chapter 163: tkinter
    • Section 163.1: Geometry Managers
    • Section 163.2: A minimal tkinter Application
  • Chapter 164: CLI subcommands with precise help output
    • Section 164.1: Native way (no libraries)
    • Section 164.2: argparse (default help formatter)
    • Section 164.3: argparse (custom help formatter)
  • Chapter 165: PostgreSQL
    • Section 165.1: Getting Started
  • Chapter 166: Python Persistence
    • Section 166.1: Python Persistence
    • Section 166.2: Function utility for save and load
  • Chapter 167: Turtle Graphics
    • Section 167.1: Ninja Twist (Turtle Graphics)
  • Chapter 168: Design Patterns
    • Section 168.1: Introduction to design patterns and Singleton Pattern
    • Section 168.2: Strategy Pattern
    • Section 168.3: Proxy
  • Chapter 169: Multidimensional arrays
    • Section 169.1: Lists in lists
    • Section 169.2: Lists in lists in lists in..
  • Chapter 170: Audio
    • Section 170.1: Working with WAV files
    • Section 170.2: Convert any soundfile with python and mpeg
    • Section 170.3: Playing Windows' beeps
    • Section 170.4: Audio With Pyglet
  • Chapter 171: Pyglet
    • Section 171.1: Installation of Pyglet
    • Section 171.2: Hello World in Pyglet
    • Section 171.3: Playing Sound in Pyglet
    • Section 171.4: Using Pyglet for OpenGL
    • Section 171.5: Drawing Points Using Pyglet and OpenGL
  • Chapter 172: Flask
    • Section 172.1: Files and Templates
    • Section 172.2: The basics
    • Section 172.3: Routing URLs
    • Section 172.4: HTTP Methods
    • Section 172.5: Jinja Templating
    • Section 172.6: The Request Object
  • Chapter 173: groupby()
    • Section 173.1: Example 4
    • Section 173.2: Example 2
    • Section 173.3: Example 3
  • Chapter 174: pygame
    • Section 174.1: Pygame's mixer module
    • Section 174.2: Installing pygame
  • Chapter 175: hashlib
    • Section 175.1: MD5 hash of a string
    • Section 175.2: algorithm provided by OpenSSL
  • Chapter 176: getting start with GZip
    • Section 176.1: Read and write GNU zip files
  • Chapter 177: ctypes
    • Section 177.1: ctypes arrays
    • Section 177.2: Wrapping functions for ctypes
    • Section 177.3: Basic usage
    • Section 177.4: Common pitfalls
    • Section 177.5: Basic ctypes object
    • Section 177.6: Complex usage
  • Chapter 178: Creating a Windows service using Python
    • Section 178.1: A Python script that can be run as a service
    • Section 178.2: Running a Flask web application as a service
  • Chapter 179: Mutable vs Immutable (and Hashable) in Python
    • Section 179.1: Mutable vs Immutable
    • Section 179.2: Mutable and Immutable as Arguments
  • Chapter 180: Python speed of program
    • Section 180.1: Deque operations
    • Section 180.2: Algorithmic Notations..
    • Section 180.3: Notation
    • Section 180.4: List operations
    • Section 180.5: Set operations
  • Chapter 181: configparser
    • Section 181.1: Creating configuration file programatically
    • Section 181.2: Basic usage
  • Chapter 182: Commonwealth Exceptions
    • Section 182.1: Other Errors
    • Section 182.2: NameError: name '???' is not defined
    • Section 182.3: TypeErrors
    • Section 182.4: Syntax Error on good code
    • Section 182.5: IndentationErrors (or indentation SyntaxErrors)
  • Chapter 183: Optical Character Recognition
    • Section 183.1: PyTesseract
    • Section 183.2: PyOCR
  • Chapter 184: graph-tool
    • Section 184.1: PyDotPlus
    • Section 184.2: PyGraphviz
  • Chapter 185: Python Virtual Environment - virtualenv
    • Section 185.1: Installation
    • Section 185.2: Usage
    • Section 185.3: Install a package in your Virtualenv
    • Section 185.4: Other useful virtualenv commands
  • Chapter 186: sys
    • Section 186.1: Command line arguments
    • Section 186.2: Script name
    • Section 186.3: Standard error stream
    • Section 186.4: Ending the process prematurely and returning an exit code
  • Chapter 187: virtual environment with virtualenvwrapper
    • Section 187.1: Create virtual environment with virtualenvwrapper
  • Chapter 188: Create virtual environment with virtualenvwrapper in windows
    • Section 188.1: Virtual environment with virtualenvwrapper for windows
  • Chapter 189: Python Requests Post
    • Section 189.1: Simple Post
    • Section 189.2: Form Encoded Data
    • Section 189.3: File Upload
    • Section 189.4: Responses
    • Section 189.5: Authentication
    • Section 189.6: Proxies
  • Chapter 190: Python Lex-Yacc
    • Section 190.1: Getting Started with PLY
    • Section 190.2: The "Hello, World!" of PLY - A Simple Calculator
    • Section 190.3: Part 1: Tokenizing Input with Lex
    • Section 190.4: Part 2: Parsing Tokenized Input with Yacc
  • Chapter 191: ChemPy - python package
    • Section 191.1: Parsing formulae
    • Section 191.2: Balancing stoichiometry of a chemical reaction
    • Section 191.3: Balancing reactions
    • Section 191.4: Chemical equilibria
    • Section 191.5: Ionic strength
    • Section 191.6: Chemical kinetics (system of ordinary dierential equations)
  • Chapter 192: pyaudio
    • Section 192.1: Callback Mode Audio I/O
    • Section 192.2: Blocking Mode Audio I/O
  • Chapter 193: shelve
    • Section 193.1: Creating a new Shelf
    • Section 193.2: Sample code for shelve
    • Section 193.3: To summarize the interface (key is a string, data is an arbitrary object):
    • Section 193.4: Write-back
  • Chapter 194: IoT Programming with Python and Raspberry PI
    • Section 194.1: Example - Temperature sensor
  • Chapter 195: kivy - Cross-platform Python Framework for NUI Development
    • Section 195.1: First App
  • Chapter 196: Call Python from C#
    • Section 196.1: Python script to be called by C# application
    • Section 196.2: C# code calling Python script
  • Chapter 197: Similarities in syntax, Dierences in meaning: Python vs. JavaScript
    • Section 197.1: `in` with lists
  • Chapter 198: Raise Custom Errors / Exceptions
    • Section 198.1: Custom Exception
    • Section 198.2: Catch custom Exception
  • Chapter 199: Pandas Transform: Preform operations on groups and concatenate the results
    • Section 199.1: Simple transform
    • Section 199.2: Multiple results per group
  • Chapter 200: Security and Cryptography
    • Section 200.1: Secure Password Hashing
    • Section 200.2: Calculating a Message Digest
    • Section 200.3: Available Hashing Algorithms
    • Section 200.4: File Hashing
    • Section 200.5: Generating RSA signatures using pycrypto
    • Section 200.6: Asymmetric RSA encryption using pycrypto
    • Section 200.7: Symmetric encryption using pycrypto
  • Chapter 201: Secure Shell Connection in Python
    • Section 201.1: ssh connection
  • Chapter 202: Python Anti-Patterns
    • Section 202.1: Overzealous except clause
    • Section 202.2: Looking before you leap with processor-intensive function
  • Chapter 203: Common Pitfalls
    • Section 203.1: List multiplication and common references
    • Section 203.2: Mutable default argument
    • Section 203.3: Changing the sequence you are iterating over
    • Section 203.4: Integer and String identity
    • Section 203.5: Dictionaries are unordered
    • Section 203.6: Variable leaking in list comprehensions and for loops
    • Section 203.7: Chaining of or operator
    • Section 203.8: sys.argv[0] is the name of the file being executed
    • Section 203.9: Accessing int literals' attributes
    • Section 203.10: Global Interpreter Lock (GIL) and blocking threads
    • Section 203.11: Multiple return
    • Section 203.12: Pythonic JSON keys
  • Credits
  • You may also like
    No review for this book yet, be the first to review.
      No comment for this book yet, be the first to comment
      You May Also Like
      Also Available On
      App store smallGoogle play small
      Categories
      Curated Lists
      • Pattern Recognition and Machine Learning (Information Science and Statistics)
        by Christopher M. Bishop
        Data mining
        by I. H. Witten
        The Elements of Statistical Learning: Data Mining, Inference, and Prediction
        by Various
        See more...
      • CK-12 Chemistry
        by Various
        Concept Development Studies in Chemistry
        by John Hutchinson
        An Introduction to Chemistry - Atoms First
        by Mark Bishop
        See more...
      • Microsoft Word - How to Use Advanced Algebra II.doc
        by Jonathan Emmons
        Advanced Algebra II: Activities and Homework
        by Kenny Felder
        de2de
        by
        See more...
      • The Sun Who Lost His Way
        by
        Tania is a Detective
        by Kanika G
        Firenze_s-Light
        by
        See more...
      • Java 3D Programming
        by Daniel Selman
        The Java EE 6 Tutorial
        by Oracle Corporation
        JavaKid811
        by
        See more...