Python Magic——函数
澹台聪
前言
函数魔法，是每一个Python Magic学员所必须掌握的魔法，无论在实战还是练习中都是必不可少的，若使用大型魔法，它可使其大型魔法变得非常容易施展，省去了复杂的招式，而且以后在使用该魔法会更加轻松。
函数
1. 特点
① 减少代码的重用。
② 保持一致性，易维护。
③ 可扩展性。
2. 格式
# def 函数名(参数): #可以不加参数，将参数加到函数内部
# 语句块
# return x #返回值，函数结束标志，可有可无
# 函数名(参数) #函数调用
对于return返回值，返回值是一个整体：
return 值=0，返回none；
return 值=1，返回object类型；
return 值>1，返回tuple元组类型。
3. 参数的使用
① 位置参数—形参顺序与实参顺序相同，缺/多一不行
def cals(x,y):
res = x**y
return res
c = cals(2,3)
d = cals(3,2) #位置参数顺序不同，结果不同
#e = cals(2,3,4) 多则报错
#f = cals 少则报错
print(c,d)
② 关键字参数—指明参数，缺/多一不行
def cals1(x,y):
res = x**y
return res
c = cals1(x=2,y=3)
d = cals1(y=2,x=3) #参数指明不同结果不同
#e = cals1(y=2,y=3) 参数指明重复，错误
print(c,d)
③ 默认参数—默认参数值
def cals2(x,y=3): #默认参数y=3
res = x**y
return res
c = cals2(x=2) #未调用则使用默认参数
d = cals2(x=2,y=4) #关键字参数重新赋值
e = cals2(2,4) #位置参数重新赋值
print(c,d,e)
④ 混合参数使用—位置参数必须在关键字参数左边，不能位置与关键字参数重复
def cals2(x,y): #默认参数y=3
res = x**y
return res
#c = cals2(x=2,3) #关键字参数在左，位置参数在右，报错
d = cals2(2,y=4) #关键字参数在右，位置参数在左
#e = cals2(2,x=2) #位置与关键字参数重复,报错
print(d)
4. 全局变量与局部变量（PS）
① 先从内部找，找不到再从外部找
② 如果函数的内容无global关键字，优先读取局部变量，若无则读取全局变量，能读取全局变量，但无法对全局变量进行重新赋值，但可变类型可以对内部元素进行操作。
③ 如果函数中有global关键字，变量本质上是全局的那个变量，可读取可赋值。
④ name = ‘a’ global name 此形式为错误形式。
⑤ 局部前加global变量名，只改变最外边变量，使之变化，靠近的不受影响。
name = 'wxt' #全局变量
def w():
name = 'lhm' #局部变量
def q():
global name #与下面互换顺序报错PS④
name = 'love'
q()
print(name)
print(name)
w()
print(name)
name1 = [1,2,3]
def m():
n = 520
def e():
name1.append(n) #PS②
print(name1)
e()
m()
5. 函数魔法与列表字典魔法连接
① *列表
def text(x,*y): #x,只取第一个元素，*y,将后面组成列表,循环遍历输出
print(x)
print(y)
text(1,2,3,4,5)
text(1,[2,3,4,5])
text(1,*['2','3',4,5]) #列表的列表等于本身
② **字典
def text(x,**y): #x,只取第一个元素，**args,将后面组成字典
print(x)
print(y)
text(1,g=2,z=3) #字典对应模式
③ 混合使用
def text(x,*y,**z): #只有这一种写法
print(x)
print(y)
print(z)
text(1,2,3,m=1,n=2)
text(1,*[2,3],**{'y':2})
6. 递归函数魔法—自己调用本身函数匿名函数
def calc(n): #print(10)-->calc(5)-->print(5)-->calc(2)
print(n) #-->print(2)-->calc(1)-->print(1)
if int(n/2)==0:
return n
return calc(int(n/2))
calc(10)
7. 匿名函数函数作用域
#lambda 形参:处理逻辑（简单逻辑，一行搞定）
a = lambda x:x+1
b = lambda x:x in 'love'
print(a(5),b('o'))
8. 函数作用域高阶函数
def foo():
name = 'love'
def bar():
name = 'wxt'
def tt():
def aa():
print('lhm')
aa()
print(name)
return tt() #加括号==调用函数
return bar #不加括号==返回函数地址
print(foo,foo())#返回函数地址
ba = foo()#调用foo()函数
ba() #调用foo()函数中仅次于foo()函数的内置函数bar()
foo()() #等同于上面两行
9. 高阶函数
① 把函数当作参数传给另一个函数
def foo(n):
print(n)
def bar(name):
return 'I love %s' %name
foo(bar('wxt'))#先里后外
② 返回值中包含函数
def bar():
print('from bar')
def foo():
print('from foo')
return bar
n = foo() #调用foo()函数将结果赋给n（返回值为bar()函数的函数地址）
n() #调用bar()函数
def bar1():
print('from bar1')
def bar2():
print('from bar2')
return bar1()
bar2() #调用bar()函数，其中bar2()函数中返回bar1()的调用
10. 三大高级函数
① map()—处理序列中每个元素,得到的结果是一个列表,该列表元素个数及位置与原来一样
num = [1,2,3]
a = map(lambda x:x+1,num) #num中元素迭代到前面函数，将运行结果存入列表
print(a) #得到列表结果地址
print(list(a)) #list()获取列表的值
num1 = ['l','o','v','e']
a1 = map(lambda x:x+'520',num1)
print(a1)
print(list(a1))
② filter()—遍历序列中的每个元素,判断每个元素得到布尔值,若True则留下来reduce()—处理一个序列,然后靶序列进行合并并操作
num = ['005','lhm','lkm']
a = filter(lambda x:x.startswith('l'),num) #num中元素迭代到前面函数，将运行结果为True的存入列表
print(a) #得到列表结果地址
print(list(a)) #list()获取列表的值
num1 = [0,5,25,2]
a1 = filter(lambda x:x>2,num1)
print(a1)
print(list(a1))
③ reduce()—处理一个序列,然后靶序列进行合并并操作
from functools import reduce
a = reduce(lambda x,y:x+y,range(10)) #没初始化值，默认为0，0+0+1+。。。+9
b = reduce(lambda x,y:x+y,range(10),6) #初始化值，初始值为6开始，6+0+1+。。。+9
print(a,b)
11. 内置函数（之前出现的就略过了）
① abs()—绝对值,hex()，oct(),bin()—二进制转十六，八，二进制
a1,a2,a3 = -1,2,0
print(abs(a1),abs(a2),abs(a3))
b1 = 6
print(bin(b1),oct(b1),hex(b1))
② str(),type()—转化为字符串，类型查看
h1 = 520
h2 = str(h1)
print(h2)
print(type(h1),type(h2))
③ bool()—布尔值（空，None，0的布尔值为False，其余全为True）
print(bool(''),bool(None),bool(0))
print(bool(['l']),bool('abc'),bool(520))
④ all()—若为空，为True；全真为True；只能有一个参数或参数值
print(all(''),all([5,2,0]),all('wxt'))
⑤ any()—有一个真即为True
print(any([5,2,0]),any('lhm'),any(''))
⑥ bytes(),encode(),decode()—编码,编码,解码
name = 'wxt'
print(name.encode('utf-8')) #encode()编码
print(name.encode('utf-8').decode('utf-8')) #decode()解码,前后编码解码方式一致
print(bytes(name,encoding='utf-8'))
print(bytes(name,encoding='utf-8').decode('utf-8')) #前后编码解码方式一致
⑦ chr(),ord()—转化为对应ASCII编码，ASCII编码转化为对应值
print(chr(98),ord('a'))
⑧ dir()—查看某一个对应下面的所对应的方法，help()—查看方法的使用方法
print(dir(list()))
print(help(list()))
⑨ divmod()—取商得余数,可做分页功能，divmod(总内容,每页内容数)–>(n,m)所需页数n+m
print(divmod(10,3))
⑩ eval()—将字符串中的数据结构提取出来，将字符串中的数学运算进行运算得到计算结果
a = [1,2,3]
print(eval(a))
print(eval('5+7'))
⑪ 11.hash()—可hash的数据类型即不可变类型，反之相反特性：
a. 传入参数与传出hash长度无关，hash定长
b. 不可反推hash
c. 可检测软件是否植入木马，只能软件不变，在任何地方或情况下hash不变
m = 'love'
print(hash(m))
print(hash(m))
m = m+'wxt'
print(hash(m))
⑫ vars()—无参数数时调用等于locals，有参数是时，参看某方法的使用方法以字典形式打印
print(vars())
print(locals())
print(vars(str))
⑬ isinstance()—判断前者是否为后者的的类型
print(isinstance(1,int),isinstance(2,str))
⑭ globals(),local()—全局变量，局部变量
print(globals())
print(locals())
⑮ zip()—压缩提取
d1 = list(zip(('w','x','t'),(5,2,0))) #前后长度相同
d2 = list(zip(('w','x','t'),(5,2,0,0,0))) #若不同，则省略后面数据
print(d1,d2) #前后对应合并
d3 = {'name':'wxt','age':19}
d4 = list(zip(d3.keys(),d3.values())) #对应合并
print(d4)
⑯ import—导入模块，不能导入字符串，import()，可以导入字符串
import time
print(time)
⑰ reversed()—顺序反转，不影响原来列表
e1 = ['l','o','v','e',5,2,0]
print(reversed(e1)) #直接调用返回的是列表地址
print(list(reversed(e1))) #list()使其成为列表
⑱ slice()—切片
f1 = 'love'
f2 = ['love',520]
print(slice(f1)) #前后None补充
print(slice(f2))
⑲ max(),min()—最大最小值，pow()—次幂函数
print(max([5,2,0]),min([5,2,0]))
print(pow(2,10),pow(2,10,5)) #2**10 2**10%5
⑳ sorted()—排序，数字从大到小，不能混合字符串数字
g1 = [5,2,0]
print(sorted(g1))
g2 = {'a':120,'b':520,'c':666}
print(sorted(g2,key=lambda key:g2[key])) #排序出key所对应的value大小顺序
12. 风湿理论
创建函数—>创建变量
调用函数—>print变量
总结
函数魔法的相关知识就简单说这些，还不赶快去学习！
类似资料：