python自带笔记本电脑_Python内置常用模块

time和datatime

Range

os

sys

hashlib

XML

json & picle

1、time和datetime

time和datetime都是python处理时间和日期的内置模块。

1.1 time模块

time模块中时间表现的方式主要有三种：

1、timestamp：时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。

2、struct_time：时间元组，共有九个元素组。

3、format time ：格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。

在python中直接获取看下：

import time

# 直接获取timestamp

>>> time.time()

1560409102.4841187

# 直接获取struct_time

>>> time.localtime()

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=13, tm_hour=14, tm_min=59, tm_sec=0, tm_wday=3, tm_yday=164, tm_isdst=0)

# 直接获取format time

>>> time.strftime('%Y-%m-%d %X')

'2019-06-13 15:01:35'

time模块主要通过6种方法进行时间格式的转换，看图：

1.1.1 时间戳和时间元组转换

>>> import time

>>> t1 = time.time() # 获取时间戳并赋值

>>> time.localtime(t1) # 将时间戳转换为时间元组

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=13, tm_hour=16, tm_min=25, tm_sec=14, tm_wday=3, tm_yday=164, tm_isdst=0)

>>> t2 = time.localtime() # 获取时间元组并赋值

>>> time.mktime(t2) # 将时间元组转换为时间戳

1560414512.0

函数gmtime()的用法和localtime() 类似，localtime作用是格式化时间戳为本地的时间，gmtime()作用是格式化时间戳为格林尼治时间(世界标准时间UTC)。

1.1.2. 格式化时间和时间元组转换

time.strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定；time.strptime() 函数接收以格式化时间，并返回时间元组，语法如下：

time.strftime(format,t1)

time.strptime(t2,format)

参数说明：

format — 格式字符串。

t1 — 可选的参数t是一个struct_time对象

t2 — 可选的参数t是一个format time对象

>>> import time

>>> time.strftime('%Y-%m-%d %X',time.localtime())

'2019-06-13 17:26:55'

>>> time.strptime('2019-05-01 14:10:15','%Y-%m-%d %X')

time.struct_time(tm_year=2019, tm_mon=5, tm_mday=1, tm_hour=14, tm_min=10, tm_sec=15, tm_wday=2, tm_yday=121, tm_isdst=-1)

# 时间元组中属性及值

属性 值

tm_year(年) 比如2017

tm_mon(月) 1 - 12

tm_mday(日) 1 - 31

tm_hour(时) 0 - 23

tm_min(分) 0 - 59

tm_sec(秒) 0 - 61

tm_wday(weekday) 0 - 6(0表示周日)

tm_yday(一年中的第几天) 1 - 366

tm_isdst(是否是夏令时) 默认为-1(1:是;0:否;-1:未知)

格式化时间中格式对应属性

%Y 年 Year with century as a decimal number.

%m 月 Month as a decimal number [01,12].

%d 日 Day of the month as a decimal number [01,31].

%H 时 Hour (24-hour clock) as a decimal number [00,23].

%M 分 Minute as a decimal number [00,59].

%S 秒 Second as a decimal number [00,61].

%z Time zone offset from UTC.

%a 周几简写(英文Sun) Locale's abbreviated weekday name.

%A 周几全名(英文Sunday) Locale's full weekday name.

%b 月份简写(英语Apr) Locale's abbreviated month name.

%B 月份全名(英语April) Locale's full month name.

%c Locale's appropriate date and time representation.

%I 十二小时制小时数 Hour (12-hour clock) as a decimal number [01,12].

%p AM/PM Locale's equivalent of either AM or PM.

%X 本地相应时间

%x 本地相应日期

1.1.3. 还有2种转换

因为格式化的时间字符串可读性很高，所以有时需要将时间戳或时间元组转换为格式化时间：

time.ctime() 函数把一个时间戳(按秒计算的浮点数)转化为格式化时间的形式。 如果参数未给或者为None的时候，将会默认time.time()为参数，

