Python函数、生成器及二叉树

Python函数

函数

• 函数的定义

  • def 函数名(参数列表):
    	函数体(代码块)
    	[return 返回值]
    

  • 函数名就是标识符，命名要求一样

  • 语句块必须缩进，约定4个空格

  • Python的函数若没有return语句，会隐式返回一个None值

  • 定义中的参数列表被称为形式参数，只是一种符号表达（标识符），简称形参

• 函数调用

  • 函数定义，只是声明了一个函数，他不能被执行，需要调用执行

  • 调用的方式，就是函数名后加上小括号，如有必要在括号内写上参数

  • 调用时写的参数就是实际参数，是实实在在的传入的值，简称实参

  • def add(x, y):
    	result = x + y  # 函数体
    	return result   # 返回值
    	
    out = add(4, 5)  # 函数调用，可能有返回值，使用变量接收这个返回值
    print(out)  # print函数加上括号也是调用
    

  • 定义需要在调用前，也就是说调用时，已经被定义过了，否则抛NameError异常

  • 函数是可调用的对象，callable()

函数参数

• 函数在定义时要约定好形式参数，调用时也提供足够的实际参数，一般来说，形参和实参个数要一致(可变参数除外)

传参方式

• 位置传参
  • 定义时，def f(x, y, z), 调用使用f(1, 3, 5)，按照参数定义顺序传入实参
• 关键字参数
  • 定义时，def(x, y, z),调用使用f(x=1, y=3, z=5),使用形参的名字来传入实参的方式，如果使用了形参名字。那么传参顺序就可和定义顺序不同
• 要求位置参数必须在关键字参数之前，位置参数是按位置对应的

参数缺省值

缺省值也称为默认值，可以在函数定义时，为形参增加一个缺省值。其作用：

• 参数的默认值可以在未传入足够的实参的时候，对没有给定的参数赋值为默认值

• 参数非常多的时候，并不需要用户每次都输入所有的参数，简化函数调用

• def add(x=4, y=5):
  	return x+y
  	
  add(y=8, 4)  # 报错
  add(11, x=20)  # 报错
  

可变参数

• 可变位置参数
  • 在形参前使用*表示该形参是可变位置参数，可以接受多个实参
  • 它将收集来的实参组织到一个tuple中
• 可变关键字参数
  • 在形参前使用**表示该形参是可变关键字参数，可以接受多个关键字参数
  • 它将收集来的实参名称和值，组织到一个dict中
• 总结：
  • 有可变位置参数和可变关键字参数
  • 可变位置参数在形参前使用一个*
  • 可变关键字参数在形参前使用**
  • 可变位置参数和可变关键字参数都可以收集若干个实参，可变位置参数收集形成一个tuple，可变关键字参数收集形成一个dict
  • 混合使用参数的时候，普通参数需要放到参数列表前面，可变参数要放到参水列表后面，可变位置参数需要在可变关键字参数之前

keyword-only参数

• def fn(*args, x, y, **kwargs):
  	print(x, y, args, kwargs, sep='\n', end='\n\n')
  fn(3, 5)  # 错
  fn(3, 5, 7)  # 错
  fn(3, 5, a=1, b='abc')  # 错
  fn(3, 5, y=6, x=7, b='abc')  # 正确
  

• Python3之后，新增了keyword-only参数

• keyword-only参数，在形参定义时，在一个*之后，或一个可变位置参数之后，出现的普通参数，就已经不是普通的参数了，称为keyword-only参数

参数的混合使用

• # 可变位置参数、keyword-only参数、缺省值
  def fn(*args, x=5):
  	print(x)
  	print(args)
  fn()  # 等价于fn(x=5)
  fn(5)  # 返回一个5和一个元组(5,)
  fn(x=6)  # x=6
  fn(1,2,3,x=10)  # 返回（1，2，3）和10
  

参数规则

• 参数列表参数一般顺序是：普通参数、缺省参数、可变位置参数、keyword-only参数（可带缺省值）、可变关键字参数
  • 代码应该易读易懂，而不是为难别人
  • 请按照书写习惯定义函数参数

参数解构

