函数:
1、函数格式:
def 函数名(): // 括号里面可以传参数
"注释内容"
代码块
ruturn 返回值 // 返回值可以是数字,字符串,列表,字典,元组,等等
2、使用函数的好处:
(1)减少代码重用
(2)保持一致性,容易维护
(3)具有可扩展性
3、函数参数:
(1)形参:不占用物理内存空间,而且只在函数内部有。
(2)实参:可以是多种数据类型,必须有固定的一个值,方便赋值给形参
def test(x,y): //定义函数的时候括号里写的就是形参
n = test(3,5) //执行函数时要赋值给形参所传的参数是实参
print(n)
(3)位置参数:实参的值要和形参的值一一对应上,少一个或多一个则报错
def test(x,y,p):
print(x)
print(y)
print(p)
test('xyy','xyp','xyyp')
结果:
(4)关键字参数:则不需要像位置参数那也一一对应,值够就行
def test(x,y,p):
print(x)
print(y)
print(p)
test(y='xyy',x='xyp',p='xyyp') // 顺序无关紧要,值不能多不能少
结果:
(5)默认参数:定义函数时默认指定的形参,但是是可以输出的
def test(x,y,p=111): // 定义了默认参数是p=111
print(x)
print(y)
print(p)
test(x=1,y=11) //执行时不给p传参数
结果:
def test(x,y,p=111):
print(x)
print(y)
print(p)
test(x=1,y=11,p=222) //形参p不变的情况下,给p传一个实参
结果:
(6)参数组:*args 表示列表, **kwargs 表示字典
方法一:
def test(x,*args,**kwargs):
x
args
kwargs
return x,args,kwargs
n = test(1,"xyy","xyyp","xyp",k1=1,k2=2,k3=3) // 第一个参数1表示位置参数,传给x,"xyy","xyyp","xyp"表示传一个列表给args,k1=1,k2=2,k3=3表示传一个字典给kwargs
print(n)
结果:
方法二:
def test(x,*args,**kwargs):
print(x)
print(args)
print(kwargs)
test(1,"xyy","xyyp","xyp",k1=1,k2=2,k3=3)
结果:
方法三:
def test(x,*args,**kwargs):
print(x)
print(args)
print(kwargs)
test(1,*["xyy","xyyp","xyp"],**{'k1':1,'k2':2,'k3':3})
结果:
4、全局变量和局部变量:
(1)全局变量:在编辑器里面定义的变量,且变量名开头没有缩进的变量叫全局变量。
例如:
(2)局部变量:在函数里面定义的变量,且只对单个函数体有用的变量叫局部变量。
例如:
(3)global关键字:
①、当函数体内没有global关键字时,且有局部变量,则优先读取局部变量,没有局部变量则读取全局变量,并且不能对局部变量进行赋值。
②、但是对于可变类型,可以对内部元素进行操作,比如:追加或删除。
③、当函数体内有global关键字时,变量本质上还是全局变量,而且可以读取并赋值。
PS:代码书写过程中,建议全局变量名要大写,局部变量名要小写
(4)nonlocal关键字:
①、调用上以及函数的局部变量
5、递归:
在函数内部,可以调用其他函数,如果一个函数在内部调用自身本身,这个函数就是递归函数。
特点:
(1)、必须有一个明确的结束条件。
(2)、每次进入更深一层递归时,问题规模相比上一次递归都相应减少。
(3)、递归效率不高,递归层次过多会导致栈溢出。
6、作用域:
def ccx(): //定义函数
name = "xyy"//定义函数体
def cjk(): //嵌套函数
name = "xyp" //定义嵌套的函数的函数体
def ml(): //嵌套第三层函数
print(name) //第三层函数体
return ml //返回值
return cjk //返回值
重点:函数的执行
n = ccx()(1)第一次执行函数的第一层函数体,则会通过return返回一个返回值是第二层函数的内存地址
x = n() (2)由于第一层函数的返回值是第二次函数的内存地址,加上()就能执行第二层函数,并且会返回一个值,是第三层函数的内存地址
x() (3)通过第二层函数的返回的第三层函数的内存地址加上()执行第 三层函数,返回值就是上一层函数的定义的变量值
结果就是:
7、匿名函数:
关键字:lambda
格式:
fun = lambda x:x+1
print(fun(2)
结果:
lambda :关键字,匿名函数的开头必须有
x :函数的形参
x+1:函数体,相当于普通函数的return返回值
fun:就相当于取函数的一个返回值,可以是任何字符
print(fun(2)) :print输出函数的最终值,fun(2)给函数传一个实参
8、函数式编程:
(1)、map函数:
例如:
num = [1,2,3,4,5,6,7] // 定义一个变量
n = map(lambda x:x+1,num) // 用map函数调用匿名函数(或自定义函数)和变量,且对变量里面的每一个值都操作一遍
print(list(n)) //返回值转换成列表并输出
(2)、filter函数
例如:
test = ["tom_sb","jony_sb","lucy_sb","xyyp"]
n = filter(lambda x:x.startswith('x'),test) //filter取布尔值,为True 的则输出
print(list(n))
(3)、reduce函数:
例如:
from functools import reduce //导入函数模块
li = [1,2,3,4,5,100]
n = reduce(lambda x,y:x+y,li) //相当于把列表里面的字符相加得结果,要操作的对象可以是列表,元组,集合等等这样的类型
print(n)
9、内置函数:
abs() 取一个数字的绝对值,可以是负数和正数,绝对值为正数
print(abs(-10))
结果:
all() 判断一个类型的布尔值,空为False,不空为True
print(all('x'))
print(all(['']))
结果:
any() 和all想反,有一个为真的则为True,都为假则为False
print(any('xyy'))
print(any(''))
结果:
bin() 把一个十进制数转换成二进制数
print(bin(10)) //插入一个整形
结果:
hex() 把一个10进制转换成16进制
print(hex(10)) //插入一个整形
结果:
oct() 把一个十进制数转换成8进制
print(oct(10)) //插入一个整形
结果:
bool() 判断一个元素的布尔值
print(bool(0)) //c插入一个为false的值
print(bool(1)) //插入一个为True的值
结果:
bytes() 将一个字符串进行编码,用什么类型编码的就怎么解码
print(bytes('你好',encoding='utf8').decode('utf8')) //utf8编码解码
print(bytes('你好',encoding='gbk').decode('gbk')) //gbk编码解码
print(bytes('你好',encoding='gbk').decode('utf8')) //gbk编码,utf8解码
结果:
chr() 判断一个数字代表的ascii码是什么
print(chr(87))
print(chr(109))
print(chr(43))
结果:
ord() 和chr想反,判断字符在ascii码中的位置
print(ord('y'))
print(ord('+'))
print(ord("p"))
结果:
dir() 查看一个内置函数都有什么功能
print(dir(dir)) //查看它本身有什么功能
结果:
divmod() 一个数除以一个数得商和余数
print(divmod(57,4)) // 54/7结果是商和余数
结果:
eval() (1)将一个字符串中的内容提取出来
test = "{'name':'xyy'}" //定义一个字典形式的字符串
print(eval(test))
结果:
(2)将一个计算表达式进行计算
print(eval('100+200*(40/8)-200')) // 传一个算法表达式
结果:
hash() 将一个元素转换成一个固定长度的hash值
print(hash('xyy')) //一个可hash的值
结果:
help() 查看一个内置函数的帮助和使用方法
print(help(hash))
结果:
globals() 打印全局变量
name = "xyy" //定义一个全局变量
def test():
print(globals()) //打印全局变量
test() //执行函数
结果:
locals() 打印局部变量
def test():
name = ['xyp','xyy'] //定义一个局部变量
print(locals())
test()
结果:
pow() 取两个整数的幂和幂的余数
print(pow(4,2)) // 计算这两个数的几次方
print(pow(3,6,5)) // 计算次方并取余数
结果:
sum() 取整数序列类型的和
num = [1,2,3,4,5,6]
print(sum(num))
结果:
max() 打印一个数据类型中的最大值
int_l = [1,2,5,9,10] //定义一个数字列表
print(max(int_l))
结果:
min() 打印一个数据类型的最小值
int_l = [1,2,5,9,10]
print(min(int_l))
结果:
zip() 拉链的形式使前后元素值相互对应
print(list(zip(('name','age'),('xyy',19))))
结果:
max和zip结合使用:
test = {'age1':19,'age2':20} // 定义一个字典
print(max(test.values())) //比较values值
print(max(test.keys())) // 比较keys值
print(max(zip(test.values(),test.keys()))) //结合比较
结果:
终极结合:
people = [
{'name':'xyp','age':1000},
{'name':'wpq','age':10000},
{'name':'xyy',"age":99}
]
print(max(people,key=lambda test:test['age']))
结果:
pow() 取两个整数的幂和幂的余数
print(pow(4,2)) // 计算这两个数的几次方
print(pow(3,6,5)) // 计算次方并取余数
结果:
10、闭包函数
例:
from urllib.request import urlopen #加载urlopen模块
def f(url): #定义函数
def f1(): #嵌套函数
c = urlopen(url).read()
print(c)
return f1 #返回值取嵌套函数的内存地址
n = f('http://www.baidu.com')
n()
闭包函数:内部函数包含对外部作用域而不是对全局作用域的名字的引用