python——闭包与装饰器、深浅拷贝

1、is 和 ==的区别

• ==判断的是两个变量的值
• is判断两个变量的内存地址是否相等

>>> a = 13467498
>>> b = 13467498
>>> id(a)		# 以10进制返回a的内存地址
2153635442032
>>> id(b)
2153635442096
>>> a is b
False
>>> a == b
True
>>> a = "flandre"	# 所有不可变类型常量内存地址都只有一个
>>> b = "flandre"
>>> a is b
True
>>> a == b
True

不可变类型：整型，长整型，浮点数，复数，布尔值，字符串，元组
可变类型：列表，字典。

2、深浅拷贝

• 浅拷贝只拷贝第一层（顶层），可以节约内存，
• 深拷贝会递归拷贝，若涉及子对象，应使用深拷贝，

>>> import copy
>>> a = [0,1,2,[46,45,56],3,4,5]
>>> b = copy.copy(a)
>>> c = copy.deepcopy(a)
>>> a.append(6)
>>> a
[0, 1, 2, [46, 45, 56], 3, 4, 5, 6]
>>> b
[0, 1, 2, [46, 45, 56], 3, 4, 5]
>>> c
[0, 1, 2, [46, 45, 56], 3, 4, 5]
>>> a[3].append(57)
>>> a
[0, 1, 2, [46, 45, 56, 57], 3, 4, 5, 6]
>>> b
[0, 1, 2, [46, 45, 56, 57], 3, 4, 5]
>>> c
[0, 1, 2, [46, 45, 56, 3, 4, 5]

3、生成器

列表推导式：

[i for i in range(101)]
[i for i in range(101) if i % 2 == 0]
[i*j for i in range(1,10) for j in range(1,10)]
# 当列表元素过多时，会很占用内存

将列表推导式的[]改成()就会产生生成器

>>> a = (i for i in range(101))
>>> type(a)
<class 'generator'>
>>> next(a)			# 使用next()函数调用可以得到生成器中的数值
0
>>> next(a)
1
>>> next(a)
2

4、可迭代对象

• 可迭代对象：列表、元组、字典、集合、字符串、生成器

列表、字典、字符串不是迭代器

• iter() # 将可迭代对象转换为迭代器

from collections import Iterator	# 迭代器
from collections import Iterable	# 可迭代对象
ls = []
print(isinstance(ls,Iterator))
# False
res = (s for s in range(10))
print(isinstance(res,Iterable))
# True
a = iter(ls)		# 将可迭代对象转换为迭代器
print(type(a))
# <class 'list_iterator'>
print(isinstance(ls,Iterable))
# True

5、闭包

闭包能够读取其他函数内部变量的函数叫闭包

def outer():
    print("outer")
    a = 20

    def inner():
        print(a)
    return inner

ss = outer()
print(ss)   # ss == 函数inner
ss()
# 输出结果
# outer
# <function outer.<locals>.inner at 0x000001FA81BB8160>
# 20

闭包可以使局部变量全局化，但是变量不能释放，占据内存

6、装饰器

在不动原有代码的基础上，将新功能添加上去，就是python的装饰器

def record_log(fn):
    def inner():    # 如果被装饰的函数存在参数，则需要在装饰器函数的里面的函数进行传递
        print("开始记录日志")
        fn()o
        print("记录日志结束")
    return inner

@record_log
def login():
    print("xx登录了")

@record_log
def reg():
    print("xx注册了")

login()
reg()


# 开始记录日志
# xx登录了
# 记录日志结束
# 开始记录日志
# xx注册了
# 记录日志结束

7、动态语言的特性

python是一门

• 解释型语言(源代码不是直接翻译成机器语言，而是先翻译成中间代码，再由解释器对中间代码进行解释运行)、脚本语言
• 弱数据类型语言(JS、Python、Ruby)
• 动态语言(JS、Python、Ruby、PHP)

Python作为一种动态语言，具有一定的特性

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

Cui = CuiHua("翠花", 18)
print(Cui.name)
print(Cui.gender)             访问不存在的属性会报错
# 报错
Cui.gender = "男"        # Python可以动态在外界设置属性
print(Cui.gender)
# 男
setattr(Cui,"address","China")  # 使用setattr设置属性
print(Cui.address)
# China
print(getattr(Cui,"name"))      # 使用getattr获取属性
# 翠花
delattr(Cui, "name")            # 使用delattr删除属性
print(Cui.name)
# 报错