堅持堅持再堅持！！！
如果文章對于你有幫助，歡迎收藏、關注、點贊與訂閱專欄
有任何疑問歡迎私信

第 11 天 - 函式

到目前為止，我們已經看到了許多內置的 Python 函式，今天，我們將重點介紹自定義函式，什么是函式？在開始制作函式之前，讓我們先了解一下什么是函式以及為什么需要它們？

定義函式

函式是設計用于執行特定任務的可重用代碼塊或編程陳述句，為了定義或宣告一個函式，Python 提供了def關鍵字，以下是定義函式的語法，只有在呼叫或呼叫函式時才執行代碼的功能塊，

宣告和呼叫函式

當我們創建一個函式時，我們稱之為宣告一個函式，當我們開始使用它時，我們稱它為呼叫或呼叫一個函式，函式可以帶引數或不帶引數宣告，

# 語法
# 宣告函式
def  function_name ():
    代碼
    代碼
# 呼叫函式
function_name ()

無引數函式

函式可以不帶引數宣告，

例子：

def  generate_full_name ():
     first_name  =  'Asabeneh' 
    last_name  =  'Yetayeh' 
    space  =  '' 
    full_name  =  first_name  +  space  +  last_name 
    print ( full_name )
 generate_full_name () #呼叫一個函式

def  add_two_numbers ():
     num_one  =  2 
    num_two  =  3 
    total  =  num_one  +  num_two 
    print ( total )
 add_two_numbers ()

回傳值的函式 - 第 1 部分

函式也可以回傳值，如果函式沒有return陳述句，則函式的值為None，讓我們使用 return 重寫上述函式，從現在開始，當我們呼叫函式并列印它時，我們會從函式中獲取一個值，

def  generate_full_name ():
     first_name  =  'Asabeneh' 
    last_name  =  'Yetayeh' 
    space  =  '' 
    full_name  =  first_name  +  space  +  last_name 
    return  full_name 
print ( generate_full_name ())

def  add_two_numbers ():
     num_one  =  2 
    num_two  =  3 
    total  =  num_one  +  num_two
    回傳 總
列印( add_two_numbers () )

帶引數的函式

在函式中，我們可以傳遞不同的資料型別（數字、字串、布林值、串列、元組、字典或集合）作為引數

• 單引數：如果我們的函式接受一個引數，我們應該用一個引數呼叫我們的函式

 # 語法
  # 宣告一個函式
  def  function_name ( parameter ):
    代碼
    代碼
  # 呼叫函式
  print ( function_name ( argument ))

例子：

def  greetings ( name ):
     message  =  name  +  ', 歡迎來到 Python for Everyone！' 
    回傳 訊息

列印（問候（'Asabeneh'））

def  add_ten ( num ):
    十 =  10
    回傳 num  + 十
列印( add_ten ( 90 ))

def  square_number ( x ):
     return  x  *  x 
print ( square_number ( 2 ) )

def  area_of_circle ( r ):
     PI  =  3.14 
    area  =  PI  *  r  **  2 
    return  area 
print ( area_of_circle ( 10 ) )

def  sum_of_numbers ( n ):
     total  =  0 
    for  i  in  range ( n + 1 ):
         total += i 
    print ( total )
 print ( sum_of_numbers ( 10 )) # 55 
print ( sum_of_numbers ( 100 )) # 5050

• 兩個引數：一個函式可能有也可能沒有一個或多個引數，一個函式也可以有兩個或多個引數，如果我們的函式接受引數，我們應該使用引數呼叫它，讓我們檢查一個帶有兩個引數的函式：

  # 語法
  # 宣告一個函式
  def  function_name ( para1 , para2 ):
    代碼
    代碼
  # 呼叫函式
  print ( function_name ( arg1 , arg2 ))

例子：

def  generate_full_name ( first_name , last_name ):
     space  =  ' ' 
      full_name  =  first_name  +  space  +  last_name 
      return  full_name 
print ( 'Full Name: ' , generate_full_name ( 'Asabeneh' , 'Yetayeh' ))

def  sum_two_numbers ( num_one , num_two ):
     sum  =  num_one  +  num_two 
    return  sum 
print ( '兩個數字的和：' , sum_two_numbers ( 1 , 9 ))

高清 calculate_age（CURRENT_YEAR，birth_year）：
    年齡 =  CURRENT_YEAR  -  birth_year
    回報 年齡;

列印（'年齡：'，計算年齡（2021年，1819年））

DEF  weight_of_object（質量，重心）：
    重量 =  STR（質量 * 重力）+  “N”  ＃的值必須改變到一個字串第一
    回傳 重量
列印（“的物體的重量以牛頓：”，weight_of_object（100，9.81 ))

使用鍵和值傳遞引數

如果我們使用鍵和值傳遞引數，則引數的順序無關緊要，

# 語法
# 宣告一個函式
def  function_name ( para1 , para2 ):
    代碼
    代碼
# 呼叫函式
print ( function_name ( para1  =  'John' , para2  =  'Doe' )) # 這里引數的順序無關緊要

例子：

def  print_fullname ( firstname , lastname ):
     space  =  ' ' 
    full_name  =  firstname   +  space  +  lastname 
    print ( full_name )
 print ( print_fullname ( firstname  =  'Asabeneh' , lastname  =  'Yetayeh' ))

def  add_two_numbers ( num1 , num2 ):
     total  =  num1  +  num2 
    print ( total )
 print ( add_two_numbers ( num2  =  3 , num1  =  2 )) # 順序無所謂

回傳值的函式 - 第 2 部分

如果我們不使用函式回傳值，那么我們的函式默認回傳None，要使用函式回傳值，我們使用關鍵字return后跟我們要回傳的變數，我們可以從函式回傳任何型別的資料型別，

• 回傳字串：

示例：

def  print_name ( firstname ):
     return  firstname 
print_name ( 'Asabeneh' ) # Asabeneh

def  print_full_name ( firstname , lastname ):
     space  =  ' ' 
    full_name  =  firstname   +  space  +  lastname 
    return  full_name 
print_full_name ( firstname = 'Asabeneh' , lastname = 'Yetayeh' )

• 回傳一個數字：

例子：

def  add_two_numbers ( num1 , num2 ):
     total  =  num1  +  num2 
    return  total 
print ( add_two_numbers ( 2 , 3 ))

高清 calculate_age（CURRENT_YEAR，birth_year）：
    年齡 =  CURRENT_YEAR  -  birth_year
    回報 年齡;
列印（'年齡：'，計算年齡（2019年，1819年））

• 回傳一個布林值：
  示例：

def  is_even ( n ):
     if  n  %  2  ==  0 :
         print ( 'even' )
         return  True     # return 停止函式的進一步執行，類似于 break 
    return  False 
print ( is_even ( 10 )) # True 
print ( is_even ( 7 ) )) # 錯誤

• 回傳串列：

示例：

DEF  find_even_numbers（?）：
    找齊 = []
    為 我 在 范圍（?  +  1）：
        如果 我 ％ 2  ==  0：
            找齊，追加（我）
    回傳 找齊
列印（find_even_numbers（10））

帶默認引數的函式

有時我們在呼叫函式時將默認值傳遞給引數，如果我們在呼叫函式時不傳遞引數，將使用它們的默認值，

# 語法
# 宣告一個函式
def  function_name ( param  =  value ):
    代碼
    代碼
# 呼叫函式
function_name ()
 function_name ( arg )

例子：

def  greetings ( name  =  'Peter' ):
     message  =  name  +  '，歡迎大家使用 Python！
    回傳 訊息
列印（問候（））
列印（問候（'Asabeneh'））

def  generate_full_name ( first_name  =  'Asabeneh' , last_name  =  'Yetayeh' ):
     space  =  ' ' 
    full_name  =  first_name  +  space  +  last_name 
    return  full_name

列印（生成全名（））
列印（生成全名（'大衛'，'史密斯'））

DEF  calculate_age（birth_year，CURRENT_YEAR  =  2021）：
    年齡 =  CURRENT_YEAR  -  birth_year
    回傳 年齡;
列印（'年齡：'，計算年齡（1821））

DEF  weight_of_object（質量，重心 =  9.81）：
    重量 =  STR（質量 * 重力）+  “N”  ＃的值必須改變到字串第一
    回傳 重量
列印（“牛頓的物體的重量：”，weight_of_object（100） ) # 9.81 - 地球表面的平均重力
列印( '以牛頓為單位的物體重量：' , weight_of_object ( 100 , 1.62 ))# 月球表面的重力

任意數量的引數

如果我們不知道傳遞給函式的引數數量，我們可以通過在引數名稱前添加 * 來創建一個可以接受任意數量引數的函式，

# 語法
# 宣告一個函式
def  function_name ( * args ):
    代碼
    代碼
# 呼叫函式
function_name ( param1 , param2 , param3 ,..)

例子：

def  sum_all_nums ( * nums ):
     total  =  0 
    for  num  in  nums :
         total  +=  num      # 同total = total + num 
    return  total 
print ( sum_all_nums ( 2 , 3 , 5 )) # 10

函式中的默認引數和任意數量的引數

def  generate_groups ( team , * args ):
     print ( team )
     for  i  in  args :
         print ( i )
 print ( generate_groups ( 'Team-1' , 'Asabeneh' , 'Brook' , 'David' , 'Eyob' ))

函式作為另一個函式的引數

#您可以將函式作為引數傳遞
def  square_number ( n ):
     return  n  *  n 
def  do_something ( f , x ):
     return  f ( x )
 print ( do_something ( square_number , 3 )) # 27

到目前為止，您取得了很多成就，繼續！您剛剛完成了第 11 天的挑戰，距離通往偉大之路還有 11 步，

第 12 天 - 模塊

什么是模塊

模塊是包含一組代碼或一組可以包含在應用程式中的功能的檔案，模塊可以是包含單個變數、函式或大型代碼庫的檔案，

創建模塊

為了創建一個模塊，我們在 python 腳本中撰寫代碼并將其保存為 .py 檔案，在專案檔案夾中創建一個名為 mymodule.py 的檔案，讓我們在這個檔案中寫一些代碼，

# mymodule.py 檔案
def  generate_full_name ( firstname , lastname ):
     return  firstname  +  ' '  +  lastname

在您的專案目錄中創建 main.py 檔案并匯入 mymodule.py 檔案，

匯入模塊

要匯入檔案，我們僅使用import關鍵字和檔案名，

# main.py 檔案
import  mymodule 
print ( mymodule . generate_full_name ( 'Asabeneh' , 'Yetayeh' )) # Asabeneh Yetayeh

從模塊匯入函式

我們可以在一個檔案中包含多個函式，并且可以以不同的方式匯入所有函式，

# main.py 檔案
from  mymodule  import  generate_full_name , sum_two_nums , person ,重力
列印( generate_full_name ( 'Asabneh' , 'Yetayeh' ))
 print ( sum_two_nums ( 1 , 9 ))
 mass  =  100 ;
重量 = 質量 * 重力
列印（重量）
列印（人[ '名字' ]）

從模塊匯入函式并重命名

在匯入程序中，我們可以重命名模塊的名稱，

＃main.py檔案
從 MyModule的 進口 generate_full_name 如 全名，sum_two_nums 作為 總，人 作為 p，重力 為 克
列印（全名（'Asabneh' ，'Yetayeh' ））
列印（總共（1，9））
的質量 =  100 ;
重量 = 質量 *  g
列印（重量）
列印（p )
列印( p [ 'firstname' ])

