表达式的建立
表达式在继续执行TNUMBERV12V4展开初始化
HTA
边线std：依照实参相关联的边线展开std传达
表达式的回到值
在软件开发中，有时，会期望 两个表达式继续执行完结后，说分配器两个结论，以期分配器特别针对具体内容的结论做先期的处置回到值是表达式顺利完成组织工作后，最终给分配器的两个结论在表达式中采用 return URL能回到结论，除非回到，表达式中止初始化表达式另一方，能采用表达式来转交表达式的回到结论表达式回到数个值时，结论为位元def add (a, b): return a + b ret1 = add(1, 2) ret2 = add(“hello”, “world”) print(“ret1 =”, ret1) print(“ret2 =”, ret2)回到值回到值是在表达式外部表述的表达式，根本无法在表达式外部采用表达式继续执行完结后，表达式外部的回到值，会被控制系统拆解相同的表达式，能表述完全相同的英文名字的回到值，但彼此间不能造成负面影响def f1(): num = 10 print(“表达式1中的num =”, num) num = 20 print(“表达式1中的num发生改变后 =”, num) def f2(): num = 30 print(“表达式2中num =”, num) f1() f2()回到值的开发周期简而言之开发周期是表达式从被建立被控制系统拆解的过程回到值表达式继续执行时才会被建立表达式继续执行完结后回到值被控制系统拆解全局表达式全局表达式是在表达式外部表述的表达式，所有表达式外部都能采用这个表达式
num = 10 def f1(): print(“表达式1中num =”, num) def f2(): print(“表达式2中num =”, num) f1() f2()
注意：表达式继续执行时，需要处置表达式时会：
首先查找表达式外部是否存在指定中文名称的回到值，如果有，直接采用。如果没有，查找表达式外部是否存在指定中文名称的全局表达式，如果有，直接采用。如果还没有，程序报错！表达式不能直接修改全局表达式的引用。在表达式外部修改全局表达式的值：如果在表达式中需要修改全局表达式，需要采用 global 展开声明
num = 10 def f1(): global num num = 20 print(“表达式1中num =”, num) def f2(): global num num = 30 print(“表达式2中num =”, num)num = 10 def f1(): num += 20 print(“表达式1中num =”, num) def f2(): num += 30 print(“表达式2中num =”, num) f1() f2()缺省参数
表述表达式时，能给某个参数指定两个默认值，具有默认值的参数就叫做 缺省参数。初始化表达式时，如果没有传入缺省参数的值，则在表达式外部采用表述表达式时指定的参数默认值。表达式的缺省参数，将常见的值设置为参数的缺省值，从而简化表达式的初始化。def f(m, n, k=1): return (m+n) * k print(f(1, 2)) print(f(1, 2, 3))多值参数采用*表述个数可变的边线实参，结论为两个位元def f1(*args): for i in args: print(i) f1(1, 2, 3)采用**表述个数可变的URL实参，结论为两个字典def f(**kwargs): print(kwargs) f(a=1, b=2, name=”xz”) 结论： {a: 1, b: 2, name: xz}递归算法递归表达式：如果在两个表达式的函数体内初始化了该表达式本身，这个表达式就称为递归表达式。递归的初始化过程每递归初始化一次表达式，都会在栈缓存分配两个栈帧每继续执行完一次表达式，都会释放相应的空间递归的优缺点缺点：占用缓存多，效率低下优点：思路和标识符简单
总结
表达式进阶：表达式的嵌套def f1(): print(“我在f1表达式中”) def f2(): print(“我在f2表达式中”) f1() f2()def wrapper(): print(“我在外层”) def inner(): print(“我在内层”) print(“内层表达式完结”) inner() print(“外层表达式完结”) wrapper()def wrapper(): print(“我在外层”) num = 1 def inner(): nonlocal num num += 1 print(“我在内层”) print(“内层表达式初始化时num =”, num) print(“内层表达式完结\n”) print(“内层表达式初始化之前num =”, num) inner() print(“外层表达式完结”) wrapper()表达式名的本质
表达式名的本质是两个指针def f1(): print(“hello”) print(f1) 结论：表达式名赋值
def f1(): print(“hello”) print(f1) f2 = f1 f3 = f2 f3()
高阶表达式：两个表达式能作为参数传给另外两个表达式，或者两个表达式的回到值为另外两个表达式（满足其一则为高阶表达式。def f1(): print(我在f1中) def f2(): print(我在f2中) def f3(f): f() def f4(f): print(我是f4) return f f3(f1) f3(f2) ret_func = f4(f2) ret_func()表达式闭包闭包作用，保证数据安全内层表达式对外层表达式非全局表达式的引用就会形成闭包被引用的非全局表达式也称自由表达式，这个自由表达式会与内层表达式造成两个绑定关系自由表达式不能在缓存中消失def wrapper(): print(我在外层) def inner(): print(我在内层) print(内层表达式完结) inner() print(外层表达式完结) wrapper()def wrapper(): print(我在外层) num = 1 def inner(): nonlocal num num += 1 print(我在内层) print(内层表达式初始化时：num =, num) print(内层表达式完结) print(内层表达式初始化之前：num =, num) inner() print(内层表达式初始化之后：num =, num) print(外层表达式完结) wrapper()例：求比特币的平均收盘价，6000美元、7000美元、8000美元、9000美元、10000美元……
li = [] def average(value): li.append(value) return sum(li) / len(li) print(average(6000)) print(average(7000)) print(average(8000))def average(): li = [] def inner(value): li.append(value) return sum(li) / len(li) return inner avg = average() print(avg(6000)) print(avg(7000)) print(avg(8000))装饰器简述
装饰器，是装修、装饰的意思，但，不发生改变原有的程序机能。比如，我装修两个房子，如果不隔音，我在墙上加一层隔音板，却不能把墙拆了，换成隔音材质。
而程序中也是一样，不能对原来的表达式造成发生改变，还要增添新的机能，初始化表达式时的接口没有变化。
比如，我们要在表达式的基础上，增加两个程序效率检测机能，也是记录表达式继续执行的时间。
方案1
import time def index(): time.sleep(2) start_time = time.time() index() end_time = time.time() print(程序运行%.3f秒 % (end_time – start_time))
方案2
import time def index(): time.sleep(2) def calc_time(): start_time = time.time() index() end_time = time.time() print(程序运行%.3f秒 % (end_time – start_time)) calc_time()
方案3
import time def index(): time.sleep(2) def calc_time(f): start_time = time.time() f() end_time = time.time() print(程序运行%.3f秒 % (end_time – start_time)) calc_time(index)语法糖import time def index(): time.sleep(2) def calc_time(f): def inner(): start_time = time.time() f() end_time = time.time() print(程序运行%.3f秒 % (end_time – start_time)) return inner # index = calc_time(index) # index() # 语法糖 @calc_time def f(): time.sleep(1.2) f() # f = calc_time(f) # f()带回到值的装饰器import time def calc_time(f): def inner(): start_time = time.time() ret = f() end_time = time.time() print(程序运行%.3f秒 % (end_time – start_time)) return ret return inner @calc_time def index(): time.sleep(2) return index print(index())带参数的装饰器import time def calc_time(f): def inner(*args, **kwargs): start_time = time.time() ret = f(*args, **kwargs) end_time = time.time() print(程序运行%.3f秒 % (end_time – start_time)) return ret return inner @calc_time def add(a, b, c): time.sleep(2) return a + b + c print(add(1, 2, 3))生成器：表达式生成器def f(): a = 1 yield a b = 2 yield b c = 3 yield c print(f()) g = f() print(g.__next__()) print(g.__next__()) print(next(g)) # print(next(g))def get_data(): for i in range(1, 10000): yield i d = get_data() for i in range(1, 10): print(next(d), end= ) print() for i in range(30, 40): print(next(d), end= )
send方法
send和next都能让生成器相关联, a) b = yield a print(b =, b) c = yield b ret = f() print(next(ret)) print(ret.send(hahaha)) print(ret.send(xxx))生成器表达式列表推导式比较耗缓存,所有数据一次性加载到缓存。而生成器表达式遵循迭代器协议，逐个造成元素g_li = (i for i in range(10)) print(g_li) for i in g_li: print(i)匿名表达式语法： 表达式名 = lambda 参数: 回到值匿名表达式并不是没有英文名字，表达式的英文名字是设置的表达式匿名表达式只有一行，逻辑完结后直接回到数据f1 = lambda m, n : m + n print(f1(1, 2)) f2 = lambda m, n : m if m > n else n print(f2(6, 9))内置表达式：zip()方法将可迭代的对象作为参数，将对象中相关联的元素打包成两个个位元，然后回到由这些位元组成的对象节约缓存能采用 list() 转换来输出列表如果各个迭代器的元素个数不一致，则回到列表长度与最短的对象完全相同，利用号操作符，能将位元解压为列表a = [1, 2] b = [4, 5, 6] c = [7, 8, 9, 10] z = zip(a, b, c) print(z) print(list(z)) m, n, k = zip(*zip(a, b, c)) print(m, n, k)filter()方法用于过滤序列，过滤掉不符合条件的元素，回到两个迭代器对象，如果要转换为列表，能采用 list() 来转换该转交两个参数，第两个为表达式，第二个为序列，序列的每个元素作为HTA给表达式展开判，然后回到 True 或 False，最终将回到 True 的元素放到新列表中def is_odd(x): return x % 2 print(list(filter(is_odd, list(range(10)))))map()方法会依照提供的表达式对指定序列做映射第两个参数 function 以参数序列中的每两个元素初始化 function 表达式，回到包含每次 function 表达式回到值的新列表def square(x): return x ** 2 print(map(square, [1, 2, 3, 4, 5])) print(list(map(square, [1, 2, 3, 4, 5]))) print(list(map(lambda x: x**2, [1, 2, 3, 4, 5]))) print(list(map(lambda m, n: m+n, [1, 2, 3, 4, 5], [6, 7, 8, 9, 10])))reduce()方法对参数序列中元素进行累积操作表达式将两个数据集合（链表，位元等）中的所有数据展开下列操作：用传给 reduce 中的表达式 function（有两个参数）先对集合中的第 1、2 个元素展开操作，得到的结论再与第三个数据用 function 表达式运算，最终得到两个结论from functools import reduce print(reduce(lambda m, n : m + n, list(range(1, 6))))人生苦短，我用Python，初学者最友好的编程语言该文简述Python常用数据类型，列表、字典、位元和集合该文简述Python语言选择结构和循环结构Python语言print语句和表达式采用什么是Linux控制系统？我们是否要用Linux学习Linux命令行，用手就行！该文简述Linux操作控制系统进程管理Linux革命性工具，shell脚本表达式编程Linux Shell正则表达式，高效操作字符串
