python中模块的概念,python中模块的用法

　　本文详细解释了Python的基本模块，并通过示例代码对其进行了详细介绍。对大家的学习或者工作都有一定的参考价值，有需要的朋友可以参考一下。

　　00-1010 1.模块1。模块的四种形式2。为什么要用模块？2.如何用模块1导入重命名，导入模块名：smt变量指向span模块的命名空间导入多个模块2。从模块名导入特定函数rom … import *语句：导入文件中的所有函数：3。循环导入4。dir()函数3。模块搜索路径1。导入模块1时搜索模块的顺序。首先，在内存中查找导入的模块。2.内置模块。3.查找环境变量sys.path(重点：sys.path的第一个值是当前可执行文件所在的文件夹)。2.搜索路径取决于可执行文件。4.Python文件的两种用法。5.包装1。两种方式导入：2。导入包3中的模块。从导入模式：在模块中导入特定模块，在模块4中导入特定函数。绝对进口和相对进口，绝对进口：5。从.导入* 6。软件开发的目录规范，settings . py common . py src . pyron . py 7。Python标准库

目录

　　一个模块可以被看作是函数的集合。

　　一个py文件可以包含一堆函数，所以一个py文件可以看作一个模块。

　　如果这个py文件的文件名是module.py，那么模块名就是module。

一、模块

　　在Python中，总共有四种类型的模块：