• def add(x, y):
  	print(x, y)
  	return x + y
  add(4, 5)  # 9
  add((4, 5))  # 报错 少一个参数
  t = 4, 5  
  add(t[0], t[1])  # 9
  add(*t)  # 9
  add(*(4, 5))  # 9
  add(*[4, 5])  # 9
  add(*{4, 5})  # 9
  add(*range(4, 6))  # 9
  
  add(*{'a':10, 'b':11})  # 'ab'
  add(**{'a':10, 'b':11})  # 报错 
  add(**{'x':100, 'y':110})  # 210
  

  • 在给函数提供实参的时候，可以在可迭代对象前使用*或者**来进行结构的解构，提取出其中所有元素作为函数的实参

  • 使用*解构成位置传参

  • 使用**解构成关键字传参

  • 提取出来的元素数目要和参数的要求匹配

  • def add(*iterable):
    	result = 0
    	for x in iterable:
    		result += x
    	return result
    add(1, 2, 3)  # 6
    add(*[1, 3, 5])  # 9
    add(*range(5))  # 10
    

函数返回值

• # return语句之后可以执行吗
  def showplus(x):
  	print(x)
  	return x + 1
  	print('~~end~~')
  	
  showplus(5)  # 不会执行
  

• # 多条return语句都会执行吗
  def showplus(x):
  	print(x)
  	return x + 1
  	return x + 2
  	
  showplus(5)  # 不会执行
  

• # 下例多个return可以执行吗
  def guess(x):
  	if x > 3:
  		return '>3'
  	else:
  		return '<=3'
  print(guess(10))  # 只执行一条
  

• 总结：

  • Python函数使用return语句返回“返回值”
  • 所有函数都有返回值，如果没有return语句，隐式调用return None
  • return语句并不一定是函数的语句块的最后一条语句
  • 一个函数可以存在多个return语句，但是只有一条可以被执行。如果没有一条return语句被执行到，隐式调用return None
  • 如果必要，可以显示调用return None，可以简写为return
  • 如果函数执行了return语句，函数就会返回，当前被执行的return语句之后的其他语句就不会被执行了
  • 返回值的作用：结束函数调用，返回“返回值”

• # 返回了多个值吗？
  def f():
  	return 1, 3, 5
  f()  # (1, 3, 5)返回了一个元组
  

  • 函数不能同时返回多个值
  • return1，3，5看似返回多个值，实际上隐式的被Python封装成了一个元组

函数作用域

作用域

一个标识符的可见范围，这就是标识符的作用域。一般常说的是变量的作用域

• def foo():
  	x = 10
  print(x)
  -->报错
  

  • 上例中，x不可以被访问到。原因在于函数是一个封装，他会开辟一个作用域，x变量被限制在这个作用域中，所以在函数外部x变量不可见
  • 每一个函数都会开辟一个作用域

• 作用域分类

  • 全局作用域

    • 在整个程序运行环境中都可见
    • 全局作用域中的变量称为全局变量

  • 局部作用域

    • 在函数、类的内部可见

    • 局部作用域中的变量称为局部变量，其使用范围不能超过其所在的局部作用域

    • 也称本地作用域local

    • # 局部变量
      def fn1():
      	x = 1  # 局部作用域，x为局部变量，使用范围在fn1内
      def fn2():
      	print(x)  # x能被打印吗？不能
      print(x)  # x不能被打印
      

    • # 全局变量
      x = 5  # 全局变量，也在函数外定义
      def f00():
      	print(x)
      foo()  # 5
      

    • 一般来说，外部作用域变量可以在函数内部可见，可以是哦也使用

    • 反过来，函数内部的局部变量，不能在函数外部看到

• 函数嵌套

  • def outer():
    	def inner():
    		print('inner')
    	print('outer')
    	inner()
    outer()  # 可以
    inner()  # 不可以
    

    • 内部函数inner不能在外部直接使用，会抛异常，因为他在函数外部不可见
    • 其实，inner不过就是一个标识符，就是一个函数outer内部定义的变量而已

• 嵌套解构的作用域

  • def outer1():
    	o = 65
    	def inner():
    		print('inner{}'.format(o))
    		print(chr(o))
    		
    	inner()
    	print('outer{}'.format(o))
    outer1()
    --->inner 65
    	A
    	outer
    

  • def outer2():
    	0 = 65
    	def inner():
    		o = 97
    		print('inner{}'.format(o))
    		print(chr(o))
    	inner()
    	print('outer{}'.format(o))
    outer2()
    --->inner 97
    	a
    	outer 65
    

  • 从执行的结果来看，外层变量在内部作用域可见

  • 内部作用域inner中，如果定义了o=97，相当于在当前函数inner作用域中重新定义了一个i虚拟的变量o，但是，这个o并不能覆盖掉外部作用域outer2中的变量o。只不过对于inner函数来说，其只能可见子集作用域中定义的变量o了。

