Python:用于类的函数

用于类的函数：

issubclass（cls，class_or_tuple）判断一个类是否继承自某个类class或某类tuple中的
一个类，如果是则返回true，否则返回false
示例：

    class A：
        pass
    class B（A）：
        pass
    class C(B)：
        pass
    issubclass(C,B)  #TRUE
    issubclass(bool)  #TRUE

封装

封装是指隐藏类的实现细节，让使用者不关心这些细节
封装的目的是让使用者通过尽可能少的方法（或属性）操作对象
私有属性和方法
python类中以双下划线__开头，不以双下划线结尾的标识符为私有成员，私有成员只能使用该类的方法进行访问和修改

	class A:
		def __init__(self):
			self.__ppp=100 #创建私有属性
			self.ppp=200  #非私有属性
		def __m(self):
			print('私有方法')
		def test(self):
			print('__ppp属性的值为'，self.__ppp)
			self.__m()  #可以调用__m
	a=A()
	print(a.__ppp)#出错，不允许访问私有属性
	print(a.ppp)#200
	a.test()

多态 polymorphic

字面意思：多种状态
编程语言的状态：
	静态（编译时的状态）  #c/c++
	动态（运行时的状态）  #c++/java
多态原指在有继承关系的类中，调用基类对象的方法，实际能调用到子类覆盖方法的现象叫多态
说明:
    python全部都得对象都只有“运行状态（多态）”没有c++语言里的编译时状态（静态）

	class shape:
		def draw(self):
			print('shape.draw被调用')
	class point(shape):
		def draw(self):
			print('point.draw被调用')
	class circle(point):
		def draw(self):
			print('circle.draw被调用')
	def mydraw(s):
		s.draw  #此处会根据s绑定对象的类型来决定调用谁
	s1=circle()
	s2=point()
	mydraw(s2)
	mydraw(s1)

---

面向对象编程语言的特征：
	继承
	封装
	多态

---

多继承 multiple inheritance

多继承是指一个类继承自两个或2个以上的基类
多继承的语法：
	class类名（基类名1，基类名2.....）
    	语句
说明：
	1.一个子类同时继承自多个父类，父类中的方法可以同时被继承下来
	2.如果两个父类中有同名的方法，而在子类中又没有覆盖此方法时，调用结果难以确定
示例：

	class car:
		def run(self,speed):
			print('汽车以',speed,'km/h的速度行驶')
	class plane:
		def fly(self,height):
			print('飞机以海拔',height,'米的高度飞行')
	class plane_car(car,plane):
		'''plane_car类同时继承2个类'''
	p1=plane_car()
	p1.fly(10000)
	p1.run(300)

多继承的问题（缺陷）
	标识符（名字空间）冲突的问题
    	要谨慎使用多继承
示例：

	class A:
		def m(self):
			print('A.m（）被调用')
	class B:
		def m(self):
			print('B.m（）被调用')
	class AB(A,B):
		pass
	ab=AB()
	ab.m()

多继承的MRO(Method Resolution Order)问题
	MRO------>方法的解决（查找）顺序
	类的__mro__属性
    	用来记录类的方法的查找顺序

    class a:
    	def go(self):
    		print('a')
    class b(a):
    	def go(self):
    		print('b')
    class c(a):
    	def go(self):
    		print('c')
    class d(b,c):
    	def go(self):
    		print('d')
    d=d()
    d.go
    >>>d.__mro__

---

对象转字符串函数的使用：
	repr(obj)返回一个附合Python语法规则的字符串，
    	通常：
    		eval（repr（obj））==obj
			str（obj）通过给定的对象返回一个字符串（这个字符串通常是给人阅读的）
说明：以上两个函数返回的是字符串

s=input('请输入')
s1=repr(s)
s2=str(s)
print('repr(s)',s1)
print('str(s)',s2)

函数重写

函数重写是指在自定义的类内添加相应的方法，让自定义的类创建的实例可以像内建对象一样进行函数操作
对象转字符串函数的重写方法
repr(obj)函数的重写方法：
    def __repr__(self):
        return'字符串'
str(obj)函数的重写方法：
    def __str__(self):
        return'字符串'
示例：

class number:
	def __init__(self,value):
		self.date=value
	def __str__(self):
		return '数字:%d' %self.date
	def __repr__(self):
		return 'number(%d)' %self.date
n1=number(100)
print('repr(n1)=',repr(n1))#n1.__repr__()
print('str(n1)=',str(n1))#n1.__str__()

str(obj)函数调用方法说明：
	1.先调用obj.__str__()方法取值。
	2.如果obj.__str__()方法不存在，则调用obj.__repr__（）方法取值
	3.如果再不存在obj.__repr__()方法.则调用object类的__repr__方法取值

内建函数重写

方法名                              函数名
__abs__(self)                  abs(obj)函数
__len__(self)                   len(obj)函数
__reversed__(self)         	reversed(obj)函数
__round__(self)             	round(obj)函数

class mylist:
	'''自定义一个容器类mylist，内部采用列表来存储内部的数据'''
	def __init__(self,iterable=()):
		self.date=[x for x in iterable]
	def __len__(self):
		'''此方法必须返回整数'''
		return len(self.date)
	myl=mylist([1,-2,3,-4])
	print(len(myl))

数值转换函数重写

方法名                               函数名
__complex__(self)            complex(obj)
__int__(self)                  	 int(obj)
__float__(self)                  float(obj)
__bool__(self)                  bool(obj)
示例：

	class mynumber:
		def __init__(self,value):
			self.date=value
		def __int__(self):
			return int(self.date)
		def __float__(self):
			return float(self.date)
	n1=mynumber('100')
	print(int(n1))#调用n1.__int__()	
	print(float(n1))#调用n1.__float__()

布尔测试函数(bool)函数重写

作用：
	用于bool（obj）函数取值：
	用于if语句的真值表达式
	用于while语句的真值表达式中
说明：
	1.优先调用obj.__bool__（）方法进行取值
	2.当不存在obj.__bool__()方法时，用obj.__len__()的返回值为零来测定布尔值
	当不存在__len__()方法时，则直接返回true

对象的属性管理函数：

getattr(obj, name[, default]) 从一个对象得到对象的属性；getattr(x, 'y') 等同于x.y; 当属性不存在时,如果给
                                             出default参数,则返回default,如果没有给出default 则产生一个AttributeError错误

hasattr(obj, name)            	用给定的name返回对象obj是否有此属性,此种做法可以避免在getattr(obj, name)时引发错误 

setattr(obj, name, value)     给对象obj的名为name的属性设置相应的值value, set(x, 'y', v) 等同于 x.y = v 		

delattr(obj, name)            	删除对象obj中的name属性, delattr(x, 'y') 等同于 del x.y 

迭代器（高级）

什么是迭代器
    可以能过next（it）函数取值的对象就是迭代器
迭代器协议：
    迭代器协议是指对象能够使用next函数获取下一项数据，在没有下一项数据时触发一个stopiteration异常来终止迭代的约定
迭代器协议的实现方法：
	__next__(self)方法来实现迭代器协议

什么是可迭代对象：
	是指能用iter（obj）函数返回迭代器的对象（实例）
	可迭代对象的内部要定义__iter__(self)方法来返回迭代器对象（实例）