Python快速入門

Python是物件導向，高階語言，解釋，動態和多用途程式設計語言。Python易於學習，而且功能強大，功能多樣的指令碼語言使其對應用程式開發具有吸引力。
Python的語法和動態型別具有其解釋性質，使其成為許多領域的指令碼編寫和快速應用程式開發的理想語言。

Python支援多種程式設計模式，包括物件導向程式設計，命令式和函式式程式設計或程序式程式設計。

Python幾乎無所不能，一些常用的開發領域，如Web程式設計。這就是為什麼它被稱為多用途，因為它可以用於網路，企業，3D CAD等軟體和系統開發。

在Python中，不需要使用資料型別來宣告變數，因為它是動態型別的，所以可以寫一個如 a=10 來宣告一個變數a中的值是一個整數型別。

Python使開發和偵錯快速，因為在python開發中沒有包含編譯步驟，並且編輯 <-> 測試 <-> 偵錯迴圈使用程式碼開發效率非常高。

Python是一種高階，解釋，互動和物件導向的指令碼語言。 Python被設計為高度可讀性。 它使用英語關鍵字，而其他語言使用標點符號。它的語法結構比其他語言少。

• Python是直譯語言 - Python程式碼在直譯器中執行時處理，執行前不需要編譯程式。 這與PERL和PHP類似。

• Python是交動的 - 在Python提示符下面直接和直譯器進行互動來編寫程式。

• Python是物件導向的 - Python支援物件導向的風格或程式設計技術，將程式碼封裝在物件內。

• Python是一門初學者的語言 - Python是初學者程式員的偉大語言，並支援從簡單的文字處理到WWW瀏覽器到遊戲的各種應用程式的開發。

第一節 Python 可以用來開發什麼？

Python作為一個整體可以用於任何軟體開發領域。下面來看看Python可以應用在哪些領域的開發。如下所列 -

1.基於控制台的應用程式

Python可用於開發基於控制台的應用程式。 例如：IPython。

2.基於音訊或視訊的應用程式

Python在多媒體部分開發，證明是非常方便的。 一些成功的應用是：TimPlayer，cplay等。

3.3D CAD應用程式

Fandango是一個真正使用Python編寫的應用程式，提供CAD的全部功能。

4.Web應用程式

Python也可以用於開發基於Web的應用程式。 一些重要的開發案例是：PythonWikiEngines，Pocoo，PythonBlogSoftware等，如國內的成功應用案例有：豆瓣，知乎等。

5.企業級應用

Python可用於建立可在企業或組織中使用的應用程式。一些實時應用程式是：OpenErp，Tryton，Picalo等。

6.影象應用

使用Python可以開發影象應用程式。 開發的應用有：VPython，Gogh，imgSeek等

第二節 Python安裝和環境組態

Python 3適用於Windows，Mac OS和大多數Linux作業系統。即使Python 2目前可用於許多其他作業系統，有部分系統Python 3還沒有提供支援或者支援了但被它們在系統上刪除了，只保留舊的Python 2版本。

參考：/3/39/1366.html

第三節 Python命令列引數

Python提供了一個getopt模組，用於解析命令列選項和引數。

$ python test.py arg1 arg2 arg3

Python sys模組通過sys.argv提供對任何命令列引數的存取。主要有兩個引數變數 -

• sys.argv是命令列引數的列表。
• len(sys.argv)是命令列引數的數量。

這裡sys.argv [0]是程式名稱，即指令碼的名稱。比如在上面範例程式碼中，sys.argv [0]的值就是 test.py。

範例

看看以下指令碼command_line_arguments.py的程式碼 -

#!/usr/bin/python3

import sys

print ('Number of arguments:', len(sys.argv), 'arguments.')
print ('Argument List:', str(sys.argv))

現在執行上面的指令碼，這將產生以下結果 -

F:\>python F:\worksp\python\command_line_arguments.py
Number of arguments: 1 arguments.
Argument List: ['F:\\worksp\\python\\command_line_arguments.py']

F:\>python F:\worksp\python\command_line_arguments.py arg1 arg2 arg3 arg4
Number of arguments: 5 arguments.
Argument List: ['F:\\worksp\\python\\command_line_arguments.py', 'arg1', 'arg2', 'arg3', 'arg4']

F:\>

注意 - 如上所述，第一個引數始終是指令碼名稱，它也被計入引數的數量。

解析命令列引數

Python提供了一個getopt模組，可用於解析命令列選項和引數。該模組提供了兩個功能和異常，以啟用命令列引數解析。

getopt.getopt方法

此方法解析命令列選項和引數列表。以下是此方法的簡單語法 -

getopt.getopt(args, options, [long_options])

getopt.GetoptError異常

當在引數列表中有一個無法識別的選項，或者當需要一個引數的選項不為任何引數時，會引發這個異常。
異常的引數是一個字串，指示錯誤的原因。 屬性msg和opt給出錯誤訊息和相關選項。

範例

假設想通過命令列傳遞兩個檔案名，也想給出一個選項用來顯示指令碼的用法。指令碼的用法如下 -

usage: file.py -i <inputfile> -o <outputfile>

以下是command_line_usage.py的以下指令碼 -

#!/usr/bin/python3

import sys, getopt

def main(argv):
   inputfile = ''
   outputfile = ''
   try:
      opts, args = getopt.getopt(argv,"hi:o:",["ifile=","ofile="])
   except getopt.GetoptError:
      print ('GetoptError, usage: command_line_usage.py -i <inputfile> -o <outputfile>')
      sys.exit(2)
   for opt, arg in opts:
      if opt == '-h':
         print ('usage: command_line_usage.py -i <inputfile> -o <outputfile>')
         sys.exit()
      elif opt in ("-i", "--ifile"):
         inputfile = arg
      elif opt in ("-o", "--ofile"):
         outputfile = arg
   print ('Input file is "', inputfile)
   print ('Output file is "', outputfile)

if __name__ == "__main__":
   main(sys.argv[1:])

現在，使用以下幾種方式執行來指令碼，輸出如下所示：

F:\worksp\python>python command_line_usage.py -h
usage: command_line_usage.py -i <inputfile> -o <outputfile>

F:\worksp\python>python command_line_usage.py -i inputfile.txt -o
GetoptError, usage: command_line_usage.py -i <inputfile> -o <outputfile>

F:\worksp\python>python command_line_usage.py -i inputfile.txt -o outputfile.txt
Input file is " inputfile.txt
Output file is " outputfile.txt

F:\worksp\python>

第四節 Python變數型別

變數是儲存儲存值的記憶體位置。也就是說，當建立一個變數時，可以在記憶體中保留一些空間。

基於變數的資料型別，直譯器分配記憶體並決定可以儲存在保留的儲存器中的內容。 因此，通過為變數分配不同的資料型別，可以在這些變數中儲存的資料型別為整數，小數或字元等等。

將值分配給變數

在Python中，變數不需要明確的宣告型別來保留記憶體空間。當向變數分配值時，Python會自動發出宣告。 等號(=)用於為變數賦值。

=運算子左側的運算元是變數的名稱，而=運算子右側的運算元是將在儲存在變數中的值。 例如 -

#!/usr/bin/python3

counter = 100          # 一個整型數
miles   = 999.99       # 一個浮點數
name    = "Maxsu"       # 一個字串
site_url  = "https://www.tw511.com" # 一個字串

print (counter)
print (miles)
print (name)
print (site_url)

這裡，100,999.99和「Maxsu」分別是分配給counter，miles和name變數的值。執行上面程式碼將產生以下結果 -

100
999.99 
Maxsu
https://www.tw511.com

多重賦值

Python允許同時為多個變數分配單個值。

例如 -

a = b = c = 1

這裡，建立一個整數物件，其值為1，並且所有三個變數都分配給相同的記憶體位置。還可以將多個物件分配給多個變數。 例如 -

a, b, c = 10, 20, "maxsu"

這裡，將兩個值為10和20的整數物件分別分配給變數a和b，並將一個值為「maxsu」的字串物件分配給變數c。

標準資料型別

儲存在記憶體中的資料可以是多種型別。 例如，一個人的年齡可儲存為一個數位值，他的地址被儲存為字母數位字串。 Python具有各種標準資料型別，用於定義可能的操作以及每個標準資料型別的儲存方法。

Python有五種標準資料型別 -

• 1.數位
• 2.字串
• 3.列表
• 4.元組
• 5.字典

1.Python數位

數位資料型別儲存數位值。當為其分配值時，將建立數位物件。 例如 -

var1 = 10
var2 = 20

可以使用del語句刪除對數位物件的參照。 del語句的語法是 -

del var1[,var2[,var3[....,varN]]]]

可以使用del語句刪除單個物件或多個物件。

例如 -

del var
del var_a, var_b

Python支援三種不同的數值型別 -

• int(有符號整數)
• float(浮點實值)
• complex(複數)

Python3中的所有整數都表示為長整數。 因此，長整數沒有單獨的數位型別。

例子

以下是一些數位範例 -

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3+e18	.876j
-0490	-90.	-.6545+0J
-0x260	-32.54e100	3e+26J
0x69	70.2-E12	4.53e-7j

複數是由x + yj表示的有序對的實數浮點陣列成，其中x和y是實數，j是虛數單位。

2.Python字串

Python中的字串被標識為在引號中表示的連續字元集。Python允許雙引號或雙引號。 可以使用片段運算子([]和[:])來獲取字串的子集(子字串)，其索引從字串開始處的索引0開始，並且以-1表示字串中的最後一個字元。

加號(+)是字串連線運算子，星號(*)是重複運算子。例如 -

#!/usr/bin/python3
#coding=utf-8
# save file: variable_types_str1.py

str = 'tw511.com'

print ('str = ', str)          # Prints complete string
print ('str[0] = ',str[0])       # Prints first character of the string
print ('str[2:5] = ',str[2:5])     # Prints characters starting from 3rd to 5th
print ('str[2:] = ',str[2:])      # Prints string starting from 3rd character
print ('str[-1] = ',str[-1])      # 最後一個字元，結果為：'!'
print ('str * 2 = ',str * 2)      # Prints string two times
print ('str + "TEST" = ',str + "TEST") # Prints concatenated string

將上面程式碼儲存到 variable_types_str1.py 檔案中，執行將產生以下結果 -

F:\worksp\python>python variable_types_str1.py
str =  tw511.com
str[0] =  y
str[2:5] =  iba
str[2:] =  ibai.com
str[-1] =  m
str * 2 =  tw511.comtw511.com
str + "TEST" =  tw511.comTEST

F:\worksp\python>

2.Python列表

列表是Python複合資料型別中最多功能的。 一個列表包含用逗號分隔並括在方括號([])中的專案。在某種程度上，列表類似於C語言中的陣列。它們之間的區別之一是Python列表的所有項可以是不同的資料型別，而C語言中的陣列只能是同種型別。

儲存在列表中的值可以使用切片運算子([]和[])來存取，索引從列表開頭的0開始，並且以-1表示列表中的最後一個專案。 加號(+)是列表連線運算子，星號(*)是重複運算子。例如 -

#!/usr/bin/python3
#coding=utf-8
# save file: variable_types_str1.py
list = [ 'yes', 'no', 786 , 2.23, 'minsu', 70.2 ]
tinylist = [100, 'maxsu']