匯入內置模塊

像其他編程語言一樣，我們也可以通過使用關鍵字import 匯入檔案/函式來匯入模塊，讓我們匯入我們將大部分時間使用的公共模塊，一些常見的內置模塊：math、datetime、os、sys、random、statistics、collections、json、re

作業系統模塊

使用 python os模塊可以自動執行許多作業系統任務，Python 中的 OS 模塊提供創建、更改當前作業目錄、洗掉目錄（檔案夾）、獲取其內容、更改和識別當前目錄的功能，

# 匯入模塊
import  os 
# 創建目錄
os . mkdir ( 'directory_name' )
 # 改變當前目錄
os . chdir ( 'path' )
 # 獲取當前作業目錄
os . getcwd ()
 # 洗掉目錄
os . 目錄()

系統模塊

sys 模塊提供用于操作 Python 運行時環境的不同部分的函式和變數，函式 sys.argv 回傳傳遞給 Python 腳本的命令列引數串列，此串列中索引 0 處的專案始終是腳本的名稱，索引 1 處是從命令列傳遞的引數，

script.py 檔案示例：

import  sys 
#print(sys.argv[0], argv[1],sys.argv[2]) # 這行會列印出： filename argument1 argument2 
print ( 'Welcome {}. Enjoy {} Challenge!' . format ( sys . argv [ 1 ], sys . argv [ 2 ]))

現在要檢查這個腳本是如何作業的，我在命令列中寫了：

python script.py Asabeneh 30DaysOfPython

結果：

歡迎，享受 30DayOfPython 挑戰！ 

一些有用的 sys 命令：

# 退出 sys 
sys，exit ()
 # 要知道最大的整數變數需要
sys，maxsize 
# 要知道環境路徑
sys . path 
# 要知道您使用的 python 版本
sys，版本

統計模塊

統計模塊提供數值資料的數理統計功能，此模塊中定義的流行統計函式：mean、median、mode、stdev等，

from  statistics  import  *  # 匯入所有統計模塊
age  = [ 20 , 20 , 4 , 24 , 25 , 22 , 26 , 20 , 23 , 22 , 26 ]
 print ( mean ( ages ))        # ~22.9 
print ( median ( ages) ))      # 23
列印（模式（年齡））        # 20
列印（stdev（年齡））       #~2.3

數學模塊

包含許多數學運算和常數的模塊，

進口 數學
列印（數學，PI）            ＃3.141592653589793，PI常數
列印（數學，SQRT（2））       ＃1.4142135623730951，平方根
列印（數學，POW（2，3））     ＃8.0，指數函式
列印（數學，地板（9.81））   ＃9，四舍五入到最低
列印（數學，小區（9.81））   # 10，四舍五入到最高
列印( math . log10 ( 100 ))    # 2，以10為底的對數

現在，我們已經匯入了math模塊，其中包含許多可以幫助我們進行數學計算的功能，要檢查模塊具有哪些功能，我們可以使用help(math)或dir(math)，這將顯示模塊中的可用功能，如果我們只想從模塊中匯入一個特定的函式，我們按如下方式匯入它：

從 數學 匯入 pi
列印( pi )

也可以一次匯入多個函式

從 數學 進口 PI，SQRT，POW，地板，小區，日志10
列印（PI）                  ＃3.141592653589793
列印（SQRT（2））             ＃1.4142135623730951
列印（POW（2，3））           ＃8.0
列印（地板（9.81））         ＃9
列印(上限( 9.81 ))         ＃10
列印（數學，LOG10（100））     ＃2

但是如果我們想匯入 math 模塊中的所有函式，我們可以使用 * ，

from  math  import  * 
print ( pi )                   # 3.141592653589793, pi 常數
列印( sqrt ( 2 ))              # 1.4142135623730951, 平方根
列印( pow ( 2 , 3 ))            # 8.0, 指數
列印( floor ( 9.81 )         四舍五入)最低的
列印( ceil ( 9.81 ))           # 10，四舍五入到最高的
列印( math .log10 ( 100 ))      # 2

當我們匯入時，我們還可以重命名函式的名稱，

from  math  import  pi  as   PI 
print ( PI ) # 3.141592653589793

字串模塊

字串模塊是一個用于多種用途的有用模塊，下面的示例顯示了 string 模塊的一些用法，

進口 字串
列印（串，ascii_letters）＃abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
列印（串，位數）         ＃0123456789
列印（串，標點符號）    ＃“＃$％＆'（）* +， - ，/？：; <=> @ [\] ^_`{|}~

隨機模塊

到目前為止，您已經熟悉了匯入模塊，讓我們再做一個匯入來熟悉它，讓我們匯入random模塊，它給我們一個 0 到 0.9999 之間的亂數… random模塊有很多功能，但在本節中我們將只使用random和randint，

from  random  import  random , randint 
print ( random ())    # 不帶任何引數；它回傳一個介于 0 和 0.9999 之間的值
print ( randint ( 5 , 20 )) # 它回傳一個介于 [5, 20] 之間的隨機整數

你要走得很遠，繼續！您剛剛完成了第 12 天的挑戰，距離通往偉大之路還有 12 步，

第 13 天 - 串列理解

Python 中的串列推導式是一種從序列創建串列的緊湊方式，這是創建新串列的一種快捷方式，串列理解比使用for回圈處理串列快得多，

# 語法
[ i  for  i  in  iterable  if  expression ]

示例：1

例如，如果您想將字串更改為字串列，您可以使用幾種方法，讓我們看看其中的一些：

# 一種方式
language  =  'Python' 
lst  =  list ( language ) # 將字串改為串列
print ( type ( lst ))      # list 
print ( lst )            # ['P', 'y', 't', 'h' ， '在']

# 第二種方式：list comprehension 
lst  = [ i  for  i  in  language ]
 print ( type ( lst )) # list 
print ( lst )        # ['P', 'y', 't', 'h', 'o', 'n']

示例：2

例如，如果你想生成一個數字串列

# 生成數字
numbers  = [ i  for  i  in  range ( 11 )]   # 生成從 0 到 10 的
數字print ( numbers )                     # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

# 可以在迭代期間進行數學運算
squares  = [ i  *  i  for  i  in  range ( 11 )]
 print ( squares )                     # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 也可以創建一個元組串列
numbers  = [( i , i  *  i ) for  i  in  range ( 11 )]
 print ( numbers )                              # [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

示例：2

串列推導式可以與 if 運算式結合使用

# 生成偶數
even_numbers  = [ i  for  i  in  range ( 21 ) if  i  %  2  ==  0 ]   # 生成 0 到 21 范圍內的偶數串列
print ( even_numbers )                     # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# 生成奇數
odd_numbers  = [ i  for  i  in  range ( 21 ) if  i  %  2  !=  0 ]   # 生成0到21范圍內的奇數
print ( odd_numbers )                       # [1, 3, 5, 7, 9, 11 , 13, 15, 17, 19] 
# 過濾數字：讓我們從下面的串列中過濾掉正偶數
numbers  = [ - 8 , - 7 , - 3 , - 1 , 0 ,1 , 3 , 4 , 5 , 7 , 6 , 8 , 10 ]
 positive_even_numbers  = [ i  for  i  in  range ( 21 ) if  i  %  2  ==  0  and  i  >  0 ]
 print ( positive_even_numbers )                     # [2, 4, 6 , 8, 10, 12, 14, 16, 18, 20]

# 展平一個三維陣列
list_of_lists  = [[ 1 , 2 , 3 ], [ 4 , 5 , 6 ], [ 7 , 8 , 9 ]]
 flattened_list  = [ number  for  row  in  list_of_lists  for  number  in  row ]
 print ( flattened_list )     # [1, 2, 3, 4, 5, 6, 7, 8, 9]

Lambda 函式

Lambda 函式是一個沒有名字的小型匿名函式，它可以接受任意數量的引數，但只能有一個運算式，Lambda 函式類似于 JavaScript 中的匿名函式，當我們想在另一個函式中撰寫匿名函式時，我們需要它，

創建 Lambda 函式

要創建 lambda 函式，我們使用lambda關鍵字，后跟引數，后跟運算式，請參閱下面的語法和示例，Lambda 函式不使用 return，但它顯式回傳運算式，

# 語法
x  =  lambda  param1 , param2 , param3 : param1  +  param2  +  param2 
print ( x ( arg1 , arg2 , arg3 ))

例子：

# 命名函式
def  add_two_nums ( a , b ):
     return  a  +  b

print ( add_two_nums ( 2 , 3 ))      # 5 
# 讓我們把上面的函式
改成 lambda 函式add_two_nums =  lambda  a , b : a  +  b 
print ( add_two_nums ( 2 , 3 ))     # 5

# 自呼叫 lambda 函式
( lambda  a , b : a  +  b )( 2 , 3 ) # 5 - 需要將其封裝在 print() 中才能在控制臺中查看結果

square  =  lambda  x : x  **  2 
print ( square ( 3 ))     # 9 
cube  =  lambda  x : x  **  3 
print ( cube ( 3 ))     # 27

# 多個變數
multiple_variable  =  lambda  a , b , c : a  **  2  -  3  *  b  +  4  *  c 
print ( multiple_variable ( 5 , 5 , 3 )) # 22

另一個函式中的 Lambda 函式

在另一個函式中使用 lambda 函式，

def  power ( x ):
    回傳 lambda  n : x  **  n

cube  =  power ( 2 )( 3 )    # 函式 power 現在需要 2 個引數來運行，在單獨的圓括號中
print ( cube )           # 8 
two_power_of_five  =  power ( 2 )( 5 ) 
 print ( two_power_of_five )   # 32

保持良好的作業，保持勢頭，天空是極限！您剛剛完成了第 13 天的挑戰，距離通往偉大之路還有 13 步，

第 14 天 - 高階函式

在 Python 中，函式被視為一等公民，允許您對函式執行以下操作：

1. 一個函式可以接受一個或多個函式作為引數
2. 一個函式可以作為另一個函式的結果回傳
3. 一個函式可以修改
4. 一個函式可以賦值給一個變數

今天，我們將介紹：

1. 將函式作為引數處理
2. 將函式作為另一個函式的回傳值回傳
3. 使用 Python 閉包和裝飾器

作為引數的函式

def  sum_numbers ( nums ):   # 普通函式
    回傳 sum ( nums )     # 一個濫用內置 sum 函式的悲傷函式 :<

def  high_order_function ( f , lst ):   # 函式作為引數
    summation  =  f ( lst )
     return  summation 
result  =  Higher_order_function ( sum_numbers , [ 1 , 2 , 3 , 4 , 5 ])
 print ( result )        # 15

作為回傳值的函式

def  square ( x ):           # 一個平方函式
    return  x  **  2

def  cube ( x ):             # 一個立方體函式
    return  x  **  3

def  absolute ( x ):         # 一個絕對值函式
    if  x  >=  0 :
         return  x 
    else :
         return  - ( x )

def  Higher_order_function ( type ): # 一個高階函式回傳一個函式
    if  type  ==  'square' :
         return  square 
    elif  type  ==  'cube' :
         return  cube 
    elif  type  ==  'absolute' :
         return  absolute

result  =  Higher_order_function ( 'square' )
 print ( result ( 3 ))        # 9 
result  =  Higher_order_function ( 'cube' )
 print ( result ( 3 ))        # 27 
