一、列表（list）
一組有序項目的集合。可變的數據類型【可進行增刪改查】
列表是以方括號“[]”包圍的數據集合，不同成員以“,”分隔。
列表中可以包含任何數據類型，也可包含另一個列表
列表可通過序號訪問其中成員
Python列表腳本操作符
列表對 + 和 * 的操作符與字符串相似。+ 號用於組合列表，* 號用於重復列表。
Python列表函數&方法
n=[1,2,3,4,5,6] m=[7,8,9,10] n.extend(m) print n
out：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 7, 8, 9, 10]
n.index(5)
out:4
#列表操作補充--切片操作 example = [0,1,2,3,4,5,6,7,8,9] #打印某一區間 左閉右開 print(example[4:8]) #想包含最后一個 print(example[4:]) #包含首個 print(example[:8]) #所有的 print(example[:]) #第三個參數為步長 print(example[1:8:2]) #倒序輸出 print(example[::-1]) #列表合並 a = [1,2,3] b = [4,5,6] print(a+b)
#替換
ex = [1,2,3,4,5,6]
ex[4:]=[9,8,7]
print(ex)#將56換為987
>>> list4=[123,["das","aaa"],234] >>> list4 >>> "aaa" in list4 #in只能判斷一個層次的元素 False >>> "aaa" in list4[1] #選中列表中的列表進行判斷 True >>> list4[1][1] 'aaa'
二、元組（tuple）
不可變序列
元組是以圓括號“()”包圍的數據集合，不同成員以“,”分隔
與列表不同：元組中數據一旦確立就不能改變
通過下標進行訪問
聲明：
L=(1,2,3)
含0個元素的元組: L = ()
含1個元素的元組:L=(1,) 注意有逗號
訪問元組：
o =('a','b','c',('d1','d2')) print o[0] print o[3][0]
a d1
age=22 name='sandra' print'%s is %d years old'%(name,age)
sandra is 22 years old
修改元組：
元組中的元素值是不允許修改的，但我們可以對元組進行連接組合，如下實例:
tup1 = (12, 34.56); tup2 = ('abc', 'xyz'); # 以下修改元組元素操作是非法的。 # tup1[0] = 100; # 創建一個新的元組 tup3 = tup1 + tup2; print tup3;
刪除元組：
del tup1
添加元組：
#通過切片方法添加
a=(1,2,3,4,5,6) a=a[:2]+(10,)+a[2:] a
元組運算符
與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味着他們可以組合和復制，運算后會生成一個新的元組。
無關閉分隔符
任意無符號的對象，以逗號隔開，默認為元組，如下實例：
print 'abc', -4.24e93, 18+6.6j, 'xyz'; x, y = 1, 2; print "Value of x , y : ", x,y;
元組內置函數
三、字典（dictionary）
字典是另一種可變容器模型，且可存儲任意類型對象。
字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式如下所示：
鍵必須是唯一的，但值則不必。
值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
訪問字典里的值
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Name']
dict['Age']
修改字典
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8;
dict['School'] = "DPS School"
刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操作。
顯示刪除一個字典用del命令，如下實例：
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dict['Name']; # 刪除鍵是'Name'的條目
dict.clear(); # 清空詞典所有條目
del dict ; # 刪除詞典
字典鍵的特性
字典值可以沒有限制地取任何python對象，既可以是標准的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，后一個值會被記住，如下實例：
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};
print "dict['Name']: ", dict['Name'];
dict['Name']: Manni
2）鍵必須不可變，所以可以用數字，字符串或元組充當，所以用列表就不行，如下實例：
dict = {['Name']: 'Zara', 'Age': 7};
print "dict['Name']: ", dict['Name'];
字典內置函數&方法
四、array（數組）--numpy
python中的list是python的內置數據類型，list中的數據類不必相同的，而array的中的類型必須全部相同。在list中的數據類型保存的是數據的存放的地址，簡單的說就是指針，並非數據，這樣保存一個list就太麻煩了，例如list1=[1,2,3,'a']需要4個指針和四個數據，增加了存儲和消耗cpu。numpy中封裝的array有很強大的功能，里面存放的都是相同的數據類型
b=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print b
b.mean()
[[ 1 2 3] [ 4 5 6] [ 7 8 9] [10 11 12]]
6.5
b.reshape(2,6) #這里的數字相乘等於12，可以任意reshape
array([[ 1, 2, 3, 4, 5, 6],
[ 7, 8, 9, 10, 11, 12]])
numpy軸
b.mean(axis=0) #列
array([ 5.5,6.5,7.5])
b.mean(axis=1) #行
array([2.,5.,8.,11.])
五、dataframe-pandas
定義：
DataFrame提供的是一個類似表的結構，由多個Series組成，而Series在DataFrame中叫columns
import pandas as pd from pandas import Series, DataFrame import numpy as np data = DataFrame(np.arange(15).reshape(3,5),index=['one','two','three'],columns=['a','b','c','d','e']) print data
a b c d e one 0 1 2 3 4 two 5 6 7 8 9 three 10 11 12 13 14
二維array：
import pandas as pd import numpy as np s1=np.array([1,2,3,4]) s2=np.array([5,6,7,8]) df=pd.DataFrame([s1,s2]) print df
Series列表（效果與二維array相同）
import pandas as pd import numpy as np s1=pd.Series(np.array([1,2,3,4])) s2=pd.Series(np.array([5,6,7,8])) df=pd.DataFrame([s1,s2]) print df
value為Series的字典結構
import pandas as pd import numpy as np s1=pd.Series(np.array([1,2,3,4])) s2=pd.Series(np.array([5,6,7,8])) df=pd.DataFrame({"a":s1,"b":s2}); print df
使用.ix[]
df.ix[條件，then操作區域]
df.ix[df.a>1,'b']=9 print df
a b 0 1 5 1 2 9 2 3 9 3 4 9
使用numpy.where，添加新列‘then’
np.where(條件，then，else)
df['new']=np.where(df.a<2,'yes','no') print df
根據條件選擇取DataFrame
直接取值df.[]
df=pd.DataFrame({"A":[1,2,3,4],"B":[5,6,7,8],"C":[1,1,1,1]})
df=df[df.A>=2]
print df
使用.loc[]
df=pd.DataFrame({"A":[1,2,3,4],"B":[5,6,7,8],"C":[1,1,1,1]})
df=df.loc[df.A>2]
print df
Grouping
groupby 形成group
df = pd.DataFrame({'animal': 'cat dog cat fish dog cat cat'.split(),
'size': list('SSMMMLL'),
'weight': [8, 10, 11, 1, 20, 12, 12],
'adult' : [False] * 5 + [True] * 2});
#列出動物中weight最大的對應size
group=df.groupby("animal").apply(lambda subf: subf['size'][subf['weight'].idxmax()])
print group
使用get_group 取出其中一分組
df = pd.DataFrame({'animal': 'cat dog cat fish dog cat cat'.split(),
'size': list('SSMMMLL'),
'weight': [8, 10, 11, 1, 20, 12, 12],
'adult' : [False] * 5 + [True] * 2});
group=df.groupby("animal")
cat=group.get_group("cat")
print cat
pandas series vs numpy array
1.pandas series可以通過describe()函數打出均值等
data.describe()
集合中包含一系列的元素，在Python中這些元素不需要是相同的類型，且這些元素在集合中是沒有存儲順序的。
集合的賦值
集合的表示方法是花括號，這與字典是一樣的，可以通過括號或構造函數來初始化一個集合，如果傳入的參數有重復，會自動忽略：
>>> {1,2,"hi",2.23}
{2.23, 2, 'hi', 1}
>>> set("hello")
{'l', 'h', 'e', 'o'}
注：由於集合和字典都用{}表示，所以初始化空的集合只能通過set()操作，{}只是表示一個空的字典
集合的增加
集合元素的增加支持兩種類型，單個元素的增加用add方法，對序列的增加用update方法。add的作用類似列表中的append，而update類似extend方法。update方法可以支持同時傳入多個參數：
>>> a={1,2}
>>> a.update([3,4],[1,2,7])
>>> a
{1, 2, 3, 4, 7}
>>> a.update("hello")
>>> a
{1, 2, 3, 4, 7, 'h', 'e', 'l', 'o'}
>>> a.add("hello")
>>> a
{1, 2, 3, 4, 'hello', 7, 'h', 'e', 'l', 'o'}
集合的刪除
集合刪除單個元素有兩種方法，兩者的區別是在元素不在原集合中時是否會拋出異常，set.discard(x)不會，set.remove(x)會拋出KeyError錯誤：
>>> a={1,2,3,4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.remove(1)
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 1
集合也支持pop()方法，不過由於集合是無序的，pop返回的結果不能確定，且當集合為空時調用pop會拋出KeyError錯誤，可以調用clear方法來清空集合：
>>> a={3,"a",2.1,1}
>>> a.pop()
1
>>> a.pop()
3
>>> a.clear()
>>> a
set()
>>> a.pop()
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'pop from an empty set'
集合操作
- 並集：set.union(s),也可以用
a|b計算 - 交集：set.intersection(s)，也可以用
a&b計算 - 差集：set.difference(s)，也可以用
a-b計算
需要注意的是Python提供了一個求對稱差集的方法set.symmetric_difference(s)，相當於兩個集合互求差集后再求並集，其實就是返回兩個集合中只出現一次的元素，也可以用a^b計算。
>>> a={1,2,3,4}
>>> b={3,4,5,6}
>>> a.symmetric_difference(b)
{1, 2, 5, 6}
1
2
3
4
set.update(s)操作相當於將兩個集合求並集並賦值給原集合，其他幾種集合操作也提供各自的update版本來改變原集合的值，形式如intersection_update(),也可以支持多參數形式。
包含關系
兩個集合之間一般有三種關系，相交、包含、不相交。在Python中分別用下面的方法判斷：
- set.isdisjoint(s)：判斷兩個集合是不是不相交
- set.issuperset(s)：判斷集合是不是包含其他集合，等同於a>=b
- set.issubset(s)：判斷集合是不是被其他集合包含，等同於a<=b
如果要真包含關系，就用符號操作>和<。
不變集合
Python提供了不能改變元素的集合的實現版本，即不能增加或刪除元素，類型名叫frozenset，使用方法如下：
>>> a = frozenset("hello") >>> a frozenset({'l', 'h', 'e', 'o'}) 1 2 3
需要注意的是frozenset仍然可以進行集合操作，只是不能用帶有update的方法。如果要一個有frozenset中的所有元素的普通集合，只需把它當作參數傳入集合的構造函數中即可：
集合的一大特性：沒有重復值
set1={1,2,3,2,2,3,4}
print type(set1)
print set1
set1.add(6)
print set1
<type 'set'> set([1, 2, 3, 4]) set([1, 2, 3, 4, 6])