面向对象（类和对象操作）

'''

类名的书写规范，建议使用驼峰命名法
    大驼峰：MyCar XiaoMi
    小驼峰：myCar xiaoMi

一个类有特征和功能两个内容组成：
    特征就是一个描述：颜色：白色，品牌：奥迪，排量：2.4 。。。
    功能就是一个能力：拉货，带美女兜风。。。。

    特征在编程中就是一个变量，在类中称为 属性
    功能在编程中就是一个函数，在类中称为 方法

类中属性一般定义在前面，方法定义在后面
'''

# 定义一个汽车的类
class Cart():
    # 属性 ==> 特征 ==> 变量
    color = '白色'  # 表示颜色属性
    brand = '奥迪'  # 表示品牌属性
    pailiang = 2.4 # 表示排列属性

    # 方法 ==> 功能 ==> 函数
    def luohuo(self):
        print('小汽车能拉货')

    def doufeng(self):
        print('小汽车能兜风')

    def bamei(self):
        print('带妹子去嗨。。。')


# 如何去使用这个类？
# 通过类实例化一个对象 在这里Cart是类，aodiobj是对象
aodiobj =  Cart()

# print(aodiobj,type(aodiobj))
# <__main__.Cart object at 0x106f08550> <class '__main__.Cart'>

# 调用对象的方法
aodiobj.bamei()

# 获取对象的属性
print(aodiobj.brand)

对象成员的操作

1.对象操作成员

其实总结下来就一句话，就是类里面的特征和功能你都动不了，但是如果自身添加或者修改的时候删除的时候只能删除你自身的东西，因为当你改动或者添加那么此时等于给自己创建了一个自己的属性和方法，所以只能删除和改动自身的属性和方法

'''
成员属性：
  访问：  对象.成员属性名
  修改：  对象.成员属性名法 = 新值。（此时等于给这个对象创建了一个自己的属性）
  添加：  对象.新成员属性 = 值 (此时是给这个对象自己新建了一个属性)
  删除：  del 对象.成员属性 (注意：只能删除这个对象自己的属性)
  
成员方法：
  访问：  对象.成员方法名()
  修改：  对象.成员方法名 = func（此时等于给这个对象创建了一个自己的方法）
  添加：  对象.方法名 = func (此时是给这个对象自己新建了一个方法)
  删除：  del 对象.方法名 (注意：只能删除这个对象自己的方法)
'''

'''
什么是对象的成员？
一个对象通过类实例化之后，那么在类中定义的属性和方法，可以使用实例化的对象进行操作
类中定义的属性也称为 成员属性，类中定义的方法，也成为成员方法

'''

# 定义一个汽车的类
class Cart():
    # 属性 ==> 特征 ==> 变量
    color = '白色'  # 表示颜色属性
    brand = '奥迪'  # 表示品牌属性
    pailiang = 2.4 # 表示排列属性

    # 方法 ==> 功能 ==> 函数
    def lahuo(self):
        print('小汽车能拉货')

    def doufeng(self):
        print('小汽车能兜风')

    def bamei(self):
        print('带妹子去嗨。。。')


# 实例化对象
a = Cart()
b = Cart()
# print(a)
# print(b)
'''
一个类可以实例化多个对象
以上的a和b变量都是对象，也都是通过Cart这个类实例化出来的对象，
但是a和b是两个对象，相同之处就在于都同由同一个类实例化出来
<__main__.Cart object at 0x1016464d0>
<__main__.Cart object at 0x101646510>
'''

# 对象的成员的操作
# 一。在类的外部，使用对象操作成员属性
# 1。访问成员属性：先访问a对象自己的color属性，没有，就去访问这个对象的类的属性
# res = a.color  # 通过对象访问类中的属性

# 2。修改对象的属性值： 实际上等于给这个对象创建了一个a对象自己的color属性。
a.color = '黑色'  # 修改对象的属性
# 此时 b 对象的color属性是什么？
# print(b.color) # b对象的属性依然原来的值

# 3。添加对象的属性： 给当前a对象创建了自己独有的属性
a.name = 'A6'    # 给对象添加属性 此时的name属性只属于当前a这个对象
# 此时 b 对象是否有name这个属性呢？
# print(b.name)  # AttributeError: 'Cart' object has no attribute 'name'

# 4。删除属性，只能删除这个对象自己的属性，包括给对象添加的和修改的
# del a.brand  # AttributeError: brand
del a.color
# 思考一个问题：brand属性不能删除，但是name属性可以删除，为什么？
'''
删除一个对象的属性时，只能删除当前这个对象自己的属性才可以，
上面例子中的brand属性并不是a对象自己的属性，而是属性Cart这个类。因此不能删除
而name这个属性，是单独给a对象添加的属性，因为可以删除
'''

