Python编程思想：设计模式与问题解决技术

需积分: 5 156 浏览量更新于2024-06-25 收藏 833KB PDF 举报

《Bruce.Eckel编程思想系列丛书》中的《Thinking in Python: Design Patterns and Problem-Solving Techniques》是Bruce Eckel编著的一本书，针对Python编程语言深度探讨了设计模式和问题解决策略。作者是MindView, Inc.的总裁，这本书在发布时仍处于初级阶段，但包含丰富的内容，适合程序员快速掌握Python。该书分为三个主要部分： 1. **引言**：提供了一个背景介绍，提到了"Y2K syndrome"（千禧年问题），即对2000年日期转换可能引发的问题的关注，以此强调软件设计的重要性。书中还强调了Python在编程中的应用，以及对程序员的一门速成课程。 2. **单元测试**：这部分着重于单元测试的重要性，提倡先编写测试再编写代码（TDD，Test-Driven Development）。书中讲解了如何使用简单的Python测试工具，区分白盒测试（基于源代码内部结构）和黑盒测试（关注功能输入输出）。此外，还有如何执行测试、自动化测试执行以及配套的练习。 3. **构建应用框架**：深入讨论了模板方法（Template Method）设计模式，这是一种控制类的行为但允许子类重写某些步骤的设计策略。此外，书中还涉及了代理（Proxy）、状态（State）和状态机（StateMachine）等设计模式的应用，以及一个简单的自动售货机示例来展示这些概念的实际操作。 4. **面向实现的抽象**：这部分指导读者如何为实现提供前端接口，通过Proxy模式处理对底层代码的访问，以及使用状态机管理复杂状态变化。作者通过实例演示如何将这些设计模式应用于实际场景。在整个过程中，书中不断阐述设计模式的概念，包括模式的定义、分类以及它们遵循的设计原则，如单一职责原则（Single Responsibility Principle）和开闭原则（Open-Closed Principle）。通过这些内容，读者不仅能掌握Python编程技巧，还能学习到如何运用设计模式提高代码质量和可维护性。《Thinking in Python》是一本结合实践与理论的编程指南，对于理解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页未读，继续阅读

weixin_40191861_zj

粉丝: 85
资源: 1万+

Python编程思想：设计模式与问题解决技术

Bruce-Eckel---Thinking-in-Python.rar_thinking in python

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

thinking in python 编程思想

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

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

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

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

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

Bruce.Eckel编程思想

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

最新资源