Python函数和Lambda表达式

1 函数

通过def关键字可以自定义一个函数

函数的基本定义：

  • 具有独立功能的代码块
  • 函数的核心作用实现代码复用，提高代码的效率
  • 函数一般分为两种类型
    • 内建函数，python已经定义的函数可以直接使用
      • print() 打印
      • input() 输入
      • eval() 字符串转化为其他数据类型
      • int() 转化为整型
      • float() 转化为浮点型
      • tuple() 转化为元组
      • list() 转化为列表
      • set() 转化为集合
      • dict() 转化为字典
      • type() 查看变量类型
      • len() 查看变量长度
      • id() 查看变量内存地址
      • range() 与for构造循环体
    • 自定义函数：由开发人员使用def关键字定义一个功能封装成函数
  • 不管是内建函数还是自定义函数，调用格式都一样
    • 函数需要手动调用才会执行　　　　　
    • 调用方式：函数名()　　　

1.1 创建函数

函数三要素（函数的签名）：

  1. 名字
  2. 参数：数量和类型(形参的类型可以指定python中任意的数据类型)
  3. 返回值：类型（返回值类型可以指定python中任意的数据类型）
?
1
2
3
4
5
6
7
8
def add(a:int,b:int)->int:
    return a+b
 
def add(a,b)->int:
    return "123"
 
def add(a,b):
   return a+b

两个关键字：def return
返回类型是可选的，而非强制，不会进行类型转换
->申明函数返回值的类型

复制代码
 1 #返回值类型可以指定，但是 不是指定类型只会警告
 2 def login(username:str,password:str)->str:
 3     print(f"您的账号是{username}")
 4     if password=="888888":
 5         return "登录成功"
 6     else:
 7         return "登录失败"
 8 
 9 msg=login("admin","888888")
10 print(msg)
11 print(login(123,888888))#可以不按照指定类型传参，但是程序会警告
复制代码

1.2 使用函数

根据函数的三要素来进行使用：
名字：加括号
参数：放在括号中进行传递
返回值：名字左边通过=接收返回值

 

函数:

  • 可以作为参数传递
  • 可以作为返回值返回
  • 可以修改名字
  • 新的覆盖旧的

1.3 函数的参数

1.3.1 位置参数

通过参数的位置，觉得参数传递给了谁

?
1
2
3
4
5
6
def add(a:int,b:int)->int:
    return a+b
 
i=add(1,3) #1传递给了谁，3传递给了谁 位置参数
i=add(b=100,a=1) #1传递给了谁，100传递给了谁 关键字参数
i=add(1,b=100) #1个位置参数，一个关键字参数 ，位置参数和关键字参数出现时，位置参数在前 关键字参数在后

1.3.2 关键字参数 b=100

总结：位置参数和关键字参数，是由传参方式决定的

1.3.3 默认参数（可选参数）

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def add(a,b=12): #位置参数在前 关键字参数在后
    return a+b
 
i=add(2)
i=add(2,5)
i=add(2,b=5)
 
def f(x,l=[]): #参数中的默认，并不是在每一次调用函数的时候，重新创建
    l.append(x)
    print(l,id(l))
 
f(1)
f(2)
f(3) #会继续使用第一次创建的列表
 
 
def f(x,l=None):
    if l is None:
        l=[]     #在每次调用函数时，重新创建列表
    l.append(x)
     
    print(l,id(l))

总结：

  • 有默认值的参数，在调用函数时，允许不传递，这时将使用默认值
  • 默认值避免使用可变对象
  • 有默认值的参数（关键字参数），应该在没有默认值参数的后面

1.3.4 不定长参数

?
1
2
3
4
5
6
7
8
9
10
def add(a=1,b=10,*args,**kwargs):
       return a+b
 
i=add()
i=add(3)
i=add(1,b=100)
i=add(1,100)
i=add(a=80,b=20)
i=add(1,2,3,4,5,6,7,8,)
i=add(1,2,lisi=19)

　　

总结：

  • *可以接受不定长（任意数量）的位置参数，存储为元组
  • ** 可以接受不定长（任意数量）的关键字参数，存储为字典
  • 位置参数在前，关键字参数在后

1.4 函数返回值

函数的返回值(可选返回值)
如果没有通过return指定返回值，将返回一个默认值：None

None 特殊的数据类型，类似于其他语言中的

Null 表示“无”，不可变，不可创建

多个返回值
python只能指定一个返回值
如果需要将多个数，同时返回，可以将其打包在同一个容器数据中：元组，列表，字典

1.5 闭包函数

1.5.1 函数的引用

函数的引用可以进行赋值，然后进行调用

复制代码
 1 def a():
 2     print("a函数被调用了")
 3 
 4 #函数的引用就是函数的名字
 5 a()
 6 #函数引用可以进行赋值
 7 b=a
 8 #b就复制了a函数的引用
 9 #那么b()=a()
10 b()
复制代码

闭包的定义：在函数的嵌套前提下，内部函数使用了外部函数的变量，并且外部函数返回了内部函数的引用（名字）

