python3基础17

day17

面向对象编程 Object-Oriented Programming

面向对象三大特征：（***）
封装，继承，多态

什么是对象:
　　对象是指现实世界中的物体或实体

什么是面向对象：
　　把一切看成(对象（实例)），用各种对象之间的关系来描述事务

对象的特征：
1.对象有很多属性（名词或形容词）
  年龄，姓名，性别...
2.对象又很多行为（动作，动词）
　　学习，吃饭，睡觉，踢球，工作...

什么是类
　　拥有相同属性和行为的对象分为一组，即为一个类
　　类是拥有描述对象的工具，用类可以创建此类的对象（实例）
　　
类和对象示意
　车 （类）　　　-------->>　BYD  E6(京A.88888) 实例，对象
　　　　　　　　　　　　-------->>　BYD  X5(京B.00000) 实例，对象
 狗　（类）　　------->  哈士奇（户籍号：00001）
           ------->  导盲犬（户籍号：00002）
 int (类)　　--------> 100(对象)
 　　　　　　　　　　--------> 200(对象)
#创建对象的工厂
类的创建语句　class语句
　　语法：
　　　class 类名（继承列表）:
       '''类文档字符串'''
　　　　　　　实例方法定义
　　　　　　　类变量定义
　　　　　　　类方法定义（@classmethod）
       静态方法定义（@classmethod）
  作用：
  　创建一个类
  　类用于描述对象的行为和属性
  　类用于创建类的一个或多个对象（实例）
  说明：
  　类名必须为标识符（与变量名命名规则相同，建议首字母大写）
　　　类名实质上就是变量，它绑定一个类
　　示例见：
　　　class.py

构造函数
　构造函数调用表达式：
　　类名 ([创建传参列表])
　　
　作用：
　　创建这个类的实例对象，并返回此实例对象的引用关系
　说明：
　　实例有自己的作用域和名字空间，可以为该实例添加实例变量
　（也叫属性）
　　实例也可以调用类方法和实例方法
　　实例可以访问类变量和实例变量　
　示例见：
　　class.py
　
class Dog:
    '''创建一个Dog类，此类用于描述
    一种小动物的行为和属性'''
    pass

dog1 = Dog()   #创建Dog类的一个实例　，自己创建的类型
print(id(dog1))

dog2 = Dog()
print(id(dog2)) #创建Dog类的第二个实例

print('------------------------------')
#对比

lst1 = list()    #系统內建类型
print(id(lst1))

lst2 = list()
print(id(lst2))
　

实例方法()
 语法：
 　class　类名(继承列表):
    def 实例方法名（self,形参名1,形参名2,...）:
    　　　＇方法文档字符串＇
    　　　　语句块
　作用：
　　用于描述一个对象的行为，让此类的全部对象拥有相同的行为

　说明：
　　实例方法的实质是函数，是定义在类内的函数
　　实例方法至少有一个形参，第一个形参用来绑定调用这个方法的实例，
　　一般命名为＇self＇

实例方法调用语句：
　实例.实例方法名（调用传参）
　或
　类名.实例方法名（实例,调用传参）

　示例见：
　instance_method.py

#此示例示意实例方法的定义和调用
class Dog:
    '''创建一个Dog类，此类用于描述
    一种小动物的行为和属性'''
    def eat(self,food):
        '''此方法用来描述小狗吃东西的行为'''
        print('id为：',id(self),"小狗正在吃",food)
    def sleep(self,hour):
        print("小狗睡了",hour,'小时')
    def play(self,obj):
        print("小狗正在玩",obj)

dog1 = Dog()   #创建一个小狗对象
dog1.eat('骨头')  #self绑定的对象是方法的调用者
                  #self绑定的就是dog1
dog1.sleep(1)
dog1.play('皮球')

dog2 = Dog()
dog2.eat('狗粮') #创建第二个小狗
dog2.sleep(3)
dog2.play('飞盘')

实例属性　atrribute(也叫实例变量)
　　每个实例可以有自己的变量用来保存对象自己的数据，称为
　　实例变量（也叫属性）
　语法：
　　实例.属性名
赋值规则同变量的赋值规则
　首次为属性赋值创建此属性
　再次为属性赋值则改变属性的绑定关系

作用：
　记录每个对象自身的数据

示例见：
　attribute.py

#此示例示意为对象添加实例变量（实例属性）及访问实例变量（实例属性）

