Python OS 模块

待我称王封你为后i 2023-09-29 22:21 17阅读 0赞

## 1、os 模块 ##

OS 模块（operating system），意为操作系统，是 python 处理文件系统的常用模块，因为 python 是跨平台的，所以使用 os 模块，不用担心操作系统使用什么模块，os 模块会帮你选择正确的模块并调用。

> **OS 模块中关于文件/ 目录常用函数的使用方法：**

<table> 
 <thead> 
  <tr> 
   <th align="center">函数名</th> 
   <th align="center">使用方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">getcwd（）</td> 
   <td align="center">返回当前工作目录</td> 
  </tr> 
  <tr> 
   <td align="center">chdir（）</td> 
   <td align="center">改变工作目录</td> 
  </tr> 
  <tr> 
   <td align="center">listdir（path=‘.’）</td> 
   <td align="center">列举指定目录中的文件名（‘.’ 表示当前目录，‘…’ 表示上一级目录）</td> 
  </tr> 
  <tr> 
   <td align="center">mkdir（）</td> 
   <td align="center">创建目录（文件夹），如该目录存在，抛出 FileExistsError 异常</td> 
  </tr> 
  <tr> 
   <td align="center">makedirs（）</td> 
   <td align="center">创建多层目录，如果存在，抛出异常</td> 
  </tr> 
  <tr> 
   <td align="center">remove（）</td> 
   <td align="center">删除文件</td> 
  </tr> 
  <tr> 
   <td align="center">rmdir（path）</td> 
   <td align="center">删除单层目录，如果该目录非空则抛出异常</td> 
  </tr> 
  <tr> 
   <td align="center">removedirs（path）</td> 
   <td align="center">删除多层目录，遇到非空抛出异常</td> 
  </tr> 
  <tr> 
   <td align="center">rename（old，new）</td> 
   <td align="center">将文件 old 重命名为 new</td> 
  </tr> 
  <tr> 
   <td align="center">system（command）</td> 
   <td align="center">运行系统的 shell 命令</td> 
  </tr> 
 </tbody> 
</table>

### 1.1、getcwd（） ###

获取当前工作目录：

>>> import os
    >>> os.getcwd()
    'C:\\Users\\hj\\AppData\\Local\\Programs\\Python\\Python36-32'

### 1.2、chdir（path） ###

改变当前工作目录，如切换到 E 盘（需要注意的是，windows 系统的文件路径是双反斜杠：\\）

# 改变目录时，可以先查看当前工作目录，再改变，最后查看是否修改成功
    >>> os.getcwd()
    'C:\\Users\\hj\\AppData\\Local\\Programs\\Python\\Python36-32'
    >>> os.chdir('E:\\')
    >>> os.getcwd()
    'E:\\'

### 1.3、listdir（path=‘.’） ###

可以帮助知道当前工作目录下有哪些文件和子目录，它会帮你列举出来，path 参数用于指定列举的目录，默认值为 ‘.’ ，代表当前目录，也可以使用 ‘…’ ，代表上一层目录：

# 我的 D 盘目录下有个 pics 的文件夹，文件夹中有个 a 文件夹和 test.txt的文件，而 a 文件夹中有个 b 文件夹和test_0的文件
    >>> os.chdir('D:\\pics\\a\\')
    >>> os.getcwd()
    'D:\\pics\\a'
    >>> os.listdir()         # 当前目录下的子目录和文件
    ['b', 'test_0.txt']
    >>> os.listdir(path='..')  # 上一级目录下的子目录和文件
    ['a', 'test.txt']

### 1.4、mkdir（path） ###

创建单层目录（即一个文件夹），如果该目录存在，则抛出 FileExistsError 的异常：

>>> os.mkdir('new_file')
    >>> os.listdir()
    ['b', 'new_file', 'test_0.txt']
    
    >>> os.mkdir('b')
    Traceback (most recent call last):
      File "<pyshell#28>", line 1, in <module>
        os.mkdir('b')
    FileExistsError: [WinError 183] 当文件已存在时，无法创建该文件。: 'b'

### 1.5、makedirs(path) ###

创建多层目录：