闭包的核心是内部函数使用了外部函数的变量，这个过程叫做闭包

闭包的意义是函数被调用完之后，函数内的局部变量会被销毁，为了方便保存外部函数变量在内部进行使用形成了闭包

复制代码
 1 def func_out(num1):
 2      def func_innner(num2):
 3          result=num1+num2
 4          print(f"外部函数的值:{num1},内部函数的值{num2},相加的结果为{result}")
 5 
 6      return func_inner
 7 
 8 # 闭包函数的执行过程
 9 f=func_out(100) #1--2(会将func——inner加载到内存但是不执行(不会执行第3，4行代码))--6---9
10 #f=func_inner
11 #f()=func_inner()
12 f(200)#2--3--4--12
复制代码

闭包的构成条件：

  • 一定要在函数的嵌套前提下构成、
  • 内部函数一定要使用到外部函数的值
  • 外部函数一定要返回了内部函数的引用

闭包的作用：

闭包可以保存外部函数的值，不会随着外部函数调用完之后被销毁

内部函数的引用（内部函数的名字），可以赋值给一个变量，那么该变量加上()那么久可以调用被指向的函数引用

1.6 函数的递归

递归：函数自己调用自己

?
1
2
3
4
5
6
7
8
def add():
   i=1;
   sum+=i;
   if sum>100
      return
   else:
       print(sum)
       add()

1.7  匿名函数--Lambda表达式

通过lambda表达式创建，一个没有名字的函数

关键字 lambda

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去

#有名字的匿名函数
add=lambda a,b:a+b
add(1,2)

#没有名字的匿名函数
print((lambda x,y:x+y)(111,222))

和普通函数的区别：　　

  1. 使用lambda关键字，而不是def创建 
  2. 创建时：不需要指定名字，不需要指定返回值
  3. 不可以包含注释
  4. 不可以包含语句块
#匿名函数可以有名字，也可以没有
#通过lambda关键字进行定义
print((lambda x, y: x + y)(1, 2))
print((lambda x, y: x + y)(111, 222))

func1=lambda x,y:x*y
print(func1(6,6))

匿名函数的特点：

  • 匿名函数可以有名字，也可以没有
  • 匿名函数调用的时候跟普通函数一样，通过()进行调用
  • 匿名函数不写return关键字也有返回值

难点是什么？

  • 定义函数时，创建作用域
  • 当匿名函数出现在函数中的时候，创建闭包作用域，错吧闭包的问题，当成匿名函数的问题

说明：

  • 函数可以作为变量进行传递
  • 变量可以作为函数执行
  • 作用域在定义函数的时候已经确定了

1.8 相关练习

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#1.创建名为f1的函数，不接收任何参数，返回None
def f1():
    pass
 
#2.创建名为f2的函数，接收2个整数参数，返回他们相加结果
def f2(a:int,b:int=10)->int:
    return a+b
 
#3.创建名为f3的函数，接收任意个参数，返回他们相加的结果
def f3(*args):
    r=None
    for arg in args:
        if r is None:
            r=arg
        else:
            r=r+arg
    return r
 
#4.创建名为f4的函数，接收一个必填参数，用来标记加法还说减法，在接收任意个参数
#返回他们相加（或相减）的结果
 
def f4(a:str,*args):
    result=None
    for i in args:
        if result is None:
            result=i
        elif a=="+":
            result+=i
 
        elif a=="-":
            result-=i
 
    return result
 
#5.创建名为f5的函数，接收一个函数，并返回另个函数
#可以将函数看为一个变量
def f5(func):
    return func
 
print(f"f1函数结果: {f1()}")
print(f"f2函数结果: {f2(3,b=6)}")
print(f"f3函数结果: {f3()}")
print(f"f3函数结果: {f3(5,6)}")
print(f"f3函数结果: {f3([1],[2])}")
print(f"f3函数结果: {f3(3,6,9,8,7)}")
print(f"f4函数结果：{f4('+')}")
print(f"f4函数结果：{f4('-')}")
print(f"f4函数结果：{f4('+',1,2,3)}")
print(f"f4函数结果：{f4('+',[1],[2])}")
print(f"f4函数结果：{f4('-',60,2,3,5)}")
 
print(f"f5函数返回结果：{f5(input('1'))}")
 
 
#有字符串s="SDAaSAbB#f$^d$^ss*fg&2er13t",编写代码找出字符串中所有的小写字母
s="SDAaSAbB#f$^d$^ss*fg&2er13t"
 
for i in s:
    #if i.islower():
    if 'a'<=i<='z':
        print(i)

　　

 

posted @   万溪汇海  阅读(66)  评论(0)  编辑  收藏  举报
相关博文：
· C语言之函数
· python 生成器
· 5.0 Python 定义并使用函数
· 2024年6月16日 Python - 函数
· python-函数与 Lambda 表达式
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 记一次.NET内存居高不下排查解决与启示
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
点击右上角即可分享
微信分享提示