pyhton之路---面向对象

Posted 2020-10-02 孟庆健

一、面向过程VS面向对象

面向过程：

     优点：极大的降低了写程序的复杂度，只需要顺着执行的步骤，堆叠代码即可。

     缺点：一套流水线或者流程就是来解决一个问题，代码就是牵一发而动全身

面向对象：

   优点：   解决了程序的扩展性，对某一个对象单独修改，会立刻反映到整个体系中如对游戏中

              一个人物参数的特征和技能修改都很容易。

  缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，

           面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。

         于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，

        这个游戏就失去平衡

 

 

类：具有相同特征的一类事物(人、狗、老虎)

 

对象／实例：具体的某一个事物（隔壁阿花、楼下旺财）

 

实例化：类——>对象的过程

二、初识类和对象：

 

>>> dict #类型dict就是类dict
<class ‘dict‘>
>>> d=dict(name=‘eva‘) #实例化
>>> d.pop(‘name‘) #向d发一条消息，执行d的方法pop
‘eva‘

 

     在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，

     对象是则是这一类事物中具体的一个。

三、类的相关知识：

初识类

声明：

 

def functionName(args):
     ‘函数文档字符串‘
      函数体 

声明函数

 

 

‘‘‘
class 类名:
    ‘类的文档字符串‘
    类体
‘‘‘

#我们创建一个类
class Data:
    pass

声明类

 

class Person:   #定义一个人类
    role = ‘person‘  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法，也叫动态属性
        print("person is walking...")

View Code

class 类名:
    类属性 = None
    def __init__(self,对象属性):
        self.对象属性 = 对象属性

    def 方法名(self):
        pass

实例 = 类名(10)
实例.方法名()

类有两种作用：属性引用和实例化

 属性引用（类名.属性）

class Person:   #定义一个人类
    role = ‘person‘  #人的角色属性都是人
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

class Person:   #定义一个人类
    role = ‘person‘  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;
        
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

类名
    类名.类属性
   类名.方法名

实例 = 类名(参数，参数)  #实例就是对象

实例
    实例.方法名()
   实例.对象属性

实例增加属性
实例.新的属性名 = 1000
print(实例.新的属性名)

关于self

self：在实例化时自动将对象/实例本身传给__init__的第一个参数，你也可以给他起个别的名字.

对象/实例只有一种作用：属性引用

 

egg = Person(‘egon‘,10,1000)
print(egg.name)
print(egg.aggressivity)
print(egg.life_value)

 

class 类名:
    def __init__(self,参数1,参数2):
        self.对象的属性1 = 参数1
        self.对象的属性2 = 参数2

    def 方法名(self):pass

    def 方法名2(self):pass

对象名 = 类名(1,2)  #对象就是实例，代表一个具体的东西
                  #类名() : 类名+括号就是实例化一个类，相当于调用了__init__方法
                  #括号里传参数，参数不需要传self，其他与init中的形参一一对应
                  #结果返回一个对象
对象名.对象的属性1   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

class Person:
    ‘‘‘
    这是一个游戏里人物的数据类型
    ‘‘‘
    role = ‘中国人‘    #类属性—— 静态属性
    def __init__(self,name,life_value,aggr):
        self.name = name #名字    #对象属性
        self.life_value = life_value #生命值 对象属性
        self.aggr = aggr #攻击力 对象属性
    def attack(self,enemy):  #攻击方法——动态属性
        enemy.life_value = enemy.life_value - self.aggr
print(Person.__doc__)
class Dog:
    def __init__(self,name,breed,aggr,life_value):
        self.nickname = name #昵称
        self.breed = breed   #品种
        self.aggr = aggr     #攻击力
        self.life_value = life_value  #生命值
    def bite(self,person):  #咬
        person.life_value = person.life_value - self.aggr

egg = Person(‘egon‘,1000,50)
alex = Person(‘alex‘,250,5)
旺财 = Dog(‘二愣子‘,‘牛头梗‘,30,20000)

egg.money = 200
print(egg.money)

class Weapon:  #武器类
    def __init__(self,name,aggr,life_value,price,attack_force):
        self.price = price
        self.name = name
        self.aggr = aggr   #伤害加成
        self.life_value = life_value #生命加成
        self.attack_force = attack_force #攻击力
    def update(self,person):  #带装备，人
        person.money = person.money - self.price
        person.aggr = person.aggr + self.aggr
        person.life_value = person.life_value + self.life_value
    def kill(self,obj):  #装备：主动技能
        obj.life_value = obj.life_value - self.attack_force

剑魂 = Weapon(‘sword_soul‘,50,250,199,10000)

if egg.money > 剑魂.price:
    剑魂.update(egg)
    egg.weapon = 剑魂

print(旺财.life_value)
print(egg.aggr)
egg.attack(旺财)
print(旺财.life_value)

egg.weapon.kill(旺财)
print(旺财.life_value)
egg.weapon.kill(旺财)
print(旺财.life_value)

人狗大战

补充：

dir(类) #返回类中的所有名字列表
isinstance(对象，类) #判断对象是否为类的实例
print(Person.__dict__) # 返回一个字典 key是属性名，value是属性值
print(Person.__module__)  #person类所在的模块
print(Person.__name__,type(Person.__name__)) #字符串数据类型的类名
from collections import namedtuple
p = namedtuple(‘Point‘,[‘x‘,‘y‘])
p1 = p(1,2)
print(p.__name__)