内置函数与匿名函数

1.匿名函数

  • 一句话函数，比较简单的函数

  • 此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.

  • lambda 是定义匿名函数的关键字，相当于函数的def.

  • lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。

  • 返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。

  • 匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据

  • 练习题

    def func(a,b):
    return a+b
print(func(1,2))

#构建匿名函数
func1 = lambda a,b: a+b
print(func1(1,2))

    # 接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式)
func2 = lambda x:(x[0],x[2])
print(func2([22,33,44,55]))

# 写匿名函数：接收两个int参数，将较大的数据返回。
func3 = lambda x,y:x if x > y else y
print(func(2,3))

2.内置函数

  • 在python中提供了68个内置函数

  • int

    print(int(3.1415))
# 3

  • float 浮点型

    print(type(3.6))

  • bin 将十进制转换成二进制并返回

    print(bin(10))
# 0b1010

  • oct 将十进制转化成八进制字符串并返回

    print(oct(10))
# 0o12

  • hex 将十进制转化成十六进制字符串并返回

    print(hex(10))
# 0xa

  • divmod 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)

    print(divmod(10,3))
# (3, 1)

  • round 保留浮点数的小数位数，默认保留整数。

    print(round(3.141592653, 2))  
# 3.14

  • pow 求x** y次幂。（三个参数为x**y的结果对z取余）

    print(pow(2,3))
# 8
print(pow(2,3,3))   #   2**3 % 3
# 2

  • bytes 把字符串转换成bytes类型 (用于不同编码之间的转化)

    s = "太白" 
b = s.encode("utf-8")
print(b)
# b'\xe5\xa4\xaa\xe7\x99\xbd'

s1 = "太白"
b = bytes(s1,encoding ="utf-8")
print(b)
# b'\xe5\xa4\xaa\xe7\x99\xbd'

  • ord 输入字符找该字符在unicode编码的位置

    print(ord("a"))
# 97

  • chr 输入位置数字找出其对应的字符 (unicode)

    print(chr(97))
# a

  • repr :返回一个对象的string形式(原型毕露)

    s1 = "太白"
print(repr(s1))
# "太白"

s1 = "太白"
msg = "我叫%s" %(s1)
print(msg)  # 我叫太白

msg = "我叫%r" %(s1)
print(msg)  我叫 "太白"

  • all :可迭代对象中，全都是True，才是True

    l1 = [1, 2, '太白', True, [1,2,3], '']
print(all(l1))
# False

  • any 可迭代对象中，有一个True 就是True

    l1 = [0, '太白', False, [], '']
print(all(l1))
# True

  • abs 获取绝对值

    v = -9
print(abs(v))
# 9

  • sum 求和

    l1 = [i for i in range(10)]
print(sum(l1))
# 45

s1 = "123456"
print(sum(s1))
# 报错

  • reversed 返回的是一个翻转的迭代器

    l1 = [i for i in range(10)]
l1.reverse()  # 列表的方法
print(l1)
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

l1 = [i for i in range(10)]
obj = reversed(l1)  
print(list(obj))
# [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

  • zip 拉链方法.函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回，

    l1 = [1, 2, 3, 4, 5]
tu1 = ('太白', 'b哥', '德刚')
s1 = 'abcd'
obj = zip(l1,tu1,s1)
print(list(obj))
# [(1, '太白', 'a'), (2, 'b哥', 'b'), (3, '德刚', 'c')]
for i in obj:
    print(i)
# (1, '太白', 'a')
# (2, 'b哥', 'b')
# (3, '德刚', 'c')

  • min max 获取最小值，最大值

    求l1的最小值
l1 = [33, 2, 3, 54, 7, -1, -9]
print(min(l1))
# -9

# 以绝对值的方式取最小值
l1 = [33, 2, 3, 54, 7, -1, -9]
l2 = []
func= lambda a:abs(a)
for i in l1
	l2.append(func(i))
print(min(l2))
# 1

l1 = [33, 2, 3, 54, 7, -1, -9]
def func(a):
    """
    第一次：a = 23  以绝对值取最小值 23
    第二次：a = 2   以绝对值取最小值 2
    第三次：a = 3   以绝对值取最小值 3
    ......
    第六次：a = -1  以绝对值取最小值 1
    第七次：a = -9  以绝对值取最小值 9
    :param a:
    :return:
    """
    return abs(a)
print(min(l1,key= func))
# -1
	
print(min(l1,key= lambda a:abs(a)))
# -1
# 凡是可以加key的：它会自动的将可迭代对象中的每个元素按照顺序传入key对应的函数中以返回值比较大小。

