Python基础（十五）

今日主要内容

• 模块初识
  • 模块导入
  • 模块路径
  • 自定义模块
• 内置模块（标准库）
  • time
  • datetime
  • random
  • sys
  • os
  • funtools

一、模块初识

（一）什么是模块

• 其实我们创建的每一个py文件就是一个模块，模块是将不同功能的函数进行归类，划分，封装的集合体
• 模块分类：
  • 内置模块（标准库）
  • 第三方模块（第三方库）
  • 自定义模块
• 模块的特点：拿来主义
  • 开发效率高，没有必要了解其中原理
  • 减少重复代码
  • 分文件管理，有助于修改和维护

（二）模块导入

1. 导入模块关键字：import

2. 模块只有在第一次导入才会执行，为了防止重复导入，python在第一次导入后就将模块名加载到内存，再次导入只是对加载到内存中的模块对象增加了一次引用，不会重复执行模块内的语句

   # text.py文件
   print("这是text.py文件中的语句")
   def func():
    print("这是text.py文件中的函数")
   
   # target.py文件
   import text
   import text
   import text
   
   运行结果：
   这是text.py文件中的语句  # 只运行一次

3. 第一次导入时发生的三件事：

   • 为源文件（被导入模块）创建新的名称空间，在被导入模块中定义的函数或者方法使用了global访问的就是这个名称空间
   • 在新创建的名称空间中执行模块中包含的代码
   • 创建同名的模块名来引用该名称空间

4. 模块导入时的查找顺序

   • 内存 > 内置 > sys.path
   • 说明：解释器运行的时候，会将一部分常用的模块加载到内存，在我们导入模块的时候解释器会查找此模块是否已被加载到内存中，如果没有就去查找内置库中有无此模块，如果还没有最后查找sys.path中的路径中是否包含此模块，进行导入，如果还没有，解释器就会报错
   • 可以通过手动添加将模块的路径添加到sys.path中，sys.path返回的是一个列表，可以使用append()方法添加，供解释器搜索

   from sys import path
   path.append(r"c:\users\11582\desktop")
   
   from text import ceshi
   ceshi()

5. 模块导入的方法：

   • import xxx：将模块全部导入
   • from xxx import xxx：导入指定模块功能
   • 在后面使用as，两者都可给导入的模块或功能重新命名

   import time as a
   from time import sleep as s

   • 说明：

     • 使用import导入时可以一行导入多个模块，但不建议，建议每使用一个import只导入一个模块

     import time
     import random
     import sys

     • 使用from可以一行导入多个功能，导入的功能在使用时会将之前定义同名的变量覆盖掉

     def time():
        print("123")
     
     from time import time
     time()
     
     运行结果：
     123

     • from xxx import *：导入模块内全部功能，可以通过__all__限制导入的功能

     # 被导入文件:zxd.py
     def name():
        print("zxd")
     
     def age():
        print("age")
     
     __all__ = ["name"]
     
     # 运行文件:target.py
     from zxd import *
     
     age()
     
     运行结果：
     nameerror: name 'age' is not defined

6. 模块的两种用法

   • 当作普通模块执行
   • 当作脚本执行

7. 如何使用模块中的功能

   • 万能的.
   • 如果利用import导入整个模块，使用时要利用模块名.功能

   import time 
   
   t = time.time()

   • 如果使用from，则可以直接使用该功能，注意这样会覆盖之前定义的功能

   def time():
    print("123")
   
   from time import time
   time()
   
   运行结果：
   123

8. 避免循环导入模块

   • 三个模块，模块1导入模块2，模块2导入模块3，模块3导入模块1（避免）

（三）自定义模块

• 注意：自定义模块时千万不要定义与内置模块相同的模块名

• 自己创建的py文件就是一个自定义模块

  # zxd.py  # 自定义模块
  def name():
    print("zxd")
  
  def age():
    print("age")
  
  # target.py
  import zxd
  
  zxd.name()
  zxd.age()
  
  运行结果：
  zxd
  23
  

• 定义模块私有部分（无法通过导入使用）

  if __name__ == "__main__":
    """私有部分"""
  

  • 原理：如果__name__在本文件运行返回的是__main__，如果被导入返回的是被导入的文件名。

  # zxd.py文件
  print(__name__)
  if __name__ == "__main__":
    """私有部分"""
  
  运行结果：
  __main__
  

  # zxd.py文件
  print(__name__)
  if __name__ == "__main__":
    """私有部分"""
  
  # target.py文件
  import zxd
  
  print(__name__)
  
  运行结果：
  zxd
  __main__
  

二、内置模块（标准库）

（一）time模块

