码迷，mamicode.com
首页 > 编程语言 > 详细

Python基础（十五）

时间：2019-10-04 10:00:50      阅读：84      评论：0      收藏：0      [点我收藏+]

标签：显示   tab   对象类型   一个   定义   解析   datatime   输入   参数   

今日主要内容

  • 模块初识
    • 模块导入
    • 模块路径
    • 自定义模块
  • 内置模块（标准库）
    • 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

Python基础（十五）

标签：显示   tab   对象类型   一个   定义   解析   datatime   输入   参数   

原文地址：https://www.cnblogs.com/tianlangdada/p/11621367.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！