1.2 語法

lambda 形參列表: 返回值
說明:

• lambda - 關(guān)鍵字，固定寫法
• 形參列表 - 和普通函數(shù)的形參列表一樣的。變量名1,變量名2..
  (參數(shù)相關(guān)的語法中，除了':類型名'對(duì)參數(shù)類型進(jìn)行說明以外，別的語法都適用)
• : - 固定寫法
• 返回值 - 相當(dāng)于普通函數(shù)中return后面的語句

注意: 匿名函數(shù)能做的事情普通函數(shù)都可以做；但是多行代碼的普通函數(shù)，匿名函數(shù)沒法實(shí)現(xiàn)

def yt_sum(n1: int, n2):
    if n1 < 10:
        print('n1')
    return n1+n2


lambda n1, n2: n1+n2

1.3 調(diào)用 （和普通函數(shù)一樣）

• 函數(shù)(實(shí)參列表) --- 函數(shù)不一定是函數(shù)名，可以是通過任何方式獲取到的類型function的值
• python中，聲明函數(shù)其實(shí)可以看成是聲明類型是function的變量；匿名函數(shù)可以看成是function類型的數(shù)據(jù)（類似100是int類型的數(shù)據(jù)）
• 變量名 = lambda 參數(shù)列表: 返回值 --- 通過'變量名()'來調(diào)用匿名函數(shù)

a = 100
b = 12.5
c = 'abc'      # 類型是str的值
d = [10, 23, 90, 'abc']     # 類型是list的值
e = {'a': 100, 'b': 200}   # 類型是dict的值
print(type(e))
print(e['a'])

f = lambda x, y: x*y     # 類型是function的值   return x*y
print(type(f))
print(f(10, 20))
print(f(y=30, x=2))

list1 = [100, b, c, d, e, lambda x, y:x+y]
print(list1[0]+200)
print(list1[-1](10, 22))

2. 高級(jí)函數(shù)

2.1 函數(shù)作為變量（重點(diǎn)?。。。?/h2>

• python中聲明函數(shù)其實(shí)就是在聲明一個(gè)類型是function的變量，函數(shù)名就是變量名。所以普通變量能做的事情，函數(shù)都能做
• 聲明一個(gè)函數(shù)func1,有一個(gè)參數(shù)一個(gè)返回值；
• func1是類型是function的變量，它里面存的數(shù)據(jù)是一個(gè)函數(shù)，函數(shù)名叫func1,有一個(gè)參數(shù)n

a = 100

# func1 = lambda n:n*n
def func1(n):
    return n*n

print(a, type(a), a//2)
print(func1, type(func1), func1(10))

2.2 普通變量能做的函數(shù)都能做

2.2.1. 用一個(gè)變量給另外一個(gè)變量賦值

print('==========用一個(gè)變量給另外一個(gè)變量賦值============')
list1 = [1, 2]
list2 = list1
print(list2[0])


def fun2(n):
    # n = 22
    return n*3   # return 22*3


a1 = fun2
print(a1(22))
"""
fun2 = function(), 有一個(gè)參數(shù)n

"""

2.2.2 變量可以作為列表/元祖的元素、作為字典的值等

list1 = [1, 2]
dict1 = {'a': list1}


def fun3(n):
    return n*2


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

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

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

2.2.3 變量作為函數(shù)的實(shí)參

將函數(shù)作為實(shí)參傳遞給另外一個(gè)函數(shù)（實(shí)參高階函數(shù)、閉包）

nums = [1, 2, 3]
print(sum(nums))


def fun4(a):
    # a = print
    a('abc')   # print('abc')


print(fun4(print))

2.3 應(yīng)用: sort方法的高級(jí)使用

列表.sort(key) - key需要傳一個(gè)類型是function的值(函數(shù))，要求這個(gè)函數(shù)有一個(gè)參數(shù)和一個(gè)返回值，參數(shù)指向的是列表中的每個(gè)元素，返回值是排序的時(shí)候的比較對(duì)象

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(['23', '9', '100', '8923'])
# yt_max(['23', '9', '100', '8923'])
# yt_max(['23', '9', '100', '8923'], key=lambda x: int(x))

2.4 嘗試: 實(shí)現(xiàn)自己的max函數(shù)

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


print(yt_max({'1': 78, '9': 20, 'a': 100}))
print(max({'1': 78, '9': 20, 'a': 100}))

print(max(['23', '9', '100', '8923'], key=lambda x: int(x)))
print(yt_max(['23', '9', '100', '8923'], key=lambda x: int(x)))

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

python中函數(shù)中可以再聲明函數(shù)

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函數(shù)
        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

3. 變量作用域

1.作用域： 變量的使用范圍

2.全局變量和局部變量

• 全局變量: python中除了在函數(shù)中或者類中聲明的變量，都是全局變量。
  全局變量的作用域:從聲明開始到文件結(jié)束的任何位置都可以使用
• 局部變量: 在函數(shù)中聲明的變量就是局部變量。
  從聲明開始到函數(shù)結(jié)束都可以使用

3. 2.1 全局變量

#這個(gè)變量a是全局變量
a = 10
print(a)

#這個(gè)變量i也是全局變量
for i in range(3):
    # 變量y是全局變量
    y = 'abc'
    print(a)

print(i, y)


def func1():
    print(a, i, y)


func1()

3.2.2 局部變量

def func2(m1):
    # 形參m1是局部變量
    print(m1)
    m2 = 200
    print(m2)


func2(100)
# print(m1)
# print(m2)

3.3 global和nonlocal

• global: 想要在一個(gè)函數(shù)中去修改一個(gè)全局變量的值，或者想要在函數(shù)中聲明一個(gè)全局變量
  global 變量名
  變量名 = 值

• nonlocal: 想要在局部的局部中修改一個(gè)局部變量的值
  nonlocal 變量名
  變量名 = 值

aa = [12, 34]


def func11():

    # 不能在函數(shù)中直接修改一個(gè)全局變量的值，而是重新聲明一個(gè)新的局部變量
    # aa = [100, 200]
    global aa, bb
    aa = 200

    # global bb
    bb = 'abc'
    print(aa, bb)


func11()
print(aa)
print(bb)

def fun22():
    aaa = 123

    def fun222():
        nonlocal aaa
        aaa = 1000
        print('==:', aaa)

    fun222()
    print(aaa)


fun22()
# print(aaa)