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中任意的数据类型）

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
返回类型是可选的，而非强制，不会进行类型转换
->申明函数返回值的类型

#返回值类型可以指定，但是 不是指定类型只会警告
def login(username:str,password:str)->str:
    print(f"您的账号是{username}")
    if password=="888888":
        return "登录成功"
    else:
        return "登录失败"

msg=login("admin","888888")
print(msg)
print(login(123,888888))#可以不按照指定类型传参，但是程序会警告

1.2 使用函数

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

 

函数:

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

1.3 函数的参数

1.3.1 位置参数

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

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 默认参数（可选参数）

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 不定长参数

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 函数的引用

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

def a():
    print("a函数被调用了")

#函数的引用就是函数的名字
a()
#函数引用可以进行赋值
b=a
#b就复制了a函数的引用
#那么b()=a()
b()

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

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

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

def func_out(num1):
     def func_innner(num2):
         result=num1+num2
         print(f"外部函数的值:{num1},内部函数的值{num2},相加的结果为{result}")

     return func_inner

# 闭包函数的执行过程
f=func_out(100) #1--2(会将func——inner加载到内存但是不执行(不会执行第3，4行代码))--6---9
#f=func_inner
#f()=func_inner()
f(200)#2--3--4--12

闭包的构成条件：

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

闭包的作用：

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

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

1.6 函数的递归

递归：函数自己调用自己

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.创建名为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)