day11总结（函数）

recode

1. 什么是函数，什么时候要使用函数
   对实现某一特定功能的代码的封装

2. 函数的声明
   def 函数名(参数列表):
   """函数说明文档"""
   函数体

3. 函数的调用
   1）语法：函数名(实参列表)
   2）回到函数声明的位置
   让实参给形参赋值（传参） - 保证每个参数都有值
   执行函数体
   确定返回值 - 看执行函数的时候有没有遇到return，遇到了return后面是什么返回值就是什么，没有遇到就是None
   回到函数调用的位置，接着往后面执行 - 这个时候函数调用表达式的值才是函数的返回值

4. 函数参数
   1）位置参数和关键字参数
   注意：两个同时存在的时候，位置参数要在关键字参数的前面
   2）参数默认值
   注意：没有默认值的参数要放在前面
   3）参数类型说明：给参数赋默认值、形参名：类型
   4）不定长参数
   *参数名 - 参数变成元祖；给这个参数赋值只能用位置参数
   **参数名 - 参数变成字典；给这个参数赋值只能用关键字参数

5. 返回值
   1）怎么确定函数的返回值 （见函数调用过程）
   2）怎么获取函数的返回值 （通过获取函数调用表达的值）
   3）声明函数的时候，是么时候需要函数的返回值；把谁作为函数的返回值 （看实现函数功能会不会产生新的数据）

lambda

1. 什么是匿名函数
   没有函数名的函数就是匿名函数 （匿名函数还是函数！！！！！！！）
2. 语法：
   lambda 形参列表:返回值
   说明：lambda - 关键字，固定写法
   形参列表 - 和普通函数的形参列表是一样的，变量名1，变量2，...（参数相关的语法中，除了':类型名'对参数类型进行说明外，别的语法都适用）
   ： - 固定写法
   返回值 - 相当于普通函数中return后面的语句
   注意：匿名函数能做的事情普通函数都可以做；但是多行代码的普通函数，匿名函数没法实现

lambda n1, n2=10: n1 + n2

3. 调用 （和普通函数一样）
   函数（实参列表） - 函数不一定是函数名，可以是通过任何方式获取到的类型function的值
   Python个中声明函数可以看成声明类型是function的变量；匿名函数可以看成是function类型的数据（类似100是int型的数据）
   变量名 = lambda 参数列表：返回值 -- 通过'变量名（）'来调用匿名函数

f = lambda x, y: x * y
print(f(x=10, y=20))

function

1. 函数作为变量（重点！！！）
   Python中声明函数其实就是在声明类型是function的变量，函数名就是变量名。所以普通变量能做的事情函数都能做
   声明一个函数func1，有一个参数，一个返回值；
   func1是类型为function的变量，它里面存的数据是一个函数，函数名叫func1，有一个参数n

def func1(n):
    return n * n

print(func1, type(func1), func1(10))

2. 普通变量能做的函数都能做

# 1）用一个变量给另一个变量赋值
print('===============用一个变量给另一个变量赋值========================')
list1 = [1, 2]
list2 = list1
print(list2[0])

def func2(n):
    return n * 3
a1 = func2
print(a1(100))

# 2）变量可以作为列表/元祖的元素，作为字典的值等
list1 = [1, 2]
dict1 = {'a': list1}

def func3(n):
    return n * 2

dict1 = {'a': list1, 'b': func3}

dict1['a'].append(100)
print(dict1)

print(dict1['b'](9))

# 3）变量可以作为函数的实参
# 将函数作为实参传递给另一个函数（实参高阶函数，闭包）
nums = [1, 2, 3]
print(sum(nums))

def func4(a):
    a('abc')

print(func4(print))

# 应用：sort方法的高级使用
# 列表.sort（key）  -  key需要传一个类型是function的值（函数），要求这个函数有一个参数和一个返回值
#                      参数指向的是列表中的每个元素，返回值是排序的时候的比较对象
nums = ['1', '34', '37', '2', '56']
def fn1(item):
    print('item', item, type(item))
    return int(item)


nums.sort(key = fn1)
print(nums)
nums.sort(key = lambda item: int(item))
print(nums)

students = [
    {'name': 'xx', 'age': 23, 'score': 98},
    {'name': 'yy', 'age': 18, 'score': 90}
]