# 二，在类的外部，操作对象的方法
# 访问对象的方法：实际上如果这个对象没有自己独立的方法，那么会访问这个对象的类的方法
# res = a.lahuo() # 通过对象访问类中方法

# 修改对象的方法:给这个对象的方法重新定义
def func():
    print('这是一个新的方法')
a.lahuo = func  # 把一个函数赋值给成员
# a.lahuo()    # 去调用方法

# 添加新的方法:给这个对象自己新创建的方法
a.func2 = func
# a.func2()

# 删除方法：可以删除当前这个对象自己的方法
del a.lahuo # 可以删除
del a.func2 # 可以删除
# del a.bamei # 不可以删除这个对象的类的方法

# a.lahuo()

'''
总结：
一个类定义类成员属性和成员方法，那么通过这个类实例化的对象，也具备这些方法和属性吗？
    实际上，创建对象的时候，并不会把类中的属性和方法复制一份给对象，而是在对象中引用父类的方法
    因此在访问对象的属性时，会先去找对象自己的属性，如果没有就去找这个类的属性和方法

一个对象由类创建以后，是一个独立的对象，会引用父类中的属性和方法
    如果在对象创建后，给对象的属性或方法，进行修改或添加，那么此时等于给这个对象创建了一个自己的属性和方法
    所以在删除时，只能删除对象被修改或添加的成员
    
这样你是否能够分清什么是对象的成员，什么是类的成员？

'''

2.类操作成员

总结一句话：使用类名进行操作时(Cart)，肯定全部改变了呀，后续无论实例出多少的对象也都是按照类的变化而去变化

'''
成员属性：
  访问：  类名.成员属性名
  修改：  类名.成员属性名法 = 新值。（此时通过这个类创建的对象都具有这个属性）
  添加：  类名.新成员属性 = 值 (此时通过这个类创建的对象都具有这个属性)
  删除：  del 类名.成员属性 (注意：删除这个类的属性后，这个类创建的对象也没有这几个属性了)
  
成员方法：
  访问：  类名.成员方法名()
  修改：  类名.成员方法名 = func（此时通过类创建的对象都被修改）
  添加：  类名.方法名 = func (此时通过类创建的对象都被修改)
  删除：  del 类名.方法名 (注意：此时通过类创建的对象都被修改)
'''

#  类成员的操作
# 定义一个汽车的类
class Cart():
    # 属性 ==> 特征 ==> 变量
    color = '白色'  # 表示颜色属性
    brand = '奥迪'  # 表示品牌属性
    pailiang = 2.4 # 表示排列属性

    # 方法 ==> 功能 ==> 函数
    def lahuo(self):
        print('小汽车能拉货')

    def doufeng(self):
        print('小汽车能兜风')

    def bamei(self):
        print('带妹子去嗨。。。')


# 在类的外部，可以直接通过类对成员进行操作
a = Cart()

# 一，类成员属性的操作
# 访问类成员属性
# print(Cart.brand)
# 修改类成员属性
Cart.brand = '宝马'
# print(Cart.brand)

# 思考：如果通过类把属性进行类修改，那么再通过这个类实例化的对象，它的属性是什么呢？那之前创建的对象呢？
b = Cart()

# print(b.brand)# 是修改后的结果
# print(a.brand) # 在类属性修改前创建的对象的属性也被修改

# 给类添加成员属性
Cart.name = 'A6'
# print(Cart.name)

# 思考：通过类创建的对象是否也有这个属性呢？之前创建的对象和之后创建的对象都会有这个新的属性
# print(b.name)
# c = Cart()
# print(c.name)

# 删除类的成员: 在之前和之后创建的对象，都不在有这个属性了
del Cart.brand
# print(a.brand)

大总结

+ 一个类可以实例化出多个对象，每个对象在内存中都独立存在的
+ 当通过类实例化对象时，并不会把类中的成员复制一份给对象，而去给对象了一个引用
+ 访问对象成员的时候，如果对象自己没有这个成员，对象会向实例化它的类去查找
+ 对象成员的添加和修改，都只会影响当前对象自己，不会影响类和其它对象
+ 删除对象的成员时，必须是该对象自己具备的成员才可以，不能删除类中引用的成员
+ 对类的成员操作，会影响通过这个类创建的对象，包括之前创建的。