AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

第五章 Python函数你知多少

2024-04-24 30
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 第五章 Python函数你知多少

函数作用：把一些复杂的代码封装起来，函数一般都是一个功能，用的时候才调用，提高重复利用率和简化程序结构。

5.1 语法

def functionName(parms1, parms2, ...):
   code block
   return expression

函数以def关键字开头，空格后跟函数名，括号里面是参数，用于传参，函数代码段里面引用。

5.2 函数定义与调用

# 定义函数
>>> def func():
...   print "Hello world!"
...   return "Hello world!" 
...
# 调用函数
>>> func()
Hello world!
'Hello world!'

当我们定义好函数，是不执行的，没有任何输出。当输入函数名后跟双小括号才会执行函数里写的代码。

顺便说下print和return区别：

有没有点奇怪！为什么print和return输出一样呢，return就加个单引号，貌似也没啥明显区别啊！其实在解释器下所有的结果都会输出的。

先了解下return作用：结束函数，并返回一个值。如果不跟表达式，会返回一个None。

好，那么我们深入了解下他们区别，举个例子，写个py程序：

#!/usr/bin/env python
def func():
    print "1: Hello world!"
    return "2: Hello world!"
func()
# python test.py
1: Hello world!

明白点了嘛？print是打印对象的值，而return是返回对象的值。也就是说你return默认是将对象值存储起来，要想知道里面的值，可以用print可以打印。

#!/usr/bin/env python
def func():
    print "1: Hello world!"
    return "2: Hello world!"
print func()
# python test.py
1: Hello world!
2: Hello world!

为什么函数里面不用print就在这里，往往我们定义一个函数是不需要打印的，而是交给其他代码去处理这个函数返回值。当然，print在调试函数代码时会起到很好的帮助。

5.3 函数参数

 5.3.1 接受参数

>>> def func(a, b):    
    ...   print a + b
    ...
    >>> func(1, 2)
    3
    >>> func(1, 2, 3)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: func() takes exactly 2 arguments (3 given)

  a和b可以理解为是个变量，可由里面代码块引用。调用函数时，小括号里面的表达式数量要对应函数参数数量，并且按传参按位置赋予函数参数位置。如果数量不对应，会抛出TypeError错误。

  当然，函数参数也可以是数组：

>>> def func(a):    
    ...   print a
    ...
    >>> func([1,2,3])
    [1, 2, 3]
    >>> func({'a':1,'b':2})
    {'a': 1, 'b': 2}

  如果不想一一对应传参，可以指定参数值：

>>> def func(a,b):    
    ...   print a + b
    ...
    >>> func(b=2,a=1)
    3

  5.3.2 函数参数默认值

  参数默认值是预先定义好，如果调用函数时传入了这个值，那么将以传入的为实际值，否则是默认值。

>>> def func(a, b=2):    
    ...   print a + b
    ...
    >>> func(1)
    3
    >>> func(1, 3)
    4

  5.3.3 接受任意数量参数

  上面方式固定了参数多个，当不知道多少参数时候可以用以下方式。

  单个星号使用：

>>> def func(*a):         
    ...   print a
    ...
    >>> func(1,2,3)
    (1, 2, 3)

  单个星号存储为一个元组。

  两个星号使用：

>>> def func(**a):    
    ...   print a
    ...
    >>> func(a=1, b=2, c=3)
    {'a': 1, 'c': 3, 'b': 2}

  两个星号存储为一个字典。可见它们都是以数组的形式传入。

  你也许在查资料的时候，会看到这样写的函数参数（*args, **kwargs），与上面只是名字不一样罢了 ：

>>> def func(*args, **kwargs):    
    ...   print args
    ...   print kwargs
    ...
    >>> func(1,2,3,a=1,b=2,c=3)
    (1, 2, 3)
    {'a': 1, 'c': 3, 'b': 2}

  与普通参数一起使用：

