5.2.6 函数可以当作参数进行传递

def func(arg):
	arg()
def ggg():
    print(123)
func(ggg)#输出就结果为123

def func(arg):
    v1 = arg()
    print(v1)
    
def show():
    print(666)
    
result = func(show)
print(result)

5.2.6 lambda表达式

  • 用于表达就简单函数

    # 三元运算，为了解决简单的if else的情况，如：
if 1 == 1:
    a = 123
else:
    a = 456

a =  123  if 1 == 1 else 456

# lambda表达式，为了解决简单函数的情况，如：
def func(a1,a2):
    return a1 + 100 

func = lambda a1,a2: a1+100

#列表的所有方法基本上返回值都是none，字符串的所有方法都是返回新的值

练习题

# 练习题1
USER_LIST = []
def func0(x):
    v = USER_LIST.append(x)
    return v 

result = func0('alex')
print(result)


# 练习题2

def func0(x):
    v = x.strip()
    return v 

result = func0(' alex ')
print(result)

############## 总结：列表所有方法基本上都是返回None；字符串的所有方法基本上都是返回新值 #################
# 练习题3
USER_LIST = []
func1 = lambda x: USER_LIST.append(x)

v1 = func1('alex')
print(v1)
print(USER_LIST)

# 练习题4
func1 = lambda x: x.split('l')

v1 = func1('alex')
print(v1)

# 练习题5
func_list = [lambda x:x.strip(), lambda y:y+199,lambda x,y:x+y]

v1 = func_list[0]('alex ')
print(v1)

v2 = func_list[1](100)
print(v2)

v3 = func_list[2](1,2)
print(v3)

5.2.7 内置函数

  • 内置函数

    • 其他

      • len
      • open
      • range
      • id
      • type

    • 输入输出

      • print
      • input

    • 强制转换

      • dict()
      • list()
      • tuple()
      • int()
      • str()
      • bool()
      • set()

    • pow

      v = pow(2,3)
print(v)

      • round

        v = round(1.127,2)
print(v)

    • 编码相关

      • chr，将十进制数字转换成 unicode 编码中的对应字符串。

        v = chr(99)
print(v)

      • ord，根据字符在unicode编码中找到其对应的十进制。

        num = ord('中')

      • 应用：

        import random

def get_random_code(length=6):
    data = []
    for i in range(length):
        v = random.randint(65,90)
        data.append(chr(v))

    return  ''.join(data)


code = get_random_code()
print(code)

        import random # 导入一个模块 

v = random.randint(起始,终止) # 得到一个随机数

    • 高级一点的内置函数

      • map，循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

        v1 = [11,22,33,44]
result = map(lambda x:x+100,v1)
print(list(result)) # 特殊

      • filter

        v1 = [11,22,33,'asd',44,'xf']

def func(x):
    if type(x) == int:
        return True
    return False
result = filter(func,v1) # [11,]
print(list(result))


result = filter(lambda x: True if type(x) == int else False ,v1)
print(list(result))

result = filter(lambda x: type(x) == int ,v1)
print(list(result))

      • reduce

        import functools
v1 = ['wo','hao','e']

def func(x,y):
    return x+y
result = functools.reduce(func,v1) 
print(result)

result = functools.reduce(lambda x,y:x+y,v1)
print(result)

  • 数学相关

    • abs，绝对值

      v = abs(-1)
print(v)#得到1，求出数字的绝对值

    • float，转换成浮点型（小数）

      v = 55
v1 = float(55)
print(v1)

    • max，找到最大值

      v = [1,2,311,21,3,]
result = max(v)
print(result)#输出311找到最大值

    • min，找最小值

      v = [1,2,311,21,3,]
result = min(v)
print(result)

    • sum，求和

      v = [1,2,311,21,3,]
result = sum(v)
print(result)#求和

    • divmod，两数相除的商和余数

      a,b = divmod(1001,5)
print(a,b)

      # 练习题  请通过分页对数据进行展示
"""
要求：
    每页显示10条数据
    让用户输入要查看的页面：页码
"""

USER_LIST = []
for i in range(1,836):
    temp = {'name':'你少妻-%s' %i,'email':'123%s@qq.com' %i }
    USER_LIST.append(temp)

# 数据总条数
total_count = len(USER_LIST)

# 每页显示10条
per_page_count= 10

# 总页码数
max_page_num,a = divmod(total_count,per_page_count)
if a>0:
    max_page_num += 1

while True:
    pager = int(input('要查看第几页：'))
    if pager < 1 or pager > max_page_num:
        print('页码不合法，必须是 1 ~ %s' %max_page_num )
    else:
        """
        # 第1页：USER_LIST[0:10] -> 0123456789
        # 第2页：USER_LIST[10:20]
        # 第3页：USER_LIST[20:30]
        ...
        """
        start = (pager-1) * per_page_count
        end = pager * per_page_count
        data = USER_LIST[start:end]
        for item in data:
            print(item)

  • 进制转换相关

    • bin，将十进制转化成二进制

      num = 13
v1 = bin(num)
print(v1)

    • oct，将十进制转换成八进制

      num = 8
v1 = oct(num)
print(v1)

    • int，将其他进制转化成十进制

      # 二进制转化成十进制
v1 = '0b1101'
result = int(v1,base=2)
print(result)

# 八进制转化成十进制
v1 = '0o1101'
result = int(v1,base=8)
print(result)

