Three---面向对象与面向过程/属性和变量/关于self/一些魔法方法的使用/继承 ...

python的面向对象

面向对象与面向过程

面向过程

• 面向过程思想：需要实现一个功能的时候，看重的是开发的步骤和过程，每一个步骤都需要自己亲力亲为，需要自己编写代码（自己来做）
  

面向对象

• 面向对象的三大特征：封装性、继承性、多态性
  
• 面向对象思想：需要实现一个功能的时候，看重的并不是过程和步骤，而是关心谁帮我做这件事（偷懒，找人帮我做）
  

类与对象

• 对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另一个新的概念——类
  
• 类：抽象的，是一张“手机设计图”
  
• 对象：具体的，是一个“真正的手机实例”
  
• 类是抽象的，在使用的时候通常会找到这个类的一个具体的存在；一个类可以找到多个对象
  

1. #学生案例
2. class Student():   #创建一个学生类
3.     #定义一个info函数，并传参至self本身
4.     def info(self,name,age,sex):   
5.         print('学生的姓名是：',self.name)
6.         print('学生的年龄是：',self.age)
7.         print('学生的性别是：',self.sex)
9. yinianji = Student()   #创建一个具体的对象：一年级
10. yinianji.info()   #实例化对象调用定义的info函数

复制代码

案例

当创建一个对象时，就是用一个模子来制造一个实物

1. #案例
2. class Dog():   #定义一个类的形式
4.     #info是一个实例方法，类对象可以调用实例方法，实例方法的第一个参数一定是self
6.     def info(self):
7.    
8.     #当对象调用实例化方法时，python会自动将对象本身的引用作为参数，传递到实例方法的第一个参数self里面
9.         print(self)
10.         print("狗祖宗")
12. #Dog这个类实例化了一个对象 jinmao
13. jinmao = Dog()
15. #对象调用实例化方法info()，执行info()中封装的代码 .表示选择属性或方法
16. jinmao.info()
18. #打印对象，则默认打印对象在内存中的地址，结果等同于info中的print(self)
19. print(jinmao)
21. #id(taidamier)则时内存地址的十进制形式表示
22. print(id(jinmao))
23. -----------------------------------------------------------
24. <__main__.Dog object at 0x00000190A9DC67F0>
25. 狗祖宗
26. <__main__.Dog object at 0x00000190A9DC67F0>
27. 1720836712432

复制代码

属性和变量

属性和变量的区别

• 属性：指某个对象的具体特性
  
• 变量：指可以更改的量
  

属性和变量的判断依据

• 根据宿主判断：变量无宿主，属性有宿主
  
• 根据宿主的不同又分为对象属性以及类属性
  

对象属性获取

• 对象既然有实例方法，也可以有自己的属性
  
• 在方法内通过self获取对象属性
  

1. #对象属性获取
2. class Dog():   #定义一个狗类
4.     def move(self):    #移动实例方法
5.         print("moving...")
7.     def attack(self):   #咬人实例方法
8.         print("咬人")
10. #实例化一个狗对象 jinmao
11. jinmao = Dog()
13. #给对象添加属性，以及对应的属性值
14. jinmao.name = "xiao"
15. jinmao.hp = 200
16. jinmao.atk = 40
17. jinmao.armor = 100
19. #通过.成员选择运算符，获取对象的属性值
20. print("%s 的生命值为：%d" %(jinmao.name,jinmao.hp))
21. print("%s 的攻击力为：%d" %(jinmao.name,jinmao.atk))
22. print("%s 的护甲值为：%d" %(jinmao.name,jinmao.armor))
24. #通过.成员选择运算符，获取对象的实例方法
25. jinmao.move()
26. jinmao.attack()
27. -----------------------------------------------------------
28. xiao 的生命值为：200
29. xiao 的攻击力为：40
30. xiao 的护甲值为：100
31. moving...
32. 咬人

复制代码

关于self

• self就是实例化对象本身
  

1. #关于self
2. class A:
3.     def f(self,data):
4.         print(self.name)
5.         print(data)
7. o = A()
9. print(A.f)
10. print(o.f)
11. -----------------------------------------------------------
12. <function A.f at 0x000002725D28ADC0>
13. <bound method A.f of <__main__.A object at 0x000002725D2467F0>>

复制代码

• 其中A.f对应的时function 即为一个普通的函数
  