>>> def func(a, b, *c):    
    ...   print a + b
    ...   print c
    ...
    >>> func(1,2,3,5,6)
    3
    (3, 5, 6)
    >>> def func(a, b, **c):
    ...   print a + b
    ...   print c
    ...
    >>> func(1,2,a=1,b=2,c=3)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: func() got multiple values for keyword argument 'a'
    >>> func(1,2,c=3,d=4,e=5)
    3
    {'c': 3, 'e': 5, 'd': 4}

   抛出异常，是因为传入的第一个参数1，和第三个参数a=1，都认为是传入函数参数a了。请注意下这点。

5.4 作用域

作用域听着挺新鲜，其实很简单，就是限制一个变量或一段代码可用范围，不在这个范围就不可用。提高了程序逻辑的局部性，减少名字冲突。

作用域范围一般是：全局（global）->局部（local）->内置（build-in）

先看看全局和局部变量：

>>> a = 2
>>> def func():
...   b = 3
...
>>> a
2
>>> b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined

a变量的作用域是整个代码中有效，称为全局变量，也就是说一段代码最开始定义的变量。

b变量的作用域在函数内部，也就是局部变量，在函数外是不可引用的。

这么一来，全局变量与局部变量即使名字一样也不冲突。

如果函数内部的变量也能在全局引用，需要使用global声明：

>>> def func():
...   global b
...   b = 3
...
>>> b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'b' is not defined
>>> func()
>>> b
3

有报错，说明一个问题，当函数没引用使用，里面的代码块是没有解释的。

使用global声明变量后外部是可以调用函数内部的变量的。

5.5 嵌套函数

1）不带参数

>>> def func():
...   x = 2
...   def func2():
...     return x
...   return func2  # 返回func2函数
...
>>> func()()
2
>>> func2()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'func2' is not defined
>>> def func():   
...   x = 2         
...   global func2
...   def func2():
...     return x 
...   return func2
...
>>> func()()
2
>>> func2()
2

内层函数可以访问外层函数的作用域。内嵌函数只能被外层函数调用，但也可以使用global声明全局作用域。

调用内部函数的另一种用法：

2）带参数

>>> def func(a):
...   def func2(b):
...     return a * b
...   return func2
...
>>> f = func(2)   # 变量指向函数。是的，变量可以指向函数。
>>> f(5)
10
>>> func(2)(5)
10

内层函数可以访问外层函数的作用域 。但变量不能重新赋值，举例说明：

>>> def func():
...   x = 2
...   def func2():
...      x = 3
...   func2()
...   return x
...
>>> func()
2
>>> def func():
...   x = 2
...   def func2():
...     x += 1
...   func2()
...   return x
...
>>> func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in func
  File "<stdin>", line 4, in func2
UnboundLocalError: local variable 'x' referenced before assignment

5.6 闭包

“官方”的解释是：所谓“闭包”，指的是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数），因而这些变量也是该表达式的一部分。

其实，上面嵌套函数就是闭包一种方式：

>>> def func(a):
...   def func2(b):
...     return a * b
...   return func2
...
>>> f = func(2)   # 变量指向函数。是的，变量可以指向函数。
>>> f(5)
10

func是一个函数，里面又嵌套了一个函数func2，外部函数传过来的a参数，这个变量会绑定到函数func2。func函数以内层函数func2作为返回值，然后把func函数存储到f变量中。当外层函数调用内层函数时，内层函数才会执行（func()()），就创建了一个闭包。

5.7 高阶函数

高阶函数是至少满足这两个任意中的一个条件：

1) 能接受一个或多个函数作为输入。

2）输出一个函数。

abs、map、reduce都是高阶函数，后面会讲解。

其实，上面所讲的嵌套函数也是高阶函数。

举例说明下高阶函数：

>>> def f(x):
...   return x * x
...
>>> def f2(func, y):
...   return func(y)
...
>>> f2(f, 2)
4

这里的f2就是一个高阶函数，因为它的第一个参数是一个函数，满足了第一个条件。


博客地址：http://lizhenliang.blog.51cto.com

QQ群：Shell/Python运维开发群 323779636


5.8 函数装饰器

