标签：__ kunfu demo self 特性面向对象 Master def

一、继承

（一）继承的概念

　　生活中的继承，一般指的是子女继承父辈的财产。

　　Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下

class A(object):
    def __init__(self):
        self.num = 1

    def demo(self):
        print(self.num)


class B(A):
    pass


result = B()
result.demo()

------------------
1

　在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

（二）单继承

　　故事：很久以前，枯荣大师有一个弟子叫张三，他马上要与世长辞，现在他想他自己的功夫传授给自己唯一的关门弟子。

class Master(object):
    def __init__(self):
        self.kunfu = "一阳指，狮吼功，六脉神剑"

    def demo(self):
        print("枯荣大师的功夫：",self.kunfu)

class Apprentice(Master):
    pass

func = Apprentice()
print(func.kunfu)
func.demo()


-------------------------
一阳指，狮吼功，六脉神剑
枯荣大师的功夫： 一阳指，狮吼功，六脉神剑

（三）多继承

　　故事：接上，张三不满足枯荣大师的功夫，现在他又拜在了张三丰的门下，想学太极

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)

func = Apprentice()
print(func.kunfu_kurong)
print(func.kunfu_sanfeng)

-------------------------------
六脉神剑
太极

所谓多继承意思就是一个类同时继承了多个父类。

（四）子类重写父类方法和属性

　　故事：接上，张三觉得师傅的功夫都有一定的不足，决定改善师傅的功夫。

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsa(self):
        print(f"张三独创的功夫---{self.kunfu_kurong}------{self.kunfu_sanfeng}")

func = Apprentice()
# print(func.kunfu_kurong)
# print(func.kunfu_sanfeng)
func.demo_zhangsa()

---------------------------------------
张三独创的功夫---万剑归宗------醉拳

（五）子类调用父类的方法和属性

　　故事：接上，张三在两位师傅功夫的基础上创建了新的功夫，但是他想在使用自己功夫的时候也可以用到师傅的功夫。

　　方法一：子类调用父类的方法和属性

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsa(self):
        print(f"张三独创的功夫---{self.kunfu_kurong}------{self.kunfu_sanfeng}")

    def demo_zhangsan_kurong(self):
        Kurong_Master.__init__(self)
        Kurong_Master.demo_kurong(self)

    def demo_zhangsan_sanfeng(self):
        Sanfeng_Master.__init__(self)
        Sanfeng_Master.demo_sanfeng(self)

func = Apprentice()

func.demo_zhangsa()
func.demo_zhangsan_kurong()
func.demo_zhangsan_sanfeng()

----------------------------------------
张三独创的功夫---万剑归宗------醉拳
枯荣大师的功夫： 六脉神剑
张三丰的功夫： 太极

　　方法二：同名的情况下，只能使用子类里面的方法

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsa(self):
        print(f"张三独创的功夫---{self.kunfu_kurong}------{self.kunfu_sanfeng}")

func = Apprentice()
# print(func.kunfu_kurong)
# print(func.kunfu_sanfeng)
func.demo_zhangsa()
demo = Kurong_Master()
demo.demo_kurong()
demo2 = Sanfeng_Master()
demo2.demo_sanfeng()

--------------------------
张三独创的功夫---万剑归宗------醉拳
枯荣大师的功夫： 六脉神剑
张三丰的功夫： 太极

（六）多层继承

　　故事：接上，多年之后，张三老了，想把自己的毕生所学，传给李四

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsa(self):
        print(f"张三独创的功夫---{self.kunfu_kurong}------{self.kunfu_sanfeng}")

    def demo_zhangsan_kurong(self):
        Kurong_Master.__init__(self)
        Kurong_Master.demo_kurong(self)

    def demo_zhangsan_sanfeng(self):
        Sanfeng_Master.__init__(self)
        Sanfeng_Master.demo_sanfeng(self)

class Disciple(Apprentice):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
    def demo_Disciple_zhangsan(self):
        Apprentice.__init__(self)
        Apprentice.demo_zhangsa(self)

    def demo_Disciple_kurong(self):
        Kurong_Master.__init__(self)
        Kurong_Master.demo_kurong(self)

    def demo_Disciple_sanfeng(self):
        Sanfeng_Master.__init__(self)
        Sanfeng_Master.demo_sanfeng(self)



func = Disciple()
func.demo_Disciple_kurong()
func.demo_Disciple_sanfeng()
func.demo_Disciple_zhangsan()

------------------------------------
枯荣大师的功夫： 六脉神剑
张三丰的功夫： 太极
张三独创的功夫---万剑归宗------醉拳

（七）super()

