Python 自学笔记 总结 2.0 面向对象

动态属性

在运行时可改变其结构的语言，例如新的函数，对象，甚至代码可以被引进，已有的函数可被删除或是其他结构上的变化。

例：可以动态为对象添属性.

class Student:
    def_ _init_ _(self,name,age):
        self.name=name
        self.age=age


stu=Student('鬼面瓷',20)


#想要在不修改当前类的代码的情况下去添加一个属性
stu.sex='女'
print(stu.name,stu.age,stu.sex)
                                        #鬼面瓷  20  女

#如果当前类不允许开发者进行动态属性添加
class Student：
    __slots__=('name','age')
        self.name=name
        self.age=age


stu=Student('鬼面瓷',20)
#想要在不修改当前类的代码的情况下去添加一个属性
stu.sex='女'
print(stu.name,stu.age,stu.sex)
                                    #系统报错：Traceback(most recent call last):

---

---

---

继承

面向对象三大特征：

·1.封装根据职责将属性和方法封装到一个抽象的类中

·2.继承实现代码的重用，相同的代码不需要重复的编写

·3.多态不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

---

01.单继承

                        1.1继承的概念，语法和特点

不使用继承（重复多写代码）

Animal
eat(self):
drink(self):
run(self):
sleep(Self):

Dog
eat(self):
drink(self):
run(self):
sleep(Self):
bark(self):

Cat
eat(self):
drink(self):
run(self):
sleep(Self):
catch(self):

需重复多写相同代码。

 使用继承（无需多写相同代码）

Animal
eat(self):
drink(self):
run(self):
sleep(Self):

Dog
bark(self):

Cat
catch(self):

Dog,Cat 继承了Animal

1）继承的语法

class类名（父类名）：
    pass

 ·子类继承自父类，可以直接享受父类中已经封装好的方法，不需要再次开发。

·子类中应该职责，封装子类特有的属性和方法。

2）专业术语

·Dog 类是Animal 类的子类，Animal 类是Dog 类的父类，Dog 类从Animal 类继承

·Dog 类是Animal 类的派生类，Animal 类是Dog 类的基类，Dog 类从Animal 类派生

3）继承的传递性

·C类从B类继承，B类又从A类继承

·那么C类就是具有B类和A类所有属性和方法

子类拥有父类以及父类的父类中封装的所有属性和方法

                        1.2方法的重写

·子类拥有父类的所有方法和属性

·子类继承自父类，可以直接享受父类中已经已经封装好的方法，不需要再次开发。

应用场景：当父类的方法实现不能满足子类需求时，可以对方法进行重写（override）

Animal
eat(self):
drink(self):
run(self):
sleep(Self):

Dog
bark(self):

Xiao Tian Quan
fly(self):

#重新定义一个和父类同名的类
bark(self)

重写父类方法有两种情况：

1.覆盖父类的方法

·如果在开发中，父类的方法实现和子类的方法实现，完全不同

·就可以使用覆盖的方法，在子类中重新编写父类的方法实现

·具体的实现方式，就相当于在子类中定义了一个和父类同名的方法并实现

2.对父类方法进行扩展

·如果在开发中，子类的方法实现中包含父类的方法实现

        （父类原本封装的方法实现是子类方法的一部分）

·就可以使用扩展的方式

        1】在子类中重写父类的方法

        2】在需要的位置使用

super（  ）.父类方法

来调用父类方法的执行

        3】代码其他的位置针对子类的需求，编写子类特有的代码实现

关于super

        ·在python中super是一个特殊的类

        ·super（）就是使用super类创建出来的对象

        ·最常使用的场景就是在重写父类方法时，调用在父类中封装的方法实现

调用父类方法的另一种方式

在python2.x时，如需调用父类的方法，还可用以下方式：

父类名.方法（self）

·这种方式目前在python3.x还支持

·不推荐使用，一旦父类发生变化，方法调用位置的类名也需修改

提示：·在开发中，父类名和super（）两种不可混用

        ·如果使用当前子类名调用方法，会形成递归调用，出现死循环

                        1.3父类的私有属性和私有方法

1.子类对象不能在自己的方法内部，直接访问父类的私有属性或私有方法。

2.子类对象可以通过父类的公有方法间接访问到私有属性或私有方法。

        ·私有属性，方法是对象的隐私，不对外公开，外界以及子类都不能直接访问。

        ·私有属性，方法通常用于做一些内部的事情

class A：
    #创建类属性
    def__init__(self):
        #公有属性
        self.num_1=100
        #私有属性
        self.__num_2=200


    #创建私有方法
    def__test(self):
        print('f')私有属性与公有属性的值：{self.num_1},{self.__num_2}'


#创建的新类要继承自类A
class B（A）：
    pass


b=B()
#使用子类去打印父类的公有属性
print（b.num_1)
                                                #100

#打印父类中的私有属性会报错，顾不可直接打印父类的私有属性 

在子类中使用父类的私有属性和私有方法

class A：
    def__init__(self):
        #公有属性
        self.num_1=100
        #私有属性
        self.__num_2=200


    #创建私有方法
    def__test(self):
        print('f')私有属性与公有属性的值：{self.num_1},{self.__num_2}')
        #公有方法中调用私有方法
        self.__test()


classB(A):
    #公有方法
    def demo(self):
        #1.在子类方法中访问父类的公有属性
        print（f'子类方法输出父类中的公有属性：{self.num_1}')
        #2.在子类中调用父类的公有方法输出私有属性
        self.test()

b=B()
b.demo()
                                #子类方法输出父类中的公有属性:100

                                 父类中的公有方法输出私有属性：200
                                 公有属性与私有属性的值：100，200


'''
子类可以通过父类中公有方法简介访问到私有属性和私有方法
'''

---

0.2多继承

 概念：

·子类可以拥有多个父类，并且具有所有弗雷德属性和方法

例：孩子会继承自己父亲和母亲的特性

A                                                                        B

test（self):                                                    demo(self):

                                           C

语法：

class 子类名（父类名1，父类名2···）
    pass

class A：
    def test(self):
        print('test方法'）


class B：
    def demo(self):
        print('demo方法')
class C(A,B)：
    pass


#创建C类对象
c=C()
c_test()
c.demo()
                        #test方法
                         demo方法

多继承使用注意事项

提问：在不同的父类中存在同名的方法，子类对象在调用方法时，会调用哪一类父类中的方法呢？

class A:
    def test(self):
        print('A---test方法')

    def demo(self):
        print('A---demo方法')


class B:
    def test(self):
        print('B---test方法')

    def demo(self):
        print('B---demo方法')


class C(B,A):
    pass

#创建c类对象
c=C()
c.test()
c.demo()
                                #B---test方法
                                 B---demo方法

答：调用顺序和继承顺序有关，若在多继承情况下发现父类中的方法有重名，尽量避免使用多继承。