發(fā)現(xiàn)很多公司要求掌握一門腳本語言，一直也想搞搞這個(gè)，看C++，Linux C編程也只是為了對系統(tǒng)更加的了解，唉，我的工作定位好像一直都不怎么明確，是要搞個(gè)自己最擅長的了，以后有時(shí)間再搞linuxC，找工作第一位。。。工作基本定位在 Java+python，大部分公司也不會(huì)要求一個(gè)人既做Java也做C++。再說這語言也是大同小異，關(guān)鍵還是編程思想


d = {"server":"mpilgrim", "database":"master"}

li = ["a", "b", "mpilgrim", "z", "example"]

Tuple 是不可變的 list。一旦創(chuàng)建了一個(gè) tuple，就不能以任何方式改變它
 t = ("a", "b", "mpilgrim", "z", "example")

連接 list 與分割字符串
>>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")   
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1)
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']

 

使用 type、str、dir 和其它內(nèi)置函數(shù)

4.3.2. str 函數(shù)
str 將數(shù)據(jù)強(qiáng)制轉(zhuǎn)換為字符串。每種數(shù)據(jù)類型都可以強(qiáng)制轉(zhuǎn)換為字符串。

例 4.6. str 介紹
>>> str(1)         
'1'
>>> horsemen = ['war', 'pestilence', 'famine']
>>> horsemen
['war', 'pestilence', 'famine']
>>> horsemen.append('Powerbuilder')
>>> str(horsemen)  
"['war', 'pestilence', 'famine', 'Powerbuilder']"
>>> str(odbchelper)
"<module 'odbchelper' from 'c:\\docbook\\dip\\py\\odbchelper.py'>"
>>> str(None)      
'None'  對于簡單的數(shù)據(jù)類型比如整型，你可以預(yù)料到 str 的正常工作，因?yàn)閹缀趺糠N語言都有一個(gè)

將整型轉(zhuǎn)化為字符串的函數(shù)。 
  然而 str 可以作用于任何數(shù)據(jù)類型的任何對象。這里它作用于一個(gè)零碎構(gòu)建的列表。 
  str 還允許作用于模塊。注意模塊的字符串形式表示包含了模塊在磁盤上的路徑名，所以你的顯示

結(jié)果將會(huì)有所不同。 
  str 的一個(gè)細(xì)小但重要的行為是它可以作用于 None，None 是 Python 的 null 值。這個(gè)調(diào)用返回字符

串 'None'。你將會(huì)使用這一點(diǎn)來改進(jìn)你的 info 函數(shù)，這一點(diǎn)你很快就會(huì)看到。 

dir 函數(shù)返回任意對象的屬性和方法列表，包括模塊對象、函數(shù)對象、字符串對象、列表對象、字

典對象 …… 相當(dāng)多的東西。

例 4.7. dir 介紹
>>> li = []
>>> dir(li)          
['append', 'count', 'extend', 'index', 'insert',
'pop', 'remove', 'reverse', 'sort']
>>> d = {}
>>> dir(d)           
['clear', 'copy', 'get', 'has_key', 'items', 'keys', 'setdefault', 'update', 'values']
>>> import odbchelper
>>> dir(odbchelper)  
['__builtins__', '__doc__', '__file__', '__name__', 'buildConnectionString']

 

最后是 callable 函數(shù)，它接收任何對象作為參數(shù)，如果參數(shù)對象是可調(diào)用的，返回 True；否則返回

False。可調(diào)用對象包括函數(shù)、類方法，甚至類自身 (下一章將更多的關(guān)注類)。

例 4.8. callable 介紹
>>> import string
>>> string.punctuation          
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>> string.join                 
<function join at 00C55A7C>
>>> callable(string.punctuation)
False
>>> callable(string.join)       
True

你已經(jīng)知道 Python 函數(shù)是對象。你不知道的是，使用 getattr 函數(shù)，可以得到一個(gè)直到運(yùn)行時(shí)才知

道名稱的函數(shù)的引用。

