闭包与装饰

def f1(a,b,c=(),*args,**kw):
    print('f1 a=',a,'b=',b,'c=',c,'args=',args,'kw=',kw)

def f2(a, b, c=(), *args,d, **kw):   #一个*元祖  俩个*字典
     *以此声明以后参数为关键字参数
     print('f2 a=', a, 'b=', b, 'c=', c, 'args=', args, 'd=',d,'kw=', kw)
t=(1,2,3,4,5)
f2(*t,d=4)
f1(*t)
kw={'a1':1,'b':2,'d':3}
f2(6,**kw)
全局变量余局部变量的作用域不同   位置决定作用域
同名时，局部变量优先
g_a=10
def text1():
    a=20
    g_a=40
    # global g_a
    # g_a=(g_a+a)
    print('text1',g_a)
text1()
print(g_a)
def add(a,b,fun):
    print(fun(a,b))
    def mtfun(a,b)
        return a+b
add(11,22,lambda arg1,arg2:arg1+arg2)



w=lambda  x:[print(i) for i in range(x)]
w=0


new_list=list(map(lambda x:x%2,range(9)))
print(type(new_list))
print(new_list)
map 会把每个数据都留下  filter 只会留下结果为true的结果
list2=[12,15,18,19,23,25]
filter1=list(filter(lambda x:x%2==1,list2))
print(type(filter1))
print(filter1)
strs=[None,'','','d','吃饭','睡觉']
def isNone(s):
    return s and len(s.strip())>0
strs1=list(filter(lambda s:s and len(s.strip())>0,strs))
print(strs1)

import math
print(math.sqrt(5)%1==0)
nums=list(filter(lambda x:math.sqrt(x)%1==0,range(1,101)))
print(nums)
li=[11,22,33,44,55]
reduce=reduce
def sqrt2(x):
    flag=False
    for i in range(1,x+1):
        if x%1!=0:
            continue
        s=x//i
        print(s)
        if s==1 and s//i==1 and i//s==1:
         flag=True
    return flag
nums=list(filter(lambda x:math.sqrt(2),range(1,101)))
print(nums)
sqrt2


a,b=3,5
a,b=b,a   #允许同时赋值
print(a,b)
冒泡排序
外侧循环n-1   内侧循环n-1-i
nums=[57,42,12,19,88,49,5,9]
for i in range(len(nums)-1):
    for j in range(len(nums)-1-i):
         if nums[j]<nums[j+1]:
             nums[j],nums[j+1]=nums[j+1],nums[j]

print(nums)



生成器迭代器
迭代器

生成一个迭代器
class Container:
    def __iter__(self,start,end):
        self.start=start
        self.end=end
    def __iter__(self):
        print('调用了__iter__(self)方法')
    def __next__(self):
        if self.start<self.end:
            i=self.start
            self.end=self.start+1
            return i
        else:
            raise StopIteration()
Cont=Container(0,10)
for i in Cont:
     print(i)



生成器
nums=(x for x in range(10))
print(nums)
print(next(nums))
print(next(nums))
print('欢迎')
print(next(nums))


fei=[]
def feibonaqi:
    for i in range(20):
        if i>2:
            fei.apaend(fei[i-1]+fei[i]
        print(fei[i])

def putong(x):
     for i in range(20):
         yield i


pt=putong(10)
pt2=putong(20)
for i in pt:
    print(i,end=' ')
print()
for i in pt2:
    print(i,end=' ')


函数：表示行为、能力
为一些代码起个名字或者为一些代码做了封装
一般oop  表现在类里 对象里
工厂模式:1.一些对象的创建行为   需要封装   2.不允许其他类随意创建此对象    3.好处:便于代码维护,分工明确
工厂类:帮助程序创建对象 可以接受不同参数
多复杂的工厂模式都是多个简单工厂


单例模式:一个实例便于资源共享
借助一个变量  中间枢纽
__init__()  初始化数据
__new__()  创建数据  构造函数
@classmethod  装饰器  将一个实例方法变为类方法
类方法:1.供所有的对象使用  2.不需要new 直接类名.
@classmethod   加载机制跟类一起加载
在什么情况下使用:1.当你发现一个方法不依赖于对象形式存在
                 2.更像一个公共的
@staticmethod  静态  优先于类
类的定义里面的类方法的第一个默认参数self表示当前对象
类属性   类名直接点  所有对象共同使用
类方法

实例属性 :  必须创建对象,以对象形式存在
实例方法:动态添加的属性或方法  不同对象不共享  类方法可以共同使用


闭包      闭包和装饰模式(装饰器)   相辅相成
def outter(fun):
    def inner():
        print('123 执行inner')
        fun()
        print('456 执行inner')

    return inner
@outter
def index():
    print('我是index......')
    ()执行   传递引用
ind=outter(index)
ind()
index()


装饰之火锅点餐
def shucaipinpan(fun):
    def caidan():
        print('蔬菜拼盘88')
        return 88+fun()
    return  caidan
def yangyou(fun):
    def caidan():
        print('新西兰羊肉,68')
        return 68+fun()
    return caidan

def xuebi(fun):
    def caidan():
        print('雪碧,5')
        return 5+fun()
    return caidan


@xuebi
@shucaipinpan
def guodi():
    print('菌汤锅,25元...')
    return 25

money=guodi()
print('总消费:',money)