第四章 函數之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

   View Code

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

   View Code

    

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（有兩個參數）先對集合中的第 一、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*