內置成員
dict :獲取類/對象的所屬成員組成的集合 *

自己編寫類文檔

doc :獲取類的文檔信息 *

class Human():
‘’’
這是一個人類的類
他有著。。的方法
可以制造出什么樣的對象
‘’’
name = “人類”
print(Human. doc )

name :獲取類名稱的字符串

str1 = tuple. name
print(str1,type(str1))

module :獲取當前類所在的文件的名稱，如果是當前文件，顯示為main(后面會講其他的)

print(list. module )
結果為builtins

bases :獲取當前類的父類列表

class Human():
pass
class Man(Human):
pass
class Woman(Human):
pass
class Child(Man,Woman):
pass
print(Child. bases )
#結果為( main.Man’>, main.Woman’>)
方法的分類
1.對象方法：該方法中會直接傳入當前對象
調用方式：對象.成員方法() #類.成員方法(self)也可以
特征：會將當前對象傳入方法中

2.類方法:在方法中會直接傳入當前類
@classmethod: 不需要實例化，直接類名.方法名()來調用。
調用方式：類.成員方法() #對象.成員方法()也可以
特征：會將當前類傳入方法中

3.綁定類的方法:在方法中不會傳入類或者對象的方法
調用方式：類.成員方法()
特征：不會傳入類或者對象,只能通過類來調用

4.靜態方法：與類和對象無關，但是存在于類結構中的方法
@staticmethod: 返回函數的靜態方法。
調用方式：類.成員方法（） 或者對象.成員方法（）
特征：類或者對象都可以調用

class Human():
# 對象方法
def say(self):
print(self)
print(“人類叫起來很動聽”)
# 類方法 在方法中會直接傳入當前類
@classmethod
def run(cls):
print(cls)
print(“人類跑起來piapia的”)
# 靜態方法：與類和對象無關，但是存在于類結構中的方法
@staticmethod
def move(name,sex,age):
print(“人類之間的遷徙活動是生存本能”)
# 綁定類方法
def eat():
print(“人類能吃的全吃了，不能吃的正在變得能吃”)
wenguang = Human()
wenguang.say()
wenguang.run()
Human.run()

使用對象調用靜態方法

wenguang.move(1,2,3)

使用類調用靜態方法

Human.move(“人類”,“女”,16)
print(Human. dict )
print(dir(wenguang))
Human.eat()
魔術方法（魔法函數）：一種特殊的方法。
特點：不需要人工調用，在特定的時刻自動執行。

1. init 初始化魔術方法 *****
1.觸發時機：實例化對象之后觸發
2.作用:為實例化的對象添加對象的所屬成員。
3.參數：一個self 接受當前對象 其他的參數根據實例化的傳參決定
4.返回值：無
5.注意事項：無
例：
class Name():
age = 18
def init (self,head):
self.sex = “男”
self.color = “black”
self.runs = self.run
print(head)
def run(self):
print(“黑人跑的快”)
name = Name(“hair”) #制作一個對象，對象初始化
print(name. dict )
name.runs()

#結果為
hair
{‘sex’: ‘男’, ‘color’: ‘black’, ‘runs’: < main .Name object at 0x00797150>>}
黑人跑的快
2. new 構造方法 *****
1.觸發時機：實例化對象的時候觸發（在__init__之前）！
2.作用:管理控制對象的生成過程。
3.參數:一個cls接受當前類，其他的參數根據實例化的參數決定
4.返回值：可有可無 沒有返回值，實例化結果為None
5.注意事項：new魔術方法跟init的魔術方法的參數一致（除了第一個）
生成對象用return object. new (cls)
例：
class YmPo(object):
def new (cls,name):
if name == “我”:
return object. new (cls)
else:
pass
hanguo = YmPo(“你”) #先 生成對象，再初始化對象
print(hanguo)

結果為none

單例設計模式：一個類無論實例化多少次，有且只有一個對象（使用__new__模式方法）
單例模式形成后，成員屬性不變，成員屬性的值改變
例：

class Human():
name = “文廣” # 屬性值為文廣
def new (cls):
if cls.name == “文廣”: # 判斷屬性值是否為文廣
cls.name = object. new (cls) # 對屬性值重新賦值
return cls.name # 把重新賦值后的屬性return出來
wenguang = Human()
print(wenguang)
guangwen = Human()
print(guangwen)
guangwen.sex = “男”
print(wenguang. dict )
print(guangwen. dict )

