Day05 - Python 常用模块

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Day05 - Python 常用模块相关的知识,希望对你有一定的参考价值。

1. 模块简介

模块就是一个保存了 Python 代码的文件。模块能定义函数,类和变量。模块里也能包含可执行的代码。

模块也是 Python 对象,具有随机的名字属性用来绑定或引用。

下例是个简单的模块support.py

1 def print_func( par ):
2      print("Hello : ", par)
3      return

1)import 语句

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

import module1[, module2[,... moduleN]

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support.py ,需要把命令放在脚本的顶端:

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3  
4 # 导入模块
5 import support
6  
7 # 现在可以调用模块里包含的函数了
8 support.print_func("Zara")

输出结果:

1 Hello : Zara

一个模块只会被导入一次,不管你执行了多少次 import ,这样可以防止导入模块被一遍又一遍地执行。

2)from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下:

from modname import name1[, name2[, ... nameN]]

例如,要导入模块 fib 的 fibonacci 函数,使用如下语句:

from fib import fibonacci

这个声明不会把整个 fib 模块导入到当前的命名空间中,它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。

3)from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目,然而这种声明不该被过多地使用。

4)定位模块

当你导入一个模块,Python 解析器对模块位置的搜索顺序是:

  • 当前目录
  • 如果不在当前目录,Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录
  • 如果都找不到,Python 会察看默认路径。UNIX 下,默认路径一般为 /usr/local/lib/python/ 。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录,PYTHONPATH 和由安装过程决定的默认目录。

5) PYTHONPATH变量

作为环境变量,PYTHONPATH 由装在一个列表里的许多目录组成。PYTHONPATH 的语法和 shel l 变量的 PATH 一样。

在Windows系统,典型的PYTHONPATH如下:

1 >>> import sys
2 >>> sys.path
3 [‘‘, C:\\\\Python35\\\\Lib\\\\idlelib, C:\\\\Python35\\\\python35.zip, C:\\\\Python35\\\\DLLs, C:\\\\Python35\\\\lib, C:\\\\Python35, C:\\\\Python35\\\\lib\\\\site-packages]

在UNIX系统,典型的PYTHONPATH如下:

set PYTHONPATH=/usr/local/lib/python

6) 命名空间和作用域

变量是拥有匹配对象的名字(标识符)。命名空间是一个包含了变量名称们(键)和它们各自相应的对象们(值)的字典。

一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。

如果一个局部变量和一个全局变量重名,则局部变量会覆盖全局变量。

每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。

Python 会智能地猜测一个变量是局部的还是全局的,它假设任何在函数内赋值的变量都是局部的。

因此,如果要给全局变量在一个函数里赋值,必须使用 global  语句。

global VarName 的表达式会告诉 Python , VarName 是一个全局变量,这样 Python 就不会在局部命名空间里寻找这个变量了。

例如,我们在全局命名空间里定义一个变量 money ,我们再在函数内给变量 money 赋值,然后 Python 会假定 money 是一个局部变量。然而,我们并没有在访问前声明一个局部变量 money ,结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句的注释就能解决这个问题。

 1 >>> money = 2000
 2 >>> def add_money():
 3     # 想改正代码就取消以下注释
 4     # global money
 5     money += 1
 6 
 7     
 8 >>> print(money)
 9 2000
10 >>> add_money()
11 Traceback (most recent call last):
12   File "<pyshell#7>", line 1, in <module>
13     add_money()
14   File "<pyshell#5>", line 4, in add_money
15     money += 1
16 UnboundLocalError: local variable money referenced before assignment
17 >>> print(money)

取消注释:

 1 >>> money = 2000
 2 >>> def add_money():
 3     global money
 4     money += 1
 5 
 6     
 7 >>> print(money)
 8 2000
 9 >>> add_money()
10 >>> print(money)
11 2001

7)Python 中的包

包是一个分层次的文件目录结构,它定义了一个由模块及子包,和子包下的子包等组成的 Python 的应用环境。

考虑一个在 Phone 目录下的 pots.py 文件。这个文件有如下源代码:

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3  
4 def Pots():
5     print("I‘m Pots Phone")

同样地,我们有另外两个保存了不同函数的文件:

  • Phone/Isdn.py 含有函数 Isdn()
  • Phone/G3.py 含有函数 G3()

现在,在 Phone 目录下创建file __init__.py:

  • Phone/__init__.py

当你导入 Phone 时,为了能够使用所有函数,你需要在 __init__.py 里使用显式的导入语句,如下:

from Pots import Pots
from Isdn import Isdn
from G3 import G3

当你把这些代码添加到 __init__.py 之后,导入Phone包的时候这些类就全都是可用的了。

1 #!/usr/bin/python
2 # -*- coding: UTF-8 -*-
3  
4 # 导入 Phone 包
5 import Phone
6  
7 Phone.Pots()
8 Phone.Isdn()
9 Phone.G3()

输出结果:

1 Im Pots Phone
2 Im 3G Phone
3 Im ISDN Phone

如上,为了举例,我们只在每个文件里放置了一个函数,但其实你可以放置许多函数。

也可以在这些文件里定义Python的类,然后为这些类建一个包。

8) dir() 函数

dir() 函数一个排好序的字符串列表,内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块、变量和函数。

如下一个简单的实例:

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3  
4 # 导入内置 math 模块
5 import math
6 
7 dir(math)

以上实例输出结果:

1 [__doc__, __loader__, __name__, __package__, __spec__, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, copysign, cos, cosh, degrees, e, erf, erfc, exp, expm1, fabs, factorial, floor, fmod, frexp, fsum, gamma, gcd, hypot, inf, isclose, isfinite, isinf, isnan, ldexp, lgamma, log, log10, log1p, log2, modf, nan, pi, pow, radians, sin, sinh, sqrt, tan, tanh, trunc]

在这里,特殊字符串变量 __name__ 指向模块的名字,__file__ 指向该模块的导入文件名。

9) globals() 和 locals() 函数

根据调用地方的不同,globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。

如果在函数内部调用 locals() ,返回的是所有能在该函数里访问的命名。

1 >>> locals()
2 {__spec__: None, __name__: __main__, __doc__: None, __loader__: <class _frozen_importlib.BuiltinImporter>, __builtins__: <module builtins (built-in)>, math: <module math (built-in)>, __package__: None}

如果在函数内部调用 globals(),返回的是所有在该函数里能访问的全局名字。

