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.yiibai.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.yiibai.com" # 一個字符串

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

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

100
999.99 
Maxsu
http://www.yiibai.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

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 = 'yiibai.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 =  yiibai.com
str[0] =  y
str[2:5] =  iba
str[2:] =  ibai.com
str[-1] =  m
str * 2 =  yiibai.comyiibai.com
str + "TEST" =  yiibai.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'])

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

數據類型轉換

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

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

編號

函數

描述

int(x [,base])

將x轉換爲整數。如果x是字符串，則要base指定基數。

float(x)

將x轉換爲浮點數。

complex(real [,imag])

創建一個複數。

str(x)

將對象x轉換爲字符串表示形式。

repr(x)

將對象x轉換爲表達式字符串。

eval(str)

評估求值一個字符串並返回一個對象。

tuple(s)

將s轉換爲元組。

list(s)

將s轉換爲列表。

set(s)

將s轉換爲集合。

dict(d)

創建一個字典，d必須是(key，value)元組的序列

frozenset(s)

將s轉換爲凍結集

chr(x)

將整數x轉換爲字符

unichr(x)

將整數x轉換爲Unicode字符。

ord(x)

將單個字符x轉換爲其整數值。

hex(x)

將整數x轉換爲十六進制字符串。

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

有關算術運算符的示例代碼，請參考：：http://www.yiibai.com/python/arithmetic\_operators\_example.html

2.比較(關係)運算符

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

運算符

描述

示例

==

如果兩個操作數的值相等，則條件爲真。

(a == b)求值結果爲 false

!=

如果兩個操作數的值不相等，則條件爲真。

(a != b)求值結果爲 true

>

如果左操作數的值大於右操作數的值，則條件成爲真。

(a > b)求值結果爲 false

<

如果左操作數的值小於右操作數的值，則條件成爲真。

(a < b)求值結果爲 true

>=

如果左操作數的值大於或等於右操作數的值，則條件成爲真。

(a >= b)求值結果爲 false

<=

如果左操作數的值小於或等於右操作數的值，則條件成爲真。

(a <= b)求值結果爲 true

有關比較(關係)運算符的示例代碼，請參考：http://www.yiibai.com/python/comparison\_operators\_example.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

有關賦值運算符的示例代碼，請參考：http://www.yiibai.com/python/assignment\_operators\_example.html

4.邏輯運算符

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

運算符

描述

示例

and

如果兩個操作數都爲真，則條件成立。

(a and b)的結果爲False

or

如果兩個操作數中的任何一個非零，則條件成爲真。

(a or b)的結果爲True

not

用於反轉操作數的邏輯狀態。

not(a and b) 的結果爲True。

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

Python快速入門

如果它存在於任一操作數，則複製位。

