1 2 3 4

模块

模块的定义与分类

模块是什么？

​ 这几天，我们进入模块的学习。在学习模块之前，我们首先要知道，什么是模块？

​ 一个函数封装一个功能，你使用的软件可能就是由n多个函数组成的（先不考虑面向对象）。比如抖音这个软件，不可能将所有程序都写入一个文件，所以咱们应该将文件划分，这样其组织结构要好并且代码不冗余。假如分了10个文件，每个文件里面可能都有相同的功能（函数），怎么办？所以将这些相同的功能封装到一个文件中，那么这个存储着很多常用的功能的py文件，就是模块。 模块就是文件，存放一堆常用的函数，比如：我要在大草原上策马奔腾，应该怎么样？我应该骑马，你也要去浪，你是不是也要骑马。我们说一个函数就是一个功能，那么把一些常用的函数放在一个py文件中，这个文件就称之为模块，模块，就是一些列常用功能的集合体。

为什么要使用模块?

  1. 从文件级别组织程序，更方便管理, 随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

  2. 拿来主义，提升开发效率 同样的原理，我们也可以下载别人写好的模块然后导入到自己的项目中使用，这种拿来主义，可以极大地提升我们的开发效率，避免重复造轮子.

    人们常说的脚本是什么？

如果你在终端上编写的代码运行完后,退出python解释器然后重新进入，那么你之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。

所以，脚本就是一个python文件，比如你之前写的购物车，模拟博客园登录系统的文件等等。

模块的分类

Python语言中，模块分为三类。

​ 第一类：内置模块，也叫做标准库。此类模块就是python解释器给你提供的，.py(模块).比如我们之前见过的time模块,os模块。标准库的模块非常多（200多个，每个模块又有很多功能），我们这几天就讲常用的十几种，后面课程中还会陆续的讲到。

​ 第二类：第三方模块，第三方库。---需要额外下载的---一些python大神写的非常好用的模块，必须通过pip install 指令安装的模块，比如BeautfulSoup, Django,等等。大概有6000多个。并发编程开始用.pypi.org

​ 第三类：自定义模块。我们自己在项目中定义的一些模块。

这几天，我们先学第一类和第三类模块，第二类模块会在我们并发编程开始逐渐的接触学习。

今天，我们先讲第三类，自定义模块。

  1. 自定义一个模块 --一个py文件

import 导入 把工具箱那过来

  1. 导入发生的事情

    1. 当前的名称空间中开辟一个新的空间(test)
    2. 将模块中所有的代买执行
    3. 通过模块名 . 进行查找函数(工具)
    4. 多次导入同一个文件只导入一次
    5. 可以使用别名 import test as f
      1. 使用别名能使文件名更短

    from test import func

    func()

  2. import 和 from 的区别 使用from...import...则是将spam中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀：tbjx.

    1. import
      1. 缺点:占用内存比较大
      2. 优点:不会和当前文件定义的变量或者函数发生冲突
    2. from
      1. 缺点:可能会和当前文件定义的变量或者函数发生冲突 --- 用as避开这个问题
      2. 优点:占用内存较少

  3. 模块:

    1. 分模块的好处:
      1. 避免写重复代码
      2. 可以多次调用
      3. 拿来主义

  4. from test import * -----把meet中所有的不是以下划线(_)开头的名字都导入到当前位置, 不能解决可能会覆盖的问题,不建议使用

    1. __all__ = ["可导入的函数名和变量名"]

      __all__=['name','read1'] #这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字

  5. 模块导入时的坑

     模块循环/嵌套导入抛出异常的根本原因是由于在python中模块被导入一次之后，就不会重新导入，只会在第一次导入时执行模块内代码

​ 在我们的项目中应该尽量避免出现循环/嵌套导入，如果出现多个模块都需要共享的数据，可以将共享的数据集中存放到某一个地方在程序出现了循环/嵌套导入后的异常分析、解决方法如下（了解，以后尽量避免）

示范文件内容如下
#创建一个m1.py
print('正在导入m1')
from m2 import y
x='m1

#创建一个m2.py
print('正在导入m2')
from m1 import x
y='m2'

#创建一个run.py
import m1

#测试一
执行run.py会抛出异常
正在导入m1
正在导入m2
Traceback (most recent call last):
  File "/python项目/run.py", line 1, in <module>
    import m1
  File "/python项目/m1.py", line 2, in <module>
    from m2 import y
  File "/python项目/m2.py", line 2, in <module>
    from m1 import x