os.makedirs('a\\b\\c')  # 表示创建了个 a 目录，里面包含 b 目录，b 目录里包含 c 目录

### 1.6、删除目录和文件 ###

用于删除指定的文件，不能删除目录：

# 当前工作目录为 D：\\file，file 目录下有 文件夹a 和 d 以及 文件 test.txt，a目录下有b，b下有c
    >>> os.getcwd()
    'D:\\file'
    >>> os.listdir()
    ['a', 'd' ,'test.txt']
    >>> os.remove('test.txt')   # 删除文件 test.txt
    
    >>> os.rmdir('d')           # 删除 文件夹 d
    
    >>> os.removedirs('a\\b\\c')  # 删除多层目录 a\\b\\c
    >>> os.listdir()     # file 文件为空
    []

### 1.7、rename（old，new） ###

重命名文件或文件夹

>>> os.listdir()
    ['a', 'test.txt']
    >>> os.rename('a', 'b')    # 重命名文件夹
    >>> os.rename('test.txt', 'test_0.txt')        # 重命名文件
    >>> os.listdir()
    ['b', 'test_0.txt']

### 1.8、system（command） ###

每种系统都会提供一些小工具，system（）函数可以使用这些工具：

# calc 是 windows 系统的自带计算器
    >>> os.system('calc')

### 1.9、walk（top） ###

walk（）函数，可以遍历 top 参数指定路径下的所有子目录，并将结果返回一个三元组（路径，\[包含目录\]，\[包含文件\]）：

# 目录结构为，b 目录下有 目录c 和文件 test.txt，目录c 下有 文件 test_0.txt，没有文件夹
    >>> for i in os.walk('b'):
    	print(i)
    
    	
    ('b', ['c'], ['test.txt'])   # b 目录下有 目录c 和文件 test.txt
    ('b\\c', [], ['test_0.txt'])  # 目录c 下有 文件 test_0.txt，没有文件夹

## 2、os.path 模块 ##

> **os.path 模块中关于路径常用函数使用方法**

<table> 
 <thead> 
  <tr> 
   <th align="center">函数名</th> 
   <th align="center">使用方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">basename（path）</td> 
   <td align="center">去掉目录路径，单独返回文件名</td> 
  </tr> 
  <tr> 
   <td align="center">dirname（path）</td> 
   <td align="center">去掉文件名，单独返回目录路径</td> 
  </tr> 
  <tr> 
   <td align="center">join（path1[，path2[，…]]）</td> 
   <td align="center">将 path1 和 path 2 各部分组合成一个路径名</td> 
  </tr> 
  <tr> 
   <td align="center">split（path）</td> 
   <td align="center">分割文件名和路径，返回（f_path，f_name）元组</td> 
  </tr> 
  <tr> 
   <td align="center">splitext（path）</td> 
   <td align="center">分离文件名与拓展名，返回（f_path，f_name）元组</td> 
  </tr> 
  <tr> 
   <td align="center">getsize（file）</td> 
   <td align="center">返回指定文件的尺寸，单位是字节</td> 
  </tr> 
  <tr> 
   <td align="center">getatime（file）</td> 
   <td align="center">返回指定文件最近的访问时间</td> 
  </tr> 
  <tr> 
   <td align="center">getctime（file）</td> 
   <td align="center">返回指定文件的创建时间</td> 
  </tr> 
  <tr> 
   <td align="center">getmtime（file）</td> 
   <td align="center">返回指定文件的最新修改时间</td> 
  </tr> 
  <tr> 
   <td align="center">以下函数返回 True 或 False</td> 
   <td align="center"></td> 
  </tr> 
  <tr> 
   <td align="center">exists（path）</td> 
   <td align="center">判断指定路径（目录或文件）是否存在</td> 
  </tr> 
  <tr> 
   <td align="center">isabs（path）</td> 
   <td align="center">判断指定路径是否为绝对路径</td> 
  </tr> 
  <tr> 
   <td align="center">isdir（path）</td> 
   <td align="center">判断指定路径是否存在且是一个目录</td> 
  </tr> 
  <tr> 
   <td align="center">isfile（path）</td> 
   <td align="center">判断指定路径是否存在且是一个文件</td> 
  </tr> 
  <tr> 
   <td align="center">islink（path）</td> 
   <td align="center">判断指定路径是否存在且是一个符号链接</td> 
  </tr> 
  <tr> 
   <td align="center">ismount（path）</td> 
   <td align="center">判断指定路径是否存在且是一个挂载点</td> 
  </tr> 
  <tr> 
   <td align="center">samefile（path1，path2）</td> 
   <td align="center">判断path1 和 path2 两个路径是否指向同一个文件</td> 
  </tr> 
 </tbody> 
