函数的的高级操作2

1.变量的作用域

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

2.全局变量

a.声明在函数或者类的外部的变量都是全局变量
b.变量的作用域从声明开始到整个py文件结束，任何位置都可以使用。

a = 10 #全局变量
for x in range(10):
    y = 20
    print(x)
print(x,y)
def func1():
    print("函数中：",a)
    print("函数中：",x,y)
func1()

3.局部变量

a.声明在函数内部或者类的里面的变量都是局部变量
b.局部变量的作用域从声明开始到函数结束，任何位置都可以使用。

def func2(num1,num2):
    print(num1,num2)
    aa = 11
    print(aa)
    for xx in range(10):
        print(xx)
    print(xx)

globle只能在函数中使用，作用是用来在函数中声明一个全局变量。

语法
global 变量
变量名 = 值

a1 = 100
def func3():
    a1 = 200    
    print(a1)
func3()
print(a1)

a1 = 100
def func3():
    global a1   #使用globle对a1进行赋值,对全局变量进行改变
    a1 = 200
    print(a1)
    global b1
    b1 = 300
func3()
print(a1)
print(b1)

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

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

def func3():
    #s声明一个局部变量
    a2 = "abc"
    def func11():
        #需求：修改a2的值
        nonlocal a2
        a2 = "python"
        print("a2的值：",a2)
        #a3d的作用域在func11中
        a4 = 111
        return a4
    a3 = func11()
    print("a2的值：",a2)
    print(a3)
func3()

练习头脑：

function = []
for x in range(5):
    def func1(a):
        return a*x
    function.append(func1)
a = function
x = 4
print(a)

t1 = function[0]=func1
t2 = function[1]=func1
t3 = function[2]=func1
t4 = function[3]=func1
t5 = function[4]=func1
print(t1(2),t2(2),t3(2),t4(2),t5(2))

4.函数作为变量

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

声明类型是int类型的变量

a = 10

声明类型是dict的变量

b = {"a":1,"b":2}

声明类型是function类型的变量

c = lambda x:x*x
def d(x):
    return x*x
print(d)

声明一个列表变量

list1 = [1,2,3]

使用列表变量list1给list2赋值

list2 = list1
print(list2[0])

声明一个function函数变量func11

def func11():
    print("这是函数")
#使用函数变量func11给ff赋值
ff = func11
# 将ff当成函数来使用。
ff()    #调用函数。就相当于你的小名、

#声明一个变量2
def func2():
    print("我是函数2")
list2 = [func2,100]
print(list2[0]())

4.函数作为函数的参数

将函数最为实参，传递给函数2，这儿的函数2就是一个高阶函数（实参高阶函数）
先将func4传给func3作为func3的实参，调用funn3，将func3的形参赋值为func4，打印func4的地址，判断是否满足类型要求，此时的x（）相当于func4（）。因为是func4函数作为func3的实参，所以是x全部替换为func4。func4（）调用func4函数，打印“我是函数444”

def func3(x):
    print(x)
    if not isinstance(x,int):
        x()
def func4():
    print("我是函数444")
print(func3(func4))

sort函数特别点

sort(self, key=None, reverse=False)
key -确定排序的时候，以什么值为标准来排序，默认以列表元素的大小为标准类排序。它需要传一个函数，必须要有一个参数和一个返回值。参数是列表的元素
reverse - 是否降序排序，需要一个bool值。
sort函数封装与应用1：

def yt_sort(list1,key = None):
    if key == None:
        for index in range(len(list1)):
            for index2 in range(index+1,len(list1)):
                curren = list1[index]
                biind = list1[index2]
                if biind < curren:
                    list1[index],list1[index2] = list1[index2],list1[index]
    else:
        for index in range(len(list1)):
            for index2 in range(index+1,len(list1)):
                curren = key(list1[index])
                biind = key(list1[index2])
                if biind < curren:
                    list1[index],list1[index2] = list1[index2],list1[index]
my_list = [1,34,89,8,20]
yt_sort(my_list)
print(my_list)

def yt_sort(list1,key = None):
    if key == None:
        for index in range(len(list1)):
            for index2 in range(index+1,len(list1)):
                curren = list1[index]
                biind = list1[index2]
                if biind < curren:
                    list1[index],list1[index2] = list1[index2],list1[index]
    else:
        for index in range(len(list1)):
            for index2 in range(index+1,len(list1)):
                curren = key(list1[index])
                biind = key(list1[index2])
                if biind < curren:
                    list1[index],list1[index2] = list1[index2],list1[index]
my_list2 = [{"name":"lorry","age":23},
            {"name":"lorrybz","age":50}
            ]
def sort_age(x):
    return x["age"]