• o.f为bound method 即在函数上绑定了一个对象 —— o
  
• 结论：o.f 是返回了一个method object ，而当去调用这个object时，他会记住被创建时绑定的对象，即返回该对象，默认参数为self
  

魔法方法

魔法方法__init__()

__init__方法可以在创建对象时就拥有一些属性，__init__通常用来做属性初始化 或 赋值 操作

• 如果类没有写__init__方法,python会自动创建，但不会执行任何操作
  
• 所以一个类里无论自己是否编写__init__方法 都一定有__init__方法
  

案例一

1. #init方法
2. class Dog():
3. #方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用
4.     def __init__(self,name,hp) -> None:
5.         #__init__方法也可以带参数
6.         self.name = name
7.         self.hp = hp
8.         print(self.name,self.hp)
10. #实例化一个对象，并自动调用__init__方法
11. xiaohuang = Dog("小黄",200)
12. ---------------------------------------------------------
13. class Dog():
15.     def f(self,name,hp):
16.         self.name = name
17.         self.hp = hp
18.         print(self.name,self.hp)
19.         
20. xiaohuang = Dog()
21. xiaohuang.f("小黄",200)

复制代码

案例二

1. #init方法二
2. class Dog():
3.    
4.     def __init__(self,name,skill,hp) -> None:
5.         
6.         self.name = name
7.         self.skill = skill
8.         self.hp = hp
9.         
10.     def move(self):
11.         print("%s 正在前往事发地点..." % self.name)
13.     def attack(self):
14.         print("%s 咬人 %s..."%(self.name,self.skill))
16.     def info(self):
17.         print("%s 的生命值：%d"%(self.name,self.hp))
19. #实例化对象时，参数会传递到对象的__init__()方法中
20. jinmao = Dog("金毛","连环咬",200)
21. hashiqi = Dog("哈士奇","不松口",300)
23. #直接输出对象即为地址
24. print(jinmao)
25. print(hashiqi)
27. #不同对象的属性值的单独保存
28. print(id(jinmao.name))
29. print(id(hashiqi.name))
31. #同一个类的不同对象，实例方法共享
32. print(id(jinmao.attack))
33. print(id(hashiqi.attack))
34. -----------------------------------------------------------
35. <__main__.Dog object at 0x000001A3209367F0>
36. <__main__.Dog object at 0x000001A32089F250>
37. 1800138028976
38. 1800138029168
39. 1800131850880
40. 1800131850880

复制代码

总结

• 在类内部获取 属性 和 实例方法，通过self获取
  
• 在类外部获取 属性 和 实例方法，通过对象名获取
  
• 如果有一个类有多个对象，每个对象的属性时各自保存的，都有各自独立的地址
  
• 实例方法时所有对象共享的，只占用一份内存空间
  
• 类会通过self来判断是哪个对象，调用了实例方法
  

魔法方法__str__()

该方法用来显示信息，通过一个字符串来描述实例对象，该方法需要return一个数据，并且只有self一个参数，在类的外部时用print(对象)打印这个数据（面向用户）

1. #str方法
2. class Person():
4.     def __init__(self,name,age):
6.         self.name = name
8.         self.age = age
10.     def __str__(self):
12.         return "此人姓名为%s,此人的年龄为%s"%(self.name,self.age)
14. p1 = Person("李四",18)
16. P2 = Person("王五",19)
18. print(p1)
19. print(P2)
20. -------------------------------------------------------------
21. 此人姓名为李四,此人的年龄为18
22. 此人姓名为王五,此人的年龄为19

复制代码

1. 触发方式：
2. 1、直接通过print函数去打印
3. 2、通过出发str函数进行转换

复制代码

魔法方法__repr__()

通过一个字符串描述实例对象的信息（面向开发人员）

1. #repr方法
2. class Person():
4.     def __init__(self,name,age):
6.         self.name = name
8.         self.age = age
10.     def __str__(self):
12.         return "此人姓名为%s,此人的年龄为%s"%(self.name,self.age)
14. p1 = Person("李四",18)
16. P2 = Person("王五",19)
18. print(repr(p1))
19. print(P2)
20. -------------------------------------------------------------
21. <__main__.Person object at 0x000001E7D9FD67F0>
22. 此人姓名为王五,此人的年龄为19

复制代码

