一、匿名函數(shù)

1.什么是匿名函數(shù)

匿名函數(shù)還是函數(shù)，只是聲明的格式和普通函數(shù)不一樣。只適用于函數(shù)功能比較簡單的函數(shù)

2.匿名函數(shù)的聲明

a.語法

變量名 = lambda 形參列表:返回值

b.說明

變量名 - 相當于函數(shù)名
lambda - 聲明匿名函數(shù)的關鍵字
形參列表 - 和普通函數(shù)的形參列表一樣
: - 固定寫法
返回值 - 就相當于普通函數(shù)中只有一天return語句的函數(shù)體

3. 匿名函數(shù)的調用

和普通函數(shù)一樣

• 1.匿名函數(shù)的參數(shù)也可以設置默認值(不會有類型提示)
• 2.匿名函數(shù)不通過添加:類型名來說明參數(shù)類型

func1 = lambda x, y=0: x+y

print(func1(10))
print(func1(y=11,x=20))

這個函數(shù)和上面的匿名函數(shù)一模一樣！

def func1(x, y):
    return x+y


print(func1(10, 20))

• 3.匿名函數(shù)可以設置不定長參數(shù)

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


func3 = lambda x: print(x)
# x = 100   return print(100)

print(func3(100))    # None


def func3(x):
    return print(x)

二、變量的作用域

1.什么是變量的作用域

就是變量能夠使用的范圍

2.全局變量和局部變量

• a.全局變量 - 沒有聲明在函數(shù)或者類中的變量都是全局變量
  全局變量的作用域是從聲明開始，到整個文件結束
• b.局部變量 - 聲明在函數(shù)或者類中的變量就是局部變量
  局部變量的作用域是從聲明開始，到函數(shù)結束

總結：當我們調用函數(shù)的時候，系統(tǒng)會自動在棧區(qū)間專門為這個函數(shù)開辟一塊獨立的內容空間，
用來保存在函數(shù)中聲明的變量(形參也是屬于聲明在函數(shù)中的變量)。當函數(shù)調用結束后，
這個函數(shù)對應的棧區(qū)間會自動銷毀 --- (函數(shù)調用過程是一個壓棧的過程)

1.全局變量1

# 變量a是全局變量
a = 100

print('外面:', a)
for x in range(5):
    print('循環(huán)里:',a)


def func1():
    print('函數(shù)中:', a)

func1()

2.全局變量

# 這兒的y也是全局變量
for y in range(3):
    print(y)

print('外面:', y)

def func2():
    print('函數(shù)里面:', y)
func2()

3.局部變量

• a.函數(shù)的形參就相當于聲明在函數(shù)中的變量，所以是局部變量

num1是局部

def func3(num1):
    print(num1)
    for x in range(3):
        print(num1)
func3(10)

 print(num1)   # 局部變量不能在函數(shù)外面使用

函數(shù)中的nums，max1和item都是局部變量

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)
# print(item)

4.如果全局變量和局部變量同名，那么在局部變量的作用域中使用的是局部變量；外部使用的是全局變量

全局變量

aa = 100


def func5():
    # 局部變量aa
    aa = 200
    print('函數(shù)里', aa)


func5()

print('外部:', aa)

3.global - 在函數(shù)中聲明一個全局變量(只能在函數(shù)中使用)

在函數(shù)中:
global 變量名
變量名 = 值

bb = 111
def func6():
    global bb
    bb = 222
    print('函數(shù)里:',bb)

    global aaa
    aaa = 100
    print(aaa)    # 100



func6()
print(bb)
print(aaa)   # 100

4. nonlocal - 想要在局部的局部中去修改布局變量的值，就使用nonlocal對變量進行說明

nonlocal 局部變量
局部變量 = 值

def func11():
    abc = 123
    def func22():
        nonlocal abc
        abc = 333
        print('func22', abc)
    func22()

    print('func11', abc)

func11()

# func22 333
# func11 123

list1 = []
i = 0 [lambda x: xi]
i = 1 [lambda x: xi, lambda x: xi]
i = 2 [lambda x: xi, lambda x: xi, lambda x: xi]
i = 3 [lambda x: xi, lambda x: xi, lambda x: xi, lambda x: xi]
i = 4 [lambda x: xi, lambda x: xi, lambda x: xi, lambda x: xi, lambda x: x*i]

