一：面向對象的初識

一：面向對象

def Person(name,hp,ad,sex):         # 模子
    dic = {'name':name,'blood':hp,'attack':ad,'sex':sex}

    def fight(dog):             # 攻擊  屬於人
        dog['blood'] -= dic['attack']   # 狗掉血，就是人的攻擊力
        print('%s打了%s，%s掉了%s血' % (dic['name'], dog['name'], dog['name'], dic['attack']))
    
    dic['fight'] = fight
    return dic

def Dog(name,hp,ad,kind):
    dic = {'name': name, 'blood': hp, 'attack': ad, 'kind': kind}

    def bite(person):           # 咬 屬於狗
        person['blood'] -= dic['attack']
        print('%s咬了%s，%s掉了%s血' % (dic['name'], person['name'], person['name'], dic['attack']))

    dic['bite'] = bite
    return dic

# 互相打
ivan = Person(' ivan ',20,1,'不詳')
print(alex)
hei = Dog('小黑',3000,10,'哈士奇')
print(hei)

ivan ['fight'](hei)
hei['bite']( ivan)     狗咬人，def bite(person):不用傳dog，（不須要傳其它的）

經過兩個模子 捏出兩個具體的角色
抽象 ：只能知道有哪些屬性
具體 ：能夠描述他的屬性的值的

給兩個特定的屬於特定角色的方法 設置了他的使用範圍
讓其餘角色不能隨意調用屬於固定角色的方法

1 先思考這個程序中有幾個角色
2 而後描述這個角色 屬性和動做
3 把這個屬性和動做都裝到一個角色中
4 面向對象編程

二：面向對象語法

對象 ：具備具體的屬性值的實際存在的例子        實例
類 ：具備相同方法和屬性的一類事物

class Dog:
    變量 = 1000
    變量2 = 'abc'
    變量3 = [(1,2),(3,4)]

查看類當中的變量，方法一
print(Dog.__dict__['變量'])               # Dog.__dict__ 生成一個字典
print(Dog.__dict__['變量2'])
print(Dog.__dict__['變量3'])
查看方法二（經常使用）
print(Dog.變量)
print(Dog.變量2)
print(Dog.變量3)

每一隻狗都須要有本身的屬性
class Dog:          # 狗模子  -- 類
    a = 1000        # 靜態變量 這個類中的變量 是全部的對象共享的值
    def __init__(self,name,hp,ad,sex):   # init自動傳進去，自動把self return回來
        print('執行我啦')
        self.__dict__['name'] = name
        self.__dict__['blood'] = hp
        self.__dict__['ad'] = ad
        self.__dict__['sex'] = sex
        print(self.__dict__)    # 上面全部的都進入到了這個字典


ivan = Dog(' ivan ',20,10,'不詳')      # 具體的狗 對象 實例化的過程
ivan = Dog(' ivan ',20,10,'不詳')
print(ivan.__dict__['name'])
print(ivan.__dict__['blood'])

# 對象 也是實例
# 建立一個對象也是建立實例



# 狗對象都是一個內存空間（字典）
# self其實是由python的語法 開闢了一個屬於具體的對象的空間
# 執行init,向self這塊空間管理的字典中添加一些key value  ，self會自動的被返回


# 實例化的過程 ：
    1.開闢了一塊空間，創造了一個self變量來指向這塊空間
    2.調用init,自動傳self參數，其餘的參數都是按照順序傳進來的
    3.執行init
    4.將self自動返回給調用者


# ivan 就等於 self ，self返回的字典給Ivan，能夠直接使用ivan內部的字典屬性，直接加.就能夠

class Dog:
    def __init__(self,name,hp,ad,kind):      # 初始化方法
        self.name = name                    # 實例變量   對象屬性
        self.blood = hp
        self.ad = ad        # 左邊ad至關於鍵，右邊ad至關於值，使用時候是寫左邊的鍵
        self.type = kind

class Person:
    a = 1000                                # 靜態變量  用類名調用
    def __init__(self,name,hp,ad,sex):        # 初始化方法
        self.name = name                     # 實例變量   對象屬性
        self.blood = hp
        self.ad = ad
        self.sex = sex

    def fight(self,dog):                # 動態變量    類方法
        dog.blood -= self.ad            # 狗掉血，就是人的攻擊力
        print('%s攻擊了%s，%s掉了%s點血'%(self.name,dog.name,dog.name,self.ad))

ivan = Dog(' ivan ',20,10,'不詳')           # ivan 對象 實例
大亮 = Person('大亮',300,20,'male')         # 大亮 對象 實例
print( ivan.blood)
大亮.fight(ivan)                  # 至關於  Person.fight(大亮, ivan)
print(ivan.blood)



1.類名能夠調用全部定義在類中的名字
    變量  : a
    函數名  : def fight             (init初始化方法是自動調用)
        
2.對象名  
能夠調用全部定義在對象中的屬性
在init函數中 和 self相關的

# 調用函數的，且調用函數的時候，會把當前的對象當作第一個參數傳遞給self

三：清晰的面向對象例子

class Dog:
    def __init__(self,name,blood,ad,kind):
        self.name = name        # 向對象的內存空間中添加屬性
        self.hp = blood         # 能夠經過self在類的內部完成 
        self.ad = ad
        self.kind = kind

    def bite(self,person):
        person.hp -= self.ad
        print('%s攻擊了%s，%s掉了%s點血' % (self.name, person.name, person.name, self.ad))

class Person:
    def __init__(self,name,hp,ad,sex):
        self.name = name
        self.hp = hp
        self.ad = ad
        self.sex = sex

    def fight(self,dog):
        dog.hp -= self.ad
        print('%s攻擊了%s，%s掉了%s點血'%(self.name,dog.name,dog.name,self.ad))

        
