pandas的基本資料結構

Series結構

類似於一維陣列的物件，它由一組Numpy中各種資料型別的資料和一組標籤組成。索引在左，值在右：

In [1]: import pandas as pd

In [2]: obj = pd.Series([1,2,3,4])

In [3]: obj
Out[3]: 
0    1
1    2
2    3
3    4
dtype: int64

注意：沒有指定索引會自動建立0到N-1(N是資料長度)作為索引

Series的values和index屬性可以獲取陣列表示形式和索引物件：

In [4]: obj.values
Out
 
[4]: array([1, 2, 3, 4], dtype=int64)

In [5]: obj.index
Out[5]: RangeIndex(start=0, stop=4, step=1)

索引可以才建立時自己指定，然後通過一個或多個索引可取得對應值：

In [6]: obj = pd.Series([1,2,3,4],index=['a','b','c','d'])

In [7]: obj
Out[7]: 
a    1
b    2
c    3
d    4
dtype: int64

In [8]: obj.index
Out[8]: Index(['a', 'b'
 
, 'c', 'd'], dtype='object')

In [9]: obj['a']
Out[9]: 1

In [10]: obj[['c','d']]
Out[10]: 
c    3
d    4
dtype: int64

可以使用一下基本運算和numpy相關函式的陣列運算，結果保留索引關係：

In [11]: import numpy as np

In [12]: obj*2
Out[12]: 
a    2
b    4
c    6
d    8
dtype: int64

In [13]: np.exp(obj)
Out[13]: 
a     2.718282
b     7.389056
 

c    20.085537
d    54.598150
dtype: float64

In [14]: obj[obj>1]
Out[14]: 
b    2
c    3
d    4
dtype: int64

Series可以看做字典，許多字典相關的函式都可用，也可直接通過字典建立Series：

In [16]: 'a' in obj
Out[16]: True

In [17]: 'e' in obj
Out[17]: False

In [18]: d = {'a':1,'b':2,'c':3}

In [19]: d
Out[19]: {'a': 1, 'b': 2, 'c': 3}

In [20]: obj = pd.Series(d)

In [21]: obj
Out[21]: 
a    1
b    2
c    3
dtype: int64

建立Series還可將鍵通過列表傳入，會自動根據傳入的字典查詢有的值來生成Series，若字典中的鍵沒有查到列表中的資料，則對應生成Series的鍵的值為NaN：

In [22]: alp = ['c','b','a','d']

In [23]: obj = pd.Series(d,index=alp)  #d={'a': 1, 'b': 2, 'c': 3},即前一個程式碼片段中的d

In [24]: obj
Out[24]: 
c    3.0
b    2.0
a    1.0
d    NaN
dtype: float64

panda的的isnull和notnull函式可以用來查詢Series的值是否為NaN：

In [26]: pd.isnull(obj)
Out[26]: 
c    False
b    False
a    False
d     True
dtype: bool

In [27]: pd.notnull(obj)
Out[27]: 
c     True
b     True
a     True
d    False
dtype: bool

Series物件本身和其索引都有name屬性，Series的索引可通過賦值修改：

In [28]: obj.name='test'

In [29]: obj.index.name='num'

In [30]: obj
Out[30]: 
num
c    3.0
b    2.0
a    1.0
d    NaN
Name: test, dtype: float64

In [31]: obj.index=['e','f','g','h']

In [32]: obj
Out[32]: 
e    3.0
f    2.0
g    1.0
h    NaN
Name: test, dtype: float64

DataFrame結構

DataFrame是表格形式的資料結構，它含有一個有序的列，每一列可以是不同的值型別。可以看做Series組成的字典公用同一個索引。即有行索引，又有列索引。構建DataFrame的方法較多，最常用的是直接傳入一個由等長列表或Numpy陣列組成的字典：

In [1]: data = {'name':['xd','xc','ch'],
   ...:         'birth':[1989,1988,1991],
   ...:         'amateur':['game','study','work']}
In [3]: frame = pd.DataFrame(data)

In [4]: frame
Out[4]: 
  amateur  birth name
0    game   1989   xd
1   study   1988   xc
2    work   1991   ch