• 一个赋值语句的问题

  • # 这个例子为什么报错
    x = 5
    def foo():
    	x += 1
    	print(x)
    foo()
    

    • 只要有’x='出现，这就是赋值语句。相当于在foo内部定义一个局部变量x，那么foo内部所有x都是这个局部变量x了
    • x = x + 1相当于使用了局部变量x，但是这个x还没有完成赋值，就被右边拿来做加1操作了
    • 如何解决呢？

global语句

• x = 5
  def foo():
  	gloabal x  # 全局变量
  	x += 1
  	print(x)
  foo()
  

  • 使用global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x
  • 全局作用域中必须有x的定义

• 使用了global，foo中的x不再是局部变量了，它是全局变量

• 总结：

  • x += 1这种是特殊形式产生的错误的原因？先引用后赋值，而python动态语言是赋值才算定义，才能被引用。解决办法，在这条语句前增加x=0之类的赋值语句，或者使用global告诉内部作用域，去全局作用域查找变量定义
  • 内部作用域使用x = 10之类的赋值语句会重新定义局部作用域使用的变量x，但是，一旦这个作用域中使用global声明x为全局的，那么x=5相当于在为全局作用域的变量x赋值

• global使用原则

  • 外部作用域变量会在内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的就是为了封装，尽量与外界隔离
  • 如果函数需要使用外部全局变量，请尽量使用函数的形参定义，并在调用传实参解决
  • 一句话：不用global。学习它就是为了深入理解变量作用域

闭包

• **自由变量：**未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量

• **闭包：**就是一个概念，出现在嵌套函数中，值得是内层函数引用到了外层函数的自由变量，就形成了 闭包。很多语言都有这个概念，最熟悉的就是javascript

  • def counter():
    	c = [0]
    	def inc():
    		c[0] += 1
    		return c[0]
    	return inc
    	
    foo = counter()
    print(foo(), foo())
    c = 100
    print(foo())
    --->1 2
    	3
    

• def counter():
  	count = 0
  	def inc():
  		count += 1  # 
  		return ccount
  	return inc
  	
  foo = counter()
  print(foo(), foo())
  --->报错
  内层函数的count未声明就使用了，所以报错
  解决办法：将外层函数的count声明为全局变量，内层函数的count引用全局变量。例：
  def counter():
      global count  # 将count声明为全局变量
  	count = 0
  	def inc():
          global count
  		count += 1  # 声明count变量引用全局变量
  		return ccount
  	return inc
  	
  foo = counter()
  print(foo(), foo())
  --->1 2
  上例使用global解决，这是全局变量的实现，而不是闭包
  如过要对这个普通变量使用闭包，Python3中可以使用nonlocal关键字
  

• nonlocal语句

  • **nonlocal：**将变量标记为不在本地作用域定义，而是咋i上级的某一级局部作用域中定义，的那甭能是全局作用域中定义。

  • def counter():
    	count = 0
    	def inc():
    		nonlocal count  # 声明count不是本地变量
    		count += 1
    		return count
    	return inc
    	
    foo = counter()
    print(foo(), foo())
    --->1 2
    count是外层函数的局部变量，被内部函数引用
    内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义
    代码中内层函数引用外部局部作用域中的自由变量，形成闭包
    

  • a = 50
    def counter():
    	nonlocal a  # 上一级作用域是全局作用域，报错
    	a += 1
    	print(a)
    	count = 0
    	def inc():
    		nonlocal count
    		count += 1
    		return count
    	return inc
    	
    foo = counter()
    foo()
    foo()
    --->报错
    

默认值的作用域

• def foo(xyz=1):
  	print(xyz)
  foo()  # 1
  foo()  # 1
  print(xyz)  # xyz没定义，当前作用域没有xyz变量
  ------------------------------------------
  def foo(xyz=[]):
  	xyz.append(1)
  	print(xyz)
  foo()  # [1]
  foo()  # [1, 1]
  print(xyz)  # xyz没定义，当前作用域没有xyz变量
  ------------------------------------------
  分析：
      因为函数也是对象，每个函数定义被执行后，就生成了一个函数对象，和函数名这个标识符关联
      函数是对象，有属性。Python把函数的默认值放在了函数对象的属性中，这个属性就伴随着这个函数对象的整个生命周期
  