1. time模块在python中是和时间相关的模块，python中的时间分为三种形式：

   • 时间戳：从1970-01-01 00:00:00到现在一共经历了多少秒，用float表示

   • 结构化时间：以元组的形式，以固定结构输出时间

     • 固定结构：年，月，日，时，分，秒，一年中第几周，一年中第几天，是否是夏令时（1是夏令时；0是非夏令时，-1表示不确定是否是夏令时）

     time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=-1)
     

   • 格式化时间：根据我们的需要对时间任意格式化

     • 格式化标准：

     %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	当前时区的名称
     %%	%号本身

2. time模块部分方法介绍：

   time.time()	获取当前时间戳
   time.sleep()	睡眠（延时）
   time.localtime()	将时间戳转换为结构化时间
   time.mktime()	将结构化时间转换为时间戳
   time.strftime()	将结构化时间转换为格式化时间
   time.strptime()	将格式化时间转换为结构化时间

   • time.time()

     • 函数定义：time()
     • 函数说明：获取当前时间戳，距离1970-01-01 00:00:00到现在经过的时间，单位是秒，结果为浮点型

     import time
     
     print(time.time())
     
     运行结果：
     1569505356.1715019
     

   • time.sleep()

     • 函数定义：sleep(seconds)
     • 函数说明：参数为秒，将执行延时数秒，可以是亚秒级别的浮点数

     import time
     
     print(1)
     time.sleep(10)
     print(2)
     
     运行结果：
     1
     2  # 相隔10s 
     

   • time.localtime()

     • 函数定义：localtime([seconds])
     • 函数返回：(tm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)
     • 函数说明：参数为时间戳，将时间戳转换为表示本地时间的时间元组，当seconds没有传入时，转换当前的时间戳

     import time
     
     print(time.localtime())
     
     运行结果：
     time.struct_time(tm_year=2019, tm_mon=9, tm_mday=26, tm_hour=22, tm_min=2, tm_sec=38, tm_wday=3, tm_yday=269, tm_isdst=0)
     

     • 返回值取值：

       • 返回值可以通过索引取值

       import time
       
       print(time.localtime()[0])
       
       运行结果：
       2019
       

       • 返回值可以通过关键字取值

       import time
       
       print(time.localtime().tm_year)
       
       运行结果：
       2019
       

   • time.mktime()

     • 函数定义：mktime(p_tuple)
     • 函数说明：参数为结构化时间元组，将结构化时间元组转换为时间戳

     import time
     
     t = time.localtime()
     print(time.mktime(t))
     
     运行结果：
     1569506956.0
     

   • time.strftime()

     • 函数定义：strftime(format, p_tuple=none)
     • 函数说明：第一个参数为格式化规范，第二个参数为结构化时间元组，将结构化时间元组转换为字符串，若时间元组不存在时，使用localtime()当前时间返回字符串

     import time
     
     t = time.localtime()
     print(time.strftime("%y-%m-%d %h:%m:%s", t))
     
     运行结果：
     2019-09-26 22:19:30
     

   • time.strptime()

     • 函数定义：strptime(string, format)
     • 函数说明：第一个参数为时间字符串，第二个参数为格式化规范，根据格式化规范将字符串解析成时间元组

     import time
     
     print(time.strptime("2019-09-26 22:19:30", "%y-%m-%d %h:%m:%s"))
     
     运行结果：
     time.struct_time(tm_year=2019, tm_mon=9, tm_mday=26, tm_hour=22, tm_min=19, tm_sec=30, tm_wday=3, tm_yday=269, tm_isdst=-1)
     

• 计算时间差

  import time
  
  time_msg = input("请输入时间:")
  def time_difference(args):
      tid = time.time() - time.mktime(time.strptime(args, "%y-%m-%d %h:%m:%s"))
      return time.localtime(tid)
  
  t = time_difference(time_msg)
  print(f"过去了{t.tm_year-1970}年{t.tm_mon-1}月{t.tm_mday-1}天{t.tm_hour}小时{t.tm_min}分{t.tm_sec}秒")
  
  运行结果：
  请输入时间:2019-01-01 00:00:00
  过去了0年8月26天6小时39分17秒
  

（二）datetime模块

• datetime模块也是一个时间模块，功能较time模块更强一些

