面向对象的三要素

封装

  1. class Turtle: # python 中的类
  2.     age = 'green'
  3.     weight = 10
  4.     legs = 4
  5.     shell = True
  6.     mouth = '大嘴'
  8.     # 方法
  9.     def climb(self):
  10.         print('我在很努力')
  11.     def run(self):
  12.         print('运行')
  13.     def bite(self):
  14.         print('陶死你')
  15.     def add(self):
  16.         print('加法运算')
  18. t = Turtle()
  19. t.climb()

继承

继承是子类自动共享父类之间数据和方法的机制

  2. '''
  3.     Mylist 继承 list 列表的方法
  4.     pass 表示占位
  6.     Mylist 这个类不做任何事情, 达到信息隐蔽
  7. '''
  8. class Mylist(list):
  9.     pass
  11. # 实例化 Mylist  实例对象
  12. list2 = Mylist()
  13. list2.append(5)
  14. list2.append(9)
  15. list2.append(15)
  17. print(list2)
  18. # 也可以进行排序
  19. print(list2.stor())
  20. ------------------------------- 
  21. >>>>[5, 19, 15] 
  22. >>>>[5, 15, 19]

多态

  2. '''
  3.  多态就是  不同对象 对同一方法 响应不同的行动
  5. '''
  8. class A:
  9.     def fun(self):
  10.         print('我是A对象里的函数')
  13. class B:
  14.     def fun(self):
  15.         print('我是B对象里的函数')
  17. a = A()
  18. b = B()
  20. a.fun()
  21. b.fun()
  22. ------------------
  23. >>>我叫张三, 该死的, 谁踢我....
  24. >>>我叫李四, 该死的, 谁踢我....
  25. >>>我叫小明, 该死的, 谁踢我....

self 是什么?

python的 self 就相当于 JavaScript 中的 this 的指针

  1. # self 指针  相当于 JavaScript中的  this  指针
  2. # 这个类相当于模版一样,
  4. class Ball:
  5.     def setName(self, name):
  6.         self.name = name
  7.     def cick(self):
  8.         print("我叫%s, 该死的, 谁踢我...." %self.name)
  10. a = Ball()
  11. a.setName("张三")
  13. b = Ball()
  14. b.setName("李四")
  16. c = Ball()
  17. c.setName("小明")
  19. a.cick()
  20. b.cick()
  21. c.cick()
  22. --------------------
  23. >>>我叫张三, 该死的, 谁踢我....
  24. >>>我叫李四, 该死的, 谁踢我....
  25. >>>我叫小明, 该死的, 谁踢我....

访问控制与属性装饰器

在python 中定义私有变量 只需要在变量或者函数名前加上 “__” 两个下划线, 那么这个函数或变量就会为私有 外部访问不了 , 同时也称为装饰器

共有变量函数

  1. # 共有 ,可以被外部访问的
  2. class temp:
  3.     age = 18
  4.     def setName(self, name):
  5.         print('我叫:%s' % name)
  7. A = temp()
  8. print(A.age)
  9. A.setName('张三')
  10. -------------------
  11. >>>18
  12. >>>我叫:张三

访问私有变量函数1

  1. '''
  2.     定义私有函数或者变量 在变量或者函数前 添加 __ 双下划线即可
  3.     然后调用共有的方法, 获取内部私有的变量或者函数
  4. '''
  6. class temp:
  7.     __age = 18
  8.     def __setName(self, name):
  9.         print('我叫:%s' % name)
  10.     def getAge(self):
  11.         print('age的值:%s' % self.__age)
  13.     def getName(self,name):
  14.         self.__setName(name)
  15. A = temp()
  16. A.getAge()
  17. A.getName('李四')
  18. ---------------------------------
  19. >>>18
  20. >>>我叫:李四

访问私有变量函数2

  1. class temp:
  2.     __age = 18
  3.     def __setName(self, name):
  4.         # print('我叫:%s' % name)
  5.         return '我叫:%s' % name
  6.     def getAge(self):
  7.         print('age的值:%s' % self.__age)
  9.     def getName(self,name):
  10.         self.__setName(name)
  11. A = temp()
  12. A.getAge()
  13. A.getName('李四')
  15. # 还可以通过 下划线类名 进行访问也可以
  16. print(A._temp__age)
  18. print(A._temp__setName('王五'))
  19. ---------------------------------
  20. >>>age的值:18
  21. >>>18
  22. >>>我叫:王五

类和实例

  1. # 类
  2. class Turbo:
  3.     name = '张三'
  4.     def add(a,b):
  5.         return a + b
  7.  # 实例化 出了 t
  8.  t = Turbo()
  9.  t.name

类方法与静态方法

静态方法 @staticmethod

为什么会报错？

静态方法不能访问实例属性、类属性、实例方法、类方法

  1. class Test2:
  2.     name ="你好世界"
  3.     @staticmethod
  4.     def static(self):
  5.         print("我的口号是:" +self.name)
  6. temp2 = Test2()
  7. temp2.static()
  8. #  static 已经通过  @staticmethod 定义成静态方法, 所以不能直接这样访问,
  9.     因为 self是上下文访问 属性name,  当然也包括这个  self
  11. ---------------------报错
  12. TypeError: static() missing 1 required positional argument: 'self'

