python魔法方法与函数_Python的魔法函数

概要

如何定义一个类

类里通常包含什么

各个部分解释

类是怎么来的

type和object的关系

判断对象的类型

上下文管理器

类结构

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

#类名后面写(object)这种写法表示是新式类，不写object是经典类，两种的区别是多继承的问题。

classOOP(object):#定义类变量，类共享的，那么实例A修改以后实例B也会受到影响（修改不可比那对象感官上看不到修改，如果是可变类型比如列表，感官上就有影响了），

#所以类变量是定义共有的属性通常不能修改，虽然技术上也可以修改。不用实例化也可以访问类变量。

var1 = "hello" #不可变对象

list1 = [] #可变对象

def __call__(self, *args, **kwargs):"""这个函数不是析构函数也不是构造函数，对象或者实例可以像函数一样调用，就像执行普通函数一样。这个如果不需要也不用写。

:param args:

:param kwargs:

:return:"""

print("我是特殊函数 __call__")def __init__(self):"""构造函数，用于初始化类的实例，实例化对象的时候就会自动调用这个方法，比如把实例变量绑定到实例上。

这里这个self其实有些特别，也就是实例化的时候会自动把实例对象传递进来，self就是实例对象。

oop = OOP() 这里其实是 OOP(oop) 所以self就是实例oop，这个self也就是为了接受隐式传递进来的实例名称

除了在 __init__ 方法中定义的东西属于实例自己之外也就是在内存中也是独立的，其他的内容包括类变量、类里面的方法在内存中都只有一份所有

实例公用。

多说一句，其实实例化的时候先执行__new__方法，该方法调用__init__方法。"""

#在 __init__ 方法里定义的变量是实例变量，实例独享的。通过实例调用变量或者其他资源是先找实例本身，如果没有就找类的。

#比如类变量和实例变量同名，你通过实例访问这个变量时，它会给你返回实例变量的值。

#加 "_" 表示私有变量，不过使用 "_" 也可以通过某种方式直接访问，所以要想使用严格的私有变量要使用 "__" 双下划线。

self._Var2 = ""

print("我是构造函数 __init__")def __del__(self):"""析构函数，当实例对象删除时候调用，所以不需要设置参数，你也传递不了参数。它是在实例销毁的时候自动调用的。

对于python解释器来说，它有垃圾回收机制，只要有实例存在解释器就认为这个类被使用。如果你del这个实例，其实你删除的

是这个实例，也就意味着切断了实例和类的关系，当解释器发现某个类没有被引用了就可以在内存中删除了。

实例保存的是指向类的指针，实例放在栈里，类放在堆里。基本数据类型放在栈里，非基本数据类型真实的数据都是在堆里，而这个变量名在栈里。

这个方法你通常不用写。"""

print("我是析构函数 __del__")defmyMethod(self):"""为什么类里面的每一个方法都是有self呢？因为我们调用的时候虽然是通过实例名称来调用，但是实际上是

OOP.myMethod(oop)这种形式，你发现它还是会自动把实例传进来，这个self就是用来接收这个实例的。所以

你在自己的方法里面可以访问变量。实例 oop 本身没有 myMethod()方法，之所以可以调用成功就是 OOP.myMonth(oop) 完成的。

对于实例来说类里面的方法都是公用的，你实例化多个对象其实这些对象是多个，但是它们所公用的类方法和类变量在内存中也只有一份，

哪个个实例调用这个方法那么这个self就是哪个实例。记住一句话实例调用方法都是对实例自身进程操作的。

再说详细点，2个针对于同一个类的实例，A实例操作一个方法会影响B实例么？显然不能，这就是self必须存在的原因，在JAVA中也是一样，只是它使用this。

:return:"""

print("自定义方法")#设置成属性用于获取内部变量

@propertydefVar(self):returnself._Var2#设置成属性形式赋值给内部变量，这个必须写在@property下面

@Var.setterdefVar(self, value):

self._Var2=valuedefmain():

oop=OOP()

oop1=OOP()#调用实例的 __call__函数

oop()#通过属性方式修改变量

oop.Var = "world"

print(oop.Var)#判断是否有某种属性