• 查看foo.__defaults__属性，它是个元组

  • def foo(xyz=[], m=123, n='abc'):
    	xzy.append(1)
    	print(xyz)
    	
    print(id(foo), foo.__defaults__)
    print(id(foo), foo.__defaults__)
    print(id(foo), foo.__defaults__)
    --->
    2216382810720 ([], 123, 'abc')
    2216382810720 ([], 123, 'abc')
    2216382810720 ([], 123, 'abc')
    函数地址并没有变，就是说foo这个函数的对象没有变过，调用它，它的属性__defaults__中使用元组保存默认值。xyz的默认值是引用类型，引用类型的元素变动，并不是元组的变化
    

  • # 非引用类型缺省值
    def foo(xyz, m=123, n='abc'):
    	m = 456
    	n = 'def'
    	print(xyz)
    print(foo.__defaults__)
    foo('magedu')
    print(foo.__defaults__)
    --->
    (123, 'abc')
    magedu
    (123, 'abc')
    属性__defaults__中使用元组保存所有位置参数默认值，它不会因为在函数体内改变了局部变量（形参）的值而发生改变
    

  • # keyword-only参数的缺省值
    def foo(xyz, m=123, *, n='abc', t=[1,2]):
    	m = 456
    	n = 'def'
    	t.append(300)
    	print(xyz, m, n, t)
    
    print(f00.__defaults__, foo.__kwdefaults__)
    foo('magedu')
    print(f00.__defaults__, foo.__kwdefaults__)
    --->
    (123,) {'n': 'abc', 't': [1, 2]}
    magedu 456 def [1, 2, 300]
    (123,) {'n': 'abc', 't': [1, 2, 300]}
    属性__defaults__中使用元组保存所有位置参数默认值
    属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值
    

  • def x(a=[]):
    	a += [5]
    	
    print(x.__defaults__)
    x()  # [5]
    x()  # [5，5]
    print(x.__defaults__)
    
    --------------------------------------------
    
    def y(a=[]):
    	a = a + [5]
    	
    print(y.__defaults__)
    y()  # [5]
    y()  # [5]
    print(y.__defaults__)
    
    

  • 总结：

    • +：表示两个列表合并并返回一个全新的列表
    • +=：表示，就地修改前一个列表，在其后追加一个列表，就是extend方法

变量名解析原则LEGB

• Local，本地作用域、局部作用域的local命名空间。函数调用时创建，调用结束消亡
• Enclosing，Python2.2时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间
• Global，全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡
• Build-in，内置模块的命名空间，生命周期从Python解释器启动时创建到解释器退出时消亡。例如print(open),print和open都是内置的变量
• 所以一个名词的查找顺序就是LEGB4

函数的销毁

• 定义一个函数就是生成一个函数对象，函数名指向的就是函数对象
• 可以使用del语句删除函数，使其引用计数减1
• 可以使用同名标识符覆盖原有定义，本质上也是使其引用计数减1
• Python程序结束时，所有对象销毁
• 函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0

匿名函数

Lambda表达式

• Python中，使用Lambda表达式构建匿名函数

  • lambda x:x ** 2  # 定义匿名函数
    (lambda x: x ** 2)(4)  # 调用
    
    foo = lambda x,y: (x+y) ** 2  # 定义函数
    foo(1, 2)
    等价于
    def foo(x,y):
    	return (x+y) ** 2
    

  • 使用lambda关键字定义匿名函数，格式为lambda[参数列表]：表达式

  • 参数列表不需要小括号。无参就不写参数

  • 冒号用来分割参数列表和表达式部分

  • 不需要使用return。表达式的值，就是匿名函数的返回值。表达式中不能出现等号

  • lambda表达式只能卸载一行上，也称单行函数

  • 匿名函数往往用在为高阶函数传参时，使用lambda表达式，往往能简化代码

• # 返回常量的函数
  print((lambda :0)())
  
  # 加法匿名函数，带缺省值
  print((lambda x, y=3:x + y )(5))  # 8
  print((lambda x, y=3:x + y)(5, 6))  # 11
  
  # keyword-only参数
  print((lambda x,*,y=30: x + y)(5))  # 35
  print((lambda x,*,y=30: x + y)(5, y = 10))  # 15
  
  # 可变参数
  print((lambda *args: (x for x in args))(*range(5)))  # 生成器对象不能立即返回值，需要next()或for循环驱动
  print((lambda *args: [x+1 for x in args])(*range(5)))  # [1, 2, 3, 4, 5]
  print((lambda *args: {x%2 for x in args})(*range(5)))  # {0, 1}
  
  # 高阶函数
  [x for x in (lambda *args: map(lambda x:x + 1, args))(*range(5))]  # [1, 2, 3, 4, 5]  
  [x for x in (lambda *args: map(lambda x: (x+1, args),args))(*range(5))]  #            [(1, (0, 1, 2, 3, 4)),
   (2, (0, 1, 2, 3, 4)),
   (3, (0, 1, 2, 3, 4)),
   (4, (0, 1, 2, 3, 4)),
   (5, (0, 1, 2, 3, 4))]
  
  

