Python编程与设计模式探索：Bruce Eckel的思考与实践指南

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

《Thinking in Python: Design Patterns and Problem-Solving Techniques》是Bruce Eckel编著的一本面向程序员的编程思想系列丛书，由Prentice Hall出版。这本书主要聚焦于Python编程语言，并深入探讨了设计模式和问题解决策略。作者 Bruce Eckel，作为MindView, Inc. 的总裁，强调了在编程实践中理解和应用这些设计理念的重要性。书中的内容分为几个部分： 1. **序言**：对书籍的整体目标和结构进行介绍，可能包括作者的意图、背景以及读者群体的预期收获。 2. **引言**：探讨了Y2K问题，这是一个历史性的编程挑战，通过这个问题引入了软件设计和架构的话题，展示了在面对复杂问题时如何思考和设计解决方案。 3. **快速Python入门**：这部分为已有编程经验的读者提供一个Python语言的基础概览，包括内置容器（如列表、元组和字典）、函数、字符串处理以及类的概念。 4. **设计模式与概念**：详细解释了什么是设计模式，它是一种解决常见问题的可重用方案，通过分类（如创建型、行为型、结构型等）和设计原则（如单一职责、开闭原则等）来理解它们。 - **单例模式**：展示了如何利用设计模式实现对象实例的唯一性，确保在整个程序中只有一个实例可用。 - **模式分类与开发挑战**：引导读者理解不同类型的模式，以及如何根据具体项目需求选择和应用合适的模式，同时强调了模式在实际开发过程中的挑战和适应性。 5. **单元测试**：这部分着重介绍了编写测试驱动的编程方法，提倡先编写测试再编写代码。讲解了简单的Python测试框架，区分白盒测试（了解内部实现）和黑盒测试（关注功能），以及如何执行和自动化测试流程。 6. **构建应用程序框架**：涵盖了设计模式在框架设计中的应用，如模板方法模式，提供了练习机会让读者实践这些设计模式。 7. **接口与代理**：介绍代理模式，以及状态机和基于表的状态机，展示了如何用这些模式处理复杂的业务逻辑，例如简单的自动售货机示例。通过这本书，读者不仅能学习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页未读，继续阅读

刘华世(Moments)

粉丝: 26
资源: 32

Python编程与设计模式探索：Bruce Eckel的思考与实践指南

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

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

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

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

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

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

PRENTICE_HALL-Thinking_In_Python.pdf

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

Bruce.Eckel编程思想

Thinking.In.C++.Second Edition.Volume 1.Prentice.Hall.Bruce.Eckel.pdf

最新资源