Python全栈工程师（包、模块的导入）-阿里云开发者社区

ParisGabriel

每天坚持手写一天一篇决定坚持几年为了梦想为了信仰

　　　　　　　　　　　　　　　　　　　　　　Python人工智能从入门到精通

$ pip3 install tensorflow ：
　　第三方模块 tensorflow 的安装
　　电脑必须有网命令行自动下载安装
dir（模块名）：
　　查看模块所有属性

自定义模块导入
示例:

自定义模块的实现方法


def myfac(n):
    print('正在计算', n, '的阶乘')


def mysum(n):
    print("正在计算1+2+3+...+%d的和" % n)


name1 = "Audi"
name2 = "TESLA"

print("mymod模块被加载!")

注意事项：
　　自定义模块的文件要求以.py结尾，文件名必须是标识符的规则

导入语句 import 语句等搜索块的路径顺序

　　import mymod
　　from mymod import myfac
　　from mymod import *
去哪儿找这个mymod.py?
　　搜索顺序:
　　　　1. 搜索程序运行时的路径(当前路径)
　　　　2. sys.path 提供的路径 sys.path是一个列表，里面放的都是模块的搜索路径
　　　　3. 搜索内建模块

模块的加载过程:
　　1. 在模块导入时，模块的所有语句都会执行
　　2. 如果一个模块已经导入，则再次导入时不会重新执行模块内的语句

模块的重新加载
　　import mymod
　　import imp
　　imp.reload(mymod) # 重新加载mymod模块

模块以导入和执行的过程:
　　1. 先搜索相关的路径，找到模块名.py
　　2. 判断是否有此模块对应的.pyc文件。如果.pyc比.py文件新,则直接加载.pyc文件
　　3. 否则用模块.py,文件生成.pyc，并加载执行

pyc python的编译
　　编译解释执行
　　mymod.py --------> mymod.pyc --------> python3

　　模块 --------> 编译好的Python3文件 --------> Python3解释执行器

模块的文档字符串:
　　模块内第一个没有赋值给任何变量的字符串称为模块的文档字符串

　　模块的 __doc__ 属性
　　　　此属性用于绑定模块的文档字符串

　　模块的 __file__属性
　　　　此属性用于记录模块对应的文件路径名

示例:

# 模块的文档字符串：

'''我的自定义模块mymod2

此模块有两个函数
  myfac和 mysum
...
'''


def myfac(n):
    '''自定义用来测试用的myfac的文档字符串'''
    print('正在计算', n, '的阶乘')


def mysum(n):
    print("正在计算1+2+3+...+%d的和" % n)


name1 = "Audi"
name2 = "TESLA"

print("mymod模块被加载!")

模块的 __name__属性
　　__name__属性用来记录模块自身名字

　　作用:
　　　　1. 记录模块名
　　　　2. 用来判断是否为主模块
　　说明:
　　　　当此模块为主模块(也就是第一个运行的模块时)运行时, __name__绑定 '__main__'
　　　　当此模块不是主模块时,而是被其它模块导入时，此时 __name__ 绑定模块名

示例:

'''此示例示意 mymod3的 __name__属性的用法'''



def test():
    pass


print("__name__属性绑定的值是:", __name__)


if __name__ == '__main__':
    print("当前mymod3.py 正在以主模块运行")
else:
    print("当前mymod3.py 正在被其它模块导入")
    print("我的模块名是", __name__)

模块的 __all__列表
　　模块中的 __all__列表是一个用来存放可导出属性的字符串列表

　　作用:
　　　　当用 from xxx import *语句导入时，只导入 __all__ 列表内的属性并且只对 from xx import * 有效

示例:

# __all__属性只对 from import * 语句有效

__all__ = ['hello1', 'name1']


def hello1():
    pass


def hello2():
    pass


def hello3():
    pass


name1 = 'aaaaaa'
name2 = 'aaaaaa'

模块的隐藏属性
　　模块中以'_'开头的属性，在from xxx import * 导入时，将不被导入，通常称这些属性为隐藏属性

示例:

 此模块在用from mymod5 import *导入时，只能导入:
# f1和 name1
def f1():
    pass


def _f2():
    pass


def __f3():
    pass


name1 = 'aaaaa'
_name2 = 'bbbbb'

随机模块 random
模块名: random
作用:
用于模拟或生成随机输出的模块

随机模块 random

说明：

random模块是用于模拟或生成随机输出的模块.

import random as R

