函数

• 说明

• 调用方式

• 多个返回值

• 比较PythonIC写法

• 拆包

嵌套函数拆包

def fun01(*args,**kwargs):
    print(args)
    print(kwargs)
fun01(1,23,4,5,6,age=19,name='yy')

	>>
(1, 23, 4, 5, 6)
{'age': 19, 'name': 'yy'}


嵌套函数中
def fun02(*args,**kwargs):
    print(args)
    print(kwargs)   
    fun01(args,kwargs)
    print(args)
    print(kwargs)

fun02(1,23,4,5,6,age=19,name='yy')

>>>
(1, 23, 4, 5, 6)
{'age': 19, 'name': 'yy'}
((1, 23, 4, 5, 6), {'age': 19, 'name': 'yy'})
{}
(1, 23, 4, 5, 6)
{'age': 19, 'name': 'yy'}

• 变化的值

• 变量

• 引用

• 递归函数

• 匿名函数

• 列表推导式

1
#一个列表保存一百个数字
list = []
for i in range(1,101):
    list.append(i)
print(list)

#推导式：[ 变量名 循环体]
list = [i for i in range(1,101)]
print(list)

2
#一个显示十个值的哈哈
list = []
#只是循环次数，不用变量，用占位符
for _ in range(10):
    list.append('哈哈')
print(list)
#优化
list = ['哈哈' for _ in range(10)]
print(list）

3
#保存1-100偶数
list = []
for i in range(1,101):
    #判断偶数
    if i%2 == 0:
        list.append(i)
print(list)
#优化
list = [i for i in range(1,101) if i%2==0]
print(list)

4
#一个列表保存[(0,1),(0,1),(0,1),
#               (1, 1),(1,1),(1,1) ]

list = []
for i in range(2):
    for j in range(3):
        #构造元组
         touple = (i,j)
         list.append(touple)
print(list)

#优化
list = [(i,j) for i in range(2) for j in range(3)]
print(list)

5 
#构造函数，   第一部分写出需要显示的，后面写条件
my_list = [val for val in range(5) if val % 2 == 0]
print(my_list)

a = [x for x in range(100)]
b = [a[y:y+3] for y in range(0,len(a),3)]
print(b)

• help

help(obj) 显示对象的帮助信息

• 装饰器 decorator

• 闭包
  
• 定义
  
  
  
• 装饰有返回值的函数
  原函数有返回值，在login=func_out(login) 的理解上，对于有返回值的函数，
  如果还在原来的框架上，login最后指向执行内层函数，由于内层函数没有返回值，最后得到的只是none
  改变就是在内层函数中设置返回值，接受原函数的返回值。

• 装饰有参数的函数

def func_out(func):
    def func_in(*args,**kwargs):
        return func(*args,**kwargs)

    return func_in


@func_out
def login(*args,**kwargs):
    print(args)
    print(kwargs)

# login = func_out(login)
# login()  ==> func_in()
# func ==> 原始的login

login(10,20,30,age = "123",name = "456")

• 装饰器参数
  如实例，设置参数的主动权在调用者，假如要把主动权拿回来，在设置装饰器的时候就给了参数，就引入了装饰器参数

def func_out(func):
	def func_in(data):
		print(data)
		func()
	return func_in

@func_out
def main():
	print('xxxxxxxxx')

main('10')
>>  10   xxxxxxxxxx

-- 给装饰器参数

def route(data):
    def func_out(func):
	def func_in():
	    print(data)
	    func()
	return func_in
     return func_out
// 三层函数嵌套


@route('10')
def main():
    print('xxxxxxxxx')

@route('10')  
    1先调用route函数，只是传参 data=10
    2 返回func_out  执行@func_out
    3 main = func_out(main)	
这样就将参数由装饰器传入了

main() 
>>>  10   xxxxxxxxxx

• 类装饰器

在@Foo默认运行login=Foo(login)的时候，完成了实例化。login作为参数传入

迭代器 iterator

表面上是一个数据流对象或者容器，当使用其中的数据的时候，每次从数据流中取一个数据，直至取完，而且数据并不会被重复使用

迭代器解决数据类型（存放数据的容器）和函数耦合的问题

迭代器协议方法
任何一个类，只要实现了或具有着两个方法，都可以成为迭代器

• _iter_
  方法返回对象本身，是for语句使用迭代器的要求
• _next_
  用于返回容器中下一个元素或数据，当容器中的数据用尽时，返回一个StopIteration异常

生成器 yield

• 备注

1. 函数内嵌套函数时，当内层函数要使用外层变量，不是global 要使用nonlocal 设定外层变量
2. import 模块。
   相当于调用的是某块的一个引用，此时如果引用体内要改变模块中的公共变量，其他文件要继续引用这个模块的话就是引用的更改过后的公共变量。
   from 模块 import *
   相当于把模块中的内容直接都拷贝到了当前文件中，此时更改公共变量的话，只是更改的当前的，源模块不收影响，其他文件要引用这个模块，还是没有更改前的变量。

匿名函数lambda