函数基础二

最新推荐文章于 2024-10-17 08:00:29 发布

diesouxi2722

最新推荐文章于 2024-10-17 08:00:29 发布

阅读量147

点赞数

文章标签： python

原文链接：http://www.cnblogs.com/allenchen168/p/11559787.html

版权

可变长参数

两种可变长形参

*形参名

def f1(*args):   # 调用函数时，有多少个位置实参，就接收多少个参数，组成元组
    print(args)
 
f1()   # 打印结果：()   # a是空元组
f1(1)  # 打印结果：(1, )  #注意有逗号
f1(1, 2)  # 打印结果：（1，2）
f1(1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 7, 7, 7, 7, 7, )

*args (约定俗称的),用元组接收多余的位置实参

**形参名

def f1(**kwargs):   # 调用函数时，有多少个关键字实参，就接收多少组参数，组成字典
    print(kwargs)

f1(x=1)  # 打印结果：{}   # 空字典

**kwargs,用字典接收多余的关键字实参

两种可变长实参

以下仅作了解

*实参

def f1(a, b, c, e, d, f, g):
    print(a, b, c, e, d, f, g)

lt = [1, 2, 3, 4, 5, 6, 7]
f1(lt[0],lt[1],lt[2],lt[3],lt[4],lt[5],lt[6])  # 一一传值
f1(*lt)  # *lt把列表中的元素打散成位置实参依次传给位置形参

**实参

def f1(a, b):
    print(a, b)

dic = {'a': 1, 'b': 2}  # a=1,b=2
f1(**dic)  # **dic把字典打散成关键字实参然后传给函数f1

函数对象

python中一切皆对象，函数也可以当作对象，有以下四大功能：

引用（拷贝）
当作容器类元素
当作函数的实参
当作函数的返回值

1、引用

def s():  # 定义函数s
    a = 10
    print(a)

x = s  # 引用函数s
x（）  # x引用了函数s后也继承了函数的特性

2、当作容器类元素

def s():  # 定义函数s
    a = 10
    return a

lt = [1,s]  # 把函数s当作列表元素
print（lt[1]）  # 打印结果为函数s的地址：<function s at 0x000001DBE30F1E18>
print（lt[1]（））  # 打印结果为：10

3、作为函数的实参

def s():  # 定义函数s
    a = 10
    return a

def f1(b):  # 定义函数f1，b为形参
    c = b() + 5
    print(c)

f1(s)  # 把函数s当作实参传值给形参b

# 打印结果为：15

4、作为函数的返回值

def s():
    print('from s')

def f(a):
    """代码"""
    return s  # 函数s作为返回值，用于执行完函数f的功能后就返回函数s以供调用

res = f(2)
print(res)
res()

字典/列表/元组/集合/布尔值，所有对象都可以做以上四件事情

函数对象 == 函数名 # 函数名不带()

函数名() # 函数名带括号就是在调用函数

函数嵌套

for循环的嵌套

打印九九乘法表

for i in range(1,10):
    for j in range(i):
        print(f'{j+1}*{i}={(j+1)*i}'',end='\t')  # \t是制表符，强制对齐
    print()   # 用于换行，每个i值的j循环完后就换行

打印结果为：

1*1=1   
1*2=2   2*2=4   
1*3=3   2*3=6   3*3=9   
1*4=4   2*4=8   3*4=12  4*4=16  
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25  
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36  
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49  
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64  
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

函数嵌套：函数里边定义函数

函数在调用之前只检测语法，不执行代码

函数内部定义的函数，外部不能调用

函数嵌套调用实例：

def max2(x,y):  # 定义第一个函数，
    if x > y:
        return x
    else:
        return y

def max4(a,b,c,d):  # 定义第二个函数
    res1 = max2(a,b)  # 调用第一个函数
    res2 = max2(c,d)  # 调用第一个函数
    res3 = max2(res1,res2)  # 调用第一个函数
    return res3

print(max4(1,2,3,4))

这就是函数的调用，函数max4 里边嵌套调用了 max2 这个函数