递归函数

• 函数直接或间接调用自身就是递归
• 递归需要偶遇边界条件、递归前进段、递归返回段
• 递归一定要有边界条件
• 当边界条件不满足时，递归前进
• 当边界条件满足的时候，递归返回
• 递归 Recursion

斐波那契数列

• # 循环实现
  a = 0
  b = 1
  n = 10
  
  for i in range(n -1):
  	a,b = b, a + b
  else:
  	print(b)
  

  # 递归实现
  f(0) = 0, f(1) = 1, f(n) = f(n-1)+f(n-2)
  
  def fib(n):
  	return 1 if n < 3 else fib(n-1) + fib(n-2)
  

• 递归要求

  • 递归一定要有推出条件，递归调用一定要执行到这个退出条件。没有推出条件的递归调用，就是无限调用
  • 递归调用的深度不宜过深
    • Python对递归调用的深度做了限制，以保护解释器
    • 超过递归深度限制，抛出RecursionError：maxinum recursion depth exceeded 超出最大深度
    • sys.getcursionlimit()

• 递归的性能

  • 循环稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果
  • fib函数代码极简易懂，但是只能获取到最外层的函数调用，内部递归结果都是中间结果。而且递归次数太多，深度越深，效率越低。为了获取斐波那契数列需要外面再套一个n次的循环，效率更低了
  • 递归还有深度限制，吐过递归复杂，函数反复压栈，栈内存很快就溢出了

• 斐波那契数列改进

  • def fib(n, a=0, b=1):
    	a,b = b, a + b
    	if n == 1:
    		return a 
    	return fib(n-1, a, b)
    	
    print(fir(5))
    

间接递归

• **间接递归：**是通过别的函数调用了函数自身

  • # 间接递归
    def foo1():
    	foo2()
    	
    def foo2():
    	foo1()
    
    foo1()
    要用规范的代码来避免这种间接递归调用的发生
    

• 递归总结：

  • 递归是一种很自然的表达，符合逻辑思维
  • 递归相对运行效率低，每一次调用函数都要开辟栈桢
  • 递归有深度限制，如果递归层次太深，函数反复压栈，栈内存很快就溢出了
  • 如果是有限次数的递归，可以使用递归调用，或者使用循环代替，循环代码稍微复杂一些，但是只要不是死循环，可以多次迭代直至算出结果
  • 绝大多数递归，都可以使用循环实现
  • 即使递归代码很简洁，但是能不用则不用递归

生成器

生成器genertor

• 生成器指的是生成器对象，可以由生成器表达式得到，也可以使用yield关键字编写一个生成器函数，调用这个函数得到一个生成器对象
• 生成器对象，是一个可迭代对象，是一个迭代器
• 生成器对象，是延迟计算，惰性求值的

生成器函数

• 函数体中包含yield语句的函数，就是生成器函数，调用后返回生成器对象

• m = (i for i in range(5))  # 生成器表达式
  print(type(m))  # generator
  print(next(m))  # 0
  print(next(m))  # 1
  
  
  def inc():  # 生成器函数
  	for i in range(5):
  		yield i
  		
  print(type(inc))  # function
  print(type(inc()))  # generator
  
  g = inc()
  print(type(g))  # function
  print(next(g))  # 0
  for x in g:
  	print(x)  # 1, 2, 3, 4
  print('----------------------------')
  for y in g:
  	print(y)  # None
  
  

  普通函数调用，函数会立即执行直到执行完毕

  生成器函数调用，并不会立即执行函数体，而是返回一个生成器对象，需要使用next函数来驱动这个生成器对象

  生成器表达式和生成器函数都可以得到生成器对象，只不过生成器函数可以写的更加复杂

  生成器函数的执行

  def gen():
  	print(1)
  	yield 2
  	print(3)
  	yield 4
  	print(5)
  	return 6
  	yield 7
  	
  next(gen())  # 打印1，返回2
  next(gen())  # 打印3，返回4
  g = gen()
  print(next(g))  # 
  print(next(g))  # 
  print(next(g))  # StopIteration
  print(next(g, 'End'))  # 没有元素给个缺省值
  

• 在生成器函数中，可以多次yield，每执行一次yield后会暂停执行，把yield表达式的值返回

• 再次执行会执行到下一个yield语句又会暂停执行

• return语句依然可以终止函数运行，但return语句的返回值不能被捕获到

