1.匿名函数

'''
1.本质：还是函数，之前函数的所有的内容都适用于它。
'''
2.声明：
函数名 = lambda  参数列表：返回值

3.函数名:变量名
lambda:声明匿名函数的关键字
参数列表:参数1，参数2，'''###(可以位置参数，可以默认值参数，可以关键字参数)'''
冒号：固定写法
返回值：表达式，表达式的值就是返回值
'''
一
test = lambda a,b:a+b
print(test(11,10))

二
print((lambda x,y:x+y)(11,10))
'''
21
'''
4.调用
'''
匿名函数的调用和普通函数一样
函数名（实参列表）
'''
'''
练习
print((lambda list1,index:list1.index(index)/2)([1,2,3,4,5],2))

#二
# x = lambda list1:(sum(list1),sum(list1)/len(list1))
# y = x([1,2,3,4,5,6])
# print(y)

print((lambda list1:(sum(list1),sum(list1)/len(list1)))([1,2,3,4,5,6]))
'''
0.5
(21, 3.5)
'''

2 变量的作用域

1.函数的调用过程是一个压栈的过程。

a.每次调用一个函数，系统就会在内存区域中的栈区间取开辟空间。保存函数调用过程中产生的数据。
b.当函数调用完成后，对应的栈区间会自动销毁。

2.函数调用时产生的栈区间保存的数据有:形参,在函数中声明的变量。

调用函数时

1.png

调用函数完成后

2.png

3.作用域：就是一个变量能够使用的范围

'''
全局变量（Global）：就是---->声明在函数和类的外面的变量<-----都是全局变量。（global 可以把局部变量变成全局变量，前提是执行到这里）
作用域：从声明开始到文件结束
'''
局部变量（local）:声明在函数中和类中的变量，就是局部变量。（nonlocal:可以在局部的局部中修改局部的变量）
作用域:从声明开始到函数（类）结束。
注意：函数的参数是声明在函数中的局部变量。
'''
如果全局变量和局部变量同名，那局部变量的作用域内使用的是局部变量的值。
'''
'''
num = 1

def test():
    global num    ### 说明num是全局变量（必须执行到这一步在可以）
    num = 100
    print(num)

test()
print(num)
'''
'''
100,100
'''

练习

def func():
    a = []
    for i in range(5):
        a.append(lambda x:x*i)
    return a

a = func()
print(a[0](2),a[2](2),a[3](2))
'''

'''

补充：

L（local） 局部作用域
E（Enclosing） 闭包函数外的函数中
G（Global） 全局作用域
B（Built-in） 内建作用域

遵循LEGB原则：以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

3.递归函数

a.定义：就是在函数中的函数体中调用函数本身，这样的函数就是递归函数。

def fun1():
    print('a')
    fun1()
'''
递归函数:是个死循环（上诉代码）
'''

b.while循环能做的事情，递归都可以做（特点）。
c.如何使用递归函数

'''
第一步：找临界值（找到让循环结束的值/找到能够确定函数的值）
第二步：假设函数的功能已经实现的前提下，找关系（找f(n)和f(n-1)的关系）
第三步：根据f(n)和f(n-1)的关系，来通过f(n-1)实现f(n)的效果
'''
1.求1+2+3+4.....100
def f(n):
    if n == 1:
        return 1
    return f(n-1)+n
print(f(4))
'''
f(3)+4  f(2)+3  f(1) 2 1
'''
2.求星星
def seq(n):
    if n == 1:
        print( '*'*n)
        return
    print(n*'*')
    seq(n-1)

seq(3)

3.斐波那契数列
def sequence(n):
    if n == 1 or n == 2:
        return 1
    return sequence(n-1)+sequence(n-2)

print(sequence(5))

d.在实际开发中，递归是能不用就不要用。递归需要不断调用函数，开辟空间，消耗内存。

4.模块和包的使用

1.封装：

'''
1.函数：对实现某一特定功能的代码段的封装
2.模块：对变量，函数，类进行封装。
模块：一个py文件就是一个模块.
'''

使用：