1 >>> globals()
2 {__spec__: None, __name__: __main__, __doc__: None, __loader__: <class _frozen_importlib.BuiltinImporter>, __builtins__: <module builtins (built-in)>, math: <module math (built-in)>, __package__: None}

两个函数的返回类型都是字典,所以名字能用 keys() 函数获取。

10) reload() 函数

当一个模块被导入到一个脚本,模块顶层部分的代码只会被执行一次。

因此,如果你想重新执行模块里顶层部分的代码,可以用 reload() 函数。

该函数会重新导入之前导入过的模块。语法如下:

reload(module_name)

在这里,module_name 要直接放模块的名字,而不是一个字符串形式。比如想重载 hello 模块,如下:

reload(hello)

2. 常用模块

1) time & calendar & datetime

Python 日期和时间

Python 程序能用很多方式处理日期和时间,转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜(历元)经过了多长时间来表示。

Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3 
4 import time # 引入time模块
5 
6 ticks = time.time()
7 print("当前时间戳为:", ticks)

输出结果:

1 当前时间戳为: 1479129524.694309

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行,UNIX和Windows只支持到2038年。

时间元组

很多Python函数用一个元组装起来的9组数字处理时间:

序号字段
0 4位数年 2008
1 1 到 12
2 1到31
3 小时 0到23
4 分钟 0到59
5 0到61 (60或61 是闰秒)
6 一周的第几日 0到6 (0是周一)
7 一年的第几日 1到366 (儒略历)
8 夏令时 -1, 0, 1, -1是决定是否为夏令时的旗帜

上述也就是struct_time元组。这种结构具有如下属性:

序号属性
0 tm_year 2008
1 tm_mon 1 到 12
2 tm_mday 1 到 31
3 tm_hour 0 到 23
4 tm_min 0 到 59
5 tm_sec 0 到 61 (60或61 是闰秒)
6 tm_wday 0到6 (0是周一)
7 tm_yday 1 到 366(儒略历)
8 tm_isdst -1, 0, 1, -1是决定是否为夏令时的旗帜

获取当前时间

从返回浮点数的时间辍方式向时间元组转换,只要将浮点数传递给如localtime之类的函数。

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3 
4 import time
5 
6 localtime = time.localtime(time.time())
7 print("本地时间为 :", localtime)

输出结果:

1 本地时间为 : time.struct_time(tm_year=2016, tm_mon=11, tm_mday=14, tm_hour=21, tm_min=21, tm_sec=2, tm_wday=0, tm_yday=319, tm_isdst=0)

获取格式化的时间

可以根据需求选取各种格式的时间,但是最简单的获取可读时间模式的函数是asctime():

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3 
4 import time
5 
6 localtime = time.asctime(time.localtime(time.time()))
7 print("本地时间为 :", localtime)

输出结果:

1 本地时间为 : Mon Nov 14 21:24:39 2016

格式化日期

可以使用 time 模块的 strftime 方法来格式化日期

time.strftime(format[, t])
 1 #!/usr/bin/env python
 2 # -*- coding: UTF-8 -*-
 3 
 4 import time
 5 
 6 # 格式化成2016-03-20 11:45:39形式
 7 print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
 8 
 9 # 格式化成Sat Mar 28 22:24:24 2016形式
10 print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
11 
12 # 将格式字符串转换为时间戳
13 a = "Mon Nov 14 21:31:45 2016"
14 print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))

输出结果:

2016-11-14 21:32:21
Mon Nov 14 21:32:21 2016
1479130305.0

python中时间日期格式化符号:

  • %y 两位数的年份表示(00-99)
  • %Y 四位数的年份表示(000-9999)
  • %m 月份(01-12)
  • %d 月内中的一天(0-31)
  • %H 24小时制小时数(0-23)
  • %I 12小时制小时数(01-12)
  • %M 分钟数(00=59)
  • %S 秒(00-59)
  • %a 本地简化星期名称
  • %A 本地完整星期名称
  • %b 本地简化的月份名称
  • %B 本地完整的月份名称
  • %c 本地相应的日期表示和时间表示
  • %j 年内的一天(001-366)
  • %p 本地A.M.或P.M.的等价符
  • %U 一年中的星期数(00-53)星期天为星期的开始
  • %w 星期(0-6),星期天为星期的开始
  • %W 一年中的星期数(00-53)星期一为星期的开始
  • %x 本地相应的日期表示
  • %X 本地相应的时间表示
  • %Z 当前时区的名称
  • %% %号本身

获取某月日历

Calendar模块有很广泛的方法用来处理年历和月历,例如打印某月的月历:

1 #!/usr/bin/env python
2 # -*- coding: UTF-8 -*-
3 
4 import calendar
5 
6 cal = calendar.month(2016, 11)
7 print("以下输出2016年11月份的日历:")
8 print(cal)

输出结果:

1 以下输出2016年11月份的日历:
2    November 2016
3 Mo Tu We Th Fr Sa Su
4     1  2  3  4  5  6
5  7  8  9 10 11 12 13
6 14 15 16 17 18 19 20
7 21 22 23 24 25 26 27
8 28 29 30

time 模块

time 模块包含以下内置函数

  • time.altzone 返回格林威治西部的夏令时地区的偏移秒数(与UTC的时间差)。如果该地区在格林威治东部会返回负值(如西欧,包括英国)。对夏令时启用地区才能使用
1 >>> time.altzone
2 -32400
  • time.asctime([tupletime]) 接受时间元组并返回一个可读的形式为 ‘Mon Nov 14 21:45:06 2016‘ 的24个字符的字符串
1 >>> time.asctime(time.localtime())
2 Mon Nov 14 21:45:06 2016
  • time.clock() 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时,比time.time()更有用
1 >>> time.clock()
2 2.83648743983101e-06
  • time.ctime([secs]) 作用相当于asctime(localtime(secs)),未给参数相当于asctime()
1 >>> time.ctime()
2 Mon Nov 14 21:48:23 2016
  • time.gmtime([secs]) 接收时间辍(1970纪元后经过的浮点秒数)并返回格林威治天文时间下的时间元组t。注:t.tm_isdst 始终为0
1 >>> time.gmtime()
2 time.struct_time(tm_year=2016, tm_mon=11, tm_mday=14, tm_hour=13, tm_min=49, tm_sec=3, tm_wday=0, tm_yday=319, tm_isdst=0)
  • time.localtime([secs]) 接收时间辍(1970纪元后经过的浮点秒数)并返回当地时间下的时间元组t(t.tm_isdst可取0或1,取决于当地当时是不是夏令时)
