内置函数二 闭包

今日总结

非常重要的一章,可是上课的我好困好困

1. 匿名函数

   1.1 lambda 形参 : 返回值 ———— lambda x : x

    	形参可有可无,返回值必须写,返回值只能是一个数据类型.  
   

   ​ 匿名函数的名字叫 lambda

   1.2 abs ( ) 绝对值

   1.3 filter("函数","可迭代对象") 写函数的时候可以指定过滤条件

   1.4 map("函数","可迭代对象" ) 写函数时,可以指定对元素的操作

   1.5 zip("可迭代对象","可迭代对象") 返回的是一个内存地址,一般是元组的形式

   1.6 sorted("可迭代对象",key = "函数名", reverse = True) key 是指定排序的规则,默认是升序,写了reverse = True 就是降序

   1.7 reserved ("可迭代对象") 对可迭代对象进行翻转(不改变源数据)

   1.8 max("可迭代对象",key = abs ) #key 指定查找,最大值时的规则

   1.9 min("可迭代对象",key = abs) #key 指定查找,最小时的规则

   1.10 sum("可迭代对象") list tuple set (字典是无序,所以不可以)

   1.11 reduce ("函数",可迭代对象) #函数指定的是计算方式

   1.12 format ( )

    		b ——  2
   

   ​ d —— 10

   ​ o —— 8

   ​ x —— 16

   2. 闭包

      定义: 嵌套函数内,使用非全局变量就是闭包

      干啥: 保证数据的安全性,装饰器的使用

   内置函数二

   abs

   # print(abs())   # 绝对值  返回的都是正数
   lst = [-1,2,3,-5,-90]
   print([abs(i) for i in lst])
   #[1, 2, 3, 5, 90]
   

​ enumerate

 enumerate    # 枚举("可迭代对象","序号的起始值")
#  默认的起始值是 0        得到的都是元组的形式

lst = [(0,1),(1,2),(2,3)]
print([i for i in enumerate(lst,10)])
#[(10, (0, 1)), (11, (1, 2)), (12, (2, 3))]

lst = [1,2,3,4,5]
print([i for i in enumerate(lst,1)])
#[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)]

lst = [2,3,4,5,6,7]
print([i for i in enumerate(lst,3)])
#[(3, 2), (4, 3), (5, 4), (6, 5), (7, 6), (8, 7)]

lst = [11,22,33,-44,23,21]
new_lst = []
for i in enumerate(lst):
    new_lst.append(i)
print(new_lst)
输出结果
[(0, 11), (1, 22), (2, 33), (3, -44), (4, 23), (5, 21)]

print([i for i in enumerate(lst,1000)])

输出结果
[(1000, 11), (1001, 22), (1002, 33), (1003, -44), (1004, 23), (1005, 21)]

max min sum (就他特殊一些)

print(max([1,2,3,4,5,6,6,7,7,77,8,9])) #77
print(min([2,3,4,56,7,8]))   #2
print(sum([1,23,4]))      #28
print(sum([1,2,3,4],10))   #20    后面的也是继续加上去

range

g = range(0,10)
g.__iter__()  #判断是否是可迭代对象

python 2 :
range(0,10)    #获取的是一个列表
xrange(0,10)   #获取的是一个可迭代对象

from collections import Iterable,Iterator
print(isinstance(g,Iterable))  #判断是否是可迭代对象
print(isinstance(g,Iterator))  #判断是否是迭代器

sep 多个元素连接符 是中间的连接符 end 是末尾