1. datatime模块中的datatime类部分方法介绍：

   datetime()	获取指定时间
   datetime.now()	获取当前时间
   datetime.timestamp()	将时间对象转换为时间戳
   datetime.fromtimestamp()	将时间戳转换为时间对象
   datetime.strftime()	将时间对象转换为字符串
   datetime.strptime()	将字符串转换为时间对象

   • datetime()

     • 函数定义：datetime(year: int, month: int, day: int, hour: int = ..., minute: int = ..., second: int = ..., microsecond: int = ..., tzinfo: optional[_tzinfo] = ..., *, fold: int = ...)
     • 函数说明：传入年，月，日，时，分，秒，微秒，时区，fold（不明参数，3.6加入），返回一个时间对象

     from datetime import datetime
     
     print(datetime(2019,9,27))
     print(type(datetime(2019,9,27)))
     
     运行结果：
     2019-09-27 00:00:00
     <class 'datetime.datetime'>  # 对象类型
     

   • datetime.now()

     • 函数定义：now(tz=none)
     • 函数说明：参数为时区，通过datetime对象创建一个时间对象，可以选择时区信息

     from datetime import datetime
     
     print(datetime.now())
     print(type(datetime.now()))
     
     运行结果：
     2019-09-27 14:06:10.948891
     <class 'datetime.datetime'>
     

   • datetime.timestamp()

     • 函数定义：timestamp(obj)
     • 函数说明：参数为时间对象，将时间对象转换为时间戳

     from datetime import datetime
     
     print(datetime.timestamp(datetime.now()))
     print(type(datetime.timestamp(datetime.now())))
     
     运行结果：
     1569565460.237563
     <class 'float'>
     

   • datetime.fromtimestamp()

     • 函数定义：fromtimestamp(t, tz=none)
     • 函数说明：第一个参数为时间戳，第二个参数为时区，将传入的时间戳转换为时间对象

     from datetime import datetime
     
     print(datetime.fromtimestamp(0))
     print(type(datetime.fromtimestamp(0)))
     
     运行结果：
     1970-01-01 08:00:00
     <class 'datetime.datetime'>
     

   • datetime.strftime()

     • 函数定义：strftime(obj, format)
     • 函数说明：第一个参数为时间对象，第二个参数为格式化规范，按照格式化规范将时间对象转换为字符串

     from datetime import datetime
     
     print(datetime.strftime(datetime.now(), "%y-%m-%d %h:%m:%s"))
     print(type(datetime.strftime(datetime.now(), "%y-%m-%d %h:%m:%s")))
     
     运行结果：
     2019-09-27 14:35:37
     <class 'str'>
     

   • datetime.strptime()

     • 函数定义：strptime(date_string, format)
     • 函数说明：第一个参数为时间字符串，第二个参数为格式化规范，将时间字符串按照格式化规范解析成时间对象

     from datetime import datetime
     
     print(datetime.strptime("2019-09-27 14:35:37", "%y-%m-%d %h:%m:%s"))
     print(type(datetime.strptime("2019-09-27 14:35:37", "%y-%m-%d %h:%m:%s")))
     
     运行结果：
     2019-09-27 14:35:37
     <class 'datetime.datetime'>
     

2. datatime模块中的timedelta类部分方法介绍：

   • timedelta()

     • 函数定义：timedelta(days: float = ..., seconds: float = ..., microseconds: float = ..., milliseconds: float = ..., minutes: float = ..., hours: float = ..., weeks: float = ..., *, fold: int = ...)
     • 函数说明：函数用于对时间对象的增减，填入对应关键字参数为时间变化的数值

     from datetime import datetime, timedelta
     
     print(datetime(2019, 1, 2))
     print(datetime(2019, 1, 2) - timedelta(days=1))
     
     运行结果：
     2019-01-02 00:00:00
     2019-01-01 00:00:00
     

（三）random模块

• random是一个随机模块，任何随机的情况都需要随机模块协助完成

