一、从空间角度研究类

类外面可以给对象封装属性

class A:

	address = '美丽富饶的沙河'

	def __init__(self, name):

			self.name = name

	def func(self):

    	if self.name == 'dsb':

    			self.skins = '吉利服'

obj = A('dsb')

# 类外面可以给对象封装属性

respons = input('太白帅不帅!')

if respons == '帅':

		obj.weapon = 'AWM'

print(obj.__dict__)

类内部封装属性

obj.func()

print(obj.__dict__)

A.teamp = '39.5'

print(A.__dict__)

obj = A('dsb')

# A.func1(111)

A.func1(obj)

print(A.__dict__)

空间角度研究类

class Person:

    mind = '有思想'

    language = '会使用语言'

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def work(self):

        print('人类一般都需要工作')

p1 = Person('dsb', 21)

del p1.mind  # 报错

# print(p1.mind)

# p1.mind = '无脑'

# print(p1.mind)

# print(Person.mind)

注意: 对象无法改变类中的属性,对象只能查询或调用类里面的内容,但是不能改变,

类是一个公共区域,所有对象只能使用公共区域里面的东西,但是不能改变这些东西

类内部的各个对象是相互独立的(除去组合这种特殊的关系之外),各个对象之间是不能相互引用或者改变的,但是也可以产生关系:

对象取值顺序

对象如果想要查询一个属性: 对象空间>类空间>父类空间

类取值顺序

类查询一个对象: 类空间>父类空间

单向不可逆原则

二、类与类之间的关系

一般的关系不可能是一个

类与类之间是可以产生关系的

python中的三种关系:

1.依赖关系(主从关系)

# 大象自己进冰箱

# 大象类

class Elephant:

		def __init__(self, name):

				self.name = name

		def open(self,ref1):

				print('大象默念三声: 芝麻开门')

				ref1.open_door()

		def close(self):

				print('大象默念三声: 芝麻关门')

# 冰箱类

class Refrigerator:

		def __init__(self, name):

				self.name = name

		def open_door(self):

				print('冰箱门被打开了...')

		def closer_door(self):

				print('冰箱门被关闭了...')

ele = Elephant('齐齐')

ref = Refrigerator('美菱')

ele.open(ref) # 这一步是关键,将ref这个类传入到Elephant的方法open中

依赖关系:就是将一个类的类名或者对象传给另一个类的方法中

练习题:

实现两个

大象执行open方法:

显示:'哪个大象 大象默念三声:芝麻开门'

显示:'哪个冰箱门,冰箱门被打开了'

# 大象类

class Elephant:

	def __init__(self, name):

		self.name = name

	def open(self,ref1):

		# print(ref1)

		print(f'大象{self.name}默念三声: 芝麻开门')

		# ref1.open_door()

	def close(self):

		print('大象默念三声: 芝麻关门')

# 冰箱类

class Refrigerator:

	def __init__(self, name):

		self.name = name

	def open_door(self,ele1):

		# print(ele1)

		print(f'{self.name}冰箱门被打开了...')

	def closer_door(self):

		print('冰箱门被关闭了...')

ele = Elephant('齐齐')

ref = Refrigerator('美菱')

ele.open(ref)

ref.open_door(ele)

ele1.open(ref)

# 以上代码敲十遍

一句话总结

依赖关系:就是将一个类的类名或者对象传给另一个类的方法中

就是将一个类Refrigerator('美菱')的类名或者实例化后的对象ref传给另一个类Elephant的ele.open方法中

2.组合关系(关联组合聚合)

class Boy:

		def __init__(self, name):

				self.name = name

		def meet(self,girl_friend=None):

    		self.girl_friend = girl_friend

		def have_diner(self):

				if self.girl_friend:

        		print(f'{self.name}请{self.girl_friend.name}一起吃六块钱的麻辣烫')

        else:

        		print('单身狗,看别人吃')

class Girl:

     	def __init__(self, name, age):

     			self.name = name

     			self.age = age

# 操作1

wu = Boy('吴超')

# wu.have_diner()

# 输出结果

单身狗,吃什么吃

# flower = Girl('如花', 48)

# 操作2

flower = Girl('如花', 48)

# 组合: 将一个类的对象封装成另一个类的对象的属性中

wu.meet(flower)

# 输出结果

吴超请如花一起吃六块钱麻辣烫

敲十遍的练习题

class GameRole: # 定义一个游戏的类

    def __init__(self, name, ad, hp): # 设置默认方法:姓名,攻击力,血量

        self.name = name

        self.ad = ad

        self.hp = hp

    def attack(self,p1): # 设置一个攻击的方法,传入的值是,被攻击人的名字

        p1.hp = p1.hp - self.ad # 传入被攻击人的血量等于被攻击人原来的血量减去攻击人的攻击力

        print(f'{self.name}攻击{p1.name},{p1.name}掉了{self.ad}血,还剩{p1.hp}血') # 这里self.name就是攻击人的名字,p1是被攻击人的名字,被攻击人掉的血也就是是攻击人的攻击力,还剩下的血量是被攻击人之前的血量减去攻击人的攻击力

    def equit_weapon(self,wea):# 定义了一个装备武器的方法,传入的值是

        self.weapon = wea

class Weapon:

    def __init__(self, name, ad):

        self.name = name

        self.ad = ad

    def attick(self, p1, p2):

        self.p1 = p1

        self.p2 = p2

        print(f'{self.p1}使用{self.name}攻击了{self.p2},{self.p2}掉了{self.ad}血')

gailun = GameRole('盖伦', 100, 10) #传入一个 盖伦的对象属性

jianhao = GameRole('剑豪', 200, 20)

gailun_gj = Weapon('青龙偃月刀', 20)

jianhao_gj = Weapon('九门大提督枪', 30)

gailun.equit_weapon(gailun_gj) #

jianhao.equit_weapon(jianhao_gj)

gailun.weapon.attick('盖伦', '剑豪')

jianhao.weapon.attick('剑豪', '盖伦')

一句话总结:

依赖关系:   就是将一个类的类名或者对象传给另一个类的方法中

组合关系就是,将一个类的对象封装到另一个类的对象的属性中,以如花为例,将类Girl('如花', 48)的实例化后的对象flower封装到另一个类Boy('吴超')的实例化对象wu的meet属性中,用wu.meet(flower)表示

继承关系

class A:

		pass

class B:

		pass

巴特西

python之面向对象的关系