time.asctime()如果参数未给或者为None的时候，将会默认time.localtime()为参数。

>>> import time

>>> time.ctime(1187640983) # 传入一个时间戳

'Tue Aug 21 04:16:23 2007'

>>> time.asctime() # 默认time.localtime()为参数

'Thu Jun 13 18:05:58 2019'

>>> time.asctime(time.localtime())

'Thu Jun 13 18:06:37 2019'

另外还有time.sleep()方法推迟调用程序的运行。

1.2 datetime模块

datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。

这里就只看一下datetime和timedelta类：

datetime.today()：返回一个表示当前本地时间的datetime对象；

datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；

datetime.utcnow()：返回一个当前utc时间的datetime对象；格林尼治时间

datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；

datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；格林尼治时间

datetime.combine(date, time)：参数是datetime.datetime类的对象、datetime.date对象、datetime.time对象，得到一个datetime.datetime对象；

datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

方法和属性

dt=datetime.datetime.now()     #datetime对象

dt.year、month、day、hour、minute、second、microsecond、tzinfo：

dt.date()：获取date对象；

dt.time()：获取time对象；

dt. replace ([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])：

dt. timetuple ()

dt. utctimetuple ()

dt. toordinal ()

dt. weekday ()

dt. isocalendar ()

dt. isoformat ([ sep] )

dt. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；

dt. strftime (format)

datetime加减

对日期和时间进行加减实际上就是把datetime往后或往前计算，得到新的datetime。加减可以直接用+和-运算符，不过需要导入timedelta这个类：

>>> from datetime import datetime, timedelta

>>> now = datetime.now()

>>> now

datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)

>>> now + timedelta(hours=10)

datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)

>>> now - timedelta(days=1)

datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)

>>> now + timedelta(days=2, hours=12)

datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)

时区转换

我们可以先通过utcnow()拿到当前的UTC时间，再转换为任意时区的时间：

# 拿到UTC时间，并强制设置时区为UTC+0:00:

>>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc)

>>> print(utc_dt)

2015-05-18 09:05:12.377316+00:00

# astimezone()将转换时区为北京时间:

>>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8)))

>>> print(bj_dt)

2015-05-18 17:05:12.377316+08:00

# astimezone()将转换时区为东京时间:

>>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9)))

>>> print(tokyo_dt)

2015-05-18 18:05:12.377316+09:00

# astimezone()将bj_dt转换时区为东京时间:

>>> tokyo_dt2 = bj_dt.astimezone(timezone(timedelta(hours=9)))

>>> print(tokyo_dt2)

2015-05-18 18:05:12.377316+09:00

时区转换的关键在于，拿到一个datetime时，要获知其正确的时区，然后强制设置时区，作为基准时间。

利用带时区的datetime通过astimezone()方法，可以转换到任意时区。

注：不是必须从UTC+0:00时区转换到其他时区，任何带时区的datetime都可以正确转换，例如上述bj_dt到tokyo_dt的转换。

2、random模块

Python中的random模块用于生成随机数。下面介绍一下random模块中最常用的几个方法：

import random

1. random.random() # 用于生成一个0到1的随机浮点数：0<= n < 1.0

>>> random.random()

0.9646844371759081

2. random.uniform(a,b) # 用于生成一个指定范围内的随机符点数n: a <= n <= b

>>> random.uniform(5,10)

6.584158762448463

3. random.randint(a,b) # 用于生成一个指定范围内的随机整数n: a <= n <= b

>>> random.randint(4,10)

6

4. random.randrange([start],stop,step) # 从指定范围内，按指定基数递增的集合中获取一个随机数

>>> random.randrange(10,18,3)

16

5. random.choice(sequence) # 从序列sequence中获取一个随机元素

>>> random.choice('hello world')

'r'

6. random.shuffle() # 用于将一个列表中的元素打乱,即将列表内的元素随机排列