例 4.10. getattr 介紹
>>> li = ["Larry", "Curly"]
>>> li.pop                      
<built-in method pop of list object at 010DF884>
>>> getattr(li, "pop")          
<built-in method pop of list object at 010DF884>
>>> getattr(li, "append")("Moe")
>>> li
["Larry", "Curly", "Moe"]
>>> getattr({}, "clear")        
<built-in method clear of dictionary object at 00F113D4>
>>> getattr((), "pop")          
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'pop'

 

4.4.1. 用于模塊的 getattr
getattr 不僅僅適用于內(nèi)置數(shù)據(jù)類型，也可作用于模塊。

例 4.11. apihelper.py 中的 getattr 函數(shù)
>>> import odbchelper
>>> odbchelper.buildConnectionString            
<function buildConnectionString at 00D18DD4>
>>> getattr(odbchelper, "buildConnectionString")
<function buildConnectionString at 00D18DD4>
>>> object = odbchelper
>>> method = "buildConnectionString"
>>> getattr(object, method)                     
<function buildConnectionString at 00D18DD4>
>>> type(getattr(object, method))               
<type 'function'>
>>> import types
>>> type(getattr(object, method)) == types.FunctionType
True
>>> callable(getattr(object, method))           
True

使用 getattr，你能夠獲得同一函數(shù)的同一引用。通常，getattr(object, "attribute") 等價(jià)于

object.attribute。如果 object 是一個(gè)模塊的話，那么 attribute 可能是定義在模塊中的任何東西：函數(shù)

、類或者全局變量。

就是相當(dāng)于函數(shù)的指針
例 4.12. 使用getattr 創(chuàng)建分發(fā)者

import statsout

def output(data, format="text"):                             
    output_function = getattr(statsout, "output_%s" % format)
    return output_function(data)                             
  output 函數(shù)接收一個(gè)必備參數(shù) data，和一個(gè)可選參數(shù) format。如果沒有指定 format 參數(shù)，其缺省

值是 text 并完成普通文本輸出函數(shù)的調(diào)用。 
  你可以連接 format 參數(shù)值和 "output_" 來創(chuàng)建一個(gè)函數(shù)名稱作為參數(shù)值，然后從 statsout 模塊中取

得該函數(shù)。這種方式允許今后很容易地?cái)U(kuò)展程序以支持其它的輸出格式，而且無需修改分發(fā)函數(shù)。

所要做的僅僅是向 statsout 中添加一個(gè)函數(shù)，比如 output_pdf，之后只要將 “pdf” 作為 format 的參

數(shù)值傳遞給 output 函數(shù)即可。 
  現(xiàn)在你可以簡單地調(diào)用輸出函數(shù)，就像調(diào)用其它函數(shù)一樣。output_function 變量是指向 statsout 模

塊中相應(yīng)函數(shù)的引用。 

你是否發(fā)現(xiàn)前面示例的一個(gè) Bug？即字符串和函數(shù)之間的松耦合，而且沒有錯(cuò)誤檢查。如果用戶傳

入一個(gè)格式參數(shù)，但是在 statsout 中沒有定義相應(yīng)的格式輸出函數(shù)，會(huì)發(fā)生什么呢？還好，getattr

會(huì)返回 None，它會(huì)取代一個(gè)有效函數(shù)并被賦值給 output_function，然后下一行調(diào)用函數(shù)的語句將會(huì)

失敗并拋出一個(gè)異常。這種方式不好。

值得慶幸的是，getattr 能夠使用可選的第三個(gè)參數(shù)，一個(gè)缺省返回值。

 

[mapping-expression for element in source-list if filter-expression]

>>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
>>> [elem for elem in li if len(elem) > 1]      
['mpilgrim', 'foo']
>>> [elem for elem in li if elem != "b"]        
['a', 'mpilgrim', 'foo', 'c', 'd', 'd']
>>> [elem for elem in li if li.count(elem) == 1]
['a', 'mpilgrim', 'foo', 'c']

使用 and 時(shí)，在布爾環(huán)境中從左到右演算表達(dá)式的值。0、''、[]、()、{}、None 在布爾環(huán)境中為假；

