模块和包的介绍和用法

一、模块

1、模块的定义

一个模块就是一个包含了python定义和声明的文件（文件名就是模块名字加上.py的后缀），模块可以被导入使用。

2、import加载的模块分为四个通用类别：　

（1）使用python编写的.py文件

（2）已被编译为共享库或DLL的C或C++扩展

（3）把一系列模块组织到一起的文件夹（注：文件夹下有一个__init__.py文件，该文件夹称之为包）

（4）使用C编写并链接到python解释器的内置模块

3、模块的使用

（1）模块可以包含可执行的语句和函数的定义，这些语句的目的是初始化模块，它们只在模块名第一次遇到导入import语句时才执行

import语句是可以在程序中的任意位置使用的,且针对同一个模块可以import多次,为了防止你重复导入，python的优化手段是：第一次导入后就将模块名加载到内存了，后续的import语句仅是对已经加载大内存中的模块对象增加了一次引用，不会重新执行模块内的语句

（2）首次import做了三件事：

1、为源文件创建新的名称空间

2、在新创建的命名空间中执行模块中包含的代码

3、创建源文件的名字来引用该命名空间

4、为模块名起别名

语法：import 模块名 as 别名

实例：有两中sql模块mysql和oracle，根据用户的输入，选择不同的sql功能
#mysql.py               #mysql模块
def sqlparse():
    print('from mysql sqlparse')
#oracle.py                #oracle模块
def sqlparse():
    print('from oracle sqlparse')
#test.py
db_type=input('>>: ')
if db_type == 'mysql':
    import mysql as db
elif db_type == 'oracle':
    import oracle as db
db.sqlparse()      #定义db别名的话，不管用户输入什么，程序会自动调用相应的模块

5、使用from ... import...导入模块

（1）和import...唯一的区别就是：使用from...import...则是将模块中的名字直接导入到当前的名称空间中，所以在当前名称空间中，直接使用名字就可以了、无需加前缀

（2）优点和缺点

优点：使用起来方便了

缺点：容易与当前执行文件中的名字冲突

（3）from...import *  这样会把模块中的所有名字导入，不包含以下划线(_)开头的名字

大部分情况下我们的python程序不应该使用这种导入方式，因为*你不知道导入了什么名字，很有可能会覆盖掉你之前已经定义的名字。而且可读性极其的差，在交互式环境中导入时没有问题。

（4）控制导入模块的名字

__all__=['money','read1'] #在要导入的模块文件中新增一行，这样在另外一个文件中用from spam import *就这能导入列表中规定的两个名字

6、 py文件区分两种用途:模块与脚本

（1）编写好的一个python文件可以有两种用途：

一：脚本，一个文件就是整个程序，用来被执行

二：模块，文件中存放着一堆功能，用来被导入使用

（2）python为我们内置了全局变量__name__，

当文件被当做脚本执行时：__name__ 等于'__main__'

当文件被当做模块导入时：__name__等于模块名

（3）作用：用来控制.py文件在不同的应用场景下执行不同的逻辑，方便测试模块

if __name__ == '__main__':      #表示作为文件被执行的时候，然后执行下面的代码

pass

7、模块的搜索路径

（1）在第一次导入某个模块时，会先检查该模块是否已经被加载到内存中（当前执行文件的名称空间对应的内存），如果有则直接引用

（2）如果没有，解释器则会查找同名的内建模块

（3）如果还没有找到就从sys.path给出的目录列表中依次寻找文件

二、包

1、包的介绍

包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

#具体的：包就是一个包含有__init__.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

2、为何要使用包

包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来

随着功能越写越多，我们无法将所以功能都放到一个文件中，于是我们使用模块去组织功能，而随着模块越来越多，我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性

3、注意事项

（1）.关于包的导入分为import和from ... import ...两种，但是无论什么情况，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点,但都必须遵循这个原则。但对于导入后，在使用时就没有这种限制了。

（2）import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

（3）包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

4、导入包的时候会执行包里面的__init__.py文件

5、绝对导入和相对导入

我们的最顶级包是写给别人用的，然后在包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：

