def
# 函数
# 修改全局变量
a = 10 def func(): global a a = 20 print(a) #10 func() print(a) #20 ----------------- # 外部访问局部变量
def outer(): a = 10 def func(): nonlocal a a = 20 return a def func(): b = outer() return b print(func()) #10
# 1 返回函数名 def outer(): def inner(): print("我是inner") return inner ret = outer() ret() # 2 闭包 里面用到了外面的变量 def func(): a = 10 def inner(): #定义inner print(a) inner() #调用inner print(inner.__closure__) # 能打印出东西就是闭包 func()
#装饰器
def wrapper(fn): def inner(*args,**kwargs): print('进站') ret = fn(*args,**kwargs) print('出检票') return inner @wrapper def train(): print('坐火车去拉萨') @wrapper def bus(): print('座公交车去拉萨') train() bus()
lst = ["张无忌", "胡辣汤", "赵敏", "灭绝"] # for循环的本质 it = lst.__iter__() # for循环的内部是用迭代器来获取数据的 while 1: try: item = it.__next__() print(item) except StopIteration: print("结束了") break
def order(): lst = [] for i in range(10000): lst.append("衣服%s" % i) return lst ret = order() print(ret[0]) # 下面生成器 工厂生产衣服的例子 def order(): for i in range(10000): yield "衣服%s" % i gen = order() print(next(gen)) print(gen.__next__())
# 生成器send 的传值的例子 def eat(): print("韭菜盒子") a = yield "红烧肉" print(a) b = yield "吱吱冒油的大肘子" print(b) # 绿豆汤 c = yield "地三鲜" print(c) # 红豆汤 g=eat() print("外面打印:" + g.__next__()) # yield "红烧肉" print("外面打印:" + g.send("疙瘩汤")) # yield "吱吱冒油的大肘子" print("外面打印:" + g.send("绿豆汤")) # yield "地三鲜" print("外面打印:" + g.send("红豆汤")) # 报错
def add(a, b): return a + b def gen_fun(): # 0 1 2 3 for i in range(4): yield i g = gen_fun() # 0 1 2 3 n=3 g = (add(i,5) for i in g) n=5 g = (add(i,5) for i in g) # # for n in [3, 5]: # g = (add(i, n) for i in g) print(list(g)) #[10, 11, 12, 13]
#二分法 两种逻辑 lst = [1,4,7,12,37,88,156,287,444] 法一 循环遍历 缺点是全遍历 n = 45 for item in lst: if n == item: print('找到了') else: print('不存在') 法二 left = 0 right = len(lst)-1 n = 12 while left <= right: middle = (left+right)//2 if n > lst[middle]: left = middle+1 elif n < lst[middle]: right = middle-1 else: print('找到了') break else: print('找不到') 递归法 def search(lst,n,left,right): if left > right: print('不存在') return mid = (left + right)//2 if n > lst[mid] : left = mid + 1 search(lst,n,left,right) elif n < lst[mid]: right = mid - 1 search(lst, n, left, right) else: print('找到了') return search(lst,12,0,len(lst)-1)
斐波那契数列 1,1,2,3,5,8,11 def fib(n): a, b = 1,1 while a < n: print(a, end=' ') a, b = b, a+b fib(1000) #输出的是1000以内的斐波那契数列
函数：对功能或者动作的封装 定义： def 函数名(参数): 函数体 函数名(参数) 返回值: 执行完函数得到的结果。 哪里调用的就返回给哪里 在函数体中写return语句, 如果程序执行到了return。 函数其余的内容就不再执行了 1. 只写return, 默认返回None, 相当于return None 2. 写return 值, 返回一个结果 3. return 值1， 值2， 值3.。。。 返回一个元组 4. 不写return 返回None.表示没有返回值 参数: 1. 形参 函数在声明的时候， 声明的变量。 用来接收外接传递的信息 1. 位置参数 2. 默认值参数 3. 不定参数 *args 接收位置参数 **kwargs接收关键字参数 def func(*args, **kwargs): pass func(*list, **dict) *， **， 在形参， 聚合 在实参， 打散 顺序 : 位置, *args, 默认值， **kwargs 2. 实参 调用函数， 给函数传递的信息 1. 位置参数 2. 关键字参数 3. 混合参数, 位置在前， 关键字在后 函数名: 函数名的本质就是一个变量 闭包: 1. 保护变量不被侵害 2. 让一个变量常驻内存 装饰器: def wrapper(func): def inner(*args, **kwargs): '''在执行xxx函数之前''' ret = func(*args, **kwargs) '''在执行xxx函数之后''' return ret return inner @wrapper # play = wrapper(play) def play(): pass play() 迭代器 配合for循环使用 作用：让不同的数据类型拥有相同的遍历方式 通过__iter__() 获取到迭代器 可迭代对象: 可以获取到迭代器: __iter__() list， dict, tuple, set, str 迭代器： __next__(), __iter__() 一个一个向外拿数据. 拿空报错 特点： 1. 只能向前， 不能反复 2. 惰性机制 3. 节省内存 生成器 本质就是迭代器, 几乎不占用内存 1. yield 生成器函数 def func(): yield 1 1. 调用这个函数的时候。 不会执行这个函数的内容。 创建一个生成器 2. 生成器.__next__() 可以让生成器从上一个yield执行到下一个yield 3. 节省内存 4. send(值) 给上一个yield位置传值 2. 生成器表达式 列表推导式: [结果 for循环 if条件] 字典推导式: {key:value for if} 集合推导式 {key for if} 生成器表达式 (结果 for if) 直接就是生成器 惰性机制，只能向前不能反复 内置函数 lambda 匿名函数 lambda 参数: 返回值 sorted：排序 sorted(可迭代对象, key, reverse) 流程:把可迭代对象中的每一项内容传递给key函数. 根据函数返回的结果进行排序 filter(func, iter) 筛选 map(func, iter) 映射 eval 能够接收到返回值 exec 没有返回值 compile 预加载一段代码. 通过eval或者exec来执行 s = input("请输入一段代码:") # "1+3" ret = eval(s) print(ret) s = input("请输入一段代码:") # "a = 10" exec(s) print(a) print("你好啊") s = '''for i in range(10): print(i) ''' c = compile(s, "", "exec") exec(c) 递归函数: 函数自己调用自己 树形结构遍历 二分法查找效率比较高. 前提条件. 必须有序序列
format(数据, 格式) print(format("abc", "<10")) #左对齐 print(format("abc", ">10")) #右对齐 print(format("abc", "^10")) #居中 print(format(5, "08b")) #00000101 print(format(0b101, "d")) #转10进制 print(format(1.234567,'f')) #默认6位 print(format(1.234567,'.2f')) #更改 print(format(1.234567,'.2e')) #科学计数法 globals() #全局变量 locals() #局部变量 print(hash('中国')) #结果一定是数字 print(hash(123)) #数字哈希值是本身 print(str('哈哈')) print(repr("jay say he love 'his \wife'")) # repr 一个字符串官方的表示形式 print(r'jay love his \n wife') #转义字符全失效 lst = [1,2,3,4,5,6] s = slice(2,5,1) #按索引 print(lst[s]) lambda 参数:返回值 a = lambda x:x+1 #匿名函数表达式 lst = [3,24,6,7] res = sorted(lst,key=abs,reverse=True) #返回新列表,原列表不受影响 print(res) print(lst) lst1 = [2,4,5,2,1] lst1.sort() # 直接作用于原列表 print(lst1) l = ['bas','footbool','pingpong'] print(list(map(lambda x:x+'杠杠的',l))) 递归 函数自己调用自己 树形结构的遍历 比较耗资源 官方1000 Windows实测998 为什么耗内存? 因为名称空间 def func(): print('我是函数') func() func()
