Using Google App Engine开发(英文影印版)

.multiple files
lists in html
specifying styles using css
styling tags with css
exerting more control over markup
validating css
tools to help you work with css
building the navigation menu
the css box model
adding navigation hints for users
summary
exercises
3. python
what is programming？
about pyttion
installing python
the essence of programming
input, processing, and output
conditional steps: a number-guessing web application
variables and expressions
naming variables
constants
handling text data using strings
using the string library
types and conversion
variables with many values at the same time: lists
repeated code: loops
python\'s backpack: dictionaries
looping through a dictionary
stored and reused code: python functions
turning traceback to our advantage using try and except
object-oriented python
comments in python
the tao of programming
summary
exercises
4. sending data to your application
making an http request
hacking the http protocol
the http protocol standards
watching http in action
html: building a form
sending form data to the server using post
handling form data in the app engine server
sending form data to the server using get
app engine log
looking at all the data available on an http request
advanced: multipart post data with file upload
summary
exercises
5. theapp engine webapp framework
a trivial app engine application
an equivalent trivial webapp application
the handler callback pattern
looking at the handler code
what is "self" and why is it there？
number guessing using the webapp framework
web server logs
summary
exercises
6. templates
template syntax
using the templates from python
the number-guessing game using templates
abstraction and separation of concerns: "model view controller"
building a multiscreen application
static files in app engine
referencing static files
generalizing template lookup with multiple templates
extending base templates
conditional processing templates
replacing more than one block in the base template
extending our application
syntax errors
more on templates
summary
exercises
7. cookies and sessions
http cookies
logging in and logging out using sessions
installing the simple session utility
using the session to mark login and logout
changing the user interface for a logged-in user
summary
exercises
8. appenginedatastore
the model-view-controller pattern
defining models
adding a new account form
adding a user account
looking through the datastore
logging in and checking accounts and passwords
retrieving and displaying many objects
terminology: different types of keys
references between data models
interactions between models
pt/tting the primary key into session
adding the chat feature
summary
exercises
9. lavascript, jquery, and ajax
jquery
create a view of the chat messages in html
asynchronously updating a

