19. Python脚本学习笔记十九标准库

19. Python脚本学习笔记十九标准库

本篇名言：“人生是条无名的河，是深是浅都要过；人生是杯无色的酒，是苦是甜都要喝；人生是首无畏的歌，是高是低都要和。愿你轻松对待自己，微笑对待生活！”

1.  Sys库

Sys模块能让用户访问与解释器联系紧密的变量和函数。

                  变量sys.argv是传递到解释器的参数，包括脚本名称。

                  Sys.exit退出当前程序。

                  Sys.platform是显示当前解释器正在运行的平台名称。

                  Sys.stdin，sys.stdout,sys.stderr模块变量时类文件流对象。

                  可以通过上节的命令

                  >>>dir(sys)

来显示所有可执行的变量、函数。

 

2.  OS库

OS库提供了多个访问操作系统服务的功能。

常用命令如下：

如，system函数执行，如下，可以调用操作系统自带的计算机程序。

>>>os.system('calc.exe')

 

3.  fileinput

fileinput模块能轻松遍历文本文件的所有行，其中最重要的是fileinput.input函数。其他如下表：

书写程序如下：

import fileinput

 

for line in fileinput.input(inplace=True):

    line = line.rstrip()

    num  = fileinput.lineno()

    print '%-40s # %2i' %(line, num)

文件命名为numlines.py

注意其中的inplace=True，表示修改的内容直接生效到文件中。

然后执行 python numlines.py numlines.py

可以发现numlines.py文件在每行末尾加入了一个行号。

执行后如下：

import fileinput                        # 1

                                        #  2

for line in fileinput.input(inplace=True): #  3

    line = line.rstrip()                 #  4

    num = fileinput.lineno()            # 5

    print '%-40s # %2i' % (line, num)   #  6

4.  集合、堆和双端队列

4.1      集合

集合Set类，位于sets模块中。

集合又序列构建。集合元素的顺序是随意的。

集合提供一些操作，例如union合并，&,|等操作，如下示例：

例如：

>>> a=set([1,2,3])

>>> b=set([2,3,4])

>>> a.union(b)

set([1, 2, 3, 4])

>>> a|b

set([1, 2, 3, 4])

>>> a&b

set([2, 3])

>>> a.intersection(b)

set([2, 3])

>>> a.difference(b)

set([1])

>>> a-b

set([1])

>>> a^b

set([1, 4])

由于集合是可变的，所以不能用做字典中的键。

 

4.2      堆

Python 中并没有独立的堆类型，只有一个包含一些堆操作函数的模块，这个模块叫做heapq(q是队列queue的缩写)。包括6个函数如下：

>>>import heapq

>>>importrandom

>>> data=range(10)

>>> data

[0, 1, 2, 3, 4,5, 6, 7, 8, 9]

>>>random.shuffle(data)

 

>>> heap=[]

>>> for n in data:

...    heapq.heappush(heap,n)

...

>>> heap

[0, 1, 3, 4, 2, 5, 8, 7, 9, 6]

>>> heapq.heappop(heap)

0

>>> heapq.heappop(heap)

1

>>> heapq.heappop(heap)

2

>>> heapq.heappop(heap)

3

>>> heapq.heappop(heap)

4

>>> heapq.heappop(heap)

5

>>> heapq.heappop(heap)

6

>>> heapq.heappop(heap)

7

此外，可以使用该函数heapify来建立堆。

>>> heap=[5,8,0,3,6,7,1,4,2]

>>> heapq.heapify(heap)

 

4.3      队列

队列在需要按照元素增加的顺序来移除元素时非常有用。

>>> import collections

>>> q=collections.deque(range(5))

>>> q

deque([0, 1, 2, 3, 4])

>>> q.append(5)

>>> q

deque([0, 1, 2, 3, 4, 5])

>>> q.appendleft(6)

>>> q

deque([6, 0, 1, 2, 3, 4, 5])

>>> q.pop()

5

>>> q.popleft()

6

>>> q

deque([0, 1, 2, 3, 4])

>>> q.rotate(3)

>>> q

deque([2, 3, 4, 0, 1])