其它任何東西都為真。還好，幾乎是所有東西。默認(rèn)情況下，布爾環(huán)境中的類實(shí)例為真，但是你可

以在類中定義特定的方法使得類實(shí)例的演算值為假。

4.6.1. 使用 and-or 技巧
例 4.17. and-or 技巧介紹
>>> a = "first"
>>> b = "second"
>>> 1 and a or b
'first'
>>> 0 and a or b
'second'
  這個(gè)語法看起來類似于 C 語言中的 bool ? a : b 表達(dá)式。整個(gè)表達(dá)式從左到右進(jìn)行演算，所以先進(jìn)

行 and 表達(dá)式的演算。1 and 'first' 演算值為 'first'，然后 'first' or 'second' 的演算值為 'first'。 
  0 and 'first' 演算值為 False，然后 0 or 'second' 演算值為 'second'。 

然而，由于這種 Python 表達(dá)式單單只是進(jìn)行布爾邏輯運(yùn)算，并不是語言的特定構(gòu)成，這是 and-or

技巧和 C 語言中的 bool ? a : b 語法非常重要的不同。如果 a 為假，表達(dá)式就不會(huì)按你期望的那樣

工作了。(你能知道我被這個(gè)問題折騰過嗎？不止一次？)

 

 

 

Python 支持一種有趣的語法，它允許你快速定義單行的最小函數(shù)。這些叫做 lambda 的函數(shù)，是從

Lisp 借用來的，可以用在任何需要函數(shù)的地方。
例 4.20. lambda 函數(shù)介紹
>>> def f(x):
...     return x*2
...    
>>> f(3)
6
>>> g = lambda x: x*2 
>>> g(3)
6
>>> (lambda x: x*2)(3)
6

總的來說，lambda 函數(shù)可以接收任意多個(gè)參數(shù) (包括可選參數(shù)) 并且返回單個(gè)表達(dá)式的值。lambda

函數(shù)不能包含命令，包含的表達(dá)式不能超過一個(gè)。不要試圖向 lambda 函數(shù)中塞入太多的東西；如

果你需要更復(fù)雜的東西，應(yīng)該定義一個(gè)普通函數(shù)，然后想讓它多長就多長。

 

例 4.25. 打印列表
>>> li = ['a', 'b', 'c']
>>> print "\n".join(li)
a
b
c  在你處理列表時(shí)，這確實(shí)是一個(gè)有用的調(diào)試技巧。在 Python 中，你會(huì)十分頻繁地操作列表。 

 

在 2.2.1 版本之前，Python 沒有單獨(dú)的布爾數(shù)據(jù)類型。為了彌補(bǔ)這個(gè)缺陷，Python 在布爾環(huán)境 (如 if

語句) 中幾乎接受所有東西，遵循下面的規(guī)則：
0 為 false; 其它所有數(shù)值皆為 true。
空串 ("") 為 false; 其它所有字符串皆為 true。
空 list ([]) 為 false; 其它所有 list 皆為 true。
空 tuple (()) 為 false; 其它所有 tuple 皆為 true。
空 dictionary ({}) 為 false; 其它所有 dictionary 皆為 true。

 

下面是 from module import 的基本語法：

from UserDict import UserDict
它與你所熟知的 import module 語法很相似，但是有一個(gè)重要的區(qū)別：UserDict 被直接導(dǎo)入到局部

名字空間去了，所以它可以直接使用，而不需要加上模塊名的限定。你可以導(dǎo)入獨(dú)立的項(xiàng)或使用

from module import * 來導(dǎo)入所有東西。

Python 中的 from module import * 像 Java 中的 import module.* ；Python 中的 import module 像 Java

中的 import module

什么時(shí)候你應(yīng)該使用 from module import？

如果你要經(jīng)常訪問模塊的屬性和方法，且不想一遍又一遍地敲入模塊名，使用 from module import

。
如果你想要有選擇地導(dǎo)入某些屬性和方法，而不想要其它的，使用 from module import。
如果模塊包含的屬性和方法與你的某個(gè)模塊同名，你必須使用 import module 來避免名字沖突。

