标签：代码块 name function dfa 变量 数列 函数嵌套 一个 使用
1.函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2.函数能提高应用的模块性，和代码的重复利用率
3.函数文档字符串用三引号引起，python使用它们来生成有关程序中函数的文档，用来说明函数
4.函数可分为：内置函数BIF，自定义函数，第三方函数
1.格式：以 def 关键词开头，后接函数标识符名称和圆括号 ( )
def 函数名（参数列表）:
函数体
2.函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”
3.直接使用：函数名（参数）来调用，也可以通过：变量=函数名（）来把函数返回值赋值给变量
4.函数必须先定义才能调用
5.函数定义若重名，则忽略最旧的，只调用最新的函数，以新覆盖旧
1.函数定义时传入形式参数（形参），函数调用时传入实际参数（实参）
2.定义函数时，函数的参数需要的是变量，不能试图用‘元组’等的形式
3.函数的参数类型按顺序：必选参数、默认参数、可变参数、命名关键字参数和关键字参数
4.一定是必选参数在前，默认参数在后，否则Python的解释器会报错
5.必选参数：须以正确的顺序传入函数。调用时的数量必须和声明时的一样
（1）定义时，传入变量
（2）调用时，传入的值要照位置顺序依次赋给参数
6.默认参数：默认参数必须指向不变对象，相当于给参数添加一个默认值
（1）定义时，直接传入参数的默认值
（2）调用时，如果传入参数值，则使用参数值，如果没有传递参数值，则会使用默认参数
7.可变参数：可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个；能处理比当初声明时更多的参数，
（1）定义时，可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号（*args）。
（2）调用时，只能通过位置传值，可变参数允许你传入0个或任意个参数，这些可变参数自动组装为一个tuple
8.关键字参数：是指函数在调用的时候，带上参数的名字去指定具体调用的是哪个参数，从而可以不用按照参数的顺序调用函数
（1）定义时，在参数前面加了一个**号（**kwargs）。
（2）调用时，只能通过关键字传值，允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict
9.命令关键字参数：限制关键字参数的名字。命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数
（1）定义时，如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*
（2）调用时，命名关键字参数必须传入参数名
1 #参数
2 def printinfo(a, b,*args,c=4,**kwargs):
3 print(‘必选参数‘,a,b)
4 print(‘默认参数‘,c)
5 print(‘可变参数1‘,args)
6 print(‘可变参数2‘,*args)
7 print(‘关键字参数1‘,kwargs)
8 print(‘关键字参数2‘,*kwargs)
9
10 printinfo(3,4,5,(42,35),name=‘a‘,c=1,age=16,)
11 #按位置传入参数
12 #3传入a,4传入b
13 #4后面的被认为*args,被判定为一个元组
14 #如果碰到关键字传参，先判定是否是默认参数传参，如果不是，则判定为关键字传参
15 -------------------------------------------------------------------------
16 必选参数 3 4
17 默认参数 1
18 可变参数1 (5, (42, 35))
19 可变参数2 5 (42, 35)
20 关键字参数1 {‘name‘: ‘a‘, ‘age‘: 16}
21 关键字参数2 name age
1.python中，类型属于对象，变量是没有类型的
2.如果有必要，可以先对参数的数据类型做检查（isinstance）
3.可变对象在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了
4.实参传递时：*解包为元组，**解包为字典
5.函数参数的装包和拆包（解包）
装包：把传递的参数，包装成一个集合；拆包：把集合参数再次分解为单独的个体
1 def my_sum(a,b,c,d):
2 print(a+b+c+d)
3
4 def test(*args):
5 #装包
6 print(args)
7
8 #拆包
9 print(*args)
10 my_sum(args[0],args[1],args[2],args[3])
11 print(my_sum(*args))
12
13 test(1,2,3,4)
14
15
16 def mysum(e,f):
17 print(e)
18 print(f)
19
20 def test2(**kwargs):
21 #装包
22 print(kwargs)
23 #拆包
24 #mysum(e=1,f=2)
25 mysum(**kwargs)
26 test2(e=1,f=2)
27 ----------------------------------------------------------------------------
28 (1, 2, 3, 4)
29 1 2 3 4
30 10
31 10
32 None
33 {‘e‘: 1, ‘f‘: 2}
34 1
35 2
6.python中只有引用传递（地址传递），是指传递过来的是一个变量的地址，
7.偏函数：指定函数的参数为某个固定值。当函数的参数个数太多，需要简化时，functools.partial创建一个偏函数，可以接收函数对象、*args和**kw这3个参数
偏函数把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单
1 def test(a,b,c,d):
2 print(a+b+c+d)
3
4 def test2(a,b,c,d=2):
5 test(a,b,c,d)
6
7 test2(1,2,3)
8
9 import functools
10 newfunction=functools.partial(test,d=3)
11 print(newfunction,type(newfunction))
12 newfunction(1,2,3)
13 ---------------------------------------------------------------------------
14
15 8
16 functools.partial(<function test at 0x056BDFA8>, d=3) <class ‘functools.partial‘>
17 9
1.如果没有使用return语句指定返回值，python也不是什么都不返回，它会返回一个None对象，所以说python所有函数都有返回值
2.函数调用时return返回一个表达式，有返回值的函数可以对改值进行保存赋值等操作
3.return可以返回多个值并调用，可以以列表，元组，字典的形式以一个整体返回，默认以元组形式
4.return还有一个功能：结束函数（相当于函数中break功能），下面的不执行
5.返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量
6.函数中return和print的区别
（1）print是函数调用直接打印出来，输出数据到控制端
（2）return是这个函数调用返回一个值，如果一个函数没有返回值，那么这个函数的计算结果无法在其他地方使用
1 def test():
2 i=7
3 return i#返回计算的值
4
5 print(‘1:‘,‘ ‘);test()#调用test函数，控制台没有输出
6 print(‘2:‘,test())#调用并操作（打印）test（）函数。test函数中没有输出,test函数的返回值为7
7 print(‘3:‘,test()==7) #调用并操作（打印）test（）函数，调用时没有打印的操作，test函数的值为7，输出比较的值True
8
9
10 def test2():
11 i=7
12 print(i)#输出数据到控制端
13 print(‘4:‘,end=‘ ‘);test2()#调用test2函数，（主要看里面有什么操作），函数中有print输出7
14 print(‘5:‘,test2())#调用并操作（打印）test2（）函数。test函数中打印7,test函数中没有返回值(None)
15 print(‘6:‘,test2()==7)#调用并操作（打印）test2（）函数，调用时打印7，test函数的值为None，输出比较的值False
16 -------------------------------------------------------------------------------
17 1:
18 2: 7
19 3: True
20 4: 7
21 7
22 5: None
23 7
24 6: False
1.lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去，lambda函数只能写一个表达式，表达式的结果就是返回值
2.lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
3.lambda [arg1 [,arg2,.....argn]]:expression
1 q=lambda x:x*x+1#定义一个函数q，参数x满足x*x+1
2 print(type(q))
3 print(q(2))
4 -----------------------------------------------------------------
5 <class ‘function‘>
6 5
1.程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的
2.变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称
3.作用域一共有4种:L （Local） 局部作用域,E （Enclosing） 闭包函数外的函数中(比如闭包),G （Global） 全局作用域,B （Built-in） 内建作用域;以 L –> E –> G –>B 的规则查找
4.Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域
5.其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问
1 x = int(2.9) # 内建作用域
2 g_count = 0 # 全局作用域
3 def outer():
4 o_count = 1 # 闭包函数外的函数中
5 def inner():
6 i_count = 2 # 局部作用域
6.闭包：在函数嵌套的前提下，内层函数引用外层函数的变量（包括参数），外层函数又把内层函数当做返回值进行返回
闭包中，如果要修改引用的外层变量需要使用nonlocal，否则当做是闭包内新定义的变量
1 #闭包 有函数动态生成的函数
2 def mi_num(x):
3 def mi(y):
4 y=y**x
5 return y
6 return mi#函数以参数的形式返回
7 a=mi_num(4)#4次方，a是一个函数
8 print(a(2))#输出2的4次方
9 -------------------------------------------------------------------
10 16
7.定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域
8.全局变量和局部变量
（1）局部变量是在一个函数内部定义的变量；作用域为函数内部；可以用locals()函数查看局部变量
（2）全局变量是在函数外部，文件最外层定义的变量；作用域为整个文件内部；可以利用golbals()函数查看全局变量
（3）局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问
（4）当内部作用域想修改外部作用域的变量时（比如函数中修改全局变量的值），就要用到global关键字,里面用外面的变量;函数内部可以更新外部的变量
（5）修改嵌套作用域中的变量（比如在嵌套函数中，希望在内部函数修改外部函数的局部变量）则需要 nonlocal 关键字,函数中对于不可变数据类型作为全局变量时，一定加global,对于操作可变数据类型全局变量时，可不加global
1 num = 1
2 def fun1():
3 global num # 需要使用 global 关键字声明
4 print(num)
5 num = 123
6 print(num)
7 fun1()
8
9 def outer():
10 num = 10
11 def inner():
12 nonlocal num # nonlocal关键字声明
13 num = 100
14 print(num)
15 inner()
16 print(num)
17 outer()
18 -------------------------------------------------------------
19 1
20 123
21 100
22 100
1.在函数名以及函数体不改变的前提下，给一个函数附加一些额外代码，扩展函数功能
2.装饰器的执行时间是立即执行
3.本身是一个函数，以函数作为一个输入，返回另一个函数
4.对有返回值的函数进行修饰，无论什么场景，保证函数返回值一致
1 def zhanshi():
2 print(‘ok‘)
3
4 def jiaprint(func): #func以函数为参数的装饰器函数
5 def wrapper():
6 print(‘运行的函数名‘,func.__name__)#输出函数的名称
7 func() #执行参数函数的功能
8 print(‘over‘)
9 return wrapper
10 zhanshi = jiaprint(zhanshi) #调用函数装饰器
11 zhanshi()
12
13
14 #等价于:
15 #def zhanshi():
16 # print(‘ok‘)
17 # def jiaprint(func):
18 # print(‘运行的函数名‘,func.__name__)
19 # func()
20 # print(‘over‘)
21 # jiaprint(zhanshi)
22 ----------------------------------------------------------------------
23 运行的函数名 zhanshi
24 ok
25 over
1 def jiaprint(func): #func以函数为参数的装饰器函数
2 def wrapper():
3 print(‘运行的函数名‘,func.__name__)#输出函数的名称
4 func() #执行参数函数的功能
5 print(‘over‘)
6 return wrapper
7
8 @jiaprint#等价于zhanshi = jiaprint(zhanshi)用函数装饰器
9 def zhanshi2():
10 print(‘nono‘)
11 zhanshi2()#zhanshi2已经用了装饰器
12 --------------------------------------------------------------------
13 运行的函数名 zhanshi2
14 nono
15 over
1 def checklogin(func):#利用checklogin函数对某一函数进行操作
2 def inner():#定义一个新的函数进行返回
3 print(‘登录验证...‘)#增加的功能
4 func()#保持原有函数的功能
5 return inner#返回值是一个新的函数
6
7
8 #语法糖 写法
9 @checklogin#利用checklogin函数对下面的函数进行增加功能的操作
10 def fss():
11 print(‘发说说‘)
12 # fss=checklogin(fss)相当于@checklogin
13
14 @checklogin#利用checklogin函数对下面的函数进行增加功能的操作
15 def ftp():
16 print(‘发图片‘)
17 # ftp=checklogin(ftp)相当于@checklogin
18
19 a=1
20 if a==1:
21 fss()
22 else:
23 ftp()
24 ---------------------------------------------------------------------------
25 登录验证...
26 发说说
1 def line(func):
2 def inner():
3 print(‘-‘*30)
4 func()
5 return inner
6
7 def star(func):
8 def inner():
9 print(‘*‘*30)
10 func()
11 return inner
12
13
14 #从上到下装饰，从下到上执行
15 @line#print_=line(print_)先装饰
16 @star#print_=star(print_)先执行
17 def print_():
18 print(‘打印‘)
19
20 print_()
21 ------------------------------------------
22 ------------------------------
23 ******************************
24 打印
1 def zsq(func):
2 def inner(*args,**kwargs):
3 print(‘*‘*30)
4 print(args,kwargs)
5 func(*args,**kwargs)
6 return inner
7 #对有参函数进行装饰，利用不定长参数
8 @zsq
9 def pnum(num,num2):
10 print(num,num2)
11 @zsq
12 def pnum2(num):
13 print(num)
14
15 pnum(123,234)
16 pnum2(26)
17 ---------------------------------------------------
18 ******************************
19 (123, 234) {}
20 123 234
21 ******************************
22 (26,) {}
23 26
1 #带有参数的装饰器
2 #通过@装饰器（参数）的方式，调用这个函数，并传递参数，并把返回值再次当做装饰器进行使用
3 #先计算@后面的内容，把这个内容当做是装饰器
4 def getzsq(char):
5 def zsq(func):
6 def inner():
7 print(char*30)
8 func()
9 return inner
10 return zsq
11 @getzsq(‘*‘)
12 def f1():
13 print(‘66‘)
14
15 f1()
16 ------------------------------------------------------
17 ******************************
18 66
1.在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数
2.递归：（1）函数调用自身；（2）设置正确的返回条件
标签：代码块 name function dfa 变量 数列 函数嵌套 一个 使用
原文地址：https://www.cnblogs.com/yu-liang/p/8612183.html
