进击的Python【第五章】:Python的高级应用(二)常用模块

时间:2022-03-26 09:00:11

Python的高级应用(二)常用模块学习

本章学习要点:

  1. Python模块的定义
  2. time &datetime模块
  3. random模块
  4. os模块
  5. sys模块
  6. shutil模块
  7. ConfigParser模块
  8. shelve模块
  9. xml处理
  10. re正则表达式

一、Python模块的定义

  有过C语言编程经验的朋友都知道在C语言中如果要引用sqrt这个函数,必须用语句"#include<math.h>"引入math.h这个头文件,否则是无法正常进行调用的。那么在Python中,如果要引用一些内置的函数,该怎么处理呢?在Python中有一个概念叫做模块(module),这个和C语言中的头文件以及Java中的包很类似,比如在Python中要调用sqrt函数,必须用import关键字引入math这个模块,下面就来了解一下Python中的模块。

模块分为三种

  • 自定义模块
  • 内置标准模块(又称标准库)
  • 开源模块

模块的调用

  在Python中用关键字import来引入某个模块,比如要引用模块math,就可以在文件最开始的地方用import math来引入。在调用math模块中的函数时,必须这样引用:

模块名.函数名

  为什么必须加上模块名这样调用呢?因为可能存在这样一种情况:在多个模块中含有相同名称的函数,此时如果只是通过函数名来调用,解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候,调用函数必须加上模块名。

  有时候我们只需要用到模块中的某个函数,只需要引入该函数即可,此时可以通过语句

from 模块名 import 函数名1,函数名2....

自定义模块

  在Python中,每个Python文件都可以作为一个模块,模块的名字就是文件的名字。

  比如有这样一个文件test.py,在test.py中定义了函数add:

#test.py

def add(a,b):
return a+b

  那么在其他文件中就可以先import test,然后通过test.add(a,b)来调用了,当然也可以通过from test import add来引入。

在引入模块的时候发生了什么

  先看一个例子,在文件test.py中的代码:

#test.py

def display():
print 'hello world' display()

  在test1.py中引入模块test:

#test1.py

import test

  然后运行test1.py,会输出"hello world"。也就是说在用import引入模块时,会将引入的模块文件中的代码执行一次。但是注意,只在第一次引入时才会执行模块文件中的代码,因为只在第一次引入时进行加载,这样做很容易理解,不仅可以节约时间还可以节约内存。

二、time &datetime模块

time模块方法:
time.time():获取当前时间的时间戳

time.localtime():接受一个时间戳,并把它转化为一个当前时间的元组。不给参数的话就会默认将time.time()作为参数传入

time.localtime():
索引 属性 含义
0 tm_year
1 tm_mon
2 tm_mday
3 tm_hour
4 tm_min
5 tm_sec
6 tm_wday 一周中的第几天
7 tm_yday 一年中的第几天
8 tm_isdst 夏令时
  1. time.mktime():和time.localtime()相反,它把一个时间元组转换成时间戳(这个必须要给一个参数)
  2. time.asctime():把一个时间元组表示为:“Sun Jul 28 03:35:26 2013”这种格式,不给参数的话就会默认将time.localtime()作为参数传入
  3. time.ctime():把一个时间戳转换为time.asctime()的表达格式,不给参数的话就会默认将time.time()作为参数传入
  4. time.gmtime():将一个时间戳转换为UTC+0时区(中国应该是+8时区,相差8个小时)的时间元组,不给参数的话就会默认将time.time()作为参数传入
  5. time.strftime(format,time.localtime()):将一个时间元组转换为格式化的时间字符,不给时间元组参数的话就会默认将time.localtime()作为参数传入

例如web日志里面的时间格式就是time.strftime('%d/%b/%Y:%X')

返回结果:

>>> time.strftime('%d/%b/%Y:%X')
'21/Aug/2016:20:06:56'

format:

属性 格式 含义 取值范围(格式)
年份 %y 去掉世纪的年份 00-99
%Y 完整的年份  
%j 一年中的第几天 001-366
月份 %m 月份 1月12日
%b 本地简化月份的名称 简写英文月份
%B 本地完整月份的名称 完整英文月份
日期 %d 一个月中的第几天 1月31日
小时 %H 一天中的第几个小时(24小时制) 00-23
%l 第几个小时(12小时制) “01-12”
分钟 %M 分钟数 00-59
%S 00-59
星期 %U 一年中的星期数(从星期天开始算) 00-53
%W 一年中的星期数(从星期一开始算)  
%w 一个星期的第几天 0-6
时区 %Z 中国:应该是GMT+8(中国标准时间) 求大神扫盲
其他 %x 本地相应日期 日/月/年
%X 本地相印时间 时:分:秒
%c 详细日期时间 日/月/年 时:分:秒
%% ‘%'字符 ‘%'字符
%p 本地am或者pm的相应符 AM    or    PM

time.strptime(stringtime,format):将时间字符串根据指定的格式化符转换成数组形式的时间,
例如:

>>> time.strptime('21/Aug/2016:20:06:56', '%d/%b/%Y:%X')
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=20, tm_min=6, tm_sec=56, tm_wday=6, tm_yday=234, tm_isdst=-1)

time.clock():返回处理器时钟时间,一般用于性能测试和基准测试等,因为他们反映了程序使用的实际时间,平常用不到这个。

time.sleep():推迟指定的时间运行,单位为秒

import time
print(time.time()) #打印时间戳
print(time.localtime())#打印本地时间元组
print(time.gmtime())#答应UTC+0时区的时间元组
print(time.ctime())#打印asctime格式化时间
print(time.mktime(time.localtime()))#将时间元组转换为时间戳
print(time.asctime())#打印格式化时间
print(time.strftime('%d/%b/%Y:%X'))#打印指定格式的时间格式
#把时间字符串和它的格式翻译成时间元组
print(time.strptime('21/Aug/2016:20:06:56', '%d/%b/%Y:%X'))
print('%0.5f'%time.clock()) #打印处理器时间
for i in range(100000):
pass
print('%0.5f'%time.clock())#打印处理器时间

结果:

1471781504.4066072
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=20, tm_min=11, tm_sec=44, tm_wday=6, tm_yday=234, tm_isdst=0)
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=12, tm_min=11, tm_sec=44, tm_wday=6, tm_yday=234, tm_isdst=0)
Sun Aug 21 20:11:44 2016
1471781504.0
Sun Aug 21 20:11:44 2016
21/Aug/2016:20:11:44
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=20, tm_min=6, tm_sec=56, tm_wday=6, tm_yday=234, tm_isdst=-1)
0.00000
0.00337

datetime模块
  datetime.time():生成一个时间对象。这个时间可以由我们来设置,默认都是0(这个类只针对时间)

#coding:utf-8
import datetime
print datetime.time()
t = datetime.time(1, 3, 5, 25)
print t
print t.hour #时
print t.minute #分
print t.second #秒
print t.microsecond #毫秒
print datetime.time.max #一天的结束时间
print datetime.time.min #一天的开始时间

结果:

00:00:00
01:03:05.000025 23:59:59.999999
00:00:00

  datetime.date():生成一个日期对象。这个日期要由我们来设置,(这个类只针对日期)

import datetime
#设置日期
t = datetime.date(2016, 8, 21)
#打印设置日期的和元组
print(t.timetuple())#日期元组
print(t)
print(t.year) #年
print(t.month) #月
print(t.day) #日
#获取今天的日期
today = datetime.date.today()
print(today)
print(datetime.datetime.now())#这个打印到毫秒级别
#获取今天日期的元组
t1 = today.timetuple()
print(t1)
#打印成ctime格式(time.ctime()格式)
#'%a %b %d %H:%M:%S %Y'
print(t.ctime())
print(today.ctime()

  结果:

time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=234, tm_isdst=-1)
2016-08-21
2016
8
21
2016-08-21
2016-08-21 20:18:10.550607
time.struct_time(tm_year=2016, tm_mon=8, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=234, tm_isdst=-1)
Sun Aug 21 00:00:00 2016
Sun Aug 21 00:00:00 2016

三、random模块

  获取一个小于1的浮点数

>>> import random
>>> print(random.random())
0.958520379647631

  获取一个从1到10的整数

>>> print(random.randint(1,10))
5

  获取一个大于0小于2的浮点数

