一、time & datetime
在Python中，通常有这几种方式来表示时间：
- 时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
- 格式化的时间字符串(Format String)
- 结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)
time模块：
import time
#--------------------------我们先以当前时间为准,让大家快速认识三种形式的时间
print(time.time()) # 时间戳:1487130156.419527
print(time.strftime("%Y-%m-%d %X")) #格式化的时间字符串:'2017-02-15 11:40:53'
print(time.localtime()) #本地时区的struct_time
print(time.gmtime()) #UTC时区的struct_time
# localtime([secs])
# 将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准
print(time.localtime(1473525444.037215))
#输出：time.struct_time(tm_year=2016, tm_mon=9, tm_mday=11, tm_hour=0, tm_min=37, tm_sec=24, tm_wday=6, tm_yday=255, tm_isdst=0)
print(time.localtime()) #返回本地时间的struct time对象格式
#输出：time.struct_time(tm_year=2018, tm_mon=1, tm_mday=20, tm_hour=9, tm_min=39, tm_sec=32, tm_wday=5, tm_yday=20, tm_isdst=0)
t = time.localtime()
print(t.tm_year, t.tm_mon) #2018 1
# mktime(t) : 将一个struct_time转化为时间戳。
print(time.mktime(time.localtime())) #1516412372.0
# gmtime([secs]) 和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。
print(time.gmtime()) #UTC时区的struct_time
#time.struct_time(tm_year=2018, tm_mon=1, tm_mday=20, tm_hour=1, tm_min=39, tm_sec=32, tm_wday=5, tm_yday=20, tm_isdst=0)
# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。
# 如果没有参数，将会将time.localtime()作为参数传入
print(time.asctime()) #返回时间格式"Sat Jan 20 09:39:32 2018"
# ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。
# 如果参数未给或者为None的时候，将会默认time.time()为参数。此时它的作用相当于time.asctime(time.localtime(secs))
print(time.ctime()) #返回Sat Jan 20 09:39:32 2018 格式, 同上
print(time.ctime(time.time())) #返回Sat Jan 20 09:39:32 2018 格式, 同上
#strftime(format[, t]) : 把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）
#转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个
#元素越界，ValueError的错误将会被抛出。
struct_time = time.localtime(time.time()-86400) #减了一天
print(time.strftime("%Y-%m-%d %H:%M:%S", struct_time)) #2018-01-19 09:39:32
print(time.strftime("%Y-%m-%d %H:%M:%S")) #2018-01-20 09:39:32
#日期字符串 转成 时间戳 两步
string_2_struct = time.strptime("2018-01-04", "%Y-%m-%d") #1、将 日期字符串 转成 struct时间对象格式
print(string_2_struct)
#time.struct_time(tm_year=2018, tm_mon=1, tm_mday=4, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=4, tm_isdst=-1)
struct_2_stamp = time.mktime(string_2_struct) #2、将struct时间对象转成时间戳
print(struct_2_stamp) #1514995200.0
#将时间戳转为字符串格式 两步
#print(time.gmtime(time.time())) #将utc时间戳转换成struct_time格式
#print(time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式
string_struct = time.localtime(1473525444.037215) #1、将时间戳转换成struct_time格式
print(time.strftime("%Y-%m-%d %H:%M:%S", string_struct)) #2、通过strftime将struct_time转换为格式化的时间字符串 2016-09-11 00:37:24
print(time.strftime("%Y-%m-%d %X", time.localtime())) #本地时间2018-01-20 10:08:51
以下是格式化字符串的时间格式：
| Directive | Meaning | Notes |
|---|---|---|
%a |
Locale’s abbreviated weekday name. | |
%A |
Locale’s full weekday name. | |
%b |
Locale’s abbreviated month name. | |
%B |
Locale’s full month name. | |
%c |
Locale’s appropriate date and time representation. | |
%d |
Day of the month as a decimal number [01,31]. | |
%H |
Hour (24-hour clock) as a decimal number [00,23]. | |
%I |
Hour (12-hour clock) as a decimal number [01,12]. | |
%j |
Day of the year as a decimal number [001,366]. | |
%m |
Month as a decimal number [01,12]. | |
%M |
Minute as a decimal number [00,59]. | |
%p |
Locale’s equivalent of either AM or PM. | (1) |
%S |
Second as a decimal number [00,61]. | (2) |
%U |
Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0. | (3) |
%w |
Weekday as a decimal number [0(Sunday),6]. | |
%W |
Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0. | (3) |
%x |
Locale’s appropriate date representation. | |
%X |
Locale’s appropriate time representation. | |
%y |
Year without century as a decimal number [00,99]. | |
%Y |
Year with century as a decimal number. | |
%z |
Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59]. | |
%Z |
Time zone name (no characters if no time zone exists). | |
%% |
A literal '%' character. |
datetime模块
import datetime
print(datetime.datetime.now()) #返回当前时间 2018-01-04 18:16:14.648327
print(datetime.date.fromtimestamp(time.time())) #时间戳直接转成日期格式 2018-01-04
print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天 2018-01-07 18:16:14.648327
print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天 2018-01-01 18:16:14.648327
print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时 2018-01-04 21:16:14.648327
print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分 2018-01-04 18:46:14.648327
c_time = datetime.datetime.now()
print(c_time.replace(minute=3, hour=2)) #时间替换 2018-01-04 02:03:14.648327
二、random模块
#随机数模块
import random
print(random.random()) #(0,1)----float 大于0且小于1之间的小数
print(random.uniform(1, 3)) #大于1小于3的小数 如1.927109612082716
print(random.randint(1, 3)) #[1,3] 大于等于1且小于等于3之间的随机整数
print(random.randrange(1, 3)) #[1,3) 大于等于1且小于3之间的整数
print(random.randrange(1, 10, 2)) #这个还可以加步长
print(random.choice([1, "23", [4, 5]])) #随机选择 1或者23或者[4,5]
print(random.sample([1, 2, 3, 4, 5, 6, 6], 2)) #从前面的列表中随机调两个
print(random.sample(range(100), 5)) #随机取5个数据
print(random.sample([1, '23', [4, 5]], 2)) #列表元素任意2个组合
item = [1, 3, 5, 7, 9]
random.shuffle(item) #打乱item的顺序,相当于"洗牌"
print(item)
#验证码1
checkcode = ''
for i in range(4):
current = random.randrange(0, 4)
if current != i:
temp = chr(random.randint(65, 90)) #ascll表里面65到90的字符
else:
temp = random.randint(0, 9)
checkcode += str(temp)
print(checkcode)
三、string模块
import string
print(string.ascii_uppercase) #输出26个大写字母 ABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.ascii_letters) #输出所有大写和小写字母 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
print(string.ascii_lowercase) #输出26个小写字母 abcdefghijklmnopqrstuvwxyz
print(string.digits) #输出所有数字 0123456789
print(string.digits+string.ascii_lowercase) # 0123456789abcdefghijklmnopqrstuvwxyz
#验证码2
source = string.digits+string.ascii_lowercase
print("".join(random.sample(source, 6))) #pgrkj8
print(random.sample(source, 6)) #['j', 'x', '7', '1', 'f', 'w']
四、json & pickle 模块
之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
import json
x = "[null,true,false,1]"
#print(eval(x)) #报错，无法解析null类型，而json就可以
print(json.loads(x)) #输出：[None, True, False, 1]
print(x) #输出：[null,true,false,1]
什么是序列化？
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
为什么要序列化？
1：持久保存状态
需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，'状态'会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。
内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。
具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。
2：跨平台数据交互
序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。
JSON 模块提供了四个方法： dumps、dump、loads、load
序列化方法：
反序列化方法：
loads 只完成了反序列化，
内存中的结构化数据 <----> json格式 <----> 字符串 <----> 保存到文件中或基于网络传输
import json
dic = {'name': 'alvin', 'age': 23, 'sex': 'male'}
print(type(dic)) # <class 'dict'>
j = json.dumps(dic)
print(type(j)) # <class 'str'>
print(j) # {"name": "alvin", "age": 23, "sex": "male"}跟dic对比一下，参照上图
# --------------序列化---------------
f = open('序列化对象', 'w')
#f.write(j) # 等价于json.dump(dic,f)
json.dump(dic, f，indent=4)
f.close()
# --------------反序列化---------------
import json
f = open('序列化对象')
data = json.loads(f.read()) # 等价于data=json.load(f)
print(data) # {'age': 23, 'sex': 'male', 'name': 'alvin'}跟j对比，参照上图
文件： 序列化对象：（加上indent=4）
{
"age": 23,
"name": "alvin",
"sex": "male"
}
序列化对象：（没有加上indent）
{"sex": "male", "name": "alvin", "age": 23}
json 和 picle 模块
json模块和picle模块都有 dumps、dump、loads、load四种方法，而且用法一样。
不同的是json模块序列化出来的是通用格式，其它编程语言都认识，就是普通的字符串，
而picle模块序列化出来的只有python可以认识，其他编程语言不认识的，表现为乱码
不过picle可以序列化函数，但是其他文件想用该函数，在该文件中需要有该文件的定义（定义和参数必须相同，内容可以不同）
python对象（obj） 与json对象的对应关系
+-------------------+---------------+
| Python | JSON |
+===================+===============+
| dict | object |
+-------------------+---------------+
| list, tuple | array |
+-------------------+---------------+
| str | string |
+-------------------+---------------+
| int, float | number |
+-------------------+---------------+
| True | true |
+-------------------+---------------+
| False | false |
+-------------------+---------------+
| None | null |
+-------------------+---------------+
五、logging模块
1.日志级别
CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置
2.默认级别为warning，默认打印到终端
import logging
logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')
'''
输出:
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''
3.为logging模块指定全局配置，针对所有logger有效，控制打印到文件中
可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有:
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
日志格式：
|
%(name)s |
Logger的名字 |
|
%(levelno)s |
数字形式的日志级别 |
|
%(levelname)s |
文本形式的日志级别 |
|
%(pathname)s |
调用日志输出函数的模块的完整路径名，可能没有 |
|
%(filename)s |
调用日志输出函数的模块的文件名 |
|
%(module)s |
调用日志输出函数的模块名 |
|
%(funcName)s |
调用日志输出函数的函数名 |
|
%(lineno)d |
调用日志输出函数的语句所在的代码行 |
|
%(created)f |
当前时间，用UNIX标准的表示时间的浮 点数表示 |
|
%(relativeCreated)d |
输出日志信息时的，自Logger创建以 来的毫秒数 |
|
%(asctime)s |
字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒 |
|
%(thread)d |
线程ID。可能没有 |
|
%(threadName)s |
线程名。可能没有 |
|
%(process)d |
进程ID。可能没有 |
|
%(message)s |
用户输出的消息 |
用法：
#test.py
#========使用
import logging
logging.basicConfig(filename='access.log',
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S %p',
level=10)
logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')
#========结果
access.log内容:
2017-07-28 20:32:17 PM - root - DEBUG -test: 调试debug
2017-07-28 20:32:17 PM - root - INFO -test: 消息info
2017-07-28 20:32:17 PM - root - WARNING -test: 警告warn
2017-07-28 20:32:17 PM - root - ERROR -test: 错误error
2017-07-28 20:32:17 PM - root - CRITICAL -test: 严重critical
level=10 就相当于 level=loggin.DEBUG
level=loggin.DEBUG意思是，把日志纪录级别设置为DEBUG，也就是说，只有日志是DEBUG或比DEBUG级别更高的日志才会被纪录到文件里（加filename
参数就会写到文件里，不加就会打印到终端）
4.logging模块的Formatter，Handler，Logger，Filter对象
如果想同时把log打印在屏幕和文件日志里，就需要了解一点复杂的知识 了
Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：
logger 提供了应用程序可以直接使用的接口；
handler 将(logger创建的)日志记录发送到合适的目的输出；
filter 提供了细度设备来决定输出哪条日志记录；
formatter 决定日志记录的最终输出格式。
logger
每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：
LOG=logging.getLogger(”chat.gui”)
而核心模块可以这样：
LOG=logging.getLogger(”chat.kernel”)
Logger.setLevel(lel)：指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt)：添加或删除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别
handler
handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以
把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个handler
Handler.setLevel(lel)：指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()：给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象
每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
1) logging.StreamHandler
使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
StreamHandler([strm])
其中strm参数是一个文件对象。默认是sys.stderr
2) logging.FileHandler
和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
FileHandler(filename[,mode])
filename是文件名，必须指定一个文件名。
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。
3) logging.handlers.RotatingFileHandler
这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日
志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已
经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。
它的构造函数是：RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])，
其中filename和mode两个参数和FileHandler一样。maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这
时上面描述的重命名过程就不会发生。backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的
chat.log.2并不会被更名，而是被删除。
4) logging.handlers.TimedRotatingFileHandler
这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。
重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。
它的构造函数是：TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。interval是时间间隔。
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：S 秒、M 分、H 小时、D 天、W 每星期（interval=0时代表星期一）
midnight 每天凌晨
举个栗子：
import logging
# create logger
logger = logging.getLogger('getLogger')
logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.NOTSET)
# create file handler and set level to WARNING
fh = logging.FileHandler("FileHandler.log")
fh.setLevel(logging.WARNING)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# add formatter to ch and fh
ch.setFormatter(formatter)
fh.setFormatter(formatter)
# add ch and fh to logger
logger.addHandler(ch)
logger.addHandler(fh)
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')
#控制台输出：
2018-01-23 17:40:06,285 - getLogger - DEBUG - debug message
2018-01-23 17:40:06,285 - getLogger - INFO - info message
2018-01-23 17:40:06,285 - getLogger - WARNING - warn message
2018-01-23 17:40:06,285 - getLogger - ERROR - error message
2018-01-23 17:40:06,286 - getLogger - CRITICAL - critical message
#FileHandler.log
2018-01-23 17:40:06,285 - getLogger - WARNING - warn message
2018-01-23 17:40:06,285 - getLogger - ERROR - error message
2018-01-23 17:40:06,286 - getLogger - CRITICAL - critical message
这两处的差异得看日志等级的设置
文件自动截断的栗子：
import logging
from logging import handlers
logger = logging.getLogger(__name__) #获取本模块名
log_file = "timelog.log"
fh = handlers.RotatingFileHandler(filename=log_file, maxBytes=10, backupCount=2)
#fh = handlers.TimedRotatingFileHandler(filename=log_file, when="S", interval=5, backupCount=3)
formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")
六、os模块
os模块是与操作系统交互的一个接口
os.getcwd() #获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") #改变当前脚本工作目录；相当于shell下cd
os.curdir #返回当前目录: ('.')
os.pardir #获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2') #可生成多层递归目录
os.removedirs('dirname1') #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') #生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') #删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() #删除一个文件
os.rename("oldname","newname") #重命名文件/目录
os.stat('path/filename') #获取文件/目录信息
os.sep #输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep #输出当前平台使用的行终止符，win下为"
",Linux下为"
"
os.pathsep #输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name #输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")#运行shell命令，直接显示
os.environ #获取系统环境变量
os.path.abspath(path) #返回path规范化的绝对路径
os.path.split(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.join(path1[, path2[, ...]]) #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) #返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) #返回path的大小
七、sys模块
sys.argv #命令行参数List，第一个元素是程序本身路径
sys.exit(n) #退出程序，正常退出时exit(0)
sys.version #获取Python解释程序的版本信息
sys.maxint #最大的Int值
sys.path #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform #返回操作系统平台名称