愚公移山日记·37

愚公移山日记·37

今天学习的是类的装饰器，类装饰器的使用，gil锁，深浅拷贝。
类的装饰器

class Test(object):
    def __init__(self):
        print('init')

    def run(self):
        print('跑')

    def __call__(self, *args, **kwargs):
        print('call')


# 创建对象
test = Test()
# test.run()
#当对象名（）此时会去调用类中的__call__() 方法
test()

类的装饰器的使用

class Test(object):
    def __init__(self, func):
        print('init')
        print('func', func)
        # func是login函数的引用
        self.func = func

    def run(self):
        print('跑')

    def __call__(self, *args, **kwargs):
        print('call')
        #调用原来的login的内容
        self.func()


@Test
# login = Test(login)
def login():
    print('开始登录')


# ret = login
# print(ret)
login()

Gil 锁的解决方案

# 解决方案
# 1，换一种解释器jPython
# 2，多进程替代多线程
# 3，使用python语言的特性：胶水  子线程用C语言来写

# 导入模块 加载C语言文件
import ctypes
import threading

# 加载so文件
mylib = ctypes.cdll.LoadLibrary('./libtest.so')
# 创建子线程 并且启动
t1 = threading.Thread(traget=mylib.Loop)
t1.start()
# 主线程 死循环

while True:
    pass

python中的可变与不可变

'''
可变：变量创建完成之后，内存可以再改变
不可变你：变量创建完成之后，内存空间一旦分配完毕，就不能再改变了
a 是一个变量 保存数字 不可变
'''


def test():
    a = 10
    print(a, '=a', id(a))
    # 修改变量值
    # 重新开辟一块新的内存
    a = 6 + 1
    print(a, '=a', id(a))


list1 = [1, 3, 5]
print('list1 = ', list1, id(list1))

#列表增加新的元素
list1.append(7)
print('list1 =', list1, id(list1))

# list1 赋值给list2
list2 = list1
list2.append(9)
print('list2 = ', list2, id(list2))

python中的深浅拷贝

# 浅拷贝：引用地址拷贝，并没有产生新的空间，如果拷贝的是对象，原对象和copy对象都指向同一个内存空间，只拷贝父对象，不会拷贝对象的内部的子对象
# 用法：copy.copy（变量）会进行拷贝

# 深拷贝：会产生新的空间，如果拷贝的是对象，原对象和copy对象都指向不同的内存空间，会拷贝对象及其子对象（会产生新的对象）
# 用法：copy.deepcopy（变量名）


# 简单可变类型的深浅拷贝问题
# 可变：变量创建完成之后，内存可以改变
# 列表和字典
import copy

def test():
    # 可变类型的潜拷贝，也会产生副本
    list1 = [1, 2, 3]
    print('list1 = ', list1, id(list1))

    # list3 = list1
    # list3.append(5)
    # print('list3 = ', list3, id(list3))

    # 拷贝：
    # 导入模块
    # 调用方法
    # copy(变量) 产生副本，浅拷贝
    list2 = copy.copy(list1)
    print('list2 = ', list2, id(list2))
    # 修改list
    list1.append(5)
    print('list1 = ', list1, id(list1))
    print('list2 = ', list2, id(list2))


def test2():
    list1 = [1, 2, 3]
    print('list1 = ', list1, id(list1))
    # deepcopy(变量) 产生副本，深拷贝
    list2 = copy.deepcopy(list1)
    print('list2 = ', list2, id(list2))
    # 修改list2
    list2.append(7)
    print('list1 = ', list1, id(list1))
    print('list2 = ', list2, id(list2))

复杂可变类型的深浅拷贝

# 含有嵌套关系的
import copy


def test():
    A = [1, 2]
    B = [3, 4]
    C = [A, B]

    print('A = ', A, id(A))
    print('B = ', B, id(B))
    print('C = ', C, id(C))
    print('C[0]', C[0], id(C[0]))
    # 复杂可变类型进行浅拷贝
    D = copy.copy(C)
    print('D = ', D, id(D))
    print('D[0] = ', D[0], id(D[0]))

    # 修改A的
    A[0] = 10
    print('A = ', A, id(A))
    print('D[0] = ', D[0], id(D[0]))

def test2():
    A = [1, 2]
    B = [3, 4]
    # [[1, 2],[3, 4]]
    C = [A, B]

    print('A = ', A, id(A))
    # print('B = ', B, id(B))
    print('C = ', C, id(C))
    # print('C[0]', C[0], id(C[0]))

    D = copy.deepcopy(C)
    print('D = ', D, id(D))
    print('D[0]= ', id(D[0]), 'c[0] = ', id(C[0]), 'A[0] = ', id(A[0]))

    # 修改A的
    A[0] = 10
    print('A = ', A, id(A))
    print('D[0] = ', D[0], id(D[0]))

test2()

ok 就这么多！