函数名	描述
R.random()	返回一个[0, 1) 之间的随机实数
R.uniform(a,b)	返回[a,b) 区间内的随机实数
R.randrange([start,] stop[, step])	返回range(start,stop,step)中的随机数
R.choice(seq)	从序列中返回随意元素
R.shuffle(seq[, random])	随机指定序列的顺序(乱序序列）
R.sample(seq,n)	从序列中选择n个随机且不重复的元素

系统模块 sys

运行时系统相关的信息

sys模块的属性

属性	描述
sys.path	模块搜索路径 path[0] 是当前脚本程序的路径名，否则为 ''
sys.modules	已加载模块的字典
sys.version	版本信息字符串
sys.version_info	版本信息的命名元组
sys.platform	操作系统平台名称信息
sys.argv	命令行参数 argv[0] 代表当前脚本程序路径名
sys.copyright	获得Python版权相关的信息
sys.builtin_module_names	获得Python内建模块的名称（字符串元组）

sys模块的函数

函数名	描述
sys.exit([arg])	退出程序，正常退出时sys.exit(0)
sys.getrecursionlimit()	得到递归嵌套层次限制（栈的深度）
sys.setrecursionlimit(n)	得到和修改递归嵌套层次限制（栈的深度）

包(模块包) package
　　包的定义
　　包是将模块以文件夹的组织形式进行分组管理的管理方法
　　作用:
　　　　将一系列模块进行分类管理，有利于防止命名冲突
　　　　可以在需要时加载一个或部分模块则不是全部模块
包目录树示例:
　　mypack/ （包名）
　　　　__init__.py （__init__.py 文件）
　　　　menu.py （模块）

　　　　games/ （子包名1）
　　　　　　__init__.py （__init__.py 文件）
　　　　　　contra.py （模块）
　　　　　　supermario.py （模块）
　　　　　　tanks.py （模块）

　　　　office/ （子包名2）
　　　　　　__init__.py （__init__.py 文件）
　　　　　　word.py （模块）
　　　　　　excel.py （模块）
　　　　　　powerpoint.py （模块）

__init__.py 文件
__init__.py是常规包内必须存在的文件
__init__.py会在包加载时自动调用

　　作用:
　　　　1. 编写此包的内容
　　　　2. 在内部填写文档字符串
　　　　3. 在__init__.py文件内可以加载此包所依懒的一些其它模块

包的导入
　　同模块的导入规则
　　# import 语句
　　　　import 包名 [as 包新名]
　　　　import 包名.模块名 [as 模块新名]
　　　　import 包名.子包名.模块名 [as 模块新名]

　　# from import语句
　　　　from 包名 import 模块名 [as 模块新名]
　　　　from 包名.子包名 import 模块名 [as 模块新名]
　　　　from 包名.子包名.模块名 import 属性名 [as 属性新名]

　　# from import *语句
　　　　from 包名 import *
　　　　from 包名.模块名 import *
　　　　...

　　导入包时的索引路径顺序:
　　　　1. 搜索程序的当前路径
　　　　2. sys.path 提供的路径

__init__.py 内的 __all__ 列表
　　作用:
　　　　用来记录此包中有哪儿些子包或模块在用from import *语句时被导入
　　说明:
　　　　__all__列表只对 from xxx import *语句起作用

包的相对导入:
　　包的相对导入是指包内模块的相互导入（不能超过包的最高界限）

　　语法:
　　　　from 相对路径包或模块 import 属性或模块名
　　　　from 相对路径包或模块 import *
　　相对路径
　　　　. 代表当前目录
　　　　.. 代表上一级目录
　　　　... 代表上二级目录
　　　　.... 以此类推
　　　　注: 相对导入时不能超出包的外部

模块的导入分三种
　　　　import tiem 直接导入模块
　　　　from time import time 导入time模块的time功能
　　　　from mymod import * 导入time模块的所有功能
这里*导入可以直接使用函数不需要加模块名.函数如果有__all__属性只导入__all__列表里的

包也是分三种差不多包所导入的是文件夹

as 给包或者模块、属性、等改名
（.）统一代表什么什么下的什么什么
解释执行器就是先把.py文件翻译成二进制码.pyc文件再进行运行（先解释后执行）
　　但运模块时自动创建__pycache__ 文件夹里面放.pyc文件文档字符串和函数一样
　　一般用三引号括起来写就可以了第一行是标题换行第三行开始写详细内容
__name__属性返回一个字符串如果返回 __main__代表程序主入口也就是第一个运行的模块
　　否则返回当前模块的名字
__all__ 属性是一个列表当三种导入方式导入时只导入列表里的其他的不导入
__开头的函数属性当三种导入方式导入时不导入_开头的隐藏函数其他的全导入
__init__.py 是必须存在的文件不存在此文件夹就不是包
　　里面可以写属性包的文档字符串

导入路径优先相对路径其次sys.path路径
　　相对路径就是当前路径或路径名加上模块
　　path是系统环境变量列表相当于全局变量在任何目录都能调用这个列表里的路径

练习:
1. 猜数字游戏
随机生成一个 0~100之间的一个整数，用变量x绑定
让用户输入一个数y,输出猜数字的结果:
1) 如果y大于x则提示: "您猜大了"
2) 如果y小于x则提示: "您猜小了"
3) 如果y等于生成的数x,则提供示用户"恭喜您猜对了 "并退出猜数字
循环重复上述步聚，直到猜对为止。
猜对了，显示用户猜数字的次数，然后退出程序

