Python9-面对对象1-day22

def Person(name,blood,aggr,sex):

    person = {
                'name' : name,
                'blood':blood,
                'aggr': aggr,
                'sex' : sex,
    }
    def attack(dog):
        dog['blood'] -= person['aggr']
        print('%s被打了，掉了%s的血' % (dog['name'],person['aggr']))
    person['attack'] = attack
    return person

#是精简了，方便增加人物，方便修改， 人物更加规范
def Dog(name,blood,aggr,kind):
    dog = {
                'name' : name,
                'blood':blood,
                'aggr': aggr,
                'kind' : kind,
    }
    def bite(person):
        person['blood'] -= dog['aggr']
        print('%s被咬了，掉了%s的血' % (person['name'],dog['aggr']))
    dog['bite'] = bite
    return dog
#攻击技能 打
# def attack(person,dog):
#     dog['blood'] -= person['aggr']
#     print('%s被打了，掉了%s的血' % (dog['name'],person['aggr']))

#咬人 咬
# def bite(dog,person):
#     person['blood'] -=dog['aggr']
#     print('%s被咬了，掉了%s的血' % (person['name'],dog['aggr']))

tim = Person('tim',300,1,'None')
nezha = Person('哪吒',300,3, '不详')
jin = Dog('金喇叭',1000,200,'teddy')
print(jin)
jin['bite'](nezha)
tim['attack'](jin)

Dog函数和Person函数，都是定义了一类事务
直到调用了函数，赋值后才真的有了一个实实在在的人或狗
面向对象编程
所谓模子就是类，类是抽象的，我能知道有什么属性，有什么技能，但不能知道属性具体的值
jin tim nezha 就是对象，有具体的值，属性和技能都是根据类规范的

初识面对对象

class 类名：
    属性 = 'a'
类名.属性
类名的作用 就是操作属性，查看属性

class Person:
    def __init__(self,*args):
        self.name = args[0]
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
tim = Person('tim',300,1,'None')     #tim是个对象  实例化
print(tim.name)
print(tim.hp)
print(tim.aggr)
print(tim.sex)

tim
300
1
None

对象  =类名()
过程：
    类名() 首先会创造出一个对象，创建了一个self变量
    给调用init方法，类名括号里的参数会被这里接收
    执行init方法
    返回self

class Person:
    def __init__(self,*args):
        # print(self.__dict__)  #self就是一个可以存储很多属性的大字典
        self.name = args[0]   #往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        # print(self.__dict__)
    def walk(self):
        print('%s走走走'%self.name)
tim = Person('tim',300,1,'不详')     #tim是个对象  实例化
# print(tim.__dict__)
# print(Person.__dict__)
Person.walk(tim)

tim走走走

class Person:
    def __init__(self,*args):
        # print(self.__dict__)  #self就是一个可以存储很多属性的大字典
        self.name = args[0]   #往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        # print(self.__dict__)
    def walk(self,n):
        print('%s走走走,走了%s步'%(self.name,n))
tim = Person('tim',300,1,'不详')     #tim是个对象  实例化
# print(tim.__dict__)
# print(Person.__dict__)
# Person.walk(tim)      #调用方法，类名.方法名（对象名）
tim.walk(5)      #Person.walk(tim)

汇总

class Person:           #类名
    country = 'China'   #创造了一个只要是这个类一定有的属性，这个属性叫类属性，也叫静态属性
    def __init__(self,*args):   #初始化方法，self是对象，是一个必须传的参数
        # print(self.__dict__)  #self就是一个可以存储很多属性的大字典
        self.name = args[0]   #往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        # print(self.__dict__)
    def walk(self,n):            #方法 一般情况下必须传self参数且必须写在第一个，后面还可以传其他参数，是自由的
        print('%s走走走,走了%s步'%(self.name,n))
tim = Person('tim',300,1,'不详')     #类名还可以实例化对象，tim是个对象  实例化
# print(tim.__dict__)
# print(Person.__dict__)
# Person.walk(tim)      #调用方法，类名.方法名（对象名）
print(Person.country)   #类名 可以查看类中的属性，不需要实例化就可以查看
tim.walk(5)      #Person.walk(tim)   #调用方法，类名.方法名（对象名）
print(tim.name)   #查看属性值
print(tim.hp)
print(tim.aggr)
print(tim.sex)

#.__dict__方法

print(Person.__dict__)
print(tim.__dict__)
print(Person.__dict__['country'])
print(tim.__dict__['name'])
tim.__dict__['name'] = '二哥'
print(tim.__dict__)
print(tim.name)

{'walk': <function Person.walk at 0x005B01E0>, 'country': 'China', '__doc__': None, '__init__': <function Person.__init__ at 0x005B02B8>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__dict__': <attribute '__dict__' of 'Person' objects>}
{'hp': 300, 'sex': '不详', 'name': 'tim', 'aggr': 1}
China
tim
{'hp': 300, 'sex': '不详', 'name': '二哥', 'aggr': 1}
二哥

class Person:           #类名
    country = 'China'   #创造了一个只要是这个类一定有的属性，这个属性叫类属性，也叫静态属性
    def __init__(self,*args):   #初始化方法，self是对象，是一个必须传的参数
        # print(self.__dict__)  #self就是一个可以存储很多属性的大字典
        self.name = args[0]   #往字典里添加属性的方式发生了一些变化
        self.hp = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        # print(self.__dict__)
    def walk(self,n):            #方法 一般情况下必须传self参数且必须写在第一个，后面还可以传其他参数，是自由的
        print('%s走走走,走了%s步'%(self.name,n))
tim = Person('tim',300,1,'不详')     #类名还可以实例化对象，tim是个对象  实例化print(tim.name)
tim.name = '二哥'
print(tim.name)
print(tim.__dict__)

tim.age = 83     #增加属性
print(tim.__dict__)

对象  =类名()
过程：
    类名() 首先会创造出一个对象，创建了一个self变量
    给调用init方法，类名括号里的参数会被这里接收
    执行init方法
    返回self
对象能做的事情：
    查看属性
    调用方法
    .__dict__对于对象的增删改查操作都可以通过字典的语法进行
类名能做的事情：
    实例化
    调用方法，只不过要自己传递self参数
    调用类中的属性
    调用类中的属性，也就是调用静态属性
    __dict__对于类中的名字只能看不能操作
练习

class Person:
    def __init__(self,name,age,sex):
        self.name =name
        self.age = age
        self.sex = sex
    def shangshan(self):
        print('%s,%s岁,%s,上山去砍柴'%(self.name,self.age,self.sex))
    def drive(self):
        print('%s,%s岁,%s,开车去东北'%(self.name,self.age,self.sex))
    def favor(self):
        print('%s,%s岁,%s,最爱大保健'%(self.name,self.age,self.sex))

ming = Person('小明','','男')
ming.shangshan()
ming.drive()
ming.favor()
zhang = Person('老张','','男')
zhang.shangshan()
zhang.drive()
zhang.favor()

小明,10岁,男,上山去砍柴
小明,10岁,男,开车去东北
小明,10岁,男,最爱大保健
老张,90岁,男,上山去砍柴
老张,90岁,男,开车去东北
老张,90岁,男,最爱大保健

# circle 属性 半径  求周长和面积

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi*(self.r **2)
    def perimeter(self):
        return 2*pi*self.r
c1 = Circle(5)
print(c1.area())
print(c1.perimeter())

78.53981633974483
31.41592653589793

定义类
init方法
self是什么 self拥有的属性都属于对象
类中可以定义静态属性
类中可以定义方法，方法都有一个必须穿的参数self
实例化
实例就是对象
对象查看属性
使用对象调用方法