python 函数

函数

函数定义

def funcName(argv): # def 是定义函数的标识符， funcName是函数名可用于外部调用 argv是函数入参，可以是需要函数处理的数据（0~多个）
    ....  # 函数体（可由多条或一条语句组成），前面由tab
    return # 函数执行到此结束，后面可跟函数的运行结果给调用的地方，可省略

局部变量和全局变量

• 局部变量：在函数内部有效的变量，作用域为整个函数
• 全局变量：可全局访问的变量，可在当前文件的各个函数中访问，但是如果需要该全局变量时，加global加以声明

# 以下两个函数中，num是各自函数中的局部变量
def printNum():
    num = 100
    numa = 200
    print("$$num ={},numa={}".format(num,numa))
def printNum1():
    num = 300
    numb = 400
    print("**num ={},numa={}".format(num,numb))
printNum()
printNum1()

$$num =100,numa=200
**num =300,numa=400

# 在访问别的函数中定义的局部变量时，会报该变量未定义
def printNum():
    num = 100
    numa = 200
    print("$$num ={},numa={}".format(num,numb))
def printNum1():
    num = 300
    numb = 400
    print("**num ={},numa={}".format(num,numa))
printNum()
printNum1()

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_3584/2901995658.py in <module>
      7     numb = 400
      8     print("**num ={},numa={}".format(num,numa))
----> 9 printNum()
     10 printNum1()


~\AppData\Local\Temp/ipykernel_3584/2901995658.py in printNum()
      2     num = 100
      3     numa = 200
----> 4     print("$$num ={},numa={}".format(num,numb))
      5 def printNum1():
      6     num = 300


NameError: name 'numb' is not defined

# 以下两个函数中，num是全局变量，在下面两个函数中都可以被访问
num = 100
def printNum():
    print("$$num =",num)
def printNum1():
    print("**num =",num + 5)
printNum()
printNum1()

$$num = 100
**num = 105

# num已经定义为全局变量，因此在printNum中赋值给num，函数不知道它是全局的还是局部的，就会报以下错误
num = 100
def printNum():
    num = num + 5
    print("$$num =",num)
def printNum1():
    print("**num =",num + 5)
printNum()
printNum1()

---------------------------------------------------------------------------

UnboundLocalError                         Traceback (most recent call last)

~\AppData\Local\Temp/ipykernel_3584/2736387970.py in <module>
      6 def printNum1():
      7     print("**num =",num + 5)
----> 8 printNum()
      9 printNum1()


~\AppData\Local\Temp/ipykernel_3584/2736387970.py in printNum()
      2 num = 100
      3 def printNum():
----> 4     num = num + 5
      5     print("$$num =",num)
      6 def printNum1():


UnboundLocalError: local variable 'num' referenced before assignment

# num已经定义为全局变量，因此在printNum中赋值给num，可先用global声明它是全局变量
num = 100
def printNum():
    global num
    num = num + 5
    print("$$num =",num)

# 在printNum中对全局变量num做了改变，因此在下面函数中，num已经变为105
def printNum1():
    print("**num =",num + 5)
printNum()
printNum1()

$$num = 105
**num = 110

形参和实参

• 形参就是定义函数时，定义的参数变量，它也是函数的局部变量
• 实参就是在调用函数时，传入函数的实际参数

def add(a,b) # a,b是形式参数，相当于add函数中的局部变量
    return a + b
c = add(3,4) # 3,4是调用函数时传入的实际参数变量
print("c = ",c)

无参无返回值函数

def printHello():
    print("hello")

printHello()

hello

无参有返回值函数

num = 100 # 全局变量，可在当前文件的所有函数中被引用
def updateNum():
    global num   # 在函数中，要修改全局变量，需要使用global进行声明
    num = num + 5;
    return num
print(updateNum())
print(updateNum())

105
110

有参无返回值函数

def printInfo(name,age):
    print("name is {},age is {}".format(name,age))
printInfo("lisi",20)

name is lisi,age is 20

有参数有返回值函数

# 以下是个简单的函数实现，a,b是两个入参，需要计算的数据，该函数最终会返回两数之和
def add(a,b):
    return a + b

print(add(2,3))
print(add(23,3))

5
26

• 函数的一大作用就是将一部分重复使用的代码封装起来，方便调用

# listShow是一个用于遍历列表的接口,此函数不需要返回值
def listShow(ls):
    for l in ls:
        # print默认的结束符是换行，如果不需要换行，可以指定end
        print(l,end=' ')
    print()