ImportError: cannot import name 'x'

#测试一结果分析
先执行run.py--->执行import m1，开始导入m1并运行其内部代码--->打印内容"正在导入m1"
--->执行from m2 import y 开始导入m2并运行其内部代码--->打印内容“正在导入m2”--->执行from m1 import x,由于m1已经被导入过了，所以不会重新导入，所以直接去m1中拿x，然而x此时并没有存在于m1中，所以报错

#测试二:执行文件不等于导入文件，比如执行m1.py不等于导入了m1
正在导入m1
正在导入m2
Traceback (most recent call last):
正在导入m1
  File "/python项目/m1.py", line 2, in <module>
    from m2 import y
  File "/python项目/m2.py", line 2, in <module>
    from m1 import x
  File "/python项目/m1.py", line 2, in <module>
    from m2 import y
ImportError: cannot import name 'y'


#测试二分析
执行m1.py，打印“正在导入m1”，执行from m2 import y ，导入m2进而执行m2.py内部代码--->打印"正在导入m2"，执行from m1 import x，此时m1是第一次被导入，执行m1.py并不等于导入了m1，于是开始导入m1并执行其内部代码--->打印"正在导入m1"，执行from m1 import y，由于m1已经被导入过了，所以无需继续导入而直接问m2要y，然而y此时并没有存在于m2中所以报错


# 解决方法:
方法一:导入语句放到最后
#m1.py
print('正在导入m1')

x='m1'

from m2 import y

#m2.py
print('正在导入m2')
y='m2'

from m1 import x

方法二:导入语句放到函数中
#m1.py
print('正在导入m1')

def f1():
    from m2 import y
    print(x,y)

x = 'm1'

# f1()
#m2.py
print('正在导入m2')

def f2():
    from m1 import x
    print(x,y)

y = 'm2'

#run.py
import m1

m1.f1()

  6. 编写好的一个python文件可以有两种用途： 一：脚本，一个文件就是整个程序，用来被执行（比如你之前写的模拟博客园登录那个作业等） 二：模块，文件中存放着一堆功能，用来被导入使用

  7. __name__,在模块中使用就是"__main__",当模块被导入的时候__name__就是被导入模块的名字 python为我们内置了全局变量__name__， 当文件被当做脚本执行时：__name__ 等于'__main__' 当文件被当做模块导入时：__name__等于模块名 作用：用来控制.py文件在不同的应用场景下执行不同的逻辑（或者是在模块文件中测试代码）

  8. 先从内存中已经加载的模块进行寻找找不到再从内置模块中寻找，内置模块如果也没有，最后去sys.path中路径包含的模块中寻找。它只会按照这个顺序从这些指定的地方去寻找，如果最终都没有找到，那么就会报错。

  9. 内存中已经加载的模块->内置模块->sys.path路径中包含的模块导入路径---自定义>内置>第三方

  10. 模块的查找顺序

    1. 在第一次导入某个模块时（比如meet），会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用（ps：python解释器在启动时会自动加载一些模块到内存中，可以使用sys.modules查看）
    2. 如果没有，解释器则会查找同名的内置模块
    3. 如果还没有找到就从sys.path给出的目录列表中依次寻找meet.py文件。

Time 模块

  1. time.time() ---获取时间戳

  2. time.sleep()---阻塞 单位秒

  3. time.gmtime()/time.localtime() 获取当前的结构化时间

  4. time.strftime("格式化",结构化时间)结构化时间转字符串时间

  5. time.strptime(字符串,格式化) 字符串时间转格式化时间

  6. time.mktime()---格式化时间转时间戳

  7. 1.时间戳: 通常的叫法,时间戳表示的是格林尼治时间是从1970年1月1日00:00:00开始按秒计算的偏移量。这个是实时变化的。我们运行“type(time.time())”，返回的是float类型
2.格式化字符串时间: 格式化的时间字符串(Format String)： ‘1999-12-06’
python中时间日期格式化符号： 
%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 当前时区的名称 
%% %号本身

  8. 构化时间:元组(struct_time) struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

