python11-函数合集

已于 2022-09-02 10:23:44 修改
阅读量658 收藏 1
点赞数
文章标签： python
于 2022-08-31 22:29:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43318393/article/details/126387001
版权

目录

1、函数定义

2、函数参数

3、作用域

4、闭包

5、装饰器

6、lambda表达式

7、生成器

8、递归

1、函数定义

使用 def 语句来定义函数，紧跟着的是函数的名字，后面带一对小括号，冒号下面就是函数体，函数体是一个代码块，也就是每次调用函数时将被执行的内容。

>>> def myfunc(name, times):
...     for i in range(times):
...         print(f"I love {name}.")
...
>>> myfunc("Python", 5)
I love Python.
I love Python.
I love Python.
I love Python.
I love Python.

有时候，我们可能需要函数干完活之后能给一个反馈，这在 BIF 函数中也很常见，比如 sum() 函数会返回求和后的结果，len() 函数会返回一个元素的长度，而 list() 函数则会将参数转换为列表后返回。只需要使用 return 语句，就可以让咱们自己定制的函数实现返回。

>>> def div(x, y):
...     z = x / y
...     return z
...
>>> div(4, 2)
2.0

2、函数参数

位置参数：参数位置固定，实参按照形参传递。关键字参数：指定具体值。默认参数：如果没有传入实参，就使用默认参数，如果使用默认参数把他们放在最后。

>>> def myfunc(s, vt, o):
...    return "".join((o, vt, s))
...
>>> myfunc("我", "打了", "小甲鱼")
'小甲鱼打了我'
>>> myfunc("小甲鱼", "打了", "我")
'我打了小甲鱼'
#位置参数

>>> myfunc(o="我", vt="打了", s="小甲鱼")
'我打了小甲鱼'
#关键字参数

>>> myfunc(o="我","打了","小甲鱼")
SyntaxError: positional argument follows keyword argument
"""同时使用位置参数和关键字参数，要注意位置参数必须在关键字参数前"""

>>> def myfunc(s="苹果", vt, o="小甲鱼"):
        
SyntaxError: non-default argument follows default argument
"""使用默认参数必须放在最后面"""
>>> def myfunc(vt, s="苹果", o="小甲鱼"):
...     return "".join((o, vt, s))
... 
>>> myfunc("拱了")
'小甲鱼拱了苹果'
#默认参数放最后

对于只能使用位置参数的函数，我们举例子为abs（）函数，例如我们使用help(abs)和help(sum)帮助文档我们可以看到函数的参数里有反斜杠。这表示反斜杠左侧必须是位置参数，不能是关键字参数，而对于反斜杠右侧就随意了。

>>> help(abs)
Help on built-in function abs in module builtins:
    
abs(x, /)
    Return the absolute value of the argument.

>>> help(sum)
Help on built-in function sum in module builtins:
    
sum(iterable, /, start=0)
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
    
    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.
>>> abs(-1.5)
1.5
>>> abs(x = -1.5)
Traceback (most recent call last):
  File "<pyshell#67>", line 1, in <module>
    abs(x = -1.5)
TypeError: abs() takes no keyword arguments

对于只能使用关键字参数，利用*号、参数 a 既可以是位置参数也可以是关键字参数，但参数 b 和参数 c 就必须是关键字参数。

>>> def abc(a, *, b, c):
...     print(a, b, c)
>>> abc(1,2,3)
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    abc(1,2,3)
TypeError: abc() takes 1 positional argument but 3 were given
>>> abc(1,b=2,c=3)
1 2 3
>>> abc(a=1,b=2,c=3)
1 2 3

收集参数：不限制参数，即在形参前面加*，形参使用叫打包，实参使用叫解包。即指定一个参数，调用的时候可以传回任意数量的参数。如果收集参数后面还有指定的其他参数，那么在调用的时候要用关键字参数来指定。收集参数也可以将参数打包成字典，做法是加两个**，对于这种情况传递参数只能用关键字参数，因为字典的键值对