#print(hasattr(oop, "_var1"))

#修改不可变对象（类变量）

print("通过实例oop查看类变量var1的值：", oop.var1)print("通过实例oop1查看类变量var1的值：", oop1.var1)print("通过实例oop修改类变量var1的值：改为100")

oop.var1= 100

print("通过实例oop查看类变量var1的值：", oop.var1)print("通过实例oop1查看类变量var1的值：", oop1.var1)#从值上看感觉类变量也属于实例，因为修改不影响，下面打印id你就看出来了

#print("通过实例oop查看类变量var1的内存地址：", id(oop.var1))

#print("通过实例oop1查看类变量var1的内存地址：", id(oop1.var1))

#print("通过实例oop修改类变量var1的值：改为100")

#oop.var1 = 100

#print("通过实例oop查看类变量var1的内存地址：", id(oop.var1))

#print("通过实例oop1查看类变量var1的内存地址：", id(oop1.var1))

#修改类变量可变类型变量

print("oop实例向list1添加一个元素A")

oop.list1.append("A")print("oop的 list1 内容为：", oop.list1)print("oop1的 list1 内容为：", oop1.list1)if __name__ == '__main__':

main()

关于类里面的类变量和实例变量还需要在说一下

#!/usr/bin/env python

# -*- coding: utf-8 -*-

class A:

# 类变量

a = 11

def __init__(self, x, y):

# 实例变量

self.x = x

self.y = y

a1 = A(1, 2)

# 这里你以为是修改的类A里面的a吗？其实不是，为什么，看下面

a1.a = 100

"""

这样定义其实会让a1这个实例多一个bb属性出来（新建到a1这个实例中），

所以上面那个a1.a 其实并不是A类里面的类变量a，而是属于实例自己的

"""

a1.bb = 200

print(a1.x, a1.y, a1.a, a1.bb) # 这也就是a1为什么会有bb

a2 = A(5, 6)

# 这里的a值还是11，a2这个实例本身没有a这个变量，但是它自己没有就会向上查找，它的上一级就是A这个类

print(a2.x, a2.y, a2.a)

A.a = 500 # 这样才会修改类变量，修改之后实例化的对象(之前或者之后)理论上都受到影响

print(A.a)

a3 = A(8, 9)

print("实例a3的a: ", a3.a)

print("实例a2的a: ", a2.a)

# a1之所以不受影响是因为之前 a1自己定义了一个a属性，这样它自己就有a属性，从而就不用去找类的a属性了

print("实例a1的a: ", a1.a)

类中其他特殊方法（也叫做魔法方法）

__dic__

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

classTestObj(object):#类变量

var1 = 999

def __init__(self, name, age):

self.name=name

self.age=age

self.list1= ['A', 'B']

self.set1= (1, 2)

self.dic1= {"a": "a", "b": "b"}defmain():

TO= TestObj(name="Tom", age=23)print(TO.__dict__)

TO.name= "张三"

print(TO.__dict__)if __name__ == '__main__':

main()

作用：查看实例里面的属性，键为属性名，值为属性值，那都包含哪些属性呢？ 所有 self.XXX 的都是属性。而且类变量也算。它永远返回的是实例当前的最新值。从输出看到类变量并没有输出。

其实这个属性通过类也可以调用

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

classTestObj(object):#类变量

var1 = 999

def __init__(self, name, age):

self.name=name

self.age=age

self.list1= ['A', 'B']

self.set1= (1, 2)

self.dic1= {"a": "a", "b": "b"}defmain():#TO = TestObj(name="Tom", age=23)

#print(TO.__dict__)

#TO.name = "张三"

#print(TO.__dict__)

#通过类来调用

print(TestObj.__dict__)if __name__ == '__main__':

main()

除了输出类变量之外还有一些类本身的东西。

__str__和__unicode__方法

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

classTestObj(object):#类变量

var1 = 999

def __init__(self, name, age):

self.name=name

self.age=agedefmain():

TO= TestObj(name="Tom", age=23)#打印实例

print(TO)if __name__ == '__main__':

main()

输出是对象的地址

这是默认输出，如果你想改变输出就是通过__str__来设置的，__unicode__是python2的方法，在python3中使用__str__

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

