python基础（13）——系统模块sys & 用户自定义模块 & 随机模块 random & 包(模块包)

 

一、系统模块sys

     运行时系统相关的信息

#1 退出程序 
import sys
print('这是第一行打印')
sys.exit()
print('这是第二行打印')

import sys

print('当前用户输入的参数个数是:', len(sys.argv))
print("当前用户的参数的列表是:", sys.argv)

import sys
print('current version is ', sys.version)

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)	得到和修改递归嵌套层次限制（栈的深度）

二、用户自定义模块

 要求:
     模块名以".py"结尾
     模块名必须是标识符的命名规则
     避免名称和内建模块冲突
 导入方式:
     import 语句
     from import 语句
     from import * 语句

# 此示例示意自义模块
def myfac(n):
    print("正在计算%d的阶乘...." % n)

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

name1 = "audi"
name2 = 'Tesla'

'''这是一个自定义模块mymod的文档字符串

此模块有两个函数和两个数据...
此处省略100字
'''
# 此示例示意自义模块
def myfac(n):
    print("正在计算%d的阶乘...." % n)


def mysum(n):
    print("正在计算1+2+3+....+", n, '的和....')
name1 = "audi"
name2 = 'Tesla'

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

print("我的模块名是:", __name__)

if __name__ == '__main__':
    print("我正在以主模块方式运行")
    mysum(10000)

1、import 语句的搜索路径顺序

    1. 索引内建模块 builtin
    2. 搜索程序的运行时路径(当前路径)
    3. sys.path提供的路径
        两种方法让用户自定义模块被导入:
           1) 将模块安装(复制)到 sys.path提供的路径
           2) 在运行程序时，在sys.path里添加自定义的路径

2、模块的加载过程:

   在模块导入时，模块的所有语句都会执行
   如果一个模块已经被导入，则再次导入时不会重新执行模块内的语句

3、模块的重新加载:

   import mymod
   import imp
   imp.reload(mymod)

4、模块被导入和执行的过程

   1、先搜索相关路径找模块文件(.py文件)
   2、判断是否有此模块对应的.pyc,如果pyc文件存在且比.py文件新则直接加载.pyc文件　
   3、否则用模块名.py 文件生成.pyc 并加载执行

5、模块的编译

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

6、模块的属性

   1、模块的文档字符串
       模块内的第一次没有赋值给任何变量的字符串为模块的文档字符串
       模块内的文档字符串绑定在模块的__doc__属性上

   2、 __doc__属性 

               __doc__属性用来绑定文档字符串

   3、__file__属性
               __file__ 属性用于绑定此模块对应的文件路径

   4、__name__属性
       作用:
           １．用来记录模块自身的名字
           ２．用来判断是否为主模块
          （注: 主模块是指程序最先被python3执行的模块)
       说明:
            当此模块为主模块运行时，__name__的值为'__main__'
            当此模块不是主模块时,__name__绑定模块的名字

7、模块的__all__ 列表:

      模块中的__all__列表必须是一个字符串列表
   作用:
       当用from xxx import *导入时，只导入__all__列表内的属性

# 此例表限定当用from mymod2 import *时只导入f1和var1
__all__ = ['f1', 'var1']
def f1():
    pass


def f2():
    pass

def f3():
    pass
var1 = 100
var2 = 200

8、模块的隐藏属性

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

# 此模块示意模块的隐藏属性
def f1():
    pass

def _f2():
    pass

def __f3():
    pass

name1 = "abc"
_name2 = '123'

三、随机模块 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个随机且不重复的元素

练习:
   １．猜数字游戏:
     随机生成一个0~100之间的一个整数，用变量x绑定　
     让用户输入一个整数用y绑定,输出猜数字的结果:
         如果y等于生成的数x,则提示'您猜对了', 并退出程序
         如果y大于x,则提示用户'您猜大了'
         如果y小于x,则提示用户'您猜小了'，并继续猜
     直到猜对为止，显示用户猜数字的次数后退出程序

