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
  1. 获取文件的路径的目录
    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
<class 'datetime.tzinfo'>
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())
================
<class 'datetime.timedelta'> 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

推荐阅读更多精彩内容