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 I‘m Pots Phone 2 I‘m 3G Phone 3 I‘m 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是一个全局字典，该字典是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 Codeshutil.copyfile(src, dst)
拷贝文件
View Codeshutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
View Codeshutil.copystat(src, dst)
拷贝状态的信息，包括：mode bits, atime, mtime, flags
View Codeshutil.copy(src, dst)
拷贝文件和权限
View Codeshutil.copy2(src, dst)
拷贝文件和状态信息
View Codeshutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件
例如：copytree(source, destination, ignore=ignore_patterns(‘*.pyc‘, ‘tmp*‘))
View Codeshutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
View Codeshutil.move(src, dst)
递归的去移动文件
View Codeshutil.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 shutilret = shutil.make_archive("wwwwwwwwww", ‘gztar‘, root_dir=‘/Users/wupeiqi/Downloads/test‘)#将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录import shutilret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", ‘gztar‘, root_dir=‘/Users/wupeiqi/Downloads/test‘) |
View Codeshutil 对压缩包的处理是调用 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 数据进行编解码，它包含了两个函数:
- json.dumps()：对数据进行编码
- 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模块，对数据进行编解码。它包含两个函数：
- pickle.dumps()
- 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 * ( (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 常用模块的主要内容，如果未能解决你的问题，请参考以下文章