01python中的函数与函数式编程(python函数)

Posted pontoon

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了01python中的函数与函数式编程(python函数)相关的知识,希望对你有一定的参考价值。

技术分享图片

一、函数的定义与调用

 
 
 
11
 
 
1
def lenght(s):
2
    l = 0
3
    for i in s:            # 关于for 循环的基本用法是时候做一波总结了
4
        l = l + 1
5
    return l
6

7

8
a = ‘ssssssss‘
9
print(lenght(a))
10

11
>>> 8
 
 

# 1 函数的返回值

1)return关键字的作用

  return 是一个关键字,这个词翻译过来就是“返回”,所以我们管写在return后面的值叫“返回值”,要研究返回值,我们还要知道返回值有几种情况:分别是没有返回值、返回一个值、返回多个值

2)没有返回值

  不写return的情况下,会默认返回一个None:我们写的第一个函数,就没有写return,这就是没有返回值的一种情况。 


 
 
 
12
 
 
 
 
 
1
def lenght(s):
2
    l = 0
3
    for i in s:            # 关于for 循环的基本用法是时候做一波总结了
4
        l = l + 1
5
    
6

7

8
a = ‘ssssssss‘
9
print(lenght(a))
10

11

12
>>> None
 
 
3)只写return
只写return,后面不写其他内容,也会返回None,有的同学会奇怪,既然没有要返回的值,完全可以不写return,为什么还要写个return呢?这里我们要说一下return的其他用法,就是一旦遇到return,结束整个函数

 
 
 
12
 
 
 
 
 
1
def ret_demo():
2
    print(111)
3
    return
4
    print(222)
5

6

7
ret = ret_demo()
8
print(ret)
9

10

11
>>>111
12
   None
 
 
4)返回一个值

      刚刚我们已经写过一个返回一个值的情况,只需在return后面写上要返回的内容即可。

5)返回多个值

  可以返回任意多个、任意数据类型的值

 
 
 
 
19
 
 
 
 
 
1
# return 返回多个值
2
def func():
3
    return 1, 2, 3, 4
4

5
func()
6
print(func())
7

8
>>>(1, 2, 3, 4)        #返回值为一个元组
9

10

11
# 返回多个值的接收
12
def func():
13
    return 1, 2, 3, 4
14

15

16
a, b, c, d = func()
17
print(a, b, c, d)
18

19
>>>1  2  3  4
 
 
总结下函数的返回    return
1)当函数没有return时:在调用函数的时候返回None
2)当函数return后面没有传参数时:调用函数时也返回None
3)return可以以元组的形式返回多个数据


# 2 函数的参数 

1)形参与实参

 
 
 
11
 
 
 
 
 
1
def lenght(s):      # 形参
2
    L = 0
3
    for i in s:     # 关于for 循环的基本用法是时候做一波总结了
4
        L = L + 1
5
    return L
6

7

8
a = ‘ssssssss‘
9
print(lenght(a))    # 实参
10

11
>>> 8
 
 
2)传递多个参数
 
 
 
7
 
 
 
 
 
1
# 函数传递多个参数
2
def sum01(x, y):
3
    return x if x > y else y        # 三元运算符
4

5
print(sum01(1, 2))
6

7
>>>2
 
 
3)位置参数
    1、按照位置传参
    2、按照关键字传参

 
 
 
11
 
 
 
 
 
1
def mymax(x,y):
2
    #此时x = 20,y = 10
3
    print(x,y)
4
    the_max = x if x > y else y
5
    return the_max
6

7
ma = mymax(y = 10,x = 20)
8
print(ma)
9

10
>>>20 10
11
   20
 
 
    3、位置、关键字混着来

 
 
 
11
 
 
 
 
 
1
def mymax(x,y):
2
    #此时x = 20,y = 10
3
    print(x,y)
4
    the_max = x if x > y else y
5
    return the_max
6

7
ma = mymax(10,y = 20)
8
print(ma)
9

10
>>>10 20
11
   20
 
 
    4、默认参数

 
 
 