能够有效地旋转元素。

5.  time

time模块包括函数能够实现以下功能：获得当前时间、操作时间和日期、从字符串读取时间以及格式化时间为字符串。

重要函数如下：

时间相关的还有两个模块：datetime和timeit模块。

一个支持日期和时间的算法，一个帮助开发人员对代码段的执行时间进行计时。

 

6.  random

random模块包括返回随机数的函数，用于模拟或用于产生随机输出的程序。不过这产生的数字是伪随机数，如果需要真正的随机数就要使用OS模块的urandom函数。

        Random模块下的重要函数如下：

我们来看下示例，计算2008年到2009年之间的随机一个数

importrandom

importtime

fromtimeimport localtime,asctime

date1=(2008,1,1,0,0,0,-1,-1,-1)

time1=time.mktime(date1)

date2=(2009,1,1,0,0,0,-1,-1,-1)

time2=time.mktime(date2)

printtime1

printtime2

printrandom.uniform(time1,time2)

printasctime(localtime(random.uniform(time1,time2)))

继续看下如何实现KTV或者酒吧里面玩的扔骰子。输入几个骰子，每个骰子几个面，然后获得总点数。

 

importrandom

fromrandomimport randrange

num=input('how many dice?')

sides=input('how many sides per die?')

sum=0

for iin range(num):sum+=randrange(sides)+1

print'result is ', sum

输出如下：

howmany dice?6

howmany sides per die?6

resultis  27

当然，结果是随机的。

再来实现一个占星术的脚本，大家可以用来忽悠小伙伴

很简单实现一个脚本如下：

importrandom

importfileinput

fortures=list(fileinput.input())

printrandom.choice(fortures)

然后准备一个文件输入：

dodge

cat

great

bad

normal

hard

等等

然后调用并输出如下：

>>>python Chapter1.py future.txt

great

最后来看下实现一个随机发牌的脚本，这是比较适合牌类游戏。

importpprint

fromrandomimport shuffle

values=range(1,11)+'Jack Queen King'.split()

suits='diamondsclubs hearts spades'.split()

deck=['%sof %s' % (v,s)for vin valuesfor sin suits]

shuffle(deck)

pprint.pprint(deck)

最后输出如下：

['2 ofclubs',

 '1 of clubs',

 '9 of hearts',

 '5 of clubs',

 'King of hearts',

 'Queen of spades',

 '4 of clubs',

 '4 of diamonds',

 '10 of clubs',

 'Queen of clubs',

 '8 of clubs',

 '6 of clubs',

 '3 of clubs',

 'Jack of diamonds',

 '3 of diamonds',

 '2 of hearts',

 '6 of diamonds',

 '7 of clubs',

 '2 of spades',

 '1 of diamonds',

 '3 of spades',

 '4 of hearts',

 '8 of spades',

 '6 of spades',

 'Jack of spades',

 '7 of spades',

 'Jack of clubs',

 '9 of diamonds',

 '4 of spades',

 'Jack of hearts',

 '8 of hearts',

 '9 of spades',

 '5 of diamonds',

 'King of clubs',

 '7 of hearts',

 '6 of hearts',

 '10 of diamonds',

 '8 of diamonds',

 'Queen of diamonds',

 '2 of diamonds',

 'King of diamonds',

 '1 of hearts',

 '5 of spades',

 '10 of hearts',

 '5 of hearts',

 '3 of hearts',

 '9 of clubs',

 '7 of diamonds',

 'Queen of hearts',

 '1 of spades',

 'King of spades',

 '10 of spades']

 

 

7.  shelve

我们来看下文件中存储数据。可以满足简单的存储方案。其中常用的函数是open和close. Open函数返回一个self对象，用来存储内容。

示例如下：

>>> import shelve

>>> s=shelve.open('test.dat')

>>> s['x']=['a','b','c']

>>> s['x'].append('d')

>>> s['x']

['a', 'b', 'c']

并没有d，其实d值个时候并还没有保存到文件中，被缓存了。

可以用临时变量绑定到获得的副本上。如下：

>>> s['x']

['a', 'b', 'c']