ls = [1,2,3,4]
listShow(ls)
print("*"*5)
ls = ['a','s','d']
listShow(ls)

1 2 3 4 
*****
a s d 

函数默认参数

在定义函数时有了默认参数，可以使我们在调用函数时传入参数比实际定义的参数少，例如上面使用的print函数，其中end就是个默认参数，默认值为换行

# 一般默认的参数，唯一参数列表的末尾
def studentInfo(name, sex, age = 18):
    #以下是元组赋值
    info = name,age,sex
    return info
# 当不指定age时，，默认是18
print(studentInfo("liming","man"))
print(studentInfo("张三","man",20))

('liming', 18, 'man')
('张三', 20, 'man')

def dateUpdate(value,key=None,st={}):

    if str(type(st)).find("dict") != -1:
        st.update({key:value})
    elif str(type(st)).find("list") != -1:
        st.append(value)
    return st
print(dateUpdate(18,"age"))
print(dateUpdate("zhangsan","name"))
print(dateUpdate(2,st=[]))
print(dateUpdate(3,))

{'age': 18}
{'age': 18, 'name': 'zhangsan'}
[2]
{'age': 18, 'name': 'zhangsan', None: 3}

可变参数

# *agrv表示一个可变参数，，sep是默认参数，放在最后
# 可变参数后面只能跟关键字参数，要不然使用位置参数不知道这可变参数到哪结束，或者*argv就放在最后
def strCat( *argv,sep="-"):
    sep.join(argv)
    
s = strCat("my","name","is","lisi")
print(s)

def addNum(*argv):
    sum1 = 0
    for i in argv:
        sum1 += i
    return sum1
print(addNum(1,2,3,4,5))

None
15

• 传入元组和列表

def addNum(nums):
    print(type(nums))
    sum1 = 0
    for i in nums:
        sum1 += i
    return sum1
l = [3,4,5,6,7]
print(addNum(l))
print("****")
t = (3,4,5,6,7)
print(addNum(t))

<class 'list'>
25
****
<class 'tuple'>
25

• 传入字典

def printDict(argv):
    print(type(argv))
    for key,value in argv.items():
        print("key = {},value = {}".format(key,value))
d = {"name":"lisi","age":18}
printDict(d)

<class 'dict'>
key = name,value = lisi
key = age,value = 18

lambda表达式

lambda表达式用于定义一个匿名函数

函数名 = lambda [参数列表]:表达式

func = lambda x:x+2
print("*"*5 + "func" + "*"*5)
print(func(1))
print(func(2))
print("*"*5 + "funcc" + "*"*5)
funcc = [lambda x : x + i for i in range(5)]
# funcc 是一个函数列表
print(funcc[1](1))
print(funcc[3](2))

*****func*****
3
4
*****funcc*****
5
6

lambda表达式做入参

def add2(num,func):
    return func(num)
print(add2(3,lambda x:x+2))

5

内部函数

def func():
    l = [5,3,3,4]
    # 内部函数
    def inner_func(l1):
        l1 = l1 * 2
        l1.sort()
        return l1
    
    # 调用内部函数
    print(inner_func(l))
    print(l)

    l = [6,4,3,2,7,4]
    print(inner_func(l))
    print(l)
    
func()

[3, 3, 3, 3, 4, 4, 5, 5]
[5, 3, 3, 4]
[2, 2, 3, 3, 4, 4, 4, 4, 6, 6, 7, 7]
[6, 4, 3, 2, 7, 4]

闭包

# 闭包
'''
在一个函数中定义一个内部函数，其中内部函数包含了函数中定义的其他变量，且函数的返回值就是该内部函数
'''
def func():
    num = 100
    # 内部函数
    def inner_func():
        nonlocal num
        num += 105
        print(num)
    # 打印出func的locals 变量(inner_func,num)
    print(locals())
    # 返回内部函数
    return inner_func
    
f = func()
print(f)
f()

{'inner_func': <function func.<locals>.inner_func at 0x000001E2308F0160>, 'num': 100}
<function func.<locals>.inner_func at 0x000001E2308F0160>
205

def func(num):
    count = 10
    def tenfold_func():
        print(num * 10)
    return tenfold_func
# 闭包返回的内部函数是会保存函数参数的
# f1 中num == 10
f1 = func(10)
print("f1:")
f1()
# f2 中num == 5
f2 = func(5)
print("f2:")
f2()
print("f1:")
f1()
'''
闭包相当于延长了num的作用域（之前作用域只在func内部）
但是num不会随着func的结束而销毁，因此相应的内存就不会被释放
'''

f1:
100
f2:
50
f1:
100