Python的魔法函数

python基础

浏览数:181

2019-9-18

AD:资源代下载服务

概要

  1. 如何定义一个类
  2. 类里通常包含什么
  3. 各个部分解释
  4. 类是怎么来的
  5. type和object的关系
  6. 判断对象的类型
  7. 上下文管理器

类结构

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


# 类名后面写(object)这种写法表示是新式类,不写object是经典类,两种的区别是多继承的问题。
class OOP(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__") def myMethod(self): """ 为什么类里面的每一个方法都是有self呢?因为我们调用的时候虽然是通过实例名称来调用,但是实际上是 OOP.myMethod(oop)这种形式,你发现它还是会自动把实例传进来,这个self就是用来接收这个实例的。所以 你在自己的方法里面可以访问变量。实例 oop 本身没有 myMethod()方法,之所以可以调用成功就是 OOP.myMonth(oop) 完成的。 对于实例来说类里面的方法都是公用的,你实例化多个对象其实这些对象是多个,但是它们所公用的类方法和类变量在内存中也只有一份, 哪个个实例调用这个方法那么这个self就是哪个实例。记住一句话实例调用方法都是对实例自身进程操作的。 再说详细点,2个针对于同一个类的实例,A实例操作一个方法会影响B实例么?显然不能,这就是self必须存在的原因,在JAVA中也是一样,只是它使用this。 :return: """ print("自定义方法") # 设置成属性用于获取内部变量 @property def Var(self): return self._Var2 # 设置成属性形式赋值给内部变量,这个必须写在@property下面 @Var.setter def Var(self, value): self._Var2 = value def main(): 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


class TestObj(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"}


def main():
    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


class TestObj(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"}


def main():
    # 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


class TestObj(object):

    # 类变量
    var1 = 999

    def __init__(self, name, age):
        self.name = name
        self.age = age


def main():
    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


class TestObj(object):

    # 类变量
    var1 = 999

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 定义__str__方法
    def __str__(self):
        return "我是TestObj"


def main():
    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


class TestObj(object):

    # 类变量
    var1 = 999

    def __init__(self, name, age):
        self.dic1 = {}

    def __getitem__(self, item):
        print("__getitem__", item)
        return self.dic1[item]

    def __setitem__(self, key, value):
        print("__setitem__", key, value)
        self.dic1[key] = value

    def __delitem__(self, key):
        print("__deleteitem__", key)


def main():
    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__ = type


class TestObj(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 定义__str__方法
    def __str__(self):
        return "我是TestObj"


def main():
    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__})


def main():
    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

class TestObj(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age
        print("__init__方法执行了")

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

        """
        如果你的类里自己重写了 __new__ 方法那么下面的这个返回必须写,否则你定义的类将不会执行__init__方法。
        这个类是继承自object,那么你其实并不知__new__原本具体都做什么,出于某些原因你必须要重写__new__方法,
        当你的逻辑写完之后,就要通过 object.__new__(cls) 来调用父类的__new__方法,完成初始化。
        """
        return object.__new__(cls)


def main():
    TO = TestObj(name="Tom", age=23)
    print(TO.name)


if __name__ == '__main__':
    main()

 

作者:昀溪