結果為
< main .Human object at 0x00766310>
< main .Human object at 0x00766310>
{‘sex’: ‘男’}
{‘sex’: ‘男’}
3. del 析構方法 ****

1.觸發時機：對象被系統回收的時候自動觸發[1.頁面執行完畢回收所有變量 2.所有對象(引用)被del的時候]
2.作用:回收程序使用過程的信息和變量等
3.參數:一個self接收當前對象
4.返回值：無
5.注意事項：無
例：
class Durk():
def del (self):
print(“del被觸發了”)
yazi = Durk()
name = yazi
print("======================")
del yazi
print("***********************")
del name
print("------------------------")
4. call
1.觸發時機：將對象當作函數調用的時候自動觸發
2.作用:常用于歸結類/對象的操作步驟，方便后期調用
3.參數:一個self接受當前對象，其余的參數根據需求添加
4.返回值：可以有，可以沒有
5.注意事項：無
class Computer():
name = “電腦”
def end(self):
print(“工作結束了”)
def call (self,sex):
print(sex)
self.run()
self.end()
return “打完收工”
def run(self):
print(“開始工作啦”)
#實例化
huipu = Computer()
res = huipu(“此電腦年齡為2年”) #將對象當做函數調用
print(res) #輸出返回值

把類作為裝飾器（本質上依然是個函數）

class Human():
def call (self,xiaoshou):
def inner():
print(“生產做出來了娃娃”)
xiaoshou()
print(“拿到錢之后再給生產生產娃娃”)
return inner

基本函數

@Human() # sell = Human()(sell)
def sell():
print(“銷售開始賣起了娃娃”)
sell()
#結果為
生產做出來了娃娃
銷售開始賣起了娃娃
拿到錢之后再給生產生產娃娃

裝飾一個類(其實是裝飾對象)

def decor(cls):
def inner():
cls.name = “文廣”
cls.age = 18
cls.face = “帥氣的一張臉”
cls.move = lambda :print(“文廣哥哥每天都在堅持跑步”)
return cls
return inner

基本類

@decor
class Human():
pass
wenguang = Human()
print(wenguang.name)
wenguang.move()

#結果為
文廣
文廣哥哥每天都在堅持跑步
5. len
1.觸發時機：使用len函數檢測對象的時候自動觸發
2.作用:使得len可以檢測對象中某個數據的信息
3.參數:一個self接受當前對象
4.返回值：必須有,必須是整型（返回值就是檢測的值）
5.注意事項：len檢測什么由程序員自己決定
例：
class Mother():
name = “賈斯丁-比伯”
def len (self):
return len(self.name)

實例化

china = Mother()
print(len(china))
6. str
1.觸發時機：使用print打印對象的時候自動觸發,使用str()轉換對象的時候也會觸發
2.作用:可以定義打印對象顯示的信息內容
3.參數:一個self接受當前對象
4.返回值：必須有，且必須是字符串類型（即顯示的對象內容）
5.注意事項：無
例：
class Bather():
def str (self):
print("__str__被觸發")
return “對象”

實例化

changjiang = Bather()
print(changjiang)
changjiang.long = “180KM”
print(changjiang. dict )
str(changjiang)
7. repr
1.觸發時機：在使用repr轉換對象的時候自動觸發
2.作用:可以設置repr函數操作對象的結果
3.參數:一個self接受有當前對象本身
4.返回值：有必須是字符串
5.注意事項：正常情況下，類中的__str__和__repr__魔術方法是完全一樣的（字符串中的str和repr魔術方法就不一樣。）
repr():將對象轉化為供解釋器讀取的形式。
repr函數和str函數除了對字符串的處理,其他的是一致的.在類中定義魔術方法的時候想使用repr方法就得定義str魔術方法
例：
#repr() 把對象轉換成供解釋器讀取的形態
#str() 除了字符串之外，其他的對象轉化的效果是一樣的

list1 = [1,2,3,4,5]
print(str(list1),type(str(list1)))
print(repr(list1),type(repr(list1)))

