python面向对象之三大特性

继承

  先看个简单的例子了解一下继承。

class Animal:   # 父类
    def __init__(self, name, age, department):
        self.name = name
        self.age = age
        self.department = department

    def running(self):
        print(‘%s可以奔跑!‘% self.name)

class Cat(Animal):   # 括号里放要继承的父类
    def __init__(self, name, age, department, tail):
        Animal.__init__(self, name, age, department)   # 即想使用父类的属性又有自己独有的属性,就在内部调用父类的__init__
        self.tail = tail    # 派生属性

class Mouse(Animal):
    def __init__(self, name, age, department, tail):
        super().__init__(name, age, department)
        # super方法只在python3中有 相当于Animal.__init__(self, name, age, department)
        self.tail = tail

class Human(Animal):
    def __init__(self, name, age, department):
        Animal.__init__(self, name, age, department)

    def create(self):    # 派生方法
        print(‘%s可以创造!‘% self.name)

cat = Cat(‘Tom‘, 10, ‘猫科‘, ‘蓝色尾巴‘)
mouse = Mouse(‘Jerry‘, 7, ‘鼠科‘, ‘灰色尾巴‘)
human = Human(‘zzy‘, 24, ‘人科‘)
print(cat.name)   # Tom
print(mouse.tail)  # 灰色尾巴
cat.running()   # Tom可以奔跑!
human.create()  # zzy可以创造!
print(Human.mro())  # [<class ‘__main__.Human‘>, <class ‘__main__.Animal‘>, <class ‘object‘>]查看继承顺序
print(Human.__bases__)  # <class ‘__main__.Animal‘>查看继承的所有父类

继承

  通过上面的例子总结一下继承的特性:

"""
    继承:子类是父类的关系  作用:可以减少代码的重复
    通过 类名(父类名) 来进行继承,
    一个类可以单继承也可以多继承
    一个类可以被单个类继承,也可以被多个类继承
    父类中没有而子类中有的属性为 派生属性
    父类中没有而子类中有的方法为 派生方法
    单继承:
        对象调用时,先在子类里找,子类里有一定用子类里的,没有再去父类里面找
    多继承:
        在新式类中(python3中都是新式类),对象调用查找是按广度查找
        新式类,默认继承object
        在经典类中,对象调用查找是深度查找
        经典类,python2.7创建的默认类,继承object后变为新式类
"""

  研究一下继承的查找顺序:这里以python3为例

class D:
    def func(self):
        print(‘d‘)

class C(D):
    def func(self):
        print(‘c‘)

class B(D):
    def func(self):
        print(‘b‘)

class A(B, C):
    def func(self):
        print(‘a‘)

a = A()
a.func()  # a A类里有就找A类

# 注释掉A类里的func
a.func()   # b  A类里没有,先从括号中最左边的B类里找

# 注释掉B类里的func
a.func()   # c  B类里没有,判断通过C类也能找到B的父类D,会从C类先找

# 注释掉C类里的func
a.func()   # d  C类里没有,就找父类D

  上面的继承顺序可以看出:

"""
    广度查找:原则就是在没找到时,按继承层级找完每一个父类
    深度查找:原则是一条继承线路找到底才会找另外的线路
"""

  再看下super方法的本质:

class A(object):
    def func(self):
        print(‘A‘)

class B(A):
    def func(self):
        super().func()
        print(‘B‘)

class C(A):
    def func(self):
        super().func()
        print(‘C‘)

class D(B, C):
    def func(self):
        super().func()
        print(‘D‘)

b = D()
b.func()  # 打印顺序为 A C B D
# super的本质 :不是单纯找父类 而是根据调用者的节点位置的广度优先顺序来的

封装

  封装 用于对代码的保护,使类中的隐藏属性和方法只有通过提供的公共访问方式来使用,而不能直接查。

  下面写个例子具体看下:

class Person:
    __keys = ‘量子编码规则‘   # 私有静态属性

    def __init__(self, name, password):
        self.name = name
        self.__password = password  # __属性  定义私有属性

    def __get_password(self):  # __方法  定义私有方法
        return self.__password   # 只能在内部访问

    def login(self, name, passwd):  # 提供公共访问方法
        if name == self.name and passwd == self.__get_password():
            print(‘登陆成功‘)

person = Person(‘zzy‘, ‘zzy123‘)
# print(person.__password)  # 报错 显示Person类找不到__password
# print(person._Person__password)  # zzy123  在外部通过  _类名__属性名 也能查看私用属性,但是不能这样用!
person.login(‘zzy‘, ‘zzy123‘)  # 登陆成功

  那子类能否继承父类的私有属性呢?

class Foo:
    __key = 123

class Son(Foo):
    print(Foo.__key)   # 报错  子类不能继承父类的私用属性

多态

"""
    多态:指一类事物有多种形态,python天生支持多态。
    python中推崇鸭子类型,即看起来用起来都很像,但却没有任何约束关系,是一种自我约束行为。比如list和tuple
        优点:松耦合,相似类之间不会有任何影响
        缺点:自我约束,随意性太强
"""

  例子