print ('list = ', list)          # Prints complete list
print ('list[0] = ',list[0])       # Prints first element of the list
print ('list[1:3] = ',list[1:3])     # Prints elements starting from 2nd till 3rd 
print ('list[2:] = ',list[2:])      # Prints elements starting from 3rd element
print ('list[-3:-1] = ',list[-3:-1])    
print ('tinylist * 2 = ',tinylist * 2)  # Prints list two times
print ('list + tinylist = ', list + tinylist) # Prints concatenated lists

將上面程式碼儲存到 variable_types_str1.py 檔案中，執行將產生以下結果 -

F:\worksp\python>python variable_types_list.py
list =  ['yes', 'no', 786, 2.23, 'minsu', 70.2]
list[0] =  yes
list[1:3] =  ['no', 786]
list[2:] =  [786, 2.23, 'minsu', 70.2]
list[-3:-1] =  [2.23, 'minsu']
tinylist * 2 =  [100, 'maxsu', 100, 'maxsu']
list + tinylist =  ['yes', 'no', 786, 2.23, 'minsu', 70.2, 100, 'maxsu']

F:\worksp\python>

3.Python元組

元組是與列表非常類似的另一個序列資料型別。元組是由多個值以逗號分隔。然而，與列表不同，元組被括在小括號內(())。

列表和元組之間的主要區別是 - 列表括在括號([])中，列表中的元素和大小可以更改，而元組括在括號(())中，無法更新。元組可以被認為是唯讀列表。 例如 -

#!/usr/bin/python3
#coding=utf-8
# save file : variable_types_tuple.py
tuple = ( 'maxsu', 786 , 2.23, 'yiibai', 70.2  )
tinytuple = (999.0, 'maxsu')

# tuple[1] = 'new item value' 不能這樣賦值

print ('tuple = ', tuple)           # Prints complete tuple
print ('tuple[0] = ', tuple[0])        # Prints first element of the tuple
print ('tuple[1:3] = ', tuple[1:3])      # Prints elements starting from 2nd till 3rd 
print ('tuple[-3:-1] = ', tuple[-3:-1])       # 輸出結果是什麼？
print ('tuple[2:] = ', tuple[2:])       # Prints elements starting from 3rd element
print ('tinytuple * 2 = ',tinytuple * 2)   # Prints tuple two times
print ('tuple + tinytuple = ', tuple + tinytuple) # Prints concatenated tuple

將上面程式碼儲存到 variable_types_tuple.py 檔案中，執行將產生以下結果 -

F:\worksp\python>python variable_types_tuple.py
tuple =  ('maxsu', 786, 2.23, 'yiibai', 70.2)
tuple[0] =  maxsu
tuple[1:3] =  (786, 2.23)
tuple[-3:-1] =  (2.23, 'yiibai')
tuple[2:] =  (2.23, 'yiibai', 70.2)
tinytuple * 2 =  (999.0, 'maxsu', 999.0, 'maxsu')
tuple + tinytuple =  ('maxsu', 786, 2.23, 'yiibai', 70.2, 999.0, 'maxsu')

F:\worksp\python>

以下程式碼對於元組無效，因為嘗試更新元組，但是元組是不允許更新的。類似的情況可能與列表 -

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # 無法更新值，程式出錯
list[2] = 1000     # 有效的更新，合法

Python字典

Python的字典是一種雜湊表型別。它們像Perl中發現的關聯陣列或雜湊一樣工作，由鍵值對組成。字典鍵幾乎可以是任何Python資料型別，但通常為了方便使用數位或字串。另一方面，值可以是任意任意的Python物件。

字典由大括號({})括起來，可以使用方括號([])分配和存取值。例如 -

#!/usr/bin/python3
#coding=utf-8
# save file : variable_types_dict.py

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is my"

tinydict = {'name': 'maxsu', 'code' : 1024, 'dept':'IT Dev'}


print ("dict['one'] = ", dict['one'])       # Prints value for 'one' key
print ('dict[2] = ', dict[2])           # Prints value for 2 key
print ('tinydict = ', tinydict)          # Prints complete dictionary
print ('tinydict.keys() = ', tinydict.keys())   # Prints all the keys
print ('tinydict.values() = ', tinydict.values()) # Prints all the values

將上面程式碼儲存到 variable_types_dict.py 檔案中，執行將產生以下結果 -

F:\worksp\python>python variable_types_dict.py
dict['one'] =  This is one
dict[2] =  This is my
tinydict =  {'name': 'maxsu', 'code': 1024, 'dept': 'IT Dev'}
tinydict.keys() =  dict_keys(['name', 'code', 'dept'])
tinydict.values() =  dict_values(['maxsu', 1024, 'IT Dev'])

字典中的元素沒有順序的概念。但是說這些元素是「亂序」是不正確的; 它們是無序的。

資料型別轉換

有時，可能需要在內建型別之間執行轉換。要在型別之間進行轉換，只需使用型別名稱作為函式即可。

有以下幾種內建函式用於執行從一種資料型別到另一種資料型別的轉換。這些函式返回一個表示轉換值的新物件。它們分別如下所示 -

編號	函式	描述
1	int(x [,base])	將x轉換為整數。如果x是字串，則要base指定基數。
2	float(x)	將x轉換為浮點數。
3	complex(real [,imag])	建立一個複數。
4	str(x)	將物件x轉換為字串表示形式。
5	repr(x)	將物件x轉換為表示式字串。
6	eval(str)	評估求值一個字串並返回一個物件。
7	tuple(s)	將s轉換為元組。
8	list(s)	將s轉換為列表。
9	set(s)	將s轉換為集合。
10	dict(d)	建立一個字典，d必須是(key，value)元組的序列
11	frozenset(s)	將s轉換為凍結集
12	chr(x)	將整數x轉換為字元
13	unichr(x)	將整數x轉換為Unicode字元。
14	ord(x)	將單個字元x轉換為其整數值。
15	hex(x)	將整數x轉換為十六進位制字串。
16	oct(x)	將整數x轉換為八進位制字串。

第五節 Python基本運算子

運算子是可以操縱運算元值的結構。如下一個表示式：10 + 20 = 30。這裡，10和20稱為運算元，+則被稱為運算子。

運算子型別

Python語言支援以下型別的運算子 -

• 1.算術運算子
• 2.比較(關係)運算子
• 3.賦值運算子
• 4.邏輯運算子
• 5.按位元運算子
• 6.成員運算子
• 7.身份運算子

下面讓我們依次來看看所有的運算子。

1.算術運算子

假設變數a的值是10，變數b的值是21，則 -

運算子	描述	範例
+	加法運算，將運算子兩邊的運算元增加。	a + b = 31
-	減法運算，將運算子左邊的運算元減去右邊的運算元。	a – b = -11
*	乘法運算，將運算子兩邊的運算元相乘	a * b = 210
/	除法運算，用右運算元除左運算元	b / a = 2.1
%	模運算，用右運算元除數左運算元並返回餘數	b % a = 1
**	對運算子進行指數(冪)計算	a ** b，表示10的21次冪
//	地板除 - 運算元的除法，其結果是刪除小數點後的商數。 但如果其中一個運算元為負數，則結果將被保留，即從零(向負無窮大)捨去	9//2 = 4 ， 9.0//2.0 = 4.0, -11//3 = -4, -11.0//3 = -4.0

有關算術運算子的範例程式碼，請參考：：/25/12885.html

2.比較(關係)運算子

比較(關係)運算子比較它們兩邊的值，並確定它們之間的關係。它們也稱為關係運算子。假設變數a的值10，變數b的值是20，則 -

運算子	描述	範例
==	如果兩個運算元的值相等，則條件為真。	(a == b)求值結果為 false
!=	如果兩個運算元的值不相等，則條件為真。	(a != b)求值結果為 true
>	如果左運算元的值大於右運算元的值，則條件成為真。	(a > b)求值結果為 false
<	如果左運算元的值小於右運算元的值，則條件成為真。	(a < b)求值結果為 true
>=	如果左運算元的值大於或等於右運算元的值，則條件成為真。	(a >= b)求值結果為 false
<=	如果左運算元的值小於或等於右運算元的值，則條件成為真。	(a <= b)求值結果為 true

有關比較(關係)運算子的範例程式碼，請參考：/25/12886.html

3.賦值運算子

假設變數a的值10，變數b的值是20，則 -

運算子	描述	範例
=	將右側運算元的值分配給左側運算元	c = a + b表示將a + b的值分配給c
+=	將右運算元相加到左運算元，並將結果分配給左運算元	c + = a等價於c = c + a
-=	從左運算元中減去右運算元，並將結果分配給左運算元	c -= a 等價於 c = c - a
*=	將右運算元與左運算元相乘，並將結果分配給左運算元	c *= a 等價於 c = c * a
/=	將左運算元除以右運算元，並將結果分配給左運算元	c /= a 等價於 c = c / a
%=	將左運算元除以右運算元的模數，並將結果分配給左運算元	c %= a 等價於 c = c % a
**=	執行指數(冪)計算，並將值分配給左運算元	c **= a 等價於 c = c ** a
//=	運算子執行地板除運算，並將值分配給左運算元	c //= a 等價於 c = c // a

有關賦值運算子的範例程式碼，請參考：/25/12887.html

4.邏輯運算子

Python語言支援以下邏輯運算子。假設變數a的值為True，變數b的值為False，那麼 -

運算子	描述	範例
and	如果兩個運算元都為真，則條件成立。	(a and b)的結果為False
or	如果兩個運算元中的任何一個非零，則條件成為真。	(a or b)的結果為True
not	用於反轉運算元的邏輯狀態。	not(a and b) 的結果為True。

有關邏輯運算子的範例程式碼，請參考：/25/12888.html

5.按位元運算子

按位元運算子執行逐位運算。 假設變數a = 60; 和變數b = 13; 現在以二進位制格式，它們將如下 -

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

Python的內建函式bin()可用於獲取整數的二進位制表示形式。

以下是Python語言支援位運算操作符 -

運算子	描述	範例
&	如果它存在於兩個運算元中，則操作符複製位到結果中	(a & b) 結果表示為 0000 1100
	如果它存在於任一運算元，則複製位。	(a b) = 61 結果表示為 0011 1101
^	二進位制互斥或。如果它是一個運算元集合，但不是同時是兩個運算元則將複製位。	(a ^ b) = 49 (結果表示為 0011 0001)
~	二進位制二補數，它是一元的，具有「翻轉」的效果。	(~a ) = -61有符號的二進位制數，表示為1100 0011的二補數形式。
<<	二進位制左移，左運算元的值由右運算元指定的位數左移。	a << 2 = 240 (結果表示為 1111 0000)
>>	二進位制右移，左運算元的值由右運算元指定的位數右移。	a >> 2 = 15(結果表示為0000 1111)

有關按位元運算子的範例程式碼，請參考：/25/12889.html

6.成員運算子

Python成員運算子測試給定值是否為序列中的成員，例如字串，列表或元組。 有兩個成員運算子，如下所述 -

運算子	描述	範例
in	如果在指定的序列中找到一個變數的值，則返回true，否則返回false。	-
not in	如果在指定序列中找不到變數的值，則返回true，否則返回false。	-

有關成員運算子的範例程式碼，請參考：/25/12890.html

7.身份運算子

身份運算子比較兩個物件的記憶體位置。常用的有兩個身份運算子，如下所述 -