>>> p=[1,2,3,4,5,6,7]

>>> random.shuffle(p)

>>> p

[5, 1, 6, 7, 4, 3, 2]

7. random.sample(sequence,k) # 从指定序列sequence中随机获取指定长度k的片断并随机排列。注意：sample函数不会修改原有序列。

>>> L = ['A','B','C',1,2,3]

>>> random.sample(L,3)

[3, 'B', 1]

>>> L

['A', 'B', 'C', 1, 2, 3]

3、OS模块

os模块提供了多数操作系统的功能接口函数。当os模块被导入后，它会自适应于不同的操作系统平台，根据不同的平台进行相应的操作，

在python编程时，经常和文件、目录打交道，所以离不了os模块。

os.getcwd() 获取当前工作的目录

os.chdir(path) 改变目录到指定path目录，注意windows标准路径分隔符为‘//’

os.makedirs('dirname1/dirname2') 可生成多层递归目录

os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname') 生成单级目录

os.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.environ 获取系统环境变量

os.path.abspath(path) 返回path规范化的绝对路径

os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

os.path.split(path) 将path分割成目录和文件名的二元组返回

os.path.splitext(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.getatime(path) 返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间

os.path.getsize(filename) 获取文件大小，目录返回0

还有

os.system() 用于运行外部程序

如web浏览器，在UNIX中，可以这样(找到浏览器位置)

os.system('/usr/bin/firefox')

在Windows中，可以这样(同样，找到浏览器位置)

os.system(r'C:\"Program Files (x86)"\"Mozilla Firefox"\firefox.exe')

注意，这里用引号将Program Files (x86)和Mozilla Firefox括起来了。如果不这样做，底层的shell将受阻与空白处，而且这里必须用反斜杠。

os.startfile() Windows特有的函数，同system，而且略微比system好用

os.system(r'C:\Program Files (x86)\Mozilla Firefox\firefox.exe')

os.startfile接受一个普通路径，即便有空白也没有关系

实际操作后发现后者比前者好用(Windows)，不光是空白原因。

View Code

4、sys模块

sys.argv 命令行参数，包括脚本名

sys.exit([arg]) 退出当前程序，可通过可选参数指定返回值或错误消息

sys.path 返回一个列表，包含模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform 返回操作系统平台名称

sys.version 获取Python解释程序的版本信息

sys.stdin 标准输入流 —— 一个类似于文件的对象

sys.stdout 标准输出流 —— 一个类似于文件的对象

sys.stderr 标准错误流 —— 一个类似于文件的对象

关于sys.argv

# 解释为：命令行参数，包括脚本(程序本身)名

# sys.argv[]说白了就是一个从程序外部获取参数的桥梁，这个“外部”很关键，因为我们从外部取得的参数可以是多个，所以获得的是一个列表(list)，

# 即sys.argv其实可以看作是一个列表，所以才能用[]提取其中的元素。其第一个元素是程序本身，随后才依次是外部给予的参数。

# 下面通过一个argv_test.py的例子看下：

# argv_test.py

import sys

a=sys.argv[0]

print(a)

# 然后命令行运行：python argv_test.py 得到如下结果

argv_test.py

# 这就是‘0’指程序本身

# 然后将0改成1，再运行一次，这次要加上一个参数：python argv_test.py hello 得到：

hello

# 那我们再把代码修改一下：a=sys.argv[2：]

# 保存后，再运行程序，这次多加几个参数，以空格隔开：python argv_test.py a b c d e f 得到：

['b', 'c', 'd', 'e']

# sys.argv[ ]其实就是一个列表，里边的项为用户输入的参数，关键就是要明白这参数是从程序外部输入的，

# 而非代码本身的什么地方，要想看到它的效果就应该将程序保存了，从外部来运行程序并给出参数。

View Code

5、hashlib模块

Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。

什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串(通常用

16进制的字符串表示)。

我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

import hashlib

md5 = hashlib.md5()

md5.update('This is hashlib'.encode('utf-8'))

print(md5.hexdigest())

# 执行结果如下：

'4965310fcf57676786876118fd09912e'

如果内容较多可以分多次调用update，最后得到的密文和一次性输入是一样的(注意空格)。

MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示

另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：

import hashlib

sh = hashlib.sha1()

sh.update('This is '.encode('utf-8'))

sh.update('hashlib'.encode('utf-8'))

sh.hexdigest()

# 执行结果如下：

'cb61e3638d1cffe5c3080f358a33cb526ca7458c'

比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法不仅越慢，而且摘要长度更长。

有没有可能两个不同的数据通过某个摘要算法得到了相同的摘要？完全有可能，因为任何摘要算法都是把无限多的数据集合映射到一

个有限的集合中。这种情况称为碰撞，这种情况可能出现，但是非常非常困难。

6、XML处理模块

首先关于xml不做介绍，想了解可以自行搜索或者去菜鸟驿站了解一下，而且也有该模块的教程。

常见的 XML 编程接口有 DOM 和 SAX，这两种接口处理 XML 文件的方式不同，当然使用场合也不同。

Python 有三种方法解析 XML，SAX，DOM，以及 ElementTree，简单说下：

SAX：用事件驱动模型，通过触发事件和回调函数来处理XML文件，是流式读取XML文件，比较快，占用内存少，但需要用户实现回调。

DOM：将 XML 数据在内存中解析成一个树，通过对树的操作来操作XML，DOM功能齐全，但是比较笨重，一是比较慢，二是比较耗内存。

ElementTree：就像一个轻量级的DOM，具有方便友好的API。代码可用性好，速度快，消耗内存少。

这里就只简单讨论一下ElementTree解析方式

6.1 API名称

from xml.etree import ElementTree as ET

6.2 基本概念

1

2008

141100

我们把xxx这种结构称为一个element，country称作element的tag，<>>之间的内容称作element的text或data，<>中的name称作element的attrib，而整个XML树被称作ElementTree。

element是一个名为xml.etree.ElementTree.Element的类，其描述为：

class xml.etree.ElementTree.Element(tag, attrib={}, **extra)

此类的所有属性和方法查看：

https://docs.python.org/2/library/xml.etree.elementtree.html #element-objects

6.3 方法释义

读取xml数据

--读取XML文件

import xml.etree.ElementTree as ET

tree = ET.parse('country_data.xml')

root = tree.getroot()

--读取XML字符串

root = ET.fromstring(country_data_as_string)

--获取element object的四大属性tag、text、attrib以及tail

root.tag #root element的tag

root.text #root element的text

root.attrib #root element本身的attrib,dict格式的

root.tail #root element的tag结束到下一个tag之间的text

--通过DICT逻辑获取树形结构的text，表示第一个child的第二个child element的text

root[0][1].text

element object的方法

Element.iter(tag) --遍历当前element树所有子节点的element(无论是子节点还是子节点的子节点),找到符合指定tag名的所有element,如果tag为空则遍历当前element树，返回所有节点element(包含当前父节点)。2.7和3.2之前的版本无此方法，可以用getiterator()代替。

Element.findall(tag) --遍历当前节点的直接子节点，找到符合指定tag名的element，返回由element组成的list

Element.find(tag) --遍历当前节点的直接子节点，找到符合指定tag名的第一个element

Element.get(key) --在当前element中获取符合指定attrib名的value

...其他方法参考官网

修改XML内容

ElementTree.write(file, encoding="us-ascii", xml_declaration=None, default_namespace=None, method="xml") --将之前的修改写入XML

Element.set(key,value) --设置element attrib

Element.append(subelement) --新增一个子element，extends(subelements)是3.2的新增用法，输入参数必须是一个element序列

Element.remove(subelement) --删除指定tag的element

示例：

>>> for rank in root.iter('rank'):

... new_rank = int(rank.text) + 1

... rank.text = str(new_rank)

... rank.set('updated', 'yes')

...

>>> tree.write('output.xml')

6.4 实例

xml的格式如下，就是通过<>节点来区别数据结构的(country_data.xml)

2

2008

141100

5

2011

59900

69

2011

13600

操作xml

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

print(root.tag)

#遍历xml文档

for child in root:

print(child.tag, child.attrib)

for i in child:

print(i.tag,i.text)

#只遍历year 节点

for node in root.iter('year'):

print(node.tag,node.text)

删除、修改xml内容

import xml.etree.ElementTree as ET

tree = ET.parse("xmltest.xml")

root = tree.getroot()

#修改

for node in root.iter('year'):

new_year = int(node.text) + 1

node.text = str(new_year)

node.set("updated","yes")

tree.write("xmltest.xml")

#删除node

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) #打印生成的格式

