liuliuya's blog
0%

函数

发表于 更新于 分类于

python的第六节课笔记（基础提升）

函数：一个可以重复使用的，用于实现单一或者相关功能的代码块。

语法结构：

1
2
3
4
def 函数名():
    函数体代码块(你想要完成的具体功能)
    
函数名()  # 函数的调用

注意：

  • def 用于定义函数的关键字
  • 函数只有在调用了之后才会执行
  • 函数名和变量名一样都是标识符，命名规则一致
  • 函数名和变量名一样，可以进行互相传递
  • 变量名重复会覆盖掉原来的值
1
2
3
4
5
#函数名和变量名一样，可以进行互相传递

a = 10
wy = a
print(wy)  # wy = a = 10 , wy的值为10， 变量的值可以互相传递
1
2
3
4
5
6
7
8
9
10
def qc():
    print("今天在上课")

print(qc)  # 直接打印函数名， 返回的是qc函数在内存当中的地址
xq = qc  # 传递的函数名，不许要加括号！！！
print(xq)  # 打印的结果与qc一致，说明就是同一个东西
#<function qc at 0x000002213F773E20>
#<function qc at 0x000002213F773E20>
qc()  #今天在上课
xq()   #今天在上课

这是一个判断是不是手机号的代码：

1
2
3
4
5
6
7
8
9
10
11
while True:
    number = input("请输入一个电话号码：")
    if number[0] != "1":
        print("不是1开头")
    elif len(number) != 11:
        print("长度不是11位")
    elif not number.isdigit():  # 不是纯数字
        print("不是纯数字")
    else:
        print("是一个手机号！！")
        break  # 正确的时候结束循环

现在把它定义为一个判断电话号码的函数;

1
2
3
4
5
6
7
8
9
10
11
12
13
def is_tel():  # 定义一个判断电话号码的函数
    number = input("请输入一个电话号码：")
    if number[0] != "1":
        print("不是1开头")
    elif len(number) != 11:
        print("长度不是11位")
    elif not number.isdigit():  # 不是纯数字
        print("不是纯数字")
    else:
        print("是一个手机号！！")


is_tel()

返回值：

语法 关键字 解释
return 想要返回的值 return 回函数体里面的值

注意：

  • 返回的位置： 函数的调用处
  • 返回值可以使用变量接收。 变量 = 函数名()
需求：完成两个数的相加，并且获取到结果
1
2
3
4
5
6
7
8
9
10
11
def my_sum():
    """
    求和函数
    """
    he = 4 + 28
    return he


res = my_sum()
print(res)   #32
print(my_sum())   #32

上面存在的BUG: 只能求固定值的和
目的：让函数变得更加灵活，可以求任意两个数的和
方法：给函数增加参数

必备参数：

形参：变量的名字写在函数定义处
实参：变量的值写在函数的调用处

需求：求任意数的和
1
2
3
4
5
6
7
#只需要通过传递不同的参数就可以完成不同数的求和
def my_sum(a, b):  #形参
    he = a + b
    return he

res = my_sum(4, 28)   #实参
print(res)  #32
1
2
3
4
5
6
7
8
9
#只需要用户通过传递不同的参数就可以完成不同数的求和
def my_sum(a, b):  #形参
    he = a + b
    return he

c = float(input("请输入一个数："))
d = float(input("请输入一个数："))
res = my_sum(c, d)   #实参
print(res)

注意：

  • 形参与实参是一一对应原则
  • 用实参给形参传递具体的值的过程称为–>传参

默认值参数：

BUG: 在必备参数中，形参和实参个数不一致，会报错

需求：定义一个函数，将两数之和默认增加100（可以指定增加的值）之后返回
1
2
3
4
#end="_"和sep="$"
print(1, 2, 3)  # 没有指定sep，使用默认的空格
print(1, 2, 3, end="_")
print(1, 2, 3, sep="$")  # 指定sep为 $ , 值与值之间使用$进行隔开
1
2
3
4
5
6
def my_sum(a, b, c =100):
    he = a + b + c
    return he

print(my_sum(10,20))  # 没有给C传值，使用默认的100,130
print(my_sum(10,20,30))  # 给C传了值，使用的是传递进去的30,60

不定长参数：

不定长参数： 可以传入也可以不传入，不传入时默认为空元组和空字典

没有指定名称的参数 *args 以元组的形式进行接收
指定了名称的参数 **kwargs 以字典的形式接收多余的参数
指定名称：在函数的调用处以【变量名 = 值 】形式进行传参就叫做指定参数的名称。
1
2
3
4
5
6
7
8
def my_sum(a, b, *args, **kwargs):
    print("a的值", a)
    print("b的值", b)  # a 和 b 一一对应拿了前面的 1 和 2
    print("args的值", args)  # 3 4 5 没有指定名称
    print("kwargs的值", kwargs)