盡量少用 from module import * ，因?yàn)榕卸ㄒ粋€(gè)特殊的函數(shù)或?qū)傩允菑哪膩淼挠行├щy，并且會(huì)造

成調(diào)試和重構(gòu)都更困難。

from UserDict import UserDict

class FileInfo(UserDict):
在 Python 中，類的基類只是簡單地列在類名后面的小括號(hào)里。不像在 Java 中有一個(gè)特殊的

extends 關(guān)鍵字。 

Python 支持多重繼承。在類名后面的小括號(hào)中，你可以列出許多你想要的類名，以逗號(hào)分隔。

class FileInfo(UserDict):
    "store file metadata"
    def __init__(self, filename=None):
        UserDict.__init__(self)       
        self["name"] = filename       
                                         一些偽面向?qū)ο笳Z言，像 Powerbuilder 有一種“擴(kuò)展”構(gòu)造函數(shù)和其它事件的

概念，即父類的方法在子類的方法執(zhí)行前被自動(dòng)調(diào)用。Python 不是這樣，你必須顯示地調(diào)用在父類中的合適方法。 
  我告訴過你，這個(gè)類像字典一樣工作，那么這里就是第一個(gè)印象。我們將參數(shù) filename 賦值給對象 name 關(guān)鍵字，作為它的值。  注意 __init__ 方法從不返回一個(gè)值。 
Java中是自動(dòng)調(diào)用默認(rèn)的無參的父類的構(gòu)造函數(shù)

 

例 5.9. 定義 UserDict 類

class UserDict:                               
    def __init__(self, dict=None):             
        self.data = {}  ×××××××××××××××××××××××××××××××××××定義類的實(shí)例變量                         
        if dict is not None: self.update(dict) 
  注意 UserDict 是一個(gè)基類，不是從任何其他類繼承而來。 
  這就是我們在 FileInfo 類中進(jìn)行了覆蓋的 __init__ 方法。注意這個(gè)父類的參數(shù)列表與子類不同。很

好，每個(gè)子類可以擁有自已的參數(shù)集，只要使用正確的參數(shù)調(diào)用父類就可以了。這里父類有一個(gè)定

義初始值的方法 (通過在 dict 參數(shù)中傳入一個(gè)字典)，這一方法我們的 FileInfo 沒有用上。

××××××××××××××××××××××××××××××××與Java的不同×××××××××××××××××××××××××××××××××××
與Java的不同，
1，Python中類的類屬性是是在類的后面直接定義的
2，而實(shí)例變量是在在__init__方法中直接定義的使用如下方式self.instancevariable=***定義,
3，然后Python中實(shí)例方法都要顯示的加上self（相當(dāng)于Java的this)參數(shù)，方法中引用實(shí)例變量時(shí)也要通過self來引用

Python 支持?jǐn)?shù)據(jù)屬性 (在 Java 叫做 “實(shí)例變量”，在 C++ 中叫 “數(shù)據(jù)成員”)，它是由某個(gè)特定的類實(shí)

例所擁有的數(shù)據(jù)。在本例中，每個(gè) UserDict 實(shí)例將擁有一個(gè) data 數(shù)據(jù)屬性。要從類外的代碼引用

這個(gè)屬性，需要用實(shí)例的名字限定它，instance.data，限定的方法與你用模塊的名字來限定函數(shù)一

樣。要在類的內(nèi)部引用一個(gè)數(shù)據(jù)屬性，我們使用 self 作為限定符。習(xí)慣上，所有的數(shù)據(jù)屬性都在

__init__ 方法中初始化為有意義的值。然而，這并不是必須的，因?yàn)閿?shù)據(jù)屬性，像局部變量一樣，

當(dāng)你首次賦給它值的時(shí)候突然產(chǎn)生。 
×××××××××××××××××××××××××××××××××與Java的不同××××××××××××××××××××××××××××××××××

Java 支持通過參數(shù)列表的重載，也就是 一個(gè)類可以有同名的多個(gè)方法，但這些方法或者是參數(shù)個(gè)

