内置函数二 闭包
今日总结
非常重要的一章,可是上课的我好困好困
-
匿名函数
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
-
闭包
定义: 嵌套函数内,使用非全局变量就是闭包
干啥: 保证数据的安全性,装饰器的使用
内置函数二
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 = "\n")
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 = "\t")
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. 装饰器
