2019-03-18

什么是匿名函数

  • 没有函数名的函数就是匿名函数 (匿名函数还是函数!!!!!!)

语法

"""
lambda 形参列表: 返回值


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


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


lambda n1, n2: n1+n2

调用 (和普通函数一样)

  • 函数(实参列表) --- 函数不一定是函数名,可以是通过任何方式获取到的类型function的值
  • python中,声明还是其实可以看成是声明类型是function的变量;匿名函数可以看成是function类型的数据(类似100是int类型的数据)
  • 变量名 = lambda 参数列表: 返回值 --- 通过'变量名()'来调用匿名函数
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))

函数作为变量(重点!!!)

  • python中声明函数其实就是在声明一个类型是function的变量,函数名就是变量名。所以普通变量能做的事情,函数都能做
  • 声明一个函数func1,有一个参数一个返回值;
  • func1是类型是function的变量,它里面存的数据是一个函数,函数名叫func1,有一个参数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))

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

  • 用一个变量给另外一个变量赋值
print('==========用一个变量给另外一个变量赋值============')
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(), 有一个参数n

"""
  • 变量可以作为列表/元祖的元素、作为字典的值等
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)
  • 变量作为函数的实参
  • 将函数作为实参传递给另外一个函数(实参高阶函数、闭包)
nums = [1, 2, 3]
print(sum(nums))


def fun4(a):
    # a = print51\

    a('abc')   # print('abc')


print(fun4(print))

应用: sort方法的高级使用

  • 列表.sort(key) - key需要传一个类型是function的值(函数),要求这个函数有一个参数和一个返回值
  • 参数指向的是列表中的每个元素,返回值是排序的时候的比较对象
nums = ['14', '40', '73', '9', '85']


def fn1(x):
    return x[0]   # 返回值决定列表中的元素按什么进行排序


nums.sort(key=fn1)
print(nums)    # ['14', '40', '73', '85', '9']
nums.sort(key=lambda item: int(item))
print(nums)   # ['9', '14', '40', '73', '85']


students = [
    {'name': 'xiaoming', 'age': 23, 'score': 90},
    {'name': 'huahu', 'age': 30, 'score': 70},
    {'name': 'zhangsan', 'age': 19, 'score': 100},
]
students.sort(key=lambda item: item['age'])
print(students)

students.sort(key=lambda item: item['score'])
print(students)

students.sort(key=lambda item: item['name'][-1])
print(students)

print(max(['10', '30', '8'], key=lambda x: int(x)))
print(max(students, key=lambda x: x['score']))

=================自定义sort函数(模拟系统的)-了解===============

"""
[20, 34, 8, 9, 70]
[70, 20, 8, 9, 34]     index = 0
[70, 34, 8, 9, 20]     index = 1
[70, 34, 20, 8, 9]      index = 2
[70, 34, 20, 9, 8]     index = 3
"""


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


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)))

max(['23', '9', '100', '8923'])

变量作为函数的返回值

  • python中函数中可以再声明函数
    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

作用域: 变量的使用范围
全局变量和局部变量:

"""
a.全局变量: python中除了在函数中或者类中声明的变量,都是全局变量。
           全局变量的作用域:从声明开始到文件结束的任何位置都可以使用
b.局部变量: 在函数中声明的变量就是局部变量。
           从声明开始到函数结束都可以使用
"""

# ============全局变量==============
# 这个变量a是全局变量
a = 10
print(a)

# 这个变量i也是全局变量
for i in range(3):
    # 变量y是全局变量
    y = 'abc'
    print(a)

print(i, y)


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


func1()


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


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

global和nonlocal

aa = [12, 34]


def func11():

    # 不能在函数中直接修改一个全局变量的值,而是重新声明一个新的局部变量
    # 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)

你可能感兴趣的:(2019-03-18)