面向对象：
把一切看做对象（实例），用各种对象之间的关系来描述事务
对象：
定义：
现实生活中的物体或实体
特征：
对象有很多属性（名词或形容词） 年龄，姓名，性别．．．
对象有很多行为（动作，动词） 学习，吃饭，睡觉，工作．．．
类：
拥有相同属性和行为的对象分为一组，即一个类
类是用来描述对象的工具，用类可以创建此类的对象（实例）
类和对象示意：
车（类） -----------> BYD E6(京A.88888)（实例，对象）
-----------> BMW X5(京B.00000)（实例，对象）
狗（类） -----------> 哈士奇（户籍号：00001）（实例，对象）
-----------> 金毛（户籍号：00002）(实例，对象)
int(类) -----------> 100(实例，对象)
-----------> 200(实例，对象)
class语句：
语法：
class 类名(继承列表):
'''类文档字符串'''
实例方法定义
类变量定义
类方法定义（@classmethod）
静态方法定义（@staticmethod）
作用：
创建一个类
类用于描述对象的行为和属性
类用于创建此类的一个或多个对象（实例）
说明：
类名必须为标识符（与变量名命名规则相同，建议首字母大写）
类名实质上就是变量，它绑定一个类
示例：
class Dog:
'''创建一个Dog类，此类用于描述一种小动物的属性和行为'''
pass
dog1 = Dog()
print(id(dog1))
dog2 = Dog()
print(id(dog2))
print('----------------')
# 对比
lst1 = list()
print(id(lst1))
lst2 = list()
print(id(lst2))
构造函数：
调用表达式：
类名([创建传参列表])
作用：
创建这个类的实例对象，并返回此实例对象的引用关系
说明：
实例也有自己的作用域和命名空间，可以为该实例添加实例变量（属性）
实例可以调用类方法和实例方法
实例可以访问类变量和实例变量
实例方法：
语法：
class 类名(继承列表):
def 实例方法名(self, 形参名１, 形参名２, ...):
'方法文档字符串'
语句块
作用：
描述一个对象的行为，让此类的全部对象都拥有相同的行为
说明：
实例方法的实质是函数，是定义在类内的函数
实例方法至少有一个形参，第一个形参用来绑定调用这个方法的实例，一般命名为＂self＂
调用：
实例.实例方法名(调用传参)
或
类名.实例方法名(实例, 调用传参)
示例：
# 此示例示意实例方法的定义和调用
class Dog:
'''创建一个Dog类，此类用于描述一种小动物的属性和行为'''
def eat(self, food):
'''此方法用来描述小狗吃东西的行为'''
print('小狗正在吃' + food)
def sleep(self):
print("小狗在睡觉")
def play(self, obj):
print("小狗在玩" + obj)
dog1 = Dog()
dog1.eat("狗粮")
dog1.play("球")
dog2 = Dog()
dog2.eat("骨头")
dog2.sleep()
实例属性：
每个实例可以有自己的变量用来保存对象自己的数据，称为实例变量（属性）
语法：
实例.属性名
赋值规则：
同变量的赋值规则
首次为属性赋值创建此属性
再次为属性赋值改变属性的绑定关系
作用：
记录每个对象自身的数据
示例：
# 此示例示意对象添加实例变量（属性）及访问实例变量（属性）
class Dog:
def eat(self, food):
print(self.color, '的', self.kind, '正在吃', food)
self.last_food = food
def show_last_food(self):
print(self.color, '的', self.kind, '上次吃的是', self.last_food)
dog1 = Dog()
dog1.kind = "京巴"
dog1.color = "白色"
dog1.color = "黑色"
dog2 = Dog()
dog2.kind = "藏獒"
dog2.color = "棕色"
print(dog1.color, '的', dog1.kind)
print(dog2.color, '的', dog2.kind)
dog1.eat("狗粮")
dog2.eat("骨头")
dog1.show_last_food()
dog2.show_last_food()
初始化方法：
作用：
对新创建的对象添加属性
语法格式：
class 类名(继承列表):
def __init__(self, [形参列表]):
语句块
说明：
初始化方法名必须为'__init__'不可改变
初始化方法会在构造函数创建实例后自动调用，且将实例自身通过第一个参数self传入__init__方法
构造函数的实参将通过__init__方法的参数列表传入到__init__方法中
初始化方法内如果需要return 语句返回，则只能返回None
示例：
# 此示例示意初始化方法的定义及使用初始化方法对新建对象添加属性
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)
析构方法：
语法：
class 类名(继承列表):
def __del__(self):
语句块
作用：
析构方法在对象被销毁时自动调用
python建议不要再对象销毁时做任何事，因为销毁时间不确定
示例：
# 此示例示意析构方法的使用
class Car:
def __init__(self, info):
self.info = info
print("汽车对象", self.info, "被创建")
def __del__(self):
print("汽车对象", self.info, "被销毁")
c1 = Car("BYD")
# 改变c1绑定的对象，之前的对象被销毁
c1 = None
# 删除变量，释放对象
del c1
L = []
L.append(Car("BMW"))
del L
input("请输入回车键继续执行程序：")
print("程序退出")
预置实例属性：
__dict__属性：
__dict__属性绑定一个存储此实例自身变量的字典
示例：
class Dog:
pass
dog1 = Dog()
print(dog1.__dict__) #{}
dog1.color = "white"
print(dog1.__dict__) #{'color': 'white'}
dog1.kind = "京巴"
print(dog1.__dict__) #{'color': 'whilte', 'kind': '京巴'}
__class__属性：
"__class__"属性绑定创建此实例的类
作用：
可以借助此属性访问创建此实例的类
示例：
class Dog:
pass
dog1 = Dog()
print(dog1.__class__)
dog2 = dog1.__class__()
print(dog2.__class__)
del语句：
可以删除对象（实例）的属性
语法：
del 对象.实例变量名
示例：
class Dog:
pass
dog1 = Dog()
dog1.color = 'white'
print(dog1.color)
del dog1.color
print(dog1.color)
小结：
１）删除变量
２）删除列表元素
３）删除字典的键，释放值
４）删除对象的属性
用于对象的函数：
isinstance(obj, class_or_tuple)
返回这个对象obj是否是某个类的对象或者某些类中的一个类的对象，如果是则返回True，否则返回False
type(obj)
返回对象类型
面向对象的综合示例：
两个人：
属性：
１．姓名： 张三 年龄：３５岁
２．姓名： 李四 年龄：８岁
行为：
１．教别人学 teach
２．工作赚钱 work
３．借钱 borrow
事情：
张三 教 李四 学 python
李四 教 张三 学 王者荣耀
张三 上班赚了 1000 块
李四 向 张三 借了 200 块
35 岁的 张三 有钱 800块，他学会了技能： 王者荣耀
8 岁的 李四 有钱 200块，他学会了技能： python
# example.py
class Human:
def __init__(self, name, age, money=0):
self.name = name
self.age = age
self.money = money
self.skill = []
def teach(self, obj, skill):
obj.skill.append(skill)
print(self.name, "教", obj.name, "学会了", skill)
def work(self, money):
self.money += money
print(self.name, "工作赚了", money, "元")
def borrow(self, obj, money):
if self.money > money:
self.money -= money
obj.money += money
print(self.name, "借了", obj.name, money, "元")
else:
print(self.name, "没有借钱给", obj.name)
def show_info(self):
print(self.age, "岁的", self.name, "有钱", self.money,
"元，他学会了技能：", self.skill[0])
h1 = Human("张三", 35)
h2 = Human("李四", 8)
h1.teach(h2, "python")
h2.teach(h1, "王者荣耀")
h1.work(1000)
h1.borrow(h2, 200)
h1.show_info()
h2.show_info()