python类与类之间的关系

在面向对象中,类和类之间也可以产生相关的关系
类中的关系: 依赖关系是最轻的,最重的是继承关系,关联关系是比较微妙的

依赖关系
执行某个动作的时候,需要xxx来帮助完成这个操作,此时的关系是最轻的.
随时可以更换另外一个东西来完成此操作

 1 class Person:
 2     def f1(self,tools):     # 通过参数的传递把另外一个类的对象传递进来
 3         tools.run()
 4         print(‘皮一下很开心‘)
 5 class Computer:
 6     def run(self):
 7         print(‘电脑开机运行‘)
 8 class Phone:
 9     def run(self):
10         print(‘手机开机‘)
11 c = Computer()
12 a = Phone()
13 p = Person()
14 p.f1(a)         #把Phone类的对象a传递给Person的f1方法作为参数
15 结果
16 手机开机
17 皮一下很开心
18
19 事例二
20 植物大战僵尸
21 class Plant:
22     def __init__(self,hp,ad):
23         self.hp = hp
24         self.ad = ad
25     def attack(self,js):
26         print(‘植物攻击僵尸‘)
27         js.hp -= self.ad
28         print(f‘僵尸掉血{self.ad},剩余{js.hp}‘)
29 class JiangShi:
30     def __init__(self,hp,ad):
31         self.hp = hp
32         self.ad = ad
33     def attack(self,zw):
34         print(‘僵尸咬植物‘)
35         zw.hp -= self.ad
36         print(f‘植物掉血{self.ad},剩余{zw.hp}‘)
37 zw = Plant(100,11)
38 js = JiangShi(80,15)
39 zw.attack(js)
40 zw.attack(js)
41 js.attack(zw)
42 js.attack(zw)
43 结果
44 植物攻击僵尸
45 僵尸掉血11,剩余69
46 植物攻击僵尸
47 僵尸掉血11,剩余58
48 僵尸咬植物
49 植物掉血15,剩余85
50 僵尸咬植物
51 植物掉血15,剩余70

关联关系
对象里面包含对象

 1 一对一关系
 2 class Boy:
 3     def __init__(self,name,girFriend=None):
 4         self.name = name
 5         self.girFriend = girFriend
 6     def play(self):
 7         if self.girFriend:
 8             print(f‘{self.name}带着他女朋友{self.girFriend.name}去吃饭‘)
 9         else:
10             print(‘单身狗,还吃什么饭‘)
11     def movie(self):
12         if self.girFriend:
13             print(f‘{self.name}带着他女朋友{self.girFriend.name}去看电影‘)
14         else:
15             print(‘单身狗,还看什么电影‘)
16 class Girl:
17     def __init__(self,name):
18         self.name = name
19 b = Boy(‘刘昊然‘)
20 g = Girl(‘刘丽‘)
21 b.play()
22
23 b.girFriend = g
24 b.play()
25
26 g2 = Girl(‘王萌‘)
27 b.girFriend = g2
28 b.movie()
29
30
31 一对多关系
32 self.teach_list = [t1,t2,...]
33 class School:
34     def __init__(self,name):
35         self.teach_list = []
36     def zhaopin(self,teach):
37         self.teach_list.append(teach)
38     def shangke(self):
39         for i in self.teach_list:
40             i.work()
41 class Teacher:
42     def __init__(self,name):
43         self.name = name
44     def work(self):
45         print(f‘{self.name}在上课‘)
46 lnh = School(‘测试‘)
47 t1 = Teacher(‘赵老师‘)
48 t2 = Teacher(‘刘老师‘)
49 lnh.zhaopin(t1)
50 lnh.zhaopin(t2)
51 lnh.shangke()
52 结果
53 赵老师在上课
54 刘老师在上课

继承关系

 1 class Base:         #父类又叫基类又叫超类
 2     def chi(self):
 3         print(‘吃饭‘)
 4 class Foo(Base):    #子类又叫派生类,这个类继承了Base类,Foo类是对Base的一个扩展
 5     def he(self):
 6         print(‘喝水‘)
 7 f = Foo()
 8 f.chi()
 9 f.he()
