第四章 函数之lambda 表达式和内置函数

4.5 lambda 表达式

1. 用于表示简单的函数。

   # 三元运算，为了解决简单的if else的情况，如：
   if 1 == 1:
       a = 123
   else:
       a = 456
   # 相当于
   a = 123 if 1==1 else 456
   print(a)

   # lambda表达式，为了解决简单函数的情况，如：
   def funa(a1,a2):
       return a1 + 100
   print(funa(1,3))    # 101
   # 相当于
   func = lambda a1,a2: a1+100
   print(func(1,3))    # 101

   # 示例一
   

   func1 = lambda : 100
   print(func1())   #100
   func2 = lambda x1: x1 * 10
   print(func2(2))     # 20
   ​
   func3 = lambda *args,**kwargs: len(args) + len(kwargs)
   print(func3("a","b","c",k="sdfgg"，a = "dfgjh"))     # 5
   ​
   # 示例二
   DATA = 100
   func4 = lambda a1: a1 + DATA
   v = func4(1)
   print(v)    # 101
   ​
   # 示例三
   DATA = 100
   def func():
       DATA = 1000
       func4 = lambda a1: a1 + DATA
       v = func4(1)
       print(v)    # 1001
   func()
   ​
   # 示例四
   func5 = lambda n1,n2: n1 if n1 > n2 else n2
   v = func5(1111,2)
   print(v)    # 1111
   # 练习题1
   USER_LIST = []
   def func0(x):
       v = USER_LIST.append(x)
       return v
   ​
   result = func0('alex')
   print(result)   # None
   print(USER_LIST)    # ['alex']
   ​
   # 练习题二
   def func0(x):
       v = x.strip()
       return v 
   ​
   result = func0(' alex ')
   print(result)   # alex
   ​
   # 练习题三
   func_list = [lambda x:x.strip(), lambda y:y+199,lambda x,y:x+y]
   ​
   v1 = func_list[0]('alex ')
   print(v1)   #alex
   ​
   v2 = func_list[1](100)
   print(v2)   # 299
   ​
   v3 = func_list[2](1,2)
   print(v3)   # 3

4.6 内置函数

1. 强制转换

   • dict() list() tuple() int() str() bool() set()

2. 输入和输出

   • input print

3. 其他函数

   • len(长度) open(打开) id(查看内存) range(输出列表) type(查看类型)

4. 数学相关

   • abs(绝对值) float(转成浮点型：小数) max(找到最大值) min(找到最小值) sum(求和) divmod(求两数相除商和余数，多用于分页)

   v = abs(-1)
   print(v)    # 1
   ​
   v = 55
   v1 = float(55)
   print(v1)   # 55.0
   ​
   v = [1,2,311,21,3,]
   result = max(v)
   print(result)   # 311
   ​
   v = [1,2,311,21,3,]
   result = min(v)
   print(result)   # 1
   ​
   v = [1,2,311,21,3,]
   result = sum(v)
   print(result)   #338
   ​
   a,b = divmod(1001,5)
   print(a,b)  # 200  1

    

5. 进制转换

   • bin，将十进制转化成二进制(0b)

     num = 13
     v1 = bin(num)
     print(v1)   # 0b1101

   • oct，将十进制转换成八进制(0o)

     num = 8
     v1 = oct(num)
     print(v1)   # 0o10

   • int，将其他进制转化成十进制

     # 二进制转化成十进制
     v1 = '0b1101'
     result = int(v1,base=2)
     print(result)   #13
     ​
     # 八进制转化成十进制
     v1 = '0o1101'
     result = int(v1,base=8)
     print(result)   # 577
     ​
     # 十六进制转化成十进制
     v1 = '0x1101'
     result = int(v1,base=16)
     print(result)   # 4353

   • hex，将十进制转换成十六进制(0x)

     num = 16
     v1 = hex(num)
     print(v1)   # 0x10

6. 编码相关

   • chr，将十进制数字转换成unicode编码中的对应字符。

     v = chr(99)
     print(v)    # c

   • ord，将字符转换成unicode编码中的对应数字

     num = ord('中')

7. 高级函数

   • map，会根据提供的函数对指定序列做映射

     • 第一个参数必须是一个函数

     • 第二个函数必须是可迭代类型（可以for循环）

     • py2最后返回一个列表；py3最后返回一个对象（节省内存）

     循环每个元素（第二个参数），然后让每个元素执行函数（第一个）参数，将每个函数 执行的结果保存到新的列表中，并返回。

     v1 = [11,22,33,44]
     result = map(lambda x :x+100,v1)
     print(list(result))#[111, 122, 133, 144]

   • filter，函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

     循环每个元素（第二个参数），然后让每个元素执行函数（第一个）参数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

     # 示例一
     v1 = [11,22,33,'fgd','egfghg',44,'sdf']
     def func(x):
         if type(x) == int:#判断v1元素是不是整型
             return True#返回
         return Flase
     result = filter(func,v1)#循环v1执行函数func,真的新建列表[11,]
     print(list(result))#输出result，默认是对象，转化为列表
     ​
     # 等于
     result = filter(lambda x: True if type(x) == int else False ,v1)
     print(list(result))
     ​
     # 等于
     result = filter(lambda x: type(x) == int ,v1)
     print(list(result))

   • reduce，函数会对参数序列中元素进行累积。

     函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

     # 示例
     import functools
     v1 = ['wo','hao','e']
     ​
     def func(x,y):
         return x+y
     result = functools.reduce(func,v1)
     print(result)#wohaoe
     ​
     # 等于
     result = functools.reduce(lambda x,y:x+y,v1)
     print(result)

8. type，查看类型/判断对象是否是类的实例（找到头）

   class Foo:
       pass
   ​
   obj = Foo()
   ​
   if type(obj) = Foo:
       print("obj是Foo类的对象")

9. issubclass 判断类是否是子类（到头都是）

   class Asd():
       pass
   ​
   class Base(Asd):
       pass
   ​
   class Base1(Base):
       pass
   ​
   class Foo(Base1):
       pass
   ​
   class Bar:
       pass
   ​
   print(issubclass(Bar,Base)) # False
   print(issubclass(Foo,Asd))  # True

10. isinstance 判断obj是否是Foo类或其基类的实例（对象），找到头都是

    class Asd:
        pass
    ​
    class Base(Asd):
        pass
    ​
    class Foo(Base):
        pass
    ​
    obj = Foo()
    ​
    print(isinstance(obj,Foo))
    print(isinstance(obj,Asd))

     

11. super 根据self对象所属类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

    class Bar(object):
        def func(self):
            print('bar.func')
            return 123
    ​
    class Base(Bar):
        pass
    ​
    class Foo(Base):
        def func(self):
            v1 = super().func()
            print('foo.func',v1)
    ​
    obj = Foo() # bar.func
    obj.func()  # foo.func 123
    # super().func() 根据类的继承关系，按照顺序挨个找func方法并执行(找到第一个就不在找了)

    class Base(object): # Base -> object
        def func(self):
            super().func()
            print('base.func')
    ​
    class Bar(object):
        def func(self):
            print('bar.func')
    ​
    class Foo(Base,Bar): # Foo -> Base -> Bar
        pass
    ​
    obj = Foo()
    obj.func()  # bar.func  base.func

     

12. 总结

    • 函数当作是一个变量：参数传值 / 当元素嵌套到字典列表中。 5*

    • lambda 表达式 3*

    • 内置函数 3*