eclipse配置python运行环境_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环境变量是否设置成功

C:\Users\jiqinlin>python

Python2.7.6 (default, Nov 10 2013, 19:24:24) [MSC v.1500 64bit (AMD64)] on win32Type"help", "copyright", "credits" or "license" formore information.>>>

python test

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__’

Py1.py#！/usr/bin/env python

deftest():print '__name__ =',__name__

if __name__ == '__main__':

test()

Py2.py#！/usr/bin/env python

importPy1.pydeftest():print '__name__ =',__name__

if __name__ == '__main__':

test()print ‘Py1.py __name__ = ’,Py1.__name__

__name__

执行结果：

__name__=__main__

Py1.py __name__=Py1

通过结果可以知道，Py2.py直接执行，那么内建变量__name__的值为__main__，否则为模块的名字，通过这个特性可以在if语句里面添加测试代码，可以提高减少BUG，提高程序的健壮性。

if __name__ == '__main__':

test()

__file__

用__file__ 来获得脚本所在的路径是比较方便的，但这可能得到的是一个相对路径，比如在脚本test.py中写入：

#!/usr/bin/env python

print __file__

按相对路径./test.py来执行，则打印得到的是相对路径，

按绝对路径执行则得到的是绝对路径。

而按用户目录来执行（~/practice/test.py），则得到的也是绝对路径（~被展开）

所以为了得到绝对路径，我们需要 os.path.realpath(__file__)。

__doc__

显示当前文件的描述信息

#!/usr/local/bin/python#coding:utf8#'''这是python文件注释信息！'''

print __doc__输出结果：#python py_doc.py

这是python文件注释信息！

__doc__

三、函数参数与返回值

#!/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 去 游泳 和 泡妞

View Code

*args

#!/usr/local/bin/python#coding:utf8#可变传参

def show(*arg): #可变列表

for item inarg:printitem

show(1,2,3,4,5,6) #以列表形式传参

def show1(**kargs): #可变字典传参

for item in kargs.items(): #接受字典两个值

printitem

show1(name='zhangsan',age = '222',jos='888')

输出：1

2

3

4

5

6('age', '222')

('jos', '888')

('name', 'zhangsan')

**Kargs

四、yield和lambda表达式

yield关键字用来定义生成器（Generator），其具体功能是可以当return使用，从函数里返回一个值，不同之处是用yield返回之后，可以让函数从上回yield返回的地点继续执行。也就是说，yield返回函数，交给调用者一个返回值，然后再“瞬移”回去，让函数继续运行， 直到吓一跳yield语句再返回一个新的值。

#!/usr/local/bin/python#yield#

deffoo():yield 1 #当执行完yield 1后函数不会往下执行

yield 2

yield 3

yield 4

for i in foo(): #执行循环打印yield 1,然后继续执行函数直到遇到下一个 yield然后跳出函数进入循环打印，值得没有yield结束。

printi

输出：1

2

3

4

View Code

在python中使用lambda来创建匿名函数，而用def创建的方法是有名称的

1 python lambda会创建一个函数对象，但不会把这个函数对象赋给一个标识符，而def则会把函数对象赋值给一个变量。

2 python lambda它只是一个表达式，而def则是一个语句。

a = lambda x,y:x+yprint a(2,4)

结果：6m= lambda x,y,z: (x-y)*zprint m(3,1,2)

结果是4

lambda

五、内置函数

#print help() #帮助信息

print dir() #获得当前模块的属性列表

print vars() #默认打印当前模块的所有属性，如果传一个对象参数则打印当前对象的属性#print type() #打印对象的类型

import temp #导入模块

importtemp

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):printifor k,v in enumerate([1,2,3,4]): #添加索引打印

printk,v------------------s= 'i am {0}'

print s.format('alex') #传值到变量

str(1) #用于将值转化为适于人阅读的形式

------------------

def Function(arg): #函数传参数

printargprint 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]printzip(x, y,z)------------------

#__import__()#hasattr()#delattr()#getattr()

module = __import__('temp')printdir(module)

val= hasattr(module, 'version')printval------------------

#callable()

#函数、类必须要有 __call__ 方法#compile#eval

com = compile('1+1','','eval')printeval(com)#exec语句

code = "for i in range(0, 10): print i"cmpcode= compile(code, '', 'exec')execcmpcode

code= "print 1"cmpcode= compile(code, '', 'single')execcmpcode------------------

