VII Python（2）基礎知識

VII Python（2）基礎知識

 

每種語言都各具特點，在各自領域都有其適用範圍，python只是其中一種，在應用方面表現較好，是一種面向對象、解釋型計算機程序設計語言，有豐富強大的類庫，常被暱稱爲膠水語言，能輕鬆的把其它語言的各類模塊聯結在一塊兒；openstack用python開發，有不少組件，python不只是腳本語言它更適合開發大型程序，它是完整意義的編程語言或控制語言，調用其它語言的類庫使其聯結起來（膠水語言）；

python很是流行，google在其網絡搜索上用python實現，Intel、HP、Citrix等公司用python編寫程序做硬件測試，NASA內部用的不少程序都用python編寫；

編程語言，用戶問題（問題空間）-->計算機（解空間，解決問題），編程語言將計算機所提供的解決問題的能力抽象，讓其接近用戶所理解的方面，抽象程度越高，則越接近人的理解，則這種語言越高級；

機器代碼-->微碼編程（芯片級別）-->高級語言（人類易理解）

解釋器（可理解爲同聲傳譯），編譯器（將寫好的整段代碼轉換爲機器所理解的二進制格式）；

bytecode字節碼，執行時編譯，相似php的opcode和java的字節碼，若在類接口統一狀況下可互換執行；

python在性能方面比C或C++要差些，python有豐富的類庫和便捷的開發工具，使得開發過程更快、效益要高，現代計算機性能更強對於微弱的性能損失可忽略，python可在任意平臺運行，只要該平臺有PVM（pythonvirtual machine），像JAVA似的一次編譯處處運行；

 

source code（.py）--編譯器compiler(PVM)-->bytecode（.pyc）--解釋器interpreter(PVM)-->processor處理器

 

python被看成三種工具：

OS級別的自動化，腳本語言（shell編程，LinuxOS級別的自動化，在這一層面最好用shell，而python要用特定的調用接口才能實現，若只是用python做系統自動化方面的事情，會大材小用、自找麻煩）；

文本處理（python在文本處理方面是shell沒法比擬的，如網頁抓取分析、正則表達式的高級處理等經過python強大的類庫完成）；

藉助框架完成各方面的開發（如藉助Django完成web開發）

 

python的實現：

CPython（原始、標準的實現方式，C語言開發的python）；

Jython（用於與JAVA語言集成的實現，JAVA語言實現的python）；

IronPython（用於與.NET框架集成的實現，.NET語言實現的python）

 

python性能優化工具：

Psyco（python語言的一個擴展模塊，能夠即時對程序代碼進行專業的算法優化，可在必定程度上提升程序的執行速度，尤爲是在程序中有大量循環操做時，目前開發工做已中止，由PyPy接替）；

PyPy（是用python實現的pthon解釋器，python語言的動態編譯器，是Psyco的後繼項目，可運行在Linux的32bit和64bit，MacOSX和WIN的32bit平臺中）；

Shed Skin（python編譯器，可以將python代碼轉換成優化的C++代碼）

 

編寫、執行python代碼（初學使用vim便可），win下有IDLE及衆多的免費及商業化的工具可提供便利（如補全等）：

交互式解釋器，#python，在命令行下直接啓動python，顯示信息取決於程序版本及OS等，交互式模式下的程序執行完後不能難以再次運行；

python程序文件，將編寫的程序保存爲.py文件，方便屢次運行

 

程序文件結構，可將函數單獨放在一文件中，python的類包含了一系列預編寫好的語句的程序文件，稱做模塊，能直接運行的模塊文件一般稱做腳本，即程序的頂層文件，python的模塊相似shell中的function（shell中的function不能單獨運行，要經過腳本（程序的頂層文件）中語句做爲入口調用才能執行）

python的程序文件，源文件一般以.py爲擴展名，第一行爲魔數shebang，執行腳本時通知要啓動的解釋器，緊接着導入模塊或變量賦值，如：

#vim firstpycode.py

#!/usr/bin/python

import platform

print platform.uname()

#chmod +x firstpycode.py

#./firstpycode.py

注：魔數shebang，在系統中任何程序要能運行一般要表現爲進程，進程想啓動要向內核註冊，由kernel給它生成進程描述結構task_struct，進程才能運行，內核必需要理解這是個可執行程序，按可執行程序內部的各類結構以瞭解其執行程序入口，內核將執行程序入口放在CPU上內核退出程序執行，kernel經過讀取第一行內容的代碼就知道如下的這些代碼不能直接在CPU上運行而要調用python程序把以後的代碼看成參數來執行，如同JVM運行指令時看到的是JAVA進程而不是具體的命令

 

python程序文件可分解成模塊、語句、表達式、對象：

程序由模塊構成；模塊包含語句；語句包含表達式；表達式創建並處理對象

注：表達式是「某事」，而語句是「作某事」即指令，如1+2是「某事」，而print1+2是「作某事」；語句的特性，它們改變了事物，如賦值語句改變了變量，print語句改變了屏幕輸出；在shell中變量是命名的內存空間，而在python中一切皆對象，對象在內存空間經過引用方式實現

 

python的IDE：

IDLE，標準python環境提供；Eclipse和PyDev；Python Win；Komodo；Wingware；Pycharm

 

python程序設計，面向過程、面向對象：

面向過程，以指令爲中心，以指令處理數據，如何組織代碼解決問題；

面向對象，以數據爲中心，全部的處理代碼都圍繞數據展開，要設計數據結構組織數據，並提供對此類數據所容許處理操做，適用大型複雜程序；先設計類由類進行實例化後，對象間互相操做完成程序執行過程

 

若要安裝更高版本的python，注意系統自帶的低版本的不能卸載，系統運行要用到

readline-devel（用於交互模式的程序控制，如刪除字符）；sqlite-devel（實現歷史命令保存）；ipython（使得使用python更便捷，如自動補全、錯誤輸出提示、格式化輸出等等）

注：ipython 是一個 python 的交互式 shell，比默認的python shell 好用得多，支持變量自動補全，自動縮近，支持 bash shell 命令，內置了許多頗有用的功能和函數。在ubuntu 下只要 sudo apt-getinstall ipython 就裝好了，經過 ipython 啓動。 IPython 是 Python 的原生交互式 shell 的加強版，能夠完成許多不一樣尋常的任務，好比幫助實現並行化計算；我主要使用它提供的交互性幫助，好比代碼着色、改進了的命令行回調、製表符完成、宏功能以及改進了的交互式幫助。3.x 將會是 IPython 最後一個統一龐大的發佈版本，下一個發佈週期（4.0）會把日益增加的項目分離成 Python 特定語言組件和語言無關組件。語言無關項目(notebook,qtconsole,etc.) 將會歸於新項目 Jupyter，而 Python 特定語言項目 (interactive Python shell,Python kernel, IPython.parallel) 將會繼續留在 IPython，並且會被分離成幾個更小的包。notebook 的圖標已經換成了 Jupyter 的圖標。

 

[root@localhost ~]# yum -y install zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel

[root@localhost ~]# tar xf Python-2.7.6.tgz

[root@localhost ~]# cd Python-2.7.6

[root@localhost Python-2.7.6]# ./configure --help | less

--enable-profiling（代碼剖析enable C-level code profiling）

--enable-unicode[=ucs[24]] （Enable Unicode strings (default isucs2)）

--with(out)-threads[=DIRECTORY]（disable/enable thread support）python的兩種線程庫