7、json&pickle模块

通过将对象序列化可以将其存储在变量或者文件中，可以保存当时对象的状态，并且需要时可以通过反序列化再次将这个对象读取出来。

python中用于序列化的主要有两个模块

json，如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

pickle，用于python特有的类型和python的数据类型间进行转换，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据。

Json模块提供了四个功能：dumps和dump(序列化)、loads和load(反序列化)

pickle模块提供了四个功能：dumps、dump、loads、load

>>> import pickle

# pickle.dumps()方法把任意对象序列化成一个bytes

>>> data = dict(name='Eric',age=23,score=59)

>>> d = pickle.dumps(data)

>>> d

b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00Ericq\x02X\x03\x00\x00\x00ageq\x03K\x17X\x05\x00\x00\x00scoreq\x04K;u.'

# pickle.dump()直接把对象序列化后写入一个文件

>>> f = open('info.txt','wb')

>>> pickle.dump(data,f)

>>> f.close()

# pickle.loads()方法可以把bytes反序列化

>>> pickle.loads(d)

{'name': 'Eric', 'age': 23, 'score': 59}

# pickle.load()方法从一个文件中直接反序列化出对象

>>> f = open('info.txt','rb')

>>> data_1=pickle.load(f)

>>> data_1

{'name': 'Eric', 'age': 23, 'score': 59}

