函数定义：

def 函数名（参数列表）
    函数体
    [return 返还值]

callable()  #判断是否为调用对象(括号内为函数名，后面不能有括号)

例：
def add(x,y):
return x + y

add(10,2)         #位置传参
add(x=10,y=2)     #关键字传参，按照形参的名字一一对应

**要求位置传参必须在关键字穿参之前。

形参：

def add(x=3,y=4):
return x + y
add()
默认不输入，缺省值为x=3,y=4，输入后已输入的为准
 
 
def sum1(iterable):  #iterable 用作可迭代对象
result = 0
for x in iterable:
result += x
return result
 
 
def sum1(iterable):  #代表可变形参，将多个参数封装到元组，不可变。和上面区别：（参数为[1,3]就错了）
result = 0
for x in iterable:
result += x
return result

可变未知参数：形参前用*   必须用位置传参。
如上；

可变关键字参数：形参前使用  如kwargs 必须用关键字参数
如下：
def showconfig(**kwargs)：    #k-v对传参
print(type(kwargs))
print(kwargs)

showconfig(host='192.168.1.1','username'='tom')

形参定义顺序：普通参数、位置参数、关键字参数
username,*args,**kwargs  
   
 

keyword-only:  # 在一个args之后出现的普通参数，成为keyword-only
 
def fn(args,x)   # x只能关键字传参
 
def fn3(x,y,*,z)   #  ''纯粹为了改变'z'变成keyword-only
 
将必须使用名称的才能使用的参数，定义为keyword-only
 
 

参数解构

add(*[4,5]) 相当于add(4,5)
add(**{'a':2,'b':4})   相当于add(a=2,b=4)
add(*{'a':2,'b':4}) 相当于add(a,b)
add(*{'a':2,'b':4}.values())

return语句执行之后，不会再进行执行函数内其他语句
 
 
 

函数作用域：

 
在函数内定义的变量只能在此函数中
 
def fn()
print('~~~')
x = 100             #x可见范围只在函数内部

fn()
print(x)                #不能输出x
   
每一个函数都会开辟一个作用域
 
作用域分类：
 
全局作用域
在整个程序运行环境中都可见
global
局部作用域  
在函数、类等内部可见
局部作用域中的变量成为局部变量，适用范围不能超过其所在作用域
local作用域
   
创建的.py的文件中，非函数的变量是全局变量
 
 
x = 1000
 
def fn2():
print(2,x)
print(1,x)
fn2()
打印：
1 1000
2 1000
 

函数嵌套：

对外不可见，对内可见  
 

例1：
x = 100
def fn():
x+= 200  #赋值即定义，x变成局部，但没被赋值，所以这么写会报错

fn()

 
例2：
x = 100
def fn()
print(x)    #会报错，只定义了x为局部变量，此时没有赋值
x = 200    #先定义为局部，等执行进行赋值

print(x)
fn()    
 

global  #声明全局变量，要用加在行数前

例3：
x = 100
def fn()
global x    #声明x为全局变量
print(x)    
x += 200

print(x)
fn()
print(x)    
打印：
100
100
300
   
   
 

*****闭包  #嵌套函数中

自由变量：#未在本地作用域中定义的变量，
例如定义在内层函数外的外层函数的作用域中的变量  
闭包：指的是内层函数引用到了外层函数的自由变量，就形成了闭包

 
内层函数如没有用到外层函数的变量，则外层的变量会消亡，用到则不会消亡
   
 

def counter():
c = 0
def inc()
nonlocal c #声明c不是当前函数本地变量，而在上一级定义，也不是全局变量
c += 1
return
 

nonlocal :不适用于最外层函数
 
 

默认值的作用域

缺省值

def foo (x=1) # 默认x = 1
x += 1
print(x)

foo()
foo()
打印：
1
1  
 
 

def bar (x=[]) # x=[]是引用类型
x += 1
print(x)    
 
foo()
foo()
打印：
[1]
[1][1]  
 
bar.defaults
([1,1],)
 

.defaults  #查看参数缺省值属性

 
如果有keyword-only：

.kwdefults  

例：
def foo (xyz,m=123,*,n='abc',t = [1,2]:

print(foo.defaults,foo.kwdefults)
(123,){'n':'abc','t':[1,2]}

a += [5]  #相当于a.extend([5]),就地修改，不会更改地址值
a = a + [5]  #相当于创建了新列表

****变量名解析原则LEGB

Local
Enclosing
Global
Build-in 内置模块的命名空间 #print(open) print open

所以一个名词的查找顺序就是LEGB

函数的消亡
本质使其引用计数清零