面向对象

一、引子 人狗大战

def person(name,sex,agger,hp):

    person_dic = {"name":name,"sex":sex,"agger":agger,"hp":hp}

    def attack(dog):   #dog("xiaogei","shachai",260,1000000)  #

        dog["hp"] -= person_dic["agger"]
        print("%s打了%s,%s掉了%s血" % (person_dic["name"],dog["name"],dog["name"],person_dic["agger"]))

    person_dic["attack"] = attack
    return person_dic

def dog(name,kind,agger,hp):

    dog_dic = {"name":name,"kind":kind,"agger":agger,"hp":hp}

    def bite(person):  #person_dic

        person["hp"] = person["hp"] - dog_dic["agger"]
        print("%s咬了%s,%s掉了%s血" % (dog_dic["name"], person["name"], person["name"],dog_dic["agger"]))

    dog_dic["bite"] = bite

    return dog_dic
hei = dog("xiaohei","shachai",260,1000000)
#字典hei = dog_dic = {"name":xiaohei,"kind":shachai,"agger":260,"hp":1000000,"bite":bite}

alex = person("alex","men",250,100000)
#字典alex = person_dic ={"name":lex,"sex":men,"agger":250,"hp":100000,"attack":attack}

alex["attack"](hei)
hei["bite"](alex)      #bite(alex)  #person_dic

二、理论知识

1.类：是一类具有相同属性和方法的事物
2.对象：是类中一个具体的具有自己属性值的，即事例

class Person:                     #类名
    role = "人"                   #类的静态变量 是所有的对象共享的一个属性
                                    类名.属性名调用的

     def attack(self):pass         #行为方法
print(Person.role)                #类提供给我们的调用方式
print(Person.attack)              #<function Person.attack at 0x000002937FDD8950>
Person.role = "中国人"
print(Person.role)                #可以改变类的变量
print(Person.__dict__)            #存储方式
print(Person.__dict__["role"])
print(Person.__dict__['attack'])


3.类只有两个作用:
(1)使用类中的名字:
查看类中的名字:
类名.变量名                  # 可以修改变量的值
类名.__dict__['变量名']      # 不能修改

(2)创造对象  实例化对象
对象就是实例,一个实际的例子
对象 = 类名()

4.对象的具体:
内存地址的不一致
不同的对象 属性的值应该不同

5.类名(参数)
(1)创造一个空对象 :     self
(2)调用__init__方法 :  初始化方法
(3)把参数传给__init__方法
(4)完成init方法中的代码
(5)自动将self返回给实例化的地方


6.self就是对象

7.调用类中的方法 :
    类名.方法名(对象)
    对象名.方法名()

8.做题思路：
1.完成类
2.首先分析一下角色和类,类里面有哪些属性__init__方法
3.再分析这个类中能有哪些行为,定义为方法
4.实例化
传参数获取实例化之后的对象
首先创造对象====类()
执行init方法
5.对象的调用
使用对象调用,对象属性,和类中的方法
6.对象名的作用:
    1.使用变量 对象名.属性名
    2.调用方法 对象名.方法名()

三，创建类

class Person:
    role = "人"
    def __init__(self,name,sex,agger,hp):
        self.name = name
        self.sex = sex
        self.agger = agger
        self.hp = hp
    def attack(self):
        print(self.name)
        print(self.sex)
obj1 = Person("alex","female",250,1)
obj2 = Person("egon","mele",500,2)
print(obj1.name,obj1.sex,obj1.agger,obj1.hp)
print(obj2.name,obj2.sex,obj2.agger,obj2.hp)
print(obj1.__dict__)
print(obj2.__dict__)

Person.attack(obj1)    #通过类调用一个类中的方法
obj1.attack()          #通过对象掉用了类中的方法

class Dog:
    role = "dog"
    def __init__(self,name,kind,agger,hp):
        self.name = name
        self.kind = kind
        self.agger = agger
        self.hp = hp
    def attack(self):
        print(self.name)
        print(self.kind)
obj3 = Dog("dog","taidi",260,10000)
print(obj3.name,obj3.kind,obj3.agger,obj3.hp)

class Person:                                     #类名
    role = '人'                                   #类的静态变量 是所有的对象共享的一个属性
    def __init__(self,name,sex,agger,hp):         #方法 动态属性  内置的双下方法
        self.name = name                          #对象属性 实例属性
        self.sex = sex
        self.agger = agger
        self.hp = hp
    def attact(self,dog):                          #自定义方法
        dog.hp -= self.agger
        print("%s打了%s,%s掉了%s血,还剩%s血"%(self.name,dog.name,dog.name,self.agger,dog.hp))
class Dog:
    def __init__(self,name,kind,agger,hp):
        self.name = name
        self.kind = kind
        self.agger = agger
        self.hp = hp
    def bite(self,person):
        person.hp -= self.agger
        print("%s咬了%s,%s掉了%s血,还剩%s血"%(self.name,person.name,person.name,self.agger,person.hp))

