python 类进一步使用

#coding=utf-8

#
#	进一步认识类
#	

#9-1 旧风格与新风格 类
class NewStyle(object):
	pass

class OldStyle:
	pass


#9-2 构造方法
__metaclass__ = type                    # 将类转换为新式类
class MyClass:
	def __init__(self):                #__init__ 构造函数， 默认
		self.nCount = 1

temp = MyClass()
print temp.nCount


#9-2-1 重写，特殊构造函数		
class MyClassCopy(MyClass):                 # 继承
	def __init__(self, num):                #__init__ 构造函数可以【重写】; 赋予值进行初始化
		self.nCount = num	

temp2 = MyClassCopy(123)
print temp2.nCount

#9-2-2调用超类构造方法
class MyClass2(MyClass):
	def __init__(self):
		MyClass.__init__(self)              # 调用父类初始化接口，进行绑定
		
temp = MyClass2()
print temp.nCount	

#9-2-3 super 函数
class MyClass3(MyClass):
	def __init__(self):
		super(MyClass3,self).__init__()        #= MyClass.__init__(self); 且 当前2.7版本； 
											   #使用super 父类 不允许用 class 类名（）:
	def show():
		print 'show func'
		
temp = MyClass3()
print temp.nCount		


#9-3 成员访问
def checkIndex(key):
	if not isinstance(key,(int, long)):raise TypeError
	if key < 0: raise IndexError

class ASequence:
	def __init__(self, start = 0, step = 1):
		'''
		func 说明
		
		'''
		
		self.start = start
		self.step = step
		self.changed = {}     # 未修改项
	def __getitem__(self, key):
		checkIndex(key)
		
		try: return self.changed[key]
		except KeyError:
			return self.start + key * self.step
	
	def __setitem__(self, key, values):
		checkIndex(key)
		self.changed[key] = values
		
s = ASequence(1,2)
print s[4]
print s.changed
s[4] = 2
print s[4]
print s[5]
#del s[4]                  #非法

#ep
class CList(list):
	def __init__(self, *arg):
		super(CList,self).__init__(*arg)
		self.count = 0
	def __getitem__(self, index):
		self.count += 1
		return super(CList,self).__getitem__(index)

c = CList(range(10))
print c
print c.reverse()
print c
del c[3:6]
print c
print c.count
print c[4] + c[2]
print c.count

#9-3 属性
#访问器
class Rgl:
	def __init__(self):
		self.w = 0
		self.h = 0
	def setSize(self, size):
		self.w, self.h = size
	def getSize(self):
		return self.w, self.h
	size = property(getSize, setSize)               # property 函数捆绑
self_Rg1 = Rgl()
self_Rg1.w = 10
self_Rg1.h = 20
print self_Rg1.getSize()
print self_Rg1.size
self_Rg1.size = 150, 200
print self_Rg1.size

#静态成员函数，类成员函数（舍弃self,使用cls）

class MyClass:
	def __init__(self):
		self.nCount = 'show init num'
	def show():                                     # 静态 无需 self, 
		print 'show'
	show = staticmethod(show)                       # 将函数弄成静态
	
	def test(cls, num):                             # cls 相当 self
		print '11233',cls.nCount, num
	test1 = classmethod(test)                       # 定义为成员函数

MyClass.show()                                       #可以直接调用
#MyClass.test()　　　　　　　　　　　　　　　　　　   # 不行
myC = MyClass()
myC.test(2)

# 第二种写法
class MyClass:
	def __init__(self):
		self.nCount = 'show init num'
		
	@staticmethod	
	def show():                                     
		print 'show'
	                  
	@classmethod
	def test(cls, num):                            
		print '11233',cls, num                        #怎么访问　成员变量？
		
MyClass.show()                                       #可以直接调用
#MyClass.test()　　　　　　　　　　　　　　　　　　   # 不行
myC = MyClass()
myC.test(2)	    

#9-3-1 拦截对象 所有特性访问

class MyR:
	def __init__(self):
		self.width = 0
		self.height = 0
	def __setattr__(self, name, value):               # 赋值时，自动调用 
		if name == 'size':
			self.width, self.height = value
		else:
			self.__dict__[name] = value
	def __getattr__(self, name):                     # 访问时，自动调用
		if name == 'size':
			return self.width, self.height
		else:
			raise AttributeError


# 9-4 迭代器
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

fib = Fibs()
for value in fib:             # 反复迭代 取值 调用 next 函数
	if value > 1000:
		print value     
		break
		
# ep 1
it = iter([1, 2, 3])
print it.next()
print it.next()
print it.next()             # 会越界，需要在next函数中进行判断
#print it.next()

# ep 2
class TestInt:
	value = 0
	def next(self):
		self.value += 10
		if self.value > 10:raise StopIteration
		return self.value
	def __iter__(self):
		return self
		
t = TestInt()
print list(t)

#9-5 生成器
nested = [[1,2], [3], [3, 4, 5], [7, 1100, -1]]
def flatten(arg):
	for sub in arg:
		for  ele in sub:
			yield ele             # 生成器

for num in flatten(nested):print num		

# 递归生成器
def flatten(arg):
	try:
		for sub in arg:
			for ele in sub:
				yield ele
	except TypeError:
		yield arg

print list(flatten(nested))

#ep		
def flatten(arg):
	try:
		try:
			arg + ''
		except TypeError:
			pass
		else:
			raise TypeError
		for sub in arg:
			for ele in sub:
				yield ele
	except TypeError:
		yield arg
		
print list(flatten(['qwe', 'llll', 'aaswq']))		

#通用生成器
def repeater(v):
	while True:		
		new = (yield v)		
		if new is not None:v = new		
		
r = repeater(42)
print r.next()
r.send('hhhh')		

# 八皇后
def conflict(state, nextX):                             # 判断位置是否冲突
	nextY = len(state)                                  #　@nextX 下一个位置
	for i in range(nextY):
		if abs(state[i] - nextX) in (0, nextY - i):     # 如果下一个皇后和正在考虑的前一个皇后的水平距离为0
			return True                                 # (列相等)；或者等于垂直距离 返回True
	return False
	
def queens(num, state):                                 # 根据其他皇后位置生成自己位置 
	if len(state) == num - 1:                           # @num: 皇后数量，state：存在前面皇后位置
		for pos in range(num):
			if not conflict(state, pos):
				yield pos
	else:
		for pos in range(num):
			if not conflict(state, pos):
				for result in queens(num, state + (pos,)):
					yield(pos,) + result
				

print list(queens(4, (1, 3, 0)))
		
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, )):
					yield (pos,) + result
					
print list(queens(3))
print list(queens(4))		
for solution in queens(8):
	print solution

print len(list(queens(8)))

#
def prettyprint(solution):
	def line(pos, length=len(solution)):
		return '. '*(pos) + 'X' + '. '*(length - pos - 1)
	for pos in solution:
		print line(pos)

import random
print prettyprint(random.choice(list(queens(8))))