數(shù)不同，或者是參數(shù)的類型不同。
Python 兩種都不支持，總之是沒有任何形式的函數(shù)重載。一個(gè) __init__ 方法就是一個(gè) __init__ 方法

，不管它有什么樣的參數(shù)。每個(gè)類只能有一個(gè) __init__ 方法，并且如果一個(gè)子類擁有一個(gè) __init__

方法，它總是 覆蓋父類的 __init__ 方法，甚至子類可以用不同的參數(shù)列表來定義它。

想想為什么不支持方法重載，是因?yàn)镻ython的參數(shù)可以定義默認(rèn)實(shí)參，有缺省值
×××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××××
應(yīng)該總是在 __init__ 方法中給一個(gè)實(shí)例的所有數(shù)據(jù)屬性賦予一個(gè)初始值。這樣做將會(huì)節(jié)省你在后面

調(diào)試的時(shí)間，不必為捕捉因使用未初始化 (也就是不存在) 的屬性而導(dǎo)致的 AttributeError 異常費(fèi)時(shí)費(fèi)

力。
class MP3FileInfo(FileInfo):
mp3file.__class__  is fileinfo.MP3FileInfo true
mp3file.__class__  is fileinfo.FileInfo         false
isinstance(mp3file,fileinfo.MP3FileInfo)  true
isinstance(mp3file,fileinfo.FileInfo)          true

li=[1,2,3]
li2[1,2,3]
li==li2 true   相當(dāng)于Java的equals()
li is li2 false 相當(dāng)于Java的==

5.7. 高級(jí)專用類方法
除了 __getitem__ 和 __setitem__ 之外 Python 還有更多的專用函數(shù)。某些可以讓你模擬出你甚至可

能不知道的功能。

下面的例子將展示 UserDict 一些其他專用方法。

例 5.16. UserDict 中更多的專用方法
    def __repr__(self): return repr(self.data)    
    def __cmp__(self, dict):                      
        if isinstance(dict, UserDict):           
            return cmp(self.data, dict.data)     
        else:                                    
            return cmp(self.data, dict)          
    def __len__(self): return len(self.data)      
    def __delitem__(self, key): del self.data[key]   __repr__ 是一個(gè)專用的方法，在當(dāng)調(diào)用 repr

(instance) 時(shí)被調(diào)用。repr 函數(shù)是一個(gè)內(nèi)置函數(shù)，它返回一個(gè)對象的字符串表示。它可以用在任何

對象上，不僅僅是類的實(shí)例。你已經(jīng)對 repr 相當(dāng)熟悉了，盡管你不知道它。在交互式窗口中，當(dāng)你

只敲入一個(gè)變量名，接著按ENTER，Python 使用 repr 來顯示變量的值。自已用一些數(shù)據(jù)來創(chuàng)建一

個(gè)字典 d ，然后用 print repr(d) 來看一看吧。 
  __cmp__ 在比較類實(shí)例時(shí)被調(diào)用。通常，你可以通過使用 == 比較任意兩個(gè) Python 對象，不只是

類實(shí)例。有一些規(guī)則，定義了何時(shí)內(nèi)置數(shù)據(jù)類型被認(rèn)為是相等的，例如，字典在有著全部相同的關(guān)

鍵字和值時(shí)是相等的。對于類實(shí)例，你可以定義 __cmp__ 方法，自已編寫比較邏輯，然后你可以

使用 == 來比較你的類，Python 將會(huì)替你調(diào)用你的 __cmp__ 專用方法。 
  __len__ 在調(diào)用 len(instance) 時(shí)被調(diào)用。len 是一個(gè)內(nèi)置函數(shù)，可以返回一個(gè)對象的長度。它可以

用于任何被認(rèn)為理應(yīng)有長度的對象。字符串的 len 是它的字符個(gè)數(shù)；字典的 len 是它的關(guān)鍵字的個(gè)

數(shù)；列表或序列的 len 是元素的個(gè)數(shù)。對于類實(shí)例，定義 __len__ 方法，接著自已編寫長度的計(jì)算

