Python的内置包(一)

一.OS模块

一).OS模块的概念:

Python os模块是Python提供的访问操作系统功能的模块，如打开、读、写、关闭文件，访问目录等等。使用os模块Python开发者可以方便的开发出跨平台的软件。
使用os模块可以做到：

• 1、方便的调用操作系统的基本功能
• 2、开发跨平台的软件
• 3、os模块是操作系统相关功能的轻量级封装，对于特定的复杂功能还是应该使用专用的模块。如：只想读取或写入文件，可以使用os.open()，如果要操作路径， 可以使用os.path模块；但，如果要在命令行上，读取所有文件中的所有行，请使用fileinput 模块；创建临时文件和目录的信息，可以使用tempfile 模块，高级文件和目录处理可以使用shutil 模块。

二. OS基本操作

1.获取当前 的目录

• os.curdir 打印出来 . 相对路径

import os
os.curdir
'.'

2.获取当前工作目录

• os.getcwd() 绝对路径

import os
os.getcwd()
'/home/jiang/PycharmProjects/111'

3.获取当前目录下的所有的文件名
fileNames=os.listdir()
fileNames=os.listdir(r'd:\codes')

import os
os.listdir()
['回调函数3.py', 'nonloca_text.py', '回调函数2.py', '回调函数.py', '.idea', '222.txt']
os.listdir('/home/jiang/PycharmProjects/111')
['回调函数3.py', 'nonloca_text.py', '回调函数2.py', '回调函数.py', '.idea', '222.txt']

4.创建目录
os.mkdir(r'd:\xxx') #在绝对路径下创建目录，如果已经存在，会把异常

import os
os.mkdir('/home/jiang/PycharmProjects/111/os_test.py')
os.mkdir('os_test01.py')

5.修改目录
os.rename('修改前','修改后')

os.rename('os_test.py','os_test02.py')
os.listdir()
['os_test02.py', '回调函数3.py', 'nonloca_text.py', 'os_test01.py', '回调函数2.py', '回调函数.py', '.idea', '222.txt']

6.删除目录和文件

删除目录 os.rmdir()

删除文件 os.remove()

# 删除目录 os.rmdir()
os.rmdir('os_test01.py')
os.listdir()
['os_test02.py', '回调函数3.py', 'nonloca_text.py', '回调函数2.py', '回调函数.py', '.idea', '222.txt']

# 删除文件 os.remove()
os.listdir()
['回调函数3.py', 'nonloca_text.py', 'os_test.py', '回调函数2.py', '回调函数.py', '.idea', '222.txt']
os.remove('os_test.py')
os.listdir()
['回调函数3.py', 'nonloca_text.py', '回调函数2.py', '回调函数.py', '.idea', '222.txt']

7.获取文件的属性
os.stat('xxx.txt') #返回各种文件的状态信息

• st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
• st_atime: 上次访问的时间。
• st_mtime: 最后一次修改的时间。
• st_ctime: 由操作系统报告的"ctime",一般为创建时间

os.stat('os_test.txt')
os.stat_result(st_mode=33204, st_ino=944347, st_dev=2049, st_nlink=1, st_uid=1000, st_gid=1000, st_size=0, st_atime=1534328554, st_mtime=1534328554, st_ctime=1534328554)

8.路径的拼接与分割

• 在当前目录下获取文件的绝对路径
  os.path.abspath('xxx.txt')

• 拼接路径
  absPaht = os.path.join(os.getcwd(), 'hahaha.txt')

• 分割路径
  os.path.split(absPath)

# 在当前目录下获取文件的绝对路径
os.path.abspath('os_test.txt')
'/home/jiang/PycharmProjects/111/os_test.txt'
# 拼接路径 
abspath = os.path.join(os.getcwd(),'os_test.py')
abspath
'/home/jiang/PycharmProjects/111/os_test.py'
 # 分割路径
os.path.split(abspath)
('/home/jiang/PycharmProjects/111', 'os_test.py')

9.判断是否是文件、目录以及是否存在

• 判断是否是目录
  os.path.isdir(path)
• 判断是否是文件
  os.path.isFile(path)
• 判断是否存在
  os.path.exists(path)

import os
os.listdir()
['os_test', '回调函数3.py', 'nonloca_text.py', 'os_test.py', '回调函数2.py', 'os_test.txt', '回调函数.py', '.idea', '222.txt']
# 判断是否是目录
os.path.isdir('nonloca_text.py')
False
os.path.isdir('os_test')
True
# 判断是否是文件
os.path.isfile('os_test.py')
True
# 判断是否存在
os.path.exists('回调函数3.py')
True
os.path.exists('os_test')
True

