文章目录

  • 前言
  • 函数
  • 1. 特点
  • 2. 格式
  • 3. 参数的使用
  • ① 位置参数---形参顺序与实参顺序相同，缺/多一不行
  • ② 关键字参数---指明参数，缺/多一不行
  • ③ 默认参数---默认参数值
  • ④ 混合参数使用---位置参数必须在关键字参数左边，不能位置与关键字参数重复
  • 4. 全局变量与局部变量（PS）
  • ① 先从内部找，找不到再从外部找
  • ② 如果函数的内容无global关键字，优先读取局部变量，若无则读取全局变量，能读取全局变量，但无法对全局变量进行重新赋值，但可变类型可以对内部元素进行操作。
  • ③ 如果函数中有global关键字，变量本质上是全局的那个变量，可读取可赋值。
  • ④ name = ‘a’ global name 此形式为错误形式。
  • ⑤ 局部前加global变量名，只改变最外边变量，使之变化，靠近的不受影响。
  • 5. 函数魔法与列表字典魔法连接
  • ① *列表
  • ② **字典
  • ③ 混合使用
  • 6. 递归函数魔法---自己调用本身函数匿名函数
  • 7. 匿名函数函数作用域
  • 8. 函数作用域高阶函数
  • 9. 高阶函数
  • ① 把函数当作参数传给另一个函数
  • ② 返回值中包含函数
  • 10. 三大高级函数
  • ① map()---处理序列中每个元素,得到的结果是一个列表,该列表元素个数及位置与原来一样
  • ② filter()---遍历序列中的每个元素,判断每个元素得到布尔值,若True则留下来reduce()---处理一个序列,然后靶序列进行合并并操作
  • ③ reduce()---处理一个序列,然后靶序列进行合并并操作
  • 11. 内置函数（之前出现的就略过了）
  • ① abs()---绝对值,hex()，oct(),bin()---二进制转十六，八，二进制
  • ② str(),type()---转化为字符串，类型查看
  • ③ bool()---布尔值（空，None，0的布尔值为False，其余全为True）
  • ④ all()---若为空，为True；全真为True；只能有一个参数或参数值
  • ⑤ any()---有一个真即为True
  • ⑥ bytes(),encode(),decode()---编码,编码,解码
  • ⑦ chr(),ord()---转化为对应ASCII编码，ASCII编码转化为对应值
  • ⑧ dir()---查看某一个对应下面的所对应的方法，help()---查看方法的使用方法
  • ⑨ divmod()---取商得余数,可做分页功能，divmod(总内容,每页内容数)-->(n,m)所需页数n+m
  • ⑩ eval（)---将字符串中的数据结构提取出来，将字符串中的数学运算进行运算得到计算结果
  • ⑪ 11.hash()---可hash的数据类型即不可变类型，反之相反特性：
  • ⑫ vars()---无参数数时调用等于locals，有参数是时，参看某方法的使用方法以字典形式打印
  • ⑬ isinstance()---判断前者是否为后者的的类型
  • ⑭ globals(),local()---全局变量，局部变量
  • ⑮ zip()---压缩提取
  • ⑯ import---导入模块，不能导入字符串，__import__()，可以导入字符串
  • ⑰ reversed()---顺序反转，不影响原来列表
  • ⑱ slice()---切片
  • ⑲ max(),min()---最大最小值，pow()---次幂函数
  • ⑳ sorted()---排序，数字从大到小，不能混合字符串数字
  • 12. 风湿理论
  • 创建函数--->创建变量
  • 调用函数--->print变量
  • 总结


前言

函数魔法，是每一个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变量

总结

函数魔法的相关知识就简单说这些，还不赶快去学习！