(a Python快速入門 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.yiibai.com/python/bitwise\_operators\_example.html

6.成員運算符

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

運算符

描述

示例

in

如果在指定的序列中找到一個變量的值，則返回true，否則返回false。

not in

如果在指定序列中找不到變量的值，則返回true，否則返回false。

有關成員運算符的示例代碼，請參考：http://www.yiibai.com/python/membership\_operators\_example.html

7.身份運算符

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

運算符

描述

示例

is

如果運算符任一側的變量指向相同的對象，則返回True，否則返回False。

is not

如果運算符任一側的變量指向相同的對象，則返回True，否則返回False。

有關身份運算符的示例代碼，請參考：http://www.yiibai.com/python/identity\_operators\_example.html

8. 運算符優先級

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

序號

運算符

描述

**

指數(次冪)運算

~ + -

補碼，一元加減(最後兩個的方法名稱是+@和-@)

* / % //

乘法，除法，模數和地板除

+ -

>> <<

向右和向左位移

&

按位與

^ Python快速入門

按位異或和常規的「OR」

<= < > >=

比較運算符

<> == !=

等於運算符

= %= /= //= -= += *= **=

賦值運算符

is is not

身份運算符

in not in

成員運算符

not or and

邏輯運算符

有關運算符優先級的示例代碼，請參考：http://www.yiibai.com/python/operators\_precedence\_example.html

第六節 Python決策

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

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

Python快速入門

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

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

編號

語句

描述

if語句

一個if語句由一個布爾表達式，後跟一個或多個語句組成。

if…else語句

一個if語句可以跟隨一個可選的else語句，當if語句的布爾表達式爲FALSE時，則else語句塊將被執行。

嵌套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快速入門

Python編程語言提供以下類型的循環來處理循環需求。

編號

循環

描述

while循環

在給定條件爲TRUE時，重複一個語句或一組語句。它在執行循環體之前測試狀態。

for循環

多次執行一系列語句，並縮寫管理循環變量的代碼。

嵌套循環

可以使用一個或多個循環在while或for循環中。

循環控制語句

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

Python支持以下控制語句。

編號

控制語句

描述

break語句

終止循環語句並將執行轉移到循環之後的語句。

continue語句

使循環跳過其主體的剩餘部分，並立即重新測試其狀態以進入下一次迭代。

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

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

編號

函數

描述

abs(x)

x的絕對值，x與零之間的(正)距離。

ceil(x)

x的上限，不小於x的最小整數。

cmp(x, y)

如果 x < y 返回 -1, 如果 x == y 返回 0, 或者如果 x > y 返回 1。在Python 3中已經棄用，可使用return (x>y)-(x<y)代替。

exp(x)

x的指數，返回e的x次冪

fabs(x)

x的絕對值。

floor(x)

不大於x的最大整數。

log(x)

x的自然對數(x > 0)。

log10(x)

以基數爲10的x的對數(x > 0)。

max(x1, x2,…)

給定參數中的最大值，最接近正無窮大值

min(x1, x2,…)

給定參數中的最小值，最接近負無窮小值

modf(x)

將x的分數和整數部分切成兩項放入元組中，兩個部分與x具有相同的符號。整數部分作爲浮點數返回。

pow(x, y)

x的y次冪

round(x [,n])

x從小數點舍入到n位數。round(0.5)結果爲 1.0， round(-0.5) 結果爲 -1.0

sqrt(x)

x的平方根(x > 0)。

隨機數函數

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

編號

函數

描述

choice(seq)

來自列表，元組或字符串的隨機項目。

randrange ([start,] stop [,step])

從範圍(start, stop, step)中隨機選擇的元素。

random()

返回隨機浮點數r(0 <= r < 1)

seed([x])

設置用於生成隨機數的整數起始值。在調用任何其他隨機模塊功能之前調用此函數，返回None。

shuffle(lst)

將列表的項目隨機化到位置。返回None。

uniform(x, y)

返回隨機浮點數 r (x <= r < y)。

三角函數

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

編號

函數

描述

acos(x)

返回x的弧餘弦值，以弧度表示。

asin(x)

返回x的弧線正弦，以弧度表示。

atan(x)

返回x的反正切，以弧度表示。

atan2(y, x)

返回atan(y / x)，以弧度表示。

cos(x)

返回x弧度的餘弦。

hypot(x, y)

返回歐幾里得規範，sqrt(x*x + y*y)

sin(x)

返回x弧度的正弦。

tan(x)

返回x弧度的正切值。

degrees(x)

將角度x從弧度轉換爲度。

radians(x)

將角度x從角度轉換爲弧度。

數學常數

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

編號

常量

描述

數學常數pi

數學常數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!

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

編號

格式化符號

轉換

%c

字符

%s

在格式化之前通過str()函數轉換字符串

%i

帶符號的十進制整數

%d

帶符號的十進制整數

%u

無符號十進制整數

%o

八進制整數

%x

十六進制整數(小寫字母)

%X

十六進制整數(大寫字母)

%e

指數符號(小寫字母’e‘)

%E

指數符號(大寫字母’E‘

%f

浮點實數

%g

％f和％e

%G

％f和％E

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

編號

符號

功能

*

參數指定寬度或精度

-

左對齊

+

顯示標誌或符號

<sp>

在正數之前留空格

#

根據是否使用「x」或「X」，添加八進制前導零(‘0‘)或十六進制前導’0x‘或’0X‘。

0

使用零作爲左邊墊符(而不是空格)

%

‘%%‘留下一個文字「%」

(var)

映射變量(字典參數)

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

編號

方法

說明

capitalize()

把字符串的第一個字母轉爲大寫

center(width, fillchar)

返回使用fillchar填充的字符串，原始字符串以總共width列爲中心。

count(str, beg = 0,end = len(string))

計算字符串中出現有多少次str或字符串的子字符串(如果開始索引beg和結束索引end,則在beg~`end`範圍匹配)。

decode(encoding = ‘UTF-8’,errors = ‘strict’)

使用編碼encoding解碼該字符串。編碼默認爲默認字符串encoding。

encode(encoding = ‘UTF-8’,errors = ‘strict’)

返回字符串的編碼字符串版本; 在錯誤的情況下，默認是拋出ValueError，除非使用’ignore‘或’replace‘給出錯誤。

endswith(suffix, beg = 0, end = len(string))

確定字符串或字符串的子字符串(如果啓動索引結束和結束索引結束)都以後綴結尾; 如果是則返回true，否則返回false。

expandtabs(tabsize = 8)

將字符串中的製表符擴展到多個空格; 如果沒有提供tabize，則默認爲每個製表符爲8個空格。

find(str, beg = 0 end = len(string))

如果索引beg和結束索引end給定，則確定str是否在字符串或字符串的子字符串中，如果找到則返回索引，否則爲-1。

index(str, beg = 0, end = len(string))

與find()相同，但如果沒有找到str，則引發異常。

isalnum()

如果字符串至少包含1個字符，並且所有字符均爲數字，則返回true，否則返回false。

isalpha()

如果字符串至少包含1個字符，並且所有字符均爲字母，則返回true，否則返回false。

isdigit()

如果字符串只包含數字則返回true，否則返回false。

islower()

如果字符串至少包含1個字母，並且所有字符均爲小寫，則返回true，否則返回false。

isnumeric()

如果unicode字符串只包含數字字符，則返回true，否則返回false。

isspace()

如果字符串只包含空格字符，則返回true，否則返回false。

istitle()

如果字符串正確「標題大小寫」，則返回true，否則返回false。

isupper()

如果字符串至少包含一個可變大小寫字符，並且所有可變大小寫字符均爲大寫，則返回true，否則返回false。

join(seq)

將序列seq中的元素以字符串表示合併(併入)到具有分隔符字符串的字符串中。

len(string)

返回字符串的長度

ljust(width[, fillchar])

返回一個空格填充的字符串，原始字符串左對齊到總共width列。

lower()

將字符串中的所有大寫字母轉換爲小寫。

lstrip()

刪除字符串中的所有前導空格

maketrans()

返回在translate函數中使用的轉換表。

max(str)

從字符串str返回最大字母字符。

replace(old, new [, max])

如果給定max值，則用new或最多最大出現替換字符串中所有出現的舊字符(old)。

rindex( str, beg = 0, end = len(string))

與index()相同，但在字符串中向後搜索。

rjust(width,[, fillchar])

返回一個空格填充字符串，原始字符串右對齊到總共寬度(width)列。

rstrip()

刪除字符串的所有尾隨空格。

split(str=

根據分隔符str(空格，如果沒有提供)拆分字符串並返回子字符串列表; 如果給定，最多分割爲num子串。

splitlines( num=string.count(‘\n’)))」)

全部拆分字符串(或num)新行符，並返回每行的列表，並刪除新行符。

startswith(str, beg=0,end=len(string))

確定字符串或字符串的子字符串(如果給定起始索引beg和結束索引end)以str開頭; 如果是則返回true，否則返回false。

strip([chars])

對字符串執行lstrip()和rstrip()

swapcase()

反轉在字符串中的所有字母大小寫，即小寫轉大寫，大寫轉小寫。

title()

返回字符串的標題版本，即所有單詞第一個字母都以大寫開頭，其餘的都是小寫的。

translate(table, deletechars=

根據轉換表STR(256個字符)，除去那些在del字符串轉換字符串。

upper()

將字符串中的小寫字母轉換爲大寫。

zfill(width)

返回原始字符串，左邊填充爲零，總共有寬度(width)字符; 對於數字zfill()保留給定的任何符號(少於一個零)。

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])

