初识面向对象

初识面向对象

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
写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

alex = Person('金老板',100,10,'不详')
taidi = Dog('小白',200,500,'泰迪')
wawa = Dog('星星',100,300,'金巴吉娃娃')

taidi['bite'](alex)  #狗咬人
alex['attack'](wawa)  #人打狗

　Dog函数和Person函数，但是定义了一类事物，直到调用了函数，赋值了之后才真的有了一个实实在在的人物或者狗狗

面向对象编程
◆所谓模子  就是  类
◆alex，泰迪，是对象
◆类是抽象的，可以知道有什么属性，有什么技能，但是不知道具体的值
◆对象是具体的，有具体的值，属性和技能但是根据类来规范的
◆先有类才有对象

自定义类

class 类名 :
    属性 = 'a'
#通过点来查看属性
print(类名.属性)
#类名的作用：操作属性，查看属性

 

class Person: # 类名
    country = "China"   # 创造了一个只要是这个类就一定有的属性，叫做类属性，也叫静态属性

    def __init__(self,*args): # 初始化方法  self是对象，是一个必须传的参数
        # self就是一个可以存储很多属性的打字典，只不过往字典里添加属性的方式发生了一些变化
        self.name = args[0]
        self.blood = args[1]
        self.aggr = args[2]
        self.sex = args[3]
        print(self.__dict__) #{'aggr': 10, 'blood': 100, 'name': '金老板', 'sex': '女'}

    def walk(self,n):  # 方法  一般情况下必须传self，且必须写再第一个位置，后面还可以传其他参数
        #  #self参数是alex传过来的,,,n是走的步数，由alex.walk(6)中的实参传进来的
        print('%s走走走，走了%s步'%(self.name,n))

alex = Person('金老板',100,10,'女')
print(alex) #<__main__.Person object at 0x000002C20A443CC0>
print(alex.name) #金老板
print(alex.__dict__) #查看所有属性{'aggr': 10, 'blood': 100, 'name': '金老板', 'sex': '女'}
self 和 alex的内存地址是一样的

Person.walk(alex,6)  #调用方法   类名.方法名(对象)
alex.walk(6)   #等价于 Person.walk(alex)   是Person.walk(alex)的简写    即对象.方法名（）

#__dict__
print(Person.__dict__) #得到的是Person类中的所有方法
print(Person.__dict__['country'])  # 得到的是china

print(alex.__dict__['name'])   # 金老板
# 修改属性值由两种方法 但是推荐使用第一种  alex.name = '柠檬'
alex.name = '柠檬'
print(alex.name)
alex.__dict__['name'] = '二哥'
print(alex.__dict__)
# 增加属性
alex.age = 50
print(alex.__dict__)

类名+（） 就是对象

◆过程：
    类名（） 首先会创造一个对象，创建了一个self变量
    调用init方法，类名括弧里的内容会被这里接收
    执行init方法
    返回self
◆对象能做的事：
    查看属性
    调用方法
    __dict__ 对于对象的增删改查操作都可以通过的语法进行
◆类名能做的事：
    调用类拿到对象的过程叫做实例化 alex = Person('金老板',100,10,'女')
    实例化
    调用方法 ： 只不过要自己传递self参数 Person.walk(alex,6)  #调用方法   类名.方法名(对象)
    调用类中的属性  print(Person.country) 类名调用属性  也就是调用静态属性
    对于类中的名字只能看 不能操作

使用面向对象的情况：
◆当有几个函数需要反反复复传入相同参数的时候，就可以考虑面向对象，这些参数都是对象的属性
◆非常明显的处理一类事物的，这些事物都具有相似的属性和功能

class Dog:
    def __init__(self,*args):
        self.name = args[0]
        self.blood = args[1]
        self.aggr = args[2]
        self.kind = args[3]
    def bite(self,person): # 狗咬人，人掉血
        person.blood -= self.aggr
        print('%s被打了，掉了%s的血' %(jin.name,self.aggr))
class Person:
    def __init__(self,name,blood,aggr,sex):
        self.name = name
        self.blood = blood
        self.aggr = aggr
        self.sex = sex
    def attack(self,dog):
        dog.blood -= self.aggr
        print('%s被打了，掉了%s的血' % (taidi.name, self.aggr))

taidi = Dog('小白',200,260,'taidi')
jin = Person('金老板',100,30,'男')
taidi.bite(jin)  #金老板被打了，掉了260的血
print(jin.blood) # -160
jin.attack(taidi)# 小白被打了，掉了30的血
print(taidi.blood)#170

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


class Person:
    def __init__(self,*args):
        self.name = args[0]
        self.age = args[1]
        self.sex = args[2]
    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))
xiaoming = Person('小明','10岁','男')
xiaoming.shangshan()
xiaoming.drive()
xiaoming.favor()
laoli = Person('老李','90岁','男')
laoli.shangshan()
laoli.drive()
laoli.favor()

#属性 半径 ，两个方法，
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def perimeter(self):
        return  2 * pi * self.r
    def area(self):
        return  self.r * self.r * round(pi,2)
l = Circle(6)
print(round(l.perimeter(),2))
print(round(l.area()),2)

class Circle:
    def __init__(self,l,h):
        self.l = l
        self.h = h
    def perimeter(self):
        return  (self.l+self.h) * 2
    def area(self):
        return  self.l * self.h
l = Circle(4,2)
print(l.perimeter())
print(l.area())