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）可以查看模块的文档字符串；

 1 示例：
 2     import math   #导入数学模块
 3     help(math)  查看模块里文档
 4     >>> math.factorial(5)    #阶乘函数
 5     120
 6     >>> math.log(1024,2)    #2 ** 10  = 1024  #求次方数
 7     10.0
 8     >>> math.sqrt(4)    #平方根
 9     2.0
10     >>> math.sqrt(16)
11     4.0
12     >>> math.pi        #
13     3.141592653589793
14 
15     import sys, os   #导入sys和os模块
16     import copy as cp    #导入copy模块，并对copy模块重新命名为cp新简单名字，方便自己调用
17     >>> L = [1,2,3,4]
18     >>> l2 = cp.deepcopy(L)
19     >>> id(l2)
20     2289561136072
21     >>> id(L)
22     2289558822024

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

1     示例：
2           from math import pi
3           from math import sin
4                   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则用当前时间设置随机种子

 1 import random
 2 
 3 # print(random.random()) #生成0到1之间的小数
 4 # print(random.randint(1,8)) #包括8
 5 # print(random.choice(['hello',4,[1,2]])) #随机选择1个元素
 6 # print(random.sample(['hello',4,[1,2]],2))   #从序列中选2个
 7 # print(random.randrange(1,5))    #不包括5
 8 # print(chr(90))    #将90数字转换为ascii码的字母
 9 
10 #生成5位的随机验证码，要包含字母与数字
11 def v_code():
12     code=''
13     for i in range(5):
14         add=random.choice([random.randrange(10),chr(random.randrange(65,91))]) 
15         code+=str(add)
16     print(code)
17 
18 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 *语句

 1 #F:PythonLocal	mooc.cnpython.1py_day13_exercise
 2 # 1.模拟'斗地主'发牌，54张，
 3 # 花色： 
 4 #     黑桃('u2664')，梅花('u2667')，方块('u2666'),红桃（'u2665'）
 5 # 大小王
 6 # 数字：  A~10JQK
 7 # 1)生成54张牌
 8 # 2）三个人玩牌，每人发17张，底牌留三张
 9 #     输入回车，打印第1个人的17张牌
10 #     输入回车，打印第2个人的17张牌
11 #     输入回车，打印第3个人的17张牌
12 #     输入回车，打印3张底牌
13 
14 #games_toudizhu.py
15 import random
16 #花色列表
17 huase = ['u2664','u2667','u2666','u2665']
18 #数字列表
19 number = ['A',2,3,4,5,6,7,8,9,10,'J','Q','K']
20 #定义排序规则
21 d = {}
22 def dict_d():
23     for x in range(1,13):
24         d[str(number[x])] = x
25     d['王'] = 17
26 
27     d[2] = 15
28     d['A'] =14
29 
30 #生成54张牌
31 def shengcheng(x,y):
32     pai = ['大王', '小王']
33     for k in x:
34         for j in y:
35             pai.append(str(k) + str(j))
36     return pai
37 
38 #发牌并对发的牌排序
39 def fapai():
40     pailx = shengcheng(huase, number)
41     random.shuffle(pailx)    #乱序
42     while True:        #循环发牌
43         n = input(':')
44         if len(pailx) >= 17:    #判断剩余牌数
45             if not n:
46                 one = random.sample(list(pailx), 17)
47                 print(sorted(one, key=lambda x:(d[x[1:3]] if str(x) != '大王' or str(x) != '小王' else d[x]), reverse=False))
48                 pailx = set(pailx) - set(one)
49                 print(len(pailx))
50         elif len(pailx) >= 3:
51             if not n:
52                 dipai = random.sample(list(pailx), 3)
53                 pailx = set(pailx) - set(dipai)        #补集
54                 print(dipai)
55         else:
56             break
57 
58 print('1.生成的54张牌为：', shengcheng(huase, number))
59 dict_d()
60 print(d)
61 print('2.发牌：',)
62 fapai()
63 
64 
65 ##或poke.py
66 # kinds = ['u2664','u2667','u2666','u2665']
67 # print('kinds=', kinds)
68 # L = [['A'] + [str(x) for x in range(2,11)] + list("JQK")]
69 # print('L=', L)
70 # poke = ['大王', '小王']
71 # for k in kinds:
72 #     for n in L:
73 #         poke.append(k + n)
74 # print('新买的牌', poke)
75 
76 # poke2 = list(poke) #复制一份
77 
78 # import random
79 # random.shuffle(poke2)
80 # input()
81 # print('第1个人的17张牌：',poke2[:17])
82 # input()
83 # print('第2个人的17张牌：',poke2[17:34])
84 # input()
85 # print('第3个人的17张牌：',poke2[34:51])
86 # input()
87 # print('3张底牌：',poke2[51:54])