class Dog:
    def eat(self,food):
        print(self.color,'的',self.kinds,'正在吃',food)
        self.last_food = food
    def show_last_food(self):
        print(self.color,"的",self.kinds,'上次吃的是',self.last_food)
dog1 = Dog()
dog1.kinds = '京巴' #添加实例属性
dog1.color = '白色' #添加 
dog1.color = '黄色' #修改实例属性绑定关系

dog2 = Dog()  #另一个对象
dog2.kinds = '藏獒'
dog2.color = '棕色'
print(dog1.color,'的',dog1.kinds)
print(dog2.color,'的',dog2.kinds)

dog1.eat('骨头')
dog2.eat('窝头')

dog1.show_last_food()
dog2.show_last_food()

练习一：
定义一个＂人＂（Human）类
　class Human:
    def set_info(self,name,age,address='不祥'):
        '''此方法用来给人对象添加姓名，年龄，家庭住址属性'''
    def show_info(self):
        '''此处显示人的信息'''

调用如下：
　h1 = Human()
 h1.set_info('小张',20,'北京东城区')
 h2 = Human()
 h2.set_info('小李',18)
 h1.show_info()
 h2.show_info()

class Human:
    def set_info(self,name,age,address='不祥'):
        #函数内所有的方法在实例方法中都可以使用
        '''此方法用来给人对象添加姓名，年龄，家庭住址属性'''
        self.name = name
        self.age = age
        self.address = address

    def show_info(self):
        '''此处显示人的信息'''
        print('姓名是：',self.name,'年龄是：',self.age,'住址是：',self.address)

h1 = Human()
h1.set_info('小张',20,'北京东城区')
h2 = Human()
h2.set_info('小李',18)
h1.show_info()
h2.show_info()

del语句
　可以删除对象（实例）的属性
　
　语法：
　　del 对象.实例变量名

 示例：
 class Dog:
     pass
dog1 = Dog()
dog1.color = '白色'
print(dog1.color)   #白色
del dog1.color    #删除属性
print(dog1.color)  #AttributeError属性错误

del语句小结：
1.删除变量　　del name
2.删除列表中的元素 del L[1],del L[::2]
3.删除字典的键   del d['name']
4.删除对象的属性　　del dog.color

初始化方法
　作用：
　　对新创建的对象添加属性

　语法格式：
　　class 类名（继承列表）:
      def __init__(self,[形参列表]):
          语句块
 注：[]代表其中的内容可以省略

 说明：
 1.初始化方法名必须为＇__init__＇不可改变
 2.初始化方法会在构造函数创建实例后自动调用，且实例自身通过一个  参数self传入__init__方法
 3.构造函数的实参将通过__init__方法的参数列表传入到__init__   方法中
　4.初始化方法如果需要return语句返回，则只能返回None

 示例见：
　　init_method.py

#此示例示意初始化方法的定义，及初始化方法对新建对象添加属性

class Car:
     '''小汽车类'''
     def __init__(self, c, b, m):
         self.color = c  #颜色
         self.brand = b  #品牌
         self.model = m  #形号
         print("初始化方法被调用")
     def run(self,speed):
         print(self.color, '的', self.brand,self.model,
              '正在以',speed,'公里/小时的速度行驶')

a4 = Car('红色','奥迪','a4')  #构造函数
a4.run(199)

#调用时直接传参利用初始化方法，为对象添加属性

t1 = Car('蓝色','TESLA','Model S')
t1.run(230)

练习二：
写一个Student类，此类创建的对象有三个属性：
　姓名，年龄，成绩
(1)用初始化方法为该类添加上述三个属性
(2)添加set_score()方法能为对象修改学生成绩
(3)添加show_info()方法，打印学生信息
如：
　
class Student:
    def __init__(self,name,age,score=0):
        self.name = name
        self.age = age
        self.score = score
        #self.name,self.age,self.score = name,age,score #序列赋值
        #name,age,score非全局变量，非局部变量，为对象自己的变量

    def set_score(self,score):
        if 0<= score <=100:
            self.score = score
    def show_info(self):
        print(self.name, self.age, '岁,成绩：',self.score)
L = []
L.append(Student('小张',20,100))
L.append(Student('小李',18,95))
L.append(Student('小魏',8))
print(L)
L[2].set_score(70)
for obj in L:
    obj.show_info() 

析构方法
　class 类名(继承列表):
　　　　def __del__(self):
         语句块
 形参列表只能写self
