面向对象-类和对象成员的操作

获取类和对象中所属成员的信息
类：类名.__dict__
对象:对象名.__dict__

类成员的操作：
成员属性:（和变量一样）
访问 类名.成员属性名
修改 类名.成员属性名 = 新值
删除 del 类名.成员属性名
添加 类名.成员属性名 = 值

成员方法：
访问 类名.方法名()
修改 类名.方法名 = 新的函数
删除 del 类名.方法名
添加 类名.新方法名 = 函数（也可以是lambda表达式）

对象成员的操作：
成员属性：
访问 对象.成员属性名
修改 对象.成员属性名 = 新值
添加 对象.成员属性名 = 值
删除 del 对象.成员属性名 （必须是属于当前对象的成员才可以）

成员方法：
访问 对象.成员方法名()
修改 对象.成员方法名 = 新的函数
添加 对象.成员方法名 = 函数
删除 del 对象.成员方法名

注意事项：
1.实例化对象的时候通常情况下类中的成员不会在对象中复制一份
2.访问对象成员的时候，只要没有该成员，对象会向实例化他的类查找。
3.对象成员的添加和修改，都只会影响当前对象本身，不会影响类和其他对象
4.删除对象成员时候，必须是该对象自身的成员才可以删除，不可以删除类和其他对象~

 

类和对像成员操作实例

#电脑类
class Computer:
    #成员属性
    cpu = 'i7-7890'
    memory = '32G'
    disk = '1T'
    display = '120Hz'
    color = '黑色'

    #成员方法
    #播放电脑
    def play_movie(self):
        print('电脑播放电影中')

    #播放音乐
    def play_music(self):
        print('电脑播放音乐中')

    #玩游戏
    def play_game(self):
        print('正在使用电脑玩游戏')


#实例化类 获取电脑的对象
pc = Computer()

#对于类的相关操作（很少使用）
#检测类中的成员
print(Computer.__dict__)

#成员属性-------------------------------------------------

#访问
print(Computer.cpu)
#输出结果：i7-7890
print(Computer.memory)
#输出结果：32G

#修改

print(Computer.__dict__) #类.__dict__：以字典结构获取类所有成员
#输出结果：{...略...  'color': '黑色',  ...略...}
Computer.color = '灰色'#相当于变量重新赋值
print(Computer.__dict__)
#输出结果：{...略...  'color': '灰色',  ...略...}

#添加
print(Computer.__dict__)
#输出结果：{...略... }
Computer.keyboard = '机械键盘'
print(Computer.__dict__)
#输出结果：{...略...  'keyboard': '机械键盘'}


#删除
print(Computer.__dict__)
#输出结果：{...略... }
del Computer.cpu
print(Computer.__dict__)
#输出结果：{...略... -->少了cpu项}


#成员方法-------------------------------------------

#访问
Computer.play_movie(None)

#添加(work)  不推荐使用
#定义一个函数
def work():
  print('使用电脑办公中')
#输出结果：电脑播放电影中
Computer.work = work #也可以使用lambda表达式添加
print(Computer.__dict__)
#输出结果：{...略... }

#修改
Computer.play_movie(None)
#输出结果：电脑播放电影中
Computer.play_movie = lambda : print('电影暂停中')
#输出结果：电影暂停中
Computer.play_movie()

#删除
print(Computer.__dict__)
#输出结果：{...略... }
del Computer.play_movie #一定不要加括号。
print(Computer.__dict__)
#输出结果：{...略... -->少了 play_movie 方法}

#=============================================
#对于对象的相关操作
#检测对象中成员
print(pc.__dict__)

#成员属性的操作

#访问
print(pc.cpu)
#输出结果：i7-7890
print(pc.disk)
#输出结果：1T

#修改
print(pc.__dict__)
#输出结果：{}

#pc.cpu = 'i9-7890'
print(pc.__dict__)
#输出结果：{'cpu': 'i9-7890'}


#添加
print(pc.__dict__)
#输出结果：{}

pc.closth = '钢化膜'
print(pc.__dict__)
#输出结果：{'closth': '钢化膜'}


#删除
print(pc.__dict__)
#输出结果：{}
del pc.cpu #不可以删除不属于当前对象的成员
#添加一个成员
pc.closth = '钢化膜'
print(pc.__dict__)
#输出结果：{'closth': '钢化膜'}
del pc.closth
print(pc.__dict__)
#输出结果：{}


#成员方法的操作

#访问
pc.play_movie()   #和类访问不同，self会自动传入一个数据
#输出结果：电脑播放电影中
#添加
print(pc.__dict__)
#输出结果：{}
pc.www = lambda : print('电脑上网中')
print(pc.__dict__)
#输出结果：{'www': <function <lambda> at 0x00000169F5EBD378>}

#修改
pc.play_game()
#输出结果：正在使用电脑玩游戏
pc.play_game  = lambda :print('LOL中~')
pc.play_game()
#输出结果：LOL中~
print(pc.__dict__)
#输出结果：{'play_game': <function <lambda> at 0x0000029C9154D378>}

#删除
#添加一个方法
pc.input = lambda : print('电脑打字中~')
print(pc.__dict__)
#输出结果：{'input': <function <lambda> at 0x0000013D3B02D378>}
del pc.input
print(pc.__dict__)
#输出结果：{}