列表的長度

[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包括以下列表函數功能 -

編號

方法

描述

cmp(list1, list2)

在Python 3中不再可用。

len(list)

給出列表的總長度。

max(list)

從列表中返回最大值的項目。

min(list)

從列表中返回最小值的項目。

list(seq)

將元組轉換爲列表。

Python包括以下列表方法 -

編號

方法

描述

list.append(obj)

將對象obj追加到列表中

list.count(obj)

返回列表中出現多少次obj的計數

list.extend(seq)

返回列表中出現多少次obj的計數

list.extend(seq)

將seq的內容附加到列表中

list.insert(index, obj)

將對象obj插入到偏移索引的列表中

list.pop(obj = list[-1])

從列表中刪除並返回最後一個對象或obj

list.remove(obj)

從列表中刪除對象obj

list.reverse()

反轉列表中的對象

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包括以下元組函數 -

編號

函數

描述

cmp(tuple1, tuple2)

比較兩個元組的元素。

len(tuple)

給出元組的總長度。

max(tuple)

從元組返回最大值項。

min(tuple)

從元組返回最大值項

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

編號

函數

描述

cmp(dict1, dict2)

在Python 3中不再可用。

len(dict)

計算出字典的總長度。它將等於字典中的數據項數目。

str(dict)

生成字典的可打印字符串表示形式

type(variable)

返回傳遞變量的類型。如果傳遞變量是字典，那麼它將返回一個字典類型。

Python包括以下字典方法 -

編號

函數

描述

dict.clear()

刪除字典dict的所有元素

dict.copy()

返回字典dict的淺拷貝

dict.fromkeys()

創建一個新的字典，其中包含seq的值和設置爲value的值。

dict.get(key, default=None)

對於鍵(key)存在則返回其對應值，如果鍵不在字典中，則返回默認值

dict.has_key(key)

此方法已刪除，使用in操作符代替

dict.items()

返回字典dict的(key，value)元組對的列表

dict.keys()

返回字典dict的鍵列表

dict.setdefault(key, default = None)

類似於get()，如果key不在字典dict中，則將執行賦值操作：dict [key] = default

dict.update(dict2)

將字典dict2的鍵值對添加到字典dict

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。

Python快速入門

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

索引

字段

值

4位數，表示年份

2018，2019…

月份

1 ~ 12

日期

1 ~ 31

小時

0 ~ 23

分鐘

0 ~ 59

秒

0 ~ 61(60或61是閏秒)

星期幾

0 ~ 6(0是星期一)

一年的第幾天

1 ~ 366(朱利安日)

夏令時

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

索引

字段

值

tm_year

2018，2019…

tm_mon

1 ~ 12

tm_mday

1 ~ 31

tm_hour

0 ~ 23

tm_min

0 ~ 59

tm_sec

0 ~ 61(60或61是閏秒)

tm_wday

0 ~ 6(0是星期一)

tm_yday

1 ~ 366(朱利安日)

tm_isdst

-1，0，1，-1表示庫確定DST

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

Python快速入門

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.altzone

本地DST時區的偏移量(以秒爲單位的UTC)，如果定義了有一個定義的話。如果本地的DST時區是UTC的東部(如在西歐，包括英國)，那麼它是負數值。

time.asctime([tupletime])

接受時間元組，並返回一個可讀的24個字符的字符串，例如’Tue Dec 11 22:07:14 2019’。

time.clock( )

將當前CPU時間返回爲浮點數秒。爲了測量不同方法的計算成本，time.clock的值比time.time()的值更有用。

time.ctime([secs])

類似於asctime(localtime(secs))，而沒有參數就像asctime()

time.gmtime([secs])

接受從時代(epoch)以秒爲單位的瞬間，並返回與UTC時間相關的時間元組t。注 - t.tm_isdst始終爲0

time.localtime([secs])

接受從時代(epoch)以秒爲單位的瞬間，並返回與本地時間相關的時間t(t.tm_isdst爲0或1，具體取決於DST是否適用於本地規則的瞬時秒)。

time.mktime(tupletime)

接受在本地時間表示爲時間元組的瞬間，並返回浮點值，該時間點以秒爲單位表示。

time.sleep(secs)

暫停調用線程secs秒。

time.strftime(fmt[,tupletime])

接受在本地時間表示爲時間元組的瞬間，並返回一個表示由字符串fmt指定的時間的字符串。

time.strptime(str,fmt = ‘%a %b %d %H:%M:%S %Y’)「)

