python函数

函数

定义：函数是指将一组语句的集合通过一个名字（函数名）封装起来，要想执行该函数，只需调用其函数名即可 。优点：1.减少重复代码；2. 使程序变得可扩展；3.使程序变得易维护

• 函数定义和调用

函数定义:
def 函数名()：
	执行语句
调用：
函数名()

def func1():
    print('Hello')
func1()

• 函数的返回值

def func():
    return 'Hello'
print(func())

#函数中遇到return,此函数结束,不在继续执行,函数中，在return后写语句，为语法错误
def func():
    print(1)
    print(2)
    return 'Hello'
	print(3)
print(func())#TabError: inconsistent use of tabs and spaces in indentation

def func():
    print('hello')
    return 'jack','tim','any'
n1,n2,n3=func()
print(n1,n2,n3)
#输出：
hello
jack tim any

return总结：
1.return 会给函数的执行者返回值。
2.如果return后面什么都不写，或者函数中没有return,则返回的结果是None
3.如果return后面写了一个值,返回给调用者这个值
4.如果return后面写了多个结果,,返回给调用者一个tuple(元组),调用者可以直接使用元组的解构获取多个变量。

• 带参数的函数

def func(name):
    print('my name is:',name)
func('alex')#my name is: alex
name='Tom'
func(name)#my name is: Tom

def定义函数的时候，括号里面的变量叫形参，引用内存空间,调用函数的时候，括号里面的变量叫实参，内存数据；注意：形参和实参必须一一对应，多一个少一个都报错

1.位置参数
位置参数就是从左至右，实参与形参一一对应
def func(a,b):
    c=a-b
    print(c)
a,b=6,2
func(a,b)#4
func(b,a)#-4
    
2.关键字参数
位置上可不一一对应
def func(a,b):
    c=a-b
    print(c)
func(a=8,b=2)#6
func(b=2,a=8)#6

3.混合参数:位置参数必须在关键字参数前面
def info(name,sex,age,):
    print("""
    姓名：%s;
    性别：%s;
    年龄：%s
    """%(name,sex,age))
info('Tom',sex='man',age=18)
#输出：
姓名：Tom;
性别：man;
年龄：18

4.默认值参数
def info(name,sex='man',age=0):
    print("""
    姓名：%s;
    性别：%s;
    年龄：%s
    """%(name,sex,age))
info('Tom')
#输出：
姓名：Tom;
性别：man;
年龄：0

def info(name,sex='man',age=0):
    print("""
    姓名：%s;
    性别：%s;
    年龄：%s
    """%(name,sex,age))
info('Any','woman','20')
#输出：
姓名：Any;
性别：woman;
年龄：20

• 非固定参数*args：传入的参数变成元组，元组可为空

*args用来接收位置参数
def func(*args):
    print(args)
func(1,2,3,'20')#(1, 2, 3, '20')
func()#()

#位置参数和*args混合使用时，*args必须在位置参数之后
def func(name,sex,*args):
    print(name,sex,args)
func('tom','boy','eat','sleep','play')#tom boy ('eat', 'sleep', 'play')
#*args可以接受元组，字典和列表
func('tom','boy',('eat','sleep','play'),['swim','run'])#tom boy (('eat', 'sleep', 'play'), ['swim', 'run'])

• 非固定参数**kwargs：传入的参数变成字典

 **kwargs用来接收关键字参数
def func(**kwargs):
    print(kwargs)
func(name='jack',sex='boy',age='20')
#输出：{'name': 'jack', 'sex': 'boy', 'age': '20'}

• 形参的顺序:位置参数，*args，默认参数，**kwargs

def func(name,sex,*args,age=0,height=0,**kwargs):
    print(name,sex,args,age,height,kwargs)
func('jack','boy','read','listen','sing',age=20,weight=120,hobby='run')
#输出：
jack boy ('read', 'listen', 'sing') 20 0 {'weight': 120, 'hobby': 'run'}

• 局部变量和全局变量

局部变量和全局变量:
1.函数体外定义的变量称为全局变量，在函数体内也生效，前提是先定义全局变量，后定义函数
2.函数体内定义的变量称为局部变量，只在当前函数体内生效
3.函数体内为全局变量赋值
4.全局变量是公共的变量，都可以用的变量。一般不推荐用全局变量，因为全局变量有以下2个缺点：（1）不安全，因为所有人都可以改；（2）会一直占着内存
name,age='alex',18
print(name,age)
def func():
    name='jack'
    age=20
    print('name：',name,' age：',age)
    print(age+1)
print(name,age)
#输出：
alex 18
name： jack  age： 20
21
alex 18
#函数里面的name 和age改变，不影响全局的name和age的值

使用global关键字定义全局变量
name,age='alex',18
print(name,age)
def func():
    global name
    global age
    name='jack'
    age=20
    print('name：',name,' age：',age)
    print(age+1)
func()
print(name,age)
#输出：
alex 18
name： jack  age： 20
21
jack 20
#使用关键字global后，name和age变为全局变量

递归函数

定义：递归函数：在一个函数里在调用这个函数本身

递归的最大深度：997

通过下面这个程序可以验证：
def func(n):
    print(n)
    n+=1
    func(n)
func(1)
递归函数如果不受到外力的阻止会一直执行下去。每一次函数调用都会产生一个属于它自己的名称空间，如果一直调用下去，就会造成名称空间占用太多内存的问题，python为了杜绝此类现象，强制的将递归层数控制在了997，997是python为了我们程序的内存优化所设定的一个默认值，我们当然还可以通过一些手段去修改它
import sys
print(sys.setrecursionlimit(1200))

举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出：fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。于是，fact(n)用递归的方式写出来就是：

def fact(n):
    if n==1:
        return 1
    return fact(n-1)*n
print(fact(5))#120
#函数计算过程：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))

注意这里有非常关键的一点：函数内部的代码是相同的，只是针对参数不同，处理的结果不同，当参数满足一个条件时，函数不再执行。这个非常重要，通常被称为递归的出口，否则会出现死循环。

计算数字累加：1.定义一个函数 sum_numbers；2.能够接收一个 num 的整数参数；3.计算 1 + 2 + ... num 的结果

def sum_numbers(num):
    if num==1:
        return 1
    return sum_numbers(num-1)+num
print(sum_numbers(5))#15

• 函数的递归在实现多维列表或元组的运算时，也非常便利，比如如下函数实现取出列表中的所有数字，并返回一个新的列表。

list2=[]
def get_num(*args):
    for i in args:
        print(type(i))
        global list2
        if type(i)==int:
            print("i:",i)
            list2.append(i)
            print("list2：",list2)
        elif type(i)==list or type(i)==tuple:
            get_num(*i)
    return list2
list1=[[3,5,8],10,[[13,"hello",14,],15,18],20,(300,700)]
get_num(list1) 
#不带*号传入的是([[3, 5, 8], 10, [[13, 'hello', 14], 15, 18], 20, (300, 700)],)
get_num(*list1) 
#带*号传入的是：([3, 5, 8], 10, [[13, 'hello', 14], 15, 18], 20, (300, 700))
print(list2)#返回：[3, 5, 8, 10, 13, 14, 15, 18, 20, 300, 700]