10
 
 
 
 
 
1
def stu_info(name,sex = "male"):    # 形参
2
    """打印学生信息函数,由于班中大部分学生都是男生,
3
        所以设置默认参数sex的默认值为‘male‘
4
    """
5
    print(name,sex)
6

7
stu_info(‘pontoon‘, ‘female‘)      # 实参
8
>>> pontoon female
9

10

 
 
    5、动态传参(*args, **kwargs)
面试题*args与**kwargs的区别?
  *args 用来将参数打包成tuple给函数体调用
  **kwargs 打包关键字参数成dict给函数体调用

 
 
 
10
 
 
 
 
 
1
def sum_func(*args):
2
    x = 0
3
    for i in args:
4
        x = i + x
5
    return x
6

7

8
print(sum_func(1, 2, 3, 4))
9

10
>>> 10
 
 
                                                       技术分享图片
6、传递可变参数
技术分享图片

 

------------------------------在函数中num = num+num与num += num是不一样的-------------------------------------------
技术分享图片

 
 
 
38
 
 
 
 
 
1
当函数接收到的参数是一个可变数据类型时,则会共享引用!
2
def mutable(num_list):
3
    num_list.extend([1, 2, 3])
4
    print(num_list)
5

6

7
gl_list = [5, 6, 7]                    # 接收一个列表        
8
mutable(gl_list)                       # 执行函数
9
print(gl_list)
10

11
>>>[5, 6, 7, 1, 2, 3]
12
[5, 6, 7, 1, 2, 3]
13

14
-----------------------------------------------------------------------------------
15
def demo(num, num_list):
16
    print(‘函数内部代码‘)
17

18
    num += num
19
    num_list += num_list               # 相当于执行num_list.extend(num_list)
20

21
    print(num)
22
    print(num_list)
23
    print(‘内部代码完成‘)
24

25

26
gl_num = 9
27
gl_list = [1, 2, 3]
28
demo(gl_num, gl_list)
29
print(gl_num)
30
print(gl_list)
31

32

33
>>>函数内部代码
34
18
35
[1, 2, 3, 1, 2, 3]
36
内部代码完成
37
9
38
[1, 2, 3, 1, 2, 3]
 
 
    7、顺序
 
函数的执行顺序:
        位置参数,*args,默认参数,**kwargs
技术分享图片

二,命名空间和作用域

技术分享图片

 技术分享图片

 

        三种命名空间之间的加载与取值顺序:        
    命名空间的本质:存放名字与值的绑定关系    

加载顺序:内置命名空间(程序运行前加载)->全局命名空间(程序运行中:从上到下加载)->局部命名空间(程序运行中:调用时才加载)

取值顺序:

  在局部调用:局部命名空间->全局命名空间->内置命名空间

  在全局调用:全局命名空间->内置命名空间

综上所述,在找寻变量时,从小范围,一层一层到大范围去找寻。

        作用域        

作用域就是作用范围,按照生效范围可以分为全局作用域和局部作用域。

全局作用域:包含内置名称空间、全局名称空间,在整个文件的任意位置都能被引用、全局有效

局部作用域:局部名称空间,只能在局部范围生效

globals和locals方法

看一段代码

 
 
 
27
 
 
 
 
 
1
# 这个函数时会报错的
2
def sss():
3
    a = 10
4
    print(a)
5

6
print(sss())
7
print(a)
8

9
>>>10
10
NameError: name ‘a‘ is not defined
11

12
-----------------------------------------------------------------------------------
13
# 加上global关键字就不会了
14
a = 20
15
def sss():
16
    global a
17
    a = 10
18
    print(a)
19

20
print(a)
21
print(sss())
22
print(a)
23

24
>>> 20        # 全局作用域的a
25
    10        # 调用函数是函数局部打印的a
26
    None      # 调用函数是由于没有返回值,所以返回None  
27
    10        # global关键字,将局部变量转换成了全局变量
 
 