>>> temp=s['x']

>>> temp.append('d')

>>> s['x']=temp

>>> s['x']

['a', 'b', 'c', 'd']

我们来看下长一点的使用shelve模块的数据库应用程序：

importshelve

 

defstore_person(db):

   """

    Query user for data and store it in theshelf object

    """

   pid = raw_input('Enter unique ID number:')

   person = {}

   person['name']  = raw_input('Entername: ')

   person['age']  = raw_input('Enterage: ')

   person['phone'] = raw_input('Enter phone number: ')

 

   db[pid] = person

 

deflookup_person(db):

   """

    Query user for ID and desired field, andfetch the corresponding data from

    the shelf object

    """

   pid = raw_input('Enter ID number: ')

   field = raw_input('What would you like toknow? (name, age, phone)  ')

   field = field.strip().lower()

   printfield.capitalize() +':', \

          db[pid][field]

 

defprint_help():

   print'The available commands are:'

   print'store  : Stores information about aperson'

   print'lookup : Looks up a person from ID number'

   print'quit   : Save changes and exit'

   print'?      : Prints this message'

 

defenter_command():

   cmd = raw_input('Enter command (? forhelp): ')

   cmd = cmd.strip().lower()

   return cmd

 

defmain():

   database = shelve.open('database.dat')# You may want to change this name

   try:

        whileTrue:

            cmd = enter_command()

            if   cmd =='store':

                store_person(database)

            elif cmd =='lookup':

                lookup_person(database)

            elif cmd =='?':

                print_help()

            elif cmd =='quit':

                return

   finally:

        database.close()

 

if __name__ =='__main__': main()

所有内容都放到函数中了，程序显得更加结构化。主程序放在main函数中，当__name__=’__main__’的时候才被调用。可以再其他程序中将这个程序作为模块导入，然后调用main.

在main函数中打开数据库并将其作为参数传递给另外需要的函数。使用try防止出现异常而破坏数据文件。

Enter_command()函数去除两边空格，并使输入转成小写字母。

                  输入接收：store,lookup,?,quit。

分别调用函数：store_person, lookup_person, print_help, 退出程序。

进行交互如下：

Entercommand (? for help): ?

Theavailable commands are:

store  : Stores information about a person

lookup: Looks up a person from ID number

quit   : Save changes and exit

?      : Prints this message

Entercommand (? for help): de

Entercommand (? for help): store

Enterunique ID number: 1

Entername: toad

Enterage: 20

Enterphone number: 1234567

Entercommand (? for help): lookup

EnterID number: 1

Whatwould you like to know? (name, age, phone) name

Name:toad

Enter command(? for help):

                  好奇心驱使，我们看看此时的数据文件时啥东西？

                  并不能直接看到我们存入的字符串和数字，看来这个数据文件是一个自己的格式存放的，这样我们就放心的，不会因为坏人拿到就直接就知道信息了。

 

8.  re

我们来看下Python中正则表达式模块，关于正则表达式，之前没用过的小伙伴也可以看看正则表达式的强大之处。关于正则表达式的内容蛤蟆在此不再展开，需要了解的朋友可以自行学习之。

Re模块中的重要函数如下：

来看下几个示例：

import re

from macpath import split

some_text='alpha, beta.... gamma delta'

print some_text.split('.')

print re.split('[. ]+',some_text)

一般的split允许使用字符串’.’ 匹配项来分割，然是正则表达式则高级的多了，不管多少个’.’

输出如下：

['alpha,beta', '', '', '', ' gamma delta']

['alpha,','beta', 'gamma', 'delta']                 

接着使用如下：

>>> pat='[a-zA-Z]+'

>>> text='"Hm...Err...are yousure?" he said, sounding insecure.'

>>> import re

>>> re.findall(pat,text)

['Hm', 'Err', 'are', 'you', 'sure', 'he','said', 'sounding', 'insecure']

                  其他函数大家可以自己去试验。

正则表示内容复杂难懂，建议大家在需要使用给定时候多查查命令，慢慢积累。

精通任何程序设计语言的最佳方法是实践，测试它的限制，探索它的威力。