week5_notebooke1

大纲：

01 装饰器进阶
02 函数的有效信息
03 可迭代对象、迭代器
04 生成器 列表生成式 生成器表达式
05 内置函数
06 二分查找

01 装饰器进阶

	#多个装饰器装饰同一个函数：
	    ## 装饰顺序从近到远
	        - 先decorate2装饰func，此时decorate2中的f为func函数，返回inner2
	        - 然后decorate1装饰func，但是此时的func等于inner2，返回inner1
	        - 最后func等于inner1
	    ## 执行顺序由远到近
	        - 按照执行顺序，先执行inner1
	        - 打印inner1 before
	        - 执行inner2，打印inner2 before
	        - 执行func，打印execute
	        - 执行inner2 after
	        - 执行inner1 after
	    ## 前期可以在f()后加注释，以方便理清装饰顺序，然后按照函数嵌套的执行顺序，判断执行顺序
		- 示例一：
			def func1(f): # f = wraper2
			    def wraper1():
			        print('before wrapper1')
			        f() # f = wraper2
			        print('after wrapper1')

			    return wraper1

			def func2(f):  # f = wraper3
			    def wraper2():
			        print('before wrapper2')
			        f() # wraper3
			        print('after wrapper2')

			    return wraper2

			def func3(f): # f = index()
			    def wraper3():
			        print('before wrapper3')
			        f() # index()
			        print('after wrapper3')
			    return wraper3

			# before wrapper1
			# before wrapper2
			# before wrapper3
			# in anthony
			# after wrapper3
			# after wrapper2
			# after wrapper1

			@func1  # func1 = func1(index)
			@func2  # func2 = func2(index)
			@func3  # func3 = func3(index)
			def index():
			    print('in anthony')

			index()

	#带参数的装饰器：
		示例一：
			def timeout(flag):
			    def func1(f):
			        def wraper1(*args,**kwargs):
			            if flag:
			                f(*args,**kwargs)
			                print('in anthony')
			            else:
			                f(*args, **kwargs)
			                print('out anthony')
			        return wraper1
			    return func1

			flag =False

			@timeout(flag)

			def index():
			    print('登录中...')
			index()

02 函数的有效信息

- 函数注释：
	__doc__  #获取函数有效信息
	__name__ #得到参数名
	from functools import wraps
		wraps(f)
- 开放封闭原则：
	- 对扩展开放
	- 对修改原内容封闭

03 可迭代对象、迭代器

可迭代对象：str,list,tuple,dict,set,range,文件句柄
	- 该对象中含有__iter__方法的就是可迭代对象，遵循可迭代协议。
判断是否是可迭代对象:
	-- '__iter__' in dir(对象)
	--  from collections import Iterable
		print(isinstance('abc',Iterable))

迭代器：
	含义：内部含有__iter__且含有__next__方法的对象就是迭代器，遵循迭代器协议。

	判断是否是迭代器:
	-- from collections import Iterator
		print(isinstance('abc',Iterator))
	-- '__iter__' in dir(对象)

	好处：
		- 节省内存
		- 惰性机制
		- 单向执行，不可逆

04 生成器

- 含义：生成器本质就是迭代器，即自定义的迭代器(自定制的迭代器)
- 构成方式：
	- 以函数的方式构建
	- 生成器表达式
	凡是函数中见到yield,即生成器

	示例：
		def func1():
			print(111)
			yield 666
			print(222)
			yield 'anthony'
		g_obj = func1()	#生成器对象
		print(g_obj.__next__())

- 对应规则：__netxt__和yield必须一一对应
- 关于send和next的区别
	  send和next都是对生成器取值
	  send会给上一个yield发送一个值
	  send不能用在第一次取值
	  最后一个yield，不能得到值

05 列表生成式 生成器表达式

列表推导式格式：简单、一行搞定
	# 遍历模式：[变量(加工后的变量) for 变量 in iterable]
		示例：l = ['python%s期' % i for i in range(1,11)]
			  print(l)
	# 筛选模式：
		示例：l = [i for i in range(1,31) if i%3==0 ]
			  print(l)
列表推导式优缺点：
	缺点：
		- 特别复杂数据无法实现,只能用代码实现
		- 不能排除错误

生成器表达式：
		l_obj = ([i for i in range(1,31) if i%3==0 ])
		for i in l_obj:
			print(i)

生成器表达式和列表推导式区别：
	- 列推直观能看出，但是占内存
	- 生成器表达式不易看出，但是节省内存

06 内置函数：python自带内置函数

其他相关：(重点)
	- eval：执行字符串类型的代码，并返回最终结果
	- exec:执行字符串类型的代码。
	- 分割：print(1,2,3,sep='*')
	- end:换行
		print(111,end='')
		print(222)

	input:函数接受一个标准输入数据，返回为 string 类型。
	print:打印输出。
	- print:
		with open('练习',encoding='utf-8','w') as f1:
	 		print('wohisshui',file=f1)

	- hash:获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
		print(hash('anthony'))
		print(hash(99))
		print(hash(True))
	- id:用于获取对象内存地址
	- help：查看函数或模块详细信息
	- callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
	- dir：检查对象中的所有方法和属性
	- int：print(int())  # 默认为0
		   print(int(3.6)) # 取值为3，取整
	float：函数用于将整数和字符串转换为浮点数

数学相关：

	abs：函数返回数字的绝对值。

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

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

　　　　pow：求xy次幂。（三个参数为xy的结果对z取余）

相关内置函数：

　　　　reversed：将一个序列翻转，并返回此翻转序列的迭代器。

　　　　slice：构造一个切片对象，用于列表的切片。

       bytes：用于不同编码之间的转化。将Unicode装换位bytes
       ord:输入字符找该字符编码的位置

　　 chr:输入位置数字找出其对应的字符

　　 ascii:是ascii码中的返回该值，不是就返回/u...

repr:返回一个对象的string形式（原形毕露）。

	# %r  原封不动的写出来
	# name = 'taibai'
	# print('我叫%r'%name)

	# repr 原形毕露
	print(repr('{"name":"alex"}'))
	print('{"name":"alex"}')

sorted：对所有可迭代的对象进行排序操作。

	示例：
		def func(x):return x[1]
		L = [('a',3),('d',4),('c',1),('e',2)]
		print(sorted(L,key=func))

		L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ]
		sorted(L, key=lambda x:x[1])               # 利用key
		[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

		students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
		sorted(students, key=lambda s: s[2])            # 按年龄排序
		[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

		sorted(students, key=lambda s: s[2], reverse=True)    # 按降序
		[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

重要：

	zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
		示例：
		l1 = [1,2,3,]
		l2 = ['a','b','c',5]
		l3 = ('*','**',(1,2,3))
		for i in zip(l1,l2,l3):
		    print(i)
	map:会根据提供的函数对指定序列做映射。
		>>>def square(x) :            # 计算平方数
		...     return x ** 2
		...
		>>> map(square, [1,2,3,4,5])   # 计算列表各个元素的平方
		[1, 4, 9, 16, 25]
		>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
		[1, 4, 9, 16, 25]

07 匿名函数

# 示例：
	func1 = lambda x,y:x+y
	print(func1())

06 二分查找