函数的嵌套和作用域链

    函数的本质:是一个变量,变量可以作为函数的参数接收,变量也被函数返回,所以一个函数既可以接受函数也可以返回函数    
  函数的嵌套的本质:就是函数接收函数以及返回函数!

 
 
 
35
 
 
 
 
 
1
# 函数之间的调用
2
def max_func(x, y):
3
    return x if x > y else y
4

5

6
def max_func01(a, b, c, d):
7
    ret1 = max_func(a, b)
8
    ret2 = max_func(c, ret1)
9
    ret3 = max_func(ret2, d)
10
    return ret3
11

12

13
print(max_func01(10, 32, -45, 22))
14

15
>>> 32
16
-------------------------------------------------------------------------------
17

18
# 函数嵌套
19
def outer():
20
    print(‘outer‘)
21

22
    def inner():
23
        print(‘inner‘)
24
    return inner
25

26
print(outer())
27

28
>>>outer
29
 <function outer.<locals>.inner at 0x000000DBE7D73730>    # 只调用了一层函数,return的是一个函数名,所以print的时候打印出了地址
30

31
print(outer()())    # 调用两层
32

33
>>>outer
34
inner
35
None                # 内层的inner()函数没有返回值,所以print None
 
 
函数的作用域链
函数的作用域链的本质:就是内部函数可以引用外部函数的变量,包括外部函数的形参
看三个例子
 1 # 函数嵌套的定义——内部函数可以使用外部函数的变量
 2 def outer():
 3     a = 1
 4 
 5     def inner():
 6         b = 2
 7         print(a)
 8         print("inner")
 9 
10         def in_inner():
11             print(a, b)
12             print("in_inner")
13         in_inner()
14     inner()
15 
16 
17 outer()
18 
19 >>>1
20 inner
21 1 2
22 in_inner

 

 1 a = 1
 2 
 3 
 4 def outer():
 5     a = 1
 6 
 7     def inner():
 8         b = 2
 9         print(a)
10         print("inner")
11 
12         def in_inner():
13             global a
14             a += 1
15             print("in_inner")
16         in_inner()
17     inner()
18     print(函数内部a:, a)
19 
20 
21 outer()
22 print("全局变量a:", a)
23 
24 >>>1
25 inner
26 in_inner
27 函数内部a: 1
28 全局变量a: 2

 

 1 a = 1
 2 
 3 
 4 def outer():
 5     a = 1
 6 
 7     def inner():
 8         a = 2
 9         print(a)
10         print("inner")
11 
12         def in_inner():
13             nonlocal a          # 不同于global只将a返回给上一级,不能返回给全局
14             a += 1
15             print("in_inner")
16         in_inner()
17         print("in_inner a:", a)
18     inner()
19     print(函数内部 a:, a)
20 
21 
22 outer()
23 print("全局变量 a:", a)
24 
25 >>> 2
26 inner
27 in_inner
28 in_inner a: 3
29 函数内部 a: 1
30 全局变量 a: 1
 

闭包

什么叫做闭包?
内部函数包含对外部作用域而非全局作用域名字的引用,该内部函数称之为闭包
为什么要用到闭包?
闭包的作用:当我们在调用完函数后,函数内部的变量都会被释放,但是使用了闭包函数,因为内部函数引用了外部函数的变量,所以外部函数的变量永远不会消失!所以闭包的作用就是储存内部函数的变量!

 
 
 
x
 
 
 
 
 
1
# 创建一个简单的闭包函数
2
def outer():
3
    a = 2
4

5
    def inner():
6
        print(a)
7
    return inner
8

9
print(outer()())
10

11
>>>2
12
None
 
 
好吧至此python函数的概念就到此为止了。

以上是关于01python中的函数与函数式编程(python函数)的主要内容,如果未能解决你的问题,请参考以下文章

笔记效率之门——Python中的函数式编程技巧

python进阶-- 01 函数式编程

人生苦短 Python当歌——Python函数式编程01

python基础13函数以及函数式编程

Python-函数与函数式编程

python入门到精通python函数式编程与应用详解