函数的传参

def sum(a,b):
    result = a+b
    print(result)
num1 = int(input("num1:"))
num2 = int(input("num2:"))
sum(num1,num2)

a,b为形参，形参不占内存空间

函数的返回值

def test():
    a = 11
    b = 22
    c = 33
    return a
    return b
    return c
num = test()
print(num)
#注意：函数只要return了，那么函数也就执行完成了，所以上面的return b,c都是不会执行的

总结：

返回值数=0:返回None

返回值数=1:返回object

返回值数>1:返回tuple

全局变量与局部变量

wendu = 0
def get_wendu():
    global wendu
    #使用global用来对一个全局变量的声明，那么这个函数中的wendu=33就不是定义一个局部变量，
    #而是对全局变量进行修改
    wendu = 33
def print_wendu():
    print("温度是%d" % wendu)
get_wendu()
print_wendu()

全局变量的位置：

a = 100
def test():
    print("a = %d" % a)
    print("b = %d" % b)
    print("c = %d" % c)
b = 200
test()
c = 300

输出结果为：

a = 100
b = 200
Traceback (most recent call last):
  File "test.py", line 7, in <module>
    test()
  File "test.py", line 5, in test
    print("c = %d" % c)
NameError: name 'c' is not defined

由上面输出的结果可知全局变量定义的位置只要定义在函数调用之前即可被函数使用！

全局变量与局部变量重名的问题：

a = 100
def test():
    a = 200
    print("a = %d" % a)
def test2():
    print("a = %d" % a)
test()
test2()

输出结果：

a = 200
a = 100

从上面的输出结果可知：函数内定义的变量只要前面没有加global那么该变量就是局部变量，函数内会优先读取局部变量！

不定长参数

def sum_2_nums(a,b,*args):
    print(a)
    print(b)
    print(args)
sum_2_nums(11,22,33,44,55)

输出结果：

11
22
(33, 44, 55)

上面输出的(33,44,55)就是*args参数 **这里注意： 如果上面的函数传递的参数是sum_2_nums(11,22,33)，那么在打印args参数时会输出(33,)，元组中如果只有一个元素，那么后面的逗号不能省略 args参数必须放在最所有形参数的最后面 **

def test(a,b,c=33,*args,**kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)
test(11,22,33,44,['a','b'],{"name":"Poe","age":18},task=99,done=89)

输出结果：

11
22
33
(44, ['a', 'b'], {'name': 'Poe', 'age': 18})   #args
{'done': 89, 'task': 99}    #kwargs

**kwargs对应实参中带变量名的传参！

如何取args参数中的值：

def test(a,b,c=33,*args ):
    print("="*30)
    print(a)
    print(b)
    print(c)
    print(args)
    result = a + b
    for num in args:
        result += num
    print("result = %d" % result)
test(11,22,33,44,66,99)
test(11,22)
test(11,22,33)

输出结果：

==============================
11
22
33
(44, 66, 99)
result = 242
==============================
11
22
33
()
result = 33
==============================
11
22
33
()
result = 33

拆包

先来看一个函数：

def test(a,b,c=33,*args,**kwargs):
    print(a)
    print(b)
    print(c)
    print(args)
    print(kwargs)

A = (44,55,66)
B = {"name":"Poe","age":18}
test(11,22,33,A,B)

输出结果：

11
22
33
((44, 55, 66), {'age': 18, 'name': 'Poe'})
{}

从上面的输出结果可知：A的元组与B的字典当做参数传到函数时，对应的形参是args，现在的需求是让A变量对应args参数，让B变量对应**kwargs参数，如何做呢？ 在调用函数时：test(11,22,33,*A,**B) 输出结果：

11
22
33
(44, 55, 66)
{'name': 'Poe', 'age': 18}

实参中一个号的作用是将元组进行拆包，拆成44，55，66传递给形参，二个号的作用是将字典拆包，拆成KEY=VALUE传递给形参，有多少个就拆成多少个

可变与不可变

python中除了数字，字符串，元组是不可变类型，其它的都是可变类型 可变类型在字典中不允许当作键，因为字典的保存方法比较特殊，如：

info = {"name":"Poe",100:"haha"}

在保存时会将键name哈希成一个值，比如：12121212，再保存这个哈希值与value值

递归

def getNums(num):
    if num == 1:
        return 1
    result = num * getNums(num-1)
    return result
result = getNums(4)
print(result)

上面函数的执行过程： 递归的问题： 一定要有递归的出口，否则函数会一直执行，直到内存被占满，最后溢出！

匿名函数

先来看一段代码：

nums = [11,22,3,1,5,665,34,64,2]
nums.sort()
print(nums)

输出结果：

[1, 2, 3, 5, 11, 22, 34, 64, 665]

nums = [11,22,3,1,5,665,34,64,2]
nums.sort()
print(nums)
nums.sort(reverse=True)
print(nums)

输出结果：

[1, 2, 3, 5, 11, 22, 34, 64, 665]
[665, 64, 34, 22, 11, 5, 3, 2, 1]

那么如果一个列表中所有的元素都是字典呢？如何按字典中的键或值来排序呢？

infos = [
    {"name":"Poe","age":20},
    {"name":"Andy","age":19},
    {"name":"Jet","age":21}
]
infos.sort(key=lambda x:x['name'])
print(infos)

输出结果：

[{'age': 19, 'name': 'Andy'}, {'age': 21, 'name': 'Jet'}, {'age': 20, 'name': 'Poe'}]

如果要按字典中的age进行排序呢？

infos.sort(key=lambda x:x['age'])

匿名函数当做实参

def test(a,b,func):
    result = func(a,b)
    return result
num = test(11,22,lambda x,y:x+y)
print(num)

匿名函数的应用：

def test(a,b,func):
    result = func(a,b)
    return result
func_new = input("请输入一个匿名函数：")
func_new = eval（func_new)   #将输入进来的字符串：lambda x,y:x+y变成一个函数
num = test(11,22,func_new)
print(num)