Rapid GUI Programming with Python and QT: The Definitive Guide to PyQt Programming / Edition 1

Hardcover (Print)
Buy New
Buy New from BN.com
$46.56
Used and New from Other Sellers
Used and New from Other Sellers
from $31.11
Usually ships in 1-2 business days
(Save 48%)
Other sellers (Hardcover)
  • All (18) from $31.11   
  • New (12) from $39.91   
  • Used (6) from $31.11   

Overview

The Insider's Best-Practice Guide to Rapid PyQt 4 GUI Development

Whether you're building GUI prototypes or full-fledged cross-platform GUI applications with native look-and-feel, PyQt 4 is your fastest, easiest, most powerful solution. Qt expert Mark Summerfield has written the definitive best-practice guide to PyQt 4 development.

With Rapid GUI Programming with Python and Qt you'll learn how to build efficient GUI applications that run on all major operating systems, including Windows, Mac OS X, Linux, and many versions of Unix, using the same source code for all of them. Summerfield systematically introduces every core GUI development technique: from dialogs and windows to data handling; from events to printing; and more. Through the book's realistic examples you'll discover a completely new PyQt 4-based programming approach, as well as coverage of many new topics, from PyQt 4's rich text engine to advanced model/view and graphics/view programming. Every key concept is illuminated with realistic, downloadable examples—all tested on Windows, Mac OS X, and Linux with Python 2.5, Qt 4.2, and PyQt 4.2, and on Windows and Linux with Qt 4.3 and PyQt 4.3.

Coverge includes

  • Python basics for every PyQt developer: data types, data structures, control structures, classes, modules, and more
  • Core PyQt GUI programming techniques: dialogs, main windows, and custom file formats
  • Using Qt Designer to design user interfaces, and to implement and test dialogs, events, the Clipboard, and drag-and-drop
  • Building custom widgets: Widget Style Sheets, composite widgets, subclassing, and more
  • Making the most of Qt 4.2's new graphics/view architecture
  • Connecting to databases, executing SQL queries, and using form and table views
  • Advanced model/view programming: custom views, generic delegates, and more
  • Implementing online help, internationalizing applications, and using PyQt's networking and multithreading facilities
Read More Show Less

Product Details

Meet the Author

Mark Summerfield works as an independent trainer and consultant specializing in C++, Qt, Python, and PyQt. He was Trolltech’s documentation manager from 2000 to 2004, was the founding editor of Qt Quarterly, Trolltech’s customer newsletter, and coauthored C++ GUI Programming with Qt 3 and C++ GUI Programming with Qt 4.

Read More Show Less

Read an Excerpt

This book teaches how to write GUI applications using the Python programming language and the Qt application development framework. The only essential prior knowledge is that you can program in some object-oriented programming language, such as C++, C#, Java, or of course, Python itself. For the rich text chapter, some familiarity with HTML and with regular expressions is assumed, and the databases and threading chapters assume some basic knowledge of those topics. A knowledge of GUI programming is not required, since all the key concepts are covered.

The book will be useful to people who program professionally as part of their job, whether as full-time software developers, or those from other disciplines, including scientists and engineers, who need to do some programming in support of their work. It is also suitable for undergraduate and post-graduate students, particularly those doing courses or research that includes a substantial computing element. The exercises (with solutions) are provided especially to help students.

Python is probably the easiest to learn and nicest scripting language in widespread use, and Qt is probably the best library for developing GUI applications. The combination of Python and Qt, "PyQt", makes it possible to develop applications on any supported platform and run them unchanged on all the supported platforms—for example, all modern versions of Windows, Linux, Mac OS X, and most Unix-based systems. No compilation is required thanks to Python being interpreted, and no source code changes to adapt to different operating systems are required thanks to Qt abstracting away the platform-specific details. We only have to copy the source file orfiles to a target machine that has both Python and PyQt installed and the application will run.

If you are new to Python: Welcome! You are about to discover a language that is clear to read and write, and that is concise without being cryptic. Python supports many programming paradigms, but because our focus is on GUI programming, we will take an object-oriented approach everywhere except in the very early chapters.

Python is a very expressive language, which means that we can usually write far fewer lines of Python code than would be required for an equivalent application written in, say, C++ or Java. This makes it possible to show some small but complete examples throughout the text, and makes PyQt an ideal tool for rapidly and easily developing GUI applications, whether for prototyping or for production use.