classTestObj(object):#类变量

var1 = 999

def __init__(self, name, age):

self.name=name

self.age=age#定义__str__方法

def __str__(self):return "我是TestObj"

defmain():

TO= TestObj(name="Tom", age=23)#打印实例

print(TO)if __name__ == '__main__':

main()

作用：在类里定义这个方法，那么在打印对象时将输出该方法的返回值。在python3中是__str__ 在python2中是__unicode__。这个方法用的最多的是在Django的module中。

__getitem__、__setitem__和__delitem__方法

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

classTestObj(object):#类变量

var1 = 999

def __init__(self, name, age):

self.dic1={}def __getitem__(self, item):print("__getitem__", item)returnself.dic1[item]def __setitem__(self, key, value):print("__setitem__", key, value)

self.dic1[key]=valuedef __delitem__(self, key):print("__deleteitem__", key)defmain():

TO= TestObj(name="Tom", age=23)

TO["name"] = "Lucy"TO["age"] = 23

print(TO.dic1)print(TO["name"])del TO["name"]if __name__ == '__main__':

main()

运行结果

通过这三个方法可以让操作实例跟操作字典一样。至于使用场景我也不知道，目前没有用到过。

这些魔法方法属于谁

#!/usr/bin/env python

# -*- coding: utf-8 -*-

class Company(object):

def __init__(self, employee_list):

self.employee = employee_list

def __getitem__(self, item):

return self.employee[item]

company = Company(["Tom", "Lucy", "Lily"])

print(company[:2])

for item in company:

print(item)

换成字典就不行了

__getitem__可以让我们增加一些更加方便的方式去操作对象，但是上面之所以不能切片了是因为字典本身不能切片，而且__getitem__里面的item是索引并不是键，所以当我们换成字典的时候就会出错。其实这种魔法方法不是为类而创建的的也不是object才有的，而是一种可以丰富对类的操作的一种方式。

上下文管理器

#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""

正常使用try语句我们是这样的

"""

def exe_try():

dic1 = {"A": "2"}

try:

print(dic1["B"])

except KeyError as e:

# 抛出异常执行这里

print("KeyError")

else:

# 不抛出异常执行这里

print("没有异常")

finally:

# 无论是否抛出异常最后都执行这里

print("finished")

# exe_try()

"""

你是否想过一个问题，打开文件会抛出异常，通常打开文件后也需要关闭文件流，为什么用 with open()语句可以不用手动关闭文件流呢？

这就是上下文管理器

"""

class Sample:

def __init__(self):

# 首先执行这个方法

print("__init__")

def __enter__(self):

# 然后会自动调用这个方法，可以理解为获取资源

print("__enter__")

return self

def __exit__(self, exc_type, exc_val, exc_tb):

# 这个函数会自动调用，当跳出with语句的时候，目的是为了释放资源

print("__exit__")

def toDo(self):

print("to do something")

# 这个用法是不是很像 with open()呢？

with Sample() as sample:

sample.toDo()

"""

__enter__和__exit__构成了上下文管理器

"""

#!/usr/bin/env python

# -*- coding: utf-8 -*-

"""

如何把上下文管理器更加简化一下呢？

"""

import contextlib

@contextlib.contextmanager # 这个装饰器把下面的函数包装成上下文管理器，主要利用了yiele的特性

def myFun(arg1):

print("begin", arg1) # 相当于 __enter__ 里面的代码

yield {} # 这里必须有个生成器

print("finished") # 相当于 __exit__ 里面的代码

with myFun("AAA") as my:

print("BBB")

类是如何创建的

一切皆对象，任何一个对象都可以找到它属于什么类型，那么类也是对象，那类的类型是什么呢？

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

__metaclass__ =typeclassTestObj(object):def __init__(self, name, age):

self.name=name

self.age=age#定义__str__方法

def __str__(self):return "我是TestObj"

defmain():

TO= TestObj(name="Tom", age=23)print(type(TO))print(type(TestObj))if __name__ == '__main__':

main()

输出

类的类型就是type，也就是说类是通过type来创建的。到底是怎么创建的呢？

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

def __init__(self, name, age):

self.name=name

self.age=age"""TestObj 对象名称