</table>

### 2.1、basename（path）和dirname（path） ###

分别用于获得文件名和路径名：

>>> os.path.dirname('file\\b\\test.txt')   # 获得路径名
    'file\\b'
    >>> os.path.basename('file\\b\\test.txt')  # 获得文件名
    'test.txt'

### 2.2、join（path1\[，path3\[，…\]\]） ###

join（）函数跟 BIF 的那个 join（）函数不同，它是用于将路径名和文件名组合成一个完整的路径：

>>> os.path.join('C:\\', 'csv', 'test.csv')
    'C:\\csv\\test.csv'

### 2.3、split（path）和splitext（path） ###

*  split（path）函数：

将 path 分隔成目录和文件名的二元组（如果完全使用目录，那么它会将最后一个目录作为文件名分离，且不会判断文件或者目录存在）。

>>> path = 'C:\Python27\Lib\site-packages\myLibrary'
    >>> os.path.split(path)
    ('C:\\Python27\\Lib\\site-packages', 'myLibrary')
    
    >>> os.path.split('a\\b\\test.txt')
    ('a\\b', 'test.txt')

*  splitext（path）：

将 path 中的文件分割成文件名和拓展名的二元组。

>>> path = 'C:\Python27\Lib\site-packages\myLibrary'
    >>> os.path.splitext(path)
    ('C:\\Python27\\Lib\\site-packages\\myLibrary', '')
    
    >>> os.path.splitext('a\\b\\text.txt')
    ('a\\b\\text', '.txt')

### 2.4、getsize（file） ###

用于获取文件的尺寸，返回值以字节为单位：

# 注意，是获取文件的尺寸，而且文件必须存在
    >>> os.getcwd()
    'D:\\file'
    >>> os.listdir()
    ['b', 'test_0.txt']
    
    >>> os.path.getsize('test_0.txt')
    4

### 2.5、获取文件的最近访问、创建和修改时间 ###

getatime（file）、getctime（file）和 getmtime（file），分别用于获得文件的最近访问时间、创建时间和修改时间，返回值为浮点型的秒数，可用 time 模块的 gmtime（）或 localtime（）函数换算。

1.  getatime（file）：获得文件的最近访问时间。

import time
    >>> temp = time.localtime(os.path.getatime('test_0.txt'))
    >>> print('test_0.txt 被访问的时间是：', time.strftime('%d %b %Y %H: %M: %S', temp))
    test_0.txt 被访问的时间是： 18 Dec 2017 17: 05: 44

1.  getctime（file）：获得文件的创建时间。

>>> temp = time.localtime(os.path.getctime('test_0.txt'))
    >>> print('test_0.txt 被访问的时间是：', time.strftime('%d %b %Y %H: %M: %S', temp))
    test_0.txt 被访问的时间是： 18 Dec 2017 17: 05: 44

1.  getmtime（file）：获得文件的修改时间

>>> temp = time.localtime(os.path.getmtime('test_0.txt'))
    >>> print('test_0.txt 被访问的时间是：', time.strftime('%d %b %Y %H: %M: %S', temp))
    test_0.txt 被访问的时间是： 19 Dec 2017 17: 09: 47

### 2.6、判断 ###

