初始面向对象

今天我们来学习python中面向对象的相关知识，在学习面向对象之前，先来了解类的相关知识和对象的相关知识。

首先，什么是类？怎么用？我们得搞清楚

def demo():
pass
demo()

'''
class 类名
类的文档字符串
类体

'''

class Student：
pass

class Person:
'''
申明一个具体的人类
''‘
    role='person'
    def __init__(self,name,life_value,aggr):
        self.name=name
        self.life_value=life_value
        self.aggr=aggr
    def attack(self):
        print('攻击')

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

属性引用（类名 属性） 具体操作如下，

class cat:
    role='anminal'
def bark(self):
print('the cat can bark...')

print(cat.role)
print(cat.bark)

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

class cat:  #定义一个猫类
    role='anminal' #猫的角色是动物
def __init__(self,name,breed,color):
        self.name=name   #每一个角色都有自己的名字
        self.breed=breed
        self.color=color
def bark(self):  #猫有叫的这种方法
print('the cat can bark...')

print(cat.role)  #查看猫的role属性
print(cat.bark)   #引用方法，注意不是在调用

实例化过程实际上就是类——->对象的转化过程

对象名=类名（参数）

cat1=Cat('carfield')  #类名()就等于在执行Cat.__init__()
#执行完__init__()就会返回一个对象。这个对象类似一个字典，存着属于这个人本身的一些属性和方法。

查看属性&调用方法

print(cat1.name)  
#查看属性直接对象名.属性
print(cat1.bark())
#查看调用方法 直接对象名.方法名

注：关于self,在实例化时自动将对象或者实例本身传递给__init__的第一个参数，你也可以改变其名字，但尽量不要这么做。

在这里我们需要对学的面向对象做一个小结：

面向对象小结——定义及调用的固定模式

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   #查看对象的属性，直接用 对象名.属性名 即可
对象名.方法名()     #调用类中的方法，直接用 对象名.方法名() 即可

对象之间的交互

  首先创造一个人类，然后在创造一个狗类，给狗类给一个方法为bark,接下来人和狗就可以打架了，以人狗大战为例，具体代码如下：   

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)
 wangcai= 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(wangcai.life_value)
print(egg.aggr)
egg.attack(wangcai)
print(wangcai.life_value)

egg.weapon.kill(wangcai)
print(wangcai.life_value)
egg.weapon.kill(wangcai)
print(wangcai.life_value)

类命名空间与对象实例的命名空间

创建一个类就会创建一个类的命名空间，用来存储类中定义的所有名字，这些名字称为类的属性。

而类有两种属性：静态属性和动态属性

• 静态属性就是直接在类中定义的变量
• 动态属性就是定义在类中的方法

补充：

dir(类) #返回类中的所有名字列表
isinstance(对象，类) #判断对象是否为类的实例

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__)

 课后习题：

 

#圆形类
class Circle:
    def __init__(self,radius):
        self.radius = radius

    def area(self):
'面积'
return self.radius **2  * 3.14

    def perimeter(self):
'周长'
return self.radius * 2 *3.14

圆 = Circle(3)
print(圆.area())
print(圆.perimeter())