Python编程之函数
程序的三种方式
面向对象：类-------》class
面向过程：过程------》def
函数式编程：函数------》def
定义函数
函数：逻辑结构化与过程化的一种编程方法------》def
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
函数特性
遇到return就退出函数，并返回返回值
返回值数可以有多个，可以是函数、列表、数字、字符串等，用逗号“，”隔开，并且以tuple形式返回
返回值数=1：返回object；返回值数=0，返回None;返回值数=多个，返回一个tuple
函数与过程
定义过程，过程默认返回None；定义函数时，如果没有定义return,会返回None
#函数 def func1(): '''description''' #函数说明 print("in the func1") return 0 #过程 没有返回值的函数 def func2(): '''description''' print("in the func2") #过程是没有返回值的函数，在python中过程会默认返回None. #过程加上return后不一定是函数式编程 import time def logger(): time_format = '%Y-%M-%D-%X' time_current = time.strftime(time_format) with open('log.txt','a+') as f: f.write("%s action " %time_current) #程序遇到return则退出，不会打印“test....” def test1(): print("in the test1.") return 0 print("test.....")
函数参数及调用
形参：不是实际存在，是虚拟变量，在定义函数和函数体时使用形参，目的是在调用函数时接受实参;形参只在函数内部有效，函数调用结束后不能再使用该变量。
实参：实际参数，调用函数时传递给函数的参数，可以是常量、变量、表达式、函数，传给形参
区别：形参是虚拟的，不占用内存空间，形参变量只有在被调用时才分配内存单元；实参是一个变量，占用内存空间，数据传递单向，实参传给形参；
位置参数，形参与实参一一对应，不能多不能少
关键字参数调用：与形参顺序无关，位置无需固定
def test(x,y) print(x) print(y) #位置参数 test(1,2) #1 2 #x,y形参（形式参数，本身不存在，如果不被调用则不占空间），1、2为实参 # 关键字参数用 x = 1 y = 2 test(x=x,y=y) #1 2 test(y=1,x=2) #2 1 #关键字参数不能写在位置参数前面 test(x=2,3) #运行出错 test(3,y=2) #3 2 test(3,x=2) #运行出错
默认参数的特点：调用函数时，默认参数非必须传递
用途： 1、默认软件安装值；2、默认连接端口
def test1(x,y=2): print(x) print(y) test1(1) #1 2 test1(1,3) #1 3 test1(1,y=3) # 1 3
参数组：实参数目不固定时使用
*args: 可以接受多个实参，并且放在一个元组中,只接受位置参数，装换成元组
**kwargs: 把n个关键字参数转换成字典的方式
def test2(*args): print(args) test2(1,2,3,4,5) #(1,2,3,4,5) test2(*[1,2,3,4]) #(1,2,3,4) 相当于tuple([1,2,3,4]) test2([1,2,3,4,5,6,7],*[1,2,3,4]) #([1, 2, 3, 4, 5, 6, 7], 1, 2, 3, 4) def test3(**kwargs): print(kwargs) test3(name="aa",age = "3",sex='F') #{name:'aa',age:'3',sex:'F'} test3(**{'name':"aa",'age':2}) #可运行
各参数混合使用
def test4(name,**kwargs): print(name) print(kwargs) test4("a") test4("a",11) #运行出错，传了两个位置参数 test4("a",age=1,sex='f')#可运行 def test5(name,age=18,**kwargs): #kwargs和默认参数位置不能更换 print(name) print(age) print(kwargs) test5("a",sex='f',age = 3)#可运行 def test6(name,age=18,*args,**kwargs): print(name) print(age) print(args) print(kwargs)
函数调用必须先定义，在调用，如果调用在定义之前，会出现找不到函数的error。
python解释器运行时，先解释def test7() => 然后调用test7()，此时还没有解释道test8，所以会报错。
下面这种情况会出错，应先定义test8，在使用test7。
def test7(name,**kwargs): print(name) print(kwargs) test8() test7("a",age=1,sex='f')#可运行 def test8(): pass
局部变量
只在函数里面生效，这个函数就是局部变量的作用域。
#name局部变量，这个函数就是这个变量的作用域 def change_name(name): print("before change:",name) # A name = "B" print("after change:",name) # B name = "A" change_name(name) print(name) #A
全局变量
在整个代码的最前面定义的变量，作用全局。
shcool = "Old" def change_name(name): print("before change:",name) #A name = "B" #name局部变量，这个函数就是这个变量的作用域 print("after change:",name) # B print(shcool) #Old name = "A" change_name(name) print(name) #A
局部变量和全局变量同名时，在定义局部变量的函数中，局部变量起作用，在其他地方，全局变量起作用。
函数默认，全局变量在局部变量不能修改，属于函数中局部变量。
school = "Old" def change_name(name): print("before change:",name) name = "B" #name局部变量，这个函数就是这个变量的作用域 print("after change:",name) school = "New" #相当于局部变量，屏蔽全局变量school print(school) #New print(school) name = "A" change_name(name) print(name) print(school) #Old
如果需要在函数中修改全局变量，则在函数中用global申明全局变量，即在函数中申明global school，不建议使用
也可以直接在函数中用global定义全局变量，效果等同于在代码最前面定义变量，但是不建议使用。
在函数中修改全局变量，随着函数来回调用，排错非常困难。
下面这种情况下可以修改，列表，字典，类等可以修改，但是字符串，整数，元组不能修改。
name = ['a','b','c'] def change_name(): name[0]="D" print(name) #['D', 'b', 'c'] change_name() print(name) #['D', 'b', 'c']
递归
在函数内部，可以调用其它函数，如果一个函数在内部调用自几本身，这个函数就是递归函数。
特性：必须有一个明确的结束条件；每次进入更深一层递归时，问题规模相比上次递归都应有所减少。递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）
def fact(n): if n == 1: return 1 return n * fact(n-1)
尾递归
在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。
这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。但是Python不支持这种机制。
def fact_fri(n): return fact_sec(n,1) def fact_sec(x,y): if x == 1: return y else: return fact_sec(x-1, x*y)
函数式编程
函数式编程是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。
函数式编程允许把函数本身作为参数传入另一个函数，还允许返回一个函数；Python对函数式编程提供部分支持，但Python不是纯函数式编程语言。
高阶函数
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
def add(x, y, f): return f(x) + f(y) add(-5, 6, abs) #11
内置函数
python内置函数
内置函数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii
map函数
map函数，接收两个参数（函数和 Iterable），将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterable返回。
def f(x): return x * x r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) print(list(r)) L = [] for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]: L.append(f(n)) print(L) #map函数作为高阶函数，事实上把运算规则抽象了，因此，还可以计算更复杂的函数，只需一行代码就能实现。
reduce函数
reduce函数，把一个函数（该函数必须接收两个参数）作用在一个序列[x1, x2, x3, ...]上，reduce把结果继续和序列的下一个元素做累积计算，结果为：
reduce(f, [x1, x2, x3, x4]，initializer) = f(f(f(x1, x2), x3), x4)
函数参数含义如下：
1、function 需要带两个参数，1个是用于保存操作的结果，另一个是每次迭代的元素。
2、iterable 待迭代处理的集合
3、initializer 初始值，可以没有。
reduce函数的运作过程是，当调用reduce方法时：
1、如果存在initializer参数，会先从iterable中取出第一个元素值，然后initializer和元素值会传给function处理；接着再从iterable中取出第二个元素值，与function函数的返回值 再一起传给function处理，以此迭代处理完所有元素。最后一次处理的function返回值就是reduce函数的返回值。>
2、如果不存在initializer参数，会先从iterable中取出第一个元素值作为initializer值，然后以此从iterable取第二个元素及以后的元素进行处理。特殊情况下，如果集合只有一个元素，则无论function如何处理，reduce返回的都是第一个元素的值。
def f(x, y): return x + y reduce(f, [1, 3, 5, 7, 9], 100) #初始值为100，默认为 #计算初始值和第一个元素：f(100, 1)，结果为101 from functools import reduce def fn(x, y): return x * 10 + y reduce(fn, [1, 3, 5, 7, 9]) #13579 from functools import reduce def add(x, y): return x + y reduce(add, [1, 3, 5, 7, 9]) #25 #str to int from functools import reduce def str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] return reduce(fn, map(char2num, s))
sorted函数
sorted函数，用于序列排序，可以接收一个key函数来实现自定义的排序，通过传入reverse=True实现反向排序。
key指定的函数将作用于list的每一个元素上，sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素。
sorted([36, 5, -12, 9, -21], key=abs) #[5, 9, -12, -21, 36] list = [36, 5, -12, 9, -21] keys = [36, 5, 12, 9, 21] #keys排序结果 => [5, 9, 12, 21, 36] #最终结果 => [5, 9, -12, -21, 36] >>> sorted(['bob', 'about', 'Zoo', 'Credit']) ['Credit', 'Zoo', 'about', 'bob'] >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ['about', 'bob', 'Credit', 'Zoo‘] >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about']
默认情况下，对字符串排序，是按照ASCII的大小比较的，由于'Z' < 'a'，结果，大写字母Z会排在小写字母a的前面行代码！
filter函数
filter函数，接收一个函数和一个序列，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。可以和匿名函数结合使用。
def is_palindrome(n): s = str(n) return s[::-1]==s and len(s) > 1 output = filter(is_palindrome, range(1, 1000)) print(list(output))
实例
#abs(n) #返回一个数的绝对值。参数可能是整数或浮点数。如果参数是一个复数,返回它的大小。 #all(iterable) #返回True,如果iterable所有的元素为真(或者如果iterable为空)，即只要不含有0返回都为真； # print(all([-1,2])) #True # print(all([0,1])) #False # print(all([])) #True #any(iterable) #返回True,如果iterable任何元素为真，即只要含有非零元素返回都为真；如果iterable为空，则返回False。 # print(any([0])) #False # print(any([])) #False # print(any([0,2])) #True #bool() # print(bool([1,2]))#True # print(bool([])) #False # print(bool([0]))#True #bytearray() #可以把字符串变成二进制数组的形式，并且可以修改，（区别字符串是不能修改的） # a = bytes("abcde",encoding="utf-8") # b= bytearray("abcde",encoding="utf-8") # print( b[1] ) # b[1]= 101 # print(b) #callable(object) #返回True，如果object可以被调用。函数和类可以被调用 # print(callable([1,2,3,4])) #False #chr(code) #ord() #返回一个字符，输入整数对应的ascii表；ord()相反 # print(chr(97)) #a # print(ord("a")) #97 #compile(source, filename, mode[, flags[, dont_inherit]]) #相当于动态导入，把字符串变成可以执行的代码。 #参数source：字符串或者AST（Abstract Syntax Trees）对象。 #参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值，可以为空。 #参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。 # 如果是exec类型，表示这是一个序列语句，可以进行运行； # 如果是eval类型，表示这是一个单一的表达式语句，可以用来计算相应的值出来； # 如果是single类型，表示这是一个单一语句，采用交互模式执行，在这种情况下，如果是一个表达式，一般会输出结果，而不是打印为None输出。 #code = ''' # def fib(max): #10 # n, a, b = 0, 0, 1 # while n < max: #n<10 # #print(b) # yield b # a, b = b, a + b # #a = b a =1, b=2, a=b , a=2, # # b = a +b b = 2+2 = 4 # n = n + 1 # return '---done---' # g = fib(6) # while True: # try: # x = next(g) # print('g:', x) # except StopIteration as e: # print('Generator return value:', e.value) # break # # ''' # # py_obj = compile(code,"err.log","exec") #通过compile把字符串变成可执行代码，使用exec执行 # exec(py_obj) # # exec(code) #也可以直接使用exec执行字符串 #dir(o) #返回对象的一些方法 # a = [1,2,3] # print(dir(a)) #divmod() #商与余数 # print(divmod(5,2)) #(2, 1) # print(divmod(4,2)) #(2, 0) #enumerate(Iterable) #返回列表的索引与值 # L = ["a","b","c"] # for index, key in enumerate(L): # print(index,":",key) # 0 : a # 1 : b # 2 : c #eval() # 可以把list,tuple,dict和string相互转化。 # 字符串转换成列表 # a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]" # type(a) # <type 'str'> # b = eval(a) # print (b) # [[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]] # type(b) # <type 'list'> # # 字符串转换成字典 # a = "{1: 'a', 2: 'b'}" # type(a) # <type 'str'> # b = eval(a) # print (b) # {1: 'a', 2: 'b'} # type(b) # <type 'dict'> # # 字符串转换成元组 # a = "([1,2], [3,4], [5,6], [7,8], (9,0))" # type(a) #<type 'str'> # b = eval(a) # print(b) # ([1, 2], [3, 4], [5, 6], [7, 8], (9, 0)) # type(b) # <type 'tuple'> #frozenset(iterable) #把集合变为不可变的序列 a = frozenset([1,2,3,4]) #globals() #以字典形式返回当前程序的所有全局变量(key)和变量值（vlaue） #print(globals()) #locals() #以字典形式返回当前程序的所有局部变量（key）和变量值（value） #hash(o) #哈希，把输入的o转换成唯一的映射数字 # print(hash("abc")) #-5177290498696341306 # print(hash("abc"))#-5177290498696341306 #hex(i) #把一个数字转换成16进制 #oct(i) #把一个数字转换成8进制 #bin(x) #将整数转换为二进制字符串前缀“0b”。 #round() #设置浮点数精度，默认保留两位小数 #zip() #按最小长度的序列拼接成元组 # a = [1,2,3,4] # b = ["a","b","c","d"] # for i in zip(a,b): # print(i) # (1, 'a') # (2, 'b') # (3, 'c') # (4, 'd') #__import__() #函数用于动态加载类和函数 。 # 如果一个模块经常变化就可以使用 __import__() 来动态载入，比如自己写的一个模块a.py，可以通过这种方式导入。 # 同import语句同样的功能，但__import__是一个函数，并且只接收字符串作为参数，所以它的作用就可想而知了。 # 其实import语句就是调用这个函数进行导入工作的，import sys <==>sys = __import__('sys') #__import__('decorator') #相当于import decorator #print() # msg = "又回到最初的起点" # f = open("1111","w",encoding="utf-8") # print(msg,"记忆中你青涩的脸",sep="|",end="",file=f) # #又回到最初的起点|记忆中你青涩的脸 以这个形式写入文件1111中。 #slice #切片处理 # a = range(20) # pattern = slice(3,8,2) # for i in a[pattern]: #等于a[3:8:2] # print(i) #3 5 7
返回函数
一个函数可以返回一个计算结果，也可以返回一个函数，返回函数并未执行。
def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum f1 = lazy_sum(1,3,5,7,9) #返回一个新的函数f1 f2 = lazy_sum(1,3,5,7,9) #返回一个新的函数f2 print f1 == f2 # False # lazy_sum()每调用一次，都会返回一个新的函数(一个独一无二的函数地址)。 print(f1(),f2) #25 <function lazy_sum.<locals>.sum at 0x0000000000B09E18> #在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量; #当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种程序结构称为闭包。 #返回的函数在其定义内部引用了局部变量args，所以，当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。 #返回函数不要引用任何循环变量，或者后续会发生变化的变量。 def f(): fs = [] for i in range(1,4): def g(): return i*i fs.append(g) return fs f1,f2,f3 = f() print(f1(),f2(),f3()) # 9 9 9 #返回函数中保存的是循环变量i，当调用函数时，i=3 #修改后的程序 #再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变。 def count(): fs = [] def lazy_sum(i): def f(): return i*i return f for i in range(1,4): fs.append(lazy_sum(i)) return fs f1,f2,f3 = count() print(f1,f2,f3) #1 4 9
匿名函数
python对匿名函数提供了有限的支持，关键字lambda表示匿名函数，冒号前的字符表示函数的参数，返回值就是表达式（只能有一个表达式）的结果。
匿名函数调用，可以把匿名函数赋值给一个变量f，通过f(*args)传参，也可以通过括号（lambda.....）(*args)
def f(): return x*x lambda x : x*x lambda : x*x lambda : x*x