Python面向对象

1.__init__的方法
2.属性查找
3.属性的调用
4.绑定关系
5.面向对象三大特性之一：继承与派生

 

知识点一：__init__方法应用

 1.1__init__方法常规格式及操作
  class OldboyStudent:
   school='odlboy'

   def __init__(self,name,age,sex):
    self.name=name
    self.age=age
    self.sex=sex

  stu1=OldboyStudent('杨智宗',27,'male')

  #stu1对象名称空间的内容
  #查看对象名称空间的内容（查）
  print(stu1.name,stu1.age,stu1.sex)   #杨智宗 27 male
  print(stu1.__dict__)                 #{'name': '杨智宗', 'age': 27, 'sex': 'male'}
  #对象名称空间增加内容（增）
  stu1.father='杨俊杰'       # {'name': '杨智宗', 'age': 27, 'sex': 'male', 'father': '杨俊杰'}
  print(stu1.__dict__)
  #改对象名称空间的内容  （改）  #{'name': '杨智宗', 'age': 27, 'sex': 'male', 'father': '杨俊杰'}
  stu1.age=66
  print(stu1.__dict__)   #{'name': '杨智宗', 'age': 66, 'sex': 'male', 'father': '杨俊杰'}
  #删除对象名称空间里面的内容（删）
  del stu1.father
  print(stu1.__dict__)   #{'name': '杨智宗', 'age': 66, 'sex': 'male'}

 1.2类的名称空间、对象的名称空间的查看操作方法
  class OldboyStudent:
   school='odlboy'

   def __init__(self,name,age,sex):
    self.name=name
    self.age=age
    self.sex=sex

  stu1=OldboyStudent('杨智宗',27,'male')

  #类名称空间的内容增加的删除：
  OldboyStudent.name='yangzhizong'
  print(OldboyStudent.__dict__)   #
  print(OldboyStudent.name)   #yangzhizong

  #对象名称空间的内容是不变的
  print(stu1.name)       #杨智宗
  print(stu1.__dict__)   #{'name': '杨智宗', 'age': 27, 'sex': 'male'}
  
# 自己总结:
 1.对象的本质就是一个名称空间，对象名称空间存放着自己独有的名字属性，二类中
   存放的是对象们共有的属性
 1.对象名称空间和类名称空间是各自单独存在的，各自空间里面的增加和删除不会影响彼此
 2.调用类产生对象，调用类的过程就是称为实例化，实例化的结果称为类的一个实例化或者对象
 
 3.stu1=OldboyStudent('杨智宗',27,'male')：
  调用用类的时候发生了2件事：
  stu1=OldboyStudent('杨智宗',27,'male')==》相当与OldboyStudent.__init__(stu1,'杨智宗',27,'male')
  1.创建了一个空对象，即可以理解为stu1（自动传参给self的值）
  2.自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入，如下
  
  class OldboyStudent:
   school='odlboy'

   def __init__(self,name,age,sex):
    self.name=name
    self.age=age
    self.sex=sex
    # print(self)              #self即stu1的值系统自动传给self<__main__.OldboyStudent object at 0x032A1CB0>

  stu1=OldboyStudent('杨智宗',27,'male')
  # print(stu1)                      #<__main__.OldboyStudent object at 0x032A1CB0>     
  
  

  
  
 
  
   
  

知识点二：属性查找
查找顺序也是先从自己名称空间里面找，如果自己里面没有再找类里面的，如果类里面也没有就会报错

 2.1例如下面：stu1里面没有xxx，就会实现从类里面查找
  class OldboyStudent:
   school='odlboy'

   def __init__(self,name,age,sex):
    self.name=name
    self.age=age
    self.sex=sex

  stu1=OldboyStudent('杨智宗',27,'male')
  OldboyStudent.xxx=123                #在类中增加
  print(stu1.__dict__)                #默认对象里面没有xxx{'name': '杨智宗', 'age': 27, 'sex': 'male'}
  print(stu1.xxx)          # 123        #stu1对象里面没有的前提下，去类里面查找

 2.2例如：用count计算对象实例化的次数
  class OldboyStudent:
   school='odlboy'
   count=0
   def __init__(self,name,age,sex,count):
    self.name=name
    self.age=age
    self.sex=sex
    OldboyStudent.count+=1

  stu1=OldboyStudent('李四',19,'male','count')
  stu1=OldboyStudent('张三',21,'female','count')
  stu1=OldboyStudent('王五',25,'male','count')
  print(OldboyStudent.count) #3  拿到执行过程中，实例化的次数

 

 

 

 

知识点三：属性的调用
# 第二节课练习：属性的调用演示
# 类名称空间中定义的数据属性和函数属性都是共享给所有对象用的
# 对象名称空间中定义的只有数据属性，而且时对象所独有的数据属性
# 类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的，
#绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入
# 类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个
class OldboyStudent:
    school='odlboy'
    def update(self):
        print(' update is running')

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def choice_custom(aa,):
        print('%s正在选课'%aa.name,aa.age,aa.sex)

stu1=OldboyStudent('杨智宗',27,'male')

#对象调用类中的函数（主要是绑定给类体对象使用的）
stu1.choice_custom()     #杨智宗正在选课 27 male
stu1.update()            #update is running
#类调用类中的函数（不常用）
OldboyStudent.update(1)  # update is running