.　　This is a very quick introduction to Python that covers only the areas of Python that are necessary for reading the rest of the book. Because we are writing a web application and not a general-purpose application, you need to know only a subset of Python. Python is a great language for beginners, casual users, and power users because it is both simple and powerful. Many claim that Python is the language for people who actually use computers.
　　Chapter 4, Sending Data to Your Application
　　This chapter sounds a little nerdy--and it is! I think that you actually need to know how the browser talks to a web server and exchanges data using HTTP. It is not all that complex, once you understand it--and it's worth learning. This chapter introduces the first simple App Engine program that we will use to explore how the HTTP request/response cycle works from both the browser and server perspectives.
　　Chapter 5, The App Engine webapp Framework
　　Properly written App Engine programs consist of a set of cooperating objects. The object-oriented design pattern is how we create and link these objects to get our work done. In this chapter, I teach the basics of object-oriented Python and then jump right into a sample App Engine program using the Google object-oriented web framework. Like the rest of the background chapters, I explain the basics of objects in Python by covering only what you need to know for App Engine.
　　Chapter 6, Templates
　　In this chapter, I introduce the first part of the Model-View-Controller pattern used in most web frameworks. Using templates, I separate the look and feel of the application (the View) from the rest of the logic of the application. Templates are files that contain HTML augmented using the Django template language to allow certain areas of the HTML to contain information that comes from your Python code (the Controller). You will learn about basic templates as well as inherited templates--where common material is kept in one file and reused across many files--object-oriented templates, as it were.
　　Chapter 7, Cookies and Sessions
　　In this chapter, I introduce the concept of a session. Sessions and cookies combine to allow the web server to work with multiple simultaneous users. Sessions associate bits of information, such as the name of the currently logged-in user, with one particular browser so that it can distinguish which incoming requests come from which browser.
　　Chapter 8, App Engine Datastore
　　Google App Engine does not provide you with a relational database. Experts in relational databases will likely feel a bit out of their element when they first look at the Google App Engine Models and Datastore. Readers who have never learned relational databases can be quite thankful that Models (as in Model-ViewController) are much simpler to use than relational databases. Also, Google has learned through experience that relational databases simply cannot scale to levels beyond millions of users. The Google Datastore can be scaled well beyond a million users. Although you may never need to scale to several million users, you will like how using Models makes storage easier.
　　Chapter 9, JavaScript, jQuery, and AJAX
　　This chapter adds a little in-browser interactivity to our application via jQuery and AJAX to implement a simple multiuser chat. It also covers how you create multiple data models and link data objects together in the Google Datastore. I explain just enough JavaScript, j Query, and AJAX to help you understand how your application works with these technologies.
　　Chapter 10, Running Your Application on the Google Infrastructure
　　This chapter covers how to run your application in the Google infrastructure cloud. You will learn how to get your free App Engine accounts and then upload your software into the cloud. You also learn about the administration interfaces that allow you to monitor and manage your application and data while you are in production.
　　Chapter 11, Memory Cache
　　The App Engine Memory Cache is a critical technology for making fast and scalable websites. Clever use of Memory Cache can dramatically reduce the load on a Datastore or the network and increase application responsiveness, particularly for material that is read over and over. In this chapter, we explore how the Memory Cache works and develop simple Session capability using the Memory Cache.
　　Teaching with This Book
　　This book came out of a University of Michigan School of Information course titled "Design of Complex Websites (SI539)." This course explores emerging web technologies, including ColdFusion, PHP, Ruby on Rails, and now Google Application Engine. The basic idea of the course was to teach in one semester students with very limited technical background enough about database-backed web development "to be dangerous to themselves and others." The course and book are aimed at introducing these concepts to a nontechnical audience.
　　The book is written at a beginning level; I think that it can be used to support a semesterlong "Introduction to Web Programming" course from high school through graduate school. Because this book includes introductions to Python and to HTML and CSS, I hope that it can be used by itself or with supporting material.
　　For beginning students, you can have a series of assignments that are very similar to the examples in the book, with minor changes such as color or adding images to pages. The assignments can be made more difficult by having the students do a series of parallel, but different, projects that correspond roughly t9 the concepts in the book's running examples.
　　The book can also be used to support a one-day workshop in App Engine. It would probably be difficult to teach Python, HTML, CSS, and App Engine in a single day. But because the examples are a single evolving application and each example builds on the previous one, it is possible to skip steps in the interest of time. You might have one exercise where the students modify the ae-OS-login example (login without session) to produce ae-O9-session (login with session) and then skip ahead to modify the ae-11chat (non-AJAX chat) to produce ae-12-ajax (AJAX-based chat). The chapters walk readers through the necessary changes from each version of the application to the next.
　　To help support the use of the book in a classroom setting, I provide freely reusable classroom materials that make it easier to use the book in other courses at my personal website (http://www.dr-chuck.com). I would love to hear from other teachers who use the book so that we can all share our experiences, assignments, tips, and lecture materials.
　　Conventions Used in This Book
　　The following typographical conventions are used in this book:
　　Italic
　　Indicates new terms, URLs, email addresses, filenames, file extensions, pathnames, directories, and Unix utilities.
　　Constant width
　　Indicates commands, options, switches, variables, attributes, keys, functions, types, classes, namespaces, methods, modules, properties, parameters, values, objects, events, event handlers, XML tags, HTML tags, macros, the contents of files,or the output from commands.
　　Constant width bold
　　Shows commands or other text that should be typed literally by the user.
　　Constant width italic
　　Shows text that should be replaced with user-supplied values.
　　This icon signifies a tip, suggestion, or general note.
　　This icon indicates a warning or caution.
　　Using Code Examples
　　This book is here to help you get your job done. In general, you may use the code in this book in your programs and documentation. You do not need to contact us for permission unless you're reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from O'Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product's documentation does require permission.
　　We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: "Using Google App Engine, by Charles Severance. Copyright 2009 Charles Severance, 978-0-596-80069-7."
　　If you feel that your use of code examples falls outside fair use or the permission given above, feel free to contact us at permissions@oreilly, com.