Python函数详解

2022.4.7
此文章重度参考python中的函数

一、函数的定义以及调用
定义函数：
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它

def 函数名（）：
   代码块
   print（）输出

调用函数
函数的调用方式

函数名([实参列表])

b = 300
def shiyan3(x,y):
    return x+y+b
shiyan3(6,5)
输出 此函数无输出
b = 300
def shiyan3(x,y):
    print(x+y+b)#将return替换为print
shiyan3(6,5)
输出 311
def shiyan4():
    b = 20
    return b
shiyan4() #return返回只是将50返回到shiyan4()这个函数中 不会主动输出 需要print函数才能输出
输出 此函数无输出
def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age
result = get_my_info()
print(result)
输出 输出为一个元组(178, 100, 18)
def test1():
    # 通过return将一个数据结果返回
    return 50
print(test1())#当函数没有形参却有实际的返回值时 需print函数将返回的函数值输出出来
输出  此函数输出50 
体会与上一个函数的区别
def shiyan4():
    b = 20
    print(b)
shiyan4()
输出 此函数的输出为20

再看函数的输出

def now():
     print('2015-3-25')
f = now
print(f)#输出  <function now at 0x000001FC37746280>
print(type(f)) #输出 <class 'function'>
f1 = now()
print(f1) #输出 2015-3-25
print(type(f1)) # 输出 None
now.__name__#不会有任何输出
print(now.__name__) #输出 now
print(f.__name__) #输出 now
#print(f1.__name__) 输出 AttributeError: 'NoneType' object has no attribute '__name__'

def function2():
    return {"key1": 1, "key2": 2, "key3": 3}
print(type(function2)) # 输出 <class 'function'>
print(type(function2())) #输出 <class 'dict'>

def test1():
    return 56
test1()
print(type(test1()))#输出 <class 'int'>
g = test1()
print(g)#输出 56
print(type(g)) #输出  <class 'int'>

def test2():
    print(75)
test2() #输出 75
print(type(test2())) #输出 75 None
g2 = test2()
print(g2)#输出 None

def test3():
    print(66)
    return 233
test3()#输出 66
print(type(test3())) #输出 66 <class 'int'>
g3 = test3()#输出 66
print(g3)#输出 233

def test4():
    print('888')
    return 'test4'
print(type(test4()))
#输出 888
#<class 'int'>
#从输出可以看出此时不算test4()函数的返回值 仅看print的值
print(test4())
#输出 888
#test4

def test5():
    print('ceshi5')
    return 'test5'
test5()#代码意为调用函数test5() 此时函数的返回值是test5
#输出 ceshi5
print(test5())
#输出 ceshi5 和 test5
#print函数首先会将括号内函数运行一遍 首先输出ceshi5
#之后再将test5()函数的返回值test5输出

def test6():
    print('999')
    print('ceshi6')
    return [21,66]
test6()
#输出 999 ceshi6
#即把所有print都输出
print(type(test6()))#无输出
#输出
#999
#ceshi6
#<class 'list'>由输出可以看出type对应的是return后的值
print(test6())
#输出 所有print以及return
# 999
#ceshi6
#[21, 66]

定义完函数后，函数是不会自动执行的，需要调用它才可以
每次调用函数时，函数都会从头开始执行，当该函数中的代码执行完毕，意味着调用结束
如果函数中执行到了return也会结束函数

二、函数中的参数
形参：定义时小括号中的参数，用来接收参数用的，称为 “形参”
实参：调用时小括号中的参数，用来传递给函数用的，称为 “实参”

def add2num(a, b):
    c = a+b
    print c

add2num(110, 22) # 调用带有参数的函数时，需要在小括号中，传递数据

1）缺省参数（默认参数）
在形参中默认有值的参数，称之为缺省参数
调用函数时，缺省参数的值如果没有传入，则取默认值。
注意：带有默认值的参数一定要位于参数列表的最后面

def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)
   print("age %d" % age)

# 调用printinfo函数
printinfo(name="miki")  # 在函数执行过程中 age去默认值35
printinfo(age=9 ,name="miki")
输出
name: miki
age: 35
name: miki
age: 9

但如果不规范书写，即默认参数不写在形参列表的最后。

>>> def printinfo(name, age=35, sex):
...     print name
...
File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

2）不定长参数（关键字参数、命名关键字参数）
不定长参数：有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。
*args是用于接收多余的未命名参数，**kwargs用于接收形参中的命名参数，其中args是一个元组类型，而kwargs是一个字典类型的数据
基本语法：

def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]
注意：
加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.

def fun(a, b, *args, **kwargs):
    print("a =%d" % a)
    print("b =%d" % b)
    print("args:")
    print(args)
    print(args) #*args 相当于 a,b = args
    print("kwargs: ")
    print(kwargs)
    #print(**kwargs) 错误代码
    报错 TypeError: 'm' is an invalid keyword argument for print()
    for key, value in kwargs.items():
    #for key, value in kwargs():这样写是错误的 
    #TypeError: 'dict' object is not callable
        print("key=%s" % value)
fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
#调用*args时输入与非关键字参数的输入形式相同
#调用时**kwargs的对应输入是 key=value形式 输出的是一个字典	
输出
a =1
b =2
args:
(3, 4, 5)#输出的是一个元组
3 4 5
kwargs: 
{'m': 6, 'n': 7, 'p': 8}#输出的是一个字典
key=6
key=7
key=8

3）缺省参数（默认参数）在args（关键字参数）或者**kwargs(命名关键字参数)后面
默认参数必须在args或者kwargs之后，不能位于形参之后，否则会输出报错
若很多个值都是不定长参数，这种情况下，可以将默认参数放到 *args或kwargs的后面，
但如果有**kwargs的话，**kwargs必须是最后的

def sum_nums_3(a, *args, b=22, c=33, **kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)
sum_nums_3(100, 200, 300, 400, 500, 600, 700, b=1, c=2, mm=800, nn=900)
#正确代码 默认参数放在*args参数之后**kwargs参数之前 可以正常输出
此时默认参数的值发生改变
sum_nums_3(100, 200, 300, 400, 500, 600, 700, mm=800, nn=900)
#正确代码 默认参数值不发生改变
sum_nums_3(100, 200, 300, 400, 500, 600, 700, mm=800, nn=900, b=1, c=2)
#正确代码 默认参数放在**kwargs参数之后 可以正常输出
默认参数的值已发生改变 
#sum_nums_3(100, b=1, c=2, 200, 300, 400, 500, 600, 700, mm=800, nn=900)
错误代码 默认参数放在*args之前 不能正常输出
SyntaxError: positional argument follows keyword argument
sum_nums_3(100, b=1, c=2, mm=800, nn=900)
#正确代码 *args输出一个空元组 后面**kwargs的输出正常
#sum_nums_3(100, mm=800, nn=900, 200, 300, 400, 500, 600, 700, b=1, c=2)
错误代码 **kwargs的参数放在*args之前不能正常输出
SyntaxError: positional argument follows keyword argument
输出
100
1
2
(200, 300, 400, 500, 600, 700)
{'mm': 800, 'nn': 900}#**kwargs 命名关键字参数输出为一个字典

100
22
33
(200, 300, 400, 500, 600, 700)
{'mm': 800, 'nn': 900}

100
1
2
(200, 300, 400, 500, 600, 700)
{'mm': 800, 'nn': 900}

100
1
2
()#当*args（关键字参数）没有传入输入值的时候 其输出为一个空元组 输出不为None
{'mm': 800, 'nn': 900}

三、函数的返回值
所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果
注意：return除了能够将数据返回之外，还有一个隐藏的功能：结束函数

返回值的理解

现实生活中的场景:
我给儿子10块钱，让他给我买包烟。这个例子中，10块钱是我给儿子的，就相当于调用函数时传递到参数，让儿子买烟这个事情最终的目标是，让他把烟给你带回来然后给你，
此时烟就是返回值

开发中的场景：
定义了一个函数，完成了获取室内温度，想一想是不是应该把这个结果给调用者，只有调用者拥有了这个返回值，才能够根据当前的温度做适当的调整

1）带有返回值的函数

#定义函数
def add2num(a, b):
    return a+b

#调用函数，顺便保存函数的返回值
result = add2num(100,98)

#因为result已经保存了add2num的返回值，所以接下来就可以使用了
print(result)

1.1）多个return的情况
一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处

如果程序设计为如下，是可以的因为不同的场景下执行不同的return
def create_nums(num):
    print("---1---")
    if num == 100:
        print("---2---")
        return num + 1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
    else:
        print("---3---")
        return num + 2
    print("---4---")
print("---4---")#如果在函数外部加上这语句 观察输出 打印出---4---
但两个输出仅会打印一次---4---
result1 = create_nums(100)
print(result1)  # 打印101
result2 = create_nums(200)
print(result2)  # 打印202
#此时---4---没有被打印  因为return之后函数就结束了
输出
---1---
---2---
101
---1---
---3---
202

---4---
---1---
---2---
101
---1---
---3---
202	

2）一个函数返回多个数据的方式
return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据。
返回多个值的时候 默认返回的是元组

def divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu  #默认是元组

result = divid(5, 2)
print(result)# 输出(2, 1) 
print([result])  # 输出[(2, 1)]
print(list(result))#输出 [2, 1]
print(dict(result)) 错误代码 不能这样返回字典
如何返回字典？	

四、函数的嵌套调用
一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用
注意：如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置
再注意：print不会结束函数 如果一个函数同一层中有多个print（没有return） 会将所有print执行完再结束

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')

def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')

testA()
若函数的同一层包含return函数
def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    return 6#如果函数定义中不包含形参 此语句不会输出任何值 只起到结束函数的作用
    print('---- testB end----')

def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')

testA()#这句代码起到调用函数teatA的作用 函数定义时无形参 调用时不写实参
输出
---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----
---- testA end----
第二输出
---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testA end----

六、全局变量
1）什么是全局变量
如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这种变量就是全局变量
2）全局变量和局部变量名字相同问题
当函数内出现局部变量和全局变量相同名字时，函数内部中的 变量名 = 数据 此时理解为定义了一个局部变量，而不是修改全局变量的值。
3）如果想要改变全局变量的值 需要加一个global声明
可以使用一次global对多个全局变量进行声明 如global a，b

