标签：示例 mode 影响 显示 之间 就是 write 封装 一个
1.初始化方法 "_init_"
#用于给对象中赋值，初始化方法
‘‘‘
顶头是py文件的注释
‘‘‘
class Foo:
‘‘‘
类的注释
‘‘‘
def __init__(self,a1):
‘‘‘
方法的注释
初始化方法
:param a1:
‘‘‘
self.a1 = a1
#1.创建一个空白对象，obj
#2.执行__init__，给对象中进行赋值（初始化）
obj = Foo("yang")
2.__new__方法(构造方法)
#new方法（构造方法）是用来帮助创建空对象的
class Foo(object):
def __init__(self):
print("给对象进行赋值")
self.x = 123
def __new__(cls,*args,**kwargs):
print("创建对象")
return object.__new__(cls) #返回什么，obj就等于什么
obj = Foo()
#当创建对象时先执行__new__再执行__init__方法
3_call_
#对象后面加括号，执行__call__方法
class Foo(object):
def __init__(self):
print("给对象进行赋值")
self.x = 123
def __new__(cls,*args,**kwargs):
print("创建对象")
return object.__new__(cls) #返回什么，obj就等于什么
def __call__(self,*arg,**kwargs):
print("执行call方法")
# obj = Foo()
# obj()
Foo()()
#当创建对象时先执行__new__再执行__init__方法
4._getitem_ setitem _delitem_
#语法的对应关系，是只关于字典的吗？这是一个问题？？？其实看样子是只关于字典的
class Foo(object):
def __setitem__(self, key, value):
print(key,value)
def __getitem__(self,item): #此处的item就是“xxx”
return item + "uuu" #为其返回值
def __delitem__(self,key):
pass
obj1 = Foo()
obj1["k1"] = 123 #内部会自动调用__settitem__方法：
val = obj1["xxx"] #内部会自动调用__getitem__方法进行取值
print(val)
del obj1["ttt"] #内部会自动调用__delitem__方法
5_str_
class Foo(object):
def __str__(self):
‘‘‘
只有在打印对象时，会自动化调用此方法，并将其返回值在页面显示出来
:return:
‘‘‘
return "kasguuas"
obj = Foo()
print(obj) #打印的时候执行__str__返回的内容，对象还是原来的对象,不会影响obj的值，只在打印的时候调用__str__
#__str__应用示例
#改进前
class User(object):
def __init__(self,name,email):
self.name = name
self.email = email
user_list = [User("二狗","2g@qq.com"),User("二蛋","2d@qq.com"),User("狗蛋","gd@qq.com")]
for item in user_list:
print(item.name,item.email)
#改进后
class User(object):
def __init__(self,name,email):
self.name = name
self.email = email
def __str__(self):
return "%s %s"%(self.name,self.email)
user_list = [User("二狗","2g@qq.com"),User("二蛋","2d@qq.com"),User("狗蛋","gd@qq.com")]
for item in user_list:
print(item) #当print对象时便触发__str__e
6_dict_
#去对象中找到所有变量并将其装换为字典
class Foo(object):
def __init__(self,name,age,email):
self.name = name
self.age = age
self.email = email
obj = Foo("yang",19,"xxxx@qq.com")
print(obj.name)
print(obj.age)
print(obj.email)
val = obj.__dict__ #去对象中找到所有变量并将其装换为字典
print(val)
‘‘‘
yang
19
xxxx@qq.com
{‘name‘: ‘yang‘, ‘age‘: 19, ‘email‘: ‘xxxx@qq.com‘}
‘‘‘
上下文管理
class Foo():
def __enter__(self):
self.x = open("a.text",mode="a",encoding="utf-8")
return self.x
def __exit__(self, exc_type, exc_val, exc_tb):
self.x.close()
with Foo() as ff: #ff为enter的返回值
ff.write("yang")
‘‘‘
思考：
这样做的目的是什么？
1.open应该是一个内置的函数，是封装好的函数。这里是把open扒开了进行解析，
由此可以看出open应该包含两个函数，但不是完全的，因为我们在调用函数后还要对函数进行关闭
2.这里面进行了好几次的对象的传递，所以精简了许多中间的传递布置
‘‘‘
#面试题
class Context:
def __enter__(self):
print("进入")
return self #此处实际上是对ctx进行传参
def __exit__(self, exc_type, exc_val, exc_tb):
print("退出")
def do_something(self):
print("内部执行")
with Context() as ctx: #参数之间进行传递，比直接调用显得麻烦，但就是函数内部的逻辑
ctx.do_something()
两对象相加
class Foo(object):
def __add__(self, other):
return 123 #返回什么val就是什么，pass时返回的为相加的函数
obj1 = Foo()
obj2 = Foo()
val = obj1 + obj2 #obj1首先触发__add__，即self为obj1，other为obj2
print(val)
标签：示例 mode 影响 显示 之间 就是 write 封装 一个
原文地址：https://www.cnblogs.com/yangzilaing/p/14009848.html