print(1,end = "
")
print(2)
#结果
1
2

连接起来
print(1,2,3, sep = "*")
#1*2*3

print(1,2,3, sep = "    ")
#1    2    3

print(1,2,3,sep = "	")
print(4)

#
1	2	3
4

print(dict( key = 1, a = "alex"))
#{'key': 1, 'a': 'alex'}

#print(list("alex"))    #['a', 'l', 'e', 'x']

print(dict(((1,2),(2,3),(3,4))))
{1: 2, 2: 3, 3: 4}

print(dict([i for i in enumerate(range(20),1)]))   # 这里的 1 是为了排序 是字典中的键
#{1: 0, 2: 1, 3: 2, 4: 3, 5: 4, 6: 5, 7: 6, 8: 7, 9: 8, 10: 9, 11: 10, 12: 11, 13: 12, 14: 13, 15: 14, 16: 15, 17: 16, 18: 17, 19: 18, 20: 19}   得到的是字典

zip 拉链 按照最小的进行合并

lst1 = [1,2,3,4,5]
lst2 = ["a","b","c","d","f","e"]
print(dict(list(zip(lst1,lst2))))
#{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'f'}    合并出来的是字典    面试题

lst1 = [1,2,3,4,5,6,7,8,9]
lst2 = ["a","b","d","e","f"]
print(dict(zip(lst1,lst2)))     去掉 list 也是可以的     面试题

dir 查看当前函数的方法

print(dir(list))   #

list  的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

重要的内置函数和匿名函数

def func():
    print(123)
    return "你好"
func()
#123

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

#  3       形参和实参

匿名函数

lambda

f = lambda x,y:(x,y)
print(f(1,2))
print(f.__name__)
#
(1, 2)
<lambda>

def func():
    return 1
print(func())
#  1

print((lambda x:x)(2))  #同一行定义  同一行调用

lambda

# lambda  关键字  ---- 定义函数
# x , y 形参
# x + y 返回值  ----   只能返回一个数据类型

# print((lambda x:x)(2))  #同一行定义  同一行调用

lst = [lambda i : i*i for i in range(10)]    for  后面的只是控制循环的次数,
print(lst[2](2))  #  没有后面(2) 就是一个地址,前面是函数地址
# 4

# lst = [lambda : i*i for i in range(10)]    形参可以不写,返回值必须要写,返回值只能返回一个数据类型
# print(lst[2]())            这里存起来 等到下面调用的时候就返回值

for i in range(10):   这一块是解释上面的为什么 i 是 9
    pass
print(i)

#类似于下面的代码  
lst = []
for i in range(10):
    def func():
        return i*i
    lst.append(func)
print(lst[2]())
#  9

lst1 = []
def func():
    for i in range(5):
        def foo():
            return i*i
        yield foo
func()
for x in func():
    lst1.append(x)
print(lst1[2]())       这个事什么意思呢?留着难题

内置函数

print(format(13,">20"))   #右对齐
print(format(13,"<20"))   #左对齐
print(format(13,"^20"))   # 居中
#
                  13
13                  
         13         

print(format(13,"08b"))   # 二进制
print(format(13,"08d"))   # 十进制
print(format(13,"08o"))   # 八进制
print(format(13,"08x"))   # 十六进制
#
00001101
00000013
00000015
0000000d            

fliter 过滤

lst = [1,2,3,4,5,6,7]
def func(s):
    return s > 3      #func 就是自己定义一个过滤条件 lst 要迭代的对象
print(list(filter(func,lst)))
#[4, 5, 6, 7]

print(list(filter(lambda x:x % 2 == 1,lst)))
#[1, 3, 5, 7]

map #对象映射

print(list(map(lambda x : x*x,[1,2,3,8,4,5])))
#[1, 4, 9, 64, 16, 25]

lst = [1,23,34,4,5,213,123,41,12,32,1]
print(sorted(lst))
[1, 1, 4, 5, 12, 23, 32, 34, 41, 123, 213]   #升序

dic = {"key":1,"key1":2,"key3":56}
print(sorted(dic,key = lambda x:dic[x],reverse = True))  #按照值排序
# key 是指定排序规则
['key3', 'key1', 'key']

lst = [1,2,3,4,6,7,6]
print(sorted(lst,reverse = True)) #降序     reverse = True
#[7, 6, 6, 4, 3, 2, 1]

reduce 累计算

from functools import reduce
print(reduce(lambda x,y:x-y,[1,2,3,4,5]))  #1-2 = -1   继续往后减
# -13   

闭包

def func():
    a = 1
    def f1():
        def foo():
            print(a)
        return foo
    return f1   #返回给 ret ret() 就是f1()调用
ret = func()
a = ret ()
a()
func()()()   # 在嵌套函数中,使用非全局变量
             #且不是本层变量,就是闭包

avg_lst = []
def func(price):
    avg_lst.append(price)
    avg = sum(avg_lst) / len(avg_lst)
    return avg
print(func(15000))
print(func(16000))
print(func(17000))
print(func(15000))

15000.0
15500.0
16000.0
15750.0

闭包的作用:

# 1.  保证数据的安全性

# 2.  装饰器