day22 面向過程與面向對象的介紹 類的定義和使用 產生對象 類名稱空間與對象名稱空間以及屬性查找 綁定方法的特殊之處 一切皆對象 小練習 對象交互之人狗大戰 總結 今日做業

一、面向過程編程

核心過程二字，過程指的是解決問題的步驟，即先幹什麼，再幹什麼

基於該思想編寫程序就比如在設計一條流水線，是一種機械的思惟方式。

　　優勢:複雜的問題流程化，進而簡單化

　　缺點:擴展性差

二、面向對象

核心"對象"二字，對象指的是特徵與技能的結合體，基於該思想編寫程序

就比如在創造一個世界，你就是這個世界的上帝，是一種上帝式的思惟方式

　　優勢:可擴展性強

　　缺點:編程的複雜度高於面向過程

=================================================================

PS.面向對象僅僅是解決了可擴展性的問題,並無表明所有

 

一、類

對象是特徵與技能的結合體，那類就是一系列對象相同的特徵與技能的結合體

二、在現實生活中P:必定是先有對象，後來隨着人類文明的發展總結出的類，對象是具體存在的，而類只是一種抽象概念

三、在程序中，務必保證:先定義類，後調用類來產生對象

現實生活中的對象：
    對象1：
        特徵：
            school="Oldboy"
            name="馬冬梅"
            age=18
            sex="female"
        技能：
            學習
            選課

    對象2：
        特徵：
            school="Oldboy"
            name="甜蜜蜜"
            age=21
            sex="male"
        技能：
            學習
            選課

    對象3：
        特徵：
            school="Oldboy"
            name="原石開"
            age=22
            sex="male"
        技能：
            學習
            選課

現實生活中的老男孩學生類：
     相同的特徵
            school="Oldboy"
     相同的技能
            學習
            選課
