函数-高级用法+闭包

   函数：增加代码可读性和重用性
   定义函数（3种形式）：

1. def funk()    def funk(a,b)    def funk(*args,**kwargs)

复制代码

   调用函数（高级用法）:
           1.函数做元素：
2种形式

1. def funk1 ():
2.     print(888)
3. def funk2():
4.     print(222)
5. content = [funk1(),funk2()] #将funk函数运行后的结果放到列表中，无return默认返回None
6. print(content)>>>[None, None]
8. def funk1 ():
9.     print(888)
10. def funk2():
11.     print(222)
12. content = [funk1,funk2] #将函数（地址）放到列表中
13. print(content)>>>[<function funk1 at 0x0000017D5ADA4168>, <function funk2 at 0x0000017D5ADA41F8>]

复制代码

          2.可被赋值给变量：
示例

1. def greet(name):
2.     return f"Hello, {name}!"
4. # 将函数 greet 赋值给变量 say_hello
5. say_hello = greet
7. # 通过变量 say_hello 调用函数
8. print(say_hello("Alice"))  # 输出: Hello, Alice!

复制代码

          3.函数可作参数：

1. def funk1 (a):
2.     a()
3. def funk2():
4.     print(222)
5. print(funk1(funk2))
6. >>>222
7. >>>None

复制代码

          4.函数可作返回值：
  闭包：
形成条件：一个函数（外部函数）里面含有另外一个函数（内部函数）且外部函数返回内部函数，而且内部函数使用了外部函数被调用时创建的局部作用域中的变量，则当外部函数被调用时（a = funk1())内部函数被返回到a上，内部函数随时可以a()进行调用，则外部函数调用时创建的局部作用域不会被消除，因此形成了闭包且此局部作用域为内部函数的父级作用域
为什么有闭包：为函数创建一块区域以后执行时方便调用

1. #无闭包情况
2. a = "guohan"
3. def funk1 ():
4.     a = "gh"
5.     print(a)
6.     return funk2
7. def funk2():
8.     print(a)
9. b = funk1()
10. b()
11. >>>gh
12. >>>guohan

复制代码

1. #有闭包情况1
2. a = "guohan"
3. def funk1 ():
4.     a = "gh"
5.     print(a)
6.     def funk2():
7.         print(a)
8.     return funk2
9. b = funk1()
10. b()
11. >>>gh
12. >>>gh
13. #有闭包情况2
14. a = "guohan"
15. def funk1 ():
16.     a = "gh"
17.     print(a)
18.     def funk2():
19.         global a #声明这里funk2函数使用全局变量a
20.         a = "gg"
21.         print(a)
22.     return funk2
23. b = funk1()
24. b()
25. >>>gh
26. >>>gg

复制代码

   简单函数lambda表达式：    lambda  参数：表达式      表达式：有返回值无赋值语句的代码（x+=1:赋值语句）
        eg：v = lambda x: x+1 if x>100 else x
        eg：v = lambda x:x>44    print(v(2))>>>False
   内置函数（初级）：
        输入输出：print，input
        强制转换：int，str，float，bool，list，dict，tuple，set
        数学相关：
max ，min ，sum    eg：
 

1. v = [1,2,3]
2. result = max(v)或者result = sum(v)
3. print(result)

复制代码

abs:求绝对值
round：保留小数（四舍五入）  round（1.237，2）>>>1.24
pow：求指数  pow（2，3）>>>8
divmod:求商和余数(用于网页对数据进行分页查看）    a,b = divmod(101,5)>>>a = 20  b = 1
数据分页查看

1. USER_LIST = [...........]
2. page_content = 7 #每页数据数
3. A,B = divmod(len(USER_LIST),page_content)
4. A = A+1 if B>0 else A #A为总页数
5. def page(a):
6.     if a in range(1,A+1):
7.         for item in USER_LIST[page_content*(a-1):page_content*a]:
8.             print(item)
9.     else:
10.         return "无页码"
11. get = int(input("页码："))
12. page(get)

复制代码

        进制转换相关：
          十进制转2（0b开头），8（0o），16（0x）：bin，oct，hex
          2，8，16转十进制：int（str，base = str表达的是几进制）  eg：result = int("1010",base = 2)
        其他：len，type，id
   内置函数（高级）：
        map：遍历序列，对序列中每个元素进行操作，最终获取新的序列。

         用法：map = (函数，可迭代对象）      最终得到一个包含所有结果的迭代器需要用list()/tuple()等转换为可见结构

1. #单个可迭代对象
2. v = [1,2,3]
3. result = list(map(lambda x:x + 100,v))
4. print(result)

复制代码

1. #多个可迭代对象（函数参数的数量得正确）
2. v1 = [1,2,3]
3. v2 = [4,5,6]
4. result = list(map(lambda x,y:x + y,v1,v2))
5. print(result)
6. >>>[5, 7, 9]

复制代码

        filter：对于序列中的元素进行筛选，最终获取符合条件的序列

 
        用法：filter = (判断函数（判断函数只能接收一个参数，判断返回Ture则保留），可迭代对象）  filter只能接收2个参数（函数，1个可迭代对象）      最终得到一个包含所有结果的迭代器需要用list()/tuple()等转换为可见结构

1. v = [1,2,3,21,22,34,54,63,234]
2. result = list(filter(lambda x:x>9,v))
3. print(result)
4. >>>[21, 22, 34, 54, 63, 234]

复制代码

        reduce：对于序列内所有元素进行累计操作          reduce      py3中不在内置函数中，在模块functools内，使用时前导入import functools模块   

        用法：import functools  reduce（函数（接收2个参数），可迭代对象）  第一次迭代函数接收2个参数（2个迭代对象），后面迭代时，上一次迭代函数的返回值作这次迭代时函数的第一个参数，第二个参数为迭代对象                  最终得到一个值，无需进行强制转换

1. import functools
2. v = ["guo","h","an"]
3. result = functools.reduce(lambda x,y:x+y,v)
4. print(result)
5. >>>guohan

复制代码

 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！