Python（英語發音：/ˈpaɪθən/）, 是一種面向對象、解釋型計算機程序設計語言，由Guido van Rossum於1989年末發明，第一個公開發行版發行於1991年。Python語法簡潔而清晰，具備豐富和強大的類庫。它常被暱稱爲膠水語言，它可以把用其餘語言製做的各類模塊（尤爲是C/C++）很輕鬆地聯結在一塊兒。常見的一種應用情形是，使用Python快速生成程序的原型（有時甚至是程序的最終界面），而後對其中有特別要求的部分，用更合適的語言改寫，好比3D遊戲中的圖形渲染模塊，性能要求特別高，就能夠用C++重寫。java
官網：https://www.python.org/python
下載：https://www.python.org/downloads/c++
一：安裝時選擇加入環境變量shell
二：重啓express
三：測試編程
打開cmd，輸入：python安全
四：hello world數據結構
1. 使用文本建立以.py後綴的文件，如test.py，輸入如下代碼(python3的語法)：app
print('hellow world');函數
2. 打開cmd，切換到test.py目錄，輸入如下命令
python test.py
五：基本語法摘要
1：函數
函數經過def定義。def關鍵字後跟函數的標識符名稱，而後跟一對圓括號，括號以內能夠包含一些變量名，該行以冒號結尾；接下來是一塊語句，即函數體。
def sumOf(a, b):
return a + b 1).函數形參
函數中的參數名稱爲‘形參’，調用函數時傳遞的值爲‘實參’
2).局部變量
在函數內定義的變量與函數外具備相同名稱的其餘變量沒有任何關係，即變量名稱對於函數來講是局部的。這稱爲變量的做用域。
global語句， 爲定義在函數外的變量賦值時使用global語句。
def func():
global x
print "x is ", x
x = 1
x = 3
func()
print x 3).默認參數
經過使用默認參數可使函數的一些參數是‘可選的’。
def say(msg, times = 1):
print msg * times
say("peter")
say("peter", 3)
注意：只有在形參表末尾的那些參數能夠有默認參數值，即不能在聲明函數形參的時候，先聲明有默認值的形參然後聲明沒有默認值的形參，只是由於賦給形參的值是根據位置而賦值的。
4).關鍵參數
若是某個函數有不少參數，而如今只想指定其中的部分，那麼能夠經過命名爲這些參數賦值（稱爲‘關鍵參數’）。
優勢：沒必要擔憂參數的順序，使函數變的更加簡單；假設其餘參數都有默認值，能夠只給咱們想要的那些參數賦值。
def func(a, b=2, c=3):
print "a is %s, b is %s, c is %s" % (a, b, c)
func(1) #a is 1, b is 2, c is 3
func(1, 5) #a is 1, b is 5, c is 3
func(1, c = 10) #a is 1, b is 2, c is 10
func(c = 20, a = 30) #a is 30, b is 2, c is 20
5).return 語句
return語句用來從一個函數返回，即跳出函數。可從函數返回一個值。
沒有返回值的return語句等價於return None。None表示沒有任何東西的特殊類型。
6).DocStrings (文檔字符串)
def func():
'''This is self-defined function
Do nothing'''
pass
print func.__doc__
2：模塊
模塊就是一個包含了全部你定義的函數和變量的文件，模塊必須以.py爲擴展名。模塊能夠從其餘程序中‘輸入’(import)以便利用它的功能。
在python程序中導入其餘模塊使用'import', 所導入的模塊必須在sys.path所列的目錄中，由於sys.path第一個字符串是空串''即當前目錄，因此程序中可導入當前目錄的模塊。
1).字節編譯的.pyc文件
導入模塊比較費時，python作了優化，以便導入模塊更快些。一種方法是建立字節編譯的文件，這些文件以.pyc爲擴展名。
pyc是一種二進制文件，是py文件經編譯後產生的一種byte code，並且是跨平臺的（平臺無關）字節碼，是有python虛擬機執行的，相似於
java或.net虛擬機的概念。pyc的內容，是跟python的版本相關的，不一樣版本編譯後的pyc文件是不一樣的。
2).from .. import
若是想直接使用其餘模塊的變量或其餘，而不加'模塊名+.'前綴，可使用from .. import。
例如想直接使用sys的argv，from sys import argv 或 from sys import *
3).模塊的__name__
每一個模塊都有一個名稱，py文件對應模塊名默認爲py文件名，也可在py文件中爲__name__賦值；若是是__name__，說明這個模塊被用戶單獨運行。
4).dir()函數
dir(sys)返回sys模塊的名稱列表；若是不提供參數，即dir()，則返回當前模塊中定義名稱列表。
del -> 刪除一個變量/名稱，del以後，該變量就不能再使用。
3：數據結構
python有三種內建的數據結構：列表、元組和字典。
1).列表
list是處理一組有序項目的數據結構，列表是可變的數據結構。列表的項目包含在方括號[]中，eg: [1, 2, 3]， 空列表[]。判斷列表中是否包含某項可使用in， 好比 l = [1, 2, 3]; print 1 in l; #True；支持索引和切片操做；索引時若超出範圍，則IndexError；使用函數len()查看長度；使用del能夠刪除列表中的項，eg: del l[0] # 若是超出範圍，則IndexError
list函數以下：
append（value） ---向列表尾添加項value
l = [1, 2, 2]
l.append(3) #[1, 2, 2, 3]
count(value) ---返回列表中值爲value的項的個數
l = [1, 2, 2]
print l.count(2) # 2
extend(list2) ---向列表尾添加列表list2
l = [1, 2, 2]
l1 = [10, 20]
l.extend(l1)
print l #[1, 2, 2, 10, 20]
index(value, [start, [stop]]) ---返回列表中第一個出現的值爲value的索引，若是沒有，則異常 ValueError
l = [1, 2, 2]
a = 4
try:
print l.index(a)
except ValueError, ve:
print "there is no %d in list" % a
insert(i, value) ---向列表i位置插入項vlaue，若是沒有i，則添加到列表尾部
l = [1, 2, 2]
l.insert(1, 100)
print l #[1, 100, 2, 2]
l.insert(100, 1000)
print l #[1, 100, 2, 2, 1000]
pop([i]) ---返回i位置項，並從列表中刪除；若是不提供參數，則刪除最後一個項；若是提供，可是i超出索引範圍，則異常IndexError
l = [0, 1, 2, 3, 4, 5]
print l.pop() # 5
print l #[0, 1, 2, 3, 4]
print l.pop(1) #1
print l #[0, 2, 3, 4]
try:
l.pop(100)
except IndexError, ie:
print "index out of range"
remove(value) ---刪除列表中第一次出現的value，若是列表中沒有vlaue，則異常ValueError
l = [1, 2, 3, 1, 2, 3]
l.remove(2)
print l #[1, 3, 1, 2, 3]
try:
l.remove(10)
except ValueError, ve:
print "there is no 10 in list"
reverse() ---列表反轉
l = [1, 2, 3]
l.reverse()
print l #[3, 2, 1]
sort(cmp=None, key=None, reverse=False) ---列表排序
2）元組
tuple和list十分類似，可是tuple是不可變的，即不能修改tuple，元組經過圓括號中用逗號分割的項定義；支持索引和切片操做；可使用 in查看一個元素是否在tuple中。空元組()；只含有一個元素的元組("a",) #須要加個逗號
優勢：tuple比list速度快；對不須要修改的數據進行‘寫保護’，能夠是代碼更安全
tuple與list能夠相互轉換，使用內置的函數list()和tuple()。
l = [1, 2, 3]
print l # [1, 2, 3]
t = tuple(l)
print t # (1, 2, 3)
l1 = list(t)
print l1 #[1, 2, 3]
元組最一般的用法是用在打印語句，以下例：
name = "xxxx"
age = 25
print "Name: %s; Age: %d" % (name, age) # Name: xxxx; Age: 25
函數以下：
count(value) ---返回元組中值爲value的元素的個數
t = (1, 2, 3, 1, 2, 3)
print t.count(2) # 2
index(value, [start, [stop]]) ---返回列表中第一個出現的值爲value的索引，若是沒有，則異常 ValueError
t = (1, 2, 3, 1, 2, 3)
print t.index(3) # 2
try:
print t.index(4)
except ValueError, ve:
print "there is no 4 in tuple" # there is no 4 in tuple
3) 字典
字典由鍵值對組成，鍵必須是惟一的；eg: d = {key1:value1, key2:value2}；空字典用{}表示；字典中的鍵值對是沒有順序的，若是想要一個特定的順序，那麼使用前須要對它們排序；d[key] = value，若是字典中已有key，則爲其賦值爲value，不然添加新的鍵值對key/value；使用del d[key] 能夠刪除鍵值對；判斷字典中是否有某鍵，可使用in 或 not in；
d = {}
d["1"] = "one"
d["2"] = "two"
d["3"] = "three"
del d["3"]
for key, value in d.items():
print "%s --> %s" % (key, value)
#1 --> one
#2 --> two
dict函數以下:
clear() ---刪除字典中全部元素
d1 = {"1":"one", "2":"two"}
d1.clear()
print d1 # {}
copy() ---返回字典的一個副本(淺複製)
d1 = {"1":"one", "2":"two"}
d2 = d1.copy()
print d2 #{'1': 'one', '2': 'two'}
dict.fromkeys(seq,val=None) ---建立並返回一個新字典，以序列seq中元素作字典的鍵，val爲字典全部鍵對應的初始值(默認爲None)
l = [1, 2, 3]
t = (1, 2, 3)
d3 = {}.fromkeys(l)
print d3 #{1: None, 2: None, 3: None}
d4 = {}.fromkeys(t, "default")
print d4 #{1: 'default', 2: 'default', 3: 'default'}
get(key,[default]) ---返回字典dict中鍵key對應值，若是字典中不存在此鍵，則返回default 的值(default默認值爲None)
d5 = {1:"one", 2:"two", 3:"three"}
print d5.get(1) #one
print d5.get(5) #None
print d5.get(5, "test") #test
has_key(key) ---判斷字典中是否有鍵key
d6 = {1:"one", 2:"two", 3:"three"}
print d6.has_key(1) #True
print d6.has_key(5) #False
items() ---返回一個包含字典中(鍵, 值)對元組的列表
d7 = {1:"one", 2:"two", 3:"three"}
for item in d7.items():
print item
#(1, 'one')
#(2, 'two')
#(3, 'three')
for key, value in d7.items():
print "%s -- %s" % (key, value)
#1 -- one
#2 -- two
#3 -- three
keys() ---返回一個包含字典中全部鍵的列表
d8 = {1:"one", 2:"two", 3:"three"}
for key in d8.keys():
print key
#1
#2
#3
values() ---返回一個包含字典中全部值的列表
d8 = {1:"one", 2:"two", 3:"three"}
for value in d8.values():
print value
#one
#two
#three
pop(key, [default]) ---若字典中key鍵存在，刪除並返回dict[key]，若不存在，且未給出default值，引起KeyError異常
d9 = {1:"one", 2:"two", 3:"three"}
print d9.pop(1) #one
print d9 #{2: 'two', 3: 'three'}
print d9.pop(5, None) #None
try:
d9.pop(5) # raise KeyError
except KeyError, ke:
print "KeyError:", ke #KeyError:5
popitem() ---刪除任意鍵值對，並返回該鍵值對，若是字典爲空，則產生異常KeyError
d10 = {1:"one", 2:"two", 3:"three"}
print d10.popitem() #(1, 'one')
print d10 #{2: 'two', 3: 'three'}
setdefault(key,[default]) ---若字典中有key，則返回vlaue值，若沒有key，則加上該key，值爲default，默認None
d = {1:"one", 2:"two", 3:"three"}
print d.setdefault(1) #one
print d.setdefault(5) #None
print d #{1: 'one', 2: 'two', 3: 'three', 5: None}
print d.setdefault(6, "six") #six
print d #{1: 'one', 2: 'two', 3: 'three', 5: None, 6: 'six'}
update(dict2) ---把dict2的元素加入到dict中去，鍵字重複時會覆蓋dict中的鍵值
d = {1:"one", 2:"two", 3:"three"}
d2 = {1:"first", 4:"forth"}
d.update(d2)
print d #{1: 'first', 2: 'two', 3: 'three', 4: 'forth'}
viewitems() ---返回一個view對象，（key, value）pair的列表，相似於視圖。優勢是，若是字典發生變化，view會同步發生變化。在迭代過程當中，字典不容許改變，不然會報異常
d = {1:"one", 2:"two", 3:"three"}
for key, value in d.viewitems():
print "%s - %s" % (key, value)
#1 - one
#2 - two
#3 - three
viewkeys() ---返回一個view對象，key的列表
d = {1:"one", 2:"two", 3:"three"}
for key in d.viewkeys():
print key
#1
#2
#3
viewvalues() ---返回一個view對象，value的列表
d = {1:"one", 2:"two", 3:"three"}
for value in d.viewvalues():
print value
#one
#two
#three
4) 序列
序列類型是指容器內的元素從0開始的索引順序訪問，一次能夠訪問一個或者多個元素；列表、元組和字符串都是序列；序列的兩個主要特色是索引操做符和切片操做符；索引能夠獲得特定元素；切片能夠獲得部分序列；
numbers = ["zero", "one", "two", "three", "four"]
print numbers[1] # one
print numbers[-1] # four
#print numbers[5] # raise IndexError
print numbers[:] # ['zero', 'one', 'two', 'three', 'four']
print numbers[3:] # ['three', 'four']
print numbers[:2] # ['zero', 'one']
print numbers[2:4] # ['two', 'three']
print numbers[1:-1] # ['one', 'two', 'three']
切片操做符中的第一個數（冒號以前）表示切片開始的位置，第二個數（冒號以後）表示切片到哪裏結束。 若是不指定第一個數，Python就從序列首開始。若是沒有指定第二個數，則Python會中止在序列尾。 注意，返回的序列從開始位置 開始 ，恰好在結束位置以前 結束。即開始位置是包含在序列切片中的，而結束位置被排斥在切片外。 能夠用負數作切片。負數用在從序列尾開始計算的位置。
4：面向對象編程
python支持面向對象編程；類和對象是面向對象編程的兩個主要方面，類建立一個新的類型，對象是這個類的實例。
對象可使用普通的屬於對象的變量存儲數據，屬於對象或類的變量被稱爲域；對象也可使用屬於類的函數，這樣的函數稱爲類的方法；域和方法能夠合稱爲類的屬性。
域有兩種類型--屬於實例的或屬於類自己；它們分別被稱爲實例變量和類變量。
類使用關鍵字class建立，類的域和方法被列在一個縮進塊中。
類的方法必須有一個額外的第一個參數，可是在調用時不爲這個參數賦值，這個特殊變量指對象自己，按照慣例它的名稱是self，相似C#中的this。
class Animal:
pass #empty block
__init__方法 在類的一個對象被建立時調用該方法；至關於c++中的構造函數。
__del__方法 在類的對象被銷燬時調用該方法；至關於c++中的析構函數。在使用del刪除一個對象時也就調用__del__方法。
Python中全部的類成員(包括數據成員)都是public的；只有一個例外，若是使用的數據成員以雙下劃線爲前綴，則爲私有變量。
class Person:
Count = 0
def __init__(self, name, age):
Person.Count += 1
self.name = name
self.__age = age
p = Person("peter", 25)
p1 = Person("john", 20)
print Person.Count #2
print p.name #peter
print p.__age #AttributeError: Person instance has no attribute '__age' 繼承：爲了使用繼承，基類的名稱做爲一個元組跟在類名稱的後面；python支持多重繼承。下面是一個關於繼承的例子：
class SchoolMember:
'''Represent any school member.'''
def __init__(self, name, age):
self.name = name
self.age = age
print "Initializing a school member."
def tell(self):
'''Tell my details'''
print "Name: %s, Age: %s, " % (self.name, self.age),
class Teacher(SchoolMember):
'''Represent a teacher.'''
def __init__(self, name, age, salary):
SchoolMember.__init__(self, name, age)
self.salary = salary
print "Initializing a teacher"
def tell(self):
SchoolMember.tell(self)
print "Salary: %d" % self.salary
class Student(SchoolMember):
'''Represent a student.'''
def __init__(self, name, age, marks):
SchoolMember.__init__(self, name, age)
self.marks = marks
print "Initializing a student"
def tell(self):
SchoolMember.tell(self)
print "Marks: %d" % self.marks
print SchoolMember.__doc__
print Teacher.__doc__
print Student.__doc__
t = Teacher("Mr. Li", 30, 9000)
s = Student("Peter", 25, 90)
members = [t, s]
for m in members:
m.tell()
5：輸入/輸出
程序與用戶的交互須要使用輸入/輸出，主要包括控制檯和文件；對於控制檯可使用raw_input和print，也可以使用str類。raw_input(xxx)輸入xxx而後讀取用戶的輸入並返回。
1). 文件輸入/輸出
可使用file類打開一個文件，使用file的read、readline和write來恰當的讀寫文件。對文件讀寫能力取決於打開文件時使用的模式，經常使用模式有讀模式("r")、寫模式("w")、追加模式("a")，文件操做以後須要調用close方法來關閉文件。
test = '''\
This is a program about file I/O.
Author: Peter Zhange
Date: 2011/12/25
'''
f = file("test.txt", "w") # open for writing, the file will be created if the file doesn't exist
f.write(test) # write text to file
f.close() # close the file
f = file("test.txt") # if no mode is specified, the default mode is readonly.
while True:
line = f.readline()
if len(line) == 0: # zero length indicates the EOF of the file
break
print line,
f.close()
2) 存儲器
python提供一個標準的模塊，成爲pickle，使用它能夠在一個文件中存儲任何python對象，以後能夠完整的取出來，這被稱爲持久地存儲對象；還有另一個模塊成爲cPickle，它的功能和pickle徹底同樣，只不過它是用c寫的，要比pickle速度快(大約快1000倍)。
import cPickle datafile = "data.data" namelist = ["peter", "john", "king"] f = file(datafile, "w") cPickle.dump(namelist, f) f.close() del namelist f = file(datafile) storednamelist = cPickle.load(f) print storednamelist #['peter', 'john', 'king']
6：異常
當程序中出現某些異常的情況時，異常就發生了。python中可使用try ... except 處理。
try:
print 1/0
except ZeroDivisionError, e:
print e
except:
print "error or exception occurred."
#integer division or modulo by zero
7：Python標準庫
Python標準庫是隨Pthon附帶安裝的，包含了大量極其有用的模塊。
1）sys模塊 sys模塊包含系統對應的功能
sys.argv ---包含命令行參數，第一個參數是py的文件名
sys.platform ---返回平臺類型
sys.exit([status]) ---退出程序，可選的status(範圍：0-127)：0表示正常退出，其餘表示不正常，可拋異常事件供捕獲
sys.path ---程序中導入模塊對應的文件必須放在sys.path包含的目錄中，使用sys.path.append添加本身的模塊路徑
sys.modules ---This is a dictionary that maps module names to modules which have already been loaded
sys.stdin,sys.stdout,sys.stderr ---包含與標準I/O 流對應的流對象
2) os模塊 該模塊包含廣泛的操做系統功能
os.name 字符串指示你正在使用的平臺。好比對於Windows，它是'nt'，而對於Linux/Unix用戶，它是'posix'
os.getcwd() 函數獲得當前工做目錄，即當前Python腳本工做的目錄路徑
os.getenv() 和os.putenv()函數分別用來讀取和設置環境變量
os.listdir() 返回指定目錄下的全部文件和目錄名
os.remove() 函數用來刪除一個文件
os.system() 函數用來運行shell命令
os.linesep 字符串給出當前平臺使用的行終止符。例如，Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'
os.sep 操做系統特定的路徑分割符
os.path.split() 函數返回一個路徑的目錄名和文件名
os.path.isfile() 和os.path.isdir()函數分別檢驗給出的路徑是一個文件仍是目錄
os.path.existe() 函數用來檢驗給出的路徑是否真地存在
8：其它
1）lambda
lambda語句被用來建立新的函數對象，並在運行時返回它們。lambda須要一個參數，後面僅跟單個表達式做爲函數體，而表達式的值被這個
新建的函數返回。 注意，即使是print語句也不能用在lambda形式中，只能使用表達式。 func = lambda s: s * 3 print func("peter ") #peter peter peter func2 = lambda a, b: a * b print func2(2, 3) #6 2） exec/eval exec語句用來執行儲存在字符串或文件中的Python語句；eval語句用來計算存儲在字符串中的有效Python表達式。 cmd = "print 'hello world'" exec cmd #hello world expression = "10 * 2 + 5" print eval(expression) #25 3）assert assert語句用來斷言某個條件是真的，而且在它非真的時候引起一個錯誤--AssertionError。 flag = True assert flag == True try: assert flag == False except AssertionError, err: print "failed" else: print "pass" 4） repr函數 repr函數用來取得對象的規範字符串表示。反引號（也稱轉換符）能夠完成相同的功能。 注意，在大多數時候有eval(repr(object)) == object。 能夠經過定義類的__repr__方法來控制對象在被repr函數調用的時候返回的內容。 arr = [1, 2, 3] print `arr` #[1, 2, 3] print repr(arr) #[1, 2, 3]