James W. Cooper

Python Programming with Design Patterns (eBook, PDF)

• Format: PDF

Produktbeschreibung

Improve Your Python Code with Modern Object-Oriented Design Patterns

To write clean, efficient, maintainable code, developers everywhere turn to design patterns. Now there's a Python-specific patterns guide that's friendly and practical enough for every Python developer, regardless of experience.

Best-selling patterns author James W. Cooper presents visual, example-driven explanations of 23 proven patterns for writing superior object-oriented code. Through clear and intuitive code samples, he introduces modern techniques for creating Python objects that interact effectively in powerful, flexible programs. Python newcomers--including those moving from other languages--will find a succinct introduction designed to get them up to speed fast.

Cooper's wide-ranging patterns coverage addresses abstract classes, multiple inheritance, GUI programming and widgets, graphical classes, drawing and plotting, math, databases, Python decorators, images, threads, iterators, creating executable code, and more. Throughout, his informal visual presentation makes patterns far easier to work with--so you can confidently build sophisticated programs that use Python's rich capabilities.

• Review the essentials of Python objects and visual programming
• Learn what design patterns are, and how they help you write better code
• Use creational patterns to enhance flexibility and avoid unnecessary complexity
• Apply structural patterns to ensure that program elements work together well in large programs
• Optimize communication between objects with behavioral patterns

---

Dieser Download kann aus rechtlichen Gründen nur mit Rechnungsadresse in A, B, BG, CY, CZ, D, DK, EW, E, FIN, F, GR, HR, H, IRL, I, LT, L, LR, M, NL, PL, P, R, S, SLO, SK ausgeliefert werden.

Produktdetails

• Verlag: Pearson ITP
• Seitenzahl: 352
• Erscheinungstermin: 17. Dezember 2021
• Englisch
• ISBN-13: 9780137579747
• Artikelnr.: 66915554

Autorenporträt

James W. Cooper holds a PhD in chemistry and worked in academia, for the scientific instrument industry, and for IBM for 25 years, primarily as a computer scientist at IBM's Thomas J. Watson Research Center. Now retired, he is the author of 20 books, including 3 on design patterns in various languages. His most recent books are Flameout: The Rise and Fall of IBM Instruments (2019) and Food Myths Debunked (2014).

James holds 11 patents and has written 60 columns for JavaPro Magazine. He has also written nearly 1,000 columns for the now vanished Examiner.com on foods and chemistry, and he currently writes his own blog: FoodScienceInstitute.com. Recently, he has written columns on Python for Medium.com and Substack.

He is also involved in local theater groups and is the treasurer for Troupers Light Opera, where he performs regularly.

Inhaltsangabe

