01-recode

1.函数的概念

函数是实现某一特定功能的代码段的封装

2.函数的声明/定义

def 函数名（形参列表）：
    函数体

形参：可以看成是声明在函数中的变量；作用是将函数外面的数据传递到函数内部
函数体：函数说明文档，实现函数功能的代码段，return语句

（重点！）声明函数的时候不会执行函数体

3.函数的调用

函数名（实参列表）

（重点！）函数调用过程：
回到函数声明的位置
传参（用实参给形参赋值）  - 保证每个参数都有值
执行函数体
结束后，确定返回值  - 自然死亡/遇到return
返回函数调用的位置 - 这个时候函数调用表达式的值才是之前确定返回值

4.函数的参数

位置参数和关键字参数
参数默认值
参数类型说明：1.直接给默认值 2.冒号类型
不定长参数：形参前加* - > ,形参变成元祖，形参前加**->将形参变成字典

5.函数的返回值 - 将函数内部传递到函数的外面

a.怎么确定函数的返回值
看执行函数的时候会不会遇到return，遇到return后面的值就是返回值。
没有遇到返回值就是None

b.怎么获取函数的返回值
通过获取函数调用表达式的值来获取返回值
普通数据能做的事情返回值都可以做

注意：每次调用函数，都会重新获取返回值

---

def func1(num: int):
    return [1, 2] * num


print(func1(3))
result = func1(2)
print(func1(3)[2])
print(func1(3)[:])
list1 = [func1(3), 100]
list1[0].append(100)
print(list1)

---

---

---

02-lambda

1.什么是匿名函数

匿名函数还是函数，只是声明的格式和普通函数不一样。只适用于函数功能比较简单的函数

def 函数名（形参列表）
    函数体

2.匿名函数的声明

a.语法
变量名 = lambda 形参列表：返回值
b.说明
变量名 - 相当于函数名
lambda - 声明匿名函数的关键字
形参列表 - 和普通函数的形参列表一样
： - 固定写法
返回值 - 相当于普通函数中只有一条return语句的函数体

3.匿名函数的调用

和普通函数一样

1.匿名函数的参数也可以设置默认值（不会有类型提示）

2.匿名函数不通过添加：类型名来说明参数类型

func1 = lambda x, y=0: x + y
print(func1(10, 20))


# 这个函数和匿名函数一模一样！
def func1(x, y):
    return x + y


print(func1(10, 20))

3.匿名函数可以设置不定长参数

func2 = lambda *nums: sum(nums)
print(func2(1, 2, 3, 4, 5))


func3 = lambda x : print(x)
print(func3(1314))
"""
1314 --匿名函数的结果是打印
None  -- 匿名函数把结果打印了，里面就是None
"""

03-scope

1.什么是变量的作用域

就是变量能够使用的范围

2.全局变量和局部变量

a.全局变量 - 没有声明在函数或者类中的变量都是全局变量
全局变量的作用域是从声明开始，到整个文件结束

b.局部变量 - 声明在函数或者类里面的变量就i是局部变量
局部变量的作用域是从声明开始，到函数结束


总结:当我们调用函数的时候,系统会自动在栈区间专门为这个函数开辟一块
独立的内容空间,用来保存函数中声明的变量(形参也是属于声明在函数中的变量).
当函数调用结束后,这个函数对应的栈区间会自动销毁
(函数掉用过程是一个压栈的过程)

1.全局变量1

# 变量a就是全局变量
a = 100

print(a)

for x in range(3):
    print('循环里:', a)


def func1():
    print('函数中：', a)


func1()

2.全局变量

# 这儿的y也是全局变量
for y in range(3):
    print(y)

print('外面:', y)


def func2():
    print('函数里面', y)


func2()

3.局部变量

# a.函数的形参就相当于声明在函数中的变量，所以是局部变量
# num1是局部变量
def func3(num1):
    print(num1)
    for x in range(3):
        print(num1)


func3(10)


# print(num1)   局部变量不能在函数外面使用
def func4(*nums):
    # nums = (1,89,9,887,0)
    max1 = nums[0]
    for item in nums:
        if item > max1:
            max1 = item
    print(max1)


func4(1, 89, 9, 887, 0)

4.如果全局变量和局部变量同名,那么在局部变量的作用域中使用的是局部变量

# 外部使用的是全局变量

3.global - 在函数中声明一个全局变量(只能在函数中使用)
在函数中:

global 变量名
变量名 = 值
"""
bb = 111


def func6():
    global bb
    bb = 222
    print('函数里', bb)

    global aa
    aa = 1111
    print(aa)


func6()
print(bb)
# 要想打印出aa的全局变量的值,就要调用函数
print(aa)

4.nonlocal - 想要在局部的局部中去修改局部变量的值,就使用nonlocal

对变量进行说明
nonlocal 局部变量
局部变量 = 值  (只能修改局部变量的值)


def func11():
    abc = 123
    print('func11', abc)

    # nonlocal func22()
    #

    def func22():
        nonlocal abc
        # abc = 4887
        abc = 5664
        # abc = 333
        print('func22', abc)

    func22()


func11()

#
list1 = []
for i in range(5):
    list1.append(lambda x: x * i)
"""
list1 = []
i=0 [lambda x: x * i]
i=1 [lambda x: x * i,lambda x: x * i]
i=2 [lambda x: x * i,lambda x: x * i,lambda x: x * i]
i=3 [lambda x: x * i,lambda x: x * i,lambda x: x * i,lambda x: x * i]
i=4 [lambda x: x * i,lambda x: x * i,lambda x: x * i,lambda x: x * i,lambda x: x * i]
"""
print(list1[0](3))
# 没有调用函数,不会执行函数体
# lambda x: x * i  x=3  return 3*4
print(list1[3](3))
# lambda x: x * i  x=3 return 3*4
# list1 = [lambda x: x * 2]
# print(list1[0](100))
print(list1)

---

---

---

04-functionVariable

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


函数名 -- 类型是function的变量
函数名（） -- 调用函数并且获取函数的返回值
普通变量能做的事情函数变量都能做

1.给别的变量赋值

# 声明了一个列表变量list1
list1 = [1, 2, 3]


# 声明一个函数变量func1
def func1():
    print('我是函数')
    return 10


# 使用列表变量给另外一个变量list2赋值，赋值后list2就可以当成列表来用
list2 = list1
# 赋值后list2就可以当成列表来用
print(list2[0])
print(list2[::-1])
list2.append(100)
print(list2)

# 使用函数变量给另外一个变量func2赋值
func2 = func1
# 赋值后func2就可以当成函数来使用
func2()
print(func2())

2.变量作为容器类数据的元素

a = 100
nums = [a, 1000, 10000]
print(nums)
print(nums[0] - 10)


def func3(x):
    print('abc', x)
    return 100


list2 = [func3, func3(10), 1000]
print(list2)
print(list2[0](1))

3.变量作为函数的实参

函数1作为函数2的实参 - -函数2就是一个高阶函数

a = 10


def func4(n: int):
    print(n + n - 1)


func4(a)


def func5(x):
    print(x)
    x(111)


func5(func4)
func5(lambda x: x * 2)

函数作为参数的应用：sort函数
列表.sort(key=None，reverse = False)
参数key - 要求是一个带有一个参数，并且返回值是布尔

all_students = [
    {'name': '张三', 'age': 19, 'score': 90},
    {'name': '李四', 'age': 24, 'score': 91},
    {'name': '剩菜', 'age': 20, 'score': 85},
    {'name': '憨猜猜', 'age': 16, 'score': 40}
]

# 这的item是需要排序的列表的元素
# def func2(item):
#     return item['age']
#
#
# 年龄从大到小
# all_students.sort(key=func2, reverse=True)
# 年龄从大到小排序
all_students.sort(key=lambda item: item['age'], reverse=True)

print(all_students)

tuple1 = (1, 12, 15, 14, 16, 3, 12)
new_tuple1 = sorted(tuple1)
print(new_tuple1)

tuple2 = (
    (10, 30),
    (53, 40),
    (21, 20),
    (5, 25)
)
new_tuple2 = sorted(tuple2, key=lambda item: sum(item))
print(new_tuple2)

=============排序原理(了解)=============

def yt_sorted(iterable, key=None, reverse=False):
    list1 = list(iterable)
    if key:
        for x in range(len(iterable) - 1):
            for y in range(x + 1, len(iterable)):
                item1 = list1[x]
                item2 = list1[y]
                if key(item1) > key(item2):
                    list1[x], list1[y] = list1[y], list1[x]
    else:
        # 快速排序
        for x in range(len(iterable) - 1):
            for y in range(x + 1, len(iterable)):
                if list1[y] < list1[x]:
                    list1[x], list1[y] = list1[y], list1[x]
    if not reverse:
        # 从小到大
        return list1

    else:
        # 从大到小
        return list1[::-1]

练习：按学生的平均分排序

all_students = [
    {'name': '张三', 'age': 19, 'score': {'c': 89, 'm': 98, 'e': 76}},
    {'name': '李四', 'age': 24, 'score': {'c': 98, 'm': 90, 'e': 70}},
    {'name': '剩菜', 'age': 20, 'score': {'c': 85, 'm': 88, 'e': 60}},
    {'name': '憨猜猜', 'age': 16, 'score': {'c': 90, 'm': 102, 'e': 96}}
]


def average(student):
    scores = student['score']
    sum1 = 0
    for key in scores:
        sum1 += scores[key]
    return sum1 / len(scores)


# 从小到大
all_students.sort(key=average)
print('***************************')
print(all_students)
"""
***************************
[{'name': '剩菜', 'age': 20, 'score': {'c': 85, 'm': 88, 'e': 60}}, {'name': '李四', 'age': 24, 'score': {'c': 98, 'm': 90, 'e': 70}}, {'name': '张三', 'age': 19, 'score': {'c': 89, 'm': 98, 'e': 76}}, {'name': '憨猜猜', 'age': 16, 'score': {'c': 90, 'm': 102, 'e': 96}}]
"""

"""
4.变量作为函数的返回值
函数1作为函数2的返回值 - 函数2是返回值高阶函数

"""

def operation(char):
    """
    算判断运算符是加减乘除的时候，各自的结果
    :param char: 加减乘除
    :return: 各自函数的返回值
    """
    # char = '+'
    if char == '+':
        def func1(*nums):
            return sum(nums)

        # 将函数作为返回值
        return func1
    elif char == '-':
        def func2(*nums):
            # 如果没有传参
            if not nums:
                return 0
            else:
                sum1 = nums[0]
                for index in range(1, len(nums)):
                    sum1 -= nums[index]
                return sum1

        return func2
    elif char == '*':
        def func3(*nums):
            if not nums:
                return 0
            else:
                sum1 = nums[0]
                for index in range(1, len(nums)):
                    sum1 *= nums[index]
                return sum1

        return func3
    elif char == '/':
        def func4(*nums):
            if not nums:
                return 0
            else:
                sum1 = nums[0]
                for index in range(1, len(nums)):
                    sum1 /= nums[index]
                return sum1

        return func4


print(operation('+')(40, 48, 49, 43))  # 180
print(operation('-')(5, 1, 2))  # 2
print(operation('*')(5, 1, 2))  # 10
print(operation('/')(25, 5, 2))  # 2.5