• return会导致当前函数返回，无法继续执行，也无法继续获取下一个值，抛出StopIteration异常

• 如果函数没有显式的return语句，如果生成器函数执行到结尾（相当于return None），一样会抛出StopIteration异常

生成器函数

• 包含yield语句的生成器函数调用后，生成生成器对象的时候，生成器函数的函数体不会立即执行
• next(generator)会从函数的当前位置向后执行到之后碰到的第一个yield语句，会弹出值，并暂停函数执行
• 再次调用next函数，和上一条一样的处理过程
• 继续调用next函数，生成器函数如果执行了（显式或隐式调用了return语句），会抛出StopIteration异常

生成器应用

• 1. 无限循环

  • def counter():
    	i = 0
    	while True:
    		i += 1
    		yield i
    		
    c = counter()
    print(next(c))  # 1
    print(next(c))  # 2
    print(next(c))  # 3
    

• 2. 计数器

  • def inc():
    	def counter():
    		i = 0
    		while True:
    			i += 1
    			yield i
    			
    	c = counter()
    	return next(c)
    	
    print(inc())  # 1
    print(inc())  # 1
    print(inc())  # 1
    

    修改上例

  • def inc():
    	def counter():
    		i = 0
    		while True:
    			i += 1
    			yield i
    			
    	c = counter()
    	def inner():
    		return next(c)
    	return inner  # return lambda : next(c)
    	
    foo = inc()
    print(f00())  # 1
    print(foo())  # 2
    print(foo())  # 3
    

• 3. 斐波那契数列

  • def fir():
    	x = 0
    	y = 1
    	while True:
    		yield y
    		x, y = y, x + y
    		
    foo = fib()
    for i in range(101):
    	print(next(foo))
    

• 4. 生成器交互

  python提供了一个和生成器对象交互的方法send，该方法可以和生成器沟通

  # 重置功能的计数器
  def inc():
  	def counter()L:
  		i = 0
  		while True:
  			i += 1
  			response = yield i
  			if response is not None:
  				i = response 
  				
  	c = counter()
  	return lambda x=False : next(c) if not x else c.send(0)
  
  foo = inc()
  print(foo())
  print(foo())
  print(foo())
  print(foo(True))
  print(foo())
  print(foo())
  print(foo())
  

• 调用send方法，就可以把send的实参传给yield语句做结果，这个结果可以在灯饰右边被赋值给其他变量

• send和next一样可以推动生成器启动并执行

• 5. 携程Coroutine

  • 生成器的高级用法
  • 它比进程、线程轻量级，是在用户空间调度函数的一种实现
  • Python3 asyncio就是协程实现，已经加入到标准库
  • Python 3.5 使用async、await关键字直接原生支持携程
  • 协程调度器实现思路
    • 有2个生成器A、B执行到了yield语句暂停，然后取执行next（B），B执行到yield语句也暂停，然后再次调用next(A),再调用next(B),周而复始，就实现了调度的效果
    • 可以引入调度的策略来实现切换的方式
  • 协程是一种非抢占式调度

yield form语法

从Python 3.3开始增加了yield from语法，使得yield from iterable等价于 for item in iterable : yield item

yield from是一种简化语法的语法糖

def inc():
	for x in range(1000):
		yield x
# 使用yield from简化
def inc():
	yield from range(1000)

foo = inc()
print(next(foo))  # 0
print(next(foo))  # 1
print(next(foo))  # 2

本质上yield from的意思就是，从from后面的可迭代对象中拿出元素一个个yield出去

树（第一部分）

• 非线性结构
• 树是n(n >= 0)个元素的集合
  • n = 0时，称为空树
  • 树只有一个特殊的没有前驱的元素，称为树的根Root
  • 树中除了根节点外，其余元素只能有一个前驱，可以有零个或多个后继
• 递归定义
  • 树T是n(n>=0)个元素的集合。n=0时，称为空树
  • 有且只有一个特殊元素根，剩余元素都可以被划分为m个互不相交的集合T1、T2、T3、。。。、Tm，而每一个集合都是树，称为T的子树Subtree
  • 子树也有自己的根