result  =  Higher_order_function ( 'absolute' )
 print ( result ( - 3 ))       # 3

從上面的例子可以看出，高階函式根據傳遞的引數回傳不同的函式

Python 閉包

Python 允許嵌套函式訪問封閉函式的外部作用域，這被稱為閉包，讓我們看看閉包在 Python 中是如何作業的，在 Python 中，閉包是通過在另一個封裝函式中嵌套一個函式然后回傳內部函式來創建的，請參閱下面的示例，

例子：

def  add_ten ():
    十 =  10 
    def  add ( num ):
        回傳 num  + 十
    回傳 添加

closure_result  =  add_ten（）
列印（closure_result（5））   ＃15
列印（closure_result（10））   ＃20

Python 裝飾器

裝飾器是 Python 中的一種設計模式，它允許用戶在不修改其結構的情況下向現有物件添加新功能，裝飾器通常在定義要裝飾的函式之前呼叫，

創建裝飾器

要創建裝飾器函式，我們需要一個帶有內部包裝函式的外部函式，

例子：

# 普通函式
def  greeting ():
     return  'Welcome to Python' 
def  uppercase_decorator ( function ):
     def  wrapper ():
         func  =  function ()
         make_uppercase  =  func . upper ()
         return  make_uppercase 
    return  wrapper 
g  =  uppercase_decorator ( greeting )
 print ( g ())           # 歡迎來到 PYTHON

## 讓我們用一個裝飾器來實作上面的例子

'''這個裝飾器函式是一個
以函式為引數的
高階函式''' def  uppercase_decorator ( function ):
     def  wrapper ():
         func  =  function ()
         make_uppercase  =  func，upper ()
         return  make_uppercase 
    return  wrapper 
@ uppercase_decorator
 def  greeting ():
     return  'Welcome to Python' 
print ( greeting ())    # WELCOME TO PYTHON

將多個裝飾器應用于單個函式

'''這些裝飾器函式是以
函式為引數的高階函式'''

# 第一個裝飾器
def  uppercase_decorator ( function ):
     def  wrapper ():
         func  =  function ()
         make_uppercase  =  func . upper ()
        回傳 make_uppercase
    回傳 包裝器

# 第二個裝飾器
def  split_string_decorator ( function ):
     def  wrapper ():
         func  =  function ()
         splitted_string  =  func . split ()
        回傳 splitted_string

    回傳 包裝器

@ split_string_decorator
 @ uppercase_decorator      # 在這種情況下，裝飾器的順序很重要 - .upper() 函式不適用于串列
def  greeting ():
     return  'Welcome to Python' 
print ( greeting ())    # WELCOME TO PYTHON

在裝飾器函式中接受引數

大多數時候我們需要我們的函式接受引數，所以我們可能需要定義一個接受引數的裝飾器，

d

ef  decorator_with_parameters ( function ):
     def  wrapper_accepting_parameters ( para1 , para2 , para3 ):
         function ( para1 , para2 , para3 )
         print ( "I live in {}" . format ( para3 ))
     return  wrapper_accepting_parameters

@ decorator_with_parameters
高清 print_full_name（FIRST_NAME，姓氏，國家）：
    列印（“我是{} {}我愛教”，格式（
        如first_name，姓氏，國家））

print_full_name ( "Asabeneh" , "Yetayeh" , '芬蘭' )

內置高階函式

我們在本部分中介紹的一些內置高階函式是map()、filter和reduce，Lambda 函式可以作為引數傳遞，而 lambda 函式的最佳用例是 map、filter 和 reduce 等函式，

Python - 地圖函式

map() 函式是一個內置函式，它接受一個函式和 iterable 作為引數，

   # 語法
    映射（函式，可迭代）

示例：1

numbers  = [ 1 , 2 , 3 , 4 , 5 ] # iterable 
def  square ( x ):
     return  x  **  2 
numbers_squared  =  map ( square , numbers )
 print ( list ( numbers_squared ))     # [1, 4, 9, 16 , 25] 
# 讓我們用一個 lambda 函式
來 應用它numbers_squared =  map ( lambda  x : x  **  2, numbers )
 print ( list ( numbers_squared ))     # [1, 4, 9, 16, 25]

示例：2

numbers_str  = [ '1' , '2' , '3' , '4' , '5' ]   # 可迭代
numbers_int  =  map ( int , numbers_str )
 print ( list ( numbers_int ))     # [1, 2, 3, 4, 5]

示例：3

names  = [ 'Asabeneh' , 'Lidiya' , 'Ermias' , 'Abraham' ]   # 可迭代

def  change_to_upper ( name ):
    回傳 name，上()

names_upper_cased  =  map ( change_to_upper , names )
 print ( list ( names_upper_cased ))     # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']

# 讓我們用一個 lambda 函式來應用它
names_upper_cased  =  map ( lambda  name : name . upper (), names )
 print ( list ( names_upper_cased ))     # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']

實際上 map 所做的是迭代一個串列，例如，它將名稱更改為大寫并回傳一個新串列，

Python - 過濾功能

filter() 函式呼叫指定的函式，該函式為指定的可迭代物件（串列）的每個專案回傳布林值，它過濾滿足過濾條件的專案，

  # 語法
    過濾器（函式，可迭代）

示例：1

# 只過濾偶數
數字 = [ 1 , 2 , 3 , 4 , 5 ]   # iterable

def  is_even ( num ):
     if  num  %  2  ==  0 :
         return  True 
    return  False

even_numbers  =  filter ( is_even , numbers )
 print ( list ( even_numbers ))        # [2, 4]

示例：2

數字 = [ 1 , 2 , 3 , 4 , 5 ]   # 可迭代

def  is_odd ( num ):
     if  num  %  2  !=  0 :
         return  True 
    return  False

奇數 = 過濾器( is_odd ,數字)
列印(串列(奇數))        # [1, 3, 5]

# 過濾長名稱
names  = [ 'Asabeneh' , 'Lidiya' , 'Ermias' , 'Abraham' ]   # iterable 
def  is_name_long ( name ):
     if  len ( name ) >  7 :
         return  True 
    return  False

long_names  =  filter ( is_name_long , names )
 print ( list ( long_names ))          # ['Asabeneh']

Python - 減少函式

在減少（）函式的fucntools模塊里定義，我們應該從這個模塊匯入，與 map 和 filter 一樣，它需要兩個引數，一個函式和一個可迭代物件，但是，它不會回傳另一個可迭代物件，而是回傳單個值，
示例：1

numbers_str  = [ '1' , '2' , '3' , '4' , '5' ]   # iterable 
def  add_two_nums ( x , y ):
     return  int ( x ) +  int ( y )

total  =  reduce ( add_two_nums , numbers_str )
 print ( total )     # 15

第 15 天 - Python 型別錯誤

當我們撰寫代碼時，我們經常會犯錯或其他一些常見的錯誤，如果我們的代碼無法運行，Python 解釋器將顯示一條訊息，其中包含有關問題發生位置和錯誤型別資訊的反饋，它有時也會為我們提供可能的修復建議，了解編程語言中不同型別的錯誤將幫助我們快速除錯我們的代碼，也可以讓我們更好地完成我們的作業，

讓我們一一看看最常見的錯誤型別，首先讓我們打開 Python 互動式 shell，轉到您的計算機終端并撰寫“python”，python互動式shell將被打開，

語法錯誤

示例 1：語法錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 列印 '世界你好'
  檔案 “<標準輸入>” ，行 1
    列印 的'Hello World' 
                      ^ 
SyntaxError錯誤：缺少 括號 中 呼叫 到 '列印'，  意思是 列印（'你好世界'）？
>> >

正如您所看到的，我們犯了一個語法錯誤，因為我們忘記用括號將字串括起來，而 Python 已經提出了解決方案，讓我們修復它，

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 列印 '世界你好'
  檔案 “<標準輸入>” ，行 1
    列印 的'Hello World' 
                      ^ 
SyntaxError錯誤：缺少 括號 中 呼叫 到 '列印'，  意思是 列印（'你好世界'）？
>> > 列印（'你好世界'）
你好 世界
>> >

錯誤是SyntaxError，修復后，我們的代碼順利執行，讓我們看看更多的錯誤型別，

名稱錯誤

示例 1：名稱錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 列印（年齡）
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
NameError：名 “年齡” 是 沒有 定義
>> >

從上面的訊息中可以看出，名稱年齡沒有定義，是的，我們確實沒有定義年齡變數，但我們試圖將它列印出來，就像我們已經宣告它一樣，現在，讓我們通過宣告它并賦值來解決這個問題，

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 列印（年齡）
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
NameError：名 '年齡' 被 未 限定
>> > 年齡 =  25 
>> > 列印（年齡）
 25 
>> >

錯誤型別是NameError，我們通過定義變數名來除錯錯誤，

索引錯誤

示例 1：索引錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 數 = [ 1，2，3，4，5 ]
 >> > 號[ 5 ]
回溯（最 近期 呼叫 最后):
   File  "<stdin>" , line  1 , in  < module > 
IndexError : list  index  out  of  range 
>> >

在上面的例子中，Python 引發了一個IndexError，因為串列只有從 0 到 4 的索引，所以它超出了范圍，

模塊未找到錯誤

示例 1：ModuleNotFoundError

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 進口 數學
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
ModuleNotFoundError：無  名為 “數學”的
模塊>> >

在上面的例子中，我故意在數學中添加了一個額外的 s 并且引發了 ModuleNotFoundError，讓我們通過從數學中洗掉額外的 s 來解決它，

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 進口 數學
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
ModuleNotFoundError：無  名為 “數學”的
模塊>> > 匯入 數學
>> >

我們修復了它，所以讓我們使用 math 模塊中的一些函式，

屬性錯誤

示例 1：屬性錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 進口 數學
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
ModuleNotFoundError：無  名為 “數學”的
模塊>> > 匯入 數學
>> > 數學，PI
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
AttributeError的：模塊 '數學' 有 沒有 屬性 'PI' 
>> >

如你所見，我又犯了一個錯誤！我嘗試從 maths 模塊呼叫 PI 函式，而不是 pi，它引發了一個屬性錯誤，這意味著該功能在模塊中不存在，讓我們通過從 PI 更改為 pi 來修復它，

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 進口 數學
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
ModuleNotFoundError：無  名為 “數學”的
模塊>> > 匯入 數學
>> > 數學，PI
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
AttributeError的：模塊 '數學' 有 沒有 屬性 'PI' 
>> > 數學，圓周率
3.141592653589793 
>> >

現在，當我們從 math 模塊呼叫 pi 時，我們得到了結果，

密鑰錯誤

示例 1：密鑰錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> >  users  = { 'name' : 'Asab' , 'age' : 250 , 'country' : 'Finland' }
 >> >  users [ 'name' ]
'阿薩布' 
>>>用戶[ '縣']
回溯（最 近期 呼叫 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
KeyError例外：'縣' 
>> >

如您所見，用于獲取字典值的鍵中存在拼寫錯誤，所以，這是一個關鍵錯誤，修復非常簡單，我們開工吧！

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> >  user  = { 'name' : 'Asab' , 'age' : 250 , 'country' : 'Finland' }
 >> >  user [ 'name' ]
'阿薩布' 
>>>用戶[ '縣']
回溯（最 近期 呼叫 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
KeyError例外：'縣' 
>> > 用戶[ '國家' ]
'芬蘭'
 >> >