yt_sort(my_list2,sort_age)
print(my_list2)

练习按最大年龄以及按照姓名进行取值。疑问。

my_list3 = [1,34,89,8,20]
my_list2 = [{"name":"lorry","age":23},
            {"name":"lorrybz","age":50}
            ]
max_age = max(my_list2,key=lambda x:x["age"])
print(max_age)
max_name = max(my_list2,key=lambda x:x["name"])
print(max_name)

按列表中第二个元素获取最大值.疑问。

#
list5 = [("a",30),("b",30),("c",20)]
max_value = max(list5,key = lambda item:item[1])
print(max_value)

6.变量作为函数的返回值也叫高阶函数

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

根据不同的符号，返回不同的功能（函数功能的描述）

def get_operation(char):
    """
    根据不同的符号，返回不同的功能（函数功能的描述）
    :param char: 运算符符号
    :return: 不同运算符对应的功能的函数
    """
    if char == "+":
        def sum1(*args,**kwargs):
            """
            求多个数的和
            :param args: 
            :param kwargs: 
            :return: 
            """
            sum2 = 0
            for item in args:
                sum2 +=item
            for key in kwargs:
                sum2 +=kwargs[key]
            return sum2
        return sum1
    elif char == "*":
        def mul(*args,**kwargs):
            cj = 1
            for item in args:
                cj *= item
            for key in kwargs:
                cj *= kwargs[key]
            return cj
        return mul
    elif char == "-":
        def sub(*args,**kwargs):
            index = 1
            first = args[0]
            while index <= len(args)-1:
                first -= args[index]
                index += 1
            return first
        return sub
    else:
        print("不支持")
        return  None
# re = get_operation("+")    #第一种用法，这就是一个函数
# print(re(10,20,30))
re = get_operation("*")(1,2,3)   #第二种用法，调用函数获取返回值，get_operation("*")（这是一个函数）
print(re)

re = get_operation("-")
print(re)#第一种用法，这就是一个函数
print(re(10,20,30))

2迭代器

1.什么是迭代器，可以存储多个数据

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

2.迭代器中数据的来源

a.将其他序列中数据转换成迭代器
b.使用生成式、生成器取产生数据

3.将数据转换成迭代器

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

• a将字符串转换成迭代器
  iter1 = iter("abcd")
  print(iter1)
• b将列表串转换成迭代器
  iter2 = iter([1,2,3])
  print(iter2)
• c将列表串转换成迭代器
  iter3 = iter({"name":"lorry","age":23})
  print(iter3)

2.获取迭代器中元素

• a.next(迭代器) - 取出迭代器中第一个元素（取出来的元素再也放不回去了）

iter1 = iter("abcd")
print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1)) #StopIteration当迭代器是空的时候没使用next获取元素， 出现StopIteration异常

iter1 = iter("abcd")
print(iter1.__next__())
print(next(iter1))

• b.b.通过for 循环取出迭代器中元素

iter2 = iter([1,2,3])
print(iter2)
for x in iter2:
    print("===",x)

5.生成器

生成器就是迭代器，迭代器不一定生成器。
生成器就是带有yield的关键字函数的结果。
调用带有yield关键字的函数，拿到的结果就是生成器，生成器中的元素就是yield关键字后面的值。
只要函数中有yield的关键字，调用函数不会再执行函数体，而是创建一个生成器
只有在获取元素，使用next进行调取数据
当获取生成器元素的时候，才会执行函数的函数体，执行到yield语句为止，并且将yield后面的值，作为结果返回。
并且保存当前执行的位置。获取上一个元素的时候，就从上次结束的位置接着往下执行函数，知道函数结束或者遇到yield
如果函数结束了，就出现异常（stop）
生成器对应的函数，执行完成遇到yield的次数，决定了生成器能产生数据的个数。

next（func1） -》 调用func1对应的函数体将yield关键字后面的值作为结果。

#
def func1():
    print("abc")
    yield 100
    print("！！！！")
    yield 1000
re = func1()
print(next(re))
print(next(re))    #只能产生一次

def func2():
    for i in range(101):
        yield i
        print("next",i)
genger = func2()
print(next(genger))
print(next(genger))
print(next(genger))

def func4():
    i = 1
    while True:
        yield "stu"+str(i)
        i += 1
gener = func4()
# print(next(gener))
for x in range(100):
    print(next(gener))

练习 可以不断产生斐波那契数列

def func5(n):
    a = 1
    b = 1
    for i in range(n):
        c = a + b
        a,b = b,c
        yield c
gener1 = func5(100)
print(next(gener1))
print(next(gener1))
print(next(gener1))
print(next(gener1))
for x in range():
    print(next(gener1))