（十七）python 构造函数，实例方法，析构方法，__class__属性

# 此示例示意定义最简单一个类
class Dog:
    '''这个类用于描述一种小动物的行为和属性'''
    pass

dog1 = Dog()  # 创建一个新的Dog类的对象
print(id(dog1))  # 打印这个对象的id

dog2 = Dog()  # 创建另一个Dog类的对象
print(id(dog2))

# 对比
lst1 = list()  # 创建一个空列表
print(id(lst1))

lst2 = list()  # 创建另一个空列表
print(id(lst2))

lst1.append(100)
lst2.append(200)
# dog1.append(10000)  # 只要在类中添加方法就可以实现此操作
# dog2.append(20000)

构造函数:

构造函数调用表达式:
类名([创建传参列表])
作用:
创建这个类的实例对象，并返回此实例对象的引用关系

实例说明:
1.实例有自己的作用域和名字空间，可以为该实例添加实例变量(也叫属性)
2.实例可以调用类方法和实例方法
3.实例可以访问类变量和实例变量

实例方法(method)

语法:
class 类名(继承列表):
def 实例方法(self,形参1,形参2,...)
'''方法的文档字符串'''
语句块
作用:
用于描述一个对象的行为，让此类型的全部对象都拥有相同的行为
说明:
实例方法的实质是函数，是定义在类内的函数
实例方法至少有一个形参，第一个形参代表调用这个方法的实例，一般命名为'self'

实例方法的调用语法:
实例.实例方法名(调用传参):
或
类名.实例方法名(实例,调用传参)

# 此示例示意定义Dog类，并让Dog创建的对象有相同的行为
# 吃，睡，玩

class Dog:
    def eat(self, food):
        print('id为', id(self), "的小狗正在吃", food)

dog1 = Dog()  # 创建一个新的Dog类的对象
print("dog1的id", id(dog1))
dog1.eat('骨头')

dog2 = Dog()
print("dog2的id", id(dog2))
dog2.eat('包子')

# 此示例示意定义Dog类，并可以用help(Dog) 查看类的文档字符串
class Dog:
    '''这是自定义的类, 用来描述小动物行为'''
    def eat(self, food):
        '''描述小狗吃饭的行为...'''
        print("小狗正在吃", food)

    def sleep(self, hour):
        print("小狗睡了", hour, '小时')

    def play(self, obj):
        print("小狗正在玩", obj)

dog1 = Dog()  # 创建一个新的Dog类的对象
dog1.eat('骨头')
dog1.sleep(1)
dog1.play('球')

dog2 = Dog()
dog2.eat('包子')
dog2.sleep(3)
dog2.play('飞盘')

实例属性 attribute (也叫实例变量)

每个实例可以用自己的变量，称为实例变量(也叫属性)
使用语法:
实例.属性名
属性的赋值规则:
1.首次为属性赋值则创建此属性
2.再次为属性赋值则改变属性的绑定关系
作用:
记录每个对象自身的数据

# 此示例示意为每个对象添加实例属性，并通过对象的方法等访问 
class Dog:
    def infos(self):
        print(self.color, '的', self.kinds)

    def eat(self, food):
        '''
        当Dog类型的对象吃东西时，用food 属性记住
        此对象吃的是什么
        '''
        print(self.color, '的', self.kinds,
              '正在吃', food)
        self.food = food

    def food_info(self):
        print(self.color, '的', self.kinds,
            '上次吃的是', self.food)
dog1 = Dog()
dog1.kinds = '京巴'  # 为dog1绑定的Dog对象添加kinds属性
dog1.color = '白色'  # 创建color实例变量 
dog1.color = '黄色'  # 改变实例变量color的绑定关系

dog2 = Dog()  # 另一个对象
dog2.kinds = '导盲犬'
dog2.color = '黑色'

dog1.infos()
dog2.infos()
# print(dog1.color, '的', dog1.kinds)  # 获取属性的数据
# print(dog2.color, '的', dog2.kinds)

dog1.eat('骨头')
dog1.food_info()

# dog2.food_info()  # dog2没有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() # 小张今年 20 岁家庭住址:北京市朝阳区
h2.show_info() # 小李今年 18 岁家庭住址:不详

class Human:
    def set_info(self, n, a, addr='不详'):
        '''此方法为'人', 添加:姓名,年龄，家庭住址属性'''
        self.name = n
        self.age = a
        self.address = addr

    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()  # 小张 今年 20 岁 家庭住址: 北京市朝阳区
h2.show_info()  # 小李 今年 18 岁 家庭住址: 不详

删除属性:

del 语句
语法:
def 对象.属性名

        class Dog:
            pass
        dog1 = Dog()
        dog1.color = '白色'  # 添加属性
        del dog1.color 删除属性

del 语句总结:
1) 删除变量 del a
2) 删除列表中的元素 del L[0]
3) 删除字典中的键 del d['name']
4) 删除对象的属性 del dog1.color

初始化方法:

