python_面向對象基礎

1、經常使用術語

一、抽象

二、封裝/接口

三、合成

四、派生/繼承/繼承結構

五、泛化/特化

六、多態

七、自省/反射

2、引言

一、假設你如今是一家遊戲公司的開發人員，如今須要你開發一款叫作<人狗大戰>的遊戲，你就思考呀，人狗做戰，那至少須要2個角色，一個是人， 一個是狗，且人和狗都有不一樣的技能，好比人拿棍打狗， 狗能夠咬人，怎麼描述這種不一樣的角色和他們的功能呢？

def person(name,age,sex,job):

    data = {

        'name':name,

        'age':age,

        'sex':sex,

        'job':job

    }

 

    return data

 

def dog(name,dog_type):

    data = {

        'name':name,

        'type':dog_type

    }

    return data

 

 

 

上面的兩個方法至關於創造了兩個模子，遊戲裏的每一個人和狗都擁有相同的屬性，遊戲開始，你根據一我的或一隻狗傳入的具體信息來塑造一我的或一條狗
傳入具體信息來塑造一個具體的人或狗
生成：

d1 = dog("李磊","京巴")

p1 = person("嚴帥",36,"F","運維")

p2 = person("egon",27,"F","Teacher"）

兩個角色對象生成了，狗和人還有不一樣的功能呀，狗會咬人，人會打狗，對不對? 怎麼實現呢，。。想到了， 能夠每一個功能再寫一個函數，想執行哪一個功能，直接 調用 就能夠了，

d1 = dog("李磊","京巴")

p1 = person("嚴帥",36,"F","運維")

p2 = person("egon",27,"F","Teacher"）

#調用方法

walk(p1)

bark(d1)

#但由於操做失誤

p1 = person("嚴帥",36,"F","運維")

bark(p1) #把人的對象傳給了狗的方法

 

 

從代碼上來看，這並沒出錯。但很顯然，人是不能調用狗的功能的，但在你的程序例沒有作限制
修改後的代碼：

def person(name, age, sex, job):

    def walk(p):

        print("person %s is walking..." % p['name'])

    data = {

        'name': name,

        'age': age,

        'sex': sex,

        'job': job,

        'walk': walk

    }

    return data

def dog(name, dog_type):

    def bark(d):

        print("dog %s:wang.wang..wang..." % d['name'])

    data = {

        'name': name,

        'type': dog_type,

        'bark': bark

    }

    return data

d1 = dog("李磊", "京巴")

p1 = person("嚴帥", 36, "F", "運維")

p2 = person("egon", 27, "F", "Teacher")

 

 

這種編程思想其實就是簡單的面向對象編程，咱們創造了兩個模子表示遊戲裏全部的人和狗以後，剩下的狗叫或者人走對於這兩個模子來講就不重要了。具體人和狗之間的交互就等着你去使用了。假如你和狗打起來了，這時候你是走路仍是拿棍子打狗就由你本身決定了。

3、 面向對象vs面向過程

面向過程:

優勢是：極大的下降了寫程序的複雜度，只須要順着要執行的步驟，堆疊代碼便可。

缺點是：一套流水線或者流程就是用來解決一個問題，代碼牽一髮而動全身。
面向對象：

優勢：解決了程序的擴展性。對某一個對象單獨修改，會馬上反映到整個體系中，如對遊戲中一我的物參數的特徵和技能修改都很容易。
缺點：可控性差，沒法向面向過程的程序設計流水線式的能夠很精準的預測問題的處理流程與結果，面向對象的程序一旦開始就由對象之間的交互解決問題，即使是上帝也沒法預測最終結果。因而咱們常常看到一個遊戲人某一參數的修改極有可能致使陰霸的技能出現，一刀砍死3我的，這個遊戲就失去平衡。
4、初識類和對象
python中一切皆爲對象，類型的本質就是類

　　dict #類型dict就是類dict

　　<class 'dict'>

　　>>> d=dict(name='eva') #實例化

　　>>> d.pop('name') #向d發一條消息，執行d的方法pop

　　'eva'
5、類的相關知識
一、初始類
   1）聲明函數：

def functionName(args):

     '函數文檔字符串'

      函數體
   2）聲明類

 '''
class 類名:
     '類的文檔字符串'
      類體
'''
#咱們建立一個類
class Data: pass

class Person:   #定義一我的類
    role = 'person'  #人的角色屬性都是人
    def walk(self):  #人均可以走路，也就是有一個走路方法，也叫動態屬性
        print("person is walking...")

 二、類的兩種做用：屬性引用和實例化

   1）屬性引用（類名.屬性）

class Person:   #定義一我的類

    role = 'person'  #人的角色屬性都是人

    def walk(self):  #人均可以走路，也就是有一個走路方法

        print("person is walking...")

print(Person.role)  #查看人的role屬性

print(Person.walk)  #引用人的走路方法，注意，這裏不是在調用

2）實例化：類名加括號就是實例化，會自動觸發__init__函數的運行，能夠用來爲每一個實例定製本身的特性

class Person:   #定義一我的類

    role = 'person'  #人的角色屬性都是人

    def __init__(self,name):

        self.name = name  # 每個角色都有本身的暱稱;

        

    def walk(self):  #人均可以走路，也就是有一個走路方法

        print("person is walking...")

print(Person.role)  #查看人的role屬性

print(Person.walk)  #引用人的走路方法，注意，這裏不是在調用

實例化的過程就是類 —- > 對象的過程

egg = Person(‘egon’)

 

 

   3）查看屬性&調用方法

        Print(egg.name）

        Print(egg.walk())

   4）關於self

      在實例化是自動將對象/實例自己傳給__init__的第一個參數，

   5）類屬性補充

      （1）定義的類的屬性到底存到了哪裏？

           dir（類名）：查出的是一個字典，key爲屬性名，value爲屬性值

      （2）特殊的類屬性

類名.__name__# 類的名字(字符串)

類名.__doc__# 類的文檔字符串

類名.__base__# 類的第一個父類(在講繼承時會講)

類名.__bases__# 類全部父類構成的元組(在講繼承時會講)

類名.__dict__# 類的字典屬性

類名.__module__# 類定義所在的模塊

類名.__class__# 實例對應的類(僅新式類中)

6、對象的相關知識

一、對象是關於類而實際存在的一個例子，即實例

二、對象/實例只有一種做用：屬性引用

class Person:  # 定義一我的類
    role = 'person'  # 人的角色屬性都是人

    def __init__(self, name, aggressivity, life_value):

        self.name = name 

# 每個角色都有本身的暱稱;
        self.aggressivity=aggressivity

# 每個角色都有本身的攻擊力;
        self.life_value = life_value # 每個角色都有本身的生命值;
    def attack(self,dog):
        # 人能夠攻擊狗，這裏的狗也是一個對象。
        # 人攻擊狗，那麼狗的生命值就會根據人的攻擊力而降低
        dog.life_value -= self.aggressivity
egg = Person('egon',10,1000)

print(egg.name)

print(egg.aggressivity)

print(egg.life_value)

 

 

7、對象之間的交互

一、人狗大戰完整代碼：

class Dog:  # 定義一個狗類
    role = 'dog'  # 狗的角色屬性都是狗
    def __init__(self, name, breed, aggressivity, life_value):
        self.name = name  # 每一隻狗都有本身的暱稱;
        self.breed = breed  # 每一隻狗都有本身的品種;
        self.aggressivity = aggressivity  # 每一隻狗都有本身的攻擊力;
        self.life_value = life_value  # 每一隻狗都有本身的生命值;
    def bite(self,people):
        # 狗能夠咬人，這裏的狗也是一個對象。
        # 狗咬人，那麼人的生命值就會根據狗的攻擊力而降低
        people.life_value -= self.aggressivity
egg = Person('egon',10,1000)  #創造了一個實實在在的人egg
ha2 = Dog('二愣子','哈士奇',10,1000)  #創造了一隻實實在在的狗ha2
print(ha2.life_value)         #看看ha2的生命值
egg.attack(ha2)               #egg打了ha2一下
print(ha2.life_value)         #ha2掉了10點血

 

 

 

 

二、圓的類：

from math import pi
class Circle:
    '''
    定義了一個圓形類；
    提供計算面積(area)和周長(perimeter)的方法
    '''
    def __init__(self,radius):
        self.radius = radius
    def area(self):
         return pi * self.radius * self.radius
    def perimeter(self):
        return 2 * pi *self.radius
circle =  Circle(10) #實例化一個圓
area1 = circle.area() #計算圓面積
per1 = circle.perimeter() #計算圓周長
print(area1,per1) #打印圓面積和周長

 

8、面對對象的組合用法

一、組合指的是，在一個類中以另一個類的對象做爲數據屬性，稱爲類的組合

class Weapon:

    def prick(self, obj):  # 這是該裝備的主動技能,扎死對方

        obj.life_value -= 500  # 假設攻擊力是500

 

class Person:  # 定義一我的類

    role = 'person'  # 人的角色屬性都是人

 

    def __init__(self, name):

        self.name = name  # 每個角色都有本身的暱稱;

        self.weapon = Weapon()  # 給角色綁定一個武器;

        

egg = Person('egon')

egg.weapon.prick() 

#egg組合了一個武器的對象，能夠直接egg.weapon來使用組合類中的全部方法

 

 

9、小結

class Animal:
     def __init__(self,name,aggr,hp):
         self.name = name
         self.aggr = aggr
         self.hp = hp
     def eat(self):
        print('回血')
        self.hp += 100


class Person(Animal):
    def __init__(self,name,aggr,hp,sex):
        Animal.__init__(self,name,aggr,hp)
        self.sex = sex
        self.money = 0
    def attack(self,dog):
        dog.hp -= self.aggr
        print(dog.hp)
    def get_weapon(self,weapon):
        if self.money >= weapon.price:
            self.money -=weapon.price
            self.weapon = weapon
            self.aggr += weapon.aggr
        else:
            print('餘額不足')
class Dog(Animal):
    def __init__(self,name,aggr,hp,kind):
        Animal.__init__(self,name,aggr,hp)
        self.kind = kind   #派生屬性
    def attack(self,person):
        person.hp -= self.aggr
        print(person.hp)
    def eat(self):
        Animal.eat(self)
        self.aggr += 2


class Weapon:
    def __init__(self,name,aggr,njd,price):
        self.name = name
        self.aggr = aggr
        self.njd = njd
        self.price = price

    def hand18(self,person):
        if self.njd > 0:
           person.hp -= self.aggr*2
           self.njd -= 1

alex = Person('jin',10,500,'nan')
dog = Dog('jin',10,500,'gong')
print(dog.name)
print(dog.hp)
print(dog.aggr)
dog.eat()
print(dog.hp)
print(dog.aggr)