我們除錯了錯誤，運行了代碼并獲得了值，

型別錯誤

示例 1：型別錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> >  4  +  '3'
回溯（最 近期 呼叫 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊>
型別錯誤： 運算元 型別（小號）為 +：'INT' 和 'STR' 
>> >

在上面的示例中，由于我們無法向字串添加數字，因此會引發 TypeError，第一個解決方案是將字串轉換為 int 或 float，另一種解決方案是將數字轉換為字串（結果將是“43”），讓我們遵循第一個修復程式，

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> >  4  +  '3'
回溯（最 近期 呼叫 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊>
型別錯誤： 運算元 型別（小號）為 +：'INT' 和 'STR' 
>> >  4  +  INT（'3' ）
 7 
>> >  4  + 浮動（'3' ）
 7.0 
>> >

錯誤消除，我們得到了預期的結果，

匯入錯誤

示例 1：型別錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 從 數學 進口 電力
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>”，線 1，在 <模塊>
無法 從“數學”匯入 名稱 “power  ” >> > 

數學模塊中沒有名為 power 的函式，它有一個不同的名稱：pow，讓我們更正一下：

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 從 數學 進口 電力
回溯（最 近期的 通話 最后）：
  檔案 “<標準輸入>”，線 1，在 <模塊>
無法 從'math' >> > from math import pow >> > pow ( 2 , 3 )
 8.0 >> >匯入 名稱 'power'  

值錯誤

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> >  INT（'12A' ）
回溯（最 近期 呼叫 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊>
無效 字面 為 INT（）與 堿 10：'12A' 
>> >

在這種情況下，我們不能將給定的字串更改為數字，因為其中包含 ‘a’ 字母，

零分誤差

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> >  1 / 0
回溯（最 近期 呼叫 最后）：
  檔案 “<標準輸入>” ，線 1，在 <模塊> 
ZeroDivisionError： 按 零
>> >

我們不能將一個數除以零，

我們已經介紹了一些 python 錯誤型別，如果你想查看更多關于它的資訊，請查看關于 python 錯誤型別的 python 檔案，如果您擅長閱讀錯誤型別，那么您將能夠快速修復錯誤，并且您還將成為一名更好的程式員，

你很優秀，你成功了一半，

第 16 天 - Python 日期時間

Python 有datetime模塊來處理日期和時間，

匯入 日期時間
列印（目錄（日期時間））
[ 'MAXYEAR' ，'MINYEAR' ，'__builtins__' ，'__cached__' ，'__doc__' ，'__file__' ，'__loader__' ，'__name__' ，'__PACKAGE__' ，'__spec__' ，'日期'，'日期時間'，' datetime_CAPI'、'sys'、'time'、'timedelta'、'timezone'、'tzinfo' ]

使用 dir 或 help 內置命令可以知道某個模塊中的可用功能，如您所見，在 datetime 模塊中有許多函式，但我們將重點介紹date、datetime、time和timedelta，讓我們一一看看，

獲取日期時間資訊

from  datetime  import  datetime 
now  =  datetime，現在()
列印(現在)                       # 2021-07-08 07:34:46.549883 
day  =  now . 天                   # 8
月 = 現在，月               # 7
年 = 現在，年                 # 2021
小時 = 現在，小時                 # 7
分鐘 = 現在，分鐘             # 38
秒 = 現在，第二
時間戳 = 現在，時間戳（）
列印（日，月，年，小時，分鐘）
列印（'時間戳'，時間戳）
列印（f' {天} / {月} / {年}，{小時}：{分鐘} '）   #8 /7/2021, 7:38

時間戳或 Unix 時間戳是從 1970 年 1 月 1 日 UTC 開始經過的秒數，

使用strftime格式化日期輸出

from  datetime  import  datetime 
new_year  =  datetime ( 2020 , 1 , 1 )
 print ( new_year )       # 2020-01-01 00:00:00 
day  =  new_year，天
月 =  new_year，月
年 =  new_year，年
小時 =  new_year，小時
分鐘 =  new_year，分
第二 =  new_year，第二
列印（日、月、年、小時、分鐘）#1 1 2020 0 0
列印（f' {天} / {月} / {年} , {小時} : {分鐘} '）   # 1/1/2020， 0:0

可以在此處找到使用strftime方法和檔案格式化日期時間，

from  datetime  import  datetime 
# 當前日期和時間
now  =  datetime . 現在()
 t  = 現在，strftime ( "%H:%M:%S" )
列印( "time:" , t )
 time_one  =  now，strftime ( "%m/%d/%Y, %H:%M:%S" )
 # mm/dd/YY H:M:S 格式
列印( "time one:" , time_one )
 time_two  =  now . 時間（"%d/%m/%Y, %H:%M:%S" )
 # dd/mm/YY H:M:S 格式
列印( "time two:" , time_two )

時間：01 :05 :01
時間一：12/05/2019，01:05 :01 第二
時間：05/12/2019，01:05:01

這是我們用來格式化時間的所有strftime符號，此模塊的所有格式的示例，

使用strptime 將字串轉換為時間

這是一個有助于理解格式的檔案，

from  datetime  import  datetime 
date_string  =  "5 December, 2019" 
print ( "date_string =" , date_string )
 date_object  =  datetime，strptime ( date_string , "%d %B, %Y" )
列印( "date_object =" , date_object )

date_string = 2019 年 12 月 5 日
date_object = 2019-12-05 00:00:00

使用日期時間中的日期

from  datetime  import  date 
d  =  date ( 2020 , 1 , 1 )
 print ( d )
 print ( 'Current date:' , d . today ())     # 2019-12-05 
# 今天的日期物件
today  =  date . today ()
 print ( "Current year:" , today . year )    # 2019 
print ( "Current month:" , today .月）＃12
列印（“當前天：” ，今，日）      ＃5

代表時間的時間物件

from  datetime  import  time 
# time(hour = 0, minute = 0, second = 0) 
a  =  time ()
 print ( "a =" , a )
 # time(hour, minute and second) 
b  =  time ( 10 , 30 , 50 )
 print ( "b =" , b )
 # time(hour, minute and second) 
c  =  time ( hours = 10 , minute = 30 , second = 50 )
print ( "c =" , c )
 # time(hour, minute, second
 , microsecond ) d  =  time ( 10 , 30 , 50 , 200555 )
 print ( "d =" , d )

輸出 a = 00:00:00
b = 10:30:50
c = 10:30:50
d = 10:30:50.200555

兩個時間點之間的差異使用

today  =  date ( year = 2019 , month = 12 , day = 5 )
 new_year  =  date ( year = 2020 , month = 1 , day = 1 )
 time_left_for_newyear  =  new_year  -  today 
# 新年還剩27天，0:00 :00
列印（'新年還剩時間：'，time_left_for_newyear）

t1  = 日期時間（年 =  2019，月 =  12，日 =  5，小時 =  0，分鐘 =  59，秒 =  0）
 t2  = 日期時間（年 =  2020，月 =  1，日 =  1，小時 =  0，分鐘 =  0 ,秒 =  0)
 diff  =  t2  -  t1 
print ( 'Time left for new year:' , diff ) # 新年剩余時間：26 天，23:01:00

使用timedelata 的兩個時間點之間的差異

從 日期時間 進口 timedelta 
T1  =  timedelta（周= 12，天= 10，小時= 4，秒= 20）
 T2  =  timedelta（天= 7，小時= 5，分鐘= 3，秒= 30）
 T3  =  T1  -  T2
列印( "t3 =" , t3)

date_string = 2019 年 12 月 5 日
date_object = 2019-12-05 00:00:00
t3 = 86 天，22:56:50

第 17 天 - 例外處理

Python 使用try和except來優雅地處理錯誤，錯誤的優雅退出（或優雅處理）是一種簡單的編程習慣用法 - 程式檢測到嚴重的錯誤情況并因此以受控方式“優雅退出”，通常，作為優雅退出的一部分，程式會向終端或日志列印描述性錯誤訊息，這使我們的應用程式更加健壯，例外的原因通常在程式本身之外，例外的一個例子可能是不正確的輸入、錯誤的檔案名、無法找到檔案、IO 設備故障，優雅地處理錯誤可以防止我們的應用程式崩潰，

我們在上一節中介紹了不同的 Python錯誤型別，如果我們在我們的程式中使用try和except，那么它不會在這些塊中引發錯誤，

嘗試：
    代碼 在 此 塊 如果 事情 去 也
只是：
    代碼 在 此 塊 來看 ，如果 事情 去 錯了

例子：

嘗試：
    列印（10  +  '5'）
除了：
    列印（'出了點問題'）

在上面的例子中，第二個運算元是一個字串，我們可以將其更改為 float 或 int 以將其與數字相加以使其作業，但是沒有任何更改，將執行第二個塊，除了，

例子：

try :
     name  =  input ( 'Enter your name:' )
     year_born  =  input ( 'Year youbirth :' )
     age  =  2019  -  year_born 
    print ( f'You are { name } . And your age is { age } .' )
除了：
    列印（'出了點問題'）

在上面的例子中，例外塊將運行，我們不知道確切的問題，為了分析問題，我們可以使用 except 的不同錯誤型別，

在下面的示例中，它將處理錯誤并告訴我們引發的錯誤型別，

try :
     name  =  input ( 'Enter your name:' )
     year_born  =  input ( 'Year youbirth :' )
     age  =  2019  -  year_born 
    print ( f'You are { name } . And your age is { age } .' )
除了 TypeError :
    列印( '發生型別錯誤' )
除了 ValueError :
    列印( '發生值錯誤' )
除外 ZeroDivisionError :
    列印（'發生零除錯誤'）

輸入您的姓名：Asabeneh
出生年份：1920
出現型別錯誤

在上面的代碼中，輸出將是TypeError，現在，讓我們添加一個額外的塊：

try :
     name  =  input ( 'Enter your name:' )
     year_born  =  input ( 'Year youbirth :' )
     age  =  2019  -  int ( year_born )
     print ( '你是{name}，你的年齡是{age}，' )
除了 TypeError :
    列印( '發生型別錯誤' )
除了 ValueError :
    列印( '發生值錯誤' )
除了 ZeroDivisionError :
    列印（“發生零除法錯誤”）
 else：
    列印（“我通常使用 try 塊運行”）
最后：
    列印（“我總是運行，”）

輸入您的姓名：Asabeneh
出生年份：1920
你是阿薩貝尼，而你的年齡是 99 歲，
我通常使用 try 塊運行
我總是跑，

它也將上面的代碼縮短如下：

try :
     name  =  input ( 'Enter your name:' )
     year_born  =  input ( 'Year youbirth :' )
     age  =  2019  -  int ( year_born )
     print ( 'You are {name}. And your age is {age}.' )
除了 例外 為 e :
    列印( e )

在 Python 中打包和解包引數

我們使用兩個運算子：

• 對于元組
  ** 用于字典

讓我們在下面舉個例子，它只需要引數，但我們有串列，我們可以解壓縮串列并更改引數，

開箱

拆箱清單

def  sum_of_five_nums ( a , b , c , d , e ):
    回傳 a  +  b  +  c  +  d  +  e

lst  = [ 1 , 2 , 3 , 4 , 5 ]
 print ( sum_of_five_nums ( lst )) # TypeError: sum_of_five_nums() 缺少 4 個必需的位置引數：'b'、'c'、'd' 和 'e'