Preface xxi
PART I: INTRODUCTION 1
The tkinter Library 2
GitHub 2
Chapter 1 Introduction to Objects 5
The Class __init__ Method 6
Variables Inside a Class 6
Collections of Classes 7
Inheritance 8
Derived Classes Created with Revised Methods 8
Multiple Inheritance 8
Drawing a Rectangle and a Square 10
Visibility of Variables 12
Properties 13
Local Variables 13
Types in Python 13
Summary 14
Programs on GitHub 15
Chapter 2 Visual Programming in Python 17
Importing Fewer Names 19
Creating an Object-Oriented Version 19
Using Message Boxes 21
Using File Dialogs 22
Understanding Options for the Pack Layout Manager 23
Using the ttk Libraries 24
Responding to User Input 25
Adding Two Numbers 26
Catching the Error 26
Applying Colors in tkinter 27
Creating Radio Buttons 27
Using a Class-Level Variable 30
Communicating Between Classes 30
Using the Grid Layout 30
Creating Checkbuttons 32
Disabling Check Boxes 32
Adding Menus to Windows 35
Using the LabelFrame 39
Moving On 40
Examples on GitHub 40
Chapter 3 Visual Programming of Tables of Data 41
Creating a Listbox 42
Displaying the State Data 44
Using a Combobox 46
The Treeview Widget 47
Inserting Tree Nodes 50
Moving On 51
Example Code on GitHub 51
Chapter 4 What Are Design Patterns? 53
Defining Design Patterns 54
The Learning Process 55
Notes on Object-Oriented Approaches 56
Python Design Patterns 57
References 57
PART II: CREATIONAL PATTERNS 59
Chapter 5 The Factory Pattern 61
How a Factory Works 61
Sample Code 62
The Two Subclasses 62
Building the Simple Factory 63
Using the Factory 63
A Simple GUI 64
Factory Patterns in Math Computation 65
Programs on GitHub 65
Thought Questions 66
Chapter 6 The Factory Method Pattern 67
The Swimmer Class 68
The Event Classes 69
Straight Seeding 70
Circle Seeding 71
Our Seeding Program 72
Other Factories 74
When to Use a Factory Method 74
Programs on GitHub 74
Chapter 7 The Abstract Factory Pattern 75
A GardenMaker Factory 75
How the User Interface Works 77
Consequences of the Abstract Factory Pattern 77
Thought Questions 78
Code on GitHub 78
Chapter 8 The Singleton Pattern 79
Throwing the Exception 80
Creating an Instance of the Class 80
Static Classes As Singleton Patterns 81
Finding the Singletons in a Large Program 81
Other Consequences of the Singleton Pattern 82
Sample Code on GitHub 82
Chapter 9 The Builder Pattern 83
An Investment Tracker 84
Calling the Builders 86
The List Box Builder 87
The Checkbox Builder 88
Displaying the Selected Securities 89
Consequences of the Builder Pattern 89
Thought Questions 89
Sample Code on GitHub 89
Chapter 10 The Prototype Pattern 91
Cloning in Python 91
Using the Prototype 92
Consequences of the Prototype Pattern 94
Sample Code on GitHub 94
Chapter 11 Summary of Creational Patterns 95
PART III: STRUCTURAL PATTERNS 97
Chapter 12 The Adapter Pattern 99
Moving Data Between Lists 99
Making an Adapter 101
The Class Adapter 103
Two-Way Adapters 103
Pluggable Adapters 103
Programs on GitHub 103
Chapter 13 The Bridge Pattern 105
Creating the User Interface 107
Extending the Bridge 108
Consequences of the Bridge Pattern 109
Programs on GitHub 110
Chapter 14 The Composite Pattern 111
An Implementation of a Composite 112
Salary Computation 112
The Employee Classes 112
The Boss Class 113
Building the Employee Tree 114
Printing the Employee Tree 114
Creating a Treeview of the Composite 116
Using Doubly Linked Lists 117
Consequences of the Composite Pattern 118
A Simple Composite 119
Other Implementation Issues 119
Dealing with Recursive Calls 119
Ordering Components 120
Caching Results 120
Programs on GitHub 120
Chapter 15 The Decorator Pattern 121
Decorating a Button 121
Using a Decorator 122
Using Nonvisual Decorators 123
Decorated Code 124
The dataclass Decorator 125
Using dataclass with Default Values 126
Decorators, Adapters, and Composites 126
Consequences of the Decorator Pattern 126
Programs on GitHub 127
Chapter 16 The Facade Pattern 129
Building the Façade Classes 131
Creating Databases and Tables 135
Using the SQLite Version 136
Consequences of the Façade 137
Programs on GitHub 137
Notes on MySQL 137
Using SQLite 138
References 138
Chapter 17 The Flyweight Pattern 139
What Are Flyweights? 139
Example Code 140
Selecting a Folder 142
Copy-on-Write Objects 143
Program on GitHub 143
Chapter 18 The Proxy Pattern 145
Using the Pillow Image Library 145
Displaying an Image Using PIL 146
Using Threads to Handle Image Loading 146
Logging from Threads 149
Copy-on-Write 149
Comparing Related Patterns 149
Programs on GitHub 150
Chapter 19 Summary of Structural Patterns 151
PART IV: BEHAVIORAL PATTERNS 153
Chapter 20 Chain of Responsibility Pattern 155
When to Use the Chain 156
Sample Code 156
The Listboxes 159
Programming a Help System 160
Receiving the Help Command 161
The First Case 162
A Chain or a Tree? 163
Kinds of Requests 164
Consequences of the Chain of Responsibility 164
Programs on GitHub 165
Chapter 21 The Command Pattern 167
When to Use the Command Pattern 167
Command Objects 168
A Keyboard Example 168
Calling the Command Objects 170
Building Command Objects 171
The Command Pattern 172
Consequences of the Command Pattern 172
Providing the Undo Function 172
Creating the Red and Blue Buttons 175
Undoing the Lines 175
Summary 176
References 176
Programs on GitHub 176
Chapter 22 The Interpreter Pattern 177
When to Use an Interpreter 177
Where the Pattern Can Be Helpful 177
A Simple Report Example 178
Interpreting the Language 179
How Parsing Works 180
Sorting Using attrgetter() 181
The Print Verb 182
The Console Interface 182
The User Interface 183
Consequences of the Interpreter Pattern 184
Programs on GitHub 185
Chapter 23 The Iterator Pattern 187
Why We Use Iterators 187
Iterators in Python 187
A Fibonacci Iterator 188
Getting the Iterator 189
Filtered Iterators 189
The Iterator Generator 191
A Fibonacci Iterator 191
Generators in Classes 192
Consequences of the Iterator Pattern 192
Programs on GitHub 193
Chapter 24 The Mediator Pattern 195
An Example System 195
Interactions Between Controls 197
Sample Code 198
Mediators and Command Objects 199
Consequences of the Mediator Pattern 200
Single Interface Mediators 200
Programs on GitHub 201
Chapter 25 The Memento Pattern 203
When to Use a Memento 203
Sample Code 204
Consequences of the Memento Pattern 209
Programs on GitHub 209
Chapter 26 The Observer Pattern 211
Example Program for Watching Colors Change 212
The Message to the Media 215
Consequences of the Observer Pattern 215
Programs on GitHub 215
Chapter 27 The State Pattern 217
Sample Code 217
Switching Between States 221
How the Mediator Interacts with the State
State Transitions 224
Programs on GitHub 224
Chapter 28 The Strategy Pattern 225
Why We Use the Strategy Pattern 225
Sample Code 226
The Context 227
The Program Commands 227
The Line and Bar Graph Strategies 228
Consequences of the Strategy Pattern 230
Programs on GitHub 231
Chapter 29 The Template Pattern 233
Why We Use Template Patterns 233
Kinds of Methods in a Template Class 234
Sample Code 234
Drawing a Standard Triangle 235
Drawing an Isosceles Triangle 236
The Triangle Drawing Program 237
Templates and Callbacks 238
Summary and Consequences 238
Example Code on GitHub 238
Chapter 30 The Visitor Pattern 239
When to Use the Visitor Pattern 239
Working with the Visitor Pattern 241
Sample Code 241
Visiting Each Class 242
Visiting Several Classes 242
Bosses Are Employees, Too 243
Double Dispatching 245
Traversing a Series of Classes 245
Consequences of the Visitor Pattern 245
Example Code on GitHub 245
PART V: A BRIEF INTRODUCTION TO PYTHON 247
Chapter 31 Variables and Syntax in Python 249
Data Types 250
Numeric Constants 250
Strings 250
Character Constants 251
Variables 252
Complex Numbers 253
Integer Division 253
Multiple Equal Signs for Initialization 254
A Simple Python Program 254
Compiling and Running This Program 255
Arithmetic Operators 255
Bitwise Operators 255
Combined Arithmetic and Assignment Statements 256
Comparison Operators 256
The input Statement 257
PEP 8 Standards 258
Variable and Function Names 258
Constants 258
Class Names 258
Indentation and Spacing 259
Comments 259
Docstrings 259
String Methods 260
Examples on GitHub 261
Chapter 32 Making Decisions in Python 263
elif is “else if” 263
Combining Conditions 264
The Most Common Mistake 264
Looping Statements in Python 265
The for Loop and Lists 265
Using range in if Statements 266
Using break and continue 266
The continue Statement 267
Python Line Length 267
The print Function 267
Formatting Numbers 268
C and Java Style Formatting 269
The format string Function 269
f-string Formatting 269
Comma-Separated Numbers 270
Strings 270
Formatting Dates 271
Using the Python match Function 271
Pattern Matching 272
Reference 273
Moving On 273
Sample Code on GitHub 273
Chapter 33 Development Environments 275
IDLE 275
Thonny 275
PyCharm 276
Visual Studio 276
Other Development Environments 276
LiClipse 276
Jupyter Notebook 277
Google Colaboratory 277
Anaconda 277
Wing 278
Command-Line Execution 278
CPython, IPython, and Jython 278
Chapter 34 Python Collections and Files 279
Slicing 279
Slicing Strings 280
Negative Indexes 281
String Prefix and Suffix Removal 281
Changing List Contents 281
Copying a List 282
Reading Files 282
Using the with Loop 283
Handling Exceptions 284
Using Dictionaries 284
Combining Dictionaries 286
Using Tuples 286
Using Sets 287
Using the map Function 287
Writing a Complete Program 288
Impenetrable Coding 288
Using List Comprehension 289
Sample Programs on GitHub 290
Chapter 35 Functions 291
Returning a Tuple 292
Where Does the Program Start? 292
Summary 293
Programs on GitHub 293
Appendix A Running Python Programs 295
If You Have Python Installed 295
Shortcuts 295
Creating an Executable Python Program 296
Command-Line Arguments 297
Index 299