json进阶

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

JSON类型Python类型

{}

dict

[]

list

"string"

str

1234.56

int或float

true/false

True/False

null

None

Python的dict对象可以直接序列化为JSON的{}，不过，很多时候，大家更喜欢用class表示对象，比如定义Students类，然后序列化：

import json

class Student(object):

def __init__(self, name, age, score):

self.name = name

self.age = age

self.score = score

s = Student('Eric', 20, 59)

print(json.dumps(s))

# 执行结果如下：

Traceback (most recent call last):

...

TypeError:Object of type Student is not JSON serializable

错误的原因是Student对象不是一个可序列化为JSON的对象

仔细看看dump()方法的参数列表，可以发现，除了第一个必须的obj参数外，dump()方法还提供了一大堆的可选参数：

可选参数default就是把任意一个对象变成一个可序列为JSON的对象，这里需要把class转换成dict：

print(json.dumps(s, default=lambda obj: obj.__dict__))

因为通常class的实例都有一个__dict__属性，它就是一个dict，用来存储实例变量。

同样的道理，如果我们要把JSON反序列化为一个Student对象实例，load()方法首先转换出一个dict对象，然后，我们传入的object_hook函数把dict实例Student实例：

def dict2student(d):return Student(d['name'], d['age'], d['score'])

即有：

s = Student('Eric', 20, 59)

#序列化

f = open('class_pickle.txt', 'w')

json.dump(s, f, default=lambda obj: obj.__dict__)

f.close()

# 反序列化

def dict2studend(d):

return Student(d['name'], d['age'], d['score'])

f = open('class_pickle.txt', 'r')

d = json.load(f, object_hook=dict2studend)

f.close()

print(d)