标签：name 16 python self 魔法 对象 Human print def

内置成员
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’: ‘帅气的文广哥哥，长腿欧巴，颜值男神’}

标签：name,16,python,self,魔法,对象,Human,print,def
来源： https://blog.csdn.net/Gold_Master/article/details/95633204

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。