• 树的概念
  • 结点：树中的数据元素
  • 结点的度degree：结点拥有的子树的数目称为度，记作d(v).
  • 叶子结点：结点的度为0，称为叶子结点leaf、终端结点、末端节点
  • 分支结点：结点的度不为0，称为非终端结点或分支结点
  • 分支：结点之间的关系
  • 内部结点：除根结点外的分支结点，当然也不包括叶子结点
  • 树的度是树内各节点的度的最大值。D结点度最大为3，树的度数就是3
  • 孩子结点：结点的子树的根节点称为该结点的子结点
  • 双亲结点：一个结点是它各子树的根结点的双亲
  • 兄弟结点：具有相同双亲结点的结点
  • 祖先结点：从根结点到该结点所经分支上所有的结点。
  • 子孙结点：结点的所有子树上的结点都称为该节点的子孙。
  • 结点的层次：根结点为第一层，根的孩子结点为第二层，以此类推，记作L(v)
  • 树的深度(高度depth)：树的层次的最大值。
  • 堂兄弟：双亲在同一层的结点
  • 有序树：结点的子树是有序的（兄弟有大小，有先后次序），不能交换
  • 无序树：结点的子树是无序的，可以交换
  • 路径：树中的k个结点n1、n2、… nk，满足ni是n(i+1)的双亲，称为n1到nk的一条路径。就是一条线串下来的，前一个都是后一个的父(前驱)结点
  • 路径长度=路径上的结点数 - 1，也就是分支数
  • 森林：m(m>=0)颗不相交的树的集合
    • 对于结点而言，其子树的集合就是森林。A结点的2棵子树的集合就是森林
  • 树的特点
    • 唯一的根
    • 子树不相交
    • 除了根以为，每个元素只能有一个前驱，可以有零个或多个后继
    • 根节点没有双亲结点（前驱），叶子结点没有孩子结点（后继）
    • vi是vj的双亲，则L(vi) = L(vj) - 1,也就是说双亲比孩子结点的层次小1
  • 堂兄弟的双亲是兄弟关系吗？
    • 不一定
• 二叉树
  • 每个结点最多2颗子树
    • 二叉树不存在度数大于2的结点
  • 它是有序树，左子树、右子树是顺序的，不饿能交换次序
  • 即使某个结点只有一个子树，也要确定它是左子树还是右子树
  • 二叉树的五种基本形态
    • 空二叉树
    • 只有一个根节点
    • 根节点只有左子树
    • 根节点只有右子树
    • 根节点有左子树和右子树
• 斜树
  • 左斜树，所有节点都只有左子树
  • 右斜树，所有结点都只有右子树
• 满二叉树
  • 一颗二叉树的所有分支结点都存在左子树和右子树，并且所有叶子节点只存在最下面一层
  • 同样深度二叉树中，满二叉树结点最多
  • k为深度(1<=k<=n),则结点总数为2^k - 1
• 完全二叉树
  • 若二叉树的深度为k，二叉树的层数从1到k-1层的结点树都达到了最大个数，在第k层的所有节点都集中在最左边，这就是完全二叉树
  • 完全二叉树由满二叉树引出
  • 满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树
  • k为深度(1<=k<=n),则结点总数最大值为2^k-1，当达到最大的是后就是满二叉树
• 二叉树的i性质
  • 性质1
    • 在二叉树的第i层上至多有2^(i -1)个结点(i>=1)
  • 性质2
    • 深度为k的二叉树，至多有2^k-1个结点(k>=1)
    • 一层 2-1 =1
    • 二层 4 -1 = 1 + 2 = 3
    • 三层 8 -1 = 1 = 1+ 2 + 4 = 7
  • 性质3
    • 对任何一个二叉树T，如果其终端结点树为n0，度数为2的结点为n2，则有n0 = n2 + 1
    • 换句话说，就是叶子节点数 - 1就等于度数为2的结点数
    • 证明
      • 总结点数为n=n0 + n1 + n2,n1为度数为1的结点总数
      • 一棵树的分支数为n-1，因为除了根节点外，其余结点都有一个分支，即n0+n1 + n2 -1
      • 分支数还等于n0 * 0 + n1 * 1 + n2 * 2，n2是2分支结点所以乘以2，2*n2 + n1
      • 可得 2*n2 + n1 = n0 + n1 + n2 -1 => n2 = n0 - 1
  • 其他性质
    • 高度为k的二叉树，至少有k个结点
    • 含有n(n>=1)的结点的二叉树高度至多为n，和上句一个意思
    • 含有n(n>=1)的结点的二叉树的高度至多为n，最小为math.ceil(log2 (n + 1)),不小于对数值的最小整数，向上取整
      • 假设高度为h，2^h-1 = n => h = log 2 (n + 1),层次数就是取整
      • 如果是8个结点，3.1699就要向上取整为4，为4层
  • 性质4
    • 就有n个结点的完全二叉树的深度为int(log 2 n) + 1或者 math.ceil(log 2 (n + 1))
  • 性质5
    • 如果有一个n个结点的完全二叉树(深度为性质4)，结点按照层序编号
    • 如果i= 1，则结点i是二叉树的根，无双亲；如果i>1,则其双亲是int(i/2),向下取整。就是子结点的编号整除2得到的就是父节点的编号。父节点如果是i，那么左孩子结点就是2i，右孩子结点就是2i+1
    • 如果2i>n,则结点i无左孩子，即结点i为叶子节点；否则其左孩子结点存在编号为2i。
    • 如果2i + 1> n，则结点i无右孩子，注意这里并不能说明结点i没有左孩子；否则右孩子结点存在编号为2i + 1.

