数据预处理(数据的操作2)

时间:2024-03-10 21:47:13

 

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])
接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"(2008年12月11日 周二18时07分14秒)的24个字符的字符串。

3

time.clock( )
用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时,比time.time()更有用。

4

time.ctime([secs])
作用相当于asctime(localtime(secs)),未给参数相当于asctime()

5

time.gmtime([secs])
接收时间辍(1970纪元后经过的浮点秒数)并返回格林威治天文时间下的时间元组t。注:t.tm_isdst始终为0

6

time.localtime([secs])
接收时间辍(1970纪元后经过的浮点秒数)并返回当地时间下的时间元组t(t.tm_isdst可取0或1,取决于当地当时是不是夏令时)。

7

time.mktime(tupletime)
接受时间元组并返回时间辍(1970纪元后经过的浮点秒数)。

8

time.sleep(secs)
推迟调用线程的运行,secs指秒数。

9

time.strftime(fmt[,tupletime])
接收以时间元组,并返回以可读字符串表示的当地时间,格式由fmt决定。

10

time.strptime(str,fmt=\'%a %b %d %H:%M:%S %Y\')
根据fmt的格式把一个时间字符串解析为时间元组。

11

time.time( )
返回当前时间的时间戳(1970纪元后经过的浮点秒数)。

12

time.tzset()
根据环境变量TZ重新初始化时间相关设置。

Time 模块包含了以下内置函数,既有时间处理相的,也有转换时间格式的:

Time模块包含了以下2个非常重要的属性:

序号

属性及描述

1

time.timezone
属性time.timezone是当地时区(未启动夏令时)距离格林威治的偏移秒数(>0,美洲;<=0大部分欧洲,亚洲,非洲)。

2

time.tzname
属性time.tzname包含一对根据情况的不同而不同的字符串,分别是带夏令时的本地时区名称,和不带的。

 

 

日历(Calendar)模块

此模块的函数都是日历相关的,例如打印某月的字符月历。

序号

函数及描述

1

calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历,3个月一行,间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。

2

calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下,首次载入caendar模块时返回0,即星期一。

3

calendar.isleap(year)
是闰年返回True,否则为false。

4

calendar.leapdays(y1,y2)
返回在Y1,Y2两年之间的闰年总数。

5

calendar.month(year,month,w=2,l=1)
返回一个多行字符串格式的year年month月日历,两行标题,一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。

6

calendar.monthcalendar(year,month)
返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示,从1开始。

7

calendar.monthrange(year,month)
返回两个整数。第一个是该月的星期几的日期码,第二个是该月的日期码。日从0(星期一)到6(星期日);月从1到12。

8

calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w,l,c).

9

calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.calendar(year,w,l,c)。

10

calendar.setfirstweekday(weekday)
设置每周的起始日期码。0(星期一)到6(星期日)。

11

calendar.timegm(tupletime)
和time.gmtime相反:接受一个时间元组形式,返回该时刻的时间辍(1970纪元后经过的浮点秒数)。

12

calendar.weekday(year,month,day)
返回给定日期的日期码。0(星期一)到6(星期日)。月份为 1(一月) 到 12(12月)。

星期一是默认的每周第一天,星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数:

 

 

其他相关模块和函数

在Python中,其他处理日期和时间的模块还有:

· datetime模块

· pytz模块

· dateutil模块