答案：

import random
x = random.randrange(101)
i = 0
while True:
    s = int(input("请输入要猜的数字0～100:"))
    i += 1
    if s > x:
        print("大了")
    elif s < x:
        print("小了")
    else:
        print("猜对了")
        print("猜了%d次" % i)
        break

这里有个2分算法 100内的猜数字一般不超过7次猜对 10000不超过20次就能猜对

练习:
1. 写一个闹钟程序，启动时设置定时时间,
到时间后打印一句"时间到...." 然后退出程序

import time
def time_out():

    h = int(input("please input:"))
    m = int(input("please input:"))
    s = int(input("please input:"))
    d = (h, m, s)
    while True:
        s = time.localtime()
        print('%02d:%02d:%02d' % (s[3], s[4], s[5]), end = "\r")
        time.gmtime(1)
        if s[3: 6] >= d:
            print("Time out")
            break
time_out()

2. 模拟斗地主发牌,扑克牌共54张
黑桃('\u2660'), 梅花('\u2663'), 方块('\u2665'), 红桃('\u2666')
A2-10JQK
大王、小王
三个人玩，每人发17张牌，底牌留三张
输入回车, 打印出第1个人的17张牌
输入回车, 打印出第2个人的17张牌
输入回车, 打印出第3个人的17张牌
输入回车, 打印三张底牌

答案：

