开发者社区> 技术小胖子> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

python之特殊方法、属性和迭代器

简介:
+关注继续查看

9.1 准备工作

class NewStyle(object)

more_code_here

class OldStyle:

more_code_here

在这两个类中,NewStyle是新式的类,OldStyle是旧式的类。如果文件以__metaclass__=type开始,那么两个类都是新式类。

除此之外,还可以在自己的类的作用域中对__metaclass__变量赋值。这样只会为这个类设定元类。元类是其他类的类-----这是个更高级的主题。


9.2 构造方法

当一个对象被创建后,会立即调用构造方法。

>>>f = FooBar()

>>>f.init()


构造方法能让它简化成如下形式:

>>>f = FooBar()


在python中创建一个构造方法很容易。只要把init方法的名字从简单的init修改为魔法版本__init__即可:

class FooBar:

def __init__(self):

self.somevar = 42

>>>f = FooBar()

>>>f.somevar

42


class FooBar():

def __init__(self,value=42)

self.somevar = value

>>>f = FooBar('This is a constructor argument')

>>>f.somevar

'This is a constructor argument'


python中有一个魔法方法叫做__del__,就是析构方法。它在对象就要被垃圾回收之前调用,但发生调用的具体时间是不可知的,所以建议读者尽力避免使用__del__函数。


9.2.1 重写一般方法和特殊的构造方法

如果一个方法在B类的一个实例中被调用,但在B类中没有找到该方法,那么就会去它的超类A里面找。

class A:

def hello(self):

print "hello,I'm A."

class B(A):

pass


A类 定义了一个叫做hello的方法,被B类继承。下面是一个说明类是如何工作的例子:

>>>a = A()

>>>b = B()

>>>a.hello()

hello,I'm A.

>>>b.hello()

hello,I'm A


因为B类没有定义自己的hello方法,所以当hello被调用时,原始的信息就被打印出来。

在子类中增加功能的最基本的方式就是增加方法。但是也可以重写一些超类的方法来自定义继承的行为。B类也能重写这个方法。比如下面的例子中B类的定义被修改了。

class B(A):

def hello(self):

print "hello,I'm B."

使用这个定义,b.hello()能产生一个不同的结果。

>>>b = B()

>>>b.hello()

hello,I'm B.

虽然重写的机制对于所有方法来说都是一样的,但是当处理构造方法比重写普通方法时,更可能遇到特别的问题:如果一个类的构造方法被重写,那么就需要调用超类的构造方法,否则对象可能不会被正确地初始化。

class Bird:

def __init__(self):

self.hungry = True

def eat(self):

if self.hungry:

print 'Aaaah...'

self.hungry = False

else:

print 'No,thanks!'

这个类定义所有的鸟都具有的一些最基本的能力:吃,用法示例;

>>>b = Bird()

>>>b.eat()

Aaaah...

>>>b.eat()

No,thanks!


就像能在这个例子中看到的,鸟吃过了以后,它就不再饥饿。为子类SongBird,它添加了唱歌的行为。

class SongBird(Bird):

def __init__(self):

self.sound = 'Squawk!'

def sing(self):

print self.sound

SongBird类和Bird类一样容易使用:

>>>sb = SongBird()

>>>sb.sing()

Squawk!


因为SongBird是Bird的一个子类,它继承了eat方法,但如果调用eat方法,就会产生一个问题:

>>>sb.eat()

报错


异常很清楚地说明了错误:SongBird没有hungry特性。原因是这样的:在SongBird中,构造方法被重写,但新的构造方法没有任何关于初始化hungry特性的代码。为了达到预期的效果,SongBird的构造方法必须调用其超类Bird的构造方法来确保进行基本的初始化。有两种方法能达到这个目的:调用超类构造方法的未绑定版本,或者使用super函数。


9.2.2 调用未绑定的超类构造方法


9.2.3 使用super函数

只能在新式类使用super函数。当前的类和对象可以作为super函数的参数使用,调用函数返回的对象的任何方法都是调用超类的方法,而不是当前类的方法。那么就可以不用再SongBird的构造方法中使用Bird,而直接使用super(SongBird,self)。除此之外__init__方法能以一个普通的绑定方式被调用。