，然后調(diào)用 len(instance)，Python 將替你調(diào)用你的 __len__ 專用方法。 
  __delitem__ 在調(diào)用 del instance[key] 時(shí)調(diào)用 ，你可能記得它作為從字典中刪除單個(gè)元素的方法。

當(dāng)你在類實(shí)例中使用 del 時(shí)，Python 替你調(diào)用 __delitem__ 專用方法。 

 
在 Java 中，通過使用 str1 == str2 可以確定兩個(gè)字符串變量是否指向同一塊物理內(nèi)存位置。這叫做

對象同一性，在 Python 中寫為 str1 is str2。在 Java 中要比較兩個(gè)字符串值，你要使用 str1.equals

(str2)；在 Python 中，你要使用 str1 == str2。某些 Java 程序員，他們已經(jīng)被教授得認(rèn)為，正是因?yàn)?/p>

在 Java 中 == 是通過同一性而不是值進(jìn)行比較，所以世界才會(huì)更美好。這些人要接受 Python 的這

個(gè)“嚴(yán)重缺失”可能要花些時(shí)間。 

ord("a") 97
ord("A") 65

 

5.8. 類屬性介紹
你已經(jīng)知道了數(shù)據(jù)屬性，它們是被一個(gè)特定的類實(shí)例所擁有的變量。Python 也支持類屬性，它們是

由類本身所擁有的。

例 5.17. 類屬性介紹

class MP3FileInfo(FileInfo):
    "store ID3v1.0 MP3 tags"
    tagDataMap = {"title"   : (  3,  33, stripnulls),
                  "artist"  : ( 33,  63, stripnulls),
                  "album"   : ( 63,  93, stripnulls),
                  "year"    : ( 93,  97, stripnulls),
                  "comment" : ( 97, 126, stripnulls),
                  "genre"   : (127, 128, ord)}

例 5.18. 修改類屬性,Java中的靜態(tài)變量
>>> class counter:
...     count = 0                    
...     def __init__(self):
...         self.__class__.count += 1 #一定得用self.__class__來引用，才是類變量，假如用self.count則定義的是實(shí)例變量,或者用
            Counter.count +=1
...    
上述代碼記錄創(chuàng)建的對象的個(gè)數(shù)

 

5.9. 私有函數(shù)
與大多數(shù)語言一樣，Python 也有私有的概念：

私有函數(shù)不可以從它們的模塊外面被調(diào)用
私有類方法不能夠從它們的類外面被調(diào)用
私有屬性不能夠從它們的類外面被訪問
與大多數(shù)的語言不同，一個(gè) Python 函數(shù)，方法，或?qū)傩允撬接羞€是公有，完全取決于它的名字。

如果一個(gè) Python 函數(shù)，類方法，或?qū)傩缘拿忠詢蓚€(gè)下劃線開始 (但不是結(jié)束)，它是私有的；其它

所有的都是公有的。 Python 沒有類方法保護(hù) 的概念 (只能用于它們自已的類和子類中)。類方法或

者是私有 (只能在它們自已的類中使用) 或者是公有 (任何地方都可使用)。

在 MP3FileInfo 中，有兩個(gè)方法：__parse 和 __setitem__。正如我們已經(jīng)討論過的，__setitem__

是一個(gè)專有方法；通常，你不直接調(diào)用它，而是通過在一個(gè)類上使用字典語法來調(diào)用，但它是公有

的，并且如果有一個(gè)真正好的理由，你可以直接調(diào)用它 (甚至從 fileinfo 模塊的外面)。然而，

__parse 是私有的，因?yàn)樵谒拿智懊嬗袃蓚€(gè)下劃線。

 
在 Python 中，所有的專用方法 (像 __setitem__) 和內(nèi)置屬性 (像 __doc__) 遵守一個(gè)標(biāo)準(zhǔn)的命名習(xí)慣

：開始和結(jié)束都有兩個(gè)下劃線。不要對你自已的方法和屬性用這種方法命名；到最后，它只會(huì)把你 (或其它人) 搞亂。