python之面向对象的基本知识

以你之姓@ 2021-10-20 01:18 413阅读 0赞

一、类：具有相同属性和技能的一类事物.

类名的角度  
  \# 操作类中的静态变量  
      \# 1, Person.\_\_dict\_\_ 查询类中的所有的内容 (不能进行增删改操作)  
print(Person.\_\_dict\_\_)  
print(Person.\_\_dict\_\_\['faith'\])  
Person.\_\_dict\_\_\['mind'\] = '无脑'  
print(Person.\_\_dict\_\_\['mind'\])  
      \# 2, 万能的  .  对类中的单个的变量进行增删改查,用 万能的 点  
print(Person.mind)  
print(Person.animal)  \# 查  
Person.money = '运用货币'  \# 增  
Person.mind = '无脑的' \# 改  
del Person.mind  
print(Person.\_\_dict\_\_)

\#操作类中的方法  (工作中基本不用类名去操作)  
Person.work(111)

对象的角度  
ret = Person()  \# 类名+()的这个过程:实例化的过程(创建一个对象的过程),  
        \# Person() 实例化对象,实例,对象.  
print(ret)  
1,只要类名+() 产生一个对象,自动执行类中的\_\_init\_\_方法.

1, 类名+()产生一个实例(对象,对象空间.)  
2, 自动执行类中的\_\_init\_\_方法,将对象空间传给\_\_init\_\_的self参数,  
3, 给对象封装相应的属性.  
 print(ret.\_\_dict\_\_)

对象的角度  
   \# 操作对象中的静态变量  
       \#1, \_\_dict\_\_ 查询对象中的所有的内容  
       \#2, 万能的.  万能的 点.  
 print(ret.name)  \# 查  
 ret.high = 175  \# 增  
 del ret.name  \# 删  
 ret.age = 73 \# 改  
 print(ret.\_\_dict\_\_)  
   \# 对象操作类中的静态变量 : 只能查询.  
 print(ret.mind)

\# 对象调用类中的方法  (工作中 通过对象执行类中的方法,而不是通过类名)  
 ret.shop()  
 print(ret)  
二、类的空间和查询顺序

查询顺序:  
  对象.属性 : 先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找....  
  类名.属性 : 先从本类空间找,如果找不到,再从父类找....

对象与对象之间是互相独立的.

计算一个类 实例化多少对象.

class Count:  
    count = 0  
    def \_\_init\_\_(self):  
        Count.count = self.count + 1

obj1 = Count()  
obj2 = Count()

print(Count.count)  
count = 0

def func():  
    print(count)  
func()

class Count:  
    count = 0  
    def \_\_init\_\_(self):  
        pass

通过类名可以更改我的类中的静态变量值  
Count.count = 6  
print(Count.\_\_dict\_\_)

但是通过对象 不能改变只能引用类中的静态变量

obj1 = Count()  
print(obj1.count)  
obj1.count = 6

三、组合: 给一个类的对象封装一个属性,这个属性是另一个类的对象.

版本一：添加武器：斧子，刀，枪，棍，棒...,  
代码不合理: 人物利用武器攻击别人,你的动作发起者是人,而不是武器.

class GameRole:
        def __init__(self, name, ad, hp):
            self.name = name
            self.ad = ad
            self.hp = hp
    
        def attack(self,p):
            p.hp = p.hp - self.ad
            print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))
    
    class Weapon:
        def __init__(self,name,ad):
            self.name = name
            self.ad = ad
        def fight(self,p1,p2):
            p2.hp = p2.hp - self.ad
            print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'\
                  % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))
    
    p1 = GameRole('大阳哥',20,500)
    p2 = GameRole('印度阿宁',50,200)
    axe = Weapon('三板斧',60)
    broadsword = Weapon('屠龙宝刀',100)
    
    axe.fight(p1,p2)
    broadsword.fight(p2,p1)
    
    p1.attack(p2)

# 版本二:
    class GameRole:
        def __init__(self, name, ad, hp):
            self.name = name
            self.ad = ad
            self.hp = hp
    
        def attack(self,p):
            p.hp = p.hp - self.ad
            print('%s 攻击 %s,%s 掉了%s血,还剩%s血' %(self.name,p.name,p.name,self.ad,p.hp))
    
        def armament_weapon(self,wea):
            self.wea = wea
    
    
    class Weapon:
        def __init__(self,name,ad):
            self.name = name
            self.ad = ad
        def fight(self,p1,p2):
            p2.hp = p2.hp - self.ad
            print('%s 用%s打了%s,%s 掉了%s血,还剩%s血'\
                  % (p1.name,self.name,p2.name,p2.name,self.ad,p2.hp))
    
    p1 = GameRole('大阳哥',20,500)
    p2 = GameRole('印度阿宁',50,200)
    axe = Weapon('三板斧',60)
    broadsword = Weapon('屠龙宝刀',100)
    # print(axe)
    p1.armament_weapon(axe)  # 给大阳哥 装备了三板斧这个对象.
    # print(p1.wea)
    # print(p1.wea.name)
    # print(p1.wea.ad)
    p1.wea.fight(p1,p2)

作业：

题一：