在python3.0 super函数可以不用任何参数进行调用。

下面的例子是对bird例子的更新。

__metaclass__ = type

class Bird:

def __init__(self):

self.hungry = True

def eat(self):

if self.hungry:

print 'Aaaah...'

self.hungry = False

else:

print 'No,thanks!'

class SongBird(Bird):

def __init__(self):

super(SongBird,self).__init__()

self.sound = 'Squawk!'

def sing(self):

print self.sound

>>>sb = SongBird()

>>>sb.sing()

Squawk!

>>>sb.eat()

Aaaah...

>>>sb.eat()

No,thanks


9.3 成员访问

规则:它是管理某种形式的行为的规则


9.3.1 基本的序列和映射规则

序列和映射是对象的集合。为了实现它们基本的行为(规则),如果对象是不可变的,那么就需要使用两个魔法方法,如果是可变的则需要使用4个。


1.__len__(self):这个方法应该返回集合中所含项目的数量。对于序列来说,这就是元素的个数;对于映射来说,则是键-值对得数量。如果__len__返回0(并且没有实现重写该行为的__nonzero__),对象会被当作一个布尔变量中的假值(空的列表,元组,字符串和字典一样)进行处理。


2.__getitem__(self,key):这个方法返回与所给键对应的值。对于一个序列,键应该是一个0~n-1的整数(或者像后面所说的负数),n是序列的长度;对于映射来说,可以使用任何种类的键。


3.__setitem__(self,key,value):这个方法应该按一定的方式存储和key相关的value,该值随可使用__getitem__来获取。当然,只能为可以修改的对象定义这个方法。


4.__delitem__(self,key):这个方法对一部分对象使用del语句时被调用,同时必须删除和元素相关的建。这个方法也是为可修改的对象定义的(并不是删除全部的对象,而只删除一些需要移除的元素)。


对这些方法的附加要求:

1.对于一个序列来说,如果键是负整数,那么要从末尾开始计数。换句话说就是x[-n]和x[len(x)-n]是一样的;

2.如果键是不适合的类型(例如,对序列使用字符串作为键),会引发一个TypeError异常;

3.如果序列的索引是正确的类型,但超出了范围,应该引发一个IndexError异常。


创建一个无穷序列:

def checkIndex(key):

if not isinstance(key),(int,long): raise TypeError

if key<0: raise IndexError

#键应该是一个非负整数

class ArithmeticSequence:

def __init__(self,start=0,step=1):

self.start = start   #序列中第一个值

self.step = step     #步长----两个相邻值之间的差别

self.changed = {}    #改变----用户修改的值的字典

#初始化算术序列

def __getitem__(self,key):

Get an item from the arithmetic sequence.

checkIndex(key)

try: return self.changed[key]       #修改了么

except KeyError:                    #否则。。。。

return self.start + key*self.step  #。。。。。计算值

def __setitem__(self,key,value):

#修改算术序列中的一个项

checkIndex(key)

self.changed[key] = value  #保存更改后的值

这里实现的是一个算术序列,该序列中的每个元素都比它前面的元素大一个常数。第一个值是由构造方法参数start(默认为0)给出的,而值与值之间的步长是由step设定的(默认为1)。用户能通过名为changed的方法将特例规则保存在字典中,从而修改一些元素的值,如果元素没有被修改,那就计算self start+key* step的值。

>>>s = ArithmeticSequence(1,2)

>>>s[4]

9

>>>s[4] = 2

>>>s[4]

2

>>>s[5]

11


注意,没有实现__del__方法的原因是我希望删除元素是非法的:

>>>del s[4]

报错


这个类没有__len__方法,因为它是无限长的。

如果使用了一个非法类型的索引,就会引发TypeError异常,如果索引的类型是正确的但超出了范围,则会引发IndexError异常:

>>>s["four"]

报错

>>>s[-42]

报错


索引检查是通过用户自定义的checkIndex函数实现的。


9.3.2 子类化列表,字典和字符串