10 print(hash(Foo))    #默认类和创建的对象都是可哈希的
11 print(hash(Foo()))
12 结果
13 吃饭
14 喝水
15 -9223371912599947772
16 -9223371912597968945
17
18 去掉可哈希
19 __hash__ = None
20 class Base:
21     def chi(self):
22         print(‘吃饭‘)
23 class Foo(Base):
24     __hash__ = None     # 当前类的对象不可哈希
25     def he(self):
26         print(‘喝水‘)
27 f = Foo()
28 f.chi()
29 f.he()
30 print(hash(Foo))    # 类名永远可哈希
31 print(hash(Foo()))  # TypeError: unhashable type: ‘Foo‘

类名相当于变量名

 1 class Foo:
 2     def chi(self,food):
 3         print(‘吃鱼和‘,food)
 4 class Bar:
 5     def chi(self,food):
 6         print(‘吃肉和‘,food)
 7 dic = {Foo:‘面包‘,Bar:‘牛奶‘}
 8 for k,v in dic.items():
 9     k().chi(v)
10 结果
11 吃鱼和 面包
12 吃肉和 牛奶

练习

 1 事例1
 2 class Base:
 3     def __init__(self, num):
 4         self.num = num
 5
 6     def func1(self):
 7         print(self.num)
 8         self.func2()
 9
10     def func2(self):
11         print(111, self.num)
12
13 class Foo(Base):
14     def func2(self):
15         print(222, self.num)
16
17 lst = [Base(1), Base(2), Foo(3)]
18 for obj in lst:
19     obj.func2()
20 结果
21 111 1
22 111 2
23 222 3
24
25 事例2
26 class Base:
27     def __init__(self, num):
28         self.num = num
29     def func1(self):
30         print(self.num)
31         self.func2()
32     def func2(self):
33         print(111, self.num)
34
35 class Foo(Base):
36     def func2(self):
37         print(222, self.num)
38
39 lst = [Base(1), Base(2), Foo(3)]
40 for obj in lst:
41     obj.func1()
42 结果
43 1
44 111 1
45 2
46 111 2
47 3
48 222 3

self:谁调用的就是谁,类型是根据调用方的对象来进行变换的
super:表示的是父类

特殊成员:
__init__()  # 创建对象的时候初始化操作
__call__()  # 对象()
__getitem__()   # 对象[哈哈]
__setitem__()   # 对象[哈哈] = 值
__new__()   # 创建对象的时候.开辟内存
__hash__()  # 可哈希 hash()

  1 __call__
  2 对象后面加括号,触发执行
  3 注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
  4 class Foo:
  5     def __init__(self):
  6         pass
  7
  8     def __call__(self, *args, **kwargs):
  9         print(‘__call__‘)
 10
 11 obj = Foo()  # 执行 __init__
 12 obj()  # 执行 __call__
 13 结果
 14 __call__
 15
 16 事例2
 17 class Foo:
 18     def __init__(self):                 # 初始化操作
 19         print(‘我是init,我是第二‘)
 20
 21     def __new__(cls, *args, **kwargs):  # 创建,是真正的构造方法,可以开辟内存
 22         print(‘我是new,我是第一‘)
 23         return object.__new__(cls)
 24
 25     def __call__(self, *args, **kwargs): # 对象()
 26         print(‘我是对象call‘)
 27
 28     def __getitem__(self, item):        # 对象[]
 29         print(‘item‘,item)
 30         print(‘我是getite‘)
 31
 32     def __setitem__(self, key, value):  # 对象[key] = value
 33         print(‘key‘,key)
 34         print(‘value‘,value)
 35 Foo()
 36 f = Foo()          # 自动执行__init__()
 37 f()                # 调用__call__()
 38 print(callable(f)) # 对象()
 39 print(f[‘娃哈哈‘]) #自动调用__getitem__()
 40 f[‘人‘]=‘刘丽‘     #自动的调用__getitem__()
 41 结果
 42 我是new,我是第一
 43 我是init,我是第二
 44 我是new,我是第一
 45 我是init,我是第二
 46 我是对象call
 47 True
 48 item 娃哈哈
 49 我是getite
 50 None
 51 key 人
 52 value 刘丽
 53
 54
 55 事例3
 56 class Foo:
 57     def __init__(self,name):
 58         self.name=name
 59
 60     def __getitem__(self, item):
 61         print(self.__dict__[item])
 62
 63     def __setitem__(self, key, value):
 64         self.__dict__[key]=value
 65     def __delitem__(self, key):
 66         print(‘del obj[key]时,我执行‘)
 67         self.__dict__.pop(key)
 68     def __delattr__(self, item):
 69         print(‘del obj.key时,我执行‘)
 70         self.__dict__.pop(item)
 71
 72 f1=Foo(‘sb‘)
 73 f1[‘age‘]=18
 74 f1[‘age1‘]=19
 75 print(f1.__dict__)
 76 del f1.age1
 77 del f1[‘age‘]
 78 f1[‘name‘]=‘alex‘
 79 print(f1.__dict__)
 80 结果
 81 {‘name‘: ‘sb‘, ‘age‘: 18, ‘age1‘: 19}
 82 del obj.key时,我执行
 83 del obj[key]时,我执行
 84 {‘name‘: ‘alex‘}
 85
 86
 87 事例4
 88 class Person:
 89     def __init__(self,name,age):
 90         self.name = name
 91         self.age = age
 92     #这个对象字符串的表示
 93     def __str__(self):  #返回该对象的字符串表示形式
 94         return f‘{self.name},{self.age}‘
 95     def __repr__(self):  #该对象的官方的字符串表示形式
 96         return f‘{self.name},{self.age}‘
 97 s = Person(‘bob‘,‘18‘)
 98 print(s)
 99 结果
