01-recode

1.函数的调用

过程：
回到函数声明的位置
用实参给形参赋值
执行函数体
过去返回值
回到函数调用的位置

压栈：当调用函数的时候，系统会自动在栈区间开辟空间保存函数调用过程中产生的数据（形参，函数中声明的变量）

2.返回值

看有没遇到return，遇到了函数的返回值就是return后面的值，没有返回值就是None
函数调用表达式的结果就是函数的返回值

3.函数的参数

位置参数和关键字参数：位置参数要在关键字参数的前面

参数的默认值：参数名 = 值
不定长参数：*参数名 ； **参数名
参数类型说明：参数名：类型名
def fun1（a：int） ->int： #函数返回值进行说明

4.匿名函数

函数名 = lambda 参数列表 ：返回值

02-变量的作用域

1.变量的作用域

变量在程序中能够使用的范围

2.全局变量

a.声明在函数或者类的外部的变量都是全局变量

b.全局变量是从声明开始到整个py文件结束，任何位置都可以使用（作用域：声明开始到文件结束）

3.局部变量

a.声明在函数或者类的里面的变量都是局部变量

b.局部变量是从声明开始到函数结束，任何位置都可以使用（作用域：从声明开始到函数结束）

4.global关键字只能在函数中使用，作用是在函数中声明一个全局变量

5.nonlocal关键字只能在函数中使用

但需要在局部的局部中修改局部变量的值，就是使用nonlocal
语法：nonlocal 变量名
变量名 = 值

def func1():
    a2 = 'abc'# 声明一个局部变量
    def func11():
        nonlocal a2
        a2 ='python'
        print(a2)
        a3 =111 #a3 的作用域在func11中
    func11()
    print('打印：',a2)
func1()

a1 = 100
def test1():
    global a1  #声明一个全局变量a1
    a1=200
    print(a1)
    global b1  #在函数里声明一个全局变量
    b1 =300
test1()
print(a1)
print(b1)

# 局部变量
def fun2(num1,num2):
    print(num1,num2)
    aa= 11
    print(aa)

functions = []
for x in range(5):
    def func1(a):
        return a*x
    functions.append(func1)
t1 =functions[0]
t2 = functions[2]
print(t1(2),t2(2))

03-函数作为变量

python 中，声明函数其实就是声明一个类型是function的变量。函数名就是变量名
函数作为变量除了用来调用函数获取返回值以外，普通变量能做的它都能做

# 声明类型是int的变量
a = 10
# 声明类型是dict类型的变量
b = {'a':1,'b':2}
# 声明类型是function类型的变量c
c = lambda x:x*x
print(type(c))
# 声明类型是function类型的变量d
def d(x):
    return x*x
print(type(d))

# 1.让一个变量给另一个变量赋值
list1 =[1,2,3]
list2 =list1
print(list2[0])# 使用列表list1给list2赋值

#声明一个函数变量func11
def func11():
    print('我是函数')
ff = func11
ff() #使用函数变量func11给ff赋值，将ff当成函数使用

# 2.将变量作为列表的元素或者字典的值
list1 = [1,2,3]
list2 =[list1,100]#将列表变量list1作为列表list2的元素
print(list2[0][0])

def func2(): #声明一个函数变量func2
    print("我是函数2")
list2 = [func2,100]  # 将函数变量func2作为列表list2的元素
print(list2[0]())

3.作为函数的参数

将函数1作为实参传递给函数2，这儿的函数2就是一个高阶函数（实参高阶函数）

def test(x):
    print('text：',x)
    if not isinstance(x,int):
        x()
a = 10 #声明一个int类型的变量a
test(a)# 将变量a作为test的实参

def func3():
    print('我是函数3')
test(func3)

3.1 sort()

def sort(key = None,reverse=False)

key - 确定排序的时候以什么值为标准来排序（默认情况下以列表元素大小为标准来排序）；
需要传一个函数，函数需要一个参数和一个返回值，这的参数的值是列表的元素
reverse - 是否降序排序，需要传个布尔值

# list2.sort()

def yt_sort(list1,key=None):
    if key == None:
        for index in range(len(list1)):
            for index2 in range(index+1,len(list1)):
                current = list1[index]
                behind = list1[index2]
                if behind < current:
                    list1[index],list1[index2] = list1[index2],list1[index]
    else:
        for index in range(len(list1)):
            for index2 in range(index+1,len(list1)):
                current = key(list1[index])
                behind = key(list1[index2])
                if behind < current:
                    list1[index],list1[index2] = list1[index2],list1[index]