又結果看出DataFrame會自動加上索引，且全部有序排列，當然可以自己指定排列順序：

In [6]: pd.DataFrame(data,columns=['birth','name','amateur'])
Out[6]: 
   birth name amateur
0   1989   xd    game
1   1988   xc   study
2   1991   ch    work

可以自己定義索引，如果順序列表中找不到，則會產生NaN：

In [7]: pd.DataFrame(data,columns=['birth','name','amateur','gender'],index=['a','b','c'])
Out[7]: 
   birth name amateur gender
a   1989   xd    game    NaN
b   1988   xc   study    NaN
c   1991   ch    work    NaN

通過字典標記，或屬性方式，可得到對應列的Series資料：

In [8]: frame['name']
Out[8]: 
0    xd
1    xc
2    ch
Name: name, dtype: object

In [9]: frame.birth
Out[9]: 
0    1989
1    1988
2    1991
Name: birth, dtype: int64

In [10]: type(frame.birth)
Out[10]: pandas.core.series.Series

通過ix方法可以索引一行的欄位：

In [13]: frame.ix[1]
Out[13]: 
amateur    study
birth       1988
name          xc
Name: 1, dtype: object

可通過賦值的方式加上新的列，若通過Series結構賦值，則可精確匹配DataFrame的索引：

In [14]: frame
Out[14]: 
  amateur  birth name
0    game   1989   xd
1   study   1988   xc
2    work   1991   ch

In [15]: frame['age'] = 24

In [16]: frame
Out[16]: 
  amateur  birth name  age
0    game   1989   xd   24
1   study   1988   xc   24
2    work   1991   ch   24

In [17]: import numpy as np
In [22]: frame['age'] = np.arange(25.,28.)

In [23]: frame
Out[23]: 
  amateur  birth name   age
0    game   1989   xd  25.0
1   study   1988   xc  26.0
2    work   1991   ch  27.0

In [24]: gen = pd.Series(['M','F'],index=[2,1])

In [25]: frame['gender']=gen

In [26]: frame
Out[26]: 
  amateur  birth name   age gender
0    game   1989   xd  25.0    NaN
1   study   1988   xc  26.0      F
2    work   1991   ch  27.0      M

del關鍵字可以刪除列：

In [27]: del frame['age']

In [28]: frame
Out[28]: 
  amateur  birth name gender
0    game   1989   xd    NaN
1   study   1988   xc      F
2    work   1991   ch      M

注意：通過索引得到的列是對應資料的檢視，因此對返回的Series資料的修改會反應到DataFrame資料上，通過Series的copy方法可以顯式的複製對應資料。

另一種構建DataFrame的方式是巢狀字典，外層字典鍵作為列索引，記憶體字典鍵作為行索引，結果也可轉置：

In [30]: dic = {'MM':{'outfile':'beautiful',2017:6.6},'GG':{'outfile':'handsome',2017:8.8}}
In [32]: frame = pd.DataFrame(dic)

In [33]: frame
Out[33]: 
               GG         MM
outfile  handsome  beautiful
2017          8.8        6.6

In [34]: frame.T
Out[34]: 
      outfile 2017
GG   handsome  8.8
MM  beautiful  6.6

下表列出DataFrame可接受的資料：

型別	說明
二維ndarry	資料矩陣，還可以傳入行標和列標
由陣列、列表、元組組成的字典	每個序列會變成DataFrame的一列。所有序列長度必須相同
Numpy的結構化/記錄陣列	類似於“由陣列組成的字典”
由Series組成的字典	每個Series會成為一列。如果沒有顯示指定索引，則各Series的索引會被合併成結果的行索引
由字典組成的字典	各內層字典會成為一列。鍵會被合併成結果的行索引，跟“由Series組成的字典”情況一樣
字典或Series的列表	各項將成為DataFrame的一行。字典鍵或Series索引的並集將會成為DataFrame的列標
由列表或元組組成的列表	類似於“二維ndarry”
另一個DataFrame	將會使用該索引，除非自己顯示指定
Numpy的MaskedArray	類似於“二維ndarry”，只是掩碼值在結果DataFrame會變為NaN缺失值

