python資料分析模組有哪些_Python資料分析模組pandas整理
技術標籤：python資料分析模組有哪些
pandas是python的一個數據分析包，是基於Numpy構建的含有更高資料結構和工具的資料分析包。
類似於Numpy的和效能是ndarry; pandas是圍繞著Series和DataFrame兩個核心資料結構展開的，Series和DataFrame分別對應於一維的序列和二維的表結構。
一般pandas的匯入約定俗成的方法如下：
from pandas import Series,DataFrame
import pandas as pd
Series
Series可以看做是一個定長有序的字典，基本任意的一維資料都可以用來構造Series物件。
>>> s = Series([1,2,3.0,'abc'])
>>> s
0 1
1 2
2 3
3 abc
dtype: object
Series的互動式顯示的字串表示形式是索引在左邊，值在右邊。因為沒有指定索引，一個包含整數0到N-1(N是資料的長度)的預設索引被建立。可以分別通過values和index來分別獲取Series的陣列表示和索引物件。如果傳入類字典的鍵值對結構，或者在初始化的時候顯示的指定一個index物件，就會形成index-value對應的series。如下所示：
>>> data={'a':1,'b':3,'c':5,'d':7}
>>> s=pd.Series(data)
>>> s
a 1
b 3
c 5
d 7
dtype: int64
>>> s2=pd.Series([1,3,5,7],index=['a','b','c','d'])
>>> s2
a 1
b 3
c 5
d 7
dtype: int64
>>> s.index
Index([u'a', u'b', u'c', u'd'], dtype='object')
>>> s.values
array([1, 3, 5, 7], dtype=int64)
Series的index和values的元素之間雖然存在對應關係， 但這與字典的對映是不同的，index和values實際仍為獨立的narray陣列，因此Series的效能是OK的。
與正規的Numpy陣列相比，你可以使用索引裡的值來選擇一個單一值或者一個值集。
>>> s[2]
5
>>> s['c']
5
>>> s[['d','a','b']]
d 7
a 1
b 3
dtype: int64
>>> s['b']=9
>>> s
a 1
b 9
c 5
d 7
dtype: int64
另外，Series和index都含有一個name屬性。
>>> s.name='a_series'
>>> s.index.name='index'
>>> s
index
a 1
b 9
c 5
d 7
Name: a_series, dtype: int64
NumPy陣列操作，值與索引之間的對應關係不會改變。
>>> s[s>5]
index
b 9
d 7
Name: a_series, dtype: int64
>>> s
index
a 1
b 9
c 5
d 7
Name: a_series, dtype: int64
>>> s*2
index
a 2
b 18
c 10
d 14
Name: a_series, dtype: int64
>>> np.exp(s)
index
a 2.718282
b 8103.083928
c 148.413159
d 1096.633158
Name: a_series, dtype: float64
另外一種思考方式，Series是一個定長的有序的字典，因為它把索引和值進行對映。
>>> 'a' in s
True
>>> '5' in s
False
>>> 5 in s
False
上文曾提到過，如果有一些資料在python字典中，可以使用傳遞字典來從這些資料中建立一個Series：
>>> sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000}
>>> obj3=pd.Series(sdata)
>>> obj3
Ohio 35000
Oregon 16000
Texas 71000
dtype: int64
同時，在傳遞字典的時候我們還可以額外的指定一組index，並且最終以傳入的index為止，具體如下所示：
>>> states = ['California', 'Ohio', 'Oregon', 'Texas']
>>> obj4 = pd.Series(sdata, index=states)
>>> obj4
California NaN
Ohio 35000
Oregon 16000
Texas 71000
dtype: float64
sdata中的三個值都被放在了合適的位置上，但是因為滅幼發現California的值，就出現了NaN，表示缺失值。在pandas中，可以使用isnull和notnull來檢測資料缺失：
>>> pd.isnull(obj4)
California True
Ohio False
Oregon False
Texas False
dtype: bool
>>> pd.notnull(obj4)
California False
Ohio True
Oregon True
Texas True
dtype: bool
還有一個重要作用是在算術運算中Series會自動對齊不同索引的資料
>>> obj5=pd.Series(obj3,index=['Ohio','Oregon','Texas','Togo'])
>>> obj5
Ohio 35000
Oregon 16000
Texas 71000
Togo NaN
dtype: float64
>>> obj5+obj4
California NaN
Ohio 70000
Oregon 32000
Texas 142000
Togo NaN
dtype: float64
Series的索引也可以通過賦值就地改變：
>>> obj4.index=['a','b','c','d']
>>> obj4
a NaN
b 35000
c 16000
d 71000
dtype: float64
DataFrame
它是一個表格型的資料結構，它由一組有序的列(類似於index)，每一列可以是不同的資料型別。基本上可以將DataFrame看做是共享一個index的Series的集合。
DataFrame有行和列的索引，在底層中資料是作為一個或者多個二維陣列儲存的。
有很多方法來構建DataFrame，最常用的一個是用一個相等長度列表的字典或者NumPy資料，具體如下所示:
>>> data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002],
'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
>>> frame=pd.DataFrame(data)
>>> frame
pop state year
0 1.5 Ohio 2000
1 1.7 Ohio 2001
2 3.6 Ohio 2002
3 2.4 Nevada 2001
4 2.9 Nevada 2002
雖然data看起來是個字典，但是字典的鍵不是充當DataFrame中的index的角色，而是Series中的name屬性，而DataFrame的index仍是[0,1,2,3,4]。
其他的構建方式：
1、字典的字典：
>>> d={'one':{'a':1,'b':2,'c':3},'two':{'a':1,'b':2,'c':3,'d':4}}
>>> df=pd.DataFrame(d)
>>> df
one two
a 1 1
b 2 2
c 3 3
d NaN 4
2、series的字典：
>>> d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
>>> df=pd.DataFrame(d)
>>> df
one two
a 1 1
b 2 2
c 3 3
d NaN 4
3、列表的字典，要求每個列表的長度是一致的否則會報錯：
>>> d={'one':[1,2,3,4],'two':[3,4,5,6]}
>>> df=pd.DataFrame(d)
>>> df
one two
0 1 3
1 2 4
2 3 5
3 4 6
>>> d={'one':[1,2,3,4],'two':[3,4,5]}
>>> df=pd.DataFrame(d)
ValueError: arrays must all be same length
4、字典的列表，其中每個字典代表的是每條記錄(DataFrame中的一行)，字典中的每個值對應的是這條記錄的相關屬性。
>>> d = [{'one' : 1,'two':1},{'one' : 2,'two' : 2},{'one' : 3,'two' : 3},{'two' : 4}]
>>> df=pd.DataFrame(d)
>>> df
one two
0 1 1
1 2 2
2 3 3
3 NaN 4
其實比較完整的DataFrame的構造器引數為DataFrame(data=None,index=None,columns=None),index為索引，columns為name。如果在columns中設定列的順序，DataFrame的列將會精確的按照所傳遞的順序排列。
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
'year': [2000, 2001, 2002, 2001, 2002],
'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
>>> frame = pd.DataFrame(data)
>>> frame
pop state year
0 1.5 Ohio 2000
1 1.7 Ohio 2001
2 3.6 Ohio 2002
3 2.4 Nevada 2001
4 2.9 Nevada 2002
>>> frame=pd.DataFrame(data, columns=['year', 'state', 'pop'])
>>> frame
year state pop
0 2000 Ohio 1.5
1 2001 Ohio 1.7
2 2002 Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9
DataFrame轉換為其他型別
df.to_dict(outtype='dict')
outtype的引數為：‘dict'、'list'、'Series’、‘records'。dict返回的是dict of dict ，list返回的是列表的字典，series返回的是序列的字典，records返回的是字典的列表。
head和tail方法可以顯示DataFrame的前N條和後N條記錄，N為引數，預設值為5。這通常是拿到DataFrame後的第一個命令，可以方便的瞭解資料內容和含義。
元組
如果df的某一列為元組，如果使用每一個元組的元素呢？
df=pd.DataFrame(out.to
In [1]: from pandas import *In [2]: def calculate(x):
...: return x*2, x*3
...:
In [3]: df = DataFrame({'a': [1,2,3], 'b': [2,3,4]})
In [4]: df
Out[4]:
a b
0 1 2
1 2 3
2 3 4
In [5]: df["A1"], df["A2"] = zip(*df["a"].map(calculate))
In [6]: df
Out[6]:
a b A1 A2
0 1 2 2 3
1 2 3 4 6
2 3 4 6 9
list())df.columns=['KS-stat', 'P-value']print df#輸出 KS-stat P-value0 -2.12978778869 0.0436431 3.50655433879 0.0018132 -1.2221274198 0.2335273 -0.977154419818 0.338240當我們使用map函式返回多個值時，真正的返回值是一個元組的Series，如果想使用元組中的每一個元素時可以用上面方法來進行獲取。
合併兩列資料
df['columns3'] = zip(df['columns2'],df['columns1'])
#會生成一個元組
在使用新合成的這一列時，按照元組的使用方法來使用資料。
如果一個函式中需要使用兩列引數，使用方法為：
df[columnsNew ] = df[[columns1,columns2]].apply(func,asix=1)
def func(x):
aa = x[0]
bb = x[1]
asix = 1 表示一行資料進入func，以元組的形式。返回值一試Series。
或者按照如下方式：
In [3]: df = DataFrame({'a': [1,2,3], 'b': [2,3,4]})In [4]: df
Out[4]:
a b
0 1 2
1 2 3
2 3 4
def func(x):
value = x['a']
return value*2
df['doubleA'] = df.apply(func,axis=1)
進一步，如果方程func需要額外的引數時：
def func(x,addional):
value = x['a']
return value*addional
df['newA']=df.apply(lambda x:func(x,5),axis=1)
函式返回兩個變數