Python 基础5 模块

模块 Module:
　　什么是模块
　　　　模块是一个包含有一系列数据，函数，类等组成的程序组；
　　　　模块是一个文件，模块文件名通常以‘.py’结尾；

模块的作用：
　　1.让一此相关的数据，函数，类等有逻辑的组织在一起，使逻辑结构更加清晰；
　　2.模块中的变量，函数和类等可提供给其它模块或程序使用；
模块的分类：
　　1.内置模块（builtins）在解析器的内部可以直接使用；通常是c语文写的，执行效率高；
　　2.标准库模块，安装python时已经安装具可直接使用；import copy;
　　3.第三方模块（通常为开源）,需要自己安装；pip3 install tensorflow安装第三方库
　　4.用户自己编写的模块（可以作为其它人的第三方模块）；

模块的导入 import:
　　import 语句
　　语法：import 模块名1 [as 模块新名1]，模块名2[as 模块新名2]，...　　

　　作用：将一个模块整体导入到当前模块中；

　　属性用法：
　　　　模块名.属性名
　　　　help(obj） 可以查看模块的文档字符串；

示例：
    import math   #导入数学模块
    help(math)  查看模块里文档
    >>> math.factorial(5)    #阶乘函数
    120
    >>> math.log(1024,2)    #2 ** 10  = 1024  #求次方数
    10.0
    >>> math.sqrt(4)    #平方根
    2.0
    >>> math.sqrt(16)
    4.0
    >>> math.pi        #
    3.141592653589793

    import sys, os   #导入sys和os模块
    import copy as cp    #导入copy模块，并对copy模块重新命名为cp新简单名字，方便自己调用
    >>> L = [1,2,3,4]
    >>> l2 = cp.deepcopy(L)
    >>> id(l2)
    2289561136072
    >>> id(L)
    2289558822024

from import 语句：
　　语法：
　　from 模块名 import 模块属性名 [as 属性新名1]，模块属性名2 [as 属性新名2]
　　作用：
　　　　将某模块的一个或多个属性导入到当前模块的作用域；

    示例：
          from math import pi
          from math import sin
                  from math import factorial as fac

from import * 语句：
　　语法：
　　　　from 模块名 import *
　　作用：
　　　　将某模块的所有属性导入到当前的模块；

示例：
    from math import *
    s = sin(pi/2)

模块被导入，只执行一次，就会被加载到字典中，再执行导入时，去字典中找，发现有对应的模块键，就不再在执行。
　　import sys
　　sys.modules 查看已导入模块的字典

模块的导入语句：
import xxx 官方优先使用
from xxx import yyy 
from xxx import *
导入语句实质是 在本地创建变量来绑定模块或函数或数据；

包的相对导入：
　　　　指包内模块的相互导入；
　　语法：
　　　　from 相对路径包或模块 import 属性或模块
　　　　或
　　　　from 相对路径包或模块 import *
　　说明：
　　　　包的相对导入不能用于Import xxx语句中
　　相对路径：
　　　　. 代表当前目录
　　　　.. 代表上一级目录
　　　　... 代表上级二级目录
　　　　.... 以此类推
　　　　注：相对导入时不能超出包的外部

　　包的加载路径：
　　　　同模块的加载路径搜索：
　　　　1.搜索当前路径;
　　　　2.搜索sys.path给定的路径;

dir() 函数：
　　　　dir([对象]) 返回一个字符串列表
　　作用：
　　　　1、如果没有参数调用，则返回当前作用域内所有变量的列表；
　　　　2、如果给定一个对象作为参数，则返回这个对象所在变量（属性）列表；
　　　　　　a. 对于一个模块，返回这个模块的全部变量；
　　　　　　b.对于一个类对象，返回类对象的所有变量，并递归基类对象的所有变量；
　　　　　　c.对于其它对象，返回所有变量、类变量和基类变量

• 数学模块 math: 文档参见： math.e 自然对数的底e math.pi 圆周率pi math.ceil(x) 对x向上取整，比如x=1.2，返回2 math.floor(x) 对x向下取整，比如x=1.2，返回1 math.sqrt(x) 返回x的平方根 math.factorial(x) 求x的阶乘 math.log(x[, base]) 返回以base为底x的对数, 如果不给出base,则以自然对数e为底 math.log10(x) 求以10为底x的对数 math.pow(x, y) 返回 x**y (x的y次方) math.fabs(x) 返回浮点数x的绝对值 角度和弧度degrees互换 math.degree(x) 将弧度x转换为角度 math.radians(x) 将角度x转换为弧度 三角函数 math.sin(x) 返回x的正弦(x为弧度) math.cos(x) 返回x的余弦(x为弧度) math.tan(x) 返回x的正切(x为弧度) math.asin(x) 返回x的反正弦(返回值为为弧度) math.acos(x) 返回x的反余弦(返回值为为弧度) math.atan(x) 返回x的反正切(返回值为为弧度)

• 系统模块 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.stdin 标准输入文件对象，多用于input()； sys.stdout 标准输出文件对象,多用于print()； sys.stderr 标准错误输出文件对象, 用于输出错误信息； sys模块的方法： sys.exit([arg]) 退出程序，正常退出时sys.exit(0)； sys.getrecursionlimit() ； sys.getrecursionlimit() 得到递归嵌套层次限制（栈的深度）； sys.setrecursionlimit(n) 得到和修改递归嵌套层次限制（栈的深度）； 自定义模块： 示例见: mymod.py #自定义模块 test_mymod.py #导入并测试模块

import 语句搜索模块的路径顺序：
　　　　1. 搜索程序运行时的路径（当前路径）
　　　　2. sys.path 提供的路径
　　　　3. 搜索内置模块
　　#为sys.path 列表添加一个路径
　　　　sys.path.append('/home/tarena') #解决方案

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

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

模块被导入和执行的过程：
　　　　1.先搜索相关路径 找模块（.py文件）
　　　　2.判断是否有此模块对应的.py文件，如果.pyc文件比.py文件新（时间戳），则直接加载.pyc文件(python3的缓存文件 字节码)；
　　　　3.否则用模块.py文件生成.pyc并加载执行；

pyc模块的编译：compile
　　编译 解释执行
　　mymod.py --------------> mymod.pyc------------------------>python3
　　编译成python3可快速执行的.pyc文件，python3在解析成CPU可运行的指令；

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

模块的__doc__属性：help(mymod)
    用于绑定模块文档字符串；
模块的__file__属性：dir(mymod)    mymod.__file__
    用于绑定模块对应.py文件路径；
模块的__name__属性：
    用来记录模块的自身的名字；
__name__作用：
      1.记录模块名
      2. 判断是否为主模块
__name__说明：
      1. 当此模块作为主模块（也就是第一个运行的模块）运行时，__name__绑定'__main__'; 
      2. 当此模块不是主模块时，__name__绑定模块名（文件名去掉.py后缀）；

模块的__all_列表：
    模块中的__all__列表是一个用来存放可导出属性的字符串列表；
__all__作用：
    限定当用from xxx import * 语句导入时，只导入__all__列表内的属性；
示例：mymod4.py
#__all__列表限定其它模块在用from mymod4 import * 导入时只导入‘myfun1’, 'myfun2','name1'
只需要在模块内定义__all__，即可实现；
__all__ = [‘myfun1’, 'myfun2','name1']

模块的隐藏属性：
    模块中以'_' 开头的属性，在from xxx import * 导入时将不被导入，通常称为隐藏属性；
#mymod6.py
var = 100
def print_var():
    print('var = ', var)
def set_var(n):
    global var
    var = n

#test_mymod6.py
from mymod6 import var
from mymod6 import print_var
from mymod6 import set_var

var = 200    #赋值只能改变本模块内的全局变量
print_var()    #100
set_var(300)
print_var()    #300

• 随机模块 random： 作用： 用于模拟或生成随机输出的模块 随机模块 random 说明：random模块是用于模拟或生成随机输出的模块. import random as R R.random() 返回一个[0, 1) 之间的随机实数，包括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个随机且不重复的元素 R.getrandbits(nbit) 以长整型的形式返回用nbit位来表示的随机数 R.seed(a=None) 用给定的数a设置随机种子,不给参数a则用当前时间设置随机种子

import random

# print(random.random()) #生成0到1之间的小数
# print(random.randint(1,8)) #包括8
# print(random.choice(['hello',4,[1,2]])) #随机选择1个元素
# print(random.sample(['hello',4,[1,2]],2))   #从序列中选2个
# print(random.randrange(1,5))    #不包括5
# print(chr(90))    #将90数字转换为ascii码的字母

#生成5位的随机验证码，要包含字母与数字
def v_code():
    code=''
    for i in range(5):
        add=random.choice([random.randrange(10),chr(random.randrange(65,91))]) 
        code+=str(add)
    print(code)

v_code()

包（模块包） package:
　　　　包是将模块以文件夹的组织形式进行分组管理的方法；
　　作用：
　　　　将一系列模块进行分类管理，有利于访问命名冲突可以在需要时加载一个或部分模块，而不是全部模块；

包示例：test_mypack.py
    mypack/
        __init__.py
        menu.py
        games/
            __init__.py
            contra.py
            supermario.py
            tanks.py
        office/
            __init__.py
            execl.py
            word.py
            powerpoint.py
创建命令：
    mkdir mypack
    cd mypacd
    touch __init__.py menu.py
    mkdir games office
    cd games
    touch __init__.py contra.py supermario.py tanks.py
    cd ../office

#test_mypack.py    
import mypack          #导入mypack包
import mypack.games     #导入mypack里的games子包
import mypack.menu     #导入mypack里的menu模块
#
mypack.menu.show_menu()    #调用menu.py里的show_menu函数

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

包的导入语法：
　　　　#同模块的导入规则相同
　　　　import 包名 [as 包别名]
　　　　import 包名.模块名 [as 模块新名]
　　　　import 包名.子包名.模块名 [as 模块新名]

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

　　　　from 包名 import *
　　　　from 包名.子包名 import *
　　　　......

模块的导入语句：
　　　　import xxx 官方优先使用
　　　　from xxx import yyy
　　　　from xxx import *

包__init__.py 内的__all__列表：
　　　　作用：
　　　　　　用来记录此包中有那些包或模块需要在from xxx import * 语句导入时被导入；
　　　　说明：
　　　　　　__all__列表只在from xxx import * 语句中起作用；只导入__all__列表内的模块；

回顾
模块：
1. sys模块  sys.version_info   sys.version
      sys.modules  已加载的模块的字典
      sys.path  （模块或包的搜索路径）
      sys.platform  平台
      sys.argv 命令行参数
      sys.exit() 退出程序
random模块：生成随机数或随机事件相关的
2.自定义模块
    文件名（模块名）.py
  导入语句：
    import 语句    from import 语句，from import *语句
3.查找.py的顺序：1.当前路径，2.sys.path，3.内建模块；
4.模块的属性：
    __doc__属性（绑定文档字符串的）
    __file__属性（绑定当前模块的路径）
    __name__属性（绑定模块名的，如果是主模块绑定'__main__'）
    __all__列表：作用限制from import *语句导入时，只能导入该模块__all__列表内的属性；
5.模块的隐藏属性：以'_'开头的全局变量名（变量/函数名/类名），在from import *语句导入时，不被导入。
包：
1. 包是整理模块用的；常规包内必须有：__init__.py(代表的是包，import mypack 实际执行的是mypack/__init__.py)    init:initializition
2.包的导入：
    import 语句，   from import 语句，  from import *语句

#F:PythonLocal	mooc.cnpython.1py_day13_exercise
# 1.模拟'斗地主'发牌，54张，
# 花色： 
#     黑桃('u2664')，梅花('u2667')，方块('u2666'),红桃（'u2665'）
# 大小王
# 数字：  A~10JQK
# 1)生成54张牌
# 2）三个人玩牌，每人发17张，底牌留三张
#     输入回车，打印第1个人的17张牌
#     输入回车，打印第2个人的17张牌
#     输入回车，打印第3个人的17张牌
#     输入回车，打印3张底牌

#games_toudizhu.py
import random
#花色列表
huase = ['u2664','u2667','u2666','u2665']
#数字列表
number = ['A',2,3,4,5,6,7,8,9,10,'J','Q','K']
#定义排序规则
d = {}
def dict_d():
    for x in range(1,13):
        d[str(number[x])] = x
    d['王'] = 17

    d[2] = 15
    d['A'] =14

#生成54张牌
def shengcheng(x,y):
    pai = ['大王', '小王']
    for k in x:
        for j in y:
            pai.append(str(k) + str(j))
    return pai

#发牌并对发的牌排序
def fapai():
    pailx = shengcheng(huase, number)
    random.shuffle(pailx)    #乱序
    while True:        #循环发牌
        n = input(':')
        if len(pailx) >= 17:    #判断剩余牌数
            if not n:
                one = random.sample(list(pailx), 17)
                print(sorted(one, key=lambda x:(d[x[1:3]] if str(x) != '大王' or str(x) != '小王' else d[x]), reverse=False))
                pailx = set(pailx) - set(one)
                print(len(pailx))
        elif len(pailx) >= 3:
            if not n:
                dipai = random.sample(list(pailx), 3)
                pailx = set(pailx) - set(dipai)        #补集
                print(dipai)
        else:
            break

print('1.生成的54张牌为：', shengcheng(huase, number))
dict_d()
print(d)
print('2.发牌：',)
fapai()


##或poke.py
# kinds = ['u2664','u2667','u2666','u2665']
# print('kinds=', kinds)
# L = [['A'] + [str(x) for x in range(2,11)] + list("JQK")]
# print('L=', L)
# poke = ['大王', '小王']
# for k in kinds:
#     for n in L:
#         poke.append(k + n)
# print('新买的牌', poke)

# poke2 = list(poke) #复制一份

# import random
# random.shuffle(poke2)
# input()
# print('第1个人的17张牌：',poke2[:17])
# input()
# print('第2个人的17张牌：',poke2[17:34])
# input()
# print('第3个人的17张牌：',poke2[34:51])
# input()
# print('3张底牌：',poke2[51:54])