1 >>> time.localtime()
2 time.struct_time(tm_year=2016, tm_mon=11, tm_mday=14, tm_hour=21, tm_min=50, tm_sec=10, tm_wday=0, tm_yday=319, tm_isdst=0)
  • time.mktime(tupletime) 接受时间元组并返回时间辍(1970纪元后经过的浮点秒数)
1 >>> time.mktime(time.localtime())
2 1479131695.0
  • time.sleep(secs) 推迟调用线程的运行,secs指秒数
1 >>> print("Start : %s" % time.ctime())
2 Start : Mon Nov 14 21:59:15 2016
3 >>> time.sleep(5)
4 >>> print("End : %s" % time.ctime())
5 End : Mon Nov 14 21:59:20 2016
  • time.strftime(fmt[,tupletime]) 接收以时间元组,并返回以可读字符串表示的当地时间,格式由fmt决定
1 >>> time.strftime("%b %d %Y %H:%M:%S", time.gmtime())
2 Nov 14 2016 14:01:42
  • time.strptime(str,fmt=‘%a %b %d %H:%M:%S %Y‘) 根据fmt的格式把一个时间字符串解析为时间元组
1 >>> struct_time = time.strptime("30 Nov 16", "%d %b %y")
2 >>> print(struct_time)
3 time.struct_time(tm_year=2016, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)
  • time.time( ) 返回当前时间的时间戳(1970纪元后经过的浮点秒数)
1 >>> time.time()
2 1479132293.9487014

时间转换

技术分享

技术分享

日历(Calendar)模块

此模块的函数都是日历相关的,例如打印某月的字符月历。

星期一是默认的每周第一天,星期天是默认的最后一天。

更改设置需调用 calendar.setfirstweekday() 函数。

模块包含了以下内置函数:

  • calendar.calendar(year,w=2,l=1,c=6) 返回一个多行字符串格式的year年年历,3个月一行,间隔距离为c,每日宽度间隔为w字符,每行长度为21* W+18+2* C,l是每星期行数
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 print(calendar.calendar(2016, w=2, l=1, c=6))

输出结果:

 1                                   2016
 2 
 3       January                   February                   March
 4 Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
 5              1  2  3       1  2  3  4  5  6  7          1  2  3  4  5  6
 6  4  5  6  7  8  9 10       8  9 10 11 12 13 14       7  8  9 10 11 12 13
 7 11 12 13 14 15 16 17      15 16 17 18 19 20 21      14 15 16 17 18 19 20
 8 18 19 20 21 22 23 24      22 23 24 25 26 27 28      21 22 23 24 25 26 27
 9 25 26 27 28 29 30 31      29                        28 29 30 31
10 
11        April                      May                       June
12 Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
13              1  2  3                         1             1  2  3  4  5
14  4  5  6  7  8  9 10       2  3  4  5  6  7  8       6  7  8  9 10 11 12
15 11 12 13 14 15 16 17       9 10 11 12 13 14 15      13 14 15 16 17 18 19
16 18 19 20 21 22 23 24      16 17 18 19 20 21 22      20 21 22 23 24 25 26
17 25 26 27 28 29 30         23 24 25 26 27 28 29      27 28 29 30
18                           30 31
19 
20         July                     August                  September
21 Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
22              1  2  3       1  2  3  4  5  6  7                1  2  3  4
23  4  5  6  7  8  9 10       8  9 10 11 12 13 14       5  6  7  8  9 10 11
24 11 12 13 14 15 16 17      15 16 17 18 19 20 21      12 13 14 15 16 17 18
25 18 19 20 21 22 23 24      22 23 24 25 26 27 28      19 20 21 22 23 24 25
26 25 26 27 28 29 30 31      29 30 31                  26 27 28 29 30
27 
28       October                   November                  December
29 Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
30                 1  2          1  2  3  4  5  6                1  2  3  4
31  3  4  5  6  7  8  9       7  8  9 10 11 12 13       5  6  7  8  9 10 11
32 10 11 12 13 14 15 16      14 15 16 17 18 19 20      12 13 14 15 16 17 18
33 17 18 19 20 21 22 23      21 22 23 24 25 26 27      19 20 21 22 23 24 25
34 24 25 26 27 28 29 30      28 29 30                  26 27 28 29 30 31
35 31
  • calendar.firstweekday() 返回当前每周起始日期的设置。默认情况下,首次载入 calendar 模块时返回0,即星期一。
1 >>> calendar.firstweekday()
2 0
  • calendar.isleap(year) 是闰年返回True,否则为false。
1 >>> calendar.isleap(2016)
2 True
  • calendar.leapdays(y1,y2) 返回在Y1,Y2两年之间的闰年总数。
1 >>> calendar.leapdays(2000, 2016)
2 4
  • calendar.month(year,month,w=2,l=1) 返回一个多行字符串格式的 year 年 month 月日历,两行标题,一周一行,每日宽度间隔为 w 字符,每行的长度为7* w+6,l是每星期的行数
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 print(calendar.month(2016, 11, w=2, l=1))

输出结果:

1    November 2016
2 Mo Tu We Th Fr Sa Su
3     1  2  3  4  5  6
4  7  8  9 10 11 12 13
5 14 15 16 17 18 19 20
6 21 22 23 24 25 26 27
7 28 29 30
  • calendar.monthcalendar(year, month) 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数,Year 年month 月外的日期都设为0,范围内的日子都由该月第几日表示,从1开始
>>> calendar.monthcalendar(2016, 11)
[[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13], [14, 15, 16, 17, 18, 19, 20], [21, 22, 23, 24, 25, 26, 27], [28, 29, 30, 0, 0, 0, 0]]
  • calendar.monthrange(year,month) 返回两个整数。第一个是该月的星期几的日期码,第二个是该月的日期码,日从0(星期一)到6(星期日),月从1到12
1 >>> calendar.monthrange(2016, 11)
2 (1, 30)
  • calendar.prcal(year,w=2,l=1,c=6) 相当于 print(calendar.calendar(year,w,l,c))
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 print(calendar.prcal(2016, w=2, l=1, c=6))

输出结果:

                                  2016

      January                   February                   March
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7          1  2  3  4  5  6
 4  5  6  7  8  9 10       8  9 10 11 12 13 14       7  8  9 10 11 12 13
11 12 13 14 15 16 17      15 16 17 18 19 20 21      14 15 16 17 18 19 20
18 19 20 21 22 23 24      22 23 24 25 26 27 28      21 22 23 24 25 26 27
25 26 27 28 29 30 31      29                        28 29 30 31

       April                      May                       June
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3                         1             1  2  3  4  5
 4  5  6  7  8  9 10       2  3  4  5  6  7  8       6  7  8  9 10 11 12
