函数
一、函数参数传值
形参：函数在定义的时候给定的参数
实参：函数在运行时赋给的参数：
1 def func(i):#i为定义时的参数，为形参 2 pass 3 func(name)#name为运行时的参数，为实参，实参与形参的名字可以相同
传值方式：
位置传值：按照定义时的顺序，用实参给形参赋值
1 def func(x,y,z): 2 print("x->",x) 3 print("y->",y) 4 print("z->",z) 5 func(1,2,3) 6 7 #按顺序将值一一赋给形参 8 x-> 1 9 y-> 2 10 z-> 3
关键字传值：形参1 = xxx，形参2 = xxx
1 def func(x,y,z): 2 print("x->",x) 3 print("y->",y) 4 print("z->",z) 5 func(x = 1,z = 2,y = 3)#将x赋值为1，y赋值为3，z赋值为2 6 #关键字传参，没有位置对应关系 7 8 9 x-> 1 10 y-> 3 11 z-> 2
混合传值：要注意混合传值时，关键字传值必须放到位置传值的右边
1 def func(x,y,z): 2 print("x->",x) 3 print("y->",y) 4 print("z->",z) 5 func(1,2,z = 3) 6 '''关键字传值，必须在最右边，并且不能对已经有位置传参的形参进行传值''' 7 8 9 10 x-> 1 11 y-> 2 12 z-> 3
万能的传值方式（可变长参数传值方式）：
*args:传值接受后组成元组（位置处传值）
**kwargs：传值后组成字典（用于关键字传值）
使用参数时遍历即可
def func(*args,**kwargs):
print(args)
print(kwargs)
func(1,2,3,x = 4,y = 5)
(1, 2, 3)
{'x': 4, 'y': 5}
二、函数的作用域问题
有下面一段简单代码：
1 name = "sunqi" 2 def foo(): 3 name = "tony" 4 print(name) 5 foo()
打印输出为“tony”，为什么是tony而不是sunqi？
直接的说是因为python在寻找变量时，是找离它最近的。就是先从函数本地内部开始找，然后去函数外面找，最后再去python内置函数中找。
例如这个输出打印，就是因为先找到了“tony”然后就用他来做为name输出。
那么就有全局变量，和本地变量的区别了
定义在程序最外边的就是全局变量，比如name =“sunqi”
定义在函数内部的变量就是局部变量也叫本地变量，比如name = “tony”
当全局变量与局部变量重名时，本地本地变量会在内部作用域中替换全局变量。从下面的例子就可以看出来，内部变量并没有修改全局变量的值
1 name = "sunqi" 2 def foo(): 3 name = "tony" 4 print(name) 5 foo() 6 print(name) 7 8 9 10 11 tony 12 sunqi
当我们要使用并修改全局变量时就需要声明global 属性
1 name = "sunqi" 2 def foo(): 3 global name 4 name = "tony" 5 print(name) 6 foo() 7 print(name) 8 9 10 tony
11 tony
可以看出全局变量已经被修改
我们来看一下下边的例子
1 name = [1,2,3,4] 2 dic = {"name":"sunqi","age":18} 3 def foo(): 4 name = [23,44,5,] 5 print(name) 6 foo() 7 print(name) 8 9 10 [23, 44, 5] 11 [1, 2, 3, 4]
和上边的例子一样，foo函数并没有对局部变量产生任何影响
1 name = [1,2,3,4] 2 dic = {"name":"sunqi","age":18} 3 def foo(): 4 name.append(7) 5 dic["age"] = 10 6 print(name) 7 print(dic.items()) 8 foo() 9 print(name) 10 print(dic.items()) 11 12 13 [1, 2, 3, 4, 7] 14 dict_items([('name', 'sunqi'), ('age', 10)]) 15 [1, 2, 3, 4, 7] 16 dict_items([('name', 'sunqi'), ('age', 10)])
例子中列表和字典局均为全局变量，foo函数引用的也是全局变量，但是为声明global。却修改了列表和字典。
原因是，既然没有声明global属性，就不能对全局变量进行赋值，但是对于可修改的全局变量来说，可以修改他们的内部元素。
比如字典，列表。
1 def foo(): 2 count = 0 3 def boo(): 4 nonlocal count# 省略掉这句话会报定义前引用的错误 5 count+=1 6 print(count) 7 boo() 8 print(count) 9 foo() 10 11 12 13 1 14 1
nonlocal用于声明非全局变量的外部变量，当不需要对上层变量进行修改时不必声明nonlocal
上边的例子没有nonlocal的话会报错：计数前未声明
1 def foo(): 2 count = 0 3 def boo(): 4 5 print(count) 6 boo() 7 print(count) 8 foo() 9 10 11 0 12 0
三、高阶函数
函数就是变量，可以被当做返回值，也可以作为参数传给另一个函数
1 def foo(): 2 count = 0 3 def boo(): 4 print(count) 5 print(boo) 6 return boo 7 f = foo() 8 print(f) 9 10 11 <function foo.<locals>.boo at 0x0000020248CC4AE8> 12 <function foo.<locals>.boo at 0x0000020248CC4AE8>
函数被return返回的是函数的地址上面的例子可以通过f()直接运行就相当于运行boo()
函数也可以作为参数传递给另一个函数：
1 #函数作为参数传递 2 num = [1,2,3,4] 3 def add(i,sum = 0): 4 """ 5 sum加法初始值,默认值为零 6 :param sum: 7 :param i: 8 :return: 9 """ 10 sum = sum +i 11 return sum 12 def test(func,num): 13 res = 0 14 for i in num: 15 res = res + func(i) 16 print(res) 17 test(add,num)#add函数作为参数传递给了test函数 18 19 20 10
四、lambda表达式，map，reduce，filter
lambda表达式的意义就是对函数的简洁表示
lambda函数也叫匿名函数
冒号前是参数，冒号后是返回值
lambda函数经常与map，reduce，filter一起使用
map()：对一个可迭代对象进行遍历，并交由lambda处理，返回一个与传入的对象长度相同，顺序相同的object对象
reduce()：对一个可迭代对象的元素进行遍历并运算，返回一个计算后的值
filter()：传入一个可迭代对象，通过设置条件筛选出满足 条件的元素，组成新的object对象，可以用列表转换后遍历输出
1 func = lambda x:x+1 2 print(func(10)) 3 func = lambda x,y,z:(x+1,y+1,z+1) 4 print(func(1,2,3)) 5 func = lambda x:x+"DE" 6 print(func("ABS")) 7 8 9 11 10 (2, 3, 4) 11 ABSDE
1 from functools import reduce 2 3 foo = [2, 18, 9, 22, 17, 24, 8, 12, 27] 4 print(list(map(lambda x: x + 1, foo))) 5 print(reduce(lambda x, y: x + y, foo)) 6 print(list(filter(lambda x: x > 10, foo))) 7 8 9 10 [3, 19, 10, 23, 18, 25, 9, 13, 28] 11 139 12 [18, 22, 17, 24, 12, 27]
五、内置函数
1、简单内置函数
1 abs()绝对值 2 ''' 3 all()函数对所有元素进行布尔运算，如果每个元素的布尔值都为True则返回True。 4 如果传入的参数为空，返回True 5 ''' 6 all() 7 8 li = [1,2,3,"suqni","",(),{},[]] 9 li_1 = [1,2,3,"suqni",] 10 li_2 = [] 11 12 print(all(li)) 13 print(all(li_1)) 14 print(all(li_2)) 15 16 False 17 True 18 True 19 20 bin()转换二进制 21 bool()布尔值判断 22 bytes()转换成字节，#指定编码utf-8保存中文，一个汉字三个字节，gbk保存中文两个字节 23 chr() ascii 转换数字与字符 24 divmod()取商得余数
2、eval()
提取字符串内容
对提取的内容进行数学运算
1 a = "[1,2,3],{'name':'sunqi'}"#提取并返回元组 2 s = "1+2*(3-1/2)%2" 3 print(eval(a)) 4 print(eval(s)) 5 6 7 ([1, 2, 3], {'name': 'sunqi'}) 8 2.0
3、hash()
返回对象的哈希值
可哈希的数据类型就是不可变数据类型
不可哈希的数据类型就是可变的数据类型（列表，字典类型需要转换成字符串类型才可哈希）
4、globals()打印全局变量
locals() 打印局部变量
1 name = "sunqi" 2 # print(globals()) 3 print("globals-->",globals()) 4 def func(): 5 name = "tony" 6 print("locals-->",locals()) 7 func()
1 globals--> {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001F81766D240>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Python_project/python_kaifa/day17_day8/test_17.py', '__cached__': None, 'name': 'sunqi'}
1 locals--> {'name': 'tony'}
5、zip()
要求参数必须为序列，比如，列表，元组，字符串
返回两个序列的元素的一对一组合的元组形式
当两个序列的长度不相同时，就会根据较短的元素进行组合
1 li = [1,2,3] 2 li_1 = ["sunqi","tony","tom"] 3 print(list(zip(li,li_1))) 4 5 6 7 [(1, 'sunqi'), (2, 'tony'), (3, 'tom')]
1 li = [1,2,3,4] 2 li_1 = ["sunqi","tony","tom"] 3 print(list(zip(li,li_1))) 4 5 6 [(1, 'sunqi'), (2, 'tony'), (3, 'tom')]
实现字典键值对的反转
1 dic = { 2 "name":"sunqi", 3 "age":18 4 } 5 print(list(zip(dic.values(),dic.keys()))) 6 7 8 9 [('sunqi', 'name'), (18, 'age')]
6、max()
比较大小，返回最大的
要求参数支持for循环
要求参数内元素数据类型相同
从元素的第一个位置开始比较，字母，字符按照ASCII码比较
1 li = [ 2 {'name':"sunqi",'age':'18'}, 3 {'name':"tony",'age':'20'}, 4 {'name':"tom",'age':'10'} 5 ] 6 print(max(li,key=lambda dic:dic['age'])) 7
8{'name': 'tony', 'age': '20'}
9#根据age的值选出最大的，内部也是调用for循环 10#然后将值传给lambda，就是一个字典，返回字典的age
7、sorted()
sorted是内置方法，排序后返回新的序列，原序列不会被修改
sort是列表的方法，不返回排序后的序列，而是之久替换原序列
1 li = [1,3,4,2,6,5,25,14] 2 3 print(sorted(li)) 4 print(li) 5 print(li.sort()) 6 print(li) 7 8 [1, 2, 3, 4, 5, 6, 14, 25] 9 [1, 3, 4, 2, 6, 5, 25, 14] 10 None#不返回新序列 11 [1, 2, 3, 4, 5, 6, 14, 25]#原序列改变
8、__import__()
导入包名是字符串的包
m = __import__("test")
9、format()
#字符串可以提供的参数 's' None >>> format('some string','s') 'some string' >>> format('some string') 'some string' #整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None >>> format(3,'b') #转换成二进制 '11' >>> format(97,'c') #转换unicode成字符 'a' >>> format(11,'d') #转换成10进制 '11' >>> format(11,'o') #转换成8进制 '13' >>> format(11,'x') #转换成16进制 小写字母表示 'b' >>> format(11,'X') #转换成16进制 大写字母表示 'B' >>> format(11,'n') #和d一样 '11' >>> format(11) #默认和d一样 '11' #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None >>> format(314159267,'e') #科学计数法，默认保留6位小数 '3.141593e+08' >>> format(314159267,'0.2e') #科学计数法，指定保留2位小数 '3.14e+08' >>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示 '3.14E+08' >>> format(314159267,'f') #小数点计数法，默认保留6位小数 '314159267.000000' >>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数 '3.141593' >>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数 '3.14159267' >>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数 '3.1415926700' >>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母 'INF' #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数 >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点 '3e-05' >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点 '3.1e-05' >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 '3.14e-05' >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写 '3.14E-05' >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点 '3' >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点 '3.1' >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点 '3.14' >>> format(0.00003141566,'.1n') #和g相同 '3e-05' >>> format(0.00003141566,'.3n') #和g相同 '3.14e-05' >>> format(0.00003141566) #和g相同 '3.141566e-05'