python——面向对象

1.python支持函数+面向对象

2.语法
class Foo: #创建类
#方法
def mail(self,email,message): #self是自带的，必须有
print("send")
return True
#调用
obj=Foo() #创建对象，对象 = 类名()
obj.mail('xxx@126.com','test_message') #通过对象去执行方法

3.函数式与面向对象对比
当一些函数中具有相同参数，比如用户密码，可以使用面向对象，将参数值封装到对象。

#函数式
def a(avg1,avg2,avg3):
    print(avg1,avg2,avg3)
def b(avg1,avg2,avg4):
    print(avg1, avg2, avg4)
a(avg1='test1',avg2='test2',avg3='test3')
b(avg1='test1',avg2='test2',avg4='test4')

#面向对象
class Foo:
    def a(self,avg3):
        print(self.avg1, self.avg2, avg3)
    def b(self,avg4):
        print(self.avg1, self.avg2, avg4)
obj=Foo()
obj.avg1='test1'    #共用的变量封装到obj对象里
obj.avg2='test2'
obj.a('test3')    #只传未封装的参数
obj.b('test4')

4.面向对象的构造方法__init__

class Foo:
    def __init__(self):
        print("init自动执行")
obj1=Foo()    #自动执行__init__方法

class Foo:
    def __init__(self,a1,a2):
        self.avg1=a1
        self.avg2=a2
        print(self.avg1,self.avg2)
obj2=Foo("test1","test2")    #自动执行__init__方法时完成对象封装

5.三大特性：封装，继承，多态

#封装

class c1:
    def __init__(self,name,obj):
        self.name=name
        self.obj=obj
class c2:
    def __init__(self,name,text):
        self.name=name
        self.text=text
    def show(self):
        print(self.text)
c2_obj=c2('c2','封装测试')
c1_obj=c1('c1',c2_obj)
print(c1_obj.obj.text)  #对象c2_obj被封装进了c1_obj，c1_obj.obj就是c2_obj
c1_obj.obj.show()

#单继承

class F1:   #父类，基类
    def show(self):
        print('show')
    def foo(self):
        print(self.name)

class F2(F1):   #子类，派生类
    def __init__(self,name):
        self.name=name
    def bar(self):
        print('bar')
obj=F2("ss")
obj.show()
obj.foo()

#多继承

class S0():
    def f2(self):
        print("S0.f2")
class S1(S0):
    def f2(self):
        print("S1.f2")
class S2():
    def f2(self):
        print("S2.f2")
class S3(S1,S2):    #S1在前，优先继承S1
    pass
obj = S3()
obj.f2()

6.类成员

#字段

class Foo:
    jt=123  #静态字段，保存在类中
    def __init__(self,name):
        self.pt=name    #普通字段，保存在对象中

obj=Foo('ss')
print(obj.pt)   #普通字段用对象访问
print(Foo.jt)   #静态字段用类访问
print(obj.jt)   #python支持用对象访问静态字段，但其他语言大多不支持，尽量不用这种方法

 #方法（方法属于类）

#1.普通方法，由对象去调用执行，至少一个self
#2.静态方法，由类调用执行，相当于函数，没有封装。
class Foo:
    @staticmethod
    def f1(arg1):
        print(arg1)
Foo.f1("test")
#3.类方法，由类调用执行，至少一个cls
class Foo:
    @classmethod
    def f2(cls):
        print(cls)  #自动传入cls，cls是类名
Foo.f2()

#属性
写成方法的形式，访问形式类似于字段。

class Pager:
    def __init__(self,all_count):
        self.all_count=all_count

    @property
    def all_pager(self):
        a1,a2=divmod(self.all_count,10)   #求商和余数
        if a2 == 0:
            return a1
        else:
            return a1+1

    @all_pager.setter
    def all_pager(self,value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print("del all_pager")

p=Pager(101)
result=p.all_pager  #加上@property后，p.all_pager访问字段的方式获取属性。如果不加@property，p.all_pager()调用方法
print(result)
p.all_pager=112 #加上@all_pager.setter后，属性支持赋值。
del p.all_pager #加上@all_pager.deleter后，属性支持del

7.成员修饰符

class Foo:
    def __init__(self,name):
        self.__name=name    #__表示私有，只能在类内部使用，外部无法访问，也无法继承。
    def f1(self):
        print(self.__name)
obj=Foo("ss")
obj.f1()

8.特殊成员

class Foo:
    def __init__(self,name):
        print("__init__")
        self.name=name
    def __call__(self, *args, **kwargs):
        print("__call__")
    def __str__(self):
        return "__str__"
    def __getitem__(self, item):
        print("__getitem__",item)
    def __setitem__(self, key, value):
        print("key",key)
        print("value",value)
    def __delitem__(self, key):
        pass
obj=Foo("ss")   #执行__init__
print(obj.__class__)    #显示对象的模块和类
obj()   #对象后面加()，调用__call__方法
print(obj)  #调用__str__方法，如果没有__str__方法会打印类的内存地址。
print(str(obj)) #str()也是调用__str__方法
print(obj.__dict__) #对象中所有字段放入字典
print(Foo.__dict__) #类中所有成员放入字典
obj['ss']   #对象后面加[]，调用__getitem__方法，且把[]内赋值给item
obj['ss']=111   #调用__setitem__方法
del obj['ss']   #调用__delitem__方法

class Foo:
    def __iter__(self):
        yield 1
        yield 2
obj=Foo()
for i in obj:   #执行__iter__方法，拿到__iter__方法的可迭代返回值
    print(i)

9.面向对象其他

#isinstance
查看对象是不是某个类创建的
#issubclass
查看类是不是某个类的子类

#执行父类的方法

class C1:
    def f1(self):
        print("C1.f1")
class C2(C1):
    def f1(self):
        super(C2, self).f1()    #主动执行父类的f1()
        print("C2.f1")
obj=C2()
obj.f1()

#例：有序字典
class MyDict(dict): #继承dict类
    def __init__(self):
        self.li = []
        super(MyDict, self).__init__()  #执行dict类的__init__方法

    def __setitem__(self, key, value):  #__setitem__方法把key和value写入字典
        self.li.append(key) #把key加入列表li
        super(MyDict, self).__setitem__(key,value)

    def __str__(self):  #print()执行__str__方法
        tmp_list = []
        for key in self.li:
            value=self.get(key)
            tmp_list.append("'%s':'%s'" %(key,value))
        tmp_str= "{" + ",".join(tmp_list) + "}"
        return tmp_str