一、函数的有用信息
在函数内，用''' '''引起来，添加的注释信息
可以写函数的功能，以及需要填写和可以扩展的注释词语
二、带参数的装饰器及多个装饰器装饰一个函数
def timmerout(flag1): # flag1 =flag
def timmer(f):
def inner(*args,**kwargs):
if flag1:
start_time = time.time()
ret = f(*args,**kwargs)
end_time = time.time()
print('此函数的执行效率%s' % (end_time - start_time))
return ret
else:
ret = f(*args, **kwargs)
return ret
return inner
return timmer
flag = False
@timmerout('alex','nan',1000) # 1,将@ 与函数分开@ timmerout(flag) 返回了timmer 2，将@timmer结合。
def func1():
time.sleep(0.3)
print('非常复杂......')
return 666
@timmerout(flag)
def func2():
time.sleep(0.3)
print('非常复杂......')
return 666
多个装饰器装饰一个函数
def wrapper1(func): # func = f函数名
def inner1():
print('wrapper1 ,before func') # 2
func()
# f函数名()
print('wrapper1 ,after func') # 4
return inner1
def wrapper2(func): # func = inner1
def inner2():
print('wrapper2 ,before func') # 1
func() # inner1()
print('wrapper2 ,after func') # 5
return inner2
三、迭代器
迭代器的好处
1，节省内存
2，惰性机制
3，单项执行，不可逆。也就是一次一行
迭代器内部含有__iter__切含有__next__方法的对象就是迭代器，遵循迭代器协议。
不可迭代类型
i1 = 123
#不可迭代'int' objece is not iterable
可迭代类型
str, list, tuple, dice, set, range, 文件句柄
该对象中，含有__iter__方法的就是可迭代对象，遵循可迭代协议。
第一种方法
1，判断该对象是不是可迭代对象 ‘__iter__’ in dir（对象）
print('__iter__' in dir(str))
print('__iter__' in dir(list))
2，判断该对象是不是可迭代对象 isinstance('abc',Iterable)
from collections import Iterable
print(isinstance('abc',Iterable))
print(isinstance('abc',str))
True
True
可迭代对象转换成迭代器
obj_s = s1.__iter__()
obj_s = iter(s1)
例：
s1 = 'abc'
print('__iter__' in dir(s1))
s2 = s1.__iter__()
print('__next__' in dir(s2))
True
True
判断该对象是不是可迭代器
from collections import Iterator
l1 = [1,2,3]
print(isinstance(l1,Iterator))
l1_obj = l1.__iter__()
print(isinstance(l1_obj,Iterator))
False
True
四、列表推导式（生成器表达式）
列表推导式
l1 = []
for i in range(1,23):
l1.append('python%s期' % i)
print(l1)
#遍历模式
l2 = ['python%s期' % i for i in range(1,23)]
print(l2)
l = [i for i in range(1,11)]
[变量（加工后的变量) for 变量 in iterable]
#遍历模式
#筛选模式
l1 = []
for i in range(1,31):
if i % 3 ==0:
l1.append(i)
print(l1)
l2 = [i for i in range(1,31) if i % 3 == 0]
print(l2)
[变量（加工后的变量) for 变量 in iterable if 条件] #筛选模式
五、内置函数
***
lambda
匿名函数
func1 = lambda x,y: x + y
print(func1(3,4))
7
res = map(lambda x: x**2,[1,5,7,4,8])
for i in res:
print(i)
1
25
49
16
64
作用域相关
***
globals():
返回一个字典，字典里面的内容是全局作用域的内容。
locals():
返回一个字典，当前位置的所有变量
其他相关
***
eval
exec:执行字符串类型的代码。
print(eval('1 + 2 +3'))
print(eval("{'name':'alex'}"),type(eval("{'name':'alex'}")))
print(exec('1 +2 +3'))
输入输出相关
*** print input
print(1, 2, 3, sep='****') # 分隔符
print(1111,end='') # 换行
print(222)
1****2****3
1111222
***
divmod
计算除数与被除数的结果，
返回一个包含商和玉树的元组
(a //b,a%b)
print(divmod(100,7))
# (商，余数)
(14, 2)
*** sum
对可迭代对象进行求和计算（可设置初始值）。
l1 = [i for i in range(100)]
print(sum(l1))
print(sum(l1,100))
4950
5050
***
min
返回可迭代对象的最小值（可加key，可以为函数名，
通过函数的规则，返回最小值）
l2 = [2,5,6,-7]
print(min(l2))
print(min(l2,key=abs))
-7
2
***
max
返回可迭代对象的最大值（可加key，可以为函数名，
通过函数的规则，返回最大值）
l2 = [2,5,6,-7]
print(max(l2,key=abs))
-7
***
sorted
对所有可迭代的对象进行排序操作
def func(x): return x[0]
L = [('a', 3), ('d', 4), ('b', 2), ('c', 1), ]
print(sorted(L, key=func))
[('a', 3), ('b', 2), ('c', 1), ('d', 4)]
def func(x): return x[1]
L = [('a', 3), ('d', 4), ('b', 2), ('c', 1), ]
print(sorted(L, key=func))
[('c', 1), ('b', 2), ('a', 3), ('d', 4)]
***
zip
拉链方法
l1 = [1,2,3,]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3),666,777)
for i in zip(l1, l2, l3):
print(i)
(1, 'a', '*')
(2, 'b', '**')
(3, 'c', (1, 2, 3))
***map:会根据提供的函数对指定序列做映射。返回的是迭代器
def square(x):
return x ** 2
print(map(square, [1,2,3,4,5]) )
for i in map(square, [1,2,3,4,5]):
print(i)
<map object at 0x004C0490>
1
4
9
16
25
**
all 可迭代对象中，全都是True才是True
**
any 可迭代对象中，有一个True 就是True
**
repr
返回一个对象的string形式（原形毕露）
print(repr('{"name":"alex"}'),type(repr('{"name":"alex"}')))
print('{"name":"alex"}')
print('python%s期' % '22')
print('python%r期' % '22')
'{"name":"alex"}' <class 'str'>
{"name":"alex"}
python22期
python'22'期
**
查看内置属性dir
调用相关
**
callable
函数用于检测下一个对象是否是可调用的如果返回True，object仍然可能调用失败。
但是如果返回False，调用对象object绝对不会成功
name = 'alex'
def func1():
print(111)
print(callable(name))
print(callable(func1))
False
True
**
abs
返回函数的绝对值
print(abs(-1.2))
1.2
*
进制转换
bin：将十进制转换成二进制并返回。
oct：将十进制转化成八进制字符串并返回。
hex：将十进制转化成十六进制字符串并返回。
print(bin(19))
print(oct(9))
print(hex(15))
*
round
保留浮点数的小数位数，默认保留整数。
print(round(3.43543656,4))
*
pow
求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2,3))
print(pow(2, 3, 3))
8
2
*
hash 获取一个对象（可哈希对象：int，str，Bool，tuple）
print(hash('alex'))
print(hash('alex1'))
print(hash((1,2,3)))
print(hash(10))
print(hash(99))
print(hash(True))
*
reversed：将一个序列翻转，并返回此翻转序列的迭代器。
l3 = [2, 3, 9, 8, 7, 4]
l3.reverse()
print(l3)
l_obj = reversed(l3)
print(l_obj)
for i in l_obj:
print(i)
[4, 7, 8, 9, 3, 2]
<list_reverseiterator object at 0x00540490>
2
3
9
8
7
4
*
slice
构造一个切片对象，用于列表的切片。
l3 = [2, 3, 9, 8, 7, 4]
rule = slice(0,3)
print(l3[rule])
[2, 3, 9]
* format 科学计算
print(format('test', '<30'))
#三十个空格
print(format('test', '>20'))
#二十个空格
print(format('test', '^20'))
#居中
test #三十个空格
test
#二十个空格
test
#居中