a = 300#a是全局变量 shiyan1 shiyan2 两个函数都可以用
def shiyan1():
    print(a) #输出300
    a = 100#a的值发生改变 但仅限于此函数内
    print('shiyan1修改前a=%d'%a)
    a = 200
    print('shiyan1修改后a=%d'%a)
def shiyan2():
    global a#如果想要在全局中改变全局变量的值 需要加global声明
    print('a=%d'%a)#输出300
    a = 20
    print('a=%d'%a)#输出20 此时全局范围内 a的值已经被改变

shiyan1()#调用函数
shiyan2()

七、多函数程序的基本使用流程
1）使用全局变量

g_num = 0
def test1():
    global g_num
    # 将处理结果存储到全局变量g_num中.....
    g_num = 100
def test2():
    # 通过获取全局变量g_num的值, 从而获取test1函数处理之后的结果
    print(g_num)
# 1. 先调用test1得到数据并且存到全局变量中
test1()
# 2. 再调用test2，处理test1函数执行之后的这个值
test2()
注意 如果不先调用test1() 直接调用test2() 输出会是0 因为此时全局变量的值未发生改变

2）使用函数的返回值、参数
非常重要的例子 一定要仔细参考 体会

def test1():
    # 通过return将一个数据结果返回
    return 50

def test2(num):
    # 通过形参的方式保存传递过来的数据，就可以处理了
    print(num)

# 1. 先调用test1得到数据并且存到变量result中
result = test1()

# 2. 调用test2时，将result的值传递到test2中，从而让这个函数对其进行处理
test2(result)

3）函数的嵌套调用

def test1():
    # 通过return将一个数据结果返回
    return 20

def test2():
    # 1. 先调用test1并且把结果返回来
    result = test1()
    # 2. 对result进行处理
    print(result)

# 调用test2时，完成所有的处理
test2() 输出20

八、拆包、交换变量的值
1）对返回的数据直接拆包
拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
除了对元组拆包之外，还可以对列表、字典等拆包
函数参数、函数本身、元组、列表、字典的拆包可以参考以下文章

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age
# result = get_my_info()
# print(result)

my_high, my_weight, my_age = get_my_info()#要拆的数据个数与变量个数相同
print(my_high)
print(my_weight)
print(my_age)

2）交换两个变量的值

# 第1种方式
# a = 4
# b = 5
# c = 0
#
# c = a
# a = b
# b = c
#
# print(a)
# print(b)

# 第2种方式
# a = 4
# b = 5
# a = a+b  # a=9, b=5
# b = a-b  # a=9, b=4
# a = a-b  # a=5, b=4
# print(a)
# print(b)

# 第3种方式
a, b = 4, 5
a, b = b, a

print(a)
print(b)

九、引用
在python中，值是靠引用来传递来的。
可以用id()来判断两个变量是否为同一个值的引用。 可将id值理解为变量的内存地址标示。

a = 1
b = a
print(b)
print(id(a)) 输出 2047670192
print(id(b)) 输出 2047670192

print("---")
# 注意a的id值已经变了
a = 2
print(id(a)) 输出 2047670208
print(id(b)) 输出 2047670208
#b没有与a交换值 所以b的内存地址并没有发生改变
输出
1
2047670192
2047670192
---
2047670208
2047670192

总结： 之前为了更好的理解变量，咱们可以把a=100理解为变量a中存放了100，事实上变量a存储是100的引用（可理解为在内存中的一个编号）

2）引用当做实参
可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
Python有没有类似C语言中的指针传参呢？

def test1(b):  # 变量b一定是一个局部变量，就看它指向的是谁？可变还是不可变
    b += b  # += 是直接对b指向的空间进行修改,而不是让b指向一个新的
    # b = b+b  # xx = xx+yyy 先把=号右边的结果计算出来,然后让b指向这个新的地方,不管原来b指向谁
    print(b)            # 现在b一定指向这个新的地方
    print(id(b))
# a = [11, 22]
a = 100
test1(a)
#测试一下
print(a)
print(id(a))
地址不一样
200
2047673376 #两个的地址不一样
100
2047671776

总结：
Python中函数参数是引用传递（注意不是值传递）
对于不可变类型，因变量不能修改，所以运算不会影响到变量自身
而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量

十、函数使用的注意事项
以下有无返回值指的是函数中是否有return语句
1）无参数 无返回值

def 函数名():
    语句

2）无参数 有返回值

def 函数名():
    语句
    return 需要返回的数值

注意:
一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据
在开发中往往根据需求来设计函数需不需要返回值
函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成

3）有参数 无返回值

def 函数名(形参列表):
    语句

4）有参数、有返回值

def 函数名(形参列表):
    语句
    return 需要返回的数值

函数名不能重复，如以下例子

函数的调用方式为：

函数名([实参列表])

关于函数调用的时候写不写实参

如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数
调用时，实参的个数和先后顺序应该和定义函数中要求的一致
如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值