静态方法的特别之处

  • 它跟类与对象无关
  • 跟在模块中直接定义普通函数没有什么区别，只是把“静态方法”放到了类里面，所以只能设置形参
  • 只能通过 类名.静态方法 来调用 ```python

class Test: name =”你好世界”

  1. @staticmethod
  2. def static(name):
  3.     print("我的口号是:" +name)

temp = Test()

temp.static(temp.name)

Test.static(temp.name)

我的口号是:你好世界 我的口号是:你好世界

  1. <a name="Bqd4L"></a>
  2. ### 类方法 @classmethod
  3. ```python
  4. class person:
  5.     name = "cool man"
  7.     @classmethod
  8.     def class_m(cls):
  9.         print("--第一个类方法--", id(cls))
  10.         print("--第一个类方法--", cls.name)
  11.         cls.self_m(cls)
  12.         cls.class_m2()
  14.     def self_m(self):
  15.         print("--实例方法--", id(self))
  16.         print("--实例方法--", self.name)
  18.     @classmethod
  19.     def class_m2(cls):
  20.         print("--第二个类方法--", id(cls))
  23. p = person()
  24. p.name = "bad boy"  # 绑定实例属性
  25. p.class_m()
  26. person.class_m()

知识点

  • 类方法内部可以直接访问类属性、类方法、实例方法
  • 可以理解成类对象的引用，哪一个类对象调用的方法， cls 就是哪个一个类的引用， 类对象.类方法 ；和实例方法中的 self 很像， 实例对象.实例方法

cls

  • 调用其他类方法时，不用传递cls参数；但调用其他实例方法时，需要传递cls参数
  • 在类方法内部调用的实例方法，接收的是一个类对象而不是实例对象，当实例对象绑定实例属性时，在实例方法中打印的仍然是类属性；表明类方法无法访问实例属性

  • 一个类只有一个类对象，即使通过实例对象调用类方法，传递的仍然是类对象的引用，所有类方法都被同一个类对象调用

    思考题

    如果方法内部 即需要访问 实例属性，又需要访问 类属性，应该定义成什么方法？
    答案：实例方法，因为可以通过 类对象.类属性 来访问，但在类方法中无法访问实例属性 ```python class Person: name = “bad boy”

    def self_m(self):

    1.   Person.name = "yep"
    2.   print(self.name)

p = Person() p.name = “陈十八” # 绑定实例属性 p.self_m()

Person.self_m(Person)

陈十八 yep

  1. <a name="h3sYt"></a>
  2. ## 继承与多态
  5. <a name="usqCm"></a>
  6. ### 子继承父类
  7. ```python
  9. class Panent:
  10.     def hello(self):
  11.         print('正在调用父类的方法....')
  13. class Child(Panent):
  14.     pass
  16. p = Panent()
  17. p.hello()
  18. c=Child()
  19. c.hello()
  20. -----------
  21. >>>正在调用父类的方法....
  22. >>>正在调用父类的方法....

如果子类中定义与父类同名的方法或者属性, 则会自动覆盖父类对应的方法或属性

  1. class Panent: # 这个是父类
  2.     def hello(self):
  3.         print('正在调用父类的方法....')
  5. class Child(Panent): # 这个是子类
  6.     def hello(self):
  7.         print('正在调用子类的方法....')
  9. p = Panent()
  10. p.hello()
  11. c=Child()
  12. c.hello()
  13. -----------
  14. >>>正在调用父类的方法....
  15. >>>正在调用子类的方法....


小案列

鲨鱼移动 的代码 会报错 为什么呢, 可是代码都相同啊!
因为 我们重写 init方法, 子类重写了父类的方法, 就会覆盖原来的方法

  1. import random as r
  4. class Fish:  # 鱼
  5.     def __init__(self):
  6.         self.x = r.randint(0, 10)
  7.         self.y = r.randint(0, 10)
  9.     def move(self):
  10.         self.x -= 1
  11.         print("我的位置是:", self.x, self.y)
  14. class Goldfish(Fish):  # 金鱼
  15.     pass
  18. class Carp(Fish):  # 鲤鱼
  19.     pass
  22. class Salmon(Fish):  # 三文鱼
  23.     pass
  26. class Shark(Fish):
  27.     def __init__(self):
  28.         self.hungry = True
  30.     def eat(self):
  31.         if self.hungry:
  32.             print("吃货的梦想就是天天有的吃")
  33.             self.hungry = False
  34.         else:
  35.             print("太撑了, 吃不下")
  37. fish = Fish()
  38. fish.move()
  40. goldfish = Goldfish()  # 金鱼移动
  41. goldfish.move()
  43. shark = Shark()  # 鲨鱼移动
  44. shark.move()
  46. ---------------------
  47. 我的位置是: 5 8
  48. 我的位置是: 5 5
  49. Traceback (most recent call last):
  50.   File "e:/001笔记大全/008Python01/demon10.py", line 40, in <module>
  51.     shark.move()
  52.   File "e:/001笔记大全/008Python01/demon10.py", line 8, in move
  53.     self.x -=1
  54. AttributeError: 'Shark' object has no attribute 'x'

