每種語言都各具特色，在各自領域都有其适用範圍，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
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
注：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)
<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------------------
#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----------------
#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--------------
#filename:using_dictionary.py
ab={'jowin':'[email protected]',
'xiang':'[email protected]',
'matsumoto':'[email protected]',
'spammer':'[email protected]'
}
print "jowin's address is %s" %ab['jowin']
ab['guido']='[email protected]'
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 [email protected]
there are 4 contacts in the address-book
contact matsumoto [email protected]
contact xiang at [email protected]
contact spammer at [email protected]
contact guido at [email protected]
guido's address is [email protected]
序列（list、tuple、字元串都是序列，序列的兩個主要特點：索引index操作符（可獲得一個特定條目）和切片split操作符（可獲得一部分條目））
序列的神奇之處在于可用相同的方法通路tuple、list、字元串
序列舉例：
[root@localhost ~]# vim seq.py
------------------script start-------------------
#filename:seq.py
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---------------------
#filename:reference.py
print 'simple assignment'
mylist=shoplist
print 'shoplist is',shoplist
print 'mylist is',mylist
print 'copy by making a full slice'
mylist=shoplist[:]
del mylist[0]
-------------------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
mylist is ['carrot', 'banana']
更多字元串内容（字元串也是對象，同樣具有方法（可檢驗一部分字元串，去除空格等各種工作），程式中使用的字元串都是str類的對象）
方法（startswith（測試字元串是否以給定的字元串開始）；find（找出給定字元串在另一字元串的位置）；'DELIMETER'.join（分隔符字元串join序列可整潔輸出））
字元串舉例：
[root@localhost ~]# vim str_methods.py
----------------script start--------------------
#filename:str_methods.py
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---------------
#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-----------------
#filename:backup_ver2.py
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'
print 'successfully backup to',target
-----------------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------------------
#filename:backup_ver3.py（優化可添加注釋資訊）
now=time.strftime('%H%M%S')
comment=raw_input('Enter a comment-->')
if len(comment)==0:
target=today+os.sep+now+'.zip'
target=today+os.sep+now+'_'+comment.replace(' ','_')+'.zip'
zip_command='zip -qr "%s" %s' %(target,' '.join(source))
print 'backup failed'
[root@localhost ~]# python backup_ver3.py
Enter a comment-->test
successfully backup to/backup/20160523/002950_test.zip
本文轉自 chaijowin 51CTO部落格，原文連結：http://blog.51cto.com/jowin/1782169，如需轉載請自行聯系原作者
![GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)