>>> os.path.exists('test_0.txt')     # 判断目录或文件是否存在
    True
    
    >>> os.path.isabs('D:\\file\\test_0.txt')   # 判断指定路径是否为绝对路径
    True
    
    >>> os.path.isdir('D:\\file\\test_0.txt')   # 判断指定路径是否为目录
    False
    
    >>> os.path.isdir('D:\\file\\b')    
    True
    
    >>> os.path.isfile('D:\\file\\test_0.txt')   # 判断指定路径是否为文件
    True
    
    >>> os.path.islink('D:\\file\\b')    # 判断指定路径是否存在一个符号链接
    False
    
    >>> os.path.ismount('D:\\file\\b')   # 判断指定路径是否存在一个挂载点
    False
    
    >>> os.path.samefile('D:\\file\\b', 'D:\\file\\')  # 判断 path1 和 path2 两个路径是否指向同一文件
    False

## 3、pickle 模块 ##

在保存文本时，都是以字符串的形式存放，如果要取出数字，那么必须现将字符串转换为数字，然而要保存的数据像列表、字典甚至是类的实例这些更复杂的数据类型时，普通的文件操作就变得不那么好用了。

pickle 模块可以将任何 python 对象都转换为二进制形式存储，这个过程称为 pickling（泡菜）；从二进制转换为对象的过程称为 unpickling。

# 将文件 my_list 存储到 my_list_path 中，后缀名随意，不过最好为（.pkl 或 .pickle）
    import pickle
    
    my_list = [123, 3.14, '你好', [456,78]]
    my_list_path = 'C:\\Users\\hj\\Desktop\\2\\my_list.pkl'
    with open(my_list_path, 'wb') as f:   # 以二进制形式保存
        pickle.dump(my_list, f)   # 存放

在电脑路径 my\_list\_path 中会创建一个 my\_list.pkl 的文件，以记事本形式打开，显示为乱码（二进制）。

# 使用时，以二进制模式把文件打开，再以 load 把数据加载出来
    import pickle
    
    my_list_path = 'C:\\Users\\hj\\Desktop\\2\\my_list.pkl'
    with open(my_list_path, 'rb') as f:     # b 是以二进制形式
        my_list = pickle.load(f)
        print(my_list)
    --------------------------------
    
    [123, 3.14, '你好', [456, 78]]

## 4、time 模块 ##

### 4.1、python 中时间的表现形式 ###

在 python 中与时间有关的模块有：time、datetime以及 calendar，学会计算时间，对程序的调优非常重要，可以在程序中打**时间戳**，来具体判断程序中哪一块耗时最多，从而找到程序调优的重心处。

1.  python 中，通常有这几种方式表示时间：时间戳、格式化的时间字符串、元组（struct\_time 共九种元素），由于 time 模块主要是调用 C 库实现的，所有在不同平台可能会有所不同。
2.  时间戳（timestamp）的方式：时间戳表示是从 1970年1月1号 00：00 开始到现在按秒计算的偏移量，查看 type（time.time() ）的返回值类型，可以看出是 float类型，返回时间戳的函数主要有 time（）、clock（）。
3.  UTC（世界协调时），格林威治天文时间，即世界标准时间，中国为 UTC + 8，DST 夏令时。
4.  元组方式：struct\_time 元组共有 9 个元素，返回 struct\_time 的函数主要有 gmtime（）、localtime（）、strptime（）。

>>> import time
    >>> ls = time.localtime()
    >>> ls
    time.struct_time(tm_year=2017, tm_mon=12, tm_mday=19, tm_hour=22, tm_min=17, tm_sec=50, tm_wday=1, tm_yday=353, tm_isdst=0)

*  tm\_year ：年
 *  tm\_mon ：月（1-12）
 *  tm\_mday ：日（1-31）
 *  tm\_hour ：时（0-23）
 *  tm\_min ：分（0-59）
 *  tm\_sec ：秒（0-59）
 *  tm\_wday ：星期几（0-6,0表示周日）
 *  tm\_yday ：一年中的第几天（1-366）
 *  tm\_isdst ：是否是夏令时（默认为-1）

# 因为它是元组，那么它就遵循元组的特性，索引、切片等
    >>> ls[0]
    2017
    >>> ls.tm_year
    2017

### 4.2、time 模块中常用函数 ###

#### 4.2.1、time.time（） ####

返回当前时间的时间戳

