首页 > > 网络编程 > 其它 >

Python之路【第八篇】:Python模块

2019-04-25 06:55:45来源：博客园阅读 ()

阅读目录

一、模块和包

模块(module)的概念：

在计算机程序的开发过程中，随着程序代码越写越多，在一个文件里代码会越来越长，越来越不容易维护。

为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里，这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。在Python中，一个.py文件就称之为一个模块(module)。

使用模块有哪些好处？

1、最大的好处就是大大提高了代码的可维护性。
2、编写代码不必从零开始。当一个模块编写完成，就可以被其他地方调用。我们在编写程序的时候，也经常饮用其他模块，包括Python内置的模块和来自第三方的模块。

模块一共分为三种：

1、python标准库
2、第三方模块
3、应用程序自定义模块

注意：

使用模块还可以避免函数名跟变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中，因此，我们在自己编写模块时，不必考虑名字会与其他模块冲突。但是也要注意，尽量不要与内置函数名字冲突。

二、模块的导入方法

1、import语句

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

当我们使用import语句的时候，Python解释器是怎样找到对应的文件？答案就是解释器有自己的搜索路径，存在sys.path里。

import sys
print(sys.path)

运行结果如下：
['G:\\python_s3\\day21', 'G:\\python_s3', 'C:\\Python35\\python35.zip', 'C:\\Python35\\DLLs', 'C:\\Python35\\lib', 'C:\\Python35', 'C:\\Python35\\lib\\site-packages', 'D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\helpers\\pycharm_matplotlib_backend']

因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块没屏蔽掉。

2、from...import ...语句

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

这个声明不会把整个modulename模块导入到当前的命名空间中，只会讲它里面的name1或name2单个引入到执行这个声明的模块的全局符号表。

3、from...import*语句

from modname import *

4、运行本质

1、import test
2、from test import add

无论1还是2，首先通过sys.path找到test.py，然后执行test脚本，区别是1会将test这个变量名加载到名字空间，而2只会将add这个变量名加载进来。

5、包(package)

1、如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，成为包(Package)。
举个例子：一个abc.py的文件就是一个名字叫abc的模块，一个simon.py的文件就是一个叫simon的模块。
现在，假设我们的abc和simon这两个模块名字和其他模块起冲突了，于是我们可以通过包来组织模块，从而避免冲突。方法就是选择一个顶层包名：


2、引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，view.py模块的名字就变成了hello_django.app01.views，类似的，manage.py的模块名则是hello_django.manage。

请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。

注意点(important)

调用包就是执行包下的__init__.py文件

#1--------------------------------
在node1中import hello是找不到的，有人说可以找到呀，那是因为你的pycharm为你把myapp这一层路径加入到了sys.path里面，所以可以找到，然而程序一旦在命令行运行，则报错。有同学问那怎么办？简单啊，自己把这个路径加进去不就OK啦：


import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR) #临时修改
import hello
hello.hello1()

#2、--------------
if __name__=='__main__':
    print('ok')

“Make a .py both importable and executable”

如果我们是直接执行某个.py文件的时候，该文件中那么"__name__ == '__main__' "是True，但是我们如果从另外一个.py文件通过import导入该文件的时候，这时__name__的值就是我们这个py文件的名字而不是__main__.

这个功能还有一个用处：调试代码的时候，在"if __name__ == '__main__' "中加入一些我们的调试代码，我们可以让外部模块调用的时候不执行我们的调试代码，但是如果我们想排查问题的时候，直接执行该模块文件，调试代码能够正常运行！

##-------------cal.py
def add(x,y):
 
    return x+y
##-------------main.py
import cal      #from module import cal
 
def main():
 
    cal.add(1,2)
     
##--------------bin.py
from module import main
 
main.main()

注意：

# from module import cal 改成 from . import cal同样可以，这是因为bin.py是我们的执行脚本，
# sys.path里有bin.py的当前环境。即/Users/simon/Desktop/whaterver/project/web这层路径，
# 无论import what ,  解释器都会按这个路径找。所以当执行到main.py时，import cal会找不到，因为
# sys.path里没有/Users/simon/Desktop/whaterver/project/web/module这个路径，而
#  from  module/.  import cal 时，解释器就可以找到了。

三、time模块(* * * *)

三种时间表示

在Python中，通常有这几种方式来表达时间：
1、时间戳(timestamp):通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”,返回的是float类型。
2、格式化的时间字符串
3、元祖(struct_time):struct_time元祖共有9个元素：(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time

#1、time():  返回当前时间的时间戳
print(time.time())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
1555996405.5020845

#2、localtime(secs):  将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。
print(time.localtime())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=13, tm_min=18, tm_sec=9, tm_wday=1, tm_yday=113, tm_isdst=0)

