带参数的函数及多个装饰器装饰一个函数、迭代器、可迭代对象转换成迭代器、列表推导式、内置函数...-CSDN博客

一、函数的有用信息

在函数内，用''' '''引起来，添加的注释信息

可以写函数的功能，以及需要填写和可以扩展的注释词语

二、带参数的装饰器及多个装饰器装饰一个函数

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

可迭代对象转换成迭代器

obj_s = s1.__iter__()

obj_s = iter(s1)

例：

s1 = 'abc'

print('__iter__' in dir(s1))

s2 = s1.__iter__()

print('__next__' in dir(s2))

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))

res = map(lambda x: x**2,[1,5,7,4,8])

for i in res:

print(i)

作用域相关

*** 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

*** 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)

** 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))

* 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>

* 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 #居中

转载于:https://www.cnblogs.com/dunkeng/p/9154180.html