# 补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self
#例如：类去调用函数update函数（必须去传参数，相当与使用一个普通函数必须为形参self传值）
# OldboyStudent.update(1)  #
# 辅助理解：
# 1.为什么类去调用函数update函数，stu1.update() #update is running，就不需要传参，
# 因为stu1=OldboyStudent('杨智宗',27,'male')在调用函数的时候，已经创建了一个空对象stu1给到self，所以默认可以直接调用
# 2.OldboyStudent.update(1)  # update is running在调用时必须按照普通函数使用，去给update函数self传值
  
  
   
  

知识点四：绑定关系
  对象去调类体中的函数，叫调用绑定方法
  def choose_course(self)：
  self其实就是一个对象，本质是个名称空间，可以拿到self里面所有的数据，
  相当与拿到了一个容器，后面绑定的函数去调用就很简单。
  
  class OldboyStudent:
   school='oldboy'

   def __init__(self,x,y,z):
    self.name=x  #stu1.name='耗哥'
    self.age=y   ##stu1.age=18
    self.sex=z

   def choose_course(self):
    print('%s is choosing course'%self.name)   #

  stu1=OldboyStudent('耗哥',18,'male')
  stu2=OldboyStudent('猪哥',17,'male')
  stu3=OldboyStudent('帅翔',19,'female')
  stu1.choose_course()
  stu2.choose_course()
  stu3.choose_course()
  print(stu1.name)

  通过对象调用choose_course，结果不同对象，得到的ID相同# print(id(stu1.choose_course()))   #490211520
  print(id(stu2.choose_course()))   #490211520                       自由都有绑定方法指向绑定方法
  print(id(stu3.choose_course()))   #490211520
  #通过类去调用choose_course，得到的id与对象调用得到的id不同
  print(id(OldboyStudent.choose_course))    #77256648                  指向的是类

  类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的，
  绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入
  print(stu1.choose_course)  # 绑定方法  就是绑定给
  <bound method OldboyStudent.choose_course of <__main__.OldboyStudent object at 0x05257C50>>
  stu1.choose_course()

  print(OldboyStudent.choose_course) #函数方法
  <function OldboyStudent.choose_course at 0x0533D7C8>
  
 

知识点五：继承
 强调：继承是类与类之间的关系
 1.什么是继承
 继承是一种新建类的方式，新建的类称为子类，被继承的类称为父类
 继承的特性是：子类会遗传父类的属性
 强制：继承是类与类的关系
 2.为什么要用继承
 继承的功能就是可以减少代码的冗余
 
 python中支持一个类同时继承多个类
 在python3中，如果一个类没有继承，那默认继承object类
 在python2中，如果没有继承，默认不会继承object类
 
 新式类:
  但凡继承了object类以及该类的子类，都是新式类
 
 经典类：
  没有继承object的类以及该类的子类，都是经典类，
 python3中都是新式类，只有在python2中才区别新式类与经典类
 
 
 对象查找属性的顺序：对象自己--》对象的类--》父类--》父类
 
 
 派生：子类中新定义的属性，子类在使用时始终以自己的为准
 
 在子类派生出的新功能中，重用父类功能的方式有两种，
 1.指明道姓访问某一个类的函数：该方式与继承无关
 
 
 
 继承前版本：
 # 继承前版本1：
  class OldboyStudent:          
   school = 'oldboy'
   def __init__(self,name,age,sex):
    self.name=name
    self.age=age
    self.sex=sex

   def choose_course(self):
    print('%s is choosing course' % self.name)

  class OldboyTeacher:
   school = 'oldboy'
   def __init__(self,name,age,sex,level):
    self.name=name
    self.age=age
    self.sex=sex
    self.level=level

   def score(self):
    print('%s is scoreing'%self.name)

  stu1=OldboyStudent('张三',34,'male')
  teal=OldboyTeacher('egon',19,'male',10)

  stu1.choose_course()
  teal.score()

  print(stu1.school)
 

 #继承后版本
  class OldboyPeople:
   school = 'oldboy'
   #老师类和学生类共用的功能
   def __init__(self, name, age, sex):
    self.name = name   #tea1.name='egon'
    self.age = age     #tea1.age='age'
    self.sex = sex     #tea1=.sex='sex'

  class OldboyStudent(OldboyPeople):           #谨记删掉之后是要继承父类

   def choose_course(self):
    print('%s is choosing course' % self.name)

  class OldboyTeacher(OldboyPeople):
  
      tea1  egon  19 male  10
   def __init__(self,name,age,sex,level):
    
    OldboyPeople.__init__(self,name,age,sex)#类去访问的就是个普通函数   #直接引用上一个类的函数，和继承无关
    self.level=level

   def score(self):
    print('%s is scoreing'%self.name)

  stu1=OldboyStudent('张三',34,'male')
  teal=OldboyTeacher('egon',19,'male',10)

  stu1.choose_course()
  teal.score()

  
  在子类派生出的新功能中重用父类功能的方式有两种：
  1.指明道姓访问某一个类的函数：该方式与继承无关
  
  

 

找对象的案列：原则自己--类--父类
 class Foo:                #父类
  def f1(self):
   print('Foo.f1')
  def f2(self):
   print('Foo.f2')   #1.父类里面找到f2并打印  Foo.f2
   self.f1()         #2.然后运行这一行，此时self是bar，所以。。

 class Bar(Foo):
  def f1(self): 
   print('Bar.f1')   #3.回到bar找f1  打印   Foo.f2

 obj=Bar()
 obj.f2()