'''
類名通常用駝峯體
#一、程序中的類
class OldboyStudent:
    # 用變量表示特徵
    school="Oldboy"

    #  用函數表示技能
    def learn(self):
        print('is learning...')

    def choose(self):
        print('choose course...')

    # print('======>')

注意：在定義類的階段會馬上執行類體內的代碼，而後將產生的名字存放於類名稱空間中
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__['school'])
print(OldboyStudent.__dict__['learn'])
OldboyStudent.__dict__['learn'](123)

print(OldboyStudent.school) # OldboyStudent.__dict__['school']
print(OldboyStudent.learn) # OldboyStudent.__dict__['learn']
OldboyStudent.learn('xxx')
OldboyStudent.learn('xxx')

OldboyStudent.country='China'   #新增屬性
OldboyStudent.school='偶的博愛' #改屬性

del OldboyStudent.country
print(OldboyStudent.__dict__)

二、調用類，產生程序中的對象

產生對象

類名稱空間與對象名稱空間以及屬性查找

# 一、程序中的類
class OldboyStudent:
    # 用變量表示特徵
    school = "Oldboy"

    # stu1, "馬冬梅", 18, 'female'
    def __init__(self, name, age, sex):  
        # self=stu1     name= "馬冬梅"   age=18     sex="female"
        # print('==========init run=============>')
        self.name = name  # stu1.name = "馬冬梅"
        self.age = age  # stu1.age = 18
        self.sex = sex  # stu1.sex = "female"

    #  用函數表示技能
    def learn(self):
        print('is learning...', self)

    def choose(self):
        print('choose course...')

在程序中：必須先定義類 - -----》調用類 - -----》對象

stu1=OldboyStudent()
stu1.NAME='馬冬梅'
stu1.AGE=18
stu1.SEX="female"

stu2=OldboyStudent()
stu2.NAME='甜蜜蜜'
stu2.AGE=21
stu2.SEX="male"

stu3=OldboyStudent()
stu3.NAME='原石開'
stu3.AGE=22
stu3.SEX="male"

print(stu1.NAME,stu1.school)
print(stu2.NAME,stu2.school)
print(stu3.NAME,stu3.school)
上述產生的三個對象都同樣了

調用類發生哪些事：
一、首先會產生一個空對象stu1
二、會自動觸發類內部的__init__函數
三、而後將空對象stu1連同調用類時括號內的參數組成（stu1,"馬冬梅",18,'female'）,
將這四個參數一塊兒傳給__init__函數

stu1=OldboyStudent("馬冬梅",18,'female')
#OldboyStudent.__init__(stu1,"馬冬梅",18,'female')
stu2=OldboyStudent("甜蜜蜜",21,'male')
#OldboyStudent.__init__(stu2,"甜蜜蜜",21,'male')
stu3=OldboyStudent("原石開",22,'male')

print(stu1.name,stu1.age,stu1.sex)
print(stu2.name,stu2.age,stu2.sex)
print(stu3.name,stu3.age,stu3.sex)

類名稱空間與對象名稱空間以及屬性查找

school = 'xxxxxxxxxxxxxxxxxxxxxxxxxx'

class OldboyStudent:
    school = 'oldboy'

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    # self=stu1
    def learn(self):
        print('%s is learning' % self.name)

    def choose(self, course):
        print('%s is choosing %s' % (self.name, course))


# 調用類---》產生類的對象，該對象也能夠稱爲類的一個實例，
# 調用類的過程也稱爲類的實例化
stu1 = OldboyStudent('李三胖', 18, 'male')
# OldboyStudent.__init__(stu1,'李三胖',18,'male')

# OldboyStudent.country='CHINA'
# print(OldboyStudent.country)

# print(OldboyStudent.__dict__)
# print(stu1.__dict__)
# print(stu1.__dict__['name'])
# print(stu1.name)
# print(stu1.school)
# print(school)

stu2 = OldboyStudent('王大炮', 28, 'male')
# print(stu2.__dict__)

# 類內部定義的變量是給全部對象共享，全部對象指向的都是同一個內存地址
# print(id(stu1.school))
# print(id(stu2.school))
# print(id(OldboyStudent.school))

綁定方法的特殊之處

類內部定義的函數，類可使用，但類來用的時候就是一個普通函數，
普通函數有幾個參就傳幾個參數
print(OldboyStudent.learn)
OldboyStudent.learn(123)

類內部定義的函數，實際上是給對象使用的，並且是綁定給對象用，
綁定給不一樣的對象就是不一樣的綁定方法
print(stu1.learn)
print(stu2.learn)
綁定方法的特殊之處在於，誰來調用，就會將誰看成第一個參數自動傳入
stu1.learn()  # OldboyStudent.learn(stu1)
stu2.learn()  # OldboyStudent.learn(stu2)

stu1.choose('python')
stu2.choose('linux')

一切皆對象

class OldboyStudent:
    school='oldboy'

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    #self=stu1
    def learn(self):
        print('%s is learning' %self.name)

    def choose(self,course):
        print('%s is choosing %s' %(self.name,course))

stu2=OldboyStudent('王大炮',28,'male')

# print(id(stu2))
# print(type(stu2)) # 類與類型是一個概念
# print(stu2)

l1=[1,2,3] #l1=list([1,2,3])
# print(type(l1))
# l1.append(4)
list.append(l1,4)
print(l1)

l2=['a','b','c']
l2.append('d')
# list.append('d')
print(l2)

print(int)
print(str)
print(dict)
print(tuple)
print(set)
print(OldboyStudent)

 小練習 (實例化三次)

# class Foo:
#     n=0
#     def __init__(self):
#         Foo.n+=1 # Foo.n=3
#
# obj1=Foo()
# obj2=Foo()
# obj3=Foo()
# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
#
# print(obj1.n)
# print(obj2.n)
# print(obj3.n)

對象交互之人狗大戰

#對對象屬性的增刪改查
# class Bar:
#     n=1111111111
#     def __init__(self,x):
#         self.x=x
#
# obj=Bar(111)
#
# # print(obj.__dict__)
# # print(obj.n)
# obj.y=2
# obj.n=3
# print(obj.__dict__)
# print(obj.n)
#
# obj.x=123
# del obj.x
# print(obj.x)
'''
現實中的對象：
    人1
        特徵：
            名字='劉晴政'
            攻擊力=60
            生命值=100
        技能：
            咬

    人2
        特徵：
            名字='王苗璐'
            攻擊力=50
            生命值=100
        技能：
            咬

現實中的人類
    相同的特徵
    相同的技能
        咬
'''

'''
現實中的對象：
    狗1
        特徵：
            名字='武培其'
            品種="京巴"
            攻擊力=80
            生命值=50
        技能：
            咬

    人2
        特徵：
            名字='李傑'
            品種="藏獒"
            攻擊力=200
            生命值=200
        技能：
            咬

現實中的狗類
    相同的特徵
    相同的技能
        咬