# 十六进制转化成十进制
v1 = '0x1101'
result = int(v1,base=16)
print(result)

    • hex，将十进制转换成十六进制

      num = 16
v1 = hex(num)
print(v1)

5.2.8 函数中高级

5.2.8.1 函数可以作为返回值
def f():
    print(123)
def b():
    return f
v = b()#v就是f函数
v（）#执行f函数
5.2.8.2 闭包

  • 闭包应用场景：装饰器，sqlaeilde源码中

  • 闭包的概念：为函数创建一块区域，并维护自己数据，以便以后调用

    def cf():
    def tm():
        print("123")#内层函数需要使用才叫一个闭包
    return tm
c = cf()#内存地址会保留这次数据的函数执行，到使用c（）把tm函数执行使用后内存才会销毁
5.2.8.3 递归

  • 递归（默认python递归最大递归次数1000次）

    def func():#死循环实例
	print(1)
    func()
func()
###################################################
def func（a，b）:#斐波那契数列，递归实现方法
    if a ==5：
    	return 500000
    print(b)
    func(b,a+b)
func(0,1)

  • 用这个模块就可以查看递归次数

1555379186868

  • 递归效率不高，尽量减少用递归。用while代替

    # 递归的返回值
def func(a):
    if a == 5:
        return 100000
    result = func(a+1) + 10

v = func(1)
name = 'alex'
def func():
    def inner():
        print(name)
     return inner
v =func()

5.3 推导式&装饰器

5.3.1 装饰器

  • 在不改变原函数代码的前提下，让函数在之前之后做些操作
  • 装饰器准则：
    • 变量的赋值
    • 看看return的是什么
    • 自己没有去上级作用域找
def func():
	pass
v = func
v()
######################################################
def base():
	print(1)
    pass
def bar():
    print（2）
    pass
base = bar
base()#执行bar函数
#####################################################


重点：（记住格式以及执行原理）
def func(arg):
    def iner():
        mun  = arg()
        print(mun)
        return mun
    return iner

@func#执行func函数并把下面参数传递相当于func（index）,将func的返回值重新赋值给下面的函数名相当于index = func（index）
def index():
    print(123)
    return 666
index()

def x(func):
    def inner(a1,a2):
        return func(a1,a2)
    return inner 

@x
def index(a1,a2):
	pass

# index = inner
index(1,2)

# ################################### 参数统一的目的是为了给原来的index函数传参
def x(func):
    def inner(a1,a2):
        return func()
    return inner 

@x
def index():
	pass
# func = 原来的index函数u
# index = inner
index(1,2)

  • 装饰器应用

    # 计算函数执行时间

def wrapper(func):
    def inner():
        start_time = time.time()
        v = func()
        end_time = time.time()
        print(end_time-start_time)
        return v
    return inner

@wrapper
def func1():
    time.sleep(2)
    print(123)
@wrapper
def func2():
    time.sleep(1)
    print(123)

def func3():
    time.sleep(1.5)
    print(123)

func1()

  • 装饰器应用场景：想要为函数拓展功能时，可以选择用装饰器

    装饰器编写格式
def func(参数):
    def iner(*args,**kwargs):
        mun  = arg(*args,**kwargs)
        return 参数（）
    return iner内层函数

  • 装饰器应用格式

    @外层函数
def index():
    print(123)
    return 666
使用函数index()

  • 带参数的装饰器场景：常见在flask框架中，让装饰器实现函数要执行N次

  • 关于参数

  • 关于返回值

5.3.1.1 带参数的装饰器

  • 带参数的装饰器实例：

    def x(counter):#实现效果@x几次输入几次执行，并返回结果以列表呈现
	def wad(func):
        def inte(*args,**kwargs):
            a = []
            for i in range(counter):
                e = func(*args,**kwargs)
                a.append(e)
            return a
        return inte
    return wad
@x(10)
def gg(c):
    print(c)

5.3.2 推导式

  • 列表推导式

    • 基本格式

      目的方便的生成一个列表
方式一
vp = [i for i in "alex"#可迭代对象]
print(vp)#输出["a","l","e","x"]
方式二
vp = [i+100 for i in range（5）]
print（vp）#输出[100,101,102,103,104]

      """
目的：方便的生成一个列表。
格式：
	v1 = [i for i in 可迭代对象 ]
	v2 = [i for i in 可迭代对象 if 条件 ] # 条件为true才进行append
"""
v1 = [ i for i in 'alex' ]  
v2 = [i+100 for i in range(10)]
v3 = [99 if i>5 else 66  for i in range(10)]

def func():
    return 100
v4 = [func for i in range(10)]

v5 = [lambda : 100 for i in range(10)]
result = v5[9]()

def func():
    return i
v6 = [func for i in range(10)]
result = v6[5]()

v7 = [lambda :i for i in range(10)]
result = v7[5]()


v8 = [lambda x:x*i for i in range(10)] # 新浪微博面试题
# 1.请问 v8 是什么？
# 2.请问 v8[0](2) 的结果是什么？

# 面试题
def num():
    return [lambda x:i*x for i in range(4)]
# num() -> [函数,函数,函数,函数]
print([ m(2) for m in num() ]) # [6,6,6,6]

# ##################### 筛选 #########################
v9 = [i for i in range(10) if i > 5]

  • 集合推导式

    • 基本格式

      vp = set(i for in "alex")

  • 字典推导式

    v1 = {"k"+str(i):i for i in range(10)}