day16 函数的用法：内置函数，匿名函数

思维导图需要补全：

一共有68个内置函数：

day16 函数的用法：内置函数，匿名函数

#内置：python自带

# def func():

#     a = 1

#     b = 2

#     print(locals())

#     print(globals())

# func()

# range(100)  #[0,100)

# range(5,100) #[5,100)

# range(1,100,2)

#可迭代对象，可以for循环，惰性运算

# range(100).__iter__()

# iterator = iter(range(100))  #拿到一个迭代器

# print(iterator.__next__())

# print(next(iterator))

# for i in range(100):

#     print(i)

# def iter():

#     return range(100).__iter__()

# print(dir([]))

# print(dir(5))

# a = 1

# def func():pass

# print(callable(a))      #不可以调用

# print(callable(print))  #可以调用

# print(callable(func))   #可以调用

#ctrl + 左键单击 ：pycharm

#help：包含所有方法名以及他的使用方法 —— 不知道用法

#dir：只包含方法名 —— 想查看某方法是否在这个数据类型中

import time   #时间

import os     #操作系统

# f = open('文件名','w',encoding='utf-8')

#打开模式：r、w、a、rb、wb，ab

#编码 utf-8/GBK

# print(id(1))

# print(id(2))

# print(hash('sajghfj;eyrwodnvjnz,.jifupwk'))  #算法

# print(hash(125342))

# print(hash((1,2,3,4)))

#数据的存储和查找

#模块：hashlib

# {'k':'v'}

# [1,2,3,4,5,6,]

# hash([1,2,3,4,5,6,])

#hash 判断一个数据类型是否可以hash

#在一个程序执行的过程中，对同一个值hash的结果总是不变

#多次执行，对同一个值的hash结果可能改变

# s = input('提示:')

# print(1,2,3,4,5,sep='*')  #sep是指定多个要打印的内容之间的分隔符

# print(1,2,sep=',')   #print('%s,%s'%(1,2))

# f = open('a','w')

# print('abc\n')

# print(2)

# import time

# for i in range(0,101,2):  #[0,2,4,6,8...100]

#      time.sleep(0.2)

#      char_num = i//2      #打印多少个'*'    8/2 = 4

#      if i == 100:

#           per_str = '\r%s%% : %s\n' % (i, '|' * char_num)

#      else:

#           per_str = '\r%s%% : %s'%(i,'|'*char_num)

#      print(per_str,end='', flush=True)

# print('你好')

# print('再见')

#ftp == 网盘

# print("\033[31;1mHello world,how are you \033[0m")

# print('\033[4;32;41m金老师')

# print('egon')

# print('alex \033[0m')

# exec("print('12345')")

# eval("print('12345')")

# print(exec('1+2+3-4'))

# print(eval('1+2+3-4'))

# a = 1+2+3-4

# print(1+2+3-4)

# code1 = 'for i in range(0,10): print (i)'

# compile1 = compile(code1,'','exec')

# exec(compile1)

#简单求值表达式用eval

# code2 = '1 + 2 + 3 + 4'

# compile2 = compile(code2,'','eval')

# print(eval(compile2))

# code3 = 'name = input("please input your name:")'

# compile3 = compile(code3,'','single')

# # name #执行前name变量不存在

# exec(compile3)

# print(name)

#exec

#eval

#compile

# print(abs(5))

# ret = divmod(10,2)   #商余

# print(ret)

# ret = divmod(3,2)

# print(ret)

# ret = divmod(7,2)

# print(ret)

#

#

# divmod(107,10)

# print(round(3.14159,2))

# print(pow(2,3.5))   #幂运算

# print(pow(3,2))

# print(pow(2,3,2))

# print(pow(2,3,3))  #x**y%z

# print(sum([1,2,3,4,5,6],-2))

# print(sum(range(100)))

#sum接收一个可迭代对象

#min

# print(min([1,4,0,9,6]))

# print(min([],default=0))

print(min([-9,1,23,5],key=abs))#匿名函数

# print(min({'z':1,'a':2}))

# t = (-25,1,3,6,8)

# print(max(t))

# print(max(t,key = abs))

# print(max((),default=100))

前情概要：

def wrapper1(func):

    def inner1(*args,**kwargs):

        print('in wrapper 1,before')

        ret = func(*args,**kwargs)   #qqxing

        print('in wrapper 1,after')

        return ret

    return inner1

def wrapper2(func):     #inner1

    def inner2(*args,**kwargs):

        print('in wrapper 2,before')

        ret = func(*args,**kwargs)   #inner1

        print('in wrapper 2,after')

        return ret

    return inner2

@wrapper2

@wrapper1

def qqxing():

    print('qqxing')

qqxing()    #inner2

内置函数补全：

# l = [3,4,2,5,7,1,5]       #

# ret = reversed(l)

# print(ret)

# print(list(ret))

# #next ,__next__

# #for

# l.reverse()

# print(l)

# l = (1,2,23,213,5612,342,43)

# sli = slice(1,5,2)   #实现了切片的函数

# print(l[sli])

#

# #l[1:5:2]  语法糖

# print(format('test', '<20'))

# print(format('test', '>20'))

# print(format('test', '^20'))

#网络编程的时候：能在网络上传递的必须是字节

# ret = bytes('你好，哈哈哈，再见',encoding='utf-8')

# #中间是网络传输的过程

# print(ret.decode(encoding='utf-8'))

# ret = bytearray('alex',encoding='utf-8')  #对比较长的字符串做修改的时候，指定某一处进行修改，不会改变这个bytearry的内存地址

# print(id(ret))

# print(ret[0])

# ret[0] = 65

# print(ret)

# print(id(ret))

#切片

# l = [1,2,3,4,5,60]

# l[1:3]