#isinstance()#issubclass()#super()#staticmethod()

View Code

六、常用模块

1、random用于生成随机数

importrandomprint random.random() #生成1以下的随机数

print random.randint(1,2) #生成1到2直接的随机整数

print random.randrange(1,10,2) #生成指定基数的随机整数

列：随机生成4位数的验证码#!/usr/local/bin/python

importrandom

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加密

importmd5

hash=md5.new()

hash.update('admin')printhash.hexdigest()import hashlib #hash加密

hash =hashlib.md5()

hash.update('admin')print hash.hexdigest()

MD5

3、序列化和json

importpickle

data= {'k1':123,'k2':'hello'}

p_str=pickle.dumps(data)printp_str#将数据通过特殊的形式转换为只有python语言人认识的字符串

with open('D:/re.pk','w') as fp:

pickle.dump(data,fp)#将数据通过特殊的形式转换为只有python语音认识的字符串，并写入文件

importjson

j_str=json.dumps(data)printj_str#将数据通过特殊的形式转换为所有程序语言都认识的字符串

with open('D:/re.json','w') as fp:

json.dump(data,fp)#将数据通过特殊的形式转换为所以程序语言都认识的字符串，并写入文件

4、re正则表达式模块

正则表达式的元字符有. ^ $ * ? { [ ] |( )

．表示任意字符

［］用来匹配一个指定的字符类别，所谓的字符类别就是你想匹配的一个字符集，对于字符集中的字符可以理解成或的关系。^ 如果放在字符串的开头，则表示取非的意思。[^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")>>> printm

None>>> m=re.search("ab+","asdfabbbb")>>> printm<_sre.SRE_Match object at 0x011B1988>

>>> printm.group()

abbbb

上例不能用re.match,因为match匹配字符串的开始，我们无法验证元字符"^"是否代表字符串的开始位置。>>> m=re.match("^ab+","asdfabbbb")>>> printm

None>>> m=re.match("ab+","asdfabbbb")>>> printm

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 inMULTILINE 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或者B9.元字符({})

{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),(?PREs),这是无名称的组和有名称的group，有名称的group，可以通过matchObject.group(name)

获取匹配的group，而无名称的group可以通过从1开始的group序号来获取匹配的组，如matchObject.group(1)。具体应用将在下面的group()方法中举例讲解11．元字符(.)

元字符“.”在默认模式下，匹配除换行符外的所有字符。在DOTALL模式下，匹配所有字符，包括换行符。>>> importre>>> re.match(".","\n")>>> m=re.match(".","\n")>>> printm

None>>> m=re.match(".","\n",re.DOTALL)>>> printm<_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\w+) (?P\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"", line 1, in m.group(1)

IndexError: no such group

If a group matches multiple times, only the last matchisaccessible:

如果一个组匹配多个，那么仅仅返回匹配的最后一个的。>>> 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)>>> printm

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\w+) (?P\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 inthe 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作为参数，然后返回替换后的字符串。下面是官网提供的例子:>>> defdashrepl(matchobj):

...if matchobj.group(0) == '-': return ' '...else: retu

View Code

5、time模块

1 importtime2 #1、时间戳 1970年1月1日之后的秒

3 #3、元组 包含了：年、日、星期等... time.struct_time

4 #4、格式化的字符串 2014-11-11 11:11

5

6 printtime.time()7 printtime.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 printtime.asctime()16 printtime.asctime(time.localtime())17 printtime.ctime(time.time())18

19 importdatetime20 '''

21 datetime.date：表示日期的类。常用的属性有year, month, day22 datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond23 datetime.datetime：表示日期时间24 datetime.timedelta：表示时间间隔，即两个时间点之间的长度25 timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])26 strftime("%Y-%m-%d")27 '''

28 importdatetime29 printdatetime.datetime.now()30 print datetime.datetime.now() - datetime.timedelta(days=5)

View Code

6、sys系统模块

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

View Code

7、os模块

1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径2 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd3 os.curdir 返回当前目录: ('.')4 os.pardir 获取当前目录的父目录字符串名：('..')5 os.makedirs('dirname1/dirname2') 可生成多层递归目录6 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推7 os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname8 os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname9 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不存在，返回False24 os.path.isabs(path) 如果path是绝对路径，返回True25 os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False26 os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False27 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略28 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间29 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

View Code