當我們運行此代碼時，它會引發錯誤，因為此函式將數字（而不是串列）作為引數，讓我們解壓/解構串列，

def  sum_of_five_nums ( a , b , c , d , e ):
    回傳 a  +  b  +  c  +  d  +  e

lst  = [ 1 , 2 , 3 , 4 , 5 ]
列印( sum_of_five_nums ( * lst ))   # 15

我們還可以在期望開始和結束的范圍內置函式中使用解包，

numbers  =  range ( 2 , 7 )   # 帶有單獨引數的普通呼叫
print ( list ( numbers )) # [2, 3, 4, 5, 6] 
args  = [ 2 , 7 ]
 numbers  =  range ( * args )   # call with從串列中解壓出來的引數
print ( numbers )       # [2, 3, 4, 5,6]

串列或元組也可以這樣解包：

country  = [ '芬蘭' , '瑞典' , '挪威' , '丹麥' , '冰島' ]
 fin , sw , nor , * rest  =  countries 
print ( fin , sw , nor , rest )    # 芬蘭 瑞典 挪威 ['丹麥', '冰島'] 
numbers  = [ 1 , 2 , 3 , 4 , 5 , 6 , 7]
 one , * middle , last  =  numbers 
print ( one , middle , last )       # 1 [2, 3, 4, 5, 6] 7

解壓字典

def  unpacking_person_info ( name , country , city , age ):
    回傳 f' { name }住在{ country } , { city }，他是{年齡}歲，
dct  = { 'name' : 'Asabeneh' , 'country' : 'Finland' , 'city' : 'Helsinki' , 'age' : 250 }
列印(unpacking_person_info（** DCT））＃Asabeneh住在芬蘭赫爾辛基，他今年 250 歲，

包裝

有時我們永遠不知道有多少引數需要傳遞給 python 函式，我們可以使用打包方法讓我們的函式接受無限數量或任意數量的引數，

裝箱單

def  sum_all ( * args ):
     s  =  0 
    for  i  in  args :
         s  +=  i 
    return  s 
print ( sum_all ( 1 , 2 , 3 ))              # 6 
print ( sum_all ( 1 , 2 , 3 , 4 , 5 , 6 , 7 )) # 28
打包字典
DEF  packing_person_info（** kwargs）：
    ＃檢查kwargs的型別，它是一個字典型別
    ＃列印（型別（kwargs）） 
	＃列印字典項
    為 鍵 在 kwargs：
        列印（“{鍵} = {kwargs [鍵]} " )
    回傳 kwargs

列印（packing_person_info（名稱= “Asabeneh”，
      國家= “芬蘭”，城市= “赫爾辛基”，年齡= 250））

名稱 = Asabeneh
國家 = 芬蘭
城市 = 赫爾辛基
年齡 = 250
{ “姓名”：“阿薩本尼”，“國家”：“芬蘭”，“城市”：“赫爾辛基”，“年齡”：250}

在 Python 中傳播

就像在 JavaScript 中一樣，在 Python 中傳播是可能的，讓我們在下面的例子中檢查一下：

lst_one  = [ 1 , 2 , 3 ]
 lst_two  = [ 4 , 5 , 6 , 7 ]
 lst  = [ 0 , * list_one , * list_two ]
 print ( lst )           # [0, 1, 2, 3, 4, 5, 6 , 7] 
country_lst_one  = [ '芬蘭' , '瑞典' , '挪威' ]
 country_lst_two  = [ '丹麥' ,'冰島' ]
 nordic_countries  = [ * country_lst_one , * country_lst_two ]
 print ( nordic_countries )   # ['芬蘭', '瑞典', '挪威', '丹麥', '冰島']

列舉

如果我們對串列的索引感興趣，我們使用enumerate內置函式來獲取串列中每個專案的索引，

為 索引，專案 在 列舉（[ 20，30，40 ]）：
    列印（指數，產品）

對于 index，i 在 enumerate ( countries ) 中：
     print ( 'hi' )
     if  i  ==  'Finland' :
         print ( 'The country {i} has been found at index {index}' )

國家芬蘭被發現在指數 1，

壓縮

有時我們想在回圈時組合串列，請參閱下面的示例：

水果 = [ '香蕉'，'橙色'，'芒果'，'檸檬'，'酸橙' ]                    
蔬菜 = [ '番茄'，'馬鈴薯'，'卷心菜'，'洋蔥'，'胡蘿卜' ]
水果和蔬菜 = []
對于 ?F，v 在 拉鏈（水果，蔬菜）：
     fruits_and_veges，追加（{ '水果'：'蔬菜' : v })

列印（水果和蔬菜）

[{ '水果'：'香蕉'，'蔬菜'：'番茄' }，{ '水果'：'橙色'，'蔬菜'：'土豆' }，{ '水果'：'芒果'，'蔬菜'：'卷心菜' }，{ '水果'：'檸檬'，'蔬菜'：'洋蔥' }，{ '水果'：'酸橙'，'蔬菜'：'胡蘿卜' }]

第 18 天 - 正則運算式

常用表達

正則運算式或 RegEx 是一種特殊的文本字串，有助于在資料中查找模式，RegEx 可用于檢查某些模式是否存在于不同的資料型別中，要首先在 python 中使用 RegEx，我們應該匯入名為re的 RegEx 模塊，

該重模塊

匯入模塊后，我們可以使用它來檢測或查找模式，

進口 重新

re模塊中的方法

為了找到一個模式，我們使用不同的re字符集集，允許在字串中搜索匹配項，

1. re.match()：僅在字串第一行的開頭搜索，如果找到則回傳匹配的物件，否則回傳 None，
2. re.search：如果字串中的任何地方都有匹配物件，包括多行字串，則回傳一個匹配物件，
3. re.findall：回傳包含所有匹配項的串列
4. re.split：獲取一個字串，在匹配點處將其拆分，回傳一個串列
5. re.sub：替換字串中的一個或多個匹配項

比賽

# 語法
重新，匹配（子串，串，再，我）
 ＃子是一個字串或圖案，字串是我們要尋找的圖案文字，如re.I是忽略大小寫

進口 重新

txt  =  '我喜歡教 python 和 javaScript' 
# 它回傳一個具有跨度的物件，并且匹配
match  =  re，match ( '我愛教' , txt , re . I )
 print ( match )   # <re.Match object; span=(0, 15), match='I love to Teaching'> 
# 我們可以使用 span 
span  =  match將匹配的開始和結束位置作為元組獲取，span ()
 print ( span )      # (0, 15) 
# 讓我們從 span 中找到開始和停止位置
start , end  =  span 
print ( start , end )   # 0, 15 
substring  =  txt [ start : end ]
 print ( substring )        # 我喜歡教書

從上面的示例中可以看出，我們正在尋找的模式（或我們正在尋找的子字串）是I love to Teaching，僅當文本以模式開頭時，match 函式才回傳一個物件，

進口 重新

txt  =  '我喜歡教 python 和 javaScript' 
match  =  re，match ( '我喜歡教' , txt , re . I )
 print ( match )   # None
字串不與I like to Teaching串在一起，因此沒有匹配，匹配方法回傳 None，

搜索

# 語法
re . match ( substring , string , re . I )
 # substring 是一個模式，string 是我們要查找的模式的文本，re.I 是 case ignore flag

進口 重新

txt  =  '''Python 是人類有史以來最美麗的語言，
我推薦 Python 作為第一門編程語言'''

# 它回傳一個具有 span 和 match 
match  =  re的物件，search ( 'first' , txt , re . I )
 print ( match )   # <re.Match object; span=(100, 105), match='first'> 
# 我們可以使用 span 
span  =  match將匹配的開始和結束位置作為元組獲取，span ()
 print ( span )      # (100, 105) 
# 讓我們從 span 
start , end  =  span 
print找到開始和停止位置( start , end )   # 100 105 
substring  =  txt [ start : end ]
 print ( substring )        # first

如您所見，搜索比匹配好得多，因為它可以在整個文本中查找模式，搜索回傳具有找到的第一個匹配項的匹配物件，否則回傳None，一個更好的re函式是findall，此函式檢查整個字串中的模式并將所有匹配項作為串列回傳，

使用findall搜索所有匹配項
findall()將所有匹配項作為串列回傳

txt  =  '''Python 是人類有史以來最美麗的語言，
我推薦 Python 作為第一門編程語言'''

# 它回傳一個串列
matches  =  re . findall ( 'language' , txt , re . I )
 print ( matches )   # ['language', 'language']

如您所見，在字串中找到了兩次language一詞，讓我們多練習一些，現在我們將在字串中查找 Python 和 python 單詞：

txt  =  '''Python 是人類有史以來最美麗的語言，
我推薦 Python 作為第一門編程語言'''

# 它回傳串列
匹配 =  re . findall ( 'python' , txt , re . I )
 print ( matches )   # ['Python', 'python']

由于我們使用re.I，因此包括小寫和大寫字母，如果我們沒有 re.I 標志，那么我們將不得不以不同的方式撰寫我們的模式，讓我們來看看：

txt  =  '''Python 是人類有史以來最美麗的語言，
我推薦 Python 作為第一門編程語言'''

匹配 = 重新，findall ( 'Python|python' , txt )
列印(匹配)   # ['Python', 'python']

#
匹配 =  re . findall ( '[Pp]ython' , txt )
列印(匹配)   # ['Python', 'python']

替換子串

txt  =  '''Python 是人類有史以來最美麗的語言，
我推薦 Python 作為第一門編程語言'''

match_replaced  =  re，sub ( 'Python|python' , 'JavaScript' , txt , re . I )
 print ( match_replaced )   # JavaScript 是人類有史以來最美麗的語言，
# 或
match_replaced  =  re . sub ( '[Pp]ython' , 'JavaScript' , txt , re . I )
列印( match_replaced )  # JavaScript 是人類有史以來最美麗的語言，

讓我們再添加一個例子，除非我們洗掉 % 符號，否則以下字串真的很難閱讀，用空字串替換 % 將清除文本，

txt  =  '''%I a%m te%%a%%che%r% a%n%d %% I l%o%ve te%ach%ing，
T%he%re i%sn%o%th%ing as r%ewarding a%se%duc%at%i%ng a%n%de%m%p%ow%er%ing p%e%o%請，
我找到 te%a%ching m%ore i%n%t%er%%es%ting t%h%an 任何其他 %jobs，
D%o%es 這%sm%ot%iv%a%te %y%o%u 到b%eat%e%a%cher？'''

匹配 = 重新，sub ( '%' , '' , txt )
列印（匹配）

我是老師，我喜歡教書，
沒有什么比教育和賦予人們權力更有價值的了，
我發現教學比任何其他作業都有趣，這會激勵你成為一名教師嗎？

使用 RegEx Split 拆分文本

txt  =  '''我是老師，我喜歡教學，
沒有什么比教育和賦予人們權力更有價值的了，
我發現教學比任何其他作業都有趣，
這會激勵你成為一名教師嗎？''' 
print ( re . split ( ' \n ' , txt )) # splitting using \n - end of line symbol

[ '我是老師，我喜歡教學，' , '沒有什么比教育和賦予人們權力更有意義的了，' , '我發現教學比任何其他作業都有趣，' , '這會激勵你成為一名教師嗎？' ]

撰寫正則運算式模式