装饰器（decorator）本身是一个函数，包装另一个函数或类，它可以让其他函数在不需要改动代码情况下动态增加功能，装饰器返回的也是一个函数对象。

先举一个例子，说明下装饰器的效果，定义两个函数，分别传参计算乘积：

#!/usr/bin/python
# -*- coding: utf-8 -*-
def f1(a, b):
    print "f1 result: " + str(a * b)
def f2(a, b):
    print "f2 result: " + str(a * b)
f1(1, 2)
f2(2, 2)
# python test.py
f1 result: 2
f2 result: 4

跟预期的那样，打印出了乘积。

如果我想给这两个函数加一个打印传入的参数，怎么办，应该这样：

#!/usr/bin/python
# -*- coding: utf-8 -*-
def f1(a, b):
    print "f1 parameter: %d %d" %(a, b)
    print "f1 result: " + str(a * b)
def f2(a, b):
    print "f2 parameter: %d %d" %(a, b)
    print "f2 result: " + str(a * b)
f1(1, 2)
f2(2, 2)
# python test.py
f1 parameter: 1 2
f1 result: 2
f2 parameter: 2 2
f2 result: 4

按照所想的打印了传入的参数，有没有方法能更简洁点呢，来看看装饰器后的效果。

#!/usr/bin/python
# -*- coding: utf-8 -*-
def deco(func):
    def f(a, b):
        print "%s parameter: %d %d" %(func.__name__, a, b)
        return func(a, b)
    return f
@deco
def f1(a, b):
    print "f1 result: " + str(a * b)
@deco
def f2(a, b):
    print "f2 result: " + str(a * b)
f1(1, 2)
f2(2, 2)
# python test.py
f1 parameter: 1 2
f1 result: 2
f2 parameter: 2 2
f2 result: 4

可见用装饰器也实现了上面方法，给要装饰的函数添加了装饰器定义的功能，这种方式显得是不是更简洁呢！

好，那么我们继续深入学习装饰器用法。

  5.8.1 无参数装饰器

方式1：函装饰器函数装饰函数    
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    def deco(func):
        return func
    def f1():
        print "Hello world!"
    myfunc = deco(f1)
    myfunc()  
    # python test.py
    Hello world!
    
    方式2：使用语法糖"@"来装饰函数
    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    def deco(func):
        return func
    @deco
    def f1():
        print "Hello world!"
    f1()
    # python test.py
    Hello world!

  方式1是将一个函数作为参数传给装饰器函数。

  方式2使用了语法糖，也实现同样效果。

  其实两种方式结果一样，方式1需要每次使用装饰器时要先变量赋值下，而方式2使用装饰器时直接用语法糖"@"引用，会显得更方便些，实际代码中一般也都是用语法糖。

  2）带参数装饰器

#!/usr/bin/python    
    # -*- coding: utf-8 -*-
    def deco(func):
        def f(a, b):
            print "function name: %s" % func.__name__   # __name__属性是获取函数名，为了说明执行了这个函数
            return func(a, b)   # 用接受过来的func函数来处理传过来的参数
        return f
    @deco
    def f1(a, b):
        print "Hello world!"
        print a + b
    f1(2, 2)
    # python test.py
    function name: f1
    Hello world!
    4

  3）不固定参数

#!/usr/bin/python    
    # -*- coding: utf-8 -*-
    def log(func):
        def deco(*args, **kwargs):
            print "function name: %s" % func.__name__
            return func(*args, **kwargs)
        return deco
    @log
    def f1(a, b):
        print "f1() run."
        print a + b
    f1(1,2)
    # python test.py
    function name: f1
    f1() run.
    3

   4）装饰器加参数

#!/usr/bin/python    
    # -*- coding: utf-8 -*-
    # 三层函数，调用log函数返回deco函数，再调用返回的函数deco，则返回值是_deco函数
    def log(arg):
        def deco(func):
            def _deco(*args, **kwargs):
                print "%s - function name: %s" % (arg, func.__name__)  
                return func(*args, **kwargs)
            return _deco
        return deco
    @log("info")
    def f1(a, b):
        print "f1() run."
        print a + b
    f1(1,2)
    # python test.py
    info - function name: f1
    f1() run.
    3

   再举一个例子，给函数输出字符串带颜色：

