Python Essentials - A Rapid Guide to the Fundamental Features of Python

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