以上生成時都可自己設定DataFrame的index和columns的name屬性，這時會顯示出來：

In [39]: frame.index.name = 'character'

In [40]: frame.columns.name = 'people'

In [41]: frame
Out[41]: 
people           GG         MM
character                     
outfile    handsome  beautiful
2017            8.8        6.6

跟Series資料類似，通過values屬性可以返回二維ndarry形式的資料：

In [42]: frame.values
Out[42]: 
array([['handsome', 'beautiful'],
       [8.8, 6.6]], dtype=object)

Index索引物件

pandas的索引物件負責管理軸標籤和其他元資料，構建Series或DataFrame時，所用的任何陣列或其他序列的標籤都會轉換成一個Index：

In [44]: obj = pd.Series(range(3),index=['a','b','c'])

In [45]: index = obj.index

In [46]: index
Out[46]: Index(['a', 'b', 'c'], dtype='object')

In [47]: index[1:]
Out[47]: Index(['b', 'c'], dtype='object')

注意：index是不可修改的。這樣才能使得Index物件在多個數據結構之間安全共享。

In [50]: index = pd.Index(np.arange(3))
In [53]: obj = pd.Series([1.1,2.2,3.3],index = index)

In [54]: index
Out[54]: Int64Index([0, 1, 2], dtype='int64')

In [55]: index is obj.index
Out[55]: True

下面列出pandas內建的Index類：

類	說明
Index	最泛化的Index物件，將軸標籤表示為一個由Python物件組成的Numpy陣列
Int64Index	針對整數的特殊Index
MultiIndex	“層次化”索引物件，表示單個軸上的多層索引。可以看做由元組組成的陣列
DatetimeIndex	儲存納秒級時間戳(用Numpy的datetime64型別表示)
PeriodIndex	針對Period資料(時間間隔)的特殊Index

索引還有一些方法和屬性，用於設定邏輯並回答有關該索引所包含的資料的常見問題，下表列出這些函式：

方法	說明
append	連線另一個Index物件，產生一個新的Index
difference	計算差集，得到一個Index
intersection	計算交集
union	計算並集
isin	計算一個指示各值是否都包含在引數集中的布林型陣列
delete	刪除索引i處的元素，並得到新的Index
drop	刪除傳入值，並得到新的Index
insert	將索引插入到i處，得到新的Index
is_monotonic	當各元素均大於等於前一個元素時，返回True
is_unique	當Index沒有重複值是，返回True
unique	計算Index中唯一值的陣列

例如：

In [54]: index
Out[54]: Int64Index([0, 1, 2], dtype='int64')

In [56]: index2 = pd.Index(range(6))
In [57]: index2
Out[57]: RangeIndex(start=0, stop=6, step=1)

In [58]: index2.difference(index)
Out[58]: Int64Index([3, 4, 5], dtype='int64')

In [59]: index2.drop(4)
Out[59]: Int64Index([0, 1, 2, 3, 5], dtype='int64')

In [61]: index2.insert(2,2)
Out[61]: Int64Index([0, 1, 2, 2, 3, 4, 5], dtype='int64')

In [63]: index2.is_monotonic
Out[63]: True

In [64]: index2.is_unique
Out[64]: True

In [66]: index2.unique()
Out[66]: Int64Index([0, 1, 2, 3, 4, 5], dtype='int64')

基本功能

下面介紹操作Series和DataFrame資料的基本手段

重新索引

pandas物件的reindex方法用來建立一個適應新索引的新物件。比如呼叫Series的reindex方法可以根據新索引重新排序。如果某個索引不存在則引入NaN，當然可以通過引數fill_value改變不存在該索引時的填充值：

In [67]: obj
Out[67]: 
0    1.1
1    2.2
2    3.3
dtype: float64

In [68]: obj.reindex([1,2,0])
Out[68]: 
1    2.2
2    3.3
0    1.1
dtype: float64

In [69]: obj  #reindex函式不改變本身，只是生成一個新的
Out[69]: 
0    1.1
1    2.2
2    3.3
dtype: float64

In [70]: obj.reindex([2,1,0,5],fill_value=10)
Out[70]: 
2     3.3
1     2.2
0     1.1
5    10.0
dtype: float64