要宣告一個字串變數，我們使用單引號或雙引號，宣告 RegEx 變數r’’，下面的模式只用小寫字母標識蘋果，為了使它不區分大小寫，我們應該重寫我們的模式，或者我們應該添加一個標志，

進口 重新

regex_pattern  =  r'apple' 
txt  =  '蘋果和香蕉是水果，一句陳詞濫調說，醫生的一天一個蘋果已經被一天一個香蕉所取代，醫生遠離我，'
匹配 =  re，findall ( regex_pattern , txt )
列印(匹配)   # ['apple']

# 為了不區分大小寫添加標志 ' 
matches  =  re . findall ( regex_pattern , txt , re . I )
 print ( matches )   # ['Apple', 'apple'] 
# 或者我們可以使用一組字符方法
regex_pattern  =  r'[Aa]pple'   # 這意味著第一個字母可以是蘋果或蘋果
匹配 = 重，findall ( regex_pattern , txt )
 print ( matches )   # ['Apple', 'apple']

1. []：一組字符

[ac] 表示 a 或 b 或 c
[az] 表示從 a 到 z 的任何字母
[AZ] 表示從 A 到 Z 的任何字符
[0-3] 表示 0 或 1 或 2 或 3
[0-9] 表示 0 到 9 之間的任意數字
[A-Za-z0-9] 任何單個字符，即 a 到 z、A 到 Z 或 0 到 9

2. \：用于轉義特殊字符

\d 表示：匹配字串包含數字的地方（0-9 的數字）
\D 表示：匹配不包含數字的字串

3. . : 除換行符以外的任何字符(\n)

4. ^：以

r’^substring’ eg r’^love’, 一個以單詞 love 開頭的句子
r’[^abc] 表示不是 a，不是 b，不是 c，

5. $：以

r’substring ′ 例 如 r ′ l o v e ' 例如 r'love ′例如r′love’，以單詞 love 結尾的句子

6. *：零次或多次

r’[a]*’ 表示一個可選的或者它可以出現多次，

7. +：一次或多次

r’[a]+’ 表示至少一次（或多次）

8. ?: 零次或一次

r’[a]?’ 表示零次或一次

9. {3}：正好 3 個字符

10. {3,}：至少 3 個字符

11. {3,8}：3 到 8 個字符

12. |: 要么

r’apple|banana’ 表示蘋果或香蕉

13. ()：捕獲和分組

讓我們用例子來闡明上面的元字符

方括號

讓我們使用方括號來包含小寫和大寫

regex_pattern  =  r'[Aa]pple'  # 這個方括號表示 A 或 a 
txt  =  '蘋果和香蕉是水果，一句陳詞濫調說，醫生的一天一個蘋果已經被一天一個香蕉所取代，讓醫生遠離我，
匹配 = 重新，findall ( regex_pattern , txt )
 print ( matches )   # ['Apple', 'apple']

如果我們要尋找香蕉，我們寫的模式如下：

regex_pattern  =  r'[Aa]pple|[Bb]anana'  # 這個方括號表示 A 或 a 
txt  =  '蘋果和香蕉是水果，一句陳詞濫調說，醫生的一天一個蘋果已經被一天一個香蕉所取代，讓醫生遠離我，
匹配 = 重新，findall ( regex_pattern , txt )
 print ( matches )   # ['Apple', 'banana', 'apple', 'banana']

使用方括號和或運算子，我們設法提取Apple、apple、Banana 和banana，

正則運算式中的轉義字符（\）

regex_pattern  =  r'\d'   # d 是一個特殊字符，表示digits 
txt  =  '此正則運算式示例于2019年12月6日制作并于2021年7月8日修訂' 
matches  =  re，findall ( regex_pattern , txt )
 print ( matches )   # ['6', '2', '0', '1', '9', '8', '2', '0', '2', '1 ']，這不是我們想要的

一次或多次(+)

regex_pattern  =  r'\d+'   # d 是一個特殊字符，表示數字，+ 表示一次或多次
txt  =  '此正則運算式示例于 2019 年 12 月 6 日制作，2021 年 7 月 8 日修訂' 
matches  =  re . findall ( regex_pattern , txt )
 print ( matches )   # ['6', '2019', '8', '2021'] - 現在更好了！

時期（，）

regex_pattern  =  r'[a].'   # 這個方括號表示 a 和 ，表示除換行符
txt  =  '''Apple 和香蕉是水果'''
匹配 =  re之外的任何字符，findall ( regex_pattern , txt )
 print ( matches )   # ['an', 'an', 'an', 'a', 'ar']

regex_pattern  =  r'[a].+'   # . 任何字符，+ 任何字符一次或多次
匹配 =  re，findall ( regex_pattern , txt )
 print ( matches )   # ['and 香蕉是水果']

零次或多次(*)

零次或多次，該模式可能不會出現，也可能會出現多次，

regex_pattern  =  r'[a].*'   # . 任何字符，* 任何字符零次或多次
txt  =  '''Apple 和香蕉是水果'''
匹配 =  re，findall ( regex_pattern , txt )
 print ( matches )   # ['and 香蕉是水果']

零次或一次（？）

零次或一次，該模式可能不會出現，也可能出現一次，

txt  =  '''我不確定是否有約定如何寫電子郵件這個詞，
有些人把它寫成電子郵件，其他人可能把它寫成電子郵件或電子郵件，''' 
regex_pattern  =  r'[Ee]-?mail'   # ? 在這里意味著 '-' 是可選的
matches  =  re，findall ( regex_pattern , txt )
 print ( matches )   # ['e-mail', 'email', 'Email', 'E-mail']

正則運算式中的量詞

我們可以使用大括號指定我們在文本中查找的子字串的長度，讓我們想象一下，我們對長度為 4 個字符的子字串感興趣：

txt  =  '此正則運算式示例于 2019 年 12 月 6 日制作并于 2021 年 7 月 8 日修訂' 
regex_pattern  =  r'\d{4}'   # 正好四次
匹配 =  re . findall ( regex_pattern , txt )
列印(匹配)   # ['2019', '2021']

TXT  =  '這個正則運算式示例被做了2019年12月6，并修改了有關2021年7月8' 
regex_pattern  =  R '\ d {1,4}'    ＃1至4
匹配 = 重，findall ( regex_pattern , txt )
 print ( matches )   # ['6', '2019', '8', '2021']

購物車 ^

• 以，，開始

txt  =  '此正則運算式示例于 2019 年 12 月 6 日制作并于 2021 年 7 月 8 日修訂' 
regex_pattern  =  r'^This'   # ^ 表示以
matches  =  re開頭，findall ( regex_pattern , txt )
列印(匹配)   # ['This']

• 否定

txt  =  '此正則運算式示例制作于2019年12月6日，修改于2021年7月8日' 
regex_pattern  =  r'[^A-Za-z ]+'   # ^ in set 字符表示否定，不是A到Z，不是a 到 z，沒有空格
匹配 =  re，findall ( regex_pattern , txt )
 print ( matches )   # ['6,', '2019', '8', '2021']

第 19 天 - 檔案處理

到目前為止，我們已經看到了不同的 Python 資料型別，我們通常以不同的檔案格式存盤我們的資料，除了處理檔案之外，我們還將在本節中看到不同的檔案格式（.txt、.json、.xml、.csv、.tsv、.excel），首先，讓我們熟悉處理具有常見檔案格式（.txt）的檔案，

檔案處理是編程的重要組成部分，它允許我們創建、讀取、更新和洗掉檔案，在 Python 中，我們使用open()內置函式來處理資料，

# 語法
open ( 'filename' , mode ) # mode(r, a, w, x, t,b) 可以是讀、寫、更新

1. “r” - 讀取 - 默認值，打開一個檔案進行讀取，如果檔案不存在則回傳錯誤
2. “a” - Append - 打開一個檔案進行追加，如果檔案不存在則創建該檔案
3. “w” - 寫入 - 打開一個檔案進行寫入，如果檔案不存在則創建該檔案
4. “x” - Create - 創建指定的檔案，如果檔案存在則回傳錯誤
5. “t” - 文本 - 默認值，文本模式
6. “b” - 二進制 - 二進制模式（例如影像）

打開檔案進行閱讀

打開的默認模式是讀取，因此我們不必指定 ‘r’ 或 ‘rt’，我在檔案目錄中創建并保存了一個名為 reading_file_example.txt 的檔案，讓我們看看它是如何完成的：

f  =  open ( './files/reading_file_example.txt' )
 print ( f ) # <_io.TextIOWrapper name='./files/reading_file_example.txt' mode='r' encoding='UTF-8'>

正如你在上面的例子中看到的，我列印了打開的檔案，它提供了一些關于它的資訊，打開的檔案有不同的讀取方法：read()、readline、readlines，必須使用close()方法關閉打開的檔案，

• read()：將整個文本作為字串讀取，如果我們想限制我們想要讀取的字符數，我們可以通過將 int
  值傳遞給read(number)方法來限制它，

f  = 打開( './files/reading_file_example.txt' )
 txt  =  f，讀取()
列印(型別( txt ))
列印( txt )
 f，關閉()

#輸出
<類' str ' >
這是一個顯示如何打開檔案和讀取的示例，
這是正文的第二行，

我們不列印所有文本，而是列印文本檔案的前 10 個字符，

f  = 打開( './files/reading_file_example.txt' )
 txt  =  f，讀取（10）
列印（型別（txt））
列印（txt）
 f，關閉()

# output 
< class ' str ' >
這是一個

• readline() : 只讀取第一行

f  = 打開( './files/reading_file_example.txt' )
 line  =  f，readline ()
列印（型別（行））
列印（行）
 f，關閉()

# output 
< class ' str ' >
這是一個顯示如何打開檔案和讀取的示例，

• readlines()：逐行讀取所有文本并回傳行串列

f  = 打開( './files/reading_file_example.txt' )
行 =  f，readlines ()
列印（型別（行））
列印（行）
 f，關閉()

# output 
< class ' list ' > 
[ '這是一個顯示如何打開檔案和讀取的示例，\n ' , '這是文本的第二行，' ]

另一種將所有行作為串列獲取的方法是使用splitlines()：

f  = 打開( './files/reading_file_example.txt' )
行 =  f，讀（），splitlines ()
列印（型別（行））
列印（行）
 f，關閉()

# output 
< class ' list ' > 
[ '這是一個顯示如何打開檔案和讀取的示例，' , '這是正文的第二行，' ]

打開檔案后，我們應該關閉它，很容易忘記關閉它們，有一種使用with打開檔案的新方法- 自行關閉檔案，讓我們用with方法重寫前面的例子：

使用 open ( './files/reading_file_example.txt' )作為 f：
     lines  =  f，讀（），splitlines ()
    列印（型別（行））
    列印（行）

# output 
< class ' list ' > 
[ '這是一個顯示如何打開檔案和讀取的示例，' , '這是正文的第二行，' ]

打開檔案進行寫入和更新

要寫入現有檔案，我們必須向open()函式添加一個模式作為引數：

1. “a” - 追加 - 將追加到檔案的末尾，如果檔案沒有，它會創建一個新檔案，
2. “w” - 寫入 - 將覆寫任何現有內容，如果它創建的檔案不存在，

讓我們將一些文本附加到我們一直在閱讀的檔案中：

使用 open ( './files/reading_file_example.txt' , 'a' )作為 f :
     f，write ( '此文本必須附加在最后' )

如果檔案不存在，下面的方法會創建一個新檔案：