class Holy:
    def cure(self, HP):
        HP += 100
        return ‘血量为%s‘% HP

class Discipline:
    def cure(self, HP):
        HP += 100
        return ‘血量为%s‘% HP

def cure(obj, HP):   # 在强数据类型语言中,obj必须要指定数据类型,在Python中就可以是多种形态的
    return obj.cure(HP)

# 这里的Discipline类和Holy类就很相似,就可以当同一个事物去使用
holy = Holy()
discipline = Discipline()
print(cure(holy, 20))
print(cure(discipline, 10))

原文地址:https://www.cnblogs.com/zxc-Weblog/p/8326100.html

时间: 2024-10-09 11:13:25

python面向对象之三大特性的相关文章

Python 面向对象的三大特性:封装,继承,多态

# 面向对象的三大特性:封装,继承,多态 # 继承的影响:资源的继承,资源的使用,资源的覆盖,资源的累加 # 资源的继承,在Python中的继承是指能使用父类的资源,而不是说在子类也复制一份父类代码到子类中 class Animate: a = 1 # 公有的资源 _b = 2 # 受保护的资源 __c = 3 # 私有的资源 def t1(self): print("t1") def _t2(self): print("t2") def __t3(self): p

python——面向对象的三大特性

继承 什么是继承 继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类 python中类的继承分为:单继承和多继承 class ParentClass1: #定义父类 pass class ParentClass2: #定义父类 pass class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass pass class SubClass2(ParentCl

python ----面向对象的三大特性---多态

多态 多态 不同的子类对象调用相同的父类方法,产生不同的执行结果. 以继承和重写父类方法为前提 原文地址:https://www.cnblogs.com/jenny-jenny/p/10055319.html

python 面向对象的三大特性之一: 封装

1. 封装的好处: 1. 将变化隔离 2. 便于使用 3. 提高复用性 4. 提高安全性 广义的封装: 实例化一个对象,给对象空间封装一些属性. 狭义的封装: 私有制. 私有成员:私有静态变量,私有方法,私有对象属性 私有静态变量: 实例化对象不能访问私有静态变量 类名不能访问私有静态变量 对于私有静态变量,类的外部不能访问 对于私有静态变量,类的内部都可以访问 子类(对象和类)不能访问父类的私有静态变量 私有方法: 类的内部可以访问 类外部不能访问 类的派生类(就是父类的方法)也不能访问 私有

Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

概念:                                                                                                                                                     ·        面向过程:根据业务逻辑从上到下写垒代码 ·        函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 ·        面向对象:对函数进行分类和封装,

Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态)

Python 入门 之 面向对象的三大特性(封装 / 继承 / 多态) 1.面向对象的三大特性: (1)继承 ? 继承是一种创建新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以称为基类或超类,新建的类称为派生类或子类. ? 在Python中实现继承非常简单,在声明类的时候,在类名后面添加一个小括号,就可以完成继承关系.单纯的从代码的层面上来看当两个类具有相同的功能或者特征的时候就可以使用继承.提取一个父类,这个父类中编写者两个类相同的部分,然后两个类分别去继承这个类就可以

面向对象的三大特性之封装

# 面向对象的三大特性之封装 # 第一个层面的封装:类就是麻袋,这本身就是一种封装 # 第二个层面的封装:类中定义私有的,只在类内部使用,外部无法访问 # 约定一:任何以单下划线开头的名字都应该是内部的,私有的 # 约定二:双下划线开头的名字(如__name),外部无法直接访问,因为这种双下划线开头的名字已经被python转化为 _类名__name # 第三个层面的封装:明确区分内外,内部的实现逻辑,外部无法知晓,并且为封装到内部的逻辑提供一个访问接口给外部使用 # 如def getvalue(

面向对象的三大特性

面向对象的三大特性: 封装, 继承, 多态 封装 封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性和操作(或服务)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节 继承: 子类拥有父类的属性和方法, 任何一个类都继承 Object (不管是java定义的还是自己定义的)::: Object.finalize()-->调用这个方法来释放资源: 多态(执行期间(执行期间-->你在控制台上写 java 类名 运行某个文件的时候叫执行期间)的动态绑定, 池绑定): 重载

接口和抽象类的对比,面向对象的三大特性和四大特性

Day09_SHJavaTraing_4-14-2017 一.接口和抽象类的对比1.相同点    ①都位于继承的顶端,用于被其他类实现或继承    ②都不能直接实例化对象    ③都包含抽象方法,其子类都必须覆写这些抽象方法2.区别 2.1从声明上: ①抽象类是一个类,需要使用关键字class声明        ②接口不是一个类,使用关键字interface声明 2.2从能够书写的成员上看: ①抽象类可以书写类中的所有成员 ②接口中只能书写成员变量和抽象函数(从JDK8开始,接口中可以有实现的函