重新索引時還可通過method選項進行向前或向後差值，可設定結果表格：

引數	說明
ffill或pad	前向填充(或搬運)值
bfill或backfill	後向填充(或搬運)值

例如：

In [72]: obj = pd.Series(['a','b','c'],index=[2,5,8])

In [73]: obj.reindex(range(8),method='pad')
Out[73]: 
0    NaN
1    NaN
2      a
3      a
4      a
5      b
6      b
7      b
dtype: object

In [74]: obj
Out[74]: 
2    a
5    b
8    c
dtype: object

對應DataFrame的reindex函式可修改行、列索引，或同時都修改。僅僅傳入序列會重新索引行：

In [76]: frame = pd.DataFrame(np.arange(9).reshape((3,3)),index=['a','b','c'],columns=['o','p','q'])

In [77]: frame
Out[77]: 
   o  p  q
a  0  1  2
b  3  4  5
c  6  7  8

In [78]: frame.reindex(['b','c','d','e'])
Out[78]: 
     o    p    q
b  3.0  4.0  5.0
c  6.0  7.0  8.0
d  NaN  NaN  NaN
e  NaN  NaN  NaN

顯示傳入index代表重新索引行，columns代表重新索引列，當然可以混合使用這兩個引數：

In [5]: frame.reindex(index=['c','b','a'],columns=['q','p','o','j'])
Out[5]: 
     q    p    o   j
c  8.0  7.0  6.0 NaN
b  5.0  4.0  3.0 NaN
a  2.0  1.0  0.0 NaN

下面列出reindex函式各個引數的說明表格：

引數	說明
index	用作索引的新序列，可以是Index例項，也可是其他序列的Python資料結構。
method	差值的方式，具體見上一個表格
fill_value	在重新索引時，需要引入缺失值時使用的代替值
limit	前向或後向填充時最大填充量
level	在MultiIndex的指定級別上匹配簡單索引，否則選取其子集
copy	預設為True，無論如何都複製；如果為Flase，則新舊相等則不復制

丟棄軸上值

使用drop函式可返回一個指定軸上刪除後的新資料物件，預設是0軸，如果要刪除其他軸上的資料，需要顯示指定axis數：

In [10]: frame
Out[10]: 
   o  p  q
a  0  1  2
b  3  4  5
c  6  7  8

In [11]: frame.drop(['b','c'])
Out[11]: 
   o  p  q
a  0  1  2

In [12]: frame.drop('a')
Out[12]: 
   o  p  q
b  3  4  5
c  6  7  8

In [13]: frame.drop('o',axis=1)
Out[13]: 
   p  q
a  1  2
b  4  5
c  7  8

索引資料

DataFrame索引選項表格：

型別	說明
obj[val]	選取DataFrame的單個列或一組列。在一些特殊情況下會比較便利：布林型陣列(過濾行)、切片(切片行)、布林型DataFrame(根據條件設定值)
obj.ix/loc[val]	選取DataFrame的單個行或一組行(loc傳入的是標籤)
obj.ix/loc[:,val]	選取單個列或列子集(loc傳入的是標籤)
obj.ix/loc[val1,val2]	同時選取行和列(loc傳入的是標籤)
reindex方法	將一個或多個軸匹配到新索引
xs方法	根據標籤選取單行或單列，並返回一個Series資料
icol、irow方法	根據整數位置選取單列或單行，並返回一個Series資料
get_value、set_value方法	根據行標籤或列標籤選取單個值

例如：

In [31]: frame
Out[31]: 
   o  p  q
a  0  1  2
b  3  4  5
c  6  7  8

In [32]: frame['o']
Out[32]: 
a    0
b    3
c    6
Name: o, dtype: int32

In [33]: frame[frame['o']>0]
Out[33]: 
   o  p  q
b  3  4  5
c  6  7  8

In [34]: frame[:2]
Out[34]: 
   o  p  q
a  0  1  2
b  3  4  5

In [47]: frame.ix[0]
Out[47]: 
o    0
p    1
q    2
Name: a, dtype: int32

In [48]: frame.ix[:,0]
Out[48]: 
a    0
b    3
c    6
Name: o, dtype: int32

