面向對象初識

類的概念:具有相同屬性和技能的一類事物

對象的概念:對一個類的具體描述

使用面向對象的好處:

1.使得代碼之間的角色關系更加明確

2.增強了代碼的可擴展性

3.規範了對象的屬性和性能

面向對象的特點:

結局的不確定性

類的內部各個部分說明和結構:

class 類名(首字母大寫):

　　#引用靜態變量

　　　　　#1.類名.__dict__[‘靜態變量名‘] #可以查看,但是不能刪改

　　　　　#2.類名.靜態變量名 #直接就可以訪問,可以刪改

　　　　　　　　#刪除一個靜態變量:del 類名.靜態變量名

　　#引用動態變量

　　　　 #1.類名.方法名 #查看這個方法的內存地址

　　　　 #2.類名.方法名(實參) #調用了這個方法,必須傳一個 實參,這個實參傳給了self

　 #創造一個對象 -示例化

　　　　 #產生一個實例(對象)的過程

　　　　 #格式: 對象 = 類名()

下面寫一個簡單的類,跟上面的概念進行對應:

class Person:
    role = ‘person‘
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    
 
def attack(self):
        print(‘%s發起了一次攻擊‘%self.name)

alex = Person(‘a_sb‘,‘不詳‘,1,5)
boss_jin = Person(‘金老板‘,‘女‘,20,50)

類中實例化的過程:

1.創造一個實例,將會作為一個實際參數

2.自動觸發一個__list__方法,並且把實例以參考的形式傳遞給__init__方法中的self形參

3.執行完__init__方法之後的,會將self自動返回給alex

__init__方法:初始化方法,給一個對象添加一些基礎屬性的方法,一般情況不是self的賦值

對象:

1.在類的內部self是本的一個對象

2.在類的外部,每個對象都對應著一個名字,這個對象指向一個對象的內存空間

屬性的調用:(兩種調用方式)

1.對象名.屬性名

2.對象名.__dict__[‘屬性名‘]

方法的調用:(兩種方式)

1.類名.方法名(對象名) # 那麽方法中的self參數就指向這個對象

2.對象名.方法名() # 這樣寫 相當於 方法中的self參數直接指向這個對象

面向對象的傳參和交互輸出

class Person:
    role = ‘person‘
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
    
    def attack(self,user):
        user.hp -= self.ad
        print(‘%s 發起一次攻擊%s,%s掉了%s點血‘ %(self.name,user.name,user.name,self.ad))

class Dog:
   def __init__(self,name,kind,hp,ad):
        self.name = name
        self.sex = kind
        self.hp = hp
        self.ad = ad
        
   def bite(self,ani):
        print(‘%s 發起一次攻擊%s,%s掉了%s點血‘ %(self.name,ani.name,ani.name,self.ad))
        ani.hp -= self.ad
        
tom = Person(‘塔姆‘,‘男‘,60,45)
teddy = Dog(‘笨笨‘,‘teddy‘,50,10)

tom.attack(teddy)
teddy.bite(tom)

print(tom.hp)
print(teddy.hp)

結果:

塔姆 發起一次攻擊笨笨,笨笨掉了45點血
笨笨 發起一次攻擊塔姆,塔姆掉了10點血
50
5

命名空間和作用域

總結:

對象屬性是獨有的,靜態屬性和方法是共享的

對象使用的名字:先找自己的內存空間中的,再找類的內存空間中的

類名.靜態變量名:對於靜態屬性的修改,應該使類名直接修改

例子代碼:

展示現在一共有多少錢?

本例中 money為不可變數據類型,self.money相當於在對象內存空間中創建了一個叫money的屬性,並不能引用\

類內存空間中的靜態變量

class Person:
    money = 0def __init__(self,name):
        self.name = name
    def work(self):
        print(self.name,‘工作,賺了1000塊錢‘)
        self.money += 1000

father = Person(‘father‘)
mother = Person(‘mother‘)
mother.work()
father.work()
print(Person.money)

變成可變數據類型,就能夠對money進行索引引用,由於是可變類型,對象空間不能完成創建,只能引用類空間的money

class Person:
    money = [0]
    def __init__(self,name):
        self.name = name
    def work(self):
        print(self.name,‘工作,賺了1000塊錢‘)
        self.money[0] += 1000

father = Person(‘father‘)
mother = Person(‘mother‘)
mother.work()
father.work()
print(Person.money)

面向對象的組合用法

軟件重用的重要方式除了繼承之外還有另外一種方式，即：組合

組合指的是:在一個類中以另外一個類的對象作為數據屬性，稱為類的組合

下面例:

class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0
    def attack(self.dog):
        dog.hp -= self.ad
        print(%s攻擊了%s，%s掉了%s點血‘ %(self.name,d.name,d.name,self.ad))
    def pay(self):
        money = int(input(‘請輸入您要充值的金額: ‘))
        self.money += money 
        print("余額是:%s" %self.money)
     def wear(self,weapon):
         #weapon 為Weapon類的引用的形參
        if self.money >= weapon.price
            self.weapon = weapon  #組合 給人裝備了武器
            self.money -= weapon.price
            print(‘購買成功,您已經順利裝備了 %s‘ %weapon.name)
        else:
            print(‘余額不足,請充值‘)
      def  attack_with_weapon(self,dog):
            if ‘weapon‘ in self._dict_:
                 self.weapon.skill(dog)
            else:
                 print(‘請先裝備武器‘)
class Dog:
       def __init__(self,name,kind,hp,ad):
            self.name = name
            self.kind = kind
            self.hp = hp
            self.ad = ad
       def bit(self,p):
            p.hp -= self.ad
            print(‘%s咬了%s一口,%s掉了%s點血‘ % (self.name, p.name, p.name, self.ad))
class Weapon:
    def __init__(self,name,price,ad,level):
        self.name = name
        self.price = price
        self.level = level
        self.ad = ad * self.level

    def skill(self,dog):
        dog.hp -= self.ad
        print(‘%s受到了%s的傷害，%s掉了%s點血‘%(dog.name,self.name,dog.name,self.ad))

例2 ,通過對圓柱進行計算,實現類的組合

from math import pi

class In_circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi*self.r ** 2
    def perimeter(self):
        return pi*self.r * 2

class Ring:
    def __init__(self,big_r,small_r):
        self.big_r = In_circle(big_r) #一個類中以另外一個類的對象作為屬性
        self.small_r = In_circle(mall_r)#一個類中以另外一個類的對象作為屬性
def n_area(self): 
　　 return self.big_r.area - self.small_r.area 

def n_perimeter(self): 

　　 return self.big_r.perimeter + self.small_r.perimeter 

r2 = Ring(8,3) 
print(r2.n_area()) 
print(r2.n_perimeter())

Python 基礎第十六---十九天(面向對象初識)