Python面向对象的特点

一、 面向三大特性

1. 封装

- 对函数进行封装

同一类函数或同一类属性封装到一个类中　　　

class DB
    def dbf1():
        pass
    def dbf2():
        pass
    def dbf3():
        pass

class File:
    def file1()"
        pass
    def file2()"
        pass
    def file3()"
        pass

　　　　

- 对数据进行封装

函数特别多，可以将数据封装到对象中，并且可以加工

def func1(a1,a2,a3,a4):
    pass

def func2(a1,a2,a3,a4):
    pass

-----------------------------------------------------------------------------------

def func1(obj):
    pass

def func2(obj):
    pass

class Data:
    def __init__(self,a1,a2,a3,a4):
        self.a1 = a1
        self.a2 = a2
        self.a3 = a3
        self.a4 = a4
        
    def dbf1(self):
        return self.a1 + self.a2

d1 = Data(11,22,33,44)


obj1 =DATA(11,22,33,44)
obj2 =DATA（44,55,66,77） 
obj.a1
obj.dbf1()

- 双层封装

对于对象也可封装

class Foo(object):
    def __init__(self,age,name)：
        self.name = name
        self.age = age

class Bar(object):
    def __init__(self,counter):
        self.counter = counter
        self.obj = Foo('18','alex')

b1 = Bar(1)

2. 继承

多个类中拥有共同的函数，抽象到父类中继承即可

3. 多态

继承父类的子类拥有多种形态的相同方法

二、 加括号的四种形式

函数，类，方法，对象

def f1():
    print('f1'):

class F2(object):
    pass

class F2(object):
    def __init__(self):
        pass
    def ff3(self):
        print('ff3')

class F4(object):
    def __init__(self):
        pass
    def __call__(self):
        print('f4')

def func(arg):
    arg()

# 函数，内部执行函数
func(f1)

# 类，内部执行__init__方法
func(F2)

# 方法
# 实例化过程中执行__init__方法
obj1 = F3()
obj1.ff3
func(obj.ff3)

# 对象
# 对象加括号直接执行类中的__call__方法
obj2 = F4()
func(obj2)

三、 常用下划线方法

以下方法会在某个特定动作触发

__init__，类加括号自动触发

__call__，对象加括号自动触发

__new__,new()是在新式类中新出现的方法，它作用在构造方法init()建造实例之前，在Python 中存在于类里面的构造方法init()负责将类的实例化，而在init()调用之前，new()决定是否要使用该init()方法，因为new()可以调用其他类的构造方法或者直接返回别的对象来作为本类 的实例。

__setattr__,__getattr__,__delattr__,对象加点加方法触发

__setitem__,__getitem__，__delitem__,对象加中括号自动触发

__enter__

__exit__

__dict__

 __add__,对象相加的时触发

四、 metaclass

- 类是由type创建，通过metaclass指定该类由谁来创建。

class Foo(object):
    pass
print(Foo)    # <class '__main__.Foo'>


Bar = type('Foo',(object,),{})
print(Bar)    #<class '__main__.AAA'>

- type的源码无法查看，但是类可以指定创建该类的类。

class MyType(type):
    def __init__(self,*args,**kwargs):
        super(MyType,self).__init__(*args,**kwargs)

class Foo(metaclass=MyType):
    pass