def fn2(x):
    return x['score']
students.sort(key=fn2)
print(students)
students.sort(key=lambda item: item['age'], reverse=True)
print(students)


# =================自定义sort函数(模拟系统的)-了解============
def yt_sort(list1, key=None, reverse=False):
    """"""

    length = len(list1)
    if reverse:
        # 降序排列
        for x in range(0, length-1):
            for y in range(x+1, length):
                if key:
                    if key(list1[y]) > key(list1[x]):
                        list1[x], list1[y] = list1[y], list1[x]
                else:
                    if list1[y] > list1[x]:
                        list1[x], list1[y] = list1[y], list1[x]

    else:

        for x in range(0, length-1):
            for y in range(x+1, length):
                if key:
                    if key(list1[y]) < key(list1[x]):
                        list1[x], list1[y] = list1[y], list1[x]
                else:
                    if list1[y] < list1[x]:
                        list1[x], list1[y] = list1[y], list1[x]



nums = ['1', '60', '27', '9']
yt_sort(nums, key=lambda x: x[-1])
print(nums)


nums = [1, 90, 89, 9]
yt_sort(nums, reverse=True)
print(nums)
# ===============自己实现max的功能====================
def yt_max(seq, key=None):
    list1 = list(seq)
    max1 = list1[0]
    for index in range(1,len(list1)):
        item = list1[index]
        if key:
            if key(item) > key(max1):
                max1 = item
        else:
            if item > max1:
                max1 = item
    return max1


nums = ['1', '34', '37', '2', '56']
print(yt_max(nums, key=lambda item: int(item)))

# 4）变量作为函数的返回值
# Python中函数中可以再声明函数
def yt_sum(n1: int, n2: int):
    sum1 = n1+n2
    return sum1


result = (yt_sum(10, 78) + 100) *2
print(result)


def operation(char):
    # char = '+'
    if char == '+':
        # sum1函数
        def sum1(*nums):
            # nums = 1,2,4,5,6
            x = 0
            for item in nums:
                x += item
            return x
        return sum1
    elif char == '-':
        def sub(*nums):
            x = nums[0]
            for index in range(1, len(nums)):
                x -= nums[index]
            return x
        return sub

    return None


result1 = operation('+')(1, 2, 4, 5, 6)    # sum1(1,2,4,5,6)    18
result2 = operation('-')(10, 4, 1)
print(result1, result2)

# 读程序
list3 = []
for i in range(5):
    # list3.append(lambda x: x*i)
    def fn(x):
        return x*i
    list3.append(fn)

"""
list3 = []
i = 0   list3 = [lambda x: x*i]
i = 1   list3 = [lambda x: x*i, ambda x: x*i]
i = 4   list3 = [lambda x: x*i, lambda x: x*i,lambda x: x*i,lambda x: x*i,lambda x: x*i]
"""
list3[3](3)      #  12
list3[0](3)      #  12
list3[2](3)      #  12

scope

1. 作用域：变量的使用范围
2. 全局变量和局部变量
   a.全局变量：Python中除了在函数中类中声明的变量，都是全局变量。全局变量的作用域：从声明开始到文件结束的任何位置都可以使用
   b.局部变量：在函数中声明的变量就是局部变量。从声明开始到函数结束都可以使用

# ==========全局变量==========
a = 10
def fun():
    print(a)
fun()

for i in range(3):
    y = 2
    print('abc')

# ============局部变量================
aa = 100
def func2(m1):
    # 不能再函数中直接修改一个全局变量的值，而是重新声明一个新的局部变量
    aa = 200
    print(m1)
    m2 = 200
    print(m2)
    print(aa)


func2(100)
print(aa)
# 3.global和nonlocal
"""
1）global：想要在一个函数中取修改一个全局变量的值，或者想要在函数中声明一个全局变量
global 变量名
变量名 = 值

2）nonloacal：想要在局部的局部中修改一个局部变量的值
nonlocal 变量名
变量名 = 值
"""
aa = [12, 34]
def func11():
    global aa, bb
    aa = 200
    bb = 'abc'
    print(aa)


func11()
print(aa)
print(bb)


def func22():
    aaa = 123