Since the emphasis of the book is on GUI programming, Part I provides a fast-paced Python tutorial as well as some PyQt coverage. This material is clearly marked to make it easy for experienced Python programmers to skip the Python they already know. Parts II, III, and IV of the book are all PyQt-specific and assume that readers can already program in Python, whether from previous experience or from reading Part I.

Quite often in programming we reach decision points when there are several possible approaches we could take. Reference books and the online documentation identify what classes, methods, and functions are available, and in some cases provide examples, but such documents rarely provide a broader context. This book gives the necessary context, highlighting the key decision points for GUI programming and offering insights into the pros and cons so that you can decide for yourself what the right policy is for your particular circumstances. For example, when you create a dialog, should it be modal or modeless? (See Chapter 5 for an explanation and policy recommendations on this issue.)

PyQt is used to write all kinds of GUI applications, from accounting applications, to visualization tools used by scientists and engineers. Figure 1, for example, shows Eric, a powerful integrated development environment that is written in PyQt. It is possible to write PyQt applications that are just tens of lines long, and medium-size projects of 1000 to 10000 lines are very common. Some commercial companies have built 100,000-line PyQt applications, with programming teams varying in size from just one person to more than a dozen people. Many in-house tools are written using PyQt, but because these are often used to gain competitive advantage, the companies involved generally do not permit their use of PyQt to be made public. PyQt is also widely used in the open source world, with games, utilities, visualization tools, and IDEs all written using it.

This book is specifically about PyQt4, the Python bindings for the Qt 4 C++ application development framework. PyQt4 is provided in the form of ten Python modules which between them contain around 400 classes and about 6000 methods and functions. All the example programs have been tested on Windows, Linux, and Mac OS X, using Python 2.5, Qt 4.2, and PyQt 4.2, and additionally on Windows and Linux using Qt 4.3 and PyQt 4.3. Backporting to earlier versions is possible in some cases, but we recommend using the most up-to-date versions of Python, Qt, and PyQt.

Python, PyQt, and Qt can be used free of charge for noncommercial purposes, but the license used by Python is different from that used by PyQt and Qt. Python is available with a very liberal license that allows it to be used to develop both commercial and noncommercial applications. Both PyQt and Qt are dual-licensed: This essentially allows them to be used to develop noncommercial applications—which must in turn be licensed using an acceptable open source license such as the GNU General Public License (GPL); or to be used to develop commercial applications—in this case, a commercial PyQt license and a commercial Qt license must be purchased. The Structure of the Book

The book is divided into four parts. Part I is primarily a rapid conversion course aimed at non-Python programmers who are familiar with an object-oriented language, although it also has some (clearly marked) PyQt content. Because the core Python language is mostly simple and is quite small, these chapters can teach the basics of Python to a sufficient extent that real Python applications can be written.

If you think that you can pick up the Python syntax simply through reading it, you might be tempted to skip Part I and dive straight into the GUI programming that begins in Part II. The early chapters in Part II include back-references to the relevant pages in Part I to support readers who choose this approach. However, even for readers familiar with Python, we recommend reading about QString in Chapter 1. If you are unfamiliar with partial function application (currying), it is important to read the subsection that covers this in Chapter 2, since this technique is sometimes used in GUI programming.

There are also Python bindings for the older Qt 3 library, but there is no reason to use that library for new projects, especially since Qt 4 offers far more functionality and is easier to use.

Part II begins by showing three tiny PyQt GUI applications to give an initial impression of what PyQt programming is like. It also explains some of the fundamental concepts involved in GUI programming, including PyQt's high-level signals and slots communication mechanism. Chapter 5 shows how to create dialogs and how to create and lay out widgets ("controls" in Windows-speak—the graphical elements that make up a user interface such as buttons, listboxes,and such) in a dialog. Dialogs are central to GUI programming: Most GUI applications have a single main window, and dozens or scores of dialogs, so this topic is covered in depth.

After the dialogs chapter comes Chapter 6, which covers main windows, including menus, toolbars, dock windows, and keyboard shortcuts, as well as loading and saving application settings. Part II's final chapters show how to create dialogs using Qt Designer, Qt's visual design tool, and how to save data in binary, text, and