# 1，暴力摩托程序（完成下列需求）：
    # 1.1
    # 创建三个游戏人物，分别是：
    # •    井井，女，18，攻击力ad为20，血量200
    # •    木木，男，20，攻击力ad为30，血量150
    # •    多多，女，19，攻击力ad为50，血量80
    # 1.2
    # 创建三个游戏武器，分别是：
    # •    平底锅，ad为20
    # •    斧子，ad为50
    # •    双节棍，ad为65
    #
    # 1.3
    # 创建三个游戏摩托车，分别是：
    #
    # •    小踏板，速度60迈
    # •    雅马哈，速度80迈
    # •    宝马，速度120迈。

class GameRole:
        def __init__(self, name, age, sex, ad, hp):
            self.name = name
            self.age = age
            self.sex = sex
            self.ad = ad
            self.hp = hp
    
        def attack(self, p):
            p.hp = p.hp - self.ad
            print("%s赤手空拳打了%s%s血，%s还剩%s血" % (self.name, p.name, self.ad, p.name, p.hp))
    
        def add_moto(self, mo):
            self.mo = mo
    
        def add_weapon(self, wea):
            self.wea = wea
    
        def road_rush(self, p1):
            p1.hp = p1.hp - self.ad - self.wea.ad
            print("%s骑着%s打了骑着%s的%s一%s，%s哭了，还剩%s血" % (
            self.name, self.mo.name, self.mo.name, p1.name, self.wea.name, p1.name, p1.hp))
    
    
    class Weapon:
        def __init__(self, name, ad):
            self.name = name
            self.ad = ad
    
        def fight(self, p1, p2):
            p2.hp = p2.hp - self.ad - p1.ad
            print("%s利用%s打了%s一%s，%s还剩%s血" % (p1.name, self.name, p2.name, self.name, p2.name, p2.hp))
    
    
    class moto:
        def __init__(self, name, speed):
            self.name = name
            self.speed = speed
    
        def drive(self, p1):
            print("%s骑着%s开着%s迈的车速在赛道上" % (p1.name, self.name, self.speed))
    
    
    p1 = GameRole('井井', '女', 18, 20, 200)
    p2 = GameRole('木木', '男', 20, 30, 150)
    p3 = GameRole('多多', '女', 19, 50, 80)
    
    w1 = Weapon('平底锅', 20)
    w2 = Weapon('斧子', 50)
    w3 = Weapon('双节棍', 65)
    
    m1 = moto("小踏车", "60")
    m2 = moto("雅马哈", "80")
    m3 = moto("宝马", "120")
    
    # 完成下列需求（利用武器打人掉的血量为武器的ad + 人的ad）：
    # （1）井井骑着小踏板开着60迈的车行驶在赛道上。
    m1.drive(p1)
    # （2）木木骑着宝马开着120迈的车行驶在赛道上。
    m3.drive(p2)
    # （3）多多骑着雅马哈开着80迈的车行驶在赛道上。
    m2.drive(p3)
    
    # （4）井井赤手空拳打了多多20滴血，多多还剩xx血。
    p1.attack(p3)
    # （5）木木赤手空拳打了多多30滴血，多多还剩xx血。
    p2.attack(p3)
    
    # （6）多多利用平底锅打了井井一平底锅，井井还剩xx血。
    p3.add_weapon(w1)
    p3.wea.fight(p3, p1)
    # （7）多多利用斧子打了木木一斧子，木木还剩xx血。
    p3.add_weapon(w2)
    p3.wea.fight(p3, p2)
    
    # （8）井井骑着宝马打了骑着小踏板的木木一双节棍，木木哭了，还剩xx血。
    p1.add_weapon(w3)
    p1.add_moto(m3)
    p2.add_moto(m1)
    p1.road_rush(p2)
    # （9）多多骑着小踏板打了骑着雅马哈的木木一斧子，木木哭了，还剩xx血。
    p2.add_moto(m1)
    p2.add_weapon(w2)
    p1.add_moto(m2)
    p2.road_rush(p1)

题二：

定义一个类，计算圆的周长和面积。

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

题三：

定义一个圆环类，计算圆环的周长和面积（升级题）。

法一：

from math import pi
    class Ring:
        def __init__(self, r1, r2):
            self.r1 = r1
            self.r2 = r2
        def area(self):
            return round(self.r1 ** 2 * pi - self.r2 ** 2 * pi, 2)
        def perimeter(self):
            return round(self.r1 * 2 * pi + self.r2 * 2 * pi, 2)
    ll = Ring(6, 3)
    print(ll.area())
    print(ll.perimeter())
    print(Ring(6, 3).area())

法二：

from math import pi
    
    
    class Circle:
        def __init__(self, r):
            self.r = r
    
        def area(self):
            return round(self.r ** 2 * pi, 2)
    
        def perimeter(self):
            return round(self.r * 2 * pi, 2)
    
    class Ring:
        def __init__(self, R1, R2):
            self.r1 = Circle(R1)
            self.r2 = Circle(R2)
    
        def area(self):
            return self.r1.area() - self.r2.area()
    
        def perimeter(self):
            return self.r1.perimeter() + self.r2.perimeter()
    
    
    ll = Ring(6, 3)
    print(ll.area())