使用 open ( './files/writing_file_example.txt' , 'w' )作為 f :
     f，write ( '此文本將寫入新創建的檔案' )

洗掉檔案

我們在上一節中已經看到，如何使用os模塊創建和洗掉目錄，現在再次，如果我們想洗掉一個檔案，我們使用os模塊，

匯入 作業系統
os，洗掉（'./files/example.txt'）

如果檔案不存在，remove 方法將引發錯誤，因此最好使用這樣的條件：

匯入 os
如果 os，路徑，存在( './files/example.txt' ):
     os，remove ( './files/example.txt' )
 else :
     print ( '檔案不存在' )

檔案型別

帶有 txt 擴展名的檔案

帶有txt擴展名的檔案是一種非常常見的資料形式，我們在上一節中已經介紹過，讓我們轉到 JSON 檔案

帶有 json 擴展名的檔案

JSON 代表 JavaScript 物件表示法，實際上，它是一個字串化的 JavaScript 物件或 Python 字典，

例子：

# 字典
person_dct = {
     "name" : "Asabeneh" ,
     "country" : "Finland" ,
     "city" : "Helsinki" ,
     "skills" :[ "JavaScrip" , "React" , "Python" ]
}
# JSON: 一個字串形式的字典
person_json  =  "{'name': 'Asabeneh', 'country': 'Finland', 'city': 'Helsinki', 'skills': ['JavaScrip', 'React', ' Python']}”

# 我們使用三個引號并使其多行以使其更具可讀性
person_json  =  '''{ 
    "name":"Asabeneh", 
    "country":"Finland", 
    "city":"Helsinki", 
    "skills":[ "JavaScrip", "React","Python"] 
}'''

將 JSON 更改為字典

要將 JSON 更改為字典，首先我們匯入 json 模塊，然后使用load方法，

import  json 
# JSON 
person_json  =  '''{ 
    "name": "Asabeneh", 
    "country": "Finland", 
    "city": "Helsinki", 
    "skills": ["JavaScrip", "React", "Python" ] 
}''' 
# 讓我們將 JSON 更改為字典
person_dct  =  json . 加載（person_json）
列印（型別（person_dct））
列印（person_dct）
列印（person_dct [ 'name' ]）

# output 
< class ' dict ' > 
{ ' name ' : ' Asabeneh ' , ' country ' : ' Finland ' , ' city ' : ' Helsinki ' , ' skills ' :[ ' JavaScrip ' , ' React ' , ' Python ' ] }
阿薩貝內

將字典更改為 JSON

要將字典更改為 JSON，我們使用json 模塊中的dumps方法，

import  json 
# python 字典
person  = {
     "name" : "Asabeneh" ,
     "country" : "Finland" ,
     "city" : "Helsinki" ,
     "skills" : [ "JavaScrip" , "React" , "Python" ]
}
# 讓我們把它轉換成 json 
person_json  =  json . dumps ( person , indent = 4 ) # indent 可以是 2, 4, 8. 美化json 
print ( type ( person_json ))
 print ( person_json )

# output 
#列印時沒有引號，但實際上是字串
# JSON 沒有型別，它是字串型別，
<類' str ' >
{
    “名稱”： “ Asabeneh ”，
     “國家”： “芬蘭”，
     “城市”： “赫爾辛基”，
     “技能”：[
         “ JavaScrip ”，
         “ React ”，
         “ Python ”
    ]
}

保存為 JSON 檔案

我們也可以將資料保存為 json 檔案，讓我們使用以下步驟將其保存為 json 檔案，寫一個json檔案，我們使用json.dump()方法，它可以帶字典、輸出檔案、ensure_ascii和縮進，

import  json 
# python 字典
person  = {
     "name" : "Asabeneh" ,
     "country" : "Finland" ,
     "city" : "Helsinki" ,
     "skills" : [ "JavaScrip" , "React" , "Python" ]
}
使用 open ( './files/json_example.json' , 'w' , encoding = 'utf-8' )作為 f :
     json，轉儲（人，f，ensure_ascii = False，縮進= 4）

在上面的代碼中，我們使用了編碼和縮進，縮進使 json 檔案易于閱讀，

帶有 csv 擴展名的檔案

CSV 代表逗號分隔值，CSV 是一種簡單的檔案格式，用于存盤表格資料，例如電子表格或資料庫，CSV 是資料科學中非常常見的資料格式，

例子：

"name","country","city","skills"
"Asabeneh","Finland","Helsinki","JavaScript"

例子：

 使用open ( './files/csv_example.csv' )匯入csv
作為f :
     csv_reader = csv，讀取器（?F，分隔符= '' ）＃瓦特使用，讀者方法來讀取CSV LINE_COUNT = 0為行中csv_reader：
        如果LINE_COUNT == 0：
            列印（f'Column名稱是：{ “” ，加入（行）}    
      
          ' )
             line_count  +=  1 
        else :
             print (
                 f' \t { row [ 0 ] }是一位老師，他住在{ row [ 1 ] } , { row [ 2 ] } .' )
             line_count  +=  1 
    print ( f '行數：   { line_count } ' )

#輸出：
列名是：姓名、國家、城市、技能
        Asabeneh 是一名教師，他住在芬蘭赫爾辛基，
行數：2

帶有 xlsx 擴展名的檔案

要讀取 excel 檔案，我們需要安裝xlrd包，在我們介紹了使用 pip 安裝軟體包之后，我們將介紹這一點，

匯入 xlrd 
excel_book  =  xlrd，open_workbook（”樣品，XLS）
列印（excel_book，nsheets）
列印（excel_book，sheet_names）

帶有 xml 擴展名的檔案

XML 是另一種看起來像 HTML 的結構化資料格式，在 XML 中，標簽不是預定義的，第一行是一個 XML 宣告，person 標簽是 XML 的根，該人具有性別屬性， 示例：XML

<? xml版本= " 1.0 " ?>
<人 性別= “女性” >
  < name >Asabeneh</ name >
  <國家>芬蘭</國家>
  < city >赫爾辛基</ city >
  <技能>
    <技能>JavaScrip</技能>
    <技能>反應</技能>
    <技能>Python</技能>
  </技能>
</人>

有關如何讀取 XML 檔案

匯入 xml，etree，ElementTree 作為 ET
樹 =  ET，決議( './files/xml_example.xml' )
 root  =  tree，getroot（）
列印（'根標簽：'，根，標簽）
的列印（'屬性：'，根，ATTRIB）
為 孩子 在 根：
    列印（'欄位：'，孩子，標簽)

#輸出
根標簽：人
屬性：{ '性別'：'男性' }
欄位：名稱
領域：國家
領域：城市
領域：技能

第 20 天 - Python 包管理器(PIP)

什么是PIP？

PIP 代表首選安裝程式，我們使用pip來安裝不同的 Python 包，包是一個 Python 模塊，可以包含一個或多個模塊或其他包，我們可以安裝到應用程式的一個或多個模塊是一個包，在編程中，我們不必撰寫每個實用程式，而是安裝包并將它們匯入到我們的應用程式中，

安裝PIP

如果您沒有安裝 pip，讓我們現在安裝它，轉到您的終端或命令提示符并復制并粘貼以下內容：

asabeneh@Asabeneh: ~ $ pip install pip

通過寫入檢查是否安裝了 pip

pip --version

asabeneh @ Asabeneh：? $ PIP  - -版本
點子 21.1，3 來自 / usr / local / lib / python3，7 /站點-包/ pip（python  3.9 .6）

如您所見，我使用的是 pip 版本 21.1.3，如果您看到某個數字低于或高于該數字，則表示您已安裝 pip，

讓我們檢查一下 Python 社區中出于不同目的使用的一些包，只是為了讓您知道有許多軟體包可用于不同的應用程式，

使用 pip 安裝包

讓我們嘗試安裝numpy，稱為 numeric python，它是機器學習和資料科學社區中最受歡迎的軟體包之一，

NumPy 是使用 Python 進行科學計算的基礎包，其中包括：

1. 一個強大的 N 維陣列物件
2. 復雜的（廣播）功能
3. 用于集成 C/C++ 和 Fortran 代碼的工具
4. 有用的線性代數、傅立葉變換和亂數功能

asabeneh@Asabeneh: ~ $ pip install numpy

讓我們開始使用 numpy，打開你的python互動式shell，撰寫python然后匯入numpy，如下所示：

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 匯入 numpy 
>> >  numpy，版本，版本
' 1.20，1 '
 >> >  lst  = [ 1 , 2 , 3 ,4 , 5 ]
 >> >  np_arr  =  numpy，陣列( lst )
 >> >  np_arr
陣列([ 1 , 2 , 3 , 4 , 5 ])
 >> >  len ( np_arr )
 5 
>> >  np_arr  *  2
陣列([ 2 ,   4 ,   6 ,   8 , 10 ])
 >> >  np_arr  +  2
陣列([ 3 , 4 , 5 , 6 , 7 ])
 >> >

Pandas 是一個開源的、BSD 許可的庫，為 Python 編程語言提供高性能、易于使用的資料結構和資料分析工具，讓我們安裝numpy的大哥pandas：

asabeneh@Asabeneh: ~ $ pip install pandas