hei = Dog("小黑","teddy",260,10000)       #调用一个Dog类,此时的hei和self一样，实例化:先创造对象 再初始化
alex = Person("alex","male",2,500)        #实例化
alex.attact(hei)     #Person.attact(alex,hei)
hei.bite(alex)       #Dog.bite(hei,alex)

总结做题思路：

1.完成类
2.首先分析一下角色和类,类里面有哪些属性__init__方法
3.再分析这个类中能有哪些行为,定义为方法
4.实例化
传参数获取实例化之后的对象
首先创造对象====类()
执行init方法
5.对象的调用
使用对象调用,对象属性,和类中的方法
6.对象名的作用:
    1.使用变量 对象名.属性名
    2.调用方法 对象名.方法名()

1.求圆的面积，圆的周长

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
c = Circle(5)
print(c.r)               #5
print(c.area())          #78.53981633974483
print(c.perimeter())     #31.41592653589793

2.面向对象编程,打印：

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

class Preson:
    def __init__(self,name,sex,age):
        self.name = name
        self.sex = sex
        self.age = age
    def clib(self):
        print("%s,%s,%s岁，上山去砍柴"%(self.name,self.sex,self.age))
    def drive(self):
        print("%s,%s,%s岁，开车去东北" %(self.name,self.sex,self.age))
    def hobby(self):
        print("%s,%s,%s岁，最爱大保健" % (self.name,self.sex, self.age))

obj1 = Preson("xiaoming","men",10)
obj1.clib()
obj1.drive()
obj1.hobby()

obj2 = Preson("zhang","men",10)
obj2.clib()
obj2.drive()
obj2.hobby()

四、理论知识

1.上帝视角
面向对象的特点 : 可扩展性强  相对控制性弱(结局不可控)   (关系复杂,大)
面向过程的特点 : 比较容易想  可扩展性弱  (关系单一,小)

2.什么是类 什么是对象 什么是实例 ?
类    是一类具有相同属性和方法的事物
对象  是类中一个具体的具有自己的属性值的,即实例

3.与实际例子结合的理论知识
class Foo:
    #__init__ 内置初始化方法
    def __init__(self):
        self.name = "alex"

        # 静态属性（静态变量）
        # 静态属性 = "中国" #是直接可以用类名。属性名调用的

        #动态属性（动态方法）（函数）
    def attack(self):pass
    def bite(self):pass
# 实例化：创造对象 执行init方法
# 对象 = 类名()
print(对象.__dict__)

五、命名空间

1.由于对象和类之间存在一个关联关系，所以对象能够找到类，但是类不能找到对象
2.使用类名.属性   只会寻找类中的静态变量名字
3.使用对象.属性   会现在对象自己的命名空间中找名字。如果找不到 再到类的内存空间中去找
4.类名.静态变量     对象.属性名
5.类名可以调用对象的属性嘛？ 不可以
6.对象可以调用类的属性嘛？  可以

class Person:
    Country = "中国人"     #静态变量
print(Person.Country)      #调用类中的变量
alex = Person()            #创建一个空的命名空间
alex.name = "alex"         #对象的属性
alex.Country = "泰国人"    #对象调用了类的属性
print(alex.Country)        #泰国人
egon = Person()            #创建一个空的命名空间
egon.name = "egon"         #对象调用了类的属性
egon.Country = "中国人人"  #在自己的命名空间创建了一个属性
print(egon.Country)        #中国人人

命名空间的例子1：
class Person:
    Country = "中国人"
alex = Person()
egon = Person()
print(alex.Country)      #中国人(类在自己的命名空间没有找到Country这个属性名，所以调用了类中的静态变量名字)
alex.Country = "印度人"  #在对象的命名空间中创建了一个Country属性名
print(alex.Country)      #印度人,（在对象自己的命名空间找到了Country这个属性名）
print(Person.Country)    #中国人,(类中的静态变量名字不会被对象改变)
# 总结：只要你使用静态变量，就用类名去调用

命名空间的例子2：使用内存地址去分析
class Person:
    money = 0
mother = Person()
father = Person()
mother.money = mother.money + 100
father.money = father.money + 100

print(mother.money,id(mother.money))     #100,1718057536指向类中静态变量的内存地址
print(father.money,id(father.money))     #100,1718057536指向类中静态变量的内存地址
print(Person.money,id(Person.money))     #0 , 1718054336 不会改变类中静态变量的内存地址

命名空间的例子3：使用内存地址去分析
class Person:
    money = [0]
mather = Person()
father = Person()
mather.money[0] = mather.money[0] + 100
print(mather.money[0],id(mather.money[0]))  #100 1718057536  改变的是类中静态变量中第一个元素，对静态变量没有影响
father.money[0] = father.money[0] + 100
print(mather.money[0],id(mather.money[0]))  #200 1718060736  改变的是类中静态变量中第一个元素，对静态变量没有影响
print(father.money[0],id(father.money[0])) #200  1718060736  改变的是类中静态变量中第一个元素，对静态变量没有影响
print(Person.money,id(Person.money))      #[200] 1763572885832 类.静态变量 的内存地址不会改变