根據格式字符串fmt解析str，並返回時間元組格式的時間。

time.time( )

返回當前時間時刻，即從時代(epoch)開始的浮點數秒數。

time.tzset()

重置庫例程使用的時間轉換規則。環境變量TZ指定如何完成。

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

編號

屬性

描述

time.timezone

屬性time.timezone是UTC和本地時區(不含DST)之間的偏移量(美洲爲 > 0，歐洲，亞洲，非洲大部分地區爲 0)。

time.tzname

屬性time.tzname是一對與區域相關的字符串，它們分別是沒有和具有DST的本地時區的名稱。

4.日曆模塊

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

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

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

編號

函數

描述

calendar.calendar(year,w = 2,l = 1,c = 6)

返回一個具有年份日曆的多行字符串格式化爲三列，以c個空格分隔。 w是每個日期的字符寬度; 每行的長度爲21 * w + 18 + 2 * c，l是每週的行數。

calendar.firstweekday( )

返回當前設置每週開始的星期。默認情況下，當日歷首次導入時設置爲：0，表示爲星期一。

calendar.isleap(year)

如果給定年份(year)是閏年則返回True; 否則返回：False。

calendar.leapdays(y1,y2)

返回在範圍(y1，y2)內的年份中的閏年總數。

calendar.month(year,month,w = 2,l = 1)

返回一個多行字符串，其中包含年份月份的日曆，每週一行和兩個標題行。 w是每個日期的字符寬度; 每行的長度爲7 * w + 6。 l是每週的行數。

calendar.monthcalendar(year,month)