11 12 13 14 15 16 17       9 10 11 12 13 14 15      13 14 15 16 17 18 19
18 19 20 21 22 23 24      16 17 18 19 20 21 22      20 21 22 23 24 25 26
25 26 27 28 29 30         23 24 25 26 27 28 29      27 28 29 30
                          30 31

        July                     August                  September
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
             1  2  3       1  2  3  4  5  6  7                1  2  3  4
 4  5  6  7  8  9 10       8  9 10 11 12 13 14       5  6  7  8  9 10 11
11 12 13 14 15 16 17      15 16 17 18 19 20 21      12 13 14 15 16 17 18
18 19 20 21 22 23 24      22 23 24 25 26 27 28      19 20 21 22 23 24 25
25 26 27 28 29 30 31      29 30 31                  26 27 28 29 30

      October                   November                  December
Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
                1  2          1  2  3  4  5  6                1  2  3  4
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       5  6  7  8  9 10 11
10 11 12 13 14 15 16      14 15 16 17 18 19 20      12 13 14 15 16 17 18
17 18 19 20 21 22 23      21 22 23 24 25 26 27      19 20 21 22 23 24 25
24 25 26 27 28 29 30      28 29 30                  26 27 28 29 30 31
31

None
  • calendar.prmonth(year,month,w=2,l=1) 相当于 print(calendar.calendar(year,w,l,c))
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 
4 import calendar
5 
6 calendar.prmonth(2016, 11, w=2, l=1)

输出结果:

1    November 2016
2 Mo Tu We Th Fr Sa Su
3     1  2  3  4  5  6
4  7  8  9 10 11 12 13
5 14 15 16 17 18 19 20
6 21 22 23 24 25 26 27
7 28 29 30
  • calendar.setfirstweekday(weekday) 设置每周的起始日期码。0(星期一)到6(星期日)
1 >>> calendar.setfirstweekday(2)
2 >>> calendar.firstweekday( )
3 2
  • calendar.timegm(tupletime) 和 time.gmtime 相反:接受一个时间元组形式,返回该时刻的时间辍(1970纪元后经过的浮点秒数)
1 >>> calendar.timegm(time.localtime())
2 1479164045
  • calendar.weekday(year,month,day) 返回给定日期的日期码。0(星期一)到6(星期日)。月份为 1(一月) 到 12(12月)
1 >>> calendar.weekday(2016,11,14)
2 0

datetime 模块

  • datetime.datetime.now() 返回当前时间
1 >>> print(datetime.datetime.now())
2 2016-11-14 23:02:30.931429
  • datetime.date.fromtimestamp(time.time()) 时间戳直接转成日期格式
1 >>> print(datetime.date.fromtimestamp(time.time()))
2 2016-11-14
  • datetime.datetime.now() + datetime.timedelta(3)) 当前时间+3天
  • datetime.datetime.now() + datetime.timedelta(-3)) 当前时间-3天
  • datetime.datetime.now() + datetime.timedelta(hours=3)) 当前时间+3小时
  • datetime.datetime.now() + datetime.timedelta(minutes=30) 当前时间+30分
 1 >>> print(datetime.datetime.now())
 2 2016-11-14 23:05:03.731169
 3 >>> print(datetime.datetime.now() + datetime.timedelta(3)) # 当前时间+3天
 4 2016-11-17 23:05:03.743169
 5 >>> print(datetime.datetime.now() + datetime.timedelta(-3)) # 当前时间-3天
 6 2016-11-11 23:05:03.755170
 7 >>> print(datetime.datetime.now() + datetime.timedelta(hours=3)) # 当前时间+3小时
 8 2016-11-15 02:05:03.765171
 9 >>> print(datetime.datetime.now() + datetime.timedelta(minutes=30)) # 当前时间+30分
10 2016-11-14 23:35:04.858233
  • replace(minute, hour) 时间替换
1 >>> c_time = datetime.datetime.now()
2 >>> print(c_time)
3 2016-11-14 23:07:37.762979
4 >>> print(c_time.replace(minute=3, hour=2))
5 2016-11-14 02:03:37.762979

2)random

Python中的random模块用于生成随机数

random.random()

用于生成一个0到1的随机浮点数: 0 <= n < 1.0

1 >>> import random
2 >>> random.random()
3 0.99107532292498801

random.uniform(a, b)

用于生成一个指定范围内的随机浮点数,两个参数其中一个是上限,一个是下限。如果a > b,则生成的随机数n: a <= n <= b;如果 a <b, 则 b <= n <= a。

1 >>> import random
2 >>> random.uniform(10, 20)
3 12.893035403821591
4 >>> random.uniform(20, 10)
5 15.344944314032574

random.randint(a, b)

用于生成一个指定范围内的整数。其中参数a是下限,参数b是上限,生成的随机数n: a <= n <= b

 1 >>> import random
 2 >>> random.randint(12, 20)    # 生成的随机数n: 12 <= n <= 20
 3 16
 4 >>> random.randint(20, 20)    # 结果永远是20
 5 20
 6 >>> random.randint(20, 10)    # 该语句是错误的,下限必须小于上限
 7 Traceback (most recent call last):
 8   File "<stdin>", line 1, in <module>
 9   File "/usr/lib64/python2.6/random.py", line 228, in randint
10     return self.randrange(a, b+1)
11   File "/usr/lib64/python2.6/random.py", line 204, in randrange
12     raise ValueError, "empty range for randrange() (%d,%d, %d)" % (istart, istop, width)
13 ValueError: empty range for randrange() (20,11, -9)

random.randrange([start], stop[, step])

从指定范围内,按指定基数递增的集合中获取一个随机数。

1 >>> import random
2 >>> random.randrange(10, 100, 2)
3 80

结果相当于从 [10, 12, 14, 16, ... 96, 98] 序列中获取一个随机数。

random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效。

random.choice(sequence)

从序列中获取一个随机元素,参数 sequence 表示一个有序类型。这里要说明 一下:sequence 在python 不是一种特定的类型,而是泛指一系列的类型。list, tuple, 字符串都属于sequence。

1 >>> import random
2 >>> random.choice("学习Python") 
3 \\xe4
4 >>> random.choice(["JGood", "is", "a", "handsome", "boy"]) 
5 boy
6 >>> random.choice(("Tuple", "List", "Dict"))
7 List

random.shuffle(x[, random])

用于将一个列表中的元素打乱

