函数
一、函数参数传值
形参:函数在定义的时候给定的参数
实参:函数在运行时赋给的参数:
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'