def myfunc(*arge):
    print("有%d个参数。"%len(arge))    #print("有{}个参数".format(len(arge)))
    #print(f"有{len(arge)}个参数")
    print("第二个参数是：%s"%arge[1])    #print("第二个参数是{}".format(arge[1]))
    #print(f"第二个参数是{arge[1]}")

    
myfunc("小甲鱼","不二如是")
有2个参数。
第二个参数是：不二如是

def myfunc(*args,a,b):
    print(args,a,b)
  
myfunc(1,2,3,a = 4,b = 5)
(1, 2, 3) 4 5

>>> def myfunc(a, *b, **c):
...     print(a, b, c)
... 
>>> myfunc(1, 2, 3, 4, x=5, y=6)
1 (2, 3, 4) {'x': 5, 'y': 6}

同样*和**也可以用在实参上，在实参上对应的解包。

>>> args = (1, 2, 3, 4)
>>> def myfunc(a, b, c, d):
...     print(a, b, c, d)
... 
>>> myfunc(*args)
1 2 3 4

>>> args = {'a':1, 'b':2, 'c':3, 'd':4}
>>> myfunc(**args)
1 2 3 4

3、作用域

局部作用域：一个变量定义在函数里面，作用域仅限于函数，为局部变量。

全局作用域：在任何函数外部定义的变量，作用域是全局的。

注意下面的x并非同一个变量，只是由于作用域不同，同名不同样。

>>> x = 880
>>> def myfunc():
...     x = 520
...     print(x)
... 
>>> myfunc()
520
>>> print(x)
880

global语句：我们在函数内部无法修改全局变量的值，除非使用global语句破除限制。

>>> x = 880
>>> def myfunc():
...     global x
...     x = 520
...     print(x)
... 
>>> myfunc()
520
>>> print(x)
520

嵌套函数，想要调用内部的函数必须先通过外部的函数

>>> def funA():
...     x = 520
...     def funB():
...         x = 880
...         print("In funB, x =", x)
...     funB()
...     print("In funA, x =", x)
... 
>>> funA()
In funB, x = 880
In funA, x = 520

nonlocal语句：通常我们无法在嵌套函数的内部修改外部函数变量的值，除非使用 nonlocal 语句破除限制：

>>> def funA():
...     x = 520
...     def funB():
...         nonlocal x
...         x = 880
...         print("In funB, x =", x)
...     funB()
...     print("In funA, x =", x)
... 
>>> funA()
In funB, x = 880
In funA, x = 880

LEGB规则:

  • L 是 Local，是局部作用域
  • E 是 Enclosed，是嵌套函数的外层函数作用域
  • G 是 Global，是全局作用域
  • B 是 Build-In，也就是内置作用域

即：局部-嵌套-全局-内置

"""在局部作用域中找到e"""
def f():
    def h():
        e = 3
        print(f"e={e}")
    h()

    
f()
e=3
"""在嵌套函数外的嵌套作用域中找到e"""
def f():
    e = 2
    def h():
        print(f"e={e}")
    h()

    
f()
e=2
"""从全局作用域中找"""
e=1
def f():
    def h():
        print(f"e={e}")
    h()

f()
e=1

"""从内置函数中找到e"""
from math import e
def f():
    def h():
        print(f"e={e}")
    h()

    
f()
e=2.718281828459045

4、闭包

>>> def funA():
...     x = 520
...     def funB():
...         print(x)
...     return funB
>>> funA()
<function funA.<locals>.funB at 0x0000014C02684040>
>>> funA()()
520
>>> funny = funA()
>>> funny
<function funA.<locals>.funB at 0x0000014C02684550>
>>> funny()
520

LEGB规则中的E，对于嵌套函数来说，外层函数的作用域是会通过某种形式保存下来，尽管函数已经调用完了，但是外层作用域的变量会保存下来，不会像局部作用域那样调用完就消失。

闭包：利用嵌套函数实现工厂的功能。

  1. 利用嵌套函数的外层作用域具有记忆功能这个特性。
  2. 将内层函数作为返回值返回。