如果希望实现一个和内建列表行为相似的序列,可以使用子类list。

当子类化一个内建类型----比如list的时候,也就间接的将object子类化了,因此类就自动成为新式类,这就意味着可以使用像super函数这样的特性了。

带有访问计数的列表

class CounterList(list):

def __init__(self,*args):

super(CounterList,self).__init__(*args)

self.counter = 0

def __getitem__(self,index):

self.counter += 1

return super(CounterList,self).__getitem__(index)

CounterList类严重依赖它的子类化超类的行为。CounterList类没有重写任何的方法(和append,extend,index一样)都能被直接使用。在两个被重写的方法中,super方法被用来调用相应的超类的方法,只在__init__中添加了所需的初始化counter特性的行为,并在__getitem__中更新了counter特性。


CounterList如何使用的例子

>>>c1 = CounterList(range(10))

>>>c1

[0,1,2,3,4,5,6,7,8,9]

>>>c1.reverse()

>>>c1

[9,8,7,6,5,4,3,2,1,0]

>>>del c1[3:6]

>>>c1

[9,8,7,3,2,1,0]

>>>c1.counter

0

>>>c1[4] + c1[2]

9

>>>c1.counter

2

正如看到的,CounterList在很多方面和列表的作用一样,但它有一个counter特性,每次列表元素被访问时,它都会自增,所以在执行家法c1[4] + c1[2],这个值自增两次,变为2.


9.5 属性

访问器是一个简单的方法,它能够使用getHeight、setHeight这样的名字来得到或者重绑定一些特性。

class Rectangle:

def __init__(self):

self.width = 0

self.height = 0

def setSize(self,size):

self.width,self.height = size

def getSize(self):

return self.width,self.height

>>>r = Rectang()

>>>r.width = 10

>>>r.height = 5

>>>r.getSize()

(10,5)

>>>r.setSize((150,100))

>>>r.width

150


python能隐藏访问器方法,让所有特性看起来一样。这些通过访问器定义的特性被称为属性。


9.5.1 property函数

property函数的使用很简单。如果已经编写了一个像上节的Rectangle那样的类,那么只要增加一行代码(子类化object,或者使用__metaclass__=type语句):

__metaclass__=type

class Rectangle:

def __init__(self):

self.width =0 

self.height = 0

def setSize(self,size):

self.width,self.height = size

def getSize(self):

return self.width,self.height

size = property(getSize,setSize)

在这个新版的Rectangle中,property函数创建了一个属性,其中访问器函数被用作参数(先是取值,然后是赋值),这个属性命为size。这样一来就不再需要担心是怎么实现的了,可以用同样的方式处理width、height和size。

>>>r = Rectangle()

>>>r.width = 10

>>>r.height = 5

>>>r.size

(10,5)

>>>r.size = 150,100

>>>r.width

150

很明显,size特性仍然取决于getSize和setSize中的计算。但它们看起来就像普通的属性一样。

如果属性的行为很奇怪,那么要确保你所使用的类为新式类;如果不是的话,虽然属性的取值部分还是可以工作,但赋值部分就不一定了。


实际上,property函数可以用0,1,2,3或者4个参数来调用。如果没有参数,产生的属性既不可读,也不可写。如果只使用一个参数调用(一个取值方法),产生的属性是只读的,第三个参数是可选是一个用于删除特性的方法。第四个参数可选是一个文档字符串。property的4个参数分别被叫做fget、fset、fdel和doc--,如果想要一个属性是只写的,并且有一个文档字符串,能使用它们作为关键字参数。

9.5.2 静态方法和类成员方法

静态方法和类成员方法分别在创建时分别被装入Staticmethod类型和Classmethod类型的对象中。静态方法的定义没有self参数,且能够被类本身直接调用。类方法在定义时需要名为cls的类似于self的参数,类成员方法可以直接用类的具体对象调用。但cls参数是自动被绑定到类的:

__metaclass__ = type

class MyClass:

def smeth():

print 'This is a static method'

smeth = staticmethod(smeth)

def cmeth(cls):

print 'This is a class method of',cls