#!/usr/bin/python    
    # -*- coding: utf-8 -*-
    def fontColor(color):
        begin = "\033["
        end = "\033[0m"
        d = {
            'red':'31m',
            'green':'32m',
            'yellow':'33m',
            'blue':'34m'
        }
        def deco(func):
            print begin + d[color] + func() + end
        return deco
    @fontColor("red")
    def f():
        return "Hello world!"
    @fontColor("green")
    def f2():
        return "Hello world!"

  可以看出装饰器处理方式满足了高阶函数的条件，所以装饰器也是一种高阶函数。

  优点：灵活给装饰器增加功能，而不修改函数，提高代码可重复利用性，增加可读性。

5.9 匿名函数

匿名函数：定义函数的一种形式，无需定义函数名和语句块，因此代码逻辑会受到局限，同时也减少代码量，增加可读性。

在Python中匿名函数是lambda。

举例子说明def关键字与lambda函数定义函数区别：

# 普通函数
>>> def func():
...   return "Hello world!"
...
>>> func()
>>> def func(a, b):
...   return a * b
...
>>> func(2, 2)
4
# 匿名函数
>>> f = lambda:"Hello world!"
>>> f()
'Hello world!'
>>> f = lambda a, b: a * b   # 冒号左边是函数参数，右边是返回值
>>> f(2, 2)
4

lambda函数一行就写成一个函数功能，省去定义函数过程，让代码更加精简。

5.10 内置高阶函数

  5.10.1 map()

  语法：map(function, sequence[, sequence, ...]) -> list

  将序列中的元素通过函数处理返回一个新列表。

  例如：

>>> lst = [1,2,3,4,5]    
    >>> map(lambda x:str(x)+".txt", lst)
    ['1.txt', '2.txt', '3.txt', '4.txt', '5.txt']

  5.10.2 filter()

  语法：filter(function or None, sequence) -> list, tuple, or string

  将序列中的元素通过函数处理返回一个新列表、元组或字符串。

  例如：过滤列表中的奇数

>>> lst = [1,2,3,4,5]    
    >>> filter(lambda x:x%2==0, lst)
    [2, 4]

  5.10.3 reduce()

  语法：reduce(function, sequence[, initial]) -> value

  reduce()是一个二元运算函数，所以只接受二元操作函数。

  例如：计算列表总和

>>> lst = [1,2,3,4,5]    
    >>> reduce(lambda x,y:x+y, lst)
    15

   先将前两个元素相加等于3，再把结果与第三个元素相加等于6，以此类推。这就是reduce()函数功能。