命名空间的例子4：使用内存地址去分析
class Person:
    money = [0]
mother = Person()
father = Person()
mother.money = [1000]
father.money = [2000]
print(mother.money,id(mother.money))  #[1000] 2670227728648 ,在自己的命名空间创建了一个money属性
print(father.money,id(father.money))  #[2000] 2670226915976 ,在自己的命名空间创建了一个money属性
print(Person.money,id(Person.money))  #[0] 2670226916104

写一个类,能统计这个类被多少个对象实例化了.所有的对象共享这个结果 init 静态变量
class Foo:
    num = 0
    def __init__(self):
        Foo.num += 1
f1 = Foo()
print(f1.num)    #1
f2 = Foo()
print(f2.num)    #2
f3 = Foo()
print(f3.num)    #3
print(Foo.num)

六、组合

1.理论知识：
组合         两个类的事儿
什么叫组合 : 一个类对象的属性 是 另外一个类的对象
两个类的事儿 :类与类之间有一种"什么有什么的关系"

例子1：求圆环的周长和圆环的面积
圆的类，圆环也是一个类
属性 大圆半径 和 小圆半径
方法 面积 和 周长
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return self.r ** 2 * pi
    def perimeter(self):
        return 2 * pi * self.r
c = Circle(5)

class Ring:
    def __init__(self,outer,inner):
        self.outer = Circle(outer)      #对象的属性  = 类的对象---->组合
        self.inner = Circle(inner)
    def area(self):
        return self.outer.area() - self.inner.area()
    def perineter(self):
        return self.outer.perimeter() + self.inner.perimeter()
r = Ring(10,5)
print(r.area())         #235.61944901923448
print(r.perineter())    #94.24777960769379

例子2： 老师  name sex course(课程)  birth
class Birthday:
    def __init__(self,year,month,day):
        self.year = year
        self.month = month
        self.day = day
class Teacher:
    def __init__(self,name,sex,course,birth):
        self.name = name
        self.sex = sex
        self.course = course
        self.birth = birth    #birth是一个对象
birth = Birthday(1960,3,7)
alex = Teacher("alex","male","python",birth)
my_birth = alex.birth
import time
if my_birth.month == time.localtime().tm_mon
    and my_birth.day == time.localtime().tm_mday:
    print("生日快乐")
else:
    print("今天不是此人生日")
print("他的生日是%s月%s日今年%s岁"%(my_birth.month, my_birth.day,time.localtime().tm_year - my_birth.year))
print(alex.name,alex.sex,alex.course,my_birth.year,my_birth.month,my_birth.day)

例子3：人狗大战
class Weapon:
    def __init__(self,name,price,agger,protect):
        self.name = name
        self.price = price
        self.agger = agger
        self.protect = protect
    def kill(self,dog):
        print("使用了%s的必杀技，打中了%s"%(self.name,dog.name))
        dog.hp = dog.hp - self.agger
        print("%s的生命值减少了%s，剩余%s"%(dog.hp,self.agger,dog.hp))
class Person:
    def __init__(self,name,sex,agger,hp):
        self.name = name
        self.sex = sex
        self.agger = agger
        self.hp = hp
    def attact(self,dog):
        dog.hp = dog.hp - self.agger
        return "%s打了%s,%s掉了%s血，还剩%s血"%(self.name,dog.name,dog.name,self.agger,dog.hp)
class Dog:
    def __init__(self,name,kind,agger,hp):
        self.name = name
        self.kind = kind
        self.agger = agger
        self.hp = hp
    def bite(self,person):
        person.hp = person.hp - self.agger
        return "%s打了%s,%s掉了%s血，还剩%s血"%(self.name,person.name,person.name,self.agger,person.hp)
weapon = Weapon("属龙宝刀",20000,999,0)
print(weapon.name)
alex = Person("alex","men",1,250)
hei = Dog("dog","teddy",260,10000)

print("欢迎登陆xxxx")
print(hei.bite(alex))

ret1 = input("输入1:充值,并且可以复活 2:退出游戏")
if ret1 == "2":
    exit()
elif ret1 == "1":
    money = int(input("10000元可以复活一次，你要充值多少元"))
    if money > 10000:
        alex.hp = 250
        alex.money = money - 10000
        print("复活成功，当前血量%s,当前帐户余额%s"%(alex.hp,alex.money))
    ret2 = input("输入1:购买武器")
    if ret2 == "1":
        if alex.money >= 2000:
            alex.money -= weapon.price
            print(111)
            alex.weap = weapon   #对象的属性 是 另一个类的对象
            print("购买成功，当前余额%s,当前武器%s"%(alex.money,alex.weap.name))
print(alex.attact(hei))     #alex打了dog,dog掉了1血，还剩9999血
alex.weap.kill(hei)
hei.bite(alex)