python函数,模块及eclipse配置python开发环境
一、eclipse的使用
1、作用
(1)最好用的IDE
(2)可调式debug
(3)查看可执行过程
(4)可查看源代码
2、安装eclipse及配置
目录
安装Python
python for eclipse插件安装
配置PyDev插件
测试
安装Python
从网站上下载最新的版本,从http://python.org/download/下载。安装过程与其他Windows软件类似。目前稳定版本为Python 2.7.6和Python 3.3.4。
在Windows命令行中使用Python
如果你想要从Windows命令行调用Python,那么需要先设置Python环境变量。
对于Windows,点击控制面板->系统->高级->环境变量。在“系统变量”表单中点击叫做PATH的变量,然后编辑这个变量,把;D:\dev\python2.7.6加到它的结尾。当然,是Python所在的安装目录。
测试python环境变量是否设置成功
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
C:\Users\jiqinlin>python Python 2.7.6 (default, Nov 10 2013, 19:24:24) [MSC v.1500 64 bit (AMD64)] on win 32 Type "help", "copyright", "credits" or "license" for more information. >>>
python for eclipse插件安装
1、下载python for eclipse
python for eclipse下载地址,如:org.python.pydev.feature-1.6.3.2010100513.zip
2、解压pydev插件后,会发现有features、plugins两个文件夹,然后把features文件夹下的文件移到D:\dev\eclipse\features目录下,把plugins文件夹下的文件移到D:\dev\eclipse\plugins目录下。
注意:D:\dev\eclipse\为eclipse安装目录
3、重启eclipse,在windows->preferences出现PyDev配置项,表示PyDev插件安装成功。
配置PyDev插件
在Window菜单中选Preference,
1、windows->preferences->PyDev->Interpreter - Python,New一个Python解释器,填上解释器名字和路径,路径选相应的python.exe。
以下几步Python 3.x必选,Python 2随意。个人比较习惯Unicode,所以一次性在这儿设定了。
2、General->Editors->Text Editors->Spelling,Encoding改成Other:UTF-8
3、General->Workspace,Text file encoding改成Other:UTF-8
至此,PyDev的配置就完成了。
测试
File->New->Project,选PyDev下的PyDev Project,Grammer和Interpreter选相应的版本,Finish。
在PyDev Package Explorer的项目上右键,New->PyDev Module,随便写个名字,Finish。
然后随便写几行代码,Run在弹出的对话框中选择Python Run,OK
二、模块的常用方法
- __name__
1. 如果模块是被导入,__name__的值为模块名字
2. 如果模块是被直接执行,__name__的值为’__main__’
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
Py1.py #!/usr/bin/env python def test(): print '__name__ = ',__name__ if __name__ == '__main__': test() Py2.py #!/usr/bin/env python import Py1.py def test(): print '__name__ = ',__name__ if __name__ == '__main__': test() print ‘Py1.py __name__ = ’,Py1.__name__
__name__=__main__
Py1.py __name__=Py1
通过结果可以知道,Py2.py直接执行,那么内建变量__name__的值为__main__,否则为模块的名字,通过这个特性可以在if语句里面添加测试代码,可以提高减少BUG,提高程序的健壮性。
test()
- __file__
用__file__ 来获得脚本所在的路径是比较方便的,但这可能得到的是一个相对路径,比如在脚本test.py中写入:
#!/usr/bin/env python
print __file__
按相对路径./test.py来执行,则打印得到的是相对路径,
按绝对路径执行则得到的是绝对路径。
而按用户目录来执行(~/practice/test.py),则得到的也是绝对路径(~被展开)
- __doc__
显示当前文件的描述信息
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#!/usr/local/bin/python #coding:utf8 # ''' 这是python文件注释信息! ''' print __doc__ 输出结果: #python py_doc.py 这是python文件注释信息!
三、函数参数与返回值
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#!/usr/local/bin/python #coding:utf8 #默认传参 # def foo(name,action='北京',acti='旅游'): print name,'去',action,'和',acti foo('zhangsan','吃饭') foo('lisi') foo('liu','游泳',acti='泡妞') 输出: zhangsan 去 吃饭 和 旅游 lisi 去 北京 和 旅游 liu 去 游泳 和 泡妞
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#!/usr/local/bin/python #coding:utf8 #可变传参 def show(*arg): #可变列表 for item in arg: print item show(1,2,3,4,5,6) #以列表形式传参 def show1(**kargs): #可变字典传参 for item in kargs.items(): #接受字典两个值 print item show1(name ='zhangsan',age = '222',jos='888') 输出: 1 2 3 4 5 6 ('age', '222') ('jos', '888') ('name', 'zhangsan')
四、yield和lambda表达式
yield关键字用来定义生成器(Generator),其具体功能是可以当return使用,从函数里返回一个值,不同之处是用yield返回之后,可以让函数从上回yield返回的地点继续执行。也就是说,yield返回函数,交给调用者一个返回值,然后再“瞬移”回去,让函数继续运行, 直到吓一跳yield语句再返回一个新的值。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#!/usr/local/bin/python #yield # def foo(): yield 1 #当执行完yield 1后函数不会往下执行 yield 2 yield 3 yield 4 for i in foo(): #执行循环打印yield 1,然后继续执行函数直到遇到下一个 yield然后跳出函数进入循环打印,值得没有yield结束。 print i 输出: 1 2 3 4
在python中使用lambda来创建匿名函数,而用def创建的方法是有名称的
1 python lambda会创建一个函数对象,但不会把这个函数对象赋给一个标识符,而def则会把函数对象赋值给一个变量。
2 python lambda它只是一个表达式,而def则是一个语句。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
a = lambda x,y:x+y print a(2,4) 结果:6 m = lambda x,y,z: (x-y)*z print m(3,1,2) 结果是4
五、内置函数
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#print help() #帮助信息 print dir() #获得当前模块的属性列表 print vars() #默认打印当前模块的所有属性,如果传一个对象参数则打印当前对象的属性 #print type() #打印对象的类型 import temp #导入模块 import temp reload(temp) #重新加载模块 id([12]) #打印数值内存地址 #is # ------------------ cmp(2,3) #比较两个元组元素。 cmp(2,2) cmp(2,1) cmp(10,1) abs() #返回数字的绝对值 bool(x) #将x转换为Boolean类型,如果x缺省,返回False,bool也为int的子类 divmod(a,b) #返回的是a//b(除法取整)以及a对b的余数 max() #返回最大值 min() #返回最小值 sum() #求和 pow(2, 11) #方法返回 (2的11次方) 的值 ------------------ len() #返回列表元素个数 all() #有一个为true则为true any() #有一个不为true则为false ------------------ chr() #返回Acis码表对应的字母 ord() #返回字母对应的数值 hex() #转换一个整数对象为十六进制的字符串 oct() #八进制转换 bin() #十进制转换 ------------------ print range(10) #打印序列 print xrange(10) #生成生成器,迭代输出结果 for i in xrange(10): print i for k,v in enumerate([1,2,3,4]): #添加索引打印 print k,v ------------------ s= 'i am {0}' print s.format('alex') #传值到变量 str(1) #用于将值转化为适于人阅读的形式 ------------------ def Function(arg): #函数传参数 print arg print apply(Function,('aaaa')) #用apply执行函数 print map(lambda x:x+1,[1,2,3]) #all print filter(lambda x: x==1,[1,23,4]) #True序列 print reduce(lambda x,y:x+y,[1,2,3]) #累加 x = [1, 2, 3] y = [4, 5, 6] z = [4, 5, 6] print zip(x, y,z) ------------------ #__import__() #hasattr() #delattr() #getattr() module = __import__('temp') print dir(module) val = hasattr(module, 'version') print val ------------------ #callable() #函数、类必须要有 __call__ 方法 #compile #eval com = compile('1+1','','eval') print eval(com) #exec语句 code = "for i in range(0, 10): print i" cmpcode = compile(code, '', 'exec') exec cmpcode code = "print 1" cmpcode = compile(code, '', 'single') exec cmpcode ------------------ #isinstance() #issubclass() #super() #staticmethod()
六、常用模块
1、random用于生成随机数
import random print random.random() #生成1以下的随机数 print random.randint(1,2) #生成1到2直接的随机整数 print random.randrange(1,10,2) #生成指定基数的随机整数 列:随机生成4位数的验证码 #!/usr/local/bin/python import random checkcode = '' for i in range(4): current = random.randrange(0,4) if current != i: temp = chr(random.randint(65,90)) else: temp = random.randint(0,9) checkcode += str(temp) print checkcode
2、md5加密
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import md5 hash = md5.new() hash.update('admin') print hash.hexdigest() import hashlib #hash加密 hash = hashlib.md5() hash.update('admin') print hash.hexdigest()
3、序列化和json
import pickle data = {'k1':123,'k2':'hello'} p_str = pickle.dumps(data) print p_str #将数据通过特殊的形式转换为只有python语言人认识的字符串 with open('D:/re.pk','w') as fp: pickle.dump(data,fp) #将数据通过特殊的形式转换为只有python语音认识的字符串,并写入文件 import json j_str = json.dumps(data) print j_str #将数据通过特殊的形式转换为所有程序语言都认识的字符串 with open('D:/re.json','w') as fp: json.dump(data,fp) #将数据通过特殊的形式转换为所以程序语言都认识的字符串,并写入文件
4、re正则表达式模块
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
正则表达式的元字符有. ^ $ * ? { [ ] | ( ) .表示任意字符 []用来匹配一个指定的字符类别,所谓的字符类别就是你想匹配的一个字符集,对于字符集中的字符可以理解成或的关系。 ^ 如果放在字符串的开头,则表示取非的意思。[^5]表示除了5之外的其他字符。而如果^不在字符串的开头,则表示它本身。 具有重复功能的元字符: * 对于前一个字符重复0到无穷次 对于前一个字符重复1到无穷次 ?对于前一个字符重复0到1次 {m,n} 对于前一个字符重复次数在为m到n次,其中,{0,} = *,{1,} = , {0,1} = ? {m} 对于前一个字符重复m次 \d 匹配任何十进制数;它相当于类 [0-9]。 \D 匹配任何非数字字符;它相当于类 [^0-9]。 \s 匹配任何空白字符;它相当于类 [ fv]。 \S 匹配任何非空白字符;它相当于类 [^ fv]。 \w 匹配任何字母数字字符;它相当于类 [a-zA-Z0-9_]。 \W 匹配任何非字母数字字符;它相当于类 [^a-zA-Z0-9_]。 正则表达式(可以称为REs,regex,regex pattens)是一个小巧的,高度专业化的编程语言,它内嵌于python开发语言中,可通过re模块使用。正则表达式的 pattern可以被编译成一系列的字节码,然后用C编写的引擎执行。下面简单介绍下正则表达式的语法 正则表达式包含一个元字符(metacharacter)的列表,列表值如下: . ^ $ * + ? { [ ] \ | ( ) 1.元字符([ ]),它用来指定一个character class。所谓character classes就是你想要匹配的字符(character)的集合.字符(character)可以单个的列出,也可以通过"-"来分隔两个字符来表示一 个范围。例如,[abc]匹配a,b或者c当中任意一个字符,[abc]也可以用字符区间来表示---[a-c].如果想要匹配单个大写字母,你可以用 [A-Z]。 元字符(metacharacters)在character class里面不起作用,如[akm$]将匹配"a","k","m","$"中的任意一个字符。在这里元字符(metacharacter)"$"就是一个普通字符。 2.元字符[^]. 你可以用补集来匹配不在区间范围内的字符。其做法是把"^"作为类别的首个字符;其它地方的"^"只会简单匹配 "^"字符本身。例如,[^5] 将匹配除 "5" 之外的任意字符。同时,在[ ]外,元字符^表示匹配字符串的开始,如"^ab+"表示以ab开头的字符串。 举例验证, >>> m=re.search("^ab+","asdfabbbb") >>> print m None >>> m=re.search("ab+","asdfabbbb") >>> print m <_sre.SRE_Match object at 0x011B1988> >>> print m.group() abbbb 上例不能用re.match,因为match匹配字符串的开始,我们无法验证元字符"^"是否代表字符串的开始位置。 >>> m=re.match("^ab+","asdfabbbb") >>> print m None >>> m=re.match("ab+","asdfabbbb") >>> print m None #验证在元字符[]中,"^"在不同位置所代表的意义。 >>> re.search("[^abc]","abcd") #"^"在首字符表示取反,即abc之外的任意字符。 <_sre.SRE_Match object at 0x011B19F8> >>> m=re.search("[^abc]","abcd") >>> m.group() 'd' >>> m=re.search("[abc^]","^") #如果"^"在[ ]中不是首字符,那么那就是一个普通字符 >>> m.group() '^' 不过对于元字符”^”有这么一个疑问.官方文档http://docs.python.org/library/re.html有关元字符”^”有这么一句话,Matches the start of the string, and in MULTILINE mode also matches immediately after each newline. 我理解的是”^”匹配字符串的开始,在MULTILINE模式下,也匹配换行符之后。 >>> m=re.search("^a\w+","abcdfa\na1b2c3") >>> m.group() 'abcdfa' >>> m=re.search("^a\w+","abcdfa\na1b2c3",re.MULTILINE), >>> m.group() # 'abcdfa' 我 认为flag设定为re.MULTILINE,根据上面那段话,他也应该匹配换行符之后,所以应该有m.group应该有"a1b2c3",但是结果没 有,用findall来尝试,可以找到结果。所以这里我理解之所以group里面没有,是因为search和match方法是匹配到就返回,而不是去匹配 所有。 >>> m=re.findall("^a\w+","abcdfa\na1b2c3",re.MULTILINE) >>> m ['abcdfa', 'a1b2c3'] 3. 元字符(\),元字符backslash。做为 Python 中的字符串字母,反斜杠后面可以加不同的字符以表示不同特殊意义。 它也可以用于取消所有的元字符,这样你 就可以在模式中匹配它们了。例如,如果你需要匹配字符 "[" 或 "\",你可以在它们之前用反斜杠来取消它们的特殊意义: \[ 或 \\ 4。元字符($)匹配字符串的结尾或者字符串结尾的换行之前。(在MULTILINE模式下,"$"也匹配换行之前) 正则表达式"foo"既匹配"foo"又匹配"foobar",而"foo$"仅仅匹配"foo". >>> re.findall("foo.$","foo1\nfoo2\n")#匹配字符串的结尾的换行符之前。 ['foo2'] >>> re.findall("foo.$","foo1\nfoo2\n",re.MULTILINE) ['foo1', 'foo2'] >>> m=re.search("foo.$","foo1\nfoo2\n") >>> m <_sre.SRE_Match object at 0x00A27170> >>> m.group() 'foo2' >>> m=re.search("foo.$","foo1\nfoo2\n",re.MULTILINE) >>> m.group() 'foo1' 看来re.MULTILINE对$的影响还是蛮大的。 5.元字符(*),匹配0个或多个 6.元字符(?),匹配一个或者0个 7.元字符(+), 匹配一个或者多个 8,元字符(|), 表示"或",如A|B,其中A,B为正则表达式,表示匹配A或者B 9.元字符({}) {m},用来表示前面正则表达式的m次copy,如"a{5}",表示匹配5个”a”,即"aaaaa" >>> re.findall("a{5}","aaaaaaaaaa") ['aaaaa', 'aaaaa'] >>> re.findall("a{5}","aaaaaaaaa") ['aaaaa'] {m.n}用来表示前面正则表达式的m到n次copy,尝试匹配尽可能多的copy。 >>> re.findall("a{2,4}","aaaaaaaa") ['aaaa', 'aaaa'] 通过上面的例子,可以看到{m,n},正则表达式优先匹配n,而不是m,因为结果不是["aa","aa","aa","aa"] >>> re.findall("a{2}","aaaaaaaa") ['aa', 'aa', 'aa', 'aa'] {m,n}? 用来表示前面正则表达式的m到n次copy,尝试匹配尽可能少的copy >>> re.findall("a{2,4}?","aaaaaaaa") ['aa', 'aa', 'aa', 'aa'] 10。元字符( "( )" ),用来表示一个group的开始和结束。 比较常用的有(REs),(?P<name>REs),这是无名称的组和有名称的group,有名称的group,可以通过matchObject.group(name) 获取匹配的group,而无名称的group可以通过从1开始的group序号来获取匹配的组,如matchObject.group(1)。具体应用将在下面的group()方法中举例讲解 11.元字符(.) 元字符“.”在默认模式下,匹配除换行符外的所有字符。在DOTALL模式下,匹配所有字符,包括换行符。 >>> import re >>> re.match(".","\n") >>> m=re.match(".","\n") >>> print m None >>> m=re.match(".","\n",re.DOTALL) >>> print m <_sre.SRE_Match object at 0x00C2CE20> >>> m.group() '\n' 下面我们首先来看一下Match Object对象拥有的方法,下面是常用的几个方法的简单介绍 1.group([group1,…]) 返回匹配到的一个或者多个子组。如果是一个参数,那么结果就是一个字符串,如果是多个参数,那么结果就是一个参数一个item的元组。group1的默 认值为0(将返回所有的匹配值).如果groupN参数为0,相对应的返回值就是全部匹配的字符串,如果group1的值是[1…99]范围之内的,那么 将匹配对应括号组的字符串。如果组号是负的或者比pattern中定义的组号大,那么将抛出IndexError异常。如果pattern没有匹配到,但 是group匹配到了,那么group的值也为None。如果一个pattern可以匹配多个,那么组对应的是样式匹配的最后一个。另外,子组是根据括号 从左向右来进行区分的。 >>> m=re.match("(\w+) (\w+)","abcd efgh, chaj") >>> m.group() # 匹配全部 'abcd efgh' >>> m.group(1) # 第一个括号的子组. 'abcd' >>> m.group(2) 'efgh' >>> m.group(1,2) # 多个参数返回一个元组 ('abcd', 'efgh') >>> m=re.match("(?P<first_name>\w+) (?P<last_name>\w+)","sam lee") >>> m.group("first_name") #使用group获取含有name的子组 'sam' >>> m.group("last_name") 'lee' 下面把括号去掉 >>> m=re.match("\w+ \w+","abcd efgh, chaj") >>> m.group() 'abcd efgh' >>> m.group(1) Traceback (most recent call last): File "<pyshell#32>", line 1, in <module> m.group(1) IndexError: no such group If a group matches multiple times, only the last match is accessible: 如果一个组匹配多个,那么仅仅返回匹配的最后一个的。 >>> m=re.match(r"(..)+","a1b2c3") >>> m.group(1) 'c3' >>> m.group() 'a1b2c3' Group的默认值为0,返回正则表达式pattern匹配到的字符串 >>> s="afkak1aafal12345adadsfa" >>> pattern=r"(\d)\w+(\d{2})\w" >>> m=re.match(pattern,s) >>> print m None >>> m=re.search(pattern,s) >>> m <_sre.SRE_Match object at 0x00C2FDA0> >>> m.group() '1aafal12345a' >>> m.group(1) '1' >>> m.group(2) '45' >>> m.group(1,2,0) ('1', '45', '1aafal12345a') 2。groups([default]) 返回一个包含所有子组的元组。Default是用来设置没有匹配到组的默认值的。Default默认是"None”, >>> m=re.match("(\d+)\.(\d+)","23.123") >>> m.groups() ('23', '123') >>> m=re.match("(\d+)\.?(\d+)?","24") #这里的第二个\d没有匹配到,使用默认值"None" >>> m.groups() ('24', None) >>> m.groups("0") ('24', '0') 3.groupdict([default]) 返回匹配到的所有命名子组的字典。Key是name值,value是匹配到的值。参数default是没有匹配到的子组的默认值。这里与groups()方法的参数是一样的。默认值为None >>> m=re.match("(\w+) (\w+)","hello world") >>> m.groupdict() {} >>> m=re.match("(?P<first>\w+) (?P<secode>\w+)","hello world") >>> m.groupdict() {'secode': 'world', 'first': 'hello'} 通过上例可以看出,groupdict()对没有name的子组不起作用 正则表达式对象 re.search(string[, pos[, endpos]]) 扫描字符串string,查找与正则表达式匹配的位置。如果找到一个匹配就返回一个MatchObject对象(并不会匹配所有的)。如果没有找到那么返回None。 第二个参数表示从字符串的那个位置开始,默认是0 第三个参数endpos限定字符串最远被查找到哪里。默认值就是字符串的长度。. >>> m=re.search("abcd", '1abcd2abcd') >>> m.group() #找到即返回一个match object,然后根据该对象的方法,查找匹配到的结果。 'abcd' >>> m.start() 1 >>> m.end() 5 >>> re.findall("abcd","1abcd2abcd") ['abcd', 'abcd'] re.split(pattern, string[, maxsplit=0, flags=0]) 用pattern来拆分string。如果pattern有含有括号,那么在pattern中所有的组也会返回。 >>> re.split("\W+","words,words,works",1) ['words', 'words,works'] >>> re.split("[a-z]","0A3b9z",re.IGNORECASE) ['0A3', '9', ''] >>> re.split("[a-z]+","0A3b9z",re.IGNORECASE) ['0A3', '9', ''] >>> re.split("[a-zA-Z]+","0A3b9z") ['0', '3', '9', ''] >>> re.split('[a-f]+', '0a3B9', re.IGNORECASE)#re.IGNORECASE用来忽略pattern中的大小写。 ['0', '3B9'] 如果在split的时候捕获了组,并且匹配字符串的开始,那么返回的结果将会以一个空串开始。 >>> re.split('(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', ''] >>> re.split('(\W+)', 'words, words...') ['words', ', ', 'words', '...', ''] re.findall(pattern, string[, flags]) 以list的形式返回string中所有与pattern匹配的不重叠的字符串。String从左向右扫描,匹配的返回结果也是以这个顺序。 Return all non-overlapping matches of pattern in string, as a list of strings. The string is scanned left-to-right, and matches are returned in the order found. If one or more groups are present in the pattern, return a list of groups; this will be a list of tuples if the pattern has more than one group. Empty matches are included in the result unless they touch the beginning of another match. >>> re.findall('(\W+)', 'words, words...') [', ', '...'] >>> re.findall('(\W+)d', 'words, words...d') ['...'] >>> re.findall('(\W+)d', '...dwords, words...d') ['...', '...'] re.finditer(pattern, string[, flags]) 与findall类似,只不过是返回list,而是返回了一个叠代器 我们来看一个sub和subn的例子 >>> re.sub("\d","abc1def2hijk","RE") 'RE' >>> x=re.sub("\d","abc1def2hijk","RE") >>> x 'RE' >>> re.sub("\d","RE","abc1def2hijk",) 'abcREdefREhijk' >>> re.subn("\d","RE","abc1def2hijk",) ('abcREdefREhijk', 2) 通过例子我们可以看出sub和subn的差别:sub返回替换后的字符串,而subn返回由替换后的字符串以及替换的个数组成的元组。 re.sub(pattern, repl, string[, count, flags]) 用repl替换字符串string中的pattern。如果pattern没有匹配到,那么返回的字符串没有变化]。Repl可以是一个字符串,也可以是 一个function。如果是字符串,如果repl是个方法/函数。对于所有的pattern匹配到。他都回调用这个方法/函数。这个函数和方法使用单个 match object作为参数,然后返回替换后的字符串。下面是官网提供的例子: >>> def dashrepl(matchobj): ... if matchobj.group(0) == '-': return ' ' ... else: retu
5、time模块
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import time 2 #1、时间戳 1970年1月1日之后的秒 3 #3、元组 包含了:年、日、星期等... time.struct_time 4 #4、格式化的字符串 2014-11-11 11:11 5 6 print time.time() 7 print time.mktime(time.localtime()) 8 9 print time.gmtime() #可加时间戳参数 10 print time.localtime() #可加时间戳参数 11 print time.strptime('2014-11-11', '%Y-%m-%d') 12 13 print time.strftime('%Y-%m-%d') #默认当前时间 14 print time.strftime('%Y-%m-%d',time.localtime()) #默认当前时间 15 print time.asctime() 16 print time.asctime(time.localtime()) 17 print time.ctime(time.time()) 18 19 import datetime 20 ''' 21 datetime.date:表示日期的类。常用的属性有year, month, day 22 datetime.time:表示时间的类。常用的属性有hour, minute, second, microsecond 23 datetime.datetime:表示日期时间 24 datetime.timedelta:表示时间间隔,即两个时间点之间的长度 25 timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]]) 26 strftime("%Y-%m-%d") 27 ''' 28 import datetime 29 print datetime.datetime.now() 30 print datetime.datetime.now() - datetime.timedelta(days=5)
6、sys系统模块
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 sys.argv 命令行参数List,第一个元素是程序本身路径 2 sys.exit(n) 退出程序,正常退出时exit(0) 3 sys.version 获取Python解释程序的版本信息 4 sys.maxint 最大的Int值 5 sys.maxunicode 最大的Unicode值 6 sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值 7 sys.platform 返回操作系统平台名称 8 sys.stdout.write('please:') 9 val = sys.stdin.readline()[:-1] 10 print val
7、os模块
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 2 os.chdir("dirname") 改变当前脚本工作目录;相当于shell下cd 3 os.curdir 返回当前目录: ('.') 4 os.pardir 获取当前目录的父目录字符串名:('..') 5 os.makedirs('dirname1/dirname2') 可生成多层递归目录 6 os.removedirs('dirname1') 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推 7 os.mkdir('dirname') 生成单级目录;相当于shell中mkdir dirname 8 os.rmdir('dirname') 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname 9 os.listdir('dirname') 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印 10 os.remove() 删除一个文件 11 os.rename("oldname","newname") 重命名文件/目录 12 os.stat('path/filename') 获取文件/目录信息 13 os.sep 输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/" 14 os.linesep 输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n" 15 os.pathsep 输出用于分割文件路径的字符串 16 os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' 17 os.system("bash command") 运行shell命令,直接显示 18 os.environ 获取系统环境变量 19 os.path.abspath(path) 返回path规范化的绝对路径 20 os.path.split(path) 将path分割成目录和文件名二元组返回 21 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 22 os.path.basename(path) 返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素 23 os.path.exists(path) 如果path存在,返回True;如果path不存在,返回False 24 os.path.isabs(path) 如果path是绝对路径,返回True 25 os.path.isfile(path) 如果path是一个存在的文件,返回True。否则返回False 26 os.path.isdir(path) 如果path是一个存在的目录,则返回True。否则返回False 27 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略 28 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 29 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间