1.import 模块 （as 重命名）
'''
通过模块.内容的形式去使用模块中的内容（能够使用的是全局变量，函数，类）
'''

2.from 模块 import 模块中的内容  
'''
从模块里面导入需要的内容（可以是多个）
'''

3.from 模块 import 模块中的内容 as 名称（自己定的名字），可以直接使用，不用加模块名。
'''
从模块里面导入需要的内容，然后把内容名称设置成自己设定的。可以直接使用自己定义的名称，不用加模块名。
from 模块 import *  即导入模块内的所有内容。
'''

4.可以导入自己写的模块，也可以导入自定义的模块

2.补充

if __name__ == '__main__':
'''
1.将不希望被别的模块导入 （执行）的代码放到模块的这个if语句中。
2.每个模块都有一个__name__属性，这个属性的值默认就是当前模块的文件名。当当前模块正在被执行（直接在当前这个模块中点了run）的时候这个__name__属性的值是'__main__'
简而言之：在本py文件中 __name__ =' __main__'
被导入后，__name__  = '自身文件名'
'''

作业

1.写一个函数将一个指定的列表中的元素逆序(例如[1, 2, 3] -> [3, 2, 1])(注意：不要使用列表自带的逆序函数)

def sort_test(list1):
    return list1[::-1]
print(sort_test([1,2,3,4,5,6]))
'''
[6, 5, 4, 3, 2, 1]
'''

2.写一个函数，提取出字符串中所有奇数位上的字符

def test_str(str1):
    print(str1[0::2],end=' ')

test_str('wowientjtjt')
'''
wwettt 
'''

3.写一个匿名函数，判断指定的年是否是闰年

leap = lambda x:not x % 4
def test(x):
    if leap(x):
        print(x,'是闰年',sep='')
    else:
        print(x,'不是闰年',sep='')

test(2000)
'''
2000是闰年
'''

4.使用递归打印：

n = 3的时候
@
@@
@@@

n = 4的时候:
@
@@
@@@
@@@@

list2 = []
def print_dg (n):
    if n == 1:
        return list2.append(1)
    list2.append(n)
    print_dg(n-1)

print_dg(5)
for x in list2[-1::-1]:
    print('@'*x)
'''
@
@@
@@@
@@@@
@@@@@
'''

5.写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def len_test(list1):
    if len(list1) > 2:
        return list1[0:2]
print(len_test([1,2,3,4,5,6]))
'''
[1, 2]
'''

6.写函数，利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。（自己背着写）

def fblq(n):
    if n == 1 or n == 2:
        return 1
    return fblq(n-1)+fblq(n-2)
print(fblq(10))
'''
55
'''

7.写一个函数，获取列表中的成绩的平均值，和最高分

def max_average(list1:list):
    list1.sort()
    sum = 0
    for x in list1:
        sum += x
    return list1[-1],sum/len(list1)

value = max_average([1,23,4,56,6,7,8,6,54,4])
print('最大值%d,平均值%d' % (value[0],value[1]))
'''
最大值56,平均值1
'''

8.写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def check_sequence(list1):
    odd_list = list1[1::2]
    return odd_list

print(check_sequence([1,2,3,4,5,6,7,8,6]))
'''
[2, 4, 6, 8]
'''

9.写一个属于自己的数学模块(封装自己认为以后常用的数学相关的函数和变量)和列表模块（封装自己认为以后常用的列表相关的操作）

pi = 3.14

def summation(n:int,y:int):
    '''
    求n ~ y之间的和(或者y~n之间的和)(包括n,y，其中n，y为整数)
    :param n:输入的第一个数
    :param y:输入的第二个数
    :return:在n ~y(或y ~ n) 之间的数的和
    '''
    sum = 0
    if n > y:
        for x in range(y,n+1):
            sum += x
    else:
        for x in range(n,y+1):
            sum += x
    return sum
def sum_list(list1:list):
    '''
    求一个列表里，奇数索引的值，并产生一个新的列表
    :param list1: 传入一个列表
    :param a:存储新的列表
    :return: 奇数索引的值
    '''
    a = []
    for x in range(0,len(list1),2):
        a.append(x)
    return a