我们要在重写init 方法的时候

解决方法1

调用未绑定的父类方法
应该要在鲨鱼的类里面 重写init 方法的时候先调用子类的init方法
只需要书写父类的名字 Fish.init(self)

  1. import random as r
  4. class Fish:  # 鱼
  5.     def __init__(self):
  6.         self.x = r.randint(0, 10)
  7.         self.y = r.randint(0, 10)
  9.     def move(self):
  10.         self.x -= 1
  11.         print("我的位置是:", self.x, self.y)
  14. class Goldfish(Fish):  # 金鱼
  15.     pass
  18. class Carp(Fish):  # 鲤鱼
  19.     pass
  22. class Salmon(Fish):  # 三文鱼
  23.     pass
  26. class Shark(Fish):
  27.     def __init__(self):
  28.         '''
  29.             原理, 子类中有跟父类一样的方法会覆盖父类的方法, 所以在修改前 添加这段代码即可
  30.             注意: Fish.__init__(self)是调用父类的
  31.                  而self 是子类的实列对象
  32.           '''
  33.         Fish.__init__(self)
  34.         self.hungry = True
  36.     def eat(self):
  37.         if self.hungry:
  38.             print("吃货的梦想就是天天有的吃")
  39.             self.hungry = False
  40.         else:
  41.             print("太撑了, 吃不下")
  43. fish = Fish()
  44. fish.move()
  46. goldfish = Goldfish()  # 金鱼移动
  47. goldfish.move()
  49. shark = Shark()  # 鲨鱼移动
  50. shark.move()
  52. ---------------------
  53. 我的位置是: 9 0
  54. 我的位置是: 9 9
  55. 我的位置是: 8 8

解决办法2

使用 super 函数 能够帮我们自动找到基类的方法, 还能帮我们传参数

  1. import random as r
  4. class Fish:  # 鱼
  5.     def __init__(self):
  6.         self.x = r.randint(0, 10)
  7.         self.y = r.randint(0, 10)
  9.     def move(self):
  10.         self.x -= 1
  11.         print("我的位置是:", self.x, self.y)
  14. class Goldfish(Fish):  # 金鱼
  15.     pass
  18. class Carp(Fish):  # 鲤鱼
  19.     pass
  22. class Salmon(Fish):  # 三文鱼
  23.     pass
  26. class Shark(Fish):
  27.     def __init__(self):
  28.         # Fish.__init__(self)
  29.         super().__init__()
  30.         self.hungry = True
  32.     def eat(self):
  33.         if self.hungry:
  34.             print("吃货的梦想就是天天有的吃")
  35.             self.hungry = False
  36.         else:
  37.             print("太撑了, 吃不下")
  39. fish = Fish()
  40. fish.move()
  42. goldfish = Goldfish()  # 金鱼移动
  43. goldfish.move()
  45. shark = Shark()  # 鲨鱼移动
  46. shark.move()
  48. --------------------------------
  49. 我的位置是: 2 0
  50. 我的位置是: 1 9
  51. 我的位置是: 2 3

多重继承

可以继承多重父类的方法
注意, 请尽量避免使用它

  2. class Base1:
  3.     def fun1(self):
  4.         print("我是fun1d.")
  6. class Base2:
  7.     def fun2(self):
  8.         print("我是fun2.")   
  10. class C(Base1, Base2):
  11.     pass
  12. b = C()
  13. b.fun1()
  14. b.fun2()
  15. ---------------------
  16. 我是fun1d.
  17. 我是fun2.

继承与多继承(组合)

思路提示 :
定义一个水池类
水池里有乌龟类, 金鱼类等等
如果使用继承和多继承显然不行, 乱搞
那怎么样才能组成一个和谐的类呢? 使用组合即可

所谓的组合就是把旧类放到新类里, 这样就组合进去了

  1. # 水池组合
  3. class Turtle: # 乌龟
  4.     def __init__(self, x):  # x 表示有多少个乌龟进来
  5.         self.num = x
  8. class Fish: # 金鱼
  9.     def __init__(self, x):  # x
  10.         self.num = x
  13. class Pool: # 水池
  14.     def __init__(self, x, y):
  15.         self.turtle = Turtle(x)
  16.         self.fish = Fish(y)
  18.     def print_num(self):
  19.         print("水池里总共有乌龟 %d 只, 小鱼 %d 条" % (self.turtle.num, self.fish.num))
  22. # 组合就是 把2 个旧类 实列化  放到 新的类里面    那么就把旧类 组合进去了, 
  24. pool = Pool(2,10)
  25. pool.print_num()
  26. --------------------------
  27. 水池里总共有乌龟 1 只, 小鱼 10 条