dic = {"a":3,"b":2,"c":1}
# 求出值最小的键
# print(min(dic))  # min默认会按照字典的键取比较大小

def func(args):
    '''
    第一次：
     args:   'a'   返回值：dic['a']     记录：3
    第二次：
     args :   'b'   返回值：dic['b']     记录：2
    第三次：
     args:    'c'   返回值：dic['c']    记录：1
    '''
    return dic[args]
print(min(dic ,key= func))
# c

def func(a):
    return dic[a]
func = lambda a:dic[a]    
print(min(dic,key= lambda a:dic[a]))
# c

  • sorted 进行排序

    l1 = [22, 33, 1, 2, 8, 7,6,5]
l2 = sorted(l1)
print(l1)
# [22, 33, 1, 2, 8, 7, 6, 5]
print(l2)
# [1, 2, 5, 6, 7, 8, 22, 33]

l3 = [('大壮', 76), ('雪飞', 70), ('纳钦', 94), ('张珵', 98), ('b哥',96)]
print(sorted(l3))
# [('b哥', 96), ('大壮', 76), ('张珵', 98), ('纳钦', 94), ('雪飞', 70)]

print(sorted(l3,key = lambda x:x[1])) #返回的是一个列表，默认从低到高 
# [('雪飞', 70), ('大壮', 76), ('纳钦', 94), ('b哥', 96), ('张珵', 98)]

print(sorted(l3,key= lambda x:x[1],reverse = True)) 
# [('张珵', 98), ('b哥', 96), ('纳钦', 94), ('大壮', 76), ('雪飞', 70)]

  • filter 类似于列表推导式的筛选模式

    将大于3的数字返回
l1 = [2, 3, 4, 1, 6, 7, 8]
print([i for i in l1 if i > 3 ])  # 返回的是列表
# [ 4, 6, 7, 8]
ret = filter(lambda x:x > 3 ,l1)  # 返回的是迭代器
print(list(ret))
# [4, 6, 7, 8]

  • map 类似于列表推导式的循环模式

    l1 = [1, 4, 9, 16, 25]

print([i*2 for i in range(1,6)])  # 返回的是列表
ret = map(lambda x: x**2,range(1,6)) # 返回的是迭代器
print(list(ret))

  • reduce

    from functools import reduce
def func(x,y):
    """
    第一次：x  y  : 11  2     x + y =     记录： 13
    第二次：x = 13   y  = 3    x + y =    记录： 16
    第三次  x = 16   y = 4 .......
    """
    return x + y

lis = reduce(func,[11,2,3,4])
print(lis)

3.闭包

  • 封闭的东西，保证数据的安全

    def make_averager():
    l1 = []
    def averager(new_value):
        l1.append(new_value)
        print(l1)
        total = sum(l1)
        return total/len(l1)
    return averager
avg = make_averager()
print(avg(100000))  # 100000
print(avg(110000))  # 105000
print(avg(120000))  # 110000
print(avg(90000))   # 105000

    1557921152322

  • 什么是闭包

    • 闭包只能存在在嵌套函数中。
    • 内层函数对外层函数非全局变量的引用(使用)，就会形成闭包。
    • 被引用的非全局变量也称自由变量，这个自由变量与内层函数产生一个绑定关系。
    • 自由变量不会再内存中消失

  • 闭包的作用

    • 保存局部信息不被销毁，保证数据的安全性。

  • 如何判断一个嵌套函数是不是闭包

    1. 闭包只能存在嵌套函数中
    2. 内存函数对外层函数非全局变量的引用（使用），就会形成闭包

  • 判断函数是否是会形成闭包

    def func():
    a = 1
    def inner():
        print(a)
    return inner
ret = func()
# 是闭包
a = 2
def func():
    def inner():
        print(a)
    return inner
ret = func()
# 不是闭包，a是全局变量

def func(a,b):
    def inner():
        print(a)
        print(b)
    return inner
a = 2
b = 3
ret = func(a,b)
print(ret())
就相当于这样
def func(a,b):
    a = 2
    b = 3
    def inner():
        print(a)
        print(b)
    return inner
ret = func(a,b)
print(ret())

  • 如何用代码判断是闭包

    def func(a,b):
    def inner():
        print(a)
        print(b)
    return inner
a = 2
b = 3
ret = func(a,b)
print(ret.__code__.co_freevars) # ('a', 'b')

总结

posted @ 2019-05-16 20:54  菜鸟学小白  阅读(61)  评论(0)    收藏  举报
ヾ(≧O≦)〃嗷~