>>> print(random.uniform(0,2))
1.6072811216275604

  获取一个从1到10步长为4的随机数

>>> print(random.randrange(1,10,4))
9

  从列表a中以随机顺序取出3个元素(一个元素只能取出一次,所以取出的个数不能大于列表所含元素的个数)

>>> a=[1,2,3,4,5]
>>> print(random.sample(a,3))
[5, 2, 1]

四、OS模块

一、os模块概述

Python os模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话,这个模块是尤为重要的。(一语中的)

二、常用方法

1、os.name

输出字符串指示正在使用的平台。如果是window 则用'nt'表示,对于Linux/Unix用户,它是'posix'。

2、os.getcwd()

函数得到当前工作目录,即当前Python脚本工作的目录路径。

3、os.listdir()

返回指定目录下的所有文件和目录名。

>>> import os
>>> os.listdir(os.getcwd())
['.idea', 'day01', 'day02', 'day02_note', 'day03', 'day04', 'day04_atm', 'day05']

4、os.remove()

删除一个文件。

5、os.system()

运行shell命令。

>>> os.system('dir')
0
>>> os.system('cmd') #启动dos

6、os.sep 可以取代操作系统特定的路径分割符。

7、os.linesep字符串给出当前平台使用的行终止符

>>> os.linesep
'\r\n' #Windows使用'\r\n',Linux使用'\n'而Mac使用'\r'。
>>> os.sep
'\\' #Windows
>>>

8、os.path.split()

函数返回一个路径的目录名和文件名

>>> os.path.split('C:\\Python35\\abc.txt')
('C:\\Python35', 'abc.txt')

9、os.path.isfile()和os.path.isdir()函数分别检验给出的路径是一个文件还是目录。

>>> os.path.isdir(os.getcwd())
True
>>> os.path.isfile('a.txt')
False

10、os.path.exists()函数用来检验给出的路径是否真地存在

>>> os.path.exists('C:\\Python25\\abc.txt')
False
>>> os.path.exists('C:\\Python25')
True
>>>

11、os.path.abspath(name):获得绝对路径

12、os.path.normpath(path):规范path字符串形式

13、os.path.getsize(name):获得文件大小,如果name是目录返回0L

14、os.path.splitext():分离文件名与扩展名

>>> os.path.splitext('a.txt')
('a', '.txt')

15、os.path.join(path,name):连接目录与文件名或目录

>>> os.path.join('c:\\Python','a.txt')
'c:\\Python\\a.txt'
>>> os.path.join('c:\\Python','f1')
'c:\\Python\\f1'
>>>

16、os.path.basename(path):返回文件名

>>> os.path.basename('a.txt')
'a.txt'
>>> os.path.basename('c:\\Python\\a.txt')
'a.txt'
>>>

17、os.path.dirname(path):返回文件路径

>>> os.path.dirname('c:\\Python\\a.txt')
'c:\\Python'

五、sys模块

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n) 退出程序,正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]

六、shutil模块

七、ConfigParser模块

用于生成和修改常见配置文档,当前模块的名称在 python 3.x 版本中变更为 configparser

Linux的配置文件基本都是下面的格式,怎么用Python生成下面的配置文件呢?