res = my_sum(1, 2, 3, 4, 5, jy="小鲸鱼", gq="搞钱小秘书")
print(res)  # 没有返回值， None

运行结果为：

需求：任意数求和
1
2
3
4
5
6
7
8
9
10
11
12
# 如何把 args 的值一个一个拿出来？
   # 方法一：对应元素个数的变量进行拆包
   # 方法二：for 循环
def my_sum(*args):
    print(args)
    he = 0  # 初始化和为0
    for i in args:
        he += i
    return he

r = my_sum(1,2,3,4,5,6)
print(r)
1
print(sum([1, 2, 3]))  # Python自带的，sum函数，对序列里面的元素进行求和

参数的顺序：

定义函数参数的时候,参数优先级： 必备参数 > 默认值参数 > 不定长参数
注意：

  • 指定名称的放在没有指定名称的后面
  • 不要和默认值参数名字一致

return 函数补充：

return 具有结束函数的功能，return后面的代码不再执行。
1
2
3
4
5
def fun1():
    return 1
    return 2

print(fun1())  #1

作用域：

一般情况下，看到缩进就要想到作用域的概念。
1
2
3
4
5
6
def fun2():
    a = 10

fun2()
a += 10
print(a)   #报错，函数有作用域，外面无法调用
但是注意：if条件和循环没有作用域的概念。
1
2
3
4
if True:
    a = 10

print(a)  #10

函数作用域：

local 局部作用域，即函数中定义的变量
作用范围小 优先级越高
enclosing 嵌套的父级函数的局部作用域
相对外面来说是局部
相对嵌套的子函数来说，是一个全局
global 全局作用域 自己定义的，写在最外面的变量
作用范围大 优先级越小
build-in 内建作用域，不需要定义，可以直接拿来用的; 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
QuanJu = 100  # 全局作用域，

def func3():
    JuBu = 200  # 局部作用域
    QuanJu = 1000
    print("局部",JuBu)
    print("全局", QuanJu)
    print("局部2号", QuanJu)  # 优先使用范围近的

    def func4():  # 嵌套在fun3里面的函数
        juBu_jubu = 10
        print(QuanJu)  # 可以访问
        print(JuBu)  # 可以访问

    func4()
    # print(juBu_jubu)  # 不可以访问

func3()
print(QuanJu)
#print(JuBu)  # 外面访问不了局部作用域

运行结果为：

在函数里面更改外面的值：

声明全局变量 global
声明局部变量 nonlocal 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
QuanJu = 100  # 全局作用域，

def func3():
    global QuanJu  # 将QuanJu当场全局变量来执行
    JuBu = 200
    QuanJu += 100  # QuanJu = QuanJu + 100
    print(QuanJu)
    def fun4():
        nonlocal JuBu
        JuBu += 300
        print(JuBu)

    fun4()

func3()
print(QuanJu)
#print(JuBu)  # 外面访问不了局部作用域

运行结果为：

闭包：

闭包最直接的作用就是可以访问外层的变量，因此可以起到函数内外沟通的桥梁。

注意：

  • 存在于嵌套关系的函数中
  • 嵌套的内部函数引用了外部函数的变量
  • 嵌套的外部函数会将内部函数名作为返回值放回
  • 把调用变成了返回函数名
作用：对于内部数据的保护。
1
2
3
4
5
6
7
8
9
10
11
12
13
def func5():
    Jubu = 200
    def func6():
        nonlocal Jubu  # 声明局部变量
        Jubu += 100
        print(Jubu)    #300
    # func6()  # 在调用外部函数的时候，内部函数会一起执行
    return func6  # 返回值位置为函数的调用处


func5()
a = func5()  # a = func6
a()  # func6()  函数名可以像变量一样进行传递

递归函数：

1
2
3
4
5
6
i = 5
j = 1
while i >= 1:
    j *= i  #累乘
    i -= 1
print(j)    #120
1
2
3
4
5
6
7
8
def f7(n):
    print(n)
    if n == 0:
        return 1
    else:
        return n * f7(n-1)

f7(5)

运行结果为：

匿名函数：

定义：lambda 参数1,参数2 ：表达式

注意：

  • lambda是定义匿名函数的关键字
  • 参数：个数不一致
  • 表达式：你希望这个函数要达到的目的
  • 特点：不需要返回值，直接在调用的时候返回表达式的结果
需求：定义一个函数，传入两个参数a b，完成次方的计算，a ** b

普通函数的定义及调用：

1
2
3
4
5
6
7
8
9
10
def cif(a, b):
    """
    这是一个求次方的函数
    :return:
    """
    mi = a ** b
    return mi  # 将求得的结果返回出去， 返回值的位置为函数的调用处

mi = cif(5, 4)  # 函数只有在调用之后才会执行
print(mi)    #625

匿名函数的定义及调用：

1
2
cif2 =lambda x, y: x ** y
print(cif2(2, 4))      #16