運算子	描述	範例
is	如果運算子任一側的變數指向相同的物件，則返回True，否則返回False。
is not	如果運算子任一側的變數指向相同的物件，則返回True，否則返回False。	-

有關身份運算子的範例程式碼，請參考：/25/12891.html

8. 運算子優先順序

下表列出了從最高優先順序到最低優先順序的所有運算子，如下所示 -

序號	運算子	描述
1	**	指數(次冪)運算
2	~ + -	二補數，一元加減(最後兩個的方法名稱是+@和-@)
3	* / % //	乘法，除法，模數和地板除
4	+ -
5	>> <<	向右和向左位移
6	&	按位元與
7	^	按位元互斥或和常規的「OR」
8	<= < > >=	比較運算子
9	<> == !=	等於運算子
10	= %= /= //= -= += *= **=	賦值運算子
11	is is not	身份運算子
12	in not in	成員運算子
13	not or and	邏輯運算子

有關運算子優先順序的範例程式碼，請參考：/25/12892.html

第六節 Python決策

決策是指在執行程式期間根據發生的情況並根據條件採取的具體操作(行動)。決策結構評估求值多個表示式，產生TRUE或FALSE作為結果。如果結果為TRUE或否則為FALSE，則需要確定要執行的操作和要執行的語句。

以下是大多數程式設計語言中的典型決策結構的一般形式 -

Python程式設計語言假定任何非零值和非空值都為TRUE值，而任何零值或空值都為FALSE值。

Python程式設計語言提供以下型別的決策語句。

編號	語句	描述
1	if語句	一個if語句由一個布林表示式，後跟一個或多個語句組成。
2	if…else語句	一個if語句可以跟隨一個可選的else語句，當if語句的布林表示式為FALSE時，則else語句塊將被執行。
3	巢狀if語句	可以在一個if或else語句中使用一個if或else if語句。

下面我們快速地來了解每個決策宣告。

單個語句套件

一個if子句套件可能只包含一行，它可能與頭語句在同一行上。

範例

以下是一行if子句的範例 -

#!/usr/bin/python3
var = 10
if ( var  == 10 ) : print ("Value of expression is 10")
print ("Good bye!")

當執行上述程式碼時，會產生以下結果 -

Value of expression is 100
Good bye!

第七節 Python迴圈

一般來說，語句依次執行 - 例如，函式中的第一個語句首先執行，然後是第二個語句，依次類推。但是有很多時候需要多次執行同一段程式碼，這就引入了回圈的概念。

程式設計語言提供了允許更複雜的執行路徑的各種控制結構。

迴圈語句允許多次執行語句或語句組。下圖說明了一個迴圈語句流程結構 -

Python程式設計語言提供以下型別的迴圈來處理迴圈需求。

編號	迴圈	描述
1	while迴圈	在給定條件為TRUE時，重複一個語句或一組語句。 它在執行迴圈體之前測試狀態。
2	for迴圈	多次執行一系列語句，並縮寫管理迴圈變數的程式碼。
3	巢狀迴圈	可以使用一個或多個迴圈在while或for迴圈中。

迴圈控制語句

迴圈控制語句從正常順序更改執行。 當執行離開範圍時，在該範圍內建立的所有自動物件都將被銷毀。

Python支援以下控制語句。

編號	控制語句	描述
1	break語句	終止迴圈語句並將執行轉移到回圈之後的語句。
2	continue語句	使迴圈跳過其主體的剩餘部分，並立即重新測試其狀態以進入下一次疊代。
3	pass語句	當語法需要但不需要執行任何命令或程式碼時，Python中就可以使用pass語句，此語句什麼也不做，用於表示「佔位」的程式碼，有關實現細節後面再寫

下面簡單地看一下迴圈控制語句。

疊代器和生成器

疊代器(Iterator)是允許程式員遍歷集合的所有元素的物件，而不管其具體實現。在Python中，迭代器物件實現了iter()和next()兩種方法。

String，List或Tuple物件可用於建立Iterator。

list = [1,2,3,4]
it = iter(list) # this builds an iterator object
print (next(it)) #prints next available element in iterator
# Iterator object can be traversed using regular for statement

for x in it:
   print (x, end=" ")
or using next() function
while True:
   try:
      print (next(it))
   except StopIteration:
      sys.exit() #you have to import sys module for this

發生器(generator)是使用yield方法產生或產生一系列值的函式。

當一個生成器函式被呼叫時，它返回一個生成器物件，而不用執行該函式。 當第一次呼叫next()方法時，函式開始執行，直到它達到yield語句，返回yielded值。 yield保持跟蹤，即記住最後一次執行，而第二個next()呼叫從前一個值繼續。

範例

以下範例定義了一個生成器，它為所有斐波納契數位生成一個疊代器。

#!usr/bin/python3
import sys
def fibonacci(n): #generator function
   a, b, counter = 0, 1, 0
   while True:
      if (counter > n): 
         return
      yield a
      a, b = b, a + b
      counter += 1
f = fibonacci(5) #f is iterator object

while True:
   try:
      print (next(f), end=" ")
   except StopIteration:
      sys.exit()

第八節 Python數位

數位資料型別用於儲存數值。它們是不可變資料型別。這意味著，更改數位資料型別的值會導致新分配物件。

當為數位資料型別分配值時，Python將建立數位物件。 例如 -

var1 = 1
var2 = 10

可以使用del語句刪除對數位物件的參照。del語句的語法是 -

del var1[,var2[,var3[....,varN]]]]

可以使用del語句一次刪除單個物件或多個物件。 例如 -

del var
del var_a, var_b

Python支援不同的數值型別 -

• int(有符號整數) - 它們通常被稱為整數或整數。它們是沒有小數點的正或負整數。 Python 3中的整數是無限大小的。 Python 2 有兩個整數型別 - int和long。 Python 3中沒有「長整數」。

• float(浮點實數值) - 也稱為浮點數，它們表示實數，並用小數點寫整數和小數部分。 浮點數也可以是科學符號，E或e表示10的冪 -

• complex(複數) - 複數是以a + bJ的形式，其中a和b是浮點，J(或j)表示-1的平方根(虛數)。數位的實部是a，虛部是b。複數在Python程式設計中並沒有太多用處。

可以以十六進位制或八進位制形式表示整數 -

>>> number = 0xA0F #Hexa-decimal
>>> number
2575

>>> number = 0o37 #Octal
>>> number
31

例子

以下是一些數位值的範例 -

int	float	complex
10	0.0	3.14j
100	15.20	45.j
-786	-21.9	9.322e-36j
080	32.3+e18	.876j
-0490	-90.	-.6545+0J
-0×260	-32.54e100	3e+26J
0×69	70.2-E12	4.53e-7j

複數由一個a + bj來表示，它是由實際浮點數的有序對組成，其中a是實部，b是複數的虛部。

數位型別轉換

Python可將包含混合型別的表示式內部的數位轉換成用於評估求值的常用型別。 有時需要從一個型別到另一個型別執行明確數位轉換，以滿足運算子或函式引數的要求。

• int(x)將x轉換為純整數。
• long(x)將x轉換為長整數。
• float(x)將x轉換為浮點數。
• complex(x)將x轉換為具有實部x和虛部0的複數。
• complex(x, y)將x和y轉換為具有實部為x和虛部為y的複數。x和y是數位表示式。

數學函式

Python中包括執行數學計算的函式，如下列表所示 -

編號	函式	描述
1	abs(x)	x的絕對值，x與零之間的(正)距離。
2	ceil(x)	x的上限，不小於x的最小整數。
3	cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 或者 如果 x > y 返回 1。在Python 3中已經棄用，可使用return (x>y)-(x<y)代替。
4	exp(x)	x的指數，返回e的x次冪
5	fabs(x)	x的絕對值。
6	floor(x)	不大於x的最大整數。
7	log(x)	x的自然對數(x > 0)。
8	log10(x)	以基數為10的x的對數(x > 0)。
9	max(x1, x2,…)	給定引數中的最大值，最接近正無窮大值
10	min(x1, x2,…)	給定引數中的最小值，最接近負無窮小值
11	modf(x)	將x的分數和整數部分切成兩項放入元組中，兩個部分與x具有相同的符號。整數部分作為浮點數返回。
12	pow(x, y)	x的y次冪
13	round(x [,n])	x從小數點捨入到n位數。round(0.5)結果為 1.0， round(-0.5) 結果為 -1.0
14	sqrt(x)	x的平方根(x > 0)。

亂數函式

亂數字用於遊戲，模擬，測試，安全和隱私應用。 Python包括以下通常使用的函式。

編號	函式	描述
1	choice(seq)	來自列表，元組或字串的隨機專案。
2	randrange ([start,] stop [,step])	從範圍(start, stop, step)中隨機選擇的元素。
3	random()	返回隨機浮點數r(0 <= r < 1)
4	seed([x])	設定用於生成亂數的整數起始值。在呼叫任何其他隨機模組功能之前呼叫此函式，返回None。
5	shuffle(lst)	將列表的專案隨機化到位置。 返回None。
6	uniform(x, y)	返回隨機浮點數 r (x <= r < y)。

三角函式

亂數字用於遊戲，模擬，測試，安全和隱私應用。 Python包括以下通常使用的函式。

編號	函式	描述
1	acos(x)	返回x的弧餘弦值，以弧度表示。
2	asin(x)	返回x的弧線正弦，以弧度表示。
3	atan(x)	返回x的反正切，以弧度表示。
4	atan2(y, x)	返回atan(y / x)，以弧度表示。
5	cos(x)	返回x弧度的餘弦。
6	hypot(x, y)	返回歐幾里得規範，sqrt(x*x + y*y)
7	sin(x)	返回x弧度的正弦。
8	tan(x)	返回x弧度的正切值。
9	degrees(x)	將角度x從弧度轉換為度。
10	radians(x)	將角度x從角度轉換為弧度。

數學常數

該模組還定義了兩個數學常數 -

編號	常數	描述
1	pi	數學常數pi
2	e	數學常數e

第九節 Python字串

字串是Python中最受歡迎、最常使用的資料型別。可以通過用引號括起字元來建立它們。 Python將單引號與雙引號相同。建立字串和向一個變數賦值一樣簡單。 例如 -

var1 = 'Hello World!'
var2 = "Python Programming"

1.存取字串中的值

Python不支援字元型別; 字元會被視為長度為1的字串，因此也被認為是一個子字串。要存取子串，請使用方括號的切片加上索引或直接使用索引來獲取子字串。 例如 -

#!/usr/bin/python3

var1 = 'Hello World!'
var2 = "Python Programming"

print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5]) # 切片加索引

當執行上述程式碼時，會產生以下結果 -

var1[0]:  H
var2[1:5]:  ytho

2.更新字串

可以通過將變數分配給另一個字串來「更新」現有的字串。 新值可以與其原值相關或完全不同的字串。 例如 -

#!/usr/bin/python3

var1 = 'Hello World!'

print ("Updated String :- ", var1[:6] + 'Python')

當執行上述程式碼時，會產生以下結果 -

Updated String :-  Hello Python

3.跳脫字元

下表是可以用反斜槓表示法表示跳脫或不可列印字元的列表。單引號以及雙引號字串的跳脫字元被解析。

