精华内容
下载资源
问答
  • python封装继承多态笔记,python封装继承多态笔记,python封装继承多态笔记适合初学者学习!
  • python封装 继承 多态

    2018-07-27 13:28:04
    2018.7.26-------面向对象-------------------- 编程范式 1》面向对象 ... 面向对象的几个特性:继承 封装 多态 @Role.py class Role: #类变量 n=123 name="我是类name" def __in...
    2018.7.26-------面向对象--------------------
    编程范式          1》面向对象
                  2》面向过程
                  3》函数式编程
     面向对象的几个特性:继承 封装 多态
     @Role.py
     class  Role:
        #类变量
        n=123
        name="我是类name"
        def __init__(self,name,role,weapon,life_value=100,money=15000):
            #构造函数
            #在实例化的时候传参 同时将r1传入 与一般函数传值不同 r1=self
    
            self.name=name   #实例变量(静态属性)  作用域实例本身
            self.role=role
            self.weapon=weapon
            self.life_value=life_value
            self.money=15000
        def shot(self):   #类的方法,功能(动态属性)
            print("shotting")
        def  got_shot(self):
            print("ah....,i got shot..")
        def buy_gun(self,gun_name):
            print("%s just  bought %s" %(self.name,gun_name))
    r1=Role('alex','police','ak47')   #存在变量里  在内存里 同时将r1传入 与一般函数传值不同
    r1.buy_gun("ak555")   #Role.buy_gun(r1)   r1=self
    r2=Role('Jack','terrrorist','ak47')  #r2叫做Role的实例
    r1.name="susong"  #修改属性
    #添加新属性 =====self.bullet_prove  (r1特有 r2不可调用)
    r1.bullet_prove= True
    del r1.weapon
    print(r1.name)  #先找实例变量 再找类变量
    r1.n="修改类变量"
    print(r1.n) # 只会修改自己的类变量  实际上在r1里添加一个n
    print(r2.n)
    Role.n="ABC"
    print(r1.n,r2.n)   #只有r2会影响
    -------------------------------------------
    析构函数
    #析构函数:在实例释放,销毁的时候,通常用于收尾工作 如关闭数据库打开的 临时链接
     def __del__(self):  #释放时自动执行
                print("%s 彻底死了。。。"%self.name)
    --------------------------------------------------
    私有属性  私有方法一样
     @ self.__life_value = life_value
      class Role:
        name = "我是class name"
        def __init__(self, name,role,weapon,life_value=1000,money=15000):
            self.name = name
            self.role = role
            self.weapon = weapon
            self.__life_value = life_value
            self.money = 15000
    
        # def __del__(self):  # 释放时自动执行
        #     print("%s 彻底死了。。。" % self.name)
        #     pass
    
        def show_status(self):
            print("name:%s weapon:%s life_val:%s" % (self.name,self.weapon,self.__life_value))
        def shot(self):
            print("shotting")
        def got_shot(self):
            self.__life_value-=50
            print("ah....,i got shot..")
        def buy_gun(self, gun_name):
            print("%s just  bought %s" % (self.name, gun_name))
    r1 = Role('alex', 'police', 'ak47')  # 存在变量里  在内存里
    r1.buy_gun("ak555")  # Role.buy_gun(r1)   r1=self
    print(r1.show_status())
    
    r1.got_shot()
    r1.show_status()
    --------------------重构父类的方法----------------------
    class People(object):
        def __init__(self,name,age):
            self.name=name
            self.age=age
        def eat(self):
            print("%s is eating..."%self.name)
        def sleep(self):
            print("%s is sleeping..." % self.name)
    
        def talk(self):
            print("%s is talking..." % self.name)
    class Man(People):
        def __init__(self,name,age,money):
            # People.__init__(self,name,age)
             super(Man, self).__init__(name,age)
             self.money=money
             print("%s 一出生就有钱 %smoney "%(self.name,self.money))
    
        def piao(self):
            print("%s is piaoing....20s...over."%self.name)
    
        def sleep(self):
            People.sleep(self)  #重构父类方法
            print("%s  man is sleeping..." % self.name)
    class Women(People):
        def get_birth(self):
            print("%s is boring baby  "%self.name)
    m1=Man("anyang",22)
    m1.eat()
    m1.piao()
    m1.sleep()
    
    w1=Women("shabia",25)
    w1.get_birth()
    ---------------------多继承----------------------
    class People(object):
        def __init__(self,name,age):
            self.name=name
            self.age=age
        def eat(self):
            print("%s is eating..."%self.name)
        def sleep(self):
            print("%s is sleeping..." % self.name)
        def talk(self):
            print("%s is talking..." % self.name)
    class Relation(object):
        def make_friends(self,obj):
            print("%s is making frineds with %s" %(self.name,obj.name))
    #继承people时name已经有了
    class Man(People,Relation):               #子类 多继承
        def __init__(self,name,age,money):
            # People.__init__(self,name,age) 先执行我自己的name
             super(Man, self).__init__(name,age)
             self.money=money
             print("%s 一出生就有钱 %smoney "%(self.name,self.money))
    
        def piao(self):
            print("%s is piaoing....20s...over."%self.name)
        def sleep(self):
            People.sleep(self)  #重构父类方法
            print("%s  man is sleeping..." % self.name)
    class Women(People,Relation):
        def get_birth(self):
            print("%s is boring baby  "%self.name)
    m1=Man("anyang",22,10)
    w1=Women("shabia",25)
    m1.make_friends(w1)
    ---------------------------新式类多继承-----------
    继承策略:广度优先(横向)py3
               深度优先         py2
               py2经典类是深度优先继承的,新式类广度优先继承
               py3都是按广度优先继承
    -------------------------------------------------------
    class School(object):
        def __init__(self,name,addr):
            self.name=name
            self.addr=addr
            self.students=[]    #格式化一个新列表
            self.staffs=[]
    
        def enroll(self,stu_obj):
            print("为学员%s办理注册手续"%stu_obj.name)
            self.students.append(stu_obj)
        def hire(self,staff_obj):
            print("雇佣新员工%s" % staff_obj)
            self.staffs.append(staff_obj)
    class SchoolMember(object):
        def __init__(self,name,age,sex,):
            self.name=name
            self.age=age
            self.sex=sex
        def tell(self):
            pass
    
    class Teacher(SchoolMember):
        def __init__(self, name, age, sex,salary,course ):
            super(Teacher,self).__init__(name,age,sex)
            self.salary=salary
            self.course=course
    
        def tell(self):
            print("""
            -----info of  Teacher:%s-------------
            Name:%s
            Age:%s
            Sex:%s
            Salary:%s
            Course:%s
            """ % (self.name, self.name, self.age, self.sex, self.salary, self.course))
    
        def teach(self):
                print("%s is teache [%s]" % (self.name, self.course))
    
    
    class Student(SchoolMember):
        def __init__(self,name,age,sex,stu_id,grade):
            super(Student,self).__init__(name,age,sex)
            self.stu_id=stu_id
            self.grade=grade
        def tell(self):
            print("""
            -----info of  Student:%s-------------
            Name:%s
            Age:%s
            Sex:%s
            Stu_id:%s
            Grade:%s
            """ % (self.name, self.name, self.age, self.sex, self.stu_id, self.grade))
        def  pay_tuition(self,amount):
            print("%s has paid tuition for $%s"%(self.name,amount))
    school=School("laonanhai","shanxi")
    
    t1=Teacher("Oldboy",22,"MF",2000,"Linux")
    t2=Teacher("song",20,"M",2000,"Python")
    s1=Student("Bai",20,"Mf",1001,"Python")
    s2=Student("xiaoBai",21,"Mf",1002,"Linux")
    t1.tell()
    s1.tell()
    school.hire(t1)
    school.enroll(s1)
    school.enroll(s2)
    
    
    school.staffs[0].teach()
    
    for stu  in school.students:
        stu.pay_tuition(5000)
    ------------------------------多态-----------------
    一种接口,多种实现
    python不直接支持多态,但可以哦间接实现
    class Animal:
        def __init__(self,name):
            self.name=name
        def talk(self):
            pass
        @staticmethod      #略
        def animal_talk(obj):
            obj.talk()
    class Cat(Animal):
        def talk(self):
            print('Meow!')
    class Dog(Animal):
        def talk(self):
            print('Wangwang!')
    
    d=Dog("zhangdongyu")
    d.talk()
    c=Cat("shabia")
    Animal.animal_talk(c)
    -----------------------------------------
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • Python3 封装继承多态阅读 (137) |发布于 2020-05-19 14:32:36面向对象编程有三大重要特征:封装继承多态封装封装是指将数据与具体操作的实现代码放在某个对象内部,使这些代码的实现细节不被外界发现,...

    Python3 封装、继承和多态

    阅读 (137) |

    发布于 2020-05-19 14:32:36

    面向对象编程有三大重要特征:封装、继承和多态。

    封装

    封装是指将数据与具体操作的实现代码放在某个对象内部,使这些代码的实现细节不被外界发现,外界只能通过接口使用该对象,而不能通过任何形式修改对象内部实现。

    封装机制,使得程序在使用某一对象时不需要关心该对象的数据结构细节及实现操作的方法。

    使用封装能隐藏对象实现细节,使代码更易维护,同时因为不能直接调用、修改对象内部的私有信息,在一定程度上保证了系统安全性。

    函数和类都使用的封装。 类通过将函数和变量封装,实现了比函数更高级别的封装。

    继承

    继承即从父类中继承其全部的方法和变量。避免写重复的代码。

    当我们写一个类,继承了其他类。那此类就是字类,被继承的类称作父类,基类或者超类。

    继承不但拥有了父类的全部方法和变量,还可以在此基础中修改,扩展新的功能。

    在python3中子类在调用某个方法或变量的时候,首先在自己内部查找,如果没有找到,则开始根据继承机制在父类里查找。

    根据父类定义中的顺序,以深度优先的方式逐一查找父类!

    从下面的实例中可以看到, A类继承了 B, C类。 当A的实例a调用show()时,发现自己没有,就会从父类中去找,先从B类中检查。发现有show()方法。就直接执行了继承自B类的show()方法。

    继承多个类时有先后顺序,前面的类优先继承。#!/usr/bin/env python

    class B:

    def show(self):

    print('i am B')

    class C:

    def show(self):

    print('i am C')

    class A(B, C):

    pass

    a = A()

    a.show()

    i am B

    那如果被继承的类没有show()方法。而被继承的类还继承了其他类里有show()方法。这时候会执行哪个类的 show() 方法呢?比如#!/usr/bin/env python

    class D:

    def show(self):

    print("i am D")

    class C(D):

    pass

    class B(C):

    pass

    class G:

    pass

    class F(G):

    pass

    class E(F):

    def show(self):

    print("i am E")

    class A(B, E):

    pass

    a = A()

    a.show()

    这时候应该是执行了哪个show()方法呢,我们前面说过了 深度优先。所以B会先去检查B类,B类中没有则继续检查B继承的类,以此类推。

    如果B及B的父类都没有,则改为检查 E类。那很明显在此例中执行了D类的show(),执行结果如下:i am D

    搜索顺序如图:

    把这个继承关系再复杂一点,如果 D,E 同时继承了 H类,且 A, B, C, D, G, F中没有show()方法, E 和 H中有show()方法。

    这种情况下A继承的show方法来自谁呢 , E or H ? 根据深度优先应该是H,但在这里却不是这样。

    这时候的继承顺序变成了下图所示:

    这是因为继承除了遵循深度优先,还要遵循先子类,后父类的查找方式。

    通过下图我们来了解一下在多继承交叉继承中, 继承关系图的拆分逻辑:

    super()函数

    我们知道,类继承中,如果子类中命名了与父类相同名字的成员,继承自父类的成员会被覆盖。

    如果我就想要使用父类的成员该怎么办呢。除了不覆盖之外,还可以使用 super()函数来实现。

    super()的语法:super(子类名, self).方法名() #这里传入的是子类的self, 调用的是父类的方法名。

    来看实例:#!/usr/bin/env python

    class A:

    def __init__(self, name):

    self.name = name

    def show(self):

    print("this is parents")

    class B(A):

    def __init__(self, name, age):

    self.name = name

    self.age = age

    super(B, self).__init__('parents')

    def show_p(self):

    super(B, self).show()

    def show(self):

    print("this is child")

    obj = B("children", 18)

    obj.show_p()

    obj.show()

    print(obj.name)

    this is parents

    this is child

    parents

    我们明明给类B的实例赋值 ”children“ ,打印出来的却是 parents。 可见通过 super(B, self).__init__('parents') 强制执行了父类 __init__()方法。

    多态

    多态,按字面意思就是”多种形态“。

    在面向对象编程语言中,接口的多种不同实现方式就是多态。

    引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4 编程技术内幕”)。

    在python语言中,多态是指父类的引用指向子类的对象。#!/usr/bin/env python

    class Animals(object):

    pass

    class Dog(Animals):

    pass

    class Cat(Animals):

    pass

    #定义变量

    a = Animals()

    c = Cat()

    #isinstance()判断一个对象是否属于某种类型【系统还是自定义的类型】

    print(isinstance(a,Animals)) #True

    print(isinstance(c,Cat)) #True

    print(isinstance(c,Animals)) #True

    print(isinstance(a,Cat)) #False

    #结论:子类对象可以是父类类型,但是,父类的对象不能是子类类型

    我们把这个实例优化一下,来看看多态的使用:#!/usr/bin/env python

    class Animals(object):

    def __init__(self, name='Animals'):

    self.name = name

    def say(self):

    print('i am ',self.name )

    class Dog(Animals):

    def __init__(self, name='Dog'):

    self.name = name

    class Cat(Animals):

    def __init__(self, name='Cat'):

    self.name = name

    a = Animals()

    a.say()

    c = Cat()

    c.say()

    d = Dog()

    d.say()

    i am Animals

    i am Cat

    i am Dog

    在这里我们发现,Dog,Cat 两个类继承自Animals类的 say() 方法打印出来的字符串是不一样。

    我们再把这个程序修改一下, 看看多态还可以:def say_hi(animals):

    animals().say()

    say_hi(Cat)

    say_hi(Dog)

    展开全文
  • 1、面向对象的三大特性:继承封装多态2、继承语法:class Student(父类):变量可以被继承#coding=utf-8importtest9classStudent(test9.Person):sum=0def __init__(self,name,age): #构造函数self.name =nameself...

    1、面向对象的三大特性:

    继承、封装和多态

    2、继承

    语法:class Student(父类):

    变量可以被继承

    #coding=utf-8

    importtest9classStudent(test9.Person):

    sum=0def __init__(self,name,age): #构造函数

    self.name =name

    self.age=agedef do_homework(self):#实例方法

    self.do_english_homework()print(self.name +"do homework")defdo_english_homework(self):print(self.name+ "do english homework")def __marketing(self,score):if score <0:return

    else:

    self.score=scoreprint (self.name+"score :" + str(score))

    将一些应该父类拥有的属性,放到父类

    classPerson():def __init__(self,name,age): #构造函数

    self.name =name

    self.age=agedef getName(self,name):#实例方法

    self.name =nameprint(self.name)

    这个是子类

    #coding=utf-8

    from test9 importPersonclassStudent(Person):

    sum=0#def __init__(self,name,age): #构造函数

    #self.name = name

    #self.age = age

    def do_homework(self):#实例方法

    self.do_english_homework()print(self.name +"do homework")defdo_english_homework(self):print(self.name+ "do english homework")

    student1= Student("anson",19)print(student1.__dict__)

    输出

    [Running] python -u "/Users/anson/Documents/Project/python_ToolCodes/test8.py"{'age': 19, 'name': 'anson'}

    这说明,变量是可以被继承的。

    方法可以被继承

    #coding=utf-8

    from test9 importPersonclassStudent(Person):

    sum=0#def __init__(self,name,age): #构造函数

    #self.name = name

    #self.age = age

    def do_homework(self):#实例方法

    self.do_english_homework()print(self.name +"do homework")defdo_english_homework(self):print(self.name+ "do english homework")

    student1= Student("anson",19)

    student1.getName()#[Running] python -u "/Users/anson/Documents/Project/python_ToolCodes/test8.py"#anson

    和Java一样,python也是单继承

    父类构造函数和子类构造函数

    子类构造方法中显式调用父类构造方法

    #coding=utf-8

    from test9 importPersonclassStudent(Person):

    sum=0def __init__(self,school):

    self.school=schooldef do_homework(self):#实例方法

    self.do_english_homework()print(self.name +"do homework")defdo_english_homework(self):print(self.name+ "do english homework")

    student1= Student("anson")

    student1.getName()

    输出:报错

    [Running] python -u "/Users/anson/Documents/Project/python_ToolCodes/test8.py"Traceback (most recent call last):

    File"/Users/anson/Documents/Project/python_ToolCodes/test8.py", line 17, in student1.getName()

    File"/Users/anson/Documents/Project/python_ToolCodes/test9.py", line 7, ingetNameprint(self.name)

    AttributeError: Student instance has no attribute'name'

    报错原因是缺少父类的构造函数的属性,即然是学生,那肯定也是人,也是要有姓名和年龄的

    所以需要改写成:

    #coding=utf-8

    from test9 importPersonclassStudent(Person):

    sum=0def __init__(self,school,name,age):

    self.school=school#Person.__init__(name,age)#显示调用父类构造函数,显然是不行的

    Person.__init__(self,name,age)#手动传入self

    def do_homework(self):#实例方法

    self.do_english_homework()print(self.name +"do homework")defdo_english_homework(self):print(self.name+ "do english homework")

    student1= Student("yangzte","anson",19)

    student1.getName()#[Running] python -u "/Users/anson/Documents/Project/python_ToolCodes/test8.py"#anson

    问题1:子类构造方法中,显示调用父类的构造方法就可以了,且用父类名就可以了

    问题2:为什么需要必须显示的传入self呢?前面说的self 是python自动给我们传的。

    一个类调用一个实例方法,本身不伦不类,但是python就是可以这么干,所以

    Person.__init__(self,name,age)#手动传入self

    显示调用父类构造方法可以这么干

    那为什么必须传self呢?

    因为如果我们new 个对象,其实是python 隐式调用了构造方法,但是self 它也是帮我们传入了的,只是我们看不见。

    包括我们用对象去调用构造方法,也是不传self的,实质上,对象就是self,python是知道的,所以对象调用构造方法或者是实例方法时,对象.构造方法(),或者对象.实例方法(),python自己就把“对象”当成self 传给构造方法__init__(self, , ,)或者实例方法(self,,,)

    但是用个类去调用一个构造方法,python都不知道具体对象到底是谁,那它就认为,跟调用普通方法没什么区别,普通方法要传全部必须参数,那这里也得着么传全了

    (能力有限,解释只能解释到这个肤浅的层面了)

    子类构造方法中隐式调用父类构造方法

    super(Student,self).__init__(name,age)#隐式调用父类构造函数;显然报错了

    这是为什么呢?解答在这里

    https://blog.csdn.net/andos/article/details/8973368

    #coding=utf-8

    from test9 importPersonclassStudent(Person):

    sum=0def __init__(self,school,name,age):

    self.school=school#Person.__init__(name,age)#显式调用父类构造函数,显然是不行的

    #Person.__init__(self,name,age)#手动传入self是可以的

    super(Student,self).__init__(name,age)#隐式调用父类构造函数,

    def do_homework(self):#实例方法

    self.do_english_homework()print(self.name + "do homework")defdo_english_homework(self):print(self.name+ "do english homework")

    student1= Student("yangzte","anson",19)

    student1.getName()#[Running] python -u "/Users/anson/Documents/Project/python_ToolCodes/test8.py"#Traceback (most recent call last):#File "/Users/anson/Documents/Project/python_ToolCodes/test8.py", line 19, in #student1 = Student("yangzte","anson",19)#File "/Users/anson/Documents/Project/python_ToolCodes/test8.py", line 10, in __init__#super(Student,self).__init__(name,age)#隐式调用父类构造函数,#TypeError: super() argument 1 must be type, not classobj

    要怎么解决呢?

    看看原来的父类

    #coding=utf-8

    classPerson():def __init__(self,name,age): #构造函数

    self.name =name

    self.age=agedef getName(self):#实例方法

    print(self.name)

    其实就是父类如果是无源之水,那就会报错,比如student的父类也得是从别的父类继承,即使是继承自万物之源Object 类 ,那也是必须的

    classPerson(object):在这句,传入了object类

    #coding=utf-8

    classPerson(object):def __init__(self,name,age): #构造函数

    self.name =name

    self.age=agedef getName(self):#实例方法

    print(self.name)

    输出:不报错了

    [Running] python -u "/Users/anson/Documents/Project/python_ToolCodes/test8.py"anson

    展开全文
  • Python作为一种面向对象语言,也有着面向对象的三种特性:封装继承多态封装:将事物相关的属性和方法封装在某一个类里面,使得在调用类创建实例时,可以不用关心类内部的实现细节。类的本质:1. 是将属性(全局...

    Python作为一种面向对象语言,也有着面向对象的三种特性:封装、继承、多态。

    封装:

    将事物相关的属性和方法封装在某一个类里面,使得在调用类创建实例时,可以不用关心类内部的实现细节。

    类的本质:

    1. 是将属性(全局变量),方法(函数)都封装在一个黑盒子里面;

    2. 类里面的方法可以共享属性,属性的修改不会影响类的外部变量,这就是类的封装产生的优势;

    3. 同时类可以被继承,子类可以拥有和父类一样的属性和方法;

    4. 并且子类可以有新的属性,新的方法。

    在类的内部,可以设置私有变量、私有方法:在一般变量或者方法前,加入两个下划线即可成为私有成员,但是不包括魔法方法(即前后都有双下划线的,因为魔法方法可以直接访问),私有成员一般不能外部直接访问,包括对象也不可以直接访问。

    继承:

    子类可以继承父类里面的属性或者方法,当然子类也可以提供自己的属性或方法,子类可以重写和覆盖父类方法或属性;python中可以多继承(此时继承的顺序很重要)。

    多态:(有人说有两种多态,一种是继承多态,即子类继承自同一个父类;一种是鸭子多态,即子类继承自不同的父类)

    (1)多态指的是对于同一个方法,不同对象调用时功能的表现形式不一样。

    (2)python中的多态并不关注对象本身,而是关注它的功能和使用 —— 也即是有这个功能即可,并不需要共同继承一个父类(当然也可以继承自同一个父类)。

    (3)在python有一个鸭子类型 (duck typing)用于实现多态,解释就是:如果一个动物走路、游泳、吃东西等都跟鸭子很像,就认为这个动物是鸭子,而不管它本身究竟是什么;

    例如加法操作,对于整数类型和字符串类型来说,结果完全不一样;但是整数和字符串,却都是可以使用加法这个功能的。

    总结:

    多态:可以对不同类的对象使用同样的操作。

    封装:对外部世界隐藏类内部的工作细节。

    继承:以普通的类为基础建立专门的类对象。

    示例:

    1. 封装和继承,也可以用 help(class_name) 获取类的基本信息

    class grandfather(object): #继承自基类 object,这个类很特别,因为所有class都会继承这个类

    '''grandfather类的定义如下''' #说明文档,获取grandfather.__doc__

    con_flag = 1 #普通静态字段

    __con_data = '爷爷' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_): #初始化方法,实例化的时候自动调用

    self.name =name

    self.age=age

    self.__id =id_print('grandfather类初始化完成')def __get_age(self): #私有函数只能在类内使用

    returnself.agedefshow_age(self):print(self.age)print('grandfather年龄显示完毕')

    这个类 grandfather封装了一个静态变量、一个私有化变量、三个方法(一个魔法方法__init__,一个私有化方法__get_age,一个一般方法show_age)。

    实例化对象时,会自动执行魔法方法__init__,当然注意:如果该方法有其他参数(除self外),那么实例化对象时必须要传入参数才行。

    上述类中,类定义的(object)表示继承;__init__方法实例化时自动执行,且第一个参数self表示创建的类实例本身,不需要传入这个参数,而是使用时会自动填充当前对象;在__init__方法中,可以把很多属性绑定到self中,因为它指向的就是实例本身。

    注意:这里的名称也不一定要用self,可以换成其他的,只要是第一个参数就行,只不过默认用这个self代表自身比较直观。

    if __name__ == '__main__':grandfather1= grandfather('g1',70,'002') #实例化对象

    grandfather1.show_age() #调用方法

    2. 继承:子类继承父类的属性和方法,如果子类中有同名的属性或者方法,则子类会覆盖父类的属性或方法;如果子类中找不到某属性或方法,会去父类中查找;多继承时,有查找顺序(python的C3算法计算的顺序,通过类名.mro()或者 类型.__mro__可获取顺序)。

    示例:

    classgrandfather(object):'''grandfather类的定义如下'''con_flag= 1 #普通静态字段

    __con_data = '爷爷' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('grandfather类初始化完成')def __get_age(self): #私有函数只能在类内使用

    returnself.agedefshow_age(self):print(self.age)print('grandfather年龄显示完毕')class father(grandfather): #继承自grandfather类

    '''father类的定义如下'''con_flag= 2 #普通静态字段

    __con_data = '爸爸' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('father类初始化完成')defshow_age(self):print(self.age)print('father年龄显示完毕')class son(father): #继承自father类

    '''son类的定义如下'''con_flag= 3 #普通静态字段

    __con_data = '儿子' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('son类初始化完成')def set_age(self, age): #用于间接修改私有变量

    self.age =agedefshow_age(self):print(self.age)print('私有静态变量:',self.con_flag)print('私有静态变量:',self.__con_data) #类内使用私有变量

    print('son年龄显示完毕')

    使用时:

    if __name__ == '__main__':

    son1= son('Tom',12,'001') #实例化,如果子类有__init__方法,就会使用子类的;否则使用父类的

    son1.show_age()print(son1.con_flag) #对象直接访问非私有变量

    print(son1._son__con_data) #对假私有变量进行访问

    son1.set_age('13')

    son1.show_age()

    son1.con_flag= 100 #可该方式可以直接修改

    print(son1.con_flag)

    son1._son__con_data= 1000 #可该方式可以直接修改私有变量

    print(son1._son__con_data)

    son1.show_age()#print(son1.__con_data) #AttributeError: 'son' object has no attribute '__con_data',因为是私有变量,不能直接用

    首先,这里的子类中方法重写了父类的方法,相当于实例化时使用时直接用的是子类的__init__方法。

    其次,前面说了,私有成员不能直接访问,但是可以间接访问,(严格的说python的私有属于假私有),有以下两种方式:

    (1)通过在类中设置访问私有成员的非私有函数,例如son类中的set_age 函数;

    (2)通过对象来访问,方式是:对象名._类名__私有成员名,例如这里的:son1._son__con_data。

    而且,如果子类中没有__init__方法,但父类中有,那么实例化子类时,也需要传参数,因为子类会继承父类的属性和方法。

    classdog(father):'''dog类的定义如下'''con_flag= 5 #普通静态字段

    __con_data = '狗狗' #私有静态变量只能在类内使用

    defshow_age(self):print(self.age)print('dog年龄显示完毕')

    调用:

    dog1 = dog('dog1',5,'005') #使用了父类的初始化函数__init__(),如果父类没有,会继续向上回溯查找,直到找到__init__方法或者都没有该方法#dog2 = dog() #报错,因为父类中存在__init__方法

    print(dog1.name)

    dog1.show_age()

    如果,子类和父类及以上均没有__init__方法,那么实例化子类时不需要传参数。

    class cat(object): #cat(dog)

    '''cat类的定义如下'''con_flag= 6 #普通静态字段

    __con_data = '猫' #私有静态变量只能在类内使用

    age = 10

    defshow_age(self):print(self.age)print('cat年龄显示完毕')classpig(cat):'''pig类的定义如下'''con_flag= 7 #普通静态字段

    __con_data = '猪' #私有静态变量只能在类内使用

    age= 5 #覆盖父类属性,因为是先查找子类,再依次向上查找

    defshow_age(self):print(self.age)print('pig年龄显示完毕')

    使用时:

    cat2 =cat()

    cat2.show_age()

    pig1=pig()

    pig1.show_age()

    3. 多态:两种多态形式 —— 继承多态和鸭子多态

    classgrandfather(object):'''grandfather类的定义如下'''con_flag= 1 #普通静态字段

    __con_data = '爷爷' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('grandfather类初始化完成')def __get_age(self): #私有函数只能在类内使用

    returnself.agedefshow_age(self):print(self.age)print('grandfather年龄显示完毕')classfather(grandfather):'''father类的定义如下'''con_flag= 2 #普通静态字段

    __con_data = '爸爸' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('father类初始化完成')defshow_age(self):print(self.age)print('father年龄显示完毕')classdaughter(father):'''daughter类的定义如下'''con_flag= 4 #普通静态字段

    __con_data = '女儿' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('daughter类初始化完成')defshow_age(self):print(self.age)print('daughter年龄显示完毕')def show_func(obj): #类似接口一样,不判断对象的类型,直接使用函数

    obj.show_age()if __name__ == '__main__':print('--- 多态 ---')

    grandfather1= grandfather('g1',70,'002')

    father1= father('f1',34,'003')

    daughter1= daughter('d1',14,'004')

    show_func(grandfather1)

    show_func(father1)

    show_func(daughter1)

    很明显,这三个类继承的都不是一样的父类,但是却存在相同的方法(都重写了父类的方法),所以可以直接像接口一样,通过对象直接调用 —— 鸭子多态。

    如果子类时继承自相同的父类呢?不重写方法的话:

    classson(father):'''son类的定义如下'''con_flag= 3 #普通静态字段

    __con_data = '儿子' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('son类初始化完成')classdaughter(father):'''daughter类的定义如下'''con_flag= 4 #普通静态字段

    __con_data = '女儿' #私有静态变量只能在类内使用

    def __init__(self,name,age,id_):

    self.name=name

    self.age=age

    self.__id =id_print('daughter类初始化完成')

    使用时:

    print('---- 继承多态 ----')

    son2= son('Jack',12,'001')

    daughter2= daughter('Nancy',14,'004')

    son2.show_age()

    daughter2.show_age()

    可见这两个实例化对象都调用了父类的相同方法,但是结果是不一致的 —— 继承多态。

    总结:

    私有成员在类外可以通过间接方式访问。

    类中的对象参数不一定要是self,可以是其他的。

    python的多重继承下次探讨。

    #

    参考:

    展开全文
  • 面向对象的三大特性:封装继承多态继承继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类单继承和多继承1 class ParentClass1: #定义...
  • 数据封装继承多态是面向对象的三大特点。数据封装:在某个类中,比如Student类(初始化有name和score两个属性),每个实例都拥有各自的name,score这些数据。我们可以通过函数来访问这些数据,比如打印一个学生的...
  • 之前学习的编程方式都是通过...面向对象有三大特性:封装继承多态首先来看看封装。封装包括两点,把内容封装到某个地方;调用封装的内容例1;classc1:def__init__(self,name,obj):self.name=nameself.obj=objclass...
  • 抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而...封装/接口封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数...
  • 本文实例讲述了Python 面向对象之封装继承多态操作。分享给大家供大家参考,具体如下:封装继承多态 是面向对象的3大特性为啥要封装好处在使用面向过程编程时,当需要对数据处理时,需要考虑用哪个模板中...
  • Thread类与Runnable接口 扩展Thread类,就无法扩展更多的类,因为Java不允许多重继承。多重继承可以通过接口实现。所以最好是使用接口而不是Thread类。 如果扩展Thread类,那么它还包含了一些方法,如yield()、...
  • 继承1 先说下什么是经典类 什么事是新式类Python 2 当中类分为新式类和经典类 Python 3中全部叫新式类 python 2中如果有继承父类是object 就是新式类,继承其他类不算,但是如果继承其他类,其他类有其他了object 那...
  • 封装含义:对外面隐藏对象的属性和方法,仅提供接口。作用:安全性(通过私有变量改变对外的使用),复用性。# 以下程序关于学生成绩,通过封装函数,实现修改、显示分数的功能classStudent(object):def__init__(self,...
  • 在面向对象的方法中,可以根据某些事物或者情景创建类,并基于这些类来创建对象。...在Python中编写类的方式如下:class Dog():'''创建小狗的类'''def __init__(self,name,age):self.name = nameself.age = age''...
  • 一....self.gun.shoot() ak47 = Gun('ak47') ak47.add_bullet(20) ak47.shoot() ryan = Soldier('Ryan') ryan.gun = ak47 ryan.fire() 标签:练习题,__,name,area,Python,self,多态,item,def 来源: ...
  • 封装可以简单的理解为隐藏一切可以隐藏的实现细节,只向外界提供简单的编程接口。我们在类中定义的方法其实就是把数据和数据的操作封装起来了,在我们创建了对象之后,只需要给对象发送一个消息(调用方法)就可以执行...
  • Python中前面几篇札记中的继承,和本文中即将讲解的多态封装是面向对象编程OOP的三个重要特征。Python不在乎引用对象的类型,多态是对象多种表现形式的体现。私有化属性加上双下划线:self.__name,在类的外面不...
  • 面向对象编程(Object Oriented Programming,OOP,面向对象...面向对象的三大特性是指:封装继承多态1、封装第一步:将内容封装到某处self 是一个形式参数:当执行obj1 = Foo('wupeiqi', 18 ) 时,self 等于 obj...
  • 封装类中把某些属性和方法隐藏起来,或者定义为私有,只在类的内部使用,在类的外部无法访问,或者留下少量的接口(函数)供外部访问;从上一篇文章中的私有属性与私有方法中的代码体现了该特性。class man():def __...
  • 今天为大家带来的内容是:Python 面向对象时的多项操作实例分析(封装继承多态)本文内容主要介绍了Python 面向对象之封装继承多态操作,结合实例形式分析了Python面相对象程序设计中封装继承多态相关操作...
  • 一、封装:1、要封装什么封装数据和方法2、为什么要封装封装不是单纯意义的隐藏:1:封装数据的主要原因是:保护隐私2:封装方法的主要原因是:隔离复杂度3、封装分为两个层面封装其实分为两个层面,但无论哪种层面...
  • 这也是在漫长的程序设计的发展过程中得到的验证结果,面向对象的编程思想较之于面向过程较好一点 封装 面向对象有封装继承多态三大特性。 封装:就是把事物封装成类,隐藏事物的属性和方法的实现细节,仅对外...
  • 继承继承:#类定义class people:#定义基本属性name = ''age = 0#定义私有属性,私有属性在类外部无法直接进行访问__weight = 0#定义构造方法def __init__(self,n,a,w):self.name = nself.age = aself.__weight = w...
  • 这里就不再讲面向对象的相关概念知识或者与面向过程的比较了,直接进入类的学习1.类的创建class people:def ...封装class people:def __init__(self,name,age):self.name=nameself.age=agesfencs=people("sfencs",19...
  • 相信你一定知道继承多态封装封装通常是为了提供统一接口而将具体实现过程或者属性以方法或者类的方式对外呈现;继承就是子类继承父类从而拥有父类的方法和属性;多态继承了同一个父类的不同子类分别重写了...
  • 面向对象的三大特征:封装继承多态封装概念:将一个对象的数据隐藏在对象内部,不让在外界直接访问,而是通过对象提供的方法来访问这些隐藏起来的数据,这样就可以在访问方法中添加访问条件限制,目的是对数据的...
  • Python入门之类(class)Python3 面向对象Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向...
  • 相信你一定知道继承多态封装封装通常是为了提供统一接口而将具体实现过程或者属性以方法或者类的方式对外呈现;继承就是子类继承父类从而拥有父类的方法和属性;多态继承了同一个父类的不同子...
  • 有三大特性:数据封装继承多态。通过class关键字定义类。面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行。为了简化程序设计,面向过程把函数继续切分为子函数,即把大块函数通过...
  • 相信你一定知道继承多态封装封装通常是为了提供统一接口而将具体实现过程或者属性以方法或者类的方式对外呈现;继承就是子类继承父类从而拥有父类的方法和属性;多态继承了同一个父类的不同子类分别重写了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,813
精华内容 1,525
关键字:

python封装继承多态

python 订阅