--with(out)-thread[=DIRECTORY]（deprecated; use --with(out)-threads）

[root@localhost Python-2.7.6]# ./configure --prefix=/usr/local/python2.7/

[root@localhost Python-2.7.6]# make && make install

[root@localhost Python-2.7.6]# ln -sv /usr/local/python2.7/bin/python2

python2           python2.7         python2.7-config  python2-config   

[root@localhost Python-2.7.6]# ln -sv /usr/local/python2.7/bin/python2.7 /usr/bin/python2.7

`/usr/bin/python2.7' ->`/usr/local/python2.7/bin/python2.7'

[root@localhost Python-2.7.6]# python2.7

Python 2.7.6 (default, Jun  5 2016, 21:35:23)

[GCC 4.4.7 20120313 (Red Hat 4.4.7-4)] onlinux2

Type "help","copyright", "credits" or "license" for moreinformation.

>>> 

>>> exit()

[root@localhost Python-2.7.6]# cd

 

[root@localhost ~]# tar xf ipython-3.0.0.tar.gz

[root@localhost ~]# cd ipython-3.0.0

[root@localhost ipython-3.0.0]# python2.7 setup.py install

[root@localhost ipython-3.0.0]# ln -sv /usr/local/python2.7/bin/ipython /usr/bin/

`/usr/bin/ipython' ->`/usr/local/python2.7/bin/ipython'

[root@localhost ipython-3.0.0]# ipython

Python 2.7.6 (default, Jun  5 2016, 21:35:23)

Type "copyright","credits" or "license" for more information.

 

IPython 3.0.0 -- An enhanced InteractivePython.

?        -> Introduction and overview of IPython's features.

%quickref -> Quick reference.

help     -> Python's own help system.

object?  -> Details about 'object', use 'object??' for extra details.

 

In [1]:

In [1]: exit()

[root@localhost ipython-3.0.0]# ls

build       docs      IPython   README.rst setupbase.py   setupegg.py  setup.py

COPYING.rst examples  PKG-INFO  scripts    setupbase.pyc  setupext

 

In [2]: import platform

In [3]: print platform.uname()

In [4]: dir(platform)   （獲取platform內置的屬性和方法（函數））

Out[4]:

['DEV_NULL',

 '__builtins__',

 '__copyright__',

 '__doc__',

 '__file__',

 '__name__',

 '__package__',

 '__version__',

 '_abspath',

 '_architecture_split',

 '_bcd2str',

 '_default_architecture',

 '_dist_try_harder',

 '_follow_symlinks',

……

In [5]: print platform.uname（獲得內存地址，uname不是屬性而是方法，方法須要調用，要用到小括號，而查看類中的屬性時不須要調用）

<function uname at 0x1f82848>

In [6]: print platform.uname()

('Linux', 'localhost.localdomain','2.6.32-431.el6.x86_64', '#1 SMP Sun Nov 10 22:19:54 EST 2013', 'x86_64','x86_64')

In [7]: platform.<TAB>  （獲得全部屬性和方法）

platform.DEV_NULL               platform.platform               platform.re

platform.architecture           platform.popen                  platform.release

platform.dist                   platform.processor              platform.string

platform.java_ver               platform.python_branch          platform.sys

platform.libc_ver               platform.python_build           platform.system

platform.linux_distribution     platform.python_compiler        platform.system_alias

platform.mac_ver               platform.python_implementation platform.uname

platform.machine                platform.python_revision        platform.version

platform.node                   platform.python_version         platform.win32_ver

platform.os                    platform.python_version_tuple

 

數據結構，經過某種方式（如對元素進行編號）組織在一塊兒的數據元素的集合，這些數據元素能夠是數據或字符，甚至能夠是其它的數據結構；

python的最基本的數據結構是序列sequence；序列中的每一個元素被分配一個序號即元素的位置，亦稱索引；

python包含6種內建的數據序列（list、tuple、string、unicode字符串、buffer對象、xrange對象）

程序=數據結構+算法

 

python的關鍵要素：

基本數據類型、對象引用（變量）、組合數據類型、邏輯操做符、控制流語句、算術操做符、輸入/輸出、函數的建立與調用

 

基本數據類型（數值、字符、布爾，任何程序語言都必須可以表示基本數據項）：

int，Integer類型（整型，不可變類型）；

float，浮點類型（浮點數、複數、十進制數字）；

字符串（是序列，不可變類型，可用name[1]搜索並查詢，python中的全部字符串都要用引號，單雙引號不區別，數值不須要引號）；

bool，布爾型，True、False不能加引號

 

對象引用:

python將全部數據存爲內存對象，python中變量事實上是指向內存對象的引用；

動態類型（在任什麼時候候只要須要，某個對象引用均可從新引用一個不一樣的對象，能夠是不一樣的數據類型）；

內建函數（type()，用於返回給定數據項的數據類型）；

=用於將變量名與內存中的某對象綁定，若是對象事先存在就直接進行綁定，不然會在內存中建立=後引用的對象；

python中變量和數據是分開存放的，變量名是個指針指向了數據的內存空間，與JAVA相似，各內存對象在不被引用時會自動的由GC回收；

變量命名規則（只能包含字母、數字、下劃線_，且不能以數字開頭，區分字母大小寫，禁止使用保留字，系統中的關鍵字即爲保留字，如if、for、while等等）；

命名慣例（以單一下劃線開始的變量名不會被from MODULE import *導入，如_x；先後有雙下劃線的變量名是系統定義的變量名，對python解釋器有重要意義，如__x__，print a+b解釋器會將運算轉爲內置的方法調用print a__add__(b)；僅以雙下劃線開頭的變量名是類的本地變量，如__x；交互式模式下，變量名爲「_」用於保存最後表達式的結果）；

In [7]: 1+1

Out[7]: 2

In [8]: print _

2

 

變量名沒有類型，對象纔有，變量名都是以標籤形式指向對象，是變量名引用的對象；變量分可變類型和不可變類型，整型、字符串是不可變類型

交互式模式下，表達式可直接執行，如；

In [9]:name='tom'

In [10]:type(name)

Out[10]:str

In [11]:name=3.14

In [12]:type(name)

Out[12]:float

 

組合數據類型：

序列類型（list、tuple、string，list是可變類型，可原處修改（在內存的存儲位置處直接修改），tuple、string是不可變類型）；

集合類型（集合set）；

映射類型（dict字典，是可變類型）

In [13]:l1=['this','is','a','sheep']

In [14]:l1[0][1]

Out[14]:'h'

In [15]:id(l1)   （該變量所指向的內存地址）

Out[15]:38673656

In [16]:l1[3]

Out[16]:'sheep'

In [17]:id(l1)

Out[17]:38673656

In [18]:print l1

['this','is', 'a', 'sheep']

In [19]: l1[3]='tom'  （支持原處修改）

In [20]: print l1

['this', 'is', 'a', 'tom']

In [21]: name='jerry'

In [22]: name[0:4:2]  （切片，會建立新的對象，原始內容並不發生改變）

Out[22]: 'jr'

列表是可變序列，元組是不可變序列，list、tuple、string是有大小的，長度可用len()得出元素個數；

python中組合數據類型也是對象，能夠嵌套，如['hello','world',[1,2,3]]；

實質上list和tuple並不真正存儲數據，而是存放對象引用；

python對象（同一類或同一種數據結構）可具備共同可被調用的特定方法（函數）

 

邏輯操做符（邏輯運算是任何程序設計語言的基本功能）：

身份操做符is（斷定左邊對象引用是否相同於右邊對象引用，也可與None比對）；

比較操做符<,>,<=,>=,!=,==；

成員操做符in,not in；

邏輯運算符and,or,not

In [23]: name='jerry'

In [24]: test='jerry'

In [25]: name is test

Out[25]: True

In [26]: test='tom'

In [27]: name is test

Out[27]: False

 

控制流語句：if,while,for...in..,try...except

 

算術操做符：

使用加強賦值操做符，性能要好，+=,-=,%=，python的int類型不可變，加強型賦值的實際過程是建立了一個新的對象來存儲結果再將變量名進行綁定，因此性能要好；

 

輸入/輸出：

現實中，具備實際功能的程序必須可以從鍵盤或文件讀取輸入，產生輸出並寫至終端或文件中；

input()、raw_input()，print（python2.*中是print語句，python3.*中是print()函數）

python解釋器提供了3種標準文件對象，分別爲標準輸入stdin、標準輸出stdout、標準錯誤stderr，在sys模塊中分別以sys.stdin、sys.stdout、sys.stderr形式提供；

print語句實現打印（一個對程序員友好的標準輸出流接口）；

從技術角度講，print是把一個或多個對象轉換爲其文本表達形式，而後發送給標準輸出或另外一個相似文件的流，在python中打印和文件和流的概念聯繫緊密，文件寫入方法是把字符串寫入到任意文件，print默認把對象打印到stdout流，並添加了一些自動的格式化；實質上print語句是python人性化特性的具體實現，它提供了sys.stdout.write()的簡單接口，再加上一些默認的格式化設置，print接受一個逗號分隔的對象列表，併爲行尾自動添加一個換行符，若是不須要，則在最後元素後添加逗號

print'string %format1 %format2...'  %(variable1,variable2,...)  （顯示的效果由%format1決定，與變量無關）

經常使用的格式化符號：

s（字符串或任意對象，格式化代碼使用str()生成字符串）

d,i（十進制整數或長整數）

u（無符號整數或長整數）

o（八進制整數或長整數）

x（十六進制整數或長整數）

X（十六進制整數）

f（浮點數，如[-]m.dddddd）

e（浮點數，如[-]m.dddddde+-xx）

E（浮點數，如[-]m.ddddddE+-xx）

g,G（指數小於-4或更高精度時使用%e或%E，不然使用%f）

r（同repr()生成的字符串）

c（單個字符）

%（字面量，顯示其自己）

 

%後可以使用的修飾符，若是有，則只能按以下順序：

%[(name)][flags][width][.precision]tpecode

其中(name)與dict類型有關，位於括號中的一個屬於後面的字典的key名，用於選出一個具體項，dict中的key能夠是字符也能夠是數字，但在格式化輸出引用時要用字符串；

其中flags中有，-表示左對齊，默認是右對齊；+表示包含數字符號，正數帶此符號；0表示一個0填充；

width指定最小寬度的數字；

.precision用於按照精度侵害字段的寬度，一個數字，指定要打印字符串的最大字符個數，浮點數中小數點以後的位數或整數的最小位數

舉例：

In [28]:d={'x':23,'y':3.14159,'z':47}  

In [29]:print '%(x)-10d %(y)0.3g' % d

23         3.14

 

函數的建立與引用：

函數是實現模塊化編程的基本組件；

python使用def定義函數，def語句建立一個函數對象，並同時建立一個指向函數的對象引用；

函數能夠參數化，經過傳遞不一樣的參數來調用；

每一個python函數都有一個返回值，默認爲None，也可以使用return VALUE明肯定義返回值；

函數也是對象，可存儲在組合數據類型中，也可做爲參數傳遞給其它函數；

callable()可用於測試函數是否可調用；

In [30]: def testFunc(arg1):

  ....:     print arg1

  ....:    

In [31]: callable(testFunc)  （測試某對象是否可調用）

Out[31]: True

注：慣例：函數名中第一個單詞的第一個字母小寫，後面的全部單詞的首字母均大寫；定義類，類名中的每一個單詞的首字母均大寫

 

 

數據類型轉換（顯式、隱式）：

str()、repr()、format()，完成非字符型數據轉爲字符；

int()轉爲整數、float()轉爲浮點數；

tuple(s)將字符串轉爲元組、set(s)將字串轉爲集合、dict(d)建立字典d必須是(key,value)的元組序列、frozenset(s)將字串轉爲不可變集合、chr(x)將整數轉爲單個字符、ord(c)將字符轉爲整數值、hex(x)將整數轉爲十六進制字串、bin(x)將整數轉爲二進制字串、oct(x)將整數轉爲八進制字串；

In [32]: num=7.9

In [33]: type(num)

Out[33]: float

In [34]: test=str(num)    （顯式轉換）

In [35]: type(test)

Out[35]: str

In [36]: type(num)

Out[36]: float

In [37]: dir(__builtins__)   （同__builtin__，python啓動時導入的內建模塊，如dir(),id(),type(),str(),help(),len(),callable()）

Out[37]:

['ArithmeticError',

 'AssertionError',

 'AttributeError',

……

In [38]: print dir(__builtins__)     （這些內建模塊均可用help()獲取其詳細信息）

['ArithmeticError', 'AssertionError', 'AttributeError','BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning','EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False','FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError','ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError','KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None','NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError','PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning','StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning','SystemError', 'SystemExit', 'TabError', 'True', 'TypeError','UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError','UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning','ValueError', 'Warning', 'ZeroDivisionError', '__IPYTHON__','__IPYTHON__active', '__debug__', '__doc__', '__import__', '__name__','__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool','buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp','coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict','dir', 'divmod', 'dreload', 'enumerate', 'eval', 'execfile', 'file', 'filter','float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr','hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance','issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max','memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print','property', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed','round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum','super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']

In [39]: help(str)

……

In [40]: name='tom'

In [41]: name.<TAB>  （name是str類，一個類所接受的操做方法，決定了類實例化後所支持的操做或運算）

name.capitalize  name.find        name.isspace     name.partition   name.rstrip      name.translate

name.center      name.format      name.istitle     name.replace     name.split       name.upper

name.count       name.index       name.isupper     name.rfind       name.splitlines  name.zfill

name.decode      name.isalnum     name.join        name.rindex      name.startswith 

name.encode      name.isalpha     name.ljust       name.rjust       name.strip      

name.endswith    name.isdigit     name.lower       name.rpartition  name.swapcase   

name.expandtabs  name.islower     name.lstrip      name.rsplit      name.title      

In [41]: name.upper()  （upper是str類的方法，將方法施加在name所引用的字符串上）

Out[41]: 'TOM'

In [42]: dir()

Out[42]:

['In',

 'Out',

 '_',

 '_10',

 '_12',

……

In [43]: print dir()

['In', 'Out', '_', '_10', '_12', '_14','_15', '_16', '_17', '_22', '_25', '_27', '_31', '_33', '_35', '_36', '_37','_4', '_41', '_42', '_7', '__', '___', '__builtin__', '__builtins__','__doc__', '__name__', '__package__', '_dh', '_i', '_i1', '_i10', '_i11','_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20','_i21', '_i22', '_i23', '_i24', '_i25', '_i26', '_i27', '_i28', '_i29', '_i3','_i30', '_i31', '_i32', '_i33', '_i34', '_i35', '_i36', '_i37', '_i38', '_i39','_i4', '_i40', '_i41', '_i42', '_i43', '_i5', '_i6', '_i7', '_i8', '_i9','_ih', '_ii', '_iii', '_oh', '_sh', 'd', 'exit', 'get_ipython', 'l1', 'name','num', 'platform', 'quit', 'test', 'testFunc']

In [44]: testFunc('hello world')  （至關於testFunc.__call__('hello world')，調用函數，小括號()表示對可調用對象的調用，全部可調用對象內部有一個方法叫call，非函數的類型是沒有的）

hello world

In [45]: name='tony'

In [46]: name()  （不可調用對象，報錯以下）

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

TypeError                                 Traceback(most recent call last)

<ipython-input-46-23d722c1bae6> in<module>()

----> 1 name()

TypeError: 'str' objectis not callable

注：任何一個對象的內置方法決定了它所能參與的運算，()就是一種調用運算符，python標準庫中有200多個內置模塊，這些模塊擁有大量函數，python模塊實際上就是包含python代碼的.py文件，其擁有自定義的函數與類及變量等；import MODULE用於導入模塊，不加文件擴展名.py，導入模塊後可訪問其內部包含的任意函數、類及變量

In [47]: import random

In [48]:x=random.choice(['a','b','c','d','e','f','g'])

In [49]: print x

e

In [50]: print x

e

注：import相似shell中的source，使用模塊時MODULE.FUNC，用from MODULE import FUNC，這樣可直接用函數名，若直接用函數名可能與其它模塊中的函數衝突（新的會覆蓋舊的）

 

 

python編程風格，語句和語法：

#（註釋，能夠在一行的任意地方開始，既不要缺乏註釋，也要避免過渡註釋）；

\（續行，轉義符）；

__doc__（文檔，python容許經過__doc__動態得到文檔字串，如print str.__doc__）；

''' '''或""" """（多行註釋，閉合操做符，續行（單一語句跨多行））；

代碼組（縮進統一使用4個空格，縮進相同的一組語句構成一個代碼塊，首行以關鍵字開始，如if、while等，以冒號結束；python使用縮進來分隔代碼組，同一代碼組的代碼行必須嚴格左對齊，不然語法錯誤；同一行放置的多個語句能夠分號做爲分隔符，但不建議這麼作；.pyc（bytecode文件在程序執行完後會自動刪除，如果模塊被導入則不會刪除）；

模塊（每個python腳本文件均可被當成是一個模塊；模塊裏的代碼能夠是一段直接執行的腳本，也能夠是一些相似庫的函數從而可由別的模塊導入）；

標識符（是計算機編程語言中容許做爲名字的有效字符串集合，由字母、數字、下劃線組成且第一個字符不能是數字，區分大小寫，不能使用保留字（或稱關鍵字，它們是語言的標識符，不能用於其它用途），標識符要作到見名知義）；

注：python內建的標識符集合，儘可能避免使用這些特別的名字，如：from,True,False,None,is,and,not,in,for,if,elif,else,while,def,return,lambda,class,try,except,finally,raise,break,continue,nonlocal,global,with,as,yield,assert,import,pass

參考google的python風格指南

 

python文件結構：

[root@localhost ~]# vim example.py

#!/usr/bin/env python  #（起始行，此種方式更靈活，同一OS可多個python版本共存，經過PYTHONENV設置當前版本）

#

"this is a test module"  #（模塊文檔，docstring，若跨行要用三引號）

import sys    #（模塊導入）

import os

debug='True'   #（全局變量定義，相對於當前程序而言是全局）

class FooClass(object):  #（類定義，自定義的類，是用特定結構組織了數據，如內置的str類、int類等，類中有對數據操做的方法）

       "Foo Class"

       pass

def test():   #（函數定義）

       "test function"

       foo=FooClass()

       if debug:

                print 'run test()'

if __name__=='__main__':    #（主程序）

       test()

[root@localhost ~]# chmod +x example.py

 

python文件主程序：

不管當前模塊是被導入仍是做爲腳本直接執行，都會執行主程序這部分代碼；全部的模塊都有能力執行代碼；

最高級別的python語句（沒有縮進，頂格寫的），在模塊被導入時就會執行，不管是否真的須要執行；穩當的作法，除那些真正須要執行的代碼之外，全部的功能代碼都經過函數創建，所以，僅在主程序中編寫大量的頂級的可執行代碼，用於被導入的模塊只應該存在較少的頂級執行代碼）；

__name__指示模塊如何被加載，若是模塊是被導入__name__的值是模塊名字，若是模塊是直接執行__name__的值是__main__；

每一個模塊都有一個名爲__name__的內建變量，此變量會根據調用此模塊的方式發生變化，若是此文件被做爲模塊導入__name__的值爲模塊名稱，若是文件被直接執行則__name__的值爲__main__；

 

python對象類型及運算：

python程序中保存的全部數據都是圍繞對象這個概念展開的，程序中存儲的全部數據都是對象；

每一個對象都有一個身份（id()，在內在中的具體位置）、一個類型（type()）、一個值，如school='magedu'會以magedu建立一個字符串對象，其身份是指向它在內存中所處位置的指針（內存地址），而school就是引用這個具體位置的名稱；

對象的類型也稱對象的類別，用於描述對象的內部表示及它支持的方法和操做，對象的類型決定了它所支持的方法和操做，某一對象一旦建立出來，它所支持或適用的方法就肯定了；

建立特定類型的對象時，有時也將該對象稱爲該類型的實例；

實例被建立後，其身份和類型就不可改變，若對象的值可修改的稱爲可變對象，若對象的值不可修改則稱爲不可變對象；

若是某個對象包含其它對象的引用，則稱其爲容器；

大多數對象都擁有大量特有的數據屬性（與對象相關的值）和方法（被調用時將在對象上執行某些操做的函數），使用點.運算符可訪問屬性和方法，訪問屬性時點號後跟屬性名便可，訪問方法點號後跟方法還要跟小括號表示調用；

類=數據（變量）+方法（函數），通常講，方法是公共的，而數據是私有的，class自定義類型時使用，type查看內置類，instance實例化；

對象的身份與類型，python內置函數id()可返回一個對象的身份，即該對象在內存中的位置；

兩個對象比較：

is運算符，身份比較，用於比較兩個對象的身份，id()用於肯定是否爲同一個對象；

type，類型比較，用於返回一個對象的類型，用於肯定是否同屬於一個類型；

==值比較，等值比較；

對象類型自己也是一個對象，稱爲對象的類，該對象的定義是惟一的，且對於某類型的全部實例都是相同的，全部類型對象都有一個指定的名稱，可用於執行類型檢查，如list、dict

In [1]: a=1

In [2]: b=2

In [3]: a is b

Out[3]: False

In [4]: a==b

Out[4]: False

In [5]: type(a) is type(b)

Out[5]: True

 

python核心數據類型：

數字（int,long,float,complex,bool）；

字符（str,unicode）；

列表（list）；

元組（tuple）；

字典（dict）；

文件（file）；

其它類型（set集合，frozenset，類類型，None）

 

其它文件類工具（pipes，fifos，sockets）

 

In [2]: str1='hello world'

In [3]: l1=list(str1)

In [4]: print l1

['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o','r', 'l', 'd']

In [5]: t1=tuple(str1)

In [6]: print t1

('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o','r', 'l', 'd')

In [7]: s1=set(str1)

In [8]: print s1

set([' ', 'e', 'd', 'h', 'l', 'o', 'r','w'])

In [9]: l1=[('a',1),('b',2),('c',3)]

In [10]: d1=dict(l1)   （使用dict建立字典，l1必須是列表它裏面包含的是分別由兩元素組成的元組，每單個元組是這個列表的元素）

In [11]: print d1

{'a': 1, 'c': 3, 'b': 2}

In [12]: f1=frozenset(str1)

In [13]: print f1

frozenset([' ', 'e', 'd', 'h', 'l', 'o','r', 'w'])

In [14]: chr(5)

Out[14]: '\x05'

In [15]: c1=chr(5)

In [16]: print c1

In [17]: type(c1)

Out[17]: str

In [18]: str1='45'

In [19]: num1=ord(str1)

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

TypeError                                 Traceback(most recent call last)

<ipython-input-19-1414c93a330e> in<module>()

----> 1 num1=ord(str1)

TypeError: ord() expected a character, butstring of length 2 found

In [20]: ord(c1)

Out[20]: 5

In [21]: hex(88)

Out[21]: '0x58'

In [22]: bin(88)

Out[22]: '0b1011000'

In [23]: oct(88)

Out[23]: '0130'

 

數字類型操做：

python有5種數字類型（bool布爾型、int整型、長整型、浮點型、complex複數），全部數字類型均爲不可變類型，python的數字字面量（bool，True爲1，False爲0；整數；浮點數；複數）；

算術運算（+,-,*,/,//截斷除法,**乘方,%,-x一元減法,+x一元加法）；

比較運算（<<左移（使數字變大）,>>右移,&按位與,|按位或,^按位異或,~x按位求反）；

In [24]: import math  （用來實現高級數學運算）

In [25]: math.

math.acos       math.atanh      math.e          math.factorial  math.hypot     math.log10      math.sin

math.acosh      math.ceil       math.erf        math.floor      math.isinf      math.log1p      math.sinh

math.asin       math.copysign   math.erfc       math.fmod       math.isnan      math.modf       math.sqrt

math.asinh      math.cos        math.exp        math.frexp      math.ldexp      math.pi         math.tan

math.atan       math.cosh       math.expm1      math.fsum       math.lgamma     math.pow        math.tanh

math.atan2      math.degrees    math.fabs       math.gamma      math.log        math.radians    math.trunc

 

序列sequence類型：

序列表示索引爲非負整數的有序對象集合，包括：字符串、列表、元組；

字符串是字符的，列表和元組是任意python對象的序列；

字符和元組是不可變序列，列表是可變序列（支持插入、刪除、替換等原處修改），全部序列都支持迭代；

字符串字面量，把文本放入單引號、雙引號、三引號之中，若要使用unicode編碼，需在字符串以前加u進行標識，如u'magedu'；

In [1]: str1=u'hello world'  （在字符串引號前加u表示支持unicode編碼，python3.X已支持此項不需加u）

In [2]: type(str1)

Out[2]: unicode

docstring文檔字符串，模塊、類、函數的第一條語句是一段字符的話，該段字符串就成爲文檔字符串，可用__doc__屬性引用；

In [3]: def printName():

  ...:     "test function"

  ...:     print 'hello magedu'

  ...:    

In [4]: printName.__doc__

Out[4]: 'test function'

適用全部序列的操做和方法：

s[i]（索引運算符）

s[i:j]（切片運算符，切片後的結果會生成新的對象，支持負索引，正負索引之和爲字串長度len(s)）

s[i:j:stride]（擴展切片運算符，stride爲步長）

min(s),max(s)（只適用於能對序列中的元素排序的序列，如果字符是按ASCII碼錶中的次序）

sum(s)（只適用於數字序列）

all(s)（檢查s中全部項是否爲True）

any(s)（檢查s中任意項是否爲True）

序列類型支持的操做符：

s+r（鏈接）；

s*N,N*s（製做s的N個副本）；

v1,v2,v3,...,vn=s（變量解包unpack）；

s[i]（索引）；

s[i:j]（切片）；

s[i:j:stride]（擴展切片）；

x in s,x not in s（從屬關係判斷）；

for x in s:（迭代）；

all(s)（若是s中的全部項都爲True則返回True）；

any(s)（若是s中的任意項爲True則返回True）；

len(s)（長度）；

min(s),max(s)；

sum(s[,initial])（具備可選初始值的項的和）；

適用於可變序列的操做：

s[i]=VALUE（項目賦值）

s[i:j]=TUPLE（切片賦值）

s[i:j:stride]=TUPLE（擴展切片賦值）

del s[i]（項目刪除）

del s[i:j]（切片刪除）

del s[i:j:stride]（擴展切片刪除）

適用於字符串str的操做和方法：

python2提供2種字符串對象類型（字節字符串，字節序列，8bit數據；unicode字符串，unicode字符序列，16bit數據；python可用32bit整數保存unicode字符，但此爲可選特性）；

help(str.METHOD)

dir(str)

In [47]: print dir(str)

['__add__', '__class__', '__contains__','__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__','__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__','__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__','__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__','__setattr__', '__sizeof__', '__str__', '__subclasshook__','_formatter_field_name_split', '_formatter_parser','capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs','find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower','isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip','partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit','rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title','translate', 'upper', 'zfill']

s.capitalize()（首字母變大寫）

s.index(sub[,start[,end]])（找到指定子字符串sub首次出現的位置，不然報錯）

s.join(t)（使用s做爲分隔符鏈接序列t中的字符串，如'_'join(str1)）

s.lower()（轉小寫）

s.upper()（轉大寫）

s.replace(old,new[,maxreplace])（替換一個子字符串）

s.split([sep[,maxsplit]])（使用sep做爲分隔符對一個字符串進行劃分，maxsplit是劃分的最大次數）

s.strip([chrs])（刪除chrs開頭和結尾的空白或字符）

可用於列表list的操做和方法：

列表（容器類型，任意對象的有序集合，經過索引訪問其中的元素，可變對象，異構（任意數據類型），支持原處修改，修改指定的索引元素，修改指定的分片，刪除語句，內置方法）；

list(s)（可將任意可迭代類型轉換爲列表，若是s已是一個列表，則該函數構造的新列表是s的一個淺複製）；

In [46]: print dir(list)

['__add__', '__class__', '__contains__','__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__','__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__','__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__','__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__','__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__','__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop','remove', 'reverse', 'sort']

s.append(x)（將一個新元素x追加到列表s末尾）；

s.extend(x)（將一個新列表追加到列表s末尾）；

s.count(x)（計算列表s中x出現的次數）；

s.index(x,[start[,stop]])（當s[i]==x.start時返回最小的i，可選參數stop用於指定搜索的起始和結束索引）；

s.insert(i,x)（在索引i處插入x）；

s.pop([i])（刪除索引i對應的元素並彈出該元素，若省略i則刪除並彈出最後一個元素）；

s.remove(x)（搜索x並從列表s中移除它）；

s.reverse()（在原處反向排序列表s中的全部元素，reverse和sort操做後不返回結果，查看要用print語句）；

s.sort([key[,reverse]])（在原處對列表s中的全部元素進行排序，key是一個鍵函數，reverse是一個標誌表示以倒序對列表進行排序，key和reverse應該始終以關鍵字函數的形式指定）；

l1+l2（合併兩個列表，返回一個新列表，不會修改原列表）；

l1*N（把l1重複N次，返回新列表）；

in,not in（成員關係判斷用，用法item in container）；

列表解析：[elem*2for elem in l1]

列表複製的兩種方式：方式一l2=l1[:]；方式二l2=copy.deepcopy(l1)；

s[i]=x（索引實現賦值）；

s[i:j]=r（切片賦值）；

s[i:j:stride]=r（擴展切片賦值）；

del s[i]（刪除一個元素）；

del s[i:j]（刪除一個切片）；

del s[i:j:stride]（刪除一個擴展切片）；

元組tuple的操做（同列表）：

元組（容器類型，任意對象的有序集合，經過索引訪問其中的元素，不可變對象，長度固定，異構，嵌套）；

In [45]: print dir(tuple)

['__add__', '__class__', '__contains__','__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__','__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__','__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__','__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__','__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

t1+t4（合併兩元組）；

t1*N（重複）；

t1=('x',[1,2,3])（元組自己是不可變對象，但元組中的某元素是可變的那最終也是可變的）；

t1[1].pop()

字典dict支持的操做和方法：

字典在其它編程語言中又稱做關聯數組或散列表，經過key實現元素存取，無序集合，可變類型容器，長度可變，異構，嵌套；

In [48]: print dir(dict)

['__class__', '__cmp__', '__contains__','__delattr__', '__delitem__', '__doc__', '__eq__', '__format__', '__ge__','__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__','__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__','__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__','__str__', '__subclasshook__', 'clear', 'copy','fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues','keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'viewitems','viewkeys', 'viewvalues']

字典複製d2=d1.copy()；

d1.get('x')等同於d1['x']（當key所對應的value存在時這兩種方式獲得的結果同樣，當key所對應的value不存在，使用get返回空，而用下標引用的方式會拋出異常）；

d1.items()（返回key,value的元組列表，把key和value拆爲元組，全部元組構成列表）；

d2={}.fromkeys(l1,0)（可將列表l1的元素生成字典d2的 key，d2的value全爲0）；

t1,t2=d1.items()（變量解包，兩邊要有相同的數量）；

d1.keys()（返回key的列表）；

d1.values()（返回value的列表）；

d1.pop('x)（刪除並彈出key所對應的value）；

d1.popitem()（隨機刪除並彈出key所對應的value）；

d1.update(d2)（相似列表的extend方法，將一個字典添加至當前字典，如有key重複新值會覆蓋當前值）；

i1=d1.iteritems()（返回迭代器對象，可用i1.next()遍歷對象的每一個元素，所有返回即結束不會再次從頭返回，若用i1.next不加小括號返回的是對象的身份，加小括號是調用其方法）；

i2=d1.iterkeys()（i2.next()）；

i3=d1.itervalues()（i3.next()）；

d1.viewitems()（顯示字典的定義方式）；

d2=dict(name='jerry',age=18,gender='M')（可用此種方式建立字典）；

d3=dict(zip('xyz','123'))（可用此種方式建立字典，zip分別將兩組序列中的元素一一對應生成元組組成的列表）

d2.viewkeys()

d2.viewvalues()

d2.viewitems()

注：help(dict)

class dict(object)

 | dict() -> new empty dictionary

 | dict(mapping) -> new dictionary initialized from a mapping object's

 |     (key, value) pairs

 | dict(iterable) -> new dictionary initialized as if via:

 |      d= {}

 |     for k, v in iterable:

 |         d[k] = v

 | dict(**kwargs) -> new dictionary initialized with the name=valuepairs

 |     in the keyword argument list.  Forexample:  dict(one=1, two=2)

注：help(zip)

zip(...)

   zip(seq1 [, seq2 [...]]) -> [(seq1[0], seq2[0] ...), (...)]

集合set的操做和方法：

set集合（無序排列的可hash的值，支持集合關係測試，支持成員關係測試，迭代，不支持index、元素獲取、切片，沒有特定語法格式，只能經過工廠函數建立；集合的類型：set()可變，frozenset()不可變）；

In [8]: print dir(set)

['__and__', '__class__', '__cmp__','__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__','__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__','__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__','__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__','__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__','__sub__', '__subclasshook__', '__xor__', 'add','clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection','intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove','symmetric_difference', 'symmetric_difference_update', 'union', 'update']

In [24]: print dir(frozenset)

['__and__', '__class__', '__cmp__','__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__','__getattribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__','__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__','__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__','__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint','issubset', 'issuperset', 'symmetric_difference', 'union']

len(s)（返回集合s中的項目數）；

s.copy()（製做s的副本）；

s.difference(t)（求差集，返回全部在s中，但不在t中的項目）；

s.intersection(t)（求交集，返回全部同時在s和t中的項目）；

s.isdisjoint(t)（若是s和t沒有相同項則返回True）；

s.issubset(t)（若是s是t的一個子集則返回True）；

s.issuperset(t)（若是s是t的一個超集則返回True）；

s.symmetric_difference(t)（求對稱差集，返回全部在s和t中，但又不一樣時在這兩個集合中的項）；

s.union(t)（求並集，返回全部在s或t中的項）；

集合類型的操做符：

s | t（s和t的並集，同s.union(t)）；

s & t（s和t的交集，同s.intersection(t)）；

s - t（求差集，同s.difference(t)）；

s ^ t（求對稱差集，同s.symmetric_difference(t)）；

max(s),min(s)

 

In [1]: s1=set([1,2,3])

In [2]: print s1

set([1, 2, 3])

In [3]: s2=set([2,3,4])

In [4]: s1 & s2

Out[4]: {2, 3}

In [5]: s1.intersection(s2)   （交集）

Out[5]: {2, 3}

In [6]: s1.symmetric_difference(s2)   （symmetric對稱）

Out[6]: {1, 4}

In [7]: s1|s2

Out[7]: {1, 2, 3, 4}

In [9]: s3=set('xyz')

In [10]: s3.pop()   （隨機刪除一個元素）

Out[10]: 'y'

In [11]: s1 | s2

Out[11]: {1, 2, 3, 4}

In [12]: s1 & s2

Out[12]: {2, 3}

In [13]: s1 - s2

Out[13]: {1}

In [14]: s1.difference(s2)

Out[14]: {1}

In [15]: s1 ^ s2

Out[15]: {1, 4}

In [16]: max(s1)

Out[16]: 3

In [17]: min(s2)

Out[17]: 2

In [18]: id(s1)

Out[18]: 39064560

In [19]: s1.update(s2)

In [20]: print s1

set([1, 2, 3, 4])

In [21]: id(s1)

Out[21]: 39064560

In [22]: s1.add(5)

In [23]: print s1

set([1, 2, 3, 4, 5])

 

 

總結：

可變對象（list,dict,set）；

不可變對象（數值、字串、tuple、frozenset）；

對象的三部分（身份id()，類型type()，值）；

方法便是某類型支持的操做（支持的調用接口），如3+5轉換爲3.__add__(5)；

類型肯定後方法就肯定了，不一樣的類有不一樣的方法，方法是施加在實例化的對象上；

python中類和類型不加區分，類=數據+方法，類在初始化時做賦值，類要實例化爲對象這些對象數據不一樣稱爲不一樣的實例；

在內存中，變量名存儲在一個位置，對象存儲在另外一個位置，變量名只是引用對象，python中變量名沒有類型，對象纔有，變量名引用了哪一種對象則變量名就是哪一種類型，當某一對象不被引用或引用計數爲0時則該對象在必定時間內可被GC回收；

點運算符兩種功能（獲取屬性和方法；屬性即所屬某實例的變量名，指定數據則會返回一個數據，要用print語句顯示；方法就是類的函數也即支持的操做，獲取方法時後面還要加小括號表示調用對象，callable()    查看某對象是否可調用，可調用對象通常爲類中的方法）；

字串用單引號、雙引號、三引號，單雙引號不加區分，三引號可跨多行；

列表用[]；

元組用()；

字典用{}；

有閉合符號的裏面的內容可直接換行，可不用加換行符，如[],(),{},''' '''；

dir(OBJECT)，獲取對象支持使用的屬性和方法，在python本身的交互模式下顯示的內容不換行，而ipython將顯示更人性化）；

某方法的具體使用幫助help(dict.popitem)；

獲取可調用對象的文檔字符串printOBJECT.__doc__；

 

容器、類型、對象（列表、元組、字典）：

字面量可跨行定義；

全部對象都有引用計數，經過sys.getrefcount(OBJECT)獲得引用計數；

列表和字典都支持兩種類型的複製操做，分別是淺複製和深複製，淺複製（僅是建立新引用並指向原有對象，當原有對象有修改時則最終是有影響的），深複製（建立新對象的引用並遞歸建立全部對象，l2=copy.deepcopy(l1)列表深複製，d2=d1.copy()字典深複製）；

python可的全部對象都是「第一類」，這意味着使用標識符命名的全部對象（函數是建立的），都具備相同狀態，因而，可以命名的全部對象均可以直接當數據進行處理；

全部序列都支持迭代；

全部序列都支持的操做和方法，s[i],s[i:j],s[i:j:stride],len(s),min(s),max(s),sum(s),all(s),any(s)；

可變序列的操做，s[index]=value,s1+s2,s1*N,objectin s,object not in s,s[i:j]=t,del s[index],del s[i:j],del s[i:j:stride]；

 

In [6]: str1='www.magedu.com'

In [7]: str1[6:0:-1]

Out[7]: 'gam.ww'

In [8]: str1[9:3:-1]

Out[8]: 'udegam'

 

In [1]: str1='www.magedu.com'

In [2]: str1.strip('www')

Out[2]: '.magedu.com'

In [3]: str1.capitalize()

Out[3]: 'Www.magedu.com'

In [4]: str1.index('edu')

Out[4]: 7

In [5]: str1.index('m',5)    （從第5個元素開始向後找）

Out[5]: 13

In [6]: l1=list(str1)

In [7]: print l1

['w', 'w', 'w', '.', 'm', 'a', 'g', 'e','d', 'u', '.', 'c', 'o', 'm']

In [8]: ''.join(l1)

Out[8]: 'www.magedu.com'

In [9]: str1.replace('edu','EDU')

Out[9]: 'www.magEDU.com'

In [10]: str1.split('.')

Out[10]: ['www', 'magedu', 'com']

In [11]: str1.split('e')

Out[11]: ['www.mag', 'du.com']

In [12]: str2='         hello     '

In [13]: str2.strip()

Out[13]: 'hello'

In [14]: id(l1)

Out[14]: 21990144

In [15]: type(l1)

Out[15]: list

In [16]: l1[0:3]=[]

In [17]: print l1

['.', 'm', 'a', 'g', 'e', 'd', 'u', '.','c', 'o', 'm']

In [18]: del l1[0]

In [19]: print l1

['m', 'a', 'g', 'e', 'd', 'u', '.', 'c','o', 'm']

In [20]: del l1[6:]

In [21]: print l1

['m', 'a', 'g', 'e', 'd', 'u']

In [22]: id(l1)    （刪除元素後身份標識不會變，即原處修改）

Out[22]: 21990144

In [23]: l1.pop(0)

Out[23]: 'm'

In [24]: print l1

['a', 'g', 'e', 'd', 'u']

In [25]: l1.sort()  （原處修改）

In [26]: print l1

['a', 'd', 'e', 'g', 'u']

In [27]: l1.reverse()   （原處修改）

In [28]: print l1

['u', 'g', 'e', 'd', 'a']

In [29]: l1=[1,2,3]

In [30]: l1[3:]=[4,5,6]   （在切片級別修改並替換元素）

In [31]: print l1

[1, 2, 3, 4, 5, 6]

In [32]: range(6)   （生成器對象）

Out[32]: [0, 1, 2, 3, 4, 5]

In [33]: import copy

In [34]: help(copy.deepcopy)

deepcopy(x, memo=None, _nil=[])

   Deep copy operation on arbitrary Python objects.

In [35]: l2=copy.deepcopy(l1)

In [36]: id(l2)

Out[36]: 22026720

In [37]: id(l1)

Out[37]: 21999984

In [38]: l3=l1[:]

In [39]: id(l3)

Out[39]: 22027152

In [41]: t1=('x',[1,2,3])

In [42]: t1[1].pop()

Out[42]: 3

In [43]: print t1

('x', [1, 2])

 

 

 

list舉例：

[root@localhost ~]# vim using_list.py

--------------script start------------------

#!/usr/bin/python

#filename:using_list.py

shoplist=['apple','mango','carrot','banana']

print 'I have',len(shoplist),'items topurchase.'

print 'these items are:',

for item in shoplist:

       print item,

print '\nI also have to buy rice.'

shoplist.append('rice')

print 'My shoplist is now',shoplist

print 'I will sort my list now.'

shoplist.sort()

print 'sorted shopping list is',shoplist

print 'the first item I will buyis',shoplist[0]

olditem=shoplist[0]

del shoplist[0]

print 'I bought the',olditem

print 'my shoplist is now',shoplist

--------------script end-------------------

[root@localhost ~]# python using_list.py

I have 4 items to purchase.

these items are: apple mango carrot banana

I also have to buy rice.

My shoplist is now ['apple', 'mango','carrot', 'banana', 'rice']

I will sort my list now.

sorted shopping list is ['apple', 'banana','carrot', 'mango', 'rice']

the first item I will buy is apple

I bought the apple

my shoplist is now ['banana', 'carrot','mango', 'rice']

 

tuple舉例：

[root@localhost ~]# vim using_tuple.py

------------------script start----------------

#!/usr/bin/python

#filename:using_tuple.py

zoo=('wolf','elephant','penguin')

print 'number of animals in he zoois',len(zoo)

new_zoo=('monkey','dolphin',zoo)

print 'number of animals in the new zoois',len(new_zoo)

print 'all animals in the new_zooare',new_zoo

print 'animals brought from old zooare',new_zoo[2]

print 'last animals brought from old zoois',new_zoo[2][2]

---------------script end------------------

[root@localhost ~]# python using_tuple.py

number of animals in he zoo is 3

number of animals in the new zoo is 3

all animals in the new_zoo are ('monkey','dolphin', ('wolf', 'elephant', 'penguin'))

animals brought from old zoo are ('wolf','elephant', 'penguin')

last animals brought from old zoo ispenguin

 

dictionary舉例：

[root@localhost ~]# vim using_dictionary.py

-------------------script start--------------

#!/usr/bin/python

#filename:using_dictionary.py

ab={'jowin':'jowin@163.com',

       'xiang':'xiang@qq.com',

       'matsumoto':'matsumoto@ruby-lang.org',

       'spammer':'spammer@hotmail.com'

       }

print "jowin's address is %s" %ab['jowin']

ab['guido']='guido@python.org'

del ab['jowin']

print '\nthere are %d contacts in theaddress-book\n' % len(ab)

for name,address in ab.items():

       print 'contact %s at %s' % (name,address)

if 'guido' in ab:

       print "\nguido's address is %s" % ab['guido']

------------------script end--------------------

[root@localhost ~]# python using_dictionary.py

jowin's address is jowin@163.com

 

there are 4 contacts in the address-book

 

contact matsumoto atmatsumoto@ruby-lang.org

contact xiang at xiang@qq.com

contact spammer at spammer@hotmail.com

contact guido at guido@python.org

 

guido's address is guido@python.org

 

序列（list、tuple、字符串都是序列，序列的兩個主要特色：索引index操做符（可得到一個特定條目）和切片split操做符（可得到一部分條目））

序列的神奇之處在於可用相同的方法訪問tuple、list、字符串

序列舉例：

[root@localhost ~]# vim seq.py

------------------script start-------------------

#!/usr/bin/python

#filename:seq.py

shoplist=['apple','mango','carrot','banana']

print 'item 0 is',shoplist[0]

print 'item 3 is',shoplist[3]

print 'item -1 is',shoplist[-1]

print 'item -2 is',shoplist[-2]

print 'item 1 to 3 is',shoplist[1:3]

print 'item 2 to end is',shoplist[2:]

print 'item start to end is',shoplist[:]

name='jowin'

print 'characters 1 to 3 is',name[1:3]

print 'characters 2 to end is',name[2:]

print 'characters start to end is',name[:]

-------------------script end---------------

[root@localhost ~]# python seq.py

item 0 is apple

item 3 is banana

item -1 is banana

item -2 is carrot

item 1 to 3 is ['mango', 'carrot']

item 2 to end is ['carrot', 'banana']

item start to end is ['apple', 'mango','carrot', 'banana']

characters 1 to 3 is ow

characters 2 to end is win

characters start to end is jowin

 

參考（當建立一個對象並給它賦一個變量時，這個變量僅僅參考那個對象，而不是表示這個對象自己，這稱做名稱到對象的綁定，變量名是指向存儲那個對象的內存，若要複製list、tuple或相似的序列或其它複雜的對象，必須使用切片操做符，若只是想要使用另外一個變量名，兩個名稱均可參考同一個對象）

注：列表的賦值語句不建立拷貝，得使用切換操做符建立序列的拷貝

參考舉例：

[root@localhost ~]# vim reference.py

--------------------script start---------------------

#!/usr/bin/python

#filename:reference.py

print 'simple assignment'

shoplist=['apple','mango','carrot','banana']

mylist=shoplist

del shoplist[0]

print 'shoplist is',shoplist

print 'mylist is',mylist

print 'copy by making a full slice'

mylist=shoplist[:]

del mylist[0]

print 'shoplist is',shoplist

print 'mylist is',mylist

-------------------script end--------------------------

[root@localhost ~]# python reference.py

simple assignment

shoplist is ['mango', 'carrot', 'banana']

mylist is ['mango', 'carrot', 'banana']

copy by making a full slice

shoplist is ['mango', 'carrot', 'banana']

mylist is ['carrot', 'banana']

 

更多字符串內容（字符串也是對象，一樣具備方法（可檢驗一部分字符串，去除空格等各類工做），程序中使用的字符串都是str類的對象）

方法（startswith（測試字符串是否以給定的字符串開始）；find（找出給定字符串在另外一字符串的位置）；'DELIMETER'.join（分隔符字符串join序列可整潔輸出））

字符串舉例：

[root@localhost ~]# vim str_methods.py

----------------script start--------------------

#!/usr/bin/python

#filename:str_methods.py

name='jowin'

if name.startswith('jow'):

       print 'yes,the string startswith "jow"'

if 'w' in name:

       print 'yes,it conatains the string "w"'

if name.find('win')!=-1:

       print 'yes,it contains the string "win"'

delimeter='_*_'

mylist=['Brazil','Russia','India','China']

print delimeter.join(mylist)

----------------script end---------------------

[root@localhost ~]# python str_methods.py

yes,the string startswith "jow"

yes,it conatains the string "w"

yes,it contains the string "win"

Brazil_*_Russia_*_India_*_China

 

備份腳本舉例：

os.sep（會根據OS給出目錄分隔符，如linux爲"/"，win爲"\"，mac爲":"，使用os.sep有利於程序移植）

time.strftime('%Y%m%d'）（格式化時間輸出）

下例給出三個版本，先完成基本功能再逐步優化，還能夠進一步優化（可用tar命令的-X選項將某文件排除在外，tar代替zip使備份更快更小；最好使用zipfile和tarfile這是python標準庫的一部分，不推薦使用os.system函數容易引起嚴重錯誤；使用-v使程序更具交互性；sys.argv使文件和目錄經過命令行直接傳遞給腳本）

[root@localhost ~]# vim backup_ver1.py

----------------script start---------------

#!/usr/bin/python

#filename:backup_ver1.py（優化文件名，用日期做爲目錄名，用時間做爲文件名）

import os,time

source=['/home/webgame/houtai','/usr/local/servernd']

target_dir='/backup/'

target=target_dir+time.strftime('%Y%m%d-%H%M%S')+'.zip'

zip_command="zip -qr '%s' %s" %(target,' '.join(source))

if os.system(zip_command)==0:

       print 'successful backup to',target

else:

       print 'backup failed'

-----------------script end----------------

[root@localhost ~]# python backup_ver1.py

successful backup to/backup/20160523-000610.zip

[root@localhost ~]# ll /backup/

total 4

-rw-r--r--. 1 root root 356 May 23 00:06 20160523-000610.zip

 

[root@localhost ~]# vim backup_ver2.py

-----------------script start-----------------

#!/usr/bin/python

#filename:backup_ver2.py

import os,time

source=['/home/webgame/houtai','/usr/local/servernd']

target_dir='/backup/'

today=target_dir+time.strftime('%Y%m%d')

now=time.strftime('%H%M%s')

if not os.path.exists(today):

       os.mkdir(today)

       print 'successfully created directory',today

target=today+os.sep+now+'.zip'

zip_command="zip -qr '%s' %s" %(target,' '.join(source))

if os.system(zip_command)==0:

       print 'successfully backup to',target

else:

       print 'backup failed'

-----------------scritp end----------------

[root@localhost ~]# python backup_ver2.py

successfully created directory/backup/20160523

successfully backup to/backup/20160523/002721.zip

 

[root@localhost ~]# vim backup_ver3.py

----------------script start------------------

#!/usr/bin/python

#filename:backup_ver3.py（優化可添加註釋信息）

import os,time

source=['/home/webgame/houtai','/usr/local/servernd']

target_dir='/backup/'

today=target_dir+time.strftime('%Y%m%d')

now=time.strftime('%H%M%S')

comment=raw_input('Enter a comment-->')

if len(comment)==0:

       target=today+os.sep+now+'.zip'

else:

       target=today+os.sep+now+'_'+comment.replace(' ','_')+'.zip'

if not os.path.exists(today):

       os.mkdir(today)

       print 'successfully created directory',today

zip_command='zip -qr "%s" %s' %(target,' '.join(source))

if os.system(zip_command)==0:

       print 'successfully backup to',target

else:

        print 'backup failed'

------------------script end--------------------

[root@localhost ~]# python backup_ver3.py

Enter a comment-->test

successfully backup to/backup/20160523/002950_test.zip