反斜線符號	十六進位制字元	描述/說明
\a	0x07	鈴聲或警報
\b	0x08	退格
\cx		Control-x
\C-x		Control-x
\e	0x1b	Escape
\f	0x0c	換頁
\M-\C-x		Meta-Control-x
\n	0x0a	新一行
\nnn		八進位制符號，其中n在0.7範圍內
\r	0x0d	回車返回
\s	0x20	空格
\t	0x09	製表符
\v	0x0b	垂直製表符
\x		字元x
\xnn		十六進位制符號，其中n在0~9，a~f或A~F範圍內

4.字串特殊運算子

假設字串變數a儲存字串值’Hello‘，變數b儲存字串值’Python‘，那麼 -

運算子	說明	範例
+	連線 - 將運算子的兩邊的值新增	a + b 結果為 HelloPython
*	重複 - 建立新字串，連線相同字串的多個副本	a*2 結果為 HelloHello
[]	切片 - 給出指定索引中的字串值，它是原字串的子串。	a[1] 結果為 e
[:]	範圍切片 - 給出給定範圍內的子字串	a[1:4] 結果為 ell
in	成員關係 - 如果給定字串中存在指定的字元，則返回true	'H' in a 結果為 1
not in	成員關係 - 如果給定字串中不存在指定的字元，則返回true	'Y' not in a 結果為 1
r/R	原始字串 - 抑制跳脫字元的實際含義。原始字串的語法與正常字串的格式完全相同，除了原始字串運算子在引號之前加上字母「r」。 「r」可以是小寫(r)或大寫(R)，並且必須緊靠在第一個引號之前。	print(r'\n') 將列印 \n ，或者 print(R'\n') 將列印 \n，要注意的是如果不加r或R作為字首，列印的結果就是一個換行。
%	格式 - 執行字串格式化	請參見本文第5節

5.字串格式化運算子

Python最酷的功能之一是字串格式運算子％。 這個操作符對於字串是獨一無二的，彌補了C語言中 printf()系列函式。 以下是一個簡單的例子 -

#!/usr/bin/python3

print ("My name is %s and weight is %d kg!" % ('Maxsu', 71))

當執行上述程式碼時，會產生以下結果 -

My name is Maxsu and weight is 71 kg!

以下是可以與%符號一起使用的完整符號集列表 -

編號	格式化符號	轉換
1	%c	字元
2	%s	在格式化之前通過str()函式轉換字串
3	%i	帶符號的十進位制整數
4	%d	帶符號的十進位制整數
5	%u	無符號十進位制整數
6	%o	八進位制整數
7	%x	十六進位制整數(小寫字母)
8	%X	十六進位制整數(大寫字母)
9	%e	指數符號(小寫字母’e‘)
10	%E	指數符號(大寫字母’E‘
11	%f	浮點實數
12	%g	％f和％e
13	%G	％f和％E

其他支援的符號和功能如下表所列 -

編號	符號	功能
1	*	引數指定寬度或精度
2	-	左對齊
3	+	顯示標誌或符號
4	<sp>	在正數之前留空格
5	#	根據是否使用「x」或「X」，新增八進位制前導零(‘0‘)或十六進位制前導’0x‘或’0X‘。
6	0	使用零作為左邊墊符(而不是空格)
7	%	‘%%‘留下一個文字「%」
8	(var)	對映變數(字典引數)
9	m.n.	m是最小總寬度，n是小數點後顯示的位數(如果應用)

6.三重引號

Python中的三重引號允許字串跨越多行，包括逐字記錄的新一行，TAB和任何其他特殊字元。

三重引號的語法由三個連續的單引號或雙引號組成。

#!/usr/bin/python3

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print (para_str)

當執行上述程式碼時，會產生以下結果。注意每個單獨的特殊字元如何被轉換成其列印形式，它是直到最後一個NEWLINEs在「up」之間的字串的末尾，並關閉三重引號。 另請注意，NEWLINEs可能會在一行或其跳脫碼(\n)的末尾顯式顯示回車符 -

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
 ], or just a NEWLINE within
the variable assignment will also show up.

原始字串根本不將反斜槓視為特殊字元。放入原始字串的每個字元都保持所寫的方式 -

#!/usr/bin/python3

print ('C:\\nowhere')

當執行上述程式碼時，會產生以下結果 -

C:\nowhere

現在演示如何使用原始的字串。將表示式修改為如下 -

#!/usr/bin/python3

print (r'C:\\nowhere')

當執行上述程式碼時，會產生以下結果 -

C:\\nowhere

7.Unicode字串

在Python 3中，所有的字串都用Unicode表示。在Python 2內部儲存為8位ASCII，因此需要附加’u‘使其成為Unicode，而現在不再需要了。

內建字串方法

Python包括以下內建方法來操作字串 -

編號	方法	說明
1	capitalize()	把字串的第一個字母轉為大寫
2	center(width, fillchar)	返回使用fillchar填充的字串，原始字串以總共width列為中心。
3	count(str, beg = 0,end = len(string))	計算字串中出現有多少次str或字串的子字串(如果開始索引beg和結束索引end,則在beg~end範圍匹配)。
4	decode(encoding = ‘UTF-8’,errors = ‘strict’)	使用編碼encoding解碼該字串。 編碼預設為預設字串encoding。
5	encode(encoding = ‘UTF-8’,errors = ‘strict’)	返回字串的編碼字串版本; 在錯誤的情況下，預設是丟擲ValueError，除非使用’ignore‘或’replace‘給出錯誤。
6	endswith(suffix, beg = 0, end = len(string))	確定字串或字串的子字串(如果啟動索引結束和結束索引結束)都以字尾結尾; 如果是則返回true，否則返回false。
7	expandtabs(tabsize = 8)	將字串中的製表符擴充套件到多個空格; 如果沒有提供tabize，則預設為每個製表符為8個空格。
8	find(str, beg = 0 end = len(string))	如果索引beg和結束索引end給定，則確定str是否在字串或字串的子字串中，如果找到則返回索引，否則為-1。
9	index(str, beg = 0, end = len(string))	與find()相同，但如果沒有找到str，則引發異常。
10	isalnum()	如果字串至少包含1個字元，並且所有字元均為數位，則返回true，否則返回false。
11	isalpha()	如果字串至少包含1個字元，並且所有字元均為字母，則返回true，否則返回false。
12	isdigit()	如果字串只包含數位則返回true，否則返回false。
13	islower()	如果字串至少包含1個字母，並且所有字元均為小寫，則返回true，否則返回false。
14	isnumeric()	如果unicode字串只包含數位字元，則返回true，否則返回false。
15	isspace()	如果字串只包含空格字元，則返回true，否則返回false。
16	istitle()	如果字串正確「標題大小寫」，則返回true，否則返回false。
17	isupper()	如果字串至少包含一個可變大小寫字元，並且所有可變大小寫字元均為大寫，則返回true，否則返回false。
18	join(seq)	將序列seq中的元素以字串表示合併(併入)到具有分隔符字串的字串中。
19	len(string)	返回字串的長度
20	ljust(width[, fillchar])	返回一個空格填充的字串，原始字串左對齊到總共width列。
21	lower()	將字串中的所有大寫字母轉換為小寫。
22	lstrip()	刪除字串中的所有前導空格
23	maketrans()	返回在translate函式中使用的轉換表。
24	max(str)	從字串str返回最大字母字元。
27	replace(old, new [, max])	如果給定max值，則用new或最多最大出現替換字串中所有出現的舊字元(old)。
28	rindex( str, beg = 0, end = len(string))	與index()相同，但在字串中向後搜尋。
29	rjust(width,[, fillchar])	返回一個空格填充字串，原始字串右對齊到總共寬度(width)列。
30	rstrip()	刪除字串的所有尾隨空格。
31	split(str=	根據分隔符str(空格，如果沒有提供)拆分字串並返回子字串列表; 如果給定，最多分割為num子串。
32	splitlines( num=string.count(‘\n’)))」)	全部拆分字串(或num)新行符，並返回每行的列表，並刪除新行符。
33	startswith(str, beg=0,end=len(string))	確定字串或字串的子字串(如果給定起始索引beg和結束索引end)以str開頭; 如果是則返回true，否則返回false。
34	strip([chars])	對字串執行lstrip()和rstrip()
35	swapcase()	反轉在字串中的所有字母大小寫，即小寫轉大寫，大寫轉小寫。
36	title()	返回字串的標題版本，即所有單詞第一個字母都以大寫開頭，其餘的都是小寫的。
37	translate(table, deletechars=	根據轉換表STR(256個字元)，除去那些在del字串轉換字串。
38	upper()	將字串中的小寫字母轉換為大寫。
39	zfill(width)	返回原始字串，左邊填充為零，總共有寬度(width)字元; 對於數位zfill()保留給定的任何符號(少於一個零)。
40	isdecimal()	如果unicode字串只包含十進位制字元，則返回true，否則返回false。

第十節 Python列表

Python中最基本的資料結構是列表。一個列表的每個元素被分配一個數位來表示它的位置或索引。 第一個索引為0，第二個索引為1，依此類推。

Python有六種內建的序列型別，但最常見的是列表和元組，將在本教學中看到。

可以在列表上執行各種型別操作。這些操作包括索引，切片，新增，乘法和檢查成員身份。此外，Python還具有內建函式，用於查詢序列的長度和查詢其最大和最小的元素。

1.Python列表

列表是Python中最通用的資料型別，可以寫成方括號之間的逗號分隔值(項)列表。列表中的專案不必是相同的型別，這一點和C語言中陣列有差別。

建立列表就在方括號之間放置不同的逗號分隔值。 例如 -

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

類似於字串索引，列表索引從0開始，列表可以被切片，連線等等。

2.存取列表中的值

要存取列表中的值，使用方括號進行切片以及索引或索引，以獲取該索引處可用的值。例如 -

#!/usr/bin/python3

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

當執行上述程式碼時，會產生以下結果 -

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

3.更新列表

可以通過在分配運算子左側給出切片來更新列表的單個或多個元素，可以使用append()方法新增到列表中的元素。例如 -

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])

list[2] = 2001
print ("New value available at index 2 : ", list[2])

註 - 在後續章節中討論了append()方法。

當執行上述程式碼時，會產生以下結果 -

Value available at index 2 :  1997
New value available at index 2 :  2001

4.刪除列表元素

要刪除列表元素，並且如果確切知道要刪除哪些元素可以使用del語句。如果不知道要刪除哪些專案，可以使用remove()方法。 例如 -

#!/usr/bin/python3
list = ['physics', 'chemistry', 1997, 2000]

print (list)
del list[2]
print ("After deleting value at index 2 : ", list)

當執行上述程式碼時，會產生以下結果 -

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :  ['physics', 'chemistry', 2000]

註 - remove()方法將在後續章節中討論。

基本列表操作

列表響應+和*運算子，這與字串十分類似; 它們也意味著這裡的連線和重複，除了結果是新的列表，而不是字串。

事實上，列表響應上一章中，在字串上使用的所有常規序列操作。

Python表示式	結果	描述
len([1, 2, 3])	3	列表的長度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	聯接
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重複
3 in [1, 2, 3]	True
for x in [1,2,3] : print (x,end = ' ')	1 2 3	疊代

索引，切片和矩陣

由於列表是序列，索引和切片的工作方式與列表一樣，對於字串。

假設以下輸入 -

