Python函数

1. 函数

1.1 函数是什么?

　　函数一词来源于数学，但编程中的「函数」概念，与数学中的函数是有很大不同的，具体区别，我们后面会讲，编程中的函数在英文中也有很多不同的叫法。在BASIC中叫做subroutine(子过程或子程序)，在Pascal中叫做procedure(过程)和function，在C中只有function，在Java里面叫做method。

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

减少重复代码
使程序变的可扩展
使程序变得易维护

1.2 函数的定义与调用

函数先定义后调用，先调用会报错
没有调用函数，函数里的代码不会执行
函数的执行流程：
- 调用函数时，解释器回到定义函数的地方执行函数体内的代码，代码执行完回到调用代码的地方，继续向下执行
- 定义函数时，函数体内部的代码不会执行

def sayhi():# sayhi 函数名
    print("Hello, I'm nobody!")
sayhi() # 调用函数

1.3 带参函数

# 下面这段代码
a,b = 5,8
c = a**b
print(c)
  
   
# 改成用函数写
def calc(x,y):
    res = x**y
    return res # 返回函数执行结果
  
c = calc(a,b)  # 结果赋值给c变量
print(c)

1.3.1 函数参数

　　形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量

　　实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

def calc(x,y):  # x,y形参
      res = x**y
      return res
calc(1,2)   # 1,2实参，也是位置参数

1.3.2 默认参数

def test(x,y=1):   # y 就是是默认参数
      print(x)
      print(y)
test(21)          # 如果y的实参不写，默认y=1
test(21,22)　　　　# y 有实参，就不会用默认值

1.3.3 关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但是关键参数必须放到位置参数后

def test(x,y): 
      print(x)
      print(y)

test(x=2,y=1)

1.3.4 非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

　　*args　　会把传入的参数变成一个元组

def test1(x,*args):    
      print(x)
      print(args)
test1(21)
#结果: 21 ()     # 后面这个()就是args,只是因为没传值,所以为空
 
test1(1,2,3,4) 
#结果：1 (2,3,4)

还可以有一个**kwargs

**kwargs　　会把传入的关键字参数打包成字典

def test1(x,*args,**kwargs):    
      print(x)
      print(args)

test1(21)
#结果：21 () {} #后面这个{}就是kwargs,只是因为没传值,所以为空

test1(21,12,22,name='alex',age='8')
#结果：21,(12,22),{'name':'ale','age':'6'}

在调用出使用*或**

*　　把元组或列表进行解包
**    把字典进行解包

def test(*args,**kwargs):
    print(args)
    print(kwargs)

lis = [1,2]
dic = {"name":"Jack","age":18}
test(*lis,**dic)    # 相当于 test(1,2,name="Jack",age=18)

2. 局部变量与全局变量

2.1 全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

2.2 特殊

列表，字典，集合，类可以在局部变量里修改。
字符串和整数不可以在局部变量里修改

def change_name(name):
    print("before change",name)
    name="Alex li"
    age=23
    print("sfer change",name)

name='alex'
change_name(name)
print(name)

#输出 
before change alex
sfer change Alex li
alex

2.3 return 返回值

　　要想获取函数的执行结果，就可以用return语句把结果返回

注意:

函数在执行过程中只要遇到return语句，就会停止执行并返回结果，也可以理解为 return 语句代表着函数的结束
如果未在函数中指定return，那这个函数的返回值为None

3. 递归函数

　　在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

def test(x):
    print(x)
    if int(x/2) > 0:
        return test(int(x/2))
test(10)

递归特性:

必须有一个明确的结束条件
每次进入更深一层递归时，问题规模相比上次递归都应有所减少
递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

4. 高阶函数

　　变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数.

# abs() 函数的作用：数字求绝对值的计算
def add(x,y,f):
      return f(x)+f(y)
res = add(3,-6,abs)
print(res)

5. 闭包函数

闭包的定义:

内函数使用外函数的局部变量，外函数将内函数返回出来的方法叫闭包，返回的内函数叫闭包函数.

闭包的特点:

延长了外函数局部变量的生命周期(实际内存给它存储了这个值,暂时不释放)

闭包的意义:

闭包可以优先使用外函数中的变量，并对闭包中的值起到了封装保护的作用。外部无法访问。

def test():
    name = "Jack"
    age = 18
    def youName():
        print("他的名字叫{}。".format(name))
    def youAge():
        print(f"{name}今年{age}岁了。")

    def master():
        return [youName,youAge]
    return master
func = test()
lis = func()
print(lis)
he_name = lis[0]
he_name()
he_age = lis[1]
he_age()

5.1 closure 和 cell_contents

__closure__　 # 判断是不是闭包
cell_contents　 # 获取对象中的内容

tup = func.__closure__    # 如果返回的元组中有数据说明是闭包
print(tup)                # 打印返回值 
func1 = tup[0].cell_contents    # 获取第一个元素对象中的内容
func1()
func2 = tup[1].cell_contents    # 获取第二个元素对象中的内容
func2()

6. 匿名函数

　　用一句话来表达只有返回值的函数

特点：简洁，高效

语法：

lambda 参数 : 表达式

无参的lambda表达式

# 函数
def func():
    return "无参的 lambda 表达式"

# lambda 表达式
func_lam = lambda :  "无参的 lambda 表达式"
print(func_lam())    # 打印结果

有参的lambda表达式

# 函数
def func(n):
    return "有参的 lambda 表达式，参数：{}".format(n)

# lambda 表达式
func_lam = lambda n :  f"有参的 lambda 表达式，参数：{n}"
print(func_lam("90"))   # 打印结果

可变参数的表达式

# *args 表达式
res = lambda *args : args
print(res(1,2,3))

# **kwargs 表达式
res2 = lambda **kwargs : kwargs
print(res2(name="Kaer",age=18))

判断条件的lambda表达式

# 函数
def func(n):
    return "奇数" if n % 2 == 1 else "偶数"

# lambda 表达式
func_lam = lambda n :  "奇数" if n % 2 == 1 else "偶数"
print(func_lam(907))   # 打印结果

排序的lambda表达式

stu = [
    {"name":"Jack","age":18},
    {"name":"Kaer","age":22},
    {"name":"Tom","age":20}
]
stu.sort(key = lambda x:x["age"],reverse=True)
print(stu)

posted @ 2023-05-23 17:27 Crazy丶迷恋阅读(26) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Crazy丶迷恋