您现在的位置：程式師世界 >> 編程語言 > >> 更多編程語言 >> Python

Python——類和對象、魔術方法（day07）

編輯：Python

面向對象編程：oop [object oriented programming] 是一種python的編程思路
面向過程：就是我們一開始學習的，按照解決問題的步驟去寫代碼【根據業務邏輯去寫代碼】
在思考問題的時候, 首先分析'怎麼按照步驟去實現' 然後將問題解決拆解成若干個步驟，並將這些步驟對應成方法一步一步的最終完成功能
面向對象：關注的是設計思維【找洗車店給錢洗車】

出差--北京
小明-- 什麼時間 - -買什麼票【高鐵汽車飛機】---酒店---回程時間
親力親為的去做【面向過程】

面向過程不足：小明沒有更多的精力去考慮別的事情

boss--- 秘書【小明需要考慮的事情】----財務----目的：北京【面向對象】

boss有更多的精力去處理其他的時候，創造更多的價值

從計算機的角度來看：面向過程不適合做大項目

而面向對象合適做更大項目的設計

類和對象

類:類是具有一組相同或者相似特征【屬性】和行為【方法】的一系列[多個]對象組合

現實世界計算機世界
行為---------> 方法
特征---------->屬性

對象: 對象是實實在在的一個東西，類的實例化，具象化

類是對象的抽象化而對象是類的一個實例

實例方法：在類的內部，使用def 關鍵字來定義第一個參數默認是 self【名字標識可以是其他的名字，但是這個位置必須被占用】

實例方法是歸於類的實例所有

屬性：類屬性實例屬性
在類的內部定義的變量【類屬性】
在方法內部定義的【通過類似於self.變量名】變量，是實例屬性

一、面向對象

面向過程的關注點是：怎麼做

面向對象的關注點是：誰來做

二、類和對象

三、實例方法和屬性

self只是一個關鍵字，可以換成其他的，他必須作為第一個參數在類中存在，才是實例方法，實例方法歸實例所有，任何實例都可以調用，對象就是類的實例

# 定義類和對象
# 類結構 類名 屬性 方法
# class 類名:
# 屬性
# 方法
class Person:
'''
對應人的特征
'''
# name='小明' #類屬性
age=20 #類屬性
'''
對應人的行為 實例方法
'''
def __init__(self):
self.name='小明' #實例屬性
pass
def eat(parms):
print("大口的吃飯")
pass
def run(self): #實例方法
print('飛快的跑')
pass
pass
def printInfo():
'''
普通方法
:return:
'''
pass
# 創建一個對象【類的實例化】
# 規則格式 對象名=類名()
xm=Person()
xm.eat() #調用函數
xm.run()
print("{}的年齡是：{}".format(xm.name,xm.age))
# 創建另外一個實例對象
xw=Person()
xw.eat() #實例方法

四、init方法

類屬性方法不能修改值，實例屬性可以

__init__也叫初始化方法

# class Pepole:
# def __init__(self):
# '''
# 實例屬性的聲明
# '''
# self.name='小倩'
# self.sex='女生'
# self.age=20
# pass
# def eat(self):
# '''
# 吃的行為
# :return:
# '''
# print('喜歡吃榴蓮')
# pass
#
# xq=Pepole()
# xq.name='小倩' #添加實例屬性
# xq.sex='女生' #添加實例屬性
# xq.age=20 #添加實例屬性
# xq.eat()
# # print(xq.name,xq.sex,xq.age)
#
# xl=Pepole() #創建出來的
# xl.name='小倩' #添加實例屬性
# xl.sex='女生' #添加實例屬性
# xl.age=20 #添加實例屬性
#
# xm=Pepole() #在創建新對象的時候 是自動執行的
# print(xm.name) #直接輸出的是默認值
# xm.name='小明'
# print(xm.name)
# 如果有n個這個對象 被實例化 那麼就需要添加很多次這樣的屬性了 顯然是比較麻煩
# init傳遞參數 改進
class Pepole:
def __init__(self,name,sex,age):
'''
實例屬性的聲明
'''
self.name=name
self.sex=sex
self.age=age
pass
def eat(self,food):
'''
吃的行為
:return:
'''
print(self.name+'喜歡吃'+food)
pass
zp=Pepole('張鵬','男生',18)
print(zp.name,zp.age)
zp.eat('香蕉')
lh=Pepole('李輝','男生',28)
lh.eat('蘋果')
print(lh.name,lh.age)
xh=Pepole('小花','女生',20)
xh.eat('橘子')
print(xh.name,xh.age)
# 總結 __init__
# 1. python 自帶的內置函數 具有特殊的函數 使用雙下劃線 包起來的【魔術方法】
# 2. 是一個初始化的方法 用來定義實例屬性 和初始化數據的，在創建對象的時候自動調用 不用手動去調用
# 3. 利用傳參的機制可以讓我們定義功能更加強大並且方便的 類