1 >>> import random
2 >>> p = ["Python", "is", "powerful", "simple", "and so on..."]  
3 >>> random.shuffle(p)  
4 >>> p
5 [is, Python, and so on..., powerful, simple]

random.sample(sequence, k)

从指定序列中随机获取指定长度的片,sample函数不会修改原有序列

1 >>> import random
2 >>> list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
3 >>> slice = random.sample(list, 5) 
4 >>> slice
5 [8, 6, 9, 3, 7]
6 >>> list
7 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

多个字符中选取特定数量的字符

1 >>> import random
2 >>> random.sample(abcdefghij,3) 
3 [i, c, b]

random.sample 验证码应用

方式一:

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 import random
 5 import string
 6 
 7 str_source = string.ascii_letters + string.digits
 8 code = random.sample(str_source, 6)
 9 for i in code:
10     print(i, end="")

输出结果:

1 0sHxSZ

方式二:

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 import random
 5 
 6 check_code = ""
 7 for i in range(6):
 8     current = random.randrange(0, 6)
 9     if current != i:
10         temp = chr(random.randint(65, 90))
11     else:
12         temp = random.randint(0, 9)
13     check_code += str(temp)
14 print(check_code)

输出结果:

1 HY5YNN

3)os

os.name

输出字符串指示正在使用的平台。

如果是window 则用‘nt‘表示:

1 >>> import os
2 >>> os.name
3 nt

对于Linux/Unix用户,它是‘posix‘:

1 >>> import os
2 >>> os.name
3 posix

os.getcwd()

获取当前工作目录,即当前 python 脚本工作的目录路径

1 >>> import os
2 >>> os.getcwd()
3 /home/test

os.chdir("dirname")

改变当前脚本工作目录,相当于shell下cd

1 >>> import os
2 >>> os.getcwd()
3 /home/test
4 >>> os.chdir("Python35")
5 >>> os.getcwd()
6 /usr/local/python35

os.curdir

返回当前目录: (‘.‘)

1 >>> import os
2 >>> os.curdir
3  .

os.pardir

获取当前目录的父目录字符串名:(‘..‘)

1 >>> import os
2 >>> os.pardir
3 ..

os.makedirs(‘dirname1/dirname2‘)

可生成多层递归目录

 1 >>> import os
 2 >>> os.getcwd()
 3 /home/test
 4 >>> os.makedirs(test1/test2)
 5 >>> os.chdir(test1)
 6 >>> os.getcwd()
 7 /home/test/test1
 8 >>> os.chdir(test2)
 9 >>> os.getcwd()
10 /home/test/test1/test2

os.removedirs(‘dirname1‘)

若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推

 1 >>> import os
 2 >>> os.getcwd()
 3 /home/test/test1/test2
 4 >>> os.chdir(..)
 5 >>> os.getcwd()
 6 /home/test/test1
 7 >>> os.removedirs(test2)
 8 >>> os.getcwd()
 9 /home/test/test1
10 >>> os.chdir(test2)
11 Traceback (most recent call last):
12   File "<stdin>", line 1, in <module>
13 OSError: [Errno 2] No such file or directory: test2

os.mkdir(‘dirname‘)

生成单级目录,相当于 shell 中 mkdir dirname

 1 >>> import os
 2 >>> os.getcwd()
 3 /home/test
 4 >>> os.chdir(test1)
 5 >>> os.getcwd()
 6 /home/test/test1
 7 >>> os.listdir(.)
 8 []
 9 >>> os.mkdir(test2)
10 >>> os.listdir(.)
11 [test2]

os.listdir(‘dirname‘)

列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印

1 >>> import os
2 >>> os.listdir(.)
3 [.zshrc, .subversion, .dbshell, .mozilla, .bash_logout, .gnome2, .bash_history, .bashrc, test1, .viminfo, .emacs, .bash_profile]

os.rmdir(‘dirname‘)

删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname

1 >>> import os
2 >>> os.getcwd()
3 /home/test/test1
4 >>> os.listdir(.)
5 [test2]
6 >>> os.rmdir(test2)
7 >>> os.listdir(.)
8 []

os.remove()

删除一个文件

1 >>> import os
2 >>> os.listdir(.)
3 [test.log]
4 >>> os.remove(test.log)
5 >>> os.listdir(.)
6 []

os.rename("oldname","newname")

重命名文件/目录

1 >>> import os
2 >>> os.listdir(.)
3 [test.log]
4 >>> os.rename(test.log,hello.txt)
5 >>> os.listdir(.)
6 [hello.txt]

os.stat(‘path/filename‘)

获取文件/目录信息

1 >>> import os
2 >>> os.listdir(.)
3 [hello.txt]
4 >>> os.stat(hello.txt)
5 posix.stat_result(st_mode=33188, st_ino=2629852, st_dev=64768L, st_nlink=1, st_uid=505, st_gid=301, st_size=0, st_atime=1478588652, st_mtime=1478588652, st_ctime=1478588686)

os.sep

输出操作系统特定的路径分隔符

win下为"\\\\"

1 >>> import os
2 >>> os.sep
3 \\\\

Linux下为"/"

>>> import os
>>> os.sep
/

os.linesep

输出当前平台使用的行终止符

win下为"\\r\\n"

1 >>> import os
2 >>> os.linesep
3 \\r\\n

Linux下为"\\n"

1 >>> import os
2 >>> os.linesep
3 \\n

os.pathsep

输出用于分割文件路径的字符串

win下为‘;‘

1 >>> import os
2 >>> os.pathsep
3 ;

Linux下为‘:‘

1 >>> import os
2 >>> os.pathsep
3 :

os.system("bash command")

运行shell命令,直接显示

1 >>> import os
2 >>> os.system(date)
3 Tue Nov  8 15:15:26 CST 2016
4 0

os.environ

获取系统环境变量

