python學習(九)----pandas模組相關函式
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就是一個子程序,兩個互不干預,當然這只是一個比喻