import random
x = random.randrange(101)

count = 0  # 用来记录猜测次数

while True:
    y = int(input("请输入: "))
    count += 1  # 次数加1
    if y == x:
        print("您猜对了")
        break
    elif y > x:
        print('您猜大了')
    elif y < x:
        print('您猜小了')

print("您猜了%d次" % count)

包(模块包)  Package

包的定义：
     包是将模块以文件夹的组织形式进行分组管理的方法
作用：
     将一系列模块进行分类管理，有利于防止命名冲突
     可以在需要时加载一个或部分模块而不是全部模块
包示例:
     mypack/
         __init__.py
         menu.py
         games/
             __init__.py
             contra.py
             supermario.py
             tanks.py
         office/
             __init__.py
             word.py
             excel.py

1、包内的 __init__.py 文件　

   __init__.py 是常规包内必须存在的文件
   __init__.py 文件会在包加载时被自动调用
   作用:
     编写此包的内容
     编写包的文档字符串

2、包的绝对导入:

   规则类似于模块的导入规则
   import 包名 [as 包新名]
   import 包名.模块名 [as 模块新名]
   import 包名.子包名.模块名 [as 模块新名]
   ...

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

   from 包名 import *
   from 包名.模块名 import *
   ...

3、import 语句搜索引　包的路径顺序

    1. 搜索程序运行时的路径(当前路径)
    2. sys.path提供的路径

4、__init__.py 内的__all__列表

   作用:
     用来记录此包中有哪儿些子包或模块需要导入
     当用from 包 import *语句导入模块时，只查找 __all__ 列表中所有的模块或子包
   说明:
     __all__列表只有在from xxx import *导入时起作用
   示例见:
     mypack/games/__init__.py

5、包的相对导入

   包的相对导入是指包内模块的相互导入

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

# 调用mypack/games/contra.py里的gameover()
import mypack.games.contra

mypack.games.contra.gameover()

# 此主模块用来测试和调用mypack包里的模块中的函数　
# import mypack.menu
# mypack.menu.show_menu()  # 第一种调用方式

# from mypack.menu import show_menu
# show_menu()

# import mypack.games.contra
# mypack.games.contra.play()

import mypack.games.contra as c
c.play()

from mypack.games.contra import play
play()

from mypack.games.contra import *

6、x循环嵌套导入错误

    如何解决：frome b import y 改为 import b

练习:

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

kinds = ['\u2660 ', '\u2663 ', '\u2665 ', '\u2666 ']
numbers = ['A'] + [str(x) for x in range(2, 11)] + list("JQK")
pokes = ['大王', '小王']
for k in kinds:
    for n in numbers:
        pokes.append(k + n)  # 生成一张牌并加入pokes列表中


L = pokes.copy()  # 从新牌复制一份
import random
random.shuffle(L)  # 洗牌
# print(L)

input()  # 等待键盘输入
print("第1个人的17张牌是:", L[:17])
#   输入回车,打印第2个人的17张牌
input()  # 等待键盘输入
print("第2个人的17张牌是:", L[17:34])
#   输入回车,打印第3个人的17张牌
input()  # 等待键盘输入
print("第3个人的17张牌是:", L[34:51])
#   输入回车,打印三张底牌
input()
print("底牌是:", L[51:])

   2. 打印 九九乘法表:
       1x1=1
       1x2=2 2x2=4
       1x3=3 2x3=6 3x3=9
       .....
       1x9=9 ..............9x9=81

#  方法1 循环嵌套
for line in range(1, 10):  # line代表行数
    for col in range(1, line + 1):  # col 代表列
        print("%dx%d=%d" % (col, line, col * line), end=' ')
    print()  # 换行

# 方法2 函数嵌套调用
def print_aline(end):
    for col in range(1, end + 1):
        print("%dx%d=%d" % (col, end, col * end), end=' ')
    print()


def print_99():
    for line in range(1, 10):
        # 打印一行
        print_aline(line)


print_99()