1 >>> import os
2 >>> os.environ
3 environ({OS: Windows_NT, PROCESSOR_REVISION: 1706, HOMEPATH: \\\\Users\\\\test, APPDATA: C:\\\\Users\\\\test\\\\AppData\\\\Roaming, PUBLIC: C:\\\\Users\\\\Public, PROGRAMFILES(X86): C:\\\\Program Files (x86), COMPUTERNAME: TEST-PC, SYSTEMDRIVE: C:, LOCALAPPDATA: C:\\\\Users\\\\test\\\\AppData\\\\Local, COMMONPROGRAMFILES: C:\\\\Program Files\\\\Common Files, SESSIONNAME: Console, FP_NO_HOST_CHECK: NO, PROCESSOR_IDENTIFIER: Intel64 Family 6 Model 23 Stepping 6, GenuineIntel, PROGRAMDATA: C:\\\\ProgramData, USERNAME: test,PROGRAMFILES: C:\\\\Program Files, CATALINA_HOME: D:\\\\apache-tomcat-6.0.45, NUMBER_OF_PROCESSORS: 2, TMP: C:\\\\Users\\\\test\\\\AppData\\\\Local\\\\Temp,PATHEXT: .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PY;.PYW, PROMPT: $P$G, COMMONPROGRAMFILES(X86): C:\\\\Program Files (x86)\\\\Common Files, COMSPEC: C:\\\\Windows\\\\system32\\\\cmd.exe, PROGRAMW6432: C:\\\\Program Files, SYSTEMROOT: C:\\\\Windows, PATH: D:\\\\Python35\\\\Scripts\\\\;D:\\\\Python35\\\\;D:\\\\oracle\\\\product\\\\10.2.0\\\\client_1\\\\bin;C:\\\\Windows\\\\system32;C:\\\\Windows;C:\\\\Windows\\\\System32\\\\Wbem;C:\\\\Windows\\\\System32\\\\WindowsPowerShell\\\\v1.0\\\\;D:\\\\Program Files\\\\TortoiseSVN\\\\bin;C:\\\\Redis\\\\;C:\\\\Java\\\\jdk1.6\\\\bin;D:\\\\MongoDB\\\\Server\\\\3.2\\\\bin, TEMP: C:\\\\Users\\\\test\\\\AppData\\\\Local\\\\Temp, USERDOMAIN: test-PC, COMMONPROGRAMW6432: C:\\\\Program Files\\\\Common Files, PROCESSOR_LEVEL: 6, PSMODULEPATH: C:\\\\Windows\\\\system32\\\\WindowsPowerShell\\\\v1.0\\\\Modules\\\\;C:\\\\Program Files\\\\Intel\\\\, USERPROFILE: C:\\\\Users\\\\test, ALLUSERSPROFILE: C:\\\\ProgramData, LOGONSERVER: \\\\\\\\TEST-PC, WINDIR: C:\\\\Windows, JAVA_HOME: C:\\\\Java\\\\jdk1.6, HOMEDRIVE: C:, PROCESSOR_ARCHITECTURE: AMD64})

os.path.abspath(path)

返回path规范化的绝对路径

1 >>> import os
2 >>> os.path.abspath(test1)
3 /home/test/test1/test1

os.path.split(path)

将path分割成目录和文件名二元组返回

1 >>> import os
2 >>> os.path.split(/home/test)
3 (/home, test)

os.path.dirname(path)

返回 path 的目录,其实就是os.path.split(path)的第一个元素

1 >>> import os
2 >>> os.path.dirname(/home/test)
3  /home

os.path.basename(path)

返回path最后的文件名,如果 path 以 / 或 \\ 结尾,那么就会返回空值,即os.path.split(path)的第二个元素

1 >>> import os
2 >>> os.path.basename(home/test)
3 test
4 >>> os.path.basename(home/test/)
5 ‘‘

os.path.exists(path)

如果path存在,返回True;如果path不存在,返回False

1 >>> import os
2 >>> os.getcwd()
3 /home/test/test1
4 >>> os.listdir(.)
5 [test2, hello.txt]
6 >>> os.path.exists(test1)
7 False
8 >>> os.path.exists(test2)
9 True

os.path.isabs(path)

如果path是绝对路径,返回True

1 >>> import os
2 >>> os.path.isabs(/home/test/test1)
3 True
4 >>> os.path.isabs(test1)
5 False

os.path.isfile(path)

如果path是一个存在的文件,返回True。否则返回False

1 >>> import os
2 >>> os.listdir(.)
3 [test2, hello.txt]
4 >>> os.path.isfile(hello.txt)
5 True
6 >>> os.path.isfile(test.log)
7 False

os.path.isdir(path)

如果path是一个存在的目录,则返回True。否则返回False

1 >>> import os
2 >>> os.listdir(.)
3 [test2, hello.txt]
4 >>> os.path.isdir(test2)
5 True
6 >>> os.path.isdir(hello.txt)
7 False

os.path.join(path1[, path2[, ...]])

将多个路径组合后返回,第一个绝对路径之前的参数将被忽略

1 >>> import os
2 >>> os.path.join(test1,test2,test)
3 test1/test2/test
4 >>> os.path.join(/home/test/test1,test2,test)
5 /home/test/test1/test2/test
6 >>> os.path.join(test1,/home/test/test1/test2,test)
7 /home/test/test1/test2/test

os.path.getatime(path)

返回path所指向的文件或者目录的最后存取时间

1 >>> import os
2 >>> os.listdir(.)
3 [test2, hello.txt]
4 >>> os.path.getatime(hello.txt)
5 1478588652.6452732

os.path.getmtime(path)

返回path所指向的文件或者目录的最后修改时间

1 >>> import os
2 >>> os.listdir(.)
3 [test2, hello.txt]
4 >>> os.path.getmtime(hello.txt)
5 1478588652.6452732

os.path.split(path)

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

1 >>> import os
2 >>> os.path.split(‘/home/test/test1/hello.txt)
3 (‘/home/test/test1, hello.txt)

os.path.getsize(name)

获得文件大小

1 >>> import os
2 >>> os.listdir(.)
3 [test2, hello.txt]
4 >>> os.path.getsize(hello.txt)
5 12
6 >>> os.path.getsize(test2)
7 4096

4)sys

sys.argv

在外部向程序内部传递参数,以list的形式返回参数列表

1 >>> import sys
2 >>> sys.argv
3 [‘‘]

示例:

1 #!/usr/bin/env python
2 # -*- coding:UTF-8 -*-
3 
4 import sys
5 
6 print(sys.argv[0])
7 print(sys.argv[1])

运行结果:

1 $ python sys.py argv1
2 sys.py
3 argv1

sys.exit(n)

执行到主程序末尾,解释器自动退出,但是如果需要中途退出程序,可以调用sys.exit函数,带有一个可选的整数参数返回给调用它的程序,表示你可以在主程序中捕获对sys.exit的调用。(0是正常退出,其他为异常)

1 >>> import sys
2 >>> sys.exit(1)
3 [[email protected] ~]$ echo $?
4 1

sys.version

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

1 >>> import sys
2 >>> sys.version
3 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AMD64)]

sys.maxint

获取最大的int值