import random
L = {"大王", "小王"}
range(2, 11)
for x in {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"}:
    L.add("\u2660 " + x)
    L.add("\u2663 " + x)
    L.add("\u2665 " + x)
    L.add("\u2666 " + x)
print("共54张牌：", L)
print()
for x in range(3):
    input()
    s = set(random.sample(L, 17))
    if x == 0:
        x = "第一个玩家："
    elif x == 1:
        x = "第二玩家："
    elif x == 2:
        x = "第三个玩家："
    print(x, s)
    L -= s
print()
print("底牌：", L)

今天的：
3. 修改学生信息管理程序，将原student_info.py 拆分为模块
要求:
1. 主事件循环放在main.py中
2. show_menu 函数放在menu.py中
3. 与学生操作相关的函数放在 student_info.py中

还有昨天的：

下载地址：https://pan.baidu.com/s/17xFe_r0g8a-nP1PrUoTXCA

已吐血身亡下次补上太晚了嘤嘤嘤.........

# 创建输入函数：input_student开始　　　　　封装信息输入

# 创建输出函数：student完成    临时菜单封装


def student():
    for a in range(1, 8, 2):
        x = "*" * a
        print(x.center(9), x.center(10), x.center(10), x.center(9))
    else:
        for y in range(1, 4 + 1):
            c = "*"
            if 4 >= 10:
                c = "***"
            print(c.center(9), c.center(10), c.center(10), c.center(9))
    print("^^^^^^^^^^^^^ System menu ^^^^^^^^^^^^^")
    print("---------------------------------------")
    print("    1):    Add Student information     ")
    print("---------------------------------------")
    print("    2):    print Student information   ")
    print("---------------------------------------")
    print("    3):    delete Student information  ")
    print("---------------------------------------")
    print("    4):    revamp Student information  ")
    print("---------------------------------------")
    print("    5):    Results sorting High --> low")
    print("---------------------------------------")
    print("    6):    Results sorting low --> High")
    print("---------------------------------------")
    print("    7):    Age sort　High --> low       ")
    print("---------------------------------------")
    print("    8):    Age sort　low --> High       ")
    print("---------------------------------------")
    print("     please input number 1~8 select    ")
    print("---------------------------------------")
    print("        input :(Q)Exit procedure       ")
    print("---------------------------------------")

# 创建输出函数：perform完成


def input_student():
    L = []
    print("--------Student information enty--------")
    while True:
        name = input("please input name:")
        if name == "":
            q = input("operation succeed! return y　/　n　:")
            if q == "y":
                break
            else:
                input_student()
        age = int(input("please input age:"))
        score = int(input("please input score:"))
        d = {}
        d = {"name": name, "age": age, "score": score}
        print("+---------------+----------+----------+")
        name = d["name"].center(15)
        age = str(d["age"]).center(10)
        score = str(d["score"]).center(10)
        print('''|%s|%s|%s|''' % (name, age, score))
        print("+---------------+----------+----------+")
        print("-----Not input Enter be no revamp!-----")
        L.append(d)
    return L
# 创建输入函数：input_student完成

# 创建输出函数：output_student开始　　　封装列表打印


def output_student(lst):
    print("-------Student information sheet-------")
    print("+---------------+----------+----------+")
    print("|      Name     |    Age   |   Score  |")
    print("+---------------+----------+----------+")
    for x in lst:
        name = x["name"].center(15)
        age = str(x["age"]).center(10)
        score = str(x["score"]).center(10)
        print('''|%s|%s|%s|''' % (name, age, score))
        print("+---------------+----------+----------+")
    q = input("operation succeed! return y　/　n　:")
    if q == "y":
        pass
    else:
        output_student()
# 创建输出函数：output_student完成

# 创建输出函数：delete_student开始　　封装删除信息


def delete_student(lst):
    name = input("please input name delete:")
    for x in lst:
        if x["name"] == name:
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = str(x["age"]).center(10)
            score = str(x["score"]).center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            delet = input("whether delete (y:yes/y:no):")
            if delet == "y":
                lst.remove(x)
    q = input("operation succeed! return y　/　n　:")
    if q == "y":
        pass
    else:
        delete_student()
# 创建输出函数：delete_student完成

# 创建输出函数：revamp_student()开始　　　封装更改信息


def revamp_student(lst):
    name = input("please input name revamp:")
    for x in lst:
        if x["name"] == name:
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = str(x["age"]).center(10)
            score = str(x["score"]).center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            print("-----not input Enter be no revamp!-----")
            rage = input("please input age revamp:")
            rscore = input("please input score revamp:")
            if rage != "":
                x["age"] = rage
            if rscore != "":
                x["score"] = rscore
            print("+---------------+----------+----------+")
            name = x["name"].center(15)
            age = str(x["age"]).center(10)
            score = str(x["score"]).center(10)
            print('''|%s|%s|%s|''' % (name, age, score))
            print("+---------------+----------+----------+")
            print("-----------revamp perform!------------")
    
    q = input("operation succeed! return y　/　n　:")
    if q == "y":
        pass
    else:
        revamp_student()
# 创建输出函数：revamp_student()完成

# 创建输出函数：output_student_by_score_desc开始　成绩高～低排序


def output_student_by_score_desc(lst):
    def k(d):
        return int(d['score'])
    L = sorted(lst, key=k, reverse=True)
    output_student(L)


# 创建输出函数：output_student_by_score_asc开始　成绩低～高排序

def output_student_by_score_asc(lst):
    L = sorted(lst, key=lambda d: int(d['score']))
    output_student(L)


# 创建输出函数：output_student_by_age_desc开始　年龄高～低排序
def output_student_by_age_desc(lst):
    L = sorted(lst, key=lambda d: int(d['age']),
               reverse=True)
    output_student(L)


# 创建输出函数：output_student_by_age_asc开始　年龄低～高排序
def output_student_by_age_asc(lst):
    L = sorted(lst, key=lambda d: int(d['age']))
    output_student(L)

# 创建输出函数：System_menu()开始　　　　临时封装系统


def System_menu():
    L = []
    while True:
        student()
        select = input("            please input:")
        if select == '1':
            L += input_student()
        elif select == '2':
            output_student(L)
        elif select == '3':
            delete_student(L)
        elif select == '4':
            revamp_student(L)
        elif select == '5':
            output_student_by_score_desc(L)
        elif select == '6':
            output_student_by_score_asc(L)
        elif select == '7':
            output_student_by_age_desc(L)
        elif select == '8':
            output_student_by_age_asc(L)
        elif select == 'q':
            break
# 创建输出函数：System_menu()完成　　　　临时封装系统


# 运行

Python全栈工程师（包、模块的导入）

随机模块 random

说明：

random模块是用于模拟或生成随机输出的模块.

系统模块 sys

sys模块的属性

sys模块的函数

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Python全栈工程师（包、模块 的导入）

随机模块 random

说明：

random模块是用于模拟或生成随机输出的模块.

系统模块 sys

sys模块的属性

sys模块的函数

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

Python全栈工程师（包、模块的导入）