asabeneh @ Asabeneh：~ $ python 
Python  3.9，6（默認，2021 年6月 28 日 ，15：26：21）
[鏘 11.0 0.0（鐺- 1100.0，33.8）在 達爾文
式 的“幫助”，“著作權”，“信用” 或 “許可” 的 更多 資訊，
>> > 匯入 熊貓

本節不是關于 numpy 或 pandas，在這里我們試圖學習如何安裝包以及如何匯入它們，如果需要，我們將在其他部分討論不同的包，

讓我們匯入一個網頁瀏覽器模塊，它可以幫助我們打開任何網站，我們不需要安裝這個模塊，它已經在 Python 3 中默認安裝了，例如，如果你想隨時打開任意數量的網站，或者你想安排一些事情，可以使用這個webbrowser模塊，

import  webbrowser  # 網頁瀏覽器模塊打開網站

# url 串列：python 
url_lists  = [
     'http://www.python.org' ,
     'https://www.linkedin.com/in/asabeneh/' ,
     'https://github.com/Asabeneh' ,
     'https://twitter.com/Asabeneh' ,
]

＃打開在不同的選項卡網站上面的串列中
的 網址 在 url_lists：
    網頁瀏覽器，open_new_tab ( url )

卸載軟體包

如果您不想保留已安裝的軟體包，可以使用以下命令洗掉它們，

pip 卸載包名

包裹清單

查看我們機器上已安裝的軟體包，我們可以使用 pip 后跟串列，

點子串列

顯示包

顯示有關包的資訊

pip 顯示包名

asabeneh@Asabeneh: ~ $ pip show pandas
名稱：熊貓
版本：1.2.3
總結：強大的資料結構，用于資料分析、時間序列和統計
主頁：http://pandas.pydata.org
作者：無
作者郵箱：無
許可證：BSD
位置：/usr/local/lib/python3.7/site-packages
需要：python-dateutil、pytz、numpy
必填項：

如果我們想要更多細節，只需添加 --verbose

asabeneh@Asabeneh: ~ $ pip show --verbose pandas
名稱：熊貓
版本：1.2.3
總結：強大的資料結構，用于資料分析、時間序列和統計
主頁：http://pandas.pydata.org
作者：無
作者郵箱：無
許可證：BSD
位置：/usr/local/lib/python3.7/site-packages
需要：numpy、pytz、python-dateutil
必填項：
元資料版本：2.1
安裝程式：pip
分類器：
  開發狀態 :: 5 - 量產/穩定
  環境 :: 控制臺
  作業系統 :: 獨立于作業系統
  目標受眾 :: 科學/研究
  編程語言 :: Python
  編程語言 :: Python :: 3
  編程語言 :: Python :: 3.5
  編程語言 :: Python :: 3.6
  編程語言 :: Python :: 3.7
  編程語言 :: Python :: 3.8
  編程語言 :: Cython
  主題 :: 科學/工程
入口點：
  [pandas_plotting_backends]
  matplotlib = pandas:plotting._matplotlib

畫中畫凍結

生成已安裝的 Python 包及其版本，輸出適合在需求檔案中使用，requirements.txt 檔案是一個檔案，它應該包含 Python 專案中所有已安裝的 Python 包，

asabeneh@Asabeneh: ~ $ pip freeze
檔案工具==0.11
Jinja2==2.7.2
標記安全==0.19
Pygments==1.6
獅身人面像==1.2.2

pip freeze 為我們提供了使用、安裝的軟體包及其版本，我們將它與 requirements.txt 檔案一起用于部署，

從 URL 讀取

到目前為止，您已經熟悉如何讀取或寫入位于本地機器上的檔案，有時，我們想使用 url 或 API 從網站讀取，API 代表應用程式介面，它是一種主要作為 json 資料在服務器之間交換結構化資料的方法，要打開網路連接，我們需要一個名為requests的包- 它允許打開網路連接并實作 CRUD（創建、讀取、更新和洗掉）操作，在本節中，我們將只介紹讀取礦石獲取 CRUD 的一部分，

讓我們安裝請求：

asabeneh @ Asabeneh : ~ $ pip  install  requests

我們將在requests模塊中看到get、status_code、headers、text和json方法：

1. get()：打開網路并從 url 獲取資料 - 它回傳一個回應物件
2. status_code : 獲取資料后，我們可以檢查操作的狀態（成功、錯誤等）
3. headers : 檢查標題型別
4. text : 從獲取的回應物件中提取文本
5. json :提取json資料讓我們從這個網站讀取一個txt檔案，https://www.w3.org/TR/PNG/iso_8859-1.txt，

import  requests  # 匯入請求模塊

url  =  'https://www.w3.org/TR/PNG/iso_8859-1.txt'  # 來自網站的文本

回應 = 請求，get ( url ) # 打開網路并獲取資料
print ( response )
 print ( response . status_code ) # status code, success:200 
print ( response . headers )      # headers 資訊
print ( response . text ) # 給出來自的所有文本這一頁

<回應 [200] >
200
{ “日期”：“格林威治標準時間 2019 年 12 月 8 日 18:00:31 ”，“最后修改時間”：“格林威治標準時間 2003 年 11 月 7 日星期五 05:51:11 ”，“ etag ”：“ 17e9-3cb15080808087 -gzip" ' , '接受范圍' : '位元組' , '快取控制' : ' max-age=31536000 ' , '過期' : '2020 年 12 月 7 日星期一 18:00:31 GMT包括子域；預載'， '內容安全策略'： '升級不安全請求' }

• 讓我們從 API 中讀取，API 代表應用程式介面，它是一種在服務器之間交換結構資料的手段，主要是 json 資料，API
  示例：https : //restcountries.eu/rest/v2/all，讓我們使用requests模塊閱讀這個 API ，

匯入 請求
url  =  'https://restcountries.eu/rest/v2/all'   # 國家 API
回應 = 請求，get ( url )   # 打開網路并獲取資料
print ( response ) # response 物件
print ( response . status_code )   # status code, success:200 
countries  =  response . json ()
列印(國家[: 1 ])  # 我們只對第一個國家進行切片，去掉切片可以看到所有國家

<回應 [200] >
200
[{ ' alpha2Code '：' AF '，
   ' alpha3Code '：' AFG '，
   ' altSpellings '：[ ' AF '，'阿富汗' ]，
   '區域'：652230.0，
   '邊界'：[ ' IRN '，' PAK ' , ' TKM ' , ' UZB ', 'TJK '，' CHN ' ]，
   ' callingCodes '：[ ' 93 ' ]，
   '資本'：'喀布爾'，
   ' cioc '：' AFG '，
   '貨幣'：[{ '代碼'：' AFN '，'姓名' : '阿富汗阿富汗尼' , '符號'：' ? ' }]，
   '區域居民稱謂詞'：'阿富汗'，
   '標志'：' https://restcountries.eu/data/afg.svg '，
   '基尼'：27.8，
   '語言'：[{ ' iso639_1 '：“ ps ”，
                  “ iso639_2 ”：“膿液”，
                  “名稱”：'普什圖語' ' nativeName '：' ???? “ }，
                { ' iso639_1 '：' uz '，
                  ' iso639_2 '：' uzb '，
                  ' name '：' Uzbek '，
                  ' nativeName '：' O?zbek ' }，
                { ' iso639_1 '：' TK '，
                  ' iso639_2 '：'三輪'，
                  '名稱'：'土庫曼'，
                  ' nativeName '：'土庫曼' }]，
   '經緯度'：[33.0，65.0]，
   '名稱'：'阿富汗' ,
   '本地名稱'：' ????????? '，
   ' numericCode '： ' 004 '，
   '人口'：27657145，
   '地區'： '亞洲'，
   ' regionalBlocs '：[{ '首字母縮略詞'： ' SAARC名稱'南亞區域協會'，
                      '南亞區域協會'：合作' ,
                      'otherAcronyms “：[]，
                      ' otherNames '：[]}]，
   ' subregion '：'南亞'，
   '時區'：[ ' UTC+04:30 ' ]，
   ' topLevelDomain '：[ '. af ' ]，
   ' translations '：{ ' br '：' Afeganist?o '，
                    ' de '：'阿富汗'，
                    ' ES '：'阿富汗'，
                    ' FA '：' ????????? '，
                    ' FR '：'阿富汗'，
                    '小時'：'阿富汗'，
                    '它'：'阿富汗'，
                    ' JA '：'アフガニスタン'，
                    ' nl '：'阿富汗'，
                    ' pt '：' Afeganist?o ' }}]

我們使用回應物件中的json()方法，如果我們正在獲取 JSON 資料，對于 txt、html、xml 等檔案格式，我們可以使用text，

創建包

我們根據一些標準將大量檔案組織在不同檔案夾和子檔案夾中，以便我們可以輕松查找和管理它們，如您所知，一個模塊可以包含多個物件，例如類、函式等，一個包可以包含一個或多個相關模塊，一個包實際上是一個包含一個或多個模塊檔案的檔案夾，讓我們使用以下步驟創建一個名為 mypackage 的包：

在 30DaysOfPython 檔案夾中創建一個名為 mypacakge 的新檔案夾在 mypackage 檔案夾中創建一個空的init .py 檔案，使用以下代碼創建模塊 algorithm.py 和 greet.py：

# mypackage/arithmetics.py 
#arithmetics.py 
def  add_numbers ( * args ):
     total  =  0 
    for  num  in  args :
         total  +=  num 
    return  total


def 減法( a , b ):
    回傳( a  -  b )


def  multiple ( a , b ):
    回傳 a  *  b


def 除法( a , b ):
    回傳 a  /  b


def 余數( a , b ):
    回傳 a  %  b


def  power ( a , b ):
    回傳 a  **  b

# mypackage/greet.py 
# greet.py 
def  greet_person ( firstname , lastname ):
     return  f' { firstname }  { lastname }，歡迎來到 30DaysOfPython Challenge！

包的檔案夾結構應如下所示：

─ 我的包裹
    ├── __init__.py
    ├──算術.py
    └── 問候.py

現在讓我們打開 python 互動式 shell 并嘗試我們創建的包：

asabeneh@Asabeneh: ~ /Desktop/30DaysOfPython$ python
Python 3.9.6（默認，2021 年 6 月 28 日，15:26:21）
[Clang 11.0.0 (clang-1100.0.33.8)] 在達爾文
輸入“ help ”、“ copyright ”、“ credits ”或“ license ” 以獲取更多資訊，
>>> from mypackage 匯入演算法
>>>算術.add_numbers(1, 2, 3, 5)
11
>>>算術.減法(5, 3)
2
>>>算術.multiple(5, 3)
15
>>>算術.除法(5, 3)
1.6666666666666667
>>>算術.remainder(5, 3)
2
>>> 算術.power(5, 3)
125
>>> from mypackage 匯入問候
>>> greet.greet_person( ' Asabeneh ' , ' Yetayeh ' )
 ' Asabeneh Yetayeh，歡迎參加 30DaysOfPython 挑戰賽！' 
>>>

如您所見，我們的軟體包運行良好，包檔案夾包含一個名為init .py的特殊檔案- 它存盤包的內容，如果我們將init .py 放在包檔案夾中，python start 會將其識別為包，在初始化指定從模塊的資源匯入到其他Python檔案的.py自曝，匯入包時，空的init .py 檔案使所有函式都可用，該INIT的.py是必不可少的檔案夾以通過Python作為一個包被識別，

關于包的更多資訊

1. 資料庫

SQLAlchemy 或 SQLObject - 面向物件訪問多個不同的資料庫系統
pip 安裝 SQLAlchemy

2. Web開發

Django - 高級 Web 框架，
pip 安裝 django

Flask - 基于 Werkzeug、Jinja 2 的 Python 微框架，（它是 BSD 許可的）
pip 安裝燒瓶

3. HTML決議器

Beautiful Soup - 專為快速周轉專案（如螢屏抓取）而設計的 HTML/XML 決議器，將接受不良標記，
pip 安裝 beautifulsoup4

PyQuery - 在 Python 中實作 jQuery；顯然比 BeautifulSoup 快，

4. XML處理

ElementTree - Element 型別是一個簡單但靈活的容器物件，旨在在記憶體中存盤分層資料結構，例如簡化的 XML 資訊集，–注意：Python 2.5 及更高版本在標準庫中有 ElementTree

5. 圖形用戶界面

PyQt - 跨平臺 Qt 框架的系結，
TkInter - 傳統的 Python 用戶界面工具包，

6. 資料分析、資料科學和機器學習

Numpy：Numpy(numeric python) 被稱為 Python 中最受歡迎的機器學習庫之一，

Pandas：是 Python 中的資料分析、資料科學和機器學習庫，提供高級資料結構和多種分析工具，

SciPy：SciPy 是一個面向應用程式開發人員和工程師的機器學習庫，SciPy 庫包含用于優化、線性代數、集成、影像處理和統計的模塊，

Scikit-Learn：它是 NumPy 和 SciPy，它被認為是處理復雜資料的最佳庫之一，

TensorFlow：是谷歌構建的機器學習庫，

Keras：被認為是 Python 中最酷的機器學習庫之一，它提供了一種更簡單的機制來表達神經網路，Keras 還提供了一些用于編譯模型、處理資料集、圖形可視化等的最佳實用程式，

7. 網路：

requests：是一個我們可以用來向服務器發送請求的包（GET、POST、DELETE、PUT）
pip 安裝請求

🎉 恭喜！ 🎉你是一個非凡的人，你有非凡的潛力，
作為一個續集更新，感興趣了解下面的學習內容，記得關注我，你們的三連是我持續輸出的動力，感謝，