>>> def power(exp):
...     def exp_of(base):
...         return base ** exp
...     return exp_of
... 
>>> square = power(2)
>>> cube = power(3)
>>> square
<function power.<locals>.exp_of at 0x000001CF6A1FAF70>
>>> square(2)
4
>>> square(5)
25
>>> cube(2)
8
>>> cube(5)
125

exp接收的是power传入的值，然后return返回的是内部嵌套exp_of 的引用，所以可以利用这个引用进行计算，以下代码为带记忆功能的函数。利用内层函数能够记住外层函数的作用域这个特性，并且使用nonlocal语句修改外层函数作用域里面的变量。

def outer():
    x = 0
    y = 0
    def inner(x1,y1):
        nonlocal x,y
        x+=x1
        y+=y1
        print(f"现在，X={x},Y={y}")
    return inner

move = outer()
move(1,2)
现在，X=1,Y=2
move(-2,-2)
现在，X=-1,Y=0

5、装饰器

把函数作为参数给另一个函数，类似 f 字符串，避免对之前的代码进行改动，直接外层进行添加。详细了解参照知乎抖音和小甲鱼相关介绍。

def myfunc():
    print("正在调用函数")
def report(func):
    print("开始调用")
    func()
    print("调用完毕")
    
report(myfunc)
开始调用
正在调用函数
调用完毕

import time
    
def time_master(func):
    def call_func():
        print("开始运行程序...")
        start = time.time()
        func()
        stop = time.time()
        print("结束程序运行...")
        print(f"一共耗费了 {(stop-start):.2f} 秒。")
    return call_func
    
@time_master
def myfunc():
    time.sleep(2)
    print("I love FishC.")
    
myfunc()

6、lambda表达式

一行流表达式。传统定义的函数，函数名就是一个函数的引用，而 lambda 表达式，整个表达式就是一个函数的引用。

lambda 是一个表达式，因此它可以用在常规函数不可能存在的地方。如下y[0]是lambda表达式的函数然后小括号里面传参数。

>>> def squareX(x):
...     return x * x
...
>>> squareX(3)
9
"""同上"""
>>> squareY = lambda y : y * y
>>> squareY(3)
9

>>> y = [lambda x : x * x, 2, 3]
>>> y[0](y[1])
4
>>> y[0](y[2])
9

利用map函数和filter函数，map函数第一个参数要求是一个函数的引用，第二个参数是序列类型，然后把第二个参数挨个传给第一个参数，运算之后构成一个迭代器。filter对指定的对象的每一个元素进行计算并返回结果为真的元素，回顾python-09。

>>>  list(mapped = map(lambda x : ord(x) + 10, "FishC"))
[80, 115, 125, 114, 77]
>>> list(filter(lambda x : x % 2, range(10)))
[1, 3, 5, 7, 9]

7、生成器

让函数退出后还能保留状态，一个是全局变量（污染空间）一个是闭包（麻烦），还有生成器。

在 Python 中，使用了 yield 语句的函数被称为生成器（generator）。定义一个生成器，很简单，就是在函数中，使用 yield 表达式代替 return 语句即可。

生成器一次只下一个蛋。

>>> def counter():
...     i = 0
...     while i <= 5:
...         yield i
...         i += 1
>>> counter()
<generator object counter at 0x0000025835D0D5F0>
>>> for i in counter():
...     print(i)
... 
0
1
2
3
4
5

"""斐波那契数列"""
>>> def fib():
...     back1, back2 = 0, 1
...     while True:
...         yield back1
...         back1, back2 = back2, back1 + back2
... 
>>> f = fib()
>>> next(f)
0
>>> next(f)
1
>>> next(f)
1
>>> next(f)
2
>>> next(f)
3
>>> next(f)
5
>>> next(f)
8
>>> next(f)
13
>>> next(f)
21

只要我们调用 next(f)，就可以继续生成一个新的斐波那契数，由于我们在函数中没有设置结束条件，那么这样我们就得到了一个永恒的斐波那契数列生成器。

8、递归

函数自己调用自己的过程。要让递归正常工作，必须要有一个结束条件，并且每次调用都将向着这个结束条件推进。