1. random模块部分方法介绍：

   random.random()	随机生成0~1之间的小数
   random.randint()	随机生成数字
   random.randrange()	随机生成数字（可以设定步长）
   random.choice()	从一个可迭代对象中随机获取一个元素
   random.choices()	从一个可迭代对象中随机获取多个元素，会有重复
   random.sample()	从一个可迭代对象中随机获取多个元素，不会有重复
   rendom.shuffle()	随机打乱顺序

   • random.random()

     • 函数定义：random()
     • 函数说明：产生0到1之间的随机小数

     import random
     
     print(random.random())
     
     运行结果：
     0.8988729646775544
     

   • random.randint()

     • 函数定义：randint(a, b)
     • 函数说明：产生a到b之间的随机数

     import random
     
     print(random.randint(1, 10))
     
     运行结果：
     9
     

   • random.randrange()

     • 函数定义：randrange(start, stop=none, step=1, _int=int)
     • 函数说明：从起始到结束的范围内产生一个随机数，可以设定步长，若不填入结束位置则默认从0开始，若不填步长，默认为1

     import random
     
     print(random.randrange(5))  # 从0到5随机生成
     print(random.randrange(1, 10))  # 从1到10随机生成
     print(random.randrange(1, 10, 2))  # 从1到10
     
     运行结果：
     4
     3
     9
     

   • random.choice()

     • 函数定义：choice(seq)
     • 函数说明：从非空序列中随机选择一个元素

     import random
     
     print(random.choice(["a", "b", "c"])
     
     运行结果：
     b
     

   • random.choices()

     • 函数定义：choices(population, weights=none, *, cum_weights=none, k=1)
     • 函数说明：从非空序列中随机选择k个元素，会有重复选择的情况，以列表的形式返回

     import random
     
     print(random.choices(["a", "b", "c"], k=3))
     
     运行结果：
     ['b', 'b', 'a']
     

   • random.sample()

     • 函数定义：sample(population, k)
     • 函数说明：随机从非空序列中选择k个元素，不会重复选择，以列表的形式返回

     import random
     
     print(random.sample(["a", "b", "c"], k=3))
     
     运行结果：
     ['c', 'b', 'a']
     

   • rendom.shuffle()

     • 函数定义：shuffle(x, random=none)
     • 函数说明：将参数重新洗牌，结果返回none

     import random
     
     lst = [1, 2, 3, 4, 5]
     random.shuffle(lst)
     print(lst)
     
     运行结果：
     [2, 3, 5, 4, 1]
     

（四）os模块

• os模块中的内容全部与操作系统有关

1. os模块部分方法介绍：

   os.makedirs('dirname1/dirname2')	递归创建目录**
   os.removedirs('dirname1')	递归删除目录
   os.mkdir('dirname')	生成单级目录；相当于shell中mkdir dirname
   os.rmdir('dirname')	删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
   os.listdir(path)	列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
   os.remove()	删除一个文件
   os.rename("oldname","newname")	重命名文件/目录
   os.stat('path/filename')	获取文件/目录信息
   os.system("bash command")	运行shell命令，直接显示
   os.popen("bash command").read()	运行shell命令，获取执行结果
   os.getcwd()	获取当前工作目录，即当前python脚本工作的目录路径
   os.chdir("dirname")	改变当前脚本工作目录；相当于shell下cd
   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的大小

   • 重点介绍常用15个方法

   • os.makedirs('dirname1/dirname2')

     • 函数定义：makedirs(dirname)
     • 函数说明：递归创建文件夹

     import os
     
     os.makedirs("dir1/dir2/dir3")  # 在当前目录递归创建文件夹
     
     运行结果：
     # 创建三层文件夹
     ◥dir1
        ◥dir2
            ◥dir3
     

   • os.removedirs('dirname1')

     • 函数定义：removedirs(dirname)
     • 函数说明：若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

     import os
     
     os.removedirs("dir1/dir2/dir3")
     
     运行结果：
     # 先判断dir3目录是否为空，若为空则删除，再一次向上判断，递归删除文件夹
     

   • os.mkdir('dirname')

     • 函数定义：mkdir(dirname)
     • 函数说明：创建单级目录

     import os
     
     os.mkdir("dir1")
     
     运行结果：
     # 创建dir1文件夹
     

   • os.rmdir('dirname')

     • 函数定义：rmdir(dirname)
     • 函数说明：删除单级目录，若目录不存在或不为空报错

     import os
     
     os.rmdir("dir1")
     
     运行结果：
     # 若dir1为空，删除dir1文件夹
     

   • os.listdir(path)

     • 函数定义：listdir(path)
     • 函数说明：返回该路径下的所有文件夹和文件，以列表的形式

     import os
     
     print(os.listdir("d:\dir"))
     
     运行结果：
     ['dir1', 'dir2', 'dir3']
     

   • os.remove()

     • 函数定义：remove(filename)
     • 函数说明：删除文件

     import os
     
     os.remove("text.py")
     
     运行结果：
     # 直接删除"text.py"文件
     

   • os.rename("oldname","newname")

     • 函数定义：rename(oldname, newname)
     • 函数说明：重命名，第一个参数为旧文件名，第二个参数为新文件名

     import os
     
     os.rename("text1.py", "text2.py")
     
     运行结果：
     # 将文件名"text1.py"改为"text2.py"
     

   • os.getcwd()

     • 函数定义：getcwd(*args, **kwargs)
     • 函数说明：返回当前文件的工作路径，以unicode字符串的形式（若被当作模块导入，则返回的是导入文件的工作路径）

     import os
     
     print(os.getcwd("text.py"))
     
     运行结果：
     d:\text.py
     

   • os.path.abspath(path)

     • 函数定义：abspath(path)
     • 函数说明：返回当文件的绝对路径

     import os
     
     print(os.path.abspath("text.py"))
     
     运行结果：
     d:\text.py
     

   • os.path.dirname(path)

     • 函数定义：dirname(path)
     • 函数说明：返回文件的目录

     import os
     
     path = r"d:\dir\dir1\name.py"
     print(os.path.dirname(path))
     
     运行结果：
     d:\dir\dir1
     

   • os.path.basename(path)

     • 函数定义：basename(path)
     • 函数说明：返回文件名

     import os
     
     path = r"d:\dir\dir1\name.py"
     print(os.path.basename(path))
     
     运行结果：
     name.py
     

   • os.path.isfile(path)

     • 函数定义：isfile(path)
     • 函数说明：判断路径是否是一个文件

     import os
     
     path = r"d:\dir\dir1\name.py"
     print(os.path.isfile(path))
     
     运行结果：
     true
     

   • os.path.isdir(path)

     • 函数定义：isdir(path)
     • 函数说明：判断路径是否是一个文件夹

     import os
     
     path = r"d:\dir\dir1"
     print(os.path.isdir(path))
     
     运行结果：
     true
     

   • os.path.join(path1[, path2[, ...]])

     • 函数定义：join(path, *paths)
     • 函数说明：将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

     import os
     
     path = r"d:\dir"
     print(os.path.join(path, "dir1", "text.py"))
     print(os.path.join("text.py", path, "dir1", "text.py"))
     
     运行结果：
     d:\dir\dir1\text.py
     d:\dir\dir1\text.py
     

   • os.path.getsize(path)

     • 函数定义：getsize(filename)
     • 函数说明：返回文件的大小

     import os
     
     path = r"d:\dir\dir1\name.py"
     print(os.path.getsize(path))
     
     运行结果：
     7971
     

（五）sys模块

• sys模块是与python解释器交互的一个接口

1. sys模块部分方法介绍：

   sys.argv	命令行参数list，第一个元素是程序本身路径
   sys.exit(n)	退出程序，正常退出时exit(0),错误退出sys.exit(1)
   sys.version	获取python解释程序的版本信息
   sys.path	返回模块的搜索路径，初始化时使用pythonpath环境变量的值
   sys.platform	返回操作系统平台名称
   sys.modules	获取所有的模块

   • sys.path

     • 方法说明：返回模块的搜索路径，以列表的形式，需要导入自定义模块时，向sys.path中添加路径

     import sys
     
     print(sys.path)
     
     运行结果：
     ['d:\\python_s26\\day15', 'd:\\python_s26', 'd:\\software\\pycharm\\pycharm\\pycharm 2019.2.1\\helpers\\pycharm_display', 'c:\\python3.6.8\\python36.zip', 'c:\\python3.6.8\\dlls', 'c:\\python3.6.8\\lib', 'c:\\python3.6.8', 'c:\\python3.6.8\\lib\\site-packages', 'd:\\software\\pycharm\\pycharm\\pycharm 2019.2.1\\helpers\\pycharm_matplotlib_backend']
     

（六）functools模块

• funtools模块针对于一些函数的操作

1. 之前介绍过的reduce()函数，用于累计算

   from functools import reduce
   
   print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5]))
   print(reduce(lambda x, y: x * y, [1, 2, 3, 4, 5], 5))
   print(reduce(lambda x, y: x * y, [], 5))
   
   运行结果：
   120
   600
   5
   

2. wraps

   • 用于修改装饰器内层函数的函数名

   • 我们在执行被装饰器装饰过的函数时，其实真正执行的是装饰器内部的inner函数，我们通过__name__方法可查看函数调用真正调用的函数名

     def wrapper(fn):
        def inner(*args, **kwargs):
            print("扩展内容")
            ret = fn(*args, **kwargs)
            print("扩展内容")
            return ret
        return inner
     
     @wrapper
     def target_func():
        print("目标函数")
     
     print(target_func.__name__)
     
     运行结果：
     inner
     

   • 但对于调用方而言，会对函数产生疑问，所以使用warps可以修改内层inner函数的函数名

     from functools import wraps
     
     def wrapper(fn):
        @wraps(fn)  # 装饰内层函数
        def inner(*args, **kwargs):
            print("扩展内容")
            ret = fn(*args, **kwargs)
            print("扩展内容")
            return ret
        return inner
     
     @wrapper
     def target_func():
        print("目标函数")
     
     print(target_func.__name__)
     
     运行结果：
     target_func