# my_list = [1,34,20,89,8]
# yt_sort(my_list)
# print(my_list)
my_list2 = [{'name':'zc','age':18},{'name':'ls','age':30},{'name':'ww','age':10}]
# yt_sort(my_list2)#TypeError: '<' not supported between instances of 'dict' and 'dict'
def get_age(x):
    return x['age']
yt_sort(my_list2,get_age)
print(my_list2)

# 练习：要求将列表中元祖的第二个元素，获取最大值
my_list3 = [('z',10),('b',30),('c',30)]
print(max(my_list3,key= lambda item:item[1]))

4.变量作为函数的返回值

返回值势函数的函数，也叫高阶函数（返回高阶函数）

def test2(n):
    sum1 = 1
    for x in range(1,n+1):
        sum1 *= x
    return sum1
re =test2(5) + 10
print(re)

def get_operation(char):

根据不同的符号返回不同的功能（函数功能的描述）
:param char: 运算符号
:return: 不同运算符对应得功能的函数

    if char == '+':
        # 求和功能
        def sum(*args,**kwargs):
            sum1 =0
            for item1 in args:
                sum1 += item1
            for key in kwargs:
                sum1 += kwargs[key]
            return sum1
        return sum
    elif char == '*':
        def mul(*args,**kwargs):
            sum1 =1
            for item1 in args:
                sum1 *=item1
            for key in kwargs:
                sum1 *= kwargs[key]
            return sum1
        return mul
    elif char == '-':
        def jian(*args,**kwargs):
            sum1 = 0
            for index in range(len(args)):
                if index == 0:
                    num = args[index]
                else:
                    sum1 = sum1 +args[index]
            sum2 = num - sum1
            return sum2
            for key in kwargs:
                sum1 = sum1 - kwargs[key]
            return sum1
        return jian
    else:
        print('不支持')
        return  None
re = get_operation('+')#re是一个函数（相当于sum函数）
print(re(1,2,3,4,5)) #调用sum函数获取返回值

04 -迭代器

1.什么事迭代器（iter）

迭代器是python中容器类的数据类型，可以同时存储多个数据。
取迭代器中的数据只能一个一个取，而且取出来的数据，在迭代器中就不存在了

2.迭代器中的数据来源

a.将其他序列转换成迭代器

b.使用生成式、生成器产生数据

3.将数据转换成迭代器

所有序列都可以转换成迭代器

# 将字符串转换成迭代器
iter1 = iter('abcd')
print(iter1)

iter2 = iter([1,2,3,4])
print(iter2)

iter3 = iter({'a':2,'b':1})
print(iter3)

4.获取迭代器中的元素

next(迭代器)/迭代器.next() - 取出迭代器中第一个元素（已经取出来的元素再也回不到迭代器中了）

print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))
# print(next(iter1))#StopIteration（当迭代器为空时，使用next获取元素会出现StopIteration异常）

5.通过for循环取出迭代器中的每个元素

for x in iter2:
    print('==',x)

05-生成器

1.什么是生成器

生成器就是迭代器，迭代器不一定是生成器
生成器就是带有yield关键字的函数的结果
调用带有yield关键字的函数，拿到的结果就是一个生成器。生成器中的元素就是yield关键字后面的值

2.生成器怎么产生数据

只要函数只要有yield关键字，调用函数不会再执行函数体获取返回值，而是创建一个生成器
当获取生成器的元素的时候，才会执行函数的函数体，执行到yield语句为止，并且将yield后面的值作为结果返回，
并且保存当前执行的位置。获取下一个元素的时候，就从上次结束的卫视接着往下去执行函数，指导函数结束或者遇到yield为止，
如果遇到yield就将yield后面的值作为结果返回，并且保存当前执行位置，如果函数结束了，就出现stopiteration

生成器对应的函数，执行完成遇到yield的次数，决定了生成器能产生的数据的个数

def func1():
    print('abc')
    yield 123
    print('!!!!')
    yield

re = func1()

print('===',next(re))#next（re） - 执行re对应的函数体，将yield关键字后边的值作为结果
print('===',next(re))

def numbers():
    for x in range(101):
        yield x
x = numbers()

# print(next(x))
# print(next(x))

# 写一个生成器可以无限产生学号
def creat_id():
    num = 0
    while True:
        yield 'stu'+str(num)
        num += 1
gener_id = creat_id()
# print(next(gener_id))
for x in range(10):
    print(next(gener_id))

# 写一个生成器，可以不断产生斐波那契数列：1，1，2，3，5，8，13，21....
def sequence(n):
    pre_1 =0
    pre_2 = 1
    for _ in range(n):
        yield pre_2
        pre_1,pre_2=pre_2,pre_1+pre_2
gen = sequence(10)
print(next(gen))
print(next(gen))
for x in range(8):
    print('==',next(gen))