Day 13

lambda 表达式补充

filter/map/reduce(函数，列表/元组/字典/可迭代的)

foo=[2,18,9,22,17,24,8,12,27]

filter():对于序列中的元素进行筛选，最终获取符合条件的序列

print(list(filter(lambda x:x%3==0,foo)))

>>>[18,9,24,12,27]

map():函数接收两个参数，一个是函数，一个是序列，map将序列的每个元素传入函数执行，并把结果作为新的list返回。

print(list(map(lambda x:x*2+10,foo)))

>>>[14,46,28,54,58,26,34,64]

reduce():对于序列内所有元素进行累计操作。

print(list(reduce(lambda x,y:x+y,foo)))

>>>139

python中的reduce内建函数是一个二元操作函数，它用来将一个数据集合（链表，集合等）中的所有数据进行下列操作，用传给reduce中的函数func()（必须是一个二元操作函数先对集合中的第1，2个数据进行操作，得到结果在与第三数据用func()函数运算，最后得到一个结果）。

import functools,_functools

print(functools,reduce(lambda x,y:x+y,foo))

>>>139

求最大值

def max(x,y):

    if x>y:

        return x;

    elif x<y:

        return y;

    else:

        return x;

print(functools,reduce(max,foo))

>>>27

键盘录入

a=int(input('请输入第一个操作数'))

b=int(input('请输入第二个操作数'))

fun1=input('请输入执行的函数：')

fun1=eval(fun1);  #把字符串转换为函数

print(fun1(a,b));

>>>请输入第一个操作数 5

>>>请输入第二个操作数 6

>>>lambda x,y:x*y

输出结果为 30

冒泡排序

#升序

冒泡原则-->执行机制

两两相比_小靠前

外侧循环：n-1

内层循环：n-1-i

l=[12,5,3,62,555,4,25,5,25,25,2,5525,2,52]

for i in range(len(l)-1):

    for j in range(len(l)-1-i):

        if l[j]>l[j+1]:

            l[j],l[j+1]=l[j+1],l[j];

print(l);

>>>[2,2,3,4,5,12,25,25,25,25,52,62,555,5525]

#把30插入到序列中，并保持升序状态

for i in range(len(l)):

    if l[i]>30:

        l.insert(i,30);

        break;

print(l);

>>>[2,2,3,4,5,12,25,25,25,25,30,52,62,555,5525]

闭包

全局变量与局部变量

class student:

    pass

    num=10;#全局变量

    def add(self,a):

        glbal num;#局部变量

        self.num=15;

        return self.num+a

s=student();

print(s.add(5));

print(s.num);

>>>20

>>>10

闭包：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包。一个闭包就是你调用了一个函数A，这个函数A返回了一个函数B给你。这个返回的函数B就叫做闭包。你在调用函数A的时候传递的参数就是自由变量。

注：return B（）即调用函数；return B 即引用，还没有执行，引用内存地址

def A():

    def B():

        return 15;

a=A();

print(a);

输出为内存地址

print(a,__name__);

>>>B

print(a());

>>>15

#nonlocal声明变量位置是闭包。

def A():

    num=10;

    def B():

        nonlcal num;

        num=num+5;

        return num;

    return B;

a=A();

print(a);

输出为内存地址

print(a,__name__);

>>>B

print(a());

>>>15

############################

def funx(x):

    def funy(y):

        return x*y;

    return funy;

x=funx(5);

print(x);

输出结果为内存地址

print(type(x));

>>>  <class 'dunction'>

print(x.__name__);

>>> funy

ret=x(6);

print(ret);

>>> 30

ret1=x(7);

print(ret1);

>>> 35

#####################

def test(a,b,fun):

    n=fun(a,b);

    return n;

lam=input('请输入一个函数')；

t=test(10,5,eval(lam));

print(t);

>>>请输入一个函数 x,y:x+y

>>>15

一旦通过装饰器来修饰的函数，他就把他当做成一个参数传递到了装饰器的函数里

def outter(fun):

    def inner():

        print('inner()---123456');

        fun();#不写fun()即不执行print('index()-----')

    return inner;

@outter

def index():

    print('index()-----')

index();

>>>inner()---123456

>>>index()-----

学生出门上课

def waitao(fun):

    print('穿上外套');

    return fun;

def kuzi(fun):

    print('穿上裤子');

    return fun;

def xiezi(fun):

    print('穿上鞋子');

    return fun;

def benben(fun):

    print('穿上笔记本');

    return fun;

@benben

@kuzi

@xiezi

@waitao

def student():

    print('学生出门去上课');

student();

>>>穿上外套

>>>穿上鞋子

>>>穿上裤子

>>>带上笔记本

>>>学生出门去上课