import time
# print(time.time())#时间戳  浮点数
# print(time.time()+500000000)#时间戳  浮点数
# time.sleep(2)#睡眠  阻塞  单位秒
# print(time.strftime("%Y-%m-%d %H:%M:%S"))# 当前时间 年-月-日 时:分:秒
# print(time.strftime("%Y-%m-%d %H:%M:%S"))# 年-月-日 时:分:秒
# print(time.gmtime())#结构化时间   数据类型:命名元组    结构化时间
# print(time.gmtime()[0])
# print(time.gmtime().tm_year)

#将时间戳转化成字符串时间
# print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime(5000000000)))
#将字符串时间转化为格式化时间
print(time.strptime("2024-3-16 12:30:30","%Y-%m-%d %H:%M:%S"))
#将字符串时间转化位时间戳
print(time.mktime(time.strptime("2024-3-16 12:30:30","%Y-%m-%d %H:%M:%S")))

![IMAGE](C:\Users\cqk52\Pictures\Camera Roll\IMAGE.png)

datetime 模块

  1. datetime.now() ----获取当前时间
  2. datetime(2019,5,20,15,14,00)-datetime(2019,5,20,14,20,00)---转成时间对象 求时间差
  3. t.timestamp() --- t当前时间 转成时间戳
  4. datetime.fromtimestamp(浮点数) ---将时间戳转成时间对象
  5. datetime.strptime(时间字符串,格式化)---- 将字符串转成时间对象,中间的连接符要一一对应
  6. datetime.now().strftime(格式化)将时间对象转成字符串
  7. datetime.now()+timedelta(hours=30*24*12) ----时间加减

总结time和datetime:

​ 用处:记录日志是使用,计算时间是使用

from datetime import datetime,timedelta

datetime -- 对象
print(type(datetime.now()))

print(datetime.now()) # 获取当前时间
print(datetime(2019,5,20,15,14,00) - datetime(2019,5,20,14,20,00))

将当前时间转化成时间戳
t = datetime.now()
print(t.timestamp())

将时间戳转化成当前时间
import time
print(datetime.fromtimestamp(15000000000))

将字符串转成对象
print(type(datetime.strptime("2019-10-10 22:23:24","%Y-%m-%d %H:%M:%S")))

将对象转成字符串
print(str(datetime.now()))
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))


datetime加减
print(datetime.now() + timedelta(hours=30 * 24 * 12))
print(datetime.now() - timedelta(hours=30 * 24 * 12))

对日期和时间进行加减实际上就是把datetime往后或往前计算，得到新的datetime。加减可以直接用 + 和 - 运算符，不过需要导入 timedelta 这个类：
from datetime import datetime, timedelta
now = datetime.now()
now
datetime.datetime(2015, 5, 18, 16, 57, 3, 540997)
now + timedelta(hours=10)
datetime.datetime(2015, 5, 19, 2, 57, 3, 540997)
now - timedelta(days=1)
datetime.datetime(2015, 5, 17, 16, 57, 3, 540997)
now + timedelta(days=2, hours=12)
datetime.datetime(2015, 5, 21, 4, 57, 3, 540997)


可见，使用 timedelta 你可以很容易地算出前几天和后几天的时刻。

random模块

import random
print(random.random())  #(0,1)开区间随机取
print(random.uniform(1,10))  #(1,10)开区间随机取
print(random.randint(1,50))  #[1,50]闭区间随机取
print(random.randrange(1,50,2))  #(起始,终止,步长)开区间随机取
print(random.choice([1,2,3,4,56,45,5,]))# 随机选择一个
print(random.choices([1,2,3,4,56,45,5,],k=2))#随机选择两个元素有重复
print(random.sample([1,2,3,4,56,45,5,],k=2))  #随机选择两个没有重复
lst = [1,2,3,4,5,6,7,8,9]


> > > item=[1,3,5,7,9]
> > > random.shuffle(item) # 打乱次序
> > > item
> > > [5, 1, 3, 7, 9]
> > > random.shuffle(item)
> > > item
> > > [5, 9, 7, 1, 3]

练习:

import random

def v_code():

    code = ''
    for i in range(5):

        num=random.randint(0,9)
        alf=chr(random.randint(65,90))
        add=random.choice([num,alf])
        code="".join([code,str(add)])

    return code

print(v_code())
posted @ 2019-07-26 08:27  学霸君主  阅读(208)  评论(0)  编辑  收藏  举报