python 面向对象 入门

#coding=utf-8

#
#python class
#

#7-1
#【多态】不同对象使用相同操作（函数）
#【封装】对外部隐藏对象工作细节
#【继承】对基础的类进行扩展

#检查对象类型 -----isinstance(对象, 类型)
object = [1,]
obj2 = {1:'name', 2:'name2'}
print isinstance(object, tuple)           # tuple 指？
print isinstance(object, dict)            # dict  指？

#7-1-1多态
print object.count(1)                     # 不同对象，相同接口
print '1234'.count('3')

print type(object)
#print issubclass(object,)

#7-1-2封装

#7-1-3继承
#可以覆盖基类函数，


#7-2类
# 类   名词 
# 方法 动词
# 特性 变量

# 子类，超类

class Person:
	def __init__(self, name = 'who'):   # 构造函数
		self.__name = name
		print 'init func'
	def __del__(self):                   # 析构函数
		print 'del func'
		del self.__name
	def __setName(self, name):
		self.__name = name
	def setName(self, name):
		self.__setName(name)	
	def getName(self):
		return self.__name
	__name = "None Name"               #函数或变量__ 两个下划线修饰 表示 私有变量

g_person = Person('java')
#print g_person.__name
print g_person.getName()              # 实例.方法
#g_person.__setName("123")            #私有成员函数，会报错	
g_person.setName("123")               # 公有 不会报错
print g_person.getName()
del Person

#7-2-1 特性、函数和方法
#方法与函数的区别，在于self参数；self绑定到这个函数
#方法 类的函数


#7-4 类的命名空间
foo = lambda x: x*x
def foo(x): return x*x

class Class:
	#print 'init Class'
	nCount = 0
	def init(self):
		Class.nCount += 1          #直接用原版 变量进行处理
	
print "show copy"
m1 = Class()
m1.init()
print m1.nCount
print Class.nCount
m2 = Class()
m2.init()
print m1.nCount
print m2.nCount
print Class.nCount

#7-5 超类
class A:
	nCount = 0
	def init(self):
		self.nCount += 1
	def print_data(self):
		print self.nCount
		
class C:
	pass
	
class B(A, C):                         #B继承 A
	nNum = 2
	def init(self, num):               # 重写 init函数
		self.nNum += num
		self.nCount = 10
		print self.nNum
		
print u'继承 '
self_B = B()
self_B.init(2)
self_B.print_data()

#7-6 类型检查
print issubclass(B, A)                  # 参数 （子类， 父类）                
print issubclass(A, B) 


print B.__bases__                       # 查看 特殊性
print isinstance(self_B, B)                   # 参数 （实例， 类名） 检查 当前实例是不是这个类
print isinstance(self_B, A)             #　True


# 7-7 接口和内省
print u'检查方法是否存在，是字符串形式'
print hasattr(self_B, 'init')         
print hasattr(self_B, 'print_data')
print hasattr(self_B, 'print_')          

#接口，既 定义的 ‘协议’；函数
# 函数 指 特性

print u'检查方法可以用，是字符串形式'
print callable(getattr(self_B, 'init', None))  # 3.0废弃 callable

print u'查看对象所有存储值'
print self_B.__dict__

#总结
#面向对象思考
#1.属于一类的变量和函数 放在一起
#2.方法 关心 实例的特性
#3.小心继承
#4.代码不易过长

#考虑要什么类， 什么方法？尝试：
#@ 写下问题的描述，把所有名词、形容词和动词 加下划线
#@ 所有【名词】 用作【类】
#@ 所有【动词】 用作【方法】
#@ 所有【形容词】， 用作【特性】
#@ 分配方法和特性

#草图，考虑 类和对象的关系（如：继承 协作），作用，精炼模型
#考虑实例，保证模型包括所有需要的东西