cmeth = classmethod(cmeth)

    手动包装和替换方法的技术看起来有点单调。python 2.4中,为这样的包装方法引入了一个叫做装饰器的新语法。使用@操作符,在方法的上方将装饰器列出,从而指定一个或者更多的装饰器。

__metaclass__ = type

class Myclass:

@staticmethod

def smeth():

print 'This is a static method'

@classmethod

def cmeth(cls):

print 'This is a class method of',cls

定义了这些方法后,就可以像下面的例子那样使用:

>>>MyClass.smeth()

This is a static method

>>>MyClass.cmeth()

This is a class method of <class '__main__.MyClass'>

静态方法和类成员方法在python中并不是向来很重要,主要的原因时大部分情况不可以使用函数或者绑定方法代替。在早期的版本中没有得到支持也是一个原因。但即使看不到两者在当前代码中的大量应用,也不要忽视静态方法和类成员方法的应用。


9.5.3 __getattr__ setattr__和它的朋友们

拦截对象的所有特性访问时可能的,这样可以用旧式类实现属性。为了在访问特性的时候可以执行代码,必须使用一些魔法方法。

1.__getattribute__(self,name):当特性name被访问时自动调用。

2.__getattr__(self,name):当特性name被访问且对象没有相应的特性时被自动调用。

3.__setattr__(self,name,value):当试图给特性name赋值时会被自动调用。

4.__delattr__(self,name):当试图删除特性name时被自动调用。

尽管和使用property函数相比有点复杂(而且在某些方面效率更低),但这些方法是很强大的,因为可以对处理很多属性的方法进行再编码。

下面还是Rectangle的例子,但这次使用的是特殊方法:

class Rectangle:

def __init__(self):

self.width = 0

self.heigth = 0

def __setattr__(self,name,value):

if name == 'size':

self.width , self.heigth = value

else:

self.__dict_[name] = value

def __getattr__(self,name)

if name == 'size':

return self.width , self.heigth

else:

raise AttributeError

这个版本的类需要注意增加的管理细节。当思考这个例子时,下面的亮点应该引起读者的重视:

1.__setattr__方法在所涉及到的特性不是size时也会调用。因为,这个方法必须把两方面都考虑进去:如果属性是size,那么就像前面那样执行操作,否则就要使用特殊方法__dict__,该特殊方法包含一个字典,字典里面所有实例的属性。为了避免__setarrt__方法被再次使用,__dict__方法被用来代替普通的特性赋值操作。

2.__getattr__方法只在普通的特性没有被找到的时候调用,这就是说如果给定的名字不是size,这个特性不存在,这个方法会引发一个AttributeError异常。如果希望类和hasattr或者是getattr这样的内建函数一起正确地工作,__getattr__方法就很重要。如果使用的时size属性,那么就会使用在前面的实现中找到的表达式。


就像死循环陷阱和__setattr__有关系一样,还有一个陷阱和__getattribute__有关系。因为__getattribute__拦截所有特性的访问,也拦截对__dict__的访问!访问__getattribute__中与Self相关的特性时,使用超类的__getattribute__方法是唯一安全的途径。


9.6 迭代器

9.6.1 迭代器规则

迭代的意思是重复做一些事很多次------就像在循环中做得那样。到现在为止只是在for循环中对序列和字典进行迭代,但实际上也能对其他的对象进行迭代:实现__iter__方法的对象。

__iter__方法返回一个迭代器,所谓的迭代器就是具有next方法(这个方法在调用时不需要任何参数)的对象。在调用next方法时,迭代器会返回它的下一个值。如果next方法被调用,但迭代器没有值可以返回,就会引发一个StopIteration异常。


迭代器规则在python 3.0 中有一些变化,在新的规则中,迭代器对象应该实现__next__方法,而不是next,而新的内建函数next可以用于访问这个方法。换句话说,next(it)等同于3.0之前版本中的it.next()


这里的列表是一个斐波那契数列。使用迭代器如下:

class Fibs:

def __init__(self):

self.a = 0

self.b = 1

def next(self):

self.a , self.b = self.b , self.a+self.b

return self.a

def __iter__(self):

return self