　　自定义模块：如果你自己写一个py文件，在里面写一堆函数，就叫自定义模块，也就是的第三方模块。用python写的py文件：已经编译成共享库或dll的C或C扩展，比如requests内置模块：用C写的内置模块并链接到python解释器，比如time package (folder):把一系列模块组织在一起的文件夹(注意：文件夹下有一个\

1、模块的四种形式

　　使用第三方或者内置模块是一种借用，可以大大提高开发效率。自定义模块，将我们自己的程序中使用的公共函数编写到一个python文件中，然后将每个程序

　　部分组件可以通过导入的方式来引用自定义模块的功能。

二、如何用模块

　　一般我们使用import和from...import...导入模块。

　　以下述spam.py内的文件代码为例。

# spam.py
　　print(from the spam.py)
　　money = 1000
　　def read1():
　　print(spam模块：, money)
　　def read2():
　　print(spam模块)
　　read1()
　　def change():
　　global money
　　money = 0

1、import 模块名

　　语法如下：

import module1[, module2[,... moduleN]

　　import导入的模块，访问需要加前缀。

　　import首次导入模块发生了3件事：

• 以模块为准创造一个模块的名称空间
• 执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
• 在当前执行文件中拿到一个模块名

　　注意：模块的重复导入会直接引用之前创造好的结果，不会重复执行模块的文件。

# run.py
　　import spam # from the spam.py
　　import spam
　　money = 111111
　　spam.read1() # spam模块：1000
　　spam.change()
　　print(spam.money) # 0
　　print(money) # 111111

导入重命名：smt变量指向span模块的名称空间

# run.py
　　import spam as sm
　　money = 111111
　　sm.money
　　sm.read1() # spam模块：1000
　　sm.read2
　　sm.change()
　　print(money) # 1000

导入多个模块

import spam, time, os
　　# 推荐使用下述方式
　　import spam
　　import time
　　import os

2、from 模块名 import 具体的函数

　　语法如下：

from modname import name1[, name2[, ... nameN]]

　　这个声明不会把整个模块导入到当前的命名空间中，它只会将模块里的一个或多个函数引入进来。

　　from...import...导入的模块，访问不需要加前缀。

　　from...import...首次导入模块发生了3件事：

• 以模块为准创造一个模块的名称空间
• 执行模块对应的文件，将执行过程中产生的名字都丢到模块的名称空间
• 在当前执行文件的名称空间中拿到一个名字，该名字直接指向模块中的某一个名字，意味着可以不用加任何前缀而直接使用

• 优点：不用加前缀，代码更加精简
• 缺点：容易与当前执行文件中名称空间中的名字冲突

# run.py
　　from spam import money
　　from spam import money,read1
　　money = 10
　　print(money) # 10

rom … import * 语句：导入文件内所有的功能：

# spam.py
　　__all__ = [money, read1] # 只允许导入money和read1
　　# run.py
　　from spam import * # 导入spam.py内的所有功能，但会受限制于__all__
　　money = 111111
　　read1() # spam模块：1000
　　change()
　　read1() # spam模块：0
　　print(money) # 111111

3、循环导入

　　以下情况会出现循环导入：

# m1.py
　　print(from m1.py)
　　from m2 import x
　　y = m1
　　# m2.py
　　print(from m2.py)
　　from m1 import y
　　x = m2

　　可以使用函数定义阶段只识别语法的特性解决循环导入的问题，或从本质上解决循环导入的问题，但是最好的解决方法是不要出现循环导入。

　　方案一：

# m1.py
　　print(from m1.py)
　　def func1():
　　from m2 import x
　　print(x)
　　y = m1
　　# m2.py
　　print(from m2.py)
　　def func1():
　　from m1 import y
　　print(y)
　　x = m2

　　方案二：

5、# m1.py
　　print(from m1.py)
　　y = m1
　　from m2 import x
　　# m2.py
　　print(from m2.py)
　　x = m2
　　from m1 import y

4、dir() 函数

　　内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:

dir(sys)
　　[__displayhook__, __doc__, __excepthook__, __loader__, __name__,
　　__package__, __stderr__, __stdin__, __stdout__,
　　_clear_type_cache, _current_frames, _debugmallocstats, _getframe,
　　_home, _mercurial, _xoptions, abiflags, api_version, argv,
　　base_exec_prefix, base_prefix, builtin_module_names, byteorder,
　　call_tracing, callstats, copyright, displayhook,
　　dont_write_bytecode, exc_info, excepthook, exec_prefix,
　　executable, exit, flags, float_info, float_repr_style,
　　getcheckinterval, getdefaultencoding, getdlopenflags,
　　getfilesystemencoding, getobjects, getprofile, getrecursionlimit,
　　getrefcount, getsizeof, getswitchinterval, gettotalrefcount,
　　gettrace, hash_info, hexversion, implementation, int_info,
　　intern, maxsize, maxunicode, meta_path, modules, path,
　　path_hooks, path_importer_cache, platform, prefix, ps1,
　　setcheckinterval, setdlopenflags, setprofile, setrecursionlimit,
　　setswitchinterval, settrace, stderr, stdin, stdout,
　　thread_info, version, version_info, warnoptions]

　　如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

a = [1, 2, 3, 4, 5]
　　import fibo
　　fib = fibo.fib
　　print(dir()) # 得到一个当前模块中定义的属性列表
　　# [__builtins__, __name__, a, fib, fibo, sys]
　　b = 5 # 建立一个新的变量 a
　　print(dir())
　　# [__annotations__, __builtins__, __cached__, __doc__, __file__, __loader__, __name__, __package__, __spec__, a, b]
　　del b # 删除变量名a
　　print(dir())
　　# [__annotations__, __builtins__, __cached__, __doc__, __file__, __loader__, __name__, __package__, __spec__, a]

三、模块搜索路径

1、导入模块时查找模块的顺序

1、先从内存中已经导入的模块中寻找

　　如果我们在运行run.py文件的时候，快速删除mmm.py文件，我们会发现文件会继续运行，而不会报错，因为mmm已经被导入内存当中。如果我们再一次运行run.py时会报错，因为mmm.py已经被删除了。

# test.py
　　import m1 # 从m1.py文件中导入的,然后会生成m1模块的名称空间
　　import time
　　# 删除m1.py文件,m1模块的名称空间仍然存在
　　time.sleep(10)
　　import m1 # 不报错,一定不是从文件中获取了m1模块,而是从内存中获取的

2、内置的模块

　　验证先从内置中找，不会先找自定义的time.py文件。

# time.py
　　print(from time.py)
　　# run.py
　　import time
　　print(time) #

3、环境变量sys.path中找（强调：sys.path的第一个值是当前执行文件的所在的文件夹）

import sys
　　for n in sys.path:
　　print(n)
　　# C:\PycharmProjects\untitled\venv\Scripts\python.exe C:/PycharmProjects/untitled/hello.py
　　# C:\PycharmProjects\untitled
　　# C:\PycharmProjects\untitled
　　# C:\Python\Python38\python38.zip
　　# C:\Python\Python38\DLLs
　　# C:\Python\Python38\lib
　　# C:\Python\Python38
　　# C:\PycharmProjects\untitled\venv
　　# C:\PycharmProjects\untitled\venv\lib\site-packages

　　如果mmm.py在C:\PycharmProjects\untitled\day16路径下，而执行文件路径为C:\PycharmProjects\untitled，如果普通导入一定会报错，我们可以把C:\PycharmProjects\untitled\day16添加到环境变量sys.path中，防止报错。

# run.py
　　import sys
　　sys.path.append(rC:\PycharmProjects\untitled\day16)
　　print(sys.path)
　　import mmm
　　mmm.f1()

2、搜索路径以执行文件为准

　　假设我们有如下目录结构的文件，文件内代码分别是：

　　而hello和spam.py不是同目录下的，因此run.py的环境变量无法直接找到m2,需要从文件夹导入

from aa import spam
　　print(spam.money)

四、Python文件的两种用途

　　一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

　　python文件总共有两种用途，一种是执行文件；另一种是被当做模块导入。

　　每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

　　1、当run.py运行的时候，aaa.py被当做引用模块，它的__name__ == 'aaa'（模块名），会执行aaa.py中的f1()。

# aaa.py
　　x = 1
　　def f1():
　　print(from f1)
　　f1()
　　# run.py
　　import aaa

　　2、aaa.py被当做可执行文件时，加上__name__ == '__main__'，单独运行aaa.py才会执行aaa.py中的f1()。 run.py运行时可以防止执行f1()。

# aaa.py
　　x = 1
　　def f1():
　　print(from f1)
　　if __name__ == __main__:
　　f1()

五、包

　　包是一种管理 Python 模块命名空间的形式，包的本质就是一个含有.py的文件的文件夹。

　　包采用"点模块名称"。比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。

　　目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包。

　　在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。

　　导入包发生的三件事：

• 创建一个包的名称空间
• 由于包是一个文件夹，无法执行包，因此执行包下的.py文件，将执行过程中产生的名字存放于包名称空间中（即包名称空间中存放的名字都是来自于.py）
• 在当前执行文件中拿到一个名字aaa，aaa是指向包的名称空间的

　　导入包就是在导入包下的.py，导入m1就是导入m1中的__init__。

1、两种方式导入：

• import ... :
  import item.subitem.subsubitem这种导入形式，除了最后一项，都必须是包，而最后一项则可以是模块或者是包，但是不可以是类，函数或者变量的名字。
• from ... import...:
  当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定义的其他名称，比如函数，类或者变量。

2、import 导入包内的模块

　　import 可以每次只导入一个包里面的特定模块，他必须使用全名去访问。

import aaa.bbb.m3
　　print(aaa.bbb.m3.func3())

　　import方式不能导入函数、变量：import aaa.bbb.m3.f3错误

3、from import方式：

导入模块内具体的模块

　　这种方式不需要那些冗长的前缀进行访问

from aaa.bbb import m3
　　print(m3.func3())

导入模块内具体的功能

　　这种方式不需要那些冗长的前缀进行访问

from aaa.bbb.m3 import func3
　　print(func3())

4、 绝对导入和相对导入

绝对导入：

# aaa/.py
　　from aaa.m1 import func1
　　from aaa.m2 import func2

相对导入：

• .代表当前被导入文件所在的文件夹
• ..代表当前被导入文件所在的文件夹的上一级
• ...代表当前被导入文件所在的文件夹的上一级的上一级

from .m1 import func1
　　from .m2 import func2

5、from...import *

　　导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。

　　这里有一个例子，在:file:sounds/effects/__init__.py中包含如下代码:

__all__ = ["echo", "surround", "reverse"]

　　这表示当你使用from sound.effects import *这种用法时，你只会导入包里面这三个子模块。

六、软件开发的目录规范

　　为了提高程序的可读性与可维护性，我们应该为软件设计良好的目录结构，这与规范的编码风格同等重要，简而言之就是把软件代码分文件目录。假设你要写一个ATM软件，你可以按照下面的目录结构管理你的软件代码：

ATM/
　　-- core/
　　 -- src.py # 业务核心逻辑代码
　　-- api/
　　 -- api.py # 接口文件
　　-- db/
　　 -- db_handle.py # 操作数据文件
　　 -- db.txt # 存储数据文件
　　-- lib/
　　 -- common.py # 共享功能
　　-- conf/
　　 -- settings.py # 配置相关
　　-- bin/
　　 -- run.py # 程序的启动文件，一般放在项目的根目录下，因为在运行时会默认将运行文件所在的文件夹作为sys.path的第一个路径，这样就省去了处理环境变量的步骤
　　-- log/
　　 -- log.log # 日志文件
　　-- requirements.txt # 存放软件依赖的外部Python包列表，详见https://pip.readthedocs.io/en/1.1/requirements.html
　　-- README # 项目说明文件

settings.py

# settings.py
　　import os
　　BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
　　DB_PATH = os.path.join(BASE_DIR, db, db.txt)
　　LOG_PATH = os.path.join(BASE_DIR, log, user.log)
　　# print(DB_PATH)
　　# print(LOG_PATH)

common.py

# common.py
　　import time
　　from conf import settings
　　def logger(msg):
　　current_time = time.strftime(%Y-%m-%d %X)
　　with open(settings.LOG_PATH, mode=a, encoding=utf-8) as f:
　　f.write(%s %s % (current_time, msg))

src.py

# src.py
　　from conf import settings
　　from lib import common
　　def login():
　　print(登陆)
　　def register():
　　print(注册)
　　name = input(username>>: )
　　pwd = input(password>>: )
　　with open(settings.DB_PATH, mode=a, encoding=utf-8) as f:
　　f.write(%s:%s\n % (name, pwd))
　　# 记录日志。。。。。。
　　common.logger(%s注册成功 % name)
　　print(注册成功)
　　def shopping():
　　print(购物)
　　def pay():
　　print(支付)
　　def transfer():
　　print(转账)
　　func_dic = {
　　1: login,
　　2: register,
　　3: shopping,
　　4: pay,
　　5: transfer,
　　}
　　def run():
　　while True:
　　print("""
　　1 登陆
　　2 注册
　　3 购物
　　4 支付
　　5 转账
　　6 退出
　　""")
　　choice = input(>>>: ).strip()
　　if choice == 6: break
　　if choice not in func_dic:
　　print(输入错误命令，傻叉)
　　continue
　　func_dic[choice]()

run.py

# run.py
　　import sys
　　import os
　　BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
　　sys.path.append(BASE_DIR)
　　from core import src
　　if __name__ == __main__:
　　src.run()

七、Python标准库

　　https://docs.python.org/zh-cn/3.8/library/index.html

　　到此这篇关于Python基础之模块的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持盛行IT软件开发工作室。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。