函式使用

零碎知識

• 靈活的if-else

  a = 3 if False else 5
  
  # 上下兩種寫法等價
  
  # if False:
  #     a = 3
  # else:
  #     a = 5
  
  print(a)
  

• 靈活的and/or

  # 前面的表示式為真，才會執行後面的表示式
  a = True and 3
  print(a)
  
  # 前面的表示式為假，後面的表示式根本無需執行
  b = False and 5
  print(b)
  
  # 前面的表示式值真，後面的表示式無需執行
  c = True or 3
  print(c)
  
  # 前面的表示式為假，需要後面表示式的判斷
   
  
  d = False or 5
  print(d)
  

• 型別判斷

  a = 250
  # print(type(a))
  # if type(a) == int:
  if type(a) == type(1):
      print('a', '是一個整數')
  
  # 判斷一個物件是不是某種型別的一個例項
  print(isinstance(a, int))
  print(isinstance(a, str))
  
  def test():
      pass
  
  # print(type(test))
  # 用能使用這種方式進行函式型別的判斷
  # print(isinstance(test, function))
   
  
  
  from inspect import isfunction
  # 判斷一個識別符號是否是函式
  print(isfunction(test))
  print(isfunction(a))
  

• 變數地址

  # 獲取變數地址
  print(id(a))
  
  b = 10
  print(id(b))
  
  # a和b地址相同
  
  lt = [1, 2, 3]
  print(id(lt))
  
  lt2 = [1, 2, 3]
  print(id(lt2))
  
  # lt和lt2地址不同
  

生成器

• 使用場景：

  在使用列表時，很多時候我們不會一下子使用資料，通常都是一個一個使用；當資料量較大的時候，定義一個列表會是程式記憶體佔用突然增大，為了解決此類問題，python中引入了生成器。

• 生成方式：

  • 方式1：將列表生成式的[]改為()即可

  # 列表生成式
  # lt = [i for i in range(10)]
  # print(lt)
  
  lt = (i for i in range(3))
  print(lt)
  
  # 可以轉換為列表
  # print(list(lt))
  
  # 可以進行遍歷
  # for i in lt:
  #     print(i)
  
  # 可以一個一個提取，當提取結束後再次提取會報StopIteration錯
  print(next(lt))
  print(next(lt))
  print(next(lt))
  print(next(lt))
  

  • 方式2：在函式中使用yield關鍵字

  '''
  # 當資料量特別大的時候，佔用記憶體會突然增大
  def test(n):
      lt = []
      for i in range(1, n+1):
          lt.append(i)
      return lt
  
  print(test(10))
  '''
  
  def test(n):
      for i in range(1, n+1):
        	# 執行到此處，函式會返回yield後的內容，然後會停止在這裡
        	yield i
          
  t = test(3)
  # print(t)
  
  # 可以一個一個提取
  # print(next(t))
  # print(next(t))
  # print(next(t))
  
  # 可以遍歷
  # for i in t:
  #	print(i)
  
  # 可以轉換為列表
  print(list(t))
  

• 使用說明：

  • 生成器物件儲存的是特定資料的生成演算法，而不是特定的所有資料
  • 使用任意一種方式操作，都是單次的
  • 生成器可以做的操作：遍歷、next、轉換為列表

迭代器

• 定義：能夠使用for-in進行遍歷，並且可以使用next函式進行迭代的物件

• 說明：

  • 生成器就是一種特殊的迭代器
  • 判斷一個物件是否是迭代器

  from collections import Iterator
  # 判斷是否是迭代器
  print(isinstance(lt, Iterator)) 
  

  • 字串及容器型別的物件都不是迭代器，他們都是可迭代物件

可迭代物件

• 定義：可以使用for-in遍歷的物件，都是可迭代物件

• 說明：

  • 前面學習過的字串及容器型別的物件都是可迭代物件
  • 迭代器一定是可迭代物件
  • 判斷一個物件是否是可迭代物件

  from collections import Iterable, Iterator
  
  lt = [1, 2, 3]
  
  # 判斷是否是可迭代物件
  print(isinstance(lt, Iterable))
  # 判斷是否是迭代器
  print(isinstance(lt, Iterator))
  

  • iter：可以將可迭代物件轉換為迭代器

  lt = [1, 2, 3]
  
  # 將可迭代物件轉換為迭代器
  lt2 = iter(lt)
  

random

• 示例：

  import random
  
  # 生成指定範圍內的隨機整數
  print(random.randint(1, 10))
  
  # 生成0~1之間的隨機小數
  print(random.random())
  
  # 生成指定範圍內的隨機整數，可以指定步幅
  print(random.randrange(1, 10, 2))
  
  lt = [1, 2, 3, 4, 5, 6, 7]
  # 從容器物件或字串中隨機挑選一個元素
  print(random.choice(lt))
  # print(random.choice('ashdaiapo'))
  
  # 從容器物件中隨機挑取指定個數的元素
  print(random.sample(lt, 3))
  
  # 從容器物件中隨機挑取一個元素，sample函式個數為1的情況
  print(random.choices(lt))
  
  # 打亂一個列表
  random.shuffle(lt)
  print(lt)
  

高階函式

• map

  • 引數：

  func：一個函式
  iter：一個可迭代物件
  

  • 功能：

  將可迭代物件遍歷，每個元素都使用該函式處理一遍，然後返回，儲存這種演算法的迭代器

  • 使用：

  from collections import Iterator
  lt = [1, 2, 3, 4, 5]
  
  def pingfang(n):
      return n * n
  
  # 返回map物件，是一個迭代器
  # ret = map(pingfang, lt)
  
  ret = map(lambda x: x*x, lt)
  print(isinstance(ret, Iterator))
  print(list(ret))
  
  # print(next(ret))
  # print(next(ret))
  
  

• 練習：

  • 熟悉字串函式：strip、lstrip、rstrip
  • 使用map函式：將一個元素全是字串的列表進行處理，去掉兩邊空白，然後首字元大寫

• filter

  • 引數

  function：一個函式
  iterable：可迭代物件
  

  • 功能：

    使用function依次作用於可迭代物件中的每個元素，當返回結果為True時保留該元素。返回filter物件，是一個迭代器。

  • 示例：

  lt = [1, 2, 3, 4, 5]
  
  def oushu(n):
  	return n%2 == 0  
  
  # 返回filter物件，是一個迭代器
  # ret = filter(oushu, lt)
  
  ret = filter(lambda x: x%2 != 0, lt)
  print(ret)
  print(list(ret))
  
  # print(next(ret)) 
  

  • 練習：使用filter函式，提取一個任意列表中長度大於3的字串元素。

• reduce

  • 引數

  function：一個函式
  sequence：一個序列
  

  • 功能：
    • 首先從序列中取出前兩個元素，作為function的引數處理一下
    • 處理完的結果與下一個元素再使用function處理一下
    • 處理結束，將處理完的結果返回
  • 示例：

  from functools import reduce
  
  lt = [1, 2, 3, 4, 5]
  
  def add(a, b):
  	return a + b
  
  # ret = reduce(add, lt)
  # ret = reduce(lambda x, y: x*y, lt)
  ret = reduce(lambda x, y: x*10 + y, lt)
  print(ret)