注意,迭代器实现了__iter__方法,这个方法实际上返回迭代器本身。在很多情况下,__iter__会放到其他的会在for循环中使用的对象中。这样一来,程序就能返回所需的迭代器。此外,推荐使迭代器实现它自己的__iter__方法,然后就能直接在for循环中使用迭代其本身。

正式的说法是,一个实现了__iter__方法的对象是可迭代的,一个实现了next方法的对象则是迭代器。

首先 产生一个Fibs对象:

>>>fibs = Fibs()

可在for循环中使用该对象----比如去查找在斐波那契数列中比1000大的数中的最小的数:

>>>for f in fibs:

if f > 1000:

print f

break

...

159

因为设置了break,所以循环在这里停止了,否则循环会一直继续下去。


内建函数iter可以从可迭代的对象中获得迭代器。

>>>it = iter([1,2,3])

>>>it.next()

1

>>>it.next()

2


9.6.2 从迭代器得到序列

除了在迭代器和可迭代对象上进行迭代外,还能把它们转换成序列。在大部分能使用序列的情况下,能使用迭代器替换。关于这个的一个很有用的例子是使用list构造方法显式的将迭代器转化为列表。

>>>class TestIterator

value = 0 

def next(self):

self.value += 1

if self.value > 10: raise StopIteration

return self.value

def __iter__(self)

return self

...

>>>ti = TestIterator()

>>>list(ti)

[1,2,3,4,5,6,7,8,9,10]


9.7 生成器

生成器是一种用普通的函数语法定义的迭代器.

nested = [[1,2],[3,4],[5]]


def flatten(nested):

for sublist in nested:

for element in sublist:

yield element

首先迭代提供的嵌套列表中的所有子列表,然后按顺序迭代子列表中的元素.如果最后一行是print element的话,那么就容易理解力.


任何包含yield语句的函数称为生成器.除了名字不同以外,它的行为和普通的函数也有很大的差别,这就在于它不是像return那样返回值,而是每次产生多个值.每次产生一个值,函数就会被冻结:即函数停在那点等待被激活.函数被激活后就从停止的那点开始执行.


通过在生成器上迭代来使用所有的值.

>>>nested = [[1,2],[3,4],[5]]

>>>for num in flatten(nested):

print num

...

1

2

3

4

5


or


>>>list(flatten(nested))

[1,2,3,4,5]


循环生成器

生成器推导式和列表推导式的工作方式类似,只不过返回的不是列表而是生成器,所返回的生成器允许你像下面这样一步一步地进行计算:

>>>g = ((i+2)**2 for i in range(2,27))

>>>g.next()

16


和列表推导式不同的就是普通圆括号的使用方式,在这样简单的例子中,还是推荐大家使用列表推导式.

生成器推导式可以在当前的圆括号直接使用,例如在函数调用中,不用增加另外一对圆括号,换句话说,可以像下面这样编写代码:

sum(i**2 for i in range(10))


9.7.2 递归生成器

def flatten(nested)

try:

for sublist in nested:

for element in flatten(sublist:)

yield element

except TypeError:

yield nested

当flatten被调用时,有两种可能性:基本情况和需要递归的情况。在基本的情况中,函数被告知展开一个元素,这种情况下,for循环会引发一个TypeError异常,生成器会产生一个元素。

如果展开的是一个列表,那么就要进行特殊处理。程序必须遍历所有的子列表,并对它们调用flatten。然后使用另一个for循环来产生被展开的子列表中的所有元素。

>>>list(flatten([[[1],2],3,4,[5,[6,7]],8]))

[1,2,3,4,5,6,7,8]

这么做只有一个问题:如果nested是一个类似于字符串的对象,那么它就是一个序列,不会引发TypeError,但是你不想对这样的对象进行迭代。


不应该在flatten函数中对类似于字符串的对象进行迭代,出于两个主要的原因。首先,需要实现的是将类似于字符串的对象当成原子值,而不是当成应被展开的序列。其次,对它们进行迭代实际上会导致无穷递归,因为一个字符串的第一个元素是另一个长度为1的字符串,而长度为1的字符串的第一个元素就是字符串本身。