list1 = []
for i in range(5):
    list1.append(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
print(list1)

# list1 = [lambda x: x*2]
# print(list1[0](100))


def func1():
    a = [1, 2]
    print(a[10])
# func1()

a = 10
func1 = lambda x: x*a
a = 20
print(func1(2))   # 40

三、函數(shù)是一種變量

python中聲明函數(shù)其實就是聲明一個類型是function的變量, 函數(shù)名就是變量名

a = 10
str1 = 'abc'
list1 = [1, 34, 'ahjs']
dict1 = {'a': 10, 'b': 100}
func1 = lambda x: x
def func2():
    print('asbc')


print(type(dict1), id(dict1))
print(type(func1), id(func1))
print(type(func2), id(func2))
print(dict1)
print(func1, func2)

函數(shù)名 -- 類型是function的變量
函數(shù)名() -- 調用函數(shù)并且獲取函數(shù)的返回值
普通變量能做的事情函數(shù)變量都能做!
1.給別的變量賦值

# 聲明了一個列表變量list1
list1 = [1, 2, 3]


# 聲明一個函數(shù)變量func1
def func1():
    print('我是一個函數(shù)!')
    return 10

# 使用列表變量給另外一個變量list2賦值,
list2 = list1
# 賦值后list2就可以當成列表來用
print(list2[0])
print(list2[::-1])
list2.append(100)
print(list2)

# 使用函數(shù)變量給另外一個變量func2賦值
func2 = func1
# 賦值后func2就可以當成函數(shù)來使用
func2()
print(func2())

2.變量作為容器類數(shù)據(jù)的元素

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


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


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

3.變量作為函數(shù)的實參
函數(shù)1作為函數(shù)2的實參 -- 函數(shù)2就是一個高階函數(shù)

a = 10


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

func4(a)
func4(10)

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

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

• 函數(shù)作為參數(shù)的應用: sort函數(shù)

列表.sort(key=None, reverse=False)
參數(shù)key - 要求是一個帶有一個參數(shù)，并且返回值是布爾的函數(shù)。這兒的參數(shù)指向的是列表中元素。
確定按照元素的什么值進行排序

list1 = [1, 23, 9, 90]
list1.sort(reverse=True)
print(list1)

all_student = [
    {'name': '張三', 'age': 19, 'score': 90},
    {'name': 'stu1', 'age': 30, 'score': 79},
    {'name': 'xiaoming', 'age': 12, 'score': 87},
    {'name': 'stu22', 'age': 29, 'score': 99}
]


# 這兒的item是需要排序的列表的元素
# def func(item):
#     return item['score']
# all_student.sort(key=func, reverse=True)
all_student.sort(key=lambda item: item['score'])   # 按成績從小到大排序
all_student.sort(key=lambda item: item['age'], reverse=True)   # 按年齡從大到小排序
print(all_student)

tuple1 = (
    (10, 20),
    (5, 80),
    (30, 90)
)
new_tuple = sorted(tuple1, key=lambda item: sum(item))
print(new_tuple)

print('=============')

練習: 按學生的平均分排序

all_student = [
    {'name': '張三', 'age': 19, 'score': {'c': 78, 'm': 90, 'e': 40}},
    {'name': 'stu1', 'age': 30, 'score': {'c': 89, 'm': 60, 'e': 98}},
    {'name': 'xiaoming', 'age': 12, 'score': {'c': 78, 'm': 67, 'e': 86}},
    {'name': 'stu22', 'age': 29, 'score': {'c': 34, 'm': 99, 'e': 50}}
]
def average(student):
    scores = student['score']
    sum1 = 0
    for key in scores:
        sum1 += scores[key]
    return sum1/3


all_student.sort(key=average)
print('~~~~~~~~~~~')
print(all_student)

排序原理(了解)

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]


print(yt_sorted([1, 20, 9, 10]))
# print(sorted(all_student, key=lambda x: x['age']))
print(yt_sorted(all_student, key=lambda x: x['age'], reverse=True))

4.變量作為函數(shù)的返回值

函數(shù)1作為函數(shù)2的返回值 - 函數(shù)2是返回值高階函數(shù)

def operation(char):
    # char = '-'
    if char == '+':
        def func1(*nums):
            return sum(nums)
        # 將函數(shù)作為函數(shù)的返回值
        return func1
    elif char == '-':
        def func2(*nums):
            # (10, 3, 4)
            # 如果沒有傳參
            if not nums:
                return 0

            sum1 = nums[0]
            for index in range(1, len(nums)):
                sum1 -= nums[index]
            return sum1

        return func2


print(operation('+')(1, 2, 3, 4))
print(operation('-')(10, 3, 4))