作用:
对新创建的对象添加属性等初始化操作
语法格式：
class 类名(继承列表):
def __init__(self[,形参列表])
语句块
注: [] 里的内容代表可省略
说明：
1.初始化方法名必须为__init__不可改变
2.初始化方法会在构造函数创建实例后自动调用，且将实例自身通过第一个参数self传入__init__ 方法
3.构造函数的实参将通过 __init__ 方法的参数列表传入到 __init__ 方法中
4.初始化方法内如果需要return语句返回，则只能返回None

class Car:
    def __init__(self, clr, brand, model):
        self.color = clr  # 颜色
        self.brand = brand  # 品牌
        self.model = model  # 型号
        # print('Car的初始化方法被调用')

    def run(self, speed):
        print(self.color, '的', self.brand,
              self.model, '正在以', speed, 
              '公里/小时的速度行驶')

c1 = Car('红色', '奥迪', 'A6')
c1.run(200)

c2 = Car('蓝色', 'TESLA', 'Model S')
c2.run(180)

练习:
写一个学生类，用来描述学生信息
要求:
1) 为该类添加初始化方法，实现在创建时自动设置'姓名','年龄','成绩'属性
2) 添加set_score 方法能为对象修改成绩信息，并限制成绩在0~100之间
3) 添加show_info 方法打印学生对象的信息

        class Student:
            def __init__(......):
                ....
            def set_score(self,score):
                ....
            def show_info(self):
                ....
        s1 = Student('小魏',17,59)
        s2.set_score(68)
        s1.show_info()  # 小魏  今年  17  岁  , 成绩是: 68

class Student:
    def __init__(self,name,age,score=0):
        self.name = name
        self.age = age
        self.score = score
    
    def set_score(self,score):
        if 0 <= score <= 100:
            self.score = score
        else:
            raise ValueError('值不再相应的范围内')

    def show_info(self):
        print(self.name,'今年',self.age,'岁','成绩是:',self.score)
    
s1 = Student('小魏',17,59)
s1.set_score(68)
s1.show_info()  # 小魏  今年  17  岁  , 成绩是: 68

析构方法

语法:
class 类名(继承列表)：
def __del__(self):
语句块
作用:
通常用来释放此对象占用的资源
说明:
1.析构方法会在对象被销毁时自动调用
2.python语句建议不要在对象销毁时做任何事情，因为对象销毁的时间难以确定

# 此示例示意析构方法的用法
class Car:
    def __init__(self, name):
        self.name = name
        print("汽车", name, '对象被创建')

    def __del__(self):
        print("汽车", self.name, '对象被销毁')

c1 = Car("BYD E6")
# del c1
# L = []
# L.append(c1)
c1 = None  # 让c1变量绑定None
while True:
    pass

print("程序结束")

预置的实例属性

__dict__属性

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

示例:
class Dog:
pass

dog1 = Dog()
print(dog1.__dict__) # {}
dog1.color = "白色"
print(dog1.__dict__) # {'color':'白色'}

class属性

__class__属性绑定创建此实例的类(类实例)
作用:
可以借助于此属性来访问创建此实例的类

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

用于类的函数:

isinstance(obj,class_or_tuple)

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

type(obj) 返回对象的类

        isinstance(3.14,float)  # True
        isinstance('hello',str)  # True
        class Dog:
            pass
        dog1 = Dog()
        isinstance(dog1,Dog)  # True

综合练习:
有两个人:
1. 姓名:张三
年龄:35岁
2. 姓名:李四
年龄:8岁
行为:
1.教别人学东西 teach
2.工作赚钱 work
3.借钱 borrow
用程序描述如下事情:
张三教李四学 python
李四教张三学滑冰
张三上班赚了 1000元钱
李四向张三借了 200元钱
显示李四的全部信息
显示张三的全部信息

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

    def teach(self, other, skl):
        other.skill.append(skl)  # other得到了技能
        print(self.name, '正在教', other.name,
              '学', skl)

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

    def borrow(self, other, money):
        '''借钱成功返回True,失败返回False'''
        # 先判断other有没有钱借
        if other.money > money:
            other.money -= money
            self.money += money
            print(other.name, '借给了',
                  self.name, money, '元钱')
            return True
        print(other.name, '没借给', self.name)
        return False  # 借钱失败

    def show_info(self):
        print(self.age, "岁的", self.name,
            '有技能:', self.skill, ',钱包内的钱数是',
            self.money)

zhang3 = Human("张三", 35)
li4 = Human('李四', 8)
zhang3.teach(li4, 'python')
li4.teach(zhang3, '滑冰')

zhang3.work(1000)  # 张三 上班 赚了 1000元钱
li4.borrow(zhang3, 200)  # 李四 向 张三 借了 200元钱

zhang3.show_info()
li4.show_info()

练习:
将之前的学生信息管理
原代码中用字典来保存每个学生信息，现改为用对象来保存每个学生信息
学生类的存于模块student.py中

# file: student.py
class Student:
def __init__(self, n, a, s):
.....
.....
# student_info.py
from student import Student # 导入Student类