>>> time.time()
    1513865956.2554889
    # 对时间戳取整
    >>> int(time.time())
    1513865973

#### 4.2.2、time.localtime(\[secs\]) ####

将一个时间戳转换为当前时区的 struct\_time，即数据数组格式的时间

sec：转换为 time.struct\_time 类型的对象的秒数

如果 secs 为提供，则以当前时间为准（即默认调用 time.time（））

# 为给定参数
    >>> time.localtime()
    time.struct_time(tm_year=2017, tm_mon=12, tm_mday=21, tm_hour=22, tm_min=25, tm_sec=18, tm_wday=3, tm_yday=355, tm_isdst=0)
    
    # 给定参数
    >>> time.localtime(1440337405.85)
    time.struct_time(tm_year=2015, tm_mon=8, tm_mday=23, tm_hour=21, tm_min=43, tm_sec=25, tm_wday=6, tm_yday=235, tm_isdst=0)

#### 4.2.3、time.gmtime（\[secs\]） ####

将一个时间戳转换为UTC时区的struct\_time  
time.gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct\_time，可选的参数sec表示从1970-1-1 00:00:00以来的秒数。其默认值为time.time()，函数返回time.struct\_time类型的对象。（struct\_time是在time模块中定义的表示时间的对象）。  
如果secs参数未提供，则以当前时间为准。

>>> import time
    >>> time.gmtime()
    time.struct_time(tm_year=2017, tm_mon=12, tm_mday=22, tm_hour=1, tm_min=48, tm_sec=3, tm_wday=4, tm_yday=356, tm_isdst=0)
    >>> time.gmtime(1440337405.85)
    time.struct_time(tm_year=2015, tm_mon=8, tm_mday=23, tm_hour=13, tm_min=43, tm_sec=25, tm_wday=6, tm_yday=235, tm_isdst=0)

#### 4.2.4、time.mktime（t） ####

将一个 struct\_time 转换为时间戳

time.mktime() 函数执行与gmtime(), localtime()相反的操作，它接收struct\_time对象作为参数,返回用秒数表示时间的浮点数。  
如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError

# t 结构化的时间或完整的 9位元组元素
    >>> time.mktime(time.localtime())
    1513907454.0

#### 4.2.5、time.sleep（secs） ####

线程推迟指定的时间运行，线程睡眠指定时间，单位为秒

# 睡眠 10 秒
    time.sleep(10)

#### 4.2.6、time.clock（） ####

这个函数， 函数以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。在不同的系统上含义不同。在 UNIX 系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在Windows中，第一次调用，返回的是进程运行时实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。

*  （1）在第一次调用的时候，返回的是程序运行的实际时间；
 *  （2）第二次之后的调用，返回的是自第一次调用后,到这次调用的时间间隔在win32系统下，这个函数返回的是真实时间（wall time），而在Unix/Linux下返回的是CPU时间

import  time
    
    def procedure():
        time.sleep(3)
    
    
    time1 = time.clock()
    
    procedure()
    print(time.clock() - time1, 'seconds process time!')
    
    time2 = time.time()
    procedure()
    print(time.time() - time2, 'seconds wall time!')
    ------------------------------------------------------------------
    
    3.0008666269000823 seconds process time!
    3.0008370876312256 seconds wall time!

#### 4.2.7、time.asctime(\[t\]) ####

把一个表示时间的元组或者 struct\_time 表示为 ‘Sun Aug 23 14：31：59 2015’ 这种形式，如果没有参数给定，那么将会使用 time.local() 作为参数传入。

>>> time.asctime(time.gmtime())
    'Fri Dec 22 02:20:36 2017'

#### 4.2.8、time.ctime（\[secs\]） ####