下面代码会持续输出 “AWBDYL”，直到你把 IDLE 关闭或者使用 Ctrl + c 快捷键强制中断执行。

>>> def funC():
...     print("AWBDYL")
...     funC()
... 
>>> funC()
AWBDYL
AWBDYL
AWBDYL
AWBDYL
AWBDYL
AWBDYL
AWBDYL
AWBDYL
AWBDYL
AWBDYL
...

求一个数的阶乘

"""迭代"""
>>> def factIter(n):
...     result = n
...     for i in range(1, n):
...         result *= i
...     return result
... 
>>> factIter(5)
120
>>> factIter(10)
3628800

"""递归"""
>>> def factRecur(n):
...     if n == 1:
...         return 1
...     else:
...         return n * factRecur(n-1)
... 
>>> factRecur(5)
120
>>> factRecur(10)
3628800

"""迭代-斐波那契数列"""
>>> def fibIter(n):
...     a = 1
...     b = 1
...     c = 1
...     while n > 2:
...         c = a + b
...         a = b
...         b = c
...         n -= 1
...     return c
... 
>>> fibIter(12)
144

"""递归-斐波那契数列"""
>>> def fibRecur(n):
...     if n == 1 or n == 2:
...         return 1
...     else:
...         return fibRecur(n-1) + fibRecur(n-2)
... 
>>> fibRecur(12)
144

学习来源于小甲鱼教学

