Python面向对象基础

Posted 2020-09-12

面向对象基本介绍

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()

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

5. obj.ret()

类的内存地址对应关系

面向对象之self

1. #!/usr/bin/env python

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

4. # 创建一个类，类名是Class_basis

5. class Class_basis:

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

7.    def ret(self,):

8.        # 输出self的内存地址

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

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

12. obj = Class_basis()

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

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

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

18. obj.ret()

执行结果

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

2. obj对象内存地址 2420760156536

3. 方法ret的self内存地址 2420760156536

5. Process finished with exit code 0

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

如图

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

面向对象之封装

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

1. 将内容封装到某处

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

1. class Foo:

2.    def ret(self):

3.        # 输出backend变量的内容

4.        print(self.backend)

6. obj = Foo()

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

8. obj.backend = "as"

9. obj.ret()

执行结果

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

2. as

4. Process finished with exit code 0

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

1. class Foo:

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

4.    def __init__(self, name):

6.        """

7.        __init__称之为构造方法

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

9.        """

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

12.        self.Name = name

14.    # 类的方法

15.    def user(self):

16.        # 输出Name的值

17.        print(self.Name)

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

20. obj = Foo("Yangwen")

22. # 执行user方法

23. obj.user()

执行结果

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

2. Ansheng

4. Process finished with exit code 0

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

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

实例

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

1. #!/usr/bin/env python

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

4. class Foo:

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

6.        self.Name = name

7.        self.Age = age

9.    def info(self):

10.        print("""

11.            My name is: %s

12.            My age is: %d

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

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

16. ansheng.info()

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

19. xiaoming.info()

执行结果

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

3.            My name is: Ansheng

4.            My age is: 18

7.            My name is: xiaoming

8.            My age is: 30

11. Process finished with exit code 0

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

面向对象之继承基础

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

实例

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

1. #!/usr/bin/env python

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

4. class People:

5.    def __init__(self):

6.        print("""

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

8.        """)

10. class China(People):

11.    def info(self):

12.        print("""

13.        你是中国人，你的语言是中文，皮肤是黄色

14.        """)

16. class Us(People):

17.    def info(self):

18.        print("""

19.        你是美国人，你的语言是英文，皮肤是黑色

20.        """)

22. c = China()

23. c.info()

25. m = Us()

26. m.info()

执行结果

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

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

6.        你是中国人，你的语言是中文，皮肤是黄色

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

12.        你是美国人，你的语言是英文，皮肤是黑色

15. 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 _*_

4. class China:

5.    def info(self):

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

8. class Us:

9.    def info(self):

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

12. class My(China, Us):

13.    def info(self):

14.        print("我就是我")

16. c = My()

17. c.info()

执行结果

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

2. 我就是我

4. Process finished with exit code 0

   
   

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

1. #!/usr/bin/env python

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

4. class China:

5.    def info(self):

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

8. class Us:

9.    def info(self):

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

12. class My(China, Us):

13.    pass

15. c = My()

16. c.info()

执行结果

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

2. 你是中国人

4. Process finished with exit code 0

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

1. #!/usr/bin/env python

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

4. class China:

5.    pass

7. class Us:

8.    def info(self):

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

11. class My(China, Us):

12.    pass

14. c = My()

15. c.info()

执行结果

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

2. 你是美国人

4. Process finished with exit code 0

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

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

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

本文出自 “一盏烛光” 博客，谢绝转载！