#3、gmtime([secs])和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。
print(time.gmtime())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=5, tm_min=21, tm_sec=25, tm_wday=1, tm_yday=113, tm_isdst=0)

#4、mktime(t):  将一个struct_time转化为时间戳
print(time.mktime(time.localtime())) #

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
1555998160.0

#5、asctime([t]):  把一个表示时间的元祖或者struct_time表示为这种形式：'Tue Apr 23 13:45:49 2019'

#如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
Tue Apr 23 13:45:49 2019


#6、ctime([secs]):  把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

print(time.ctime())  #Tue Apr 23 14:02:45 2019

print(time.ctime(time.time()))  #Tue Apr 23 14:03:50 2019


#7、strftime(format[,t])  #把一个代表时间的元祖或者struct_time(如由time.localtime()和time.gmtime()返回)  转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素过界，ValueError的错误将会被抛出。

print(time.strftime("%Y-%m-%d %X",time.localtime()))  #2019-04-23 14:11:12


#8、time.strptime(string[, format])  #把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

print(time.strptime('2019-04-23 14:15:07', '%Y-%m-%d %X'))

输出结果为：
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=14, tm_min=15, tm_sec=7, tm_wday=1, tm_yday=113, tm_isdst=-1)

#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

#9、sleep(sesc)
print(time.sleep(3))   #线程推迟指定的时间运行，单位为秒。


#10、clock

# 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数(时间戳)。而在windows中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间，即两次时间差。

关系图：

四、random模块(* *)

import random

ret=random.random()
# ret=random.randint(1,3)  #[1,3]
# ret=random.randrange(1,3)  #[1,3]
# ret=random.choice([11,22,33,44,55])
# ret=random.sample([11,22,33,44,55],2)
# ret=random.uniform(1,4)
# print(ret)
# ret=[1,2,3,4,5]
# random.shuffle(ret)
# print(ret)

item=[1,3,5,7,9]
random.shuffle(item)
print(item)

#随机生成验证码

import random
def v_code():

    ret=""
    for i in range(5):
        num=random.randint(0,9)
        alf=chr(random.randint(65,122))

        s=str(random.choice([num,alf]))
        ret+=s
    return ret
print(v_code())

五、os模块(* * * *)

os模块是与操作系统交互的接口

os.getcwd()  #获取当前工作目录，即当前python脚本的目录路径

os.chdir("dirname")  #改变当前脚本工作目录，相当于shell下cd

os.cudir  #返回当前目录：(' . ')

os.pardir   #获取当前目录的父目录字符串名：(' . . ')

os.makedirs('dirname1/dirname2')  #可生成多层递归目录

os.removedirs('dirname1')  #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推

os.mkdir('dirname')  #生成单级目录，相当于linux中mkdir dirname

os.rmdir('dirname')   #删除单级空目录，若目录不为空则无法删除，报错，相当于shell中rmdir dirname

os.listdir('dirname')  #列出指定目录下的所有文件和子目录，包含隐藏文件，并以列表的方式打印

os.remove()  #删除一个文件

os.rename("oldname","newname")  #重命名文件/目录

os.stat('path/filename')   #获取文件/目录信息
例：
print(os.stat("sss.py"))
C:\Python35\python3.exe G:/python_s3/day22/os_test.py
os.stat_result(st_mode=33206, st_ino=11821949021847676, st_dev=2159804260, st_nlink=1, st_uid=0, st_gid=0, st_size=10, st_atime=1556025329, st_mtime=1556025329, st_ctime=1556025302)

os.sep   #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep  #输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"

os.pathsep   #输出用于分隔文件路径的字符 win下为; ,Linux下为：

os.name   #输出字符串指示当前使用平台。win-->'nt'; Linux-->'posix'

os.system("bash command")   #运行shell命令，直接显示