　　调用父类方法

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"

    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        # Kurong_Master.__init__(self)
        # Sanfeng_Master.__init__(self)
        # self.kunfu_kurong = "万剑归宗"
        # self.kunfu_sanfeng = "醉拳"
        super().__init__()
        super().demo_kurong()
        
func = Apprentice()
func.demo_kurong()

-----------------------
枯荣大师的功夫： 六脉神剑
枯荣大师的功夫： 六脉神剑

二、私有权限

（一）定义私有属性和方法

　　在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。

　　故事：续集：枯荣大师还有一招狮吼功，不想传授给他的徒弟，这个时候，可以把狮吼功这个属性设置为私有。

　　设置私有权限的方法：在属性名和方法名前面加上两个下划线__.

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"
        self.__kurong = "狮吼功"

    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)
    def __demo_kurong(self):
        print("枯荣大师的功夫：",self.__kurong)

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsa(self):
        print(f"张三独创的功夫---{self.kunfu_kurong}------{self.kunfu_sanfeng}")

    def demo_zhangsan_kurong(self):
        Kurong_Master.__init__(self)
        Kurong_Master.demo_kurong(self)

    def demo_zhangsan_sanfeng(self):
        Sanfeng_Master.__init__(self)
        Sanfeng_Master.demo_sanfeng(self)



func = Apprentice()

func.__demo_kurong()   # 报错

　　私有属性和私有方法只能在类里面访问和修改　　

（二）获取和修改私有属性值

　　在Python中，一般定义函数名get_xx用来获取私有属性，定义set_xx，用来修改私有属性值。

class Kurong_Master(object):
    def __init__(self):
        self.kunfu_kurong = "六脉神剑"
        self.__kurong = "狮吼功"


    def demo_kurong(self):
        print("枯荣大师的功夫：",self.kunfu_kurong)
    def get_demo(self):
        return self.__kurong
    def set_demo(self):
        self.__kurong = "一阳指"

class Sanfeng_Master(object):
    def __init__(self):
        self.kunfu_sanfeng = "太极"

    def demo_sanfeng(self):
        print("张三丰的功夫：",self.kunfu_sanfeng)


class Apprentice(Kurong_Master,Sanfeng_Master):
    def __init__(self):
        Kurong_Master.__init__(self)
        Sanfeng_Master.__init__(self)
        self.kunfu_kurong = "万剑归宗"
        self.kunfu_sanfeng = "醉拳"

    def demo_zhangsa(self):
        print(f"张三独创的功夫---{self.kunfu_kurong}------{self.kunfu_sanfeng}")





func = Kurong_Master()
print(func.get_demo())
func.set_demo()
print(func.get_demo())

------------------------------
狮吼功
一阳指

三、面向对象的三大特征

封装

　　　　将属性和方法书写到类的里面的操作即为封装

　　　　封装可以为属性和方法添加私有权限

继承

　　　　子类默认继承父类的所有属性和方法

　　　　子类可以重写父类属性和方法

多态

　　　　传入不同的对象，产生不同的结果

　　多态

　　多态指的是一类事物有多种形态

　　定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。

好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！
实现步骤：

　　　　定义父类，并提供公共方法

　　　　定义子类，并重写父类方法

　　　　传递子类对象给调用者，可以看到不同子类执行效果不同

class Son1(Father):
    def demo(self):
        print("正面强攻")

class Son2(Father):
    def demo(self):
        print("背后偷袭")

class Main(object):
    def func_demo(self,result):
        result.demo()

func1 = Son1()
func2 = Son2()
func3 = Main()
func3.func_demo(func1)
func3.func_demo(func2)

------------------------
正面强攻
背后偷袭

四、类属性和实例属性

　　类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。

　　类属性可以使用类对象或实例对象访问

class Demo(object):
    num = 10

func = Demo()
print(Demo.num)
print(func.num)

-------------------
10
10

　　修改类属性

　　类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。

class A():
    name = 1
    age = 2

A.name = 3
A.age = 20

print(A.name)
print(A.age)

--------------
3
20

五、类方法和静态方法

　　需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数。

class Demo(object):
    __num = 10

    @classmethod
    def get_num(cls):
        return cls.__num

func = Demo()
print(func.get_num())

-------------------
10

　　静态方法

　　当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性、类方法、创建实例等）时，定义静态方法。

　　取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗。

class Demo(object):

    @classmethod
    def get_info(cls):
        print("我是一个静态方法")

func = Demo()
func.get_info()

-------------------------
我是一个静态方法

标签：__,kunfu,demo,self,特性,面向对象,Master,def
From： https://www.cnblogs.com/LoLong/p/16756636.html

面向对象的特性