五、self

六、魔法方法

（1）str方法

通常用來查看常用信息，沒有str時直接打印實例對象出現地址，有str時出現他的return

（2）new方法

new比init先執行，實例化類，創建的實例對象的返回值給init的第一個參數，不寫new會自動調用

class Person:
def __init__(self,pro,name,food):
'''
:param pro: 專業
:param name: 姓名
:param food: 食物
'''
self.pro=pro #實例屬性的定義
self.name=name
self.food=food
print('----init-----函數執行')
pass
'''
定義類
'''
def eat(self,name,food):
'''
實例方法
:return:
'''
# print('self=%s',id(self))
print('%s 喜歡吃 %s 修的專業是:%s'%(self.name,self.food,self.pro))
pass
def __str__(self):
'''
打印對象 自定義對象 是內容格式的
:return:
'''
return '%s 喜歡吃 %s 修的專業是:%s'%(self.name,self.food,self.pro)
pass
def __new__(cls, *args, **kwargs):
'''
創建對象實例的方法 每調用一次 就會生成一個新的對象 cls 就是class的縮寫
場景：可以控制創建對象的一些屬性限定 經常用來做單例模式的時候來使用
:param args:
:param kwargs:
'''
print('----new-----函數的執行')
return object.__new__(cls) #在這裡是真正創建對象實例的
pass
pass
# xw是一個新的實例化對象
xw=Person('心理學','小王','榴蓮')
# print('xw=%s',id(xw))
# xw.eat('小王','榴蓮')
print(xw) #直接輸出對象
# 小結 self特點
# self只有在類中定義 實例方法的時候才有意義,在調用時候不必傳入相應的參數 而是由解釋器 自動去指向
# self的名字是可以更改的 可以定義成其他的名字，只是約定俗成的定義成了 self
# self 指的是 類實例對象本身, 相當於java中 this
# __new__和__init___函數的區別
# __new__ 類的實例化方法 必須要返回該實例 否則對象就創建不成功
# __init___ 用來做數據屬性的初始化工作 也可以認為是實例的構造方法 接受類的實例 self 並對其進行構造
# __new__ 至少有一個參數是 cls 代表要實例化的類 ，此參數在實例化時由python解釋器自動提供
# __new__ 函數 執行要早於 __init___ 函數

七、雙人對決