返回int類型的列表。每個子列表表示一個星期。年份月份以外的天數設置爲0; 該月內的日期設定爲月份的第幾日：1 ~ 31。

calendar.monthrange(year,month)

返回兩個整數。第一個是年度月(month)的星期幾的代碼; 第二個是當月的天數。表示星期幾爲0(星期一)至6(星期日); 月份是1到12。

calendar.prcal(year,w = 2,l = 1,c = 6)

類似於：calendar.calendar(year，w，l，c)的打印。

calendar.prmonth(year,month,w = 2,l = 1)

類似於：calendar.month(year,month,w,l)的打印。

calendar.setfirstweekday(weekday)

將每週的第一天設置爲星期幾的代碼。星期幾的代碼爲0(星期一)至6(星期日)。

calendar.timegm(tupletime)

time.gmtime的倒數：以時間元組的形式接受時刻，並返回與從時代(epoch)開始的浮點數相同的時刻。

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

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

編號

模式

描述

r

打開的文件爲只讀模式。文件指針位於文件的開頭，這是默認模式。

rb

打開僅用二進制格式讀取的文件。文件指針位於文件的開頭，這是默認模式。

r+

打開讀寫文件。文件指針放在文件的開頭。

rb+

以二進制格式打開一個用於讀寫文件。文件指針放在文件的開頭。

w

打開僅供寫入的文件。如果文件存在，則覆蓋該文件。如果文件不存在，則創建一個新文件進行寫入。

wb

打開僅用二進制格式寫入的文件。如果文件存在，則覆蓋該文件。如果文件不存在，則創建一個新文件進行寫入。

w+

打開寫入和取讀的文件。如果文件存在，則覆蓋現有文件。如果文件不存在，創建一個新文件進行閱讀和寫入。

wb+

打開一個二進制格式的寫入和讀取文件。如果文件存在，則覆蓋現有文件。如果文件不存在，創建一個新文件進行閱讀和寫入。

a

打開一個文件進行追加。如果文件存在，則文件指針位於文件末尾。也就是說，文件處於追加模式。如果文件不存在，它將創建一個新文件進行寫入。

ab

打開一個二進制格式的文件。如果文件存在，則文件指針位於文件末尾。也就是說，文件處於追加模式。如果文件不存在，它將創建一個新文件進行寫入。

a+

打開一個文件，用於追加和閱讀。如果文件存在，則文件指針位於文件末尾。文件以附加模式打開。如果文件不存在，它將創建一個新文件進行閱讀和寫入。

ab+

打開一個二進制格式的附加和讀取文件。如果文件存在，則文件指針位於文件末尾。文件以附加模式打開。如果文件不存在，它將創建一個新文件進行讀取和寫入。

文件對象屬性

打開一個文件並且有一個文件對象後，可以獲得與該文件相關的各種信息。

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

編號

屬性

描述

file.closed

如果文件關閉則返回true，否則返回false。

file.mode

返回打開文件的訪問模式。

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

Python教程

面向對象

高級部分

其它雜項

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

第二節 Python安裝和環境配置

第三節 Python命令行參數

示例

解析命令行參數

示例

第四節 Python變量類型

將值分配給變量

多重賦值

標準數據類型

1.Python數字

2.Python字符串

2.Python列表

3.Python元組

Python字典

數據類型轉換

第五節 Python基本運算符

運算符類型

1.算術運算符

2.比較(關係)運算符

3.賦值運算符

4.邏輯運算符

5.按位運算符

6.成員運算符

7.身份運算符

8. 運算符優先級

第六節 Python決策

單個語句套件

第七節 Python循環

循環控制語句

迭代器和生成器

示例

第八節 Python數字

數字類型轉換

數學函數

隨機數函數

三角函數

數學常數

第九節 Python字符串

1.訪問字符串中的值

2.更新字符串

3.轉義字符

4.字符串特殊運算符

5.字符串格式化運算符

6.三重引號

7.Unicode字符串

第十節 Python列表

1.Python列表

2.訪問列表中的值

3.更新列表

4.刪除列表元素

基本列表操作

索引，切片和矩陣

內置列表函數和方法

第十一節 Python元組

1.訪問元組中的值

2.更新元組

3.刪除元組元素

4.基本元組操作

5.索引，切片和矩陣

6.內置元組函數功能

第十二節 Python字典

1.訪問字典中的值

2.更新字典

3.刪除詞典元素

4. 字典鍵的屬性

5.內置詞典函數和方法

第十三節 Python日期和時間

一些常用代碼示例

1. 時間間隔

2. 什麼是TimeTuple？

2.1.獲取當前時間

2.2.獲取格式化時間

2.3.獲取一個月的日曆

3.時間模塊