　析构方法在对象被销毁时被自动调用
　python语言建议不要在对象销毁时做任何事情，因为销毁时间难以确定

示例见：
　del_method.py

class Car:
     #在对象创建之后被调用
    def __init__(self,info):
        self.info = info
        print('汽车对象',info,'被创建')

     #在删除变量之前会执行，验证对象什么时候被销毁
    def __del__(self):
        print('汽车对象',slef.info,'被销毁')

c1 = Car('BYD E6')
c1 = None   #改变对象的绑定关系可以释放BYD E6对象
del c1      #删除变量，释放对象
L = []
L.append(Car('汽车１'))    
L.append(Car('汽车２'))
L.append(Car('汽车３'))   
del L       #释放列表
input('请输入回车键继续执行程序：')
print('程序退出')

预置实例属性
　__dict__属性
　__dict__属性绑定一个存储此实例自身变量字典

示例：
　class Dog:
    pass
 dog1 = Dog()
 print(dog1.__dict__)
 #{}
 dog1.color = '白色'
 print(dog1.__dict__)
 #{'color':'白色'}
 dog1.kind = '京巴'
 print(dog1.__dict__)
 #{'color':'白色','kinds':'京巴'}

__class__属性
'__class__'属性绑定创建此实例的类

作用：
　可以借助此属性来访问创建此实例的类

示例:
class Dog:
    pass
dog1 = Dog()
print(dog1.__class__)
dog2 = dog1.__class__()
print(dog2.__class__)

#Dog绑定的是一个类

用于类（对象/实例）的函数：

 isinstance(obj, class_or_tuple)返回这个对象obj是否是某个类的对象或者某些类中的一个类的对象
 ，如果是则返回True，否则返回False

 type(obj)  返回对象的类型

class Dog:
    pass
dog1 = Dog()
isinstance(dog1,int)  #False
isinstance(dog1,Dog)  #True

isinstance(3.14,(int,tuple,str))  #False
isinstance(3.14,(int,str,float))  #True

type(3.14)('123.455')   #True
type(dog1) 等同于 dog1.__class__

练习三：
面向对象的综合示例：
　　有两个人：
　　　　属性
　　　　　1.姓名：张三，年龄：35岁
　　　　　2.姓名：李四，年龄：8岁
　　　　行为：
　　　　　1.教别人学东西　　teach
　　　　　2.工作赚钱　　　work
　　　　　3.借钱　　　borrow
   
　事情：
　　张三　教　李四　学　pyhton
　　李四　教　张三　学　王者荣耀
　　张三　上班赚了　1000　元钱
　　李四　向　张三　借了　200　元钱
　　35　岁的　张三　有钱　800元，它学会的技能: 王者荣耀
　　8　岁的　李四　有钱 200元，它学会的技能: python

class Human:
    def __init__(self,n,a):
        self.name = n    #姓名
        self.age = a   #年龄
        self.money = 0   #钱数为0
        self.skill = []  #技能列表

    def teach(self,other,skill):
        print(self.name,'教',other.name,'学',skill)
        other.skill.append(skill)   #让other添加技能

    def work(self,m):
        print(self.name,'上班赚了',m,'元钱')
        self.money += m

    def borrow(self,other,m):
        if other.money > m:
            print(self.name,'向',other.name,'借',m,'元钱')
            other.money -= m
            self.money += m
        else:
            print(other.name,'没有借钱给',self.name)
            
    def show_info(self):
        print(self.age,'岁的',self.name,'有钱',self.money,
               '元，它学会的技能：',
             '，'.join(self.skill))

zhang3 = Human('张三',35)
li4 = Human('李四',8)
#张三　教　李四　学　pyhton
zhang3.teach(li4,'python')
# 　　李四　教　张三　学　王者荣耀
li4.teach(zhang3,'王者荣耀')
# 　　张三　上班赚了　1000　元钱
zhang3.work(1000)
# 　　李四　向　张三　借了　200　元钱
li4.borrow(zhang3,200)
# 　　35　岁的　张三　有钱　800元，它学会的技能: 王者荣耀
zhang3.show_info()
# 　　8　岁的　李四　有钱 200元，它学会的技能: python
li4.show_info()

课后练习：
1.看懂全部面向对象的综合示例：
2.将学生信息管理程序，原来由字典保存每个学生的信息，现改为用对象来保存学生信息
要求：
　用student类来描述，将student类写在独立模块：
　student.py中