type() 函数

"TestObj" 类名称

(object,) 继承自哪里，可以为空

{} 方法名称和方法，字典形式 方法就是上面定义的"""TestObj= type("TestObj", (object,), {"__init__": __init__})defmain():

TO= TestObj(name="Tom", age=23)print(type(TO))print(type(TestObj))if __name__ == '__main__':

main()

现在知道为什么TestObj的type是type了吧。

关于type和object

type用来生成类，而类用来生成实例，所以我们通过type命令可以查看这个实例或者说是对象是由谁生成的也就是其类型

a = 1

print(type(1), " 生成1")

print(type(int), " 生成int")

print(type(type), " 生成type")

# 基类

class MyClass:

pass

# object是所有类都要继承的类也就是最顶层的类，或者说所有类的父类，类的祖先

print("MyClass的基类是：", MyClass.__bases__)

print("type的基类是：", type.__bases__)

print("object的type是：", type(object))

print("Object的基类是：", object.__bases__)

type的基类是object， 而object的type是type，看起来是个环形。object是type的实例，而type又继承自object，type也是自己的实例。在Python中

一切为对象，list、str、int等都是对象，可能有人问这命名是类啊，没错它们是类但也是对象。这一点和JAVA有所区别。这些东西之所有是类但同时也是对象

是因为他们都是type的实例。它们继承自object但是它们也是type的实例，只有实例才可以叫做对象，否则它们就是类。

type是自己的实例，object是type的实例，而type又继承了object，str是type的实例同时继承了objcet。

判断对象类型

我们知道获取对象类型通过type来查看。但是还有一个叫做isinstance，这两个有什么区别呢？

#!/usr/bin/env python

# -*- coding: utf-8 -*-

class A:

pass

class B(A):

def test(self):

print("Test")

b = B()

print(isinstance(b, B))

print(isinstance(b, A))

print(type(b) is A)

结果是type不认为实例b是A的类型，但是isinstance则任务b是A的类型，b是B的实例，而B继承了A所以说b是A的类型也没有错。那他俩有什么区别呢？

发现用 isinstance 和 type 得到的结果不同，因为type(b) 指向的就是B这个类，而A就是A这个类，显然不相同，虽然B继承自A，但是用 isinstance 就会得到相同的结果，它会追溯它判断b是不是A这个类型，因为b是B的实例，而B继承自A，所以结果为 True。

说到底type不会认为子类的对象的类型是父类，而isinstance则会子类的对象也是父类的类型。

多继承时super的执行顺序

#!/usr/bin/env python

# -*- coding: utf-8 -*-

class A:

def __init__(self):

print("A")

class B(A):

def __init__(self):

print("B")

# 调用父类方法，Python2写法

# super(Son, self).__init__()

# 调用父类方法，Python3简化写法

super().__init__() #

class C(A):

def __init__(self):

print("C")

super().__init__() #

class D(B, C):

def __init__(self):

print("D")

super().__init__() #

# 打印D的MRO看一下

print(D.__mro__)

d = D()

常规上我们说super是调用父类方法，没错但是不太严谨，它是调用MRO路径寻找的下一个类的方法。当你使用单继承的时候看不出来，

当使用多继承的时候就会看出来。

__new__方法

#!/usr/bin/env python#-*- coding: utf-8 -*-#Author: rex.cheny#E-mail: rex.cheny@outlook.com

classTestObj(object):def __init__(self, name, age):

self.name=name

self.age=ageprint("__init__方法执行了")def __new__(cls, *args, **kwargs):"""该方法会在__init__之前调用.

:return:"""

print("__new__方法执行了")"""如果你的类里自己重写了 __new__ 方法那么下面的这个返回必须写，否则你定义的类将不会执行__init__方法。

这个类是继承自object，那么你其实并不知__new__原本具体都做什么，出于某些原因你必须要重写__new__方法，

当你的逻辑写完之后，就要通过 object.__new__(cls) 来调用父类的__new__方法，完成初始化。"""

return object.__new__(cls)defmain():

TO= TestObj(name="Tom", age=23)print(TO.name)if __name__ == '__main__':

main()