os.environ   #获取系统环境变量
例：
print(os.environ)
environ({'FP_NO_HOST_CHECK': 'NO', 'PUBLIC': 'C:\\Users\\Public', 'PYCHARM': 'D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\bin;', 'COMPUTERNAME': 'DELL-PC', 'PYTHONPATH': 'G:\\python_s3;D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\helpers\\pycharm_matplotlib_backend', 'PYCHARM_HOSTED': '1', 'PYCHARM_MATPLOTLIB_PORT'

os.path.abspath(path)   #返回path规范化的绝对路径

os.path.split(path)   #将path分割成目录和文件名二元组返回
例：
print(os.path.split(r"G:\python_s3\day22\sss.py"))
输出结果：
('G:\\python_s3\\day22', 'sss.py')

os.path.dirname(path)   #返回path的目录。其实就是os.path.split(path)的第一个元素
例：
print(os.path.dirname(r"G:\python_s3\day22\sss.py"))
输出结果：
G:\python_s3\day22

os.path.basename(path)   #返回path最后的文件名，如果path以/ 或 \结尾，那么就会返回空值。即os.path.split(path) 的第二个元素
例：
print(os.path.basename(r"G:\python_s3\day22\sss.py"))
输出结果：
sss.py

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,paht2[,  ...])   #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
例：
a="G:\python_s3\day22"
b="sss.py"

print(os.path.join(a,b))
输出结果：
G:\python_s3\day22\sss.py

os.path.getatime(paht)   #返回path所指向的文件或者目录的最后存取时间

os.path.getmtime(path)   #返回path所指向的文件或者目录的最后修改时间

三、实现装饰器知识储备

装饰器=高阶函数+函数嵌套+闭包

四、高阶函数

高阶函数的定义：
1、函数接收的参数是一个函数名
2、函数的返回值是一个函数名
3、满足上述条件任意一个，都可称之为高阶函数

五、函数嵌套

def father(name):
    print('from father %s' %name)
    def son():
        print('from the son')
        def grandson():
            print('from the grandson')
        grandson()
    son()

father('朱锐')

六、闭包

1、闭包

def father(name):
    print('from father %s' %name)
    def son():
        print('from the son')
        def grandson():
            print('from the grandson')
        grandson()
    son()

father('朱锐')

'''
闭包
'''

def father(name):
    def son():
        # name='simon1'
        print('我的爸爸是%s' %name)
        def grandson():
            print('我的爷爷是%s' %name)
        grandson()
    son()
father('simon')

2、函数闭包装饰器基本实现

import time
def timmer(func):
    def wrapper():
        # print(func)
        start_time=time.time()
        func() #就是在运行test()
        stop_time=time.time()
        print('运行时间是%s' %(stop_time-start_time))
    return wrapper
@timmer #语法糖，这个是重点

def test():
    time.sleep(3)
    print('test函数运行完毕')

# res=timmer(test) #返回的是wrapper的地址
# res() #执行的是wrapper()

# test=timmer(test) #返回的是wrapper的地址
# test() #执行的是wrapper()

test()
'''
语法糖
'''
# @timmer #就相当于 test=timmer(test)

3、函数闭包加上返回值

#未加返回值
import time
def timmer(func):
    def wrapper():
        # print(func)
        start_time=time.time()
        func() #就是在运行test()
        stop_time=time.time()
        print('运行时间是%s' %(stop_time-start_time))
        return 123
    return wrapper
@timmer #语法糖

def test():
    time.sleep(3)
    print('test函数运行完毕')
    return '这是test的返回值'
res=test() #就是在运行wrapper
print(res)

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day20/加上返回值.py
test函数运行完毕
运行时间是3.000171661376953
123

#加上返回值
import time
def timmer(func):
    def wrapper():
        # print(func)
        start_time=time.time()
        res=func() #就是在运行test()     ##主要修改这里1
        stop_time=time.time()
        print('运行时间是%s' %(stop_time-start_time))
        return res     ##修改这里2
    return wrapper
@timmer #语法糖

def test():
    time.sleep(3)
    print('test函数运行完毕')
    return '这是test的返回值'
res=test() #就是在运行wrapper
print(res)

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day20/加上返回值.py
test函数运行完毕
运行时间是3.000171661376953
这是test的返回值

4、函数闭包加上参数

import time
def timmer(func):
    def wrapper(name,age):   #加入参数，name,age
        # print(func)
        start_time=time.time()
        res=func(name,age) ##加入参数，name,age
        stop_time=time.time()
        print('运行时间是%s' %(stop_time-start_time))
        return res
    return wrapper
@timmer #语法糖

def test(name,age): #加入参数，name,age
    time.sleep(3)
    print('test函数运行完毕,名字是【%s】,年龄是【%s】' % (name,age))
    return '这是test的返回值'
res=test('simon',18) #就是在运行wrapper
print(res)

使用可变长参数代码如下：达到的效果是传参灵活

import time
def timmer(func):
    def wrapper(*args,**kwargs): #test('simon',18)  args=('simon') kwargs={'age':18}
        # print(func)
        start_time=time.time()
        res=func(*args,**kwargs) #就是在运行test()     func(*('simon'),**{'age':18})
        stop_time=time.time()
        print('运行时间是%s' %(stop_time-start_time))
        return res
    return wrapper
@timmer #语法糖

def test(name,age):
    time.sleep(3)
    print('test函数运行完毕,名字是【%s】,年龄是【%s】' % (name,age))
    return '这是test的返回值'
def test1(name,age,gender):
    time.sleep(1)
    print('test函数运行完毕,名字是【%s】,年龄是【%s】,性别是【%s】' % (name,age,gender))
res=test('simon',18) #就是在运行wrapper
print(res)

test1('simon',18,'male')

5、装饰器的使用

#无参装饰器
import time
def timmer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print('run time is %s' %(stop_time-start_time))
        return res
    return wrapper

@timmer
def foo():
    time.sleep(3)
    print('from foo')
foo()

#有参装饰器
def auth(driver='file'):
    def auth2(func):
        def wrapper(*args,**kwargs):
            name=input("user: ")
            pwd=input("pwd: ")

            if driver == 'file':
                if name == 'simon' and pwd == '123':
                    print('login successful')
                    res=func(*args,**kwargs)
                    return res
            elif driver == 'ldap':
                print('ldap')
        return wrapper
    return auth2

@auth(driver='file')
def foo(name):
    print(name)

foo('simon')

#验证功能装饰器

#验证功能装饰器
user_list=[
    {'name':'simon','passwd':'123'},
    {'name':'zhurui','passwd':'123'},
    {'name':'william','passwd':'123'},
    {'name':'zhurui1','passwd':'123'},
]
current_dic={'username':None,'login':False}


def auth_func(func):
    def wrapper(*args,**kwargs):
        if current_dic['username'] and current_dic['login']:
            res=func(*args,**kwargs)
            return res
        username=input('用户名：').strip()
        passwd=input('密码：').strip()
        for user_dic in user_list:
            if username == user_dic['name'] and passwd == user_dic['passwd']:
                current_dic['username']=username
                current_dic['login']=True
                res=func(*args,**kwargs)
                return res
        else:
            print('用户名或者密码错误')

        # if username == 'simon' and passwd == '123':
        #     user_dic['username']=username
        #     user_dic['login']=True
        #     res=func(*args,**kwargs)
        #     return res
        # else:
        #     print('用户名或密码错误')
    return wrapper

@auth_func
def index():
    print('欢迎来到某宝首页')
@auth_func
def home(name):
    print('欢迎回家%s' %name)
@auth_func
def shopping_car(name):
    print('%s购物车里有[%s,%s,%s]' %(name,'餐具','沙发','电动车'))

print('before----->',current_dic)
index()
print('after---->',current_dic)
home('simon')
# shopping_car('simon')

#带参数验证功能装饰器

#带参数验证功能装饰器
user_list=[
    {'name':'simon','passwd':'123'},
    {'name':'zhurui','passwd':'123'},
    {'name':'william','passwd':'123'},
    {'name':'zhurui1','passwd':'123'},
]
current_dic={'username':None,'login':False}

def auth(auth_type='filedb'):
    def auth_func(func):
        def wrapper(*args,**kwargs):
            print('认证类型是',auth_type)
            if auth_type == 'filedb':
                if current_dic['username'] and current_dic['login']:
                    res = func(*args, **kwargs)
                    return res
                username=input('用户名：').strip()
                passwd=input('密码：').strip()
                for user_dic in user_list:
                    if username == user_dic['name'] and passwd == user_dic['passwd']:
                        current_dic['username']=username
                        current_dic['login']=True
                        res = func(*args, **kwargs)
                        return res
                else:
                    print('用户名或者密码错误')
            elif auth_type == 'ldap':
                print('这玩意没搞过，不知道怎么玩')
                res = func(*args, **kwargs)
                return res
            else:
                print('鬼才知道你用的什么认证方式')
                res = func(*args, **kwargs)
                return res

        return wrapper
    return auth_func

@auth(auth_type='filedb') #auth_func=auth(auth_type='filedb')-->@auth_func 附加了一个auth_type  --->index=auth_func(index)
def index():
    print('欢迎来到某宝主页')

@auth(auth_type='ldap')
def home(name):
    print('欢迎回家%s' %name)
#
@auth(auth_type='sssssss')
def shopping_car(name):
    print('%s的购物车里有［%s,%s,%s］' %(name,'奶茶','妹妹','娃娃'))

# print('before-->',current_dic)
# index()
# print('after--->',current_dic)
# home('simon')
shopping_car('simon')

原文链接:https://www.cnblogs.com/hackerer/p/10753752.html
如有疑问请与原作者联系

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有