str1 = “今天是個好\n日子”
print(str(str1),type(str(str1)))
print(repr(str1),type(repr(str1)))
#結果為
今天是個好
日子
‘今天是個好\n日子’
8. bool
1.觸發時機：使用bool() 轉換對象的時候自動觸發（一般情況下，對象轉換的結果默認就是True）
2.作用: 用于控制檢測對象成員的信息
3.參數:一個self接受當前對象
4.返回值：必須有且必須是布爾值
5.注意事項：無

class Yether():
def init (self,sex):
self.sex = sex
def bool (self):
if self.sex == “男”:
return False
else:
return True

實例化

zhangbairen = Yether(“女”)
print(bool(zhangbairen))
屬性相關的魔術方法：
就是獲取成員，刪除成員，修改成員相關聯的魔術方法
4個與屬性相關的常用魔術方法
1. getattr
2. setattr
3. delattr
4. getattribute
屬性訪問的順序！
1.調用__getattribute__
2.【調用數據描述符】
3.調用當前對象的所屬成員
4.調用類的所屬成員
5.【調用非數據描述符】
6.調用父類的所屬成員
7.調用__getattr__
注意：以上步驟是調用某個成員的訪問順序及優先級。前面的能獲取成員，就不會向后查找

1. getattribute
觸發時機：訪問對象成員的時候就會觸發，無論成員是否存在
作用：可以在用戶獲取數據的時候進行數據處理等操作
參數：一個self接受當前對象，另外一個參數接受訪問對象成員名稱的字符串
返回值：有 不設定返回None，return的值即是處理后的對象成員值
注意事項:在當前魔術方法中禁止使用 當前對象.成員 的方式訪問成員，會觸發遞歸操作，必須借助object的__getattribute__來獲取當前對象的成員
例:

class Naither():
def init (self):
self.name = “老干媽”
self.age = 60
def getattribute (self, item):
if item == “name”:
res = super(). getattribute (item)#若用self.item 就會觸發遞歸
return res[0]+"*"+res[-1]
else:
return super(). getattribute (item)

實例化

laoganma = Naither()
print(laoganma.name)
print(laoganma.age)

結果
老*媽
60
2. getattr *****
觸發時機：訪問不存在的對象成員的時候自動觸發
作用：防止訪問不存在成員的時候報錯，為不存在的成員定義值(return的值)
參數：一個self接受當前對象，第二個參數接受訪問成員的名稱字符串
返回值：可有可無
注意事項:無
例:
class Human:
def init (self):
self.name = ‘東方不敗’
def getattr (self,val):
#檢測用于訪問與name相關的信息都返回名稱 (name)
if ‘name’ in val:
return self.name
#實例化對象
df = Human()
print(df. dict )
#訪問對象成員
print(df.name2)
3. setattr *****
觸發時機：添加對象成員或者修改對象成員的時候自動觸發！
作用：可以限制或者管理對象成員的添加與修改操作
參數：一個self接受當前對象 第二個接受設置的成員名稱字符串 第三個設置的值
返回值：無
注意事項:在當前魔術方法中禁止使用當前對象.成員名 = 值的方式，會觸發遞歸操作!,必須借助須借助object的__setattr__
例如:

class S_Nvther():
def setattr (self, key, value):
if key == “name”:
pass
else:
super(). setattr (key, value)

實例化

luoli = S_Nvther()
luoli.sex = “孫女乖乖”

luoli.name = “小兔紙”

print(luoli.sex)
print(luoli. dict )

#結果為
孫女乖乖
{‘sex’: ‘孫女乖乖’}
4. delattr
觸發時機：刪除對象成員的時候自動觸發
作用：1.可以限制對象成員的刪除 2.刪除不存在的屬性時防止報錯
參數：一個self接受當前對象，另外一個接受刪除的成員屬性名稱的字符串
返回值：無
注意事項:如果要刪除對象成員，要借助object中的__delattr__來操作。
例:

class MySelf():
def init (self):
self.name = “帥氣的文廣哥哥，長腿歐巴，顏值男神”
self.girlfriend = “劉亦菲”
def delattr (self, item):
if item == “name”:
pass
else:
object. delattr (self, item)

實例化

wenguang = MySelf()
print(wenguang. dict )
del wenguang.girlfriend
print(wenguang. dict )

#結果為
{‘name’: ‘帥氣的文廣哥哥，長腿歐巴，顏值男神’, ‘girlfriend’: ‘劉亦菲’}
{‘name’: ‘帥氣的文廣哥哥，長腿歐巴，顏值男神’}