为了处理这种情况,则必须在生成器的开始处添加一个检查语句。试着将传入的对象和一个字符串拼接,看看会不会出现TypeError,这是检查一个对象是不是似类于字符串的最简单、最快速的方法。下面是加入了检查语句的生成器:

def flatten(nested):

try:

try: nested+ ''

except TypeError:pass

else:raise TypeError

for sublist in nested:

for element in flatten(sublist):

yield element

except TypeError:

yield nested

如果表达式nested+ 引发了一个TypeError,它就会被忽略。然而如果没有引发TypeError,那么内层try语句中的else子句就会引发一个它自己的TypeError异常。这就会按照原来的样子生成类似于字符串的对象。

>>>list(flatten({'foo',['bar',['baz']]]))

['foo','bar','baz']

上面的代码没有执行类型检查.这里没有测试nested是否是一个字符串,而只是检查nested的行为是不是像一个字符串.


9.7.3 通用生成器

生成器是一个包含yield关键字的函数.当它被调用时,在函数体中的代码不会被执行,而会返回一个迭代器.每次请求一个值,就会执行生成器中德代码,直到遇到一个yield或者return语句.yield语句意味着应该生成一个值.return语句意味着生成器要停止执行.换句话说,生成器是两部分组成:生成器的函数和生成器的迭代器.生成器的函数是def语句定义的,包含yield的部分,生成器的迭代器是这个函数返回的部分.按一种不是很准确的说法,两个实体经常被当作一个,合起来叫做生成器.

>>>def simple_generator():

yield 1

>>>simple_generator

<function simple_generator at 153b44>

>>>simple_generator()

<generator object at 1510b0>


生成器的函数返回的迭代器可以像其他的迭代器那样使用.


9.7.4 生成器方法

生成器的新属性是在开始运行后卫生成器提供值得能力.表现为生成器和"外部世界"进行交流的渠道,要注意下面两点.

1.外部作用域访问生成器的send方法,就像访问next方法一样,只不过前者使用一个参数

2.在内部则刮起生成器,yield现在作为表达式而不是语句使用,换句话说,当生成器重新运行的时候,yield方法返回一个值,也就是外部通过send方法发送的值.如果next方法被使用,那么yield方法返回None.

注意,使用send方法只有在生成器挂起之后才有意义,如果在此之前需要给生成器提供更多信息,那么只需使用生成器函数的参数.

def repeater(value):

while True:

new = (yield value)

if new is not None: value = new

使用方法如下:

r = repeater(42)

r.next()

42

r.send("Hello,world!")

"Hello,world!"


注意看yield表达式周围的括号的使用.虽然并未严格要求,但在使用返回值得时候,安全起见还是要闭合yield表达式.

生成器还有其他两种方法:

1.throw方法用于在生成器内引发一个异常

2.close方法用于停止生成器

close方法也是建立在异常的基础上的.他在yield运行处引发一个GeneratorExit异常,所以如果需要在生成器内进行代码清理的话,则可以将yield语句放在try/finally语句中.如果需要的话,还可以捕捉GeneratorExit异常,但随后必需将其重新引发,引发另外一个异常或者直接返回.试着在生成器的close方法被调用后再通过生成器生成一个值则会导致RuntimeError异常.


9.7.5 模拟生成器

如何使用普通的函数模拟生成器。

先从生成器的代码开始。首先将下面语句放在函数体的开始处:

result = []

如果代码已经使用了result这个名字,那么应该用其他名字代替,然后将下面这种形式的代码

yield some_expression

用下面的语句替换:

result.append(some_expression)

最后,在函数的末尾,添加下面这条语句:

return  result

尽管这个版本可能不适用于所有生成器,但对大多数生成器来说是可行的。

flatten生成器用普通的函数重写的版本

def flatten(nested):

result = []

try:

try: nested + ''

except TypeError:pass

else:raise TypeError

for sublist in nested:

for element in flatten(sublist):

result.append(element)

except TypeError:

result.append(nested)

return result


9.8 八皇后问题

9.8.1 生成器和回溯

