Python 類型的層次結構

Python 編程語言是一種簡單但功能強大的語言。本文將探索該語言的對象屬性，開頭部分介紹了一些簡單的內置數據類型。此外，本文還介紹了 Python 元組類，并用它演示容器類型的概念。
在 Python 語言中，所有事物都是程序可以訪問的對象, 其中包括保存整數的簡單類型，以及您編寫的實際代碼和這些代碼在 Python 解釋器中的表示。對于熟悉其他編程語言的人來說，此行為可能導致某些混亂。但是，在實踐中，不會出現這種情況。Python 有一個良好定義的類型（或對象）層次結構。該層次結構在概念上可以劃分為四種類別：簡單類型、容器類型、代碼類型 和內部類型。這四種類別和簡單類型本身在本系列的第一篇文章“Python 入門，第 1 部分：Python 的內置數據類型”中作了介紹。本文將再次查看可以在 Python 中使用的那些簡單的內置數據類型，這次著重介紹這些類型的對象屬性。然后，我們將介紹容器 類型的概念，并且將 Python tuple 類作為此類型的第一個示例，進行重點介紹。

簡單類型
內置到 Python 編程語言中的簡單數據類型包括：

bool
int
float
complex
支持簡單數據類型不是 Python 獨有的功能，因為多數現代編程語言都具有完整類型補充。例如 Java? 語言甚至有一組更豐富的原始數據類型：

byte
short
int
long
float
double
char
boolean
但是，在 Python 中，簡單數據類型并不是原始數據類型，而是完善的對象，它們有自已的方法和類。另外，這些簡單的內置類型是不可改變的，這意味著：創建對象之后，您無法更改對象的值。如果需要新值，則必須創建新的對象。Python 簡單數據類型的不可改變特性與其他多數流行語言（如 Java 語言）處理簡單原始類型的方式不同。但是，當您對這些簡單數據類型的對象屬性有了更多的了解之后，就很容易理解這種差異。

所以，整數如何能夠擁有一些方法？它僅僅是一個數字嗎？不是的，至少在 Python 中答案是否定的。您自已可以對它進行檢驗：僅借助內置的 help 方法，就可以向 Python 解釋器咨詢關于 int 對象的信息（參見清單 1 ）。

清單 1. Python 解釋器: 用于整數對象的 Help