1 >>> import sys
2 >>> sys.maxint
3 9223372036854775807

sys.path

返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
>>> import sys
>>> sys.path
[‘‘, /usr/local/python35/lib/python35.zip, /usr/local/python35/lib/python3.5, /usr/local/python35/lib/python3.5/plat-linux, /usr/local/python35/lib/python3.5/lib-dynload, /usr/local/python35/lib/python3.5/site-packages]

sys.platform

返回操作系统平台名称
1 >>> import sys
2 >>> sys.platform
3 linux
sys.modules
sys.modules是一个全局字典,该字典是python启动后就加载在内存中。每当程序员导入新的模块,sys.modules将自动记录该模块。当第二次再导入该模块时,python会直接到字典中查找,从而加快了程序运行的速度。它拥有字典所拥有的一切方法。
1 >>> import sys
2 >>> sys.modules
3 {_sitebuiltins: <module _sitebuiltins from /usr/local/python35/lib/python3.5/_sitebuiltins.py>, encodings.aliases: <module encodings.aliases from /usr/local/python35/lib/python3.5/encodings/aliases.py>, errno: <module errno (built-in)>, _collections_abc: <module _collections_abc from /usr/local/python35/lib/python3.5/_collections_abc.py>, atexit: <module atexit (built-in)>, posixpath: <module posixpath from /usr/local/python35/lib/python3.5/posixpath.py>, _codecs: <module _codecs (built-in)>, __main__: <module __main__ (built-in)>, builtins: <module builtins (built-in)>, io: <module io from /usr/local/python35/lib/python3.5/io.py>, genericpath: <module genericpath from /usr/local/python35/lib/python3.5/genericpath.py>, site: <module site from /usr/local/python35/lib/python3.5/site.py>, _io: <module io (built-in)>, _frozen_importlib_external: <module _frozen_importlib_external (frozen)>, _stat: <module _stat (built-in)>, _thread: <module _thread (built-in)>, encodings.latin_1: <module encodings.latin_1 from /usr/local/python35/lib/python3.5/encodings/latin_1.py>, encodings.utf_8: <module encodings.utf_8 from /usr/local/python35/lib/python3.5/encodings/utf_8.py>, _imp: <module _imp (built-in)>, os: <module os from /usr/local/python35/lib/python3.5/os.py>, _weakref: <module _weakref (built-in)>, zipimport: <module zipimport (built-in)>, posix: <module posix (built-in)>, stat: <module stat from /usr/local/python35/lib/python3.5/stat.py>, os.path: <module posixpath from /usr/local/python35/lib/python3.5/posixpath.py>, codecs: <module codecs from /usr/local/python35/lib/python3.5/codecs.py>, abc: <module abc from /usr/local/python35/lib/python3.5/abc.py>, _frozen_importlib: <module _frozen_importlib (frozen)>, encodings: <module encodings from /usr/local/python35/lib/python3.5/encodings/__init__.py>, marshal: <module marshal (built-in)>, _signal: <module _signal (built-in)>, _weakrefset: <module _weakrefset from /usr/local/python35/lib/python3.5/_weakrefset.py>, sys: <module sys (built-in)>, sysconfig: <module sysconfig from /usr/local/python35/lib/python3.5/sysconfig.py>, _warnings: <module _warnings (built-in)>, _sysconfigdata: <module _sysconfigdata from /usr/local/python35/lib/python3.5/_sysconfigdata.py>}
sys.stdout.write(‘please:‘)
1 >>> import sys
2 >>> sys.stdout.write(please:)
3 please:7

val = sys.stdin.readline()[:-1]

1 >>> import sys
2 >>> val = sys.stdin.readline()[:-1]
3 Hello World
4 >>> val
5 Hello World

5)shutil

高级的对文件、文件夹、压缩包处理的模块

 copyfile( src, dst)  从源src复制到dst中去。当然前提是目标地址是具备可写权限。抛出的异常信息为IOException. 如果当前的dst已存在的话就会被覆盖掉
 copymode( src, dst)  只是会复制其权限其他的东西是不会被复制的
 copystat( src, dst)  复制权限、最后访问时间、最后修改时间
 copy( src, dst)     复制一个文件到一个文件或一个目录
 copy2( src, dst)   在copy上的基础上再复制文件最后访问时间与修改时间也复制过来了,类似于cp –p的东西
 copy2( src, dst)   如果两个位置的文件系统是一样的话相当于是rename操作,只是改名;如果是不在相同的文件系统的话就是做move操作
 copytree(olddir,newdir,True/Flase)  把olddir拷贝一份newdir,如果第3个参数是True,则复制目录时将保持文件夹下的符号连接,如果第3个参数是False,则将在复制的目录下生成物理副本来替代符号连接

shutil.copyfileobj(fsrc, fdst[, length])

将文件内容拷贝到另一个文件中,可以部分内容

技术分享 View Code

shutil.copyfile(src, dst)
拷贝文件

技术分享 View Code

shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变

技术分享 View Code

shutil.copystat(src, dst)
拷贝状态的信息,包括:mode bits, atime, mtime, flags

技术分享 View Code

shutil.copy(src, dst)
拷贝文件和权限

技术分享 View Code

shutil.copy2(src, dst)
拷贝文件和状态信息

技术分享 View Code

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件

例如:copytree(source, destination, ignore=ignore_patterns(‘*.pyc‘, ‘tmp*‘))

技术分享 View Code

shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件

技术分享 View Code

shutil.move(src, dst)
递归的去移动文件

技术分享 View Code

shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径,例如:zip、tar

  • base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径,
    如:www                        =>保存至当前路径
    如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/
  • format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
  • root_dir: 要压缩的文件夹路径(默认当前目录)
  • owner: 用户,默认当前用户
  • group: 组,默认当前组
  • logger: 用于记录日志,通常是logging.Logger对象
1
2
3
4
5
6
7
8
9
#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录
 
import shutil
ret = shutil.make_archive("wwwwwwwwww"‘gztar‘, root_dir=‘/Users/wupeiqi/Downloads/test‘)
 
 
#将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录
import shutil
ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww"‘gztar‘, root_dir=‘/Users/wupeiqi/Downloads/test‘)
技术分享 View Code

shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的,详细:

技术分享 zipfile 压缩解压
技术分享 tarfile 压缩解压
技术分享 ZipFile
技术分享 TarFile 

 

6)json & pickle

用于序列化的两个模块

  • json,用于字符串和 python 数据类型间进行转换
  • pickle,用于 python 特有的类型和 python 数据类型间进行转换