# 決戰紫禁之巅有兩個人物，西門吹雪以及葉孤城
# 屬性：
# name 玩家的名字
# blood 玩家血量
#
# 方法：
# tong() 捅對方一刀,對方掉血10滴
# kanren() 砍對方一刀，對方掉血15滴
# chiyao() 吃一顆藥，補血10滴
# __str__ 打印玩家狀態。
#
# 第一步 需要先去定義一個類【角色類】
import time # 導入時間的包
import random
class Role:
def __init__(self,name,hp):
'''
構造初始化函數
:param name: 角色名
:param hp: 血量
'''
self.name = name
self.hp = hp
pass
def tongyidao(self,enemy):
'''
捅人
:param enemy:敵人
:return:
'''
# 敵人掉10血
enemy.hp -= 10
info = '[%s]捅了[%s]一刀' %(self.name,enemy.name)
print(info)
pass
def kanyidao(self,enemy):
'''
砍人
:param enemy:敵人
:return:
'''
# 敵人掉15血
enemy.hp -= 15
info = '[%s]砍了[%s]一刀' %(self.name, enemy.name)
print(info)
pass
def chiyao(self):
'''
吃藥
:return:
'''
self.hp += 10
info = '[%s]吃了一顆補血藥，增加了10滴血' %(self.name)
print(info)
pass
def __str__(self):
return '%s 還剩下 %s 的血量' %(self.name, self.hp)
# 第二步 創建2個：西門吹雪、葉孤城 實例化對象
xmcx = Role('西門吹雪', 100)
ygc = Role('葉孤城', 100)
def xmcx_zhandou(go):
"""
xmcx所有可能發生的狀況
:param go: 隨機戰斗的值
:return:
"""
if go == 1:
xmcx.tongyidao(ygc) # 西門吹雪捅了葉孤城一刀+
elif go == 2:
xmcx.kanyidao(ygc) # 西門吹雪看了葉孤城一刀
else:
xmcx.chiyao() # 西門吹雪吃藥
pass
def ygc_zhandou(go):
"""
ygc所有可能發生的狀況
:param go: 隨機戰斗的值
:return:
"""
if go == 1:
ygc.tongyidao(xmcx) # 葉孤城捅了西門吹雪一刀
elif go == 2:
ygc.kanyidao(xmcx) # 葉孤城看了西門吹雪一刀
else:
ygc.chiyao() # 葉孤城吃藥
pass
# for i in range(1,10):
# go = random.randint(1,4)
# print(go)
i = 1 # 回合數
while 1:
xmcx_go = random.randint(1,3) # xmcx隨機戰斗狀況
ygc_go = random.randint(1,3) # ygc隨機戰斗狀況
xianshou = random.randint(1,2) # 隨機先手
print('--------------------第 %d 回合----------------------' % i)
if xmcx.hp <= 0 or ygc.hp <= 0:
break
if xianshou == 1: # xmcx先手
xmcx_zhandou(xmcx_go)
ygc_zhandou(ygc_go)
else:
ygc_zhandou(ygc_go) # ygc先手
xmcx_zhandou(xmcx_go)
print(xmcx) # 打印對象狀態
print(ygc) # 打印對象狀態
time.sleep(2) # 延時1s
i += 1
pass
print('對戰結束')
if xmcx.hp <= 0:
print('[葉孤城]獲勝')
elif ygc.hp <= 0:
print('[西門吹雪]獲勝')
# while True:
# if xmcx.hp <= 0 or ygc.hp <= 0:
# break
# xmcx.tongyidao(ygc) # 西門吹雪捅了葉孤城一刀
# print(ygc) # 打印對象狀態
# print(xmcx)
# print('---------------------------------------------')
# ygc.tongyidao(xmcx)
# print(ygc) # 打印對象狀態
# print(xmcx)
# print('---------------------------------------------')
# xmcx.chiyao()
# print(ygc) # 打印對象狀態
# print(xmcx)
# print('---------------------------------------------')
# time.sleep(1) # 延時1s
# pass
#
# print('對戰結束')

八、作業

# 1、python中如何通過類創建對象，請用代碼舉例說明。
class Student:
def run(self):
print('學生每天進行2000米的跑步訓練')
pass
pass
xiaoli=Student() #創建一個對象
xiaoli.run()
# 2、如何在類中定義一個方法，請用代碼舉例說明。
# 參考上述demo
# 3、定義一個水果類，然後通過水果類，創建蘋果對象、橘子對象、西瓜對象並分別添加上顏色屬性
class SgClass:
def __init__(self,name,color):
'''
:param name:
:param color:
'''
self.color=color
self.name=name
pass
def __str__(self):
return '%s 的顏色是【%s】'%(self.name,self.color)
pass
pg=SgClass('蘋果','紅色')
pg.zj=10 #通過對象添加對象屬性
print(pg)
print('*'*40)
jz=SgClass('橘子','橙色')
print(jz)
print('*'*40)
xg=SgClass('西瓜','黑皮')
print(xg)
# 4、請編寫代碼，驗證self就是實例本身。
class Person:
def weight(self):
print('self=%s'%id(self))
pass
# liming=Person()
# liming.weight()
# print(id(liming))
# 5、定義一個Animal類
# (1)、使用__init__初始化方法為對象添加初始屬性。如顏色，名字，年齡。
# (2)、定義動物方法，如run，eat等方法。如調用eat方法時打印xx在吃東西就可以。
# (3)、定義一個__str__方法，輸出對象的所有屬性。
class Animal:
def __init__(self,color,name,age):
'''
:param color:
:param name:
:param age:
'''
self.color=color
self.name = name
self.age = age
pass
def eat(self):
print('%s 在吃東西'%self.name)
pass
def run(self):
print('%s 在飛快的跑' % self.name)
pass
def __str__(self):
return '%s 的顏色是:%s 今年 %d 歲了'%(self.name,self.color,self.age)
def __del__(self):
print('xhl')
pass
tigger=Animal('黃色','東北虎',4)
tigger.run()
tigger.eat()
print(tigger)
# del tigger
input('ddz')