hei = Dog('小黑',300,20,'哈士奇')
ivan = Person(' ivan ',20,1,'不詳')
ivan.fight(hei)
print(hei.hp)
hei.bite(ivan)
print(ivan.hp)

class Dog:
    def __init__(self,name,blood,ad,kind):
        self.name = name        # 向對象的內存空間中添加屬性
        self.hp = blood         # 能夠經過self在類的內部完成
        self.ad = ad
        self.kind = kind

hei = Dog('小黑',300,20,'哈士奇')
hua = Dog('小花',400,30,'薩摩耶')
print(hei.name)     # 小黑
print(hei.ad)       #  20
print(hei.kind)     # 哈士奇

hei.food = '單身狗糧'       # 也能夠經過對象名在類的外部完成修改
hei.hp = 305               # 也能夠在類的外部經過對象名來修改屬性的值

print(hei.__dict__)  # {'name': '小黑', 'hp': 305, 'ad': 20, 'kind': '哈士奇', 'food': '單身狗糧'}
print(hei.hp)        # 305
print(hei. __dict__[‘hp’])   # 305
del hei.hp                  # 刪除屬性
print(hei.__dict__) # {'name': '小黑', 'ad': 20, 'kind': '哈士奇', 'food': '單身狗糧'}

# self 就是 誰實例它，就是誰

# 圓形類
# 屬性 ：半徑
# 方法 ：計算周長(2pir) 計算面積(pir^2)

from math import pi
print(pi)

class Circle:
    def __init__(self,r):      
        self.r = r
    def area(self):
        return pi * self.r**2
    def perimeter(self):
        return 2*self.r*pi
    
c1 = Circle(5)
c2 = Circle(15)
print(c1.area())
print(c1.perimeter())
print(c2.area())
print(c2.perimeter())

一切皆對象 ，全部的變量都是對象，是什麼數據類型就是哪一個對象
list 類
[1,2,3] 對象

int 數據類型
a = 1

dict
{'k':'v'}

# 數據類型 也是類
# 對象 就是具體的數字

因此有的列表都可以使用列表的方法
因此有的數字都可以使用列表的方法

四：練習

# 長方形 Rectangle               # 正方形 Square       # 圓形 circular
# 平行四邊形 Parallelogram       # 三角形 Triangle
# 邊長 Side length               # 高 high

# 長方形
class Rectangle:
    def __init__(self,long,wide):
        self.long=long
        self.wide=wide
    def area(self):
         return self.long*self.wide
    def perimeter(self):
         return self.long*2+self.wide*2

r1=Rectangle(2,3)
print(r1.area())        # 6
print(r1.perimeter())   # 10

# 正方形
class Square:
    def __init__(self,long):
        self.long=long
    def area(self):
         return self.long*self.long
    def perimeter(self):
         return self.long*4

r1=Square(2)
print(r1.area()) # 4 
print(r1.perimeter()) #8


# 平行四邊形  底bottom  高high  斜邊 hypotenuse
# 周長＝2（底邊+斜邊）   # 面積＝底*高
class Parallelogram:
    def __init__(self,bottom,high,hypotenuse):
        self.bottom=bottom
        self.high=high
        self.hypotenuse=hypotenuse
    def area(self):
         return self.bottom*self.high
    def perimeter(self):
         return (self.bottom+self.hypotenuse)*2

r1=Parallelogram(2,3,4)
print(r1.area())  # 6 
print(r1.perimeter()) #12


# 三角形  底bottom     高high  斜邊 long
# 周長＝long *3        # 面積＝底*高/2
class Triangle:
    def __init__(self,bottom,high,long):
        self.bottom=bottom
        self.high=high
        self.long=long
    def area(self):
         return self.bottom*self.high/2
    def perimeter(self):
         return self.long*3

r1=Triangle(2,3,4)
print(r1.area())  # 3.0
print(r1.perimeter())  # 12

# 圓形
from math import pi
print(pi) # 3.141592653589793
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi * self.r**2
    def perimeter(self):
        return 2*self.r*pi

c1 = Circle(5)
c2 = Circle(15)

print(c1.area())        # 78.53981633974483
print(c1.perimeter())   # 31.41592653589793
print(c2.area())        # 706.8583470577034
print(c2.perimeter())   # 94.24777960769379

五：總結

幾十個函數
去查看和圓形相關的方法是須要必定時間找到對應方法的
無論求圓形周長仍是面積，都須要傳參數r
全部的函數都是求周長和麪積，致使給函數起名字的時候老是要帶着圖形

面向對象的優勢
規劃了代碼中的函數處理的是哪一類問題
解決了傳參數的問題
方便擴展
方便重用

類 ：有相同特徵的事物歸爲一類
對象、實例 ：類的具體化

實例化 ：經過類創造一個對象的過程
    對象 = 類名(參數，參數)
    1.開闢一塊內存空間，讓self指向它
    2.調用__init__方法,執行init
    3.把self返回給調用者

    
類當中有哪些成員：        靜態變量 ；動態變量，對象方法
對象能夠存哪些方法：      全部的對象屬性都在對象裏
類名能作什麼：           查看靜態變量；實例化對象
對象名能作什麼：         屬性的增刪改查；方法的調用

定義類
class 類名:
    靜態變量 = 1000
    def __init__(self,arg1,arg2):
        if arg1<=arg2:
            self.arg1 = arg1
            self.arg2 = arg2
        else:
            self.arg1 = arg2
            self.arg2 = arg1
    def 其餘方法(self):
        print('其餘方法每每是類名對應的對象所作的動做、行爲')
        print('每每還會用到self內部的一些變量')

對象1 = 類名(1,2)
對象2 = 類名(3,4)