資料結構的簡單計算

DataFrame資料進行相加時，不重疊的地方產生NaN值，可以通過其本身的add方法傳入相加的值，和fill_value引數：

In [66]: frame1 = pd.DataFrame(np.arange(6.).reshape((2,3)),columns=['a','b','c'])
In [69]: frame2 = pd.DataFrame(np.arange(12.).reshape((3,4)),columns=list('abcd'))

In [70]: frame1
Out[70]: 
     a    b    c
0  0.0  1.0  2.0
1  3.0  4.0  5.0

In [71]: frame2
Out[71]: 
     a    b     c     d
0  0.0  1.0   2.0   3.0
1  4.0  5.0   6.0   7.0
2  8.0  9.0  10.0  11.0

In [72]: frame1+frame2
Out[72]: 
     a    b     c   d
0  0.0  2.0   4.0 NaN
1  7.0  9.0  11.0 NaN
2  NaN  NaN   NaN NaN

In [73]: frame1.add(frame2,fill_value=0.)
Out[73]: 
     a    b     c     d
0  0.0  2.0   4.0   3.0
1  7.0  9.0  11.0   7.0
2  8.0  9.0  10.0  11.0

In [75]: frame2-frame1.ix[0]
Out[75]: 
     a    b    c   d
0  0.0  0.0  0.0 NaN
1  4.0  4.0  4.0 NaN
2  8.0  8.0  8.0 NaN

函式的應用

Numpy的ufuncs(元素級陣列方法)也可用來操作pandas物件：

In [79]: np.sqrt(frame)
Out[79]: 
          o         p         q
a  0.000000  1.000000  1.414214
b  1.732051  2.000000  2.236068
c  2.449490  2.645751  2.828427

還可以直接將函式應用到DataFrame的apply方法上：

In [81]: frame.apply(lambda x:x.max()-x.min(),axis=1)
Out[81]: 
a    2
b    2
c    2
dtype: int64

也可使用應用到每個元素的方法applymap：

In [83]: frame.applymap(lambda x:'%.2f'%x)
Out[83]: 
      o     p     q
a  0.00  1.00  2.00
b  3.00  4.00  5.00
c  6.00  7.00  8.00

排序

對索引排序也是對資料的常用操作，使用的函式是sort_index，該函式可以指定axis引數表示行索引排序或列索引排序，指定ascending指定升序或降序排序。對值排序可使用sort_values函式，其中指定by代表對一列或多列的值進行排序：

In [85]: frame.sort_index(axis=1,ascending=False)
Out[85]: 
   q  p  o
a  2  1  0
b  5  4  3
c  8  7  6

In [88]: frame.sort_values(by=['p','o'],ascending=False)
Out[88]: 
   o  p  q
c  6  7  8
b  3  4  5
a  0  1  2

排名

排名使用rank方法，其引數method對應的選項意思為：

method	說明
‘average’	預設：在相等分組中，為各個值分配平均排名
‘min’	使用整個分組的最小排名
‘max’	使用整個分組的最大排名
‘first’	按照原始資料中出現順序分配排名

例如：

obj = pd.Series([-3,2,7,3,3])

obj.rank()
Out[13]: 
0    1.0
1    2.0
2    5.0
3    3.5
4    3.5
dtype: float64

obj = pd.Series([-3,2,7,3,3,3])

obj.rank()
Out[15]: 
0    1.0
1    2.0
2    6.0
3    4.0
4    4.0
5    4.0
dtype: float64

顯然，如果出現被排名的出現相同的結果，那麼平均方法就按照佔有的排名數字的平均數給出排名的序列值。

計算描述統計的方法

下面列出描述和彙總統計的常用方法：

方法	說明
count	非NA值的數量
describe	針對Series或各DataFrame列計算彙總統計
count	非NA值的數量
describe	針對Series和DataFrame列計算彙總統計
min、max	計算最小值和最大值
argmin、argmax	計算能夠獲取到最小值、最大值的索引位置(整數)
idxmin、idxmax	計算能夠獲取到最小值、最大值的索引值
quantile	計算樣本的分位數(0到1)
sum	值的總和
mean	值的平均數
median	值的算術中位數(50%分位數)
mad	根據平均值計算平均絕對離差
var	樣本值的方差
std	樣本值的標準差
skew	樣本值的偏度(三階矩)
kurt	樣本值的峰度(四階矩)
cumsum	樣本值的累計和
cummin、cummax	樣本值的累計最大值和累計最小值
cumprod	樣本值的累計積
diff	計算一階差分(對時間序列很有用)
pct_change	計算百分數變化