高阶函数

• 函数在Python是一等公民(First-Class Object)
• 函数也是对象，是可调用对象
• 函数可以作为普通变量，也可以作为函数的参数，返回值

高阶函数

高阶函数(High-order Function)

• 数学概念 y = f(g(x))

• 在数学和计算机科学中，高阶函数应当是至少满足下面一个条件的函数

  • 接受一个或多个函数作为参数
  • 输出一个函数

• def counter(base):
  	def inc(step=1):
  		base += step  # base没定义
  		return base
  	return inc
  	
  

练习：自定义sort函数

def sort(iterable, *, key=None, reverse=False):
	newlist = []
	for x in iterable:
		
		for i, y in enumerate(newlist):
			if x > y:  # y立即插入，说明y小，被挤向右边
				newlist.insert(i, x)
				break
		else:  # 不大于，说明是最小的，尾部追加
			newlist.append(x)
	return newlist
		

• x > y或 x < y 能控制什么

  • 可以控制是升还是降序

• 进一步实现reverse参数

  • def sort(iterable, *, key=Non, reverse=False):
    	newlist =[]
    	for x in iterable:
    		for i,y in enumerate(newlist):
    			comp = x > y if reverse else x < y  # 实现reverse参数
    			if comp:  # x > y立即插入，说明y小，被挤向右边
    				newlist.insert(i, x)
    				break
    		else:  # 不大于，说明是最小的，尾部追加
    			newlist.append(x)
    	return newlist
    

  进一步实现key参数功能

  def sort(iterable, *,key=None, reverse=False):
  	newlist = []
  	for x in iterable:
  		cx = key(x) if key else x
  		for i,y in enumerate(newlist):
  			cy = key(y) if reverse else cx < cy # 实现reverse参数
  			if comp: # x > y立即插入，说明y小，被挤向右边
  				newlist.insert(i, x)
  				break
  		else: # 不大于，说明是最小的，尾部追加
  			newlist.append(x)
  	return newlist
  

内建高阶函数

排序sorted

定义sorted(iterable, *, key=None, reverse=False) -> list

sorted(list, key=lambda x:6-x)  # 返回新列表
list.sort(key=lambda x: 6-x)  # 就地修改

过滤filter

• 定义filter(function, iterable)

• 对可迭代对象进行遍历，返回一个迭代器

• function参数是一个参数的函数，且返回值应当是bool类型，或其返回值等效布尔值

• function参数如果是None，可迭代对象的每一个元素自身等效布尔值

• list(filter(lambda x:x%3==0, [1,9,55,150,-3,78, 28, 123]))  # [9, 150, -3, 78, 123]
  list(filter(None, range(5)))  # [1, 2, 3, 4]
  list(filter(None, range(-5, 5)))  # [-5, -4, -3, -2, -1, 1, 2, 3, 4]
  

映射map

• 定义map(function, *iterable) -> map object

• 对多个可迭代对象的元素， 按照指定的函数进行映射

• 返回一个迭代器

• list(map(lambda x: 2*x+1, range(10)))  # [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
  dict(map(lambda x: (x%5, x), range(500)))  # {0: 495, 1: 496, 2: 497, 3: 498, 4: 499}
  dict(map(lambda x,y: (x,y), 'abcde', range(10)))  # {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
  

柯里化

• 指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数为参数的函数

• z = f(x, y)转化成z = f(x)(y)的形式

• def add(x, y):
  	return x + y
  

  原来函数调用为add(4, 5),柯里化目标是add(4)(5),如何实现？

  每一次括号说明是函数调用，说明add(4)(5)是2次函数调用

  add(4)(5)
  等价于
  t = add(4)
  t(5)
  

  也就是说add(4)应该返回函数

  def add(x):
  	def _add(y):
  		return x + y
  	return _add
  	
  add(100, 200)
  

  通过函数嵌套可以把函数转化成柯里化函数