# ret = memoryview(bytes('你好',encoding='utf-8'))

# print(ret)

# print(len(ret))

# print(ret[:3])

# print(bytes(ret[:3]).decode('utf-8'))

# print(bytes(ret[3:]).decode('utf-8'))

# print(ord('a'))

# print(chr(97))

# print(ascii(97))

# print(repr(1))

# print(repr('1'))

# print('name : %r'%('金老板'))

# l = ['笔记本','phone','apple','banana']

# for i,j in enumerate(l,1):

#     print(i,j)

# print(all([1,2,3,4,0]))

# print(all([1,2,3,4]))

# print(all([1,2,3,None]))

# print(all([1,2,3,'']))

# print(any([True,None,False]))

# print(any([False,None,False]))

#拉链函数

# print(list(zip([0,1,2,3,4],[5,6,7,8],['a','b'])))

#过滤函数

# def is_odd(x):

#     if x>10:

#         return True

# ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

# print(list(ret))

# def is_odd(x):

#     if x%2 == 0:

#         return True

# ret = filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

# print(list(ret))

#filter就是有一个可迭代对象，想要一个新的内容集，是从原可迭代对象中筛选出来的

# def func(x):

#     #return x.strip()    #‘   ’.strip() ==> '' ==> return False

#                          # 'test'.strip() ==> 'test'

#     return x and x.strip() #None  False and

#去掉所有的空内容和字符串中的空格

# l = ['test', None, '', 'str', '  ', 'END']

# ret = filter(func,l)

# print(list(ret))

#新内容少于等于原内容的时候，才能用到filter

#新内容的个数等于原内容的个数

# ret = map(abs,[-1,-5,6,-7])   #abs(-1) = 1   abs(-5) = 5

# print(list(ret))

#filter和map

#参数很相近：都是一个函数名+可迭代对象

#且返回值页很相近：都是返回可迭代对象

#区别

#filter是做筛选的，结果还是原来就在可迭代对象中的项

#map是对可迭代对象中的每一项做操作的，结果不一定是原来就在可迭代对象中的项

#有一个list， L = [1,2,3,4,5,6,7,8]，我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理

# def func(x):

#     return x*x

# ret = map(func,[1,2,3,4,5,6,7,8])

# print(list(ret))

#sort 是直接修改原列表的顺序，节省内存

#sorted 是生成一个新列表，不改变原来的列表

#key = func

# print(sorted([-5,3,-4,2,-1],reverse=True))

# print(sorted([-5,3,-4,2,-1],key=abs))

# l2 = ['ajkhs',(1,2),'a',[1,2,3,4]]

# print(sorted(l2,key=len,reverse=True))

# print(ascii('a'))

# print(ascii(1))

匿名函数：

# def calc(n):return n**n

# print(calc(10))

# cal = lambda n:n**n #lambda表达式、匿名函数

# cal = lambda: 1==2 #lambda表达式、匿名函数

# cal = lambda n: True if 1==2 else False #lambda表达式、匿名函数

# print(cal())

# def add(x,y):return x+y

# add = lambda x,y:x+y

# print(add(1,2))

# print(max([1,2,3,4,-5],key=abs))

# dic={'k1':10,'k2':100,'k3':30}

# # print(max(dic.values()))

# # print(max(dic))

# print(max(dic,key=lambda k:dic[k]))

# def func(x):

#     return x*x

# ret = map(lambda x:x*x,[1,2,3,4,5,6,7,8])

# print(list(ret))

# def func(num):

#     return num>99 and num<1000

ret = filter(lambda num: num>99 and num<1000,[1,4,6,823,67,23])

print(list(ret))

# def func(num):

#     if num > 10:

#         return True

    #return num>10

ret = filter(lambda num:num>10,[1,4,6,823,67,23])

ret = filter(lambda num:True if num>10 else False,[1,4,6,823,67,23])

print(list(ret))

#max min

#map filter

这是一道经典题:关于lambda表达式加上列表生成式

def num():

    return [lambda x:i*x for i in range(4)]  
"""
这里的range(4)就是循环0,1,2,3到3截止,然后得到的是4个lambda函数,这个列表是列表生成式,这个生成式直接就把执行后的结果返回给了这个列表里面,
所以我们得到的这个列表本身就是里面的for循环执行后的结果,那么这个for循环执行完这个i就是3,所以就得到下面的lambda表达式里面的i=3
[lambda x:3*x,lambda x:3*x,lambda x:3*x,lambda x:3*x]这里就是返回值,
一个列表,每一个列表中的元素都是一个lambda函数
]
"""

print([m(2) for m in num()])这里也是一个列表生成式,里面的num()会先执行,就触发了我们上面的函数,得到返回值是一个列表,列表里面是一个个lambda表达式的函数,
然后循环这个列表,把每一个函数进行传参调用,得到的就是我们上面的函数被调用加上参数的结果,就是lambda 2:2*3  结果就是6,每一个lambda都是6这个结果,最终打印的结果是[6,6,6,6]

匿名函数进阶的面试题：

# d = lambda p:p*2

# t = lambda p:p*3

# x = 2

# x = d(x)   #4 = d(2)

# x = t(x)   #12 = t(4)

# x = d(x)   #24 = d(12)

# print(x)

#2.现有两元组(('a'),('b')),(('c'),('d')),

# 请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

# t1 = (('a'),('b'))

# t2 = (('c'),('d'))

# t3 = zip(t1,t2)  #[('a','c'),('b','d')]

# print(list(map(lambda t:{t[0]:t[1]},[('a','c'),('b','d')])))

#3.

def multipliers():

    return (lambda x:i*x for i in range(4))

print([m(2) for m in multipliers()])

# i = 0

# m =  lambda x:i*x

# m(2)

# i = 1

# m =  lambda x:i*x

# m(2)