函数

1.变量的作用域

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

1.全局变量

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

2.局部变量

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

3.global

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

• 语法：
  global 变量名
  变量名 = 值

4.nonlocal

当需要在局部的局部中修改局部的变量的值，就使用nonlocal

• 语法
  nonlocal 变量名
  变量名 = 值

#==================全局变量================
a=10
for x in  range(10):
    y = 20
    print(x)
print(x,y)


def func1():
    print("函数中",a,x,y)


func1()

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

# print(num1) #NameError: name 'num1' is not defined


#================global=======================
#声明一个全局变量a1
a1 = 100
def test1():
    #声明一个局部变量a1
    a1 =200
    print("函数内"，a1)  
   #声明一个全局变量a1
    global  a1
    a1=200
    print("函数内",a1)


test1()
print("函数外",a1)


#===================== nonlocal==========================
def func1():
    a2 = "abc"
    def func2():
        nonlocal a2
        a2 ="python"
        print("a2:",a2)
        #a3的作用域在func2（）中，使用func1（）不能使用
        a3 =111
    func2()
    print("func1()中：",a2)
func1()


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

---

2.函数作为变量

python中，声明函数其实就是声明一个类型是function的变量。函数名就是变量名

函数作为变量，除了可以用来调用函数获取返回值，普通变量能做的，它都能做

#声明类型是int类型的变量
a=10
#声明类型是dict类型的变量
b = {"a":12,"b":200}
#声明类型是function类型的变量
c = lambda x:x*x
#声明类型是function类型的变量d
def d(x):
    return x*x

print(type(d)) #<class 'function'>

普通变量能做的：

• 1.让一个变量给另一个变量赋值

# 声明一个列表变量list1
list1 =[1,2,3,4]
# 使用列表变量list1给list2赋值
list2 = list1
#将list2当做列表来用
print(list2[2]) #3

#声明一个类型为function的变量func11
def func11():
    print("我是函数")
#用函数变量func11给ff赋值
ff = func11
#将ff当做函数来用
ff() #我是函数

• 2.将变量作为列表的元素或者是字典的值

list1 =[1,2,3,4]
list2 =[list1,100]

# 声明函数变量func2
def func2():
    print("我是函数2")

list2 = [func2,100]
print(list2[0]()) #我是函数2
                  #None

3.作为函数的参数

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

def test(x):
    print(x)
# 声明一个int类型的变量a
a = 10
#将变量a作为实参传递给变量test
test(a)

# 声明一个function类型的变量
def func3():
    print("我是函数3")
    return "我是函数test"  
test(func3())  #func3() => "我是函数test" 

4.sort函数

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

list1 =[1,2,3,4]
list1.sort()

#取最大年龄对应的列表
print(max([["a",10],["b",200],["c",30]],key=lambda item:item[1]))

5.将变量作为函数的返回值

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

re = test2(5)+1
print(re) #121

def get_operation(char):
    """
    根据不同的符号返回不同的功能（函数功能描述）
    :param char: 运算符符号
    :return: 一个运算符对应的相应的函数
    """
    if char =="+":
        def sum(*args,**kwargs):
            """
            求多个数的和
            :param args:
            :param kwargs:
            :return:
            """
            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 items in args:
                sum1*=items
            for  key in  kwargs:
                sum1*=kwargs[key]
            return sum1
        return mul
    elif char == "-":
        def poor(*args,**kwargs):
            poor1 =args[0]
            for item in args:
                poor1-=item
            for key in kwargs:
                poor1 -= kwargs[key]
            return poor1
        return poor
    else:
        def x(*args,**kwargs):
            return "输入不规范"
        return "输入不规范"
re = get_operation("*")

print(get_operation("-")(1,6,7,a=1,b=2))

---

3.迭代器

1.什么是迭代器(iter)

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

2.迭代器中数据的来源

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

• 1.将数据转换成迭代器
  所有的序列都可以转换成迭代器
• 2.将字符串转换成迭代器

iter1 = iter('abcd')
print(iter1)

iter2 = iter([1, 10, 100, 1000])
print(iter2)

  iter3 = iter({'name': '小明', 'age': 20})
print(iter3)

3.获取迭代器中的元素

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

iter1 = iter('abcd')
print(next(iter1)) #a
print(next(iter1)) #b
print(next(iter1))#c
print(next(iter1))#d
# print(next(iter1))   # 当迭代器是空的时候，使用next获取元素，会出现StopIteration异常

iter2 = iter([1, 10, 100, 1000])
print(iter2.__next__()) #1
print(next(iter2)) #10

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

iter2 = iter([1, 10, 100, 1000])
for x in iter2:
    print('==:', x)#==: 1
                  #==: 10
                  #==: 100
                  #==: 1000
print(next(iter2))   # 出现异常StopIteration，因为for循环已经将这个迭代器中的元素取完了

---

4.生成器

生成器就是迭代器；迭代器不一定是生成器
生成器就是带有yield关键字的函数的结果

• 1.调用带有yield关键字的函数，拿到的结果就是一个生成器。生成器的元素就是yield关键字后面的值

• 2.只要有yield关键字，就不会执行函数体与获取返回值，而是创建一个生成器
  当获取生成器的元素的时候，才会执行函数的函数体，执行到yield语句位置，
  并且将yield后面的值作为结果返回；并且保存当前执行的位置;
  直到函数结束或者遇到yield为止

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

def x():
    print("函数里")
    yield 100
    print("!!!")
    yield 200


print(x())  #<generator object x at 0x00000000026BF5E8>   生成器

re = x()  #生成一个生成器
#next(x()) - 执行x（）对应的函数体，将yield关键字后面的值作为结果
print(next(re)) #100
print(next(re)) #200

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

re = numbers()
for i in range(101):
    print("迭代器：",next(re))

    #写一个生成器可以无限产生学号
def  creat_id():
    num = 1
    while True:
        yield num
        num+=1

re = creat_id()

print(next(re))


#写一个生成器，可以不断产生斐波拉契数列1,1,2,3,5,8,13...
def fb_num():
    num1 = 0
    num2 = 1
    index = 0
    while True:
        num1,num2=num2,num1+num2
        index+=1
        yield "第%d数为：%d"%(index,num1)
re = fb_num(10)

for i in re:
    print(re)

print(int(True))