10. 获取文件的路径的目录
    os.path.dirname(path1) # 返回文件的目录
    os.path.basename(path1) # 返回文件名

os.listdir()
['os_test', '回调函数3.py', 'nonloca_text.py', 'os_test.py', '回调函数2.py', 'os_test.txt', '回调函数.py', '.idea', '222.txt']
# 获取文件的路径的目录
os.path.dirname('os_test.py')
''
os.path.basename('os_test.py')
'os_test.py'

11.拓展
os.path.getsize(path) 返回path的大小
os.path.getatime() 返回目录最后存取时间
os.path.getmtime() 返回最后修改时间
os.getpid() 获取当前进程id
os.getppid() 获取当前进程id的上一级进程id

os.path.getsize('nonloca_text.py')
374
os.path.getatime('nonloca_text.py')
1534251977.7073188
os.path.getmtime('nonloca_text.py')
1534251977.1993375
os.getpid()
8470
os.getppid()
3350

二. datatime 模块

一). 基本介绍

datetime模块用于是date和time模块的合集，datetime有两个常量，MAXYEAR和MINYEAR，分别是9999和1.
datetime模块定义了5个类，分别是:

• datetime.date：表示日期的类
• datetime.datetime：表示日期时间的类
• datetime.time：表示时间的类
• datetime.timedelta：表示时间间隔，即两个时间点的间隔

• datetime.tzinfo：时区的相关信息 #不常用

  
  
  

  datetime.png
  
  

  (/home/jiang/图片/datetime.png)

二).具体用法

1. date类

datetime.date(year, month, day)

• 静态方法和字段
  • date.max、date.min：date对象所能表示的最大、最小日期；
  • date.resolution：date对象表示日期的最小单位。这里是天。
  • date.today()：返回一个表示当前本地日期的date对象；
  • date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；

from datetime import *
import time

data_max = date.max
print('date.max:',data_max)

data_min = date.min
print('date.min:',data_min)

data_today = date.today()
print('data_today:',data_today)

data_resolution = date.resolution
print('data_resolution:',data_resolution)

data_fromtimestamp = date.fromtimestamp(time.time())
print('data_fromtimestamp:',data_fromtimestamp)

=====================
date.max: 9999-12-31
date.min: 0001-01-01
data_today: 2018-08-15
data_resolution: 1 day, 0:00:00
data_fromtimestamp: 2018-08-15

• 方法和属性
  d1 = date(2018,8,15)#date对象
  d1.year、date.month、date.day：年、月、日；
  d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
  d1.timetuple()：返回日期对应的time.struct_time对象；
  d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
  d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
  d1.isocalendar()：返回格式如(year，month，day)的元组；
  d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
  d1.strftime(fmt)：和time模块format相同。

from datetime import *
import time

now = date(2018,8,15)

print('年:',now.year,'月:',now.month,'日:',now.day)
tomorrow = now.replace(day=16)
print('now.timetuple():',now.timetuple())
print('星期几:',now.weekday()) # 返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
print('星期几:',now.isoweekday()) # 返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；

print('now.isocalendar()',now.isocalendar())
print('now.isoformat()',now.isoformat())
print('now.strftime(fmt)',now.strftime('%Y-%m-%d'))
=================
年: 2018 月: 8 日: 15
now.timetuple(): time.struct_time(tm_year=2018, tm_mon=8, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=227, tm_isdst=-1)
星期几: 2
星期几: 3
now.isocalendar() (2018, 33, 3)
now.isoformat() 2018-08-15
now.strftime(fmt) 2018-08-15

2. datetime类

datetime相当于date和time结合起来。
datetime.datetime (year, month, day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )

• 静态方法和字段
  • 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)：根据date和time，创建一个datetime对象；
  • datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；

from datetime import *
import time

print('datetime.today():',datetime.today())
print('datetime.now():',datetime.now())
print('datetime.utcnow():',datetime.utcnow())
print('datetime.fromtimestamp():',datetime.fromtimestamp(time.time()))

print('datetime.utcfromtimestamp():',datetime.utcfromtimestamp(time.time()))

=================
datetime.today(): 2018-08-15 20:07:50.806633
datetime.now(): 2018-08-15 20:07:50.806746
datetime.utcnow(): 2018-08-15 12:07:50.806777
datetime.fromtimestamp(): 2018-08-15 20:07:50.806790
datetime.utcfromtimestamp(): 2018-08-15 12:07:50.806801

