内置成员
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)
#结果为(<class ‘main.Man’>, <class ‘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’: <bound method Name.run of <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)))
#结果为
今天是个好
日子 <class ‘str’>
‘今天是个好\n日子’ <class ‘str’>
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’: ‘帅气的文广哥哥，长腿欧巴，颜值男神’}