rb% python
Python 2.4 (#1, Mar 29 2005, 12:05:39)
[GCC 3.3 20030304ppp(Apple Computer, Inc. build 1495)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> help(int)

Help on class int in module __builtin__:

class int(object)
 |  int(x[, base]) -> integer
 | 
 |  Convert a string or number to an integer, if possible.  A floating point
 |  argument will be truncated towards zero (this does not include a string
 |  representation of a floating point number!)  When converting a string, use
 |  the optional base.  It is an error to supply a base when converting a
 |  non-string. If the argument is outside the integer range a long object
 |  will be returned instead.
 | 
 |  Methods defined here:
 | 
 |  __abs__(...)
 |      x.__abs__() <==> abs(x)
 | 
 |  __add__(...)
 |      x.__add__(y) <==> x+y
...

這具體說明了什么？只有一個事情，那就是可以方便地從 Python 解釋器中得到幫助，但是從后面部分可以獲得更多幫助。第一行告訴您正在查看 int 類的幫助頁面，它是一個內置的數據類型。如果您對面向對象的編程的概念不太熟悉，那么可以將類 想像成只是一個用于構建特殊事物并與之交互的藍圖。好比房子的設計藍圖，不僅顯示如何構建房子，還顯示房子完工之后，如何更好地使用房子。例如，設計圖會顯示不同房間的位置、在房間之間的移動方式以及出入房子的通道情況。

第一行的下面是對實際 int 類的詳細說明。在這一點上，您可能不熟悉如何在 Python 中創建類，因為顯示的語法類似于外語。沒關系，我將在另一篇文章中對此進行全面介紹?，F在，您只需要知道：int 對象是從 object 類中繼承而來，它是 Python 中許多內容的一個基類。

后面的幾行介紹 int 類的構造函數。構造函數 只是創建特定類實例（或對象) 的特殊方法。構造函數方法好比建筑承包人，它利用房子的設計圖建房子。在 Python 中，構造函數的名稱與其創建的類的名稱相同。類可以有不同的構造函數方法，這些方法是通過類名稱后的圓括號內附帶的不同屬性進行區分。類可以有不同構造函數方法的較好的一個例子就是 int 類, 實際上，您可以用多種方法調用它，具體采用哪種方法取決于圓括號中放置的參數（參見清單 2）。

清單 2. Python 解釋器：int 類構造函數

>>> int()
0
>>> int(100)          # Create an integer with the value of 100

>>> int("100", 10)    # Create an integer with the value of 100 in base 10
100

100
>>> int("100", 8)     # Create an integer with the value of 100 in base 8

64

這四個構造函數調用創建了四個不同的整數。第一個構造函數創建了一個整數對象，其值為 0，在沒有值提供給 int 類構造函數的情況下，該值是所使用的默認值。第二個構造函數根據規定創建了一個值為 100 的整數。第三個構造函數采用了字符串“100”并創建了以 10 為基數的整數值（常見的十進制系統）。最后一個構造函數也采用了字符串“100”—— 但是它使用基數 8 來創建整數值，通常稱為 八進制。不過，該值在輸出時會被轉換成十進制數值，這就是該數字顯示為 64 的原因。

您可能想知道如果省略了構造函數調用中的圓括號將會發生什么。在這種情況下，您可以向該變量分配一個實際的類名稱，有效地為原先的類創建一個別名（參見清單 3）。

清單 3. Python 解釋器：int 類型

>>> it = int         #  Create an alias to the integer class
>>> it(100)
100
>>> type(it)         #  We created a new type

<type 'type'>
>>> type(it(100))    #  Our new type just makes integers
<type 'int'>

真是太棒了！您立即可以創建一個由內置 int 類定義的新數據類型。但請注意不好的一面，不要濫用這一新功能。優秀的程序員除了使代碼具有良好性能外，還應努力使代碼清淅。這類編碼技巧的確有其使用價值，但它們并不常見。

使用 Python 解釋器可以使新的 Python 程序員簡化學習過程，少走彎路。如果您想詳細了解 Python 內的 help 工具，只需在 Python 解釋器中的命令提示符下鍵入 help() ，就可以訪問交互式的幫助工具（參見清單 4)。

清單 4. Python 解釋器：幫助解釋器

>>> help()

Welcome to Python 2.4!  This is the online help utility.

If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://www.python.org/doc/tut/.

Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".

To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics".  Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".

help>

您可能已經對此有所了解，但在 help> 提示符處輸入 int 可以顯示那些為以前的 int 類顯示的類描述。

容器類型
到目前為止，已經談論了許多 Python 語言中使用的簡單類型。但是多數程序并不簡單，它們涉及通常由簡單類型組成的復雜數據。因此，現在的問題就成了“如何在 Python 中處理復雜數據？”

如果您熟悉面向對象的語言，如 Java 或 C#，那么您可能認為該問題的答案很簡單：只需創建一個新類來處理復雜的數據即可。該方法也適用于 Python，原因是 Python 支持通過類創建新類型。但是，在多數情況下，Python 還可以提供更為簡單的方法。當您的程序需要一次處理多個對象時，就可以利用 Python 容器類：

tuple
string
unicode
list
set
frozenset
dictionary
這些容器類型提供了兩種功能。前六個類型是有序的，最后一個類型 dictionary 則是一個映射。有序類型與映射類型的區別較為簡單。有序類型 僅僅是指對象的順序。所有的有序類型（除 set 和 frozenset 類型外）都支持訪問給定順序的對象。相比之下，映射容器 則用于保存那些對順序不是很敏感的對象；通過提供可以找到關系值的密鑰，就可以從容器中提取值。

容器類型間的另一個不同點來自于它們所持有的數據的特性，下面四種容器類型的順序是不可變的：

tuple
string
unicode
frozenset
這意味著在您創建了這些容器類型之一后，所存儲的數據就不可更改。如果出于某種原因需要更改數據，則需要創建一個新容器來保存新的數據。

后三種容器類型（list、set 和 dictionary）都是可變容器，因此，它們可以根據需要更改保存的任何數據（但在 dictionary 中所使用的密鑰是不可變的，就像您房間的鑰匙）。雖然可變容器非常靈活，但它們的動態特性會對性能造成影響。例如，tuple 類型，盡管它是不可變的，靈活性較差，但在同一環境中使用時，它們通常比 list 類型快得多。