绝对导入：以最顶级包作为起始

相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）

6、包以及包所包含的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的

如果执行文件和包在同一路径，那么程序会顺利执行。否则会报错，很显然，需要一种方法解决路径问题

import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))    #通过执行文件的绝对路径找到包的路径，这里包在执行文件两层目录外
sys.path.append(BASE_DIR)                                           #将包的路径添加到环境变量里

7、软件开发规范

#===============>star.py
import sys,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()
#===============>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.json')
LOG_PATH=os.path.join(BASE_DIR,'log','access.log')
LOGIN_TIMEOUT=5
"""
logging配置
"""
# 定义三种日志输出格式
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]'                   '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': LOG_PATH,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}
#===============>src.py
from conf import settings
from lib import common
import time
logger=common.get_logger(__name__)
current_user={'user':None,'login_time':None,'timeout':int(settings.LOGIN_TIMEOUT)}
def auth(func):
    def wrapper(*args,**kwargs):
        if current_user['user']:
            interval=time.time()-current_user['login_time']
            if interval < current_user['timeout']:
                return func(*args,**kwargs)
        name = input('name>>: ')
        password = input('password>>: ')
        db=common.conn_db()
        if db.get(name):
            if password == db.get(name).get('password'):
                logger.info('登录成功')
                current_user['user']=name
                current_user['login_time']=time.time()
                return func(*args,**kwargs)
        else:
            logger.error('用户名不存在')
    return wrapper
@auth
def buy():
    print('buy...')
@auth
def run():
    print('''
购物
查看余额
转账
    ''')
    while True:
        choice = input('>>: ').strip()
        if not choice:continue
        if choice == '1':
            buy()
#===============>db.json
{"egon": {"password": "123", "money": 3000}, "alex": {"password": "alex3714", "money": 30000}, "wsb": {"password": "3714", "money": 20000}}
#===============>common.py
from conf import settings
import logging
import logging.config
import json
def get_logger(name):
    logging.config.dictConfig(settings.LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(name)  # 生成一个log实例
    return logger
def conn_db():
    db_path=settings.DB_PATH
    dic=json.load(open(db_path,'r',encoding='utf-8'))
    return dic
#===============>access.log
[2017-10-21 19:08:20,285][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]
[2017-10-21 19:08:32,206][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]
[2017-10-21 19:08:37,166][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]
[2017-10-21 19:08:39,535][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]
[2017-10-21 19:08:40,797][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]
[2017-10-21 19:08:47,093][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]
[2017-10-21 19:09:01,997][MainThread:10900][task_id:core.src][src.py:19][INFO][登录成功]
[2017-10-21 19:09:05,781][MainThread:10900][task_id:core.src][src.py:24][ERROR][用户名不存在]
[2017-10-21 19:09:29,878][MainThread:8812][task_id:core.src][src.py:19][INFO][登录成功]
[2017-10-21 19:09:54,117][MainThread:9884][task_id:core.src][src.py:19][INFO][登录成功]

原创博客链接http://www.cnblogs.com/linhaifeng/articles/6379069.html

原文地址：http://blog.51cto.com/qidian510/2058272

时间： 2024-11-05 22:37:24

模块和包的介绍和用法的相关文章

python协程函数、递归、匿名函数与内置函数使用、模块与包

目录: 协程函数(yield生成器用法二) 面向过程编程 递归 匿名函数与内置函数的使用 模块 包 常用标准模块之re(正则表达式) 一.协程函数(yield生成器用法二) 1.生成器的语句形式 a.生成器相关python函数.装饰器.迭代器.生成器,我们是如何使用生成器的.一个生成器能暂停执行并返回一个中间的结果这就是 yield 语句的功能 : 返回一个中间值给调用者并暂停执行. 我们的调用方式为yeild 1的方式,此方式又称为生成器的语句形式. 而使用生成器的场景:使用生成器最好的场景就

day 5 正则 模块与包

协程函数 首先要明确协程函数特点:yield变为表达式,可以通过g.send(value)传值,用send传值时协程函数需要初始化,也可以说是生成器函数的一种 yield的另一种用法: 1.yield的语句形式: yield 1(生成器) 2.yield的表达式形式: x=yield (协程函数) x=yield g.send('1111'),先把1111传给yield,由yield赋值给x 然后再往下执行,直到再次碰到yield,然后把yield后的返回值返回 >>> def func

Python学习笔记五（模块与包）

一.模块 1.模块介绍 一个模块就是包含了一组功能的python文件,可以通过import导入模块使用. python中模块分为四个类别: a) 使用python编写的.py文件 b) 已被编译为共享库或DLL的C或C++扩展 c) 把一系列模块组织到一起的文件夹,文件夹内有__init__.py文件,称该文件夹为包 d) 使用C编写并链接到python解释器的内置模块 定义my_module.py模块,模块名为my_module print("from my_module.py")