Part III gives deeper coverage of some of the topics covered in Part II, and introduces many new topics. Chapter 9 shows how to lay out widgets in quite sophisticated ways, and how to handle multiple documents. Chapter 10 covers low-level event handlers, and how to use the clipboard as well as drag and drop, text, HTML, and binary data. Chapter 11 shows how to modify and subclass existing widgets, and how to create entirely new widgets from scratch, with complete control over their appearance and behavior. This chapter also shows how to do basic graphics. Chapter 12 shows how to use Qt 4.2's new graphics/view architecture, which is particularly suited to handling large numbers of independent graphical objects. Qt's HTML-capable rich text engine is covered in Chapter 13. This chapter also covers printing both to paper and to PDF files.

Part III concludes with two chapters on model/view programming: Chapter 14 introduces the subject and shows how to use Qt's built-in views and how to create custom data models and custom delegates, and Chapter 15 shows how to use the model/view architecture to perform database programming.

Part IV continues the model/view theme, with coverage of three different advanced model/view topics in Chapter 16. The first section of Chapter 17 describes the techniques that can be used for providing online help, and the second section explains how to internationalize an application, including how to use Qt's translation tools to create translation files. The Python standard library provides its own classes for networking and for threading, but in the last two chapters of Part IV we show how to do networking and threading using PyQt's classes.

Appendix A explains where Python, PyQt, and Qt can be obtained, and how to install them on Windows, Mac OS X, and Linux. PyQt is much easier to learn if you install it and try out some of the exercises, and if you inspect some of the example code. Appendix B presents screenshots and brief descriptions of selected PyQt widgets; this is helpful for those new to GUI programming. Appendix C presents diagrams of some of PyQt's key class hierarchies; this is useful for getting to know what classes PyQt has to offer and how they are related.