生成器是逐渐产生结果的复杂递归算法的理想实现工具。

def conflict(state,nextX):

nextY = len(state)

for i in range(nextY):

if abs(state[i]-nextX) in (0,nextY-i):

return True

return False

参数nextX代表下一个皇后的水平位置(x坐标或列),nextY代表垂直位置(y坐标或行)。这个函数对前面的每个皇后的位置做一个简单的检查,如果下一个皇后和前面的皇后有同样的水平位置,或者是在一条对角线上,就会发生冲突,接着返回True。如果没有这样的冲突发生,那么返回False,不太容易理解的是下面的表达式:

abs(state[i]-nextX) in (0,nextY-i):

如果下一个皇后和正在考虑的前一个皇后的水平距离为0或者等于垂直距离就返回True,否则就返回False。


9.8.5 基本情况

从基本的情况开始:最后一个皇后。你想让它做什么?假设你想找出所有可能的解决方案;

这样一来,它能根据其他的皇后位置生成它自己能占据的所有位置。能把这样的情况直接描绘出。

def queens(num,state):

if len(state) == num-1:

for pos in range(num):

if not conflict(state,pos):

yield pos

用人类的语言来描述,它的意思是:如果只剩一个皇后没有位置,那么遍历它所有的可能的位置,并且返回没有冲突发生的位置。num参数是皇后的总数。state参数是存放前面皇后的位置信息的元组。假设有4个皇后,前3个分别被放置在1,3,0号位置。

>>>list(queens(4,(1,3,0)))

[2]


9.8.6  需要递归的情况

...

else:

for pos in range(num):

if not conflict(state,pos):

for result in queens(num,state + (pos))

yield(pos)+result

for pos和if not conflice部分和前面的代码相同。添加一些默认的参数:

def queens(num=8,state()):

for pos in range(num):

if not conflict(state,pos):

if len(state) == num-1:

yield(pos,)

else:

for result in queens(num,state+ (pos,)):

yiled(pos) + result

生成器queens能给出所有的解决方案

>>>list(queens(3))

[]

>>>list(queens(4))

[(1,3,0,2),(2,0,3,1)]

>>>for solution in queens(8):

print solution

...

(0,4,7,5,2,6,1,3)

(0,5,7,2,6,3,1,4)

...


如果用8个皇后做参数来运行queens。

>>>len(list(queens(8)))

92


9.8.7 打包

def prettyprint(solution):

def line(pos,length=len(solution));

return '. ' * pos + 'X ' + '. ' * (length-pos-1)

for pos in solution:

print line(pos)

注意prettyprint中创建了一个小的助手函数。之所以将其放在prettyprint内,是因为我们假设在外面的任何地方都不会用到它。下面打印出一个令我满意的随机解决方案。可以看到该方案是正确的。

>>>import random

>>>prettyprint(random.choice(list(queens(8))))



      本文转自潘阔 51CTO博客,原文链接http://blog.51cto.com/pankuo/1661443:,如需转载请自行联系原作者




版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Python编程:实现tail-n查看日志文件
Python编程:实现tail-n查看日志文件
6 0
Python编程:heapq模块堆排序
堆是一个二叉树,其中每个父节点的值都小于或等于其所有子节点的值。 整个堆的最小元素总是位于二叉树的根节点。 python的heapq模块提供了对堆的支持。 堆数据结构最重要的特征是heap[0]永远是最小的元素
9 0
Python编程:MySQLdb模块对数据库的基本增删改查操作
Python编程:MySQLdb模块对数据库的基本增删改查操作
10 0
Python编程:heapq模块堆排序
Python编程:heapq模块堆排序
10 0
Python编程:paramiko模块远程登录
Python编程:paramiko模块远程登录
16 0
Python编程:traceback模块
Python编程:traceback模块
20 0
Python编程:itertools模块
Python编程:itertools模块
13 0
Python编程:flask-cors模块解决Flask跨域请求Cross-Origin问题
Python编程:flask-cors模块解决Flask跨域请求Cross-Origin问题
135 0
Python编程:os模块
Python编程:os模块
62 0
21114
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载