Python编程思维：设计模式与问题解决

需积分: 22 144 浏览量更新于2024-07-26 收藏 831KB PDF 举报

《思考在Python：设计模式与问题解决技术》是Bruce Eckel编著的一套编程思想系列丛书中的一本，由Prentice Hall出版。本书专注于Python编程语言，并结合设计模式和问题解决策略，为程序员提供了一种全新的视角来理解和应用编程。在本书的开篇，作者首先介绍了"Y2K syndrome"（千年虫问题）的历史背景，以此引入编程实践中需要考虑的上下文和组件之间的协作。通过一个快速的Python编程入门课程，读者可以对Python有一个基本的认识，包括Python的概述、内置容器的使用、函数的定义、字符串操作以及类的概念。这部分旨在帮助读者建立起扎实的基础，理解Python的核心特性和编程范式。接下来，本书重点探讨了设计模式这一概念。设计模式是一种通用的解决方案，它描述了在特定情况下如何解决常见问题，使得代码更具可重用性、灵活性和清晰度。书中解释了什么是设计模式，包括模式的分类和范畴，如结构型模式（如单例模式）、行为型模式（如策略模式），以及设计原则（如单一职责原则和开闭原则）。随后，作者详细剖析了单例模式作为设计模式的一个实例，阐述其实现方式以及在不同场景中的应用。接着，章节转向如何根据问题类型对设计模式进行分类，强调了设计模式在软件开发过程中的挑战和实践技巧。第二部分，"单元测试"，提倡了测试驱动开发(TDD)的理念，即先编写测试再编写代码，以确保程序的质量。书中有指导性的内容，如如何编写简单的测试框架，区分白盒测试（关注代码内部逻辑）和黑盒测试（关注外部行为），以及如何自动化测试执行，这些都是现代软件工程中的重要实践。第三部分涉及构建应用程序框架，通过模板方法模式（Template Method）为例，展示了如何在高层抽象中定义算法流程，而将具体的实现细节留给子类。这部分内容有助于读者理解如何设计模块化和可扩展的架构。最后，第四部分讨论了如何通过代理（Proxy）和状态管理（State和StateMachine）来控制对象的行为和隐藏其复杂性。作者提供了如表驱动状态机的例子，展示如何通过状态转换表来管理状态机的逻辑，这在处理复杂的业务流程或游戏逻辑时非常实用。《Thinking in Python: Design Patterns and Problem-Solving Techniques》不仅教授了Python语言的使用，还深入浅出地讲解了设计模式的应用，为读者提供了解决实际编程问题的工具和思维方式。通过阅读这本书，程序员可以提升编程技能，学习到高效的问题解决策略，并且更好地组织和设计他们的代码。

Classes

Like everything else in Python, the definition of a class uses a minimum of

additional syntax. You use the class keyword, and inside the body you use

def to create methods. Here’s a simple class: Add Comment

#: c01:SimpleClass.py

class Simple:

def __init__(self, str):

print "Inside the Simple constructor"

self.s = str

# Two methods:

def show(self):

print self.s

def showMsg(self, msg):

print msg + ':',

self.show() # Calling another method

if __name__ == "__main__":

# Create an object:

x = Simple("constructor argument")

x.show()

x.showMsg("A message")

#:~

Both methods have “self” as their first argument. C++ and Java both have

a hidden first argument in their class methods, which points to the object

that the method was called for and can be accessed using the keyword

this. Python methods also use a reference to the current object, but when

you are defining a method you must explicitly specify the reference as the

first argument. Traditionally, the reference is called self but you could use

any identifier you want (if you do not use self you will probably confuse a

lot of people, however). If you need to refer to fields in the object or other

methods in the object, you must use self in the expression. However,

when you call a method for an object as in x.show( ), you do not hand it

the reference to the object – that is done for you. Add Comment

Here, the first method is special, as is any identifier that begins and ends

with double underscores. In this case, it defines the constructor, which is

automatically called when the object is created, just like in C++ and Java.

However, at the bottom of the example you can see that the creation of an

object looks just like a function call using the class name. Python’s spare

syntax makes you realize that the new keyword isn’t really necessary in

C++ or Java, either. Add Comment

All the code at the bottom is set off by an if clause, which checks to see if

something called __name__ is equivalent to __main__. Again, the

double underscores indicate special names. The reason for the if is that

any file can also be used as a library module within another program

(modules are described shortly). In that case, you just want the classes

defined, but you don’t want the code at the bottom of the file to be

executed. This particular if statement is only true when you are running

this file directly; that is, if you say on the command line: Add Comment

Python SimpleClass.py

However, if this file is imported as a module into another program, the

__main__ code is not executed. Add Comment

Something that’s a little surprising at first is that you define fields inside

methods, and not outside of the methods like C++ or Java (if you create

fields using the C++/Java style, they implicitly become static fields). To

create an object field, you just name it – using self – inside of one of the

methods (usually in the constructor, but not always), and space is created

when that method is run. This seems a little strange coming from C++ or

Java where you must decide ahead of time how much space your object is

going to occupy, but it turns out to be a very flexible way to program. Add

Comment

Inheritance

Because Python is weakly typed, it doesn’t really care about interfaces –

all it cares about is applying operations to objects (in fact, Java’s

interface keyword would be wasted in Python). This means that

inheritance in Python is different from inheritance in C++ or Java, where

you often inherit simply to establish a common interface. In Python, the

only reason you inherit is to inherit an implementation – to re-use the

code in the base class. Add Comment

If you’re going to inherit from a class, you must tell Python to bring that

class into your new file. Python controls its name spaces as aggressively as

Java does, and in a similar fashion (albeit with Python’s penchant for

simplicity). Every time you create a file, you implicitly create a module

(which is like a package in Java) with the same name as that file. Thus, no

package keyword is needed in Python. When you want to use a module,

you just say import and give the name of the module. Python searches

the PYTHONPATH in the same way that Java searches the CLASSPATH

(but for some reason, Python doesn’t have the same kinds of pitfalls as

Java does) and reads in the file. To refer to any of the functions or classes

within a module, you give the module name, a period, and the function or

剩余176页未读，继续阅读

txp914

粉丝: 22
资源: 702

Python编程思维：设计模式与问题解决

Thinking_In_Python

Thinking in python

[Bruce.Eckel编程思想系列丛书].PRENTICE-HALL-Thinking-In-Python-177ye

Python编程思想 [Bruce.Eckel编程思想系列丛书].Thinking_In_Python.pdf

[Bruce.Eckel编程思想系列丛书].part_04.rar

[Bruce.Eckel编程思想系列丛书].part_03.rar

[Bruce.Eckel编程思想系列丛书].part_01.rar

[Bruce.Eckel编程思想系列丛书].part_02.rar

PRENTICE_HALL-Thinking_In_Python.pdf

[Bruce.Eckel编程思想系列丛书]

最新资源