[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes [bitbucket.org]
User = hg [topsecret.server.com]
Port = 50022
ForwardX11 = no

用ConfigParser模块即可

import configparser

config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'} config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = '50022' # mutates the parser
topsecret['ForwardX11'] = 'no' # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
config.write(configfile)

八、shelve 模块

shelve是一个简单的数据存储方案,他只有一个函数就是open(),这个函数接收一个参数就是文件名,然后返回一个shelf对象,你可以用他来存储东西,就可以简单的把他当作一个字典,当你存储完毕的时候,就调用close函数来关闭

import shelve

d = shelve.open('shelve_test') #打开一个文件

class Test(object):
def __init__(self,n):
self.n = n t = Test(123)
t2 = Test(123334) name = ["alex","rain","test"]
d["test"] = name #持久化列表
d["t1"] = t #持久化类
d["t2"] = t2 d.close()

九、XML文件处理

什么是xml?

xml即可扩展标记语言,它可以用来标记数据、定义数据类型,是一种允许用户对自己的标记语言进行定义的源语言。

解析的xml文件(country.xml):

<?xml version="1.0"?>
<data>
<country name="Singapore">
<rank>4</rank>
<year>2011</year>
<gdppc>59900</gdppc>
<neighbor name="Malaysia" direction="N"/>
</country>
<country name="Panama">
<rank>68</rank>
<year>2011</year>
<gdppc>13600</gdppc>
<neighbor name="Costa Rica" direction="W"/>
<neighbor name="Colombia" direction="E"/>
</country>
</data>

使用xml.etree.ElementTree处理XML

  ElementTree生来就是为了处理XML,它在Python标准库中有两种实现:一种是纯Python实现的,如xml.etree.ElementTree,另一种是速度快一点的xml.etree.cElementTree。注意:尽量使用C语言实现的那种,因为它速度更快,而且消耗的内存更少。

#!/usr/bin/evn python
#coding:utf-8 try:
import xml.etree.cElementTree as ET
except ImportError:
import xml.etree.ElementTree as ET
import sys try:
tree = ET.parse("country.xml") #打开xml文档
#root = ET.fromstring(country_string) #从字符串传递xml
root = tree.getroot() #获得root节点
except Exception, e:
print("Error:cannot parse file:country.xml.")
sys.exit(1)
print(root.tag, "---", root.attrib)
for child in root:
print(child.tag, "---", child.attrib) print("*"*10)
print(root[0][1].text) #通过下标访问
print(root[0].tag, root[0].text)
print("*"*10) for country in root.findall('country'): #找到root节点下的所有country节点
rank = country.find('rank').text #子节点下节点rank的值
name = country.get('name') #子节点下属性name的值
print(name, rank) #修改xml文件
for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country) tree.write('output.xml')

创建XML文件

import xml.etree.ElementTree as ET

new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19' et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True) ET.dump(new_xml) #打印生成的格式

九、re正则表达式

常用的正则表达符号

'.'     默认匹配除\n之外的任意一个字符,若指定flag DOTALL,则匹配任意字符,包括换行
'^' 匹配字符开头,若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$' 匹配字符结尾,或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*' 匹配*号前的字符0次或多次,re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a']
'+' 匹配前一个字符1次或多次,re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?' 匹配前一个字符1次或0次
'{m}' 匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次,re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|' 匹配|左或|右的字符,re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配,re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c '\A' 只从字符开头匹配,re.search("\Aabc","alexabc") 是匹配不到的
'\Z' 匹配字符结尾,同$
'\d' 匹配数字0-9
'\D' 匹配非数字
'\w' 匹配[A-Za-z0-9]
'\W' 匹配非[A-Za-z0-9]
's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t' '(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

re的主要功能函数

常用的功能函数包括:compile、search、match、split、findall(finditer)、sub(subn)
compile
re.compile(pattern[, flags])
作用:把正则表达式语法转化成正则表达式对象
flags定义包括:
re.I:忽略大小写
re.L:表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M:多行模式
re.S:' . '并且包括换行符在内的任意字符(注意:' . '不包括换行符)
re.U: 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库

search
re.search(pattern, string[, flags])
search (string[, pos[, endpos]])
作用:在字符串中查找匹配正则表达式模式的位置,返回 MatchObject 的实例,如果没有找到匹配的位置,则返回 None。

match
re.match(pattern, string[, flags])
match(string[, pos[, endpos]])
作用:match() 函数只在字符串的开始位置尝试匹配正则表达式,也就是只报告从位置 0 开始的匹配情况,而 search() 函数是扫描整个字符串来查找匹配。如果想要搜索整个字符串来寻找匹配,应当用 search()。

下面是几个例子:

#!/usr/bin/env python
import re
r1 = re.compile(r'world')
if r1.match('helloworld'):
print 'match succeeds'
else:
print 'match fails'
if r1.search('helloworld'):
print 'search succeeds'
else:
print 'search fails'

说明一下:r是raw(原始)的意思。因为在表示字符串中有一些转义符,如表示回车'\n'。如果要表示\表需要写为'\\'。但如果我就是需要表示一个'\'+'n',不用r方式要写为:'\\n'。但使用r方式则为r'\n'这样清晰多了。