Python essentials: modernize existing Python code and plan code migrations to Python using this definitive guide

Cover
Copyright
Credits
About the Author
About the Reviewers
www.PacktPub.com
Table of Contents
Preface
Chapter 1: Getting Started
	Installation or upgrade
		Installing Python on Windows
			Considering some alternatives
		Upgrading to Python 3.4 in Mac OS X
			Adding the Tkinter package
		Upgrading to Python 3.4 in Linux
	Using the Read-Evaluate-Print Loop (REPL)
		Confirming that things are working
		Doing simple arithmetic
		Assigning results to variables
		Using import to add features
	Interacting with the help subsystem
		Using the pydoc program
	Creating simple script files
		Simplified syntax rules
	The Python ecosystem
		The idea of extensibility via add-ons
		Using the Python Package Index – PyPI
			Using pip to gather modules
			Using easy_install to add modules
			Installing modules manually
	Looking at other Python interpreters
	Summary
Chapter 2: Simple Data Types
	Introducing the built-in operators
		Making comparisons
		Using integers
			Using the bit-oriented operators
		Using rational numbers
		Using decimal numbers
		Using floating-point numbers
		Using complex numbers
	The numeric tower
	The math libraries
	Using bits and Boolean values
	Working with sequences
		Slicing and dicing a sequence
	Using string and bytes values
		Writing string literals
		Using raw string literals
		Using byte string literals
		Using the string operators
		Converting between Unicode and bytes
		Using string methods
		Accessing the details of a string
		Parsing strings into substrings
	Using the tuple collection
	The None object
	The consequences of immutability
	Using the built-in conversion functions
	Summary
Chapter 3: Expressions and Output
	Expressions, operators, and data types
		Using operators on non-numeric data
	The print() function
	Examining syntax rules
	Splitting, partitioning, and joining strings
		Using the format() method to make more readable output
	Summary of the standard string libraries
		Using the re module to parse strings
			Using regular expressions
			Creating a regular expression string
			Working with Unicode, ASCII and bytes
		Using the locale module for personalization
	Summary
Chapter 4: Variables, Assignment and Scoping Rules
	Simple assignment and variables
	Multiple assignment
		Using repeated assignment
	Using the head, *tail assignment
	Augmented assignment
	The input() function
	Python language concepts
		Object types versus variable declarations
		Avoiding confusion when naming variables
		Garbage collection via reference counting
		The little-used del statement
	The Python namespace concept
		Globals and locals
	Summary
Chapter 5: Logic, Comparisons, and Conditions
	Boolean data and the bool() function
	Comparison operators
		Combining comparisons to simplify the logic
		Testing float values
		Comparing object IDs with the is operator
		Equality and object hash values
	Logic operators – and, or, not, if-else
		Short-circuit (or non-strict) evaluation
	The if-elif-else statement
		Adding elif clauses
	The pass statement as placeholder
	The assert statement
	The logic of the None object
	Summary
Chapter 6: More Complex Data Types
	The mutability and immutability distinction
	Using the list collection
		Using list operators
		Mutating a list with subscripts
		Mutating a list with method functions
		Accessing a list
	Using collection functions
	Using the set collection
		Using set operators
		Mutating a set with method functions
		Using augmented assignment with sets
		Accessing a set with operators and method functions
	Mappings
		Using dictionary operators
		Using dictionary mutators
		Using methods for accessing items in a mapping
		Using extensions from the collections module
	Processing collections with the for statement
		Using literal lists in a for statement
		Using the range() and enumerate() functions
	Iterating with the while statement
	The continue and break statements
		Breaking early from a loop
	Using the else clause on a loop
	Summary
Chapter 7: Basic Function Definitions
	Looking at the five kinds of callables
	Defining functions with positional parameters
		Defining multiple parameters
		Using the return statement
		Evaluating a function with positional or keyword arguments
		Writing a function\'s docstring
	Mutable and immutable argument values
	Defining optional parameters via default values
		A warning about mutable default values
	Using the \"everything else\" notations of * and **
		Using sequences and dictionaries to fill in *args and *kw
	Nested function definitions
	Working with namespaces
		Assigning a global variable
		Assigning a non-local variable
	Defining lambdas
	Writing additional function annotations
	Summary
Chapter 8: More Advanced Functions
	Using the for statement with iterable collections
		Iterators and iterable collections
	Consequences and next steps
	Using generator expressions and comprehensions
		Limitations of generator expressions
		Using multiple loops and conditions
		Writing comprehensions
	Defining generator functions with the yield statement
	Using the higher-order functions
		Writing our own higher-order functions
	Using the built-in reductions – max, min, and reduce
	Three ways to sort a sequence
		Sorting via a key function
		Sorting via wrapping and unwrapping
	Functional programming design patterns
	Summary
Chapter 9: Exceptions
	The core exception concept
		Examining the exception object
	Using the try and except statements
		Using nested try statements
	Matching exception classes in an except clause
		Matching more general exceptions
		The empty except clause
	Creating our own exceptions
	Using a finally clause
	Use cases for exceptions
	Issuing warnings instead of exceptions
	Permission versus forgiveness – a Pythonic approach
	Summary
Chapter 10: Files, Databases, Networks, and Contexts
	The essential file concept
		Opening text files
		Filtering text lines
		Working with raw bytes
		Using file-like objects
	Using a context manager via the with statement
		Closing file-like objects with contextlib
	Using the shelve module as a database
		Using the sqlite database
		Using object-relational mapping
	Web services and Internet protocols
	Physical format considerations
	Summary
Chapter 11: Class Definitions
	Creating a class
	Writing the suite of statements in a class
	Using instance variables and methods
	Pythonic object-oriented programming
		Trying to do type casting
		Designing for encapsulation and privacy
	Using properties
	Using inheritance to simplify class definitions
		Using multiple inheritance and the mixin design pattern
	Using class methods and attributes
		Using mutable class variables
		Writing static methods
	Using __slots__ to save storage
	The ABCs of abstract base classes
		Writing a callable class
	Summary
Chapter 12: Scripts, Modules, Packages, Libraries, and Applications
	Script file rules
	Running a script by the filename
		Running a script by its module name
		Running a script using OS shell rules
		Choosing good script names
	Creating a reusable module
	Creating a hybrid library/application modules
	Creating a package
	Designing alternative implementations
	Seeing the package search path
	Summary
Chapter 13: Metaprogramming and Decorators
	Simple metaprogramming with decorators
	Defining our own decorator
	More complex metaprogramming with metaclasses
	Summary
FChapter 14: it and Finish – Unit Testing, Packaging, and Documentation
	Writing docstrings
	Writing unit tests with doctest
	Using the unittest library for testing
		Combining doctest and unittest
	Using other add-on test libraries
	Logging events and conditions
		Configuring the logging system
	Writing documentation with RST markup
		Creating HTML documentation from an RST source
		Using the Sphinx tool
	Organizing Python code
	Summary
Chapter 15: Next Steps
	Leveraging the standard library
	Leveraging PyPI – the Python Package Index
	Types of applications
	Building CLI applications
		Getting command-line arguments with argparse
		Using the cmd module for interactive applications
	Building GUI applications
		Using more sophisticated packages
	Building web applications
		Using a web framework
		Building a RESTful web service with Flask
	Plugging into a MapReduce framework
	Summary
Index