• Python核心编程


    1. 模块循环导入问题
    2. 深拷贝和浅拷贝
    3. 位运算
    4. 获取私有属性的值
    5. property的使用
    6. 迭代器
    7. 闭包
    8. 装饰器
    9. python动态添加属性以及方法
    10. 生成器
     
     

    1.模块循环导入问题
    #vi a.py
    from b import b
    def a():
        print('-----a-----')
        b()
    a()
    #vi b.py
    from a import a
    def b():
        print('-----b-----')
    def c():
        print('------c-----')
        a()
    c()
    #python3 a.py的结果是:ImportError:cannot import name 'a'
    解决办法:不要互相调用,另外写个主模块去调它们(子模块)
     

    2.深拷贝与浅拷贝
    #浅拷贝
    a = [11,22,33]
    b = a
    id(a) == id(b)   #True
     
    #深拷贝
    a = [11,22,33]
    import copy
    c = copy.deepcopy(a)
    id(a) == id(b) #False
     
    #copy与deepcopy的区别
    copy只拷贝第一层引用;deepcopy是递归拷贝所有引用
    当copy遇到元组时,会进行浅拷贝(只指向)
     

    3.位运算
    & 按位与
    | 按位或
    ^ 按位异或
    ~ 按位取反
    << 按位左移
    >> 按位右移
    用途:直接操作二进制,省内存,效率高
    按位移:
    8>>1   4
    8<<1   16
    按位与:
    全1才1否则0:只有对应的两个二进制均为1时,结果位才为1,否则为0
    按位或:
    有1就1 只要对应的二个二进位有一个为1时,结果位就为1,否则为0
    按位异或:
    不同为1 只要对应的二进位相异(不相同)时,结果为1,否则为0
    取反:
    ~9 = -10
     

    4.获取私有属性的值:
    class Test(object):
        def __init__(self):
            self.__num = 100
        def setNum(self, newNum):
            self.__num = newNum #修改私有属性的值
        def getNum(self):
            return self.__num #返回私有属性的值
     
    t = Test()
    #print('t.__num')
    #t.__num = 200
    #print(t.__num)
    print(t.getNum())
    t.setNum(39)
    print(t.getNum())
    #私有化的本质是把私有属性给改名了。如_类名__num
     

    5.property的使用:
    class Test(object):
        def __init__(self):
            self.__num = 100
        def setNum(self, newNum):
            self.__num = newNum #修改私有属性的值
        def getNum(self):
            return self.__num #返回私有属性的值
        num = property(getNum, setNum)
    t = Test()
    t.num = 200 #相当于t.setNum(9)
    print(t.num)
    注意点:
    t.num 到底是调用getNum()还是setNum(),要根据实际的场景来判断;
    如果是给t.num赋值,那么一定调用setNum();
    如果是获取t.num的值,那么就一定调用getNum();
    property的作用:相当于把方法进行了封装,开发者在对属性设置数据的时候更方便了
    #使用装饰器
    class Test(object):
        def __init__(self):
            self.__num = 100
        @property
        def num(self):
            return self.__num
        @num.setter
        def num(self, newNum):
            self.__num = newNum
     
    t = Test()
    t.num = 200
    print(t.num)
     

    6.迭代器:
    判断是否为Itarable类型
    from collections import Iterable
    a = isinstance('abv', Iterable)
    print(a)
    #判断是否为Iterator类型
    from collections import Iterator
    a = isinstance('ac', Iterator)
    print(a)
    使用iter()函数把Iterable变成Iterator
    a = isinstance(iter('abc'), Iterator)
    print(a)
     

    7.闭包:
    #函数里面套用函数,里面的函数用到了外面函数的参数,就叫做闭包
    def test(number):
        def test2(number2):
            print('-----%s-----'%number2)
            return number+number2
        return test2 #返回函数的地址
     
    ret = test(100) #ret已经记住了外部的参数
    print(ret(20))
    #一个闭包的实际例子
    def line_conf(a, b):
        def line(x):
            return a*x + b
        return line
     
    line1 = line_conf(1, 1)
    line2 = line_conf(4, 5)
    print(line1(5))
    print(line2(5))
    #函数的最终形式(y=x+!)(y=4x+5)
    #1.闭包优化了变量,原来需要类对象完成的工作,闭包也可以完成
    #2.由于闭包引用了外部函数的局部变量,则外部函数的局部变量没有及时释放,消耗内存
    #初始设计
    def function(a,b,x):
        print(a*x+b)
     
    function(1,1,0)
     

    8.装饰器:
    #装饰器第一个版本
    def base(func):
        def inner():
           print('-----装饰器-----')
           func()
        return inner
     
    def a():
        print('-----a------')
     
    def b():
        print('-----b------')
     
    innerFunc = base(b)
    innerFunc()
    装饰器的第二个版本
    def base(func):
        def inner():
           print('-----正在验证权限-----')
           if False:
               func()
           else:
                print('没有权限')
        return inner
    @base
    def a():
        print('-----a------')
    @base
    def b():
        print('-----b------')
     
    b()
    #装饰器的执行顺序,快递(装的时候是从里往外装,拆的时候从外往里拆)
    #coding:utf-8
    def w1(func):
        print('-----正在装饰1-----')
        def inner():
            print('-----正在验证权限1-----')
            func()
        return inner
     
    def w2(func):
        print('-----正在装饰2-----')
        def inner():
            print('-----正在验证权限2-----')
            func()
        return inner
     
    @w1
    @w2
    def f1():
        print('-----f1-----')
    #有参数
    def func(functionName):
        print('-----func-----1---')
        def func_in(a, b): #如果a,b没有定义,那么会导致下面的调用失败
            print('----func_in----1----')
            functionName(a, b)   #要把a, b当作实参进行传递
        print('----func----2----')
        return func_in
     
    @func
    def test(a, b):
        print('-----test-a=%d, b=%d-----'%(a, b))
     
    test(11,22)
    #不确定参数
    def func(functionName):
        print('-----func-----1---')
        def func_in(*args, **kwargs): #如果a,b没有定义,那么会导致下面的调用失败
            print('----func_in----1----')
            functionName(*args, **kwargs)   #要把a, b当作实参进行传递
        print('----func----2----')
        return func_in
     
    @func
    def test(a, b, c):
        print('-----test-a=%d, b=%d-----'%(a, b, c))
     
    @func
    def test2(a, b, c, d):
        print('-----test-a=%d, b=%d, c=%d, d=%d---'%(a, b, c, d))
    test(11,22,33)
    test2(22,33,44,55)
    #装饰器对对带有返回值的函数进行装饰
    #解ret为None的bug
    def func(functionName):
        print('-----func-----1---')
        def func_in():
            print('----func_in----1----')
            functionName()
        print('----func----2----')
        return func_in
     
    @func
    def test():
        print('-----tes-----')
        return 'haha'
    ret = test()
    print('test return value is %s'%ret)
    #因为test()指向了func_in(),而func_in由调用了test(),而return的返回值却没有变量来接收,因此只需要找一个变量来接收functionName()的返回值就好了
    #通用装饰器
    def func(functionName):
        def func_in(*args, **kwargs):
            ret = functionName(*args, **kwargs)
            return ret
        return func_in
     
    @func
    def test():
        print('-----test1-----')
        return 'haha'
     
    @func
    def test2():
        print('-----test2-----')
    @func
    def test3(a):
        print('----test3----a=%d--'%a)
     
    ret = test()
    print('test return value is %s'%ret)
    a = test2()
    print('test2 return value is %s'%a)
    test3(11)
    #带有参数的装饰器
    def func_arg(arg):
        def func(functionName):
            def func_in():
                print('-----记录日志--arg=%s---'%arg)
                if arg == 'heihei':
                    functionName()
                    functionName()
                            else:
                                  functionName()
            return func_in
        return func
    #1.先执行func_arg('heihei')函数,这个函数return的结果是func这个函数的引用
    #2.@func
    #3.使用@func对test进行装饰
    #带有参数的装饰器,能够起到在运行时,有不同的功能
    @func_arg('heihei')
    def test():
        print('-----test-----')
     
    test()
     

    9.动态添加属性和方法
    作用域:
    什么是命名空间?
    名字起作用的范围
    globals
    locals
    LEGB规则:
    找一个变量,先找局部,再找有没有闭包,再找全局变量,再找内键
    #为类动态添加属性
    class mate(object):
        def __init__(self, Newname, Newage):
            self.name = Newname
            self.age = Newage
    laowang = mate('老王', 18)
    为变量添加单一属性
    laowang.addr = '北京'
    print(laowang.addr)
    #为类添加属性
    mate.addr = '中国'
    print(laowang.addr)
    #为类动态添加方法
    import types
    class mate(object):
        def __init__(self, Newname, Newage):
            self.name = Newname
            self.age = Newage
        def eat(self):
            print('----eat----')
    def run(self):
        print('-----run-----')
    wang = mate('老王', 18)
    wang.run = types.MethodType(run, wang)
    wang.run()
    #静态方法添加
    @staticmethod
    def test():
        print('-----static method---')
    p.test = test
    p.test()
    __slots__方法
    使用__slots__来限制class实例能添加的属性,但是仅能对当期的类添加限制,对继承的子类没有限制
    __slots__ = [‘name’, ‘age’]
     

    10.生成器:
    第一种生成器:把列表生成式的[]变为()
    a = [x*2 for x in range(10)]
    a = (x*2 for x in range(10))
    print(a)
    next(a)
    创建生成式方法二
    def creatNum():
        print('-----start-----')
        a, b = 0, 1
        for i in range(5):
            print('-----1-----')
            yield b
            print('-----2-----')
            a, b = b, a+b
        print('-----stop-----')
    a = creatNum()
    for num in a:
        print(num)
    #send的使用
    def test():
        i = 0
        while i <5:
            temp = yield i
            print(temp)
            i += 1
     
    t = test()
    t.__next__()
    t.send('haha')
    第一次调用send的解决办法:
    1.先用next,在用send
    2.send(None),再使用send 
    #多任务(协程)
    def test1():
        while True:
            print('-----1-----')
            yield None
    def test2():
        while True:
            print('-----2-----')
            yield None
    t1 = test1()
    t2 = test2()
    while True:
        t1.__next__()
        t2.__next__()
     
     
     
     
     
     
     
     
     
     
     
     
  • 相关阅读:
    VUE(vue对象的简单属性)
    使用Dockerfile封装Django镜像
    Django路由小知识
    字符编码小知识
    python值的引用传递和go语言的值传递
    centos输入正确的账号和密码登陆不进去
    迅为4412开发平台Zigbee模块在物联网智能家居中的应用
    全新升级4412开发板项目学习实战资料
    迅为4418开发板平台应用于智能门禁系统
    【分享】iTOP-iMX6UL开发板驱动看门狗 watchdog 以及 Linux-c 测试例程
  • 原文地址:https://www.cnblogs.com/xyya/p/9601862.html
Copyright © 2020-2023  润新知