方法的常用選項表格：
|選項|說明|
|axis|DataFrame的行用0，列用1|
|skipna|排除缺失值，預設值為True|
|level|如果軸是層次化索引的(即MultiIndex)，則根據level分組約簡|
例如：

In [23]: frame = pd.DataFrame([[3.4,np.nan],[4.5,5.6],[np.nan,np.nan],[1.1,4.4]],index=['a','b','c','d'],columns=['one','two'])

In [24]: frame
Out[24]: 
   one  two
a  3.4  NaN
b  4.5  5.6
c  NaN  NaN
d  1.1  4.4

In [25]: frame.sum()
Out[25]: 
one     9.0
two    10.0
dtype: float64

In [26]: frame.sum(axis=1)
Out[26]: 
a     3.4
b    10.1
c     0.0
d     5.5
dtype: float64

In [27]: frame.mean()
Out[27]: 
one    3.0
two    5.0
dtype: float64

In [29]: frame.cumsum()
Out[29]: 
   one   two
a  3.4   NaN
b  7.9   5.6
c  NaN   NaN
d  9.0  10.0

一些其他常用方法

方法名	方法作用
corr	計算相關係數
cov	計算協方差
unique	計算Series中唯一值的陣列，按發現的順序返回
value_count	返回一個Sereies，其索引為唯一值，其值為各個值出現的頻率，按計數值降序排列
isin	計算一個表示“Series各值是否包含於傳入的值序列中”的布林型陣列

回憶：

協方差公式：

