python笔记(18)--类的命名空间、实例化绑定方法和类的组合用法

内容目录：

• 类的命名空间
• 实例化的绑定方法
• 类的组合用法

面向对象回顾：

示例一：人狗大战：

class Dog:
    def __init__(self,name,blood,aggr,kind):
        self.name = name
        self.blood = blood
        self.aggr = aggr
        self.kind = kind
    def bite(self,person):
        #狗咬人，人掉血
        person.hp -= self.aggr
        print('狗咬人，人剩了%s血'%(person.hp))

class Person:
    def __init__(self,name,blood,aggr,sex):
        #self就是一个可以存储很多属性的大字典
        self.name = name
        self.hp = blood
        self.aggr = aggr
        self.sex = sex
    def attack(self,dog):
        dog.blood -= self.aggr
        print('人打狗，狗剩了%s血'%(dog.blood))

jin = Dog('金老板',100,20,'teddy')
alex = Person('alex',1000,10,'男')
Dog.bite(jin,alex)
Person.attack(alex,jin)

示例二：计算圆的周长和面积：

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi*(self.r**2)
    def perimeter(self):
        return 2*pi*self.r

obj = Circle(5)
area = obj.area()
perimeter = obj.perimeter()
print(area,perimeter)

• 定义类

  class 类名:     #-----定义类
      变量 ：     #-----类属性，静态属性
      def 函数:   #-----方法，动态属性
  

• init方法

  • python帮我们创建了一个对象self
  • 每当我们调用类的时候都会自动触发这个方法，默认传self
  • 在init方法里可以对self进行赋值

• self是什么 self拥有属性都属于对象

  • 在类的内部，self就是一个对象

• 实例化

  • 对象 = 类（参数是init方法的）

• 实例 = 对象

  • 两者之间没有区别

• 对象查看属性

  • 对象.属性名

• 对象调用方法

  • 对象.方法名(参数)

内容详细：

1.类的命名空间

• 类中的静态变量，可以被实例后的对象和类本身调用

• 类中的变量无法被实例化后的对象修改

• 对于不可变数据类型来说，类变量最好用类名操作

• 对于可变数据类型来说，对象名的修改是共享的，重新赋值是独立的

  class Course:
      language = 'Chinese'
      pice = ['北京','上海']
      def __init__(self,teacher,course_name,period,price):
          self.teacher = teacher
          self.name = course_name
          self.period = period
          self.price = price
      def func(self):
          pass
  
  Course.language = 'English'
  # Course.__dict__['language'] = 'CHINA'      #不能修改内部默认的字典，修改无效
  print(Course.language)              # English
  python = Course('alec','python','6 months',2000)
  linux = Course('oldboy','linux','4 months',1000)
  
  #对于类中静态不可变类型来说，实例化对象不可修改类中静态变量，只能重新在自己开辟的空间中创建赋值
  python.language = 'python'      #重新开辟内存空间，重新赋值language = 'python'
  print(Course.language,python.language)     #English python
  linux.language = 'linux'        #重新开辟内存空间，重新赋值language = 'linux'
  print(Course.language,linux.language)       #English linux
  
  #对于类中静态可变类型来说，实例化对象修改了相当于对类中变量修改
  python.pice[0] = '郑州'
  print(Course.pice,python.pice)             #['郑州', '上海'] ['郑州', '上海']
  linux.pice[1] = '广州'
  print(Course.pice,linux.pice)              #['郑州', '广州'] ['郑州', '广州']
  

练习：

• 创建一个类，每实例化一个对象就计数一次。最终所有的对象共享这个数据

  class Foo:
      count = 0
      def __init__(self):
          Foo.count += 1
  
  
  f1 = Foo()
  f2 = Foo()
  print(f1.count)     #2
  print(f2.count)     #2
  
  f3 = Foo()
  print(f1.count)     #3
  

2.实例化的绑定方法

• 实例化调用方式时，内存空间为重新开辟后的地址

  class Foo:
      def func(self):
          print('func')
      def inner(self):
          pass
  f1 = Foo()
  print(Foo.func) #<function Foo.func at 0x000002C48D8FBA60>
  print(f1.func)  #<bound method Foo.func of <__main__.Foo object at 0x000002C48D8F9470>>
  print(f1.inner) #<bound method Foo.inner of <__main__.Foo object at 0x000002C48D8F9470>>
  #实例化调用方法bound到类中的方法
  

3.类的组合用法

• 组合：最起码为两个类以上才能用到组合

  class Dog:
      def __init__(self,name,aggr,hp,kind):
          self.name = name
          self.aggr = aggr
          self.hp = hp
          self.kind = kind
      def bite(self,person):
          person.hp -= self.aggr
  
  class Person:
      def __init__(self,name,aggr,hp,sex):
          self.name = name
          self.aggr = aggr
          self.hp = hp
          self.sex = sex
          self.money = 0
      def attack(self,dog):
          dog.hp -= self.aggr
      def get_weapon(self,weapon):
          if self.money >= weapon.price:
              self.money -= weapon.price
              self.weapon = weapon
              self.aggr += weapon.aggr
          else:
              print('余额不足')
              
  class Weapon:
      def __init__(self,name,aggr,njd,price):
          self.name = name
          self.aggr = aggr
          self.njd = njd
          self.price = price
      def hand18(self,person):
          if self.njd >=0:
              person.hp -= self.aggr * 2
              self.njd -= 1
  
  alex = Person('alex',10,100,'男')
  jin = Dog('金老板',100,500,'teddy')
  w = Weapon('打狗棒',100,3,998)
  
  alex.money += 1000
  alex.get_weapon(w)
  print(alex.aggr)
  
  alex.attack(jin)
  print(jin.hp)
  alex.weapon.hand18(jin)				#两个类组合
  print(jin.hp)