• 方法和属性
  dt=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)：
  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)

from datetime import *
import time

dt = datetime.now()
print('年-月-日-时:分:秒:毫秒:',dt.year,dt.month,dt.day,dt.hour,dt.minute,dt.second,dt.microsecond)
print(tzinfo)
print('dt.date():',dt.date())
print('dt.time():',dt.time())
print('dt.timetuple():',dt.timetuple())
print('dt.utctimetuple():',dt.utctimetuple())
print('dt.toordinal():',dt.toordinal())
print('dt.weekday():',dt.weekday())
print('dt.isocalendar():',dt.isocalendar())
print('dt.isoformat():',dt.isoformat())
print('dt.ctime():',dt.ctime())
print('dt.strftime():',dt.strftime(str(time.time())))
print('dt.replace():',dt.replace(2018,8,16,21,24,45,56))
======================
年-月-日-时:分:秒:毫秒: 2018 8 15 20 26 49 211926

dt.date(): 2018-08-15
dt.time(): 20:26:49.211926
dt.timetuple(): time.struct_time(tm_year=2018, tm_mon=8, tm_mday=15, tm_hour=20, tm_min=26, tm_sec=49, tm_wday=2, tm_yday=227, tm_isdst=-1)
dt.utctimetuple(): time.struct_time(tm_year=2018, tm_mon=8, tm_mday=15, tm_hour=20, tm_min=26, tm_sec=49, tm_wday=2, tm_yday=227, tm_isdst=0)
dt.toordinal(): 736921
dt.weekday(): 2
dt.isocalendar(): (2018, 33, 3)
dt.isoformat(): 2018-08-15T20:26:49.211926
dt.ctime(): Wed Aug 15 20:26:49 2018
dt.strftime(): 1534336009.2120526
dt.replace(): 2018-08-16 21:24:45.000056

3. time类

datetime.time(hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] )
time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；

• 方法和属性
  t1 = time(10,23,15)#time对象
  t1.hour、t1.minute、t1.second、t1.microsecond：时、分、秒、微秒；
  t1.tzinfo：时区信息；
  t1.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
  t1.isoformat()：返回型如"HH:MM:SS"格式的字符串表示；
  t1.strftime(fmt)：同time模块中的format；

from datetime import *

tm = time(21,6,56,10)
print('时:分:秒:毫秒:',tm.hour,tm.minute,tm.second,tm.microsecond)
print('tm.tzinfo:',tm.tzinfo)
print('tm.replace:',tm.replace(22,13,25,96))
print('tm.isoformat:',tm.isoformat())
print('tm.strftime:',tm.strftime("%X"))
========================
时:分:秒:毫秒: 21 6 56 10
tm.tzinfo: None
tm.replace: 22:13:25.000096
tm.isoformat: 21:06:56.000010
tm.strftime: 21:06:56

4. timedelta类，时间加减

使用timedelta可以很方便的在日期上做天days，小时hour，分钟，秒，毫秒，微妙的时间计算，如果要计算月份则需要另外的办法。

from datetime import *

dt = datetime.now()
# 日期减一天

dt1 = dt + timedelta(days=-1)  #昨天
dt2 = dt - timedelta(days=1)   #昨天
dt3 = dt + timedelta(days=1)  #明天
delta_obj = dt3-dt

print(type(delta_obj),delta_obj)

print(delta_obj.days,delta_obj.total_seconds())
================
 1 day, 0:00:00
1 86400.0

5. tzinfo时区类

from datetime import datetime, tzinfo,timedelta

"""
tzinfo是关于时区信息的类
tzinfo是一个抽象类，所以不能直接被实例化
"""
class UTC(tzinfo):
    """UTC"""
    def __init__(self,offset = 0):
        self._offset = offset

    def utcoffset(self, dt):
        return timedelta(hours=self._offset)

    def tzname(self, dt):
        return "UTC +%s" % self._offset

    def dst(self, dt):
        return timedelta(hours=self._offset)

#北京时间
beijing = datetime(2011,11,11,0,0,0,tzinfo = UTC(8))
print ("beijing time:",beijing)
#曼谷时间
bangkok = datetime(2011,11,11,0,0,0,tzinfo = UTC(7))
print ("bangkok time",bangkok)
#北京时间转成曼谷时间
print ("beijing-time to bangkok-time:",beijing.astimezone(UTC(7)))

