Python笔记第3章,模块和模块的经常使用方法,函数式编程yield,三元运算Lambda表达式,内置涵数,经常使用模块
<--目录-->java
模块和模块的经常使用方法python
函数式编程mysql
yieldlinux
三元运算正则表达式
Lambda表达式sql
内置涵数shell
经常使用模块数据库
【模块和模块的经常使用方法】
相当重要的__init__.py #包必定要有这个__init__.py文件，他才是包，这样才能经过form 包名 import 模块名（.py文件名）来去引用这个包的某个模块的某个函数功能编程
判断是否为主文件:__name__
if __name__ == '__main__'
当前文件路径: __file__json
当前文件描述: __doc__
1）if __name__ == '__main__'
例子1：
在main的包下面，有着index模块
在file的包下面，有着demo模块
cat index.py
#!/usr/bin/env python
#coding:utf-8
print __name__
python index.py
print __main__
cat demo.py
#!/usr/bin/env python
#coding:utf-8
print __name__
python demo.py
print __main__
例子2：
cat index.py
#!/usr/bin/env python
#coding:utf-8
from file import demo
print 'index',__name__
cat demo.py
#!/usr/bin/env python
#coding:utf-8
print 'demo',__name__
def Foo():
print "老狗去砍柴"
python index.py
demo,file.demo
index,__main__
总结：经过if __name__ == '__main__':
来判断当前这个.py脚本是否是主程序，若是是主程序就执行，好处就是当***来***的时候，来调用个人主程序他调用不上
2）当前文件路径: __file__
3）当前文件描述: __doc__
例子：
[root@localhost opt]# pwd;ls
/opt/
test.py
cat
test.py
#!/usr/bin/env python
#coding:utf-8
'''
This is g
test
@author:wsyht
'''
4）print __file__ #查看当前文径路径
5）print __doc__ #查看模块（.py文件）的注释
[root@localhost opt]# python test.py test.py
This is g test@author:wsyht
【函数式编程】
参数 def Fun(arg,*args,**kargs)：
默认参数 print arg
可变参数 print args
print kargs
返回值 return 'success'
1)默认参数和返回值示例
例子1：
def foo(name):
print name,'去砍柴'
foo('wsyht')
foo('jenkins')
foo('peter')
例子2：
def login（username):
if username == "wsyht":
return '登录成功'
else:
return '登录失败'
def detail(user):
print user,'验证成功'
if __name__ == '__main__':
user= raw_input('请输入用户名：')
res = login(user) #检查用户是否登录成功
if res == "登录成功"
detail(user) #显示详细信息
else:
print "没奖金了"
例子3：
def foo(name,action='砍柴',where=''): 设置默认值=砍柴，能够加多个默认参数，但默认参数的必定要放在最后面
print name,'去',action,where
foo('wsyht','砍柴')
foo('jenkins','吃饭') #不设置第二个值，就会使用设置好的默认参数"砍柴"
foo('peter'，where='上海') #默认按位置传参，指定where='上海'，就是能够不用按顺序传，给他的值就是上海，无论上面where的位置在哪
foo('jim'，where='上海'，action="oo") #默认按位置传参，指定where='上海'，就是能够不用按顺序传，给他的值就是上海，无论上面where的位置在哪
2）可变参数示例
例子4：
#!/usr/bin/env Python
#coding:utf-8
'''
def show1(arg):
for item in arg:
print item
def show2(arg1,arg2):
print arg1,arg2
#show1(['Lyang','wsyht'])
show2('Liyang','zhangsan')
def show(*arg): #加一个*你就能够加N个参数
for item in arg:
print item
show('wsyht','tom','peter','jenkins','jack')
'''
'''
def show(**kargs):
for item in kargs.items():
print item
show(name='wsyht',age='26')
'''
#以元组方式传进去
def show(**kargs):
for item in kargs.items():
print item
user_dict={'k1':123,'k2':456}
show(**user_dict) #元组方式传进去前面要加两个*
【yield的使用】
代码示例1：
#!/usr/bin/env python
#coding:utf-8
'''
print range(10)
print xrange(10)
for item in xrange(10): #便 利才生成数字
print item
'''
def foo():
yield 1 #eclipse上打上断点,debug测试
yield 2
yield 3
yield 4
yield 5
re = foo()
#print re #调用的是生成器
for item in re: #便利的时候才能使用re
print item
代码示例2：
#!/usr/bin/env python
#coding:utf-8
def WsyhtReadlines():
seek = 0
while True:
with open('F:/wsyht.txt','r') as f:
f.seek(seek)
data = f.readline() #读取一行
if data:
seek = f.tell()
yield data
else:
return #若是return了，那么整个函数将退出
#print WsyhtReadlines() #这样输出就是一个生成器
for item in WsyhtReadlines():
print item
'''
f = open('d:/temp.txt,'r')
f.read()
f.close()
with open('d:/temp.txt','r') as f: #这样写就不须要再对文件close了
print 'xxxx'
print 'ok'
'''
【三元运算和Lambda表达式】
1）三元运算
代码实例：
result = 'gt' if 1>3 else 'lt'
print result
例子：
#!/usr/bin/env python
#coding:utf-8
temp = None
if 1>3:
temp = 'gt'
else:
temp = 'lt'
print temp
#上面方法实现跟下面代码方法实现效果同样
result = 'gt' if 1>3 else 'lt'
print result
2）Lambda表达式
代码实例：
a = lambda x,y:x+y
print a(4,10)
例子：
#!/usr/bin/env pythondef foo(x,y): return x+yprint
foo(16,10)
temp = lambda x,y:x+y
print temp(16,10)
'''temp = lambda x:x*x
print temp(4)''''''temp = lambda x,y,z:x+y+z
print temp(1,3,5)'''
其它示例：>>> [i*2 for i in range(10)] [0, 2, 4, 6, 8, 10, 12,
14, 16, 18]f>>> map(lambda x:x*2, range(10))[0, 2, 4, 6, 8, 10,
12, 14, 16, 18]>>> map(lambda x:x**x, range(10)) [1, 1, 4, 27,
256, 3125, 46656, 823543, 16777216, 387420489]>>>
【内置函数】
help() #查看帮助
dir() #把相应的key列出来，全部的内置函数
vars() #列出全部key和Values,全部的内置函数
type() #查看类型
import temp #导入模块
reload(temp) #重复导入模块
id() #查看内存地址
#help,dir(),vars(),type()演示
>>> a = []
#它是一个类，调用一个类来建立类表
>>> a1 = list()
>>> help(a)
#查看帮助
>>> print dir() #把相应的key列出来，全部的内置函数
>>> print
vars() #列出全部key和Values,全部的内置函数
>>> print type(a)
#查看类型
>>> print type(a1) #查看类型
#reload(demo)演示
#file包下有一个demo.py模块文件
#main包下有一个index.py文件
#cat demo.py
#!/usr/bin/env python
#coding:utf-8
print 'demo.py'
#python index.py
#python index.py
#!/usr/bin/env python
#coding:utf-8
from file import demo #当导入的时候就会执行一篇demo模块里面的全部代码
#from file import demo #Python下再用重复的代码导入相同的模块是不会导入的，他只导入一次
#若是想导两次，就要用reload(demo)
from file import demo
reload(demo)
#id演示，查看所占用的内存空间
>>> t1=123
>>>
t2=888
>>> print id(t1)
28244048
>>> print
id(t2)
28560048
cmp() 判断先后值大小，前大-1，后大1，同大0
abs() 求觉对值
bool() 0为False，其它为True
divmod() 求商取余
man() 求最大值
min() 求最小值
sum() 求和
pow() 求次方
>>> cmp(2,3) #后面大负1
-1
>>>
cmp(5,3) #前面大正1
1
>>> cmp(5,5) #等大出零
0
>>>
print abs(-9) #求觉对值
9
>>> print bool(0)
#求布尔值
False
>>> print bool(1)
True
>>> print
bool(15)
True
>>> print bool(-3)
True
>>> print
divmod(9,4) #求商取余
(2, 1)
>>> print divmod(14,4)
(3,
2)
>>> print divmod(15,3)
(5, 0)
>>> print
max([11,22,33,333]) #求最大值
333
>>> print min([11,22,33,333])
#求最小值
11
>>> print sum([11,22,33]) #求和
66
>>>
print pow(2,3)
#2的3次方
8
all() 一假则假，全真才真
any() 一真则真，全假才假
>>> print all([1,2,3,0])
#一假则假
False
>>> print all([1,2,3,1])
#全真则真
True
>>> print any([0,0,0,0])
#全假则假
False
>>> print any([1,0,0,0])
#一真则真
True
>>> print any([1,2,3,1])
True
>>> print
bool('')
False
>>> print bool(None)
False
chr() ASCALL码对应的字符 #必须记住
ord() ASCALL码对应的数字 #必须记住
hex() 十六进制转换
oct() 八进制转换
bin() 二进制转换
>>> print chr(65)
#ASCALL码对应的字符
A
>>> print chr(66)
B
>>> print
chr(67)
C
>>> print chr(68)
D
>>> print chr(69)
E
>>> print ord('A') #ASCALL码对应的数字
65
>>> print
ord('B')
66
>>> print hex(2000)
#十六进制转换
0x7d0
>>> print oct(2000)
#八进制转换
03720
>>> print bin(2)
#二进制转换
0b10
enumerate() 加序列号 #必须记住
format() 格式化输出
>>> li = ['手表','汽车','房']
>>> for item in li:print item
...
手表
汽车
房
>>> for item in enumerate(li):print item
#enumerate是加序列号
...
(0, '\xe6\x89\x8b\xe8\xa1\xa8')
(1,
'\xe6\xb1\xbd\xe8\xbd\xa6')
(2, '\xe6\x88\xbf')
>>> for item in
enumerate(li,1):print item #括号第二个参数是指起始值
...
(1,
'\xe6\x89\x8b\xe8\xa1\xa8')
(2, '\xe6\xb1\xbd\xe8\xbd\xa6')
(3,
'\xe6\x88\xbf')
>>> for item in enumerate(li,3):print item
...
(3, '\xe6\x89\x8b\xe8\xa1\xa8')
(4, '\xe6\xb1\xbd\xe8\xbd\xa6')
(5,
'\xe6\x88\xbf')
>>> for item in enumerate(li,1):print
item[0],item[1]
...
1 手表
2 汽车
3 房
>>> s='My Name {0}
{1}'
>>> print s.format('is','wsyht')
My Name is
wsyht
>>> s='My Name {0},{1}'
>>> print
s.format('is','wsyht')
My Name
is,wsyht
#调用函数的两种方法
def function(arg): print arg
function('wsyht') #第一种调用方法
apply(function,('wsyht')) #执行函数，第二种调用方法，这种应用不普遍，知道就好
#map的使用，全部数进行相加，相减，相乘等
>>> print map(lambda x:x+1,[1,2,3])
#all[2, 3, 4]
>>> li = [11,22,33] #第一种方法>>>
temp=[]>>> for item in li:temp.append(item + 100)...
>>> print temp[111, 122, 133]
>>> def foo(arg):return arg + 100 #第二种方法... >>>
li = [11,22,33]>>> temp=[]>>> for item in
li:temp.append(foo(item))... >>> print temp[111, 122,
133]
>>> def foo(arg):return arg + 100 #使用map的方法...
>>> li = [11,22,33]>>> temp =
map(foo,li)>>> print temp[111, 122, 133]
>>> li = [11,22,33]>>> temp = map(lambda
arg:arg+100,li) #最简单的map方法把他便利出来>>> print temp[111, 122,
133]
#filter的使用，过滤条件，只有是True序列的，才会对他进行相加，相减操做
#!/usr/bin/env
python
#coding:utf-8
li = [2,5,11,22,33]
def foo(arg):
if
arg<22:
return True
else:
return False
temp =
filter(foo,li)
print
temp
#reduce的使用，累加，累乘操做
>>> li=[2,5,7]
>>> print
reduce(lambda x,y:x+y,li) #最少要有两个变量x,y
14
>>> print
reduce(lambda
x,y:x*y,li)
70
#zip的使用，把他们的列表的每一列拼接成一组打印出来
>>> x = [1,2,3]
>>> y =
[4,5,6]
>>> z = [7,8,9]
>>> q = [1,3,5]
>>>
print zip(x,y,z,q)
[(1, 4, 7, 1), (2, 5, 8, 3), (3, 6, 9, 5)]
>>>
q = [1,3,5]
>>> x = [2,4,6]
>>> z = [2,4]
>>> print zip(q,x,z)
[(1, 2, 2), (3, 4,
4)]
#eval的使用
>>> a = '8*8'
>>> print
a
8*8
>>> print eval(a)
64
#反射，__import__()的使用，经过字符串的形式去导入模块，并以字符串的形式执行函数
附加知识：
getattr() #获取模块的函数数
hasattr() #判断模块有没有这个函数
delattr() #删除这个模块的某个函数
#查看帮助
#import os
#help(os)
演示1：经过字符串的形式去导入模块
>>> temp = 'sys'
>>> model =
__import__(temp)
>>> print model.path
['',
'/usr/local/python2.7/lib/python27.zip', '/usr/local/python2.7/lib/python2.7',
'/usr/local/python2.7/lib/python2.7/plat-linux2',
'/usr/local/python2.7/lib/python2.7/lib-tk',
'/usr/local/python2.7/lib/python2.7/lib-old',
'/usr/local/python2.7/lib/python2.7/lib-dynload',
'/usr/local/python2.7/lib/python2.7/site-packages']
#演示2：
main包下有三个模块,index.py ,mysqlserver.py,sqlserver.py
cat
mysqlserver.py
#!/usr/bin/env python
def count():
return 2
cat sqlserver
#!/usr/bin/env python
def count():
return 2
#index.py例子1,经过字符串的形式去导入模块
#!/usr/bin/env python
'''
import mysqlserver
print mysqlserver.count()
import sqlserver
print sqlserver.count()
'''
temp = 'mysqlserver' #动态切换模块，模块下执行的方法同样，当一个宕掉了，能够快速切换，比上述方法方便快速
model = __import__(temp)
model.count()
#index.py例子2,
cat index.py
temp = 'mysqlserver' #模块名字
func = 'count' #函数名字
model = __import__(temp) #以字符串的形式导入模块
function = getattr(model,func) #获取model模块找func函数
print function() #以字符串的形式执行函数
#val = hasattr(model,'version') #判断model模块里有没有version这个函数
#print val
#dels = delattr(model,'count') #删除model模块里的count函数
#print dels
#用在开发大型程序，随时能够切换数据库的场景下
【经常使用模块】
1)random模块
#random生成验证码，生成数字
>>> import random
>>> print random.random() #0到1之间
0.455011787105
>>> print random.random()
0.0645256529981
>>> print random.random()
0.881869685668
>>> print random.randint(1,5) #生成1到5包括1和5
5
>>> print random.randint(1,5)
1
>>> print random.randint(1,5)
3
>>> print random.randint(1,5)
1
>>> print random.randint(1,5)
5
>>> print random.randint(1,5)
1
>>> print random.randint(1,5)
4
>>> print random.randint(1,5)
2
>>> print random.randrange(1,3) #生成1，2但小于3的数
2
>>> print random.randrange(1,3)
2
>>> print random.randrange(1,3)
2
>>> print random.randrange(1,3)
2
>>> print random.randrange(1,3)
2
>>> print random.randrange(1,3)
2
>>> print random.randrange(1,3)
2
>>> print random.randrange(1,3)
1
>>> print random.randrange(1,3)
1
#生成字母
>>> temp = random.randint(65,90)
>>> print chr(temp)
#验证码案例：
#!/usr/bin/env python
#coding:utf-8
import random
code = []
for i in range(6):
if i == random.randint(0,5):
code.append(str(random.randint(0,5)))
else:
temp = random.randint(65,90)
code.append(chr(temp))
print ''.join(code)
2）hashlib模块
#md5加密
>>> import hashlib
>>> hash = hashlib.md5() #建立一个md5()对像，
>>> hash.update('admin') #对像里有一个update函数，把admin经过md5加密
>>> hash.hexdigest() #输出十六进制数
'21232f297a57a5a743894a0e4a801fc3'
>>> hash.digest()
'!#/)zW\xa5\xa7C\x89J\x0eJ\x80\x1f\xc3'
3)序列化和json
pickle序列化：能够把一个对像或一个列表或一个字典经过Python特有的机制序列化，还能够反序列化
特殊二进制的方式加密一下，
>>>import pickle
>>>li = ['wsyht',11,22,'ok','yes']
>>>dumpsed = pickle.dumps(li) #序列化
>>>print dumpsed
>>>print type(dumpsed) #查看类型已经序列化成字符串
>>>loadsed = pickle.loads(dumpsed) #反序列化
>>>print loadsed
>>>print type(loadsed) #查看类型又反序列化成了列表
#!/usr/bin/env python
import pickle
li = ['wsyht',11,22,'ok','yes']
pickle.dump(li,open('f:/temp.txt','w')) #序列化到文件
应用场景：在Python和Python之间文件传输的时候给他序列化，内存之间数据交互
pickle和json的区别
pickle只能在Python中用
json是全部的语言都支持的数据接口格式，java和python想在内存之间作数据交互就要用json不然用pickle便可
pickle全部数据类型均可以序列化，
json他只能去序列化常规的数据类型
>>> import json
>>> name_dic = {'name':'wsyht','age':23}
>>> json.dumps(name_dic)
'{"age": 23, "name": "wsyht"}'
>>> serialized_obj = json.dumps(name_dic)
>>> json.loads(serialized_obj)
{u'age': 23, u'name': u'wsyht'}
>>> import pickle
>>> pickle.dumps(name_dic)
"(dp0\nS'age'\np1\nI23\nsS'name'\np2\nS'wsyht'\np3\ns."
#pickle序列化以后看不清里面的内容
#json序列化以后能够看清里面的内容
4）os模块
os.getcwd() 获取当前工做目录，即当前python脚本工做的目录路径
os.chdir("dirname") 改变当前脚本工做目录；至关于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；至关于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则没法删除，报错；至关于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的全部文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操做系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 若是path存在，返回True；若是path不存在，返回False
os.path.isabs(path) 若是path是绝对路径，返回True
os.path.isfile(path) 若是path是一个存在的文件，返回True。不然返回False
os.path.isdir(path) 若是path是一个存在的目录，则返回True。不然返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径以前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
5）sys模块
sys.argv 命令行参数List，第一个元素是程序自己路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操做系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
print val
6）re模块
compile
match search findall
group groups
正则表达式经常使用格式：
字符：\d \w \t .
次数：* + ? {m} {m,n}
示例：
#!#/usr/bin/env python
#coding:utf-8
import re
result1 = re.match('\d+', '1afsfweasfcxvsfd123') #在你给的字符串起始位置去匹配,\d从数字开始找，+表示一个到多个
if result1: #当result1等于True的时候，就是匹配，若是匹配就输出里面的内容
print result1.group() #用group方法把他匹配的内容输出出来
else:
print 'nothing'
result2 = re.search('\d+', 'alsfj3af') #在整个内容里面去匹配，\d从数字开始找，+表示一个到多个
if result2:
print result2.group() #用group方法把他匹配的内容输出出来
result3 = re.findall('\d+', 'asfaf11sf22lj33') #只要匹配全都拿出来
print result3
com = re.compile('\d+')
print com.findall('asfaf11sf22lj33')
result5 = re.search('(\d+)\w*(\d+)','aasflsjfa12aaljsf22lj13bb')
print result5.group() #全部匹配内容输出
print result5.groups() #只把括号\d，也就是组里面的内容输出
result6 = re.search('a{3,5}','aaaaaa') #匹配3到5次的aaaaa输出出来
print result6.group()
总结：
match：只在第一个字符串开始找，若是没有匹配，则再也不继续找，若是第一个字符串中有，则只输出第一个
searh: 在全部内容里找，直到找到为止，但只输出找到的第一个
findall：把全部找到的匹配的内容，都经过列表的形式打印出来
compile: 编译以后再去匹配，这样能够加快匹配的速度
group: 把他匹配的内容输出出来
groups：分组
匹配的字符：
\d：表示数字的意思
\w: 表明下划线，字母，数字
\t：制表符，除了回车之外的全部字符
匹配的次数：
* 大于等于0，0到多个
+ 大于等于1，1个到多个
? 0或1
{m} 次数，如a{6}，出现6次a的进行匹配
{m,n} 如a{3,7} 出现3到7次的就进行匹配
例子1：
法1
>>> ip = '12.23.84.dsfa.23s.3234~lsjfw+23sfaf192.168.32.43_w342d~@#9436'
>>> import re
>>> re.findall('[0-9]{1,3}',ip)
['12', '23', '84', '23', '323', '4', '23', '192', '168', '32', '43', '342', '943', '6']
>>> re.findall('[0-9]{1,3}\.[0-9]{1,3}',ip)
['12.23', '192.168', '32.43']
>>> re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}',ip)
['12.23.84', '192.168.32']
>>> re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}',ip)
['192.168.32.43']
法2:
>>> re.findall('(\d+)',ip)
['12', '23', '84', '23', '3234', '23', '192', '168', '32', '43', '342', '9436']
>>> re.findall('(\.+\d+){1,3}',ip)
['.84', '.23', '.3234', '.43']
>>> re.findall('(?:\.+\d+){1,3}',ip) #?:表示匹配括号的那一组数据，必须连着
['.23.84', '.23', '.3234', '.168.32.43']
>>> re.findall('[0-9]{1,3}(?:\.+\d+){3}',ip)
['192.168.32.43']
法3：
>>> re.findall('(?:\d+\.+){3}\d{1,3}',ip)
['192.168.32.43']
法4：
>>> re.findall('(?:\d{1,3}\.){3}\d{1,3}',ip)
['192.168.32.43']
7）time模块
三种表示主式：
一、时间戳 1970年1月1往后的秒
二、元组包含了：年、日、星期等...time.struct_time
三、格式化的字符串 2014-11-11 11:11 print time.time()
#时间戳形式存在
print time.time()
print time.mktime(time.localtime()) #print (time.localtime())此为元组形式，这一整句意思是把元组形式转化成时间戳形式
#元组形式存在
print time.gmtime() #可加时间戳参数
print time.localtime() #可加时间戳参数
print time.strptime('2014-11-11','%Y-%m-%d') #字符串形式转换成元组形式
#字符串形式存在
print time.strftime('%Y-%m-%d') #默认当前时间，必须记住，工做中用得最多
print time.strftime('%Y-%m-%d',time.localtime()) #默认当前时间
print time.asctime()
print time.asctime(time.localtime())
print time.ctime(time.time())
时间的三种表示方式演示
>>> import time
>>> print time.time()
1469014348.5 #秒，时间戳的方式
>>> print time.gmtime()
time.struct_time(tm_year=2016, tm_mon=7, tm_mday=20, tm_hour=11, tm_min=25, tm_sec=53, tm_wday=2, tm_yday=202, tm_isdst=0)
>>> print time.strftime('%Y-%m-%d %H:%M:%S')
2016-07-20 19:36:16
8）datetime模块
import datetime
'''
datetime.date：表示日期的类。经常使用的属性有year, month, day
datetime.time：表示时间的类。经常使用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''
import datetime
print datetime.datetime.now()
print datetime.datetime.now() - datetime.timedelta(days=5)
9)shutil模块
windows系统下使用的模块
import shutil
shutil.copyfile('f:/temp.txt', 'f:/os.txt') #复制文件
shutil.copytree('f:/temp', 'f:/os') #复制目录
相关文章
- 1. Python笔记第3章,模块和模块的经常使用方法,函数式编程yield,三元运算Lambda表达式,内置涵数,经常使用模块...
- 2. python经常使用第三方模块
- 3. Python学习----第二模块笔记（函数和经常使用模块）
- 4. 第二模块：函数编程 第2章·经常使用模块
- 5. 内置函数，匿名函数，正则表达式，经常使用模块
- 6. python os模块经常使用函数
- 7. Python---sys模块经常使用函数
- 8. Python 经常使用函数 configparser模块
- 9. Python函数——经常使用模块
- 10. python time模块经常使用函数
- 更多相关文章...
- • Lua 模块与包 - Lua 教程
- • DTD - XML 构建模块 - DTD 教程
- • 委托模式
- • 常用的分布式事务解决方案
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章