1. #修改repr值
2. class Person():
4.     def __init__(self,name,age):
6.         self.name = name
8.         self.age = age
10.     def __str__(self):
12.         return "此人姓名为%s,此人的年龄为%s"%(self.name,self.age)
14.     def __repr__(self):   #更改repr参数值
16.         return "self"
18. p1 = Person("李四",18)
20. P2 = Person("王五",19)
22. print(repr(p1))
23. print(repr(P2))
24. print(P2)
25. -------------------------------------------------------------
26. self
27. self
28. 此人姓名为王五,此人的年龄为19

复制代码

repr与str

在输出值时当存在str方法便会优先输出str，repr可以面向开发者，同样repr方法也可以作为一种方法去输出str

1. #repr与str
2. import datetime
4. t = datetime.datetime.now()
6. print(t)   #此处输出的为datetime库中的类对应的str字符串
8. print(repr(t))   #同时输出repr进行对比
9. -------------------------------------------------------------
10. 2022-07-15 23:53:55.418332   #此为对应字符串输出值
12. datetime.datetime(2022, 7, 15, 23, 53, 55, 418332)   #此为repr值

复制代码

1. #通过eval函数输出repr
2. import datetime
4. t = datetime.datetime.now()
6. print(t)   #此处输出的为datetime库中的类对应的str字符串
8. tmp = repr(t)
10. result = eval(tmp)   #使用eval函数执行输出repr值的t
12. print(result)
13. -------------------------------------------------------------
14. 2022-07-16 00:00:31.144619
15. 2022-07-16 00:00:31.144619

复制代码

魔法方法__del__()

创建对象后，python解释器默认调用__init__()方法
当删除一个对象时，python解释器也会默认调用一个方法，这个方法叫__del__()

1. #del方法
3. class Dog():
4.     #创建对象后__init__方法会自动被调用
5.     def __init__(self, name):
6.         print("__init__方法被调用",name+"出生了")
7.         self.name = name
9.     #当对象执行完毕被删除时，__del__方法会自动被调用
10.     def __del__(self):
11.         print("__del__方法被调用%s死了"%(self.name))
14. jinmao = Dog("金毛")
15. ---------------------------------------------------------
16. __init__方法被调用 金毛出生了
17. __del__方法被调用金毛死了

复制代码

继承

• 子类可以重写父类的属性和方法后，依然可以调用父类的属性和方法
  
• 使用super方法调用父类
  
• 多层继承关系同样可以实现
  
• 装饰器
  

1. class Dog():   #创建父类Dog
2.    
3.     def __init__(self) -> None:
4.         self.name = "dog dad"
5.     def skill_dad1(self):
6.         print("attack people")
8. class Dog2():   #创建父类Dog2
10.     def __init__(self) -> None:
11.         self.name = "dog mom"
12.     def skill_mom1(self):
13.         print("attack dog")
14.     def skill_mom2(self):
15.         print("摇尾巴")
17. class Son(Dog,Dog2):   
18. #创建子类Son并继承父类Dog和Dog2，继承时优先继承第一个父类Dog
20.     def __init__(self) -> None:
21.         self.name = "dog son"
22.     def skill(self):
23.         print("lick people")
24.     def dad_skill(self):   
25.         #通过super方法进行调用父类所定义的函数与方法
26.         super().__init__()   
27.         super().skill_dad1()
28.     def mom_skill(self):
29.         super().__init__()
30.         super().skill_mom1()
31.         super().skill_mom2()
32.    
34. jinmao = Son()
35. jinmao.dad_skill()
36. jinmao.mom_skill()
37. --------------------------------------------------------------
38. attack people
39. attack dog
40. 摇尾巴

复制代码

多态

• 不同的子对象调用相同的父类放啊，产生不同的结果（继承+重写）
  
• 一个父类可以拥有多个子类继承
  

1. #多态
2. class Dog():
3.     def __init__(self) -> None:
4.         self.name = "dog mom"
6.     def skill(self):
7.         print("attack dog")
9. #子类/派生类
10. class Son1(Dog):
11.     def skill(self):
12.         print("attack man")
14. class Son2(Dog):
15.     def skill(self):
16.         print("attack woman")
18. class Son3(Dog):
19.     def skill(self):
20.         print("attack child")
22. #实例化
23. son1 = Son1().skill()
24. son2 = Son2().skill()
25. son3 = Son3().skill()
26. ---------------------------------------------------------
27. attack man
28. attack woman
29. attack child

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！