Pandas常用資料預處理方法及指令
1.前言
前一段時間，在小夥伴的慫恿下參加了京東的Jdata資料大賽（並以剪刀石頭布的方式決定的組長，草率！
不過非常感謝小夥伴們對我的信任，還有我們一起學習的熱情讓我一下恢復了對學習的xing趣了呢），作為一名小白，抱著學習的心態去的，所謂的萬事開頭難是真的，從來沒接觸過這種比賽或工作的我也是一頭霧水，以前沒上過資料處理和挖掘的課程，不知從何下手，就是在這樣一窮二白的情況下開始了長達兩週的工作。
向曾經參加過類似比賽的師兄取經、請教老師解題思路、查閱相關書籍（幸好我之前有買許多相關書籍）、逛各種論壇、競賽官方qq群，做了很多準備，當然最難的就是動手實踐。很多理論在實戰面前都是蒼白的，比如書裡面經常說視覺化、視覺化，對於資料的視覺化我們可以得到很多的資訊，然而有一些是可以這樣做的，另一些如使用者購買關係網路因為資料量的問題、而且就算抽樣的話，視覺化後我們依然分析不出個所以然來
（可能還是方法沒用對）。
在這兩週內在每天提交次數、每週截至提交日期的壓力下，我快速成長了起來，一開始不知道用什麼軟體、程式碼處理資料，後來查資料、問人確定了幾個可選方案，直接上手幹，第一個方案不行，查查怎麼回事還不行就換，最後決定使用jupyter notebook+pandas+matplot的方案果斷上；(神奇的 )
從pandas資料結構什麼都不知道，到從各種部落格蒐集所需要的程式碼，後來發現遺忘速度真的很快，用完就忘還得重新找對應部落格、資料很麻煩，所以就有了我這篇總結的雛形，經過不斷的完善在經歷了一整個資料處理流程下來，常用的程式碼都已經總結的很完善了，然後就是學習了一些大牛開源的程式碼後，發現：我艹，還能這麼搞！
兩週的工作主要就是兩個部分：資料處理+上模型跑程式碼，然後就不斷的迴圈重複，跑完程式碼提交看看有什麼問題，藉由這次比賽經歷我也得到了許多寶貴的經驗，如很多事情想和做是不一樣的，做了才會有深刻的理解，理解了才會更好的思考。
不過很遺憾的是，因為時間和精力有限，沒能繼續做下去，再往下做基本就是使用者推薦的事了，也看了一些使用者推薦的資料和具體的實現方法，可以實現的，但因為已過兩週，超過了我的預算，而且與我感興趣領域不很相關，而且在此期間有了一些成長，從無到有還是收穫許多，所以選擇退出。
不過好記性不如爛筆頭，已過去一段時間，發現再不總結歸納，又要忘的差不多，所以給自己一個藉口，好好整理一下，以便日後需要的時候用的著，在這裡也是想和大家分享一下。
最後還想和大家分享的是微信文章的下載和學習小技巧，我一般都是直接將網頁下載或者另存為pdf看，foxit reader還是一個很好的pdf閱讀器，我可以在上面設定各種快捷鍵方便我做註釋。
PS:因為時間有限而且總結的內容有點多，格式來不及統計，各位將就看吧！
2.常用資料預處理方法
這個部分總結的是在python中常見的資料預處理方法。
2.1標準化（Standardization or Mean Removal and Variance Scaling)
變換後各維特徵有0均值，單位方差。也叫z-score規範化（零均值規範化）。計算方式是將特徵值減去均值，除以標準差。
sklearn.preprocessing.scale(X)
一般會把train和test集放在一起做標準化，或者在train集上做標準化後，用同樣的標準化去標準化test集，此時可以用scaler
scaler = sklearn.preprocessing.StandardScaler().fit(train)
scaler.transform(train)
scaler.transform(test)
實際應用中，需要做特徵標準化的常見情景：SVM
2.2最小-最大規範化
最小-最大規範化對原始資料進行線性變換，變換到[0,1]區間（也可以是其他固定最小最大值的區間）
min_max_scaler = sklearn.preprocessing.MinMaxScaler()
min_max_scaler.fit_transform(X_train)
2.3規範化（Normalization）
規範化是將不同變化範圍的值對映到相同的固定範圍，常見的是[0,1]，此時也稱為歸一化。
將每個樣本變換成unit norm。
X = [[ 1, -1, 2],[ 2, 0, 0], [ 0, 1, -1]]
sklearn.preprocessing.normalize(X, norm='l2')
得到：
array([[ 0.40, -0.40, 0.81], [ 1, 0, 0], [ 0, 0.70, -0.70]])
可以發現對於每一個樣本都有，0.4^2+0.4^2+0.81^2=1,這就是L2 norm，變換後每個樣本的各維特徵的平方和為1。類似地，L1 norm則是變換後每個樣本的各維特徵的絕對值和為1。還有max norm，則是將每個樣本的各維特徵除以該樣本各維特徵的最大值。
在度量樣本之間相似性時，如果使用的是二次型kernel，需要做Normalization
2.4特徵二值化（Binarization）
給定閾值，將特徵轉換為0/1
binarizer = sklearn.preprocessing.Binarizer(threshold=1.1)
binarizer.transform(X)
2.5標籤二值化（Label binarization）
lb = sklearn.preprocessing.LabelBinarizer()
2.6類別特徵編碼
有時候特徵是類別型的，而一些演算法的輸入必須是數值型，此時需要對其編碼。
enc = preprocessing.OneHotEncoder()
enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])
enc.transform([[0, 1, 3]]).toarray() #array([[ 1., 0., 0., 1., 0., 0., 0., 0., 1.]])
上面這個例子，第一維特徵有兩種值0和1，用兩位去編碼。第二維用三位，第三維用四位。
另一種編碼方式
newdf=pd.get_dummies(df,columns=["gender","title"],dummy_na=True)
詳細的說明可以在後面常用指令中看到
Examples
>>> import pandas as pd
>>> s = pd.Series(list('abca'))
>>> pd.get_dummies(s)
a b c
0 1 0 0
1 0 1 0
2 0 0 1
3 1 0 0
>>> s1 = ['a', 'b', np.nan]
>>> pd.get_dummies(s1)
a b
0 1 0
1 0 1
2 0 0
>>> pd.get_dummies(s1, dummy_na=True)
a b NaN
0 1 0 0
1 0 1 0
2 0 0 1
>>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'],
'C': [1, 2, 3]})
>>> pd.get_dummies(df, prefix=['col1', 'col2'])
C col1_a col1_b col2_a col2_b col2_c
0 1 1 0 0 1 0
1 2 0 1 1 0 0
2 3 1 0 0 0 1
>>> pd.get_dummies(pd.Series(list('abcaa')))
a b c
0 1 0 0
1 0 1 0
2 0 0 1
3 1 0 0
4 1 0 0
2.7標籤編碼（Label encoding）
le = sklearn.preprocessing.LabelEncoder()
le.fit([1, 2, 2, 6])
le.transform([1, 1, 2, 6]) #array([0, 0, 1, 2])
#非數值型轉化為數值型
le.fit(["paris", "paris", "tokyo", "amsterdam"])
le.transform(["tokyo", "tokyo", "paris"]) #array([2, 2, 1])
2.8特徵中含異常值時
sklearn.preprocessing.robust_scale
2.9生成多項式特徵
這個其實涉及到特徵工程了，多項式特徵/交叉特徵。
poly = sklearn.preprocessing.PolynomialFeatures(2)
poly.fit_transform(X)
原始特徵：
轉化後：
3常用指令
#以後呼叫pandas函式都用pd
import pandas as pd
#將matplotlib的圖表直接嵌入到Notebook之中，或者使用指定的介面庫顯示圖表
%matplotlib inline
df = pd.read_csv('檔案路徑地址/名.csv',header=0,encoding='gbk')
df.head(5)
df.tail(5)
3.1對缺失值的處理
#填充缺失值
df.fillna(0)
df.model_id.fillna(-1)
pandas使用isnull()和notnull()函式來判斷缺失情況。
對於缺失資料一般處理方法為濾掉或者填充。
濾除缺失資料
對於一個Series，dropna()函式返回一個包含非空資料和索引值的Series，例如：
對於DataFrame，dropna()函式同樣會丟掉所有含有空元素的資料，例如：
但是可以指定how='all'，這表示只有行裡的資料全部為空時才丟棄，例如：
如果想以同樣的方式按列丟棄，可以傳入axis=1，例如：
#將第2列為空的行去掉
tmp=tmp[-pd.isnull(tmp.iloc[:,2])]
填充缺失資料
如果不想丟掉缺失的資料而是想用預設值填充這些空洞，可以使用fillna()函式：
如果不想只以某個標量填充，可以傳入一個字典，對不同的列填充不同的值：
3.2快速描述
df.describe()
3.3返回df的長度
len（df）
3.4賦值
df.loc[:,’a’]=np.array([5]*len(df))#給df賦新列‘a’
df[df>0]=-df
通過定位df.loc or df.iloc [,]=1
3.5設定每列標籤，推薦使用第二種。其實可以直接開啟編輯，在表頭寫上標籤（直接編輯這個如果不需要多次重複讀取資料可以這麼幹，其他情況儘量不要這麼幹）。
df.columns = ['water_year','rain_octsep', 'outflow_octsep',
'rain_decfeb','outflow_decfeb','rain_junaug', 'outflow_junaug']
df.rename(columns={'total_bill': 'total', 'tip': 'pit', 'sex': 'xes'}, inplace=True)
3.6有時你想提取一整列，使用列的標籤可以非常簡單地做到：
df['rain_octsep']或df.rain_ocstep
注意，當我們提取列的時候，會得到一個 series ，而不是 dataframe 。記得我們前面提到過，你可以把 dataframe 看作是一個 series 的字典，所以在抽取列的時候，我們就會得到一個 series。
還記得我在命名列標籤的時候特意指出的嗎？不用空格、破折號之類的符號，這樣我們就可以像訪問物件屬性一樣訪問數
3.7返回由【布林值】構成的dataframe，就是這個標籤小於1000和大於1000的資訊。
df.rain_octsep < 1000 # Or df['rain_octsep] < 1000
3.8過濾後，得到的表，資訊的篩選
df[df.rain_octsep < 1000]
3.9選擇區域
df[0:3]選擇行；df.loc[:,[‘a’,’b’]]通過標籤在多個軸上選擇
df.loc[0:3,[‘a’,’b’]]標籤切片
#返回索引為xxx字串的series
df.loc['xxx']
df.loc[3,’a’]快速訪問標量
#資料條件篩選，篩選出標籤為a內容=x的行series
df.loc[df[‘a’]==’x’]
#保留b,c列篩選外加排序
df.loc[df[‘a’]==’x’,[‘a’,‘b’,’c’]].sort([‘a’],ascending=False)
#多列資料篩選並排序
df.loc[(df[‘a’]==’x’)&(df[‘b’]>10),[‘a’,’b’,’c’]].sort([‘a’],ascending=False)
#按篩選條件求和，滿足前一條件則對b求和..還有按條件計算均值mean(),max(),min(),count()
df.loc[df[‘a’]==’x’].b.sum()
df.loc[(df[‘a’]==’x’)&(df[‘c’]>10)].b.sum()#就是多條件求和，sumifs
3.10用isin()方法過濾，確認a列中是否有one、two，有則篩出來
df[df[‘a’].isin([‘one’,’two’])]
3.11iloc返回固定行的series，非常好用
df.iloc[30]
df.iloc[3]返回行
df.iloc[3:5,1:2]返回某一選片
df.iloc[[1,2,4],[0,2]]返回特定選片交集
df.iloc[1:3,:]返回1:3行
df.iloc[1,2]返回特定位置資料
3.12設定某標籤為索引
df=df.set_index(['xxx'])
3.13將索引恢復為資料，如果先排序了，再恢復不影響排序結果
df = df.reset_index('xxx')
3.14排序，True是升序，False是降序，.head(x)選取特定行排序
df.sort_index(ascending=True)
#對‘a’進行排序
df.sort([‘a’],ascending=False)
df.sort(colums=’a’)
#對多列進行排序
df.sort([‘a’,’b’],ascending=False)
3.15分組，將某一列標籤合併並統計將結果賦給tf，如size（），max、min、mean等函式
#10*10指間隔為10,1000*1000間隔為1000
tf=df.groupby(df.year // 10 *10).max()
decade_rain = df.groupby([df.year // 10 * 10, df.rain_octsep // 1000 * 1000])[['outflow_octsep','outflow_decfeb', 'outflow_junaug']].mean()
#分別對k1,k2列進行排序,df1,df2都是中間變數型別，為groupby型別，使用推導式【x for x in df1】顯示
df1=df.groupby([‘k1’,’k2’])
df2=df.groupby(‘k1’)
3.16返回資料規模，行和列
df.shape
3.17返回各列資料格式
df.dtypes
3.18python輸出替代%s替代string，等，‘’%（a，b）後面括號內是幾個替代值
print("I'm %s. I'm %d year old" % ('Vamei', 99))
3.19新增列，除了insert
df[‘new’]=[‘a’,’b’,’c’]
#插入列,第二個位置，名為‘e’，值=df[‘a’]
df.insert(1,’e’,df[‘a’])
3.20刪除行列,1為列0為行
df2=df.drop([‘a’,’b’],axis=1)
#輸出並刪除‘b’列，將b列插入到第一列
b=df.pop(‘b’)
df.insert(0,’b’,b)
3.21將結果輸出成csv
df.to_csv(‘xxx.csv’,index=False,encoding=’utf-8’,)
|
path_or_buf：字串或檔案控制代碼，預設為無 檔案路徑或物件，如果沒有提供結果作為字串返回。 sep：character，default'，' 輸出檔案的欄位分隔符。 na_rep：string，default'' 缺少資料表示 float_format：string，default None 格式化浮點數字符串 列：序列，可選 要寫的列 標題：布林或字串列表，預設為True 寫出列名。如果給出了一個字串列表，那麼它被認為是列名稱的別名 index：boolean，預設為True 寫行名（索引） index_label：字串或序列，或False，預設為無 如果需要，索引列的列標籤。如果沒有給出，並且 頭和索引為True，則使用索引名稱。如果DataFrame使用MultiIndex，則應該給出一個序列。如果False不列印索引名稱的欄位。使用index_label = False更容易在R中匯入 模式：str Python寫入模式，預設'w' encoding：string，可選 表示在輸出檔案中使用的編碼的字串，在Python 2上預設為“ascii”，在Python 3上預設為“utf-8”。 壓縮：字串，可選 表示在輸出檔案中使用的壓縮字串的字串，允許的值為'gzip'，'bz2'，'xz'，僅在第一個引數為檔名時使用 line_terminator：string，default'\n' 在輸出檔案中使用的換行字元或字元序列 引用：來自csv模組的可選常量 預設為csv.QUOTE_MINIMAL。如果您設定了一個float_format， 那麼float將被轉換為字串，因此csv.QUOTE_NONNUMERIC將它們視為非數字 quotechar：string（length 1），default'“' 字元用來引用欄位 doublequote：boolean，預設為True 控制在一個欄位內引用quotechar escapechar：string（length 1），default None 適當時用於逃避sep和quotechar的字元 chunksize：int或None 一次寫入的行 tupleize_cols：boolean，default False 將multi_index列作為元組列表（如果為True）或新（擴充套件格式），如果為False） date_format：string，default無 格式為datetime物件的字串 decimal：string，default'。' 字元識別為小數分隔符。例如使用'，'為歐洲資料 新版本0.16.0。 |
3.22資料合併
1.merge
merge 函式通過一個或多個鍵來將資料集的行連線起來。該函式的主要 應用場景是針對同一個主鍵存在兩張包含不同特徵的表，通過該主鍵的連線，將兩張表進行合併。合併之後，兩張表的行數沒有增加，列數是兩張表的列數之和減一。
函式的具體引數為：
merge(left,right,how='inner',on=None,left_on=None,right_on=None,
left_index=False,right_index=False,sort=False,suffixes=('_x','_y'),copy=True)
· on=None 指定連線的列名，若兩列希望連線的列名不一樣，可以通過left_on和right_on 來具體指定
· how=’inner’,引數指的是左右兩個表主鍵那一列中存在不重合的行時，取結果的方式：inner表示交集，outer 表示並集，left 和right 表示取某一邊。
舉例如下
import pandas as pd
df1 = pd.DataFrame([[1,2,3],[5,6,7],[3,9,0],[8,0,3]],columns=['x1','x2','x3'])
df2 = pd.DataFrame([[1,2],[4,6],[3,9]],columns=['x1','x4'])
print df1
print df2
df3 = pd.merge(df1,df2,how = 'left',on='x1')
print df3
在這裡我分別設定了兩個DataFrame類別的變數df1,df2,(平常我們用的表csv檔案，讀取之後也是DataFrame 格式)。然後我設定 on=’x1’,即以兩個表中的x1為主鍵進行連線，設定how=’left’ ,即是以兩個表中merge函式中左邊那個表的行為準，保持左邊錶行數不變，拿右邊的表與之合併。結果如下：
第一個結果為how=’left’的情況。第二個結果為how=’inner’的情況。
注意:在how=’left’設定後，左邊行之所以能夠保持不變，是因為右邊的表主鍵列沒有重複的值，x下面我會舉個例子作為思考題：
這是兩張表，分別為df1,df2;
第一個問題：
在預設情況下即merge(df1,df2)其他引數為預設值的返回結果是 什麼？
第二個問題：
在加上how=’left’之後的返回結果是什麼？
看完了問題之後，返回去看這兩張表，不著急看答案，仔細想想。
這兩個問題明白之後，表之間的連線和對映應該都能夠明白了。
2.concat
concat 與其說是連線，更準確的說是拼接。就是把兩個表直接合在一起。於是有一個突出的問題，是橫向拼接還是縱向拼接，所以concat 函式的關鍵引數是axis 。
函式的具體引數是：
concat(objs,axis=0,join='outer',join_axes=None,ignore_index=False,keys=None,levels=None,names=None,verigy_integrity=False)
· objs 是需要拼接的物件集合，一般為列表或者字典
· axis=0 是行拼接，拼接之後行數增加，列數也根據join來定，join=’outer’時，列數是兩表並集。同理join=’inner’,列數是兩表交集。
在預設情況下，axis=0為縱向拼接，此時有
concat([df1,df2]) 等價於 df1.append(df2)
在axis=1 時為橫向拼接 ，此時有
concat([df1,df2],axis=1) 等價於 merge(df1,df2,left_index=True,right_index=True,how='outer')
舉個例子
import pandas as pd
df1 = pd.DataFrame({'key':['a','a','b','b'],'data1':range(4)})
print df1
df2 = pd.DataFrame({'key':['b','b','c','c'],'data2':range(4)})
print df2
print pd.concat([df1,df2],axis=1)
print pd.merge(df1,df2,left_index=True,right_index=True,how='outer')
3.23類別特徵編碼get_dummy
是一種很實用的將字典中某一列的可能存在的值，多維化對映在對應行，有點像one-hot編碼方式，統計該列所有可能存在的值（像sort），作為字典新新增的幾個列向量，每一行之前存在哪個值，對應列處值就是1，否則為0。
格式如下：pandas.get_dummies()
引數有：data（資料），prefix（字首），columns（選擇進行處理的列），dummy_na（是否將NaN新增到dummies），drop_first(將統計出來的k個dummies去掉第一個得到k-1個dummies)
舉例：import pandas as pd
S=pd.Series(list(‘abca’))
>>> pd.get_dummies(s)
a b c
0 1 0 0
1 0 1 0
2 0 0 1
3 1 0 0
>>> s1 = ['a', 'b', np.nan]
>>> pd.get_dummies(s1)
a b
0 1 0
1 0 1
2 0 0
>>> pd.get_dummies(s1, dummy_na=True)
a b NaN
0 1 0 0
1 0 1 0
2 0 0 1
>>> df = pd.DataFrame({'A': ['a', 'b', 'a'], 'B': ['b', 'a', 'c'], 'C': [1, 2, 3]})
>>> pd.get_dummies(df, prefix=['col1', 'col2'])
C col1_a col1_b col2_a col2_b col2_c
0 1 1 0 0 1 0
1 2 0 1 1 0 0
2 3 1 0 0 0 1
>>> pd.get_dummies(pd.Series(list('abcaa')))
a b c
0 1 0 0
1 0 1 0
2 0 0 1
3 1 0 0
4 1 0 0
>>> pd.get_dummies(pd.Series(list('abcaa')), drop_first=True))
b c
0 0 0
1 1 0
2 0 1
3 0 0
4 0 0
3.24apply函式lambda部分
python的lambda表示式很想swift語言裡的Closure閉包，無函式名的語句塊，可以指定傳入引數、計算結果。
語法格式如下：
lambda 傳入引數 ： 返回的計算表示式
eg1， 求一個數的平方
>>> g = lambda x : x ** 2
# x為傳入引數， 冒號後的x ** 2為傳回表示式
>>> print g(4)
16
>>> def h(x):
... return x ** 2
...
>>> print h(4)
16
eg2， 求兩數之和
>>> t = lambda x,y: x +y
# x和y為傳入引數， 冒號後的 x + y為傳回值的表示式
>>> t(2, 4)
6
eg3，用map 求1...4平方 => 1*1,2*2,3*3,4*4
map(lambda x : x * x, range(1,5))
返回值是[1,4,9,16]
lambda賦值語句是倒裝的，0 if x==-1 #令x=0當x==-1時。
3.25對多列條件進行apply處理，定義函式
def do_something(x, y):
return x * y
df['new_col'] = map(lambda x, y: do_something(x, y) , df['col_1'], df['col_2'])
3.26浮點小數四捨五入
round(x,5)#保留小數點後5位
3.27常用時間處理，time、datetime、timedelta
Python其實內建了很多方式處理日期和時間，很方便，在我最初對時間的處理上，簡單粗暴的用幾位數表示，帶來了後續時間間隔計算的各種麻煩，後來忽然發現python已經內建了時間的處理的庫。。。
Python 提供了一個 time 和 calendar 模組可以用於格式化日期和時間。
時間間隔是以秒為單位的浮點小數。
每個時間戳都以自從1970年1月1日午夜（曆元）經過了多長時間來表示。
Python 的 time 模組下有很多函式可以轉換常見日期格式。如函式time.time()用於獲取當前時間戳, 如下例項:
#!/usr/bin/python# -*- coding: UTF-8 -*-
import time; # 引入time模組
ticks = time.time()print "當前時間戳為:", ticks
以上例項輸出結果：
當前時間戳為: 1459994552.51
時間戳單位最適於做日期運算。但是1970年之前的日期就無法以此表示了。太遙遠的日期也不行，UNIX和Windows只支援到2038年。
什麼是時間元組？很多Python函式用一個元組裝起來的9組數字處理時間:
|
序號 |
欄位 |
值 |
|
0 |
4位數年 |
2008 |
|
1 |
月 |
1 到 12 |
|
2 |
日 |
1到31 |
|
3 |
小時 |
0到23 |
|
4 |
分鐘 |
0到59 |
|
5 |
秒 |
0到61 (60或61 是閏秒) |
|
6 |
一週的第幾日 |
0到6 (0是週一) |
|
7 |
一年的第幾日 |
1到366 (儒略曆) |
|
8 |
夏令時 |
-1, 0, 1, -1是決定是否為夏令時的旗幟 |
|
序號 |
屬性 |
值 |
|
0 |
tm_year |
2008 |
|
1 |
tm_mon |
1 到 12 |
|
2 |
tm_mday |
1 到 31 |
|
3 |
tm_hour |
0 到 23 |
|
4 |
tm_min |
0 到 59 |
|
5 |
tm_sec |
0 到 61 (60或61 是閏秒) |
|
6 |
tm_wday |
0到6 (0是週一) |
|
7 |
tm_yday |
1 到 366(儒略曆) |
|
8 |
tm_isdst |
-1, 0, 1, -1是決定是否為夏令時的旗幟 |
上述也就是struct_time元組。這種結構具有如下屬性：
獲取當前時間
從返回浮點數的時間輟方式向時間元組轉換，只要將浮點數傳遞給如localtime之類的函式。
#!/usr/bin/python# -*- coding: UTF-8 -*-
import time
localtime = time.localtime(time.time())print "本地時間為 :", localtime
以上例項輸出結果：
本地時間為 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)
獲取格式化的時間
你可以根據需求選取各種格式，但是最簡單的獲取可讀的時間模式的函式是asctime():
#!/usr/bin/python# -*- coding: UTF-8 -*-
import time
localtime = time.asctime( time.localtime(time.time()) )print "本地時間為 :", localtime
以上例項輸出結果：
本地時間為 : Thu Apr 7 10:05:21 2016
格式化日期
我們可以使用 time 模組的 strftime 方法來格式化日期，：
time.strftime(format[, t])
#!/usr/bin/python# -*- coding: UTF-8 -*-
import time
# 格式化成2016-03-20 11:45:39形式print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# 格式化成Sat Mar 28 22:24:24 2016形式print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())
# 將格式字串轉換為時間戳
a = "Sat Mar 28 22:24:24 2016"print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))
以上例項輸出結果：
2016-04-07 10:25:09Thu Apr 07 10:25:09 20161459175064.0
python中時間日期格式化符號：
· %y 兩位數的年份表示（00-99）
· %Y 四位數的年份表示（000-9999）
· %m 月份（01-12）
· %d 月內中的一天（0-31）
· %H 24小時制小時數（0-23）
· %I 12小時制小時數（01-12）
· %M 分鐘數（00=59）
· %S 秒（00-59）
· %a 本地簡化星期名稱
· %A 本地完整星期名稱
· %b 本地簡化的月份名稱
· %B 本地完整的月份名稱
· %c 本地相應的日期表示和時間表示
· %j 年內的一天（001-366）
· %p 本地A.M.或P.M.的等價符
· %U 一年中的星期數（00-53）星期天為星期的開始
· %w 星期（0-6），星期天為星期的開始
· %W 一年中的星期數（00-53）星期一為星期的開始
· %x 本地相應的日期表示
· %X 本地相應的時間表示
· %Z 當前時區的名稱
· %% %號本身
獲取某月日曆
Calendar模組有很廣泛的方法用來處理年曆和月曆，例如列印某月的月曆：
#!/usr/bin/python# -*- coding: UTF-8 -*-
import calendar
cal = calendar.month(2016, 1)print "以下輸出2016年1月份的日曆:"print cal;
以上例項輸出結果：
以下輸出2016年1月份的日曆:
January 2016Mo Tu We Th Fr Sa Su
1 2 3
4 5 6 7 8 9 1011 12 13 14 15 16 1718 19 20 21 22 23 2425 26 27 28 29 30 31
Time 模組
|
序號 |
函式及描述 |
|
1 |
time.altzone |
|
2 |
time.asctime([tupletime]) |
|
3 |
time.clock( ) |
|
4 |
time.ctime([secs]) |
|
5 |
time.gmtime([secs]) |
|
6 |
time.localtime([secs]) |
|
11 |
time.time( ) |
|
12 |