L = ['C++'', 'Java', 'Python']

Python表示式	結果	描述
L[2]	'Python'	偏移量，從零開始
L[-2]	'Java'	負數：從右到右
L[1:]	['Java', 'Python']	切片提取部分

內建列表函式和方法

Python包括以下列表函式功能 -

編號	方法	描述
1	cmp(list1, list2)	在Python 3中不再可用。
2	len(list)	給出列表的總長度。
3	max(list)	從列表中返回最大值的專案。
4	min(list)	從列表中返回最小值的專案。
5	list(seq)	將元組轉換為列表。

Python包括以下列表方法 -

編號	方法	描述
1	list.append(obj)	將物件obj追加到列表中
2	list.count(obj)	返回列表中出現多少次obj的計數
3	list.extend(seq)	返回列表中出現多少次obj的計數
4	list.extend(seq)	將seq的內容附加到列表中
5	list.insert(index, obj)	將物件obj插入到偏移索引的列表中
6	list.pop(obj = list[-1])	從列表中刪除並返回最後一個物件或obj
7	list.remove(obj)	從列表中刪除物件obj
8	list.reverse()	反轉列表中的物件
9	list.sort([func])	排序列表的物件，如果給出，則使用比較函式func來排序

第十一節 Python元組

元組是一系列不可變的Python物件。元組是一種序列，就像列表一樣。元組和列表之間的主要區別是元組不能像列表那樣改變元素的值，可以簡單地理解為「唯讀列表」。 元組使用小括號 - ()，而列表使用方括號 - [] 。

建立一個元組只需使用逗號分隔值放入小括號的一個序列。 或者，也可以將這些逗號分隔值放在括號之間。 例如 -

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

空的元組寫成兩個不含任何東西的小括號 -

tup1 = ();

要編寫一個包含單個值的元組，必須包含一個逗號，即使只有一個值(這是規範寫法) -

tup1 = (50,)
## 也可以這樣寫
tup2 = (50)

1.存取元組中的值

要存取元組中的值，請使用方括號進行指定索引切片或索引，以獲取該索引處的值。 例如 -

#!/usr/bin/python3

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

當執行上述程式碼時，會產生以下結果 -

tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

2.更新元組

元組是不可變的，這意味著我們無法更新或更改元組元素的值。 但是可以使用現有元組的一部分來建立新的元組，如下例所示：

#!/usr/bin/python3

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# Following action is not valid for tuples
# tup1[0] = 100;

# So let's create a new tuple as follows
tup3 = tup1 + tup2
print (tup3)

當執行上述程式碼時，會產生以下結果 -

(12, 34.56, 'abc', 'xyz')

3.刪除元組元素

刪除單個元組元素是不可能的。 當然，將不必要的元素放在另一個元組中也沒有什麼錯。

要顯式刪除整個元組，只需使用del語句。 例如 -

#!/usr/bin/python3

tup = ('physics', 'chemistry', 1997, 2000);

print (tup)
del tup;
print "After deleting tup : "
print (tup)

執行上面程式碼，將產生以下結果 -

註 - 引發異常。這是因為在del tup之後，元組不再存在。

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
   File "test.py", line 9, in <module>
      print tup;
NameError: name 'tup' is not defined

4.基本元組操作

元組響應+和*運算子很像字串; 它們執行連線和重複操作，但結果是一個新的元組，而不是一個字串。

事實上，元組中類似字串操作和使用的所有常規序列操作都有作了講解。

Python表示式	結果	描述
len((1, 2, 3))	3	長度
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	連線操作
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	重複
3 in (1, 2, 3)	True	成員關係
for x in (1,2,3) : print (x, end = ' ')	1 2 3	疊代

5.索引，切片和矩陣

由於元組是序列，索引和切片的工作方式與列表的工作方式相同，假設輸入以下值：

T=('C++', 'Java', 'Python')

那麼 -

Python表示式	結果
T[2]	'Python'	偏移量，從零開始
T[-2]	'Java'	負數：從右到左
T[1:]	('Java', 'Python')	切片提取部分

6.內建元組函式功能

Python包括以下元組函式 -

編號	函式	描述
1	cmp(tuple1, tuple2)	比較兩個元組的元素。
2	len(tuple)	給出元組的總長度。
3	max(tuple)	從元組返回最大值項。
4	min(tuple)	從元組返回最大值項
5	tuple(seq)	將列表轉換為元組。

第十二節 Python字典

每個鍵與其值使用一個冒號(:)分開，這些鍵-值對是使用逗號分隔的，整個字典專案用大括號括起來。 沒有任何專案的空字典只用兩個花括號寫成：{}

鍵在字典中是唯一的，而值可以不必是唯一的。字典的值可以是任何型別的，但是鍵必須是不可變的資料型別，例如字串，數位或元組。

1.存取字典中的值

要存取字典元素，可以使用熟悉的中括號以及鍵來獲取其值。 以下是一個簡單的例子 -

#!/usr/bin/python3

dict = {'Name': 'Maxsu', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

當執行上述程式碼時，會產生以下結果 -

dict['Name']:  Maxsu
dict['Age']:  7

如果嘗試使用鍵(不是字典的一部分)存取資料項，會收到以下錯誤，如下範例 -

#!/usr/bin/python3

dict = {'Name': 'Maxsu', 'Age': 7, 'Class': 'First'}
print ("dict['Minsu']: ", dict['Minsu'])

當執行上述程式碼時，會產生以下結果 -

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Minsu'

2.更新字典

可以通過新增新資料項或鍵值對，修改現有資料項或刪除現有資料項來更新字典，如下面給出的簡單範例所示。

#!/usr/bin/python3

dict = {'Name': 'Maxsu', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School" # Add new entry

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

當執行上述程式碼時，會產生以下結果 -

dict['Age']:  8
dict['School']:  DPS School

3.刪除詞典元素

可以刪除單個字典元素或清除字典的全部內容。也可以在單個操作中刪除整個字典。

要顯式刪除整個字典，只需使用del語句。 以下是一個簡單的例子 -

#!/usr/bin/python3

dict = {'Name': 'Maxsu', 'Age': 7, 'Class': 'First'}

del dict['Name'] # remove entry with key 'Name'
dict.clear()     # remove all entries in dict
del dict         # delete entire dictionary

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

這產生以下結果：程式丟擲了一個例外，因為在執行del dict之後，字典不再存在。

print ("dict['Age']: ", dict['Age'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'type' object is not subscriptable
>>> print ("dict['School']: ", dict['School'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'type' object is not subscriptable

註 - del()方法將在後續章節中討論。

4. 字典鍵的屬性

字典值沒有限制。它們可以是任意任意的Python物件，標準物件或使用者定義的物件。 但是，對於鍵來說也是如此。

關於字典的鍵有兩個要點：

(a). 不允許每鍵多於資料值。這意味著不允許重複的鍵。 在分配過程中遇到重複鍵時，則以最後一個賦值為準。 例如 -

#!/usr/bin/python3

dict = {'Name': 'Maxsu', 'Age': 7, 'Name': 'Minlee'}
print ("dict['Name']: ", dict['Name'])

當執行上述程式碼時，會產生以下結果 -

dict['Name']:  Minlee

(b). 鍵必須是不可變的。 這意味著可以使用字串，數位或元組作為字典鍵，但不允許使用['key']。 以下是一個簡單的例子 -

#!/usr/bin/python3

dict = {['Name']: 'Maxsu', 'Age': 7}
print ("dict['Name']: ", dict['Name'])

當執行上述程式碼時，會產生以下結果 -

Traceback (most recent call last):
   File "test.py", line 3, in <module>
      dict = {['Name']: 'Maxsu', 'Age': 7}
TypeError: list objects are unhashable

5.內建詞典函式和方法

Python包括以下字典函式 -

編號	函式	描述
1	cmp(dict1, dict2)	在Python 3中不再可用。
2	len(dict)	計算出字典的總長度。它將等於字典中的資料項數目。
3	str(dict)	生成字典的可列印字串表示形式
4	type(variable)	返回傳遞變數的型別。如果傳遞變數是字典，那麼它將返回一個字典型別。

Python包括以下字典方法 -

編號	函式	描述
1	dict.clear()	刪除字典dict的所有元素
2	dict.copy()	返回字典dict的淺拷貝
3	dict.fromkeys()	建立一個新的字典，其中包含seq的值和設定為value的值。
4	dict.get(key, default=None)	對於鍵(key)存在則返回其對應值，如果鍵不在字典中，則返回預設值
5	dict.has_key(key)	此方法已刪除，使用in操作符代替
6	dict.items()	返回字典dict的(key，value)元組對的列表
7	dict.keys()	返回字典dict的鍵列表
8	dict.setdefault(key, default = None)	類似於get()，如果key不在字典dict中，則將執行賦值操作：dict [key] = default
9	dict.update(dict2)	將字典dict2的鍵值對新增到字典dict
10	dict.values()	返回字典dict的值列表

第十三節 Python日期和時間

Python程式可以通過多種方式處理日期和時間。日期格式之間的轉換是計算機常見問題。Python的時間(time)和日曆(calendar)模組可用於跟蹤日期和時間。

一些常用程式碼範例

• 獲取當前時間和日期，如：2018-08-18 12：12：00
• 計算兩個日期相差天數
• 計算程式執行的時間

#!/usr/bin/python3
#coding=utf-8

import time  
import datetime  

starttime = datetime.datetime.now()  

time.sleep(5)  

endtime = datetime.datetime.now()  
print ((endtime - starttime).seconds )

• 計算十天之後的日期時間

#!/usr/bin/python3
#coding=utf-8

import time  
import datetime  

d1 = datetime.datetime.now()  
d3 = d1 + datetime.timedelta(days =10)  

print (str(d3))
print (d3.ctime())

• 獲取兩個日期時間的時間差

t = (datetime.datetime(2019,1,13,12,0,0) - datetime.datetime.now()).total_seconds()
print ("t = ", t)
## 輸出結果
t = 49367780.076406

Python中有提供與日期和時間相關的4個模組。它們分別是 -

模組	說明
time	time是一個僅包含與日期和時間相關的函式和常數的模組，在本模組中定義了C/C++編寫的幾個類。 例如，struct_time類。
datetime	datetime是一個使用物件導向程式設計設計的模組，可以在Python中使用日期和時間。它定義了幾個表示日期和時間的類。
calendar	日曆是一個提供函式的模組，以及與Calendar相關的幾個類，它們支援將日曆映像生成為text，html，….
locale	該模組包含用於格式化或基於區域設定分析日期和時間的函式。

1. 時間間隔

時間間隔是以秒為單位的浮點數。 從1970年1月1日上午12:00(epoch)，這是一種時間的特殊時刻表示。

在Python中，當前時刻與上述特殊的某個時間點之間以秒為單位的時間。這個時間段叫做Ticks。

time模組中的time()函式返回從1970年1月1日上午12點開始的秒數。

# Import time module.
import time;

# Seconds
ticks = time.time()


print ("Number of ticks since 12:00am, January 1, 1970: ", ticks)

執行上面程式碼，得到以下結果 -

Number of ticks since 12:00am, January 1, 1970:  1497970093.6243818

但是，這個形式不能表示在時代(1970年1月1日上午12:00)之前的日期。在未來的日子也不能以這種方式表示 - 截止點是在2038年的UNIX和Windows的某個時刻。

2. 什麼是TimeTuple？

許多Python時間函式將時間處理為9個數位的元組，如下所示：

索引	欄位	值
0	4位數，表示年份	2018，2019…
1	月份	1 ~ 12
2	日期	1 ~ 31
3	小時	0 ~ 23
4	分鐘	0 ~ 59
5	秒	0 ~ 61(60或61是閏秒)
6	星期幾	0 ~ 6(0是星期一)
7	一年的第幾天	1 ~ 366(朱利安日)
8	夏令時	-1，0，1，-1表示庫確定DST

一個範例

import time
print (time.localtime());

這將產生如下結果：

time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9, 
   tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

上面的元組相當於struct_time結構。此結構具有以下屬性 -

索引	欄位	值
0	tm_year	2018，2019…
1	tm_mon	1 ~ 12
2	tm_mday	1 ~ 31
3	tm_hour	0 ~ 23
4	tm_min	0 ~ 59
5	tm_sec	0 ~ 61(60或61是閏秒)
6	tm_wday	0 ~ 6(0是星期一)
7	tm_yday	1 ~ 366(朱利安日)
8	tm_isdst	-1，0，1，-1表示庫確定DST

能用圖片說明白的盡量用圖片說明 -

2.1.獲取當前時間

要將從時間浮點值開始的秒數瞬間轉換為時間序列，將浮點值傳遞給返回具有所有有效九個專案的時間元組的函式(例如本地時間)。

#!/usr/bin/python3
import time

localtime = time.localtime(time.time())
print ("Local current time :", localtime)

# 當前時間
curtime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print (curtime)

執行上面程式碼，這將產生如下結果 -

Local current time : time.struct_time(tm_year=2017, tm_mon=6, tm_mday=20, tm_hour=23,
tm_min=9, tm_sec=36, tm_wday=1, tm_yday=171, tm_isdst=0)
Curtime is =>  2017-06-20 23:09:36

2.2.獲取格式化時間

可以根據需要格式化任何時間，但也可使用可讀格式獲取時間的簡單方法是 - asctime() -

#!/usr/bin/python3
import time

localtime = time.asctime( time.localtime(time.time()) )
print ("Local current time :", localtime)

執行上面程式碼，這將產生如下結果 -

Local current time : Mon Feb 15 10:32:13 2018

2.3.獲取一個月的日曆

calendar模組提供了廣泛的方法來顯示年曆和月度日曆。 在這裡，將列印一個給定月份的日曆(2021年11月) -

#!/usr/bin/python3
import calendar

cal = calendar.month(2021, 11)
print ("Here is the calendar:")
print (cal)

執行上面程式碼後，將輸出以下結果 -

   November 2021
Mo Tu We Th Fr Sa Su 
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30

3.時間模組

Python中有一個受歡迎的時間(time)模組，它提供了處理時間和表示之間轉換的功能。以下是所有時間(time)可用方法的列表。

編號	方法	描述
1	time.altzone	本地DST時區的偏移量(以秒為單位的UTC)，如果定義了有一個定義的話。 如果原生的DST時區是UTC的東部(如在西歐，包括英國)，那麼它是負數值。
2	time.asctime([tupletime])	接受時間元組，並返回一個可讀的24個字元的字串，例如’Tue Dec 11 22:07:14 2019’。
3	time.clock( )	將當前CPU時間返回為浮點數秒。 為了測量不同方法的計算成本，time.clock的值比time.time()的值更有用。
4	time.ctime([secs])	類似於asctime(localtime(secs))，而沒有引數就像asctime()
5	time.gmtime([secs])	接受從時代(epoch)以秒為單位的瞬間，並返回與UTC時間相關的時間元組t。 註 - t.tm_isdst始終為0
6	time.localtime([secs])	接受從時代(epoch)以秒為單位的瞬間，並返回與本地時間相關的時間t(t.tm_isdst為0或1，具體取決於DST是否適用於本地規則的瞬時秒)。
7	time.mktime(tupletime)	接受在本地時間表示為時間元組的瞬間，並返回浮點值，該時間點以秒為單位表示。
8	time.sleep(secs)	暫停呼叫執行緒secs秒。
9	time.strftime(fmt[,tupletime])	接受在本地時間表示為時間元組的瞬間，並返回一個表示由字串fmt指定的時間的字串。
10	time.strptime(str,fmt = ‘%a %b %d %H:%M:%S %Y’)「)	根據格式字串fmt解析str，並返回時間元組格式的時間。
11	time.time( )	返回當前時間時刻，即從時代(epoch)開始的浮點數秒數。
12	time.tzset()	重置庫例程使用的時間轉換規則。環境變數TZ指定如何完成。

時間(time)模組有兩個重要的屬性可用。它們是 -

編號	屬性	描述
1	time.timezone	屬性time.timezone是UTC和本地時區(不含DST)之間的偏移量(美洲為 > 0，歐洲，亞洲，非洲大部分地區為 0)。
2	time.tzname	屬性time.tzname是一對與區域相關的字串，它們分別是沒有和具有DST的本地時區的名稱。

4.日曆模組

calendar模組提供與日曆相關的功能，包括為給定的月份或年份列印文字日曆的功能。

預設情況下，日曆將星期一作為一週的第一天，將星期日作為最後一天。 如果想要更改這個，可呼叫calendar.setfirstweekday()函式設定修改。

以下是calendar模組可用的功能函式列表 -

編號	函式	描述
1	calendar.calendar(year,w = 2,l = 1,c = 6)	返回一個具有年份日曆的多行字串格式化為三列，以c個空格分隔。 w是每個日期的字元寬度; 每行的長度為21 * w + 18 + 2 * c，l是每週的行數。
2	calendar.firstweekday( )	返回當前設定每週開始的星期。預設情況下，當日曆首次匯入時設定為：0，表示為星期一。
3	calendar.isleap(year)	如果給定年份(year)是閏年則返回True; 否則返回：False。
4	calendar.leapdays(y1,y2)	返回在範圍(y1，y2)內的年份中的閏年總數。
5	calendar.month(year,month,w = 2,l = 1)	返回一個多行字串，其中包含年份月份的日曆，每週一行和兩個標題行。 w是每個日期的字元寬度; 每行的長度為7 * w + 6。 l是每週的行數。
6	calendar.monthcalendar(year,month)	返回int型別的列表。每個子列表表示一個星期。年份月份以外的天數設定為0; 該月內的日期設定為月份的第幾日：1 ~ 31。
7	calendar.monthrange(year,month)	返回兩個整數。第一個是年度月(month)的星期幾的程式碼; 第二個是當月的天數。表示星期幾為0(星期一)至6(星期日); 月份是1到12。
8	calendar.prcal(year,w = 2,l = 1,c = 6)	類似於：calendar.calendar(year，w，l，c)的列印。
9	calendar.prmonth(year,month,w = 2,l = 1)	類似於：calendar.month(year,month,w,l)的列印。
10	calendar.setfirstweekday(weekday)	將每週的第一天設定為星期幾的程式碼。 星期幾的程式碼為0(星期一)至6(星期日)。
11	calendar.timegm(tupletime)	time.gmtime的倒數：以時間元組的形式接受時刻，並返回與從時代(epoch)開始的浮點數相同的時刻。
12	calendar.weekday(year,month,day)	返回給定日期的星期幾的程式碼。星期幾的程式碼為0(星期一)至6(星期日); 月數是1(1月)到12(12月)。

5.其他模組和功能

如果您有興趣，那麼可以在Python中找到其他重要的模組和功能列表，其中包含日期和時間。以下列出其它有用的模組 -

• datetime模組
• pytz模組
• dateutil模組

第十四節 Python函式

函式是一個有組織，可重複使用的程式碼塊，用於執行單個相關操作。 函式為應用程式提供更好的模組化和高度的程式碼重用。

我們知道，Python中也有給很多內建的函式，如print()等，但使用者也可以建立自己的函式。這樣的函式稱為使用者定義函式。

1.定義函式

可以定義提供所需函式的功能。 以下是在Python中定義函式的簡單規則。

• 函式塊以關鍵字def開頭，後跟函式名和小括號(())。
• 任何輸入引數或引數應放置在這些小括號中。也可以在這些小括號內定義引數。
• 每個函式中的程式碼塊以冒號(:)開始，並縮排。
• 函式內的第一個語句可以是可選語句 - 函式的文件或docstring字串。
• 語句return [expression]用於退出一個函式，可選地將一個表示式傳回給呼叫者。如果沒有使用引數的return語句，則它與return None相同。

語法

def functionname( parameters ):
    "function_docstring"
    function_suite
    return [expression]

預設情況下，引數具有位置行為，您需要按照定義的順序通知它們或呼叫它們。

範例

以下函式將字串作為輸入引數，並在標準螢幕上列印引數的值。

def printme( str ):
    "This prints a passed string into this function"
    print (str)
    return

2.呼叫函式

定義一個函式需要為它起一個名字，指定要包括在函式中的引數並構造程式碼塊。
當函式的基本結構完成，可以通過從另一個函式呼叫它或直接從Python提示符執行它。 以下是一個呼叫print_str()函式的例子 -

#!/usr/bin/python3

# Function definition is here
def print_str( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call print_str function
print_str("This is first call to the user defined function!")
print_str("Again second call to the same function")

當執行上述程式碼時，會產生以下結果 -

This is first call to the user defined function!
Again second call to the same function

3.通過參照與通過值傳遞

Python語言中的所有引數(引數)都將通過參照傳遞。如果在函式中更改引數所指的內容，則更改也會反映在呼叫函式的外部。 例如 -

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   print ("Values inside the function before change: ", mylist)
   mylist[2]=50
   print ("Values inside the function after change: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

在這裡，將保持對傳遞物件的參照並在相同的物件中賦值。 因此，這將產生以下結果 -

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

在上面的輸出結果中，可以清楚地看到，mylist[2]的值原來只在函式內賦了一個值：50，但在函式外部的最後一個語句打出來的值是：50，這說明更改也會反映在呼叫函式的外部。

還有一個例子：引數通過參照傳遞，參照在被呼叫函式內被覆蓋。

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def changeme( mylist ):
    "This changes a passed list into this function"
    mylist = [1,2,3,4] # This would assi new reference in mylist
    print ("Values inside the function: ", mylist)
    return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

引數mylist是changeme()函式的區域性變數。在函式中更改mylist不影響mylist的值。函式執行完成後，最終將產生以下結果 -

Values inside the function:  [1, 2, 3, 4]
Values outside the function:  [10, 20, 30]

4.函式引數

可以使用以下型別的形式引數來呼叫函式 -

• 必需引數
• 關鍵字引數
• 預設引數
• 可變長度引數

4.1.必需引數

必需引數是以正確的位置順序傳遞給函式的引數。這裡，函式呼叫中的引數數量應與函式定義完全一致。

如下範例中，要呼叫printme()函式，則必需要傳遞一個引數，否則會出現如下語法錯誤 -

#!/usr/bin/python3

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# 現在要呼叫函式，但不提供引數
printme()

當執行上述程式碼時，會產生以下結果 -

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

提示：在呼叫 printme()函式時，提供一個引數就可以了。如：printme('Maxsu') 。

4.2.關鍵字引數

關鍵字引數與函式呼叫有關。 在函式呼叫中使用關鍵字引數時，呼叫者通過引數名稱來標識引數。

這允許跳過引數或將其置於無序狀態，因為Python直譯器能夠使用提供的關鍵字將值與引數進行匹配。還可以通過以下方式對printme()函式進行關鍵字呼叫 -

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

# Now you can call printme function
printme( str = "My string")

當執行上述程式碼時，會產生以下結果 -

My string

以下範例給出了更清晰的對映。請注意，引數的順序並不重要。

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print ("Name: ", name, "Age: ", age)
   return

# Now you can call printinfo function
printinfo( age = 25, name = "Maxsu" )
printinfo(name = "Minsu", age = 26 )

當執行上述程式碼時，會產生以下結果 -

Name:  Maxsu Age:  25
Name:  Minsu Age:  26

4.3.預設引數

如果在該引數的函式呼叫中沒有提供值，則預設引數是一個假設為預設值的引數。 以下範例給出了預設引數的想法，如果未通過，則列印預設年齡(age) -

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printinfo( name, age = 25 ):
   "This prints a passed info into this function"
   print ("Name: ", name, "Age ", age)
   return

# Now you can call printinfo function
printinfo( age = 22, name = "Maxsu" )
printinfo( name = "Minsu" )

當執行上述程式碼時，會產生以下結果 -

Name:  Maxsu Age  22
Name:  Minsu Age  25

4.4.可變長度引數

在定義函式時，可能需要處理更多引數的函式。這些引數被稱為可變長度引數，並且不像要求的和預設的引數那樣在函式定義中命名。

具有非關鍵字變數引數的函式的語法如下：

def functionname([formal_args,] *var_args_tuple ):
    "function_docstring"
    function_suite
    return [expression]

星號(*)放在儲存所有非關鍵字變數引數值的變數名之前。 如果在函式呼叫期間沒有指定額外的引數，則此元組保持為空。以下是一個簡單的例子 -

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printinfo( arg1, *vartuple ):
    "This prints a variable passed arguments"
    print ("Output is: ", arg1)
    for var in vartuple:
      print (var, )
    return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

當執行上述程式碼時，會產生以下結果 -

Output is:  10
Output is:  70
60
50

5.匿名函式

這些函式被稱為匿名的，因為它們沒有使用def關鍵字以標準方式宣告。可以使用lambda關鍵字建立小型匿名函式。

• Lambda表單可以接受任意數量的引數，但只能以表示式的形式返回一個值。它們不能包含命令或多個表示式。
• 匿名函式不能直接呼叫列印，因為lambda需要一個表示式。
• Lambda函式有自己的本地名稱空間，不能存取其引數列表和全域性名稱空間中的變數。
• 雖然lambdas是一個單行版本的函式，但它們並不等同於C或C++中的內聯語句，其目的是通過傳遞函式來進行堆疊分配。

語法

lambda函式的語法只包含一個語句，如下所示：

lambda [arg1 [,arg2,.....argn]]:expression

以下是一個範例，以顯示lambda形式的函式如何工作 -

#!/usr/bin/python3

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2


# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))

當執行上述程式碼時，會產生以下結果 -

Value of total :  30
Value of total :  40

6.return語句

return [expression]語句退出一個函式，可選地將一個表示式傳回給呼叫者。沒有引數的return語句與return None相同。

下面給出的所有例子都沒有返回任何值。可以從函式返回值，如下所示：

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print ("Inside the function : ", total)
   return total

# Now you can call sum function
total = sum( 10, 20 )
print ("Outside the function : ", total )

全部執行上述程式碼時，會產生以下結果 -

Inside the function :  30
Outside the function :  30

7.變數範圍

程式中的所有變數在該程式的所有位置可能無法存取。這取決於在哪裡宣告一個變數。變數的範圍決定了可以存取特定識別符號的程式部分。Python中有兩個變數的基本範圍 -

• 全域性變數
• 區域性變數

8.全域性與區域性變數

在函式體內定義的變數具有區域性作用域，外部定義的變數具有全域性作用域。

區域性變數只能在它們宣告的函式內部存取，而全域性變數可以通過所有函式在整個程式體中存取。 當呼叫一個函式時，它內部宣告的變數被帶入範圍。 以下是一個簡單的例子 -

total = 0 # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print ("Inside the function local total : ", total)
   return total

# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )

當執行上述程式碼時，會產生以下結果 -

Inside the function local total :  30
Outside the function global total :  0

第十五節 Python模組

模組允許邏輯地組織Python程式碼。 將相關程式碼分組到一個模組中，使程式碼更容易理解和使用。 模組是一個具有任意命名屬性的Python物件，可以繫結和參照。

簡單來說，模組是一個由Python程式碼組成的檔案。模組可以定義函式，類和變數。 模組還可以包括可執行的程式碼。

範例

下面是一個名稱為aname的模組的Python程式碼通常位於一個名稱為aname.py的檔案中。以下是一個簡單模組的例子：support.py -

def print_func( par ):
   print "Hello : ", par
   return

1.import語句

可以通過在其他Python原始檔中執行import語句來將任何Python原始檔用作模組。匯入具有以下語法 -

import module1[, module2[,... moduleN]

當直譯器遇到匯入語句時，如果模組存在於搜尋路徑中，則匯入該模組。搜尋路徑是匯入模組之前直譯器搜尋的目錄的列表。例如，要匯入模組hello.py，需要將以下命令放在指令碼的頂部 -

#!/usr/bin/python3

# Import module support
import support

# Now you can call defined function that module as follows
support.print_func("Maxsu")

當執行上述程式碼時，會產生以下結果 -

Hello : Maxsu

不管模組被匯入多少次，模組只能載入一次。這樣可以防止模組執行重複發生，如果有多個匯入。

2.from…import語句

Python from語句允許將模組中的特定屬性匯入到當前的名稱空間中。 from...import具有以下語法 -

from modname import name1[, name2[, ... nameN]]

例如，要從模組 fib 匯入函式fibonacci，請使用以下語句 -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

此語句不會將整個模組fib匯入到當前名稱空間中; 它只是將fibonacci從模組fib引入匯入模組的全域性符號表。

3.from…import *語句

也可以使用以下import語句將模組中的所有名稱匯入到當前名稱空間中 -

from modname import *

這提供了將所有專案從模組匯入到當前名稱空間中的簡單方法; 但是，這個說法應該謹慎使用。

4.執行模組作為指令碼

在模組中，模組的名稱(作為字串)可用作全域性變數__name__的值。模組中的程式碼將被執行，就像您匯入它一樣，但是__name__設定為「__main__」。

在模組的最後新增這個程式碼 -

#!/usr/bin/python3

# Fibonacci numbers module

def fib(n): # return Fibonacci series up to n
   result = []
   a, b = 0, 1
   while b < n:
      result.append(b)
      a, b = b, a + b
   return result
if __name__ == "__main__":
   f = fib(100)
   print(f)

執行上述程式碼時，將顯示以下輸出。

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

5.定位模組

當匯入模組時，Python直譯器將按以下順序搜尋模組 -

• 當前目錄。
• 如果沒有找到該模組，Python會在shell變數PYTHONPATH中搜尋每個目錄。
• 如果其他所有失敗，Python將檢查預設路徑。 在UNIX上，此預設路徑通常是/usr/local/lib/python3/ 或者 /usr/sbin/

模組搜尋路徑作為sys.path變數儲存在系統模組sys中。sys.path變數包含當前目錄PYTHONPATH和依賴於安裝的預設值。

6.PYTHONPATH變數

PYTHONPATH是一個環境變數，由目錄列表組成。 PYTHONPATH的語法與shell變數`PATH```的語法相同。

這是一個典型的Windows系統上的PYTHONPATH -

set PYTHONPATH = c:\python34\lib;

這裡是UNIX系統的典型PYTHONPATH -

set PYTHONPATH = /usr/local/lib/python

7.名稱空間和範圍

變數是對映到物件的名稱(識別符號)。 名稱空間是變數名(鍵)及其對應物件(值)的字典。

• Python語句可以存取本地名稱空間和全域性名稱空間中的變數。如果本地和全域性變數具有相同的名稱，則區域性變數會影響全域性變數。
• 每個函式都有自己的本地名稱空間。 類方法遵循與普通函式相同的範圍規則。
• Python對於變數是本地還是全域性都進行了有根據的判斷。它假定在函式中分配值的任何變數都是原生的。
• 因此，為了將值分配給函式內的全域性變數，必須首先使用global語句。
• 語句global VarName告訴Python VarName是一個全域性變數。Python停止搜尋本地名稱空間的變數。

例如，在全域性名稱空間中定義一個變數Money。 在函式Money中為Money賦值，因此Python將Money作為區域性變數。

但是，如果在設定之前就存取了本地變數Money的值，它會產生一個錯誤：UnboundLocalError。 這裡可以通過取消註釋global語句來解決問題。如下範例程式碼 -

#!/usr/bin/python3

Money = 2000
def AddMoney():
   # Uncomment the following line to fix the code:
   # global Money
   Money = Money + 1

print (Money)
AddMoney()
print (Money)

8.dir( )函式

dir()內建函式返回一個包含由模組定義的名稱的字串的排序列表。這個列表包含模組中定義的所有模組，變數和函式的名稱。 以下是一個簡單的例子 -

#!/usr/bin/python3

# Import built-in module math
import time

content = dir(time)

print (content)

當執行上述程式碼時，會產生以下結果 -

['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__',
'altzone', 'asctime', 'clock', 'ctime', 'daylight', 'get_clock_info', 'gmtime',
'localtime', 'mktime', 'monotonic', 'perf_counter', 'process_time', 'sleep',
'strftime', 'strptime', 'struct_time', 'time', 'timezone', 'tzname']

這裡，特殊的字串變數__name__是模組的名稱，__file__是載入模組的檔案名。

9.globals()和locals()函式

globals()和locals()函式可用於返回全域性和本地名稱空間中的名稱，具體取決於它們被呼叫的位置。

• 如果locals()從一個函式中呼叫，它將返回從該函式本地存取的所有名稱。
• 如果從函式中呼叫globals()，它將返回從該函式全域性存取的所有名稱。

這兩個函式的返回型別是字典。 因此，可以使用keys()函式提取名稱。

10.reload()函式

當將模組匯入到指令碼中時，模組的頂級部分的程式碼只能執行一次。
因此，如果要重新執行模組中的頂級程式碼，可以使用reload()函式。reload()函式再次匯入以前匯入的模組。 reload()函式的語法是這樣的 -

reload(module_name)

這裡，module_name是要重新載入的模組的名稱，而不是包含模組名稱的字串。 例如，要重新載入hello模組，請執行以下操作 -

reload(hello)

11.Python中的包

Python中的包是一個分層檔案目錄結構，它定義了一個由模組和子包和子子包組成的Python應用程式環境，等等。

在package目錄中建立兩個目錄：pkg和pkg2， 然後分別在這兩個目錄中建立兩個檔案：a.py和b.py。該檔案具有以下一行原始碼 -

檔案： pkg/a.py -

#!/usr/bin/python3
#coding=utf-8
# save file: pkg/a.py
def fun():
    print ("I'm pkg.a.fun() ")

檔案： pkg/b.py -

#!/usr/bin/python3
#coding=utf-8
# save file: pkg/b.py
def fun():
    print ("I'm pkg.b.fun() ")

檔案： pkg2/a.py -

#!/usr/bin/python3
#coding=utf-8
# save file: pkg2/a.py
def fun():
    print ("I'm pkg2.a.fun() ")

檔案： pkg2/b.py -

#!/usr/bin/python3
#coding=utf-8
# save file: pkg2/b.py
def fun():
    print ("I'm pkg2.b.fun() ")

在package目錄中建立一個主程式檔案：main.py，用於演示如何呼叫包中的各個檔案 -

#!/usr/bin/python3
#coding=utf-8
# save file: phone/pots.py

import pkg.a as a
import pkg.b as b

import pkg2.a as a2
import pkg2.b as b2

a.fun()
b.fun()

a2.fun()
b2.fun()

import pkg2.a
import pkg2.b

print('----------- another way -----------------')
pkg2.a.fun()
pkg2.b.fun()

整個程式碼的目錄如下所示 -

package
  |- pkg
      |- __init__.py
      |- a.py
      |- b.py
  |- pkg2
      |- __init__.py
      |- a.py
      |- b.py

當執行上述程式碼時，會產生以下結果 -

I'm pkg.a.fun() 
I'm pkg.b.fun() 
I'm pkg2.a.fun() 
I'm pkg2.b.fun() 
----------- another way -----------------
I'm pkg2.a.fun() 
I'm pkg2.b.fun()

在上面的例子中，將每個檔案中的一個函式作為範例，但是可以在檔案中編寫多個函式。還可以在這些檔案中定義不同的Python類，然後可以使用這些類來建立包。

第十六節 Python檔案讀寫

在本章中將介紹Python 3中可用的所有基本檔案讀取I/O功能。有關更多功能，請參考標準Python文件。

列印到螢幕

產生輸出的最簡單方法是使用print語句，可以傳遞零個或多個由逗號分隔的表示式。此函式將傳遞的表示式轉換為字串，並將結果寫入標準輸出，如下所示：

#!/usr/bin/python3

print ("Python是世界上最牛逼的語言,", "難道不是嗎?")

執行上面程式碼後，將在標準螢幕上產生以下結果 -

Python是世界上最牛逼的語言, 難道不是嗎?

從鍵盤讀取輸入

Python 2有兩個內建的函式用於從標準輸入讀取資料，預設情況下來自鍵盤。這兩個函式分別是：input()和raw_input()。

在Python 3中，不建議使用raw_input()函式。 input()函式可以從鍵盤讀取數並作為字串型別，而不管它是否用引號括起來(「或」「)。

>>> x = input("input something:")
input something:yes,input some string
>>> x
'yes,input some string'
>>> x = input("input something:")
input something:1239900
>>> x
'1239900'
>>>

開啟和關閉檔案

在前面我們學習讀取和寫入標準的輸入和輸出。 現在，來看看如何使用實際的資料檔案。Python提供了預設操作檔案所必需的基本功能和方法。可以使用檔案物件執行大部分檔案操作。

開啟檔案

在讀取或寫入檔案之前，必須使用Python的內建open()函式開啟檔案。此函式建立一個檔案物件，該物件將用於呼叫與其相關聯的其他支援方法。

語法

file object = open(file_name [, access_mode][, buffering])

這裡是引數詳細資訊 -

• file_name - file_name引數是一個字串值，指定要存取的檔案的名稱。
• access_mode - access_mode確定檔案開啟的模式，即讀取，寫入，追加等。可能的值的完整列表如下表所示。 這是一個可選引數，預設檔案存取模式為(r - 也就是唯讀)。
• buffering - 如果buffering值設定為0，則不會發生緩衝。 如果緩衝值buffering為1，則在存取檔案時執行行緩衝。如果將緩衝值buffering指定為大於1的整數，則使用指定的緩衝區大小執行緩衝操作。如果為負，則緩衝區大小為系統預設值(預設行為)。

以下是開啟檔案使用的模式的列表 -

編號	模式	描述
1	r	開啟的檔案為唯讀模式。檔案指標位於檔案的開頭，這是預設模式。
2	rb	開啟僅用二進位制格式讀取的檔案。檔案指標位於檔案的開頭，這是預設模式。
3	r+	開啟讀寫檔案。檔案指標放在檔案的開頭。
4	rb+	以二進位制格式開啟一個用於讀寫檔案。檔案指標放在檔案的開頭。
5	w	開啟僅供寫入的檔案。 如果檔案存在，則覆蓋該檔案。 如果檔案不存在，則建立一個新檔案進行寫入。
6	wb	開啟僅用二進位制格式寫入的檔案。如果檔案存在，則覆蓋該檔案。 如果檔案不存在，則建立一個新檔案進行寫入。
7	w+	開啟寫入和取讀的檔案。如果檔案存在，則覆蓋現有檔案。 如果檔案不存在，建立一個新檔案進行閱讀和寫入。
8	wb+	開啟一個二進位制格式的寫入和讀取檔案。 如果檔案存在，則覆蓋現有檔案。 如果檔案不存在，建立一個新檔案進行閱讀和寫入。
9	a	開啟一個檔案進行追加。 如果檔案存在，則檔案指標位於檔案末尾。也就是說，檔案處於追加模式。如果檔案不存在，它將建立一個新檔案進行寫入。
10	ab	開啟一個二進位制格式的檔案。如果檔案存在，則檔案指標位於檔案末尾。 也就是說，檔案處於追加模式。如果檔案不存在，它將建立一個新檔案進行寫入。
11	a+	開啟一個檔案，用於追加和閱讀。 如果檔案存在，則檔案指標位於檔案末尾。 檔案以附加模式開啟。 如果檔案不存在，它將建立一個新檔案進行閱讀和寫入。
12	ab+	開啟一個二進位制格式的附加和讀取檔案。 如果檔案存在，則檔案指標位於檔案末尾。檔案以附加模式開啟。如果檔案不存在，它將建立一個新檔案進行讀取和寫入。

檔案物件屬性

開啟一個檔案並且有一個檔案物件後，可以獲得與該檔案相關的各種資訊。

以下是與檔案物件相關的所有屬性的列表 -

編號	屬性	描述
1	file.closed	如果檔案關閉則返回true，否則返回false。
2	file.mode	返回開啟檔案的存取模式。
3	file.name	返回檔案的名稱。

注意 - Python 3.x中不支援softspace屬性

範例

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)
print ("Closed or not : ", fo.closed)
print ("Opening mode : ", fo.mode)
fo.close()

執行上面程式碼，這產生以下結果 -

Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb

close()方法

檔案物件的close()方法重新整理任何未寫入的資訊並關閉檔案物件，之後不能再進行寫入操作。
當檔案的參照物件重新分配給另一個檔案時，Python也會自動關閉一個檔案。但使用close()方法關閉檔案是個好習慣。

語法

fileObject.close();

範例

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)

# Close opened file
fo.close()

執行上面程式碼，這產生以下結果 -

Name of the file:  foo.txt

讀取和寫入檔案

檔案物件提供了一組存取方法，使程式碼編寫更方便。下面將演示如何使用read()和write()方法來讀取和寫入檔案。

write()方法

write()方法將任何字串寫入開啟的檔案。 重要的是要注意，Python字串可以是二進位制資料，而不僅僅是文字。

write()方法不會在字串的末尾新增換行符(‘\n‘)

語法

fileObject.write(string);

這裡，傳遞引數 - string 是要寫入開啟檔案的內容。

範例

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "w")
fo.write( "Python is a great language.\nYeah its great!!\n")

# Close opend file
fo.close()

上述範例將建立一個foo.txt檔案，並將給定的內容寫入到該檔案中，最後將關閉檔案。 在執行上面語句後，如果開啟檔案(foo.txt)，它將應該以下內容 -

Python is a great language.
Yeah its great!!

read()方法

read()方法用於從開啟的檔案讀取一個字串。 重要的是要注意Python字串除文字資料外可以是二進位制資料。。

語法

fileObject.read([count]);

這裡，傳遞引數 - count是從開啟的檔案讀取的位元組數。 該方法從檔案的開始位置開始讀取，如果count不指定值或丟失，則盡可能地嘗試讀取檔案，直到檔案結束。

範例

下面來一個檔案foo.txt，這是上面範例中建立的。

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)

# Close opened file
fo.close()

執行上面程式碼，這產生以下結果 -

Read String is :  Python is

檔案位置

tell()方法用於獲取檔案中的當前位置; 換句話說，下一次讀取或寫入將發生在從檔案開始處之後的多個位元組數的位置。

seek(offset [，from])方法更改當前檔案位置。 offset引數表示要移動的位元組數。 from引數指定要移動位元組的參照位置。

如果from設定為0，則將檔案的開頭作為參考位置。 如果設定為1，則將當前位置用作參考位置。 如果設定為2，則檔案的末尾將被作為參考位置。

範例

下面來一個檔案foo.txt，這是上面範例中建立的。

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)

# Check current position
position = fo.tell()
print ("Current file position : ", position)

# Reposition pointer at the beginning once again
position = fo.seek(0, 0)
str = fo.read(10)
print ("Again read String is : ", str)

# Close opened file
fo.close()

執行上面程式碼，這產生以下結果 -

Read String is :  Python is
Current file position :  10
Again read String is :  Python is

重新命名和刪除檔案

Python os模組提供用於執行檔案處理操作(如重新命名和刪除檔案)的方法。要使用此模組，需要先將它匯入，然後可以呼叫任何相關的函式。

rename()方法

rename()方法有兩個引數，即當前的檔案名和新的檔案名。

語法

os.rename(current_file_name, new_file_name)

範例

以下是一個將現有檔案test1.txt重新命名為test2.txt的範例 -

#!/usr/bin/python3
import os

# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )

remove()方法

使用remove()方法並通過提供要刪除的檔案的名稱作為引數來刪除檔案。

語法

os.remove(file_name)

範例

以下是刪除現有檔案test2.txt的範例 -

#!/usr/bin/python3
import os

# Delete file test2.txt
os.remove("text2.txt")

Python中的目錄

所有檔案都包含在各種目錄中，Python處理目錄問題也很容易。 os模組有幾種方法可以用來建立，刪除和更改目錄。

mkdir()方法

使用os模組的mkdir()方法在當前目錄中建立目錄。需要為此方法提供一個引數，指定要建立的目錄的名稱。

語法

os.mkdir("newdir")

範例

以下是在當前目錄中建立一個目錄：test 的範例 -

#!/usr/bin/python3
import os

# Create a directory "test"
os.mkdir("test")

使用chdir()方法來更改當前目錄。 chdir()方法接受一個引數，它是要選擇作為當前目錄的目錄的名稱。

語法

os.chdir("newdir")

範例

以下是進入「/home/newdir」目錄的範例 -

#!/usr/bin/python3
import os

# Changing a directory to "/home/newdir"
os.chdir("/home/newdir")

getcwd()方法

getcwd()方法用於顯示當前工作目錄。

os.getcwd()

範例

以下是給出當前目錄的一個例子 -

#!/usr/bin/python3
import os

# This would give location of the current directory
os.getcwd()

rmdir()方法

rmdir()方法刪除該方法中作為引數傳遞的目錄。刪除目錄之前，應刪除其中的所有內容。

os.rmdir('dirname')

範例

以下是刪除「/tmp/test」目錄的範例。需要給出目錄的完全限定名稱，否則將在當前目錄中搜尋該目錄。

#!/usr/bin/python3
import os

# This would  remove "/tmp/test"  directory.
os.rmdir( "/tmp/test"  )

檔案和目錄相關方法

有三個重要的來源，它們提供了廣泛的實用方法來處理和操作Windows和Unix作業系統上的檔案和目錄。它們如下 -

• 檔案物件和方法 - 檔案物件提供了操作檔案的功能。
• OS物件和方法 - 這提供了處理檔案和目錄的方法。