100 bob,18
101
102 事例5
103 class B:
104     def __str__(self):
105         return ‘str : class B‘
106     def __repr__(self):
107         return ‘repr : class B‘
108 b = B()
109 print(‘%s‘ % b)     #这个执行的是__str__函数方法
110 print(‘%r‘ % b)     #这个执行的是__repr__函数方法
111 结果
112 str : class B
113 repr : class B
114
115
116 __del__
117 析构方法,当对象在内存中被释放时,自动触发执行
118 注:此方法一般无须定义,因为Python是一门高级语言,程序员在使用时无需关心内存的分配和释放,因为此工作都是交给Python解释器来执行,所以,析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
119 class Foo:
120
121     def __del__(self):
122         print(‘执行我啦‘)
123
124 f1=Foo()
125 del f1
126 print(‘------->‘)
127 结果
128 执行我啦
129 ------->

原文地址:https://www.cnblogs.com/selina1997/p/10158822.html

时间: 2024-11-08 13:28:46

python类与类之间的关系的相关文章

PHP类和对象之间的关系

类是对象的描述: 类和对象之间的关系类似于建房子的图纸和房子: 创建类--new对象--用对象: 一.对象的两个特性: --对象的行为(功能):可以对对象施加操作,例如,电视机的开.关.转换频道: --对象的状态(属性):当施加操作时对象如何反应,例如,电视机的外形.尺寸.颜色等: 例子: 根据一份配置单组装六十台电脑,配置单里每增加一项配置,60台电脑各增加一厢配置. 1.配置单就是要创建的"类": 2.60台电脑就是创建的对象: 3.60台电脑间没有连系: 二.如何抽象一个类 1.

3.2-面向对象(类与对象之间的关系)