python 深入模块和包

模块可以包含可执行语句以及函数的定义. 这些语句通常用于初始化模块. 它们只在 第一次 导入时执行.只在第一次导入的时候执行,第一次.妈蛋的第一次...后面再次导入就不执行了. [1](如果文件以脚本的方式执行,它们也会运行.) 每个模块都有自己的私有符号表, 模块内定义的所有函数用其作为全局符号表. 被导入的模块的名字放在导入模块的全局符号表中. import 语句的一个变体直接从被导入的模块中导入名字到导入模块的符号表中. 例如: >>> >>> from fibo

Spring 相关jar包详细介绍

文章转自:http://blog.csdn.net/farawayhome/article/details/6623946 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件. Aspectj是java最早的提供AOP的应用框架. dist 目录下是Spring 的发布包,关于发布包下面会详细进行说明. docs 目录下是相关的文档,包括有Spring api 的javadoc.reference 参考指南.Spring的标签库使用文件及Spring MVC 的M

python模块与包

模块是包括python定义和声明的文件.文件名=模块名+".py".模块名保存在全局变量__name__中. 1.模块中的执行语句,只是在导入时执行一次.这些语句通常用于初始化模块. 2.被导入的模块被放到全局语义表中. 3.import用法 +import moduleName +from moduleName import moudleContent +from moudleName import * 导入所有的除了以下划线开头的命名. 4.导入module查找路径:先从当前目录中

unity3D游戏开发之iTween介绍和用法

unity3D游戏开发之iTween介绍和用法 一．iTween 介绍 iTween是一个动画库,作者创建它的目的就是最小的投入实现最大的产出.让你做开发更轻松,用它可以轻松实现各种动画,晃动,旋转,移动,褪色,上色,控制音频等等 二．iTween 原理 iTween的核心是数值插值,简单说就是给iTween两个数值(开始值,结束值),它会自动生成一些中间值. 三．iTween 下载:  从官网http://itween.pixelplacement.com下载 主要文件有两个iTween.cs

day05 协程函数，递归函数，匿名函数lambda，内置函数map reduce filter max min zip sorted，匿名函数lambda和内置函数结合使用，面向过程编程与函数编程，模块与包的使用，re模块内置函数

基础篇 本章大纲: 协程函数 递归函数 匿名函数lambda 内置函数map reduce filter  max min zip sorted 匿名函数lambda和内置函数结合使用 面向过程编程与函数编程 模块与包的使用 re模块内置函数 一,协程函数 注意:函数先定义,后使用.这是函数第一原则.函数主要分为定义,调用 1.1,什么是协程函数 协程函数特点:yield变为表达式,可以通过g.send(value)传值,用send传值时协程函数需要初始化,也可以说是生成器函数的一种 1.2,协

python之路--模块和包--景丽洋

python之路--模块和包 阅读目录 一 模块 3.1 import 3.2 from ... import... 3.3 把模块当做脚本执行 3.4 模块搜索路径 3.5 编译python文件 二 包 2.2 import 2.3 from ... import ... 2.4 __init__.py文件 2.5  from glance.api import * 2.6 绝对导入和相对导入 2.7 单独导入包 回到顶部 一 模块 1 什么是模块? 常见的场景:一个模块就是一个包含了pyth