Cov(X,Y)=E[(X−m1)(Y−m2)

相關推薦

python學習(九)----pandas模組相關函式

pandas的基本資料結構 Series結構 類似於一維陣列的物件，它由一組Numpy中各種資料型別的資料和一組標籤組成。索引在左，值在右： In [1]: import pandas as pd In [2]: obj = pd.Series(

python學習筆記15 模組numpy函式

Time：20181019 NumPy是Python語言的一個擴充程式庫。支援高階大量的維度陣列與矩陣運算，此外也針對陣列運算提供大量的數學函式庫。 1、np.newaxis： np.newaxis:放在第幾個位置，就會在shape裡面看到相應的位置增加了一個維數 &g

Python學習(九)--[進階]函數

相同 pen 調用 UNC 返回函數 列表 日誌 ref str 閉包 Python的函數時可以嵌套的，可以將一個函數放在另外一個裏面。 def multiplier(factor): def multiplyByFactor(numb

python學習day15 day16 內建函式、匿名函式

https://www.processon.com/view/link/5bdc4fe3e4b09ed8b0c75e81 例子： print(locals()) #返回本地作用域中的所有名字 print(globals()) #返回全域性作用域中的所有名字 global 變數 nonlocal

少說話多寫程式碼之Python學習021——匯入模組

從其他模組匯入函式時，通常我們使用 import 模組， 或者 from 模組 import 函式 如果匯入指定的幾個函式，可以這樣 from 模組 import 函式1,函式2，函式3 或者 from 模組 import * 最後一種表示從某模組中匯入所有函式。 對於匯入的模組和函式，我們

Python學習-第2課（函式，函式文件）

一、函式 1.定義 程式碼的一種組織形式 一個函式一般完成一項特定的功能 函式使用 函式需要先定義 使用函式，俗稱呼叫 2.函式的引數和返回值 引數： 負責給函式傳遞一些必要的資料或者資訊 形參（形式引數）： 在函式定義的時

python學習之六(內建函式的使用)

# 斷是否全部為真，布林運算 print(all([1,2,'1'])) # 有一個為真返回真 print(any([0,1])) # 把十進位制轉換為二進位制 print(bin(3)) # 判斷布林值0,None的布林值為false,其他都是true print(bool(None)) # 把字

python學習筆記：取整函式

三種取整方式： 一、向下取整：即捨去小數點後所有資料。int (n)，例如： int(3.67) #figure out 3 二、四捨五入：round(n)，例如： round(4.56) #figure out 5 round(-4.56) #figure o

python 學習彙總27：itertools函式詳解（ tcy）

itertools函式 2018/11/14 2.1.建立新iter： count(start=0, step=1)#無限迴圈數;按Ctrl + C退出 # 返回均勻間隔值無限流；通常用作map()生成連續資料點的引數。此外，用於zip()新增序列號 g = itertools.count

python 學習彙總26：itertools函式彙總簡表（ tcy）

itertools 2018 / 9 / 13    說明  用途： 操作迭代物件;為高效迴圈建立迭代器的函式 模組標準化一套核心快速高效記憶體工具，一起構成一個“迭代器代數” 很好處理operator模組中高速功能。 # 將乘法運算子對映到2向量形成高效點

python學習之旅2（函式進階）

目錄 　楔子 　名稱空間和作用域 　函式巢狀及作用域鏈 　函式名的本質 　閉包 　本章小結 楔子 假如有一個函式，實現返回兩個數中的較大值： def my_max(x,y): m = x if x>y else y return mbigger

python 學習彙總59：高階函式與類的關係（初級學習- tcy）

 目錄：  1. class定義 2. 內部類 3.外部定義函式 4.高階函式與類的關係 5.物件記憶體管理 6.類作用域 7.使用輸出引數 8.類屬性 9.類特性 10.描述符 11.檢視類屬性 12.繼承 13.型別檢測測試，檢視父子類 15.元類 16.基類 17.類裝

python基礎內建模組相關

python內建函式：compile() 描述 compile() 函式將一個字串編譯為位元組程式碼。 語法 以下是 compile() 方法的語法: compile(source, filename, mode[, flags[, dont_inherit]]) 引數

Python 學習筆記（四）[函式進階]

異常 異常捕獲 try: myfile = open('1.txt') except Exception: print('開啟檔案錯誤') else: print('開啟檔案') myfile.close() finally: print('開啟檔案結束')

Python學習筆記（三）[函式基礎]

概念 定義 宣告 a = 1 if a == 1: def func(): print('a == 1') else: def func(): print('a != 1') 傳參 # 預設

Python學習(6):pandas

一.Series建立 1.直接建立 s=pd.Series([1,3,6,np.nan,44,1]) 2.可以在建立Series時新增index，並可使用Series.index檢視具體的index。需要注意的一點是，當從陣列建立Series時，若指定index，那麼index長度

python學習之-常用模組

json 和pickle 模組 json和pickle模組下都有4個功能 dumps  <---> loads  （序列化 <--->反序列化） dump <---> load （簡單寫法序列化<---> 簡單寫法反序列化） 用途：序

python學習之-hashlib模組（加密演算法模組）

hash演算法模組內有很多種，如md5、sha1等，只是加密的程度不一樣 hash是一種演算法 該演算法接收傳入的文字內容,經過hash運算得到一串hash值 hash值具備三個特點: 1. 如果傳入的內容相同,得到hash一定相同 2. 不能根據hash值反推出內容（無法反解，但是目前已被破解）

python學習之-re模組（正則表示式模組）

什麼是正則表示式 正則就是用一些具有特殊含義的符號組合到一起（稱為正則表示式）來描述字元或者字串的方法。或者說：正則就是用來描述一類事物的規則。（在Python中）它內嵌在Python中，並通過 re 模組實現。正則表示式模式被編譯成一系列的位元組碼，然後由用 C 編寫的匹配引擎執行。 生活中處處都是正則

python學習之-subprocess模組（子程序模組）

什麼是程序 一個程式執行起來了就是一個程序 但是程式本身不是程序，程式是一對程式碼而已 所以程序就是一個抽象的概念，就是程式執行起來的一個過程 程序和程序之間是相互獨立的，互不影響 如何理解子程序和父程序 抽象的說一個QQ程式是一個父程序，word就是一個子程序，兩個互不干預，當然這只是一個比喻