Python: Visual QuickStart Guide [Pehme köide]

1. Getting Started.


Getting Python. Reading Python Documentation. Opening a Command-Prompt
Window. Setting Your Path. Using Python Environment Variables. Running
Programs in Interactive Mode. Running Programs in Script Mode. Using IDLE.
Specifying Command-Line Options. Passing Arguments to a Script.



2. Expressions and Statements.


Documenting Programs. Naming Variables. Creating Expressions. Creating
Expression Statements. Creating Variables. Deleting Variables. Printing
Objects. Determining an Object's Identity. Creating References to the Same
Object. Determining an Object's Type. Using Boolean Operators. Using
Comparison Operators. Chaining Comparisons. Determining the Order of
Evaluation. Summarizing Objects.



3. Working with Numbers.


Understanding the Types of Numbers. Understanding Promotion. Performing
Basic Arithmetic. Raising a Number to a Power. Getting the Remainder of a
Division. Getting the Quotient of a Division. Controlling Calculation Order.
Making Augmented Assignments. Converting Among Number Types. Comparing
Numbers. Using Mathematical Functions. Using Advanced Mathematical Functions.
Generating Random Numbers.



4. Working with Strings.


Creating a String. Inserting Special Characters into a String. Creating a
Unicode String. Finding the Length of a String. Indexing a String (Extracting
a Character). Slicing a String (Extracting a Substring). Concatenating
Strings. Repeating a String. Using String Methods and Functions. Changing
String Case. Testing a String. Trimming and Justifying a String. Searching
for Substrings. Replacing Substrings. Translating a String. Splitting and
Joining Strings. Performing List Operations on a String. Converting a String.
Comparing Strings. Printing Formatted Strings.



5. Working with Lists and Tuples.


Creating a List or Tuple. Finding the Length of a List or Tuple. Indexing
a List or Tuple (Extracting an Item). Slicing a List or Tuple (Extracting a
Segment). Copying a List or Tuple. Concatenating Lists or Tuples. Repeating a
List or Tuple. Converting a List or Tuple. Comparing Lists or Tuples. Testing
List or Tuple Membership. Modifying a List. Replacing List Items. Counting
Matching List Values. Searching a List. Adding List Items. Removing List
Items. Sorting a List. Inserting Items into a Sorted List. Defining a Custom
List Sort Order. Reversing a List.



6. Working with Dictionaries.


Using Dictionary Operators and Methods. Creating a Dictionary. Printing a
Dictionary. Getting a Value by Using a Key. Getting All of a Dictionary's
Values. Getting All of a Dictionary's Keys. Getting All of a Dictionary's
Key-Value Pairs. Determining Whether a Key Exists. Counting a Dictionary's
Key-Value Pairs. Adding or Replacing a Key-Value Pair. Removing a Key-Value
Pair. Removing a Random Key-Value Pair. Clearing or Deleting a Dictionary.
Combining Dictionaries. Copying a Dictionary. Converting a Dictionary
2. Comparing Dictionaries. Sorting a Dictionary. Storing Computed Values in a
Dictionary.



7. Control Flow Statements.


Splitting Statements Across Lines. Creating Compound Statements. Using
pass to Create a Null Statement. Indenting Blocks of Statements. Putting
Multiple Statements on a Line. Using if Conditionals. Using if-else
Conditionals. Using if-elif-else Conditionals. Using while Loops. Using
while-else Loops. Using for Loops. Using for-else Loops. Looping over a Range
of Integers. Skipping Part of a Loop Iteration. Exiting a Loop.



8. Functions.


Defining a Function. Documenting a Function. Calling a Function. Returning
a Value from a Function. Returning Multiple Values from a Function.
Specifying Positional Arguments. Specifying Default Parameter Values.
Specifying Keyword Arguments. Specifying an Arbitrary Number of Positional
Arguments. Specifying an Arbitrary Number of Keyword Arguments. Combining
Argument-Passing Techniques. Creating Recursive Functions. Passing Mutable
and Immutable Arguments to Functions. Declaring Global Variables. Assigning a
Function to a Variable. Using Functional Programming Tools. Using lambda
Expressions to Create Functions. Using apply to Call a Function. Using map to
Apply a Function to Sequence Items. Using zip to Group Sequence Items. Using
filter to Remove Sequence Items Conditionally. Using reduce to Reduce a
Sequence. Using List Comprehensions to Create Lists.



9. Modules.


Structuring a Module. Creating a Module. Documenting a Module. Loading a
Module with import. Accessing Attributes. Listing an Object's Attributes.
Manipulating Attributes. Loading Specific Module Names with from. Loading a
Module Under a Different Name with as. Enabling Language Features. Reloading
a Module with reload. Specifying the Module Search Path. Determining Whether
a Module Is Running As a Program. Determining Which Modules Are Loaded.
Understanding Namespaces. Accessing Namespaces. Understanding Scoping Rules.
Nesting Functions. Grouping Modules into Packages. Terminating a Program
Explicitly. Running Code Programmatically.



10. Files.


Opening a File. Reading from a File. Writing to a File. Closing a File.
Changing Position in a File. Truncating a File. Getting File Object
Information. Printing to a File. Accessing Standard Input and Output Files.
Prompting for User Input. Using the File System. Accessing Environment
Variables. Changing the Working Directory. Listing Directory Contents.
Creating a Directory. Removing a Directory. Renaming a File or Directory.
Removing a File. Getting Path Information. Getting File Information.
Splitting Paths. Joining Paths. Saving Objects As Files.



11. Exceptions.


Understanding the Exception Hierarchy. Handling an Exception. Ignoring an
Exception. Getting an Exception's Argument. Handling All Exceptions. Running
Code in the Absence of an Exception. Handling Multiple Exceptions. Running
Mandatory Cleanup Code. Raising an Exception Explicitly. Creating
User-Defined Exceptions. Making an Assertion.



12. Classes.


Understanding OOP Terminology. Defining a Class. Documenting a Class.
Accessing Built-In Class Attributes. Creating an Instance. Accessing Built-In
Instance Attributes. Creating Class Variables. Using Special Methods to
Overload Standard Behavior. Creating Instance Variables with an
Initialization Method. Destroying an Instance. Creating a String
Representation of an Instance. Setting the Truth Value of an Instance.
Comparing Instances. Accessing Instance Attributes. Treating an Instance Like
a List or Dictionary. Performing Mathematical Operations on Instances.
Calling an Instance. Defining and Invoking a Custom Method. Deriving New
Classes from Existing Classes. Hiding Private Data. Determining Class
Membership.



Appendix.


Learning Python. Getting Support. Editing and Debugging Code. Programming
Resources.



Index.

Chris Fehily is a writer and consultant living in San Francisco.