将一个时间戳（按秒计算的浮点数）转换为 time.asctime（）的形式，如果未指定参数，将会默认使用 time.time（），作用相当于 time.asctime（time.localtime(secs）。

# sec 要转换为字符串时间的秒数
    >>> time.ctime(1440338541.0)
    'Sun Aug 23 22:02:21 2015'
    >>> time.ctime()
    'Fri Dec 22 10:23:32 2017'

#### 4.2.9、time.strftime（format \[, t\]） ####

返回字符串表示的当地时间。  
把一个代表时间的元组或者struct\_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串，格式由参数format决定。如果未指定，将传入time.localtime()。如果元组中任何一个元素越界，就会抛出ValueError的异常。函数返回的是一个可读表示的本地时间的字符串。

*  format ：格式化字符串
 *  t：可选参数是一个 struct\_time 对象

时间字符串支持的格式符号：（区分大小写）

%a  本地星期名称的简写（如星期四为Thu）      
    %A  本地星期名称的全称（如星期四为Thursday）      
    %b  本地月份名称的简写（如八月份为agu）    
    %B  本地月份名称的全称（如八月份为august）       
    %c  本地相应的日期和时间的字符串表示（如：15/08/27 10:20:06）       
    %d  一个月中的第几天（01 - 31）  
    %f  微妙（范围0.999999）    
    %H  一天中的第几个小时（24小时制，00 - 23）       
    %I  第几个小时（12小时制，0 - 11）       
    %j  一年中的第几天（001 - 366）     
    %m  月份（01 - 12）    
    %M  分钟数（00 - 59）       
    %p  本地am或者pm的相应符      
    %S  秒（00 - 61）    
    %U  一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之    前的所有天数都放在第0周。     
    %w  一个星期中的第几天（0 - 6，0是星期天）    
    %W  和%U基本相同，不同的是%W以星期一为一个星期的开始。    
    %x  本地相应日期字符串（如15/08/01）     
    %X  本地相应时间字符串（如08:08:10）     
    %y  去掉世纪的年份（00 - 99）两个数字表示的年份       
    %Y  完整的年份（4个数字表示年份）
    %z  与UTC时间的间隔（如果是本地时间，返回空字符串）
    %Z  时区的名字（如果是本地时间，返回空字符串）       
    %%  ‘%’字符

>>> import time
    >>> ls = time.localtime()
    >>> ls
    time.struct_time(tm_year=2017, tm_mon=12, tm_mday=22, tm_hour=10, tm_min=29, tm_sec=24, tm_wday=4, tm_yday=356, tm_isdst=0)
    >>> time.strftime('%Y-%m-%d  %H:%M:%S', ls)
    '2017-12-22  10:29:24'

import  time
    from datetime import datetime
    
    # 获取当前时间的时分秒
    print(time.strftime('%H:%M:%S'))
    10:33:36
    
    print(time.strftime('%y-%m-%d'))     # 获取当前时间的年月日 
    
    t = datetime.now()                 # 格式符实例
    print(t)
    
    print(t.strftime('%a'))            # 当前时间的星期简写
    print(t.strftime('%A'))            # 当前时间的星期全写
    print(t.strftime('%B'))            # 当前时间的月份全写
    ----------------------
    
    17-12-22
    2017-12-22 10:42:49.912259
    Fri
    Friday
    December

#### 4.2.10、time.striptime（string \[,format\]） ####

将格式字符串转换成 struct\_time

该函数是time.strftime()函数的逆操作。time strptime() 函数根据指定的格式把一个时间字符串解析为时间元组。所以函数返回的是struct\_time对象。

>>> stime = "2015-08-24 13:01:30"  # 创建一个时间字符串变量 stime
    # 通过strptime（）函数将 stime转换为 struct_time形式
    >>> formattime = time.strptime(stime,"%Y-%m-%d %H:%M:%S")
    >>> formattime
    time.struct_time(tm_year=2015, tm_mon=8, tm_mday=24, tm_hour=13, tm_min=1, tm_sec=30, tm_wday=0, tm_yday=236, tm_isdst=-1)

# 遍历返回的时间元组序列
    >>> for i in formattime:
    	print(i, end=' ')
    
    	
    2015 8 24 13 1 30 0 236 -1

注意在使用strptime()函数将一个指定格式的时间字符串转化成元组时，参数format的格式必须和string的格式保持一致，如果string中日期间使用“-”分隔，format中也必须使用“-”分隔，时间中使用冒号“:”分隔，后面也必须使用冒号分隔，否则会报格式不匹配的错误。