這些容器類提供了強大的功能，它們通常是多數 Python 程序的核心。本文的其余部分討論了 tuple 類型，它用于引入許多與創建和使用 Python 中的容器類型有關的基本概念。其余的類型將在以后的文章中討論。

元組
tuple 類型像一個口袋，在出門前可以把所需的任何東西一股腦地放在里面。您可以將鑰匙、駕駛證、便箋簿和鋼筆放在口袋里，您的口袋是存放各種東西的收集箱。Python 的 tuple 類型與口袋類似，它可以存放不同類型的對象。您只需向變量分配一個用逗號分隔的對象序列，就可以創建一個 tuple（參見清單 5）。

清單 5. Python 解釋器：創建一個 tuple

>>> t = (0,1,2,3,4,5,6,7,8,9)
>>> type(t)
<type 'tuple'>
>>> t
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> tt = 0,1,2,3,4,5,6,7,8,9
>>> type(tt)
<type 'tuple'>
>>> tt
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> tc=tuple((0,1,2,3,4,5,6,7,8,9))
>>> tc
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> et = ()     # An empty tuple
>>> et
()
>>> st = (1,)   # A single item tuple
>>> st
(1,)

該示例代碼顯示了如何以多種方式創建 tuple。第一種方法是創建一個包含從 0 到 9 整數序列的 tuple。第二種方法與第一種相同，但這次省去了括號。在創建一個 tuple 時，括號通常是可選的，但有時是必需的，這取決于上下文。結果，您會習慣性地使用括號來減少混淆。最后一個 tupletc 使用了一個實際的類構造函數來創建 tuple。這里重要的一點是，構造函數構成中僅有一個變量，因此您必須在括號中包括對象序列。最后兩個構造函數調用演示了如何通過在括號內不放任何東西來創建空的 tuple (et)，以及如何通過將一個逗號放在序列中僅有的一個項目后面來創建 tuple (st)。

使用口袋裝東西的一個主要原因是為了方便生活。但要求在需要這些東西的時候能夠迅速地從口袋中取出它們。Python 中的多數容器類型（其中包括 tuple）允許您使用方括號操作符從集合中方便地訪問數據項。但 Python 比其他語言更具靈活性：您可以使用通常稱為分段 的方法選擇一個項目或多個有序項目（參見清單 6）。

清單 6. Python 解釋器：從 tuple 訪問項目

>>> t = (0,1,2,3,4,5,6,7,8,9)
>>> t[2]
2
>>> type(t[2])
<type 'int'>
>>> t[0], t[1], t[9]
(0, 1, 9)
>>> t[2:7]            # Slice out five elements from the tuple
(2, 3, 4, 5, 6)
>>> type(t[2:7])
<type 'tuple'>
>>> t[2:7:2]          # Slice out three elements from the tuple
(2, 4, 6)

在創建簡單的 tuple 之后，前面的示例顯示如何選擇一個數據項 —— 在本示例中是整數 2。這時，請注意 Python 使用了零排序，其中集合中的項目從零開始編號。如果您熟悉使用 Java 語言、C# 或其他從 C 語言派生的語言進行編程，那么您應該非常熟悉此行為。否則，該概念也是非常簡單的。用于訪問數據項的索引只聲明集合中越過第一個數據項有多遠，或者稱為序列，您需要去獲得所需的內容。因此，要獲得第三個數據項（在本示例中為整數 2），您需要從第一個數據項起越過兩個數據項。在訪問第三個數據項時，Python 知道它是一個整數對象。您還可以方便地從集合中提取多個數據項。在本示例中，您創建了一個新的 tuple，其值為從最初的 tuple 開始第一、第二和第十個值。

其余的示例顯示了如何使用 Python 的分段功能從序列中一次選擇多個數據項。術語分段 是指從序列中對數據項進行分段的方法。分段的工作方式是聲明開始索引、結束索引和一個可選的步驟大小，全部都用分號分隔。因此，t[2:7] 將 tuple 中的第三到第七個數據項分段，而 t[2:7:2] 則對每兩個數據項進行分段，從 tuple 中的第三個數據項開始一直到第七個數據項。