3.2 类与对象的关系 使用计算机语言就是不断的在描述现实生活中的事物. java中描述事物通过类的形式体现,类是具体事物的抽象,概念上的定义. 对象即是该类事物实实在在存在的个体 . 3.2.1  类与对象( 图例) 3.2.2  类的定义 生活中描述事物无非就是描述事物的属性和行为. ?  如:人有身高,体重等属性,有说话,打球等行为. Java中用类class来描述事物也是如此 ?  属性:对应类中的成员变量. ?  行为:对应类中的成员函数. 定义类其实在定义类中的成员(成员变量和成员函

UML图类,接口之间的关系

UML图类之间的关系(来自大话设计模式中的一张图,代表了类,接口之间的各种关系) 原文地址:https://www.cnblogs.com/linlf03/p/9735917.html

什么是类,什么是对象,类和对象之间的关系

类的概念:类是具有相同属性和服务的一组对象的集合.它为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分.在面向对象的编程语言中,类是一个独立的程序单位,它应该有一个类名并包括属性说明和服务说明两个主要部分. 对象的概念:对象是系统中用来描述客观事物的一个实体,它是构成系统的一个基本单位.一个对象由一组属性和对这组属性进行操作的一组服务组成.从更抽象 的角度来说,对象是问题域或实现域中某些事物的一个抽象,它反映该事物在系统中需要保存的信息和发挥的作用:它是一组属性和有权对这

【PHP面向对象(OOP)编程入门教程】2.什么是类,什么是对象,类和对象之间的关系

类的概念:类是具有相同属性和服务的一组对象的集合.它为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分.在面向对象的编程语言中,类是一个独立的程序单位,它应该有一个类名并包括属性说明和服务说明两个主要部分. 对象的概念:对象是系统中用来描述客观事物的一个实体,它是构成系统的一个基本单位.一个对象由一组属性和对这组属性进行操作的一组服务组成.从更抽象 的角度来说,对象是问题域或实现域中某些事物的一个抽象,它反映该事物在系统中需要保存的信息和发挥的作用:它是一组属性和有权对这

Java 中判断类和实例之间的关系

判断类与实例的关系有以下三种方式 1.instanceof关键字,用来判断对象是否是类的实例 (对象 => 类 )   2.isAssignableFrom,用来判断类型间是否存在派生关系 (类 = > 类)   3.isInstance方法,用来判断对象是否属于某个类型的实例 (类 => 对象 //use instanceof,用来判断对象是否是类的实例 System.out.println(new A() instanceof B);//类型比较 //use isAssignable

Python包管理工具之间的关系

转自http://www.nowamagic.net/academy/part/13/302/ 当前的包管理工具链是 easy_install/pip + distribute/setuptools + distutils, 显得较为混乱. 而将来的工具链组合非常简单:pip + distutils2. 1. distutils : Python 自带的基本安装工具,适用于非常简单的应用场景,使用: 为项目创建 setup.py 脚本. 执行 setup.py install 可进行安装. 2.

类、接口、实现之间的关系

类可以看成是一个个抽象的对象的宏观描述,例如:人, 类的成员分为字段和方法 程序中的字段对应:人的嘴.有脸 程序中的方法对应:人能干活.说话 程序中的对象对应:张三.李四(是造物者已经实实在在造出的人) 实现类.接口类.调用之间的关系是什么呢?我们可以用我们生活中插座来举例子 程序中的接口对应:三线插座接口.二线插座接口,其中三线插座接口的标准都是一样的,即都有同样的功能:例如:三线插座接口外部有三个孔(字段).能够通电(方法) 程序中的实现对应:不同三线接口的实现可以是不一样的.例如:三个孔的

java 类与类之间的关系 及uml图

类与接口之间的关系 : 继承 类与类之间的关系 :继承关系  包含关系 类与对象之间的关系 : 实例 UML 类图中类与类之间的关系: 泛化关系(generalization) 关联关系(association) 聚合关系(aggregation) 合成关系 (compostion) 依赖关系 (dependency) 1.泛化(Generalization)[泛化]表示类与类之间的继承关系,接口与接口之间的继承关系,或类对接口的实现关系.一般化的关系是从子类指向父类的,与继承或实现的方法相反.

静态联编,动态联编,类指针之间的关系,虚函数与多态性,纯虚函数,虚析构函数

1.静态联编,是程序的匹配,连接在编译阶段实现,也称为早期匹配.重载函数使用静态联编. 2.动态联编是指程序联编推迟到运行时进行,所以又称为晚期联编.switch语句和if语句是动态联编的例子. #include<iostream> void go(int num) { } void go(char *str) { } //class //::在一个类中 class A { public: void go(int num) { } void go(char *str) { } }; void