1.幾個可能用到的內置函數

查看內置函數：
    print(dir(__builtins__))
常見函數：
    len 求長度
    min 最小值
    max 最大值
    sorted 排序，從小到大
    reversed 反向
    sum 求和
進制轉換：
    bin()  轉換為二進制
    oct()   轉換為八進制
    hex()   轉換為十六進制
    ord()   將字符轉換成對應的ASIIC碼值
    chr()   將ASIIC碼值轉換成對應的字符
補充：
    1.enumerate()   返回一個可以枚舉的對象
    2.filter()      過濾器
    3.map()         加工。對於參數iterable中的每個元素都應用fuction函數，並返回一個map對象
    4.zip()         將對象逐一配對

1.1 查看參數使用：
    >>> help(sum)
Help on built-in function sum in module builtins：
sum(iterable, start=0, /)
    Return the sum of a ‘start‘ value (default: 0) plus an iterable of numbers
    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.

  >>> sum((1,23,4))
  28
  >>> sum([1,2,3])
  6
  >>> sum([1,2,3],10)
  16
  >>> sum([10,20,30],20)  #值=iterable值+start值
  80
  >>> sum([10,20,30],22)    #值=iterable值+start值
  82
  >>> sum({1:12,2:30})      #key相加 
  3
1.2 二進制：
  >>> bin(1)
  ‘0b1‘
  >>> bin(2)
  ‘0b10‘
1.3 八進制：
  >>> oct(8)
  ‘0o10‘
  >>> oct(12)
  ‘0o14‘
1.4 十六進制：
  >>> hex(10)
  ‘0xa‘
  >>> hex(9)
  ‘0x9‘
  >>> hex(15)
  ‘0xf‘
1.5 將ASIIC碼轉換成相應的字符
  >>> chr(65)
  ‘A‘
  >>> chr(32)
  ‘ ‘
1.6 將字符轉換成ASIIC碼
  >>> ord(‘a‘)
  97
  >>> ord(‘ ‘)
  32
