Python高级编程1-闭包,迭代器,装饰器,生成器

本文链接：https://blog.csdn.net/MrLeeYongSheng/article/details/77922731

从新导入

import imp
imp.reload(模块)

循环导入

程序会挂掉

a.py

import b
b.bTest()

def aTest():
    print("a")

b.py

import a
a.aTest():

def bTest():
    print("b")

==,is

a = [11,22,33]
b = [11,22,33]

a==b 为 true
a is b 为 false

c = a
c is a 为true

== 内容是否相同

is 指向是否同一个东西(地址是否相同)

附加

a= 100
b = 100
a is b -- true
有范围限制

深拷贝,浅拷贝

浅拷贝

a = [11,22,33]
b = a #a指向的地址赋值给b,这就是浅拷贝

深拷贝

import copy

a = [11,22,33]
c = copy.deepcopy(a)

此时a,b的ID不一样,指向的地址不相同

a = [11,22,33] 
b = [44,55,66]
c = [a,b]

d = c #浅拷贝
e = copy.deepcopy(d) #深拷贝,递归拷贝

#e[0] = [11,22,33]
a.append(44) #a=[11,22,33,44]
c[0] = [11,22,33,44]
e[0] = [11,22,33]

copy

f = copy.copy(d)  #只拷贝第一层,不会递归拷贝

若d为不可变类型,如元组时,则拷贝为浅拷贝(其地址所指向的对象为同一个内容,其ID相同)

进制,位运算

进制转换

二进制
a = bin(18)

八进制
a = oct(18)

十六进制
a = hex(18)

十进制
int(数,进制数)
int("0x12",16)

位运算

左移

a = a<<1

右移

a = a>>1

按位与

7&8

按位或

7|8

按位异或

7^8

按位取反

a = ~a

私有化

class Test(object):
    def __init__(self):
        self.num = 100 #可以直接使用

t = Test()
t.num #直接使用

在属性名加两个_,后使属性私有化

名字重整

私有属性名字重整

t = Test()
dir(t) #可以查看一下

_名字

禁止from xxx import * 来导入
但是 import xxx 还是能使用的

property

class Test(object):
    def __init__(self):
        self.__num = 100

    def getNum(self):
        return self.__num

    def setNum(self,num):
        self.__num = num

    __num = property(getNum,setNum)



t = Test()
t.num = 1 #相当于t.setNum(1)
print(t.num) #相当于t.getNum()

使用装饰器(相当于注解)

class Test(object):
    def __init__(self):
        self.__num = 100

    @property #1)声明了num. 2)声明了getter
    def num(self):
        return self.__num

    @num.setter #声明setter
    def num(self,num): #命名必须为property所声明的名字:num
        self.__num = num


t = Test()
t.num = 1 #相当于t.setNum(1)
print(t.num) #相当于t.getNum()

迭代器

使用for来迭代

for temp in list

可迭代对象

list,tuple,dict,set,str

generator:
    a = (x for x in range(10))

判断是否可迭代

from collections import Iterable

isinstance("abc",Iterable) #判断是否可迭代对象

列表不是可迭代对象,但是可以迭代,只是不可以使用next(list).

生成可迭代对象

iter(list)

闭包

一个函数里定义一个函数,并且在内部函数使用了外部函数的变量,称该整体为闭包

def test(num1):

    def test_in(num2):
        print(num1+num2)

    return test_in

ret = test(100) #把100存在num1
ret(1)  #打印101
ret(100) #打印200
ret(200) #打印300

装饰器

def w1(func):
    def inner():
        print("--w1--")
        func() 
    return inner

def f1():
    print("---f1---")

f1 = w1(f1)
f1()

使用@

@w1
def f1():
    print("---f1---")

什么时候执行装饰器

def w1(func):
    print("--正在装饰--")
    def inner():
        print("--w1--")
        func() 
    return inner

@w1
def f1():
    print("---f1---")

等价于执行
f1 = w1(f1) 
打印:--正在装饰--

两个装饰器

@w1
@w2
def f1():
    print("---f1---")

等价于
    f1 = w1(w2(f1))

传递不定长参数 ###

@w1
def f1():
    print("---f1---")

什么时候执行装饰器

def w1(func):
    print("--正在装饰--")
    def inner(*args,**kwargs):
        print("--w1--")
        func(*args,**kwargs) #此处的*为解包,使其为最初始调用的形式传递 
    return inner

@w1
def f1(*args,**kwargs):
    print("---f1---")

有返回值的函数的装饰器

def w1(func):
    print("--正在装饰--")
    def inner():
        print("--w1--")
        a = func()
        print("----")
        return a 
    return inner

@w1
def f1():
    print("---f1---")   
    return "abc"

通用装饰器

def w1(func):
    def inner(*args,**kwargs):
        print("--w1-start--")
        ret = func(*args,**kwargs) #此处的*为解包,使其为最初始调用的形式传递
        print("--w1-end--")
        return ret 
    return inner

怎么通用呢?

1)可变参数,随你怎么传,只要合规定的来

2)有返回值

带有参数的装饰器

def func_arg(arg):
    def func(f):
        def func_in():
            f()
    print("arg=%s"%arg)
    return func

@func_arg("hello")
def f1():
    pass

作用域

查看全局变量

globals()

查看局部变量

locals()

def f():
    a=100
    print(locals())

局部变量使用优先级高于全局变量

查看内嵌

dir(buildin)

变量使用顺序

局部–>全局–>内嵌

动态

动态添加属性

class Person(object):
    def __init__(self,name,age):
        self.age = age
        self.name = name

a = Person()
a.addr = "asdf"
print(a.addr) #给对象添加属性,不会影响类

Person.addr = "aaaa" #给类添加属性

动态添加方法

对象绑定普通方法

def func(self):
    pass

import types
p1.func = types.MethodType(func,p1)#给对象添加方法

xxx = types.MethodType(func,p1)
xxx() 等价于 p1.func()

类绑定静态方法

@staticmethod
def func():
    pass

P.func = func

类绑定类方法

@classmethod
def func(cls):
    pass

P.func = func()

slots

插槽,限制属性

class Person():
    __slots__ = ("name","age")

p = Person()
p.name = "asdf"

p.a = 10 #抛错

生成器

列表生成式

a = [x for x in range(10)]

end

生成器说明:什么时候用,什么时候生成

保存的是一种算法.

创建生成器

a = (x for x in range(10))

使用

next(a)

yield 创建生成器

def func():
    for x in rang(10):
        print("---1---")
        yield x #执行到这里会停止下来,把值并返回
        print("---2---") #下一次从这里开始执行

x = func() #返回值为一个生成器
next(x)

使用for循环遍历生成器

for x in a:
    pass

对生成器的操作

a.next()等价于next(a)

send

def func():
    for x in rang(10):
        temp = yield x #执行到这里会停止下来,把值并返回
        print("---%s---"%temp)

x = func() #返回值为一个生成器
x.send("kkk") #把参数传递到temp   

x.send(None)等价于next

实现多线程任务

def thread1():
    while True:
        print("---1---")
        yeild None

def thread2():
    while True:
        print("---2---")
        yeild None

t1 = thread1()
t2 = thread2()

while True:
    t1.__next__()
    t2.__next__()