#计算时间差时也会考虑时区的问题
timespan = beijing - bangkok
print ("时差:",timespan)
=============================
beijing time: 2011-11-11 00:00:00+08:00
bangkok time 2011-11-11 00:00:00+07:00
beijing-time to bangkok-time: 2011-11-10 23:00:00+07:00
时差: -1 day, 23:00:00

time 模块

ime模块中时间表现的格式主要有三种：

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

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

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

time.png

1. 时间格式转换图

time_gs.png

2. 主要time生成方法和time格式转换方法实例

• 基本概念
  时间戳:以整型或者浮点型来表示一个时间间隔,以1970年1月1日0点0分0秒为参考时间;
  时间元组: 一种python的数据结构,有九个整型内容
  字符串形式:2017/10/19, 2017-10-19, 10:15:54, 20171018

  • 获取当前时间戳
    time.time()

  • 获取当地时间
    time.localtime()

  • 把时间戳转成时间元组 gmtime
    time.gmtime(time.time())

  • 把时间元组转成时间戳

    time.mktime(timeTuple)

  • 把时间元组转成字符串

    time.strftime()
    time.strftime('%Y-%M-%d %H:%M:%S',timeTuple)　-->把时间元组转成这种格式的字符串

  • 把时间字符串转成时间元组
    time.strptime()

    st = '2018-10-12'
    st2 = '2018/10/13'

    t_1 = time.strptime(st, '%Y-%m-%d') -->前面参数是字符串，后面参数是字符串的格式
    t_2 = time.strptime(st2, '%Y/%m/%d')

  • 把时间戳转成字符串
    time.ctime()

import time

# 获取当前时间戳(timestamp)
t = time.time()
print('获取当前时间戳:',t)

# 获取当地时间(struct_time
s_t = time.localtime(time.time())
print('获取当地时间:',s_t)

# 把时间戳转成时间元组  gmtime
t_g = time.gmtime(time.time())
print('把时间戳转成时间元组:',t_g)

# 把时间元组转成时间戳   mktime(timeTuple)
t_m = time.mktime(t_g)
print('把时间戳转成时间元组:',t_m)
# 把时间元组转成字符串    time.strftime()
t_s = time.strftime("%Y-%m-%d %X",time.localtime())

print('把时间元组转成字符串:',t_s)

# 生成固定格式的时间表示格式
t_a = time.asctime(time.localtime())
print('生成固定格式的时间表示格式',t_a)

# 把时间戳转成字符串  time(time.time())
t_c = time.ctime(time.time())
print('把时间戳转成字符串',t_c)
====================
获取当前时间戳: 1534421104.0705442
获取当地时间: time.struct_time(tm_year=2018, tm_mon=8, tm_mday=16, tm_hour=20, tm_min=5, tm_sec=4, tm_wday=3, tm_yday=228, tm_isdst=0)
把时间戳转成时间元组: time.struct_time(tm_year=2018, tm_mon=8, tm_mday=16, tm_hour=12, tm_min=5, tm_sec=4, tm_wday=3, tm_yday=228, tm_isdst=0)
把时间戳转成时间元组: 1534392304.0
把时间元组转成字符串: 2018-08-16 20:05:04
生成固定格式的时间表示格式 Thu Aug 16 20:05:04 2018
把时间戳转成字符串 Thu Aug 16 20:05:04 2018

3. struct_time元组元素结构

属性	值
tm_year（年）	比如2018
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

4. format time结构化表示

格式	含义
%a	本地（locale）简化星期名称
%A	本地完整星期名称
%b	本地简化月份名称
%B	本地完整月份名称
%c	本地相应的日期和时间表示
%d	一个月中的第几天（01 - 31）
%H	一天中的第几个小时（24小时制，00 - 23）
%I	第几个小时（12小时制，01 - 12）
%j	一年中的第几天（001 - 366）
%m	月份（01 - 12
%M	分钟数（00 - 59）
%p	本地am或者pm的相应符
%S	秒（01 - 61
%U	一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。
%w	和%U基本相同，不同的是%W以星期一为一个星期的开始。
%x	本地相应日期
%X	本地相应时间
%y	去掉世纪的年份（00 - 99）
%Y	完整的年份
%Z	时区的名字（如果不存在为空字符）
%%	‘%’字符

5. time加减

import time
t1 = time.time()
t2=t1+10
===============
time.ctime(): 1534422377.9069533
time.ctime(): 1534422387.9069533