VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > temp > python入门教程 >

  • Python面向对象编程代码详解(依赖关系,关联关系,组合关系)

Python面向对象编程代码详解(依赖关系,关联关系,组合关系)
面向对象编程
 
面向对象编程
 
Oop变编程是利用类和对象来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为他可以使程序的维护和扩展变得更简单．
 
Class　类
 
一个类就是对一类相同属性的对象、蓝图、原型．简单来说就是模板
 
Object　对象
 
对象就是实体　人狗大战中的人和狗就是对象　　　　
 
通过赋值调用模板生成的实体，就是实例化
 
Inheritance继承　
 
一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
 
Encapsulation 封装
 
在类中对数据的而赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法．
 
面向过程编程
 
就是程序从上倒下一步步　执行，一步步从上到下，从头到尾的解决问题
 
面向过程的例子：有个需求是对网站的日志进行分析，生成邮件报告，分为以下步骤：
 
到各台服务器上收集日志，因为有许多台网站服务器，同时对外提供服务
对日志进行各种维度的分析，比如:pv,uv,来源地,访问的设备等
生成报告，发送邮件　
面向对象vs面向过程总结　
 
面向过程的优点:极大的降低了写程序的复杂度，只要顺着执行的步骤，堆叠德玛即可
 
缺点是:一套流水线或者流程就是用来解决一个问题，代码前一发动全身
 
面向对象的优点:解决了程序的扩展性，对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中的一个任务参数的特征和技能修改都很容易
 
缺点:可控性差，无法向面向过程的程序设计流水线式的可以很精准的也测问题的处理流程与结果
 
 
 
类的基本语法
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Dog:
    dog_type = "jingba"  #属性，类属性，类变量   ,公共属性，所有狗都相同的属性
    hp = "100"
 
    def __init__(self,name,age):   # 初始化方法，构造方法　，构造函数　实例化时会自自动执行，进行初始化工作
        print('haha',name,age)
        #要想把name,age两个值，真正的存到实例里．就需要把两个值跟实例绑定
        self.name = name
        self.age = age
 
    def sayhi(self):    #方法，第一个参数必须是self , self代表实例本身
        print("hello ,i  am a dog ,my type is %s"%self.dog_type,self.name,self.age)
 
 
d1 = Dog("xdd",2)   # 生成了一个实例
d2 = Dog('jack',3)
 
d1.sayhi()
d2.sayhi()
 
print(d1.dog_type)
Self 代表实例本身
 
属性引用      类属性属于共有属性　　，实例属性属于私有属性
 
类的公共属性引用  ==> 类名.属性
 
实例属性的引用　==＞ d.name
 
 
 
类之间的依赖关系
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding:utf-8 -*-
class Dog:
 
    def __init__(self,name,age,breed,master):
        self.name = name
        self.age = age
        self.breed = breed
        self.master = master
    def depends(self):
        print("hi ,i am %s, i am %s years old,my breed is %s my master is %s"%(self.name,self.age,self.breed,self.master))
 
 
class People:
 
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def lugou(self,dog):
        print("i want liugou %s"%dog.name)
 
p = People("jack",20)
d = Dog("xdd",2,"jingba",p.name)
 
d.depends()
对象之间的关联关系　
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
# -*- coding:utf-8 -*-
class Relationship:  # 为了保存couple之间的情侣关系
    def __init__(self):
        self.couple = []
 
    def make_couple(self, obj1, obj2):
        self.couple = [obj1, obj2]
        print("%s and %s is couple" % (obj1.name, obj2.name))
 
    def get_my_parter(self, obj):
        # print("find %s de couple"%obj.name)
        for i in self.couple:
            if i != obj:
                return i
        else:
            print("alone dog")
    def break_up(self):
        print("%s and %s break up"%(self.couple[0].name,self.couple[1].name))
        self.couple = []  # 分手
 
class Person:
    def __init__(self, name, age, sex, relation):
        self.name = name
        self.age = age
        self.sex = sex
        self.relation = relation
        # self.parter = None  # 应该是一个对象
 
    def do(self):
        pass
 
 
make_cp = Relationship()
 
p1 = Person("xdd", 22, 'Man', make_cp)
p2 = Person("dogs", 23, "Woamn", make_cp)
 
make_cp.make_couple(p1, p2) #情感状态
 
# 双向关联，绑定
p1.parter = p2
p2.parter = p1
 
print(p1.parter.name, p2.parter.name)#  情侣名字　
 
print(p1.relation.get_my_parter(p1).name)  # p1的对象
 
p1.relation.break_up()# 分手
 
p2.relation.get_my_parter(p2)# 情感状态
对象间的组合关系
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# -*- coding:utf-8 -*-
# 组合关系由一堆组件构成一个完整的实体，组件本身独立，但又不能自己运行，必须跟宿主组合在一起运行
class Dog:
 
    hp = 100
 
    def __init__(self,name,breed,attack_val):
        self.name = name
        self.breed = breed
        self.attack_val = attack_val
 
    def dog_bite(self,person):
        person.hp -= self.attack_val
        print("Dog [%s] bite person [%s] ,person hp - [%s],hp is [%s]"%(self.name,person.name,self.attack_val,person.hp))
 
 
class Weapon:  #武器
 
    def dog_stick(self,obj):
        self.name = "打狗棒"
        self.attackval = 30
        obj.hp -= self.attackval
        self.print_log(obj)
 
    def print_log(self,obj):
        print("[%s] bei [%s] attack ,- hp [%s],hp is [%s]"%(obj.name,self.name,self.attackval,obj.hp))
 
class Person:
    hp = 100
 
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.weapon = Weapon()
        #self.attack_val = attack_val
 
    # def person_beat(self,dog):
    #     dog.hp -= self.attack_val
    #     print("People [%s] beat Dog [%s], Dog - hp [%s],Dog hp is [%s]"%(self.name,dog.name,self.attack_val,dog.hp))
 
d = Dog("dogs","erha",30)
p = Person("xdd",12)
d.dog_bite(p)
p.weapon.dog_stick(d)
　　
出处：https://www.cnblogs.com/zjaiccn/p/13220174.html

相关教程