小白学python6

小白学python6

一、和类、对象相关的BIF(内置函数)
1.issubclass(子类名class,父类名classinfo)：class是classinfo 的子类则返回true

>>> class A:
	 pass

	
>>> class B(A):
	pass

>>> issubclass(B,A) //B是A的子类返回True
True
>>> issubclass(B,B)
True
>>> issubclass(A,B)
False

2.isinstance(实例object,类\元组classinfo)检查一个实例是否属于一个类

>>> class C:
	pass

>>> b=B()
>>> isinstance(b,B)  //b是B的子类，返回True
True
>>> isinstance(b,A)
True
>>> isinstance(b,C)
False
>>> 

3.hasattr(对象obect,name属性名);判断对象是否有属性名，其中属性名要用‘’引住

>>> class C:
	def __init__(self,x=0):
		self.x=x

		
>>> c=C()
>>> hasattr(c,'x')
True
>>> getattr(c,'y',"您检索的属性不存在")
'您检索的属性不存在'
>>> 

4.getattr(对象obect,name属性名):获得对象的属性名
5.setattr(对象obect,name属性名):设置对象的属性名
6.delattr(对象obect,name属性名):删除对象的属性名
7.property(getSize,setSize,selSize):分别是 获取属性的方法、设置属性的方法、删除属性的方法

>>> class C:
	def __init__(self,size=10):
		self.size=size
	def getSize(self):
		return self.size
	def setSize(self,value):
		self.size=value
	def delSize(self):
		del self.size
	x=property(getSize,setSize,delSize)

	
>>> c1=C()
>>> c1.getSize()
>10
>>> c1.x
10
>>> c1.x=18
>>> c1.getSize()
18
>>> 
>>> del c1.x
>>> c1.x
Traceback (most recent call last):
  File "<pyshell#59>", line 1, in <module>
    c1.x
  File "<pyshell#51>", line 5, in getSize
    return self.size
AttributeError: 'C' object has no attribute 'size'
>>> 

二、魔法方法（类似于构造函数和析构函数），使用双下划线
1.init(self)第一个参数是self
通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性， 做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。

>>> class Rectangle:
	def __init__(self,x,y):
		self.x=x
		self.y=y
	def getP(self):
		return (self.x+self.y)*2
	def getA(self):
		return(self.x*self.y)
>>> r=Rectangle(2,3)
>>> r.getP()
10
>>> r.getA()
6
>>> 

2.new(cls)是第一个被调用的方法
通常用于控制生成一个新实例的过程。它是类级别的方法。
①当我们在继承一些不可变的类时(比如int, str, tuple)，我们可以通过这个方法自定义这些不可变类的实例化过程。

我们用int类来举例：

假如我们需要一个永远都是正数的整数类型，可以通过继承int类，然后可能会写出这样的代码：

class PositiveInteger(int):
    def __init__(self, value):
        super(PositiveInteger, self).__init__(self, abs(value))
 
i = PositiveInteger(-3)
print i

运行后发现该还是-3，这是因为int是不可变类型，所以这个时候就需要重载__new__()方法，才能起到自定义的作用：

class PositiveInteger(int):
    def __new__(cls, value):
        return super(PositiveInteger, cls).__new__(cls, abs(value))
 
i = PositiveInteger(-3)
print i

②可以用__new__()方法来实现单例：

class Singleton(object):
    def __new__(cls):
        # 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象
        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)
        return cls.instance

obj1 = Singleton()
obj2 = Singleton()
obj1.attr1 = 'value1'

print(obj1.attr1, obj2.attr1)   #value1 value1
print(obj1 is obj2) #True

可以看出obj1和obj2是同一个实例。
3.del(self)

>>> class C:
	def __init__(self):
		print("我是__init__方法，我被调用了")
	def __del__(self):
		print("我是__del__方法，我被调用了")

		
>>> c1=C()
我是__init__方法，我被调用了 //当类C被实例化是就开始调用__init__函数
>>> c2=c1
>>> c3=c2
>>> del c3
>>> del c2
>>> del c1
我是__del__方法，我被调用了  //当所有对于类C的引用全部del之后，类C里面的del方法才会被调用

>>> 

三、工厂函数（实质是系统类的实例对象）
1.魔法方法是可以修改的，修改之后可以直接打入系统内部让自己的算法变得更加流畅

>>> class int(int):
	def __add__(self,other):
		return int.__sub__(self,other)

	
>>> a=int('5')
>>> a
5
>>> b=int(3)
>>> a+b  //这里在进行+这个运算时，实际上系统调用的是sub(减)这个操作
2
>>> 

2.反运算

>>> class Nint(int):
	def __rsub__(self,other):
		return int.__sub__(other,self) //变换顺序之后是3-a

	
>>> a=Nint(5)
>>> 3-a
-2
>>>