雨 蛮好看的
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实验十一 函数
Junds0的博客
01-04 3851
第1关：定义判断质数的函数 本关任务：编写一个能判断质数的函数。若参数是质数，返回true；否则返回false。 主程序输入一个数n，然后调用该函数判断其是否是质数，是则显示n是质数，否则显示n不是质数。 def isprime(a): #代码开始 v=1 for i in range(2,a): if a%i==0: v=0 return v #代码结束 n=eval(input("请输入一个数")) if isprime(n): p
python 11 函数
woaixuexi6666的博客
08-02 1293
python学习11天
python 学习笔记十一 函数
Late_whale的博客 作者：代码搬运工老李的二师兄
02-03 1267
文章目录函数定义函数调用函数函数的参数默认参数实参的传递方式位置参数关键字参数实参类型不定长参数（参数的装包）参数的解包返回值help(函数名)文档字符串作用域全局作用域函数作用域变量的查找 函数 函数也是一个对象； 函数用来保存一些可执行的代码，并在需要的时候对这些语句进行多次的调用； 函数常用于实现某种功能； 定义函数 格式： def 函数名 ([形参1…形参n])：   代码块 注意 ...
数据库原理 头歌实训 存储程序
thewiller的博客
04-27 5606
自定义函数的创建。
头歌Python数据框、序列定义及数据处理应用实验闯关
热门推荐
数据攻城狮的博客
04-06 2万+
头歌Python数据框、序列定义及数据处理应用实验闯关
【头歌系统Python实验】函数调用
学习的博客
12-11 2946
任务描述我们在编程过程中会用到很多函数，但我们不需要每个函数都自己去编写，因为 Python 内置了很多十分有用的函数，我们在编程过程中可以直接调用。本关目标是让学习者了解并掌握一些常用的 Python 内置函数的用法。相关知识数学运算abs()类型转换bool()序列操作all()：判断可迭代对象的每个元素是否都为True：判断可迭代对象的元素是否有为True：对可迭代对象进行排序，返回一个新的列表。对象操作help()：返回对象的帮助信息；dir()：返回对象或者当前作用域内的属性列表。
python基础（十一）：函数
一点一滴铺就人生
05-04 1376
一、函数存在的意义 函数存在就是解决以下问题的： 程序组织结构不清晰，可读性差 代码冗余 可维护性、可扩展性差 二、定义函数 函数的定义：就相当于事先将函数体代码保存起来，然后将内存地址赋值给函数名，函数名就是对这段代码的引用，这和变量的定义是相似的。 定义函数的语法： def 函数名(参数1,参数2,...): """文档描述""" 函数体 return 值 ...
python基础（11）之函数
PY洋洋
12-29 458
一、创建函数与调用 二、参数 三、参数数量 四、任意参数，*args 五、关键字参数 七、任意关键字参数，**kwargs 八、默认参数值 九、将列表作为参数传递 十、返回值 十一、pass语句
python笔记 - 函数（十一）
weixin_42295011的博客
07-18 50
函数
Python学习之第十一天 函数
青灬火的博客
07-30 122
今天为大家介绍的是Python中函数的概念，以下为相关学习代码，感兴趣的童鞋可以参考练习。 # 机构：家里蹲 # 作者：青灬火 # 时间：2021/7/21 23:15 #1、函数的创建和调用 ''' 什么是函数 函数就是执行特定任务以完成特定功能的一段代码 为什么需要函数 复用代码 隐藏实现细节 提高可维护性 提高可读性便于调试 函数的创建 def 函数名([输入参数]): 函数体 [return ***] ''' def
Python-Python函数-教学设计.docx
06-11
问答互动引出学习目标 讲授法 示范练习 随堂报告 Python-Python函数-教学设计全文共6页，当前为第1页。Python-Python函数-教学设计全文共6页，当前为第1页。《Python函数》教学设计 Python-Python函数-教学设计全文...
python学习-函数
01-04
python学习-函数 Python是一种解释型的、面向对象的、带有动态语义的高级程序设计语言。它是由荷兰人吉多·罗萨姆于1989年发布的，第一个公开发行版发行于1991年。Python注重解决问题的方法，而不是语法和结构。它被...
python基础-函数详解
12-21
高阶函数：五、函数中的参数六、python函数的注意事项 python基础-函数详解 一、什么是函数 函数：就是一套定义好的流程，输入数据得到结果。函数之间可能相互独立，也可能一个函数的输入是另一个函数的输出，也可能...
Python—-函数
12-22
函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求，可以实现更高效的代码复用 1. 基础用法 定义语法： def 函数名([参数列表]): “文档字符串” (注释) 函数体...
程序设计-python案例-函数返回值
04-15
python零基础初学者 体验程序
python 11高级特性
ruoruoruo666的博客
07-10 1393
切片 取列表中前3个元素我们常见的方法有两种： [L[0],L[1],L[2]] 采用循环的方式如下图所示。 对这种经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。对于取上面问题取3个元素用一行代码就能完成切片。 L[0:3]表示，从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。 L[-2: ]表示从倒数第2个元素开始取直到最后一个元素。 L[-2:-1]表示从倒数第2个元素开始取直到倒数第1个元素但不包
湖南大学python头歌实训 实验11：数据思维（一）
hkxxxx_的博客
12-28 1465
第1关：创建numpy数组都是些新语法，博主还没怎么重视，回来才发现期末占1/3！
python学习（十一）面向对象
韩若熙的博客
03-11 372
文章目录前言一、异常1、什么是异常 前言 python是一种面向对象的语言。 一、异常 1、什么是异常 用法如下： #!/usr/bin/python # -*- coding: UTF-8 -*- try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") except IOError: print "Error: 没有找到文件或读取文件失败" else: print "内容写入文件成功" fh.
【头歌系统Python实验】经典函数实例
学习的博客
12-12 2611
第1关：递归函数 - 汉诺塔的魅力 任务描述 在 Python 函数内部，我们可以去调用其他函数。所以如果一个函数在内部调用自身，这个函数我们就称为递归函数。本关我们将以汉诺塔的例子来感受递归函数的方法与应用。
python中--eq--函数规则
最新发布
05-19
在Python中，--eq--函数是一个特殊的方法，用于比较两个对象是否相等。该方法的使用非常广泛，例如，在使用==运算符时会自动调用该方法。 --eq--函数的规则如下： 1. 函数名称为__eq__。 2. 函数需要接收两个参数self和other，self代表当前对象，而other代表另外一个对象。 3. 函数需要返回一个布尔值，True表示两个对象相等，False表示两个对象不相等。 如果没有定义__eq__函数，Python会默认使用is运算符来比较两个对象是否相等。这意味着只有在两个对象的引用指向同一个内存地址时才会返回True。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值