If you have never used Python before, you should begin by reading Chapters 1-6 in order. If you already know Python, at least read the string policy (in bullet points on page 28), and skim the material in Chapter 2 (apart from the first section, which you'll know well). Make sure that you are comfortable with lambda and partial function application, both of which are covered in Chapter 2. It is probably also worth skimming Chapter 3 as well. Then read Chapters 4, 5, and 6 in order.

Once you have covered the first six chapters, you have covered the essentials of Python and the fundamentals of PyQt.

Chapter 7 is useful if you want to know how to create dialogs using a visual design tool rather than purely by hand coding, something that can save a lot of time. For file handling, at least read the first three sections of Chapter 8. If you plan to write and read text files, also read Chapter 8's fourth section, and similarly the fifth section if you are going to use

For Part III, at the least read Chapter 10's first section, on event handling, and all of Chapter 11. Chapter 12 and the first section of Chapter 13 assume that you have read about PyQt's event handling, and that you have read Chapter 11. Chapters 9 and 14 can be read stand-alone in this part, but Chapter 15 assumes that you have read Chapter 14.

In Part IV, Chapter 16 assumes that you have read Chapters 14 and 15, but the other chapters can be read independently.

If you find errors in the text or in the examples, or have other comments, please write to mark@qtrac.eu quoting "PyQt book" in the subject line. The book's home page, where any corrections will be published, and from where the examples and exercise solutions can be downloaded, is http://www.qtrac.eu/pyqtbook.html.

If you want to participate in the PyQt community, it is worthwhile joining the mailing list. Go to http://www.riverbankcomputing.com/mailman/listinfo/pyqt to find a link to the archive, so that you can see what the mailing list is like, and also for a form for joining. Python also has mailing lists and other community activities. For these, go to http://www.python.org/community.

Read More Show Less

Table of Contents

Foreword xiii

Introduction 1

Part I: Python Programming

Chapter 1. Data Types and Data Structures 9

Executing Python Code 10

Variables and Objects 12

Numbers and Strings 15

Collections 29

Built-in Functions 37

Summary 41

Exercises 42

Chapter 2. Control Structures 45

Conditional Branching 46

Looping 49

Functions 55

Exception Handling 66

Summary 72

Exercises 72

Chapter 3. Classes and Modules 75

Creating Instances 77

Methods and Special Methods 79

Inheritance and Polymorphism 99

Modules and Multifile Applications 104

Summary 107

Exercises 108

Part II: Basic GUI Programming

Chapter 4. Introduction to GUI Programming 111

A Pop-Up Alert in 25 Lines 112

An Expression Evaluator in 30 Lines 116

A Currency Converter in 70 Lines 121

Signals and Slots 127

Summary 136

Exercise 137

Chapter 5. Dialogs 139

Dumb Dialogs 141

Standard Dialogs 147

Smart Dialogs 154

Summary 162

Exercise 163

Chapter 6. Main Windows 165

Creating a Main Window 166

Handling User Actions 190

Summary 201

Exercise 202

Chapter 7. Using Qt Designer 205

Designing User Interfaces 208

Implementing Dialogs 216

Testing Dialogs 221

Summary 223

Exercise 224

Chapter 8. Data Handling and Custom File Formats 227

Main Window Responsibilities 229

Data Container Responsibilities 235

Saving and Loading Binary Files 240

Saving and Loading Text Files 249

Saving and Loading XML Files 256

Summary 265

Exercise 266

Part III: Intermediate GUI Programming

Chapter 9. Layouts and Multiple Documents 269

Layout Policies 270

Tab Widgets and Stacked Widgets 272

Splitters 280

Single Document Interface(SDI) 283

Multiple Document Interface(MDI) 290

Summary 300

Exercise 301

Chapter 10. Events, the Clipboard, and Drag and Drop 303

The Event-Handling Mechanism 303

Reimplementing Event Handlers 305

Using the Clipboard 310

Drag and Drop 312

Summary 317

Exercise 318

Chapter 11. Custom Widgets 321

Using Widget Style Sheets 322

Creating Composite Widgets 325

Subclassing Built-in Widgets 326

Subclassing QWidget 328

Summary 345

Exercise 346

Chapter 12. Item-Based Graphics 349

Custom and Interactive Graphics Items 351

Animation and Complex Shapes 368

Summary 378

Exercise 379

Chapter 13. Rich Text and Printing 381

Rich Text Editing 382

Printing Documents 398

Summary 411

Exercise 412

Chapter 14. Model/View Programming 413

Using the Convenience Item Widgets 415

Creating Custom Models 423

Creating Custom Delegates 436

Summary 442

Exercise 443

Chapter 15. Databases 445

Connecting to the Database 446

Executing SQL Queries 446

Using Database Form Views 451

Using Database Table Views 457

Summary 470

Exercise 471

Part IV: Advanced GUI Programming

Chapter 16. Advanced Model/View Programming 475

Custom Views 476

Generic Delegates 483

Representing Tabular Data in Trees 492

Summary 505

Exercise 505

Chapter 17. Online Help and Internationalization 509

Online Help 510

Internationalization 512

Summary 519

Exercise 520

Chapter 18. Networking 521

Creating a TCP Client 523

Creating a TCP Server 529

Summary 534

Exercise 534

Chapter 19. Multithreading 537

Creating a Threaded Server 539

Creating and Managing Secondary Threads 544

Implementing a Secondary Thread 552

Summary 557

Exercise 558

This Is Not Quite the End 559

Appendix A. Installing 561

Appendix B. Selected PyQt Widgets 575

Appendix C. Selected PyQt Class Hierarchies 581

Index 585

Read More Show Less

Preface

This book teaches how to write GUI applications using the Python programming language and the Qt application development framework. The only essential prior knowledge is that you can program in some object-oriented programming language, such as C++, C#, Java, or of course, Python itself. For the rich text chapter, some familiarity with HTML and with regular expressions is assumed, and the databases and threading chapters assume some basic knowledge of those topics. A knowledge of GUI programming is not required, since all the key concepts are covered.

The book will be useful to people who program professionally as part of their job, whether as full-time software developers, or those from other disciplines, including scientists and engineers, who need to do some programming in support of their work. It is also suitable for undergraduate and post-graduate students, particularly those doing courses or research that includes a substantial computing element. The exercises (with solutions) are provided especially to help students.

Python is probably the easiest to learn and nicest scripting language in widespread use, and Qt is probably the best library for developing GUI applications. The combination of Python and Qt, "PyQt", makes it possible to develop applications on any supported platform and run them unchanged on all the supported platforms--for example, all modern versions of Windows, Linux, Mac OS X, and most Unix-based systems. No compilation is required thanks to Python being interpreted, and no source code changes to adapt to different operating systems are required thanks to Qt abstracting away the platform-specific details. We only have to copy the source file or files to a target machine that has both Python and PyQt installed and the application will run.

If you are new to Python: Welcome! You are about to discover a language that is clear to read and write, and that is concise without being cryptic. Python supports many programming paradigms, but because our focus is on GUI programming, we will take an object-oriented approach everywhere except in the very early chapters.

Python is a very expressive language, which means that we can usually write far fewer lines of Python code than would be required for an equivalent application written in, say, C++ or Java. This makes it possible to show some small but complete examples throughout the text, and makes PyQt an ideal tool for rapidly and easily developing GUI applications, whether for prototyping or for production use.

Since the emphasis of the book is on GUI programming, Part I provides a fast-paced Python tutorial as well as some PyQt coverage. This material is clearly marked to make it easy for experienced Python programmers to skip the Python they already know. Parts II, III, and IV of the book are all PyQt-specific and assume that readers can already program in Python, whether from previous experience or from reading Part I.

Quite often in programming we reach decision points when there are several possible approaches we could take. Reference books and the online documentation identify what classes, methods, and functions are available, and in some cases provide examples, but such documents rarely provide a broader context. This book gives the necessary context, highlighting the key decision points for GUI programming and offering insights into the pros and cons so that you can decide for yourself what the right policy is for your particular circumstances. For example, when you create a dialog, should it be modal or modeless? (See Chapter 5 for an explanation and policy recommendations on this issue.)

PyQt is used to write all kinds of GUI applications, from accounting applications, to visualization tools used by scientists and engineers. Figure 1, for example, shows Eric, a powerful integrated development environment that is written in PyQt. It is possible to write PyQt applications that are just tens of lines long, and medium-size projects of 1000 to 10000 lines are very common. Some commercial companies have built 100,000-line PyQt applications, with programming teams varying in size from just one person to more than a dozen people. Many in-house tools are written using PyQt, but because these are often used to gain competitive advantage, the companies involved generally do not permit their use of PyQt to be made public. PyQt is also widely used in the open source world, with games, utilities, visualization tools, and IDEs all written using it.

This book is specifically about PyQt4, the Python bindings for the Qt 4 C++ application development framework. PyQt4 is provided in the form of ten Python modules which between them contain around 400 classes and about 6000 methods and functions. All the example programs have been tested on Windows, Linux, and Mac OS X, using Python 2.5, Qt 4.2, and PyQt 4.2, and additionally on Windows and Linux using Qt 4.3 and PyQt 4.3. Backporting to earlier versions is possible in some cases, but we recommend using the most up-to-date versions of Python, Qt, and PyQt.

Python, PyQt, and Qt can be used free of charge for noncommercial purposes, but the license used by Python is different from that used by PyQt and Qt. Python is available with a very liberal license that allows it to be used to develop both commercial and noncommercial applications. Both PyQt and Qt are dual-licensed: This essentially allows them to be used to develop noncommercial applications--which must in turn be licensed using an acceptable open source license such as the GNU General Public License (GPL); or to be used to develop commercial applications--in this case, a commercial PyQt license and a commercial Qt license must be purchased.

The Structure of the Book

The book is divided into four parts. Part I is primarily a rapid conversion course aimed at non-Python programmers who are familiar with an object-oriented language, although it also has some (clearly marked) PyQt content. Because the core Python language is mostly simple and is quite small, these chapters can teach the basics of Python to a sufficient extent that real Python applications can be written.

If you think that you can pick up the Python syntax simply through reading it, you might be tempted to skip Part I and dive straight into the GUI programming that begins in Part II. The early chapters in Part II include back-references to the relevant pages in Part I to support readers who choose this approach. However, even for readers familiar with Python, we recommend reading about QString in Chapter 1. If you are unfamiliar with partial function application (currying), it is important to read the subsection that covers this in Chapter 2, since this technique is sometimes used in GUI programming.

There are also Python bindings for the older Qt 3 library, but there is no reason to use that library for new projects, especially since Qt 4 offers far more functionality and is easier to use.

Part II begins by showing three tiny PyQt GUI applications to give an initial impression of what PyQt programming is like. It also explains some of the fundamental concepts involved in GUI programming, including PyQt's high-level signals and slots communication mechanism. Chapter 5 shows how to create dialogs and how to create and lay out widgets ("controls" in Windows-speak--the graphical elements that make up a user interface such as buttons, listboxes,and such) in a dialog. Dialogs are central to GUI programming: Most GUI applications have a single main window, and dozens or scores of dialogs, so this topic is covered in depth.

After the dialogs chapter comes Chapter 6, which covers main windows, including menus, toolbars, dock windows, and keyboard shortcuts, as well as loading and saving application settings. Part II's final chapters show how to create dialogs using Qt Designer, Qt's visual design tool, and how to save data in binary, text, and XML formats.

Part III gives deeper coverage of some of the topics covered in Part II, and introduces many new topics. Chapter 9 shows how to lay out widgets in quite sophisticated ways, and how to handle multiple documents. Chapter 10 covers low-level event handlers, and how to use the clipboard as well as drag and drop, text, HTML, and binary data. Chapter 11 shows how to modify and subclass existing widgets, and how to create entirely new widgets from scratch, with complete control over their appearance and behavior. This chapter also shows how to do basic graphics. Chapter 12 shows how to use Qt 4.2's new graphics/view architecture, which is particularly suited to handling large numbers of independent graphical objects. Qt's HTML-capable rich text engine is covered in Chapter 13. This chapter also covers printing both to paper and to PDF files.

Part III concludes with two chapters on model/view programming: Chapter 14 introduces the subject and shows how to use Qt's built-in views and how to create custom data models and custom delegates, and Chapter 15 shows how to use the model/view architecture to perform database programming.

Part IV continues the model/view theme, with coverage of three different advanced model/view topics in Chapter 16. The first section of Chapter 17 describes the techniques that can be used for providing online help, and the second section explains how to internationalize an application, including how to use Qt's translation tools to create translation files. The Python standard library provides its own classes for networking and for threading, but in the last two chapters of Part IV we show how to do networking and threading using PyQt's classes.

Appendix A explains where Python, PyQt, and Qt can be obtained, and how to install them on Windows, Mac OS X, and Linux. PyQt is much easier to learn if you install it and try out some of the exercises, and if you inspect some of the example code. Appendix B presents screenshots and brief descriptions of selected PyQt widgets; this is helpful for those new to GUI programming. Appendix C presents diagrams of some of PyQt's key class hierarchies; this is useful for getting to know what classes PyQt has to offer and how they are related.

If you have never used Python before, you should begin by reading Chapters 1-6 in order. If you already know Python, at least read the string policy (in bullet points on page 28), and skim the material in Chapter 2 (apart from the first section, which you'll know well). Make sure that you are comfortable with lambda and partial function application, both of which are covered in Chapter 2. It is probably also worth skimming Chapter 3 as well. Then read Chapters 4, 5, and 6 in order.

Once you have covered the first six chapters, you have covered the essentials of Python and the fundamentals of PyQt.

Chapter 7 is useful if you want to know how to create dialogs using a visual design tool rather than purely by hand coding, something that can save a lot of time. For file handling, at least read the first three sections of Chapter 8. If you plan to write and read text files, also read Chapter 8's fourth section, and similarly the fifth section if you are going to use XML files.

For Part III, at the least read Chapter 10's first section, on event handling, and all of Chapter 11. Chapter 12 and the first section of Chapter 13 assume that you have read about PyQt's event handling, and that you have read Chapter 11. Chapters 9 and 14 can be read stand-alone in this part, but Chapter 15 assumes that you have read Chapter 14.

In Part IV, Chapter 16 assumes that you have read Chapters 14 and 15, but the other chapters can be read independently.

If you find errors in the text or in the examples, or have other comments, please write to mark@qtrac.eu quoting "PyQt book" in the subject line. The book's home page, where any corrections will be published, and from where the examples and exercise solutions can be downloaded, is http://www.qtrac.eu/pyqtbook.html.

If you want to participate in the PyQt community, it is worthwhile joining the mailing list. Go to http://www.riverbankcomputing.com/mailman/listinfo/pyqt to find a link to the archive, so that you can see what the mailing list is like, and also for a form for joining. Python also has mailing lists and other community activities. For these, go to http://www.python.org/community.

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)