文章标签：
Python
存储
Shell
分布式计算
运维
关键词：
Python函数
李振良_阿良
目录
相关文章
白子寰
|
3月前
|
Python
【python从入门到精通】-- 第五战：函数大总结
【python从入门到精通】-- 第五战：函数大总结
白子寰
101 0
德国都芳最好
|
2月前
|
搜索推荐 Python
利用Python内置函数实现的冒泡排序算法
在上述代码中，`bubble_sort` 函数接受一个列表 `arr` 作为输入。通过两层循环，外层循环控制排序的轮数，内层循环用于比较相邻的元素并进行交换。如果前一个元素大于后一个元素，就将它们交换位置。
德国都芳最好
140 67
站大爷
|
3天前
|
JSON 监控 安全
深入理解 Python 的 eval() 函数与空全局字典 {}
`eval()` 函数在 Python 中能将字符串解析为代码并执行，但伴随安全风险，尤其在处理不受信任的输入时。传递空全局字典 {} 可限制其访问内置对象，但仍存隐患。建议通过限制函数和变量、使用沙箱环境、避免复杂表达式、验证输入等提高安全性。更推荐使用 `ast.literal_eval()`、自定义解析器或 JSON 解析等替代方案，以确保代码安全性和可靠性。
站大爷
15 2
vohelon
|
30天前
|
Python
Python中的函数是**一种命名的代码块，用于执行特定任务或计算
Python中的函数是**一种命名的代码块，用于执行特定任务或计算
vohelon
49 18
听白
|
22天前
|
数据可视化 DataX Python
Seaborn 教程-绘图函数
Seaborn 教程-绘图函数
听白
46 8
vohelon
|
1月前
|
Python
Python中的函数
Python中的函数
vohelon
44 8
游客5fdji2pvmf8888
|
2月前
|
监控 测试技术 数据库
Python中的装饰器：解锁函数增强的魔法####
本文深入探讨了Python语言中一个既强大又灵活的特性——装饰器（Decorator），它以一种优雅的方式实现了函数功能的扩展与增强。不同于传统的代码复用机制，装饰器通过高阶函数的形式，为开发者提供了在不修改原函数源代码的前提下，动态添加新功能的能力。我们将从装饰器的基本概念入手，逐步解析其工作原理，并通过一系列实例展示如何利用装饰器进行日志记录、性能测试、事务处理等常见任务，最终揭示装饰器在提升代码可读性、维护性和功能性方面的独特价值。 ####
游客5fdji2pvmf8888
34 2
bruce_xiaowei
|
2月前
|
Python
Python中的`range`函数与负增长
在Python中，`range`函数用于生成整数序列，支持正向和负向增长。本文详细介绍了如何使用`range`生成负增长的整数序列，并提供了多个实际应用示例，如反向遍历列表、生成倒计时和计算递减等差数列的和。通过这些示例，读者可以更好地掌握`range`函数的使用方法。
bruce_xiaowei
54 5
aliyun1622584902-46568
|
3月前
|
Python
Python之函数详解
【10月更文挑战第12天】
aliyun1622584902-46568
41 2
Python之函数详解
aliyun1622584902-46568
|
3月前
|
存储 数据安全/隐私保护 索引
Python 散列类型三以及函数基础
【10月更文挑战第11天】
aliyun1622584902-46568
32 1
Python 散列类型三以及函数基础

热门文章

最新文章

  • 1
    使用Python实现智能食品库存管理的深度学习模型
  • 2
    Python实现常用办公文件格式转换
  • 3
    猫狗宠物识别系统Python+TensorFlow+人工智能+深度学习+卷积网络算法
  • 4
    pyenv 管理多个 Python 版本(1)
  • 5
    Python编程数据结构的深入理解
  • 6
    Python的标准库
  • 7
    利用Python内置函数实现的冒泡排序算法
  • 8
    使用Python实现智能食品消费习惯分析的深度学习模型
  • 9
    使用Python实现深度学习模型的分布式训练
  • 10
    在 Python 中，如何将日期时间类型转换为字符串？
  • 1
    Python 密码学实用指南（全）（2）
    46
  • 2
    【python】习题 第10周
    64
  • 3
    【python】习题第8周
    65
  • 4
    【python】习题第7周（上）
    96
  • 5
    【python】习题 6-10周（下）
    65
  • 6
    【python】习题 6-10周（中）
    69
  • 7
    Python 入门指南（七）（4）
    54
  • 8
    【python】习题 1-5周（中）
    99
  • 9
    【python】习题 1-5周（上）
    57
  • 10
    Python 入门指南（七）（2）
    63

    • 相关课程

    更多
  • Python爬虫实战
  • Python开发基础入门
  • Python常用数据科学库
  • Python网络爬虫实战
  • Python完全自学手册图文教程
  • Python基础快速入门实战教程

    • 相关电子书

    更多
  • From Python Scikit-Learn to Sc
  • Data Pre-Processing in Python:
  • 双剑合璧-Python和大数据计算平台的结合

    • 相关实验场景

    更多
  • 用Python画圣诞树
  • Python选择及循环结构
  • 云端Python及基本操作
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
  • Python新手入门（Anolis OS）

    • 推荐镜像

    更多
  • python-release
  • nodejs-release
  • composer
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月