1.7 enumerate:
    >>> help(enumerate)
    Help on class enumerate in module builtins:

    class enumerate(object)
     |  enumerate(iterable[, start]) -> iterator for index, value of iterable
     |  
     |  Return an enumerate object.  iterable must be another object that supports
     |  iteration.  The enumerate object yields pairs containing a count (from
     |  start, which defaults to zero) and a value yielded by the iterable argument.
     |  enumerate is useful for obtaining an indexed list:
     |      (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
     |  
     |  Methods defined here:
     |  
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  
     |  __iter__(self, /)
     |      Implement iter(self).
     |  
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  
     |  __next__(self, /)
     |      Implement next(self).
     |  
     |  __reduce__(...)
     |      Return state information for pickling.
  >>> enumerate([1,2,3,4])
  <enumerate object at 0x000000000343EF78>      #返回一個叠代器
  >>> list(enumerate([1,2,3,4]))                    #查看
  [(0, 1), (1, 2), (2, 3), (3, 4)]              #返回一個帶索引的可枚舉對象，index默認0，也可指定
  >>> list(enumerate([‘a‘,‘b‘,‘c‘,‘d‘]))
  [(0, ‘a‘), (1, ‘b‘), (2, ‘c‘), (3, ‘d‘)]      #返回一個帶索引的可枚舉對象，index默認0，也可指定
  >>> list(enumerate([‘a‘,‘b‘,‘c‘,‘d‘],3))
  [(3, ‘a‘), (4, ‘b‘), (5, ‘c‘), (6, ‘d‘)]
  >>> list(enumerate((1,23,4,5,6),3))
  [(3, 1), (4, 23), (5, 4), (6, 5), (7, 6)]
  >>> list(enumerate({1,2,3,4,5},3))        #返回一個偽索引
  [(3, 1), (4, 2), (5, 3), (6, 4), (7, 5)]
  >>> list(enumerate({1:2,2:3,3:4},3))      #按可以返回
  [(3, 1), (4, 2), (5, 3)]
1.8 filter 過濾器
    >>> help(filter)
    Help on class filter in module builtins：
    class filter(object)
     |  filter(function or None, iterable) --> filter object
     |  Return an iterator yielding those items of iterable for which function(item)
     |  is true. If function is None, return the items that are true.
     |  Methods defined here:
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |  __iter__(self, /)
     |      Implement iter(self). 
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |  __next__(self, /)
     |      Implement next(self).
     |  __reduce__(...)
     |      Return state information for pickling.
     >>> filter(lambda x:x>2,[1,2,3,4,5])   #lambda x:x>2是個函數體
    <filter object at 0x0000000003420EB8>   #返回函數體
    >>> list(filter(lambda x:x>2,[1,2,3,4,5]))
    [3, 4, 5]
    >>> list(filter(None,[1,2,3,4,5]))
    [1, 2, 3, 4, 5]
1.9 map加工
  >>> help(map)
  Help on class map in module builtins:
  class map(object)
   |  map(func, *iterables) --> map object
   |  Make an iterator that computes the function using arguments from
   |  each of the iterables.  Stops when the shortest iterable is exhausted.
   |  Methods defined here:
   |  __getattribute__(self, name, /)
   |      Return getattr(self, name).
   |  __iter__(self, /)
   |      Implement iter(self).
   |  __new__(*args, **kwargs) from builtins.type
   |      Create and return a new object.  See help(type) for accurate signature. 
   |  __next__(self, /)
   |      Implement next(self).
   |  __reduce__(...)
   |      Return state information for pickling.
   >>> list(map(str,[1,2,3,4]))
    [‘1‘, ‘2‘, ‘3‘, ‘4‘]
1.10 zip 將對象逐一配對
    >>> list(zip([1,2,3],[4,5,6]))
    [(1, 4), (2, 5), (3, 6)]
    >>> list(zip((1,2,3),(4,5,6)))
    [(1, 4), (2, 5), (3, 6)]
    >>> list(zip([1,2,3],(4,5,6)))
    [(1, 4), (2, 5), (3, 6)]
    >>> list(zip([1,2,3,4],[5,6,7,8,9],[‘a‘,‘b‘]))
    [(1, 5, ‘a‘), (2, 6, ‘b‘)]
 

2.函數內變量的作用域

變量的作用域與其定義的方式有關：
    局部變量：變量在函數內部定義，則變量的作用域在函數內部
    全局變量：變量在函數的外部定義，則變量的作用域是全局

    global：用來在函數或其它局部作用域中，聲明全局變量.(作用於全局)
    nonlocal:用在函數或其它作用域中，聲明外層(非全局)變量。(作用於局部)
使用global情況：
    全局變量可以在函數內部訪問，但 不能改變
    如果在函數內部想修改全局變量，可以使用global來修飾變量

    局部變量只能在局部進行訪問和修改
    如果在函數外部，想訪問局部變量，也可以使用global，將局部變量聲明為全局變量

使用nonlocal的情況：
    當裏層局部，需要修改外層局部時，需要使用nonlocal。(如：嵌套函數)

總結：
    global： 函數中，需要修改全局變量時使用
    nonlocal：當裏層局部，需要修改外層局部時，使用。(局部調用局部，使用nonlocal)

2.1 全局、局部變量
    x=1         #全局變量，全局能被局部引用，但不能被局部修改
    def fun():
        y=2     #局部變量不能進入全局
        print(x,y)
2.2 局部修改全局變量，使用global
    x=1
    def fun():
        global x   #先聲明
        x += 1
        print(x)
2.3 全局調用局部變量，使用global
    def fun():
        global x
        x = 1
        print(x)
2.4 局部變量
    def test():
        a=1             #局部外層變量
        print(a)
        def test2():
            b=2         #局部裏層變量
            print(a,b)
        test2()         #沒有此行，只輸出test()。test2()不輸出
     >>> test()
      1
      1 2
  2.5 局部裏層修改局部外層：
    def test():
      a=1       #局部外層
      print(a)
      def test2():
          b=2       #局部裏層
          nonlocal a        #聲明為局部變量
          a += 1            #修改變量
          print(a,b)
    test2()
    >>> test()
    1
    2 2
 

3.內嵌函數和閉包

嵌套函數：
  def test():
      a=1
      print(a)
      def test2():
          b=2
          nonlocal a
          a += 1
          print(a,b)
      test2()       #嵌套函數調用內嵌函數
 閉包<兩個函數，嵌套>：
     def test():
        a=1
        print(a)
        def test2():
            b=2
            print(b)
        return test2    #返回裏層函數的函數體-閉包
    >>> test()
    1
    <function test.<locals>.test2 at 0x00000000005B7F28>
回調函數<兩個函數，不嵌套>：
    def test1():
        print(‘first‘)
    def fun(a):
        a()
        print(‘two‘)
    fun(test1)
    ================== RESTART: C:\Users\xinyu\Desktop\test.py ==================
    first
    two
 

4.遞歸

函數調用自己本身

‘‘‘
例題：有5個人坐在一起，問第五個人多少歲？他說比第4個人大2歲。
       問第4個人歲數，他說比第3個人大2歲。
       問第三個人，又說比第2人大兩歲。
       問第2個人，說比第一個人大兩歲。
       最後問第一個人，他說是10歲。
       請問第五個人多少歲？
‘‘‘
遞歸的核心：
    1.遞歸推導式
    2.遞歸終止條件
def age(n):
    if n == 1:
        return 10
    else:
        return age(n-1)+2

階乘： 5！=5*4*3*2*1
#n != n*(n-1)*(n-2)*....1
def jicheng(n):
    if n == 1:
        return 1
    else:
        return jicheng(n-1)*n

python基礎-內置函數-作用域-閉包-遞歸-python3