python函数

1.函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段

2.语法：
def 函数名（参数列表）:   #函数名可以随意编写，但最好不要与内置函数重复，不然内置函数将被替换成你所定义的函数 
 函数体
 return XXX
可以返回多个值，返回的多个值组成一个元组，返回值加上一对中括号，则返回一个列表

在编程过程中可以定义自己想要实现的功能的函数，语法如下：

eg：
def test(x):                    #参数列表里的参数为形参  
    x=10  
    print('-----',x)  
x=5                             #这里的x为实参，虽然与形参一样，但是却是不同的两个值  
test(x)  
print('--+--',x) 
输出结果
----- 10  
--+-- 5 

3 可变参数和不可变参数
不可变类型为：字符串、元组和数值
可变类型为：列表、字典、集合。
在函数中对不可变参数重新赋值后，函数的输出结果则会输出新赋值，而对可变参数中的某个元素重新赋值后，可变参数本身没有动，只是将内部元素进行了修改。

eg：
def a(x):  
    x=10  
    print(x)  
s=1  
a(s)  
def b(y):  
    y[2]=14  
    print(y)  
k=[1,2,3,4,5,6]  
b(k)
输出结果：
10  
[1, 2, 14, 4, 5, 6] 

4 函数中的5种参数

       必需参数、默认参数、可变参数、命名关键字参数和关键字参数
语法： def 函数名（必需参数，默认参数，可变参数，命名关键字参数和关键字参数）
           函数体
      这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。但是请注意，参数定义的顺序必须是：必需参数、默认参数、可变参数/命名关键字参数和关键字参数。

必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：

eg
def printinfo(name, age=35):
    print("名字: ", name)
    print("年龄: ", age)
    return
# 调用printinfo函数  
printinfo(age=30, name="Leo")
print("------------------------")
printinfo(name="Leo")
输出结果:
名字:  Leo  
年龄:  30  
------------------------  
名字:  Leo  
年龄:  35  

关键字参数与命名关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

eg：
def f2(a, b, c=0, *e, x, d,**kW):  
    print('a =', a, 'b =', b, 'c =', c, 'e=', e,'x=',x,'d=',d,'k =', kw)  
args = (1, 2, 3, 4)  
kw = {'d': 99, 'x': '#'}  
f2(*args,**kw) 
输出结果：
a = 1 b = 2 c = 3 e= (4,) x= # d= 99 k = {'d': 99, 'x': '#'}

不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述参数不同，声明时不会命名。
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple元组
基本语法如下：

def a(*args):    #主要区别为加了‘*’符号   加了星号（*）的变量名会存放所有未命名的变量参数
    函数体  
    return 
eg： 
def kebiancanshu(*args):
    print(args)
nums=[1,2,3,4]
nums2=[2,3,5]
kebiancanshu(*nums,nums2)
kebiancanshu(*nums)
kebiancanshu(nums)          #nums整体作为一个元素带进去，函数认为上传个元素，即为一个元素组成的元组
输出结果:
(1, 2, 3, 4, [2, 3, 5])
(1, 2, 3, 4)
([1, 2, 3, 4],)

全局变量和局部变量

全局变量
在一个模块中最高级别的变量有全局作用域，除非被删除，否则能存活到程序运行结束。所有函数都能访问全局变量。

局部变量
定义在函数内的变量有局部作用域。
依赖于定义变量的函数现阶段是否处于活动状态。
调用函数时，局部变量产生，暂时存在。
一旦函数执行完，局部变量将会被释放。

注：
同一个函数中，不允许有同名局部变量
不同函数中，可以有同名局部变量
同一个程序中，全局变量和局部变量同名时，局部变量具有更高的优先级
但是有时候我们想要函数中修改外部作用域的变量时，就需要global方法来实现了。
eg：
num = 1  
def fun1():  
    global num  # 需要使用 global 关键字声明  
    print(num)   
    num = 2  
    print(num)  
fun1() 
输出结果：
1
2