#1. #A:列表解析在一个序列的值上应用一个任意表达式,将其结果收集到一个新的列表中并返回 #B:map是一个迭代器,根据需求产生结果,同样为了节省内存,列表解析被编码成生成器表达式 def Fun(x) : return x ** 2 L0 = [1, 2, 3] L1 = [x ** 2 for x in L0] #L1 = [1, 4, 9] L2 = [Fun(x) for x in L0] #L2 = [1, 4, 9] L3 = [(x , y) for x in L0 if x % 2 == 0 for y in L1 if y % 2 == 1] #L3 = [(2, 1), (2, 9)] L4 = list(x ** 2 + 1 for x in L0) #L4 = [2, 5, 10] #2.有两种语言会尽可能的延迟结果创建 #A:生成器函数:编写为常规的def语句,但是使用yieled语句一次返回一个结果,在每个结果之间挂起和继续他们的状态 #B:生成器表达式:每次按需产生结果的一个对象 #3. #A:生成器函数和常规函数之间的主要代码不同之处在于,生成器yields(产生)一个值,而不是返回一个值,yield语句挂起该函数并向调用者发送一个值,但是保留足够的状态以使得函数能够从它离开的地方继续 #B:当继续时候,函数在上一个yield返回后立即继续执行,从函数角度来看,这允许其代码随时间产生一系列值,而不是一次计算它们并在诸如列表的内容中返回它们 #C:函数包含一条yield语句,该语句特别编译为生成器。当调用时,它们返回一个迭代器对象,支持__next__来进行自动创建。 #D:生成器函数也可能有一条return语句,总是在def语句块的末尾,直接终止值的生成 #E:生成器函数和生成器表达式自生都是迭代器,并只支持一次活跃的迭代,我们无法同时拥有位于不同位置的多个迭代器 def fun(n): for i in range(n): yield i ** 2 fun_3 = fun(3) value = fun_3.__next__ #value = <method-wrapper '__next__' of generator object at 0x0000000002B0D558> n0 = value() #n0 = 0 n1 = fun_3.__next__() #n1 = 1 n2 = fun_3.__next__() #n1 = 4 try: n2 = fun_3.__next__() except StopIteration: pass #执行至此 fun_it0 = fun(3) fun_it1 = fun(3) b0 = iter(fun_3) is fun_3 #b0 = True b1 = fun_it0 == fun_it1 #b1 = False #4. #A:从语法上讲,生成器表达式就像一般的列表解析一样,但是它们是括在圆括号中而不是方括号中,返回一个生成器对象,这个对象支持迭代 it= (x * 2 for x in 'szn') L0 = [] for v in it: L0.append(v) #L0 = ['ss', 'zz', 'nn'] #5. #A:zip L0 = list(zip("szn")) #L0 = [('s',), ('z',), ('n',)] L0 = list(zip("szn", ())) #L0 = [] def myMap0(fun, *seqs): res = [] for arg in zip(*seqs): #注意这里是*seqs而不是seqs,这里对seqs进行了解包 res.append(fun(*arg)) return res def fun(x): return x + ['szn'] L0 = myMap0(fun, [[1, 2, 3], [4, 5, 6, 7]]) #L0 = [[1, 2, 3, 'szn'], [4, 5, 6, 7, 'szn']] L0 = myMap0(fun, [[1, 2, 3], [4, 5, 6, 7], [8]]) #L0 = L0 = [[1, 2, 3, 'szn'], [4, 5, 6, 7, 'szn'], [8, 'szn']] L0 = myMap0(lambda x, y : x + y, [1, 2, 3], [4, 5, 6, 7]) #L0 = [5, 7, 9] L0 = myMap0(lambda x : x + 1, [1, 2]) #L0 = [2, 3] L0 = list(zip(*([1, 2, 3], [4, 5, 6, 7]))) #L0 = [(1, 4), (2, 5), (3, 6)] L1 = list(zip(([1, 2, 3], [4, 5, 6, 7]))) #L1 = [([1, 2, 3],), ([4, 5, 6, 7],)] def fun(v, v1):return v, v1 v = fun(*([1, 2, 3], [4, 5, 6, 7])) #v = ([1, 2, 3], [4, 5, 6, 7]) def myMap1(fun, *seqs): return [fun(*args) for args in zip(*seqs)] L0 = myMap1(lambda x, y : x + y, [1, 2, 3], [4, 5, 6, 7]) #L0 = [5, 7, 9] def myMap2(fun, *seqs): res = [] for args in zip(*seqs): yield fun(*args) L0 = list(myMap1(lambda x, y : x + y, [1, 2, 3], [4, 5, 6, 7])) #L0 = [5, 7, 9] def myMap3(fun, *seqs): return (fun(*args) for args in zip(*seqs)) L0 = list(myMap3(lambda x, y : x + y, [1, 2, 3], [4, 5, 6, 7])) #L0 = [5, 7, 9] #6. #A: L0 = [1, 2, 3] it = iter(L0) it1 = iter(it) bValue = it is it1 #bValue = True list(it) bValue = bool(it) #bValue = True L1 = [] bValue = bool(iter(L1)) #bValue = True def fun(args): it = iter(args) while 1: value = it.__next__() yield value value = list(fun([1, 2, 3])) #value = [1, 2, 3] #8. #A:!!!!!!!!!!!!!!!!!待研究 def FunA(*args): it = map(iter, args) while 1: it1 = it.__next__() #问题一:这里进行的迭代不会引发StopIterator异常吗 while 1: try: value = it1.__next__() print("") yield value except: break value0 = list(FunA([1, 2], ['a', 'b', 'c'])) #value0 = [1, 2, 'a', 'b', 'c'] 问题二:为什么这里value0 = [1, 2, 'a', 'b', 'c'] def FunB(*args): it = map(iter, args) while 1: it1 = it.__next__() while 1: value = it1.__next__() print("") yield value value1 = list(FunB([1, 2], ['a', 'b', 'c'])) #value1 = [1, 2] 问题三:为什么这里value1 = [1, 2] #9.!!!!!!!!!!!!!!!!!待研究 def myzipA(*args): iters = list(map(iter, args)) while iters: res = [next(i) for i in iters] yield tuple(res) value = list(myzipA('abc', 'efg')) #value = [('a', 'e'), ('b', 'f'), ('c', 'g')] ''' def myzipB(*args): iters = map(iter, args) while iters: res = [next(i) for i in iters] yield tuple(res) value = list(myzipB('abc', 'efg')) ''' #10. #A:time.time()返回1970年至今的秒计数 #B:time.clock()在Unix 中,将当前的处理器时间以浮点数的形式返回,单位为秒。它的精确度(准确地说是“处理器时间”的精确度)取决于同名的C函数,无论如何,这个函数是python关于时间计算的标尺。 # WINDOWS中,第一次调用,返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。(实际上是以WIN32上QueryPerformanceCounter()为基础,它比毫秒表示更为精确 #C:time.sleep()设置休眠的秒数 import time t = time.time() #t = 1491912888.716247 t0 = time.clock() time.sleep(1) t1 = time.clock() - t0 #t1 = 0.9995179215014475 #11. #A: import sys str = sys.platform #str = 'win32' #12. #A:函数陷阱 value = 10 def funA(): print(value) #运行到这里的时候会出错 value = 2 #产生上述错误的原因在于:被赋值的变量名在函数内部被当做本地变量对待,而不是仅仅在赋值以后的语句才被当做是本地变量,所以所执行的print语句中使用了未定义的本地变量名 def funB(): global value print(value) #正常运行 value = 1 #全局变量value被更改了 def funC(): import __main__ list = dir(__main__) #list = ['Fun', 'FunA', 'FunB', 'L0', 'L1', 'L2', 'L3', 'L4', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', ...] print(__main__.value) #输出的是全局变量value value = 1 #不会修改全局变量value #13 #A:模块是对象,并且所有的模块都有一个内置属性 __name__。一个模块的 __name__ 的值取决于您如何应用模块。如果 import 一个模块,那么模块__name__ 的值通常为模块文件名, # 不带路径或者文件扩展名。但是您也可以像一个标准的程序样直接运行模块,在这种情况下, __name__ 的值将是一个特别缺省"__main__" ''' Test.py内容: def FunTest20(): return __name__ ''' import Test str = Test.FunTest20() #str = 'Test' str1 = __name__ #str1 = '__main__' #14. #A:默认参数是在def语句运行时评估并保存的,而不是在函数调用时。从内部讲,python会将每个默认参数保存成一个对象,附加在这个函数本身 valueTest = 10 def FunTest(value = []): value.append(1) return value value0 = FunTest() #value0 = [1] value1 = FunTest() #value1 = [1, 1] bValue = value0 is value1 #bValue = True