'''
class People:
    def __init__(self, name, aggresivity, life_value=100):
        self.name = name
        self.aggresivity = aggresivity
        self.life_value = life_value

    def bite(self, enemy): #self=p1   enemy=d1
        enemy.life_value-=self.aggresivity
        print("""
        人[%s] 咬了一口狗 [%s]
        狗掉血[%s]
        狗還剩血量[%s]
        """ %(self.name,enemy.name,self.aggresivity,enemy.life_value)
        )

class Dog:
    def __init__(self, name, dog_type, aggresivity, life_value):
        self.name = name
        self.dog_type = dog_type
        self.aggresivity = aggresivity
        self.life_value = life_value

    def bite(self, enemy): #self = d1    enemy= p1
        enemy.life_value-=self.aggresivity
        print("""
        狗[%s] 咬了一口人 [%s]
        人掉血[%s]
        人還剩血量[%s]
        """ %(self.name,enemy.name,self.aggresivity,enemy.life_value)
        )
p1 = People('劉清政', 60)
d1=Dog('李傑',"藏獒",200,200)

p1.bite(d1)
d1.bite(p1)

綁定:誰調用他就表明誰

相關補充

在python3中定義類的時候默認定義繼承object的類，方便python2識別
class OldboyPeople(object):

#python爲類內置的特殊屬性
類名.__name__# 類的名字(字符串)
類名.__doc__# 類的文檔字符串
類名.__base__# 類的第一個父類(在講繼承時會講)
類名.__bases__# 類全部父類構成的元組(在講繼承時會講)
類名.__dict__# 類的字典屬性
類名.__module__# 類定義所在的模塊
類名.__class__# 實例對應的類(僅新式類中)

類的特殊屬性(瞭解便可)

今日做業

面向對象做業
1.默寫:面向對象與面向過程的優缺點對比,及使用場景
2.初始化函數的做用是什麼,有什麼特色

做用:
init 函數用於初始化對象,它會在建立對象時,自動執行,
並傳入調用類時傳遞的參數,第一個參數表示要初始化的對象自己,

特色:
self(第一個)參數不須要手動傳遞
self表示對象本身 是一個形式參數,名字能夠隨便取,可是不建議修改

3.什麼是綁定方法,有什麼特色

綁定方法:把對象與函數進行綁定
特色:誰來調用，就會將誰看成第一個參數自動傳入

4.對象與類的屬性查找順序什麼怎麼樣的

當對象中不存在是會到類裏面查找，若是對象中存在這個屬性，優先訪問對象中的屬性
# 查找順序爲 對象 ->  類

5.什麼是類?  什麼是對象?

對象是特徵與技能的結合體
類是一系列特徵與技能的結合體

6.擴展題
設計王者榮耀中的英雄類,每一個英雄對象能夠對其餘英雄對象使用技能
具有如下屬性
英雄名稱,等級,血量
和Q_hurt,W_hurt,E_hurt 三個屬性,表示各技能的傷害量
具有如下技能
Q W E
三個技能都須要一個敵方英雄做爲參數,當敵方血量小於等於0時輸出角色死亡

class Hero:

    def __init__(self,name,level,hp,Q_hurt,W_hurt,E_hurt):
        self.name = name
        self.level = level
        self.hp = hp
        self.Q_hurt = Q_hurt
        self.W_hurt = W_hurt
        self.E_hurt = E_hurt

    def Q(self,enemy):

        enemy.hp -= self.Q_hurt
        print("%s 對%s 釋放了 %s 技能" % (self.name,enemy.name,"Q"))
        print("形成了%s點傷害,剩餘血量%s" % (self.Q_hurt, enemy.hp))
        if enemy.hp <= 0:
            print("%s被%s弄死了" % (enemy.name,self.name))

    def W(self,enemy):
        enemy.hp -= self.W_hurt
        print("%s 對%s 釋放了 %s 技能" % (self.name, enemy.name, "W"))
        print("形成了%s點傷害,剩餘血量%s" % (self.W_hurt,enemy.hp))
        if enemy.hp <= 0:
            print("%s被%s弄死了" % (enemy.name, self.name))

    def E(self,enemy):
        enemy.hp -= self.E_hurt
        print("%s 對%s 釋放了 %s 技能" % (self.name, enemy.name, "E"))
        print("形成了%s點傷害,剩餘血量%s" % (self.E_hurt, enemy.hp))
        if enemy.hp <= 0:
            print("%s被%s弄死了" % (enemy.name, self.name))

# 建立兩個英雄
hero1 = Hero("小妲己",15,2000,50,500,600)

hero2 = Hero("小魯班",15,1500,50,500,600)

hero1.Q(hero2)
hero1.W(hero2)
hero1.E(hero2)
hero1.E(hero2)