我目前創建的 tuple 對象是同類的，它們僅包含整數對象。所幸的是，tuple 要比顯示的示例復雜得多，因為 tuple 實際上是一個異構容器（參見清單 7）。

清單 7. Python 解釋器：異構的 tuple

>>> t = (0,1,"two",3.0, "four", (5, 6))
>>> t
(0, 1, 'two', 3.0, 'four', (5, 6))
>>> t[1:4]
(1, 'two', 3.0)
>>> type(t[2])
<type 'str'>
>>> type(t[3])
<type 'float'>
>>> type(t[5])
<type 'tuple'>
>>> t[5] = (0,1)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: object does not support item assignment

您會看到，創建可以擁有各種類型數據項（其中包括另一 tuple）的 tuple 是多么方便。并且可以使用方括號操作符以相同的方式訪問所有數據項，它支持將不同類型的有序數據項分段。然而，tuple 是不可變的。因此，當我嘗試更改第五個元素時，發現不允許對數據項分配。打一個簡單的比方，在您將某些東西放入口袋后，改變所取東西的惟一方式是取一個新口袋，并將所有數據項放進去。

如果需要在現有 tuple 中創建一個包含數據項子集的新 tuple，最簡單的方法是使用相關的片段，并根據需要同時添加子集（參見清單 8）。

清單 8. Python 解釋器：使用 tuple

>>> tn = t[1:3] + t[3:6]  # Add two tuples
>>> tn
(1, 'two', 3.0, 'four', (5, 6))
>>> tn = t[1:3] + t[3:6] + (7,8,9,"ten")
>>> tn
(1, 'two', 3.0, 'four', (5, 6), 7, 8, 9, 'ten')
>>> t2 = tn[:]            # Duplicate an entire tuple, a full slice

>>> t2
(1, 'two', 3.0, 'four', (5, 6), 7, 8, 9, 'ten')
>>> len(tn)               # Find out how many items are in the tuple
9 
>>> tn[4][0]              # Aclearcase/" target="_blank" >ccess a nested tuple
5

您還可以將現有 tuple 的片段與新 tuple 的片段合并在一起。使用片段語法，無需指定開始或結束索引，就可以制作現有 tuple 的副本。最后兩個示例也非常有趣。內置的 len 方法告訴您 tuple 中數據項的數量。從嵌套的 tuple 訪問數據項也非常簡單：選擇嵌套的 tuple，然后從中訪問有趣的數據項。

您還可以從稱為打包 的過程的一組現有變量中創建一個tuple。反之亦然，其中，tuple 中的值被指派給變量。這之后的過程稱為解包，它是用于許多情形的功能十分強大的技術，其中包括希望從一個函數中返回多個值。在解包 tuple 時，僅有的問題是必須為 tuple 中的每個數據項提供一個變量（參見清單 9）。

清單 9. Python 解釋器：打包和解包 tuple

>>> i = 1
>>> s = "two"
>>> f = 3.0
>>> t = (i, s, f)         # Pack the variables into a tuple
>>> t
(1, 'two', 3.0)
>>> ii, ss, ff = t        # Unpack the tuple into the named variables

>>> ii
1
>>> ii, ff = t            # Not enough variables to unpack three element tuple
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: too many values to unpack
 

簡化概念
盡管看上去十分復雜，但 Python 的對象屬性實際上簡化了 Python 語言新手常常面臨的一些更為復雜的概念。在了解如何使用對象之后，所有東西都是對象這一概念意味著您已經進一步理解了一些新概念。如 Python 的容器類型。使困難的任務變得簡單化是使用 Python 得到的常見好處之一；另一個例子是內置的幫助工具，只需在 Python 提示符處輸入 help()，就可以在 Python 解釋器中看到該工具。由于生活不是用一些簡單的概念描述的，所以 Python 提供了一組豐富的容器（即集合）對象。在本文中，我介紹了其中的最簡單的對象 —— tuple。要正確使用 tuple，就需要熟悉它的工作方式。但是，由于許多其他容器類型具有類似的功能，其中包括分段以及打包或解包，了解 tuple 的工作原理意味著您已經開始完全理解 Python 中的其他容器類型。

原文轉自：http://www.anti-gravitydesign.com