面向对象基本介绍

Python编程方式:

  1. 面向过程编程

  2. 面向函数编程

  3. 面向对象编程

名称定义:

  1. 如果函数没有在类中称之为函数

  2. 如果函数在类中称之为方法


创建类

  1. # 创建一个类,类名是Class_basis

  2. class Class_basis:

  3.    # 在类里面创建了一个方法ret,类里面的方法必须加一个self关键字

  4.    def ret(self):

  5.        # 当调用方法的时候输出ret

  6.        print("ret")

使用类

  1. # 通过Class_basis类创建一个对象obj(创建一个Class_basis实例),类名后面加括号

  2. obj = Class_basis()

  3. # 通过对象调用类中的ret方法

  4. obj.ret()

类的内存地址对应关系

object-oriented-basis-01

面向对象之self

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. # 创建一个类,类名是Class_basis

  4. class Class_basis:

  5.    # 在类里面创建了一个方法ret

  6.    def ret(self,):

  7.        # 输出self的内存地址

  8.        print("方法ret的self内存地址", id(self))

  9. # 创建一个对象obj,类名后面加括号

  10. obj = Class_basis()

  11. # 输出对象obj的内存地址

  12. print("obj对象内存地址", id(obj))

  13. # 通过对象调用类中的ret方法

  14. obj.ret()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2. obj对象内存地址 2420760156536

  3. 方法retself内存地址 2420760156536

  4. Process finished with exit code 0

通过上面的测试可以很清楚的看到obj对象和类的方法中self内存地址是一样的,那么方法中的self就等于obj

如图

object-oriented-basis-02

self是形式参数,有Python自行传递。

面向对象之封装

封装就是将内容封装到某个地方,以后再去调用被封装在某处的内容,在使用面向对象的封装特性时,需要:

  1. 将内容封装到某处

  2. 从某处调用被封装的内容

  1. class Foo:

  2.    def ret(self):

  3.        # 输出backend变量的内容

  4.        print(self.backend)

  5. obj = Foo()

  6. # 在对象中创建一个backend变量

  7. obj.backend = "as"

  8. obj.ret()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2. as

  3. Process finished with exit code 0

上面的封装是一种非主流的封装方式,下面的__init__构造方法封装方式是主流的封装方式

  1. class Foo:

  2.    # 进入类的时候首先执行__init__方法

  3.    def __init__(self, name):

  4.        """

  5.        __init__称之为构造方法

  6.        :param name: Foo传递过来的参数

  7.        """

  8.        # 在类中创建一个成员Name,它的值是传过来的形参name

  9.        self.Name = name

  10.    # 类的方法

  11.    def user(self):

  12.        # 输出Name的值

  13.        print(self.Name)

  14. # 创建对象,并且将"Ansheng"封装到对象中,类+括号的时候会自动执行__init__方法

  15. obj = Foo("Yangwen")

  16. # 执行user方法

  17. obj.user()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2. Ansheng

  3. Process finished with exit code 0

del_ 解释器销毁对象时候自动调用,特殊的名:析构方法

封装的应用场景之一就是当同一类型的方法具有相同参数时,直接封装到对象即可。

实例

通过用户输入年龄和姓名输出用户的个人信息

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. class Foo:

  4.    def __init__(self, name, age):

  5.        self.Name = name

  6.        self.Age = age

  7.    def info(self):

  8.        print("""

  9.            My name is: %s

  10.            My age is: %d

  11.        """ % (self.Name, self.Age))

  12. ansheng = Foo("Yangwen", 18)

  13. ansheng.info()

  14. xiaoming = Foo("xiaoming", 30)

  15. xiaoming.info()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2.            My name is: Ansheng

  3.            My age is: 18

  4.            My name is: xiaoming

  5.            My age is: 30

  6. Process finished with exit code 0

封装的应用场景之二就是把类当作模块,创建多个对象(对象内封装的数据可以不一样)

面向对象之继承基础

继承,面向对象中的继承和现实生活中的继承相同,即:子可以继承父的内容。

实例

创建一个信息相关的类,比如说人拥有四肢头发耳朵等信息,在创建一个中国人和外国人的类,中国人的语言是中文,皮肤是×××,外国人的语言是英文,皮肤是黑色。

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. class People:

  4.    def __init__(self):

  5.        print("""

  6.        你的通用特征有:四肢、头发、眼、耳朵

  7.        """)

  8. class China(People):

  9.    def info(self):

  10.        print("""

  11.        你是中国人,你的语言是中文,皮肤是×××

  12.        """)

  13. class Us(People):

  14.    def info(self):

  15.        print("""

  16.        你是美国人,你的语言是英文,皮肤是黑色

  17.        """)

  18. c = China()

  19. c.info()

  20. m = Us()

  21. m.info()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2.        你的通用特征有:四肢、头发、眼、耳朵

  3.        你是中国人,你的语言是中文,皮肤是×××

  4.        你的通用特征有:四肢、头发、眼、耳朵

  5.        你是美国人,你的语言是英文,皮肤是黑色

  6. Process finished with exit code 0

People —> 父类 or 基类

China and Us —> 子类 or 派生类

  1. 派生类可以集成基类中所有的功能

  2. 派生类和积累同时存在,优先找派生类

  3. Python类可以同时继承多个类

面向对象之继承之多继承(新式类)

多继承就是在class My(China, Us):括号内放入多个父类名。

多继承顺序

My(China, Us)时,因为My类中有info这个方法,所以输出的结果是我就是我

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. class China:

  4.    def info(self):

  5.        print("你是中国人")

  6. class Us:

  7.    def info(self):

  8.        print("你是美国人")

  9. class My(China, Us):

  10.    def info(self):

  11.        print("我就是我")

  12. c = My()

  13. c.info()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2. 我就是我

  3. Process finished with exit code 0

My(China, Us)时,My类中没有info这个方法,输出的结果是你是中国人,默认括号内左边的类优先

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. class China:

  4.    def info(self):

  5.        print("你是中国人")

  6. class Us:

  7.    def info(self):

  8.        print("你是美国人")

  9. class My(China, Us):

  10.    pass

  11. c = My()

  12. c.info()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2. 你是中国人

  3. Process finished with exit code 0

My(China, Us)时,My类中没有info这个方法,China类中也没有info这个方法,输出的结果是你是美国人

  1. #!/usr/bin/env python

  2. # _*_ coding:utf-8 _*_

  3. class China:

  4.    pass

  5. class Us:

  6.    def info(self):

  7.        print("你是美国人")

  8. class My(China, Us):

  9.    pass

  10. c = My()

  11. c.info()

执行结果

  1. C:\Python35\python.exe F:/Python_code/sublime/Week06/Day02/class_01.py

  2. 你是美国人

  3. Process finished with exit code 0

面向对象之继承之多继承时的查找顺序

  • 顶层两个类没有父类的情况

object-oriented-basis-03

  • 顶层两个类有父类的情况

object-oriented-basis-04