Json 模块提供了四个功能:dumps、dump、loads、load

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

 

JSON 模块

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,易于阅读和编写,同时也易于机器解析和生成,它基于 JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999 的一个子集。 JSON采用完全独立于语言的文本格式,但是也使用了类似于C语言家族的习惯(包括C, C++, C#, Java, JavaScript, Perl, Python等)。 这些特性使JSON成为理想的数据交换语言。

Python3 中可以使用 json 模块来对 JSON 数据进行编解码,它包含了两个函数:

  1. json.dumps():对数据进行编码
  2. json.loads():对数据进行解码

json.dumps与json.loads实例

1 #!/usr/bin/env python
2 # -*- coding:UTF-8 -*-
3 
4 import json
5 # 将python的基础数据类型转化成字符串
6 dic = {"k1": "v1", "k2": "v2"}
7 print("Python原始数据:", repr(dic), type(dic))
8 result = json.dumps(dic)    # 将字典类型转换为字符串类型
9 print("JSON对象:", result, type(result))

输出结果:

1 Python原始数据: {k2: v2, k1: v1} <class dict>
2 JSON对象: {"k2": "v2", "k1": "v1"} <class str>

JSON 编码的字符串转换回 Python 数据结构

 1 #!/usr/bin/env python
 2 # -*- coding:UTF-8 -*-
 3 
 4 import json
 5 # 将 python 的基础数据类型转化成字符串
 6 dic = {"k1": "v1", "k2": "v2"}
 7 print("Python原始数据:", repr(dic), type(dic))
 8 result = json.dumps(dic)    # 将字典类型转换为字符串类型
 9 print("JSON对象:", result, type(result))
10 
11 # 将 python 字符串类型转化为 python 基本数据类型
12 result = json.loads(result)
13 print("result[‘k1‘]:", result[k1])
14 print("result[‘k2‘]:", result[k2])

输出结果:

1 Python原始数据: {k1: v1, k2: v2} <class dict>
2 JSON对象: {"k1": "v1", "k2": "v2"} <class str>
3 result[k1]: v1
4 result[k2]: v2

如果要处理的是文件而不是字符串,可以使用 json.dump() 和 json.load() 来编码和解码JSON数据

 1 #!/usr/bin/env python
 2 # -*- coding:UTF-8 -*-
 3 
 4 import json
 5 
 6 data = {
 7     name: "James",
 8     age: 24,
 9     job: "IT"
10 }
11 # 写入 json 数据
12 with open(db.json, w, encoding="UTF-8") as f:
13     json.dump(data, f)
14 
15 # 读取json数据
16 with open(db.json, r, encoding="UTF-8") as f:
17     res = json.load(f)
18     print(res,type(res))

输出结果:

1 {name: James, age: 24, job: IT} <class dict>

PICKLE 模块

pickle 模块使用的数据格式是 python 专用的,并且不同版本不向后兼容,同时也不能被其他语言说识别。要和其他语言交互,可以使用内置的 json 包使用 pickle 模块你可以把Python对象直接保存到文件,而不需要把他们转化为字符串,也不用底层的文件访问操作把它们写入到一个二进制文件里。 pickle模块会创建一个python语言专用的二进制格式,基本上不用考虑任何文件细节,它会帮你干净利落地完成读写独享操作,唯一需要的只是一个合法的文件句柄。

python3中可以使用pickle模块,对数据进行编解码。它包含两个函数:

  1. pickle.dumps()
  2. pickle.loads()

pickle.dumps与pickle.loads实例

 1 #!/usr/bin/env python
 2 # -*- coding:UTF-8 -*-
 3 
 4 import pickle
 5 
 6 data = {
 7     name: "James",
 8     age: 24,
 9     job: "IT"
10 }
11 
12 print("原始python对象:", repr(data))
13 r = pickle.dumps(data)
14 print("pickle转换后的对象:", r)
15 res = pickle.loads(r)
16 print("res[‘name‘]:", res[name])
17 print("res[‘age‘]:", res[age])
18 print("res[‘job‘]:", res[job])

输出结果:

1 原始python对象: {name: James, job: IT, age: 24}
2 pickle转换后的对象: b\\x80\\x03}q\\x00(X\\x04\\x00\\x00\\x00nameq\\x01X\\x05\\x00\\x00\\x00Jamesq\\x02X\\x03\\x00\\x00\\x00jobq\\x03X\\x02\\x00\\x00\\x00ITq\\x04X\\x03\\x00\\x00\\x00ageq\\x05K\\x18u.
3 res[name]: James
4 res[age]: 24
5 res[job]: IT

如果要处理的是文件而不是字符串,你可以使用 pickle.dump() 和 pickle.load() 来编码和解码JSON数据

 1 #!/usr/bin/env python
 2 # -*- coding:UTF-8 -*-
 3 
 4 import pickle
 5 
 6 data = {
 7     name: "James",
 8     age: 24,
 9     job: "IT"
10 }
11 # 写入数据,要以wb格式写入
12 pickle.dump(data, open(db, wb))
13 # 读取数据,要以rb格式读取
14 f = open(db, rb)
15 res = pickle.load(f)
16 print(res)

输出结果:

1 {name: James, age: 24, job: IT}

pickle和json的区别:

  • json 适合跨语言,对于 python 而言仅适用于 Python 基本数据类型
  • pickle 仅适用于 python,pickle 适用于 python 所有数据类型的序列化
  • pickle 写入和读取文件时,用的是 ‘b’模式,而 json 没有。
  • json 只能序列化最基本的数据类型,而 pickle 可以序列化所有的数据类型,包括类,函数都可以序列化。

7)shelve

8)xml 处理

9)yaml 处理

10)configparser

11) hashlib

12) subprocess

13) logging

14) re 正则表达式

 

本节作业

开发一个简单的python计算器

  1. 实现加减乘除及拓号优先级解析
  2. 用户输入 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后,必须自己解析里面的(),+,-,*,/符号和公式(不能调用eval等类似功能偷懒实现),运算后得出结果,结果必须与真实的计算器所得出的结果一致

 

hint:

re.search(r‘\\([^()]+\\)‘,s).group()

‘(-40/5)‘















以上是关于Day05 - Python 常用模块的主要内容,如果未能解决你的问题,请参考以下文章

Python自动化基础day05:Python常用模块学习

Python基础-常用模块-day05-2

Day5 模块及Python常用模块

Python 之路 Day5 - 常用模块学习

Python 之路 Day5 - 常用模块学习

Day5 - Python基础5 常用模块学习